Article GOBOARD1, MML version 4.99.1005

:: GOBOARD1:th 1
theorem
for b1, b2 being Element of REAL holds
   abs (b1 - b2) = 1
iff
   (b2 < b1 & b1 = b2 + 1 or b1 < b2 & b2 = b1 + 1);

:: GOBOARD1:th 2
theorem
for b1, b2, b3, b4 being Element of NAT holds
   (abs (b1 - b2)) + abs (b3 - b4) = 1
iff
   (abs (b1 - b2) = 1 & b3 = b4 or abs (b3 - b4) = 1 & b1 = b2);

:: GOBOARD1:th 3
theorem
for b1 being Element of NAT holds
      1 < b1
   iff
      ex b2 being Element of NAT st
         b1 = b2 + 1 & 0 < b2;

:: GOBOARD1:th 7
theorem
for b1 being Relation-like Function-like FinSequence-like set
for b2, b3, b4 being Element of NAT
      st len b1 = b3 + 1 & b2 in dom b1 & b4 in Seg b3 & (Del(b1,b2)) . b4 <> b1 . b4
   holds (Del(b1,b2)) . b4 = b1 . (b4 + 1);

:: GOBOARD1:attrnot 1 => GOBOARD1:attr 1
definition
  let a1 be Relation-like Function-like real-valued set;
  attr a1 is increasing means
    for b1, b2 being Element of NAT
          st b1 in proj1 a1 & b2 in proj1 a1 & b1 < b2
       holds a1 . b1 < a1 . b2;
end;

:: GOBOARD1:dfs 1
definiens
  let a1 be Relation-like Function-like real-valued set;
To prove
     a1 is increasing
it is sufficient to prove
  thus for b1, b2 being Element of NAT
          st b1 in proj1 a1 & b2 in proj1 a1 & b1 < b2
       holds a1 . b1 < a1 . b2;

:: GOBOARD1:def 1
theorem
for b1 being Relation-like Function-like real-valued set holds
      b1 is increasing
   iff
      for b2, b3 being Element of NAT
            st b2 in proj1 b1 & b3 in proj1 b1 & b2 < b3
         holds b1 . b2 < b1 . b3;

:: GOBOARD1:attrnot 2 => FUNCT_1:attr 3
definition
  let a1 be Relation-like Function-like set;
  attr a1 is constant means
    for b1, b2 being Element of NAT
          st b1 in dom a1 & b2 in dom a1
       holds a1 . b1 = a1 . b2;
end;

:: GOBOARD1:dfs 2
definiens
  let a1 be Relation-like Function-like FinSequence-like set;
To prove
     a1 is constant
it is sufficient to prove
  thus for b1, b2 being Element of NAT
          st b1 in dom a1 & b2 in dom a1
       holds a1 . b1 = a1 . b2;

:: GOBOARD1:def 2
theorem
for b1 being Relation-like Function-like FinSequence-like set holds
      b1 is constant
   iff
      for b2, b3 being Element of NAT
            st b2 in dom b1 & b3 in dom b1
         holds b1 . b2 = b1 . b3;

:: GOBOARD1:exreg 1
registration
  cluster Relation-like Function-like non empty finite FinSequence-like complex-valued ext-real-valued real-valued increasing FinSequence of REAL;
end;

:: GOBOARD1:exreg 2
registration
  cluster Relation-like Function-like constant finite FinSequence-like complex-valued ext-real-valued real-valued FinSequence of REAL;
end;

:: GOBOARD1:funcnot 1 => GOBOARD1:func 1
definition
  let a1 be FinSequence of the carrier of TOP-REAL 2;
  func X_axis A1 -> FinSequence of REAL means
    len it = len a1 &
     (for b1 being Element of NAT
           st b1 in dom it
        holds it . b1 = (a1 /. b1) `1);
end;

:: GOBOARD1:def 3
theorem
for b1 being FinSequence of the carrier of TOP-REAL 2
for b2 being FinSequence of REAL holds
      b2 = X_axis b1
   iff
      len b2 = len b1 &
       (for b3 being Element of NAT
             st b3 in dom b2
          holds b2 . b3 = (b1 /. b3) `1);

:: GOBOARD1:funcnot 2 => GOBOARD1:func 2
definition
  let a1 be FinSequence of the carrier of TOP-REAL 2;
  func Y_axis A1 -> FinSequence of REAL means
    len it = len a1 &
     (for b1 being Element of NAT
           st b1 in dom it
        holds it . b1 = (a1 /. b1) `2);
end;

:: GOBOARD1:def 4
theorem
for b1 being FinSequence of the carrier of TOP-REAL 2
for b2 being FinSequence of REAL holds
      b2 = Y_axis b1
   iff
      len b2 = len b1 &
       (for b3 being Element of NAT
             st b3 in dom b2
          holds b2 . b3 = (b1 /. b3) `2);

:: GOBOARD1:th 14
theorem
for b1 being FinSequence of REAL
for b2, b3, b4 being Element of NAT
      st b1 <> {} &
         proj2 b1 c= Seg b2 &
         b1 . len b1 = b2 &
         (for b5 being Element of NAT
            st 1 <= b5 & b5 <= (len b1) - 1
         for b6, b7 being Element of REAL
               st b6 = b1 . b5 & b7 = b1 . (b5 + 1) & abs (b6 - b7) <> 1
            holds b6 = b7) &
         b3 in Seg b2 &
         b3 + 1 in Seg b2 &
         b4 in dom b1 &
         b1 . b4 = b3 &
         (for b5 being Element of NAT
               st b5 in dom b1 & b1 . b5 = b3
            holds b5 <= b4)
   holds b4 + 1 in dom b1 & b1 . (b4 + 1) = b3 + 1;

:: GOBOARD1:th 15
theorem
for b1 being FinSequence of REAL
for b2 being Element of NAT
      st b1 <> {} &
         proj2 b1 c= Seg b2 &
         b1 . 1 = 1 &
         b1 . len b1 = b2 &
         (for b3 being Element of NAT
            st 1 <= b3 & b3 <= (len b1) - 1
         for b4, b5 being Element of REAL
               st b4 = b1 . b3 & b5 = b1 . (b3 + 1) & abs (b4 - b5) <> 1
            holds b4 = b5)
   holds (for b3 being Element of NAT
          st b3 in Seg b2
       holds ex b4 being Element of NAT st
          b4 in dom b1 & b1 . b4 = b3) &
    (for b3, b4, b5 being Element of NAT
    for b6 being Element of REAL
          st b3 in dom b1 &
             b1 . b3 = b5 &
             (for b7 being Element of NAT
                   st b7 in dom b1 & b1 . b7 = b5
                holds b7 <= b3) &
             b3 < b4 &
             b4 in dom b1 &
             b6 = b1 . b4
       holds b5 < b6);

:: GOBOARD1:th 16
theorem
for b1 being FinSequence of the carrier of TOP-REAL 2
for b2 being Element of NAT
      st b2 in dom b1 & 2 <= len b1
   holds b1 /. b2 in L~ b1;

:: GOBOARD1:th 17
theorem
for b1 being non empty set
for b2 being tabular FinSequence of b1 *
for b3, b4 being Element of NAT
      st b4 in dom b2 & b3 in Seg width b2
   holds (Col(b2,b3)) . b4 = (Line(b2,b4)) . b3;

:: GOBOARD1:attrnot 3 => GOBOARD1:attr 2
definition
  let a1 be non empty set;
  let a2 be tabular FinSequence of a1 *;
  redefine attr a2 is empty-yielding means
    (0 <> len a2) implies 0 = width a2;
end;

:: GOBOARD1:dfs 5
definiens
  let a1 be non empty set;
  let a2 be tabular FinSequence of a1 *;
To prove
     a1 is empty-yielding
it is sufficient to prove
  thus (0 <> len a2) implies 0 = width a2;

:: GOBOARD1:def 5
theorem
for b1 being non empty set
for b2 being tabular FinSequence of b1 * holds
      b2 is empty-yielding
   iff
      (0 = len b2 or 0 = width b2);

:: GOBOARD1:attrnot 4 => GOBOARD1:attr 3
definition
  let a1 be tabular FinSequence of (the carrier of TOP-REAL 2) *;
  attr a1 is X_equal-in-line means
    for b1 being Element of NAT
          st b1 in dom a1
       holds X_axis Line(a1,b1) is constant;
end;

:: GOBOARD1:dfs 6
definiens
  let a1 be tabular FinSequence of (the carrier of TOP-REAL 2) *;
To prove
     a1 is X_equal-in-line
it is sufficient to prove
  thus for b1 being Element of NAT
          st b1 in dom a1
       holds X_axis Line(a1,b1) is constant;

:: GOBOARD1:def 6
theorem
for b1 being tabular FinSequence of (the carrier of TOP-REAL 2) * holds
      b1 is X_equal-in-line
   iff
      for b2 being Element of NAT
            st b2 in dom b1
         holds X_axis Line(b1,b2) is constant;

:: GOBOARD1:attrnot 5 => GOBOARD1:attr 4
definition
  let a1 be tabular FinSequence of (the carrier of TOP-REAL 2) *;
  attr a1 is Y_equal-in-column means
    for b1 being Element of NAT
          st b1 in Seg width a1
       holds Y_axis Col(a1,b1) is constant;
end;

:: GOBOARD1:dfs 7
definiens
  let a1 be tabular FinSequence of (the carrier of TOP-REAL 2) *;
To prove
     a1 is Y_equal-in-column
it is sufficient to prove
  thus for b1 being Element of NAT
          st b1 in Seg width a1
       holds Y_axis Col(a1,b1) is constant;

:: GOBOARD1:def 7
theorem
for b1 being tabular FinSequence of (the carrier of TOP-REAL 2) * holds
      b1 is Y_equal-in-column
   iff
      for b2 being Element of NAT
            st b2 in Seg width b1
         holds Y_axis Col(b1,b2) is constant;

:: GOBOARD1:attrnot 6 => GOBOARD1:attr 5
definition
  let a1 be tabular FinSequence of (the carrier of TOP-REAL 2) *;
  attr a1 is Y_increasing-in-line means
    for b1 being Element of NAT
          st b1 in dom a1
       holds Y_axis Line(a1,b1) is increasing;
end;

:: GOBOARD1:dfs 8
definiens
  let a1 be tabular FinSequence of (the carrier of TOP-REAL 2) *;
To prove
     a1 is Y_increasing-in-line
it is sufficient to prove
  thus for b1 being Element of NAT
          st b1 in dom a1
       holds Y_axis Line(a1,b1) is increasing;

:: GOBOARD1:def 8
theorem
for b1 being tabular FinSequence of (the carrier of TOP-REAL 2) * holds
      b1 is Y_increasing-in-line
   iff
      for b2 being Element of NAT
            st b2 in dom b1
         holds Y_axis Line(b1,b2) is increasing;

:: GOBOARD1:attrnot 7 => GOBOARD1:attr 6
definition
  let a1 be tabular FinSequence of (the carrier of TOP-REAL 2) *;
  attr a1 is X_increasing-in-column means
    for b1 being Element of NAT
          st b1 in Seg width a1
       holds X_axis Col(a1,b1) is increasing;
end;

:: GOBOARD1:dfs 9
definiens
  let a1 be tabular FinSequence of (the carrier of TOP-REAL 2) *;
To prove
     a1 is X_increasing-in-column
it is sufficient to prove
  thus for b1 being Element of NAT
          st b1 in Seg width a1
       holds X_axis Col(a1,b1) is increasing;

:: GOBOARD1:def 9
theorem
for b1 being tabular FinSequence of (the carrier of TOP-REAL 2) * holds
      b1 is X_increasing-in-column
   iff
      for b2 being Element of NAT
            st b2 in Seg width b1
         holds X_axis Col(b1,b2) is increasing;

:: GOBOARD1:exreg 3
registration
  cluster Relation-like non empty-yielding Function-like finite FinSequence-like 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) *;
end;

:: GOBOARD1:th 19
theorem
for b1 being tabular X_equal-in-line X_increasing-in-column FinSequence of (the carrier of TOP-REAL 2) *
for b2 being set
for b3, b4 being Element of NAT
      st b2 in proj2 Line(b1,b3) & b2 in proj2 Line(b1,b4) & b3 in dom b1 & b4 in dom b1
   holds b3 = b4;

:: GOBOARD1:th 20
theorem
for b1 being tabular Y_equal-in-column Y_increasing-in-line FinSequence of (the carrier of TOP-REAL 2) *
for b2 being set
for b3, b4 being Element of NAT
      st b2 in proj2 Col(b1,b3) & b2 in proj2 Col(b1,b4) & b3 in Seg width b1 & b4 in Seg width b1
   holds b3 = b4;

:: GOBOARD1:modenot 1
definition
  mode Go-board is 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) *;
end;

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

:: GOBOARD1:th 22
theorem
for b1 being FinSequence of the carrier of TOP-REAL 2
for 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 b2 in dom b1 & b1 /. 1 in proj2 Col(b3,1)
   holds (b1 | b2) /. 1 in proj2 Col(b3,1);

:: GOBOARD1:th 23
theorem
for b1 being FinSequence of the carrier of TOP-REAL 2
for 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 b2 in dom b1 & b1 /. b2 in proj2 Col(b3,width b3)
   holds (b1 | b2) /. len (b1 | b2) in proj2 Col(b3,width b3);

:: GOBOARD1:th 24
theorem
for b1 being FinSequence of the carrier of TOP-REAL 2
for b2, b3, b4, b5 being Element of NAT
for 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 proj2 b1 misses proj2 Col(b6,b2) & b1 /. b3 = b6 *(b4,b5) & b3 in dom b1 & b4 in dom b6
   holds b2 <> b5;

:: GOBOARD1:funcnot 3 => GOBOARD1:func 3
definition
  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) *;
  let a2 be Element of NAT;
  assume a2 in Seg width a1 & 1 < width a1;
  func DelCol(A1,A2) -> 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) * means
    len it = len a1 &
     (for b1 being Element of NAT
           st b1 in dom a1
        holds it . b1 = Del(Line(a1,b1),a2));
end;

:: GOBOARD1:def 10
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 NAT
   st b2 in Seg width b1 & 1 < width b1
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) * holds
      b3 = DelCol(b1,b2)
   iff
      len b3 = len b1 &
       (for b4 being Element of NAT
             st b4 in dom b1
          holds b3 . b4 = Del(Line(b1,b4),b2));

:: GOBOARD1:th 25
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 b1 in Seg width b3 & 1 < width b3 & b2 in dom b3
   holds Line(DelCol(b3,b1),b2) = Del(Line(b3,b2),b1);

:: GOBOARD1:th 26
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 b1 in Seg width b3 & width b3 = b2 + 1 & 0 < b2
   holds width DelCol(b3,b1) = b2;

:: GOBOARD1:th 27
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 b1 in Seg width b2 & 1 < width b2
   holds width b2 = (width DelCol(b2,b1)) + 1;

:: GOBOARD1:th 28
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 in Seg width b4 & 1 < width b4 & b2 in dom b4 & b3 in Seg width DelCol(b4,b1)
   holds (DelCol(b4,b1)) *(b2,b3) = (Del(Line(b4,b2),b1)) . b3;

:: GOBOARD1:th 29
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 in Seg width b4 & width b4 = b2 + 1 & 0 < b2 & 1 <= b3 & b3 < b1
   holds Col(DelCol(b4,b1),b3) = Col(b4,b3) & b3 in Seg width DelCol(b4,b1) & b3 in Seg width b4;

:: GOBOARD1:th 30
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 in Seg width b4 & width b4 = b2 + 1 & 0 < b2 & b1 <= b3 & b3 <= b2
   holds Col(DelCol(b4,b1),b3) = Col(b4,b3 + 1) &
    b3 in Seg width DelCol(b4,b1) &
    b3 + 1 in Seg width b4;

:: GOBOARD1:th 31
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 in Seg width b5 & width b5 = b2 + 1 & 0 < b2 & b3 in dom b5 & 1 <= b4 & b4 < b1
   holds (DelCol(b5,b1)) *(b3,b4) = b5 *(b3,b4) & b4 in Seg width b5;

:: GOBOARD1: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 in Seg width b5 & width b5 = b2 + 1 & 0 < b2 & b3 in dom b5 & b1 <= b4 & b4 <= b2
   holds (DelCol(b5,b1)) *(b3,b4) = b5 *(b3,b4 + 1) &
    b4 + 1 in Seg width b5;

:: GOBOARD1:th 33
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 width b3 = b1 + 1 & 0 < b1 & b2 in Seg b1
   holds Col(DelCol(b3,1),b2) = Col(b3,b2 + 1) &
    b2 in Seg width DelCol(b3,1) &
    b2 + 1 in Seg width b3;

:: GOBOARD1:th 34
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 width b4 = b1 + 1 & 0 < b1 & b2 in Seg b1 & b3 in dom b4
   holds (DelCol(b4,1)) *(b3,b2) = b4 *(b3,b2 + 1) &
    1 in Seg width b4;

:: GOBOARD1:th 35
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 width b3 = b1 + 1 & 0 < b1 & b2 in Seg b1
   holds Col(DelCol(b3,width b3),b2) = Col(b3,b2) &
    b2 in Seg width DelCol(b3,width b3);

:: GOBOARD1:th 36
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 width b4 = b1 + 1 & 0 < b1 & b2 in Seg b1 & b3 in dom b4
   holds b2 in Seg width b4 &
    (DelCol(b4,width b4)) *(b3,b2) = b4 *(b3,b2) &
    width b4 in Seg width b4;

:: GOBOARD1:th 37
theorem
for b1 being FinSequence of the carrier of TOP-REAL 2
for 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 proj2 b1 misses proj2 Col(b5,b2) & b1 /. b3 in proj2 Line(b5,b4) & b3 in dom b1 & b2 in Seg width b5 & b4 in dom b5 & 1 < width b5
   holds b1 /. b3 in proj2 Line(DelCol(b5,b2),b4);

:: GOBOARD1:prednot 1 => GOBOARD1:pred 1
definition
  let a1 be set;
  let a2 be FinSequence of a1;
  let a3 be tabular FinSequence of a1 *;
  pred A2 is_sequence_on A3 means
    (for b1 being Element of NAT
           st b1 in dom a2
        holds ex b2, b3 being Element of NAT st
           [b2,b3] in Indices a3 & a2 /. b1 = a3 *(b2,b3)) &
     (for b1 being Element of NAT
        st b1 in dom a2 & b1 + 1 in dom a2
     for b2, b3, b4, b5 being Element of NAT
           st [b2,b3] in Indices a3 & [b4,b5] in Indices a3 & a2 /. b1 = a3 *(b2,b3) & a2 /. (b1 + 1) = a3 *(b4,b5)
        holds (abs (b2 - b4)) + abs (b3 - b5) = 1);
end;

:: GOBOARD1:dfs 11
definiens
  let a1 be set;
  let a2 be FinSequence of a1;
  let a3 be tabular FinSequence of a1 *;
To prove
     a2 is_sequence_on a3
it is sufficient to prove
  thus (for b1 being Element of NAT
           st b1 in dom a2
        holds ex b2, b3 being Element of NAT st
           [b2,b3] in Indices a3 & a2 /. b1 = a3 *(b2,b3)) &
     (for b1 being Element of NAT
        st b1 in dom a2 & b1 + 1 in dom a2
     for b2, b3, b4, b5 being Element of NAT
           st [b2,b3] in Indices a3 & [b4,b5] in Indices a3 & a2 /. b1 = a3 *(b2,b3) & a2 /. (b1 + 1) = a3 *(b4,b5)
        holds (abs (b2 - b4)) + abs (b3 - b5) = 1);

:: GOBOARD1:def 11
theorem
for b1 being set
for b2 being FinSequence of b1
for b3 being tabular FinSequence of b1 * holds
      b2 is_sequence_on b3
   iff
      (for b4 being Element of NAT
             st b4 in dom b2
          holds ex b5, b6 being Element of NAT st
             [b5,b6] in Indices b3 & b2 /. b4 = b3 *(b5,b6)) &
       (for b4 being Element of NAT
          st b4 in dom b2 & b4 + 1 in dom b2
       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)
          holds (abs (b5 - b7)) + abs (b6 - b8) = 1);

:: GOBOARD1:th 38
theorem
for b1 being Element of NAT
for b2 being set
for b3 being FinSequence of b2
for b4 being tabular FinSequence of b2 * holds
   (b1 in dom b3 implies 1 <= len (b3 | b1)) &
    (b3 is_sequence_on b4 implies b3 | b1 is_sequence_on b4);

:: GOBOARD1:th 39
theorem
for b1, b2 being FinSequence of the carrier of TOP-REAL 2
for b3 being set
for b4 being tabular FinSequence of b3 *
   st (for b5 being Element of NAT
            st b5 in dom b1
         holds ex b6, b7 being Element of NAT st
            [b6,b7] in Indices b4 & b1 /. b5 = b4 *(b6,b7)) &
      (for b5 being Element of NAT
            st b5 in dom b2
         holds ex b6, b7 being Element of NAT st
            [b6,b7] in Indices b4 & b2 /. b5 = b4 *(b6,b7))
for b5 being Element of NAT
      st b5 in dom (b1 ^ b2)
   holds ex b6, b7 being Element of NAT st
      [b6,b7] in Indices b4 & (b1 ^ b2) /. b5 = b4 *(b6,b7);

:: GOBOARD1:th 40
theorem
for b1, b2 being FinSequence of the carrier of TOP-REAL 2
for b3 being set
for b4 being tabular FinSequence of b3 *
   st (for b5 being Element of NAT
         st b5 in dom b1 & b5 + 1 in dom b1
      for b6, b7, b8, b9 being Element of NAT
            st [b6,b7] in Indices b4 & [b8,b9] in Indices b4 & b1 /. b5 = b4 *(b6,b7) & b1 /. (b5 + 1) = b4 *(b8,b9)
         holds (abs (b6 - b8)) + abs (b7 - b9) = 1) &
      (for b5 being Element of NAT
         st b5 in dom b2 & b5 + 1 in dom b2
      for b6, b7, b8, b9 being Element of NAT
            st [b6,b7] in Indices b4 & [b8,b9] in Indices b4 & b2 /. b5 = b4 *(b6,b7) & b2 /. (b5 + 1) = b4 *(b8,b9)
         holds (abs (b6 - b8)) + abs (b7 - b9) = 1) &
      (for b5, b6, b7, b8 being Element of NAT
            st [b5,b6] in Indices b4 & [b7,b8] in Indices b4 & b1 /. len b1 = b4 *(b5,b6) & b2 /. 1 = b4 *(b7,b8) & len b1 in dom b1 & 1 in dom b2
         holds (abs (b5 - b7)) + abs (b6 - b8) = 1)
for b5 being Element of NAT
   st b5 in dom (b1 ^ b2) & b5 + 1 in dom (b1 ^ b2)
for b6, b7, b8, b9 being Element of NAT
      st [b6,b7] in Indices b4 &
         [b8,b9] in Indices b4 &
         (b1 ^ b2) /. b5 = b4 *(b6,b7) &
         (b1 ^ b2) /. (b5 + 1) = b4 *(b8,b9)
   holds (abs (b6 - b8)) + abs (b7 - b9) = 1;

:: GOBOARD1:th 41
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 & b1 in Seg width b2 & proj2 b3 misses proj2 Col(b2,b1) & 1 < width b2
   holds b3 is_sequence_on DelCol(b2,b1);

:: GOBOARD1:th 42
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 & b1 in dom b3
   holds ex b4 being Element of NAT st
      b4 in dom b2 & b3 /. b1 in proj2 Line(b2,b4);

:: GOBOARD1:th 43
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 &
      b1 in dom b4 &
      b1 + 1 in dom b4 &
      b2 in dom b3 &
      b4 /. b1 in proj2 Line(b3,b2) &
      not b4 /. (b1 + 1) in proj2 Line(b3,b2)
for b5 being Element of NAT
      st b4 /. (b1 + 1) in proj2 Line(b3,b5) &
         b5 in dom b3
   holds abs (b2 - b5) = 1;

:: GOBOARD1:th 44
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 1 <= len b4 &
         b4 /. len b4 in proj2 Line(b3,len b3) &
         b4 is_sequence_on b3 &
         b1 in dom b3 &
         b1 + 1 in dom b3 &
         b2 in dom b4 &
         b4 /. b2 in proj2 Line(b3,b1) &
         (for b5 being Element of NAT
               st b5 in dom b4 & b4 /. b5 in proj2 Line(b3,b1)
            holds b5 <= b2)
   holds b2 + 1 in dom b4 &
    b4 /. (b2 + 1) in proj2 Line(b3,b1 + 1);

:: GOBOARD1:th 45
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 1 <= len b2 &
         b2 /. 1 in proj2 Line(b1,1) &
         b2 /. len b2 in proj2 Line(b1,len b1) &
         b2 is_sequence_on b1
   holds (for b3 being Element of NAT
          st 1 <= b3 & b3 <= len b1
       holds ex b4 being Element of NAT st
          b4 in dom b2 & b2 /. b4 in proj2 Line(b1,b3)) &
    (for b3 being Element of NAT
          st 1 <= b3 & b3 <= len b1 & 2 <= len b2
       holds L~ b2 meets proj2 Line(b1,b3)) &
    (for b3, b4, b5, b6 being Element of NAT
          st 1 <= b3 &
             b3 <= len b1 &
             1 <= b4 &
             b4 <= len b1 &
             b5 in dom b2 &
             b6 in dom b2 &
             b2 /. b5 in proj2 Line(b1,b3) &
             (for b7 being Element of NAT
                   st b7 in dom b2 & b2 /. b7 in proj2 Line(b1,b3)
                holds b7 <= b5) &
             b5 < b6 &
             b2 /. b6 in proj2 Line(b1,b4)
       holds b3 < b4);

:: GOBOARD1:th 46
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 & b1 in dom b3
   holds ex b4 being Element of NAT st
      b4 in Seg width b2 & b3 /. b1 in proj2 Col(b2,b4);

:: GOBOARD1:th 47
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 &
      b1 in dom b4 &
      b1 + 1 in dom b4 &
      b2 in Seg width b3 &
      b4 /. b1 in proj2 Col(b3,b2) &
      not b4 /. (b1 + 1) in proj2 Col(b3,b2)
for b5 being Element of NAT
      st b4 /. (b1 + 1) in proj2 Col(b3,b5) &
         b5 in Seg width b3
   holds abs (b2 - b5) = 1;

:: GOBOARD1:th 48
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 1 <= len b4 &
         b4 /. len b4 in proj2 Col(b3,width b3) &
         b4 is_sequence_on b3 &
         b1 in Seg width b3 &
         b1 + 1 in Seg width b3 &
         b2 in dom b4 &
         b4 /. b2 in proj2 Col(b3,b1) &
         (for b5 being Element of NAT
               st b5 in dom b4 & b4 /. b5 in proj2 Col(b3,b1)
            holds b5 <= b2)
   holds b2 + 1 in dom b4 &
    b4 /. (b2 + 1) in proj2 Col(b3,b1 + 1);

:: GOBOARD1:th 49
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 1 <= len b2 &
         b2 /. 1 in proj2 Col(b1,1) &
         b2 /. len b2 in proj2 Col(b1,width b1) &
         b2 is_sequence_on b1
   holds (for b3 being Element of NAT
          st 1 <= b3 & b3 <= width b1
       holds ex b4 being Element of NAT st
          b4 in dom b2 & b2 /. b4 in proj2 Col(b1,b3)) &
    (for b3 being Element of NAT
          st 1 <= b3 & b3 <= width b1 & 2 <= len b2
       holds L~ b2 meets proj2 Col(b1,b3)) &
    (for b3, b4, b5, b6 being Element of NAT
          st 1 <= b3 &
             b3 <= width b1 &
             1 <= b4 &
             b4 <= width b1 &
             b5 in dom b2 &
             b6 in dom b2 &
             b2 /. b5 in proj2 Col(b1,b3) &
             (for b7 being Element of NAT
                   st b7 in dom b2 & b2 /. b7 in proj2 Col(b1,b3)
                holds b7 <= b5) &
             b5 < b6 &
             b2 /. b6 in proj2 Col(b1,b4)
       holds b3 < b4);

:: GOBOARD1:th 50
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 b1 in dom b4 &
      b4 /. b1 in proj2 Col(b3,b2) &
      b2 in Seg width b3 &
      b4 /. 1 in proj2 Col(b3,1) &
      b4 is_sequence_on b3 &
      (for b5 being Element of NAT
            st b5 in dom b4 & b4 /. b5 in proj2 Col(b3,b2)
         holds b1 <= b5)
for b5 being Element of NAT
   st b5 in dom b4 & b5 <= b1
for b6 being Element of NAT
      st b6 in Seg width b3 & b4 /. b5 in proj2 Col(b3,b6)
   holds b6 <= b2;

:: GOBOARD1:th 51
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 &
         b2 /. 1 in proj2 Col(b1,1) &
         b2 /. len b2 in proj2 Col(b1,width b1) &
         1 < width b1 &
         1 <= len b2
   holds ex b3 being FinSequence of the carrier of TOP-REAL 2 st
      b3 /. 1 in proj2 Col(DelCol(b1,width b1),1) &
       b3 /. len b3 in proj2 Col(DelCol(b1,width b1),width DelCol(b1,width b1)) &
       1 <= len b3 &
       b3 is_sequence_on DelCol(b1,width b1) &
       proj2 b3 c= proj2 b2;

:: GOBOARD1:th 52
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 &
         (proj2 b2) /\ proj2 Col(b1,1) <> {} &
         (proj2 b2) /\ proj2 Col(b1,width b1) <> {}
   holds ex b3 being FinSequence of the carrier of TOP-REAL 2 st
      proj2 b3 c= proj2 b2 &
       b3 /. 1 in proj2 Col(b1,1) &
       b3 /. len b3 in proj2 Col(b1,width b1) &
       1 <= len b3 &
       b3 is_sequence_on b1;

:: GOBOARD1:th 53
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 b1 in dom b3 &
         b4 is_sequence_on b3 &
         b4 /. len b4 in proj2 Line(b3,len b3) &
         b2 in dom b4 &
         b4 /. b2 in proj2 Line(b3,b1)
   holds (for b5 being Element of NAT
          st b1 <= b5 & b5 <= len b3
       holds ex b6 being Element of NAT st
          b6 in dom b4 & b2 <= b6 & b4 /. b6 in proj2 Line(b3,b5)) &
    (for b5 being Element of NAT
          st b1 < b5 & b5 <= len b3
       holds ex b6 being Element of NAT st
          b6 in dom b4 & b2 < b6 & b4 /. b6 in proj2 Line(b3,b5));