Article JORDAN9, MML version 4.99.1005

:: JORDAN9:th 3
theorem
for b1 being non empty TopSpace-like TopStruct
for b2, b3, b4, b5 being Element of bool the carrier of b1
      st b2 is connected(b1) & b3 is_a_component_of b5 & b4 is_a_component_of b5 & b2 meets b3 & b2 meets b4 & b2 c= b5
   holds b3 = b4;

:: JORDAN9:th 4
theorem
for b1 being non empty set
for b2, b3 being FinSequence of b1
      st for b4 being Element of NAT holds
           b2 | b4 = b3 | b4
   holds b2 = b3;

:: JORDAN9:th 5
theorem
for b1 being Element of NAT
for b2 being non empty set
for b3 being FinSequence of b2
      st b1 in dom b3
   holds ex b4 being Element of NAT st
      b4 in dom Rev b3 & b1 + b4 = (len b3) + 1 & b3 /. b1 = (Rev b3) /. b4;

:: JORDAN9:th 6
theorem
for b1 being Element of NAT
for b2 being non empty set
for b3 being FinSequence of b2
      st b1 in dom Rev b3
   holds ex b4 being Element of NAT st
      b4 in dom b3 & b1 + b4 = (len b3) + 1 & (Rev b3) /. b1 = b3 /. b4;

:: JORDAN9:th 7
theorem
for b1 being non empty set
for b2 being tabular FinSequence of b1 *
for b3 being FinSequence of b1 holds
      b3 is_sequence_on b2
   iff
      Rev b3 is_sequence_on b2;

:: JORDAN9:th 8
theorem
for b1 being Element of NAT
for b2 being tabular FinSequence of (the carrier of TOP-REAL 2) *
for b3 being FinSequence of the carrier of TOP-REAL 2
      st b3 is_sequence_on b2 & 1 <= b1 & b1 <= len b3
   holds b3 /. b1 in Values b2;

:: JORDAN9:th 9
theorem
for b1 being Element of NAT
for b2 being FinSequence of the carrier of TOP-REAL 2
for b3 being set
      st b1 <= len b2 & b3 in L~ (b2 /^ b1)
   holds ex b4 being Element of NAT st
      b1 + 1 <= b4 & b4 + 1 <= len b2 & b3 in LSeg(b2,b4);

:: JORDAN9:th 10
theorem
for b1 being Element of NAT
for b2 being non empty-yielding tabular X_equal-in-line Y_equal-in-column Y_increasing-in-line X_increasing-in-column FinSequence of (the carrier of TOP-REAL 2) *
for b3 being FinSequence of the carrier of TOP-REAL 2
      st b3 is_sequence_on b2 & 1 <= b1 & b1 + 1 <= len b3
   holds b3 /. b1 in left_cell(b3,b1,b2) & b3 /. b1 in right_cell(b3,b1,b2);

:: JORDAN9:th 11
theorem
for b1 being Element of NAT
for b2 being non empty-yielding tabular X_equal-in-line Y_equal-in-column Y_increasing-in-line X_increasing-in-column FinSequence of (the carrier of TOP-REAL 2) *
for b3 being FinSequence of the carrier of TOP-REAL 2
      st b3 is_sequence_on b2 & 1 <= b1 & b1 + 1 <= len b3
   holds Int left_cell(b3,b1,b2) <> {} & Int right_cell(b3,b1,b2) <> {};

:: JORDAN9:th 12
theorem
for b1 being Element of NAT
for b2 being non empty-yielding tabular X_equal-in-line Y_equal-in-column Y_increasing-in-line X_increasing-in-column FinSequence of (the carrier of TOP-REAL 2) *
for b3 being FinSequence of the carrier of TOP-REAL 2
      st b3 is_sequence_on b2 & 1 <= b1 & b1 + 1 <= len b3
   holds Int left_cell(b3,b1,b2) is connected(TOP-REAL 2) & Int right_cell(b3,b1,b2) is connected(TOP-REAL 2);

:: JORDAN9:th 13
theorem
for b1 being Element of NAT
for b2 being non empty-yielding tabular X_equal-in-line Y_equal-in-column Y_increasing-in-line X_increasing-in-column FinSequence of (the carrier of TOP-REAL 2) *
for b3 being FinSequence of the carrier of TOP-REAL 2
      st b3 is_sequence_on b2 & 1 <= b1 & b1 + 1 <= len b3
   holds Cl Int left_cell(b3,b1,b2) = left_cell(b3,b1,b2) &
    Cl Int right_cell(b3,b1,b2) = right_cell(b3,b1,b2);

:: JORDAN9:th 14
theorem
for b1 being Element of NAT
for b2 being non empty-yielding tabular X_equal-in-line Y_equal-in-column Y_increasing-in-line X_increasing-in-column FinSequence of (the carrier of TOP-REAL 2) *
for b3 being FinSequence of the carrier of TOP-REAL 2
      st b3 is_sequence_on b2 & LSeg(b3,b1) is horizontal
   holds ex b4 being Element of NAT st
      1 <= b4 &
       b4 <= width b2 &
       (for b5 being Element of the carrier of TOP-REAL 2
             st b5 in LSeg(b3,b1)
          holds b5 `2 = (b2 *(1,b4)) `2);

:: JORDAN9:th 15
theorem
for b1 being Element of NAT
for b2 being non empty-yielding tabular X_equal-in-line Y_equal-in-column Y_increasing-in-line X_increasing-in-column FinSequence of (the carrier of TOP-REAL 2) *
for b3 being FinSequence of the carrier of TOP-REAL 2
      st b3 is_sequence_on b2 & LSeg(b3,b1) is vertical
   holds ex b4 being Element of NAT st
      1 <= b4 &
       b4 <= len b2 &
       (for b5 being Element of the carrier of TOP-REAL 2
             st b5 in LSeg(b3,b1)
          holds b5 `1 = (b2 *(b4,1)) `1);

:: JORDAN9:th 16
theorem
for b1, b2 being Element of NAT
for b3 being non empty-yielding tabular X_equal-in-line Y_equal-in-column Y_increasing-in-line X_increasing-in-column FinSequence of (the carrier of TOP-REAL 2) *
for b4 being FinSequence of the carrier of TOP-REAL 2
      st b4 is_sequence_on b3 & b4 is special & b1 <= len b3 & b2 <= width b3
   holds Int cell(b3,b1,b2) misses L~ b4;

:: JORDAN9:th 17
theorem
for b1 being Element of NAT
for b2 being non empty-yielding tabular X_equal-in-line Y_equal-in-column Y_increasing-in-line X_increasing-in-column FinSequence of (the carrier of TOP-REAL 2) *
for b3 being FinSequence of the carrier of TOP-REAL 2
      st b3 is_sequence_on b2 & b3 is special & 1 <= b1 & b1 + 1 <= len b3
   holds Int left_cell(b3,b1,b2) misses L~ b3 & Int right_cell(b3,b1,b2) misses L~ b3;

:: JORDAN9:th 18
theorem
for b1, b2 being Element of NAT
for b3 being non empty-yielding tabular X_equal-in-line Y_equal-in-column Y_increasing-in-line X_increasing-in-column FinSequence of (the carrier of TOP-REAL 2) *
      st 1 <= b1 & b1 + 1 <= len b3 & 1 <= b2 & b2 + 1 <= width b3
   holds (b3 *(b1,b2)) `1 = (b3 *(b1,b2 + 1)) `1 &
    (b3 *(b1,b2)) `2 = (b3 *(b1 + 1,b2)) `2 &
    (b3 *(b1 + 1,b2 + 1)) `1 = (b3 *(b1 + 1,b2)) `1 &
    (b3 *(b1 + 1,b2 + 1)) `2 = (b3 *(b1,b2 + 1)) `2;

:: JORDAN9:th 19
theorem
for b1 being non empty-yielding tabular X_equal-in-line Y_equal-in-column Y_increasing-in-line X_increasing-in-column FinSequence of (the carrier of TOP-REAL 2) *
for b2 being Element of the carrier of TOP-REAL 2
for b3, b4 being Element of NAT
      st 1 <= b3 & b3 + 1 <= len b1 & 1 <= b4 & b4 + 1 <= width b1
   holds    b2 in cell(b1,b3,b4)
   iff
      (b1 *(b3,b4)) `1 <= b2 `1 &
       b2 `1 <= (b1 *(b3 + 1,b4)) `1 &
       (b1 *(b3,b4)) `2 <= b2 `2 &
       b2 `2 <= (b1 *(b3,b4 + 1)) `2;

:: JORDAN9:th 20
theorem
for b1, b2 being Element of NAT
for b3 being non empty-yielding tabular X_equal-in-line Y_equal-in-column Y_increasing-in-line X_increasing-in-column FinSequence of (the carrier of TOP-REAL 2) *
      st 1 <= b1 & b1 + 1 <= len b3 & 1 <= b2 & b2 + 1 <= width b3
   holds cell(b3,b1,b2) = {|[b4,b5]| where b4 is Element of REAL, b5 is Element of REAL: (b3 *(b1,b2)) `1 <= b4 & b4 <= (b3 *(b1 + 1,b2)) `1 & (b3 *(b1,b2)) `2 <= b5 & b5 <= (b3 *(b1,b2 + 1)) `2};

:: JORDAN9:th 21
theorem
for b1, b2 being Element of NAT
for b3 being non empty-yielding tabular X_equal-in-line Y_equal-in-column Y_increasing-in-line X_increasing-in-column FinSequence of (the carrier of TOP-REAL 2) *
for b4 being Element of the carrier of TOP-REAL 2
      st 1 <= b1 &
         b1 + 1 <= len b3 &
         1 <= b2 &
         b2 + 1 <= width b3 &
         b4 in Values b3 &
         b4 in cell(b3,b1,b2) &
         b4 <> b3 *(b1,b2) &
         b4 <> b3 *(b1,b2 + 1) &
         b4 <> b3 *(b1 + 1,b2 + 1)
   holds b4 = b3 *(b1 + 1,b2);

:: JORDAN9:th 22
theorem
for b1, b2 being Element of NAT
for b3 being non empty-yielding tabular X_equal-in-line Y_equal-in-column Y_increasing-in-line X_increasing-in-column FinSequence of (the carrier of TOP-REAL 2) *
      st 1 <= b1 & b1 + 1 <= len b3 & 1 <= b2 & b2 + 1 <= width b3
   holds b3 *(b1,b2) in cell(b3,b1,b2) &
    b3 *(b1,b2 + 1) in cell(b3,b1,b2) &
    b3 *(b1 + 1,b2 + 1) in cell(b3,b1,b2) &
    b3 *(b1 + 1,b2) in cell(b3,b1,b2);

:: JORDAN9:th 23
theorem
for b1, b2 being Element of NAT
for b3 being non empty-yielding tabular X_equal-in-line Y_equal-in-column Y_increasing-in-line X_increasing-in-column FinSequence of (the carrier of TOP-REAL 2) *
for b4 being Element of the carrier of TOP-REAL 2
      st 1 <= b1 & b1 + 1 <= len b3 & 1 <= b2 & b2 + 1 <= width b3 & b4 in Values b3 & b4 in cell(b3,b1,b2)
   holds b4 is_extremal_in cell(b3,b1,b2);

:: JORDAN9:th 24
theorem
for b1 being Element of NAT
for b2 being non empty-yielding tabular X_equal-in-line Y_equal-in-column Y_increasing-in-line X_increasing-in-column FinSequence of (the carrier of TOP-REAL 2) *
for b3 being FinSequence of the carrier of TOP-REAL 2
      st 2 <= len b2 & 2 <= width b2 & b3 is_sequence_on b2 & 1 <= b1 & b1 + 1 <= len b3
   holds ex b4, b5 being Element of NAT st
      1 <= b4 & b4 + 1 <= len b2 & 1 <= b5 & b5 + 1 <= width b2 & LSeg(b3,b1) c= cell(b2,b4,b5);

:: JORDAN9:th 25
theorem
for b1 being Element of NAT
for b2 being non empty-yielding tabular X_equal-in-line Y_equal-in-column Y_increasing-in-line X_increasing-in-column FinSequence of (the carrier of TOP-REAL 2) *
for b3 being FinSequence of the carrier of TOP-REAL 2
for b4 being Element of the carrier of TOP-REAL 2
      st 2 <= len b2 & 2 <= width b2 & b3 is_sequence_on b2 & 1 <= b1 & b1 + 1 <= len b3 & b4 in Values b2 & b4 in LSeg(b3,b1) & b4 <> b3 /. b1
   holds b4 = b3 /. (b1 + 1);

:: JORDAN9:th 26
theorem
for b1, b2, b3 being Element of NAT
for b4 being non empty-yielding tabular X_equal-in-line Y_equal-in-column Y_increasing-in-line X_increasing-in-column FinSequence of (the carrier of TOP-REAL 2) *
      st [b1,b2] in Indices b4 & 1 <= b3 & b3 <= width b4
   holds (b4 *(b1,b2)) `1 <= (b4 *(len b4,b3)) `1;

:: JORDAN9:th 27
theorem
for b1, b2, b3 being Element of NAT
for b4 being non empty-yielding tabular X_equal-in-line Y_equal-in-column Y_increasing-in-line X_increasing-in-column FinSequence of (the carrier of TOP-REAL 2) *
      st [b1,b2] in Indices b4 & 1 <= b3 & b3 <= len b4
   holds (b4 *(b1,b2)) `2 <= (b4 *(b3,width b4)) `2;

:: JORDAN9:th 28
theorem
for b1 being Element of NAT
for b2 being non empty-yielding tabular X_equal-in-line Y_equal-in-column Y_increasing-in-line X_increasing-in-column FinSequence of (the carrier of TOP-REAL 2) *
for b3, b4 being FinSequence of the carrier of TOP-REAL 2
   st b3 is_sequence_on b2 & b3 is special & L~ b4 c= L~ b3 & 1 <= b1 & b1 + 1 <= len b3
for b5 being Element of bool the carrier of TOP-REAL 2
      st (b5 = (right_cell(b3,b1,b2)) \ L~ b4 or b5 = (left_cell(b3,b1,b2)) \ L~ b4)
   holds b5 is connected(TOP-REAL 2);

:: JORDAN9:th 29
theorem
for b1 being non empty-yielding tabular X_equal-in-line Y_equal-in-column Y_increasing-in-line X_increasing-in-column FinSequence of (the carrier of TOP-REAL 2) *
for b2 being non constant non empty circular special unfolded s.c.c. standard FinSequence of the carrier of TOP-REAL 2
   st b2 is_sequence_on b1
for b3 being Element of NAT
      st 1 <= b3 & b3 + 1 <= len b2
   holds (right_cell(b2,b3,b1)) \ L~ b2 c= RightComp b2 &
    (left_cell(b2,b3,b1)) \ L~ b2 c= LeftComp b2;

:: JORDAN9:th 30
theorem
for b1 being non empty compact non horizontal non vertical Element of bool the carrier of TOP-REAL 2
for b2 being natural set holds
   ex b3 being Element of NAT st
      1 <= b3 &
       b3 + 1 <= len Gauge(b1,b2) &
       N-min b1 in cell(Gauge(b1,b2),b3,(width Gauge(b1,b2)) -' 1) &
       N-min b1 <> (Gauge(b1,b2)) *(b3,(width Gauge(b1,b2)) -' 1);

:: JORDAN9:th 31
theorem
for b1 being non empty compact non horizontal non vertical Element of bool the carrier of TOP-REAL 2
for b2, b3, b4 being natural set
      st 1 <= b3 &
         b3 + 1 <= len Gauge(b1,b2) &
         N-min b1 in cell(Gauge(b1,b2),b3,(width Gauge(b1,b2)) -' 1) &
         N-min b1 <> (Gauge(b1,b2)) *(b3,(width Gauge(b1,b2)) -' 1) &
         1 <= b4 &
         b4 + 1 <= len Gauge(b1,b2) &
         N-min b1 in cell(Gauge(b1,b2),b4,(width Gauge(b1,b2)) -' 1) &
         N-min b1 <> (Gauge(b1,b2)) *(b4,(width Gauge(b1,b2)) -' 1)
   holds b3 = b4;

:: JORDAN9:th 32
theorem
for b1 being non empty compact non horizontal non vertical Element of bool the carrier of TOP-REAL 2
for b2 being natural set
for b3 being non constant non empty circular special unfolded s.c.c. standard FinSequence of the carrier of TOP-REAL 2
      st b3 is_sequence_on Gauge(b1,b2) &
         (for b4 being Element of NAT
               st 1 <= b4 & b4 + 1 <= len b3
            holds left_cell(b3,b4,Gauge(b1,b2)) misses b1 & right_cell(b3,b4,Gauge(b1,b2)) meets b1) &
         (ex b4 being Element of NAT st
            1 <= b4 &
             b4 + 1 <= len Gauge(b1,b2) &
             b3 /. 1 = (Gauge(b1,b2)) *(b4,width Gauge(b1,b2)) &
             b3 /. 2 = (Gauge(b1,b2)) *(b4 + 1,width Gauge(b1,b2)) &
             N-min b1 in cell(Gauge(b1,b2),b4,(width Gauge(b1,b2)) -' 1) &
             N-min b1 <> (Gauge(b1,b2)) *(b4,(width Gauge(b1,b2)) -' 1))
   holds N-min L~ b3 = b3 /. 1;

:: JORDAN9:funcnot 1 => JORDAN9:func 1
definition
  let a1 be non empty compact non horizontal non vertical Element of bool the carrier of TOP-REAL 2;
  let a2 be natural set;
  assume a1 is connected(TOP-REAL 2);
  func Cage(A1,A2) -> non constant non empty circular special unfolded s.c.c. standard clockwise_oriented FinSequence of the carrier of TOP-REAL 2 means
    it is_sequence_on Gauge(a1,a2) &
     (ex b1 being Element of NAT st
        1 <= b1 &
         b1 + 1 <= len Gauge(a1,a2) &
         it /. 1 = (Gauge(a1,a2)) *(b1,width Gauge(a1,a2)) &
         it /. 2 = (Gauge(a1,a2)) *(b1 + 1,width Gauge(a1,a2)) &
         N-min a1 in cell(Gauge(a1,a2),b1,(width Gauge(a1,a2)) -' 1) &
         N-min a1 <> (Gauge(a1,a2)) *(b1,(width Gauge(a1,a2)) -' 1)) &
     (for b1 being Element of NAT
           st 1 <= b1 & b1 + 2 <= len it
        holds (front_left_cell(it,b1,Gauge(a1,a2)) misses a1 & front_right_cell(it,b1,Gauge(a1,a2)) misses a1 implies it turns_right b1,Gauge(a1,a2)) &
         (front_left_cell(it,b1,Gauge(a1,a2)) misses a1 & front_right_cell(it,b1,Gauge(a1,a2)) meets a1 implies it goes_straight b1,Gauge(a1,a2)) &
         (front_left_cell(it,b1,Gauge(a1,a2)) misses a1 or it turns_left b1,Gauge(a1,a2)));
end;

:: JORDAN9:def 1
theorem
for b1 being non empty compact non horizontal non vertical Element of bool the carrier of TOP-REAL 2
for b2 being natural set
   st b1 is connected(TOP-REAL 2)
for b3 being non constant non empty circular special unfolded s.c.c. standard clockwise_oriented FinSequence of the carrier of TOP-REAL 2 holds
      b3 = Cage(b1,b2)
   iff
      b3 is_sequence_on Gauge(b1,b2) &
       (ex b4 being Element of NAT st
          1 <= b4 &
           b4 + 1 <= len Gauge(b1,b2) &
           b3 /. 1 = (Gauge(b1,b2)) *(b4,width Gauge(b1,b2)) &
           b3 /. 2 = (Gauge(b1,b2)) *(b4 + 1,width Gauge(b1,b2)) &
           N-min b1 in cell(Gauge(b1,b2),b4,(width Gauge(b1,b2)) -' 1) &
           N-min b1 <> (Gauge(b1,b2)) *(b4,(width Gauge(b1,b2)) -' 1)) &
       (for b4 being Element of NAT
             st 1 <= b4 & b4 + 2 <= len b3
          holds (front_left_cell(b3,b4,Gauge(b1,b2)) misses b1 & front_right_cell(b3,b4,Gauge(b1,b2)) misses b1 implies b3 turns_right b4,Gauge(b1,b2)) &
           (front_left_cell(b3,b4,Gauge(b1,b2)) misses b1 & front_right_cell(b3,b4,Gauge(b1,b2)) meets b1 implies b3 goes_straight b4,Gauge(b1,b2)) &
           (front_left_cell(b3,b4,Gauge(b1,b2)) misses b1 or b3 turns_left b4,Gauge(b1,b2)));

:: JORDAN9:th 33
theorem
for b1, b2 being Element of NAT
for b3 being non empty compact non horizontal non vertical Element of bool the carrier of TOP-REAL 2
      st b3 is connected(TOP-REAL 2) & 1 <= b1 & b1 + 1 <= len Cage(b3,b2)
   holds left_cell(Cage(b3,b2),b1,Gauge(b3,b2)) misses b3 &
    right_cell(Cage(b3,b2),b1,Gauge(b3,b2)) meets b3;

:: JORDAN9:th 34
theorem
for b1 being Element of NAT
for b2 being non empty compact non horizontal non vertical Element of bool the carrier of TOP-REAL 2
      st b2 is connected(TOP-REAL 2)
   holds N-min L~ Cage(b2,b1) = (Cage(b2,b1)) /. 1;