Article IDEAL_1, MML version 4.99.1005
:: IDEAL_1:exreg 1
registration
cluster non empty add-associative right_zeroed left_zeroed addLoopStr;
end;
:: IDEAL_1:exreg 2
registration
cluster non empty non trivial add-cancelable Abelian add-associative right_zeroed associative commutative well-unital distributive left_zeroed doubleLoopStr;
end;
:: IDEAL_1:th 1
theorem
for b1 being non empty add-associative right_zeroed left_zeroed addLoopStr
for b2, b3 being Element of the carrier of b1 holds
Sum <*b2,b3*> = b2 + b3;
:: IDEAL_1:attrnot 1 => IDEAL_1:attr 1
definition
let a1 be non empty addLoopStr;
let a2 be Element of bool the carrier of a1;
attr a2 is add-closed means
for b1, b2 being Element of the carrier of a1
st b1 in a2 & b2 in a2
holds b1 + b2 in a2;
end;
:: IDEAL_1:dfs 1
definiens
let a1 be non empty addLoopStr;
let a2 be Element of bool the carrier of a1;
To prove
a2 is add-closed
it is sufficient to prove
thus for b1, b2 being Element of the carrier of a1
st b1 in a2 & b2 in a2
holds b1 + b2 in a2;
:: IDEAL_1:def 1
theorem
for b1 being non empty addLoopStr
for b2 being Element of bool the carrier of b1 holds
b2 is add-closed(b1)
iff
for b3, b4 being Element of the carrier of b1
st b3 in b2 & b4 in b2
holds b3 + b4 in b2;
:: IDEAL_1:attrnot 2 => IDEAL_1:attr 2
definition
let a1 be non empty multMagma;
let a2 be Element of bool the carrier of a1;
attr a2 is left-ideal means
for b1, b2 being Element of the carrier of a1
st b2 in a2
holds b1 * b2 in a2;
end;
:: IDEAL_1:dfs 2
definiens
let a1 be non empty multMagma;
let a2 be Element of bool the carrier of a1;
To prove
a2 is left-ideal
it is sufficient to prove
thus for b1, b2 being Element of the carrier of a1
st b2 in a2
holds b1 * b2 in a2;
:: IDEAL_1:def 2
theorem
for b1 being non empty multMagma
for b2 being Element of bool the carrier of b1 holds
b2 is left-ideal(b1)
iff
for b3, b4 being Element of the carrier of b1
st b4 in b2
holds b3 * b4 in b2;
:: IDEAL_1:attrnot 3 => IDEAL_1:attr 3
definition
let a1 be non empty multMagma;
let a2 be Element of bool the carrier of a1;
attr a2 is right-ideal means
for b1, b2 being Element of the carrier of a1
st b2 in a2
holds b2 * b1 in a2;
end;
:: IDEAL_1:dfs 3
definiens
let a1 be non empty multMagma;
let a2 be Element of bool the carrier of a1;
To prove
a2 is right-ideal
it is sufficient to prove
thus for b1, b2 being Element of the carrier of a1
st b2 in a2
holds b2 * b1 in a2;
:: IDEAL_1:def 3
theorem
for b1 being non empty multMagma
for b2 being Element of bool the carrier of b1 holds
b2 is right-ideal(b1)
iff
for b3, b4 being Element of the carrier of b1
st b4 in b2
holds b4 * b3 in b2;
:: IDEAL_1:exreg 3
registration
let a1 be non empty addLoopStr;
cluster non empty add-closed Element of bool the carrier of a1;
end;
:: IDEAL_1:exreg 4
registration
let a1 be non empty multMagma;
cluster non empty left-ideal Element of bool the carrier of a1;
end;
:: IDEAL_1:exreg 5
registration
let a1 be non empty multMagma;
cluster non empty right-ideal Element of bool the carrier of a1;
end;
:: IDEAL_1:exreg 6
registration
let a1 be non empty doubleLoopStr;
cluster non empty add-closed left-ideal right-ideal Element of bool the carrier of a1;
end;
:: IDEAL_1:exreg 7
registration
let a1 be non empty doubleLoopStr;
cluster non empty add-closed right-ideal Element of bool the carrier of a1;
end;
:: IDEAL_1:exreg 8
registration
let a1 be non empty doubleLoopStr;
cluster non empty add-closed left-ideal Element of bool the carrier of a1;
end;
:: IDEAL_1:condreg 1
registration
let a1 be non empty commutative multMagma;
cluster non empty left-ideal -> right-ideal (Element of bool the carrier of a1);
end;
:: IDEAL_1:condreg 2
registration
let a1 be non empty commutative multMagma;
cluster non empty right-ideal -> left-ideal (Element of bool the carrier of a1);
end;
:: IDEAL_1:modenot 1
definition
let a1 be non empty doubleLoopStr;
mode Ideal of a1 is non empty add-closed left-ideal right-ideal Element of bool the carrier of a1;
end;
:: IDEAL_1:modenot 2
definition
let a1 be non empty doubleLoopStr;
mode RightIdeal of a1 is non empty add-closed right-ideal Element of bool the carrier of a1;
end;
:: IDEAL_1:modenot 3
definition
let a1 be non empty doubleLoopStr;
mode LeftIdeal of a1 is non empty add-closed left-ideal Element of bool the carrier of a1;
end;
:: IDEAL_1:th 2
theorem
for b1 being non empty left_add-cancelable right_zeroed left-distributive doubleLoopStr
for b2 being non empty left-ideal Element of bool the carrier of b1 holds
0. b1 in b2;
:: IDEAL_1:th 3
theorem
for b1 being non empty right_add-cancelable right-distributive left_zeroed doubleLoopStr
for b2 being non empty right-ideal Element of bool the carrier of b1 holds
0. b1 in b2;
:: IDEAL_1:th 4
theorem
for b1 being non empty right_zeroed addLoopStr holds
{0. b1} is add-closed(b1);
:: IDEAL_1:th 5
theorem
for b1 being non empty right_add-cancelable right-distributive left_zeroed doubleLoopStr holds
{0. b1} is left-ideal(b1);
:: IDEAL_1:th 6
theorem
for b1 being non empty left_add-cancelable right_zeroed left-distributive doubleLoopStr holds
{0. b1} is right-ideal(b1);
:: IDEAL_1:funcreg 1
registration
let a1 be non empty right_zeroed addLoopStr;
cluster {0. a1} -> add-closed;
end;
:: IDEAL_1:funcreg 2
registration
let a1 be non empty right_add-cancelable right-distributive left_zeroed doubleLoopStr;
cluster {0. a1} -> left-ideal;
end;
:: IDEAL_1:funcreg 3
registration
let a1 be non empty left_add-cancelable right_zeroed left-distributive doubleLoopStr;
cluster {0. a1} -> right-ideal;
end;
:: IDEAL_1:th 7
theorem
for b1 being non empty right_complementable add-associative right_zeroed distributive doubleLoopStr holds
{0. b1} is non empty add-closed left-ideal right-ideal Element of bool the carrier of b1;
:: IDEAL_1:th 8
theorem
for b1 being non empty right_complementable add-associative right_zeroed right-distributive doubleLoopStr holds
{0. b1} is non empty add-closed left-ideal Element of bool the carrier of b1;
:: IDEAL_1:th 9
theorem
for b1 being non empty right_complementable add-associative right_zeroed left-distributive doubleLoopStr holds
{0. b1} is non empty add-closed right-ideal Element of bool the carrier of b1;
:: IDEAL_1:th 10
theorem
for b1 being non empty doubleLoopStr holds
the carrier of b1 is non empty add-closed left-ideal right-ideal Element of bool the carrier of b1;
:: IDEAL_1:th 11
theorem
for b1 being non empty doubleLoopStr holds
the carrier of b1 is non empty add-closed left-ideal Element of bool the carrier of b1;
:: IDEAL_1:th 12
theorem
for b1 being non empty doubleLoopStr holds
the carrier of b1 is non empty add-closed right-ideal Element of bool the carrier of b1;
:: IDEAL_1:attrnot 4 => IDEAL_1:attr 4
definition
let a1 be non empty add-cancelable right_zeroed distributive left_zeroed doubleLoopStr;
let a2 be non empty add-closed left-ideal right-ideal Element of bool the carrier of a1;
redefine attr a2 is trivial means
a2 = {0. a1};
end;
:: IDEAL_1:dfs 4
definiens
let a1 be non empty add-cancelable right_zeroed distributive left_zeroed doubleLoopStr;
let a2 be non empty add-closed left-ideal right-ideal Element of bool the carrier of a1;
To prove
a1 is trivial
it is sufficient to prove
thus a2 = {0. a1};
:: IDEAL_1:def 4
theorem
for b1 being non empty add-cancelable right_zeroed distributive left_zeroed doubleLoopStr
for b2 being non empty add-closed left-ideal right-ideal Element of bool the carrier of b1 holds
b2 is trivial
iff
b2 = {0. b1};
:: IDEAL_1:attrnot 5 => IDEAL_1:attr 5
definition
let a1 be 1-sorted;
let a2 be Element of bool the carrier of a1;
attr a2 is proper means
a2 <> the carrier of a1;
end;
:: IDEAL_1:dfs 5
definiens
let a1 be 1-sorted;
let a2 be Element of bool the carrier of a1;
To prove
a2 is proper
it is sufficient to prove
thus a2 <> the carrier of a1;
:: IDEAL_1:def 5
theorem
for b1 being 1-sorted
for b2 being Element of bool the carrier of b1 holds
b2 is proper(b1)
iff
b2 <> the carrier of b1;
:: IDEAL_1:exreg 9
registration
let a1 be non empty 1-sorted;
cluster proper Element of bool the carrier of a1;
end;
:: IDEAL_1:exreg 10
registration
let a1 be non empty non trivial add-cancelable right_zeroed distributive left_zeroed doubleLoopStr;
cluster non empty add-closed left-ideal right-ideal proper Element of bool the carrier of a1;
end;
:: IDEAL_1:th 13
theorem
for b1 being non empty right_complementable add-associative right_zeroed left-distributive left_unital doubleLoopStr
for b2 being non empty left-ideal Element of bool the carrier of b1
for b3 being Element of the carrier of b1
st b3 in b2
holds - b3 in b2;
:: IDEAL_1:th 14
theorem
for b1 being non empty right_complementable add-associative right_zeroed right-distributive right_unital doubleLoopStr
for b2 being non empty right-ideal Element of bool the carrier of b1
for b3 being Element of the carrier of b1
st b3 in b2
holds - b3 in b2;
:: IDEAL_1:th 15
theorem
for b1 being non empty right_complementable add-associative right_zeroed left-distributive left_unital doubleLoopStr
for b2 being non empty add-closed left-ideal Element of bool the carrier of b1
for b3, b4 being Element of the carrier of b1
st b3 in b2 & b4 in b2
holds b3 - b4 in b2;
:: IDEAL_1:th 16
theorem
for b1 being non empty right_complementable add-associative right_zeroed right-distributive right_unital doubleLoopStr
for b2 being non empty add-closed right-ideal Element of bool the carrier of b1
for b3, b4 being Element of the carrier of b1
st b3 in b2 & b4 in b2
holds b3 - b4 in b2;
:: IDEAL_1:th 17
theorem
for b1 being non empty add-cancelable add-associative right_zeroed distributive left_zeroed doubleLoopStr
for b2 being non empty add-closed right-ideal Element of bool the carrier of b1
for b3 being Element of b2
for b4 being Element of NAT holds
b4 * b3 in b2;
:: IDEAL_1:th 18
theorem
for b1 being non empty add-cancelable right_zeroed associative well-unital distributive left_zeroed doubleLoopStr
for b2 being non empty right-ideal Element of bool the carrier of b1
for b3 being Element of b2
for b4 being Element of NAT
st b4 <> 0
holds b3 |^ b4 in b2;
:: IDEAL_1:funcnot 1 => IDEAL_1:func 1
definition
let a1 be non empty addLoopStr;
let a2 be non empty add-closed Element of bool the carrier of a1;
func add|(A2,A1) -> Function-like quasi_total Relation of [:a2,a2:],a2 equals
(the addF of a1) || a2;
end;
:: IDEAL_1:def 6
theorem
for b1 being non empty addLoopStr
for b2 being non empty add-closed Element of bool the carrier of b1 holds
add|(b2,b1) = (the addF of b1) || b2;
:: IDEAL_1:funcnot 2 => IDEAL_1:func 2
definition
let a1 be non empty multMagma;
let a2 be non empty right-ideal Element of bool the carrier of a1;
func mult|(A2,A1) -> Function-like quasi_total Relation of [:a2,a2:],a2 equals
(the multF of a1) || a2;
end;
:: IDEAL_1:def 7
theorem
for b1 being non empty multMagma
for b2 being non empty right-ideal Element of bool the carrier of b1 holds
mult|(b2,b1) = (the multF of b1) || b2;
:: IDEAL_1:funcnot 3 => IDEAL_1:func 3
definition
let a1 be non empty addLoopStr;
let a2 be non empty add-closed Element of bool the carrier of a1;
func Gr(A2,A1) -> non empty addLoopStr equals
addLoopStr(#a2,add|(a2,a1),In(0. a1,a2)#);
end;
:: IDEAL_1:def 8
theorem
for b1 being non empty addLoopStr
for b2 being non empty add-closed Element of bool the carrier of b1 holds
Gr(b2,b1) = addLoopStr(#b2,add|(b2,b1),In(0. b1,b2)#);
:: IDEAL_1:funcreg 4
registration
let a1 be non empty add-cancelable add-associative right_zeroed distributive left_zeroed doubleLoopStr;
let a2 be non empty add-closed Element of bool the carrier of a1;
cluster Gr(a2,a1) -> non empty add-associative;
end;
:: IDEAL_1:funcreg 5
registration
let a1 be non empty add-cancelable add-associative right_zeroed distributive left_zeroed doubleLoopStr;
let a2 be non empty add-closed right-ideal Element of bool the carrier of a1;
cluster Gr(a2,a1) -> non empty right_zeroed;
end;
:: IDEAL_1:funcreg 6
registration
let a1 be non empty Abelian doubleLoopStr;
let a2 be non empty add-closed Element of bool the carrier of a1;
cluster Gr(a2,a1) -> non empty Abelian;
end;
:: IDEAL_1:funcreg 7
registration
let a1 be non empty right_complementable Abelian add-associative right_zeroed right_unital distributive left_zeroed doubleLoopStr;
let a2 be non empty add-closed right-ideal Element of bool the carrier of a1;
cluster Gr(a2,a1) -> non empty right_complementable;
end;
:: IDEAL_1:th 19
theorem
for b1 being non empty right_unital doubleLoopStr
for b2 being non empty left-ideal Element of bool the carrier of b1 holds
b2 is proper(b1)
iff
not 1. b1 in b2;
:: IDEAL_1:th 20
theorem
for b1 being non empty right_unital left_unital doubleLoopStr
for b2 being non empty right-ideal Element of bool the carrier of b1 holds
b2 is proper(b1)
iff
for b3 being Element of the carrier of b1
st b3 is unital(b1)
holds not b3 in b2;
:: IDEAL_1:th 21
theorem
for b1 being non empty right_unital doubleLoopStr
for b2 being non empty left-ideal right-ideal Element of bool the carrier of b1 holds
b2 is proper(b1)
iff
for b3 being Element of the carrier of b1
st b3 is unital(b1)
holds not b3 in b2;
:: IDEAL_1:th 22
theorem
for b1 being non empty non degenerated right_complementable Abelian add-associative right_zeroed associative commutative well-unital distributive doubleLoopStr holds
b1 is non empty non degenerated right_complementable almost_left_invertible Abelian add-associative right_zeroed associative commutative well-unital distributive doubleLoopStr
iff
for b2 being non empty add-closed left-ideal right-ideal Element of bool the carrier of b1
st b2 <> {0. b1}
holds b2 = the carrier of b1;
:: IDEAL_1:modenot 4 => IDEAL_1:mode 1
definition
let a1 be non empty multLoopStr;
let a2 be non empty Element of bool the carrier of a1;
mode LinearCombination of A2 -> FinSequence of the carrier of a1 means
for b1 being set
st b1 in dom it
holds ex b2, b3 being Element of the carrier of a1 st
ex b4 being Element of a2 st
it /. b1 = (b2 * b4) * b3;
end;
:: IDEAL_1:dfs 9
definiens
let a1 be non empty multLoopStr;
let a2 be non empty Element of bool the carrier of a1;
let a3 be FinSequence of the carrier of a1;
To prove
a3 is LinearCombination of a2
it is sufficient to prove
thus for b1 being set
st b1 in dom a3
holds ex b2, b3 being Element of the carrier of a1 st
ex b4 being Element of a2 st
a3 /. b1 = (b2 * b4) * b3;
:: IDEAL_1:def 9
theorem
for b1 being non empty multLoopStr
for b2 being non empty Element of bool the carrier of b1
for b3 being FinSequence of the carrier of b1 holds
b3 is LinearCombination of b2
iff
for b4 being set
st b4 in dom b3
holds ex b5, b6 being Element of the carrier of b1 st
ex b7 being Element of b2 st
b3 /. b4 = (b5 * b7) * b6;
:: IDEAL_1:modenot 5 => IDEAL_1:mode 2
definition
let a1 be non empty multLoopStr;
let a2 be non empty Element of bool the carrier of a1;
mode LeftLinearCombination of A2 -> FinSequence of the carrier of a1 means
for b1 being set
st b1 in dom it
holds ex b2 being Element of the carrier of a1 st
ex b3 being Element of a2 st
it /. b1 = b2 * b3;
end;
:: IDEAL_1:dfs 10
definiens
let a1 be non empty multLoopStr;
let a2 be non empty Element of bool the carrier of a1;
let a3 be FinSequence of the carrier of a1;
To prove
a3 is LeftLinearCombination of a2
it is sufficient to prove
thus for b1 being set
st b1 in dom a3
holds ex b2 being Element of the carrier of a1 st
ex b3 being Element of a2 st
a3 /. b1 = b2 * b3;
:: IDEAL_1:def 10
theorem
for b1 being non empty multLoopStr
for b2 being non empty Element of bool the carrier of b1
for b3 being FinSequence of the carrier of b1 holds
b3 is LeftLinearCombination of b2
iff
for b4 being set
st b4 in dom b3
holds ex b5 being Element of the carrier of b1 st
ex b6 being Element of b2 st
b3 /. b4 = b5 * b6;
:: IDEAL_1:modenot 6 => IDEAL_1:mode 3
definition
let a1 be non empty multLoopStr;
let a2 be non empty Element of bool the carrier of a1;
mode RightLinearCombination of A2 -> FinSequence of the carrier of a1 means
for b1 being set
st b1 in dom it
holds ex b2 being Element of the carrier of a1 st
ex b3 being Element of a2 st
it /. b1 = b3 * b2;
end;
:: IDEAL_1:dfs 11
definiens
let a1 be non empty multLoopStr;
let a2 be non empty Element of bool the carrier of a1;
let a3 be FinSequence of the carrier of a1;
To prove
a3 is RightLinearCombination of a2
it is sufficient to prove
thus for b1 being set
st b1 in dom a3
holds ex b2 being Element of the carrier of a1 st
ex b3 being Element of a2 st
a3 /. b1 = b3 * b2;
:: IDEAL_1:def 11
theorem
for b1 being non empty multLoopStr
for b2 being non empty Element of bool the carrier of b1
for b3 being FinSequence of the carrier of b1 holds
b3 is RightLinearCombination of b2
iff
for b4 being set
st b4 in dom b3
holds ex b5 being Element of the carrier of b1 st
ex b6 being Element of b2 st
b3 /. b4 = b6 * b5;
:: IDEAL_1:exreg 11
registration
let a1 be non empty multLoopStr;
let a2 be non empty Element of bool the carrier of a1;
cluster non empty Relation-like Function-like finite FinSequence-like LinearCombination of a2;
end;
:: IDEAL_1:exreg 12
registration
let a1 be non empty multLoopStr;
let a2 be non empty Element of bool the carrier of a1;
cluster non empty Relation-like Function-like finite FinSequence-like LeftLinearCombination of a2;
end;
:: IDEAL_1:exreg 13
registration
let a1 be non empty multLoopStr;
let a2 be non empty Element of bool the carrier of a1;
cluster non empty Relation-like Function-like finite FinSequence-like RightLinearCombination of a2;
end;
:: IDEAL_1:funcnot 4 => IDEAL_1:func 4
definition
let a1 be non empty multLoopStr;
let a2, a3 be non empty Element of bool the carrier of a1;
let a4 be LinearCombination of a2;
let a5 be LinearCombination of a3;
redefine func a4 ^ a5 -> LinearCombination of a2 \/ a3;
end;
:: IDEAL_1:th 23
theorem
for b1 being non empty associative multLoopStr
for b2 being non empty Element of bool the carrier of b1
for b3 being Element of the carrier of b1
for b4 being LinearCombination of b2 holds
b3 * b4 is LinearCombination of b2;
:: IDEAL_1:th 24
theorem
for b1 being non empty associative multLoopStr
for b2 being non empty Element of bool the carrier of b1
for b3 being Element of the carrier of b1
for b4 being LinearCombination of b2 holds
b4 * b3 is LinearCombination of b2;
:: IDEAL_1:th 25
theorem
for b1 being non empty right_unital multLoopStr
for b2 being non empty Element of bool the carrier of b1
for b3 being LeftLinearCombination of b2 holds
b3 is LinearCombination of b2;
:: IDEAL_1:funcnot 5 => IDEAL_1:func 5
definition
let a1 be non empty multLoopStr;
let a2, a3 be non empty Element of bool the carrier of a1;
let a4 be LeftLinearCombination of a2;
let a5 be LeftLinearCombination of a3;
redefine func a4 ^ a5 -> LeftLinearCombination of a2 \/ a3;
end;
:: IDEAL_1:th 26
theorem
for b1 being non empty associative multLoopStr
for b2 being non empty Element of bool the carrier of b1
for b3 being Element of the carrier of b1
for b4 being LeftLinearCombination of b2 holds
b3 * b4 is LeftLinearCombination of b2;
:: IDEAL_1:th 27
theorem
for b1 being non empty multLoopStr
for b2 being non empty Element of bool the carrier of b1
for b3 being Element of the carrier of b1
for b4 being LeftLinearCombination of b2 holds
b4 * b3 is LinearCombination of b2;
:: IDEAL_1:th 28
theorem
for b1 being non empty left_unital multLoopStr
for b2 being non empty Element of bool the carrier of b1
for b3 being RightLinearCombination of b2 holds
b3 is LinearCombination of b2;
:: IDEAL_1:funcnot 6 => IDEAL_1:func 6
definition
let a1 be non empty multLoopStr;
let a2, a3 be non empty Element of bool the carrier of a1;
let a4 be RightLinearCombination of a2;
let a5 be RightLinearCombination of a3;
redefine func a4 ^ a5 -> RightLinearCombination of a2 \/ a3;
end;
:: IDEAL_1:th 29
theorem
for b1 being non empty associative multLoopStr
for b2 being non empty Element of bool the carrier of b1
for b3 being Element of the carrier of b1
for b4 being RightLinearCombination of b2 holds
b4 * b3 is RightLinearCombination of b2;
:: IDEAL_1:th 30
theorem
for b1 being non empty associative multLoopStr
for b2 being non empty Element of bool the carrier of b1
for b3 being Element of the carrier of b1
for b4 being RightLinearCombination of b2 holds
b3 * b4 is LinearCombination of b2;
:: IDEAL_1:th 31
theorem
for b1 being non empty associative commutative multLoopStr
for b2 being non empty Element of bool the carrier of b1
for b3 being LinearCombination of b2 holds
b3 is LeftLinearCombination of b2 & b3 is RightLinearCombination of b2;
:: IDEAL_1:th 32
theorem
for b1 being non empty doubleLoopStr
for b2 being non empty Element of bool the carrier of b1
for b3 being non empty LinearCombination of b2 holds
ex b4 being LinearCombination of b2 st
ex b5 being Element of the carrier of b1 st
b3 = b4 ^ <*b5*> & <*b5*> is LinearCombination of b2;
:: IDEAL_1:th 33
theorem
for b1 being non empty doubleLoopStr
for b2 being non empty Element of bool the carrier of b1
for b3 being non empty LeftLinearCombination of b2 holds
ex b4 being LeftLinearCombination of b2 st
ex b5 being Element of the carrier of b1 st
b3 = b4 ^ <*b5*> & <*b5*> is LeftLinearCombination of b2;
:: IDEAL_1:th 34
theorem
for b1 being non empty doubleLoopStr
for b2 being non empty Element of bool the carrier of b1
for b3 being non empty RightLinearCombination of b2 holds
ex b4 being RightLinearCombination of b2 st
ex b5 being Element of the carrier of b1 st
b3 = b4 ^ <*b5*> & <*b5*> is RightLinearCombination of b2;
:: IDEAL_1:prednot 1 => IDEAL_1:pred 1
definition
let a1 be non empty multLoopStr;
let a2 be non empty Element of bool the carrier of a1;
let a3 be LinearCombination of a2;
let a4 be FinSequence of [:the carrier of a1,the carrier of a1,the carrier of a1:];
pred A4 represents A3 means
len a4 = len a3 &
(for b1 being set
st b1 in dom a3
holds a3 . b1 = ((a4 /. b1) `1 * ((a4 /. b1) `2)) * ((a4 /. b1) `3) &
(a4 /. b1) `2 in a2);
end;
:: IDEAL_1:dfs 12
definiens
let a1 be non empty multLoopStr;
let a2 be non empty Element of bool the carrier of a1;
let a3 be LinearCombination of a2;
let a4 be FinSequence of [:the carrier of a1,the carrier of a1,the carrier of a1:];
To prove
a4 represents a3
it is sufficient to prove
thus len a4 = len a3 &
(for b1 being set
st b1 in dom a3
holds a3 . b1 = ((a4 /. b1) `1 * ((a4 /. b1) `2)) * ((a4 /. b1) `3) &
(a4 /. b1) `2 in a2);
:: IDEAL_1:def 12
theorem
for b1 being non empty multLoopStr
for b2 being non empty Element of bool the carrier of b1
for b3 being LinearCombination of b2
for b4 being FinSequence of [:the carrier of b1,the carrier of b1,the carrier of b1:] holds
b4 represents b3
iff
len b4 = len b3 &
(for b5 being set
st b5 in dom b3
holds b3 . b5 = ((b4 /. b5) `1 * ((b4 /. b5) `2)) * ((b4 /. b5) `3) &
(b4 /. b5) `2 in b2);
:: IDEAL_1:th 35
theorem
for b1 being non empty multLoopStr
for b2 being non empty Element of bool the carrier of b1
for b3 being LinearCombination of b2 holds
ex b4 being FinSequence of [:the carrier of b1,the carrier of b1,the carrier of b1:] st
b4 represents b3;
:: IDEAL_1:th 36
theorem
for b1, b2 being non empty multLoopStr
for b3 being non empty Element of bool the carrier of b1
for b4 being LinearCombination of b3
for b5 being non empty Element of bool the carrier of b2
for b6 being Function-like quasi_total Relation of the carrier of b1,the carrier of b2
for b7 being FinSequence of [:the carrier of b1,the carrier of b1,the carrier of b1:]
st b6 .: b3 c= b5 & b7 represents b4
holds ex b8 being LinearCombination of b5 st
len b4 = len b8 &
(for b9 being set
st b9 in dom b8
holds b8 . b9 = ((b6 . ((b7 /. b9) `1)) * (b6 . ((b7 /. b9) `2))) * (b6 . ((b7 /. b9) `3)));
:: IDEAL_1:prednot 2 => IDEAL_1:pred 2
definition
let a1 be non empty multLoopStr;
let a2 be non empty Element of bool the carrier of a1;
let a3 be LeftLinearCombination of a2;
let a4 be FinSequence of [:the carrier of a1,the carrier of a1:];
pred A4 represents A3 means
len a4 = len a3 &
(for b1 being set
st b1 in dom a3
holds a3 . b1 = (a4 /. b1) `1 * ((a4 /. b1) `2) &
(a4 /. b1) `2 in a2);
end;
:: IDEAL_1:dfs 13
definiens
let a1 be non empty multLoopStr;
let a2 be non empty Element of bool the carrier of a1;
let a3 be LeftLinearCombination of a2;
let a4 be FinSequence of [:the carrier of a1,the carrier of a1:];
To prove
a4 represents a3
it is sufficient to prove
thus len a4 = len a3 &
(for b1 being set
st b1 in dom a3
holds a3 . b1 = (a4 /. b1) `1 * ((a4 /. b1) `2) &
(a4 /. b1) `2 in a2);
:: IDEAL_1:def 13
theorem
for b1 being non empty multLoopStr
for b2 being non empty Element of bool the carrier of b1
for b3 being LeftLinearCombination of b2
for b4 being FinSequence of [:the carrier of b1,the carrier of b1:] holds
b4 represents b3
iff
len b4 = len b3 &
(for b5 being set
st b5 in dom b3
holds b3 . b5 = (b4 /. b5) `1 * ((b4 /. b5) `2) &
(b4 /. b5) `2 in b2);
:: IDEAL_1:th 37
theorem
for b1 being non empty multLoopStr
for b2 being non empty Element of bool the carrier of b1
for b3 being LeftLinearCombination of b2 holds
ex b4 being FinSequence of [:the carrier of b1,the carrier of b1:] st
b4 represents b3;
:: IDEAL_1:th 38
theorem
for b1, b2 being non empty multLoopStr
for b3 being non empty Element of bool the carrier of b1
for b4 being LeftLinearCombination of b3
for b5 being non empty Element of bool the carrier of b2
for b6 being Function-like quasi_total Relation of the carrier of b1,the carrier of b2
for b7 being FinSequence of [:the carrier of b1,the carrier of b1:]
st b6 .: b3 c= b5 & b7 represents b4
holds ex b8 being LeftLinearCombination of b5 st
len b4 = len b8 &
(for b9 being set
st b9 in dom b8
holds b8 . b9 = (b6 . ((b7 /. b9) `1)) * (b6 . ((b7 /. b9) `2)));
:: IDEAL_1:prednot 3 => IDEAL_1:pred 3
definition
let a1 be non empty multLoopStr;
let a2 be non empty Element of bool the carrier of a1;
let a3 be RightLinearCombination of a2;
let a4 be FinSequence of [:the carrier of a1,the carrier of a1:];
pred A4 represents A3 means
len a4 = len a3 &
(for b1 being set
st b1 in dom a3
holds a3 . b1 = (a4 /. b1) `1 * ((a4 /. b1) `2) &
(a4 /. b1) `1 in a2);
end;
:: IDEAL_1:dfs 14
definiens
let a1 be non empty multLoopStr;
let a2 be non empty Element of bool the carrier of a1;
let a3 be RightLinearCombination of a2;
let a4 be FinSequence of [:the carrier of a1,the carrier of a1:];
To prove
a4 represents a3
it is sufficient to prove
thus len a4 = len a3 &
(for b1 being set
st b1 in dom a3
holds a3 . b1 = (a4 /. b1) `1 * ((a4 /. b1) `2) &
(a4 /. b1) `1 in a2);
:: IDEAL_1:def 14
theorem
for b1 being non empty multLoopStr
for b2 being non empty Element of bool the carrier of b1
for b3 being RightLinearCombination of b2
for b4 being FinSequence of [:the carrier of b1,the carrier of b1:] holds
b4 represents b3
iff
len b4 = len b3 &
(for b5 being set
st b5 in dom b3
holds b3 . b5 = (b4 /. b5) `1 * ((b4 /. b5) `2) &
(b4 /. b5) `1 in b2);
:: IDEAL_1:th 39
theorem
for b1 being non empty multLoopStr
for b2 being non empty Element of bool the carrier of b1
for b3 being RightLinearCombination of b2 holds
ex b4 being FinSequence of [:the carrier of b1,the carrier of b1:] st
b4 represents b3;
:: IDEAL_1:th 40
theorem
for b1, b2 being non empty multLoopStr
for b3 being non empty Element of bool the carrier of b1
for b4 being RightLinearCombination of b3
for b5 being non empty Element of bool the carrier of b2
for b6 being Function-like quasi_total Relation of the carrier of b1,the carrier of b2
for b7 being FinSequence of [:the carrier of b1,the carrier of b1:]
st b6 .: b3 c= b5 & b7 represents b4
holds ex b8 being RightLinearCombination of b5 st
len b4 = len b8 &
(for b9 being set
st b9 in dom b8
holds b8 . b9 = (b6 . ((b7 /. b9) `1)) * (b6 . ((b7 /. b9) `2)));
:: IDEAL_1:th 41
theorem
for b1 being non empty multLoopStr
for b2 being non empty Element of bool the carrier of b1
for b3 being LinearCombination of b2
for b4 being Element of NAT holds
b3 | Seg b4 is LinearCombination of b2;
:: IDEAL_1:th 42
theorem
for b1 being non empty multLoopStr
for b2 being non empty Element of bool the carrier of b1
for b3 being LeftLinearCombination of b2
for b4 being Element of NAT holds
b3 | Seg b4 is LeftLinearCombination of b2;
:: IDEAL_1:th 43
theorem
for b1 being non empty multLoopStr
for b2 being non empty Element of bool the carrier of b1
for b3 being RightLinearCombination of b2
for b4 being Element of NAT holds
b3 | Seg b4 is RightLinearCombination of b2;
:: IDEAL_1:funcnot 7 => IDEAL_1:func 7
definition
let a1 be non empty doubleLoopStr;
let a2 be Element of bool the carrier of a1;
assume a2 is not empty;
func A2 -Ideal -> non empty add-closed left-ideal right-ideal Element of bool the carrier of a1 means
a2 c= it &
(for b1 being non empty add-closed left-ideal right-ideal Element of bool the carrier of a1
st a2 c= b1
holds it c= b1);
end;
:: IDEAL_1:def 15
theorem
for b1 being non empty doubleLoopStr
for b2 being Element of bool the carrier of b1
st b2 is not empty
for b3 being non empty add-closed left-ideal right-ideal Element of bool the carrier of b1 holds
b3 = b2 -Ideal
iff
b2 c= b3 &
(for b4 being non empty add-closed left-ideal right-ideal Element of bool the carrier of b1
st b2 c= b4
holds b3 c= b4);
:: IDEAL_1:funcnot 8 => IDEAL_1:func 8
definition
let a1 be non empty doubleLoopStr;
let a2 be Element of bool the carrier of a1;
assume a2 is not empty;
func A2 -LeftIdeal -> non empty add-closed left-ideal Element of bool the carrier of a1 means
a2 c= it &
(for b1 being non empty add-closed left-ideal Element of bool the carrier of a1
st a2 c= b1
holds it c= b1);
end;
:: IDEAL_1:def 16
theorem
for b1 being non empty doubleLoopStr
for b2 being Element of bool the carrier of b1
st b2 is not empty
for b3 being non empty add-closed left-ideal Element of bool the carrier of b1 holds
b3 = b2 -LeftIdeal
iff
b2 c= b3 &
(for b4 being non empty add-closed left-ideal Element of bool the carrier of b1
st b2 c= b4
holds b3 c= b4);
:: IDEAL_1:funcnot 9 => IDEAL_1:func 9
definition
let a1 be non empty doubleLoopStr;
let a2 be Element of bool the carrier of a1;
assume a2 is not empty;
func A2 -RightIdeal -> non empty add-closed right-ideal Element of bool the carrier of a1 means
a2 c= it &
(for b1 being non empty add-closed right-ideal Element of bool the carrier of a1
st a2 c= b1
holds it c= b1);
end;
:: IDEAL_1:def 17
theorem
for b1 being non empty doubleLoopStr
for b2 being Element of bool the carrier of b1
st b2 is not empty
for b3 being non empty add-closed right-ideal Element of bool the carrier of b1 holds
b3 = b2 -RightIdeal
iff
b2 c= b3 &
(for b4 being non empty add-closed right-ideal Element of bool the carrier of b1
st b2 c= b4
holds b3 c= b4);
:: IDEAL_1:th 44
theorem
for b1 being non empty doubleLoopStr
for b2 being non empty add-closed left-ideal right-ideal Element of bool the carrier of b1 holds
b2 -Ideal = b2;
:: IDEAL_1:th 45
theorem
for b1 being non empty doubleLoopStr
for b2 being non empty add-closed left-ideal Element of bool the carrier of b1 holds
b2 -LeftIdeal = b2;
:: IDEAL_1:th 46
theorem
for b1 being non empty doubleLoopStr
for b2 being non empty add-closed right-ideal Element of bool the carrier of b1 holds
b2 -RightIdeal = b2;
:: IDEAL_1:modenot 7 => IDEAL_1:mode 4
definition
let a1 be non empty doubleLoopStr;
let a2 be non empty add-closed left-ideal right-ideal Element of bool the carrier of a1;
mode Basis of A2 -> non empty Element of bool the carrier of a1 means
it -Ideal = a2;
end;
:: IDEAL_1:dfs 18
definiens
let a1 be non empty doubleLoopStr;
let a2 be non empty add-closed left-ideal right-ideal Element of bool the carrier of a1;
let a3 be non empty Element of bool the carrier of a1;
To prove
a3 is Basis of a2
it is sufficient to prove
thus a3 -Ideal = a2;
:: IDEAL_1:def 18
theorem
for b1 being non empty doubleLoopStr
for b2 being non empty add-closed left-ideal right-ideal Element of bool the carrier of b1
for b3 being non empty Element of bool the carrier of b1 holds
b3 is Basis of b2
iff
b3 -Ideal = b2;
:: IDEAL_1:th 47
theorem
for b1 being non empty right_complementable add-associative right_zeroed distributive doubleLoopStr holds
{0. b1} -Ideal = {0. b1};
:: IDEAL_1:th 48
theorem
for b1 being non empty add-cancelable right_zeroed distributive left_zeroed doubleLoopStr holds
{0. b1} -Ideal = {0. b1};
:: IDEAL_1:th 49
theorem
for b1 being non empty right_add-cancelable right_zeroed right-distributive left_zeroed doubleLoopStr holds
{0. b1} -LeftIdeal = {0. b1};
:: IDEAL_1:th 50
theorem
for b1 being non empty left_add-cancelable right_zeroed left-distributive doubleLoopStr holds
{0. b1} -RightIdeal = {0. b1};
:: IDEAL_1:th 51
theorem
for b1 being non empty well-unital doubleLoopStr holds
{1. b1} -Ideal = the carrier of b1;
:: IDEAL_1:th 52
theorem
for b1 being non empty right_unital doubleLoopStr holds
{1. b1} -LeftIdeal = the carrier of b1;
:: IDEAL_1:th 53
theorem
for b1 being non empty left_unital doubleLoopStr holds
{1. b1} -RightIdeal = the carrier of b1;
:: IDEAL_1:th 54
theorem
for b1 being non empty doubleLoopStr holds
([#] b1) -Ideal = the carrier of b1;
:: IDEAL_1:th 55
theorem
for b1 being non empty doubleLoopStr holds
([#] b1) -LeftIdeal = the carrier of b1;
:: IDEAL_1:th 56
theorem
for b1 being non empty doubleLoopStr holds
([#] b1) -RightIdeal = the carrier of b1;
:: IDEAL_1:th 57
theorem
for b1 being non empty doubleLoopStr
for b2, b3 being non empty Element of bool the carrier of b1
st b2 c= b3
holds b2 -Ideal c= b3 -Ideal;
:: IDEAL_1:th 58
theorem
for b1 being non empty doubleLoopStr
for b2, b3 being non empty Element of bool the carrier of b1
st b2 c= b3
holds b2 -LeftIdeal c= b3 -LeftIdeal;
:: IDEAL_1:th 59
theorem
for b1 being non empty doubleLoopStr
for b2, b3 being non empty Element of bool the carrier of b1
st b2 c= b3
holds b2 -RightIdeal c= b3 -RightIdeal;
:: IDEAL_1:th 60
theorem
for b1 being non empty add-cancelable add-associative right_zeroed associative well-unital distributive left_zeroed doubleLoopStr
for b2 being non empty Element of bool the carrier of b1
for b3 being set holds
b3 in b2 -Ideal
iff
ex b4 being LinearCombination of b2 st
b3 = Sum b4;
:: IDEAL_1:th 61
theorem
for b1 being non empty add-cancelable add-associative right_zeroed associative well-unital distributive left_zeroed doubleLoopStr
for b2 being non empty Element of bool the carrier of b1
for b3 being set holds
b3 in b2 -LeftIdeal
iff
ex b4 being LeftLinearCombination of b2 st
b3 = Sum b4;
:: IDEAL_1:th 62
theorem
for b1 being non empty add-cancelable add-associative right_zeroed associative well-unital distributive left_zeroed doubleLoopStr
for b2 being non empty Element of bool the carrier of b1
for b3 being set holds
b3 in b2 -RightIdeal
iff
ex b4 being RightLinearCombination of b2 st
b3 = Sum b4;
:: IDEAL_1:th 63
theorem
for b1 being non empty add-cancelable add-associative right_zeroed associative commutative well-unital distributive left_zeroed doubleLoopStr
for b2 being non empty Element of bool the carrier of b1 holds
b2 -Ideal = b2 -LeftIdeal & b2 -Ideal = b2 -RightIdeal;
:: IDEAL_1:th 64
theorem
for b1 being non empty add-cancelable add-associative right_zeroed associative commutative well-unital distributive left_zeroed doubleLoopStr
for b2 being Element of the carrier of b1 holds
{b2} -Ideal = {b2 * b3 where b3 is Element of the carrier of b1: TRUE};
:: IDEAL_1:th 65
theorem
for b1 being non empty add-cancelable Abelian add-associative right_zeroed associative commutative well-unital distributive left_zeroed doubleLoopStr
for b2, b3 being Element of the carrier of b1 holds
{b2,b3} -Ideal = {(b2 * b4) + (b3 * b5) where b4 is Element of the carrier of b1, b5 is Element of the carrier of b1: TRUE};
:: IDEAL_1:th 66
theorem
for b1 being non empty doubleLoopStr
for b2 being Element of the carrier of b1 holds
b2 in {b2} -Ideal;
:: IDEAL_1:th 67
theorem
for b1 being non empty right_complementable Abelian add-associative right_zeroed associative commutative well-unital distributive left_zeroed doubleLoopStr
for b2 being non empty Element of bool the carrier of b1
for b3 being Element of the carrier of b1
st b3 in b2 -Ideal
holds {b3} -Ideal c= b2 -Ideal;
:: IDEAL_1:th 68
theorem
for b1 being non empty doubleLoopStr
for b2, b3 being Element of the carrier of b1 holds
b2 in {b2,b3} -Ideal & b3 in {b2,b3} -Ideal;
:: IDEAL_1:th 69
theorem
for b1 being non empty doubleLoopStr
for b2, b3 being Element of the carrier of b1 holds
{b2} -Ideal c= {b2,b3} -Ideal &
{b3} -Ideal c= {b2,b3} -Ideal;
:: IDEAL_1:funcnot 10 => IDEAL_1:func 10
definition
let a1 be non empty multMagma;
let a2 be Element of bool the carrier of a1;
let a3 be Element of the carrier of a1;
func A3 * A2 -> Element of bool the carrier of a1 equals
{a3 * b1 where b1 is Element of the carrier of a1: b1 in a2};
end;
:: IDEAL_1:def 19
theorem
for b1 being non empty multMagma
for b2 being Element of bool the carrier of b1
for b3 being Element of the carrier of b1 holds
b3 * b2 = {b3 * b4 where b4 is Element of the carrier of b1: b4 in b2};
:: IDEAL_1:funcreg 8
registration
let a1 be non empty multLoopStr;
let a2 be non empty Element of bool the carrier of a1;
let a3 be Element of the carrier of a1;
cluster a3 * a2 -> non empty;
end;
:: IDEAL_1:funcreg 9
registration
let a1 be non empty distributive doubleLoopStr;
let a2 be add-closed Element of bool the carrier of a1;
let a3 be Element of the carrier of a1;
cluster a3 * a2 -> add-closed;
end;
:: IDEAL_1:funcreg 10
registration
let a1 be non empty associative doubleLoopStr;
let a2 be right-ideal Element of bool the carrier of a1;
let a3 be Element of the carrier of a1;
cluster a3 * a2 -> right-ideal;
end;
:: IDEAL_1:th 70
theorem
for b1 being non empty left_add-cancelable right_zeroed left-distributive doubleLoopStr
for b2 being non empty Element of bool the carrier of b1 holds
(0. b1) * b2 = {0. b1};
:: IDEAL_1:th 71
theorem
for b1 being non empty left_unital doubleLoopStr
for b2 being Element of bool the carrier of b1 holds
(1. b1) * b2 = b2;
:: IDEAL_1:funcnot 11 => IDEAL_1:func 11
definition
let a1 be non empty addLoopStr;
let a2, a3 be Element of bool the carrier of a1;
func A2 + A3 -> Element of bool the carrier of a1 equals
{b1 + b2 where b1 is Element of the carrier of a1, b2 is Element of the carrier of a1: b1 in a2 & b2 in a3};
end;
:: IDEAL_1:def 20
theorem
for b1 being non empty addLoopStr
for b2, b3 being Element of bool the carrier of b1 holds
b2 + b3 = {b4 + b5 where b4 is Element of the carrier of b1, b5 is Element of the carrier of b1: b4 in b2 & b5 in b3};
:: IDEAL_1:funcreg 11
registration
let a1 be non empty addLoopStr;
let a2, a3 be non empty Element of bool the carrier of a1;
cluster a2 + a3 -> non empty;
end;
:: IDEAL_1:funcnot 12 => IDEAL_1:func 12
definition
let a1 be non empty Abelian addLoopStr;
let a2, a3 be Element of bool the carrier of a1;
redefine func a2 + a3 -> Element of bool the carrier of a1;
commutativity;
:: for a1 being non empty Abelian addLoopStr
:: for a2, a3 being Element of bool the carrier of a1 holds
:: a2 + a3 = a3 + a2;
end;
:: IDEAL_1:funcreg 12
registration
let a1 be non empty Abelian add-associative addLoopStr;
let a2, a3 be add-closed Element of bool the carrier of a1;
cluster a2 + a3 -> add-closed;
end;
:: IDEAL_1:funcreg 13
registration
let a1 be non empty left-distributive doubleLoopStr;
let a2, a3 be right-ideal Element of bool the carrier of a1;
cluster a2 + a3 -> right-ideal;
end;
:: IDEAL_1:funcreg 14
registration
let a1 be non empty right-distributive doubleLoopStr;
let a2, a3 be left-ideal Element of bool the carrier of a1;
cluster a2 + a3 -> left-ideal;
end;
:: IDEAL_1:th 72
theorem
for b1 being non empty add-associative addLoopStr
for b2, b3, b4 being Element of bool the carrier of b1 holds
b2 + (b3 + b4) = (b2 + b3) + b4;
:: IDEAL_1:th 73
theorem
for b1 being non empty right_add-cancelable right_zeroed right-distributive left_zeroed doubleLoopStr
for b2, b3 being non empty right-ideal Element of bool the carrier of b1 holds
b2 c= b2 + b3;
:: IDEAL_1:th 74
theorem
for b1 being non empty right_add-cancelable right-distributive left_zeroed doubleLoopStr
for b2, b3 being non empty right-ideal Element of bool the carrier of b1 holds
b3 c= b2 + b3;
:: IDEAL_1:th 75
theorem
for b1 being non empty addLoopStr
for b2, b3 being Element of bool the carrier of b1
for b4 being add-closed Element of bool the carrier of b1
st b2 c= b4 & b3 c= b4
holds b2 + b3 c= b4;
:: IDEAL_1:th 76
theorem
for b1 being non empty add-cancelable Abelian add-associative right_zeroed associative commutative well-unital distributive left_zeroed doubleLoopStr
for b2, b3 being Element of the carrier of b1 holds
{b2,b3} -Ideal = {b2} -Ideal + ({b3} -Ideal);
:: IDEAL_1:funcnot 13 => IDEAL_1:func 13
definition
let a1 be non empty 1-sorted;
let a2, a3 be Element of bool the carrier of a1;
redefine func A2 /\ A3 -> Element of bool the carrier of a1 equals
{b1 where b1 is Element of the carrier of a1: b1 in a2 & b1 in a3};
commutativity;
:: for a1 being non empty 1-sorted
:: for a2, a3 being Element of bool the carrier of a1 holds
:: a2 /\ a3 = a3 /\ a2;
idempotence;
:: for a1 being non empty 1-sorted
:: for a2 being Element of bool the carrier of a1 holds
:: a2 /\ a2 = a2;
end;
:: IDEAL_1:def 21
theorem
for b1 being non empty 1-sorted
for b2, b3 being Element of bool the carrier of b1 holds
b2 /\ b3 = {b4 where b4 is Element of the carrier of b1: b4 in b2 & b4 in b3};
:: IDEAL_1:funcreg 15
registration
let a1 be non empty left_add-cancelable right_zeroed left-distributive doubleLoopStr;
let a2, a3 be non empty left-ideal Element of bool the carrier of a1;
cluster a2 /\ a3 -> non empty;
end;
:: IDEAL_1:funcreg 16
registration
let a1 be non empty addLoopStr;
let a2, a3 be add-closed Element of bool the carrier of a1;
cluster a2 /\ a3 -> add-closed;
end;
:: IDEAL_1:funcreg 17
registration
let a1 be non empty multLoopStr;
let a2, a3 be left-ideal Element of bool the carrier of a1;
cluster a2 /\ a3 -> left-ideal;
end;
:: IDEAL_1:funcreg 18
registration
let a1 be non empty multLoopStr;
let a2, a3 be right-ideal Element of bool the carrier of a1;
cluster a2 /\ a3 -> right-ideal;
end;
:: IDEAL_1:th 80
theorem
for b1 being non empty right_complementable Abelian add-associative right_zeroed left-distributive left_unital left_zeroed doubleLoopStr
for b2 being non empty add-closed left-ideal Element of bool the carrier of b1
for b3 being Element of bool the carrier of b1
for b4 being non empty Element of bool the carrier of b1
st b3 c= b2
holds b2 /\ (b3 + b4) = b3 + (b2 /\ b4);
:: IDEAL_1:funcnot 14 => IDEAL_1:func 14
definition
let a1 be non empty doubleLoopStr;
let a2, a3 be Element of bool the carrier of a1;
func A2 *' A3 -> Element of bool the carrier of a1 equals
{Sum b1 where b1 is FinSequence of the carrier of a1: for b2 being Element of NAT
st 1 <= b2 & b2 <= len b1
holds ex b3, b4 being Element of the carrier of a1 st
b1 . b2 = b3 * b4 & b3 in a2 & b4 in a3};
end;
:: IDEAL_1:def 22
theorem
for b1 being non empty doubleLoopStr
for b2, b3 being Element of bool the carrier of b1 holds
b2 *' b3 = {Sum b4 where b4 is FinSequence of the carrier of b1: for b5 being Element of NAT
st 1 <= b5 & b5 <= len b4
holds ex b6, b7 being Element of the carrier of b1 st
b4 . b5 = b6 * b7 & b6 in b2 & b7 in b3};
:: IDEAL_1:funcreg 19
registration
let a1 be non empty doubleLoopStr;
let a2, a3 be Element of bool the carrier of a1;
cluster a2 *' a3 -> non empty;
end;
:: IDEAL_1:funcnot 15 => IDEAL_1:func 15
definition
let a1 be non empty commutative doubleLoopStr;
let a2, a3 be Element of bool the carrier of a1;
redefine func a2 *' a3 -> Element of bool the carrier of a1;
commutativity;
:: for a1 being non empty commutative doubleLoopStr
:: for a2, a3 being Element of bool the carrier of a1 holds
:: a2 *' a3 = a3 *' a2;
end;
:: IDEAL_1:funcreg 20
registration
let a1 be non empty add-associative right_zeroed doubleLoopStr;
let a2, a3 be Element of bool the carrier of a1;
cluster a2 *' a3 -> add-closed;
end;
:: IDEAL_1:funcreg 21
registration
let a1 be non empty left_add-cancelable right_zeroed associative left-distributive doubleLoopStr;
let a2, a3 be right-ideal Element of bool the carrier of a1;
cluster a2 *' a3 -> right-ideal;
end;
:: IDEAL_1:funcreg 22
registration
let a1 be non empty right_add-cancelable associative right-distributive left_zeroed doubleLoopStr;
let a2, a3 be left-ideal Element of bool the carrier of a1;
cluster a2 *' a3 -> left-ideal;
end;
:: IDEAL_1:th 81
theorem
for b1 being non empty left_add-cancelable right_zeroed left-distributive left_zeroed doubleLoopStr
for b2 being non empty Element of bool the carrier of b1 holds
{0. b1} *' b2 = {0. b1};
:: IDEAL_1:th 82
theorem
for b1 being non empty add-cancelable right_zeroed distributive left_zeroed doubleLoopStr
for b2 being non empty add-closed right-ideal Element of bool the carrier of b1
for b3 being non empty add-closed left-ideal Element of bool the carrier of b1 holds
b2 *' b3 c= b2 /\ b3;
:: IDEAL_1:th 83
theorem
for b1 being non empty add-cancelable Abelian add-associative right_zeroed associative distributive left_zeroed doubleLoopStr
for b2, b3, b4 being non empty right-ideal Element of bool the carrier of b1 holds
b2 *' (b3 + b4) = (b2 *' b3) + (b2 *' b4);
:: IDEAL_1:th 84
theorem
for b1 being non empty add-cancelable Abelian add-associative right_zeroed associative commutative distributive left_zeroed doubleLoopStr
for b2, b3 being non empty right-ideal Element of bool the carrier of b1 holds
(b2 + b3) *' (b2 /\ b3) c= b2 *' b3;
:: IDEAL_1:th 85
theorem
for b1 being non empty left_add-cancelable right_zeroed left-distributive doubleLoopStr
for b2, b3 being non empty add-closed left-ideal Element of bool the carrier of b1 holds
(b2 + b3) *' (b2 /\ b3) c= b2 /\ b3;
:: IDEAL_1:prednot 4 => IDEAL_1:pred 4
definition
let a1 be non empty addLoopStr;
let a2, a3 be Element of bool the carrier of a1;
pred A2,A3 are_co-prime means
a2 + a3 = the carrier of a1;
end;
:: IDEAL_1:dfs 23
definiens
let a1 be non empty addLoopStr;
let a2, a3 be Element of bool the carrier of a1;
To prove
a2,a3 are_co-prime
it is sufficient to prove
thus a2 + a3 = the carrier of a1;
:: IDEAL_1:def 23
theorem
for b1 being non empty addLoopStr
for b2, b3 being Element of bool the carrier of b1 holds
b2,b3 are_co-prime
iff
b2 + b3 = the carrier of b1;
:: IDEAL_1:th 86
theorem
for b1 being non empty left_unital left_zeroed doubleLoopStr
for b2, b3 being non empty Element of bool the carrier of b1
st b2,b3 are_co-prime
holds b2 /\ b3 c= (b2 + b3) *' (b2 /\ b3);
:: IDEAL_1:th 87
theorem
for b1 being non empty add-cancelable Abelian add-associative right_zeroed associative commutative distributive left_unital left_zeroed doubleLoopStr
for b2 being non empty add-closed left-ideal right-ideal Element of bool the carrier of b1
for b3 being non empty add-closed left-ideal Element of bool the carrier of b1
st b2,b3 are_co-prime
holds b2 *' b3 = b2 /\ b3;
:: IDEAL_1:funcnot 16 => IDEAL_1:func 16
definition
let a1 be non empty multMagma;
let a2, a3 be Element of bool the carrier of a1;
func A2 % A3 -> Element of bool the carrier of a1 equals
{b1 where b1 is Element of the carrier of a1: b1 * a3 c= a2};
end;
:: IDEAL_1:def 24
theorem
for b1 being non empty multMagma
for b2, b3 being Element of bool the carrier of b1 holds
b2 % b3 = {b4 where b4 is Element of the carrier of b1: b4 * b3 c= b2};
:: IDEAL_1:funcreg 23
registration
let a1 be non empty left_add-cancelable right_zeroed left-distributive doubleLoopStr;
let a2, a3 be non empty left-ideal Element of bool the carrier of a1;
cluster a2 % a3 -> non empty;
end;
:: IDEAL_1:funcreg 24
registration
let a1 be non empty left_add-cancelable right_zeroed left-distributive doubleLoopStr;
let a2, a3 be non empty add-closed left-ideal Element of bool the carrier of a1;
cluster a2 % a3 -> add-closed;
end;
:: IDEAL_1:funcreg 25
registration
let a1 be non empty left_add-cancelable right_zeroed associative commutative left-distributive doubleLoopStr;
let a2, a3 be non empty left-ideal Element of bool the carrier of a1;
cluster a2 % a3 -> left-ideal;
end;
:: IDEAL_1:funcreg 26
registration
let a1 be non empty left_add-cancelable right_zeroed associative commutative left-distributive doubleLoopStr;
let a2, a3 be non empty left-ideal Element of bool the carrier of a1;
cluster a2 % a3 -> right-ideal;
end;
:: IDEAL_1:th 88
theorem
for b1 being non empty multLoopStr
for b2 being non empty right-ideal Element of bool the carrier of b1
for b3 being Element of bool the carrier of b1 holds
b2 c= b2 % b3;
:: IDEAL_1:th 89
theorem
for b1 being non empty left_add-cancelable right_zeroed left-distributive doubleLoopStr
for b2 being non empty add-closed left-ideal Element of bool the carrier of b1
for b3 being Element of bool the carrier of b1 holds
(b2 % b3) *' b3 c= b2;
:: IDEAL_1:th 90
theorem
for b1 being non empty right_add-cancelable right-distributive left_zeroed doubleLoopStr
for b2 being non empty add-closed right-ideal Element of bool the carrier of b1
for b3 being Element of bool the carrier of b1 holds
(b2 % b3) *' b3 c= b2;
:: IDEAL_1:th 91
theorem
for b1 being non empty right_add-cancelable associative commutative right-distributive left_zeroed doubleLoopStr
for b2 being non empty add-closed right-ideal Element of bool the carrier of b1
for b3, b4 being Element of bool the carrier of b1 holds
(b2 % b3) % b4 = b2 % (b3 *' b4);
:: IDEAL_1:th 92
theorem
for b1 being non empty multLoopStr
for b2, b3, b4 being Element of bool the carrier of b1 holds
(b3 /\ b4) % b2 = (b3 % b2) /\ (b4 % b2);
:: IDEAL_1:th 93
theorem
for b1 being non empty right_add-cancelable right_zeroed right-distributive left_zeroed doubleLoopStr
for b2 being add-closed Element of bool the carrier of b1
for b3, b4 being non empty right-ideal Element of bool the carrier of b1 holds
b2 % (b3 + b4) = (b2 % b3) /\ (b2 % b4);
:: IDEAL_1:funcnot 17 => IDEAL_1:func 17
definition
let a1 be non empty well-unital doubleLoopStr;
let a2 be Element of bool the carrier of a1;
func sqrt A2 -> Element of bool the carrier of a1 equals
{b1 where b1 is Element of the carrier of a1: ex b2 being Element of NAT st
b1 |^ b2 in a2};
end;
:: IDEAL_1:def 25
theorem
for b1 being non empty well-unital doubleLoopStr
for b2 being Element of bool the carrier of b1 holds
sqrt b2 = {b3 where b3 is Element of the carrier of b1: ex b4 being Element of NAT st
b3 |^ b4 in b2};
:: IDEAL_1:funcreg 27
registration
let a1 be non empty well-unital doubleLoopStr;
let a2 be non empty Element of bool the carrier of a1;
cluster sqrt a2 -> non empty;
end;
:: IDEAL_1:funcreg 28
registration
let a1 be non empty add-cancelable Abelian add-associative right_zeroed associative commutative well-unital distributive left_zeroed doubleLoopStr;
let a2 be non empty add-closed right-ideal Element of bool the carrier of a1;
cluster sqrt a2 -> add-closed;
end;
:: IDEAL_1:funcreg 29
registration
let a1 be non empty associative commutative well-unital doubleLoopStr;
let a2 be non empty left-ideal Element of bool the carrier of a1;
cluster sqrt a2 -> left-ideal;
end;
:: IDEAL_1:funcreg 30
registration
let a1 be non empty associative commutative well-unital doubleLoopStr;
let a2 be non empty left-ideal Element of bool the carrier of a1;
cluster sqrt a2 -> right-ideal;
end;
:: IDEAL_1:th 94
theorem
for b1 being non empty associative well-unital doubleLoopStr
for b2 being non empty Element of bool the carrier of b1
for b3 being Element of the carrier of b1 holds
b3 in sqrt b2
iff
ex b4 being Element of NAT st
b3 |^ b4 in sqrt b2;
:: IDEAL_1:th 95
theorem
for b1 being non empty add-cancelable right_zeroed associative well-unital distributive left_zeroed doubleLoopStr
for b2 being non empty add-closed right-ideal Element of bool the carrier of b1
for b3 being non empty add-closed left-ideal Element of bool the carrier of b1 holds
sqrt (b2 *' b3) = sqrt (b2 /\ b3);
:: IDEAL_1:attrnot 6 => IDEAL_1:attr 6
definition
let a1 be non empty doubleLoopStr;
let a2 be non empty add-closed left-ideal right-ideal Element of bool the carrier of a1;
attr a2 is finitely_generated means
ex b1 being non empty finite Element of bool the carrier of a1 st
a2 = b1 -Ideal;
end;
:: IDEAL_1:dfs 26
definiens
let a1 be non empty doubleLoopStr;
let a2 be non empty add-closed left-ideal right-ideal Element of bool the carrier of a1;
To prove
a2 is finitely_generated
it is sufficient to prove
thus ex b1 being non empty finite Element of bool the carrier of a1 st
a2 = b1 -Ideal;
:: IDEAL_1:def 26
theorem
for b1 being non empty doubleLoopStr
for b2 being non empty add-closed left-ideal right-ideal Element of bool the carrier of b1 holds
b2 is finitely_generated(b1)
iff
ex b3 being non empty finite Element of bool the carrier of b1 st
b2 = b3 -Ideal;
:: IDEAL_1:exreg 14
registration
let a1 be non empty doubleLoopStr;
cluster non empty add-closed left-ideal right-ideal finitely_generated Element of bool the carrier of a1;
end;
:: IDEAL_1:funcreg 31
registration
let a1 be non empty doubleLoopStr;
let a2 be non empty finite Element of bool the carrier of a1;
cluster a2 -Ideal -> non empty add-closed left-ideal right-ideal finitely_generated;
end;
:: IDEAL_1:attrnot 7 => IDEAL_1:attr 7
definition
let a1 be non empty doubleLoopStr;
attr a1 is Noetherian means
for b1 being non empty add-closed left-ideal right-ideal Element of bool the carrier of a1 holds
b1 is finitely_generated(a1);
end;
:: IDEAL_1:dfs 27
definiens
let a1 be non empty doubleLoopStr;
To prove
a1 is Noetherian
it is sufficient to prove
thus for b1 being non empty add-closed left-ideal right-ideal Element of bool the carrier of a1 holds
b1 is finitely_generated(a1);
:: IDEAL_1:def 27
theorem
for b1 being non empty doubleLoopStr holds
b1 is Noetherian
iff
for b2 being non empty add-closed left-ideal right-ideal Element of bool the carrier of b1 holds
b2 is finitely_generated(b1);
:: IDEAL_1:exreg 15
registration
cluster non empty non degenerated right_complementable Abelian add-associative right_zeroed associative commutative well-unital distributive Euclidian doubleLoopStr;
end;
:: IDEAL_1:attrnot 8 => IDEAL_1:attr 8
definition
let a1 be non empty doubleLoopStr;
let a2 be non empty add-closed left-ideal right-ideal Element of bool the carrier of a1;
attr a2 is principal means
ex b1 being Element of the carrier of a1 st
a2 = {b1} -Ideal;
end;
:: IDEAL_1:dfs 28
definiens
let a1 be non empty doubleLoopStr;
let a2 be non empty add-closed left-ideal right-ideal Element of bool the carrier of a1;
To prove
a2 is principal
it is sufficient to prove
thus ex b1 being Element of the carrier of a1 st
a2 = {b1} -Ideal;
:: IDEAL_1:def 28
theorem
for b1 being non empty doubleLoopStr
for b2 being non empty add-closed left-ideal right-ideal Element of bool the carrier of b1 holds
b2 is principal(b1)
iff
ex b3 being Element of the carrier of b1 st
b2 = {b3} -Ideal;
:: IDEAL_1:attrnot 9 => IDEAL_1:attr 9
definition
let a1 be non empty doubleLoopStr;
attr a1 is PID means
for b1 being non empty add-closed left-ideal right-ideal Element of bool the carrier of a1 holds
b1 is principal(a1);
end;
:: IDEAL_1:dfs 29
definiens
let a1 be non empty doubleLoopStr;
To prove
a1 is PID
it is sufficient to prove
thus for b1 being non empty add-closed left-ideal right-ideal Element of bool the carrier of a1 holds
b1 is principal(a1);
:: IDEAL_1:def 29
theorem
for b1 being non empty doubleLoopStr holds
b1 is PID
iff
for b2 being non empty add-closed left-ideal right-ideal Element of bool the carrier of b1 holds
b2 is principal(b1);
:: IDEAL_1:th 96
theorem
for b1 being non empty doubleLoopStr
for b2 being non empty Element of bool the carrier of b1
st b2 <> {0. b1}
holds ex b3 being Element of the carrier of b1 st
b3 <> 0. b1 & b3 in b2;
:: IDEAL_1:th 97
theorem
for b1 being non empty right_complementable add-associative right_zeroed well-unital distributive left_zeroed Euclidian doubleLoopStr holds
b1 is PID;
:: IDEAL_1:th 98
theorem
for b1 being non empty doubleLoopStr
st b1 is PID
holds b1 is Noetherian;
:: IDEAL_1:funcreg 32
registration
cluster INT.Ring -> Noetherian;
end;
:: IDEAL_1:exreg 16
registration
cluster non empty non degenerated right_complementable Abelian add-associative right_zeroed associative commutative well-unital distributive Noetherian doubleLoopStr;
end;
:: IDEAL_1:th 99
theorem
for b1 being non empty add-cancelable add-associative right_zeroed associative well-unital distributive left_zeroed Noetherian doubleLoopStr
for b2 being non empty Element of bool the carrier of b1 holds
ex b3 being non empty finite Element of bool the carrier of b1 st
b3 c= b2 & b3 -Ideal = b2 -Ideal;
:: IDEAL_1:th 100
theorem
for b1 being non empty doubleLoopStr
st for b2 being non empty Element of bool the carrier of b1 holds
ex b3 being non empty finite Element of bool the carrier of b1 st
b3 c= b2 & b3 -Ideal = b2 -Ideal
for b2 being Function-like quasi_total Relation of NAT,the carrier of b1 holds
ex b3 being Element of NAT st
b2 . (b3 + 1) in (rng (b2 | (b3 + 1))) -Ideal;
:: IDEAL_1:funcreg 33
registration
let a1, a2 be non empty set;
let a3 be Function-like quasi_total Relation of a1,a2;
let a4 be non empty Element of bool a1;
cluster a3 | a4 -> non empty Relation-like;
end;
:: IDEAL_1:th 101
theorem
for b1 being non empty doubleLoopStr
st for b2 being Function-like quasi_total Relation of NAT,the carrier of b1 holds
ex b3 being Element of NAT st
b2 . (b3 + 1) in (rng (b2 | (b3 + 1))) -Ideal
for b2 being Function-like quasi_total Relation of NAT,bool the carrier of b1
st for b3 being Element of NAT holds
b2 . b3 is non empty add-closed left-ideal right-ideal Element of bool the carrier of b1
holds ex b3, b4 being Element of NAT st
b3 < b4 & not b2 . b3 c< b2 . b4;
:: IDEAL_1:th 102
theorem
for b1 being non empty doubleLoopStr
st for b2 being Function-like quasi_total Relation of NAT,bool the carrier of b1
st for b3 being Element of NAT holds
b2 . b3 is non empty add-closed left-ideal right-ideal Element of bool the carrier of b1
holds ex b3, b4 being Element of NAT st
b3 < b4 & not b2 . b3 c< b2 . b4
holds b1 is Noetherian;