Article PRALG_2, MML version 4.99.1005

:: PRALG_2:modenot 1 => PRALG_2:mode 1
definition
  let a1 be non empty functional with_common_domain set;
  redefine mode Element of a1 -> ManySortedSet of DOM a1;
end;

:: PRALG_2:funcnot 1 => PRALG_2:func 1
definition
  let a1 be Relation-like Function-like set;
  func Commute A1 -> Relation-like Function-like set means
    (for b1 being set holds
           b1 in proj1 it
        iff
           ex b2 being Relation-like Function-like set st
              b2 in proj1 a1 & b1 = commute b2) &
     (for b1 being Relation-like Function-like set
           st b1 in proj1 it
        holds it . b1 = a1 . commute b1);
end;

:: PRALG_2:def 6
theorem
for b1, b2 being Relation-like Function-like set holds
   b2 = Commute b1
iff
   (for b3 being set holds
          b3 in proj1 b2
       iff
          ex b4 being Relation-like Function-like set st
             b4 in proj1 b1 & b3 = commute b4) &
    (for b3 being Relation-like Function-like set
          st b3 in proj1 b2
       holds b2 . b3 = b1 . commute b3);

:: PRALG_2:th 8
theorem
for b1 being Relation-like Function-like set
      st proj1 b1 = {{}}
   holds Commute b1 = b1;

:: PRALG_2:funcnot 2 => PRALG_2:func 2
definition
  let a1 be Relation-like Function-like Function-yielding set;
  redefine func Frege A1 -> Function-yielding ManySortedSet of product doms a1 means
    for b1 being Relation-like Function-like set
          st b1 in product doms a1
       holds it . b1 = a1 .. b1;
end;

:: PRALG_2:def 8
theorem
for b1 being Relation-like Function-like Function-yielding set
for b2 being Function-yielding ManySortedSet of product doms b1 holds
      b2 = Frege b1
   iff
      for b3 being Relation-like Function-like set
            st b3 in product doms b1
         holds b2 . b3 = b1 .. b3;

:: PRALG_2:funcreg 1
registration
  let a1 be set;
  let a2, a3 be non-empty ManySortedSet of a1;
  cluster [|a2,a3|] -> non-empty;
end;

:: PRALG_2:th 9
theorem
for b1 being non empty set
for b2 being set
for b3, b4 being ManySortedSet of b1
for b5 being Function-like quasi_total Relation of b2,b1 holds
   [|b3,b4|] * b5 = [|b3 * b5,b4 * b5|];

:: PRALG_2:funcnot 3 => PRALG_2:func 3
definition
  let a1 be non empty set;
  let a2 be set;
  let a3, a4 be non-empty ManySortedSet of a1;
  let a5 be Function-like quasi_total Relation of a2,a1 *;
  let a6 be Function-like quasi_total Relation of a2,a1;
  let a7 be set;
  let a8 be Function-like quasi_total Relation of (a3 # * a5) . a7,(a3 * a6) . a7;
  let a9 be Function-like quasi_total Relation of (a4 # * a5) . a7,(a4 * a6) . a7;
  assume a7 in a2;
  func [[:A8,A9:]] -> Function-like quasi_total Relation of ([|a3,a4|] # * a5) . a7,([|a3,a4|] * a6) . a7 means
    for b1 being Relation-like Function-like set
          st b1 in ([|a3,a4|] # * a5) . a7
       holds it . b1 = [a8 . pr1 b1,a9 . pr2 b1];
end;

:: PRALG_2:def 10
theorem
for b1 being non empty set
for b2 being set
for b3, b4 being non-empty ManySortedSet of b1
for b5 being Function-like quasi_total Relation of b2,b1 *
for b6 being Function-like quasi_total Relation of b2,b1
for b7 being set
for b8 being Function-like quasi_total Relation of (b3 # * b5) . b7,(b3 * b6) . b7
for b9 being Function-like quasi_total Relation of (b4 # * b5) . b7,(b4 * b6) . b7
   st b7 in b2
for b10 being Function-like quasi_total Relation of ([|b3,b4|] # * b5) . b7,([|b3,b4|] * b6) . b7 holds
      b10 = [[:b8,b9:]]
   iff
      for b11 being Relation-like Function-like set
            st b11 in ([|b3,b4|] # * b5) . b7
         holds b10 . b11 = [b8 . pr1 b11,b9 . pr2 b11];

:: PRALG_2:funcnot 4 => PRALG_2:func 4
definition
  let a1 be non empty set;
  let a2 be set;
  let a3, a4 be non-empty ManySortedSet of a1;
  let a5 be Function-like quasi_total Relation of a2,a1 *;
  let a6 be Function-like quasi_total Relation of a2,a1;
  let a7 be ManySortedFunction of a3 # * a5,a3 * a6;
  let a8 be ManySortedFunction of a4 # * a5,a4 * a6;
  func [[:A7,A8:]] -> ManySortedFunction of [|a3,a4|] # * a5,[|a3,a4|] * a6 means
    for b1 being set
       st b1 in a2
    for b2 being Function-like quasi_total Relation of (a3 # * a5) . b1,(a3 * a6) . b1
    for b3 being Function-like quasi_total Relation of (a4 # * a5) . b1,(a4 * a6) . b1
          st b2 = a7 . b1 & b3 = a8 . b1
       holds it . b1 = [[:b2,b3:]];
end;

:: PRALG_2:def 11
theorem
for b1 being non empty set
for b2 being set
for b3, b4 being non-empty ManySortedSet of b1
for b5 being Function-like quasi_total Relation of b2,b1 *
for b6 being Function-like quasi_total Relation of b2,b1
for b7 being ManySortedFunction of b3 # * b5,b3 * b6
for b8 being ManySortedFunction of b4 # * b5,b4 * b6
for b9 being ManySortedFunction of [|b3,b4|] # * b5,[|b3,b4|] * b6 holds
      b9 = [[:b7,b8:]]
   iff
      for b10 being set
         st b10 in b2
      for b11 being Function-like quasi_total Relation of (b3 # * b5) . b10,(b3 * b6) . b10
      for b12 being Function-like quasi_total Relation of (b4 # * b5) . b10,(b4 * b6) . b10
            st b11 = b7 . b10 & b12 = b8 . b10
         holds b9 . b10 = [[:b11,b12:]];

:: PRALG_2:modenot 2 => PRALG_2:mode 2
definition
  let a1 be set;
  let a2 be non empty ManySortedSign;
  mode MSAlgebra-Family of A1,A2 -> ManySortedSet of a1 means
    for b1 being set
          st b1 in a1
       holds it . b1 is non-empty MSAlgebra over a2;
end;

:: PRALG_2:dfs 5
definiens
  let a1 be set;
  let a2 be non empty ManySortedSign;
  let a3 be ManySortedSet of a1;
To prove
     a3 is MSAlgebra-Family of a1,a2
it is sufficient to prove
  thus for b1 being set
          st b1 in a1
       holds a3 . b1 is non-empty MSAlgebra over a2;

:: PRALG_2:def 12
theorem
for b1 being set
for b2 being non empty ManySortedSign
for b3 being ManySortedSet of b1 holds
      b3 is MSAlgebra-Family of b1,b2
   iff
      for b4 being set
            st b4 in b1
         holds b3 . b4 is non-empty MSAlgebra over b2;

:: PRALG_2:funcnot 5 => PRALG_2:func 5
definition
  let a1 be non empty set;
  let a2 be non empty ManySortedSign;
  let a3 be MSAlgebra-Family of a1,a2;
  let a4 be Element of a1;
  redefine func a3 . a4 -> non-empty MSAlgebra over a2;
end;

:: PRALG_2:funcnot 6 => PRALG_2:func 6
definition
  let a1 be non empty ManySortedSign;
  let a2 be MSAlgebra over a1;
  func |.A2.| -> set equals
    union proj2 the Sorts of a2;
end;

:: PRALG_2:def 13
theorem
for b1 being non empty ManySortedSign
for b2 being MSAlgebra over b1 holds
   |.b2.| = union proj2 the Sorts of b2;

:: PRALG_2:funcreg 2
registration
  let a1 be non empty ManySortedSign;
  let a2 be non-empty MSAlgebra over a1;
  cluster |.a2.| -> non empty;
end;

:: PRALG_2:funcnot 7 => PRALG_2:func 7
definition
  let a1 be non empty set;
  let a2 be non empty ManySortedSign;
  let a3 be MSAlgebra-Family of a1,a2;
  func |.A3.| -> set equals
    union {|.a3 . b1.| where b1 is Element of a1: TRUE};
end;

:: PRALG_2:def 14
theorem
for b1 being non empty set
for b2 being non empty ManySortedSign
for b3 being MSAlgebra-Family of b1,b2 holds
   |.b3.| = union {|.b3 . b4.| where b4 is Element of b1: TRUE};

:: PRALG_2:funcreg 3
registration
  let a1 be non empty set;
  let a2 be non empty ManySortedSign;
  let a3 be MSAlgebra-Family of a1,a2;
  cluster |.a3.| -> non empty;
end;

:: PRALG_2:th 10
theorem
for b1 being non empty non void ManySortedSign
for b2 being MSAlgebra over b1
for b3 being Element of the OperSymbols of b1 holds
   Args(b3,b2) = product ((the_arity_of b3) * the Sorts of b2) &
    proj1 ((the_arity_of b3) * the Sorts of b2) = proj1 the_arity_of b3 &
    Result(b3,b2) = (the Sorts of b2) . the_result_sort_of b3;

:: PRALG_2:th 11
theorem
for b1 being non empty non void ManySortedSign
for b2 being MSAlgebra over b1
for b3 being Element of the OperSymbols of b1
      st the_arity_of b3 = {}
   holds Args(b3,b2) = {{}};

:: PRALG_2:funcnot 8 => PRALG_2:func 8
definition
  let a1 be non empty ManySortedSign;
  let a2, a3 be non-empty MSAlgebra over a1;
  func [:A2,A3:] -> MSAlgebra over a1 equals
    MSAlgebra(#[|the Sorts of a2,the Sorts of a3|],[[:the Charact of a2,the Charact of a3:]]#);
end;

:: PRALG_2:def 15
theorem
for b1 being non empty ManySortedSign
for b2, b3 being non-empty MSAlgebra over b1 holds
[:b2,b3:] = MSAlgebra(#[|the Sorts of b2,the Sorts of b3|],[[:the Charact of b2,the Charact of b3:]]#);

:: PRALG_2:funcreg 4
registration
  let a1 be non empty ManySortedSign;
  let a2, a3 be non-empty MSAlgebra over a1;
  cluster [:a2,a3:] -> strict;
end;

:: PRALG_2:funcnot 9 => PRALG_2:func 9
definition
  let a1 be set;
  let a2 be non empty ManySortedSign;
  let a3 be Element of the carrier of a2;
  let a4 be MSAlgebra-Family of a1,a2;
  func Carrier(A4,A3) -> ManySortedSet of a1 means
    for b1 being set
          st b1 in a1
       holds ex b2 being MSAlgebra over a2 st
          b2 = a4 . b1 & it . b1 = (the Sorts of b2) . a3
    if a1 <> {}
    otherwise it = {};
end;

:: PRALG_2:def 16
theorem
for b1 being set
for b2 being non empty ManySortedSign
for b3 being Element of the carrier of b2
for b4 being MSAlgebra-Family of b1,b2
for b5 being ManySortedSet of b1 holds
   (b1 = {} or    (b5 = Carrier(b4,b3)
    iff
       for b6 being set
             st b6 in b1
          holds ex b7 being MSAlgebra over b2 st
             b7 = b4 . b6 & b5 . b6 = (the Sorts of b7) . b3)) &
    (b1 = {} implies    (b5 = Carrier(b4,b3)
    iff
       b5 = {}));

:: PRALG_2:funcreg 5
registration
  let a1 be set;
  let a2 be non empty ManySortedSign;
  let a3 be Element of the carrier of a2;
  let a4 be MSAlgebra-Family of a1,a2;
  cluster Carrier(a4,a3) -> non-empty;
end;

:: PRALG_2:funcnot 10 => PRALG_2:func 10
definition
  let a1 be set;
  let a2 be non empty ManySortedSign;
  let a3 be MSAlgebra-Family of a1,a2;
  func SORTS A3 -> ManySortedSet of the carrier of a2 means
    for b1 being Element of the carrier of a2 holds
       it . b1 = product Carrier(a3,b1);
end;

:: PRALG_2:def 17
theorem
for b1 being set
for b2 being non empty ManySortedSign
for b3 being MSAlgebra-Family of b1,b2
for b4 being ManySortedSet of the carrier of b2 holds
      b4 = SORTS b3
   iff
      for b5 being Element of the carrier of b2 holds
         b4 . b5 = product Carrier(b3,b5);

:: PRALG_2:funcreg 6
registration
  let a1 be set;
  let a2 be non empty ManySortedSign;
  let a3 be MSAlgebra-Family of a1,a2;
  cluster SORTS a3 -> non-empty;
end;

:: PRALG_2:funcnot 11 => PRALG_2:func 11
definition
  let a1 be set;
  let a2 be non empty ManySortedSign;
  let a3 be MSAlgebra-Family of a1,a2;
  func OPER A3 -> Function-yielding ManySortedSet of a1 means
    for b1 being set
          st b1 in a1
       holds ex b2 being MSAlgebra over a2 st
          b2 = a3 . b1 & it . b1 = the Charact of b2
    if a1 <> {}
    otherwise it = {};
end;

:: PRALG_2:def 18
theorem
for b1 being set
for b2 being non empty ManySortedSign
for b3 being MSAlgebra-Family of b1,b2
for b4 being Function-yielding ManySortedSet of b1 holds
   (b1 = {} or    (b4 = OPER b3
    iff
       for b5 being set
             st b5 in b1
          holds ex b6 being MSAlgebra over b2 st
             b6 = b3 . b5 & b4 . b5 = the Charact of b6)) &
    (b1 = {} implies    (b4 = OPER b3
    iff
       b4 = {}));

:: PRALG_2:th 12
theorem
for b1 being set
for b2 being non empty ManySortedSign
for b3 being MSAlgebra-Family of b1,b2 holds
   proj1 uncurry OPER b3 = [:b1,the OperSymbols of b2:];

:: PRALG_2:th 13
theorem
for b1 being non empty set
for b2 being non empty non void ManySortedSign
for b3 being MSAlgebra-Family of b1,b2
for b4 being Element of the OperSymbols of b2 holds
   commute OPER b3 in Funcs(the OperSymbols of b2,Funcs(b1,proj2 uncurry OPER b3));

:: PRALG_2:funcnot 12 => PRALG_2:func 12
definition
  let a1 be set;
  let a2 be non empty non void ManySortedSign;
  let a3 be MSAlgebra-Family of a1,a2;
  let a4 be Element of the OperSymbols of a2;
  func A3 ?. A4 -> Function-yielding ManySortedSet of a1 equals
    (commute OPER a3) . a4;
end;

:: PRALG_2:def 19
theorem
for b1 being set
for b2 being non empty non void ManySortedSign
for b3 being MSAlgebra-Family of b1,b2
for b4 being Element of the OperSymbols of b2 holds
   b3 ?. b4 = (commute OPER b3) . b4;

:: PRALG_2:th 14
theorem
for b1 being non empty set
for b2 being Element of b1
for b3 being non empty non void ManySortedSign
for b4 being MSAlgebra-Family of b1,b3
for b5 being Element of the OperSymbols of b3 holds
   (b4 ?. b5) . b2 = Den(b5,b4 . b2);

:: PRALG_2:th 15
theorem
for b1 being non empty set
for b2 being non empty non void ManySortedSign
for b3 being MSAlgebra-Family of b1,b2
for b4 being Element of the OperSymbols of b2
for b5 being set
      st b5 in proj2 Frege (b3 ?. b4)
   holds b5 is Relation-like Function-like set;

:: PRALG_2:th 16
theorem
for b1 being non empty set
for b2 being non empty non void ManySortedSign
for b3 being MSAlgebra-Family of b1,b2
for b4 being Element of the OperSymbols of b2
for b5 being Relation-like Function-like set
      st b5 in proj2 Frege (b3 ?. b4)
   holds proj1 b5 = b1 &
    (for b6 being Element of b1 holds
       b5 . b6 in Result(b4,b3 . b6));

:: PRALG_2:th 17
theorem
for b1 being non empty set
for b2 being non empty non void ManySortedSign
for b3 being MSAlgebra-Family of b1,b2
for b4 being Element of the OperSymbols of b2
for b5 being Relation-like Function-like set
      st b5 in proj1 Frege (b3 ?. b4)
   holds proj1 b5 = b1 &
    (for b6 being Element of b1 holds
       b5 . b6 in Args(b4,b3 . b6)) &
    proj2 b5 c= Funcs(proj1 the_arity_of b4,|.b3.|);

:: PRALG_2:th 18
theorem
for b1 being non empty set
for b2 being non empty non void ManySortedSign
for b3 being MSAlgebra-Family of b1,b2
for b4 being Element of the OperSymbols of b2 holds
   proj1 doms (b3 ?. b4) = b1 &
    (for b5 being Element of b1 holds
       (doms (b3 ?. b4)) . b5 = Args(b4,b3 . b5));

:: PRALG_2:funcnot 13 => PRALG_2:func 13
definition
  let a1 be set;
  let a2 be non empty non void ManySortedSign;
  let a3 be MSAlgebra-Family of a1,a2;
  func OPS A3 -> ManySortedFunction of (SORTS a3) # * the Arity of a2,(SORTS a3) * the ResultSort of a2 means
    for b1 being Element of the OperSymbols of a2 holds
       it . b1 = IFEQ(the_arity_of b1,{},commute (a3 ?. b1),Commute Frege (a3 ?. b1))
    if a1 <> {}
    otherwise TRUE;
end;

:: PRALG_2:def 20
theorem
for b1 being set
for b2 being non empty non void ManySortedSign
for b3 being MSAlgebra-Family of b1,b2
for b4 being ManySortedFunction of (SORTS b3) # * the Arity of b2,(SORTS b3) * the ResultSort of b2 holds
   (b1 = {} or    (b4 = OPS b3
    iff
       for b5 being Element of the OperSymbols of b2 holds
          b4 . b5 = IFEQ(the_arity_of b5,{},commute (b3 ?. b5),Commute Frege (b3 ?. b5)))) &
    (b1 = {} implies (b4 = OPS b3 implies TRUE) & b4 = OPS b3);

:: PRALG_2:funcnot 14 => PRALG_2:func 14
definition
  let a1 be set;
  let a2 be non empty non void ManySortedSign;
  let a3 be MSAlgebra-Family of a1,a2;
  func product A3 -> MSAlgebra over a2 equals
    MSAlgebra(#SORTS a3,OPS a3#);
end;

:: PRALG_2:def 21
theorem
for b1 being set
for b2 being non empty non void ManySortedSign
for b3 being MSAlgebra-Family of b1,b2 holds
   product b3 = MSAlgebra(#SORTS b3,OPS b3#);

:: PRALG_2:funcreg 7
registration
  let a1 be set;
  let a2 be non empty non void ManySortedSign;
  let a3 be MSAlgebra-Family of a1,a2;
  cluster product a3 -> strict;
end;

:: PRALG_2:th 20
theorem
for b1 being set
for b2 being non empty non void ManySortedSign
for b3 being MSAlgebra-Family of b1,b2 holds
   the Sorts of product b3 = SORTS b3 & the Charact of product b3 = OPS b3;