Article GOBRD13, MML version 4.99.1005

:: GOBRD13:funcnot 1 => GOBRD13:func 1
definition
  let a1 be non empty set;
  let a2 be non empty FinSequenceSet of the carrier of TOP-REAL 2;
  let a3 be Function-like quasi_total Relation of a1,a2;
  let a4 be Element of a1;
  redefine func a3 . a4 -> FinSequence of the carrier of TOP-REAL 2;
end;

:: GOBRD13:funcnot 2 => GOBRD13:func 2
definition
  let a1 be Relation-like Function-like set;
  func Values A1 -> set equals
    Union rngs a1;
end;

:: GOBRD13:def 1
theorem
for b1 being Relation-like Function-like set holds
   Values b1 = Union rngs b1;

:: GOBRD13:th 1
theorem
for b1 being Element of NAT
for b2 being non empty set
for b3 being FinSequence of b2 * holds
   b3 . b1 is FinSequence of b2;

:: GOBRD13:condreg 1
registration
  let a1 be set;
  cluster -> FinSequence-yielding (FinSequence of a1 *);
end;

:: GOBRD13:condreg 2
registration
  cluster Relation-like Function-like FinSequence-yielding -> Function-yielding (set);
end;

:: GOBRD13:th 3
theorem
for b1 being non empty set
for b2 being FinSequence of b1 * holds
   Values b2 = union {proj2 b3 where b3 is Element of b1 *: b3 in proj2 b2};

:: GOBRD13:funcreg 1
registration
  let a1 be non empty set;
  let a2 be FinSequence of a1 *;
  cluster Values a2 -> finite;
end;

:: GOBRD13:th 4
theorem
for b1 being Element of NAT
for b2 being non empty set
for b3 being FinSequence of b2
for b4 being tabular FinSequence of b2 *
      st b1 in dom b4 & b4 . b1 = b3
   holds len b3 = width b4;

:: GOBRD13:th 5
theorem
for b1, b2 being Element of NAT
for b3 being non empty set
for b4 being FinSequence of b3
for b5 being tabular FinSequence of b3 *
      st b1 in dom b5 & b5 . b1 = b4 & b2 in dom b4
   holds [b1,b2] in Indices b5;

:: GOBRD13:th 6
theorem
for b1, b2 being Element of NAT
for b3 being non empty set
for b4 being FinSequence of b3
for b5 being tabular FinSequence of b3 *
      st [b1,b2] in Indices b5 & b5 . b1 = b4
   holds len b4 = width b5 & b2 in dom b4;

:: GOBRD13:th 7
theorem
for b1 being non empty set
for b2 being tabular FinSequence of b1 * holds
   Values b2 = {b2 *(b3,b4) where b3 is Element of NAT, b4 is Element of NAT: [b3,b4] in Indices b2};

:: GOBRD13:th 8
theorem
for b1 being non empty set
for b2 being tabular FinSequence of b1 * holds
   card Values b2 <= (len b2) * width b2;

:: GOBRD13:th 9
theorem
for b1 being FinSequence of the carrier of TOP-REAL 2
for b2 being tabular FinSequence of (the carrier of TOP-REAL 2) *
      st b1 is_sequence_on b2
   holds proj2 b1 c= Values b2;

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

:: GOBRD13:th 11
theorem
for b1, b2, b3 being Element of NAT
for b4, 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 Values b4 c= Values b5 & [b1,b2] in Indices b4 & 1 <= b3 & b3 <= width b5 & b4 *(b1,b2) = b5 *(len b5,b3)
   holds b1 = len b4;

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

:: GOBRD13:th 13
theorem
for b1, b2, b3 being Element of NAT
for b4, 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 Values b4 c= Values b5 & [b1,b2] in Indices b4 & 1 <= b3 & b3 <= len b5 & b4 *(b1,b2) = b5 *(b3,width b5)
   holds b2 = width b4;

:: GOBRD13:th 14
theorem
for b1, b2, b3, b4 being Element of NAT
for b5, b6 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 Values b5 c= Values b6 & 1 <= b1 & b1 < len b5 & 1 <= b2 & b2 <= width b5 & 1 <= b3 & b3 < len b6 & 1 <= b4 & b4 <= width b6 & b5 *(b1,b2) = b6 *(b3,b4)
   holds (b6 *(b3 + 1,b4)) `1 <= (b5 *(b1 + 1,b2)) `1;

:: GOBRD13:th 15
theorem
for b1, b2, b3, b4 being Element of NAT
for b5, b6 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 b5 *(b1 -' 1,b2) in Values b6 & 1 < b1 & b1 <= len b5 & 1 <= b2 & b2 <= width b5 & 1 < b3 & b3 <= len b6 & 1 <= b4 & b4 <= width b6 & b5 *(b1,b2) = b6 *(b3,b4)
   holds (b5 *(b1 -' 1,b2)) `1 <= (b6 *(b3 -' 1,b4)) `1;

:: GOBRD13:th 16
theorem
for b1, b2, b3, b4 being Element of NAT
for b5, b6 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 b5 *(b1,b2 + 1) in Values b6 & 1 <= b1 & b1 <= len b5 & 1 <= b2 & b2 < width b5 & 1 <= b3 & b3 <= len b6 & 1 <= b4 & b4 < width b6 & b5 *(b1,b2) = b6 *(b3,b4)
   holds (b6 *(b3,b4 + 1)) `2 <= (b5 *(b1,b2 + 1)) `2;

:: GOBRD13:th 17
theorem
for b1, b2, b3, b4 being Element of NAT
for b5, b6 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 Values b5 c= Values b6 & 1 <= b1 & b1 <= len b5 & 1 < b2 & b2 <= width b5 & 1 <= b3 & b3 <= len b6 & 1 < b4 & b4 <= width b6 & b5 *(b1,b2) = b6 *(b3,b4)
   holds (b5 *(b1,b2 -' 1)) `2 <= (b6 *(b3,b4 -' 1)) `2;

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

:: GOBRD13:th 19
theorem
for b1, b2, b3, b4 being Element of NAT
for b5, b6 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 Values b5 c= Values b6 & [b1,b2] in Indices b5 & [b3,b4] in Indices b6 & b5 *(b1,b2) = b6 *(b3,b4)
   holds cell(b6,b3 -' 1,b4) c= cell(b5,b1 -' 1,b2);

:: GOBRD13:th 20
theorem
for b1, b2, b3, b4 being Element of NAT
for b5, b6 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 Values b5 c= Values b6 & [b1,b2] in Indices b5 & [b3,b4] in Indices b6 & b5 *(b1,b2) = b6 *(b3,b4)
   holds cell(b6,b3,b4 -' 1) c= cell(b5,b1,b2 -' 1);

:: GOBRD13:th 21
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 circular special unfolded s.c.c. standard FinSequence of the carrier of TOP-REAL 2
      st b2 is_sequence_on b1
   holds Values GoB b2 c= Values b1;

:: GOBRD13:funcnot 3 => GOBRD13:func 3
definition
  let a1 be FinSequence of the carrier of TOP-REAL 2;
  let a2 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) *;
  let a3 be Element of NAT;
  assume 1 <= a3 & a3 + 1 <= len a1 & a1 is_sequence_on a2;
  func right_cell(A1,A3,A2) -> Element of bool the carrier of TOP-REAL 2 means
    for b1, b2, b3, b4 being Element of NAT
          st [b1,b2] in Indices a2 &
             [b3,b4] in Indices a2 &
             a1 /. a3 = a2 *(b1,b2) &
             a1 /. (a3 + 1) = a2 *(b3,b4) &
             (b1 = b3 & b2 + 1 = b4 implies it <> cell(a2,b1,b2)) &
             (b1 + 1 = b3 & b2 = b4 implies it <> cell(a2,b1,b2 -' 1)) &
             (b1 = b3 + 1 & b2 = b4 implies it <> cell(a2,b3,b4))
       holds b1 = b3 & b2 = b4 + 1 & it = cell(a2,b1 -' 1,b4);
end;

:: GOBRD13:def 2
theorem
for b1 being 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) *
for b3 being Element of NAT
   st 1 <= b3 & b3 + 1 <= len b1 & b1 is_sequence_on b2
for b4 being Element of bool the carrier of TOP-REAL 2 holds
      b4 = right_cell(b1,b3,b2)
   iff
      for b5, b6, b7, b8 being Element of NAT
            st [b5,b6] in Indices b2 &
               [b7,b8] in Indices b2 &
               b1 /. b3 = b2 *(b5,b6) &
               b1 /. (b3 + 1) = b2 *(b7,b8) &
               (b5 = b7 & b6 + 1 = b8 implies b4 <> cell(b2,b5,b6)) &
               (b5 + 1 = b7 & b6 = b8 implies b4 <> cell(b2,b5,b6 -' 1)) &
               (b5 = b7 + 1 & b6 = b8 implies b4 <> cell(b2,b7,b8))
         holds b5 = b7 & b6 = b8 + 1 & b4 = cell(b2,b5 -' 1,b8);

:: GOBRD13:funcnot 4 => GOBRD13:func 4
definition
  let a1 be FinSequence of the carrier of TOP-REAL 2;
  let a2 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) *;
  let a3 be Element of NAT;
  assume 1 <= a3 & a3 + 1 <= len a1 & a1 is_sequence_on a2;
  func left_cell(A1,A3,A2) -> Element of bool the carrier of TOP-REAL 2 means
    for b1, b2, b3, b4 being Element of NAT
          st [b1,b2] in Indices a2 &
             [b3,b4] in Indices a2 &
             a1 /. a3 = a2 *(b1,b2) &
             a1 /. (a3 + 1) = a2 *(b3,b4) &
             (b1 = b3 & b2 + 1 = b4 implies it <> cell(a2,b1 -' 1,b2)) &
             (b1 + 1 = b3 & b2 = b4 implies it <> cell(a2,b1,b2)) &
             (b1 = b3 + 1 & b2 = b4 implies it <> cell(a2,b3,b4 -' 1))
       holds b1 = b3 & b2 = b4 + 1 & it = cell(a2,b1,b4);
end;

:: GOBRD13:def 3
theorem
for b1 being 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) *
for b3 being Element of NAT
   st 1 <= b3 & b3 + 1 <= len b1 & b1 is_sequence_on b2
for b4 being Element of bool the carrier of TOP-REAL 2 holds
      b4 = left_cell(b1,b3,b2)
   iff
      for b5, b6, b7, b8 being Element of NAT
            st [b5,b6] in Indices b2 &
               [b7,b8] in Indices b2 &
               b1 /. b3 = b2 *(b5,b6) &
               b1 /. (b3 + 1) = b2 *(b7,b8) &
               (b5 = b7 & b6 + 1 = b8 implies b4 <> cell(b2,b5 -' 1,b6)) &
               (b5 + 1 = b7 & b6 = b8 implies b4 <> cell(b2,b5,b6)) &
               (b5 = b7 + 1 & b6 = b8 implies b4 <> cell(b2,b7,b8 -' 1))
         holds b5 = b7 & b6 = b8 + 1 & b4 = cell(b2,b5,b8);

:: GOBRD13:th 22
theorem
for b1, b2, b3 being Element of NAT
for b4 being FinSequence of the carrier of TOP-REAL 2
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 1 <= b1 &
         b1 + 1 <= len b4 &
         b4 is_sequence_on b5 &
         [b2,b3] in Indices b5 &
         [b2,b3 + 1] in Indices b5 &
         b4 /. b1 = b5 *(b2,b3) &
         b4 /. (b1 + 1) = b5 *(b2,b3 + 1)
   holds left_cell(b4,b1,b5) = cell(b5,b2 -' 1,b3);

:: GOBRD13:th 23
theorem
for b1, b2, b3 being Element of NAT
for b4 being FinSequence of the carrier of TOP-REAL 2
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 1 <= b1 &
         b1 + 1 <= len b4 &
         b4 is_sequence_on b5 &
         [b2,b3] in Indices b5 &
         [b2,b3 + 1] in Indices b5 &
         b4 /. b1 = b5 *(b2,b3) &
         b4 /. (b1 + 1) = b5 *(b2,b3 + 1)
   holds right_cell(b4,b1,b5) = cell(b5,b2,b3);

:: GOBRD13:th 24
theorem
for b1, b2, b3 being Element of NAT
for b4 being FinSequence of the carrier of TOP-REAL 2
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 1 <= b1 &
         b1 + 1 <= len b4 &
         b4 is_sequence_on b5 &
         [b2,b3] in Indices b5 &
         [b2 + 1,b3] in Indices b5 &
         b4 /. b1 = b5 *(b2,b3) &
         b4 /. (b1 + 1) = b5 *(b2 + 1,b3)
   holds left_cell(b4,b1,b5) = cell(b5,b2,b3);

:: GOBRD13:th 25
theorem
for b1, b2, b3 being Element of NAT
for b4 being FinSequence of the carrier of TOP-REAL 2
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 1 <= b1 &
         b1 + 1 <= len b4 &
         b4 is_sequence_on b5 &
         [b2,b3] in Indices b5 &
         [b2 + 1,b3] in Indices b5 &
         b4 /. b1 = b5 *(b2,b3) &
         b4 /. (b1 + 1) = b5 *(b2 + 1,b3)
   holds right_cell(b4,b1,b5) = cell(b5,b2,b3 -' 1);

:: GOBRD13:th 26
theorem
for b1, b2, b3 being Element of NAT
for b4 being FinSequence of the carrier of TOP-REAL 2
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 1 <= b1 & b1 + 1 <= len b4 & b4 is_sequence_on b5 & [b2,b3] in Indices b5 & [b2 + 1,b3] in Indices b5 & b4 /. b1 = b5 *(b2 + 1,b3) & b4 /. (b1 + 1) = b5 *(b2,b3)
   holds left_cell(b4,b1,b5) = cell(b5,b2,b3 -' 1);

:: GOBRD13:th 27
theorem
for b1, b2, b3 being Element of NAT
for b4 being FinSequence of the carrier of TOP-REAL 2
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 1 <= b1 & b1 + 1 <= len b4 & b4 is_sequence_on b5 & [b2,b3] in Indices b5 & [b2 + 1,b3] in Indices b5 & b4 /. b1 = b5 *(b2 + 1,b3) & b4 /. (b1 + 1) = b5 *(b2,b3)
   holds right_cell(b4,b1,b5) = cell(b5,b2,b3);

:: GOBRD13:th 28
theorem
for b1, b2, b3 being Element of NAT
for b4 being FinSequence of the carrier of TOP-REAL 2
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 1 <= b1 & b1 + 1 <= len b4 & b4 is_sequence_on b5 & [b2,b3 + 1] in Indices b5 & [b2,b3] in Indices b5 & b4 /. b1 = b5 *(b2,b3 + 1) & b4 /. (b1 + 1) = b5 *(b2,b3)
   holds left_cell(b4,b1,b5) = cell(b5,b2,b3);

:: GOBRD13:th 29
theorem
for b1, b2, b3 being Element of NAT
for b4 being FinSequence of the carrier of TOP-REAL 2
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 1 <= b1 & b1 + 1 <= len b4 & b4 is_sequence_on b5 & [b2,b3 + 1] in Indices b5 & [b2,b3] in Indices b5 & b4 /. b1 = b5 *(b2,b3 + 1) & b4 /. (b1 + 1) = b5 *(b2,b3)
   holds right_cell(b4,b1,b5) = cell(b5,b2 -' 1,b3);

:: GOBRD13:th 30
theorem
for b1 being Element of NAT
for b2 being FinSequence of the carrier of TOP-REAL 2
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 b2 & b2 is_sequence_on b3
   holds (left_cell(b2,b1,b3)) /\ right_cell(b2,b1,b3) = LSeg(b2,b1);

:: GOBRD13:th 31
theorem
for b1 being Element of NAT
for b2 being FinSequence of the carrier of TOP-REAL 2
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 b2 & b2 is_sequence_on b3
   holds right_cell(b2,b1,b3) is closed(TOP-REAL 2);

:: GOBRD13:th 32
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 1 <= b1 & b1 + 1 <= len b3 & b3 is_sequence_on b4 & b1 + 1 <= b2
   holds left_cell(b3,b1,b4) = left_cell(b3 | b2,b1,b4) & right_cell(b3,b1,b4) = right_cell(b3 | b2,b1,b4);

:: GOBRD13: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 1 <= b1 & b1 + 1 <= len (b3 /^ b2) & b2 <= len b3 & b3 is_sequence_on b4
   holds left_cell(b3,b1 + b2,b4) = left_cell(b3 /^ b2,b1,b4) &
    right_cell(b3,b1 + b2,b4) = right_cell(b3 /^ b2,b1,b4);

:: GOBRD13: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) *
for b3 being non empty circular special unfolded s.c.c. standard FinSequence of the carrier of TOP-REAL 2
      st 1 <= b1 & b1 + 1 <= len b3 & b3 is_sequence_on b2
   holds left_cell(b3,b1,b2) c= left_cell(b3,b1) & right_cell(b3,b1,b2) c= right_cell(b3,b1);

:: GOBRD13:funcnot 5 => GOBRD13:func 5
definition
  let a1 be FinSequence of the carrier of TOP-REAL 2;
  let a2 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) *;
  let a3 be Element of NAT;
  assume 1 <= a3 & a3 + 1 <= len a1 & a1 is_sequence_on a2;
  func front_right_cell(A1,A3,A2) -> Element of bool the carrier of TOP-REAL 2 means
    for b1, b2, b3, b4 being Element of NAT
          st [b1,b2] in Indices a2 &
             [b3,b4] in Indices a2 &
             a1 /. a3 = a2 *(b1,b2) &
             a1 /. (a3 + 1) = a2 *(b3,b4) &
             (b1 = b3 & b2 + 1 = b4 implies it <> cell(a2,b3,b4)) &
             (b1 + 1 = b3 & b2 = b4 implies it <> cell(a2,b3,b4 -' 1)) &
             (b1 = b3 + 1 & b2 = b4 implies it <> cell(a2,b3 -' 1,b4))
       holds b1 = b3 &
        b2 = b4 + 1 &
        it = cell(a2,b3 -' 1,b4 -' 1);
end;

:: GOBRD13:def 4
theorem
for b1 being 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) *
for b3 being Element of NAT
   st 1 <= b3 & b3 + 1 <= len b1 & b1 is_sequence_on b2
for b4 being Element of bool the carrier of TOP-REAL 2 holds
      b4 = front_right_cell(b1,b3,b2)
   iff
      for b5, b6, b7, b8 being Element of NAT
            st [b5,b6] in Indices b2 &
               [b7,b8] in Indices b2 &
               b1 /. b3 = b2 *(b5,b6) &
               b1 /. (b3 + 1) = b2 *(b7,b8) &
               (b5 = b7 & b6 + 1 = b8 implies b4 <> cell(b2,b7,b8)) &
               (b5 + 1 = b7 & b6 = b8 implies b4 <> cell(b2,b7,b8 -' 1)) &
               (b5 = b7 + 1 & b6 = b8 implies b4 <> cell(b2,b7 -' 1,b8))
         holds b5 = b7 &
          b6 = b8 + 1 &
          b4 = cell(b2,b7 -' 1,b8 -' 1);

:: GOBRD13:funcnot 6 => GOBRD13:func 6
definition
  let a1 be FinSequence of the carrier of TOP-REAL 2;
  let a2 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) *;
  let a3 be Element of NAT;
  assume 1 <= a3 & a3 + 1 <= len a1 & a1 is_sequence_on a2;
  func front_left_cell(A1,A3,A2) -> Element of bool the carrier of TOP-REAL 2 means
    for b1, b2, b3, b4 being Element of NAT
          st [b1,b2] in Indices a2 &
             [b3,b4] in Indices a2 &
             a1 /. a3 = a2 *(b1,b2) &
             a1 /. (a3 + 1) = a2 *(b3,b4) &
             (b1 = b3 & b2 + 1 = b4 implies it <> cell(a2,b3 -' 1,b4)) &
             (b1 + 1 = b3 & b2 = b4 implies it <> cell(a2,b3,b4)) &
             (b1 = b3 + 1 & b2 = b4 implies it <> cell(a2,b3 -' 1,b4 -' 1))
       holds b1 = b3 & b2 = b4 + 1 & it = cell(a2,b3,b4 -' 1);
end;

:: GOBRD13:def 5
theorem
for b1 being 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) *
for b3 being Element of NAT
   st 1 <= b3 & b3 + 1 <= len b1 & b1 is_sequence_on b2
for b4 being Element of bool the carrier of TOP-REAL 2 holds
      b4 = front_left_cell(b1,b3,b2)
   iff
      for b5, b6, b7, b8 being Element of NAT
            st [b5,b6] in Indices b2 &
               [b7,b8] in Indices b2 &
               b1 /. b3 = b2 *(b5,b6) &
               b1 /. (b3 + 1) = b2 *(b7,b8) &
               (b5 = b7 & b6 + 1 = b8 implies b4 <> cell(b2,b7 -' 1,b8)) &
               (b5 + 1 = b7 & b6 = b8 implies b4 <> cell(b2,b7,b8)) &
               (b5 = b7 + 1 & b6 = b8 implies b4 <> cell(b2,b7 -' 1,b8 -' 1))
         holds b5 = b7 & b6 = b8 + 1 & b4 = cell(b2,b7,b8 -' 1);

:: GOBRD13:th 35
theorem
for b1, b2, b3 being Element of NAT
for b4 being FinSequence of the carrier of TOP-REAL 2
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 1 <= b1 &
         b1 + 1 <= len b4 &
         b4 is_sequence_on b5 &
         [b2,b3] in Indices b5 &
         [b2,b3 + 1] in Indices b5 &
         b4 /. b1 = b5 *(b2,b3) &
         b4 /. (b1 + 1) = b5 *(b2,b3 + 1)
   holds front_left_cell(b4,b1,b5) = cell(b5,b2 -' 1,b3 + 1);

:: GOBRD13:th 36
theorem
for b1, b2, b3 being Element of NAT
for b4 being FinSequence of the carrier of TOP-REAL 2
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 1 <= b1 &
         b1 + 1 <= len b4 &
         b4 is_sequence_on b5 &
         [b2,b3] in Indices b5 &
         [b2,b3 + 1] in Indices b5 &
         b4 /. b1 = b5 *(b2,b3) &
         b4 /. (b1 + 1) = b5 *(b2,b3 + 1)
   holds front_right_cell(b4,b1,b5) = cell(b5,b2,b3 + 1);

:: GOBRD13:th 37
theorem
for b1, b2, b3 being Element of NAT
for b4 being FinSequence of the carrier of TOP-REAL 2
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 1 <= b1 &
         b1 + 1 <= len b4 &
         b4 is_sequence_on b5 &
         [b2,b3] in Indices b5 &
         [b2 + 1,b3] in Indices b5 &
         b4 /. b1 = b5 *(b2,b3) &
         b4 /. (b1 + 1) = b5 *(b2 + 1,b3)
   holds front_left_cell(b4,b1,b5) = cell(b5,b2 + 1,b3);

:: GOBRD13:th 38
theorem
for b1, b2, b3 being Element of NAT
for b4 being FinSequence of the carrier of TOP-REAL 2
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 1 <= b1 &
         b1 + 1 <= len b4 &
         b4 is_sequence_on b5 &
         [b2,b3] in Indices b5 &
         [b2 + 1,b3] in Indices b5 &
         b4 /. b1 = b5 *(b2,b3) &
         b4 /. (b1 + 1) = b5 *(b2 + 1,b3)
   holds front_right_cell(b4,b1,b5) = cell(b5,b2 + 1,b3 -' 1);

:: GOBRD13:th 39
theorem
for b1, b2, b3 being Element of NAT
for b4 being FinSequence of the carrier of TOP-REAL 2
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 1 <= b1 & b1 + 1 <= len b4 & b4 is_sequence_on b5 & [b2,b3] in Indices b5 & [b2 + 1,b3] in Indices b5 & b4 /. b1 = b5 *(b2 + 1,b3) & b4 /. (b1 + 1) = b5 *(b2,b3)
   holds front_left_cell(b4,b1,b5) = cell(b5,b2 -' 1,b3 -' 1);

:: GOBRD13:th 40
theorem
for b1, b2, b3 being Element of NAT
for b4 being FinSequence of the carrier of TOP-REAL 2
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 1 <= b1 & b1 + 1 <= len b4 & b4 is_sequence_on b5 & [b2,b3] in Indices b5 & [b2 + 1,b3] in Indices b5 & b4 /. b1 = b5 *(b2 + 1,b3) & b4 /. (b1 + 1) = b5 *(b2,b3)
   holds front_right_cell(b4,b1,b5) = cell(b5,b2 -' 1,b3);

:: GOBRD13:th 41
theorem
for b1, b2, b3 being Element of NAT
for b4 being FinSequence of the carrier of TOP-REAL 2
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 1 <= b1 & b1 + 1 <= len b4 & b4 is_sequence_on b5 & [b2,b3 + 1] in Indices b5 & [b2,b3] in Indices b5 & b4 /. b1 = b5 *(b2,b3 + 1) & b4 /. (b1 + 1) = b5 *(b2,b3)
   holds front_left_cell(b4,b1,b5) = cell(b5,b2,b3 -' 1);

:: GOBRD13:th 42
theorem
for b1, b2, b3 being Element of NAT
for b4 being FinSequence of the carrier of TOP-REAL 2
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 1 <= b1 & b1 + 1 <= len b4 & b4 is_sequence_on b5 & [b2,b3 + 1] in Indices b5 & [b2,b3] in Indices b5 & b4 /. b1 = b5 *(b2,b3 + 1) & b4 /. (b1 + 1) = b5 *(b2,b3)
   holds front_right_cell(b4,b1,b5) = cell(b5,b2 -' 1,b3 -' 1);

:: GOBRD13:th 43
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 1 <= b1 & b1 + 1 <= len b3 & b3 is_sequence_on b4 & b1 + 1 <= b2
   holds front_left_cell(b3,b1,b4) = front_left_cell(b3 | b2,b1,b4) &
    front_right_cell(b3,b1,b4) = front_right_cell(b3 | b2,b1,b4);

:: GOBRD13:prednot 1 => GOBRD13:pred 1
definition
  let a1 be set;
  let a2 be FinSequence of a1;
  let a3 be tabular FinSequence of a1 *;
  let a4 be Element of NAT;
  pred A2 turns_right A4,A3 means
    for b1, b2, b3, b4 being Element of NAT
          st [b1,b2] in Indices a3 &
             [b3,b4] in Indices a3 &
             a2 /. a4 = a3 *(b1,b2) &
             a2 /. (a4 + 1) = a3 *(b3,b4) &
             (b1 = b3 & b2 + 1 = b4 & [b3 + 1,b4] in Indices a3 implies a2 /. (a4 + 2) <> a3 *(b3 + 1,b4)) &
             (b1 + 1 = b3 & b2 = b4 & [b3,b4 -' 1] in Indices a3 implies a2 /. (a4 + 2) <> a3 *(b3,b4 -' 1)) &
             (b1 = b3 + 1 & b2 = b4 & [b3,b4 + 1] in Indices a3 implies a2 /. (a4 + 2) <> a3 *(b3,b4 + 1))
       holds b1 = b3 &
        b2 = b4 + 1 &
        [b3 -' 1,b4] in Indices a3 &
        a2 /. (a4 + 2) = a3 *(b3 -' 1,b4);
end;

:: GOBRD13:dfs 6
definiens
  let a1 be set;
  let a2 be FinSequence of a1;
  let a3 be tabular FinSequence of a1 *;
  let a4 be Element of NAT;
To prove
     a2 turns_right a4,a3
it is sufficient to prove
  thus for b1, b2, b3, b4 being Element of NAT
          st [b1,b2] in Indices a3 &
             [b3,b4] in Indices a3 &
             a2 /. a4 = a3 *(b1,b2) &
             a2 /. (a4 + 1) = a3 *(b3,b4) &
             (b1 = b3 & b2 + 1 = b4 & [b3 + 1,b4] in Indices a3 implies a2 /. (a4 + 2) <> a3 *(b3 + 1,b4)) &
             (b1 + 1 = b3 & b2 = b4 & [b3,b4 -' 1] in Indices a3 implies a2 /. (a4 + 2) <> a3 *(b3,b4 -' 1)) &
             (b1 = b3 + 1 & b2 = b4 & [b3,b4 + 1] in Indices a3 implies a2 /. (a4 + 2) <> a3 *(b3,b4 + 1))
       holds b1 = b3 &
        b2 = b4 + 1 &
        [b3 -' 1,b4] in Indices a3 &
        a2 /. (a4 + 2) = a3 *(b3 -' 1,b4);

:: GOBRD13:def 6
theorem
for b1 being set
for b2 being FinSequence of b1
for b3 being tabular FinSequence of b1 *
for b4 being Element of NAT holds
      b2 turns_right b4,b3
   iff
      for b5, b6, b7, b8 being Element of NAT
            st [b5,b6] in Indices b3 &
               [b7,b8] in Indices b3 &
               b2 /. b4 = b3 *(b5,b6) &
               b2 /. (b4 + 1) = b3 *(b7,b8) &
               (b5 = b7 & b6 + 1 = b8 & [b7 + 1,b8] in Indices b3 implies b2 /. (b4 + 2) <> b3 *(b7 + 1,b8)) &
               (b5 + 1 = b7 & b6 = b8 & [b7,b8 -' 1] in Indices b3 implies b2 /. (b4 + 2) <> b3 *(b7,b8 -' 1)) &
               (b5 = b7 + 1 & b6 = b8 & [b7,b8 + 1] in Indices b3 implies b2 /. (b4 + 2) <> b3 *(b7,b8 + 1))
         holds b5 = b7 &
          b6 = b8 + 1 &
          [b7 -' 1,b8] in Indices b3 &
          b2 /. (b4 + 2) = b3 *(b7 -' 1,b8);

:: GOBRD13:prednot 2 => GOBRD13:pred 2
definition
  let a1 be set;
  let a2 be FinSequence of a1;
  let a3 be tabular FinSequence of a1 *;
  let a4 be Element of NAT;
  pred A2 turns_left A4,A3 means
    for b1, b2, b3, b4 being Element of NAT
          st [b1,b2] in Indices a3 &
             [b3,b4] in Indices a3 &
             a2 /. a4 = a3 *(b1,b2) &
             a2 /. (a4 + 1) = a3 *(b3,b4) &
             (b1 = b3 & b2 + 1 = b4 & [b3 -' 1,b4] in Indices a3 implies a2 /. (a4 + 2) <> a3 *(b3 -' 1,b4)) &
             (b1 + 1 = b3 & b2 = b4 & [b3,b4 + 1] in Indices a3 implies a2 /. (a4 + 2) <> a3 *(b3,b4 + 1)) &
             (b1 = b3 + 1 & b2 = b4 & [b3,b4 -' 1] in Indices a3 implies a2 /. (a4 + 2) <> a3 *(b3,b4 -' 1))
       holds b1 = b3 &
        b2 = b4 + 1 &
        [b3 + 1,b4] in Indices a3 &
        a2 /. (a4 + 2) = a3 *(b3 + 1,b4);
end;

:: GOBRD13:dfs 7
definiens
  let a1 be set;
  let a2 be FinSequence of a1;
  let a3 be tabular FinSequence of a1 *;
  let a4 be Element of NAT;
To prove
     a2 turns_left a4,a3
it is sufficient to prove
  thus for b1, b2, b3, b4 being Element of NAT
          st [b1,b2] in Indices a3 &
             [b3,b4] in Indices a3 &
             a2 /. a4 = a3 *(b1,b2) &
             a2 /. (a4 + 1) = a3 *(b3,b4) &
             (b1 = b3 & b2 + 1 = b4 & [b3 -' 1,b4] in Indices a3 implies a2 /. (a4 + 2) <> a3 *(b3 -' 1,b4)) &
             (b1 + 1 = b3 & b2 = b4 & [b3,b4 + 1] in Indices a3 implies a2 /. (a4 + 2) <> a3 *(b3,b4 + 1)) &
             (b1 = b3 + 1 & b2 = b4 & [b3,b4 -' 1] in Indices a3 implies a2 /. (a4 + 2) <> a3 *(b3,b4 -' 1))
       holds b1 = b3 &
        b2 = b4 + 1 &
        [b3 + 1,b4] in Indices a3 &
        a2 /. (a4 + 2) = a3 *(b3 + 1,b4);

:: GOBRD13:def 7
theorem
for b1 being set
for b2 being FinSequence of b1
for b3 being tabular FinSequence of b1 *
for b4 being Element of NAT holds
      b2 turns_left b4,b3
   iff
      for b5, b6, b7, b8 being Element of NAT
            st [b5,b6] in Indices b3 &
               [b7,b8] in Indices b3 &
               b2 /. b4 = b3 *(b5,b6) &
               b2 /. (b4 + 1) = b3 *(b7,b8) &
               (b5 = b7 & b6 + 1 = b8 & [b7 -' 1,b8] in Indices b3 implies b2 /. (b4 + 2) <> b3 *(b7 -' 1,b8)) &
               (b5 + 1 = b7 & b6 = b8 & [b7,b8 + 1] in Indices b3 implies b2 /. (b4 + 2) <> b3 *(b7,b8 + 1)) &
               (b5 = b7 + 1 & b6 = b8 & [b7,b8 -' 1] in Indices b3 implies b2 /. (b4 + 2) <> b3 *(b7,b8 -' 1))
         holds b5 = b7 &
          b6 = b8 + 1 &
          [b7 + 1,b8] in Indices b3 &
          b2 /. (b4 + 2) = b3 *(b7 + 1,b8);

:: GOBRD13:prednot 3 => GOBRD13:pred 3
definition
  let a1 be set;
  let a2 be FinSequence of a1;
  let a3 be tabular FinSequence of a1 *;
  let a4 be Element of NAT;
  pred A2 goes_straight A4,A3 means
    for b1, b2, b3, b4 being Element of NAT
          st [b1,b2] in Indices a3 &
             [b3,b4] in Indices a3 &
             a2 /. a4 = a3 *(b1,b2) &
             a2 /. (a4 + 1) = a3 *(b3,b4) &
             (b1 = b3 & b2 + 1 = b4 & [b3,b4 + 1] in Indices a3 implies a2 /. (a4 + 2) <> a3 *(b3,b4 + 1)) &
             (b1 + 1 = b3 & b2 = b4 & [b3 + 1,b4] in Indices a3 implies a2 /. (a4 + 2) <> a3 *(b3 + 1,b4)) &
             (b1 = b3 + 1 & b2 = b4 & [b3 -' 1,b4] in Indices a3 implies a2 /. (a4 + 2) <> a3 *(b3 -' 1,b4))
       holds b1 = b3 &
        b2 = b4 + 1 &
        [b3,b4 -' 1] in Indices a3 &
        a2 /. (a4 + 2) = a3 *(b3,b4 -' 1);
end;

:: GOBRD13:dfs 8
definiens
  let a1 be set;
  let a2 be FinSequence of a1;
  let a3 be tabular FinSequence of a1 *;
  let a4 be Element of NAT;
To prove
     a2 goes_straight a4,a3
it is sufficient to prove
  thus for b1, b2, b3, b4 being Element of NAT
          st [b1,b2] in Indices a3 &
             [b3,b4] in Indices a3 &
             a2 /. a4 = a3 *(b1,b2) &
             a2 /. (a4 + 1) = a3 *(b3,b4) &
             (b1 = b3 & b2 + 1 = b4 & [b3,b4 + 1] in Indices a3 implies a2 /. (a4 + 2) <> a3 *(b3,b4 + 1)) &
             (b1 + 1 = b3 & b2 = b4 & [b3 + 1,b4] in Indices a3 implies a2 /. (a4 + 2) <> a3 *(b3 + 1,b4)) &
             (b1 = b3 + 1 & b2 = b4 & [b3 -' 1,b4] in Indices a3 implies a2 /. (a4 + 2) <> a3 *(b3 -' 1,b4))
       holds b1 = b3 &
        b2 = b4 + 1 &
        [b3,b4 -' 1] in Indices a3 &
        a2 /. (a4 + 2) = a3 *(b3,b4 -' 1);

:: GOBRD13:def 8
theorem
for b1 being set
for b2 being FinSequence of b1
for b3 being tabular FinSequence of b1 *
for b4 being Element of NAT holds
      b2 goes_straight b4,b3
   iff
      for b5, b6, b7, b8 being Element of NAT
            st [b5,b6] in Indices b3 &
               [b7,b8] in Indices b3 &
               b2 /. b4 = b3 *(b5,b6) &
               b2 /. (b4 + 1) = b3 *(b7,b8) &
               (b5 = b7 & b6 + 1 = b8 & [b7,b8 + 1] in Indices b3 implies b2 /. (b4 + 2) <> b3 *(b7,b8 + 1)) &
               (b5 + 1 = b7 & b6 = b8 & [b7 + 1,b8] in Indices b3 implies b2 /. (b4 + 2) <> b3 *(b7 + 1,b8)) &
               (b5 = b7 + 1 & b6 = b8 & [b7 -' 1,b8] in Indices b3 implies b2 /. (b4 + 2) <> b3 *(b7 -' 1,b8))
         holds b5 = b7 &
          b6 = b8 + 1 &
          [b7,b8 -' 1] in Indices b3 &
          b2 /. (b4 + 2) = b3 *(b7,b8 -' 1);

:: GOBRD13:th 44
theorem
for b1, b2 being Element of NAT
for b3 being set
for b4 being FinSequence of b3
for b5 being tabular FinSequence of b3 *
      st 1 <= b1 & b1 + 2 <= len b4 & b1 + 2 <= b2 & b4 | b2 turns_right b1,b5
   holds b4 turns_right b1,b5;

:: GOBRD13:th 45
theorem
for b1, b2 being Element of NAT
for b3 being set
for b4 being FinSequence of b3
for b5 being tabular FinSequence of b3 *
      st 1 <= b1 & b1 + 2 <= len b4 & b1 + 2 <= b2 & b4 | b2 turns_left b1,b5
   holds b4 turns_left b1,b5;

:: GOBRD13:th 46
theorem
for b1, b2 being Element of NAT
for b3 being set
for b4 being FinSequence of b3
for b5 being tabular FinSequence of b3 *
      st 1 <= b1 & b1 + 2 <= len b4 & b1 + 2 <= b2 & b4 | b2 goes_straight b1,b5
   holds b4 goes_straight b1,b5;

:: GOBRD13:th 47
theorem
for b1 being Element of NAT
for b2 being set
for b3, b4 being FinSequence of b2
for b5 being tabular FinSequence of b2 *
      st 1 < b1 & b1 + 1 <= len b3 & b1 + 1 <= len b4 & b3 is_sequence_on b5 & b3 | b1 = b4 | b1 & b3 turns_right b1 -' 1,b5 & b4 turns_right b1 -' 1,b5
   holds b3 | (b1 + 1) = b4 | (b1 + 1);

:: GOBRD13:th 48
theorem
for b1 being Element of NAT
for b2 being set
for b3, b4 being FinSequence of b2
for b5 being tabular FinSequence of b2 *
      st 1 < b1 & b1 + 1 <= len b3 & b1 + 1 <= len b4 & b3 is_sequence_on b5 & b3 | b1 = b4 | b1 & b3 turns_left b1 -' 1,b5 & b4 turns_left b1 -' 1,b5
   holds b3 | (b1 + 1) = b4 | (b1 + 1);

:: GOBRD13:th 49
theorem
for b1 being Element of NAT
for b2 being set
for b3, b4 being FinSequence of b2
for b5 being tabular FinSequence of b2 *
      st 1 < b1 & b1 + 1 <= len b3 & b1 + 1 <= len b4 & b3 is_sequence_on b5 & b3 | b1 = b4 | b1 & b3 goes_straight b1 -' 1,b5 & b4 goes_straight b1 -' 1,b5
   holds b3 | (b1 + 1) = b4 | (b1 + 1);

:: GOBRD13:th 50
theorem
for b1, b2 being Element of NAT
for b3 being non empty set
for b4 being tabular FinSequence of b3 *
      st 1 <= b1 & b1 <= len b4 & 1 <= b2 & b2 <= width b4
   holds b4 *(b1,b2) in Values b4;