Article JORDAN1H, MML version 4.99.1005

:: JORDAN1H:exreg 1
registration
  cluster with_non-empty_element set;
end;

:: JORDAN1H:exreg 2
registration
  let a1 be non empty with_non-empty_element set;
  cluster non empty Relation-like non-empty Function-like finite FinSequence-like Function-yielding FinSequence-yielding FinSequence of a1 *;
end;

:: JORDAN1H:funcreg 1
registration
  let a1 be Relation-like non-empty Function-like Function-yielding set;
  cluster rngs a1 -> Relation-like non-empty Function-like;
end;

:: JORDAN1H:th 6
theorem
for b1, b2 being Element of the carrier of TOP-REAL 2
      st b1 <> b2
   holds b1 in Cl ((LSeg(b1,b2)) \ {b1,b2});

:: JORDAN1H:th 7
theorem
for b1, b2 being Element of the carrier of TOP-REAL 2
      st b1 <> b2
   holds Cl ((LSeg(b1,b2)) \ {b1,b2}) = LSeg(b1,b2);

:: JORDAN1H:th 8
theorem
for b1 being Element of bool the carrier of TOP-REAL 2
for b2, b3 being Element of the carrier of TOP-REAL 2
      st b2 <> b3 & (LSeg(b2,b3)) \ {b2,b3} c= b1
   holds LSeg(b2,b3) c= Cl b1;

:: JORDAN1H:funcnot 1 => JORDAN1H:func 1
definition
  func RealOrd -> Relation of REAL,REAL equals
    {[b1,b2] where b1 is Element of REAL, b2 is Element of REAL: b1 <= b2};
end;

:: JORDAN1H:def 1
theorem
RealOrd = {[b1,b2] where b1 is Element of REAL, b2 is Element of REAL: b1 <= b2};

:: JORDAN1H:th 9
theorem
for b1, b2 being Element of REAL
      st [b1,b2] in RealOrd
   holds b1 <= b2;

:: JORDAN1H:th 10
theorem
field RealOrd = REAL;

:: JORDAN1H:funcreg 2
registration
  cluster RealOrd -> total reflexive antisymmetric transitive being_linear-order;
end;

:: JORDAN1H:th 11
theorem
RealOrd linearly_orders REAL;

:: JORDAN1H:th 12
theorem
for b1 being finite Element of bool REAL holds
   SgmX(RealOrd,b1) is increasing;

:: JORDAN1H:th 13
theorem
for b1 being FinSequence of REAL
for b2 being finite Element of bool REAL
      st b2 = rng b1
   holds SgmX(RealOrd,b2) = Incr b1;

:: JORDAN1H:funcreg 3
registration
  let a1 be finite Element of bool REAL;
  cluster SgmX(RealOrd,a1) -> increasing;
end;

:: JORDAN1H:th 15
theorem
for b1 being non empty set
for b2 being finite Element of bool b1
for b3 being total reflexive antisymmetric transitive being_linear-order Relation of b1,b1 holds
   len SgmX(b3,b2) = card b2;

:: JORDAN1H:th 16
theorem
for b1 being FinSequence of the carrier of TOP-REAL 2 holds
   X_axis b1 = proj1 * b1;

:: JORDAN1H:th 17
theorem
for b1 being FinSequence of the carrier of TOP-REAL 2 holds
   Y_axis b1 = proj2 * b1;

:: JORDAN1H:funcnot 2 => JORDAN1H:func 2
definition
  let a1 be non empty set;
  let a2 be FinSequence of a1 *;
  redefine func Values a2 -> Element of bool a1;
end;

:: JORDAN1H:funcreg 4
registration
  let a1 be non empty with_non-empty_elements set;
  let a2 be non empty non-empty FinSequence of a1 *;
  cluster Values a2 -> non empty;
end;

:: JORDAN1H:th 18
theorem
for b1 being non empty set
for b2 being tabular FinSequence of b1 *
for b3 being Element of NAT
      st b3 in Seg width b2
   holds rng Col(b2,b3) c= Values b2;

:: JORDAN1H:th 19
theorem
for b1 being non empty set
for b2 being tabular FinSequence of b1 *
for b3 being Element of NAT
      st b3 in dom b2
   holds rng Line(b2,b3) c= Values b2;

:: JORDAN1H:th 20
theorem
for b1 being non empty-yielding tabular X_increasing-in-column FinSequence of (the carrier of TOP-REAL 2) * holds
   len b1 <= card (proj1 .: Values b1);

:: JORDAN1H:th 21
theorem
for b1 being tabular X_equal-in-line FinSequence of (the carrier of TOP-REAL 2) * holds
   card (proj1 .: Values b1) <= len b1;

:: JORDAN1H:th 22
theorem
for b1 being non empty-yielding tabular X_equal-in-line X_increasing-in-column FinSequence of (the carrier of TOP-REAL 2) * holds
   len b1 = card (proj1 .: Values b1);

:: JORDAN1H:th 23
theorem
for b1 being non empty-yielding tabular Y_increasing-in-line FinSequence of (the carrier of TOP-REAL 2) * holds
   width b1 <= card (proj2 .: Values b1);

:: JORDAN1H:th 24
theorem
for b1 being non empty-yielding tabular Y_equal-in-column FinSequence of (the carrier of TOP-REAL 2) * holds
   card (proj2 .: Values b1) <= width b1;

:: JORDAN1H:th 25
theorem
for b1 being non empty-yielding tabular Y_equal-in-column Y_increasing-in-line FinSequence of (the carrier of TOP-REAL 2) * holds
   width b1 = card (proj2 .: Values b1);

:: JORDAN1H:th 26
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 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 LSeg(b2,b3) c= left_cell(b2,b3,b1);

:: JORDAN1H:th 27
theorem
for b1 being Element of NAT
for b2 being non empty circular special unfolded s.c.c. standard FinSequence of the carrier of TOP-REAL 2
      st 1 <= b1 & b1 + 1 <= len b2
   holds left_cell(b2,b1,GoB b2) = left_cell(b2,b1);

:: JORDAN1H:th 28
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 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 LSeg(b2,b3) c= right_cell(b2,b3,b1);

:: JORDAN1H:th 29
theorem
for b1 being Element of NAT
for b2 being non empty circular special unfolded s.c.c. standard FinSequence of the carrier of TOP-REAL 2
      st 1 <= b1 & b1 + 1 <= len b2
   holds right_cell(b2,b1,GoB b2) = right_cell(b2,b1);

:: JORDAN1H:th 30
theorem
for b1 being Element of bool the carrier of TOP-REAL 2
for b2 being non empty non constant circular special unfolded s.c.c. standard FinSequence of the carrier of TOP-REAL 2
      st b1 is_a_component_of (L~ b2) ` & b1 <> RightComp b2
   holds b1 = LeftComp b2;

:: JORDAN1H:th 31
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 empty non constant 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 Int right_cell(b2,b3,b1) c= RightComp b2 & Int left_cell(b2,b3,b1) c= LeftComp b2;

:: JORDAN1H:th 32
theorem
for b1, b2, b3, b4 being Element of NAT
for b5 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 b5 & [b3,b4] in Indices b5 & b5 *(b1,b2) = b5 *(b3,b4)
   holds b1 = b3 & b2 = b4;

:: JORDAN1H:th 33
theorem
for b1, b2 being Element of NAT
for b3 being FinSequence of the carrier of TOP-REAL 2
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 b3 is_sequence_on b4
   holds mid(b3,b1,b2) is_sequence_on b4;

:: JORDAN1H:condreg 1
registration
  cluster non empty-yielding tabular X_equal-in-line Y_equal-in-column Y_increasing-in-line X_increasing-in-column -> non empty non-empty (FinSequence of (the carrier of TOP-REAL 2) *);
end;

:: JORDAN1H:th 34
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) *
      st 1 <= b1 & b1 <= len b2
   holds (SgmX(RealOrd,proj1 .: Values b2)) . b1 = (b2 *(b1,1)) `1;

:: JORDAN1H:th 35
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) *
      st 1 <= b1 & b1 <= width b2
   holds (SgmX(RealOrd,proj2 .: Values b2)) . b1 = (b2 *(1,b1)) `2;

:: JORDAN1H:th 36
theorem
for b1 being non empty FinSequence of the carrier of TOP-REAL 2
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) *
      st b1 is_sequence_on b2 &
         (ex b3 being Element of NAT st
            [1,b3] in Indices b2 & b2 *(1,b3) in rng b1) &
         (ex b3 being Element of NAT st
            [len b2,b3] in Indices b2 & b2 *(len b2,b3) in rng b1)
   holds proj1 .: rng b1 = proj1 .: Values b2;

:: JORDAN1H:th 37
theorem
for b1 being non empty FinSequence of the carrier of TOP-REAL 2
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) *
      st b1 is_sequence_on b2 &
         (ex b3 being Element of NAT st
            [b3,1] in Indices b2 & b2 *(b3,1) in rng b1) &
         (ex b3 being Element of NAT st
            [b3,width b2] in Indices b2 & b2 *(b3,width b2) in rng b1)
   holds proj2 .: rng b1 = proj2 .: Values b2;

:: JORDAN1H:funcreg 5
registration
  let a1 be 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) *;
  cluster Values a1 -> non empty;
end;

:: JORDAN1H:th 38
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) * holds
   b1 = GoB(SgmX(RealOrd,proj1 .: Values b1),SgmX(RealOrd,proj2 .: Values b1));

:: JORDAN1H:th 39
theorem
for b1 being non empty FinSequence of the carrier of TOP-REAL 2
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) *
      st proj1 .: rng b1 = proj1 .: Values b2 &
         proj2 .: rng b1 = proj2 .: Values b2
   holds b2 = GoB b1;

:: JORDAN1H:th 40
theorem
for b1 being non empty FinSequence of the carrier of TOP-REAL 2
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) *
      st b1 is_sequence_on b2 &
         (ex b3 being Element of NAT st
            [1,b3] in Indices b2 & b2 *(1,b3) in rng b1) &
         (ex b3 being Element of NAT st
            [b3,1] in Indices b2 & b2 *(b3,1) in rng b1) &
         (ex b3 being Element of NAT st
            [len b2,b3] in Indices b2 & b2 *(len b2,b3) in rng b1) &
         (ex b3 being Element of NAT st
            [b3,width b2] in Indices b2 & b2 *(b3,width b2) in rng b1)
   holds b2 = GoB b1;

:: JORDAN1H:th 41
theorem
for b1, b2, b3 being Element of NAT
for b4 being compact non horizontal non vertical Element of bool the carrier of TOP-REAL 2
      st b1 <= b2 & 1 <= b3 & b3 + 1 <= len Gauge(b4,b2)
   holds [\((b3 - 2) / (2 |^ (b2 -' b1))) + 2/] is Element of NAT;

:: JORDAN1H:th 42
theorem
for b1, b2, b3 being Element of NAT
for b4 being compact non horizontal non vertical Element of bool the carrier of TOP-REAL 2
      st b1 <= b2 & 1 <= b3 & b3 + 1 <= len Gauge(b4,b2)
   holds 1 <= [\((b3 - 2) / (2 |^ (b2 -' b1))) + 2/] &
    [\((b3 - 2) / (2 |^ (b2 -' b1))) + 2/] + 1 <= len Gauge(b4,b1);

:: JORDAN1H:th 43
theorem
for b1, b2, b3, b4 being Element of NAT
for b5 being compact non horizontal non vertical Element of bool the carrier of TOP-REAL 2
      st b1 <= b2 & 1 <= b3 & b3 + 1 <= len Gauge(b5,b2) & 1 <= b4 & b4 + 1 <= width Gauge(b5,b2)
   holds ex b6, b7 being Element of NAT st
      b6 = [\((b3 - 2) / (2 |^ (b2 -' b1))) + 2/] &
       b7 = [\((b4 - 2) / (2 |^ (b2 -' b1))) + 2/] &
       cell(Gauge(b5,b2),b3,b4) c= cell(Gauge(b5,b1),b6,b7);

:: JORDAN1H:th 44
theorem
for b1, b2, b3, b4 being Element of NAT
for b5 being compact non horizontal non vertical Element of bool the carrier of TOP-REAL 2
      st b1 <= b2 & 1 <= b3 & b3 + 1 <= len Gauge(b5,b2) & 1 <= b4 & b4 + 1 <= width Gauge(b5,b2)
   holds ex b6, b7 being Element of NAT st
      1 <= b6 &
       b6 + 1 <= len Gauge(b5,b1) &
       1 <= b7 &
       b7 + 1 <= width Gauge(b5,b1) &
       cell(Gauge(b5,b2),b3,b4) c= cell(Gauge(b5,b1),b6,b7);

:: JORDAN1H:th 47
theorem
for b1 being Element of bool the carrier of TOP-REAL 2
      st b1 is Bounded(2)
   holds UBD b1 is not Bounded(2);

:: JORDAN1H:th 48
theorem
for b1 being Element of the carrier of TOP-REAL 2
for b2 being non empty non constant circular special unfolded s.c.c. standard FinSequence of the carrier of TOP-REAL 2
      st Rotate(b2,b1) is clockwise_oriented
   holds b2 is clockwise_oriented;

:: JORDAN1H:th 49
theorem
for b1 being non empty non constant circular special unfolded s.c.c. standard FinSequence of the carrier of TOP-REAL 2
      st LeftComp b1 = UBD L~ b1
   holds b1 is clockwise_oriented;

:: JORDAN1H:th 50
theorem
for b1 being non empty non constant circular special unfolded s.c.c. standard FinSequence of the carrier of TOP-REAL 2 holds
   (Cl LeftComp b1) ` = RightComp b1;

:: JORDAN1H:th 51
theorem
for b1 being non empty non constant circular special unfolded s.c.c. standard FinSequence of the carrier of TOP-REAL 2 holds
   (Cl RightComp b1) ` = LeftComp b1;

:: JORDAN1H:th 52
theorem
for b1 being Element of NAT
for b2 being compact non horizontal non vertical Element of bool the carrier of TOP-REAL 2
      st b2 is connected(TOP-REAL 2)
   holds GoB Cage(b2,b1) = Gauge(b2,b1);

:: JORDAN1H:th 53
theorem
for b1 being Element of NAT
for b2 being compact non horizontal non vertical Element of bool the carrier of TOP-REAL 2
      st b2 is connected(TOP-REAL 2)
   holds N-min b2 in right_cell(Cage(b2,b1),1);

:: JORDAN1H:th 54
theorem
for b1, b2 being Element of NAT
for b3 being compact non horizontal non vertical Element of bool the carrier of TOP-REAL 2
      st b3 is connected(TOP-REAL 2) & b1 <= b2
   holds L~ Cage(b3,b2) c= Cl RightComp Cage(b3,b1);

:: JORDAN1H:th 55
theorem
for b1, b2 being Element of NAT
for b3 being compact non horizontal non vertical Element of bool the carrier of TOP-REAL 2
      st b3 is connected(TOP-REAL 2) & b1 <= b2
   holds LeftComp Cage(b3,b1) c= LeftComp Cage(b3,b2);

:: JORDAN1H:th 56
theorem
for b1, b2 being Element of NAT
for b3 being compact non horizontal non vertical Element of bool the carrier of TOP-REAL 2
      st b3 is connected(TOP-REAL 2) & b1 <= b2
   holds RightComp Cage(b3,b2) c= RightComp Cage(b3,b1);

:: JORDAN1H:funcnot 3 => JORDAN1H:func 3
definition
  let a1 be compact non horizontal non vertical Element of bool the carrier of TOP-REAL 2;
  let a2 be Element of NAT;
  func X-SpanStart(A1,A2) -> Element of NAT equals
    (2 |^ (a2 -' 1)) + 2;
end;

:: JORDAN1H:def 2
theorem
for b1 being compact non horizontal non vertical Element of bool the carrier of TOP-REAL 2
for b2 being Element of NAT holds
   X-SpanStart(b1,b2) = (2 |^ (b2 -' 1)) + 2;

:: JORDAN1H:th 58
theorem
for b1 being Element of NAT
for b2 being compact non horizontal non vertical Element of bool the carrier of TOP-REAL 2 holds
   2 < X-SpanStart(b2,b1) & X-SpanStart(b2,b1) < len Gauge(b2,b1);

:: JORDAN1H:th 59
theorem
for b1 being Element of NAT
for b2 being compact non horizontal non vertical Element of bool the carrier of TOP-REAL 2 holds
   1 <= (X-SpanStart(b2,b1)) -' 1 &
    (X-SpanStart(b2,b1)) -' 1 < len Gauge(b2,b1);

:: JORDAN1H:prednot 1 => JORDAN1H:pred 1
definition
  let a1 be compact non horizontal non vertical Element of bool the carrier of TOP-REAL 2;
  let a2 be Element of NAT;
  pred A2 is_sufficiently_large_for A1 means
    ex b1 being Element of NAT st
       b1 < width Gauge(a1,a2) &
        cell(Gauge(a1,a2),(X-SpanStart(a1,a2)) -' 1,b1) c= BDD a1;
end;

:: JORDAN1H:dfs 3
definiens
  let a1 be compact non horizontal non vertical Element of bool the carrier of TOP-REAL 2;
  let a2 be Element of NAT;
To prove
     a2 is_sufficiently_large_for a1
it is sufficient to prove
  thus ex b1 being Element of NAT st
       b1 < width Gauge(a1,a2) &
        cell(Gauge(a1,a2),(X-SpanStart(a1,a2)) -' 1,b1) c= BDD a1;

:: JORDAN1H:def 3
theorem
for b1 being compact non horizontal non vertical Element of bool the carrier of TOP-REAL 2
for b2 being Element of NAT holds
      b2 is_sufficiently_large_for b1
   iff
      ex b3 being Element of NAT st
         b3 < width Gauge(b1,b2) &
          cell(Gauge(b1,b2),(X-SpanStart(b1,b2)) -' 1,b3) c= BDD b1;

:: JORDAN1H:th 60
theorem
for b1 being Element of NAT
for b2 being compact non horizontal non vertical Element of bool the carrier of TOP-REAL 2
      st b1 is_sufficiently_large_for b2
   holds 1 <= b1;

:: JORDAN1H:th 61
theorem
for b1 being non empty compact non horizontal non vertical Element of bool the carrier of TOP-REAL 2
for b2 being Element of NAT
for b3 being FinSequence of the carrier of TOP-REAL 2
   st b3 is_sequence_on Gauge(b1,b2) & 1 < len b3
for b4, b5 being Element of NAT
      st left_cell(b3,(len b3) -' 1,Gauge(b1,b2)) meets b1 &
         [b4,b5] in Indices Gauge(b1,b2) &
         b3 /. ((len b3) -' 1) = (Gauge(b1,b2)) *(b4,b5) &
         [b4,b5 + 1] in Indices Gauge(b1,b2) &
         b3 /. len b3 = (Gauge(b1,b2)) *(b4,b5 + 1)
   holds [b4 -' 1,b5 + 1] in Indices Gauge(b1,b2);

:: JORDAN1H:th 62
theorem
for b1 being non empty compact non horizontal non vertical Element of bool the carrier of TOP-REAL 2
for b2 being Element of NAT
for b3 being FinSequence of the carrier of TOP-REAL 2
   st b3 is_sequence_on Gauge(b1,b2) & 1 < len b3
for b4, b5 being Element of NAT
      st left_cell(b3,(len b3) -' 1,Gauge(b1,b2)) meets b1 &
         [b4,b5] in Indices Gauge(b1,b2) &
         b3 /. ((len b3) -' 1) = (Gauge(b1,b2)) *(b4,b5) &
         [b4 + 1,b5] in Indices Gauge(b1,b2) &
         b3 /. len b3 = (Gauge(b1,b2)) *(b4 + 1,b5)
   holds [b4 + 1,b5 + 1] in Indices Gauge(b1,b2);

:: JORDAN1H:th 63
theorem
for b1 being non empty compact non horizontal non vertical Element of bool the carrier of TOP-REAL 2
for b2 being Element of NAT
for b3 being FinSequence of the carrier of TOP-REAL 2
   st b3 is_sequence_on Gauge(b1,b2) & 1 < len b3
for b4, b5 being Element of NAT
      st left_cell(b3,(len b3) -' 1,Gauge(b1,b2)) meets b1 &
         [b5 + 1,b4] in Indices Gauge(b1,b2) &
         b3 /. ((len b3) -' 1) = (Gauge(b1,b2)) *(b5 + 1,b4) &
         [b5,b4] in Indices Gauge(b1,b2) &
         b3 /. len b3 = (Gauge(b1,b2)) *(b5,b4)
   holds [b5,b4 -' 1] in Indices Gauge(b1,b2);

:: JORDAN1H:th 64
theorem
for b1 being non empty compact non horizontal non vertical Element of bool the carrier of TOP-REAL 2
for b2 being Element of NAT
for b3 being FinSequence of the carrier of TOP-REAL 2
   st b3 is_sequence_on Gauge(b1,b2) & 1 < len b3
for b4, b5 being Element of NAT
      st left_cell(b3,(len b3) -' 1,Gauge(b1,b2)) meets b1 &
         [b4,b5 + 1] in Indices Gauge(b1,b2) &
         b3 /. ((len b3) -' 1) = (Gauge(b1,b2)) *(b4,b5 + 1) &
         [b4,b5] in Indices Gauge(b1,b2) &
         b3 /. len b3 = (Gauge(b1,b2)) *(b4,b5)
   holds [b4 + 1,b5] in Indices Gauge(b1,b2);

:: JORDAN1H:th 65
theorem
for b1 being non empty compact non horizontal non vertical Element of bool the carrier of TOP-REAL 2
for b2 being Element of NAT
for b3 being FinSequence of the carrier of TOP-REAL 2
   st b3 is_sequence_on Gauge(b1,b2) & 1 < len b3
for b4, b5 being Element of NAT
      st front_left_cell(b3,(len b3) -' 1,Gauge(b1,b2)) meets b1 &
         [b4,b5] in Indices Gauge(b1,b2) &
         b3 /. ((len b3) -' 1) = (Gauge(b1,b2)) *(b4,b5) &
         [b4,b5 + 1] in Indices Gauge(b1,b2) &
         b3 /. len b3 = (Gauge(b1,b2)) *(b4,b5 + 1)
   holds [b4,b5 + 2] in Indices Gauge(b1,b2);

:: JORDAN1H:th 66
theorem
for b1 being non empty compact non horizontal non vertical Element of bool the carrier of TOP-REAL 2
for b2 being Element of NAT
for b3 being FinSequence of the carrier of TOP-REAL 2
   st b3 is_sequence_on Gauge(b1,b2) & 1 < len b3
for b4, b5 being Element of NAT
      st front_left_cell(b3,(len b3) -' 1,Gauge(b1,b2)) meets b1 &
         [b4,b5] in Indices Gauge(b1,b2) &
         b3 /. ((len b3) -' 1) = (Gauge(b1,b2)) *(b4,b5) &
         [b4 + 1,b5] in Indices Gauge(b1,b2) &
         b3 /. len b3 = (Gauge(b1,b2)) *(b4 + 1,b5)
   holds [b4 + 2,b5] in Indices Gauge(b1,b2);

:: JORDAN1H:th 67
theorem
for b1 being non empty compact non horizontal non vertical Element of bool the carrier of TOP-REAL 2
for b2 being Element of NAT
for b3 being FinSequence of the carrier of TOP-REAL 2
   st b3 is_sequence_on Gauge(b1,b2) & 1 < len b3
for b4, b5 being Element of NAT
      st front_left_cell(b3,(len b3) -' 1,Gauge(b1,b2)) meets b1 &
         [b5 + 1,b4] in Indices Gauge(b1,b2) &
         b3 /. ((len b3) -' 1) = (Gauge(b1,b2)) *(b5 + 1,b4) &
         [b5,b4] in Indices Gauge(b1,b2) &
         b3 /. len b3 = (Gauge(b1,b2)) *(b5,b4)
   holds [b5 -' 1,b4] in Indices Gauge(b1,b2);

:: JORDAN1H:th 68
theorem
for b1 being non empty compact non horizontal non vertical Element of bool the carrier of TOP-REAL 2
for b2 being Element of NAT
for b3 being FinSequence of the carrier of TOP-REAL 2
   st b3 is_sequence_on Gauge(b1,b2) & 1 < len b3
for b4, b5 being Element of NAT
      st front_left_cell(b3,(len b3) -' 1,Gauge(b1,b2)) meets b1 &
         [b4,b5 + 1] in Indices Gauge(b1,b2) &
         b3 /. ((len b3) -' 1) = (Gauge(b1,b2)) *(b4,b5 + 1) &
         [b4,b5] in Indices Gauge(b1,b2) &
         b3 /. len b3 = (Gauge(b1,b2)) *(b4,b5)
   holds [b4,b5 -' 1] in Indices Gauge(b1,b2);

:: JORDAN1H:th 69
theorem
for b1 being non empty compact non horizontal non vertical Element of bool the carrier of TOP-REAL 2
for b2 being Element of NAT
for b3 being FinSequence of the carrier of TOP-REAL 2
   st b3 is_sequence_on Gauge(b1,b2) & 1 < len b3
for b4, b5 being Element of NAT
      st front_right_cell(b3,(len b3) -' 1,Gauge(b1,b2)) meets b1 &
         [b4,b5] in Indices Gauge(b1,b2) &
         b3 /. ((len b3) -' 1) = (Gauge(b1,b2)) *(b4,b5) &
         [b4,b5 + 1] in Indices Gauge(b1,b2) &
         b3 /. len b3 = (Gauge(b1,b2)) *(b4,b5 + 1)
   holds [b4 + 1,b5 + 1] in Indices Gauge(b1,b2);

:: JORDAN1H:th 70
theorem
for b1 being non empty compact non horizontal non vertical Element of bool the carrier of TOP-REAL 2
for b2 being Element of NAT
for b3 being FinSequence of the carrier of TOP-REAL 2
   st b3 is_sequence_on Gauge(b1,b2) & 1 < len b3
for b4, b5 being Element of NAT
      st front_right_cell(b3,(len b3) -' 1,Gauge(b1,b2)) meets b1 &
         [b4,b5] in Indices Gauge(b1,b2) &
         b3 /. ((len b3) -' 1) = (Gauge(b1,b2)) *(b4,b5) &
         [b4 + 1,b5] in Indices Gauge(b1,b2) &
         b3 /. len b3 = (Gauge(b1,b2)) *(b4 + 1,b5)
   holds [b4 + 1,b5 -' 1] in Indices Gauge(b1,b2);

:: JORDAN1H:th 71
theorem
for b1 being non empty compact non horizontal non vertical Element of bool the carrier of TOP-REAL 2
for b2 being Element of NAT
for b3 being FinSequence of the carrier of TOP-REAL 2
   st b3 is_sequence_on Gauge(b1,b2) & 1 < len b3
for b4, b5 being Element of NAT
      st front_right_cell(b3,(len b3) -' 1,Gauge(b1,b2)) meets b1 &
         [b5 + 1,b4] in Indices Gauge(b1,b2) &
         b3 /. ((len b3) -' 1) = (Gauge(b1,b2)) *(b5 + 1,b4) &
         [b5,b4] in Indices Gauge(b1,b2) &
         b3 /. len b3 = (Gauge(b1,b2)) *(b5,b4)
   holds [b5,b4 + 1] in Indices Gauge(b1,b2);

:: JORDAN1H:th 72
theorem
for b1 being non empty compact non horizontal non vertical Element of bool the carrier of TOP-REAL 2
for b2 being Element of NAT
for b3 being FinSequence of the carrier of TOP-REAL 2
   st b3 is_sequence_on Gauge(b1,b2) & 1 < len b3
for b4, b5 being Element of NAT
      st front_right_cell(b3,(len b3) -' 1,Gauge(b1,b2)) meets b1 &
         [b4,b5 + 1] in Indices Gauge(b1,b2) &
         b3 /. ((len b3) -' 1) = (Gauge(b1,b2)) *(b4,b5 + 1) &
         [b4,b5] in Indices Gauge(b1,b2) &
         b3 /. len b3 = (Gauge(b1,b2)) *(b4,b5)
   holds [b4 -' 1,b5] in Indices Gauge(b1,b2);