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;