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;