Article FREEALG, MML version 4.99.1005
:: FREEALG:attrnot 1 => FREEALG:attr 1
definition
let a1 be set;
attr a1 is disjoint_with_NAT means
a1 misses NAT;
end;
:: FREEALG:dfs 1
definiens
let a1 be set;
To prove
a1 is disjoint_with_NAT
it is sufficient to prove
thus a1 misses NAT;
:: FREEALG:def 1
theorem
for b1 being set holds
b1 is disjoint_with_NAT
iff
b1 misses NAT;
:: FREEALG:exreg 1
registration
cluster non empty disjoint_with_NAT set;
end;
:: FREEALG:attrnot 2 => RELAT_1:attr 2
notation
let a1 be Relation-like set;
antonym with_zero for non-empty;
end;
:: FREEALG:attrnot 3 => RELAT_1:attr 2
notation
let a1 be Relation-like set;
synonym without_zero for non-empty;
end;
:: FREEALG:attrnot 4 => RELAT_1:attr 2
definition
let a1 be Relation-like set;
attr a1 is with_zero means
not 0 in proj2 a1;
end;
:: FREEALG:dfs 2
definiens
let a1 be Relation-like set;
To prove
a1 is non-empty
it is sufficient to prove
thus not 0 in proj2 a1;
:: FREEALG:def 2
theorem
for b1 being Relation-like set holds
b1 is non-empty
iff
not 0 in proj2 b1;
:: FREEALG:exreg 2
registration
cluster non empty Relation-like non non-empty Function-like finite FinSequence-like FinSequence of NAT;
end;
:: FREEALG:exreg 3
registration
cluster non empty Relation-like non-empty Function-like finite FinSequence-like FinSequence of NAT;
end;
:: FREEALG:funcnot 1 => FREEALG:func 1
definition
let a1 be non empty partial quasi_total non-empty UAStr;
let a2 be Element of NAT;
assume a2 in dom the charact of a1;
func oper(A2,A1) -> Element of Operations a1 equals
(the charact of a1) . a2;
end;
:: FREEALG:def 4
theorem
for b1 being non empty partial quasi_total non-empty UAStr
for b2 being Element of NAT
st b2 in dom the charact of b1
holds oper(b2,b1) = (the charact of b1) . b2;
:: FREEALG:modenot 1 => FREEALG:mode 1
definition
let a1 be non empty partial quasi_total non-empty UAStr;
mode GeneratorSet of A1 -> Element of bool the carrier of a1 means
for b1 being Element of bool the carrier of a1
st b1 is opers_closed(a1) & it c= b1
holds b1 = the carrier of a1;
end;
:: FREEALG:dfs 4
definiens
let a1 be non empty partial quasi_total non-empty UAStr;
let a2 be Element of bool the carrier of a1;
To prove
a2 is GeneratorSet of a1
it is sufficient to prove
thus for b1 being Element of bool the carrier of a1
st b1 is opers_closed(a1) & a2 c= b1
holds b1 = the carrier of a1;
:: FREEALG:def 5
theorem
for b1 being non empty partial quasi_total non-empty UAStr
for b2 being Element of bool the carrier of b1 holds
b2 is GeneratorSet of b1
iff
for b3 being Element of bool the carrier of b1
st b3 is opers_closed(b1) & b2 c= b3
holds b3 = the carrier of b1;
:: FREEALG:attrnot 5 => FREEALG:attr 2
definition
let a1 be non empty partial quasi_total non-empty UAStr;
let a2 be GeneratorSet of a1;
attr a2 is free means
for b1 being non empty partial quasi_total non-empty UAStr
st a1,b1 are_similar
for b2 being Function-like quasi_total Relation of a2,the carrier of b1 holds
ex b3 being Function-like quasi_total Relation of the carrier of a1,the carrier of b1 st
b3 is_homomorphism a1,b1 & b3 | a2 = b2;
end;
:: FREEALG:dfs 5
definiens
let a1 be non empty partial quasi_total non-empty UAStr;
let a2 be GeneratorSet of a1;
To prove
a2 is free
it is sufficient to prove
thus for b1 being non empty partial quasi_total non-empty UAStr
st a1,b1 are_similar
for b2 being Function-like quasi_total Relation of a2,the carrier of b1 holds
ex b3 being Function-like quasi_total Relation of the carrier of a1,the carrier of b1 st
b3 is_homomorphism a1,b1 & b3 | a2 = b2;
:: FREEALG:def 6
theorem
for b1 being non empty partial quasi_total non-empty UAStr
for b2 being GeneratorSet of b1 holds
b2 is free(b1)
iff
for b3 being non empty partial quasi_total non-empty UAStr
st b1,b3 are_similar
for b4 being Function-like quasi_total Relation of b2,the carrier of b3 holds
ex b5 being Function-like quasi_total Relation of the carrier of b1,the carrier of b3 st
b5 is_homomorphism b1,b3 & b5 | b2 = b4;
:: FREEALG:attrnot 6 => FREEALG:attr 3
definition
let a1 be non empty partial quasi_total non-empty UAStr;
attr a1 is free means
ex b1 being GeneratorSet of a1 st
b1 is free(a1);
end;
:: FREEALG:dfs 6
definiens
let a1 be non empty partial quasi_total non-empty UAStr;
To prove
a1 is free
it is sufficient to prove
thus ex b1 being GeneratorSet of a1 st
b1 is free(a1);
:: FREEALG:def 7
theorem
for b1 being non empty partial quasi_total non-empty UAStr holds
b1 is free
iff
ex b2 being GeneratorSet of b1 st
b2 is free(b1);
:: FREEALG:exreg 4
registration
cluster non empty strict partial quasi_total non-empty free UAStr;
end;
:: FREEALG:exreg 5
registration
let a1 be non empty partial quasi_total non-empty free UAStr;
cluster free GeneratorSet of a1;
end;
:: FREEALG:th 1
theorem
for b1 being non empty strict partial quasi_total non-empty UAStr
for b2 being Element of bool the carrier of b1
st (Constants b1 = {} implies b2 <> {})
holds b2 is GeneratorSet of b1
iff
GenUnivAlg b2 = b1;
:: FREEALG:funcnot 2 => FREEALG:func 2
definition
let a1 be non empty FinSequence of NAT;
let a2 be set;
func REL(A1,A2) -> Relation of (dom a1) \/ a2,((dom a1) \/ a2) * means
for b1 being Element of (dom a1) \/ a2
for b2 being Element of ((dom a1) \/ a2) * holds
[b1,b2] in it
iff
b1 in dom a1 & a1 . b1 = len b2;
end;
:: FREEALG:def 8
theorem
for b1 being non empty FinSequence of NAT
for b2 being set
for b3 being Relation of (dom b1) \/ b2,((dom b1) \/ b2) * holds
b3 = REL(b1,b2)
iff
for b4 being Element of (dom b1) \/ b2
for b5 being Element of ((dom b1) \/ b2) * holds
[b4,b5] in b3
iff
b4 in dom b1 & b1 . b4 = len b5;
:: FREEALG:funcnot 3 => FREEALG:func 3
definition
let a1 be non empty FinSequence of NAT;
let a2 be set;
func DTConUA(A1,A2) -> strict DTConstrStr equals
DTConstrStr(#(dom a1) \/ a2,REL(a1,a2)#);
end;
:: FREEALG:def 9
theorem
for b1 being non empty FinSequence of NAT
for b2 being set holds
DTConUA(b1,b2) = DTConstrStr(#(dom b1) \/ b2,REL(b1,b2)#);
:: FREEALG:funcreg 1
registration
let a1 be non empty FinSequence of NAT;
let a2 be set;
cluster DTConUA(a1,a2) -> non empty strict;
end;
:: FREEALG:th 2
theorem
for b1 being non empty FinSequence of NAT
for b2 being set holds
Terminals DTConUA(b1,b2) c= b2 & NonTerminals DTConUA(b1,b2) = dom b1;
:: FREEALG:th 3
theorem
for b1 being non empty FinSequence of NAT
for b2 being disjoint_with_NAT set holds
Terminals DTConUA(b1,b2) = b2;
:: FREEALG:funcreg 2
registration
let a1 be non empty FinSequence of NAT;
let a2 be set;
cluster DTConUA(a1,a2) -> strict with_nonterminals;
end;
:: FREEALG:funcreg 3
registration
let a1 be non empty non non-empty FinSequence of NAT;
let a2 be set;
cluster DTConUA(a1,a2) -> strict with_nonterminals with_useful_nonterminals;
end;
:: FREEALG:funcreg 4
registration
let a1 be non empty FinSequence of NAT;
let a2 be non empty disjoint_with_NAT set;
cluster DTConUA(a1,a2) -> strict with_terminals with_nonterminals with_useful_nonterminals;
end;
:: FREEALG:funcnot 4 => FREEALG:func 4
definition
let a1 be non empty FinSequence of NAT;
let a2 be set;
let a3 be natural set;
assume a3 in dom a1;
func Sym(A3,A1,A2) -> Element of the carrier of DTConUA(a1,a2) equals
a3;
end;
:: FREEALG:def 10
theorem
for b1 being non empty FinSequence of NAT
for b2 being set
for b3 being natural set
st b3 in dom b1
holds Sym(b3,b1,b2) = b3;
:: FREEALG:funcnot 5 => FREEALG:func 5
definition
let a1 be non empty FinSequence of NAT;
let a2 be non empty disjoint_with_NAT set;
let a3 be natural set;
assume a3 in dom a1;
func FreeOpNSG(A3,A1,A2) -> non empty Function-like homogeneous quasi_total Relation of (TS DTConUA(a1,a2)) *,TS DTConUA(a1,a2) means
dom it = (a1 /. a3) -tuples_on TS DTConUA(a1,a2) &
(for b1 being FinSequence of TS DTConUA(a1,a2)
st b1 in dom it
holds it . b1 = (Sym(a3,a1,a2)) -tree b1);
end;
:: FREEALG:def 11
theorem
for b1 being non empty FinSequence of NAT
for b2 being non empty disjoint_with_NAT set
for b3 being natural set
st b3 in dom b1
for b4 being non empty Function-like homogeneous quasi_total Relation of (TS DTConUA(b1,b2)) *,TS DTConUA(b1,b2) holds
b4 = FreeOpNSG(b3,b1,b2)
iff
dom b4 = (b1 /. b3) -tuples_on TS DTConUA(b1,b2) &
(for b5 being FinSequence of TS DTConUA(b1,b2)
st b5 in dom b4
holds b4 . b5 = (Sym(b3,b1,b2)) -tree b5);
:: FREEALG:funcnot 6 => FREEALG:func 6
definition
let a1 be non empty FinSequence of NAT;
let a2 be non empty disjoint_with_NAT set;
func FreeOpSeqNSG(A1,A2) -> FinSequence of PFuncs((TS DTConUA(a1,a2)) *,TS DTConUA(a1,a2)) means
len it = len a1 &
(for b1 being Element of NAT
st b1 in dom it
holds it . b1 = FreeOpNSG(b1,a1,a2));
end;
:: FREEALG:def 12
theorem
for b1 being non empty FinSequence of NAT
for b2 being non empty disjoint_with_NAT set
for b3 being FinSequence of PFuncs((TS DTConUA(b1,b2)) *,TS DTConUA(b1,b2)) holds
b3 = FreeOpSeqNSG(b1,b2)
iff
len b3 = len b1 &
(for b4 being Element of NAT
st b4 in dom b3
holds b3 . b4 = FreeOpNSG(b4,b1,b2));
:: FREEALG:funcnot 7 => FREEALG:func 7
definition
let a1 be non empty FinSequence of NAT;
let a2 be non empty disjoint_with_NAT set;
func FreeUnivAlgNSG(A1,A2) -> non empty strict partial quasi_total non-empty UAStr equals
UAStr(#TS DTConUA(a1,a2),FreeOpSeqNSG(a1,a2)#);
end;
:: FREEALG:def 13
theorem
for b1 being non empty FinSequence of NAT
for b2 being non empty disjoint_with_NAT set holds
FreeUnivAlgNSG(b1,b2) = UAStr(#TS DTConUA(b1,b2),FreeOpSeqNSG(b1,b2)#);
:: FREEALG:th 4
theorem
for b1 being non empty FinSequence of NAT
for b2 being non empty disjoint_with_NAT set holds
signature FreeUnivAlgNSG(b1,b2) = b1;
:: FREEALG:funcnot 8 => FREEALG:func 8
definition
let a1 be non empty FinSequence of NAT;
let a2 be non empty disjoint_with_NAT set;
func FreeGenSetNSG(A1,A2) -> Element of bool the carrier of FreeUnivAlgNSG(a1,a2) equals
{root-tree b1 where b1 is Element of the carrier of DTConUA(a1,a2): b1 in Terminals DTConUA(a1,a2)};
end;
:: FREEALG:def 14
theorem
for b1 being non empty FinSequence of NAT
for b2 being non empty disjoint_with_NAT set holds
FreeGenSetNSG(b1,b2) = {root-tree b3 where b3 is Element of the carrier of DTConUA(b1,b2): b3 in Terminals DTConUA(b1,b2)};
:: FREEALG:th 5
theorem
for b1 being non empty FinSequence of NAT
for b2 being non empty disjoint_with_NAT set holds
FreeGenSetNSG(b1,b2) is not empty;
:: FREEALG:funcnot 9 => FREEALG:func 9
definition
let a1 be non empty FinSequence of NAT;
let a2 be non empty disjoint_with_NAT set;
redefine func FreeGenSetNSG(a1,a2) -> GeneratorSet of FreeUnivAlgNSG(a1,a2);
end;
:: FREEALG:funcnot 10 => FREEALG:func 10
definition
let a1 be non empty FinSequence of NAT;
let a2 be non empty disjoint_with_NAT set;
let a3 be non empty set;
let a4 be Element of the carrier of DTConUA(a1,a2);
let a5 be Function-like quasi_total Relation of FreeGenSetNSG(a1,a2),a3;
assume a4 in Terminals DTConUA(a1,a2);
func pi(A5,A4) -> Element of a3 equals
a5 . root-tree a4;
end;
:: FREEALG:def 15
theorem
for b1 being non empty FinSequence of NAT
for b2 being non empty disjoint_with_NAT set
for b3 being non empty set
for b4 being Element of the carrier of DTConUA(b1,b2)
for b5 being Function-like quasi_total Relation of FreeGenSetNSG(b1,b2),b3
st b4 in Terminals DTConUA(b1,b2)
holds pi(b5,b4) = b5 . root-tree b4;
:: FREEALG:funcnot 11 => FREEALG:func 11
definition
let a1 be non empty FinSequence of NAT;
let a2 be set;
let a3 be Element of the carrier of DTConUA(a1,a2);
assume ex b1 being Relation-like Function-like FinSequence-like set st
a3 ==> b1;
func @ A3 -> Element of NAT equals
a3;
end;
:: FREEALG:def 16
theorem
for b1 being non empty FinSequence of NAT
for b2 being set
for b3 being Element of the carrier of DTConUA(b1,b2)
st ex b4 being Relation-like Function-like FinSequence-like set st
b3 ==> b4
holds @ b3 = b3;
:: FREEALG:th 6
theorem
for b1 being non empty FinSequence of NAT
for b2 being non empty disjoint_with_NAT set holds
FreeGenSetNSG(b1,b2) is free(FreeUnivAlgNSG(b1,b2));
:: FREEALG:funcreg 5
registration
let a1 be non empty FinSequence of NAT;
let a2 be non empty disjoint_with_NAT set;
cluster FreeUnivAlgNSG(a1,a2) -> non empty strict partial quasi_total non-empty free;
end;
:: FREEALG:funcnot 12 => FREEALG:func 12
definition
let a1 be non empty FinSequence of NAT;
let a2 be non empty disjoint_with_NAT set;
redefine func FreeGenSetNSG(a1,a2) -> free GeneratorSet of FreeUnivAlgNSG(a1,a2);
end;
:: FREEALG:funcnot 13 => FREEALG:func 13
definition
let a1 be non empty non non-empty FinSequence of NAT;
let a2 be disjoint_with_NAT set;
let a3 be natural set;
assume a3 in dom a1;
func FreeOpZAO(A3,A1,A2) -> non empty Function-like homogeneous quasi_total Relation of (TS DTConUA(a1,a2)) *,TS DTConUA(a1,a2) means
dom it = (a1 /. a3) -tuples_on TS DTConUA(a1,a2) &
(for b1 being FinSequence of TS DTConUA(a1,a2)
st b1 in dom it
holds it . b1 = (Sym(a3,a1,a2)) -tree b1);
end;
:: FREEALG:def 17
theorem
for b1 being non empty non non-empty FinSequence of NAT
for b2 being disjoint_with_NAT set
for b3 being natural set
st b3 in dom b1
for b4 being non empty Function-like homogeneous quasi_total Relation of (TS DTConUA(b1,b2)) *,TS DTConUA(b1,b2) holds
b4 = FreeOpZAO(b3,b1,b2)
iff
dom b4 = (b1 /. b3) -tuples_on TS DTConUA(b1,b2) &
(for b5 being FinSequence of TS DTConUA(b1,b2)
st b5 in dom b4
holds b4 . b5 = (Sym(b3,b1,b2)) -tree b5);
:: FREEALG:funcnot 14 => FREEALG:func 14
definition
let a1 be non empty non non-empty FinSequence of NAT;
let a2 be disjoint_with_NAT set;
func FreeOpSeqZAO(A1,A2) -> FinSequence of PFuncs((TS DTConUA(a1,a2)) *,TS DTConUA(a1,a2)) means
len it = len a1 &
(for b1 being Element of NAT
st b1 in dom it
holds it . b1 = FreeOpZAO(b1,a1,a2));
end;
:: FREEALG:def 18
theorem
for b1 being non empty non non-empty FinSequence of NAT
for b2 being disjoint_with_NAT set
for b3 being FinSequence of PFuncs((TS DTConUA(b1,b2)) *,TS DTConUA(b1,b2)) holds
b3 = FreeOpSeqZAO(b1,b2)
iff
len b3 = len b1 &
(for b4 being Element of NAT
st b4 in dom b3
holds b3 . b4 = FreeOpZAO(b4,b1,b2));
:: FREEALG:funcnot 15 => FREEALG:func 15
definition
let a1 be non empty non non-empty FinSequence of NAT;
let a2 be disjoint_with_NAT set;
func FreeUnivAlgZAO(A1,A2) -> non empty strict partial quasi_total non-empty UAStr equals
UAStr(#TS DTConUA(a1,a2),FreeOpSeqZAO(a1,a2)#);
end;
:: FREEALG:def 19
theorem
for b1 being non empty non non-empty FinSequence of NAT
for b2 being disjoint_with_NAT set holds
FreeUnivAlgZAO(b1,b2) = UAStr(#TS DTConUA(b1,b2),FreeOpSeqZAO(b1,b2)#);
:: FREEALG:th 7
theorem
for b1 being non empty non non-empty FinSequence of NAT
for b2 being disjoint_with_NAT set holds
signature FreeUnivAlgZAO(b1,b2) = b1;
:: FREEALG:th 8
theorem
for b1 being non empty non non-empty FinSequence of NAT
for b2 being disjoint_with_NAT set holds
FreeUnivAlgZAO(b1,b2) is with_const_op;
:: FREEALG:th 9
theorem
for b1 being non empty non non-empty FinSequence of NAT
for b2 being disjoint_with_NAT set holds
Constants FreeUnivAlgZAO(b1,b2) <> {};
:: FREEALG:funcnot 16 => FREEALG:func 16
definition
let a1 be non empty non non-empty FinSequence of NAT;
let a2 be disjoint_with_NAT set;
func FreeGenSetZAO(A1,A2) -> Element of bool the carrier of FreeUnivAlgZAO(a1,a2) equals
{root-tree b1 where b1 is Element of the carrier of DTConUA(a1,a2): b1 in Terminals DTConUA(a1,a2)};
end;
:: FREEALG:def 20
theorem
for b1 being non empty non non-empty FinSequence of NAT
for b2 being disjoint_with_NAT set holds
FreeGenSetZAO(b1,b2) = {root-tree b3 where b3 is Element of the carrier of DTConUA(b1,b2): b3 in Terminals DTConUA(b1,b2)};
:: FREEALG:funcnot 17 => FREEALG:func 17
definition
let a1 be non empty non non-empty FinSequence of NAT;
let a2 be disjoint_with_NAT set;
redefine func FreeGenSetZAO(a1,a2) -> GeneratorSet of FreeUnivAlgZAO(a1,a2);
end;
:: FREEALG:funcnot 18 => FREEALG:func 18
definition
let a1 be non empty non non-empty FinSequence of NAT;
let a2 be disjoint_with_NAT set;
let a3 be non empty set;
let a4 be Element of the carrier of DTConUA(a1,a2);
let a5 be Function-like quasi_total Relation of FreeGenSetZAO(a1,a2),a3;
assume a4 in Terminals DTConUA(a1,a2);
func pi(A5,A4) -> Element of a3 equals
a5 . root-tree a4;
end;
:: FREEALG:def 21
theorem
for b1 being non empty non non-empty FinSequence of NAT
for b2 being disjoint_with_NAT set
for b3 being non empty set
for b4 being Element of the carrier of DTConUA(b1,b2)
for b5 being Function-like quasi_total Relation of FreeGenSetZAO(b1,b2),b3
st b4 in Terminals DTConUA(b1,b2)
holds pi(b5,b4) = b5 . root-tree b4;
:: FREEALG:th 10
theorem
for b1 being non empty non non-empty FinSequence of NAT
for b2 being disjoint_with_NAT set holds
FreeGenSetZAO(b1,b2) is free(FreeUnivAlgZAO(b1,b2));
:: FREEALG:funcreg 6
registration
let a1 be non empty non non-empty FinSequence of NAT;
let a2 be disjoint_with_NAT set;
cluster FreeUnivAlgZAO(a1,a2) -> non empty strict partial quasi_total non-empty free;
end;
:: FREEALG:funcnot 19 => FREEALG:func 19
definition
let a1 be non empty non non-empty FinSequence of NAT;
let a2 be disjoint_with_NAT set;
redefine func FreeGenSetZAO(a1,a2) -> free GeneratorSet of FreeUnivAlgZAO(a1,a2);
end;
:: FREEALG:exreg 6
registration
cluster non empty strict partial quasi_total non-empty with_const_op free UAStr;
end;