Article PRELAMB, MML version 4.99.1005

:: PRELAMB:structnot 1 => PRELAMB:struct 1
definition
  struct(1-sorted) typealg(#
    carrier -> set,
    left_quotient -> Function-like quasi_total Relation of [:the carrier of it,the carrier of it:],the carrier of it,
    right_quotient -> Function-like quasi_total Relation of [:the carrier of it,the carrier of it:],the carrier of it,
    inner_product -> Function-like quasi_total Relation of [:the carrier of it,the carrier of it:],the carrier of it
  #);
end;

:: PRELAMB:attrnot 1 => PRELAMB:attr 1
definition
  let a1 be typealg;
  attr a1 is strict;
end;

:: PRELAMB:exreg 1
registration
  cluster strict typealg;
end;

:: PRELAMB:aggrnot 1 => PRELAMB:aggr 1
definition
  let a1 be set;
  let a2, a3, a4 be Function-like quasi_total Relation of [:a1,a1:],a1;
  aggr typealg(#a1,a2,a3,a4#) -> strict typealg;
end;

:: PRELAMB:selnot 1 => PRELAMB:sel 1
definition
  let a1 be typealg;
  sel the left_quotient of a1 -> Function-like quasi_total Relation of [:the carrier of a1,the carrier of a1:],the carrier of a1;
end;

:: PRELAMB:selnot 2 => PRELAMB:sel 2
definition
  let a1 be typealg;
  sel the right_quotient of a1 -> Function-like quasi_total Relation of [:the carrier of a1,the carrier of a1:],the carrier of a1;
end;

:: PRELAMB:selnot 3 => PRELAMB:sel 3
definition
  let a1 be typealg;
  sel the inner_product of a1 -> Function-like quasi_total Relation of [:the carrier of a1,the carrier of a1:],the carrier of a1;
end;

:: PRELAMB:exreg 2
registration
  cluster non empty strict typealg;
end;

:: PRELAMB:modenot 1
definition
  let a1 be non empty typealg;
  mode type of a1 is Element of the carrier of a1;
end;

:: PRELAMB:funcnot 1 => PRELAMB:func 1
definition
  let a1 be non empty typealg;
  let a2, a3 be Element of the carrier of a1;
  func A2 \ A3 -> Element of the carrier of a1 equals
    (the left_quotient of a1) .(a2,a3);
end;

:: PRELAMB:def 1
theorem
for b1 being non empty typealg
for b2, b3 being Element of the carrier of b1 holds
b2 \ b3 = (the left_quotient of b1) .(b2,b3);

:: PRELAMB:funcnot 2 => PRELAMB:func 2
definition
  let a1 be non empty typealg;
  let a2, a3 be Element of the carrier of a1;
  func A2 /" A3 -> Element of the carrier of a1 equals
    (the right_quotient of a1) .(a2,a3);
end;

:: PRELAMB:def 2
theorem
for b1 being non empty typealg
for b2, b3 being Element of the carrier of b1 holds
b2 /" b3 = (the right_quotient of b1) .(b2,b3);

:: PRELAMB:funcnot 3 => PRELAMB:func 3
definition
  let a1 be non empty typealg;
  let a2, a3 be Element of the carrier of a1;
  func A2 * A3 -> Element of the carrier of a1 equals
    (the inner_product of a1) .(a2,a3);
end;

:: PRELAMB:def 3
theorem
for b1 being non empty typealg
for b2, b3 being Element of the carrier of b1 holds
b2 * b3 = (the inner_product of b1) .(b2,b3);

:: PRELAMB:modenot 2
definition
  let a1 be non empty typealg;
  mode PreProof of a1 is Function-like finite DecoratedTree-like ParametrizedSubset of [:[:(the carrier of a1) *,the carrier of a1:],NAT:];
end;

:: PRELAMB:attrnot 2 => PRELAMB:attr 2
definition
  let a1 be non empty typealg;
  let a2 be Function-like finite DecoratedTree-like ParametrizedSubset of [:[:(the carrier of a1) *,the carrier of a1:],NAT:];
  let a3 be Element of proj1 a2;
  attr a3 is correct means
    branchdeg a3 = 0 &
     (ex b1 being Element of the carrier of a1 st
        (a2 . a3) `1 = [<*b1*>,b1])
    if (a2 . a3) `2 = 0,
branchdeg a3 = 1 &
     (ex b1 being FinSequence of the carrier of a1 st
        ex b2, b3 being Element of the carrier of a1 st
           (a2 . a3) `1 = [b1,b2 /" b3] &
            (a2 . (a3 ^ <*0*>)) `1 = [b1 ^ <*b3*>,b2])
    if (a2 . a3) `2 = 1,
branchdeg a3 = 1 &
     (ex b1 being FinSequence of the carrier of a1 st
        ex b2, b3 being Element of the carrier of a1 st
           (a2 . a3) `1 = [b1,b3 \ b2] &
            (a2 . (a3 ^ <*0*>)) `1 = [<*b3*> ^ b1,b2])
    if (a2 . a3) `2 = 2,
branchdeg a3 = 2 &
     (ex b1, b2, b3 being FinSequence of the carrier of a1 st
        ex b4, b5, b6 being Element of the carrier of a1 st
           (a2 . a3) `1 = [((b2 ^ <*b4 /" b5*>) ^ b1) ^ b3,b6] &
            (a2 . (a3 ^ <*0*>)) `1 = [b1,b5] &
            (a2 . (a3 ^ <*1*>)) `1 = [(b2 ^ <*b4*>) ^ b3,b6])
    if (a2 . a3) `2 = 3,
branchdeg a3 = 2 &
     (ex b1, b2, b3 being FinSequence of the carrier of a1 st
        ex b4, b5, b6 being Element of the carrier of a1 st
           (a2 . a3) `1 = [((b2 ^ b1) ^ <*b5 \ b4*>) ^ b3,b6] &
            (a2 . (a3 ^ <*0*>)) `1 = [b1,b5] &
            (a2 . (a3 ^ <*1*>)) `1 = [(b2 ^ <*b4*>) ^ b3,b6])
    if (a2 . a3) `2 = 4,
for b1 being Element of the carrier of a1 holds
       branchdeg a3 = 1 &
        (ex b2 being FinSequence of the carrier of a1 st
           ex b3, b4 being Element of the carrier of a1 st
              ex b5 being FinSequence of the carrier of a1 st
                 (a2 . a3) `1 = [(b2 ^ <*b3 * b4*>) ^ b5,b1] &
                  (a2 . (a3 ^ <*0*>)) `1 = [((b2 ^ <*b3*>) ^ <*b4*>) ^ b5,b1])
    if (a2 . a3) `2 = 5,
branchdeg a3 = 2 &
     (ex b1, b2 being FinSequence of the carrier of a1 st
        ex b3, b4 being Element of the carrier of a1 st
           (a2 . a3) `1 = [b1 ^ b2,b3 * b4] &
            (a2 . (a3 ^ <*0*>)) `1 = [b1,b3] &
            (a2 . (a3 ^ <*1*>)) `1 = [b2,b4])
    if (a2 . a3) `2 = 6,
branchdeg a3 = 2 &
     (ex b1, b2, b3 being FinSequence of the carrier of a1 st
        ex b4, b5 being Element of the carrier of a1 st
           (a2 . a3) `1 = [(b2 ^ b1) ^ b3,b5] &
            (a2 . (a3 ^ <*0*>)) `1 = [b1,b4] &
            (a2 . (a3 ^ <*1*>)) `1 = [(b2 ^ <*b4*>) ^ b3,b5])
    if (a2 . a3) `2 = 7
    otherwise contradiction;
end;

:: PRELAMB:dfs 4
definiens
  let a1 be non empty typealg;
  let a2 be Function-like finite DecoratedTree-like ParametrizedSubset of [:[:(the carrier of a1) *,the carrier of a1:],NAT:];
  let a3 be Element of proj1 a2;
To prove
     a3 is correct
it is sufficient to prove
  per cases;
  case (a2 . a3) `2 = 0;
    thus branchdeg a3 = 0 &
     (ex b1 being Element of the carrier of a1 st
        (a2 . a3) `1 = [<*b1*>,b1]);
  end;
  case (a2 . a3) `2 = 1;
    thus branchdeg a3 = 1 &
     (ex b1 being FinSequence of the carrier of a1 st
        ex b2, b3 being Element of the carrier of a1 st
           (a2 . a3) `1 = [b1,b2 /" b3] &
            (a2 . (a3 ^ <*0*>)) `1 = [b1 ^ <*b3*>,b2]);
  end;
  case (a2 . a3) `2 = 2;
    thus branchdeg a3 = 1 &
     (ex b1 being FinSequence of the carrier of a1 st
        ex b2, b3 being Element of the carrier of a1 st
           (a2 . a3) `1 = [b1,b3 \ b2] &
            (a2 . (a3 ^ <*0*>)) `1 = [<*b3*> ^ b1,b2]);
  end;
  case (a2 . a3) `2 = 3;
    thus branchdeg a3 = 2 &
     (ex b1, b2, b3 being FinSequence of the carrier of a1 st
        ex b4, b5, b6 being Element of the carrier of a1 st
           (a2 . a3) `1 = [((b2 ^ <*b4 /" b5*>) ^ b1) ^ b3,b6] &
            (a2 . (a3 ^ <*0*>)) `1 = [b1,b5] &
            (a2 . (a3 ^ <*1*>)) `1 = [(b2 ^ <*b4*>) ^ b3,b6]);
  end;
  case (a2 . a3) `2 = 4;
    thus branchdeg a3 = 2 &
     (ex b1, b2, b3 being FinSequence of the carrier of a1 st
        ex b4, b5, b6 being Element of the carrier of a1 st
           (a2 . a3) `1 = [((b2 ^ b1) ^ <*b5 \ b4*>) ^ b3,b6] &
            (a2 . (a3 ^ <*0*>)) `1 = [b1,b5] &
            (a2 . (a3 ^ <*1*>)) `1 = [(b2 ^ <*b4*>) ^ b3,b6]);
  end;
  case (a2 . a3) `2 = 5;
    thus for b1 being Element of the carrier of a1 holds
       branchdeg a3 = 1 &
        (ex b2 being FinSequence of the carrier of a1 st
           ex b3, b4 being Element of the carrier of a1 st
              ex b5 being FinSequence of the carrier of a1 st
                 (a2 . a3) `1 = [(b2 ^ <*b3 * b4*>) ^ b5,b1] &
                  (a2 . (a3 ^ <*0*>)) `1 = [((b2 ^ <*b3*>) ^ <*b4*>) ^ b5,b1]);
  end;
  case (a2 . a3) `2 = 6;
    thus branchdeg a3 = 2 &
     (ex b1, b2 being FinSequence of the carrier of a1 st
        ex b3, b4 being Element of the carrier of a1 st
           (a2 . a3) `1 = [b1 ^ b2,b3 * b4] &
            (a2 . (a3 ^ <*0*>)) `1 = [b1,b3] &
            (a2 . (a3 ^ <*1*>)) `1 = [b2,b4]);
  end;
  case (a2 . a3) `2 = 7;
    thus branchdeg a3 = 2 &
     (ex b1, b2, b3 being FinSequence of the carrier of a1 st
        ex b4, b5 being Element of the carrier of a1 st
           (a2 . a3) `1 = [(b2 ^ b1) ^ b3,b5] &
            (a2 . (a3 ^ <*0*>)) `1 = [b1,b4] &
            (a2 . (a3 ^ <*1*>)) `1 = [(b2 ^ <*b4*>) ^ b3,b5]);
  end;
  case (a2 . a3) `2 <> 0 & (a2 . a3) `2 <> 1 & (a2 . a3) `2 <> 2 & (a2 . a3) `2 <> 3 & (a2 . a3) `2 <> 4 & (a2 . a3) `2 <> 5 & (a2 . a3) `2 <> 6 & (a2 . a3) `2 <> 7;
    thus contradiction;
  end;

:: PRELAMB:def 5
theorem
for b1 being non empty typealg
for b2 being Function-like finite DecoratedTree-like ParametrizedSubset of [:[:(the carrier of b1) *,the carrier of b1:],NAT:]
for b3 being Element of proj1 b2 holds
   ((b2 . b3) `2 = 0 implies    (b3 is correct(b1, b2)
    iff
       branchdeg b3 = 0 &
        (ex b4 being Element of the carrier of b1 st
           (b2 . b3) `1 = [<*b4*>,b4]))) &
    ((b2 . b3) `2 = 1 implies    (b3 is correct(b1, b2)
    iff
       branchdeg b3 = 1 &
        (ex b4 being FinSequence of the carrier of b1 st
           ex b5, b6 being Element of the carrier of b1 st
              (b2 . b3) `1 = [b4,b5 /" b6] &
               (b2 . (b3 ^ <*0*>)) `1 = [b4 ^ <*b6*>,b5]))) &
    ((b2 . b3) `2 = 2 implies    (b3 is correct(b1, b2)
    iff
       branchdeg b3 = 1 &
        (ex b4 being FinSequence of the carrier of b1 st
           ex b5, b6 being Element of the carrier of b1 st
              (b2 . b3) `1 = [b4,b6 \ b5] &
               (b2 . (b3 ^ <*0*>)) `1 = [<*b6*> ^ b4,b5]))) &
    ((b2 . b3) `2 = 3 implies    (b3 is correct(b1, b2)
    iff
       branchdeg b3 = 2 &
        (ex b4, b5, b6 being FinSequence of the carrier of b1 st
           ex b7, b8, b9 being Element of the carrier of b1 st
              (b2 . b3) `1 = [((b5 ^ <*b7 /" b8*>) ^ b4) ^ b6,b9] &
               (b2 . (b3 ^ <*0*>)) `1 = [b4,b8] &
               (b2 . (b3 ^ <*1*>)) `1 = [(b5 ^ <*b7*>) ^ b6,b9]))) &
    ((b2 . b3) `2 = 4 implies    (b3 is correct(b1, b2)
    iff
       branchdeg b3 = 2 &
        (ex b4, b5, b6 being FinSequence of the carrier of b1 st
           ex b7, b8, b9 being Element of the carrier of b1 st
              (b2 . b3) `1 = [((b5 ^ b4) ^ <*b8 \ b7*>) ^ b6,b9] &
               (b2 . (b3 ^ <*0*>)) `1 = [b4,b8] &
               (b2 . (b3 ^ <*1*>)) `1 = [(b5 ^ <*b7*>) ^ b6,b9]))) &
    ((b2 . b3) `2 = 5 implies    (b3 is correct(b1, b2)
    iff
       for b4 being Element of the carrier of b1 holds
          branchdeg b3 = 1 &
           (ex b5 being FinSequence of the carrier of b1 st
              ex b6, b7 being Element of the carrier of b1 st
                 ex b8 being FinSequence of the carrier of b1 st
                    (b2 . b3) `1 = [(b5 ^ <*b6 * b7*>) ^ b8,b4] &
                     (b2 . (b3 ^ <*0*>)) `1 = [((b5 ^ <*b6*>) ^ <*b7*>) ^ b8,b4]))) &
    ((b2 . b3) `2 = 6 implies    (b3 is correct(b1, b2)
    iff
       branchdeg b3 = 2 &
        (ex b4, b5 being FinSequence of the carrier of b1 st
           ex b6, b7 being Element of the carrier of b1 st
              (b2 . b3) `1 = [b4 ^ b5,b6 * b7] &
               (b2 . (b3 ^ <*0*>)) `1 = [b4,b6] &
               (b2 . (b3 ^ <*1*>)) `1 = [b5,b7]))) &
    ((b2 . b3) `2 = 7 implies    (b3 is correct(b1, b2)
    iff
       branchdeg b3 = 2 &
        (ex b4, b5, b6 being FinSequence of the carrier of b1 st
           ex b7, b8 being Element of the carrier of b1 st
              (b2 . b3) `1 = [(b5 ^ b4) ^ b6,b8] &
               (b2 . (b3 ^ <*0*>)) `1 = [b4,b7] &
               (b2 . (b3 ^ <*1*>)) `1 = [(b5 ^ <*b7*>) ^ b6,b8]))) &
    ((b2 . b3) `2 <> 0 & (b2 . b3) `2 <> 1 & (b2 . b3) `2 <> 2 & (b2 . b3) `2 <> 3 & (b2 . b3) `2 <> 4 & (b2 . b3) `2 <> 5 & (b2 . b3) `2 <> 6 & (b2 . b3) `2 <> 7 implies b3 is not correct(b1, b2) & (TRUE or b3 is correct(b1, b2)));

:: PRELAMB:attrnot 3 => PRELAMB:attr 3
definition
  let a1 be non empty typealg;
  let a2 be Element of the carrier of a1;
  attr a2 is left means
    ex b1, b2 being Element of the carrier of a1 st
       a2 = b1 \ b2;
end;

:: PRELAMB:dfs 5
definiens
  let a1 be non empty typealg;
  let a2 be Element of the carrier of a1;
To prove
     a2 is left
it is sufficient to prove
  thus ex b1, b2 being Element of the carrier of a1 st
       a2 = b1 \ b2;

:: PRELAMB:def 6
theorem
for b1 being non empty typealg
for b2 being Element of the carrier of b1 holds
      b2 is left(b1)
   iff
      ex b3, b4 being Element of the carrier of b1 st
         b2 = b3 \ b4;

:: PRELAMB:attrnot 4 => PRELAMB:attr 4
definition
  let a1 be non empty typealg;
  let a2 be Element of the carrier of a1;
  attr a2 is right means
    ex b1, b2 being Element of the carrier of a1 st
       a2 = b1 /" b2;
end;

:: PRELAMB:dfs 6
definiens
  let a1 be non empty typealg;
  let a2 be Element of the carrier of a1;
To prove
     a2 is right
it is sufficient to prove
  thus ex b1, b2 being Element of the carrier of a1 st
       a2 = b1 /" b2;

:: PRELAMB:def 7
theorem
for b1 being non empty typealg
for b2 being Element of the carrier of b1 holds
      b2 is right(b1)
   iff
      ex b3, b4 being Element of the carrier of b1 st
         b2 = b3 /" b4;

:: PRELAMB:attrnot 5 => PRELAMB:attr 5
definition
  let a1 be non empty typealg;
  let a2 be Element of the carrier of a1;
  attr a2 is middle means
    ex b1, b2 being Element of the carrier of a1 st
       a2 = b1 * b2;
end;

:: PRELAMB:dfs 7
definiens
  let a1 be non empty typealg;
  let a2 be Element of the carrier of a1;
To prove
     a2 is middle
it is sufficient to prove
  thus ex b1, b2 being Element of the carrier of a1 st
       a2 = b1 * b2;

:: PRELAMB:def 8
theorem
for b1 being non empty typealg
for b2 being Element of the carrier of b1 holds
      b2 is middle(b1)
   iff
      ex b3, b4 being Element of the carrier of b1 st
         b2 = b3 * b4;

:: PRELAMB:attrnot 6 => PRELAMB:attr 6
definition
  let a1 be non empty typealg;
  let a2 be Element of the carrier of a1;
  attr a2 is primitive means
    a2 is not left(a1) & a2 is not right(a1) & a2 is not middle(a1);
end;

:: PRELAMB:dfs 8
definiens
  let a1 be non empty typealg;
  let a2 be Element of the carrier of a1;
To prove
     a2 is primitive
it is sufficient to prove
  thus a2 is not left(a1) & a2 is not right(a1) & a2 is not middle(a1);

:: PRELAMB:def 9
theorem
for b1 being non empty typealg
for b2 being Element of the carrier of b1 holds
      b2 is primitive(b1)
   iff
      b2 is not left(b1) & b2 is not right(b1) & b2 is not middle(b1);

:: PRELAMB:funcnot 4 => PRELAMB:func 4
definition
  let a1 be non empty typealg;
  let a2 be Function-like finite DecoratedTree-like ParametrizedSubset of the carrier of a1;
  let a3 be Element of proj1 a2;
  redefine func a2 . a3 -> Element of the carrier of a1;
end;

:: PRELAMB:prednot 1 => PRELAMB:pred 1
definition
  let a1 be non empty typealg;
  let a2 be Function-like finite DecoratedTree-like ParametrizedSubset of the carrier of a1;
  let a3 be Element of the carrier of a1;
  pred A2 represents A3 means
    proj1 a2 is finite &
     (for b1 being Element of proj1 a2 holds
        (branchdeg b1 = 0 or branchdeg b1 = 2) &
         (branchdeg b1 = 0 implies a2 . b1 is primitive(a1)) &
         (branchdeg b1 = 2 implies ex b2, b3 being Element of the carrier of a1 st
            (a2 . b1 <> b2 /" b3 & a2 . b1 <> b2 \ b3 implies a2 . b1 = b2 * b3) &
             a2 . (b1 ^ <*0*>) = b2 &
             a2 . (b1 ^ <*1*>) = b3));
end;

:: PRELAMB:dfs 9
definiens
  let a1 be non empty typealg;
  let a2 be Function-like finite DecoratedTree-like ParametrizedSubset of the carrier of a1;
  let a3 be Element of the carrier of a1;
To prove
     a2 represents a3
it is sufficient to prove
  thus proj1 a2 is finite &
     (for b1 being Element of proj1 a2 holds
        (branchdeg b1 = 0 or branchdeg b1 = 2) &
         (branchdeg b1 = 0 implies a2 . b1 is primitive(a1)) &
         (branchdeg b1 = 2 implies ex b2, b3 being Element of the carrier of a1 st
            (a2 . b1 <> b2 /" b3 & a2 . b1 <> b2 \ b3 implies a2 . b1 = b2 * b3) &
             a2 . (b1 ^ <*0*>) = b2 &
             a2 . (b1 ^ <*1*>) = b3));

:: PRELAMB:def 10
theorem
for b1 being non empty typealg
for b2 being Function-like finite DecoratedTree-like ParametrizedSubset of the carrier of b1
for b3 being Element of the carrier of b1 holds
      b2 represents b3
   iff
      proj1 b2 is finite &
       (for b4 being Element of proj1 b2 holds
          (branchdeg b4 = 0 or branchdeg b4 = 2) &
           (branchdeg b4 = 0 implies b2 . b4 is primitive(b1)) &
           (branchdeg b4 = 2 implies ex b5, b6 being Element of the carrier of b1 st
              (b2 . b4 <> b5 /" b6 & b2 . b4 <> b5 \ b6 implies b2 . b4 = b5 * b6) &
               b2 . (b4 ^ <*0*>) = b5 &
               b2 . (b4 ^ <*1*>) = b6));

:: PRELAMB:prednot 2 => not PRELAMB:pred 1
notation
  let a1 be non empty typealg;
  let a2 be Function-like finite DecoratedTree-like ParametrizedSubset of the carrier of a1;
  let a3 be Element of the carrier of a1;
  antonym a2 does_not_represent a3 for a2 represents a3;
end;

:: PRELAMB:attrnot 7 => PRELAMB:attr 7
definition
  let a1 be non empty typealg;
  attr a1 is free means
    (for b1 being Element of the carrier of a1 holds
        (b1 is left(a1) implies b1 is not right(a1)) & (b1 is left(a1) implies b1 is not middle(a1)) & (b1 is right(a1) implies b1 is not middle(a1))) &
     (for b1 being Element of the carrier of a1 holds
        ex b2 being Function-like finite DecoratedTree-like ParametrizedSubset of the carrier of a1 st
           for b3 being Function-like finite DecoratedTree-like ParametrizedSubset of the carrier of a1 holds
                 b3 represents b1
              iff
                 b2 = b3);
end;

:: PRELAMB:dfs 10
definiens
  let a1 be non empty typealg;
To prove
     a1 is free
it is sufficient to prove
  thus (for b1 being Element of the carrier of a1 holds
        (b1 is left(a1) implies b1 is not right(a1)) & (b1 is left(a1) implies b1 is not middle(a1)) & (b1 is right(a1) implies b1 is not middle(a1))) &
     (for b1 being Element of the carrier of a1 holds
        ex b2 being Function-like finite DecoratedTree-like ParametrizedSubset of the carrier of a1 st
           for b3 being Function-like finite DecoratedTree-like ParametrizedSubset of the carrier of a1 holds
                 b3 represents b1
              iff
                 b2 = b3);

:: PRELAMB:def 11
theorem
for b1 being non empty typealg holds
      b1 is free
   iff
      (for b2 being Element of the carrier of b1 holds
          (b2 is left(b1) implies b2 is not right(b1)) & (b2 is left(b1) implies b2 is not middle(b1)) & (b2 is right(b1) implies b2 is not middle(b1))) &
       (for b2 being Element of the carrier of b1 holds
          ex b3 being Function-like finite DecoratedTree-like ParametrizedSubset of the carrier of b1 st
             for b4 being Function-like finite DecoratedTree-like ParametrizedSubset of the carrier of b1 holds
                   b4 represents b2
                iff
                   b3 = b4);

:: PRELAMB:funcnot 5 => PRELAMB:func 5
definition
  let a1 be non empty typealg;
  let a2 be Element of the carrier of a1;
  assume a1 is free;
  func repr_of A2 -> Function-like finite DecoratedTree-like ParametrizedSubset of the carrier of a1 means
    for b1 being Function-like finite DecoratedTree-like ParametrizedSubset of the carrier of a1 holds
          b1 represents a2
       iff
          it = b1;
end;

:: PRELAMB:def 12
theorem
for b1 being non empty typealg
for b2 being Element of the carrier of b1
   st b1 is free
for b3 being Function-like finite DecoratedTree-like ParametrizedSubset of the carrier of b1 holds
      b3 = repr_of b2
   iff
      for b4 being Function-like finite DecoratedTree-like ParametrizedSubset of the carrier of b1 holds
            b4 represents b2
         iff
            b3 = b4;

:: PRELAMB:funcnot 6 => PRELAMB:func 6
definition
  let a1 be non empty typealg;
  let a2 be FinSequence of the carrier of a1;
  let a3 be Element of the carrier of a1;
  redefine func [a2, a3] -> Element of [:(the carrier of a1) *,the carrier of a1:];
end;

:: PRELAMB:modenot 3 => PRELAMB:mode 1
definition
  let a1 be non empty typealg;
  mode Proof of A1 -> Function-like finite DecoratedTree-like ParametrizedSubset of [:[:(the carrier of a1) *,the carrier of a1:],NAT:] means
    proj1 it is finite &
     (for b1 being Element of proj1 it holds
        b1 is correct(a1, it));
end;

:: PRELAMB:dfs 12
definiens
  let a1 be non empty typealg;
  let a2 be Function-like finite DecoratedTree-like ParametrizedSubset of [:[:(the carrier of a1) *,the carrier of a1:],NAT:];
To prove
     a2 is Proof of a1
it is sufficient to prove
  thus proj1 a2 is finite &
     (for b1 being Element of proj1 a2 holds
        b1 is correct(a1, a2));

:: PRELAMB:def 13
theorem
for b1 being non empty typealg
for b2 being Function-like finite DecoratedTree-like ParametrizedSubset of [:[:(the carrier of b1) *,the carrier of b1:],NAT:] holds
      b2 is Proof of b1
   iff
      proj1 b2 is finite &
       (for b3 being Element of proj1 b2 holds
          b3 is correct(b1, b2));

:: PRELAMB:th 1
theorem
for b1 being non empty typealg
for b2 being Proof of b1
for b3 being Element of proj1 b2
      st branchdeg b3 = 1
   holds b3 ^ <*0*> in proj1 b2;

:: PRELAMB:th 2
theorem
for b1 being non empty typealg
for b2 being Proof of b1
for b3 being Element of proj1 b2
      st branchdeg b3 = 2
   holds b3 ^ <*0*> in proj1 b2 &
    b3 ^ <*1*> in proj1 b2;

:: PRELAMB:th 3
theorem
for b1 being non empty typealg
for b2 being Proof of b1
for b3 being Element of proj1 b2
      st (b2 . b3) `2 = 0
   holds ex b4 being Element of the carrier of b1 st
      (b2 . b3) `1 = [<*b4*>,b4];

:: PRELAMB:th 4
theorem
for b1 being non empty typealg
for b2 being Proof of b1
for b3 being Element of proj1 b2
      st (b2 . b3) `2 = 1
   holds ex b4 being Element of proj1 b2 st
      ex b5 being FinSequence of the carrier of b1 st
         ex b6, b7 being Element of the carrier of b1 st
            b4 = b3 ^ <*0*> &
             (b2 . b3) `1 = [b5,b6 /" b7] &
             (b2 . b4) `1 = [b5 ^ <*b7*>,b6];

:: PRELAMB:th 5
theorem
for b1 being non empty typealg
for b2 being Proof of b1
for b3 being Element of proj1 b2
      st (b2 . b3) `2 = 2
   holds ex b4 being Element of proj1 b2 st
      ex b5 being FinSequence of the carrier of b1 st
         ex b6, b7 being Element of the carrier of b1 st
            b4 = b3 ^ <*0*> &
             (b2 . b3) `1 = [b5,b7 \ b6] &
             (b2 . b4) `1 = [<*b7*> ^ b5,b6];

:: PRELAMB:th 6
theorem
for b1 being non empty typealg
for b2 being Proof of b1
for b3 being Element of proj1 b2
      st (b2 . b3) `2 = 3
   holds ex b4, b5 being Element of proj1 b2 st
      ex b6, b7, b8 being FinSequence of the carrier of b1 st
         ex b9, b10, b11 being Element of the carrier of b1 st
            b4 = b3 ^ <*0*> &
             b5 = b3 ^ <*1*> &
             (b2 . b3) `1 = [((b7 ^ <*b9 /" b10*>) ^ b6) ^ b8,b11] &
             (b2 . b4) `1 = [b6,b10] &
             (b2 . b5) `1 = [(b7 ^ <*b9*>) ^ b8,b11];

:: PRELAMB:th 7
theorem
for b1 being non empty typealg
for b2 being Proof of b1
for b3 being Element of proj1 b2
      st (b2 . b3) `2 = 4
   holds ex b4, b5 being Element of proj1 b2 st
      ex b6, b7, b8 being FinSequence of the carrier of b1 st
         ex b9, b10, b11 being Element of the carrier of b1 st
            b4 = b3 ^ <*0*> &
             b5 = b3 ^ <*1*> &
             (b2 . b3) `1 = [((b7 ^ b6) ^ <*b10 \ b9*>) ^ b8,b11] &
             (b2 . b4) `1 = [b6,b10] &
             (b2 . b5) `1 = [(b7 ^ <*b9*>) ^ b8,b11];

:: PRELAMB:th 8
theorem
for b1 being non empty typealg
for b2 being Element of the carrier of b1
for b3 being Proof of b1
for b4 being Element of proj1 b3
      st (b3 . b4) `2 = 5
   holds ex b5 being Element of proj1 b3 st
      ex b6 being FinSequence of the carrier of b1 st
         ex b7, b8 being Element of the carrier of b1 st
            ex b9 being FinSequence of the carrier of b1 st
               b5 = b4 ^ <*0*> &
                (b3 . b4) `1 = [(b6 ^ <*b7 * b8*>) ^ b9,b2] &
                (b3 . b5) `1 = [((b6 ^ <*b7*>) ^ <*b8*>) ^ b9,b2];

:: PRELAMB:th 9
theorem
for b1 being non empty typealg
for b2 being Proof of b1
for b3 being Element of proj1 b2
      st (b2 . b3) `2 = 6
   holds ex b4, b5 being Element of proj1 b2 st
      ex b6, b7 being FinSequence of the carrier of b1 st
         ex b8, b9 being Element of the carrier of b1 st
            b4 = b3 ^ <*0*> &
             b5 = b3 ^ <*1*> &
             (b2 . b3) `1 = [b6 ^ b7,b8 * b9] &
             (b2 . b4) `1 = [b6,b8] &
             (b2 . b5) `1 = [b7,b9];

:: PRELAMB:th 10
theorem
for b1 being non empty typealg
for b2 being Proof of b1
for b3 being Element of proj1 b2
      st (b2 . b3) `2 = 7
   holds ex b4, b5 being Element of proj1 b2 st
      ex b6, b7, b8 being FinSequence of the carrier of b1 st
         ex b9, b10 being Element of the carrier of b1 st
            b4 = b3 ^ <*0*> &
             b5 = b3 ^ <*1*> &
             (b2 . b3) `1 = [(b7 ^ b6) ^ b8,b10] &
             (b2 . b4) `1 = [b6,b9] &
             (b2 . b5) `1 = [(b7 ^ <*b9*>) ^ b8,b10];

:: PRELAMB:th 11
theorem
for b1 being non empty typealg
for b2 being Proof of b1
for b3 being Element of proj1 b2
      st (b2 . b3) `2 <> 0 & (b2 . b3) `2 <> 1 & (b2 . b3) `2 <> 2 & (b2 . b3) `2 <> 3 & (b2 . b3) `2 <> 4 & (b2 . b3) `2 <> 5 & (b2 . b3) `2 <> 6
   holds (b2 . b3) `2 = 7;

:: PRELAMB:attrnot 8 => PRELAMB:attr 8
definition
  let a1 be non empty typealg;
  let a2 be Function-like finite DecoratedTree-like ParametrizedSubset of [:[:(the carrier of a1) *,the carrier of a1:],NAT:];
  attr a2 is cut-free means
    for b1 being Element of proj1 a2 holds
       (a2 . b1) `2 <> 7;
end;

:: PRELAMB:dfs 13
definiens
  let a1 be non empty typealg;
  let a2 be Function-like finite DecoratedTree-like ParametrizedSubset of [:[:(the carrier of a1) *,the carrier of a1:],NAT:];
To prove
     a2 is cut-free
it is sufficient to prove
  thus for b1 being Element of proj1 a2 holds
       (a2 . b1) `2 <> 7;

:: PRELAMB:def 14
theorem
for b1 being non empty typealg
for b2 being Function-like finite DecoratedTree-like ParametrizedSubset of [:[:(the carrier of b1) *,the carrier of b1:],NAT:] holds
      b2 is cut-free(b1)
   iff
      for b3 being Element of proj1 b2 holds
         (b2 . b3) `2 <> 7;

:: PRELAMB:funcnot 7 => PRELAMB:func 7
definition
  let a1 be non empty typealg;
  func size_w.r.t. A1 -> Function-like quasi_total Relation of the carrier of a1,NAT means
    for b1 being Element of the carrier of a1 holds
       it . b1 = card proj1 repr_of b1;
end;

:: PRELAMB:def 15
theorem
for b1 being non empty typealg
for b2 being Function-like quasi_total Relation of the carrier of b1,NAT holds
      b2 = size_w.r.t. b1
   iff
      for b3 being Element of the carrier of b1 holds
         b2 . b3 = card proj1 repr_of b3;

:: PRELAMB:funcnot 8 => PRELAMB:func 8
definition
  let a1 be non empty set;
  let a2 be FinSequence of a1;
  let a3 be Function-like quasi_total Relation of a1,NAT;
  redefine func a3 * a2 -> FinSequence of REAL;
end;

:: PRELAMB:funcnot 9 => PRELAMB:func 9
definition
  let a1 be non empty typealg;
  let a2 be Proof of a1;
  func cutdeg A2 -> natural set means
    ex b1, b2, b3 being FinSequence of the carrier of a1 st
       ex b4, b5 being Element of the carrier of a1 st
          (a2 . {}) `1 = [(b2 ^ b1) ^ b3,b5] &
           (a2 . <*0*>) `1 = [b1,b4] &
           (a2 . <*1*>) `1 = [(b2 ^ <*b4*>) ^ b3,b5] &
           it = (((size_w.r.t. a1) . b4) + ((size_w.r.t. a1) . b5)) + Sum ((size_w.r.t. a1) * ((b2 ^ b1) ^ b3))
    if (a2 . {}) `2 = 7
    otherwise it = 0;
end;

:: PRELAMB:def 16
theorem
for b1 being non empty typealg
for b2 being Proof of b1
for b3 being natural set holds
   ((b2 . {}) `2 = 7 implies    (b3 = cutdeg b2
    iff
       ex b4, b5, b6 being FinSequence of the carrier of b1 st
          ex b7, b8 being Element of the carrier of b1 st
             (b2 . {}) `1 = [(b5 ^ b4) ^ b6,b8] &
              (b2 . <*0*>) `1 = [b4,b7] &
              (b2 . <*1*>) `1 = [(b5 ^ <*b7*>) ^ b6,b8] &
              b3 = (((size_w.r.t. b1) . b7) + ((size_w.r.t. b1) . b8)) + Sum ((size_w.r.t. b1) * ((b5 ^ b4) ^ b6)))) &
    ((b2 . {}) `2 = 7 or    (b3 = cutdeg b2
    iff
       b3 = 0));

:: PRELAMB:modenot 4 => PRELAMB:mode 2
definition
  let a1 be non empty typealg;
  let a2 be non empty set;
  mode Model of A1,A2 -> Function-like quasi_total Relation of the carrier of a1,bool (a2 *) means
    for b1, b2 being Element of the carrier of a1 holds
    it . (b1 * b2) = {b3 ^ b4 where b3 is Element of a2 *, b4 is Element of a2 *: b3 in it . b1 & b4 in it . b2} &
     it . (b1 /" b2) = {b3 where b3 is Element of a2 *: for b4 being Element of a2 *
           st b4 in it . b2
        holds b3 ^ b4 in it . b1} &
     it . (b2 \ b1) = {b3 where b3 is Element of a2 *: for b4 being Element of a2 *
           st b4 in it . b2
        holds b4 ^ b3 in it . b1};
end;

:: PRELAMB:dfs 16
definiens
  let a1 be non empty typealg;
  let a2 be non empty set;
  let a3 be Function-like quasi_total Relation of the carrier of a1,bool (a2 *);
To prove
     a3 is Model of a1,a2
it is sufficient to prove
  thus for b1, b2 being Element of the carrier of a1 holds
    a3 . (b1 * b2) = {b3 ^ b4 where b3 is Element of a2 *, b4 is Element of a2 *: b3 in a3 . b1 & b4 in a3 . b2} &
     a3 . (b1 /" b2) = {b3 where b3 is Element of a2 *: for b4 being Element of a2 *
           st b4 in a3 . b2
        holds b3 ^ b4 in a3 . b1} &
     a3 . (b2 \ b1) = {b3 where b3 is Element of a2 *: for b4 being Element of a2 *
           st b4 in a3 . b2
        holds b4 ^ b3 in a3 . b1};

:: PRELAMB:def 17
theorem
for b1 being non empty typealg
for b2 being non empty set
for b3 being Function-like quasi_total Relation of the carrier of b1,bool (b2 *) holds
      b3 is Model of b1,b2
   iff
      for b4, b5 being Element of the carrier of b1 holds
      b3 . (b4 * b5) = {b6 ^ b7 where b6 is Element of b2 *, b7 is Element of b2 *: b6 in b3 . b4 & b7 in b3 . b5} &
       b3 . (b4 /" b5) = {b6 where b6 is Element of b2 *: for b7 being Element of b2 *
             st b7 in b3 . b5
          holds b6 ^ b7 in b3 . b4} &
       b3 . (b5 \ b4) = {b6 where b6 is Element of b2 *: for b7 being Element of b2 *
             st b7 in b3 . b5
          holds b7 ^ b6 in b3 . b4};

:: PRELAMB:structnot 2 => PRELAMB:struct 2
definition
  struct(typealg) typestr(#
    carrier -> set,
    left_quotient -> Function-like quasi_total Relation of [:the carrier of it,the carrier of it:],the carrier of it,
    right_quotient -> Function-like quasi_total Relation of [:the carrier of it,the carrier of it:],the carrier of it,
    inner_product -> Function-like quasi_total Relation of [:the carrier of it,the carrier of it:],the carrier of it,
    derivability -> Relation of (the carrier of it) *,the carrier of it
  #);
end;

:: PRELAMB:attrnot 9 => PRELAMB:attr 9
definition
  let a1 be typestr;
  attr a1 is strict;
end;

:: PRELAMB:exreg 3
registration
  cluster strict typestr;
end;

:: PRELAMB:aggrnot 2 => PRELAMB:aggr 2
definition
  let a1 be set;
  let a2, a3, a4 be Function-like quasi_total Relation of [:a1,a1:],a1;
  let a5 be Relation of a1 *,a1;
  aggr typestr(#a1,a2,a3,a4,a5#) -> strict typestr;
end;

:: PRELAMB:selnot 4 => PRELAMB:sel 4
definition
  let a1 be typestr;
  sel the derivability of a1 -> Relation of (the carrier of a1) *,the carrier of a1;
end;

:: PRELAMB:exreg 4
registration
  cluster non empty strict typestr;
end;

:: PRELAMB:prednot 3 => PRELAMB:pred 2
definition
  let a1 be non empty typestr;
  let a2 be FinSequence of the carrier of a1;
  let a3 be Element of the carrier of a1;
  pred A2 ==>. A3 means
    [a2,a3] in the derivability of a1;
end;

:: PRELAMB:dfs 17
definiens
  let a1 be non empty typestr;
  let a2 be FinSequence of the carrier of a1;
  let a3 be Element of the carrier of a1;
To prove
     a2 ==>. a3
it is sufficient to prove
  thus [a2,a3] in the derivability of a1;

:: PRELAMB:def 18
theorem
for b1 being non empty typestr
for b2 being FinSequence of the carrier of b1
for b3 being Element of the carrier of b1 holds
      b2 ==>. b3
   iff
      [b2,b3] in the derivability of b1;

:: PRELAMB:attrnot 10 => PRELAMB:attr 10
definition
  let a1 be non empty typestr;
  attr a1 is SynTypes_Calculus-like means
    (for b1 being Element of the carrier of a1 holds
        <*b1*> ==>. b1) &
     (for b1 being FinSequence of the carrier of a1
     for b2, b3 being Element of the carrier of a1
           st b1 ^ <*b3*> ==>. b2
        holds b1 ==>. b2 /" b3) &
     (for b1 being FinSequence of the carrier of a1
     for b2, b3 being Element of the carrier of a1
           st <*b3*> ^ b1 ==>. b2
        holds b1 ==>. b3 \ b2) &
     (for b1, b2, b3 being FinSequence of the carrier of a1
     for b4, b5, b6 being Element of the carrier of a1
           st b1 ==>. b5 & (b2 ^ <*b4*>) ^ b3 ==>. b6
        holds ((b2 ^ <*b4 /" b5*>) ^ b1) ^ b3 ==>. b6) &
     (for b1, b2, b3 being FinSequence of the carrier of a1
     for b4, b5, b6 being Element of the carrier of a1
           st b1 ==>. b5 & (b2 ^ <*b4*>) ^ b3 ==>. b6
        holds ((b2 ^ b1) ^ <*b5 \ b4*>) ^ b3 ==>. b6) &
     (for b1, b2 being FinSequence of the carrier of a1
     for b3, b4, b5 being Element of the carrier of a1
           st ((b1 ^ <*b3*>) ^ <*b4*>) ^ b2 ==>. b5
        holds (b1 ^ <*b3 * b4*>) ^ b2 ==>. b5) &
     (for b1, b2 being FinSequence of the carrier of a1
     for b3, b4 being Element of the carrier of a1
           st b1 ==>. b3 & b2 ==>. b4
        holds b1 ^ b2 ==>. b3 * b4);
end;

:: PRELAMB:dfs 18
definiens
  let a1 be non empty typestr;
To prove
     a1 is SynTypes_Calculus-like
it is sufficient to prove
  thus (for b1 being Element of the carrier of a1 holds
        <*b1*> ==>. b1) &
     (for b1 being FinSequence of the carrier of a1
     for b2, b3 being Element of the carrier of a1
           st b1 ^ <*b3*> ==>. b2
        holds b1 ==>. b2 /" b3) &
     (for b1 being FinSequence of the carrier of a1
     for b2, b3 being Element of the carrier of a1
           st <*b3*> ^ b1 ==>. b2
        holds b1 ==>. b3 \ b2) &
     (for b1, b2, b3 being FinSequence of the carrier of a1
     for b4, b5, b6 being Element of the carrier of a1
           st b1 ==>. b5 & (b2 ^ <*b4*>) ^ b3 ==>. b6
        holds ((b2 ^ <*b4 /" b5*>) ^ b1) ^ b3 ==>. b6) &
     (for b1, b2, b3 being FinSequence of the carrier of a1
     for b4, b5, b6 being Element of the carrier of a1
           st b1 ==>. b5 & (b2 ^ <*b4*>) ^ b3 ==>. b6
        holds ((b2 ^ b1) ^ <*b5 \ b4*>) ^ b3 ==>. b6) &
     (for b1, b2 being FinSequence of the carrier of a1
     for b3, b4, b5 being Element of the carrier of a1
           st ((b1 ^ <*b3*>) ^ <*b4*>) ^ b2 ==>. b5
        holds (b1 ^ <*b3 * b4*>) ^ b2 ==>. b5) &
     (for b1, b2 being FinSequence of the carrier of a1
     for b3, b4 being Element of the carrier of a1
           st b1 ==>. b3 & b2 ==>. b4
        holds b1 ^ b2 ==>. b3 * b4);

:: PRELAMB:def 19
theorem
for b1 being non empty typestr holds
      b1 is SynTypes_Calculus-like
   iff
      (for b2 being Element of the carrier of b1 holds
          <*b2*> ==>. b2) &
       (for b2 being FinSequence of the carrier of b1
       for b3, b4 being Element of the carrier of b1
             st b2 ^ <*b4*> ==>. b3
          holds b2 ==>. b3 /" b4) &
       (for b2 being FinSequence of the carrier of b1
       for b3, b4 being Element of the carrier of b1
             st <*b4*> ^ b2 ==>. b3
          holds b2 ==>. b4 \ b3) &
       (for b2, b3, b4 being FinSequence of the carrier of b1
       for b5, b6, b7 being Element of the carrier of b1
             st b2 ==>. b6 & (b3 ^ <*b5*>) ^ b4 ==>. b7
          holds ((b3 ^ <*b5 /" b6*>) ^ b2) ^ b4 ==>. b7) &
       (for b2, b3, b4 being FinSequence of the carrier of b1
       for b5, b6, b7 being Element of the carrier of b1
             st b2 ==>. b6 & (b3 ^ <*b5*>) ^ b4 ==>. b7
          holds ((b3 ^ b2) ^ <*b6 \ b5*>) ^ b4 ==>. b7) &
       (for b2, b3 being FinSequence of the carrier of b1
       for b4, b5, b6 being Element of the carrier of b1
             st ((b2 ^ <*b4*>) ^ <*b5*>) ^ b3 ==>. b6
          holds (b2 ^ <*b4 * b5*>) ^ b3 ==>. b6) &
       (for b2, b3 being FinSequence of the carrier of b1
       for b4, b5 being Element of the carrier of b1
             st b2 ==>. b4 & b3 ==>. b5
          holds b2 ^ b3 ==>. b4 * b5);

:: PRELAMB:exreg 5
registration
  cluster non empty SynTypes_Calculus-like typestr;
end;

:: PRELAMB:modenot 5
definition
  mode SynTypes_Calculus is non empty SynTypes_Calculus-like typestr;
end;

:: PRELAMB:th 12
theorem
for b1 being non empty SynTypes_Calculus-like typestr
for b2, b3 being Element of the carrier of b1 holds
<*b2 /" b3*> ^ <*b3*> ==>. b2 &
 <*b3*> ^ <*b3 \ b2*> ==>. b2;

:: PRELAMB:th 13
theorem
for b1 being non empty SynTypes_Calculus-like typestr
for b2, b3 being Element of the carrier of b1 holds
<*b2*> ==>. b3 /" (b2 \ b3) & <*b2*> ==>. (b3 /" b2) \ b3;

:: PRELAMB:th 14
theorem
for b1 being non empty SynTypes_Calculus-like typestr
for b2, b3, b4 being Element of the carrier of b1 holds
<*b2 /" b3*> ==>. (b2 /" b4) /" (b3 /" b4);

:: PRELAMB:th 15
theorem
for b1 being non empty SynTypes_Calculus-like typestr
for b2, b3, b4 being Element of the carrier of b1 holds
<*b2 \ b3*> ==>. (b4 \ b2) \ (b4 \ b3);

:: PRELAMB:th 16
theorem
for b1 being non empty SynTypes_Calculus-like typestr
for b2, b3, b4 being Element of the carrier of b1
      st <*b2*> ==>. b3
   holds <*b2 /" b4*> ==>. b3 /" b4 & <*b4 \ b2*> ==>. b4 \ b3;

:: PRELAMB:th 17
theorem
for b1 being non empty SynTypes_Calculus-like typestr
for b2, b3, b4 being Element of the carrier of b1
      st <*b2*> ==>. b3
   holds <*b4 /" b3*> ==>. b4 /" b2 & <*b3 \ b4*> ==>. b2 \ b4;

:: PRELAMB:th 18
theorem
for b1 being non empty SynTypes_Calculus-like typestr
for b2, b3 being Element of the carrier of b1 holds
<*b2 /" ((b2 /" b3) \ b2)*> ==>. b2 /" b3;

:: PRELAMB:th 19
theorem
for b1 being non empty SynTypes_Calculus-like typestr
for b2, b3 being Element of the carrier of b1
      st <*b2*> ==>. b3
   holds <*> the carrier of b1 ==>. b3 /" b2 & <*> the carrier of b1 ==>. b2 \ b3;

:: PRELAMB:th 20
theorem
for b1 being non empty SynTypes_Calculus-like typestr
for b2 being Element of the carrier of b1 holds
   <*> the carrier of b1 ==>. b2 /" b2 & <*> the carrier of b1 ==>. b2 \ b2;

:: PRELAMB:th 21
theorem
for b1 being non empty SynTypes_Calculus-like typestr
for b2, b3 being Element of the carrier of b1 holds
<*> the carrier of b1 ==>. (b2 /" (b3 \ b2)) /" b3 &
 <*> the carrier of b1 ==>. b3 \ ((b2 /" b3) \ b2);

:: PRELAMB:th 22
theorem
for b1 being non empty SynTypes_Calculus-like typestr
for b2, b3, b4 being Element of the carrier of b1 holds
<*> the carrier of b1 ==>. ((b2 /" b3) /" (b4 /" b3)) /" (b2 /" b4) &
 <*> the carrier of b1 ==>. (b4 \ b2) \ ((b3 \ b4) \ (b3 \ b2));

:: PRELAMB:th 23
theorem
for b1 being non empty SynTypes_Calculus-like typestr
for b2, b3 being Element of the carrier of b1
      st <*> the carrier of b1 ==>. b2
   holds <*> the carrier of b1 ==>. b3 /" (b3 /" b2) &
    <*> the carrier of b1 ==>. (b2 \ b3) \ b3;

:: PRELAMB:th 24
theorem
for b1 being non empty SynTypes_Calculus-like typestr
for b2, b3 being Element of the carrier of b1 holds
<*b2 /" (b3 /" b3)*> ==>. b2;

:: PRELAMB:prednot 4 => PRELAMB:pred 3
definition
  let a1 be non empty SynTypes_Calculus-like typestr;
  let a2, a3 be Element of the carrier of a1;
  pred A2 <==>. A3 means
    <*a2*> ==>. a3 & <*a3*> ==>. a2;
end;

:: PRELAMB:dfs 19
definiens
  let a1 be non empty SynTypes_Calculus-like typestr;
  let a2, a3 be Element of the carrier of a1;
To prove
     a2 <==>. a3
it is sufficient to prove
  thus <*a2*> ==>. a3 & <*a3*> ==>. a2;

:: PRELAMB:def 20
theorem
for b1 being non empty SynTypes_Calculus-like typestr
for b2, b3 being Element of the carrier of b1 holds
   b2 <==>. b3
iff
   <*b2*> ==>. b3 & <*b3*> ==>. b2;

:: PRELAMB:th 25
theorem
for b1 being non empty SynTypes_Calculus-like typestr
for b2 being Element of the carrier of b1 holds
   b2 <==>. b2;

:: PRELAMB:th 26
theorem
for b1 being non empty SynTypes_Calculus-like typestr
for b2, b3 being Element of the carrier of b1 holds
b2 /" b3 <==>. b2 /" ((b2 /" b3) \ b2);

:: PRELAMB:th 27
theorem
for b1 being non empty SynTypes_Calculus-like typestr
for b2, b3, b4 being Element of the carrier of b1 holds
b2 /" (b3 * b4) <==>. (b2 /" b4) /" b3;

:: PRELAMB:th 28
theorem
for b1 being non empty SynTypes_Calculus-like typestr
for b2, b3, b4 being Element of the carrier of b1 holds
<*b2 * (b3 /" b4)*> ==>. (b2 * b3) /" b4;

:: PRELAMB:th 29
theorem
for b1 being non empty SynTypes_Calculus-like typestr
for b2, b3 being Element of the carrier of b1 holds
<*b2*> ==>. (b2 * b3) /" b3 & <*b2*> ==>. b3 \ (b3 * b2);

:: PRELAMB:th 30
theorem
for b1 being non empty SynTypes_Calculus-like typestr
for b2, b3, b4 being Element of the carrier of b1 holds
(b2 * b3) * b4 <==>. b2 * (b3 * b4);