Article POLYNOM3, MML version 4.99.1005

:: POLYNOM3:th 1
theorem
for b1 being non empty right_complementable add-associative right_zeroed addLoopStr
for b2 being FinSequence of the carrier of b1
      st for b3 being Element of NAT
              st b3 in dom b2
           holds b2 . b3 = 0. b1
   holds Sum b2 = 0. b1;

:: POLYNOM3:th 2
theorem
for b1 being non empty Abelian add-associative right_zeroed addLoopStr
for b2 being FinSequence of the carrier of b1 holds
   Sum b2 = Sum Rev b2;

:: POLYNOM3:th 3
theorem
for b1 being FinSequence of REAL holds
   Sum b1 = Sum Rev b1;

:: POLYNOM3:th 4
theorem
for b1 being FinSequence of NAT
for b2 being Element of NAT
      st b2 in dom b1
   holds b1 . b2 <= Sum b1;

:: POLYNOM3:funcnot 1 => POLYNOM3:func 1
definition
  let a1 be non empty set;
  let a2 be Element of NAT;
  let a3 be FinSequence of a1;
  redefine func Del(a3,a2) -> FinSequence of a1;
end;

:: POLYNOM3:funcnot 2 => POLYNOM3:func 2
definition
  let a1 be non empty set;
  let a2, a3 be Element of a1;
  redefine func <*a2, a3*> -> Element of 2 -tuples_on a1;
end;

:: POLYNOM3:funcnot 3 => POLYNOM3:func 3
definition
  let a1 be non empty set;
  let a2, a3 be Element of NAT;
  let a4 be Element of a2 -tuples_on a1;
  let a5 be Element of a3 -tuples_on a1;
  redefine func a4 ^ a5 -> Element of (a2 + a3) -tuples_on a1;
end;

:: POLYNOM3:condreg 1
registration
  let a1 be non empty set;
  let a2 be Element of NAT;
  cluster -> FinSequence-yielding (FinSequence of a2 -tuples_on a1);
end;

:: POLYNOM3:funcnot 4 => POLYNOM3:func 4
definition
  let a1 be non empty set;
  let a2, a3 be Element of NAT;
  let a4 be FinSequence of a2 -tuples_on a1;
  let a5 be FinSequence of a3 -tuples_on a1;
  redefine func a4 ^^ a5 -> Element of ((a2 + a3) -tuples_on a1) *;
end;

:: POLYNOM3:sch 1
scheme POLYNOM3:sch 1
{F1 -> non empty set,
  F2 -> Element of NAT,
  F3 -> Element of NAT,
  F4 -> Element of F1()}:
ex b1 being FinSequence of F1() * st
   len b1 = F2() &
    (for b2 being Element of NAT
          st b2 in Seg F2()
       holds len (b1 /. b2) = F3(b2) &
        (for b3 being Element of NAT
              st b3 in dom (b1 /. b2)
           holds (b1 /. b2) . b3 = F4(b2, b3)))


:: POLYNOM3:prednot 1 => POLYNOM3:pred 1
definition
  let a1 be Element of NAT;
  let a2, a3 be Element of a1 -tuples_on NAT;
  pred A2 < A3 means
    ex b1 being Element of NAT st
       b1 in Seg a1 &
        a2 . b1 < a3 . b1 &
        (for b2 being Element of NAT
              st 1 <= b2 & b2 < b1
           holds a2 . b2 = a3 . b2);
  asymmetry;
::  for a1 being Element of NAT
::  for a2, a3 being Element of a1 -tuples_on NAT
::        st a2 < a3
::     holds not a3 < a2;
end;

:: POLYNOM3:dfs 1
definiens
  let a1 be Element of NAT;
  let a2, a3 be Element of a1 -tuples_on NAT;
To prove
     a2 < a3
it is sufficient to prove
  thus ex b1 being Element of NAT st
       b1 in Seg a1 &
        a2 . b1 < a3 . b1 &
        (for b2 being Element of NAT
              st 1 <= b2 & b2 < b1
           holds a2 . b2 = a3 . b2);

:: POLYNOM3:def 1
theorem
for b1 being Element of NAT
for b2, b3 being Element of b1 -tuples_on NAT holds
   b2 < b3
iff
   ex b4 being Element of NAT st
      b4 in Seg b1 &
       b2 . b4 < b3 . b4 &
       (for b5 being Element of NAT
             st 1 <= b5 & b5 < b4
          holds b2 . b5 = b3 . b5);

:: POLYNOM3:prednot 2 => POLYNOM3:pred 1
notation
  let a1 be Element of NAT;
  let a2, a3 be Element of a1 -tuples_on NAT;
  synonym a3 > a2 for a2 < a3;
end;

:: POLYNOM3:prednot 3 => POLYNOM3:pred 2
definition
  let a1 be Element of NAT;
  let a2, a3 be Element of a1 -tuples_on NAT;
  pred A2 <= A3 means
    (not a2 < a3) implies a2 = a3;
  reflexivity;
::  for a1 being Element of NAT
::  for a2 being Element of a1 -tuples_on NAT holds
::     a2 <= a2;
end;

:: POLYNOM3:dfs 2
definiens
  let a1 be Element of NAT;
  let a2, a3 be Element of a1 -tuples_on NAT;
To prove
     a2 <= a3
it is sufficient to prove
  thus (not a2 < a3) implies a2 = a3;

:: POLYNOM3:def 2
theorem
for b1 being Element of NAT
for b2, b3 being Element of b1 -tuples_on NAT holds
   b2 <= b3
iff
   (b2 < b3 or b2 = b3);

:: POLYNOM3:prednot 4 => POLYNOM3:pred 2
notation
  let a1 be Element of NAT;
  let a2, a3 be Element of a1 -tuples_on NAT;
  synonym a3 >= a2 for a2 <= a3;
end;

:: POLYNOM3:th 5
theorem
for b1 being Element of NAT
for b2, b3, b4 being Element of b1 -tuples_on NAT holds
(b2 < b3 & b3 < b4 implies b2 < b4) &
 ((b2 < b3 implies not b3 <= b4) & (b2 <= b3 implies not b3 < b4) & (b2 <= b3 implies not b3 <= b4) or b2 <= b4);

:: POLYNOM3:th 6
theorem
for b1 being Element of NAT
for b2, b3 being Element of b1 -tuples_on NAT
      st b2 <> b3
   holds ex b4 being Element of NAT st
      b4 in Seg b1 &
       b2 . b4 <> b3 . b4 &
       (for b5 being Element of NAT
             st 1 <= b5 & b5 < b4
          holds b2 . b5 = b3 . b5);

:: POLYNOM3:th 7
theorem
for b1 being Element of NAT
for b2, b3 being Element of b1 -tuples_on NAT
      st not b2 <= b3
   holds b3 < b2;

:: POLYNOM3:funcnot 5 => POLYNOM3:func 5
definition
  let a1 be Element of NAT;
  func TuplesOrder A1 -> reflexive antisymmetric transitive total Relation of a1 -tuples_on NAT,a1 -tuples_on NAT means
    for b1, b2 being Element of a1 -tuples_on NAT holds
       [b1,b2] in it
    iff
       b1 <= b2;
end;

:: POLYNOM3:def 3
theorem
for b1 being Element of NAT
for b2 being reflexive antisymmetric transitive total Relation of b1 -tuples_on NAT,b1 -tuples_on NAT holds
      b2 = TuplesOrder b1
   iff
      for b3, b4 being Element of b1 -tuples_on NAT holds
         [b3,b4] in b2
      iff
         b3 <= b4;

:: POLYNOM3:funcreg 1
registration
  let a1 be Element of NAT;
  cluster TuplesOrder a1 -> reflexive antisymmetric transitive total being_linear-order;
end;

:: POLYNOM3:funcnot 6 => POLYNOM3:func 6
definition
  let a1 be non empty Element of NAT;
  let a2 be Element of NAT;
  func Decomp(A2,A1) -> FinSequence of a1 -tuples_on NAT means
    ex b1 being finite Element of bool (a1 -tuples_on NAT) st
       it = SgmX(TuplesOrder a1,b1) &
        (for b2 being Element of a1 -tuples_on NAT holds
              b2 in b1
           iff
              Sum b2 = a2);
end;

:: POLYNOM3:def 4
theorem
for b1 being non empty Element of NAT
for b2 being Element of NAT
for b3 being FinSequence of b1 -tuples_on NAT holds
      b3 = Decomp(b2,b1)
   iff
      ex b4 being finite Element of bool (b1 -tuples_on NAT) st
         b3 = SgmX(TuplesOrder b1,b4) &
          (for b5 being Element of b1 -tuples_on NAT holds
                b5 in b4
             iff
                Sum b5 = b2);

:: POLYNOM3:funcreg 2
registration
  let a1 be non empty Element of NAT;
  let a2 be Element of NAT;
  cluster Decomp(a2,a1) -> one-to-one non empty FinSequence-yielding;
end;

:: POLYNOM3:th 8
theorem
for b1 being Element of NAT holds
   len Decomp(b1,1) = 1;

:: POLYNOM3:th 9
theorem
for b1 being Element of NAT holds
   len Decomp(b1,2) = b1 + 1;

:: POLYNOM3:th 10
theorem
for b1 being Element of NAT holds
   Decomp(b1,1) = <*<*b1*>*>;

:: POLYNOM3:th 11
theorem
for b1, b2, b3, b4, b5 being Element of NAT
      st (Decomp(b3,2)) . b1 = <*b4,b3 -' b4*> &
         (Decomp(b3,2)) . b2 = <*b5,b3 -' b5*>
   holds    b1 < b2
   iff
      b4 < b5;

:: POLYNOM3:th 12
theorem
for b1, b2, b3, b4 being Element of NAT
      st (Decomp(b2,2)) . b1 = <*b3,b2 -' b3*> &
         (Decomp(b2,2)) . (b1 + 1) = <*b4,b2 -' b4*>
   holds b4 = b3 + 1;

:: POLYNOM3:th 13
theorem
for b1 being Element of NAT holds
   (Decomp(b1,2)) . 1 = <*0,b1*>;

:: POLYNOM3:th 14
theorem
for b1, b2 being Element of NAT
      st b2 in Seg (b1 + 1)
   holds (Decomp(b1,2)) . b2 = <*b2 -' 1,(b1 + 1) -' b2*>;

:: POLYNOM3:funcnot 7 => POLYNOM3:func 7
definition
  let a1 be non empty multMagma;
  let a2, a3, a4 be Function-like quasi_total Relation of NAT,the carrier of a1;
  let a5 be FinSequence of 3 -tuples_on NAT;
  func prodTuples(A2,A3,A4,A5) -> Element of (the carrier of a1) * means
    len it = len a5 &
     (for b1 being Element of NAT
           st b1 in dom a5
        holds it . b1 = ((a2 . ((a5 /. b1) /. 1)) * (a3 . ((a5 /. b1) /. 2))) * (a4 . ((a5 /. b1) /. 3)));
end;

:: POLYNOM3:def 5
theorem
for b1 being non empty multMagma
for b2, b3, b4 being Function-like quasi_total Relation of NAT,the carrier of b1
for b5 being FinSequence of 3 -tuples_on NAT
for b6 being Element of (the carrier of b1) * holds
      b6 = prodTuples(b2,b3,b4,b5)
   iff
      len b6 = len b5 &
       (for b7 being Element of NAT
             st b7 in dom b5
          holds b6 . b7 = ((b2 . ((b5 /. b7) /. 1)) * (b3 . ((b5 /. b7) /. 2))) * (b4 . ((b5 /. b7) /. 3)));

:: POLYNOM3:th 15
theorem
for b1 being non empty multMagma
for b2, b3, b4 being Function-like quasi_total Relation of NAT,the carrier of b1
for b5 being FinSequence of 3 -tuples_on NAT
for b6 being Function-like quasi_total bijective Relation of dom b5,dom b5
for b7 being FinSequence of 3 -tuples_on NAT
      st b7 = b5 * b6
   holds prodTuples(b2,b3,b4,b7) = (prodTuples(b2,b3,b4,b5)) * b6;

:: POLYNOM3:th 16
theorem
for b1 being set
for b2 being FinSequence of b1 *
for b3 being Element of NAT holds
   Card (b2 | b3) = (Card b2) | b3;

:: POLYNOM3:th 17
theorem
for b1 being FinSequence of REAL
for b2 being FinSequence of NAT
   st b1 = b2
for b3 being Element of NAT holds
   b1 | b3 = b2 | b3;

:: POLYNOM3:th 18
theorem
for b1 being FinSequence of NAT
for b2, b3 being Element of NAT
      st b2 <= b3
   holds Sum (b1 | b2) <= Sum (b1 | b3);

:: POLYNOM3:th 19
theorem
for b1 being set
for b2 being FinSequence of b1
for b3 being Element of NAT
      st b3 < len b2
   holds b2 | (b3 + 1) = (b2 | b3) ^ <*b2 . (b3 + 1)*>;

:: POLYNOM3:th 20
theorem
for b1 being FinSequence of REAL
for b2 being Element of NAT
      st b2 < len b1
   holds Sum (b1 | (b2 + 1)) = (Sum (b1 | b2)) + (b1 . (b2 + 1));

:: POLYNOM3:th 21
theorem
for b1 being FinSequence of NAT
for b2, b3, b4, b5 being Element of NAT
      st b2 < len b1 &
         b3 < len b1 &
         1 <= b4 &
         1 <= b5 &
         b4 <= b1 . (b2 + 1) &
         b5 <= b1 . (b3 + 1) &
         (Sum (b1 | b2)) + b4 = (Sum (b1 | b3)) + b5
   holds b2 = b3 & b4 = b5;

:: POLYNOM3:th 22
theorem
for b1, b2 being set
for b3 being FinSequence of b1 *
for b4 being FinSequence of b2 *
for b5, b6, b7, b8 being Element of NAT
      st b5 in dom b3 &
         b6 in dom b4 &
         b7 in dom (b3 . b5) &
         b8 in dom (b4 . b6) &
         Card b3 = Card b4 &
         (Sum ((Card b3) | (b5 -' 1))) + b7 = (Sum ((Card b4) | (b6 -' 1))) + b8
   holds b5 = b6 & b7 = b8;

:: POLYNOM3:modenot 1
definition
  let a1 be non empty ZeroStr;
  mode Polynomial of a1 is Function-like quasi_total finite-Support Relation of NAT,the carrier of a1;
end;

:: POLYNOM3:th 23
theorem
for b1 being non empty ZeroStr
for b2 being Function-like quasi_total finite-Support Relation of NAT,the carrier of b1
for b3 being Element of NAT holds
      len b2 <= b3
   iff
      b3 is_at_least_length_of b2;

:: POLYNOM3:sch 2
scheme POLYNOM3:sch 2
{F1 -> non empty addLoopStr,
  F2 -> Element of NAT,
  F3 -> Element of the carrier of F1()}:
ex b1 being Function-like quasi_total finite-Support Relation of NAT,the carrier of F1() st
   len b1 <= F2() &
    (for b2 being Element of NAT
          st b2 < F2()
       holds b1 . b2 = F3(b2))


:: POLYNOM3:funcreg 3
registration
  let a1 be non empty right_zeroed addLoopStr;
  let a2, a3 be Function-like quasi_total finite-Support Relation of NAT,the carrier of a1;
  cluster a2 + a3 -> Function-like quasi_total finite-Support;
end;

:: POLYNOM3:th 24
theorem
for b1 being non empty right_zeroed addLoopStr
for b2, b3 being Function-like quasi_total finite-Support Relation of NAT,the carrier of b1
for b4 being Element of NAT
      st b4 is_at_least_length_of b2 & b4 is_at_least_length_of b3
   holds b4 is_at_least_length_of b2 + b3;

:: POLYNOM3:th 25
theorem
for b1 being non empty right_zeroed addLoopStr
for b2, b3 being Function-like quasi_total finite-Support Relation of NAT,the carrier of b1 holds
support (b2 + b3) c= (support b2) \/ support b3;

:: POLYNOM3:funcnot 8 => POLYNOM3:func 8
definition
  let a1 be non empty Abelian addLoopStr;
  let a2, a3 be Function-like quasi_total Relation of NAT,the carrier of a1;
  redefine func a2 + a3 -> Function-like quasi_total Relation of NAT,the carrier of a1;
  commutativity;
::  for a1 being non empty Abelian addLoopStr
::  for a2, a3 being Function-like quasi_total Relation of NAT,the carrier of a1 holds
::  a2 + a3 = a3 + a2;
end;

:: POLYNOM3:th 26
theorem
for b1 being non empty add-associative addLoopStr
for b2, b3, b4 being Function-like quasi_total Relation of NAT,the carrier of b1 holds
(b2 + b3) + b4 = b2 + (b3 + b4);

:: POLYNOM3:funcreg 4
registration
  let a1 be non empty right_complementable add-associative right_zeroed addLoopStr;
  let a2 be Function-like quasi_total finite-Support Relation of NAT,the carrier of a1;
  cluster - a2 -> Function-like quasi_total finite-Support;
end;

:: POLYNOM3:funcnot 9 => NORMSP_1:func 4
definition
  let a1 be non empty addLoopStr;
  let a2, a3 be Function-like quasi_total Relation of NAT,the carrier of a1;
  func A2 - A3 -> Function-like quasi_total Relation of NAT,the carrier of a1 equals
    a2 + - a3;
end;

:: POLYNOM3:def 8
theorem
for b1 being non empty addLoopStr
for b2, b3 being Function-like quasi_total Relation of NAT,the carrier of b1 holds
b2 - b3 = b2 + - b3;

:: POLYNOM3:funcreg 5
registration
  let a1 be non empty right_complementable add-associative right_zeroed addLoopStr;
  let a2, a3 be Function-like quasi_total finite-Support Relation of NAT,the carrier of a1;
  cluster a2 - a3 -> Function-like quasi_total finite-Support;
end;

:: POLYNOM3:th 27
theorem
for b1 being non empty addLoopStr
for b2, b3 being Function-like quasi_total Relation of NAT,the carrier of b1
for b4 being Element of NAT holds
   (b2 - b3) . b4 = (b2 . b4) - (b3 . b4);

:: POLYNOM3:funcnot 10 => POLYNOM3:func 9
definition
  let a1 be non empty ZeroStr;
  func 0_. A1 -> Function-like quasi_total Relation of NAT,the carrier of a1 equals
    NAT --> 0. a1;
end;

:: POLYNOM3:def 9
theorem
for b1 being non empty ZeroStr holds
   0_. b1 = NAT --> 0. b1;

:: POLYNOM3:funcreg 6
registration
  let a1 be non empty ZeroStr;
  cluster 0_. a1 -> Function-like quasi_total finite-Support;
end;

:: POLYNOM3:th 29
theorem
for b1 being non empty right_zeroed addLoopStr
for b2 being Function-like quasi_total Relation of NAT,the carrier of b1 holds
   b2 + 0_. b1 = b2;

:: POLYNOM3:th 30
theorem
for b1 being non empty right_complementable add-associative right_zeroed addLoopStr
for b2 being Function-like quasi_total Relation of NAT,the carrier of b1 holds
   b2 - b2 = 0_. b1;

:: POLYNOM3:funcnot 11 => POLYNOM3:func 10
definition
  let a1 be non empty multLoopStr_0;
  func 1_. A1 -> Function-like quasi_total Relation of NAT,the carrier of a1 equals
    (0_. a1) +*(0,1. a1);
end;

:: POLYNOM3:def 10
theorem
for b1 being non empty multLoopStr_0 holds
   1_. b1 = (0_. b1) +*(0,1. b1);

:: POLYNOM3:funcreg 7
registration
  let a1 be non empty multLoopStr_0;
  cluster 1_. a1 -> Function-like quasi_total finite-Support;
end;

:: POLYNOM3:th 31
theorem
for b1 being non empty multLoopStr_0 holds
   (1_. b1) . 0 = 1. b1 &
    (for b2 being natural set
          st b2 <> 0
       holds (1_. b1) . b2 = 0. b1);

:: POLYNOM3:funcnot 12 => POLYNOM3:func 11
definition
  let a1 be non empty doubleLoopStr;
  let a2, a3 be Function-like quasi_total Relation of NAT,the carrier of a1;
  func A2 *' A3 -> Function-like quasi_total Relation of NAT,the carrier of a1 means
    for b1 being Element of NAT holds
       ex b2 being FinSequence of the carrier of a1 st
          len b2 = b1 + 1 &
           it . b1 = Sum b2 &
           (for b3 being Element of NAT
                 st b3 in dom b2
              holds b2 . b3 = (a2 . (b3 -' 1)) * (a3 . ((b1 + 1) -' b3)));
end;

:: POLYNOM3:def 11
theorem
for b1 being non empty doubleLoopStr
for b2, b3, b4 being Function-like quasi_total Relation of NAT,the carrier of b1 holds
   b4 = b2 *' b3
iff
   for b5 being Element of NAT holds
      ex b6 being FinSequence of the carrier of b1 st
         len b6 = b5 + 1 &
          b4 . b5 = Sum b6 &
          (for b7 being Element of NAT
                st b7 in dom b6
             holds b6 . b7 = (b2 . (b7 -' 1)) * (b3 . ((b5 + 1) -' b7)));

:: POLYNOM3:funcreg 8
registration
  let a1 be non empty right_complementable add-associative right_zeroed distributive doubleLoopStr;
  let a2, a3 be Function-like quasi_total finite-Support Relation of NAT,the carrier of a1;
  cluster a2 *' a3 -> Function-like quasi_total finite-Support;
end;

:: POLYNOM3:th 32
theorem
for b1 being non empty right_complementable Abelian add-associative right_zeroed right-distributive doubleLoopStr
for b2, b3, b4 being Function-like quasi_total Relation of NAT,the carrier of b1 holds
b2 *' (b3 + b4) = (b2 *' b3) + (b2 *' b4);

:: POLYNOM3:th 33
theorem
for b1 being non empty right_complementable Abelian add-associative right_zeroed left-distributive doubleLoopStr
for b2, b3, b4 being Function-like quasi_total Relation of NAT,the carrier of b1 holds
(b2 + b3) *' b4 = (b2 *' b4) + (b3 *' b4);

:: POLYNOM3:th 34
theorem
for b1 being non empty right_complementable Abelian add-associative right_zeroed associative well-unital distributive doubleLoopStr
for b2, b3, b4 being Function-like quasi_total Relation of NAT,the carrier of b1 holds
(b2 *' b3) *' b4 = b2 *' (b3 *' b4);

:: POLYNOM3:funcnot 13 => POLYNOM3:func 12
definition
  let a1 be non empty Abelian add-associative right_zeroed commutative doubleLoopStr;
  let a2, a3 be Function-like quasi_total Relation of NAT,the carrier of a1;
  redefine func a2 *' a3 -> Function-like quasi_total Relation of NAT,the carrier of a1;
  commutativity;
::  for a1 being non empty Abelian add-associative right_zeroed commutative doubleLoopStr
::  for a2, a3 being Function-like quasi_total Relation of NAT,the carrier of a1 holds
::  a2 *' a3 = a3 *' a2;
end;

:: POLYNOM3:th 35
theorem
for b1 being non empty right_complementable add-associative right_zeroed right-distributive doubleLoopStr
for b2 being Function-like quasi_total Relation of NAT,the carrier of b1 holds
   b2 *' 0_. b1 = 0_. b1;

:: POLYNOM3:th 36
theorem
for b1 being non empty right_complementable add-associative right_zeroed right-distributive well-unital doubleLoopStr
for b2 being Function-like quasi_total Relation of NAT,the carrier of b1 holds
   b2 *' 1_. b1 = b2;

:: POLYNOM3:funcnot 14 => POLYNOM3:func 13
definition
  let a1 be non empty right_complementable add-associative right_zeroed distributive doubleLoopStr;
  func Polynom-Ring A1 -> non empty strict doubleLoopStr means
    (for b1 being set holds
           b1 in the carrier of it
        iff
           b1 is Function-like quasi_total finite-Support Relation of NAT,the carrier of a1) &
     (for b1, b2 being Element of the carrier of it
     for b3, b4 being Function-like quasi_total Relation of NAT,the carrier of a1
           st b1 = b3 & b2 = b4
        holds b1 + b2 = b3 + b4) &
     (for b1, b2 being Element of the carrier of it
     for b3, b4 being Function-like quasi_total Relation of NAT,the carrier of a1
           st b1 = b3 & b2 = b4
        holds b1 * b2 = b3 *' b4) &
     0. it = 0_. a1 &
     1. it = 1_. a1;
end;

:: POLYNOM3:def 12
theorem
for b1 being non empty right_complementable add-associative right_zeroed distributive doubleLoopStr
for b2 being non empty strict doubleLoopStr holds
      b2 = Polynom-Ring b1
   iff
      (for b3 being set holds
             b3 in the carrier of b2
          iff
             b3 is Function-like quasi_total finite-Support Relation of NAT,the carrier of b1) &
       (for b3, b4 being Element of the carrier of b2
       for b5, b6 being Function-like quasi_total Relation of NAT,the carrier of b1
             st b3 = b5 & b4 = b6
          holds b3 + b4 = b5 + b6) &
       (for b3, b4 being Element of the carrier of b2
       for b5, b6 being Function-like quasi_total Relation of NAT,the carrier of b1
             st b3 = b5 & b4 = b6
          holds b3 * b4 = b5 *' b6) &
       0. b2 = 0_. b1 &
       1. b2 = 1_. b1;

:: POLYNOM3:funcreg 9
registration
  let a1 be non empty right_complementable Abelian add-associative right_zeroed distributive doubleLoopStr;
  cluster Polynom-Ring a1 -> non empty strict Abelian;
end;

:: POLYNOM3:funcreg 10
registration
  let a1 be non empty right_complementable add-associative right_zeroed distributive doubleLoopStr;
  cluster Polynom-Ring a1 -> non empty strict add-associative;
end;

:: POLYNOM3:funcreg 11
registration
  let a1 be non empty right_complementable add-associative right_zeroed distributive doubleLoopStr;
  cluster Polynom-Ring a1 -> non empty strict right_zeroed;
end;

:: POLYNOM3:funcreg 12
registration
  let a1 be non empty right_complementable add-associative right_zeroed distributive doubleLoopStr;
  cluster Polynom-Ring a1 -> non empty right_complementable strict;
end;

:: POLYNOM3:funcreg 13
registration
  let a1 be non empty right_complementable Abelian add-associative right_zeroed commutative distributive doubleLoopStr;
  cluster Polynom-Ring a1 -> non empty strict commutative;
end;

:: POLYNOM3:funcreg 14
registration
  let a1 be non empty right_complementable Abelian add-associative right_zeroed associative well-unital distributive doubleLoopStr;
  cluster Polynom-Ring a1 -> non empty strict associative;
end;

:: POLYNOM3:funcreg 15
registration
  let a1 be non empty right_complementable Abelian add-associative right_zeroed commutative well-unital distributive doubleLoopStr;
  cluster Polynom-Ring a1 -> non empty strict well-unital;
end;

:: POLYNOM3:funcreg 16
registration
  let a1 be non empty right_complementable Abelian add-associative right_zeroed distributive doubleLoopStr;
  cluster Polynom-Ring a1 -> non empty strict distributive;
end;

:: POLYNOM3:th 37
theorem
for b1 being non empty right_complementable Abelian add-associative right_zeroed commutative well-unital distributive doubleLoopStr holds
   1. Polynom-Ring b1 = 1_. b1;