Article JORDAN23, MML version 4.99.1005

:: JORDAN23:th 1
theorem
for b1 being FinSequence of the carrier of TOP-REAL 2
for b2 being Element of the carrier of TOP-REAL 2
      st b2 in L~ b1
   holds 1 <= len L_Cut(b1,b2);

:: JORDAN23:th 2
theorem
for b1 being non empty FinSequence of the carrier of TOP-REAL 2
for b2 being Element of the carrier of TOP-REAL 2 holds
   1 <= len R_Cut(b1,b2);

:: JORDAN23:th 3
theorem
for b1 being FinSequence of the carrier of TOP-REAL 2
for b2, b3 being Element of the carrier of TOP-REAL 2 holds
B_Cut(b1,b2,b3) <> {};

:: JORDAN23:funcreg 1
registration
  let a1 be set;
  cluster <*a1*> -> one-to-one;
end;

:: JORDAN23:attrnot 1 => JORDAN23:attr 1
definition
  let a1 be Relation-like Function-like FinSequence-like set;
  attr a1 is almost-one-to-one means
    for b1, b2 being Element of NAT
          st b1 in dom a1 & b2 in dom a1 & (b1 = 1 implies b2 <> len a1) & (b1 = len a1 implies b2 <> 1) & a1 . b1 = a1 . b2
       holds b1 = b2;
end;

:: JORDAN23:dfs 1
definiens
  let a1 be Relation-like Function-like FinSequence-like set;
To prove
     a1 is almost-one-to-one
it is sufficient to prove
  thus for b1, b2 being Element of NAT
          st b1 in dom a1 & b2 in dom a1 & (b1 = 1 implies b2 <> len a1) & (b1 = len a1 implies b2 <> 1) & a1 . b1 = a1 . b2
       holds b1 = b2;

:: JORDAN23:def 1
theorem
for b1 being Relation-like Function-like FinSequence-like set holds
      b1 is almost-one-to-one
   iff
      for b2, b3 being Element of NAT
            st b2 in dom b1 & b3 in dom b1 & (b2 = 1 implies b3 <> len b1) & (b2 = len b1 implies b3 <> 1) & b1 . b2 = b1 . b3
         holds b2 = b3;

:: JORDAN23:attrnot 2 => JORDAN23:attr 2
definition
  let a1 be Relation-like Function-like FinSequence-like set;
  attr a1 is weakly-one-to-one means
    for b1 being Element of NAT
          st 1 <= b1 & b1 < len a1
       holds a1 . b1 <> a1 . (b1 + 1);
end;

:: JORDAN23:dfs 2
definiens
  let a1 be Relation-like Function-like FinSequence-like set;
To prove
     a1 is weakly-one-to-one
it is sufficient to prove
  thus for b1 being Element of NAT
          st 1 <= b1 & b1 < len a1
       holds a1 . b1 <> a1 . (b1 + 1);

:: JORDAN23:def 2
theorem
for b1 being Relation-like Function-like FinSequence-like set holds
      b1 is weakly-one-to-one
   iff
      for b2 being Element of NAT
            st 1 <= b2 & b2 < len b1
         holds b1 . b2 <> b1 . (b2 + 1);

:: JORDAN23:attrnot 3 => JORDAN23:attr 3
definition
  let a1 be Relation-like Function-like FinSequence-like set;
  attr a1 is poorly-one-to-one means
    for b1 being Element of NAT
          st 1 <= b1 & b1 < len a1
       holds a1 . b1 <> a1 . (b1 + 1)
    if len a1 <> 2
    otherwise TRUE;
end;

:: JORDAN23:dfs 3
definiens
  let a1 be Relation-like Function-like FinSequence-like set;
To prove
     a1 is poorly-one-to-one
it is sufficient to prove
  per cases;
  case len a1 <> 2;
    thus for b1 being Element of NAT
          st 1 <= b1 & b1 < len a1
       holds a1 . b1 <> a1 . (b1 + 1);
  end;
  case len a1 = 2;
    thus TRUE;
  end;

:: JORDAN23:def 3
theorem
for b1 being Relation-like Function-like FinSequence-like set holds
   (len b1 = 2 or    (b1 is poorly-one-to-one
    iff
       for b2 being Element of NAT
             st 1 <= b2 & b2 < len b1
          holds b1 . b2 <> b1 . (b2 + 1))) &
    (len b1 = 2 implies (b1 is poorly-one-to-one implies TRUE) & b1 is poorly-one-to-one);

:: JORDAN23:th 4
theorem
for b1 being set
for b2 being FinSequence of b1 holds
      b2 is almost-one-to-one
   iff
      for b3, b4 being Element of NAT
            st b3 in dom b2 & b4 in dom b2 & (b3 = 1 implies b4 <> len b2) & (b3 = len b2 implies b4 <> 1) & b2 /. b3 = b2 /. b4
         holds b3 = b4;

:: JORDAN23:th 5
theorem
for b1 being set
for b2 being FinSequence of b1 holds
      b2 is weakly-one-to-one
   iff
      for b3 being Element of NAT
            st 1 <= b3 & b3 < len b2
         holds b2 /. b3 <> b2 /. (b3 + 1);

:: JORDAN23:th 6
theorem
for b1 being set
for b2 being FinSequence of b1 holds
      b2 is poorly-one-to-one
   iff
      (len b2 = 2 or for b3 being Element of NAT
            st 1 <= b3 & b3 < len b2
         holds b2 /. b3 <> b2 /. (b3 + 1));

:: JORDAN23:condreg 1
registration
  cluster Relation-like Function-like one-to-one FinSequence-like -> almost-one-to-one (set);
end;

:: JORDAN23:condreg 2
registration
  cluster Relation-like Function-like FinSequence-like almost-one-to-one -> poorly-one-to-one (set);
end;

:: JORDAN23:th 7
theorem
for b1 being Relation-like Function-like FinSequence-like set
      st len b1 <> 2
   holds    b1 is weakly-one-to-one
   iff
      b1 is poorly-one-to-one;

:: JORDAN23:funcreg 2
registration
  cluster {} -> weakly-one-to-one;
end;

:: JORDAN23:funcreg 3
registration
  let a1 be set;
  cluster <*a1*> -> weakly-one-to-one;
end;

:: JORDAN23:funcreg 4
registration
  let a1, a2 be set;
  cluster <*a1,a2*> -> poorly-one-to-one;
end;

:: JORDAN23:exreg 1
registration
  cluster Relation-like Function-like non empty finite FinSequence-like weakly-one-to-one set;
end;

:: JORDAN23:exreg 2
registration
  let a1 be non empty set;
  cluster Relation-like Function-like non empty finite FinSequence-like circular weakly-one-to-one FinSequence of a1;
end;

:: JORDAN23:th 8
theorem
for b1 being Relation-like Function-like FinSequence-like set
      st b1 is almost-one-to-one
   holds Rev b1 is almost-one-to-one;

:: JORDAN23:th 9
theorem
for b1 being Relation-like Function-like FinSequence-like set
      st b1 is weakly-one-to-one
   holds Rev b1 is weakly-one-to-one;

:: JORDAN23:th 10
theorem
for b1 being Relation-like Function-like FinSequence-like set
      st b1 is poorly-one-to-one
   holds Rev b1 is poorly-one-to-one;

:: JORDAN23:exreg 3
registration
  cluster Relation-like Function-like one-to-one non empty finite FinSequence-like set;
end;

:: JORDAN23:funcreg 5
registration
  let a1 be Relation-like Function-like FinSequence-like almost-one-to-one set;
  cluster Rev a1 -> Relation-like Function-like FinSequence-like almost-one-to-one;
end;

:: JORDAN23:funcreg 6
registration
  let a1 be Relation-like Function-like FinSequence-like weakly-one-to-one set;
  cluster Rev a1 -> Relation-like Function-like FinSequence-like weakly-one-to-one;
end;

:: JORDAN23:funcreg 7
registration
  let a1 be Relation-like Function-like FinSequence-like poorly-one-to-one set;
  cluster Rev a1 -> Relation-like Function-like FinSequence-like poorly-one-to-one;
end;

:: JORDAN23:th 11
theorem
for b1 being non empty set
for b2 being FinSequence of b1
   st b2 is almost-one-to-one
for b3 being Element of b1 holds
   Rotate(b2,b3) is almost-one-to-one;

:: JORDAN23:th 12
theorem
for b1 being non empty set
for b2 being FinSequence of b1
   st b2 is weakly-one-to-one & b2 is circular(b1)
for b3 being Element of b1 holds
   Rotate(b2,b3) is weakly-one-to-one;

:: JORDAN23:th 13
theorem
for b1 being non empty set
for b2 being FinSequence of b1
   st b2 is poorly-one-to-one & b2 is circular(b1)
for b3 being Element of b1 holds
   Rotate(b2,b3) is poorly-one-to-one;

:: JORDAN23:exreg 4
registration
  let a1 be non empty set;
  cluster Relation-like Function-like one-to-one non empty finite FinSequence-like circular FinSequence of a1;
end;

:: JORDAN23:funcreg 8
registration
  let a1 be non empty set;
  let a2 be almost-one-to-one FinSequence of a1;
  let a3 be Element of a1;
  cluster Rotate(a2,a3) -> almost-one-to-one;
end;

:: JORDAN23:funcreg 9
registration
  let a1 be non empty set;
  let a2 be circular weakly-one-to-one FinSequence of a1;
  let a3 be Element of a1;
  cluster Rotate(a2,a3) -> weakly-one-to-one;
end;

:: JORDAN23:funcreg 10
registration
  let a1 be non empty set;
  let a2 be circular poorly-one-to-one FinSequence of a1;
  let a3 be Element of a1;
  cluster Rotate(a2,a3) -> poorly-one-to-one;
end;

:: JORDAN23:th 14
theorem
for b1 being non empty set
for b2 being FinSequence of b1 holds
      b2 is almost-one-to-one
   iff
      b2 /^ 1 is one-to-one & b2 | ((len b2) -' 1) is one-to-one;

:: JORDAN23:funcreg 11
registration
  let a1 be compact non horizontal non vertical Element of bool the carrier of TOP-REAL 2;
  let a2 be Element of NAT;
  cluster Cage(a1,a2) -> non constant non empty circular special unfolded s.c.c. standard clockwise_oriented almost-one-to-one;
end;

:: JORDAN23:funcreg 12
registration
  let a1 be compact non horizontal non vertical Element of bool the carrier of TOP-REAL 2;
  let a2 be Element of NAT;
  cluster Cage(a1,a2) -> non constant non empty circular special unfolded s.c.c. standard clockwise_oriented weakly-one-to-one;
end;

:: JORDAN23:th 15
theorem
for b1 being FinSequence of the carrier of TOP-REAL 2
for b2 being Element of the carrier of TOP-REAL 2
      st b2 in L~ b1 & b1 is weakly-one-to-one
   holds B_Cut(b1,b2,b2) = <*b2*>;

:: JORDAN23:th 16
theorem
for b1 being Relation-like Function-like FinSequence-like set
      st b1 is one-to-one
   holds b1 is weakly-one-to-one;

:: JORDAN23:condreg 3
registration
  cluster Relation-like Function-like one-to-one FinSequence-like -> weakly-one-to-one (set);
end;

:: JORDAN23:th 17
theorem
for b1 being FinSequence of the carrier of TOP-REAL 2
   st b1 is weakly-one-to-one
for b2, b3 being Element of the carrier of TOP-REAL 2
      st b2 in L~ b1 & b3 in L~ b1
   holds B_Cut(b1,b2,b3) = Rev B_Cut(b1,b3,b2);

:: JORDAN23:th 18
theorem
for b1 being FinSequence of the carrier of TOP-REAL 2
for b2 being Element of the carrier of TOP-REAL 2
for b3 being Element of NAT
      st b1 is poorly-one-to-one & b1 is unfolded & b1 is s.n.c. & 1 < b3 & b3 <= len b1 & b2 = b1 . b3
   holds (Index(b2,b1)) + 1 = b3;

:: JORDAN23:th 19
theorem
for b1 being FinSequence of the carrier of TOP-REAL 2
   st b1 is weakly-one-to-one
for b2, b3 being Element of the carrier of TOP-REAL 2
      st b2 in L~ b1 & b3 in L~ b1
   holds (B_Cut(b1,b2,b3)) /. 1 = b2;

:: JORDAN23:th 20
theorem
for b1 being FinSequence of the carrier of TOP-REAL 2
   st b1 is weakly-one-to-one
for b2, b3 being Element of the carrier of TOP-REAL 2
      st b2 in L~ b1 & b3 in L~ b1
   holds (B_Cut(b1,b2,b3)) /. len B_Cut(b1,b2,b3) = b3;

:: JORDAN23:th 21
theorem
for b1 being FinSequence of the carrier of TOP-REAL 2
for b2 being Element of the carrier of TOP-REAL 2
      st b2 in L~ b1
   holds L~ L_Cut(b1,b2) c= L~ b1;

:: JORDAN23:th 22
theorem
for b1 being FinSequence of the carrier of TOP-REAL 2
for b2, b3 being Element of the carrier of TOP-REAL 2
      st b2 in L~ b1 & b3 in L~ b1 & b1 is weakly-one-to-one
   holds L~ B_Cut(b1,b2,b3) c= L~ b1;

:: JORDAN23:th 23
theorem
for b1, b2 being Relation-like Function-like FinSequence-like set holds
dom b1 c= dom (b1 ^' b2);

:: JORDAN23:th 24
theorem
for b1 being Relation-like Function-like non empty FinSequence-like set
for b2 being Relation-like Function-like FinSequence-like set holds
   dom b2 c= dom (b1 ^' b2);

:: JORDAN23:th 25
theorem
for b1, b2 being Relation-like Function-like FinSequence-like set
      st b1 ^' b2 is constant
   holds b1 is constant;

:: JORDAN23:th 26
theorem
for b1, b2 being Relation-like Function-like FinSequence-like set
      st b1 ^' b2 is constant & b1 . len b1 = b2 . 1 & b1 <> {}
   holds b2 is constant;

:: JORDAN23:th 27
theorem
for b1 being special FinSequence of the carrier of TOP-REAL 2
for b2, b3 being Element of NAT holds
mid(b1,b2,b3) is special;

:: JORDAN23:th 28
theorem
for b1 being unfolded FinSequence of the carrier of TOP-REAL 2
for b2, b3 being Element of NAT holds
mid(b1,b2,b3) is unfolded;

:: JORDAN23:th 29
theorem
for b1 being FinSequence of the carrier of TOP-REAL 2
   st b1 is special
for b2 being Element of the carrier of TOP-REAL 2
      st b2 in L~ b1
   holds L_Cut(b1,b2) is special;

:: JORDAN23:th 30
theorem
for b1 being FinSequence of the carrier of TOP-REAL 2
   st b1 is special
for b2 being Element of the carrier of TOP-REAL 2
      st b2 in L~ b1
   holds R_Cut(b1,b2) is special;

:: JORDAN23:th 31
theorem
for b1 being FinSequence of the carrier of TOP-REAL 2
   st b1 is special & b1 is weakly-one-to-one
for b2, b3 being Element of the carrier of TOP-REAL 2
      st b2 in L~ b1 & b3 in L~ b1
   holds B_Cut(b1,b2,b3) is special;

:: JORDAN23:th 32
theorem
for b1 being FinSequence of the carrier of TOP-REAL 2
   st b1 is unfolded
for b2 being Element of the carrier of TOP-REAL 2
      st b2 in L~ b1
   holds L_Cut(b1,b2) is unfolded;

:: JORDAN23:th 33
theorem
for b1 being FinSequence of the carrier of TOP-REAL 2
   st b1 is unfolded
for b2 being Element of the carrier of TOP-REAL 2
      st b2 in L~ b1
   holds R_Cut(b1,b2) is unfolded;

:: JORDAN23:th 34
theorem
for b1 being FinSequence of the carrier of TOP-REAL 2
   st b1 is unfolded & b1 is weakly-one-to-one
for b2, b3 being Element of the carrier of TOP-REAL 2
      st b2 in L~ b1 & b3 in L~ b1
   holds B_Cut(b1,b2,b3) is unfolded;

:: JORDAN23:th 35
theorem
for b1, b2 being FinSequence of the carrier of TOP-REAL 2
for b3 being Element of the carrier of TOP-REAL 2
      st b1 is almost-one-to-one &
         b1 is special &
         b1 is unfolded &
         b1 is s.n.c. &
         b3 in L~ b1 &
         b3 <> b1 . 1 &
         b2 = (mid(b1,1,Index(b3,b1))) ^ <*b3*>
   holds b2 is_S-Seq_joining b1 /. 1,b3;

:: JORDAN23:th 36
theorem
for b1 being FinSequence of the carrier of TOP-REAL 2
for b2 being Element of the carrier of TOP-REAL 2
      st b1 is poorly-one-to-one & b1 is unfolded & b1 is s.n.c. & b2 in L~ b1 & b2 = b1 . ((Index(b2,b1)) + 1) & b2 <> b1 . len b1
   holds ((Index(b2,Rev b1)) + Index(b2,b1)) + 1 = len b1;

:: JORDAN23:th 37
theorem
for b1 being non empty FinSequence of the carrier of TOP-REAL 2
for b2 being Element of the carrier of TOP-REAL 2
      st b1 is weakly-one-to-one & 2 <= len b1
   holds L_Cut(b1,b1 /. 1) = b1;

:: JORDAN23:th 38
theorem
for b1 being non empty FinSequence of the carrier of TOP-REAL 2
for b2 being Element of the carrier of TOP-REAL 2
      st b1 is poorly-one-to-one & b1 is unfolded & b1 is s.n.c. & b2 in L~ b1 & b2 <> b1 . len b1
   holds L_Cut(Rev b1,b2) = Rev R_Cut(b1,b2);

:: JORDAN23:th 39
theorem
for b1 being FinSequence of the carrier of TOP-REAL 2
for b2 being Element of the carrier of TOP-REAL 2
      st b1 is almost-one-to-one & b1 is special & b1 is unfolded & b1 is s.n.c. & b2 in L~ b1 & b2 <> b1 . 1
   holds R_Cut(b1,b2) is_S-Seq_joining b1 /. 1,b2;

:: JORDAN23:th 40
theorem
for b1 being non empty FinSequence of the carrier of TOP-REAL 2
for b2 being Element of the carrier of TOP-REAL 2
      st b1 is almost-one-to-one & b1 is special & b1 is unfolded & b1 is s.n.c. & b2 in L~ b1 & b2 <> b1 . len b1 & b2 <> b1 . 1
   holds L_Cut(b1,b2) is_S-Seq_joining b2,b1 /. len b1;

:: JORDAN23:th 41
theorem
for b1 being FinSequence of the carrier of TOP-REAL 2
for b2 being Element of the carrier of TOP-REAL 2
      st b1 is almost-one-to-one & b1 is special & b1 is unfolded & b1 is s.n.c. & b2 in L~ b1 & b2 <> b1 . 1
   holds R_Cut(b1,b2) is being_S-Seq;

:: JORDAN23:th 42
theorem
for b1 being non empty FinSequence of the carrier of TOP-REAL 2
for b2 being Element of the carrier of TOP-REAL 2
      st b1 is almost-one-to-one & b1 is special & b1 is unfolded & b1 is s.n.c. & b2 in L~ b1 & b2 <> b1 . len b1 & b2 <> b1 . 1
   holds L_Cut(b1,b2) is being_S-Seq;

:: JORDAN23:th 43
theorem
for b1 being non empty FinSequence of the carrier of TOP-REAL 2
for b2, b3 being Element of the carrier of TOP-REAL 2
      st b1 is almost-one-to-one & b1 is special & b1 is unfolded & b1 is s.n.c. & len b1 <> 2 & b2 in L~ b1 & b3 in L~ b1 & b2 <> b3 & b2 <> b1 . 1 & b3 <> b1 . 1
   holds B_Cut(b1,b2,b3) is_S-Seq_joining b2,b3;

:: JORDAN23:th 44
theorem
for b1 being non empty FinSequence of the carrier of TOP-REAL 2
for b2, b3 being Element of the carrier of TOP-REAL 2
      st b1 is almost-one-to-one & b1 is special & b1 is unfolded & b1 is s.n.c. & len b1 <> 2 & b2 in L~ b1 & b3 in L~ b1 & b2 <> b3 & b2 <> b1 . 1 & b3 <> b1 . 1
   holds B_Cut(b1,b2,b3) is being_S-Seq;

:: JORDAN23:th 45
theorem
for b1 being Element of NAT
for b2 being compact non horizontal non vertical Element of bool the carrier of TOP-REAL 2
for b3, b4 being Element of the carrier of TOP-REAL 2
      st b3 in BDD L~ Cage(b2,b1)
   holds ex b5 being being_S-Seq FinSequence of the carrier of TOP-REAL 2 st
      b5 = B_Cut((Rotate(Cage(b2,b1),(Cage(b2,b1)) /. Index(South-Bound(b3,L~ Cage(b2,b1)),Cage(b2,b1)))) | ((len Rotate(Cage(b2,b1),(Cage(b2,b1)) /. Index(South-Bound(b3,L~ Cage(b2,b1)),Cage(b2,b1)))) -' 1),South-Bound(b3,L~ Cage(b2,b1)),North-Bound(b3,L~ Cage(b2,b1))) &
       (ex b6 being being_S-Seq FinSequence of the carrier of TOP-REAL 2 st
          b6 is_sequence_on GoB (b5 ^' <*North-Bound(b3,L~ Cage(b2,b1)),South-Bound(b3,L~ Cage(b2,b1))*>) &
           L~ <*North-Bound(b3,L~ Cage(b2,b1)),South-Bound(b3,L~ Cage(b2,b1))*> = L~ b6 &
           b6 /. 1 = North-Bound(b3,L~ Cage(b2,b1)) &
           b6 /. len b6 = South-Bound(b3,L~ Cage(b2,b1)) &
           2 <= len b6 &
           (ex b7 being being_S-Seq FinSequence of the carrier of TOP-REAL 2 st
              b7 is_sequence_on GoB (b5 ^' <*North-Bound(b3,L~ Cage(b2,b1)),South-Bound(b3,L~ Cage(b2,b1))*>) &
               L~ b5 = L~ b7 &
               b5 /. 1 = b7 /. 1 &
               b5 /. len b5 = b7 /. len b7 &
               len b5 <= len b7 &
               (ex b8 being non constant non empty circular special unfolded s.c.c. standard FinSequence of the carrier of TOP-REAL 2 st
                  b8 = b7 ^' b6)));