Article GOBOARD6, MML version 4.99.1005

:: GOBOARD6:th 4
theorem
for b1 being non empty Reflexive MetrStruct
for b2 being Element of the carrier of b1
for b3 being real set
      st 0 < b3
   holds b2 in Ball(b2,b3);

:: GOBOARD6:th 5
theorem
for b1 being Element of NAT
for b2 being Element of the carrier of Euclid b1
for b3 being Element of the carrier of TOP-REAL b1
for b4 being real set
      st b2 = b3 & 0 < b4
   holds Ball(b2,b4) is a_neighborhood of b3;

:: GOBOARD6:th 6
theorem
for b1 being Element of NAT
for b2 being Element of REAL
for b3 being Element of bool the carrier of TOP-REAL b1
for b4 being Element of the carrier of Euclid b1
      st b3 = Ball(b4,b2)
   holds b3 is open(TOP-REAL b1);

:: GOBOARD6:th 7
theorem
for b1 being non empty Reflexive discerning symmetric triangle MetrStruct
for b2 being Element of the carrier of b1
for b3 being Element of bool the carrier of TopSpaceMetr b1 holds
      b2 in Int b3
   iff
      ex b4 being real set st
         0 < b4 & Ball(b2,b4) c= b3;

:: GOBOARD6:th 8
theorem
for b1 being Element of NAT
for b2 being Element of the carrier of Euclid b1
for b3 being Element of bool the carrier of TOP-REAL b1 holds
      b2 in Int b3
   iff
      ex b4 being real set st
         0 < b4 & Ball(b2,b4) c= b3;

:: GOBOARD6:th 9
theorem
for b1, b2, b3, b4 being Element of REAL
for b5, b6 being Element of the carrier of Euclid 2
      st b5 = |[b1,b2]| & b6 = |[b3,b4]|
   holds dist(b5,b6) = sqrt ((b1 - b3) ^2 + ((b2 - b4) ^2));

:: GOBOARD6:th 10
theorem
for b1, b2, b3, b4 being Element of REAL
for b5 being Element of the carrier of Euclid 2
      st b5 = |[b1,b2]| & 0 <= b3 & b3 < b4
   holds |[b1 + b3,b2]| in Ball(b5,b4);

:: GOBOARD6:th 11
theorem
for b1, b2, b3, b4 being Element of REAL
for b5 being Element of the carrier of Euclid 2
      st b5 = |[b1,b2]| & 0 <= b3 & b3 < b4
   holds |[b1,b2 + b3]| in Ball(b5,b4);

:: GOBOARD6:th 12
theorem
for b1, b2, b3, b4 being Element of REAL
for b5 being Element of the carrier of Euclid 2
      st b5 = |[b1,b2]| & 0 <= b3 & b3 < b4
   holds |[b1 - b3,b2]| in Ball(b5,b4);

:: GOBOARD6:th 13
theorem
for b1, b2, b3, b4 being Element of REAL
for b5 being Element of the carrier of Euclid 2
      st b5 = |[b1,b2]| & 0 <= b3 & b3 < b4
   holds |[b1,b2 - b3]| in Ball(b5,b4);

:: GOBOARD6:th 14
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 (b3 *(b1,b2)) + (b3 *(b1 + 1,b2 + 1)) = (b3 *(b1,b2 + 1)) + (b3 *(b1 + 1,b2));

:: GOBOARD6:th 15
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
   Int v_strip(b1,0) = {|[b2,b3]| where b2 is Element of REAL, b3 is Element of REAL: b2 < (b1 *(1,1)) `1};

:: GOBOARD6:th 16
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
   Int v_strip(b1,len b1) = {|[b2,b3]| where b2 is Element of REAL, b3 is Element of REAL: (b1 *(len b1,1)) `1 < b2};

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

:: GOBOARD6:th 18
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
   Int h_strip(b1,0) = {|[b2,b3]| where b2 is Element of REAL, b3 is Element of REAL: b3 < (b1 *(1,1)) `2};

:: GOBOARD6:th 19
theorem
for b1 being non empty-yielding tabular X_equal-in-line Y_equal-in-column Y_increasing-in-line X_increasing-in-column FinSequence of (the carrier of TOP-REAL 2) * holds
   Int h_strip(b1,width b1) = {|[b2,b3]| where b2 is Element of REAL, b3 is Element of REAL: (b1 *(1,width b1)) `2 < b3};

:: GOBOARD6:th 20
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 Int h_strip(b2,b1) = {|[b3,b4]| where b3 is Element of REAL, b4 is Element of REAL: (b2 *(1,b1)) `2 < b4 &
    b4 < (b2 *(1,b1 + 1)) `2};

:: GOBOARD6: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) * holds
   Int cell(b1,0,0) = {|[b2,b3]| where b2 is Element of REAL, b3 is Element of REAL: b2 < (b1 *(1,1)) `1 & b3 < (b1 *(1,1)) `2};

:: GOBOARD6:th 22
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
   Int cell(b1,0,width b1) = {|[b2,b3]| where b2 is Element of REAL, b3 is Element of REAL: b2 < (b1 *(1,1)) `1 & (b1 *(1,width b1)) `2 < b3};

:: GOBOARD6:th 23
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 Int cell(b2,0,b1) = {|[b3,b4]| where b3 is Element of REAL, b4 is Element of REAL: b3 < (b2 *(1,1)) `1 &
    (b2 *(1,b1)) `2 < b4 &
    b4 < (b2 *(1,b1 + 1)) `2};

:: GOBOARD6:th 24
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
   Int cell(b1,len b1,0) = {|[b2,b3]| where b2 is Element of REAL, b3 is Element of REAL: (b1 *(len b1,1)) `1 < b2 & b3 < (b1 *(1,1)) `2};

:: GOBOARD6:th 25
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
   Int cell(b1,len b1,width b1) = {|[b2,b3]| where b2 is Element of REAL, b3 is Element of REAL: (b1 *(len b1,1)) `1 < b2 & (b1 *(1,width b1)) `2 < b3};

:: GOBOARD6:th 26
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 Int cell(b2,len b2,b1) = {|[b3,b4]| where b3 is Element of REAL, b4 is Element of REAL: (b2 *(len b2,1)) `1 < b3 &
    (b2 *(1,b1)) `2 < b4 &
    b4 < (b2 *(1,b1 + 1)) `2};

:: GOBOARD6: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 1 <= b1 & b1 < len b2
   holds Int cell(b2,b1,0) = {|[b3,b4]| where b3 is Element of REAL, b4 is Element of REAL: (b2 *(b1,1)) `1 < b3 &
    b3 < (b2 *(b1 + 1,1)) `1 &
    b4 < (b2 *(1,1)) `2};

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

:: GOBOARD6:th 29
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 Int cell(b3,b1,b2) = {|[b4,b5]| where b4 is Element of REAL, b5 is Element of REAL: (b3 *(b1,1)) `1 < b4 &
    b4 < (b3 *(b1 + 1,1)) `1 &
    (b3 *(1,b2)) `2 < b5 &
    b5 < (b3 *(1,b2 + 1)) `2};

:: GOBOARD6:th 30
theorem
for b1 being Element of NAT
for b2 being Element 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 <= width b3 & b2 in Int h_strip(b3,b1)
   holds (b3 *(1,b1)) `2 < b2 `2;

:: GOBOARD6:th 31
theorem
for b1 being Element of NAT
for b2 being Element 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 b1 < width b3 & b2 in Int h_strip(b3,b1)
   holds b2 `2 < (b3 *(1,b1 + 1)) `2;

:: GOBOARD6:th 32
theorem
for b1 being Element of NAT
for b2 being Element 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 <= len b3 & b2 in Int v_strip(b3,b1)
   holds (b3 *(b1,1)) `1 < b2 `1;

:: GOBOARD6:th 33
theorem
for b1 being Element of NAT
for b2 being Element 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 b1 < len b3 & b2 in Int v_strip(b3,b1)
   holds b2 `1 < (b3 *(b1 + 1,1)) `1;

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

:: GOBOARD6: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 + 1 <= len b2
   holds ((1 / 2) * ((b2 *(b1,width b2)) + (b2 *(b1 + 1,width b2)))) + |[0,1]| in Int cell(b2,b1,width b2);

:: GOBOARD6:th 36
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 + 1 <= len b2
   holds ((1 / 2) * ((b2 *(b1,1)) + (b2 *(b1 + 1,1)))) - |[0,1]| in Int cell(b2,b1,0);

:: GOBOARD6:th 37
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 + 1 <= width b2
   holds ((1 / 2) * ((b2 *(len b2,b1)) + (b2 *(len b2,b1 + 1)))) + |[1,0]| in Int cell(b2,len b2,b1);

:: GOBOARD6:th 38
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 + 1 <= width b2
   holds ((1 / 2) * ((b2 *(1,b1)) + (b2 *(1,b1 + 1)))) - |[1,0]| in Int cell(b2,0,b1);

:: GOBOARD6:th 39
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 *(1,1)) - |[1,1]| in Int cell(b1,0,0);

:: GOBOARD6:th 40
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 *(len b1,width b1)) + |[1,1]| in Int cell(b1,len b1,width b1);

:: GOBOARD6:th 41
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 *(1,width b1)) + |[- 1,1]| in Int cell(b1,0,width b1);

:: GOBOARD6:th 42
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 *(len b1,1)) + |[1,- 1]| in Int cell(b1,len b1,0);

:: GOBOARD6: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) *
      st 1 <= b1 & b1 < len b3 & 1 <= b2 & b2 < width b3
   holds LSeg((1 / 2) * ((b3 *(b1,b2)) + (b3 *(b1 + 1,b2 + 1))),(1 / 2) * ((b3 *(b1,b2)) + (b3 *(b1,b2 + 1)))) c= (Int cell(b3,b1,b2)) \/ {(1 / 2) * ((b3 *(b1,b2)) + (b3 *(b1,b2 + 1)))};

:: GOBOARD6: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) *
      st 1 <= b1 & b1 < len b3 & 1 <= b2 & b2 < width b3
   holds LSeg((1 / 2) * ((b3 *(b1,b2)) + (b3 *(b1 + 1,b2 + 1))),(1 / 2) * ((b3 *(b1,b2 + 1)) + (b3 *(b1 + 1,b2 + 1)))) c= (Int cell(b3,b1,b2)) \/ {(1 / 2) * ((b3 *(b1,b2 + 1)) + (b3 *(b1 + 1,b2 + 1)))};

:: GOBOARD6:th 45
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((1 / 2) * ((b3 *(b1,b2)) + (b3 *(b1 + 1,b2 + 1))),(1 / 2) * ((b3 *(b1 + 1,b2)) + (b3 *(b1 + 1,b2 + 1)))) c= (Int cell(b3,b1,b2)) \/ {(1 / 2) * ((b3 *(b1 + 1,b2)) + (b3 *(b1 + 1,b2 + 1)))};

:: GOBOARD6:th 46
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((1 / 2) * ((b3 *(b1,b2)) + (b3 *(b1 + 1,b2 + 1))),(1 / 2) * ((b3 *(b1,b2)) + (b3 *(b1 + 1,b2)))) c= (Int cell(b3,b1,b2)) \/ {(1 / 2) * ((b3 *(b1,b2)) + (b3 *(b1 + 1,b2)))};

:: GOBOARD6:th 47
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 LSeg(((1 / 2) * ((b2 *(1,b1)) + (b2 *(1,b1 + 1)))) - |[1,0]|,(1 / 2) * ((b2 *(1,b1)) + (b2 *(1,b1 + 1)))) c= (Int cell(b2,0,b1)) \/ {(1 / 2) * ((b2 *(1,b1)) + (b2 *(1,b1 + 1)))};

:: GOBOARD6:th 48
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 LSeg(((1 / 2) * ((b2 *(len b2,b1)) + (b2 *(len b2,b1 + 1)))) + |[1,0]|,(1 / 2) * ((b2 *(len b2,b1)) + (b2 *(len b2,b1 + 1)))) c= (Int cell(b2,len b2,b1)) \/ {(1 / 2) * ((b2 *(len b2,b1)) + (b2 *(len b2,b1 + 1)))};

:: GOBOARD6:th 49
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 LSeg(((1 / 2) * ((b2 *(b1,1)) + (b2 *(b1 + 1,1)))) - |[0,1]|,(1 / 2) * ((b2 *(b1,1)) + (b2 *(b1 + 1,1)))) c= (Int cell(b2,b1,0)) \/ {(1 / 2) * ((b2 *(b1,1)) + (b2 *(b1 + 1,1)))};

:: GOBOARD6:th 50
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 LSeg(((1 / 2) * ((b2 *(b1,width b2)) + (b2 *(b1 + 1,width b2)))) + |[0,1]|,(1 / 2) * ((b2 *(b1,width b2)) + (b2 *(b1 + 1,width b2)))) c= (Int cell(b2,b1,width b2)) \/ {(1 / 2) * ((b2 *(b1,width b2)) + (b2 *(b1 + 1,width b2)))};

:: GOBOARD6:th 51
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 LSeg(((1 / 2) * ((b2 *(1,b1)) + (b2 *(1,b1 + 1)))) - |[1,0]|,(b2 *(1,b1)) - |[1,0]|) c= (Int cell(b2,0,b1)) \/ {(b2 *(1,b1)) - |[1,0]|};

:: GOBOARD6:th 52
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 LSeg(((1 / 2) * ((b2 *(1,b1)) + (b2 *(1,b1 + 1)))) - |[1,0]|,(b2 *(1,b1 + 1)) - |[1,0]|) c= (Int cell(b2,0,b1)) \/ {(b2 *(1,b1 + 1)) - |[1,0]|};

:: GOBOARD6:th 53
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 LSeg(((1 / 2) * ((b2 *(len b2,b1)) + (b2 *(len b2,b1 + 1)))) + |[1,0]|,(b2 *(len b2,b1)) + |[1,0]|) c= (Int cell(b2,len b2,b1)) \/ {(b2 *(len b2,b1)) + |[1,0]|};

:: GOBOARD6:th 54
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 LSeg(((1 / 2) * ((b2 *(len b2,b1)) + (b2 *(len b2,b1 + 1)))) + |[1,0]|,(b2 *(len b2,b1 + 1)) + |[1,0]|) c= (Int cell(b2,len b2,b1)) \/ {(b2 *(len b2,b1 + 1)) + |[1,0]|};

:: GOBOARD6:th 55
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 LSeg(((1 / 2) * ((b2 *(b1,1)) + (b2 *(b1 + 1,1)))) - |[0,1]|,(b2 *(b1,1)) - |[0,1]|) c= (Int cell(b2,b1,0)) \/ {(b2 *(b1,1)) - |[0,1]|};

:: GOBOARD6:th 56
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 LSeg(((1 / 2) * ((b2 *(b1,1)) + (b2 *(b1 + 1,1)))) - |[0,1]|,(b2 *(b1 + 1,1)) - |[0,1]|) c= (Int cell(b2,b1,0)) \/ {(b2 *(b1 + 1,1)) - |[0,1]|};

:: GOBOARD6:th 57
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 LSeg(((1 / 2) * ((b2 *(b1,width b2)) + (b2 *(b1 + 1,width b2)))) + |[0,1]|,(b2 *(b1,width b2)) + |[0,1]|) c= (Int cell(b2,b1,width b2)) \/ {(b2 *(b1,width b2)) + |[0,1]|};

:: GOBOARD6:th 58
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 LSeg(((1 / 2) * ((b2 *(b1,width b2)) + (b2 *(b1 + 1,width b2)))) + |[0,1]|,(b2 *(b1 + 1,width b2)) + |[0,1]|) c= (Int cell(b2,b1,width b2)) \/ {(b2 *(b1 + 1,width b2)) + |[0,1]|};

:: GOBOARD6:th 59
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
   LSeg((b1 *(1,1)) - |[1,1]|,(b1 *(1,1)) - |[1,0]|) c= (Int cell(b1,0,0)) \/ {(b1 *(1,1)) - |[1,0]|};

:: GOBOARD6:th 60
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
   LSeg((b1 *(len b1,1)) + |[1,- 1]|,(b1 *(len b1,1)) + |[1,0]|) c= (Int cell(b1,len b1,0)) \/ {(b1 *(len b1,1)) + |[1,0]|};

:: GOBOARD6:th 61
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
   LSeg((b1 *(1,width b1)) + |[- 1,1]|,(b1 *(1,width b1)) - |[1,0]|) c= (Int cell(b1,0,width b1)) \/ {(b1 *(1,width b1)) - |[1,0]|};

:: GOBOARD6:th 62
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
   LSeg((b1 *(len b1,width b1)) + |[1,1]|,(b1 *(len b1,width b1)) + |[1,0]|) c= (Int cell(b1,len b1,width b1)) \/ {(b1 *(len b1,width b1)) + |[1,0]|};

:: GOBOARD6:th 63
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
   LSeg((b1 *(1,1)) - |[1,1]|,(b1 *(1,1)) - |[0,1]|) c= (Int cell(b1,0,0)) \/ {(b1 *(1,1)) - |[0,1]|};

:: GOBOARD6:th 64
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
   LSeg((b1 *(len b1,1)) + |[1,- 1]|,(b1 *(len b1,1)) - |[0,1]|) c= (Int cell(b1,len b1,0)) \/ {(b1 *(len b1,1)) - |[0,1]|};

:: GOBOARD6:th 65
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
   LSeg((b1 *(1,width b1)) + |[- 1,1]|,(b1 *(1,width b1)) + |[0,1]|) c= (Int cell(b1,0,width b1)) \/ {(b1 *(1,width b1)) + |[0,1]|};

:: GOBOARD6:th 66
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
   LSeg((b1 *(len b1,width b1)) + |[1,1]|,(b1 *(len b1,width b1)) + |[0,1]|) c= (Int cell(b1,len b1,width b1)) \/ {(b1 *(len b1,width b1)) + |[0,1]|};

:: GOBOARD6:th 67
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 + 1 < width b3
   holds LSeg((1 / 2) * ((b3 *(b1,b2)) + (b3 *(b1 + 1,b2 + 1))),(1 / 2) * ((b3 *(b1,b2 + 1)) + (b3 *(b1 + 1,b2 + 2)))) c= ((Int cell(b3,b1,b2)) \/ Int cell(b3,b1,b2 + 1)) \/ {(1 / 2) * ((b3 *(b1,b2 + 1)) + (b3 *(b1 + 1,b2 + 1)))};

:: GOBOARD6:th 68
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 < width b3 & 1 <= b2 & b2 + 1 < len b3
   holds LSeg((1 / 2) * ((b3 *(b2,b1)) + (b3 *(b2 + 1,b1 + 1))),(1 / 2) * ((b3 *(b2 + 1,b1)) + (b3 *(b2 + 2,b1 + 1)))) c= ((Int cell(b3,b2,b1)) \/ Int cell(b3,b2 + 1,b1)) \/ {(1 / 2) * ((b3 *(b2 + 1,b1)) + (b3 *(b2 + 1,b1 + 1)))};

:: GOBOARD6:th 69
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 & 1 < width b2
   holds LSeg(((1 / 2) * ((b2 *(b1,1)) + (b2 *(b1 + 1,1)))) - |[0,1]|,(1 / 2) * ((b2 *(b1,1)) + (b2 *(b1 + 1,2)))) c= ((Int cell(b2,b1,0)) \/ Int cell(b2,b1,1)) \/ {(1 / 2) * ((b2 *(b1,1)) + (b2 *(b1 + 1,1)))};

:: GOBOARD6:th 70
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 & 1 < width b2
   holds LSeg(((1 / 2) * ((b2 *(b1,width b2)) + (b2 *(b1 + 1,width b2)))) + |[0,1]|,(1 / 2) * ((b2 *(b1,width b2)) + (b2 *(b1 + 1,(width b2) -' 1)))) c= ((Int cell(b2,b1,(width b2) -' 1)) \/ Int cell(b2,b1,width b2)) \/ {(1 / 2) * ((b2 *(b1,width b2)) + (b2 *(b1 + 1,width b2)))};

:: GOBOARD6:th 71
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 & 1 < len b2
   holds LSeg(((1 / 2) * ((b2 *(1,b1)) + (b2 *(1,b1 + 1)))) - |[1,0]|,(1 / 2) * ((b2 *(1,b1)) + (b2 *(2,b1 + 1)))) c= ((Int cell(b2,0,b1)) \/ Int cell(b2,1,b1)) \/ {(1 / 2) * ((b2 *(1,b1)) + (b2 *(1,b1 + 1)))};

:: GOBOARD6:th 72
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 & 1 < len b2
   holds LSeg(((1 / 2) * ((b2 *(len b2,b1)) + (b2 *(len b2,b1 + 1)))) + |[1,0]|,(1 / 2) * ((b2 *(len b2,b1)) + (b2 *((len b2) -' 1,b1 + 1)))) c= ((Int cell(b2,(len b2) -' 1,b1)) \/ Int cell(b2,len b2,b1)) \/ {(1 / 2) * ((b2 *(len b2,b1)) + (b2 *(len b2,b1 + 1)))};

:: GOBOARD6:th 73
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 < len b2 & 1 <= b1 & b1 + 1 < width b2
   holds LSeg(((1 / 2) * ((b2 *(1,b1)) + (b2 *(1,b1 + 1)))) - |[1,0]|,((1 / 2) * ((b2 *(1,b1 + 1)) + (b2 *(1,b1 + 2)))) - |[1,0]|) c= ((Int cell(b2,0,b1)) \/ Int cell(b2,0,b1 + 1)) \/ {(b2 *(1,b1 + 1)) - |[1,0]|};

:: GOBOARD6:th 74
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 < len b2 & 1 <= b1 & b1 + 1 < width b2
   holds LSeg(((1 / 2) * ((b2 *(len b2,b1)) + (b2 *(len b2,b1 + 1)))) + |[1,0]|,((1 / 2) * ((b2 *(len b2,b1 + 1)) + (b2 *(len b2,b1 + 2)))) + |[1,0]|) c= ((Int cell(b2,len b2,b1)) \/ Int cell(b2,len b2,b1 + 1)) \/ {(b2 *(len b2,b1 + 1)) + |[1,0]|};

:: GOBOARD6:th 75
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 < width b2 & 1 <= b1 & b1 + 1 < len b2
   holds LSeg(((1 / 2) * ((b2 *(b1,1)) + (b2 *(b1 + 1,1)))) - |[0,1]|,((1 / 2) * ((b2 *(b1 + 1,1)) + (b2 *(b1 + 2,1)))) - |[0,1]|) c= ((Int cell(b2,b1,0)) \/ Int cell(b2,b1 + 1,0)) \/ {(b2 *(b1 + 1,1)) - |[0,1]|};

:: GOBOARD6:th 76
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 < width b2 & 1 <= b1 & b1 + 1 < len b2
   holds LSeg(((1 / 2) * ((b2 *(b1,width b2)) + (b2 *(b1 + 1,width b2)))) + |[0,1]|,((1 / 2) * ((b2 *(b1 + 1,width b2)) + (b2 *(b1 + 2,width b2)))) + |[0,1]|) c= ((Int cell(b2,b1,width b2)) \/ Int cell(b2,b1 + 1,width b2)) \/ {(b2 *(b1 + 1,width b2)) + |[0,1]|};

:: GOBOARD6:th 77
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) *
      st 1 < len b1 & 1 < width b1
   holds LSeg((b1 *(1,1)) - |[1,1]|,((1 / 2) * ((b1 *(1,1)) + (b1 *(1,2)))) - |[1,0]|) c= ((Int cell(b1,0,0)) \/ Int cell(b1,0,1)) \/ {(b1 *(1,1)) - |[1,0]|};

:: GOBOARD6:th 78
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) *
      st 1 < len b1 & 1 < width b1
   holds LSeg((b1 *(len b1,1)) + |[1,- 1]|,((1 / 2) * ((b1 *(len b1,1)) + (b1 *(len b1,2)))) + |[1,0]|) c= ((Int cell(b1,len b1,0)) \/ Int cell(b1,len b1,1)) \/ {(b1 *(len b1,1)) + |[1,0]|};

:: GOBOARD6:th 79
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) *
      st 1 < len b1 & 1 < width b1
   holds LSeg((b1 *(1,width b1)) + |[- 1,1]|,((1 / 2) * ((b1 *(1,width b1)) + (b1 *(1,(width b1) -' 1)))) - |[1,0]|) c= ((Int cell(b1,0,width b1)) \/ Int cell(b1,0,(width b1) -' 1)) \/ {(b1 *(1,width b1)) - |[1,0]|};

:: GOBOARD6:th 80
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) *
      st 1 < len b1 & 1 < width b1
   holds LSeg((b1 *(len b1,width b1)) + |[1,1]|,((1 / 2) * ((b1 *(len b1,width b1)) + (b1 *(len b1,(width b1) -' 1)))) + |[1,0]|) c= ((Int cell(b1,len b1,width b1)) \/ Int cell(b1,len b1,(width b1) -' 1)) \/ {(b1 *(len b1,width b1)) + |[1,0]|};

:: GOBOARD6:th 81
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) *
      st 1 < width b1 & 1 < len b1
   holds LSeg((b1 *(1,1)) - |[1,1]|,((1 / 2) * ((b1 *(1,1)) + (b1 *(2,1)))) - |[0,1]|) c= ((Int cell(b1,0,0)) \/ Int cell(b1,1,0)) \/ {(b1 *(1,1)) - |[0,1]|};

:: GOBOARD6:th 82
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) *
      st 1 < width b1 & 1 < len b1
   holds LSeg((b1 *(1,width b1)) + |[- 1,1]|,((1 / 2) * ((b1 *(1,width b1)) + (b1 *(2,width b1)))) + |[0,1]|) c= ((Int cell(b1,0,width b1)) \/ Int cell(b1,1,width b1)) \/ {(b1 *(1,width b1)) + |[0,1]|};

:: GOBOARD6:th 83
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) *
      st 1 < width b1 & 1 < len b1
   holds LSeg((b1 *(len b1,1)) + |[1,- 1]|,((1 / 2) * ((b1 *(len b1,1)) + (b1 *((len b1) -' 1,1)))) - |[0,1]|) c= ((Int cell(b1,len b1,0)) \/ Int cell(b1,(len b1) -' 1,0)) \/ {(b1 *(len b1,1)) - |[0,1]|};

:: GOBOARD6:th 84
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) *
      st 1 < width b1 & 1 < len b1
   holds LSeg((b1 *(len b1,width b1)) + |[1,1]|,((1 / 2) * ((b1 *(len b1,width b1)) + (b1 *((len b1) -' 1,width b1)))) + |[0,1]|) c= ((Int cell(b1,len b1,width b1)) \/ Int cell(b1,(len b1) -' 1,width b1)) \/ {(b1 *(len b1,width b1)) + |[0,1]|};

:: GOBOARD6:th 85
theorem
for b1, b2 being Element of NAT
for b3 being Element 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 b4 & 1 <= b2 & b2 + 1 <= width b4
   holds LSeg((1 / 2) * ((b4 *(b1,b2)) + (b4 *(b1 + 1,b2 + 1))),b3) meets Int cell(b4,b1,b2);

:: GOBOARD6:th 86
theorem
for b1 being Element of NAT
for b2 being Element 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 b3
   holds LSeg(b2,((1 / 2) * ((b3 *(b1,width b3)) + (b3 *(b1 + 1,width b3)))) + |[0,1]|) meets Int cell(b3,b1,width b3);

:: GOBOARD6:th 87
theorem
for b1 being Element of NAT
for b2 being Element 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 b3
   holds LSeg(((1 / 2) * ((b3 *(b1,1)) + (b3 *(b1 + 1,1)))) - |[0,1]|,b2) meets Int cell(b3,b1,0);

:: GOBOARD6:th 88
theorem
for b1 being Element of NAT
for b2 being Element 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 <= width b3
   holds LSeg(((1 / 2) * ((b3 *(1,b1)) + (b3 *(1,b1 + 1)))) - |[1,0]|,b2) meets Int cell(b3,0,b1);

:: GOBOARD6:th 89
theorem
for b1 being Element of NAT
for b2 being Element 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 <= width b3
   holds LSeg(b2,((1 / 2) * ((b3 *(len b3,b1)) + (b3 *(len b3,b1 + 1)))) + |[1,0]|) meets Int cell(b3,len b3,b1);

:: GOBOARD6:th 90
theorem
for b1 being Element 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) * holds
   LSeg(b1,(b2 *(1,1)) - |[1,1]|) meets Int cell(b2,0,0);

:: GOBOARD6:th 91
theorem
for b1 being Element 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) * holds
   LSeg(b1,(b2 *(len b2,width b2)) + |[1,1]|) meets Int cell(b2,len b2,width b2);

:: GOBOARD6:th 92
theorem
for b1 being Element 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) * holds
   LSeg(b1,(b2 *(1,width b2)) + |[- 1,1]|) meets Int cell(b2,0,width b2);

:: GOBOARD6:th 93
theorem
for b1 being Element 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) * holds
   LSeg(b1,(b2 *(len b2,1)) + |[1,- 1]|) meets Int cell(b2,len b2,0);

:: GOBOARD6:th 94
theorem
for b1 being non empty Reflexive discerning symmetric triangle MetrStruct
for b2 being Element of the carrier of b1
for b3 being Element of the carrier of TopSpaceMetr b1
for b4 being real set
      st b2 = b3 & 0 < b4
   holds Ball(b2,b4) is a_neighborhood of b3;

:: GOBOARD6:th 95
theorem
for b1 being non empty Reflexive discerning symmetric triangle MetrStruct
for b2 being Element of bool the carrier of TopSpaceMetr b1
for b3 being Element of the carrier of b1 holds
      b3 in Cl b2
   iff
      for b4 being real set
            st 0 < b4
         holds Ball(b3,b4) meets b2;

:: GOBOARD6:th 96
theorem
for b1 being Element of NAT
for b2 being Element of bool the carrier of TOP-REAL b1
for b3 being Element of the carrier of TOP-REAL b1
for b4 being Element of the carrier of Euclid b1
   st b3 = b4
for b5 being real set
      st 0 < b5
   holds    b3 in Cl b2
   iff
      for b6 being real set
            st 0 < b6 & b6 < b5
         holds Ball(b4,b6) meets b2;