:: FREEALG semantic presentation

definition
let c1 be set ;
attr a1 is missing_with_Nat means :Def1: :: FREEALG:def 1
a1 misses NAT ;
end;

:: deftheorem Def1 defines missing_with_Nat FREEALG:def 1 :
for b1 being set holds
( b1 is missing_with_Nat iff b1 misses NAT );

registration
cluster non empty missing_with_Nat set ;
existence
ex b1 being set st
( not b1 is empty & b1 is missing_with_Nat )
proof end;
end;

Lemma2: ( not 0 in rng <*1*> & 0 in rng <*0*> )
proof end;

notation
let c1 be Relation;
antonym with_zero c1 for non-empty c1;
synonym without_zero c1 for non-empty c1;
end;

definition
let c1 be Relation;
redefine attr a1 is non-empty means :Def2: :: FREEALG:def 2
not 0 in rng a1;
compatibility
( not c1 is with_zero iff not 0 in rng c1 )
by RELAT_1:def 9;
end;

:: deftheorem Def2 defines with_zero FREEALG:def 2 :
for b1 being Relation holds
( not b1 is with_zero iff not 0 in rng b1 );

registration
cluster non empty with_zero FinSequence of NAT ;
existence
ex b1 being FinSequence of NAT st
( not b1 is empty & b1 is with_zero )
proof end;
cluster non empty without_zero FinSequence of NAT ;
existence
ex b1 being FinSequence of NAT st
( not b1 is empty & not b1 is with_zero )
proof end;
end;

definition
let c1 be Universal_Algebra;
let c2 be Nat;
assume E4: c2 in dom the charact of c1 ;
canceled;
func oper c2,c1 -> operation of a1 equals :Def4: :: FREEALG:def 4
the charact of a1 . a2;
coherence
the charact of c1 . c2 is operation of c1
by E4, FUNCT_1:def 5;
end;

:: deftheorem Def3 FREEALG:def 3 :
canceled;

:: deftheorem Def4 defines oper FREEALG:def 4 :
for b1 being Universal_Algebra
for b2 being Nat holds
( b2 in dom the charact of b1 implies oper b2,b1 = the charact of b1 . b2 );

definition
let c1 be Universal_Algebra;
mode GeneratorSet of c1 -> Subset of a1 means :Def5: :: FREEALG:def 5
the carrier of (GenUnivAlg a2) = the carrier of a1;
existence
ex b1 being Subset of c1 st the carrier of (GenUnivAlg b1) = the carrier of c1
proof end;
end;

:: deftheorem Def5 defines GeneratorSet FREEALG:def 5 :
for b1 being Universal_Algebra
for b2 being Subset of b1 holds
( b2 is GeneratorSet of b1 iff the carrier of (GenUnivAlg b2) = the carrier of b1 );

definition
let c1 be Universal_Algebra;
let c2 be GeneratorSet of c1;
attr a2 is free means :Def6: :: FREEALG:def 6
for b1 being Universal_Algebra holds
( a1,b1 are_similar implies for b2 being Function of a2,the carrier of b1 holds
ex b3 being Function of a1,b1 st
( b3 is_homomorphism a1,b1 & b3 | a2 = b2 ) );
end;

:: deftheorem Def6 defines free FREEALG:def 6 :
for b1 being Universal_Algebra
for b2 being GeneratorSet of b1 holds
( b2 is free iff for b3 being Universal_Algebra holds
( b1,b3 are_similar implies for b4 being Function of b2,the carrier of b3 holds
ex b5 being Function of b1,b3 st
( b5 is_homomorphism b1,b3 & b5 | b2 = b4 ) ) );

definition
let c1 be Universal_Algebra;
attr a1 is free means :Def7: :: FREEALG:def 7
ex b1 being GeneratorSet of a1 st b1 is free;
end;

:: deftheorem Def7 defines free FREEALG:def 7 :
for b1 being Universal_Algebra holds
( b1 is free iff ex b2 being GeneratorSet of b1 st b2 is free );

registration
cluster strict free UAStr ;
existence
ex b1 being Universal_Algebra st
( b1 is free & b1 is strict )
proof end;
end;

registration
let c1 be free Universal_Algebra;
cluster free GeneratorSet of a1;
existence
ex b1 being GeneratorSet of c1 st b1 is free
by Def7;
end;

theorem Th1: :: FREEALG:1
for b1 being strict Universal_Algebra
for b2 being Subset of b1 holds
( b2 is GeneratorSet of b1 iff GenUnivAlg b2 = b1 )
proof end;

definition
let c1 be non empty FinSequence of NAT ;
let c2 be set ;
func REL c1,c2 -> Relation of (dom a1) \/ a2,((dom a1) \/ a2) * means :Def8: :: FREEALG:def 8
for b1 being Element of (dom a1) \/ a2
for b2 being Element of ((dom a1) \/ a2) * holds
( [b1,b2] in a3 iff ( b1 in dom a1 & a1 . b1 = len b2 ) );
existence
ex b1 being Relation of (dom c1) \/ c2,((dom c1) \/ c2) * st
for b2 being Element of (dom c1) \/ c2
for b3 being Element of ((dom c1) \/ c2) * holds
( [b2,b3] in b1 iff ( b2 in dom c1 & c1 . b2 = len b3 ) )
proof end;
uniqueness
for b1, b2 being Relation of (dom c1) \/ c2,((dom c1) \/ c2) * holds
( ( for b3 being Element of (dom c1) \/ c2
for b4 being Element of ((dom c1) \/ c2) * holds
( [b3,b4] in b1 iff ( b3 in dom c1 & c1 . b3 = len b4 ) ) ) & ( for b3 being Element of (dom c1) \/ c2
for b4 being Element of ((dom c1) \/ c2) * holds
( [b3,b4] in b2 iff ( b3 in dom c1 & c1 . b3 = len b4 ) ) ) implies b1 = b2 )
proof end;
end;

:: deftheorem Def8 defines REL FREEALG:def 8 :
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 ) ) );

definition
let c1 be non empty FinSequence of NAT ;
let c2 be set ;
func DTConUA c1,c2 -> strict DTConstrStr equals :: FREEALG:def 9
DTConstrStr(# ((dom a1) \/ a2),(REL a1,a2) #);
correctness
coherence
DTConstrStr(# ((dom c1) \/ c2),(REL c1,c2) #) is strict DTConstrStr
;
;
end;

:: deftheorem Def9 defines DTConUA FREEALG:def 9 :
for b1 being non empty FinSequence of NAT
for b2 being set holds DTConUA b1,b2 = DTConstrStr(# ((dom b1) \/ b2),(REL b1,b2) #);

registration
let c1 be non empty FinSequence of NAT ;
let c2 be set ;
cluster DTConUA a1,a2 -> non empty strict ;
coherence
not DTConUA c1,c2 is empty
;
end;

theorem Th2: :: FREEALG:2
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 )
proof end;

theorem Th3: :: FREEALG:3
for b1 being non empty FinSequence of NAT
for b2 being missing_with_Nat set holds Terminals (DTConUA b1,b2) = b2
proof end;

registration
let c1 be non empty FinSequence of NAT ;
let c2 be set ;
cluster DTConUA a1,a2 -> non empty strict with_nonterminals ;
coherence
DTConUA c1,c2 is with_nonterminals
proof end;
end;

registration
let c1 be non empty with_zero FinSequence of NAT ;
let c2 be set ;
cluster DTConUA a1,a2 -> non empty strict with_nonterminals with_useful_nonterminals ;
coherence
( DTConUA c1,c2 is with_nonterminals & DTConUA c1,c2 is with_useful_nonterminals )
proof end;
end;

registration
let c1 be non empty FinSequence of NAT ;
let c2 be non empty missing_with_Nat set ;
cluster DTConUA a1,a2 -> non empty strict with_terminals with_nonterminals with_useful_nonterminals ;
coherence
( DTConUA c1,c2 is with_terminals & DTConUA c1,c2 is with_nonterminals & DTConUA c1,c2 is with_useful_nonterminals )
proof end;
end;

definition
let c1 be non empty FinSequence of NAT ;
let c2 be set ;
let c3 be Nat;
assume E11: c3 in dom c1 ;
func Sym c3,c1,c2 -> Symbol of (DTConUA a1,a2) equals :Def10: :: FREEALG:def 10
a3;
coherence
c3 is Symbol of (DTConUA c1,c2)
by E11, XBOOLE_0:def 2;
end;

:: deftheorem Def10 defines Sym FREEALG:def 10 :
for b1 being non empty FinSequence of NAT
for b2 being set
for b3 being Nat holds
( b3 in dom b1 implies Sym b3,b1,b2 = b3 );

definition
let c1 be non empty FinSequence of NAT ;
let c2 be non empty missing_with_Nat set ;
let c3 be Nat;
assume E12: c3 in dom c1 ;
func FreeOpNSG c3,c1,c2 -> non empty homogeneous quasi_total PartFunc of (TS (DTConUA a1,a2)) * , TS (DTConUA a1,a2) means :Def11: :: FREEALG:def 11
( dom a4 = (a1 /. a3) -tuples_on (TS (DTConUA a1,a2)) & ( for b1 being FinSequence of TS (DTConUA a1,a2) holds
( b1 in dom a4 implies a4 . b1 = (Sym a3,a1,a2) -tree b1 ) ) );
existence
ex b1 being non empty homogeneous quasi_total PartFunc of (TS (DTConUA c1,c2)) * , TS (DTConUA c1,c2) st
( dom b1 = (c1 /. c3) -tuples_on (TS (DTConUA c1,c2)) & ( for b2 being FinSequence of TS (DTConUA c1,c2) holds
( b2 in dom b1 implies b1 . b2 = (Sym c3,c1,c2) -tree b2 ) ) )
proof end;
uniqueness
for b1, b2 being non empty homogeneous quasi_total PartFunc of (TS (DTConUA c1,c2)) * , TS (DTConUA c1,c2) holds
( dom b1 = (c1 /. c3) -tuples_on (TS (DTConUA c1,c2)) & ( for b3 being FinSequence of TS (DTConUA c1,c2) holds
( b3 in dom b1 implies b1 . b3 = (Sym c3,c1,c2) -tree b3 ) ) & dom b2 = (c1 /. c3) -tuples_on (TS (DTConUA c1,c2)) & ( for b3 being FinSequence of TS (DTConUA c1,c2) holds
( b3 in dom b2 implies b2 . b3 = (Sym c3,c1,c2) -tree b3 ) ) implies b1 = b2 )
proof end;
end;

:: deftheorem Def11 defines FreeOpNSG FREEALG:def 11 :
for b1 being non empty FinSequence of NAT
for b2 being non empty missing_with_Nat set
for b3 being Nat holds
( b3 in dom b1 implies for b4 being non empty homogeneous quasi_total PartFunc 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) holds
( b5 in dom b4 implies b4 . b5 = (Sym b3,b1,b2) -tree b5 ) ) ) ) );

definition
let c1 be non empty FinSequence of NAT ;
let c2 be non empty missing_with_Nat set ;
func FreeOpSeqNSG c1,c2 -> PFuncFinSequence of (TS (DTConUA a1,a2)) means :Def12: :: FREEALG:def 12
( len a3 = len a1 & ( for b1 being Nat holds
( b1 in dom a3 implies a3 . b1 = FreeOpNSG b1,a1,a2 ) ) );
existence
ex b1 being PFuncFinSequence of (TS (DTConUA c1,c2)) st
( len b1 = len c1 & ( for b2 being Nat holds
( b2 in dom b1 implies b1 . b2 = FreeOpNSG b2,c1,c2 ) ) )
proof end;
uniqueness
for b1, b2 being PFuncFinSequence of (TS (DTConUA c1,c2)) holds
( len b1 = len c1 & ( for b3 being Nat holds
( b3 in dom b1 implies b1 . b3 = FreeOpNSG b3,c1,c2 ) ) & len b2 = len c1 & ( for b3 being Nat holds
( b3 in dom b2 implies b2 . b3 = FreeOpNSG b3,c1,c2 ) ) implies b1 = b2 )
proof end;
end;

:: deftheorem Def12 defines FreeOpSeqNSG FREEALG:def 12 :
for b1 being non empty FinSequence of NAT
for b2 being non empty missing_with_Nat set
for b3 being PFuncFinSequence of (TS (DTConUA b1,b2)) holds
( b3 = FreeOpSeqNSG b1,b2 iff ( len b3 = len b1 & ( for b4 being Nat holds
( b4 in dom b3 implies b3 . b4 = FreeOpNSG b4,b1,b2 ) ) ) );

definition
let c1 be non empty FinSequence of NAT ;
let c2 be non empty missing_with_Nat set ;
func FreeUnivAlgNSG c1,c2 -> strict Universal_Algebra equals :: FREEALG:def 13
UAStr(# (TS (DTConUA a1,a2)),(FreeOpSeqNSG a1,a2) #);
coherence
UAStr(# (TS (DTConUA c1,c2)),(FreeOpSeqNSG c1,c2) #) is strict Universal_Algebra
proof end;
end;

:: deftheorem Def13 defines FreeUnivAlgNSG FREEALG:def 13 :
for b1 being non empty FinSequence of NAT
for b2 being non empty missing_with_Nat set holds FreeUnivAlgNSG b1,b2 = UAStr(# (TS (DTConUA b1,b2)),(FreeOpSeqNSG b1,b2) #);

theorem Th4: :: FREEALG:4
for b1 being non empty FinSequence of NAT
for b2 being non empty missing_with_Nat set holds signature (FreeUnivAlgNSG b1,b2) = b1
proof end;

definition
let c1 be non empty FinSequence of NAT ;
let c2 be non empty missing_with_Nat set ;
func FreeGenSetNSG c1,c2 -> Subset of (FreeUnivAlgNSG a1,a2) equals :: FREEALG:def 14
{ (root-tree b1) where B is Symbol of (DTConUA a1,a2) : b1 in Terminals (DTConUA a1,a2) } ;
coherence
{ (root-tree b1) where B is Symbol of (DTConUA c1,c2) : b1 in Terminals (DTConUA c1,c2) } is Subset of (FreeUnivAlgNSG c1,c2)
proof end;
end;

:: deftheorem Def14 defines FreeGenSetNSG FREEALG:def 14 :
for b1 being non empty FinSequence of NAT
for b2 being non empty missing_with_Nat set holds FreeGenSetNSG b1,b2 = { (root-tree b3) where B is Symbol of (DTConUA b1,b2) : b3 in Terminals (DTConUA b1,b2) } ;

theorem Th5: :: FREEALG:5
for b1 being non empty FinSequence of NAT
for b2 being non empty missing_with_Nat set holds
not FreeGenSetNSG b1,b2 is empty
proof end;

definition
let c1 be non empty FinSequence of NAT ;
let c2 be non empty missing_with_Nat set ;
redefine func FreeGenSetNSG as FreeGenSetNSG c1,c2 -> GeneratorSet of FreeUnivAlgNSG a1,a2;
coherence
FreeGenSetNSG c1,c2 is GeneratorSet of FreeUnivAlgNSG c1,c2
proof end;
end;

definition
let c1 be non empty FinSequence of NAT ;
let c2 be non empty missing_with_Nat set ;
let c3 be non empty set ;
let c4 be Symbol of (DTConUA c1,c2);
let c5 be Function of FreeGenSetNSG c1,c2,c3;
assume E16: c4 in Terminals (DTConUA c1,c2) ;
func pi c5,c4 -> Element of a3 equals :Def15: :: FREEALG:def 15
a5 . (root-tree a4);
coherence
c5 . (root-tree c4) is Element of c3
proof end;
end;

:: deftheorem Def15 defines pi FREEALG:def 15 :
for b1 being non empty FinSequence of NAT
for b2 being non empty missing_with_Nat set
for b3 being non empty set
for b4 being Symbol of (DTConUA b1,b2)
for b5 being Function of FreeGenSetNSG b1,b2,b3 holds
( b4 in Terminals (DTConUA b1,b2) implies pi b5,b4 = b5 . (root-tree b4) );

definition
let c1 be non empty FinSequence of NAT ;
let c2 be set ;
let c3 be Symbol of (DTConUA c1,c2);
given c4 being FinSequence such that E17: c3 ==> c4 ;
func @ c3 -> Nat equals :Def16: :: FREEALG:def 16
a3;
coherence
c3 is Nat
proof end;
end;

:: deftheorem Def16 defines @ FREEALG:def 16 :
for b1 being non empty FinSequence of NAT
for b2 being set
for b3 being Symbol of (DTConUA b1,b2) holds
( ex b4 being FinSequence st b3 ==> b4 implies @ b3 = b3 );

theorem Th6: :: FREEALG:6
for b1 being non empty FinSequence of NAT
for b2 being non empty missing_with_Nat set holds FreeGenSetNSG b1,b2 is free
proof end;

registration
let c1 be non empty FinSequence of NAT ;
let c2 be non empty missing_with_Nat set ;
cluster FreeUnivAlgNSG a1,a2 -> strict free ;
coherence
FreeUnivAlgNSG c1,c2 is free
proof end;
end;

definition
let c1 be non empty FinSequence of NAT ;
let c2 be non empty missing_with_Nat set ;
redefine func FreeGenSetNSG as FreeGenSetNSG c1,c2 -> free GeneratorSet of FreeUnivAlgNSG a1,a2;
coherence
FreeGenSetNSG c1,c2 is free GeneratorSet of FreeUnivAlgNSG c1,c2
by Th6;
end;

definition
let c1 be non empty with_zero FinSequence of NAT ;
let c2 be missing_with_Nat set ;
let c3 be Nat;
assume E19: c3 in dom c1 ;
func FreeOpZAO c3,c1,c2 -> non empty homogeneous quasi_total PartFunc of (TS (DTConUA a1,a2)) * , TS (DTConUA a1,a2) means :Def17: :: FREEALG:def 17
( dom a4 = (a1 /. a3) -tuples_on (TS (DTConUA a1,a2)) & ( for b1 being FinSequence of TS (DTConUA a1,a2) holds
( b1 in dom a4 implies a4 . b1 = (Sym a3,a1,a2) -tree b1 ) ) );
existence
ex b1 being non empty homogeneous quasi_total PartFunc of (TS (DTConUA c1,c2)) * , TS (DTConUA c1,c2) st
( dom b1 = (c1 /. c3) -tuples_on (TS (DTConUA c1,c2)) & ( for b2 being FinSequence of TS (DTConUA c1,c2) holds
( b2 in dom b1 implies b1 . b2 = (Sym c3,c1,c2) -tree b2 ) ) )
proof end;
uniqueness
for b1, b2 being non empty homogeneous quasi_total PartFunc of (TS (DTConUA c1,c2)) * , TS (DTConUA c1,c2) holds
( dom b1 = (c1 /. c3) -tuples_on (TS (DTConUA c1,c2)) & ( for b3 being FinSequence of TS (DTConUA c1,c2) holds
( b3 in dom b1 implies b1 . b3 = (Sym c3,c1,c2) -tree b3 ) ) & dom b2 = (c1 /. c3) -tuples_on (TS (DTConUA c1,c2)) & ( for b3 being FinSequence of TS (DTConUA c1,c2) holds
( b3 in dom b2 implies b2 . b3 = (Sym c3,c1,c2) -tree b3 ) ) implies b1 = b2 )
proof end;
end;

:: deftheorem Def17 defines FreeOpZAO FREEALG:def 17 :
for b1 being non empty with_zero FinSequence of NAT
for b2 being missing_with_Nat set
for b3 being Nat holds
( b3 in dom b1 implies for b4 being non empty homogeneous quasi_total PartFunc 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) holds
( b5 in dom b4 implies b4 . b5 = (Sym b3,b1,b2) -tree b5 ) ) ) ) );

definition
let c1 be non empty with_zero FinSequence of NAT ;
let c2 be missing_with_Nat set ;
func FreeOpSeqZAO c1,c2 -> PFuncFinSequence of (TS (DTConUA a1,a2)) means :Def18: :: FREEALG:def 18
( len a3 = len a1 & ( for b1 being Nat holds
( b1 in dom a3 implies a3 . b1 = FreeOpZAO b1,a1,a2 ) ) );
existence
ex b1 being PFuncFinSequence of (TS (DTConUA c1,c2)) st
( len b1 = len c1 & ( for b2 being Nat holds
( b2 in dom b1 implies b1 . b2 = FreeOpZAO b2,c1,c2 ) ) )
proof end;
uniqueness
for b1, b2 being PFuncFinSequence of (TS (DTConUA c1,c2)) holds
( len b1 = len c1 & ( for b3 being Nat holds
( b3 in dom b1 implies b1 . b3 = FreeOpZAO b3,c1,c2 ) ) & len b2 = len c1 & ( for b3 being Nat holds
( b3 in dom b2 implies b2 . b3 = FreeOpZAO b3,c1,c2 ) ) implies b1 = b2 )
proof end;
end;

:: deftheorem Def18 defines FreeOpSeqZAO FREEALG:def 18 :
for b1 being non empty with_zero FinSequence of NAT
for b2 being missing_with_Nat set
for b3 being PFuncFinSequence of (TS (DTConUA b1,b2)) holds
( b3 = FreeOpSeqZAO b1,b2 iff ( len b3 = len b1 & ( for b4 being Nat holds
( b4 in dom b3 implies b3 . b4 = FreeOpZAO b4,b1,b2 ) ) ) );

definition
let c1 be non empty with_zero FinSequence of NAT ;
let c2 be missing_with_Nat set ;
func FreeUnivAlgZAO c1,c2 -> strict Universal_Algebra equals :: FREEALG:def 19
UAStr(# (TS (DTConUA a1,a2)),(FreeOpSeqZAO a1,a2) #);
coherence
UAStr(# (TS (DTConUA c1,c2)),(FreeOpSeqZAO c1,c2) #) is strict Universal_Algebra
proof end;
end;

:: deftheorem Def19 defines FreeUnivAlgZAO FREEALG:def 19 :
for b1 being non empty with_zero FinSequence of NAT
for b2 being missing_with_Nat set holds FreeUnivAlgZAO b1,b2 = UAStr(# (TS (DTConUA b1,b2)),(FreeOpSeqZAO b1,b2) #);

theorem Th7: :: FREEALG:7
for b1 being non empty with_zero FinSequence of NAT
for b2 being missing_with_Nat set holds signature (FreeUnivAlgZAO b1,b2) = b1
proof end;

theorem Th8: :: FREEALG:8
for b1 being non empty with_zero FinSequence of NAT
for b2 being missing_with_Nat set holds FreeUnivAlgZAO b1,b2 is with_const_op
proof end;

theorem Th9: :: FREEALG:9
for b1 being non empty with_zero FinSequence of NAT
for b2 being missing_with_Nat set holds
Constants (FreeUnivAlgZAO b1,b2) <> {}
proof end;

definition
let c1 be non empty with_zero FinSequence of NAT ;
let c2 be missing_with_Nat set ;
func FreeGenSetZAO c1,c2 -> Subset of (FreeUnivAlgZAO a1,a2) equals :: FREEALG:def 20
{ (root-tree b1) where B is Symbol of (DTConUA a1,a2) : b1 in Terminals (DTConUA a1,a2) } ;
coherence
{ (root-tree b1) where B is Symbol of (DTConUA c1,c2) : b1 in Terminals (DTConUA c1,c2) } is Subset of (FreeUnivAlgZAO c1,c2)
proof end;
end;

:: deftheorem Def20 defines FreeGenSetZAO FREEALG:def 20 :
for b1 being non empty with_zero FinSequence of NAT
for b2 being missing_with_Nat set holds FreeGenSetZAO b1,b2 = { (root-tree b3) where B is Symbol of (DTConUA b1,b2) : b3 in Terminals (DTConUA b1,b2) } ;

definition
let c1 be non empty with_zero FinSequence of NAT ;
let c2 be missing_with_Nat set ;
redefine func FreeGenSetZAO as FreeGenSetZAO c1,c2 -> GeneratorSet of FreeUnivAlgZAO a1,a2;
coherence
FreeGenSetZAO c1,c2 is GeneratorSet of FreeUnivAlgZAO c1,c2
proof end;
end;

definition
let c1 be non empty with_zero FinSequence of NAT ;
let c2 be missing_with_Nat set ;
let c3 be non empty set ;
let c4 be Symbol of (DTConUA c1,c2);
let c5 be Function of FreeGenSetZAO c1,c2,c3;
assume E24: c4 in Terminals (DTConUA c1,c2) ;
func pi c5,c4 -> Element of a3 equals :Def21: :: FREEALG:def 21
a5 . (root-tree a4);
coherence
c5 . (root-tree c4) is Element of c3
proof end;
end;

:: deftheorem Def21 defines pi FREEALG:def 21 :
for b1 being non empty with_zero FinSequence of NAT
for b2 being missing_with_Nat set
for b3 being non empty set
for b4 being Symbol of (DTConUA b1,b2)
for b5 being Function of FreeGenSetZAO b1,b2,b3 holds
( b4 in Terminals (DTConUA b1,b2) implies pi b5,b4 = b5 . (root-tree b4) );

theorem Th10: :: FREEALG:10
for b1 being non empty with_zero FinSequence of NAT
for b2 being missing_with_Nat set holds FreeGenSetZAO b1,b2 is free
proof end;

registration
let c1 be non empty with_zero FinSequence of NAT ;
let c2 be missing_with_Nat set ;
cluster FreeUnivAlgZAO a1,a2 -> strict free ;
coherence
FreeUnivAlgZAO c1,c2 is free
proof end;
end;

definition
let c1 be non empty with_zero FinSequence of NAT ;
let c2 be missing_with_Nat set ;
redefine func FreeGenSetZAO as FreeGenSetZAO c1,c2 -> free GeneratorSet of FreeUnivAlgZAO a1,a2;
coherence
FreeGenSetZAO c1,c2 is free GeneratorSet of FreeUnivAlgZAO c1,c2
by Th10;
end;

registration
cluster strict with_const_op free UAStr ;
existence
ex b1 being Universal_Algebra st
( b1 is strict & b1 is free & b1 is with_const_op )
proof end;
end;