Article CHAIN_1, MML version 4.99.1005

:: CHAIN_1:th 1
theorem
for b1, b2 being real set
      st b1 < b2
   holds ex b3 being Element of REAL st
      b1 < b3 & b3 < b2;

:: CHAIN_1:th 2
theorem
for b1, b2 being real set holds
ex b3 being Element of REAL st
   b1 < b3 & b2 < b3;

:: CHAIN_1:sch 1
scheme CHAIN_1:sch 1
{F1 -> non empty set,
  F2 -> non empty set,
  F3 -> Element of F1()}:
{F3(b1, b2) where b1 is Element of F2(), b2 is Element of F2(): P1[b1, b2]} c= F1()


:: CHAIN_1:funcnot 1 => CHAIN_1:func 1
definition
  let a1 be set;
  let a2 be Element of bool a1;
  redefine func bool a2 -> Element of bool bool a1;
end;

:: CHAIN_1:attrnot 1 => XBOOLE_0:attr 1
definition
  let a1 be set;
  attr a1 is zero means
    a1 <= 0;
end;

:: CHAIN_1:dfs 1
definiens
  let a1 be real Element of NAT;
To prove
     a1 is empty
it is sufficient to prove
  thus a1 <= 0;

:: CHAIN_1:def 1
theorem
for b1 being real Element of NAT holds
      b1 is empty
   iff
      b1 <= 0;

:: CHAIN_1:attrnot 2 => XBOOLE_0:attr 1
definition
  let a1 be set;
  attr a1 is zero means
    a1 < 1;
end;

:: CHAIN_1:dfs 2
definiens
  let a1 be Element of NAT;
To prove
     a1 is empty
it is sufficient to prove
  thus a1 < 1;

:: CHAIN_1:def 2
theorem
for b1 being Element of NAT holds
      b1 is empty
   iff
      b1 < 1;

:: CHAIN_1:funcreg 1
registration
  let a1 be non empty Element of NAT;
  cluster Seg a1 -> non empty;
end;

:: CHAIN_1:attrnot 3 => REALSET1:attr 1
definition
  let a1 be set;
  attr a1 is trivial means
    for b1, b2 being set
          st b1 in a1 & b2 in a1
       holds b1 = b2;
end;

:: CHAIN_1:dfs 3
definiens
  let a1 be set;
To prove
     a1 is trivial
it is sufficient to prove
  thus for b1, b2 being set
          st b1 in a1 & b2 in a1
       holds b1 = b2;

:: CHAIN_1:def 3
theorem
for b1 being set holds
      b1 is trivial
   iff
      for b2, b3 being set
            st b2 in b1 & b3 in b1
         holds b2 = b3;

:: CHAIN_1:th 4
theorem
for b1, b2 being set holds
   {b1,b2} is trivial
iff
   b1 = b2;

:: CHAIN_1:exreg 1
registration
  cluster finite non trivial set;
end;

:: CHAIN_1:funcreg 2
registration
  let a1 be non trivial set;
  let a2 be set;
  cluster a1 \/ a2 -> non trivial;
end;

:: CHAIN_1:funcreg 3
registration
  let a1 be non trivial set;
  let a2 be set;
  cluster a2 \/ a1 -> non trivial;
end;

:: CHAIN_1:funcreg 4
registration
  cluster REAL -> non trivial;
end;

:: CHAIN_1:exreg 2
registration
  let a1 be non trivial set;
  cluster finite non trivial Element of bool a1;
end;

:: CHAIN_1:th 5
theorem
for b1, b2 being set
      st b1 is trivial & b1 \/ {b2} is not trivial
   holds ex b3 being set st
      b1 = {b3};

:: CHAIN_1:sch 2
scheme CHAIN_1:sch 2
{F1 -> non empty set,
  F2 -> non empty finite Element of bool F1()}:
P1[F2()]
provided
   for b1 being Element of F1()
         st b1 in F2()
      holds P1[{b1}]
and
   for b1 being Element of F1()
   for b2 being non empty finite Element of bool F1()
         st b1 in F2() & b2 c= F2() & not b1 in b2 & P1[b2]
      holds P1[b2 \/ {b1}];


:: CHAIN_1:sch 3
scheme CHAIN_1:sch 3
{F1 -> non trivial set,
  F2 -> finite non trivial Element of bool F1()}:
P1[F2()]
provided
   for b1, b2 being Element of F1()
         st b1 in F2() & b2 in F2() & b1 <> b2
      holds P1[{b1,b2}]
and
   for b1 being Element of F1()
   for b2 being finite non trivial Element of bool F1()
         st b1 in F2() & b2 c= F2() & not b1 in b2 & P1[b2]
      holds P1[b2 \/ {b1}];


:: CHAIN_1:th 6
theorem
for b1 being set holds
      Card b1 = 2
   iff
      ex b2, b3 being set st
         b2 in b1 &
          b3 in b1 &
          b2 <> b3 &
          (for b4 being set
                st b4 in b1 & b4 <> b2
             holds b4 = b3);

:: CHAIN_1:th 7
theorem
for b1, b2 being Element of NAT holds
      b1 is even
   iff
      b2 is even
iff
   b1 + b2 is even;

:: CHAIN_1:th 8
theorem
for b1, b2 being finite set
      st b1 misses b2
   holds       card b1 is even
      iff
         card b2 is even
   iff
      card (b1 \/ b2) is even;

:: CHAIN_1:th 9
theorem
for b1, b2 being finite set holds
      card b1 is even
   iff
      card b2 is even
iff
   card (b1 \+\ b2) is even;

:: CHAIN_1:funcnot 2 => EUCLID:func 1
definition
  let a1 be natural set;
  func REAL A1 -> non empty FinSequenceSet of REAL means
    for b1 being set holds
          b1 in it
       iff
          b1 is Function-like quasi_total Relation of Seg a1,REAL;
end;

:: CHAIN_1:def 4
theorem
for b1 being Element of NAT
for b2 being non empty FinSequenceSet of REAL holds
      b2 = REAL b1
   iff
      for b3 being set holds
            b3 in b2
         iff
            b3 is Function-like quasi_total Relation of Seg b1,REAL;

:: CHAIN_1:modenot 1 => CHAIN_1:mode 1
definition
  let a1 be non empty Element of NAT;
  mode Grating of A1 -> Function-like quasi_total Relation of Seg a1,bool REAL means
    for b1 being Element of Seg a1 holds
       it . b1 is not trivial & it . b1 is finite;
end;

:: CHAIN_1:dfs 5
definiens
  let a1 be non empty Element of NAT;
  let a2 be Function-like quasi_total Relation of Seg a1,bool REAL;
To prove
     a2 is Grating of a1
it is sufficient to prove
  thus for b1 being Element of Seg a1 holds
       a2 . b1 is not trivial & a2 . b1 is finite;

:: CHAIN_1:def 5
theorem
for b1 being non empty Element of NAT
for b2 being Function-like quasi_total Relation of Seg b1,bool REAL holds
      b2 is Grating of b1
   iff
      for b3 being Element of Seg b1 holds
         b2 . b3 is not trivial & b2 . b3 is finite;

:: CHAIN_1:funcnot 3 => CHAIN_1:func 2
definition
  let a1 be non empty Element of NAT;
  let a2 be Grating of a1;
  let a3 be Element of Seg a1;
  redefine func a2 . a3 -> finite non trivial Element of bool REAL;
end;

:: CHAIN_1:th 10
theorem
for b1 being non empty Element of NAT
for b2 being Element of REAL b1
for b3 being Grating of b1 holds
      b2 in product b3
   iff
      for b4 being Element of Seg b1 holds
         b2 . b4 in b3 . b4;

:: CHAIN_1:th 11
theorem
for b1 being non empty Element of NAT
for b2 being Grating of b1 holds
   product b2 is finite;

:: CHAIN_1:th 12
theorem
for b1 being non empty finite Element of bool REAL holds
   ex b2 being Element of REAL st
      b2 in b1 &
       (for b3 being Element of REAL
             st b3 in b1
          holds b3 <= b2);

:: CHAIN_1:th 13
theorem
for b1 being non empty finite Element of bool REAL holds
   ex b2 being Element of REAL st
      b2 in b1 &
       (for b3 being Element of REAL
             st b3 in b1
          holds b2 <= b3);

:: CHAIN_1:th 14
theorem
for b1 being finite non trivial Element of bool REAL holds
   ex b2, b3 being Element of REAL st
      b2 in b1 &
       b3 in b1 &
       b2 < b3 &
       (for b4 being Element of REAL
             st b4 in b1 & b2 < b4
          holds b3 <= b4);

:: CHAIN_1:th 15
theorem
for b1 being non empty finite Element of bool REAL holds
   ex b2 being Element of REAL st
      b2 in b1 &
       (for b3 being Element of REAL
             st b3 in b1
          holds b3 <= b2);

:: CHAIN_1:th 16
theorem
for b1 being finite non trivial Element of bool REAL holds
   ex b2, b3 being Element of REAL st
      b2 in b1 &
       b3 in b1 &
       b3 < b2 &
       (for b4 being Element of REAL
             st b4 in b1
          holds b3 <= b4 & b4 <= b2);

:: CHAIN_1:modenot 2 => CHAIN_1:mode 2
definition
  let a1 be finite non trivial Element of bool REAL;
  mode Gap of A1 -> Element of [:REAL,REAL:] means
    ex b1, b2 being Element of REAL st
       it = [b1,b2] &
        b1 in a1 &
        b2 in a1 &
        (b1 < b2 &
         (for b3 being Element of REAL
               st b3 in a1 & b1 < b3
            holds b2 <= b3) or b2 < b1 &
         (for b3 being Element of REAL
               st b3 in a1
            holds b3 <= b1 & b2 <= b3));
end;

:: CHAIN_1:dfs 6
definiens
  let a1 be finite non trivial Element of bool REAL;
  let a2 be Element of [:REAL,REAL:];
To prove
     a2 is Gap of a1
it is sufficient to prove
  thus ex b1, b2 being Element of REAL st
       a2 = [b1,b2] &
        b1 in a1 &
        b2 in a1 &
        (b1 < b2 &
         (for b3 being Element of REAL
               st b3 in a1 & b1 < b3
            holds b2 <= b3) or b2 < b1 &
         (for b3 being Element of REAL
               st b3 in a1
            holds b3 <= b1 & b2 <= b3));

:: CHAIN_1:def 6
theorem
for b1 being finite non trivial Element of bool REAL
for b2 being Element of [:REAL,REAL:] holds
      b2 is Gap of b1
   iff
      ex b3, b4 being Element of REAL st
         b2 = [b3,b4] &
          b3 in b1 &
          b4 in b1 &
          (b3 < b4 &
           (for b5 being Element of REAL
                 st b5 in b1 & b3 < b5
              holds b4 <= b5) or b4 < b3 &
           (for b5 being Element of REAL
                 st b5 in b1
              holds b5 <= b3 & b4 <= b5));

:: CHAIN_1:th 17
theorem
for b1 being finite non trivial Element of bool REAL
for b2, b3 being Element of REAL holds
   [b2,b3] is Gap of b1
iff
   b2 in b1 &
    b3 in b1 &
    (b2 < b3 &
     (for b4 being Element of REAL
           st b4 in b1 & b2 < b4
        holds b3 <= b4) or b3 < b2 &
     (for b4 being Element of REAL
           st b4 in b1
        holds b4 <= b2 & b3 <= b4));

:: CHAIN_1:th 18
theorem
for b1 being finite non trivial Element of bool REAL
for b2, b3, b4, b5 being Element of REAL
      st b1 = {b2,b3}
   holds    [b4,b5] is Gap of b1
   iff
      (b4 = b2 & b5 = b3 or b4 = b3 & b5 = b2);

:: CHAIN_1:th 19
theorem
for b1 being finite non trivial Element of bool REAL
for b2 being Element of REAL
      st b2 in b1
   holds ex b3 being Element of REAL st
      [b2,b3] is Gap of b1;

:: CHAIN_1:th 20
theorem
for b1 being finite non trivial Element of bool REAL
for b2 being Element of REAL
      st b2 in b1
   holds ex b3 being Element of REAL st
      [b3,b2] is Gap of b1;

:: CHAIN_1:th 21
theorem
for b1 being finite non trivial Element of bool REAL
for b2, b3, b4 being Element of REAL
      st [b2,b3] is Gap of b1 & [b2,b4] is Gap of b1
   holds b3 = b4;

:: CHAIN_1:th 22
theorem
for b1 being finite non trivial Element of bool REAL
for b2, b3, b4 being Element of REAL
      st [b2,b3] is Gap of b1 & [b4,b3] is Gap of b1
   holds b2 = b4;

:: CHAIN_1:th 23
theorem
for b1 being finite non trivial Element of bool REAL
for b2, b3, b4, b5 being Element of REAL
      st b2 < b3 & [b3,b2] is Gap of b1 & b4 < b5 & [b5,b4] is Gap of b1
   holds b3 = b5 & b2 = b4;

:: CHAIN_1:funcnot 4 => CHAIN_1:func 3
definition
  let a1 be non empty Element of NAT;
  let a2, a3 be Element of REAL a1;
  func cell(A2,A3) -> non empty Element of bool REAL a1 equals
    {b1 where b1 is Element of REAL a1: (ex b2 being Element of Seg a1 st
       (a2 . b2 <= b1 . b2 implies a3 . b2 < b1 . b2) implies ex b2 being Element of Seg a1 st
       a3 . b2 < a2 . b2 &
        (b1 . b2 <= a3 . b2 or a2 . b2 <= b1 . b2))};
end;

:: CHAIN_1:def 7
theorem
for b1 being non empty Element of NAT
for b2, b3 being Element of REAL b1 holds
cell(b2,b3) = {b4 where b4 is Element of REAL b1: (ex b5 being Element of Seg b1 st
   (b2 . b5 <= b4 . b5 implies b3 . b5 < b4 . b5) implies ex b5 being Element of Seg b1 st
   b3 . b5 < b2 . b5 &
    (b4 . b5 <= b3 . b5 or b2 . b5 <= b4 . b5))};

:: CHAIN_1:th 24
theorem
for b1 being non empty Element of NAT
for b2, b3, b4 being Element of REAL b1 holds
   b2 in cell(b3,b4)
iff
   (ex b5 being Element of Seg b1 st
      (b3 . b5 <= b2 . b5 implies b4 . b5 < b2 . b5) implies ex b5 being Element of Seg b1 st
      b4 . b5 < b3 . b5 &
       (b2 . b5 <= b4 . b5 or b3 . b5 <= b2 . b5));

:: CHAIN_1:th 25
theorem
for b1 being non empty Element of NAT
for b2, b3, b4 being Element of REAL b1
      st for b5 being Element of Seg b1 holds
           b2 . b5 <= b3 . b5
   holds    b4 in cell(b2,b3)
   iff
      for b5 being Element of Seg b1 holds
         b2 . b5 <= b4 . b5 & b4 . b5 <= b3 . b5;

:: CHAIN_1:th 26
theorem
for b1 being non empty Element of NAT
for b2, b3, b4 being Element of REAL b1
      st ex b5 being Element of Seg b1 st
           b2 . b5 < b3 . b5
   holds    b4 in cell(b3,b2)
   iff
      ex b5 being Element of Seg b1 st
         b2 . b5 < b3 . b5 &
          (b4 . b5 <= b2 . b5 or b3 . b5 <= b4 . b5);

:: CHAIN_1:th 27
theorem
for b1 being non empty Element of NAT
for b2, b3 being Element of REAL b1 holds
b2 in cell(b2,b3) & b3 in cell(b2,b3);

:: CHAIN_1:th 28
theorem
for b1 being non empty Element of NAT
for b2 being Element of REAL b1 holds
   cell(b2,b2) = {b2};

:: CHAIN_1:th 29
theorem
for b1 being non empty Element of NAT
for b2, b3, b4, b5 being Element of REAL b1
      st for b6 being Element of Seg b1 holds
           b2 . b6 <= b3 . b6
   holds    cell(b4,b5) c= cell(b2,b3)
   iff
      for b6 being Element of Seg b1 holds
         b2 . b6 <= b4 . b6 & b4 . b6 <= b5 . b6 & b5 . b6 <= b3 . b6;

:: CHAIN_1:th 30
theorem
for b1 being non empty Element of NAT
for b2, b3, b4, b5 being Element of REAL b1
      st for b6 being Element of Seg b1 holds
           b2 . b6 < b3 . b6
   holds    cell(b3,b2) c= cell(b4,b5)
   iff
      for b6 being Element of Seg b1 holds
         b2 . b6 <= b5 . b6 & b5 . b6 < b4 . b6 & b4 . b6 <= b3 . b6;

:: CHAIN_1:th 31
theorem
for b1 being non empty Element of NAT
for b2, b3, b4, b5 being Element of REAL b1
      st (for b6 being Element of Seg b1 holds
            b2 . b6 <= b3 . b6) &
         (for b6 being Element of Seg b1 holds
            b4 . b6 < b5 . b6)
   holds    cell(b2,b3) c= cell(b5,b4)
   iff
      ex b6 being Element of Seg b1 st
         (b3 . b6 <= b4 . b6 or b5 . b6 <= b2 . b6);

:: CHAIN_1:th 32
theorem
for b1 being non empty Element of NAT
for b2, b3, b4, b5 being Element of REAL b1
      st (for b6 being Element of Seg b1 holds
           b2 . b6 <= b3 . b6 or for b6 being Element of Seg b1 holds
           b3 . b6 < b2 . b6)
   holds    cell(b2,b3) = cell(b4,b5)
   iff
      b2 = b4 & b3 = b5;

:: CHAIN_1:funcnot 5 => CHAIN_1:func 4
definition
  let a1 be non empty Element of NAT;
  let a2 be Grating of a1;
  let a3 be Element of NAT;
  assume a3 <= a1;
  func cells(A3,A2) -> non empty finite Element of bool bool REAL a1 equals
    {cell(b1,b2) where b1 is Element of REAL a1, b2 is Element of REAL a1: (for b3 being Element of bool Seg a1
          st card b3 = a3
       holds ex b4 being Element of Seg a1 st
          (b4 in b3 & b1 . b4 < b2 . b4 implies [b1 . b4,b2 . b4] is not Gap of a2 . b4) &
           (not b4 in b3 & b1 . b4 = b2 . b4 implies not b1 . b4 in a2 . b4) implies a3 = a1 &
     (for b3 being Element of Seg a1 holds
        b2 . b3 < b1 . b3 &
         [b1 . b3,b2 . b3] is Gap of a2 . b3))};
end;

:: CHAIN_1:def 8
theorem
for b1 being non empty Element of NAT
for b2 being Grating of b1
for b3 being Element of NAT
      st b3 <= b1
   holds cells(b3,b2) = {cell(b4,b5) where b4 is Element of REAL b1, b5 is Element of REAL b1: (for b6 being Element of bool Seg b1
         st card b6 = b3
      holds ex b7 being Element of Seg b1 st
         (b7 in b6 & b4 . b7 < b5 . b7 implies [b4 . b7,b5 . b7] is not Gap of b2 . b7) &
          (not b7 in b6 & b4 . b7 = b5 . b7 implies not b4 . b7 in b2 . b7) implies b3 = b1 &
    (for b6 being Element of Seg b1 holds
       b5 . b6 < b4 . b6 &
        [b4 . b6,b5 . b6] is Gap of b2 . b6))};

:: CHAIN_1:th 33
theorem
for b1 being Element of NAT
for b2 being non empty Element of NAT
for b3 being Grating of b2
   st b1 <= b2
for b4 being Element of bool REAL b2 holds
      b4 in cells(b1,b3)
   iff
      ex b5, b6 being Element of REAL b2 st
         b4 = cell(b5,b6) &
          (for b7 being Element of bool Seg b2
                st card b7 = b1
             holds ex b8 being Element of Seg b2 st
                (b8 in b7 & b5 . b8 < b6 . b8 implies [b5 . b8,b6 . b8] is not Gap of b3 . b8) &
                 (not b8 in b7 & b5 . b8 = b6 . b8 implies not b5 . b8 in b3 . b8) implies b1 = b2 &
           (for b7 being Element of Seg b2 holds
              b6 . b7 < b5 . b7 &
               [b5 . b7,b6 . b7] is Gap of b3 . b7));

:: CHAIN_1:th 34
theorem
for b1 being Element of NAT
for b2 being non empty Element of NAT
for b3, b4 being Element of REAL b2
for b5 being Grating of b2
      st b1 <= b2
   holds    cell(b3,b4) in cells(b1,b5)
   iff
      (for b6 being Element of bool Seg b2
            st card b6 = b1
         holds ex b7 being Element of Seg b2 st
            (b7 in b6 & b3 . b7 < b4 . b7 implies [b3 . b7,b4 . b7] is not Gap of b5 . b7) &
             (not b7 in b6 & b3 . b7 = b4 . b7 implies not b3 . b7 in b5 . b7) implies b1 = b2 &
       (for b6 being Element of Seg b2 holds
          b4 . b6 < b3 . b6 &
           [b3 . b6,b4 . b6] is Gap of b5 . b6));

:: CHAIN_1:th 35
theorem
for b1 being Element of NAT
for b2 being non empty Element of NAT
for b3, b4 being Element of REAL b2
for b5 being Grating of b2
   st b1 <= b2 &
      cell(b3,b4) in cells(b1,b5) &
      (ex b6 being Element of Seg b2 st
         (b3 . b6 < b4 . b6 implies [b3 . b6,b4 . b6] is not Gap of b5 . b6) &
          (b3 . b6 = b4 . b6 implies not b3 . b6 in b5 . b6))
for b6 being Element of Seg b2 holds
   b4 . b6 < b3 . b6 &
    [b3 . b6,b4 . b6] is Gap of b5 . b6;

:: CHAIN_1:th 36
theorem
for b1 being Element of NAT
for b2 being non empty Element of NAT
for b3, b4 being Element of REAL b2
for b5 being Grating of b2
   st b1 <= b2 & cell(b3,b4) in cells(b1,b5)
for b6 being Element of Seg b2 holds
   b3 . b6 in b5 . b6 & b4 . b6 in b5 . b6;

:: CHAIN_1:th 37
theorem
for b1 being Element of NAT
for b2 being non empty Element of NAT
for b3, b4 being Element of REAL b2
for b5 being Grating of b2
   st b1 <= b2 &
      cell(b3,b4) in cells(b1,b5) &
      (ex b6 being Element of Seg b2 st
         b4 . b6 < b3 . b6)
for b6 being Element of Seg b2 holds
   b4 . b6 < b3 . b6;

:: CHAIN_1:th 38
theorem
for b1 being non empty Element of NAT
for b2 being Grating of b1
for b3 being Element of bool REAL b1 holds
      b3 in cells(0,b2)
   iff
      ex b4 being Element of REAL b1 st
         b3 = cell(b4,b4) &
          (for b5 being Element of Seg b1 holds
             b4 . b5 in b2 . b5);

:: CHAIN_1:th 39
theorem
for b1 being non empty Element of NAT
for b2, b3 being Element of REAL b1
for b4 being Grating of b1 holds
      cell(b2,b3) in cells(0,b4)
   iff
      b2 = b3 &
       (for b5 being Element of Seg b1 holds
          b2 . b5 in b4 . b5);

:: CHAIN_1:th 40
theorem
for b1 being non empty Element of NAT
for b2 being Grating of b1
for b3 being Element of bool REAL b1 holds
      b3 in cells(b1,b2)
   iff
      ex b4, b5 being Element of REAL b1 st
         b3 = cell(b4,b5) &
          (for b6 being Element of Seg b1 holds
             [b4 . b6,b5 . b6] is Gap of b2 . b6) &
          (for b6 being Element of Seg b1 holds
             b4 . b6 < b5 . b6 or for b6 being Element of Seg b1 holds
             b5 . b6 < b4 . b6);

:: CHAIN_1:th 41
theorem
for b1 being non empty Element of NAT
for b2, b3 being Element of REAL b1
for b4 being Grating of b1 holds
      cell(b2,b3) in cells(b1,b4)
   iff
      (for b5 being Element of Seg b1 holds
          [b2 . b5,b3 . b5] is Gap of b4 . b5) &
       (for b5 being Element of Seg b1 holds
          b2 . b5 < b3 . b5 or for b5 being Element of Seg b1 holds
          b3 . b5 < b2 . b5);

:: CHAIN_1:th 42
theorem
for b1 being Element of NAT
for b2 being non empty Element of NAT
for b3 being Grating of b2
   st b2 = b1 + 1
for b4 being Element of bool REAL b2 holds
      b4 in cells(b1,b3)
   iff
      ex b5, b6 being Element of REAL b2 st
         ex b7 being Element of Seg b2 st
            b4 = cell(b5,b6) &
             b5 . b7 = b6 . b7 &
             b5 . b7 in b3 . b7 &
             (for b8 being Element of Seg b2
                   st b8 <> b7
                holds b5 . b8 < b6 . b8 &
                 [b5 . b8,b6 . b8] is Gap of b3 . b8);

:: CHAIN_1:th 43
theorem
for b1 being Element of NAT
for b2 being non empty Element of NAT
for b3, b4 being Element of REAL b2
for b5 being Grating of b2
      st b2 = b1 + 1
   holds    cell(b3,b4) in cells(b1,b5)
   iff
      ex b6 being Element of Seg b2 st
         b3 . b6 = b4 . b6 &
          b3 . b6 in b5 . b6 &
          (for b7 being Element of Seg b2
                st b7 <> b6
             holds b3 . b7 < b4 . b7 &
              [b3 . b7,b4 . b7] is Gap of b5 . b7);

:: CHAIN_1:th 44
theorem
for b1 being non empty Element of NAT
for b2 being Grating of b1
for b3 being Element of bool REAL b1 holds
      b3 in cells(1,b2)
   iff
      ex b4, b5 being Element of REAL b1 st
         ex b6 being Element of Seg b1 st
            b3 = cell(b4,b5) &
             (b5 . b6 <= b4 . b6 implies b1 = 1 & b5 . b6 < b4 . b6) &
             [b4 . b6,b5 . b6] is Gap of b2 . b6 &
             (for b7 being Element of Seg b1
                   st b7 <> b6
                holds b4 . b7 = b5 . b7 & b4 . b7 in b2 . b7);

:: CHAIN_1:th 45
theorem
for b1 being non empty Element of NAT
for b2, b3 being Element of REAL b1
for b4 being Grating of b1 holds
      cell(b2,b3) in cells(1,b4)
   iff
      ex b5 being Element of Seg b1 st
         (b3 . b5 <= b2 . b5 implies b1 = 1 & b3 . b5 < b2 . b5) &
          [b2 . b5,b3 . b5] is Gap of b4 . b5 &
          (for b6 being Element of Seg b1
                st b6 <> b5
             holds b2 . b6 = b3 . b6 & b2 . b6 in b4 . b6);

:: CHAIN_1:th 46
theorem
for b1, b2 being Element of NAT
for b3 being non empty Element of NAT
for b4, b5, b6, b7 being Element of REAL b3
for b8 being Grating of b3
   st b1 <= b3 & b2 <= b3 & cell(b4,b5) in cells(b1,b8) & cell(b6,b7) in cells(b2,b8) & cell(b4,b5) c= cell(b6,b7)
for b9 being Element of Seg b3
      st (b4 . b9 = b6 . b9 implies b5 . b9 <> b7 . b9) &
         (b4 . b9 = b6 . b9 implies b5 . b9 <> b6 . b9) &
         (b4 . b9 = b7 . b9 implies b5 . b9 <> b7 . b9)
   holds b4 . b9 <= b5 . b9 & b7 . b9 < b6 . b9 & b7 . b9 <= b4 . b9 & b5 . b9 <= b6 . b9;

:: CHAIN_1:th 47
theorem
for b1, b2 being Element of NAT
for b3 being non empty Element of NAT
for b4, b5, b6, b7 being Element of REAL b3
for b8 being Grating of b3
      st b1 < b2 & b2 <= b3 & cell(b4,b5) in cells(b1,b8) & cell(b6,b7) in cells(b2,b8) & cell(b4,b5) c= cell(b6,b7)
   holds ex b9 being Element of Seg b3 st
      (b4 . b9 = b6 . b9 & b5 . b9 = b6 . b9 or b4 . b9 = b7 . b9 & b5 . b9 = b7 . b9);

:: CHAIN_1:th 48
theorem
for b1 being non empty Element of NAT
for b2, b3, b4, b5 being Element of REAL b1
for b6 being Grating of b1
for b7, b8 being Element of bool Seg b1
      st cell(b2,b3) c= cell(b4,b5) &
         (for b9 being Element of Seg b1
               st (b9 in b7 & b2 . b9 < b3 . b9 implies [b2 . b9,b3 . b9] is not Gap of b6 . b9)
            holds not b9 in b7 & b2 . b9 = b3 . b9 & b2 . b9 in b6 . b9) &
         (for b9 being Element of Seg b1
               st (b9 in b8 & b4 . b9 < b5 . b9 implies [b4 . b9,b5 . b9] is not Gap of b6 . b9)
            holds not b9 in b8 & b4 . b9 = b5 . b9 & b4 . b9 in b6 . b9)
   holds b7 c= b8 &
    (for b9 being Element of Seg b1
          st (not b9 in b7 implies not b9 in b8)
       holds b2 . b9 = b4 . b9 & b3 . b9 = b5 . b9) &
    (for b9 being Element of Seg b1
          st not b9 in b7 &
             b9 in b8 &
             (b2 . b9 = b4 . b9 implies b3 . b9 <> b4 . b9)
       holds b2 . b9 = b5 . b9 & b3 . b9 = b5 . b9);

:: CHAIN_1:modenot 3
definition
  let a1 be non empty Element of NAT;
  let a2 be Grating of a1;
  let a3 be Element of NAT;
  mode Cell of a3,a2 is Element of cells(a3,a2);
end;

:: CHAIN_1:modenot 4
definition
  let a1 be non empty Element of NAT;
  let a2 be Grating of a1;
  let a3 be Element of NAT;
  mode Chain of a3,a2 is Element of bool cells(a3,a2);
end;

:: CHAIN_1:funcnot 6 => CHAIN_1:func 5
definition
  let a1 be non empty Element of NAT;
  let a2 be Grating of a1;
  let a3 be Element of NAT;
  func 0_(A3,A2) -> Element of bool cells(a3,a2) equals
    {};
end;

:: CHAIN_1:def 9
theorem
for b1 being non empty Element of NAT
for b2 being Grating of b1
for b3 being Element of NAT holds
   0_(b3,b2) = {};

:: CHAIN_1:funcnot 7 => CHAIN_1:func 6
definition
  let a1 be non empty Element of NAT;
  let a2 be Grating of a1;
  func Omega A2 -> Element of bool cells(a1,a2) equals
    cells(a1,a2);
end;

:: CHAIN_1:def 10
theorem
for b1 being non empty Element of NAT
for b2 being Grating of b1 holds
   Omega b2 = cells(b1,b2);

:: CHAIN_1:funcnot 8 => XBOOLE_0:func 5
notation
  let a1 be non empty Element of NAT;
  let a2 be Grating of a1;
  let a3 be Element of NAT;
  let a4, a5 be Element of bool cells(a3,a2);
  synonym a4 + a5 for a1 \+\ a2;
end;

:: CHAIN_1:funcnot 9 => CHAIN_1:func 7
definition
  let a1 be non empty Element of NAT;
  let a2 be Grating of a1;
  let a3 be Element of NAT;
  let a4, a5 be Element of bool cells(a3,a2);
  redefine func a4 + a5 -> Element of bool cells(a3,a2);
  commutativity;
::  for a1 being non empty Element of NAT
::  for a2 being Grating of a1
::  for a3 being Element of NAT
::  for a4, a5 being Element of bool cells(a3,a2) holds
::  a4 + a5 = a5 + a4;
end;

:: CHAIN_1:funcnot 10 => CHAIN_1:func 8
definition
  let a1 be non empty Element of NAT;
  let a2 be Grating of a1;
  func infinite-cell A2 -> Element of cells(a1,a2) means
    ex b1, b2 being Element of REAL a1 st
       it = cell(b1,b2) &
        (for b3 being Element of Seg a1 holds
           b2 . b3 < b1 . b3 &
            [b1 . b3,b2 . b3] is Gap of a2 . b3);
end;

:: CHAIN_1:def 11
theorem
for b1 being non empty Element of NAT
for b2 being Grating of b1
for b3 being Element of cells(b1,b2) holds
      b3 = infinite-cell b2
   iff
      ex b4, b5 being Element of REAL b1 st
         b3 = cell(b4,b5) &
          (for b6 being Element of Seg b1 holds
             b5 . b6 < b4 . b6 &
              [b4 . b6,b5 . b6] is Gap of b2 . b6);

:: CHAIN_1:th 49
theorem
for b1 being non empty Element of NAT
for b2, b3 being Element of REAL b1
for b4 being Grating of b1
      st cell(b2,b3) is Element of cells(b1,b4)
   holds    cell(b2,b3) = infinite-cell b4
   iff
      for b5 being Element of Seg b1 holds
         b3 . b5 < b2 . b5;

:: CHAIN_1:th 50
theorem
for b1 being non empty Element of NAT
for b2, b3 being Element of REAL b1
for b4 being Grating of b1 holds
      cell(b2,b3) = infinite-cell b4
   iff
      for b5 being Element of Seg b1 holds
         b3 . b5 < b2 . b5 &
          [b2 . b5,b3 . b5] is Gap of b4 . b5;

:: CHAIN_1:sch 4
scheme CHAIN_1:sch 4
{F1 -> non empty Element of NAT,
  F2 -> Grating of F1(),
  F3 -> Element of NAT,
  F4 -> Element of bool cells(F3(),F2())}:
P1[F4()]
provided
   P1[0_(F3(),F2())]
and
   for b1 being Element of cells(F3(),F2())
         st b1 in F4()
      holds P1[{b1}]
and
   for b1, b2 being Element of bool cells(F3(),F2())
         st b1 c= F4() & b2 c= F4() & P1[b1] & P1[b2]
      holds P1[b1 + b2];


:: CHAIN_1:funcnot 11 => CHAIN_1:func 9
definition
  let a1 be non empty Element of NAT;
  let a2 be Grating of a1;
  let a3 be Element of NAT;
  let a4 be Element of cells(a3,a2);
  func star A4 -> Element of bool cells(a3 + 1,a2) equals
    {b1 where b1 is Element of cells(a3 + 1,a2): a4 c= b1};
end;

:: CHAIN_1:def 12
theorem
for b1 being non empty Element of NAT
for b2 being Grating of b1
for b3 being Element of NAT
for b4 being Element of cells(b3,b2) holds
   star b4 = {b5 where b5 is Element of cells(b3 + 1,b2): b4 c= b5};

:: CHAIN_1:th 51
theorem
for b1 being Element of NAT
for b2 being non empty Element of NAT
for b3 being Grating of b2
for b4 being Element of cells(b1,b3)
for b5 being Element of cells(b1 + 1,b3) holds
      b5 in star b4
   iff
      b4 c= b5;

:: CHAIN_1:funcnot 12 => CHAIN_1:func 10
definition
  let a1 be non empty Element of NAT;
  let a2 be Grating of a1;
  let a3 be Element of NAT;
  let a4 be Element of bool cells(a3 + 1,a2);
  func del A4 -> Element of bool cells(a3,a2) equals
    {b1 where b1 is Element of cells(a3,a2): a3 + 1 <= a1 & card ((star b1) /\ a4) is odd};
end;

:: CHAIN_1:def 13
theorem
for b1 being non empty Element of NAT
for b2 being Grating of b1
for b3 being Element of NAT
for b4 being Element of bool cells(b3 + 1,b2) holds
   del b4 = {b5 where b5 is Element of cells(b3,b2): b3 + 1 <= b1 & card ((star b5) /\ b4) is odd};

:: CHAIN_1:funcnot 13 => CHAIN_1:func 10
notation
  let a1 be non empty Element of NAT;
  let a2 be Grating of a1;
  let a3 be Element of NAT;
  let a4 be Element of bool cells(a3 + 1,a2);
  synonym . a4 for del a4;
end;

:: CHAIN_1:prednot 1 => CHAIN_1:pred 1
definition
  let a1 be non empty Element of NAT;
  let a2 be Grating of a1;
  let a3 be Element of NAT;
  let a4 be Element of bool cells(a3 + 1,a2);
  let a5 be Element of bool cells(a3,a2);
  pred A5 bounds A4 means
    a5 = del a4;
end;

:: CHAIN_1:dfs 14
definiens
  let a1 be non empty Element of NAT;
  let a2 be Grating of a1;
  let a3 be Element of NAT;
  let a4 be Element of bool cells(a3 + 1,a2);
  let a5 be Element of bool cells(a3,a2);
To prove
     a5 bounds a4
it is sufficient to prove
  thus a5 = del a4;

:: CHAIN_1:def 14
theorem
for b1 being non empty Element of NAT
for b2 being Grating of b1
for b3 being Element of NAT
for b4 being Element of bool cells(b3 + 1,b2)
for b5 being Element of bool cells(b3,b2) holds
      b5 bounds b4
   iff
      b5 = del b4;

:: CHAIN_1:th 52
theorem
for b1 being Element of NAT
for b2 being non empty Element of NAT
for b3 being Grating of b2
for b4 being Element of cells(b1,b3)
for b5 being Element of bool cells(b1 + 1,b3) holds
      b4 in del b5
   iff
      b1 + 1 <= b2 & card ((star b4) /\ b5) is odd;

:: CHAIN_1:th 53
theorem
for b1 being Element of NAT
for b2 being non empty Element of NAT
for b3 being Grating of b2
   st b2 < b1 + 1
for b4 being Element of bool cells(b1 + 1,b3) holds
   del b4 = 0_(b1,b3);

:: CHAIN_1:th 54
theorem
for b1 being Element of NAT
for b2 being non empty Element of NAT
for b3 being Grating of b2
   st b1 + 1 <= b2
for b4 being Element of cells(b1,b3)
for b5 being Element of cells(b1 + 1,b3) holds
      b4 in del {b5}
   iff
      b4 c= b5;

:: CHAIN_1:th 55
theorem
for b1 being Element of NAT
for b2 being non empty Element of NAT
for b3 being Grating of b2
   st b2 = b1 + 1
for b4 being Element of cells(b1,b3) holds
   card star b4 = 2;

:: CHAIN_1:th 56
theorem
for b1 being non empty Element of NAT
for b2 being Grating of b1
for b3 being Element of cells(0 + 1,b2) holds
   card del {b3} = 2;

:: CHAIN_1:th 57
theorem
for b1 being non empty Element of NAT
for b2 being Grating of b1 holds
   Omega b2 = (0_(b1,b2)) ` & 0_(b1,b2) = (Omega b2) `;

:: CHAIN_1:th 58
theorem
for b1 being Element of NAT
for b2 being non empty Element of NAT
for b3 being Grating of b2
for b4 being Element of bool cells(b1,b3) holds
   b4 + 0_(b1,b3) = b4;

:: CHAIN_1:th 60
theorem
for b1 being non empty Element of NAT
for b2 being Grating of b1
for b3 being Element of bool cells(b1,b2) holds
   b3 ` = b3 + Omega b2;

:: CHAIN_1:th 61
theorem
for b1 being Element of NAT
for b2 being non empty Element of NAT
for b3 being Grating of b2 holds
   del 0_(b1 + 1,b3) = 0_(b1,b3);

:: CHAIN_1:th 62
theorem
for b1 being Element of NAT
for b2 being Grating of b1 + 1 holds
   del Omega b2 = 0_(b1,b2);

:: CHAIN_1:th 63
theorem
for b1 being Element of NAT
for b2 being non empty Element of NAT
for b3 being Grating of b2
for b4, b5 being Element of bool cells(b1 + 1,b3) holds
del (b4 + b5) = (del b4) + del b5;

:: CHAIN_1:th 64
theorem
for b1 being Element of NAT
for b2 being Grating of b1 + 1
for b3 being Element of bool cells(b1 + 1,b2) holds
   del (b3 `) = del b3;

:: CHAIN_1:th 65
theorem
for b1 being Element of NAT
for b2 being non empty Element of NAT
for b3 being Grating of b2
for b4 being Element of bool cells((b1 + 1) + 1,b3) holds
   del del b4 = 0_(b1,b3);

:: CHAIN_1:modenot 5 => CHAIN_1:mode 3
definition
  let a1 be non empty Element of NAT;
  let a2 be Grating of a1;
  let a3 be Element of NAT;
  mode Cycle of A3,A2 -> Element of bool cells(a3,a2) means
    ((a3 = 0 implies card it is odd)) implies ex b1 being Element of NAT st
       a3 = b1 + 1 &
        (ex b2 being Element of bool cells(b1 + 1,a2) st
           b2 = it & del b2 = 0_(b1,a2));
end;

:: CHAIN_1:dfs 15
definiens
  let a1 be non empty Element of NAT;
  let a2 be Grating of a1;
  let a3 be Element of NAT;
  let a4 be Element of bool cells(a3,a2);
To prove
     a4 is Cycle of a3,a2
it is sufficient to prove
  thus ((a3 = 0 implies card a4 is odd)) implies ex b1 being Element of NAT st
       a3 = b1 + 1 &
        (ex b2 being Element of bool cells(b1 + 1,a2) st
           b2 = a4 & del b2 = 0_(b1,a2));

:: CHAIN_1:def 15
theorem
for b1 being non empty Element of NAT
for b2 being Grating of b1
for b3 being Element of NAT
for b4 being Element of bool cells(b3,b2) holds
      b4 is Cycle of b3,b2
   iff
      ((b3 = 0 implies card b4 is odd) implies ex b5 being Element of NAT st
         b3 = b5 + 1 &
          (ex b6 being Element of bool cells(b5 + 1,b2) st
             b6 = b4 & del b6 = 0_(b5,b2)));

:: CHAIN_1:th 66
theorem
for b1 being Element of NAT
for b2 being non empty Element of NAT
for b3 being Grating of b2
for b4 being Element of bool cells(b1 + 1,b3) holds
      b4 is Cycle of b1 + 1,b3
   iff
      del b4 = 0_(b1,b3);

:: CHAIN_1:th 67
theorem
for b1 being Element of NAT
for b2 being non empty Element of NAT
for b3 being Grating of b2
   st b2 < b1
for b4 being Element of bool cells(b1,b3) holds
   b4 is Cycle of b1,b3;

:: CHAIN_1:th 68
theorem
for b1 being non empty Element of NAT
for b2 being Grating of b1
for b3 being Element of bool cells(0,b2) holds
      b3 is Cycle of 0,b2
   iff
      card b3 is even;

:: CHAIN_1:funcnot 14 => CHAIN_1:func 10
definition
  let a1 be non empty Element of NAT;
  let a2 be Grating of a1;
  let a3 be Element of NAT;
  let a4 be Element of bool cells(a3 + 1,a2);
  func del A4 -> Element of bool cells(a3,a2) equals
    0_(a3,a2);
end;

:: CHAIN_1:def 16
theorem
for b1 being non empty Element of NAT
for b2 being Grating of b1
for b3 being Element of NAT
for b4 being Cycle of b3 + 1,b2 holds
   del b4 = 0_(b3,b2);

:: CHAIN_1:funcnot 15 => CHAIN_1:func 11
definition
  let a1 be non empty Element of NAT;
  let a2 be Grating of a1;
  let a3 be Element of NAT;
  redefine func 0_(a3,a2) -> Cycle of a3,a2;
end;

:: CHAIN_1:funcnot 16 => CHAIN_1:func 12
definition
  let a1 be non empty Element of NAT;
  let a2 be Grating of a1;
  redefine func Omega a2 -> Cycle of a1,a2;
end;

:: CHAIN_1:funcnot 17 => CHAIN_1:func 13
definition
  let a1 be non empty Element of NAT;
  let a2 be Grating of a1;
  let a3 be Element of NAT;
  let a4, a5 be Cycle of a3,a2;
  redefine func a4 + a5 -> Cycle of a3,a2;
  commutativity;
::  for a1 being non empty Element of NAT
::  for a2 being Grating of a1
::  for a3 being Element of NAT
::  for a4, a5 being Cycle of a3,a2 holds
::  a4 + a5 = a5 + a4;
end;

:: CHAIN_1:th 69
theorem
for b1 being non empty Element of NAT
for b2 being Grating of b1
for b3 being Cycle of b1,b2 holds
   b3 ` is Cycle of b1,b2;

:: CHAIN_1:funcnot 18 => CHAIN_1:func 14
definition
  let a1 be non empty Element of NAT;
  let a2 be Grating of a1;
  let a3 be Element of NAT;
  let a4 be Element of bool cells(a3 + 1,a2);
  redefine func del a4 -> Cycle of a3,a2;
end;

:: CHAIN_1:funcnot 19 => CHAIN_1:func 15
definition
  let a1 be non empty Element of NAT;
  let a2 be Grating of a1;
  let a3 be Element of NAT;
  func Chains(A3,A2) -> non empty strict right_complementable Abelian add-associative right_zeroed addLoopStr means
    the carrier of it = bool cells(a3,a2) &
     0. it = 0_(a3,a2) &
     (for b1, b2 being Element of the carrier of it
     for b3, b4 being Element of bool cells(a3,a2)
           st b1 = b3 & b2 = b4
        holds b1 + b2 = b3 + b4);
end;

:: CHAIN_1:def 17
theorem
for b1 being non empty Element of NAT
for b2 being Grating of b1
for b3 being Element of NAT
for b4 being non empty strict right_complementable Abelian add-associative right_zeroed addLoopStr holds
      b4 = Chains(b3,b2)
   iff
      the carrier of b4 = bool cells(b3,b2) &
       0. b4 = 0_(b3,b2) &
       (for b5, b6 being Element of the carrier of b4
       for b7, b8 being Element of bool cells(b3,b2)
             st b5 = b7 & b6 = b8
          holds b5 + b6 = b7 + b8);

:: CHAIN_1:modenot 6
definition
  let a1 be non empty Element of NAT;
  let a2 be Grating of a1;
  let a3 be Element of NAT;
  mode GrChain of a3,a2 is Element of the carrier of Chains(a3,a2);
end;

:: CHAIN_1:th 70
theorem
for b1 being Element of NAT
for b2 being non empty Element of NAT
for b3 being Grating of b2
for b4 being set holds
      b4 is Element of bool cells(b1,b3)
   iff
      b4 is Element of the carrier of Chains(b1,b3);

:: CHAIN_1:funcnot 20 => CHAIN_1:func 16
definition
  let a1 be non empty Element of NAT;
  let a2 be Grating of a1;
  let a3 be Element of NAT;
  func del(A3,A2) -> Homomorphism of Chains(a3 + 1,a2),Chains(a3,a2) means
    for b1 being Element of the carrier of Chains(a3 + 1,a2)
    for b2 being Element of bool cells(a3 + 1,a2)
          st b1 = b2
       holds it . b1 = del b2;
end;

:: CHAIN_1:def 18
theorem
for b1 being non empty Element of NAT
for b2 being Grating of b1
for b3 being Element of NAT
for b4 being Homomorphism of Chains(b3 + 1,b2),Chains(b3,b2) holds
      b4 = del(b3,b2)
   iff
      for b5 being Element of the carrier of Chains(b3 + 1,b2)
      for b6 being Element of bool cells(b3 + 1,b2)
            st b5 = b6
         holds b4 . b5 = del b6;