Article MONOID_0, MML version 4.99.1005
:: MONOID_0:modenot 1
definition
let a1 be 1-sorted;
mode BinOp of a1 is Function-like quasi_total Relation of [:the carrier of a1,the carrier of a1:],the carrier of a1;
end;
:: MONOID_0:attrnot 1 => MONOID_0:attr 1
definition
let a1 be 1-sorted;
attr a1 is constituted-Functions means
for b1 being Element of the carrier of a1 holds
b1 is Relation-like Function-like set;
end;
:: MONOID_0:dfs 1
definiens
let a1 be 1-sorted;
To prove
a1 is constituted-Functions
it is sufficient to prove
thus for b1 being Element of the carrier of a1 holds
b1 is Relation-like Function-like set;
:: MONOID_0:def 1
theorem
for b1 being 1-sorted holds
b1 is constituted-Functions
iff
for b2 being Element of the carrier of b1 holds
b2 is Relation-like Function-like set;
:: MONOID_0:attrnot 2 => MONOID_0:attr 2
definition
let a1 be 1-sorted;
attr a1 is constituted-FinSeqs means
for b1 being Element of the carrier of a1 holds
b1 is Relation-like Function-like FinSequence-like set;
end;
:: MONOID_0:dfs 2
definiens
let a1 be 1-sorted;
To prove
a1 is constituted-FinSeqs
it is sufficient to prove
thus for b1 being Element of the carrier of a1 holds
b1 is Relation-like Function-like FinSequence-like set;
:: MONOID_0:def 2
theorem
for b1 being 1-sorted holds
b1 is constituted-FinSeqs
iff
for b2 being Element of the carrier of b1 holds
b2 is Relation-like Function-like FinSequence-like set;
:: MONOID_0:exreg 1
registration
cluster constituted-Functions 1-sorted;
end;
:: MONOID_0:exreg 2
registration
cluster constituted-FinSeqs 1-sorted;
end;
:: MONOID_0:condreg 1
registration
let a1 be constituted-Functions 1-sorted;
cluster -> Relation-like Function-like (Element of the carrier of a1);
end;
:: MONOID_0:condreg 2
registration
cluster constituted-FinSeqs -> constituted-Functions (1-sorted);
end;
:: MONOID_0:condreg 3
registration
let a1 be constituted-FinSeqs 1-sorted;
cluster -> FinSequence-like (Element of the carrier of a1);
end;
:: MONOID_0:funcnot 1 => MONOID_0:func 1
definition
let a1 be set;
let a2, a3 be FinSequence of a1;
redefine func a2 ^ a3 -> Element of a1 *;
end;
:: MONOID_0:funcnot 2 => RELAT_1:func 5
notation
let a1, a2 be Relation-like Function-like set;
synonym a2 (*) a1 for a1 * a2;
end;
:: MONOID_0:attrnot 3 => MONOID_0:attr 3
definition
let a1 be non empty set;
let a2 be Function-like quasi_total Relation of [:a1,a1:],a1;
attr a2 is left-invertible means
for b1, b2 being Element of a1 holds
ex b3 being Element of a1 st
a2 .(b3,b1) = b2;
end;
:: MONOID_0:dfs 3
definiens
let a1 be non empty set;
let a2 be Function-like quasi_total Relation of [:a1,a1:],a1;
To prove
a2 is left-invertible
it is sufficient to prove
thus for b1, b2 being Element of a1 holds
ex b3 being Element of a1 st
a2 .(b3,b1) = b2;
:: MONOID_0:def 3
theorem
for b1 being non empty set
for b2 being Function-like quasi_total Relation of [:b1,b1:],b1 holds
b2 is left-invertible(b1)
iff
for b3, b4 being Element of b1 holds
ex b5 being Element of b1 st
b2 .(b5,b3) = b4;
:: MONOID_0:attrnot 4 => MONOID_0:attr 4
definition
let a1 be non empty set;
let a2 be Function-like quasi_total Relation of [:a1,a1:],a1;
attr a2 is right-invertible means
for b1, b2 being Element of a1 holds
ex b3 being Element of a1 st
a2 .(b1,b3) = b2;
end;
:: MONOID_0:dfs 4
definiens
let a1 be non empty set;
let a2 be Function-like quasi_total Relation of [:a1,a1:],a1;
To prove
a2 is right-invertible
it is sufficient to prove
thus for b1, b2 being Element of a1 holds
ex b3 being Element of a1 st
a2 .(b1,b3) = b2;
:: MONOID_0:def 4
theorem
for b1 being non empty set
for b2 being Function-like quasi_total Relation of [:b1,b1:],b1 holds
b2 is right-invertible(b1)
iff
for b3, b4 being Element of b1 holds
ex b5 being Element of b1 st
b2 .(b3,b5) = b4;
:: MONOID_0:attrnot 5 => MONOID_0:attr 5
definition
let a1 be non empty set;
let a2 be Function-like quasi_total Relation of [:a1,a1:],a1;
attr a2 is invertible means
for b1, b2 being Element of a1 holds
ex b3, b4 being Element of a1 st
a2 .(b1,b3) = b2 & a2 .(b4,b1) = b2;
end;
:: MONOID_0:dfs 5
definiens
let a1 be non empty set;
let a2 be Function-like quasi_total Relation of [:a1,a1:],a1;
To prove
a2 is invertible
it is sufficient to prove
thus for b1, b2 being Element of a1 holds
ex b3, b4 being Element of a1 st
a2 .(b1,b3) = b2 & a2 .(b4,b1) = b2;
:: MONOID_0:def 5
theorem
for b1 being non empty set
for b2 being Function-like quasi_total Relation of [:b1,b1:],b1 holds
b2 is invertible(b1)
iff
for b3, b4 being Element of b1 holds
ex b5, b6 being Element of b1 st
b2 .(b3,b5) = b4 & b2 .(b6,b3) = b4;
:: MONOID_0:attrnot 6 => MONOID_0:attr 6
definition
let a1 be non empty set;
let a2 be Function-like quasi_total Relation of [:a1,a1:],a1;
attr a2 is left-cancelable means
for b1, b2, b3 being Element of a1
st a2 .(b1,b2) = a2 .(b1,b3)
holds b2 = b3;
end;
:: MONOID_0:dfs 6
definiens
let a1 be non empty set;
let a2 be Function-like quasi_total Relation of [:a1,a1:],a1;
To prove
a2 is left-cancelable
it is sufficient to prove
thus for b1, b2, b3 being Element of a1
st a2 .(b1,b2) = a2 .(b1,b3)
holds b2 = b3;
:: MONOID_0:def 6
theorem
for b1 being non empty set
for b2 being Function-like quasi_total Relation of [:b1,b1:],b1 holds
b2 is left-cancelable(b1)
iff
for b3, b4, b5 being Element of b1
st b2 .(b3,b4) = b2 .(b3,b5)
holds b4 = b5;
:: MONOID_0:attrnot 7 => MONOID_0:attr 7
definition
let a1 be non empty set;
let a2 be Function-like quasi_total Relation of [:a1,a1:],a1;
attr a2 is right-cancelable means
for b1, b2, b3 being Element of a1
st a2 .(b2,b1) = a2 .(b3,b1)
holds b2 = b3;
end;
:: MONOID_0:dfs 7
definiens
let a1 be non empty set;
let a2 be Function-like quasi_total Relation of [:a1,a1:],a1;
To prove
a2 is right-cancelable
it is sufficient to prove
thus for b1, b2, b3 being Element of a1
st a2 .(b2,b1) = a2 .(b3,b1)
holds b2 = b3;
:: MONOID_0:def 7
theorem
for b1 being non empty set
for b2 being Function-like quasi_total Relation of [:b1,b1:],b1 holds
b2 is right-cancelable(b1)
iff
for b3, b4, b5 being Element of b1
st b2 .(b4,b3) = b2 .(b5,b3)
holds b4 = b5;
:: MONOID_0:attrnot 8 => MONOID_0:attr 8
definition
let a1 be non empty set;
let a2 be Function-like quasi_total Relation of [:a1,a1:],a1;
attr a2 is cancelable means
for b1, b2, b3 being Element of a1
st (a2 .(b1,b2) = a2 .(b1,b3) or a2 .(b2,b1) = a2 .(b3,b1))
holds b2 = b3;
end;
:: MONOID_0:dfs 8
definiens
let a1 be non empty set;
let a2 be Function-like quasi_total Relation of [:a1,a1:],a1;
To prove
a2 is cancelable
it is sufficient to prove
thus for b1, b2, b3 being Element of a1
st (a2 .(b1,b2) = a2 .(b1,b3) or a2 .(b2,b1) = a2 .(b3,b1))
holds b2 = b3;
:: MONOID_0:def 8
theorem
for b1 being non empty set
for b2 being Function-like quasi_total Relation of [:b1,b1:],b1 holds
b2 is cancelable(b1)
iff
for b3, b4, b5 being Element of b1
st (b2 .(b3,b4) = b2 .(b3,b5) or b2 .(b4,b3) = b2 .(b5,b3))
holds b4 = b5;
:: MONOID_0:attrnot 9 => MONOID_0:attr 9
definition
let a1 be non empty set;
let a2 be Function-like quasi_total Relation of [:a1,a1:],a1;
attr a2 is uniquely-decomposable means
a2 is having_a_unity(a1) &
(for b1, b2 being Element of a1
st a2 .(b1,b2) = the_unity_wrt a2
holds b1 = b2 & b2 = the_unity_wrt a2);
end;
:: MONOID_0:dfs 9
definiens
let a1 be non empty set;
let a2 be Function-like quasi_total Relation of [:a1,a1:],a1;
To prove
a2 is uniquely-decomposable
it is sufficient to prove
thus a2 is having_a_unity(a1) &
(for b1, b2 being Element of a1
st a2 .(b1,b2) = the_unity_wrt a2
holds b1 = b2 & b2 = the_unity_wrt a2);
:: MONOID_0:def 9
theorem
for b1 being non empty set
for b2 being Function-like quasi_total Relation of [:b1,b1:],b1 holds
b2 is uniquely-decomposable(b1)
iff
b2 is having_a_unity(b1) &
(for b3, b4 being Element of b1
st b2 .(b3,b4) = the_unity_wrt b2
holds b3 = b4 & b4 = the_unity_wrt b2);
:: MONOID_0:th 1
theorem
for b1 being non empty set
for b2 being Function-like quasi_total Relation of [:b1,b1:],b1 holds
b2 is invertible(b1)
iff
b2 is left-invertible(b1) & b2 is right-invertible(b1);
:: MONOID_0:th 2
theorem
for b1 being non empty set
for b2 being Function-like quasi_total Relation of [:b1,b1:],b1 holds
b2 is cancelable(b1)
iff
b2 is left-cancelable(b1) & b2 is right-cancelable(b1);
:: MONOID_0:th 3
theorem
for b1 being set
for b2 being Function-like quasi_total Relation of [:{b1},{b1}:],{b1} holds
b2 = {[b1,b1]} --> b1 &
b2 is having_a_unity({b1}) &
b2 is commutative({b1}) &
b2 is associative({b1}) &
b2 is idempotent({b1}) &
b2 is invertible({b1}) &
b2 is cancelable({b1}) &
b2 is uniquely-decomposable({b1});
:: MONOID_0:attrnot 10 => GROUP_1:attr 1
definition
let a1 be non empty multMagma;
attr a1 is unital means
the multF of a1 is having_a_unity(the carrier of a1);
end;
:: MONOID_0:dfs 10
definiens
let a1 be non empty multMagma;
To prove
a1 is unital
it is sufficient to prove
thus the multF of a1 is having_a_unity(the carrier of a1);
:: MONOID_0:def 10
theorem
for b1 being non empty multMagma holds
b1 is unital
iff
the multF of b1 is having_a_unity(the carrier of b1);
:: MONOID_0:attrnot 11 => GROUP_1:attr 5
definition
let a1 be non empty multMagma;
attr a1 is commutative means
the multF of a1 is commutative(the carrier of a1);
end;
:: MONOID_0:dfs 11
definiens
let a1 be non empty multMagma;
To prove
a1 is commutative
it is sufficient to prove
thus the multF of a1 is commutative(the carrier of a1);
:: MONOID_0:def 11
theorem
for b1 being non empty multMagma holds
b1 is commutative
iff
the multF of b1 is commutative(the carrier of b1);
:: MONOID_0:attrnot 12 => GROUP_1:attr 3
definition
let a1 be non empty multMagma;
attr a1 is associative means
the multF of a1 is associative(the carrier of a1);
end;
:: MONOID_0:dfs 12
definiens
let a1 be non empty multMagma;
To prove
a1 is associative
it is sufficient to prove
thus the multF of a1 is associative(the carrier of a1);
:: MONOID_0:def 12
theorem
for b1 being non empty multMagma holds
b1 is associative
iff
the multF of b1 is associative(the carrier of b1);
:: MONOID_0:attrnot 13 => MONOID_0:attr 10
definition
let a1 be non empty multMagma;
attr a1 is idempotent means
the multF of a1 is idempotent(the carrier of a1);
end;
:: MONOID_0:dfs 13
definiens
let a1 be non empty multMagma;
To prove
a1 is idempotent
it is sufficient to prove
thus the multF of a1 is idempotent(the carrier of a1);
:: MONOID_0:def 13
theorem
for b1 being non empty multMagma holds
b1 is idempotent
iff
the multF of b1 is idempotent(the carrier of b1);
:: MONOID_0:attrnot 14 => MONOID_0:attr 11
definition
let a1 be non empty multMagma;
attr a1 is left-invertible means
the multF of a1 is left-invertible(the carrier of a1);
end;
:: MONOID_0:dfs 14
definiens
let a1 be non empty multMagma;
To prove
a1 is left-invertible
it is sufficient to prove
thus the multF of a1 is left-invertible(the carrier of a1);
:: MONOID_0:def 14
theorem
for b1 being non empty multMagma holds
b1 is left-invertible
iff
the multF of b1 is left-invertible(the carrier of b1);
:: MONOID_0:attrnot 15 => MONOID_0:attr 12
definition
let a1 be non empty multMagma;
attr a1 is right-invertible means
the multF of a1 is right-invertible(the carrier of a1);
end;
:: MONOID_0:dfs 15
definiens
let a1 be non empty multMagma;
To prove
a1 is right-invertible
it is sufficient to prove
thus the multF of a1 is right-invertible(the carrier of a1);
:: MONOID_0:def 15
theorem
for b1 being non empty multMagma holds
b1 is right-invertible
iff
the multF of b1 is right-invertible(the carrier of b1);
:: MONOID_0:attrnot 16 => MONOID_0:attr 13
definition
let a1 be non empty multMagma;
attr a1 is invertible means
the multF of a1 is invertible(the carrier of a1);
end;
:: MONOID_0:dfs 16
definiens
let a1 be non empty multMagma;
To prove
a1 is invertible
it is sufficient to prove
thus the multF of a1 is invertible(the carrier of a1);
:: MONOID_0:def 16
theorem
for b1 being non empty multMagma holds
b1 is invertible
iff
the multF of b1 is invertible(the carrier of b1);
:: MONOID_0:attrnot 17 => MONOID_0:attr 14
definition
let a1 be non empty multMagma;
attr a1 is left-cancelable means
the multF of a1 is left-cancelable(the carrier of a1);
end;
:: MONOID_0:dfs 17
definiens
let a1 be non empty multMagma;
To prove
a1 is left-cancelable
it is sufficient to prove
thus the multF of a1 is left-cancelable(the carrier of a1);
:: MONOID_0:def 17
theorem
for b1 being non empty multMagma holds
b1 is left-cancelable
iff
the multF of b1 is left-cancelable(the carrier of b1);
:: MONOID_0:attrnot 18 => MONOID_0:attr 15
definition
let a1 be non empty multMagma;
attr a1 is right-cancelable means
the multF of a1 is right-cancelable(the carrier of a1);
end;
:: MONOID_0:dfs 18
definiens
let a1 be non empty multMagma;
To prove
a1 is right-cancelable
it is sufficient to prove
thus the multF of a1 is right-cancelable(the carrier of a1);
:: MONOID_0:def 18
theorem
for b1 being non empty multMagma holds
b1 is right-cancelable
iff
the multF of b1 is right-cancelable(the carrier of b1);
:: MONOID_0:attrnot 19 => MONOID_0:attr 16
definition
let a1 be non empty multMagma;
attr a1 is cancelable means
the multF of a1 is cancelable(the carrier of a1);
end;
:: MONOID_0:dfs 19
definiens
let a1 be non empty multMagma;
To prove
a1 is cancelable
it is sufficient to prove
thus the multF of a1 is cancelable(the carrier of a1);
:: MONOID_0:def 19
theorem
for b1 being non empty multMagma holds
b1 is cancelable
iff
the multF of b1 is cancelable(the carrier of b1);
:: MONOID_0:attrnot 20 => MONOID_0:attr 17
definition
let a1 be non empty multMagma;
attr a1 is uniquely-decomposable means
the multF of a1 is uniquely-decomposable(the carrier of a1);
end;
:: MONOID_0:dfs 20
definiens
let a1 be non empty multMagma;
To prove
a1 is uniquely-decomposable
it is sufficient to prove
thus the multF of a1 is uniquely-decomposable(the carrier of a1);
:: MONOID_0:def 20
theorem
for b1 being non empty multMagma holds
b1 is uniquely-decomposable
iff
the multF of b1 is uniquely-decomposable(the carrier of b1);
:: MONOID_0:exreg 3
registration
cluster non empty strict unital associative commutative constituted-Functions constituted-FinSeqs idempotent invertible cancelable uniquely-decomposable multMagma;
end;
:: MONOID_0:th 4
theorem
for b1 being non empty multMagma
st b1 is unital
holds the_unity_wrt the multF of b1 is_a_unity_wrt the multF of b1;
:: MONOID_0:th 5
theorem
for b1 being non empty multMagma holds
b1 is unital
iff
for b2 being Element of the carrier of b1 holds
(the_unity_wrt the multF of b1) * b2 = b2 & b2 * the_unity_wrt the multF of b1 = b2;
:: MONOID_0:th 6
theorem
for b1 being non empty multMagma holds
b1 is unital
iff
ex b2 being Element of the carrier of b1 st
for b3 being Element of the carrier of b1 holds
b2 * b3 = b3 & b3 * b2 = b3;
:: MONOID_0:th 9
theorem
for b1 being non empty multMagma holds
b1 is idempotent
iff
for b2 being Element of the carrier of b1 holds
b2 * b2 = b2;
:: MONOID_0:th 10
theorem
for b1 being non empty multMagma holds
b1 is left-invertible
iff
for b2, b3 being Element of the carrier of b1 holds
ex b4 being Element of the carrier of b1 st
b4 * b2 = b3;
:: MONOID_0:th 11
theorem
for b1 being non empty multMagma holds
b1 is right-invertible
iff
for b2, b3 being Element of the carrier of b1 holds
ex b4 being Element of the carrier of b1 st
b2 * b4 = b3;
:: MONOID_0:th 12
theorem
for b1 being non empty multMagma holds
b1 is invertible
iff
for b2, b3 being Element of the carrier of b1 holds
ex b4, b5 being Element of the carrier of b1 st
b2 * b4 = b3 & b5 * b2 = b3;
:: MONOID_0:th 13
theorem
for b1 being non empty multMagma holds
b1 is left-cancelable
iff
for b2, b3, b4 being Element of the carrier of b1
st b2 * b3 = b2 * b4
holds b3 = b4;
:: MONOID_0:th 14
theorem
for b1 being non empty multMagma holds
b1 is right-cancelable
iff
for b2, b3, b4 being Element of the carrier of b1
st b3 * b2 = b4 * b2
holds b3 = b4;
:: MONOID_0:th 15
theorem
for b1 being non empty multMagma holds
b1 is cancelable
iff
for b2, b3, b4 being Element of the carrier of b1
st (b2 * b3 = b2 * b4 or b3 * b2 = b4 * b2)
holds b3 = b4;
:: MONOID_0:th 16
theorem
for b1 being non empty multMagma holds
b1 is uniquely-decomposable
iff
the multF of b1 is having_a_unity(the carrier of b1) &
(for b2, b3 being Element of the carrier of b1
st b2 * b3 = the_unity_wrt the multF of b1
holds b2 = b3 & b3 = the_unity_wrt the multF of b1);
:: MONOID_0:th 17
theorem
for b1 being non empty multMagma
st b1 is associative
holds b1 is invertible
iff
b1 is unital & the multF of b1 is having_an_inverseOp(the carrier of b1);
:: MONOID_0:condreg 4
registration
cluster non empty Group-like associative -> invertible (multMagma);
end;
:: MONOID_0:condreg 5
registration
cluster non empty associative invertible -> Group-like (multMagma);
end;
:: MONOID_0:condreg 6
registration
cluster non empty invertible -> left-invertible right-invertible (multMagma);
end;
:: MONOID_0:condreg 7
registration
cluster non empty left-invertible right-invertible -> invertible (multMagma);
end;
:: MONOID_0:condreg 8
registration
cluster non empty cancelable -> left-cancelable right-cancelable (multMagma);
end;
:: MONOID_0:condreg 9
registration
cluster non empty left-cancelable right-cancelable -> cancelable (multMagma);
end;
:: MONOID_0:condreg 10
registration
cluster non empty associative invertible -> unital cancelable (multMagma);
end;
:: MONOID_0:attrnot 21 => VECTSP_1:attr 4
definition
let a1 be non empty multLoopStr;
attr a1 is well-unital means
1. a1 is_a_unity_wrt the multF of a1;
end;
:: MONOID_0:dfs 21
definiens
let a1 be non empty multLoopStr;
To prove
a1 is well-unital
it is sufficient to prove
thus 1. a1 is_a_unity_wrt the multF of a1;
:: MONOID_0:def 21
theorem
for b1 being non empty multLoopStr holds
b1 is well-unital
iff
1. b1 is_a_unity_wrt the multF of b1;
:: MONOID_0:th 18
theorem
for b1 being non empty multLoopStr holds
b1 is well-unital
iff
for b2 being Element of the carrier of b1 holds
(1. b1) * b2 = b2 & b2 * 1. b1 = b2;
:: MONOID_0:th 19
theorem
for b1 being non empty multLoopStr
st b1 is well-unital
holds 1. b1 = the_unity_wrt the multF of b1;
:: MONOID_0:exreg 4
registration
cluster non empty strict unital associative commutative well-unital constituted-Functions constituted-FinSeqs idempotent invertible cancelable uniquely-decomposable multLoopStr;
end;
:: MONOID_0:modenot 2
definition
mode Monoid is non empty associative well-unital multLoopStr;
end;
:: MONOID_0:modenot 3 => MONOID_0:mode 1
definition
let a1 be multMagma;
mode MonoidalExtension of A1 -> multLoopStr means
multMagma(#the carrier of it,the multF of it#) = multMagma(#the carrier of a1,the multF of a1#);
end;
:: MONOID_0:dfs 22
definiens
let a1 be multMagma;
let a2 be multLoopStr;
To prove
a2 is MonoidalExtension of a1
it is sufficient to prove
thus multMagma(#the carrier of a2,the multF of a2#) = multMagma(#the carrier of a1,the multF of a1#);
:: MONOID_0:def 22
theorem
for b1 being multMagma
for b2 being multLoopStr holds
b2 is MonoidalExtension of b1
iff
multMagma(#the carrier of b2,the multF of b2#) = multMagma(#the carrier of b1,the multF of b1#);
:: MONOID_0:condreg 11
registration
let a1 be non empty multMagma;
cluster -> non empty (MonoidalExtension of a1);
end;
:: MONOID_0:th 20
theorem
for b1 being non empty multMagma
for b2 being MonoidalExtension of b1 holds
the carrier of b2 = the carrier of b1 &
the multF of b2 = the multF of b1 &
(for b3, b4 being Element of the carrier of b2
for b5, b6 being Element of the carrier of b1
st b3 = b5 & b4 = b6
holds b3 * b4 = b5 * b6);
:: MONOID_0:exreg 5
registration
let a1 be multMagma;
cluster strict MonoidalExtension of a1;
end;
:: MONOID_0:th 21
theorem
for b1 being non empty multMagma
for b2 being MonoidalExtension of b1 holds
(b1 is unital implies b2 is unital) & (b1 is commutative implies b2 is commutative) & (b1 is associative implies b2 is associative) & (b1 is invertible implies b2 is invertible) & (b1 is uniquely-decomposable implies b2 is uniquely-decomposable) & (b1 is cancelable implies b2 is cancelable);
:: MONOID_0:condreg 12
registration
let a1 be constituted-Functions multMagma;
cluster -> constituted-Functions (MonoidalExtension of a1);
end;
:: MONOID_0:condreg 13
registration
let a1 be constituted-FinSeqs multMagma;
cluster -> constituted-FinSeqs (MonoidalExtension of a1);
end;
:: MONOID_0:condreg 14
registration
let a1 be non empty unital multMagma;
cluster -> unital (MonoidalExtension of a1);
end;
:: MONOID_0:condreg 15
registration
let a1 be non empty associative multMagma;
cluster -> associative (MonoidalExtension of a1);
end;
:: MONOID_0:condreg 16
registration
let a1 be non empty commutative multMagma;
cluster -> commutative (MonoidalExtension of a1);
end;
:: MONOID_0:condreg 17
registration
let a1 be non empty invertible multMagma;
cluster -> invertible (MonoidalExtension of a1);
end;
:: MONOID_0:condreg 18
registration
let a1 be non empty cancelable multMagma;
cluster -> cancelable (MonoidalExtension of a1);
end;
:: MONOID_0:condreg 19
registration
let a1 be non empty uniquely-decomposable multMagma;
cluster -> uniquely-decomposable (MonoidalExtension of a1);
end;
:: MONOID_0:exreg 6
registration
let a1 be non empty unital multMagma;
cluster non empty strict unital well-unital MonoidalExtension of a1;
end;
:: MONOID_0:th 22
theorem
for b1 being non empty unital multMagma
for b2, b3 being strict well-unital MonoidalExtension of b1 holds
b2 = b3;
:: MONOID_0:modenot 4 => MONOID_0:mode 2
definition
let a1 be multMagma;
mode SubStr of A1 -> multMagma means
the multF of it c= the multF of a1;
end;
:: MONOID_0:dfs 23
definiens
let a1, a2 be multMagma;
To prove
a2 is SubStr of a1
it is sufficient to prove
thus the multF of a2 c= the multF of a1;
:: MONOID_0:def 23
theorem
for b1, b2 being multMagma holds
b2 is SubStr of b1
iff
the multF of b2 c= the multF of b1;
:: MONOID_0:exreg 7
registration
let a1 be multMagma;
cluster strict SubStr of a1;
end;
:: MONOID_0:exreg 8
registration
let a1 be non empty multMagma;
cluster non empty strict SubStr of a1;
end;
:: MONOID_0:exreg 9
registration
let a1 be non empty unital multMagma;
cluster non empty strict unital associative commutative idempotent invertible cancelable uniquely-decomposable SubStr of a1;
end;
:: MONOID_0:modenot 5 => MONOID_0:mode 3
definition
let a1 be multMagma;
mode MonoidalSubStr of A1 -> multLoopStr means
the multF of it c= the multF of a1 &
(for b1 being multLoopStr
st a1 = b1
holds 1. it = 1. b1);
end;
:: MONOID_0:dfs 24
definiens
let a1 be multMagma;
let a2 be multLoopStr;
To prove
a2 is MonoidalSubStr of a1
it is sufficient to prove
thus the multF of a2 c= the multF of a1 &
(for b1 being multLoopStr
st a1 = b1
holds 1. a2 = 1. b1);
:: MONOID_0:def 24
theorem
for b1 being multMagma
for b2 being multLoopStr holds
b2 is MonoidalSubStr of b1
iff
the multF of b2 c= the multF of b1 &
(for b3 being multLoopStr
st b1 = b3
holds 1. b2 = 1. b3);
:: MONOID_0:exreg 10
registration
let a1 be multMagma;
cluster strict MonoidalSubStr of a1;
end;
:: MONOID_0:exreg 11
registration
let a1 be non empty multMagma;
cluster non empty strict MonoidalSubStr of a1;
end;
:: MONOID_0:modenot 6 => MONOID_0:mode 3
definition
let a1 be multMagma;
mode MonoidalSubStr of A1 -> multLoopStr means
the multF of it c= the multF of a1 & 1. it = 1. a1;
end;
:: MONOID_0:dfs 25
definiens
let a1, a2 be multLoopStr;
To prove
a2 is MonoidalSubStr of a1
it is sufficient to prove
thus the multF of a2 c= the multF of a1 & 1. a2 = 1. a1;
:: MONOID_0:def 25
theorem
for b1, b2 being multLoopStr holds
b2 is MonoidalSubStr of b1
iff
the multF of b2 c= the multF of b1 & 1. b2 = 1. b1;
:: MONOID_0:exreg 12
registration
let a1 be non empty well-unital multLoopStr;
cluster non empty strict associative commutative well-unital idempotent invertible cancelable uniquely-decomposable MonoidalSubStr of a1;
end;
:: MONOID_0:th 23
theorem
for b1 being multMagma
for b2 being MonoidalSubStr of b1 holds
b2 is SubStr of b1;
:: MONOID_0:modenot 7 => MONOID_0:mode 4
definition
let a1 be multMagma;
let a2 be MonoidalExtension of a1;
redefine mode SubStr of a2 -> SubStr of a1;
end;
:: MONOID_0:modenot 8 => MONOID_0:mode 5
definition
let a1 be multMagma;
let a2 be SubStr of a1;
redefine mode SubStr of a2 -> SubStr of a1;
end;
:: MONOID_0:modenot 9 => MONOID_0:mode 6
definition
let a1 be multMagma;
let a2 be MonoidalSubStr of a1;
redefine mode SubStr of a2 -> SubStr of a1;
end;
:: MONOID_0:modenot 10 => MONOID_0:mode 7
definition
let a1 be multMagma;
let a2 be MonoidalSubStr of a1;
redefine mode MonoidalSubStr of a2 -> MonoidalSubStr of a1;
end;
:: MONOID_0:th 24
theorem
for b1 being non empty multMagma
for b2 being non empty multLoopStr holds
b1 is SubStr of b1 & b2 is MonoidalSubStr of b2;
:: MONOID_0:th 25
theorem
for b1 being non empty multMagma
for b2 being non empty SubStr of b1
for b3 being non empty MonoidalSubStr of b1 holds
the carrier of b2 c= the carrier of b1 & the carrier of b3 c= the carrier of b1;
:: MONOID_0:th 26
theorem
for b1 being non empty multMagma
for b2 being non empty SubStr of b1 holds
the multF of b2 = (the multF of b1) || the carrier of b2;
:: MONOID_0:th 27
theorem
for b1 being non empty multMagma
for b2 being non empty SubStr of b1
for b3, b4 being Element of the carrier of b2
for b5, b6 being Element of the carrier of b1
st b3 = b5 & b4 = b6
holds b3 * b4 = b5 * b6;
:: MONOID_0:th 28
theorem
for b1 being non empty multMagma
for b2, b3 being non empty SubStr of b1
st the carrier of b2 = the carrier of b3
holds multMagma(#the carrier of b2,the multF of b2#) = multMagma(#the carrier of b3,the multF of b3#);
:: MONOID_0:th 29
theorem
for b1 being non empty multLoopStr
for b2, b3 being non empty MonoidalSubStr of b1
st the carrier of b2 = the carrier of b3
holds multLoopStr(#the carrier of b2,the multF of b2,the OneF of b2#) = multLoopStr(#the carrier of b3,the multF of b3,the OneF of b3#);
:: MONOID_0:th 30
theorem
for b1 being non empty multMagma
for b2, b3 being non empty SubStr of b1
st the carrier of b2 c= the carrier of b3
holds b2 is SubStr of b3;
:: MONOID_0:th 31
theorem
for b1 being non empty multLoopStr
for b2, b3 being non empty MonoidalSubStr of b1
st the carrier of b2 c= the carrier of b3
holds b2 is MonoidalSubStr of b3;
:: MONOID_0:th 32
theorem
for b1 being non empty multMagma
for b2 being non empty SubStr of b1
st b1 is unital & the_unity_wrt the multF of b1 in the carrier of b2
holds b2 is unital & the_unity_wrt the multF of b1 = the_unity_wrt the multF of b2;
:: MONOID_0:th 33
theorem
for b1 being non empty well-unital multLoopStr
for b2 being non empty MonoidalSubStr of b1 holds
b2 is well-unital;
:: MONOID_0:th 34
theorem
for b1 being non empty multMagma
for b2 being non empty SubStr of b1
st b1 is commutative
holds b2 is commutative;
:: MONOID_0:th 35
theorem
for b1 being non empty multMagma
for b2 being non empty SubStr of b1
st b1 is associative
holds b2 is associative;
:: MONOID_0:th 36
theorem
for b1 being non empty multMagma
for b2 being non empty SubStr of b1
st b1 is idempotent
holds b2 is idempotent;
:: MONOID_0:th 37
theorem
for b1 being non empty multMagma
for b2 being non empty SubStr of b1
st b1 is cancelable
holds b2 is cancelable;
:: MONOID_0:th 38
theorem
for b1 being non empty multMagma
for b2 being non empty SubStr of b1
st the_unity_wrt the multF of b1 in the carrier of b2 & b1 is uniquely-decomposable
holds b2 is uniquely-decomposable;
:: MONOID_0:th 39
theorem
for b1 being non empty well-unital uniquely-decomposable multLoopStr
for b2 being non empty MonoidalSubStr of b1 holds
b2 is uniquely-decomposable;
:: MONOID_0:condreg 20
registration
let a1 be non empty constituted-Functions multMagma;
cluster non empty -> constituted-Functions (SubStr of a1);
end;
:: MONOID_0:condreg 21
registration
let a1 be non empty constituted-Functions multMagma;
cluster non empty -> constituted-Functions (MonoidalSubStr of a1);
end;
:: MONOID_0:condreg 22
registration
let a1 be non empty constituted-FinSeqs multMagma;
cluster non empty -> constituted-FinSeqs (SubStr of a1);
end;
:: MONOID_0:condreg 23
registration
let a1 be non empty constituted-FinSeqs multMagma;
cluster non empty -> constituted-FinSeqs (MonoidalSubStr of a1);
end;
:: MONOID_0:condreg 24
registration
let a1 be non empty well-unital multLoopStr;
cluster non empty -> well-unital (MonoidalSubStr of a1);
end;
:: MONOID_0:condreg 25
registration
let a1 be non empty commutative multMagma;
cluster non empty -> commutative (SubStr of a1);
end;
:: MONOID_0:condreg 26
registration
let a1 be non empty commutative multMagma;
cluster non empty -> commutative (MonoidalSubStr of a1);
end;
:: MONOID_0:condreg 27
registration
let a1 be non empty associative multMagma;
cluster non empty -> associative (SubStr of a1);
end;
:: MONOID_0:condreg 28
registration
let a1 be non empty associative multMagma;
cluster non empty -> associative (MonoidalSubStr of a1);
end;
:: MONOID_0:condreg 29
registration
let a1 be non empty idempotent multMagma;
cluster non empty -> idempotent (SubStr of a1);
end;
:: MONOID_0:condreg 30
registration
let a1 be non empty idempotent multMagma;
cluster non empty -> idempotent (MonoidalSubStr of a1);
end;
:: MONOID_0:condreg 31
registration
let a1 be non empty cancelable multMagma;
cluster non empty -> cancelable (SubStr of a1);
end;
:: MONOID_0:condreg 32
registration
let a1 be non empty cancelable multMagma;
cluster non empty -> cancelable (MonoidalSubStr of a1);
end;
:: MONOID_0:condreg 33
registration
let a1 be non empty well-unital uniquely-decomposable multLoopStr;
cluster non empty -> uniquely-decomposable (MonoidalSubStr of a1);
end;
:: MONOID_0:sch 1
scheme MONOID_0:sch 1
{F1 -> non empty multMagma,
F2 -> non empty Element of bool the carrier of F1()}:
ex b1 being non empty strict SubStr of F1() st
the carrier of b1 = F2()
provided
for b1, b2 being Element of F2() holds
b1 * b2 in F2();
:: MONOID_0:sch 2
scheme MONOID_0:sch 2
{F1 -> non empty multMagma}:
ex b1 being non empty strict SubStr of F1() st
for b2 being Element of the carrier of F1() holds
b2 in the carrier of b1
iff
P1[b2]
provided
for b1, b2 being Element of the carrier of F1()
st P1[b1] & P1[b2]
holds P1[b1 * b2]
and
ex b1 being Element of the carrier of F1() st
P1[b1];
:: MONOID_0:sch 3
scheme MONOID_0:sch 3
{F1 -> non empty multLoopStr,
F2 -> non empty Element of bool the carrier of F1()}:
ex b1 being non empty strict MonoidalSubStr of F1() st
the carrier of b1 = F2()
provided
for b1, b2 being Element of F2() holds
b1 * b2 in F2()
and
1. F1() in F2();
:: MONOID_0:sch 4
scheme MONOID_0:sch 4
{F1 -> non empty multLoopStr}:
ex b1 being non empty strict MonoidalSubStr of F1() st
for b2 being Element of the carrier of F1() holds
b2 in the carrier of b1
iff
P1[b2]
provided
for b1, b2 being Element of the carrier of F1()
st P1[b1] & P1[b2]
holds P1[b1 * b2]
and
P1[1. F1()];
:: MONOID_0:funcnot 3 => ALGSTR_0:func 6
notation
let a1 be non empty multMagma;
let a2, a3 be Element of the carrier of a1;
synonym a2 [*] a3 for a2 * a3;
end;
:: MONOID_0:funcnot 4 => MONOID_0:func 2
definition
func <REAL,+> -> non empty strict unital associative commutative invertible cancelable multMagma equals
multMagma(#REAL,addreal#);
end;
:: MONOID_0:def 26
theorem
<REAL,+> = multMagma(#REAL,addreal#);
:: MONOID_0:th 41
theorem
for b1 being set holds
b1 is Element of the carrier of <REAL,+>
iff
b1 is Element of REAL;
:: MONOID_0:th 43
theorem
for b1 being non empty SubStr of <REAL,+>
for b2, b3 being Element of the carrier of b1
for b4, b5 being Element of REAL
st b2 = b4 & b3 = b5
holds b2 * b3 = b4 + b5;
:: MONOID_0:th 44
theorem
for b1 being non empty unital SubStr of <REAL,+> holds
the_unity_wrt the multF of b1 = 0;
:: MONOID_0:condreg 34
registration
let a1 be non empty unital multMagma;
cluster non empty associative invertible -> unital Group-like cancelable (SubStr of a1);
end;
:: MONOID_0:funcnot 5 => MONOID_0:func 3
definition
redefine func INT.Group -> non empty strict unital invertible SubStr of <REAL,+>;
end;
:: MONOID_0:th 46
theorem
for b1 being non empty strict SubStr of <REAL,+> holds
b1 = INT.Group
iff
the carrier of b1 = INT;
:: MONOID_0:th 47
theorem
for b1 being set holds
b1 is Element of the carrier of INT.Group
iff
b1 is integer set;
:: MONOID_0:funcnot 6 => MONOID_0:func 4
definition
func <NAT,+> -> non empty strict unital uniquely-decomposable SubStr of INT.Group means
the carrier of it = NAT;
end;
:: MONOID_0:def 27
theorem
for b1 being non empty strict unital uniquely-decomposable SubStr of INT.Group holds
b1 = <NAT,+>
iff
the carrier of b1 = NAT;
:: MONOID_0:funcnot 7 => MONOID_0:func 5
definition
func <NAT,+,0> -> non empty strict well-unital MonoidalExtension of <NAT,+> means
TRUE;
end;
:: MONOID_0:def 28
theorem
for b1 being non empty strict well-unital MonoidalExtension of <NAT,+> holds
(b1 = <NAT,+,0> implies TRUE) & b1 = <NAT,+,0>;
:: MONOID_0:funcnot 8 => BINOP_2:func 47
definition
func addnat -> Function-like quasi_total Relation of [:NAT,NAT:],NAT equals
the multF of <NAT,+>;
end;
:: MONOID_0:def 29
theorem
addnat = the multF of <NAT,+>;
:: MONOID_0:th 49
theorem
<NAT,+> = multMagma(#NAT,addnat#);
:: MONOID_0:th 50
theorem
for b1 being set holds
b1 is Element of the carrier of <NAT,+,0>
iff
b1 is Element of NAT;
:: MONOID_0:th 51
theorem
for b1, b2 being Element of NAT
for b3, b4 being Element of the carrier of <NAT,+,0>
st b1 = b3 & b2 = b4
holds b3 * b4 = b1 + b2;
:: MONOID_0:th 52
theorem
<NAT,+,0> = multLoopStr(#NAT,addnat,0#);
:: MONOID_0:th 53
theorem
addnat = addreal || NAT & addnat = addint || NAT;
:: MONOID_0:th 54
theorem
0 is_a_unity_wrt addnat & addnat is uniquely-decomposable(NAT);
:: MONOID_0:funcnot 9 => MONOID_0:func 6
definition
func <REAL,*> -> non empty strict unital associative commutative multMagma equals
multMagma(#REAL,multreal#);
end;
:: MONOID_0:def 30
theorem
<REAL,*> = multMagma(#REAL,multreal#);
:: MONOID_0:th 56
theorem
for b1 being set holds
b1 is Element of the carrier of <REAL,*>
iff
b1 is Element of REAL;
:: MONOID_0:th 58
theorem
for b1 being non empty SubStr of <REAL,*>
for b2, b3 being Element of the carrier of b1
for b4, b5 being Element of REAL
st b2 = b4 & b3 = b5
holds b2 * b3 = b4 * b5;
:: MONOID_0:th 60
theorem
for b1 being non empty unital SubStr of <REAL,*>
st the_unity_wrt the multF of b1 <> 0
holds the_unity_wrt the multF of b1 = 1;
:: MONOID_0:funcnot 10 => MONOID_0:func 7
definition
func <NAT,*> -> non empty strict unital uniquely-decomposable SubStr of <REAL,*> means
the carrier of it = NAT;
end;
:: MONOID_0:def 31
theorem
for b1 being non empty strict unital uniquely-decomposable SubStr of <REAL,*> holds
b1 = <NAT,*>
iff
the carrier of b1 = NAT;
:: MONOID_0:funcnot 11 => MONOID_0:func 8
definition
func <NAT,*,1> -> non empty strict well-unital MonoidalExtension of <NAT,*> means
TRUE;
end;
:: MONOID_0:def 32
theorem
for b1 being non empty strict well-unital MonoidalExtension of <NAT,*> holds
(b1 = <NAT,*,1> implies TRUE) & b1 = <NAT,*,1>;
:: MONOID_0:funcnot 12 => BINOP_2:func 48
definition
func multnat -> Function-like quasi_total Relation of [:NAT,NAT:],NAT equals
the multF of <NAT,*>;
end;
:: MONOID_0:def 33
theorem
multnat = the multF of <NAT,*>;
:: MONOID_0:th 61
theorem
<NAT,*> = multMagma(#NAT,multnat#);
:: MONOID_0:th 62
theorem
for b1, b2 being Element of NAT
for b3, b4 being Element of the carrier of <NAT,*>
st b1 = b3 & b2 = b4
holds b3 * b4 = b1 * b2;
:: MONOID_0:th 63
theorem
the_unity_wrt the multF of <NAT,*> = 1;
:: MONOID_0:th 64
theorem
for b1, b2 being Element of NAT
for b3, b4 being Element of the carrier of <NAT,*,1>
st b1 = b3 & b2 = b4
holds b3 * b4 = b1 * b2;
:: MONOID_0:th 65
theorem
<NAT,*,1> = multLoopStr(#NAT,multnat,1#);
:: MONOID_0:th 66
theorem
multnat = multreal || NAT;
:: MONOID_0:th 67
theorem
1 is_a_unity_wrt multnat & multnat is uniquely-decomposable(NAT);
:: MONOID_0:funcnot 13 => MONOID_0:func 9
definition
let a1 be non empty set;
func A1 *+^ -> non empty strict unital associative constituted-FinSeqs cancelable uniquely-decomposable multMagma means
the carrier of it = a1 * &
(for b1, b2 being Element of the carrier of it holds
b1 * b2 = b1 ^ b2);
end;
:: MONOID_0:def 34
theorem
for b1 being non empty set
for b2 being non empty strict unital associative constituted-FinSeqs cancelable uniquely-decomposable multMagma holds
b2 = b1 *+^
iff
the carrier of b2 = b1 * &
(for b3, b4 being Element of the carrier of b2 holds
b3 * b4 = b3 ^ b4);
:: MONOID_0:funcnot 14 => MONOID_0:func 10
definition
let a1 be non empty set;
func A1 *+^+<0> -> non empty strict well-unital MonoidalExtension of a1 *+^ means
TRUE;
end;
:: MONOID_0:def 35
theorem
for b1 being non empty set
for b2 being non empty strict well-unital MonoidalExtension of b1 *+^ holds
(b2 = b1 *+^+<0> implies TRUE) & b2 = b1 *+^+<0>;
:: MONOID_0:funcnot 15 => MONOID_0:func 11
definition
let a1 be non empty set;
func A1 -concatenation -> Function-like quasi_total Relation of [:a1 *,a1 *:],a1 * equals
the multF of a1 *+^;
end;
:: MONOID_0:def 36
theorem
for b1 being non empty set holds
b1 -concatenation = the multF of b1 *+^;
:: MONOID_0:th 68
theorem
for b1 being non empty set holds
b1 *+^ = multMagma(#b1 *,b1 -concatenation#);
:: MONOID_0:th 69
theorem
for b1 being non empty set holds
the_unity_wrt the multF of b1 *+^ = {};
:: MONOID_0:th 70
theorem
for b1 being non empty set holds
the carrier of b1 *+^+<0> = b1 * & the multF of b1 *+^+<0> = b1 -concatenation & 1. (b1 *+^+<0>) = {};
:: MONOID_0:th 71
theorem
for b1 being non empty set
for b2, b3 being Element of the carrier of b1 *+^+<0> holds
b2 * b3 = b2 ^ b3;
:: MONOID_0:th 72
theorem
for b1 being non empty set
for b2 being non empty SubStr of b1 *+^
for b3, b4 being Element of the carrier of b2 holds
b3 * b4 = b3 ^ b4;
:: MONOID_0:th 73
theorem
for b1 being non empty set
for b2 being non empty unital SubStr of b1 *+^ holds
the_unity_wrt the multF of b2 = {};
:: MONOID_0:th 74
theorem
for b1 being non empty set
for b2 being non empty SubStr of b1 *+^
st {} is Element of the carrier of b2
holds b2 is unital & the_unity_wrt the multF of b2 = {};
:: MONOID_0:th 75
theorem
for b1, b2 being non empty set
st b1 c= b2
holds b1 *+^ is SubStr of b2 *+^;
:: MONOID_0:th 76
theorem
for b1 being non empty set holds
b1 -concatenation is having_a_unity(b1 *) & the_unity_wrt (b1 -concatenation) = {} & b1 -concatenation is associative(b1 *);
:: MONOID_0:funcnot 16 => MONOID_0:func 12
definition
let a1 be set;
func GPFuncs A1 -> non empty strict unital associative constituted-Functions multMagma means
the carrier of it = PFuncs(a1,a1) &
(for b1, b2 being Element of the carrier of it holds
b1 * b2 = b2 * b1);
end;
:: MONOID_0:def 37
theorem
for b1 being set
for b2 being non empty strict unital associative constituted-Functions multMagma holds
b2 = GPFuncs b1
iff
the carrier of b2 = PFuncs(b1,b1) &
(for b3, b4 being Element of the carrier of b2 holds
b3 * b4 = b4 * b3);
:: MONOID_0:funcnot 17 => MONOID_0:func 13
definition
let a1 be set;
func MPFuncs A1 -> non empty strict well-unital MonoidalExtension of GPFuncs a1 means
TRUE;
end;
:: MONOID_0:def 38
theorem
for b1 being set
for b2 being non empty strict well-unital MonoidalExtension of GPFuncs b1 holds
(b2 = MPFuncs b1 implies TRUE) & b2 = MPFuncs b1;
:: MONOID_0:funcnot 18 => MONOID_0:func 14
definition
let a1 be set;
func A1 -composition -> Function-like quasi_total Relation of [:PFuncs(a1,a1),PFuncs(a1,a1):],PFuncs(a1,a1) equals
the multF of GPFuncs a1;
end;
:: MONOID_0:def 39
theorem
for b1 being set holds
b1 -composition = the multF of GPFuncs b1;
:: MONOID_0:th 77
theorem
for b1, b2 being set holds
b1 is Element of the carrier of GPFuncs b2
iff
b1 is Function-like Relation of b2,b2;
:: MONOID_0:th 78
theorem
for b1 being set holds
the_unity_wrt the multF of GPFuncs b1 = id b1;
:: MONOID_0:th 79
theorem
for b1 being set
for b2 being non empty SubStr of GPFuncs b1
for b3, b4 being Element of the carrier of b2 holds
b3 * b4 = b4 * b3;
:: MONOID_0:th 80
theorem
for b1 being set
for b2 being non empty SubStr of GPFuncs b1
st id b1 is Element of the carrier of b2
holds b2 is unital & the_unity_wrt the multF of b2 = id b1;
:: MONOID_0:th 81
theorem
for b1, b2 being set
st b1 c= b2
holds GPFuncs b1 is SubStr of GPFuncs b2;
:: MONOID_0:funcnot 19 => MONOID_0:func 15
definition
let a1 be set;
func GFuncs A1 -> non empty strict unital SubStr of GPFuncs a1 means
the carrier of it = Funcs(a1,a1);
end;
:: MONOID_0:def 40
theorem
for b1 being set
for b2 being non empty strict unital SubStr of GPFuncs b1 holds
b2 = GFuncs b1
iff
the carrier of b2 = Funcs(b1,b1);
:: MONOID_0:funcnot 20 => MONOID_0:func 16
definition
let a1 be set;
func MFuncs A1 -> strict well-unital MonoidalExtension of GFuncs a1 means
TRUE;
end;
:: MONOID_0:def 41
theorem
for b1 being set
for b2 being strict well-unital MonoidalExtension of GFuncs b1 holds
(b2 = MFuncs b1 implies TRUE) & b2 = MFuncs b1;
:: MONOID_0:th 82
theorem
for b1, b2 being set holds
b1 is Element of the carrier of GFuncs b2
iff
b1 is Function-like quasi_total Relation of b2,b2;
:: MONOID_0:th 83
theorem
for b1 being set holds
the multF of GFuncs b1 = b1 -composition || Funcs(b1,b1);
:: MONOID_0:th 84
theorem
for b1 being set holds
the_unity_wrt the multF of GFuncs b1 = id b1;
:: MONOID_0:th 85
theorem
for b1 being set holds
the carrier of MFuncs b1 = Funcs(b1,b1) &
the multF of MFuncs b1 = b1 -composition || Funcs(b1,b1) &
1. MFuncs b1 = id b1;
:: MONOID_0:funcnot 21 => MONOID_0:func 17
definition
let a1 be set;
func GPerms A1 -> non empty strict unital invertible SubStr of GFuncs a1 means
for b1 being Element of the carrier of GFuncs a1 holds
b1 in the carrier of it
iff
b1 is Function-like quasi_total bijective Relation of a1,a1;
end;
:: MONOID_0:def 42
theorem
for b1 being set
for b2 being non empty strict unital invertible SubStr of GFuncs b1 holds
b2 = GPerms b1
iff
for b3 being Element of the carrier of GFuncs b1 holds
b3 in the carrier of b2
iff
b3 is Function-like quasi_total bijective Relation of b1,b1;
:: MONOID_0:th 86
theorem
for b1, b2 being set holds
b1 is Element of the carrier of GPerms b2
iff
b1 is Function-like quasi_total bijective Relation of b2,b2;
:: MONOID_0:th 87
theorem
for b1 being set holds
the_unity_wrt the multF of GPerms b1 = id b1 & 1_ GPerms b1 = id b1;
:: MONOID_0:th 88
theorem
for b1 being set
for b2 being Element of the carrier of GPerms b1 holds
b2 " = b2 ";
:: MONOID_0:th 89
theorem
for b1 being 1-sorted
st the carrier of b1 is functional
holds b1 is constituted-Functions;