Article ALGSTR_0, MML version 4.99.1005
:: ALGSTR_0:structnot 1 => ALGSTR_0:struct 1
definition
struct(1-sorted) addMagma(#
carrier -> set,
addF -> Function-like quasi_total Relation of [:the carrier of it,the carrier of it:],the carrier of it
#);
end;
:: ALGSTR_0:attrnot 1 => ALGSTR_0:attr 1
definition
let a1 be addMagma;
attr a1 is strict;
end;
:: ALGSTR_0:exreg 1
registration
cluster strict addMagma;
end;
:: ALGSTR_0:aggrnot 1 => ALGSTR_0:aggr 1
definition
let a1 be set;
let a2 be Function-like quasi_total Relation of [:a1,a1:],a1;
aggr addMagma(#a1,a2#) -> strict addMagma;
end;
:: ALGSTR_0:selnot 1 => ALGSTR_0:sel 1
definition
let a1 be addMagma;
sel the addF of a1 -> Function-like quasi_total Relation of [:the carrier of a1,the carrier of a1:],the carrier of a1;
end;
:: ALGSTR_0:funcreg 1
registration
let a1 be non empty set;
let a2 be Function-like quasi_total Relation of [:a1,a1:],a1;
cluster addMagma(#a1,a2#) -> non empty strict;
end;
:: ALGSTR_0:funcreg 2
registration
let a1 be trivial set;
let a2 be Function-like quasi_total Relation of [:a1,a1:],a1;
cluster addMagma(#a1,a2#) -> trivial strict;
end;
:: ALGSTR_0:funcreg 3
registration
let a1 be non trivial set;
let a2 be Function-like quasi_total Relation of [:a1,a1:],a1;
cluster addMagma(#a1,a2#) -> non trivial strict;
end;
:: ALGSTR_0:funcnot 1 => ALGSTR_0:func 1
definition
let a1 be addMagma;
let a2, a3 be Element of the carrier of a1;
func A2 + A3 -> Element of the carrier of a1 equals
(the addF of a1) .(a2,a3);
end;
:: ALGSTR_0:def 1
theorem
for b1 being addMagma
for b2, b3 being Element of the carrier of b1 holds
b2 + b3 = (the addF of b1) .(b2,b3);
:: ALGSTR_0:funcnot 2 => ALGSTR_0:func 2
definition
func Trivial-addMagma -> addMagma equals
addMagma(#1,op2#);
end;
:: ALGSTR_0:def 2
theorem
Trivial-addMagma = addMagma(#1,op2#);
:: ALGSTR_0:funcreg 4
registration
cluster Trivial-addMagma -> non empty trivial strict;
end;
:: ALGSTR_0:exreg 2
registration
cluster non empty trivial strict addMagma;
end;
:: ALGSTR_0:attrnot 2 => ALGSTR_0:attr 2
definition
let a1 be addMagma;
let a2 be Element of the carrier of a1;
attr a2 is left_add-cancelable means
for b1, b2 being Element of the carrier of a1
st a2 + b1 = a2 + b2
holds b1 = b2;
end;
:: ALGSTR_0:dfs 3
definiens
let a1 be addMagma;
let a2 be Element of the carrier of a1;
To prove
a2 is left_add-cancelable
it is sufficient to prove
thus for b1, b2 being Element of the carrier of a1
st a2 + b1 = a2 + b2
holds b1 = b2;
:: ALGSTR_0:def 3
theorem
for b1 being addMagma
for b2 being Element of the carrier of b1 holds
b2 is left_add-cancelable(b1)
iff
for b3, b4 being Element of the carrier of b1
st b2 + b3 = b2 + b4
holds b3 = b4;
:: ALGSTR_0:attrnot 3 => ALGSTR_0:attr 3
definition
let a1 be addMagma;
let a2 be Element of the carrier of a1;
attr a2 is right_add-cancelable means
for b1, b2 being Element of the carrier of a1
st b1 + a2 = b2 + a2
holds b1 = b2;
end;
:: ALGSTR_0:dfs 4
definiens
let a1 be addMagma;
let a2 be Element of the carrier of a1;
To prove
a2 is right_add-cancelable
it is sufficient to prove
thus for b1, b2 being Element of the carrier of a1
st b1 + a2 = b2 + a2
holds b1 = b2;
:: ALGSTR_0:def 4
theorem
for b1 being addMagma
for b2 being Element of the carrier of b1 holds
b2 is right_add-cancelable(b1)
iff
for b3, b4 being Element of the carrier of b1
st b3 + b2 = b4 + b2
holds b3 = b4;
:: ALGSTR_0:attrnot 4 => ALGSTR_0:attr 4
definition
let a1 be addMagma;
let a2 be Element of the carrier of a1;
attr a2 is add-cancelable means
a2 is right_add-cancelable(a1) & a2 is left_add-cancelable(a1);
end;
:: ALGSTR_0:dfs 5
definiens
let a1 be addMagma;
let a2 be Element of the carrier of a1;
To prove
a2 is add-cancelable
it is sufficient to prove
thus a2 is right_add-cancelable(a1) & a2 is left_add-cancelable(a1);
:: ALGSTR_0:def 5
theorem
for b1 being addMagma
for b2 being Element of the carrier of b1 holds
b2 is add-cancelable(b1)
iff
b2 is right_add-cancelable(b1) & b2 is left_add-cancelable(b1);
:: ALGSTR_0:condreg 1
registration
let a1 be addMagma;
cluster left_add-cancelable right_add-cancelable -> add-cancelable (Element of the carrier of a1);
end;
:: ALGSTR_0:condreg 2
registration
let a1 be addMagma;
cluster add-cancelable -> left_add-cancelable right_add-cancelable (Element of the carrier of a1);
end;
:: ALGSTR_0:attrnot 5 => ALGSTR_0:attr 5
definition
let a1 be addMagma;
attr a1 is left_add-cancelable means
for b1 being Element of the carrier of a1 holds
b1 is left_add-cancelable(a1);
end;
:: ALGSTR_0:dfs 6
definiens
let a1 be addMagma;
To prove
a1 is left_add-cancelable
it is sufficient to prove
thus for b1 being Element of the carrier of a1 holds
b1 is left_add-cancelable(a1);
:: ALGSTR_0:def 6
theorem
for b1 being addMagma holds
b1 is left_add-cancelable
iff
for b2 being Element of the carrier of b1 holds
b2 is left_add-cancelable(b1);
:: ALGSTR_0:attrnot 6 => ALGSTR_0:attr 6
definition
let a1 be addMagma;
attr a1 is right_add-cancelable means
for b1 being Element of the carrier of a1 holds
b1 is right_add-cancelable(a1);
end;
:: ALGSTR_0:dfs 7
definiens
let a1 be addMagma;
To prove
a1 is right_add-cancelable
it is sufficient to prove
thus for b1 being Element of the carrier of a1 holds
b1 is right_add-cancelable(a1);
:: ALGSTR_0:def 7
theorem
for b1 being addMagma holds
b1 is right_add-cancelable
iff
for b2 being Element of the carrier of b1 holds
b2 is right_add-cancelable(b1);
:: ALGSTR_0:attrnot 7 => ALGSTR_0:attr 7
definition
let a1 be addMagma;
attr a1 is add-cancelable means
a1 is right_add-cancelable & a1 is left_add-cancelable;
end;
:: ALGSTR_0:dfs 8
definiens
let a1 be addMagma;
To prove
a1 is add-cancelable
it is sufficient to prove
thus a1 is right_add-cancelable & a1 is left_add-cancelable;
:: ALGSTR_0:def 8
theorem
for b1 being addMagma holds
b1 is add-cancelable
iff
b1 is right_add-cancelable & b1 is left_add-cancelable;
:: ALGSTR_0:condreg 3
registration
cluster left_add-cancelable right_add-cancelable -> add-cancelable (addMagma);
end;
:: ALGSTR_0:condreg 4
registration
cluster add-cancelable -> left_add-cancelable right_add-cancelable (addMagma);
end;
:: ALGSTR_0:funcreg 5
registration
cluster Trivial-addMagma -> add-cancelable;
end;
:: ALGSTR_0:exreg 3
registration
cluster non empty trivial strict add-cancelable addMagma;
end;
:: ALGSTR_0:condreg 5
registration
let a1 be left_add-cancelable addMagma;
cluster -> left_add-cancelable (Element of the carrier of a1);
end;
:: ALGSTR_0:condreg 6
registration
let a1 be right_add-cancelable addMagma;
cluster -> right_add-cancelable (Element of the carrier of a1);
end;
:: ALGSTR_0:structnot 2 => ALGSTR_0:struct 2
definition
struct(ZeroStr, addMagma) addLoopStr(#
carrier -> set,
addF -> Function-like quasi_total Relation of [:the carrier of it,the carrier of it:],the carrier of it,
ZeroF -> Element of the carrier of it
#);
end;
:: ALGSTR_0:attrnot 8 => ALGSTR_0:attr 8
definition
let a1 be addLoopStr;
attr a1 is strict;
end;
:: ALGSTR_0:exreg 4
registration
cluster strict addLoopStr;
end;
:: ALGSTR_0:aggrnot 2 => ALGSTR_0:aggr 2
definition
let a1 be set;
let a2 be Function-like quasi_total Relation of [:a1,a1:],a1;
let a3 be Element of a1;
aggr addLoopStr(#a1,a2,a3#) -> strict addLoopStr;
end;
:: ALGSTR_0:funcreg 6
registration
let a1 be non empty set;
let a2 be Function-like quasi_total Relation of [:a1,a1:],a1;
let a3 be Element of a1;
cluster addLoopStr(#a1,a2,a3#) -> non empty strict;
end;
:: ALGSTR_0:funcreg 7
registration
let a1 be trivial set;
let a2 be Function-like quasi_total Relation of [:a1,a1:],a1;
let a3 be Element of a1;
cluster addLoopStr(#a1,a2,a3#) -> trivial strict;
end;
:: ALGSTR_0:funcreg 8
registration
let a1 be non trivial set;
let a2 be Function-like quasi_total Relation of [:a1,a1:],a1;
let a3 be Element of a1;
cluster addLoopStr(#a1,a2,a3#) -> non trivial strict;
end;
:: ALGSTR_0:funcnot 3 => ALGSTR_0:func 3
definition
func Trivial-addLoopStr -> addLoopStr equals
addLoopStr(#1,op2,op0#);
end;
:: ALGSTR_0:def 9
theorem
Trivial-addLoopStr = addLoopStr(#1,op2,op0#);
:: ALGSTR_0:funcreg 9
registration
cluster Trivial-addLoopStr -> non empty trivial strict;
end;
:: ALGSTR_0:exreg 5
registration
cluster non empty trivial strict addLoopStr;
end;
:: ALGSTR_0:attrnot 9 => ALGSTR_0:attr 9
definition
let a1 be addLoopStr;
let a2 be Element of the carrier of a1;
attr a2 is left_complementable means
ex b1 being Element of the carrier of a1 st
b1 + a2 = 0. a1;
end;
:: ALGSTR_0:dfs 10
definiens
let a1 be addLoopStr;
let a2 be Element of the carrier of a1;
To prove
a2 is left_complementable
it is sufficient to prove
thus ex b1 being Element of the carrier of a1 st
b1 + a2 = 0. a1;
:: ALGSTR_0:def 10
theorem
for b1 being addLoopStr
for b2 being Element of the carrier of b1 holds
b2 is left_complementable(b1)
iff
ex b3 being Element of the carrier of b1 st
b3 + b2 = 0. b1;
:: ALGSTR_0:attrnot 10 => ALGSTR_0:attr 10
definition
let a1 be addLoopStr;
let a2 be Element of the carrier of a1;
attr a2 is right_complementable means
ex b1 being Element of the carrier of a1 st
a2 + b1 = 0. a1;
end;
:: ALGSTR_0:dfs 11
definiens
let a1 be addLoopStr;
let a2 be Element of the carrier of a1;
To prove
a2 is right_complementable
it is sufficient to prove
thus ex b1 being Element of the carrier of a1 st
a2 + b1 = 0. a1;
:: ALGSTR_0:def 11
theorem
for b1 being addLoopStr
for b2 being Element of the carrier of b1 holds
b2 is right_complementable(b1)
iff
ex b3 being Element of the carrier of b1 st
b2 + b3 = 0. b1;
:: ALGSTR_0:attrnot 11 => ALGSTR_0:attr 11
definition
let a1 be addLoopStr;
let a2 be Element of the carrier of a1;
attr a2 is complementable means
a2 is right_complementable(a1) & a2 is left_complementable(a1);
end;
:: ALGSTR_0:dfs 12
definiens
let a1 be addLoopStr;
let a2 be Element of the carrier of a1;
To prove
a2 is complementable
it is sufficient to prove
thus a2 is right_complementable(a1) & a2 is left_complementable(a1);
:: ALGSTR_0:def 12
theorem
for b1 being addLoopStr
for b2 being Element of the carrier of b1 holds
b2 is complementable(b1)
iff
b2 is right_complementable(b1) & b2 is left_complementable(b1);
:: ALGSTR_0:condreg 7
registration
let a1 be addLoopStr;
cluster left_complementable right_complementable -> complementable (Element of the carrier of a1);
end;
:: ALGSTR_0:condreg 8
registration
let a1 be addLoopStr;
cluster complementable -> left_complementable right_complementable (Element of the carrier of a1);
end;
:: ALGSTR_0:funcnot 4 => ALGSTR_0:func 4
definition
let a1 be addLoopStr;
let a2 be Element of the carrier of a1;
assume a2 is left_complementable(a1) & a2 is right_add-cancelable(a1);
func - A2 -> Element of the carrier of a1 means
it + a2 = 0. a1;
end;
:: ALGSTR_0:def 13
theorem
for b1 being addLoopStr
for b2 being Element of the carrier of b1
st b2 is left_complementable(b1) & b2 is right_add-cancelable(b1)
for b3 being Element of the carrier of b1 holds
b3 = - b2
iff
b3 + b2 = 0. b1;
:: ALGSTR_0:funcnot 5 => ALGSTR_0:func 5
definition
let a1 be addLoopStr;
let a2, a3 be Element of the carrier of a1;
func A2 - A3 -> Element of the carrier of a1 equals
a2 + - a3;
end;
:: ALGSTR_0:def 14
theorem
for b1 being addLoopStr
for b2, b3 being Element of the carrier of b1 holds
b2 - b3 = b2 + - b3;
:: ALGSTR_0:funcreg 10
registration
cluster Trivial-addLoopStr -> add-cancelable;
end;
:: ALGSTR_0:attrnot 12 => ALGSTR_0:attr 12
definition
let a1 be addLoopStr;
attr a1 is left_complementable means
for b1 being Element of the carrier of a1 holds
b1 is left_complementable(a1);
end;
:: ALGSTR_0:dfs 15
definiens
let a1 be addLoopStr;
To prove
a1 is left_complementable
it is sufficient to prove
thus for b1 being Element of the carrier of a1 holds
b1 is left_complementable(a1);
:: ALGSTR_0:def 15
theorem
for b1 being addLoopStr holds
b1 is left_complementable
iff
for b2 being Element of the carrier of b1 holds
b2 is left_complementable(b1);
:: ALGSTR_0:attrnot 13 => ALGSTR_0:attr 13
definition
let a1 be addLoopStr;
attr a1 is right_complementable means
for b1 being Element of the carrier of a1 holds
b1 is right_complementable(a1);
end;
:: ALGSTR_0:dfs 16
definiens
let a1 be addLoopStr;
To prove
a1 is right_complementable
it is sufficient to prove
thus for b1 being Element of the carrier of a1 holds
b1 is right_complementable(a1);
:: ALGSTR_0:def 16
theorem
for b1 being addLoopStr holds
b1 is right_complementable
iff
for b2 being Element of the carrier of b1 holds
b2 is right_complementable(b1);
:: ALGSTR_0:attrnot 14 => ALGSTR_0:attr 14
definition
let a1 be addLoopStr;
attr a1 is complementable means
a1 is right_complementable & a1 is left_complementable;
end;
:: ALGSTR_0:dfs 17
definiens
let a1 be addLoopStr;
To prove
a1 is complementable
it is sufficient to prove
thus a1 is right_complementable & a1 is left_complementable;
:: ALGSTR_0:def 17
theorem
for b1 being addLoopStr holds
b1 is complementable
iff
b1 is right_complementable & b1 is left_complementable;
:: ALGSTR_0:condreg 9
registration
cluster left_complementable right_complementable -> complementable (addLoopStr);
end;
:: ALGSTR_0:condreg 10
registration
cluster complementable -> left_complementable right_complementable (addLoopStr);
end;
:: ALGSTR_0:funcreg 11
registration
cluster Trivial-addLoopStr -> complementable;
end;
:: ALGSTR_0:exreg 6
registration
cluster non empty trivial add-cancelable strict complementable addLoopStr;
end;
:: ALGSTR_0:condreg 11
registration
let a1 be left_complementable addLoopStr;
cluster -> left_complementable (Element of the carrier of a1);
end;
:: ALGSTR_0:condreg 12
registration
let a1 be right_complementable addLoopStr;
cluster -> right_complementable (Element of the carrier of a1);
end;
:: ALGSTR_0:structnot 3 => ALGSTR_0:struct 3
definition
struct(1-sorted) multMagma(#
carrier -> set,
multF -> Function-like quasi_total Relation of [:the carrier of it,the carrier of it:],the carrier of it
#);
end;
:: ALGSTR_0:attrnot 15 => ALGSTR_0:attr 15
definition
let a1 be multMagma;
attr a1 is strict;
end;
:: ALGSTR_0:exreg 7
registration
cluster strict multMagma;
end;
:: ALGSTR_0:aggrnot 3 => ALGSTR_0:aggr 3
definition
let a1 be set;
let a2 be Function-like quasi_total Relation of [:a1,a1:],a1;
aggr multMagma(#a1,a2#) -> strict multMagma;
end;
:: ALGSTR_0:selnot 2 => ALGSTR_0:sel 2
definition
let a1 be multMagma;
sel the multF of a1 -> Function-like quasi_total Relation of [:the carrier of a1,the carrier of a1:],the carrier of a1;
end;
:: ALGSTR_0:funcreg 12
registration
let a1 be non empty set;
let a2 be Function-like quasi_total Relation of [:a1,a1:],a1;
cluster multMagma(#a1,a2#) -> non empty strict;
end;
:: ALGSTR_0:funcreg 13
registration
let a1 be trivial set;
let a2 be Function-like quasi_total Relation of [:a1,a1:],a1;
cluster multMagma(#a1,a2#) -> trivial strict;
end;
:: ALGSTR_0:funcreg 14
registration
let a1 be non trivial set;
let a2 be Function-like quasi_total Relation of [:a1,a1:],a1;
cluster multMagma(#a1,a2#) -> non trivial strict;
end;
:: ALGSTR_0:funcnot 6 => ALGSTR_0:func 6
definition
let a1 be multMagma;
let a2, a3 be Element of the carrier of a1;
func A2 * A3 -> Element of the carrier of a1 equals
(the multF of a1) .(a2,a3);
end;
:: ALGSTR_0:def 18
theorem
for b1 being multMagma
for b2, b3 being Element of the carrier of b1 holds
b2 * b3 = (the multF of b1) .(b2,b3);
:: ALGSTR_0:funcnot 7 => ALGSTR_0:func 7
definition
func Trivial-multMagma -> multMagma equals
multMagma(#1,op2#);
end;
:: ALGSTR_0:def 19
theorem
Trivial-multMagma = multMagma(#1,op2#);
:: ALGSTR_0:funcreg 15
registration
cluster Trivial-multMagma -> non empty trivial strict;
end;
:: ALGSTR_0:exreg 8
registration
cluster non empty trivial strict multMagma;
end;
:: ALGSTR_0:attrnot 16 => ALGSTR_0:attr 16
definition
let a1 be multMagma;
let a2 be Element of the carrier of a1;
attr a2 is left_mult-cancelable means
for b1, b2 being Element of the carrier of a1
st a2 * b1 = a2 * b2
holds b1 = b2;
end;
:: ALGSTR_0:dfs 20
definiens
let a1 be multMagma;
let a2 be Element of the carrier of a1;
To prove
a2 is left_mult-cancelable
it is sufficient to prove
thus for b1, b2 being Element of the carrier of a1
st a2 * b1 = a2 * b2
holds b1 = b2;
:: ALGSTR_0:def 20
theorem
for b1 being multMagma
for b2 being Element of the carrier of b1 holds
b2 is left_mult-cancelable(b1)
iff
for b3, b4 being Element of the carrier of b1
st b2 * b3 = b2 * b4
holds b3 = b4;
:: ALGSTR_0:attrnot 17 => ALGSTR_0:attr 17
definition
let a1 be multMagma;
let a2 be Element of the carrier of a1;
attr a2 is right_mult-cancelable means
for b1, b2 being Element of the carrier of a1
st b1 * a2 = b2 * a2
holds b1 = b2;
end;
:: ALGSTR_0:dfs 21
definiens
let a1 be multMagma;
let a2 be Element of the carrier of a1;
To prove
a2 is right_mult-cancelable
it is sufficient to prove
thus for b1, b2 being Element of the carrier of a1
st b1 * a2 = b2 * a2
holds b1 = b2;
:: ALGSTR_0:def 21
theorem
for b1 being multMagma
for b2 being Element of the carrier of b1 holds
b2 is right_mult-cancelable(b1)
iff
for b3, b4 being Element of the carrier of b1
st b3 * b2 = b4 * b2
holds b3 = b4;
:: ALGSTR_0:attrnot 18 => ALGSTR_0:attr 18
definition
let a1 be multMagma;
let a2 be Element of the carrier of a1;
attr a2 is mult-cancelable means
a2 is right_mult-cancelable(a1) & a2 is left_mult-cancelable(a1);
end;
:: ALGSTR_0:dfs 22
definiens
let a1 be multMagma;
let a2 be Element of the carrier of a1;
To prove
a2 is mult-cancelable
it is sufficient to prove
thus a2 is right_mult-cancelable(a1) & a2 is left_mult-cancelable(a1);
:: ALGSTR_0:def 22
theorem
for b1 being multMagma
for b2 being Element of the carrier of b1 holds
b2 is mult-cancelable(b1)
iff
b2 is right_mult-cancelable(b1) & b2 is left_mult-cancelable(b1);
:: ALGSTR_0:condreg 13
registration
let a1 be multMagma;
cluster left_mult-cancelable right_mult-cancelable -> mult-cancelable (Element of the carrier of a1);
end;
:: ALGSTR_0:condreg 14
registration
let a1 be multMagma;
cluster mult-cancelable -> left_mult-cancelable right_mult-cancelable (Element of the carrier of a1);
end;
:: ALGSTR_0:attrnot 19 => ALGSTR_0:attr 19
definition
let a1 be multMagma;
attr a1 is left_mult-cancelable means
for b1 being Element of the carrier of a1 holds
b1 is left_mult-cancelable(a1);
end;
:: ALGSTR_0:dfs 23
definiens
let a1 be multMagma;
To prove
a1 is left_mult-cancelable
it is sufficient to prove
thus for b1 being Element of the carrier of a1 holds
b1 is left_mult-cancelable(a1);
:: ALGSTR_0:def 23
theorem
for b1 being multMagma holds
b1 is left_mult-cancelable
iff
for b2 being Element of the carrier of b1 holds
b2 is left_mult-cancelable(b1);
:: ALGSTR_0:attrnot 20 => ALGSTR_0:attr 20
definition
let a1 be multMagma;
attr a1 is right_mult-cancelable means
for b1 being Element of the carrier of a1 holds
b1 is right_mult-cancelable(a1);
end;
:: ALGSTR_0:dfs 24
definiens
let a1 be multMagma;
To prove
a1 is right_mult-cancelable
it is sufficient to prove
thus for b1 being Element of the carrier of a1 holds
b1 is right_mult-cancelable(a1);
:: ALGSTR_0:def 24
theorem
for b1 being multMagma holds
b1 is right_mult-cancelable
iff
for b2 being Element of the carrier of b1 holds
b2 is right_mult-cancelable(b1);
:: ALGSTR_0:attrnot 21 => ALGSTR_0:attr 21
definition
let a1 be multMagma;
attr a1 is mult-cancelable means
a1 is left_mult-cancelable & a1 is right_mult-cancelable;
end;
:: ALGSTR_0:dfs 25
definiens
let a1 be multMagma;
To prove
a1 is mult-cancelable
it is sufficient to prove
thus a1 is left_mult-cancelable & a1 is right_mult-cancelable;
:: ALGSTR_0:def 25
theorem
for b1 being multMagma holds
b1 is mult-cancelable
iff
b1 is left_mult-cancelable & b1 is right_mult-cancelable;
:: ALGSTR_0:condreg 15
registration
cluster left_mult-cancelable right_mult-cancelable -> mult-cancelable (multMagma);
end;
:: ALGSTR_0:condreg 16
registration
cluster mult-cancelable -> left_mult-cancelable right_mult-cancelable (multMagma);
end;
:: ALGSTR_0:funcreg 16
registration
cluster Trivial-multMagma -> mult-cancelable;
end;
:: ALGSTR_0:exreg 9
registration
cluster non empty trivial strict mult-cancelable multMagma;
end;
:: ALGSTR_0:condreg 17
registration
let a1 be left_mult-cancelable multMagma;
cluster -> left_mult-cancelable (Element of the carrier of a1);
end;
:: ALGSTR_0:condreg 18
registration
let a1 be right_mult-cancelable multMagma;
cluster -> right_mult-cancelable (Element of the carrier of a1);
end;
:: ALGSTR_0:structnot 4 => ALGSTR_0:struct 4
definition
struct(OneStr, multMagma) multLoopStr(#
carrier -> set,
multF -> Function-like quasi_total Relation of [:the carrier of it,the carrier of it:],the carrier of it,
OneF -> Element of the carrier of it
#);
end;
:: ALGSTR_0:attrnot 22 => ALGSTR_0:attr 22
definition
let a1 be multLoopStr;
attr a1 is strict;
end;
:: ALGSTR_0:exreg 10
registration
cluster strict multLoopStr;
end;
:: ALGSTR_0:aggrnot 4 => ALGSTR_0:aggr 4
definition
let a1 be set;
let a2 be Function-like quasi_total Relation of [:a1,a1:],a1;
let a3 be Element of a1;
aggr multLoopStr(#a1,a2,a3#) -> strict multLoopStr;
end;
:: ALGSTR_0:funcreg 17
registration
let a1 be non empty set;
let a2 be Function-like quasi_total Relation of [:a1,a1:],a1;
let a3 be Element of a1;
cluster multLoopStr(#a1,a2,a3#) -> non empty strict;
end;
:: ALGSTR_0:funcreg 18
registration
let a1 be trivial set;
let a2 be Function-like quasi_total Relation of [:a1,a1:],a1;
let a3 be Element of a1;
cluster multLoopStr(#a1,a2,a3#) -> trivial strict;
end;
:: ALGSTR_0:funcreg 19
registration
let a1 be non trivial set;
let a2 be Function-like quasi_total Relation of [:a1,a1:],a1;
let a3 be Element of a1;
cluster multLoopStr(#a1,a2,a3#) -> non trivial strict;
end;
:: ALGSTR_0:funcnot 8 => ALGSTR_0:func 8
definition
func Trivial-multLoopStr -> multLoopStr equals
multLoopStr(#1,op2,op0#);
end;
:: ALGSTR_0:def 26
theorem
Trivial-multLoopStr = multLoopStr(#1,op2,op0#);
:: ALGSTR_0:funcreg 20
registration
cluster Trivial-multLoopStr -> non empty trivial strict;
end;
:: ALGSTR_0:exreg 11
registration
cluster non empty trivial strict multLoopStr;
end;
:: ALGSTR_0:funcreg 21
registration
cluster Trivial-multLoopStr -> mult-cancelable;
end;
:: ALGSTR_0:attrnot 23 => ALGSTR_0:attr 23
definition
let a1 be multLoopStr;
let a2 be Element of the carrier of a1;
attr a2 is left_invertible means
ex b1 being Element of the carrier of a1 st
b1 * a2 = 1. a1;
end;
:: ALGSTR_0:dfs 27
definiens
let a1 be multLoopStr;
let a2 be Element of the carrier of a1;
To prove
a2 is left_invertible
it is sufficient to prove
thus ex b1 being Element of the carrier of a1 st
b1 * a2 = 1. a1;
:: ALGSTR_0:def 27
theorem
for b1 being multLoopStr
for b2 being Element of the carrier of b1 holds
b2 is left_invertible(b1)
iff
ex b3 being Element of the carrier of b1 st
b3 * b2 = 1. b1;
:: ALGSTR_0:attrnot 24 => ALGSTR_0:attr 24
definition
let a1 be multLoopStr;
let a2 be Element of the carrier of a1;
attr a2 is right_invertible means
ex b1 being Element of the carrier of a1 st
a2 * b1 = 1. a1;
end;
:: ALGSTR_0:dfs 28
definiens
let a1 be multLoopStr;
let a2 be Element of the carrier of a1;
To prove
a2 is right_invertible
it is sufficient to prove
thus ex b1 being Element of the carrier of a1 st
a2 * b1 = 1. a1;
:: ALGSTR_0:def 28
theorem
for b1 being multLoopStr
for b2 being Element of the carrier of b1 holds
b2 is right_invertible(b1)
iff
ex b3 being Element of the carrier of b1 st
b2 * b3 = 1. b1;
:: ALGSTR_0:attrnot 25 => ALGSTR_0:attr 25
definition
let a1 be multLoopStr;
let a2 be Element of the carrier of a1;
attr a2 is invertible means
a2 is right_invertible(a1) & a2 is left_invertible(a1);
end;
:: ALGSTR_0:dfs 29
definiens
let a1 be multLoopStr;
let a2 be Element of the carrier of a1;
To prove
a2 is invertible
it is sufficient to prove
thus a2 is right_invertible(a1) & a2 is left_invertible(a1);
:: ALGSTR_0:def 29
theorem
for b1 being multLoopStr
for b2 being Element of the carrier of b1 holds
b2 is invertible(b1)
iff
b2 is right_invertible(b1) & b2 is left_invertible(b1);
:: ALGSTR_0:condreg 19
registration
let a1 be multLoopStr;
cluster left_invertible right_invertible -> invertible (Element of the carrier of a1);
end;
:: ALGSTR_0:condreg 20
registration
let a1 be multLoopStr;
cluster invertible -> left_invertible right_invertible (Element of the carrier of a1);
end;
:: ALGSTR_0:funcnot 9 => ALGSTR_0:func 9
definition
let a1 be multLoopStr;
let a2 be Element of the carrier of a1;
assume a2 is left_invertible(a1) & a2 is right_mult-cancelable(a1);
func / A2 -> Element of the carrier of a1 means
it * a2 = 1. a1;
end;
:: ALGSTR_0:def 30
theorem
for b1 being multLoopStr
for b2 being Element of the carrier of b1
st b2 is left_invertible(b1) & b2 is right_mult-cancelable(b1)
for b3 being Element of the carrier of b1 holds
b3 = / b2
iff
b3 * b2 = 1. b1;
:: ALGSTR_0:attrnot 26 => ALGSTR_0:attr 26
definition
let a1 be multLoopStr;
attr a1 is left_invertible means
for b1 being Element of the carrier of a1 holds
b1 is left_invertible(a1);
end;
:: ALGSTR_0:dfs 31
definiens
let a1 be multLoopStr;
To prove
a1 is left_invertible
it is sufficient to prove
thus for b1 being Element of the carrier of a1 holds
b1 is left_invertible(a1);
:: ALGSTR_0:def 31
theorem
for b1 being multLoopStr holds
b1 is left_invertible
iff
for b2 being Element of the carrier of b1 holds
b2 is left_invertible(b1);
:: ALGSTR_0:attrnot 27 => ALGSTR_0:attr 27
definition
let a1 be multLoopStr;
attr a1 is right_invertible means
for b1 being Element of the carrier of a1 holds
b1 is right_invertible(a1);
end;
:: ALGSTR_0:dfs 32
definiens
let a1 be multLoopStr;
To prove
a1 is right_invertible
it is sufficient to prove
thus for b1 being Element of the carrier of a1 holds
b1 is right_invertible(a1);
:: ALGSTR_0:def 32
theorem
for b1 being multLoopStr holds
b1 is right_invertible
iff
for b2 being Element of the carrier of b1 holds
b2 is right_invertible(b1);
:: ALGSTR_0:attrnot 28 => ALGSTR_0:attr 28
definition
let a1 be multLoopStr;
attr a1 is invertible means
a1 is right_invertible & a1 is left_invertible;
end;
:: ALGSTR_0:dfs 33
definiens
let a1 be multLoopStr;
To prove
a1 is invertible
it is sufficient to prove
thus a1 is right_invertible & a1 is left_invertible;
:: ALGSTR_0:def 33
theorem
for b1 being multLoopStr holds
b1 is invertible
iff
b1 is right_invertible & b1 is left_invertible;
:: ALGSTR_0:condreg 21
registration
cluster left_invertible right_invertible -> invertible (multLoopStr);
end;
:: ALGSTR_0:condreg 22
registration
cluster invertible -> left_invertible right_invertible (multLoopStr);
end;
:: ALGSTR_0:funcreg 22
registration
cluster Trivial-multLoopStr -> invertible;
end;
:: ALGSTR_0:exreg 12
registration
cluster non empty trivial mult-cancelable strict invertible multLoopStr;
end;
:: ALGSTR_0:condreg 23
registration
let a1 be left_invertible multLoopStr;
cluster -> left_invertible (Element of the carrier of a1);
end;
:: ALGSTR_0:condreg 24
registration
let a1 be right_invertible multLoopStr;
cluster -> right_invertible (Element of the carrier of a1);
end;
:: ALGSTR_0:structnot 5 => ALGSTR_0:struct 5
definition
struct(multLoopStr, ZeroOneStr) multLoopStr_0(#
carrier -> set,
multF -> Function-like quasi_total Relation of [:the carrier of it,the carrier of it:],the carrier of it,
ZeroF -> Element of the carrier of it,
OneF -> Element of the carrier of it
#);
end;
:: ALGSTR_0:attrnot 29 => ALGSTR_0:attr 29
definition
let a1 be multLoopStr_0;
attr a1 is strict;
end;
:: ALGSTR_0:exreg 13
registration
cluster strict multLoopStr_0;
end;
:: ALGSTR_0:aggrnot 5 => ALGSTR_0:aggr 5
definition
let a1 be set;
let a2 be Function-like quasi_total Relation of [:a1,a1:],a1;
let a3, a4 be Element of a1;
aggr multLoopStr_0(#a1,a2,a3,a4#) -> strict multLoopStr_0;
end;
:: ALGSTR_0:funcreg 23
registration
let a1 be non empty set;
let a2 be Function-like quasi_total Relation of [:a1,a1:],a1;
let a3, a4 be Element of a1;
cluster multLoopStr_0(#a1,a2,a3,a4#) -> non empty strict;
end;
:: ALGSTR_0:funcreg 24
registration
let a1 be trivial set;
let a2 be Function-like quasi_total Relation of [:a1,a1:],a1;
let a3, a4 be Element of a1;
cluster multLoopStr_0(#a1,a2,a3,a4#) -> trivial strict;
end;
:: ALGSTR_0:funcreg 25
registration
let a1 be non trivial set;
let a2 be Function-like quasi_total Relation of [:a1,a1:],a1;
let a3, a4 be Element of a1;
cluster multLoopStr_0(#a1,a2,a3,a4#) -> non trivial strict;
end;
:: ALGSTR_0:funcnot 10 => ALGSTR_0:func 10
definition
func Trivial-multLoopStr_0 -> multLoopStr_0 equals
multLoopStr_0(#1,op2,op0,op0#);
end;
:: ALGSTR_0:def 34
theorem
Trivial-multLoopStr_0 = multLoopStr_0(#1,op2,op0,op0#);
:: ALGSTR_0:funcreg 26
registration
cluster Trivial-multLoopStr_0 -> non empty trivial strict;
end;
:: ALGSTR_0:exreg 14
registration
cluster non empty trivial strict multLoopStr_0;
end;
:: ALGSTR_0:funcnot 11 => ALGSTR_0:func 11
definition
let a1 be multLoopStr_0;
let a2 be Element of the carrier of a1;
func A2 " -> Element of the carrier of a1 means
it * a2 = 1. a1
if a2 is left_invertible(a1) & a2 is right_mult-cancelable(a1)
otherwise it = 0. a1;
end;
:: ALGSTR_0:def 35
theorem
for b1 being multLoopStr_0
for b2, b3 being Element of the carrier of b1 holds
(b2 is left_invertible(b1) & b2 is right_mult-cancelable(b1) implies (b3 = b2 "
iff
b3 * b2 = 1. b1)) &
(b2 is left_invertible(b1) & b2 is right_mult-cancelable(b1) or (b3 = b2 "
iff
b3 = 0. b1));
:: ALGSTR_0:attrnot 30 => ALGSTR_0:attr 30
definition
let a1 be multLoopStr_0;
attr a1 is almost_left_cancelable means
for b1 being Element of the carrier of a1
st b1 <> 0. a1
holds b1 is left_mult-cancelable(a1);
end;
:: ALGSTR_0:dfs 36
definiens
let a1 be multLoopStr_0;
To prove
a1 is almost_left_cancelable
it is sufficient to prove
thus for b1 being Element of the carrier of a1
st b1 <> 0. a1
holds b1 is left_mult-cancelable(a1);
:: ALGSTR_0:def 36
theorem
for b1 being multLoopStr_0 holds
b1 is almost_left_cancelable
iff
for b2 being Element of the carrier of b1
st b2 <> 0. b1
holds b2 is left_mult-cancelable(b1);
:: ALGSTR_0:attrnot 31 => ALGSTR_0:attr 31
definition
let a1 be multLoopStr_0;
attr a1 is almost_right_cancelable means
for b1 being Element of the carrier of a1
st b1 <> 0. a1
holds b1 is right_mult-cancelable(a1);
end;
:: ALGSTR_0:dfs 37
definiens
let a1 be multLoopStr_0;
To prove
a1 is almost_right_cancelable
it is sufficient to prove
thus for b1 being Element of the carrier of a1
st b1 <> 0. a1
holds b1 is right_mult-cancelable(a1);
:: ALGSTR_0:def 37
theorem
for b1 being multLoopStr_0 holds
b1 is almost_right_cancelable
iff
for b2 being Element of the carrier of b1
st b2 <> 0. b1
holds b2 is right_mult-cancelable(b1);
:: ALGSTR_0:attrnot 32 => ALGSTR_0:attr 32
definition
let a1 be multLoopStr_0;
attr a1 is almost_cancelable means
a1 is almost_left_cancelable & a1 is almost_right_cancelable;
end;
:: ALGSTR_0:dfs 38
definiens
let a1 be multLoopStr_0;
To prove
a1 is almost_cancelable
it is sufficient to prove
thus a1 is almost_left_cancelable & a1 is almost_right_cancelable;
:: ALGSTR_0:def 38
theorem
for b1 being multLoopStr_0 holds
b1 is almost_cancelable
iff
b1 is almost_left_cancelable & b1 is almost_right_cancelable;
:: ALGSTR_0:condreg 25
registration
cluster almost_left_cancelable almost_right_cancelable -> almost_cancelable (multLoopStr_0);
end;
:: ALGSTR_0:condreg 26
registration
cluster almost_cancelable -> almost_left_cancelable almost_right_cancelable (multLoopStr_0);
end;
:: ALGSTR_0:funcreg 27
registration
cluster Trivial-multLoopStr_0 -> almost_cancelable;
end;
:: ALGSTR_0:exreg 15
registration
cluster non empty trivial strict almost_cancelable multLoopStr_0;
end;
:: ALGSTR_0:attrnot 33 => ALGSTR_0:attr 33
definition
let a1 be multLoopStr_0;
attr a1 is almost_left_invertible means
for b1 being Element of the carrier of a1
st b1 <> 0. a1
holds b1 is left_invertible(a1);
end;
:: ALGSTR_0:dfs 39
definiens
let a1 be multLoopStr_0;
To prove
a1 is almost_left_invertible
it is sufficient to prove
thus for b1 being Element of the carrier of a1
st b1 <> 0. a1
holds b1 is left_invertible(a1);
:: ALGSTR_0:def 39
theorem
for b1 being multLoopStr_0 holds
b1 is almost_left_invertible
iff
for b2 being Element of the carrier of b1
st b2 <> 0. b1
holds b2 is left_invertible(b1);
:: ALGSTR_0:attrnot 34 => ALGSTR_0:attr 34
definition
let a1 be multLoopStr_0;
attr a1 is almost_right_invertible means
for b1 being Element of the carrier of a1
st b1 <> 0. a1
holds b1 is right_invertible(a1);
end;
:: ALGSTR_0:dfs 40
definiens
let a1 be multLoopStr_0;
To prove
a1 is almost_right_invertible
it is sufficient to prove
thus for b1 being Element of the carrier of a1
st b1 <> 0. a1
holds b1 is right_invertible(a1);
:: ALGSTR_0:def 40
theorem
for b1 being multLoopStr_0 holds
b1 is almost_right_invertible
iff
for b2 being Element of the carrier of b1
st b2 <> 0. b1
holds b2 is right_invertible(b1);
:: ALGSTR_0:attrnot 35 => ALGSTR_0:attr 35
definition
let a1 be multLoopStr_0;
attr a1 is almost_invertible means
a1 is almost_right_invertible & a1 is almost_left_invertible;
end;
:: ALGSTR_0:dfs 41
definiens
let a1 be multLoopStr_0;
To prove
a1 is almost_invertible
it is sufficient to prove
thus a1 is almost_right_invertible & a1 is almost_left_invertible;
:: ALGSTR_0:def 41
theorem
for b1 being multLoopStr_0 holds
b1 is almost_invertible
iff
b1 is almost_right_invertible & b1 is almost_left_invertible;
:: ALGSTR_0:condreg 27
registration
cluster almost_left_invertible almost_right_invertible -> almost_invertible (multLoopStr_0);
end;
:: ALGSTR_0:condreg 28
registration
cluster almost_invertible -> almost_left_invertible almost_right_invertible (multLoopStr_0);
end;
:: ALGSTR_0:funcreg 28
registration
cluster Trivial-multLoopStr_0 -> almost_invertible;
end;
:: ALGSTR_0:exreg 16
registration
cluster non empty trivial strict almost_cancelable almost_invertible multLoopStr_0;
end;
:: ALGSTR_0:structnot 6 => ALGSTR_0:struct 6
definition
struct(addLoopStr, multLoopStr_0) doubleLoopStr(#
carrier -> set,
addF -> Function-like quasi_total Relation of [:the carrier of it,the carrier of it:],the carrier of it,
multF -> Function-like quasi_total Relation of [:the carrier of it,the carrier of it:],the carrier of it,
OneF -> Element of the carrier of it,
ZeroF -> Element of the carrier of it
#);
end;
:: ALGSTR_0:attrnot 36 => ALGSTR_0:attr 36
definition
let a1 be doubleLoopStr;
attr a1 is strict;
end;
:: ALGSTR_0:exreg 17
registration
cluster strict doubleLoopStr;
end;
:: ALGSTR_0:aggrnot 6 => ALGSTR_0:aggr 6
definition
let a1 be set;
let a2, a3 be Function-like quasi_total Relation of [:a1,a1:],a1;
let a4, a5 be Element of a1;
aggr doubleLoopStr(#a1,a2,a3,a4,a5#) -> strict doubleLoopStr;
end;
:: ALGSTR_0:funcreg 29
registration
let a1 be non empty set;
let a2, a3 be Function-like quasi_total Relation of [:a1,a1:],a1;
let a4, a5 be Element of a1;
cluster doubleLoopStr(#a1,a2,a3,a4,a5#) -> non empty strict;
end;
:: ALGSTR_0:funcreg 30
registration
let a1 be trivial set;
let a2, a3 be Function-like quasi_total Relation of [:a1,a1:],a1;
let a4, a5 be Element of a1;
cluster doubleLoopStr(#a1,a2,a3,a4,a5#) -> trivial strict;
end;
:: ALGSTR_0:funcreg 31
registration
let a1 be non trivial set;
let a2, a3 be Function-like quasi_total Relation of [:a1,a1:],a1;
let a4, a5 be Element of a1;
cluster doubleLoopStr(#a1,a2,a3,a4,a5#) -> non trivial strict;
end;
:: ALGSTR_0:funcnot 12 => ALGSTR_0:func 12
definition
func Trivial-doubleLoopStr -> doubleLoopStr equals
doubleLoopStr(#1,op2,op2,op0,op0#);
end;
:: ALGSTR_0:def 42
theorem
Trivial-doubleLoopStr = doubleLoopStr(#1,op2,op2,op0,op0#);
:: ALGSTR_0:funcreg 32
registration
cluster Trivial-doubleLoopStr -> non empty trivial strict;
end;
:: ALGSTR_0:exreg 18
registration
cluster non empty trivial strict doubleLoopStr;
end;