Article GOBOARD5, MML version 4.99.1005

:: GOBOARD5:th 1
theorem
for b1 being Relation-like Function-like FinSequence-like tabular set
for b2, b3 being Element of NAT
      st [b2,b3] in Indices b1
   holds 1 <= b2 & b2 <= len b1 & 1 <= b3 & b3 <= width b1;

:: GOBOARD5:funcnot 1 => GOBOARD5:func 1
definition
  let a1 be tabular FinSequence of (the carrier of TOP-REAL 2) *;
  let a2 be natural set;
  func v_strip(A1,A2) -> Element of bool the carrier of TOP-REAL 2 equals
    {|[b1,b2]| where b1 is Element of REAL, b2 is Element of REAL: (a1 *(a2,1)) `1 <= b1 & b1 <= (a1 *(a2 + 1,1)) `1}
    if 1 <= a2 & a2 < len a1,
{|[b1,b2]| where b1 is Element of REAL, b2 is Element of REAL: (a1 *(a2,1)) `1 <= b1}
    if len a1 <= a2
    otherwise {|[b1,b2]| where b1 is Element of REAL, b2 is Element of REAL: b1 <= (a1 *(a2 + 1,1)) `1};
end;

:: GOBOARD5:def 1
theorem
for b1 being tabular FinSequence of (the carrier of TOP-REAL 2) *
for b2 being natural set holds
   (1 <= b2 & b2 < len b1 implies v_strip(b1,b2) = {|[b3,b4]| where b3 is Element of REAL, b4 is Element of REAL: (b1 *(b2,1)) `1 <= b3 & b3 <= (b1 *(b2 + 1,1)) `1}) &
    (len b1 <= b2 implies v_strip(b1,b2) = {|[b3,b4]| where b3 is Element of REAL, b4 is Element of REAL: (b1 *(b2,1)) `1 <= b3}) &
    ((1 <= b2 implies len b1 <= b2) & b2 < len b1 implies v_strip(b1,b2) = {|[b3,b4]| where b3 is Element of REAL, b4 is Element of REAL: b3 <= (b1 *(b2 + 1,1)) `1});

:: GOBOARD5:funcnot 2 => GOBOARD5:func 2
definition
  let a1 be tabular FinSequence of (the carrier of TOP-REAL 2) *;
  let a2 be natural set;
  func h_strip(A1,A2) -> Element of bool the carrier of TOP-REAL 2 equals
    {|[b1,b2]| where b1 is Element of REAL, b2 is Element of REAL: (a1 *(1,a2)) `2 <= b2 & b2 <= (a1 *(1,a2 + 1)) `2}
    if 1 <= a2 & a2 < width a1,
{|[b1,b2]| where b1 is Element of REAL, b2 is Element of REAL: (a1 *(1,a2)) `2 <= b2}
    if width a1 <= a2
    otherwise {|[b1,b2]| where b1 is Element of REAL, b2 is Element of REAL: b2 <= (a1 *(1,a2 + 1)) `2};
end;

:: GOBOARD5:def 2
theorem
for b1 being tabular FinSequence of (the carrier of TOP-REAL 2) *
for b2 being natural set holds
   (1 <= b2 & b2 < width b1 implies h_strip(b1,b2) = {|[b3,b4]| where b3 is Element of REAL, b4 is Element of REAL: (b1 *(1,b2)) `2 <= b4 & b4 <= (b1 *(1,b2 + 1)) `2}) &
    (width b1 <= b2 implies h_strip(b1,b2) = {|[b3,b4]| where b3 is Element of REAL, b4 is Element of REAL: (b1 *(1,b2)) `2 <= b4}) &
    ((1 <= b2 implies width b1 <= b2) & b2 < width b1 implies h_strip(b1,b2) = {|[b3,b4]| where b3 is Element of REAL, b4 is Element of REAL: b4 <= (b1 *(1,b2 + 1)) `2});

:: GOBOARD5:th 2
theorem
for b1, b2 being Element of NAT
for b3 being tabular FinSequence of (the carrier of TOP-REAL 2) *
      st b3 is Y_equal-in-column & 1 <= b1 & b1 <= width b3 & 1 <= b2 & b2 <= len b3
   holds (b3 *(b2,b1)) `2 = (b3 *(1,b1)) `2;

:: GOBOARD5:th 3
theorem
for b1, b2 being Element of NAT
for b3 being tabular FinSequence of (the carrier of TOP-REAL 2) *
      st b3 is X_equal-in-line & 1 <= b1 & b1 <= width b3 & 1 <= b2 & b2 <= len b3
   holds (b3 *(b2,b1)) `1 = (b3 *(b2,1)) `1;

:: GOBOARD5:th 4
theorem
for b1, b2, b3 being Element of NAT
for b4 being tabular FinSequence of (the carrier of TOP-REAL 2) *
      st b4 is X_increasing-in-column & 1 <= b1 & b1 <= width b4 & 1 <= b2 & b2 < b3 & b3 <= len b4
   holds (b4 *(b2,b1)) `1 < (b4 *(b3,b1)) `1;

:: GOBOARD5:th 5
theorem
for b1, b2, b3 being Element of NAT
for b4 being tabular FinSequence of (the carrier of TOP-REAL 2) *
      st b4 is Y_increasing-in-line & 1 <= b1 & b1 < b2 & b2 <= width b4 & 1 <= b3 & b3 <= len b4
   holds (b4 *(b3,b1)) `2 < (b4 *(b3,b2)) `2;

:: GOBOARD5:th 6
theorem
for b1, b2 being Element of NAT
for b3 being tabular FinSequence of (the carrier of TOP-REAL 2) *
      st b3 is Y_equal-in-column & 1 <= b1 & b1 < width b3 & 1 <= b2 & b2 <= len b3
   holds h_strip(b3,b1) = {|[b4,b5]| where b4 is Element of REAL, b5 is Element of REAL: (b3 *(b2,b1)) `2 <= b5 & b5 <= (b3 *(b2,b1 + 1)) `2};

:: GOBOARD5:th 7
theorem
for b1 being Element of NAT
for b2 being tabular FinSequence of (the carrier of TOP-REAL 2) *
      st b2 is not empty-yielding & b2 is Y_equal-in-column & 1 <= b1 & b1 <= len b2
   holds h_strip(b2,width b2) = {|[b3,b4]| where b3 is Element of REAL, b4 is Element of REAL: (b2 *(b1,width b2)) `2 <= b4};

:: GOBOARD5:th 8
theorem
for b1 being Element of NAT
for b2 being tabular FinSequence of (the carrier of TOP-REAL 2) *
      st b2 is not empty-yielding & b2 is Y_equal-in-column & 1 <= b1 & b1 <= len b2
   holds h_strip(b2,0) = {|[b3,b4]| where b3 is Element of REAL, b4 is Element of REAL: b4 <= (b2 *(b1,1)) `2};

:: GOBOARD5:th 9
theorem
for b1, b2 being Element of NAT
for b3 being tabular FinSequence of (the carrier of TOP-REAL 2) *
      st b3 is X_equal-in-line & 1 <= b1 & b1 < len b3 & 1 <= b2 & b2 <= width b3
   holds v_strip(b3,b1) = {|[b4,b5]| where b4 is Element of REAL, b5 is Element of REAL: (b3 *(b1,b2)) `1 <= b4 & b4 <= (b3 *(b1 + 1,b2)) `1};

:: GOBOARD5:th 10
theorem
for b1 being Element of NAT
for b2 being tabular FinSequence of (the carrier of TOP-REAL 2) *
      st b2 is not empty-yielding & b2 is X_equal-in-line & 1 <= b1 & b1 <= width b2
   holds v_strip(b2,len b2) = {|[b3,b4]| where b3 is Element of REAL, b4 is Element of REAL: (b2 *(len b2,b1)) `1 <= b3};

:: GOBOARD5:th 11
theorem
for b1 being Element of NAT
for b2 being tabular FinSequence of (the carrier of TOP-REAL 2) *
      st b2 is not empty-yielding & b2 is X_equal-in-line & 1 <= b1 & b1 <= width b2
   holds v_strip(b2,0) = {|[b3,b4]| where b3 is Element of REAL, b4 is Element of REAL: b3 <= (b2 *(1,b1)) `1};

:: GOBOARD5:funcnot 3 => GOBOARD5:func 3
definition
  let a1 be tabular FinSequence of (the carrier of TOP-REAL 2) *;
  let a2, a3 be natural set;
  func cell(A1,A2,A3) -> Element of bool the carrier of TOP-REAL 2 equals
    (v_strip(a1,a2)) /\ h_strip(a1,a3);
end;

:: GOBOARD5:def 3
theorem
for b1 being tabular FinSequence of (the carrier of TOP-REAL 2) *
for b2, b3 being natural set holds
cell(b1,b2,b3) = (v_strip(b1,b2)) /\ h_strip(b1,b3);

:: GOBOARD5:attrnot 1 => GOBOARD5:attr 1
definition
  let a1 be FinSequence of the carrier of TOP-REAL 2;
  attr a1 is s.c.c. means
    for b1, b2 being Element of NAT
          st b1 + 1 < b2 &
             ((b1 <= 1 or len a1 <= b2) implies b2 + 1 < len a1)
       holds LSeg(a1,b1) misses LSeg(a1,b2);
end;

:: GOBOARD5:dfs 4
definiens
  let a1 be FinSequence of the carrier of TOP-REAL 2;
To prove
     a1 is s.c.c.
it is sufficient to prove
  thus for b1, b2 being Element of NAT
          st b1 + 1 < b2 &
             ((b1 <= 1 or len a1 <= b2) implies b2 + 1 < len a1)
       holds LSeg(a1,b1) misses LSeg(a1,b2);

:: GOBOARD5:def 4
theorem
for b1 being FinSequence of the carrier of TOP-REAL 2 holds
      b1 is s.c.c.
   iff
      for b2, b3 being Element of NAT
            st b2 + 1 < b3 &
               ((b2 <= 1 or len b1 <= b3) implies b3 + 1 < len b1)
         holds LSeg(b1,b2) misses LSeg(b1,b3);

:: GOBOARD5:attrnot 2 => GOBOARD5:attr 2
definition
  let a1 be non empty FinSequence of the carrier of TOP-REAL 2;
  attr a1 is standard means
    a1 is_sequence_on GoB a1;
end;

:: GOBOARD5:dfs 5
definiens
  let a1 be non empty FinSequence of the carrier of TOP-REAL 2;
To prove
     a1 is standard
it is sufficient to prove
  thus a1 is_sequence_on GoB a1;

:: GOBOARD5:def 5
theorem
for b1 being non empty FinSequence of the carrier of TOP-REAL 2 holds
      b1 is standard
   iff
      b1 is_sequence_on GoB b1;

:: GOBOARD5:exreg 1
registration
  cluster Relation-like Function-like non constant non empty finite FinSequence-like circular special unfolded s.c.c. standard FinSequence of the carrier of TOP-REAL 2;
end;

:: GOBOARD5:th 12
theorem
for b1 being non empty FinSequence of the carrier of TOP-REAL 2
for b2 being Element of NAT
      st b2 in dom b1
   holds ex b3, b4 being Element of NAT st
      [b3,b4] in Indices GoB b1 & b1 /. b2 = (GoB b1) *(b3,b4);

:: GOBOARD5:th 13
theorem
for b1 being non empty standard FinSequence of the carrier of TOP-REAL 2
for b2 being Element of NAT
   st b2 in dom b1 & b2 + 1 in dom b1
for b3, b4, b5, b6 being Element of NAT
      st [b3,b4] in Indices GoB b1 &
         [b5,b6] in Indices GoB b1 &
         b1 /. b2 = (GoB b1) *(b3,b4) &
         b1 /. (b2 + 1) = (GoB b1) *(b5,b6)
   holds (abs (b3 - b5)) + abs (b4 - b6) = 1;

:: GOBOARD5:modenot 1
definition
  mode special_circular_sequence is non empty circular special unfolded s.c.c. FinSequence of the carrier of TOP-REAL 2;
end;

:: GOBOARD5:funcnot 4 => GOBOARD5:func 4
definition
  let a1 be non empty circular special unfolded s.c.c. standard FinSequence of the carrier of TOP-REAL 2;
  let a2 be Element of NAT;
  assume 1 <= a2 & a2 + 1 <= len a1;
  func right_cell(A1,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 GoB a1 &
             [b3,b4] in Indices GoB a1 &
             a1 /. a2 = (GoB a1) *(b1,b2) &
             a1 /. (a2 + 1) = (GoB a1) *(b3,b4) &
             (b1 = b3 & b2 + 1 = b4 implies it <> cell(GoB a1,b1,b2)) &
             (b1 + 1 = b3 & b2 = b4 implies it <> cell(GoB a1,b1,b2 -' 1)) &
             (b1 = b3 + 1 & b2 = b4 implies it <> cell(GoB a1,b3,b4))
       holds b1 = b3 & b2 = b4 + 1 & it = cell(GoB a1,b1 -' 1,b4);
end;

:: GOBOARD5:def 6
theorem
for b1 being non empty circular special unfolded s.c.c. standard FinSequence of the carrier of TOP-REAL 2
for b2 being Element of NAT
   st 1 <= b2 & b2 + 1 <= len b1
for b3 being Element of bool the carrier of TOP-REAL 2 holds
      b3 = right_cell(b1,b2)
   iff
      for b4, b5, b6, b7 being Element of NAT
            st [b4,b5] in Indices GoB b1 &
               [b6,b7] in Indices GoB b1 &
               b1 /. b2 = (GoB b1) *(b4,b5) &
               b1 /. (b2 + 1) = (GoB b1) *(b6,b7) &
               (b4 = b6 & b5 + 1 = b7 implies b3 <> cell(GoB b1,b4,b5)) &
               (b4 + 1 = b6 & b5 = b7 implies b3 <> cell(GoB b1,b4,b5 -' 1)) &
               (b4 = b6 + 1 & b5 = b7 implies b3 <> cell(GoB b1,b6,b7))
         holds b4 = b6 & b5 = b7 + 1 & b3 = cell(GoB b1,b4 -' 1,b7);

:: GOBOARD5:funcnot 5 => GOBOARD5:func 5
definition
  let a1 be non empty circular special unfolded s.c.c. standard FinSequence of the carrier of TOP-REAL 2;
  let a2 be Element of NAT;
  assume 1 <= a2 & a2 + 1 <= len a1;
  func left_cell(A1,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 GoB a1 &
             [b3,b4] in Indices GoB a1 &
             a1 /. a2 = (GoB a1) *(b1,b2) &
             a1 /. (a2 + 1) = (GoB a1) *(b3,b4) &
             (b1 = b3 & b2 + 1 = b4 implies it <> cell(GoB a1,b1 -' 1,b2)) &
             (b1 + 1 = b3 & b2 = b4 implies it <> cell(GoB a1,b1,b2)) &
             (b1 = b3 + 1 & b2 = b4 implies it <> cell(GoB a1,b3,b4 -' 1))
       holds b1 = b3 & b2 = b4 + 1 & it = cell(GoB a1,b1,b4);
end;

:: GOBOARD5:def 7
theorem
for b1 being non empty circular special unfolded s.c.c. standard FinSequence of the carrier of TOP-REAL 2
for b2 being Element of NAT
   st 1 <= b2 & b2 + 1 <= len b1
for b3 being Element of bool the carrier of TOP-REAL 2 holds
      b3 = left_cell(b1,b2)
   iff
      for b4, b5, b6, b7 being Element of NAT
            st [b4,b5] in Indices GoB b1 &
               [b6,b7] in Indices GoB b1 &
               b1 /. b2 = (GoB b1) *(b4,b5) &
               b1 /. (b2 + 1) = (GoB b1) *(b6,b7) &
               (b4 = b6 & b5 + 1 = b7 implies b3 <> cell(GoB b1,b4 -' 1,b5)) &
               (b4 + 1 = b6 & b5 = b7 implies b3 <> cell(GoB b1,b4,b5)) &
               (b4 = b6 + 1 & b5 = b7 implies b3 <> cell(GoB b1,b6,b7 -' 1))
         holds b4 = b6 & b5 = b7 + 1 & b3 = cell(GoB b1,b4,b7);

:: GOBOARD5:th 14
theorem
for b1, b2 being Element of NAT
for b3 being tabular FinSequence of (the carrier of TOP-REAL 2) *
      st b3 is not empty-yielding & b3 is X_equal-in-line & b3 is X_increasing-in-column & b1 < len b3 & 1 <= b2 & b2 < width b3
   holds LSeg(b3 *(b1 + 1,b2),b3 *(b1 + 1,b2 + 1)) c= v_strip(b3,b1);

:: GOBOARD5:th 15
theorem
for b1, b2 being Element of NAT
for b3 being tabular FinSequence of (the carrier of TOP-REAL 2) *
      st b3 is not empty-yielding & b3 is X_equal-in-line & b3 is X_increasing-in-column & 1 <= b1 & b1 <= len b3 & 1 <= b2 & b2 < width b3
   holds LSeg(b3 *(b1,b2),b3 *(b1,b2 + 1)) c= v_strip(b3,b1);

:: GOBOARD5:th 16
theorem
for b1, b2 being Element of NAT
for b3 being tabular FinSequence of (the carrier of TOP-REAL 2) *
      st b3 is not empty-yielding & b3 is Y_equal-in-column & b3 is Y_increasing-in-line & b1 < width b3 & 1 <= b2 & b2 < len b3
   holds LSeg(b3 *(b2,b1 + 1),b3 *(b2 + 1,b1 + 1)) c= h_strip(b3,b1);

:: GOBOARD5:th 17
theorem
for b1, b2 being Element of NAT
for b3 being tabular FinSequence of (the carrier of TOP-REAL 2) *
      st b3 is not empty-yielding & b3 is Y_equal-in-column & b3 is Y_increasing-in-line & 1 <= b1 & b1 <= width b3 & 1 <= b2 & b2 < len b3
   holds LSeg(b3 *(b2,b1),b3 *(b2 + 1,b1)) c= h_strip(b3,b1);

:: GOBOARD5:th 18
theorem
for b1, b2 being Element of NAT
for b3 being tabular FinSequence of (the carrier of TOP-REAL 2) *
      st b3 is Y_equal-in-column & b3 is Y_increasing-in-line & 1 <= b1 & b1 <= len b3 & 1 <= b2 & b2 + 1 <= width b3
   holds LSeg(b3 *(b1,b2),b3 *(b1,b2 + 1)) c= h_strip(b3,b2);

:: GOBOARD5:th 19
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 < len b3 & 1 <= b2 & b2 < width b3
   holds LSeg(b3 *(b1 + 1,b2),b3 *(b1 + 1,b2 + 1)) c= cell(b3,b1,b2);

:: GOBOARD5: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 <= len b3 & 1 <= b2 & b2 < width b3
   holds LSeg(b3 *(b1,b2),b3 *(b1,b2 + 1)) c= cell(b3,b1,b2);

:: GOBOARD5:th 21
theorem
for b1, b2 being Element of NAT
for b3 being tabular FinSequence of (the carrier of TOP-REAL 2) *
      st b3 is X_equal-in-line & b3 is X_increasing-in-column & 1 <= b1 & b1 <= width b3 & 1 <= b2 & b2 + 1 <= len b3
   holds LSeg(b3 *(b2,b1),b3 *(b2 + 1,b1)) c= v_strip(b3,b2);

:: GOBOARD5: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 b1 < width b3 & 1 <= b2 & b2 < len b3
   holds LSeg(b3 *(b2,b1 + 1),b3 *(b2 + 1,b1 + 1)) c= cell(b3,b2,b1);

:: GOBOARD5: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) *
      st 1 <= b1 & b1 < len b3 & 1 <= b2 & b2 <= width b3
   holds LSeg(b3 *(b1,b2),b3 *(b1 + 1,b2)) c= cell(b3,b1,b2);

:: GOBOARD5:th 24
theorem
for b1 being Element of NAT
for b2 being tabular FinSequence of (the carrier of TOP-REAL 2) *
      st b2 is not empty-yielding & b2 is X_equal-in-line & b2 is X_increasing-in-column & b1 + 1 <= len b2
   holds (v_strip(b2,b1)) /\ v_strip(b2,b1 + 1) = {b3 where b3 is Element of the carrier of TOP-REAL 2: b3 `1 = (b2 *(b1 + 1,1)) `1};

:: GOBOARD5:th 25
theorem
for b1 being Element of NAT
for b2 being tabular FinSequence of (the carrier of TOP-REAL 2) *
      st b2 is not empty-yielding & b2 is Y_equal-in-column & b2 is Y_increasing-in-line & b1 + 1 <= width b2
   holds (h_strip(b2,b1)) /\ h_strip(b2,b1 + 1) = {b3 where b3 is Element of the carrier of TOP-REAL 2: b3 `2 = (b2 *(1,b1 + 1)) `2};

:: GOBOARD5: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 < len b3 & 1 <= b2 & b2 < width b3
   holds (cell(b3,b1,b2)) /\ cell(b3,b1 + 1,b2) = LSeg(b3 *(b1 + 1,b2),b3 *(b1 + 1,b2 + 1));

:: GOBOARD5:th 27
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 < width b3 & 1 <= b2 & b2 < len b3
   holds (cell(b3,b2,b1)) /\ cell(b3,b2,b1 + 1) = LSeg(b3 *(b2,b1 + 1),b3 *(b2 + 1,b1 + 1));

:: GOBOARD5:th 28
theorem
for b1, b2, b3 being Element of NAT
for b4 being non empty circular special unfolded s.c.c. standard FinSequence of the carrier of TOP-REAL 2
      st 1 <= b1 &
         b1 + 1 <= len b4 &
         [b2 + 1,b3] in Indices GoB b4 &
         [b2 + 1,b3 + 1] in Indices GoB b4 &
         b4 /. b1 = (GoB b4) *(b2 + 1,b3) &
         b4 /. (b1 + 1) = (GoB b4) *(b2 + 1,b3 + 1)
   holds left_cell(b4,b1) = cell(GoB b4,b2,b3) &
    right_cell(b4,b1) = cell(GoB b4,b2 + 1,b3);

:: GOBOARD5:th 29
theorem
for b1, b2, b3 being Element of NAT
for b4 being non empty circular special unfolded s.c.c. standard FinSequence of the carrier of TOP-REAL 2
      st 1 <= b1 &
         b1 + 1 <= len b4 &
         [b2,b3 + 1] in Indices GoB b4 &
         [b2 + 1,b3 + 1] in Indices GoB b4 &
         b4 /. b1 = (GoB b4) *(b2,b3 + 1) &
         b4 /. (b1 + 1) = (GoB b4) *(b2 + 1,b3 + 1)
   holds left_cell(b4,b1) = cell(GoB b4,b2,b3 + 1) &
    right_cell(b4,b1) = cell(GoB b4,b2,b3);

:: GOBOARD5:th 30
theorem
for b1, b2, b3 being Element of NAT
for b4 being non empty circular special unfolded s.c.c. standard FinSequence of the carrier of TOP-REAL 2
      st 1 <= b1 &
         b1 + 1 <= len b4 &
         [b2,b3 + 1] in Indices GoB b4 &
         [b2 + 1,b3 + 1] in Indices GoB b4 &
         b4 /. b1 = (GoB b4) *(b2 + 1,b3 + 1) &
         b4 /. (b1 + 1) = (GoB b4) *(b2,b3 + 1)
   holds left_cell(b4,b1) = cell(GoB b4,b2,b3) &
    right_cell(b4,b1) = cell(GoB b4,b2,b3 + 1);

:: GOBOARD5:th 31
theorem
for b1, b2, b3 being Element of NAT
for b4 being non empty circular special unfolded s.c.c. standard FinSequence of the carrier of TOP-REAL 2
      st 1 <= b1 &
         b1 + 1 <= len b4 &
         [b2 + 1,b3 + 1] in Indices GoB b4 &
         [b2 + 1,b3] in Indices GoB b4 &
         b4 /. b1 = (GoB b4) *(b2 + 1,b3 + 1) &
         b4 /. (b1 + 1) = (GoB b4) *(b2 + 1,b3)
   holds left_cell(b4,b1) = cell(GoB b4,b2 + 1,b3) &
    right_cell(b4,b1) = cell(GoB b4,b2,b3);

:: GOBOARD5:th 32
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)) /\ right_cell(b2,b1) = LSeg(b2,b1);