Article MSUALG_2, MML version 4.99.1005

:: MSUALG_2:funcreg 1
registration
  let a1 be set;
  let a2 be ManySortedSet of a1;
  let a3 be non-empty ManySortedSet of a1;
  cluster a2 \/ a3 -> non-empty;
end;

:: MSUALG_2:funcreg 2
registration
  let a1 be set;
  let a2 be ManySortedSet of a1;
  let a3 be non-empty ManySortedSet of a1;
  cluster a3 \/ a2 -> non-empty;
end;

:: MSUALG_2:th 2
theorem
for b1 being non empty set
for b2, b3 being ManySortedSet of b1
for b4 being Element of b1 * holds
   product (b4 * (b2 /\ b3)) = (product (b4 * b2)) /\ product (b4 * b3);

:: MSUALG_2:modenot 1
definition
  let a1 be non empty ManySortedSign;
  let a2 be MSAlgebra over a1;
  mode MSSubset of a2 is ManySortedSubset of the Sorts of a2;
end;

:: MSUALG_2:attrnot 1 => MSUALG_2:attr 1
definition
  let a1 be non empty ManySortedSign;
  let a2 be Element of the carrier of a1;
  attr a2 is with_const_op means
    ex b1 being Element of the OperSymbols of a1 st
       (the Arity of a1) . b1 = {} & (the ResultSort of a1) . b1 = a2;
end;

:: MSUALG_2:dfs 1
definiens
  let a1 be non empty ManySortedSign;
  let a2 be Element of the carrier of a1;
To prove
     a2 is with_const_op
it is sufficient to prove
  thus ex b1 being Element of the OperSymbols of a1 st
       (the Arity of a1) . b1 = {} & (the ResultSort of a1) . b1 = a2;

:: MSUALG_2:def 2
theorem
for b1 being non empty ManySortedSign
for b2 being Element of the carrier of b1 holds
      b2 is with_const_op(b1)
   iff
      ex b3 being Element of the OperSymbols of b1 st
         (the Arity of b1) . b3 = {} & (the ResultSort of b1) . b3 = b2;

:: MSUALG_2:attrnot 2 => MSUALG_2:attr 2
definition
  let a1 be non empty ManySortedSign;
  attr a1 is all-with_const_op means
    for b1 being Element of the carrier of a1 holds
       b1 is with_const_op(a1);
end;

:: MSUALG_2:dfs 2
definiens
  let a1 be non empty ManySortedSign;
To prove
     a1 is all-with_const_op
it is sufficient to prove
  thus for b1 being Element of the carrier of a1 holds
       b1 is with_const_op(a1);

:: MSUALG_2:def 3
theorem
for b1 being non empty ManySortedSign holds
      b1 is all-with_const_op
   iff
      for b2 being Element of the carrier of b1 holds
         b2 is with_const_op(b1);

:: MSUALG_2:funcreg 3
registration
  let a1 be non empty set;
  let a2 be set;
  let a3 be Function-like quasi_total Relation of a2,a1 *;
  let a4 be Function-like quasi_total Relation of a2,a1;
  cluster ManySortedSign(#a1,a2,a3,a4#) -> non empty strict;
end;

:: MSUALG_2:exreg 1
registration
  cluster non empty strict non void all-with_const_op ManySortedSign;
end;

:: MSUALG_2:funcnot 1 => MSUALG_2:func 1
definition
  let a1 be non empty non void ManySortedSign;
  let a2 be MSAlgebra over a1;
  let a3 be Element of the carrier of a1;
  func Constants(A2,A3) -> Element of bool ((the Sorts of a2) . a3) means
    ex b1 being non empty set st
       b1 = (the Sorts of a2) . a3 &
        it = {b2 where b2 is Element of b1: ex b3 being Element of the OperSymbols of a1 st
           (the Arity of a1) . b3 = {} & (the ResultSort of a1) . b3 = a3 & b2 in proj2 Den(b3,a2)}
    if (the Sorts of a2) . a3 <> {}
    otherwise it = {};
end;

:: MSUALG_2:def 4
theorem
for b1 being non empty non void ManySortedSign
for b2 being MSAlgebra over b1
for b3 being Element of the carrier of b1
for b4 being Element of bool ((the Sorts of b2) . b3) holds
   ((the Sorts of b2) . b3 = {} or    (b4 = Constants(b2,b3)
    iff
       ex b5 being non empty set st
          b5 = (the Sorts of b2) . b3 &
           b4 = {b6 where b6 is Element of b5: ex b7 being Element of the OperSymbols of b1 st
              (the Arity of b1) . b7 = {} & (the ResultSort of b1) . b7 = b3 & b6 in proj2 Den(b7,b2)})) &
    ((the Sorts of b2) . b3 = {} implies    (b4 = Constants(b2,b3)
    iff
       b4 = {}));

:: MSUALG_2:funcnot 2 => MSUALG_2:func 2
definition
  let a1 be non empty non void ManySortedSign;
  let a2 be MSAlgebra over a1;
  func Constants A2 -> ManySortedSubset of the Sorts of a2 means
    for b1 being Element of the carrier of a1 holds
       it . b1 = Constants(a2,b1);
end;

:: MSUALG_2:def 5
theorem
for b1 being non empty non void ManySortedSign
for b2 being MSAlgebra over b1
for b3 being ManySortedSubset of the Sorts of b2 holds
      b3 = Constants b2
   iff
      for b4 being Element of the carrier of b1 holds
         b3 . b4 = Constants(b2,b4);

:: MSUALG_2:funcreg 4
registration
  let a1 be non empty non void all-with_const_op ManySortedSign;
  let a2 be non-empty MSAlgebra over a1;
  let a3 be Element of the carrier of a1;
  cluster Constants(a2,a3) -> non empty;
end;

:: MSUALG_2:funcreg 5
registration
  let a1 be non empty non void all-with_const_op ManySortedSign;
  let a2 be non-empty MSAlgebra over a1;
  cluster Constants a2 -> non-empty;
end;

:: MSUALG_2:prednot 1 => MSUALG_2:pred 1
definition
  let a1 be non empty non void ManySortedSign;
  let a2 be MSAlgebra over a1;
  let a3 be Element of the OperSymbols of a1;
  let a4 be ManySortedSubset of the Sorts of a2;
  pred A4 is_closed_on A3 means
    proj2 ((Den(a3,a2)) | ((a4 # * the Arity of a1) . a3)) c= (a4 * the ResultSort of a1) . a3;
end;

:: MSUALG_2:dfs 5
definiens
  let a1 be non empty non void ManySortedSign;
  let a2 be MSAlgebra over a1;
  let a3 be Element of the OperSymbols of a1;
  let a4 be ManySortedSubset of the Sorts of a2;
To prove
     a4 is_closed_on a3
it is sufficient to prove
  thus proj2 ((Den(a3,a2)) | ((a4 # * the Arity of a1) . a3)) c= (a4 * the ResultSort of a1) . a3;

:: MSUALG_2:def 6
theorem
for b1 being non empty non void ManySortedSign
for b2 being MSAlgebra over b1
for b3 being Element of the OperSymbols of b1
for b4 being ManySortedSubset of the Sorts of b2 holds
      b4 is_closed_on b3
   iff
      proj2 ((Den(b3,b2)) | ((b4 # * the Arity of b1) . b3)) c= (b4 * the ResultSort of b1) . b3;

:: MSUALG_2:attrnot 3 => MSUALG_2:attr 3
definition
  let a1 be non empty non void ManySortedSign;
  let a2 be MSAlgebra over a1;
  let a3 be ManySortedSubset of the Sorts of a2;
  attr a3 is opers_closed means
    for b1 being Element of the OperSymbols of a1 holds
       a3 is_closed_on b1;
end;

:: MSUALG_2:dfs 6
definiens
  let a1 be non empty non void ManySortedSign;
  let a2 be MSAlgebra over a1;
  let a3 be ManySortedSubset of the Sorts of a2;
To prove
     a3 is opers_closed
it is sufficient to prove
  thus for b1 being Element of the OperSymbols of a1 holds
       a3 is_closed_on b1;

:: MSUALG_2:def 7
theorem
for b1 being non empty non void ManySortedSign
for b2 being MSAlgebra over b1
for b3 being ManySortedSubset of the Sorts of b2 holds
      b3 is opers_closed(b1, b2)
   iff
      for b4 being Element of the OperSymbols of b1 holds
         b3 is_closed_on b4;

:: MSUALG_2:th 3
theorem
for b1 being non empty non void ManySortedSign
for b2 being Element of the OperSymbols of b1
for b3 being MSAlgebra over b1
for b4, b5 being ManySortedSubset of the Sorts of b3
      st b4 c= b5
   holds (b4 # * the Arity of b1) . b2 c= (b5 # * the Arity of b1) . b2;

:: MSUALG_2:funcnot 3 => MSUALG_2:func 3
definition
  let a1 be non empty non void ManySortedSign;
  let a2 be MSAlgebra over a1;
  let a3 be Element of the OperSymbols of a1;
  let a4 be ManySortedSubset of the Sorts of a2;
  assume a4 is_closed_on a3;
  func A3 /. A4 -> Function-like quasi_total Relation of (a4 # * the Arity of a1) . a3,(a4 * the ResultSort of a1) . a3 equals
    (Den(a3,a2)) | ((a4 # * the Arity of a1) . a3);
end;

:: MSUALG_2:def 8
theorem
for b1 being non empty non void ManySortedSign
for b2 being MSAlgebra over b1
for b3 being Element of the OperSymbols of b1
for b4 being ManySortedSubset of the Sorts of b2
      st b4 is_closed_on b3
   holds b3 /. b4 = (Den(b3,b2)) | ((b4 # * the Arity of b1) . b3);

:: MSUALG_2:funcnot 4 => MSUALG_2:func 4
definition
  let a1 be non empty non void ManySortedSign;
  let a2 be MSAlgebra over a1;
  let a3 be ManySortedSubset of the Sorts of a2;
  func Opers(A2,A3) -> ManySortedFunction of a3 # * the Arity of a1,a3 * the ResultSort of a1 means
    for b1 being Element of the OperSymbols of a1 holds
       it . b1 = b1 /. a3;
end;

:: MSUALG_2:def 9
theorem
for b1 being non empty non void ManySortedSign
for b2 being MSAlgebra over b1
for b3 being ManySortedSubset of the Sorts of b2
for b4 being ManySortedFunction of b3 # * the Arity of b1,b3 * the ResultSort of b1 holds
      b4 = Opers(b2,b3)
   iff
      for b5 being Element of the OperSymbols of b1 holds
         b4 . b5 = b5 /. b3;

:: MSUALG_2:th 4
theorem
for b1 being non empty non void ManySortedSign
for b2 being MSAlgebra over b1
for b3 being ManySortedSubset of the Sorts of b2
      st b3 = the Sorts of b2
   holds b3 is opers_closed(b1, b2) &
    (for b4 being Element of the OperSymbols of b1 holds
       b4 /. b3 = Den(b4,b2));

:: MSUALG_2:th 5
theorem
for b1 being non empty non void ManySortedSign
for b2 being MSAlgebra over b1
for b3 being ManySortedSubset of the Sorts of b2
      st b3 = the Sorts of b2
   holds Opers(b2,b3) = the Charact of b2;

:: MSUALG_2:modenot 2 => MSUALG_2:mode 1
definition
  let a1 be non empty non void ManySortedSign;
  let a2 be MSAlgebra over a1;
  mode MSSubAlgebra of A2 -> MSAlgebra over a1 means
    the Sorts of it is ManySortedSubset of the Sorts of a2 &
     (for b1 being ManySortedSubset of the Sorts of a2
           st b1 = the Sorts of it
        holds b1 is opers_closed(a1, a2) & the Charact of it = Opers(a2,b1));
end;

:: MSUALG_2:dfs 9
definiens
  let a1 be non empty non void ManySortedSign;
  let a2, a3 be MSAlgebra over a1;
To prove
     a3 is MSSubAlgebra of a2
it is sufficient to prove
  thus the Sorts of a3 is ManySortedSubset of the Sorts of a2 &
     (for b1 being ManySortedSubset of the Sorts of a2
           st b1 = the Sorts of a3
        holds b1 is opers_closed(a1, a2) & the Charact of a3 = Opers(a2,b1));

:: MSUALG_2:def 10
theorem
for b1 being non empty non void ManySortedSign
for b2, b3 being MSAlgebra over b1 holds
   b3 is MSSubAlgebra of b2
iff
   the Sorts of b3 is ManySortedSubset of the Sorts of b2 &
    (for b4 being ManySortedSubset of the Sorts of b2
          st b4 = the Sorts of b3
       holds b4 is opers_closed(b1, b2) & the Charact of b3 = Opers(b2,b4));

:: MSUALG_2:exreg 2
registration
  let a1 be non empty non void ManySortedSign;
  let a2 be MSAlgebra over a1;
  cluster strict MSSubAlgebra of a2;
end;

:: MSUALG_2:funcreg 6
registration
  let a1 be non empty non void ManySortedSign;
  let a2 be non-empty MSAlgebra over a1;
  cluster MSAlgebra(#the Sorts of a2,the Charact of a2#) -> strict non-empty;
end;

:: MSUALG_2:exreg 3
registration
  let a1 be non empty non void ManySortedSign;
  let a2 be non-empty MSAlgebra over a1;
  cluster strict non-empty MSSubAlgebra of a2;
end;

:: MSUALG_2:th 6
theorem
for b1 being non empty non void ManySortedSign
for b2 being MSAlgebra over b1 holds
   b2 is MSSubAlgebra of b2;

:: MSUALG_2:th 7
theorem
for b1 being non empty non void ManySortedSign
for b2, b3, b4 being MSAlgebra over b1
      st b2 is MSSubAlgebra of b3 & b3 is MSSubAlgebra of b4
   holds b2 is MSSubAlgebra of b4;

:: MSUALG_2:th 8
theorem
for b1 being non empty non void ManySortedSign
for b2, b3 being MSAlgebra over b1
      st b2 is strict MSSubAlgebra of b3 & b3 is strict MSSubAlgebra of b2
   holds b2 = b3;

:: MSUALG_2:th 9
theorem
for b1 being non empty non void ManySortedSign
for b2 being MSAlgebra over b1
for b3, b4 being MSSubAlgebra of b2
      st the Sorts of b3 c= the Sorts of b4
   holds b3 is MSSubAlgebra of b4;

:: MSUALG_2:th 10
theorem
for b1 being non empty non void ManySortedSign
for b2 being MSAlgebra over b1
for b3, b4 being strict MSSubAlgebra of b2
      st the Sorts of b3 = the Sorts of b4
   holds b3 = b4;

:: MSUALG_2:th 11
theorem
for b1 being non empty non void ManySortedSign
for b2 being MSAlgebra over b1
for b3 being MSSubAlgebra of b2 holds
   Constants b2 is ManySortedSubset of the Sorts of b3;

:: MSUALG_2:th 12
theorem
for b1 being non empty non void all-with_const_op ManySortedSign
for b2 being non-empty MSAlgebra over b1
for b3 being non-empty MSSubAlgebra of b2 holds
   Constants b2 is non-empty ManySortedSubset of the Sorts of b3;

:: MSUALG_2:th 13
theorem
for b1 being non empty non void all-with_const_op ManySortedSign
for b2 being non-empty MSAlgebra over b1
for b3, b4 being non-empty MSSubAlgebra of b2 holds
(the Sorts of b3) /\ the Sorts of b4 is non-empty;

:: MSUALG_2:funcnot 5 => MSUALG_2:func 5
definition
  let a1 be non empty non void ManySortedSign;
  let a2 be MSAlgebra over a1;
  let a3 be ManySortedSubset of the Sorts of a2;
  func SubSort A3 -> set means
    for b1 being set holds
          b1 in it
       iff
          b1 in Funcs(the carrier of a1,bool Union the Sorts of a2) &
           b1 is ManySortedSubset of the Sorts of a2 &
           (for b2 being ManySortedSubset of the Sorts of a2
                 st b2 = b1
              holds b2 is opers_closed(a1, a2) & Constants a2 c= b2 & a3 c= b2);
end;

:: MSUALG_2:def 11
theorem
for b1 being non empty non void ManySortedSign
for b2 being MSAlgebra over b1
for b3 being ManySortedSubset of the Sorts of b2
for b4 being set holds
      b4 = SubSort b3
   iff
      for b5 being set holds
            b5 in b4
         iff
            b5 in Funcs(the carrier of b1,bool Union the Sorts of b2) &
             b5 is ManySortedSubset of the Sorts of b2 &
             (for b6 being ManySortedSubset of the Sorts of b2
                   st b6 = b5
                holds b6 is opers_closed(b1, b2) & Constants b2 c= b6 & b3 c= b6);

:: MSUALG_2:funcreg 7
registration
  let a1 be non empty non void ManySortedSign;
  let a2 be MSAlgebra over a1;
  let a3 be ManySortedSubset of the Sorts of a2;
  cluster SubSort a3 -> non empty;
end;

:: MSUALG_2:funcnot 6 => MSUALG_2:func 6
definition
  let a1 be non empty non void ManySortedSign;
  let a2 be MSAlgebra over a1;
  func SubSort A2 -> set means
    for b1 being set holds
          b1 in it
       iff
          b1 in Funcs(the carrier of a1,bool Union the Sorts of a2) &
           b1 is ManySortedSubset of the Sorts of a2 &
           (for b2 being ManySortedSubset of the Sorts of a2
                 st b2 = b1
              holds b2 is opers_closed(a1, a2));
end;

:: MSUALG_2:def 12
theorem
for b1 being non empty non void ManySortedSign
for b2 being MSAlgebra over b1
for b3 being set holds
      b3 = SubSort b2
   iff
      for b4 being set holds
            b4 in b3
         iff
            b4 in Funcs(the carrier of b1,bool Union the Sorts of b2) &
             b4 is ManySortedSubset of the Sorts of b2 &
             (for b5 being ManySortedSubset of the Sorts of b2
                   st b5 = b4
                holds b5 is opers_closed(b1, b2));

:: MSUALG_2:funcreg 8
registration
  let a1 be non empty non void ManySortedSign;
  let a2 be MSAlgebra over a1;
  cluster SubSort a2 -> non empty;
end;

:: MSUALG_2:funcnot 7 => MSUALG_2:func 7
definition
  let a1 be non empty non void ManySortedSign;
  let a2 be MSAlgebra over a1;
  let a3 be Element of SubSort a2;
  func @ A3 -> ManySortedSubset of the Sorts of a2 equals
    a3;
end;

:: MSUALG_2:def 13
theorem
for b1 being non empty non void ManySortedSign
for b2 being MSAlgebra over b1
for b3 being Element of SubSort b2 holds
   @ b3 = b3;

:: MSUALG_2:th 14
theorem
for b1 being non empty non void ManySortedSign
for b2 being MSAlgebra over b1
for b3, b4 being ManySortedSubset of the Sorts of b2 holds
   b4 in SubSort b3
iff
   b4 is opers_closed(b1, b2) & Constants b2 c= b4 & b3 c= b4;

:: MSUALG_2:th 15
theorem
for b1 being non empty non void ManySortedSign
for b2 being MSAlgebra over b1
for b3 being ManySortedSubset of the Sorts of b2 holds
      b3 in SubSort b2
   iff
      b3 is opers_closed(b1, b2);

:: MSUALG_2:funcnot 8 => MSUALG_2:func 8
definition
  let a1 be non empty non void ManySortedSign;
  let a2 be MSAlgebra over a1;
  let a3 be ManySortedSubset of the Sorts of a2;
  let a4 be Element of the carrier of a1;
  func SubSort(A3,A4) -> set means
    for b1 being set holds
          b1 in it
       iff
          ex b2 being ManySortedSubset of the Sorts of a2 st
             b2 in SubSort a3 & b1 = b2 . a4;
end;

:: MSUALG_2:def 14
theorem
for b1 being non empty non void ManySortedSign
for b2 being MSAlgebra over b1
for b3 being ManySortedSubset of the Sorts of b2
for b4 being Element of the carrier of b1
for b5 being set holds
      b5 = SubSort(b3,b4)
   iff
      for b6 being set holds
            b6 in b5
         iff
            ex b7 being ManySortedSubset of the Sorts of b2 st
               b7 in SubSort b3 & b6 = b7 . b4;

:: MSUALG_2:funcreg 9
registration
  let a1 be non empty non void ManySortedSign;
  let a2 be MSAlgebra over a1;
  let a3 be ManySortedSubset of the Sorts of a2;
  let a4 be Element of the carrier of a1;
  cluster SubSort(a3,a4) -> non empty;
end;

:: MSUALG_2:funcnot 9 => MSUALG_2:func 9
definition
  let a1 be non empty non void ManySortedSign;
  let a2 be MSAlgebra over a1;
  let a3 be ManySortedSubset of the Sorts of a2;
  func MSSubSort A3 -> ManySortedSubset of the Sorts of a2 means
    for b1 being Element of the carrier of a1 holds
       it . b1 = meet SubSort(a3,b1);
end;

:: MSUALG_2:def 15
theorem
for b1 being non empty non void ManySortedSign
for b2 being MSAlgebra over b1
for b3, b4 being ManySortedSubset of the Sorts of b2 holds
   b4 = MSSubSort b3
iff
   for b5 being Element of the carrier of b1 holds
      b4 . b5 = meet SubSort(b3,b5);

:: MSUALG_2:th 16
theorem
for b1 being non empty non void ManySortedSign
for b2 being MSAlgebra over b1
for b3 being ManySortedSubset of the Sorts of b2 holds
   (Constants b2) \/ b3 c= MSSubSort b3;

:: MSUALG_2:th 17
theorem
for b1 being non empty non void ManySortedSign
for b2 being MSAlgebra over b1
for b3 being ManySortedSubset of the Sorts of b2
      st (Constants b2) \/ b3 is non-empty
   holds MSSubSort b3 is non-empty;

:: MSUALG_2:th 18
theorem
for b1 being non empty non void ManySortedSign
for b2 being Element of the OperSymbols of b1
for b3 being MSAlgebra over b1
for b4, b5 being ManySortedSubset of the Sorts of b3
      st b5 in SubSort b4
   holds ((MSSubSort b4) # * the Arity of b1) . b2 c= (b5 # * the Arity of b1) . b2;

:: MSUALG_2:th 19
theorem
for b1 being non empty non void ManySortedSign
for b2 being Element of the OperSymbols of b1
for b3 being MSAlgebra over b1
for b4, b5 being ManySortedSubset of the Sorts of b3
      st b5 in SubSort b4
   holds proj2 ((Den(b2,b3)) | (((MSSubSort b4) # * the Arity of b1) . b2)) c= (b5 * the ResultSort of b1) . b2;

:: MSUALG_2:th 20
theorem
for b1 being non empty non void ManySortedSign
for b2 being Element of the OperSymbols of b1
for b3 being MSAlgebra over b1
for b4 being ManySortedSubset of the Sorts of b3 holds
   proj2 ((Den(b2,b3)) | (((MSSubSort b4) # * the Arity of b1) . b2)) c= ((MSSubSort b4) * the ResultSort of b1) . b2;

:: MSUALG_2:th 21
theorem
for b1 being non empty non void ManySortedSign
for b2 being MSAlgebra over b1
for b3 being ManySortedSubset of the Sorts of b2 holds
   MSSubSort b3 is opers_closed(b1, b2) & b3 c= MSSubSort b3;

:: MSUALG_2:funcnot 10 => MSUALG_2:func 10
definition
  let a1 be non empty non void ManySortedSign;
  let a2 be MSAlgebra over a1;
  let a3 be ManySortedSubset of the Sorts of a2;
  assume a3 is opers_closed(a1, a2);
  func A2 | A3 -> strict MSSubAlgebra of a2 equals
    MSAlgebra(#a3,Opers(a2,a3)#);
end;

:: MSUALG_2:def 16
theorem
for b1 being non empty non void ManySortedSign
for b2 being MSAlgebra over b1
for b3 being ManySortedSubset of the Sorts of b2
      st b3 is opers_closed(b1, b2)
   holds b2 | b3 = MSAlgebra(#b3,Opers(b2,b3)#);

:: MSUALG_2:funcnot 11 => MSUALG_2:func 11
definition
  let a1 be non empty non void ManySortedSign;
  let a2 be MSAlgebra over a1;
  let a3, a4 be MSSubAlgebra of a2;
  func A3 /\ A4 -> strict MSSubAlgebra of a2 means
    the Sorts of it = (the Sorts of a3) /\ the Sorts of a4 &
     (for b1 being ManySortedSubset of the Sorts of a2
           st b1 = the Sorts of it
        holds b1 is opers_closed(a1, a2) & the Charact of it = Opers(a2,b1));
end;

:: MSUALG_2:def 17
theorem
for b1 being non empty non void ManySortedSign
for b2 being MSAlgebra over b1
for b3, b4 being MSSubAlgebra of b2
for b5 being strict MSSubAlgebra of b2 holds
      b5 = b3 /\ b4
   iff
      the Sorts of b5 = (the Sorts of b3) /\ the Sorts of b4 &
       (for b6 being ManySortedSubset of the Sorts of b2
             st b6 = the Sorts of b5
          holds b6 is opers_closed(b1, b2) & the Charact of b5 = Opers(b2,b6));

:: MSUALG_2:funcnot 12 => MSUALG_2:func 12
definition
  let a1 be non empty non void ManySortedSign;
  let a2 be MSAlgebra over a1;
  let a3 be ManySortedSubset of the Sorts of a2;
  func GenMSAlg A3 -> strict MSSubAlgebra of a2 means
    a3 is ManySortedSubset of the Sorts of it &
     (for b1 being MSSubAlgebra of a2
           st a3 is ManySortedSubset of the Sorts of b1
        holds it is MSSubAlgebra of b1);
end;

:: MSUALG_2:def 18
theorem
for b1 being non empty non void ManySortedSign
for b2 being MSAlgebra over b1
for b3 being ManySortedSubset of the Sorts of b2
for b4 being strict MSSubAlgebra of b2 holds
      b4 = GenMSAlg b3
   iff
      b3 is ManySortedSubset of the Sorts of b4 &
       (for b5 being MSSubAlgebra of b2
             st b3 is ManySortedSubset of the Sorts of b5
          holds b4 is MSSubAlgebra of b5);

:: MSUALG_2:funcreg 10
registration
  let a1 be non empty non void ManySortedSign;
  let a2 be non-empty MSAlgebra over a1;
  let a3 be non-empty ManySortedSubset of the Sorts of a2;
  cluster GenMSAlg a3 -> strict non-empty;
end;

:: MSUALG_2:th 22
theorem
for b1 being non empty non void ManySortedSign
for b2 being strict MSAlgebra over b1
for b3 being ManySortedSubset of the Sorts of b2
      st b3 = the Sorts of b2
   holds GenMSAlg b3 = b2;

:: MSUALG_2:th 23
theorem
for b1 being non empty non void ManySortedSign
for b2 being MSAlgebra over b1
for b3 being strict MSSubAlgebra of b2
for b4 being ManySortedSubset of the Sorts of b2
      st b4 = the Sorts of b3
   holds GenMSAlg b4 = b3;

:: MSUALG_2:th 24
theorem
for b1 being non empty non void ManySortedSign
for b2 being non-empty MSAlgebra over b1
for b3 being MSSubAlgebra of b2 holds
   (GenMSAlg Constants b2) /\ b3 = GenMSAlg Constants b2;

:: MSUALG_2:funcnot 13 => MSUALG_2:func 13
definition
  let a1 be non empty non void ManySortedSign;
  let a2 be non-empty MSAlgebra over a1;
  let a3, a4 be MSSubAlgebra of a2;
  func A3 "\/" A4 -> strict MSSubAlgebra of a2 means
    for b1 being ManySortedSubset of the Sorts of a2
          st b1 = (the Sorts of a3) \/ the Sorts of a4
       holds it = GenMSAlg b1;
end;

:: MSUALG_2:def 19
theorem
for b1 being non empty non void ManySortedSign
for b2 being non-empty MSAlgebra over b1
for b3, b4 being MSSubAlgebra of b2
for b5 being strict MSSubAlgebra of b2 holds
      b5 = b3 "\/" b4
   iff
      for b6 being ManySortedSubset of the Sorts of b2
            st b6 = (the Sorts of b3) \/ the Sorts of b4
         holds b5 = GenMSAlg b6;

:: MSUALG_2:th 25
theorem
for b1 being non empty non void ManySortedSign
for b2 being non-empty MSAlgebra over b1
for b3 being MSSubAlgebra of b2
for b4, b5 being ManySortedSubset of the Sorts of b2
      st b5 = b4 \/ the Sorts of b3
   holds (GenMSAlg b4) "\/" b3 = GenMSAlg b5;

:: MSUALG_2:th 26
theorem
for b1 being non empty non void ManySortedSign
for b2 being non-empty MSAlgebra over b1
for b3 being MSSubAlgebra of b2
for b4 being ManySortedSubset of the Sorts of b2
      st b4 = the Sorts of b2
   holds (GenMSAlg b4) "\/" b3 = GenMSAlg b4;

:: MSUALG_2:th 27
theorem
for b1 being non empty non void ManySortedSign
for b2 being non-empty MSAlgebra over b1
for b3, b4 being MSSubAlgebra of b2 holds
b3 "\/" b4 = b4 "\/" b3;

:: MSUALG_2:th 28
theorem
for b1 being non empty non void ManySortedSign
for b2 being non-empty MSAlgebra over b1
for b3, b4 being strict MSSubAlgebra of b2 holds
b3 /\ (b3 "\/" b4) = b3;

:: MSUALG_2:th 29
theorem
for b1 being non empty non void ManySortedSign
for b2 being non-empty MSAlgebra over b1
for b3, b4 being strict MSSubAlgebra of b2 holds
(b3 /\ b4) "\/" b4 = b4;

:: MSUALG_2:funcnot 14 => MSUALG_2:func 14
definition
  let a1 be non empty non void ManySortedSign;
  let a2 be MSAlgebra over a1;
  func MSSub A2 -> set means
    for b1 being set holds
          b1 in it
       iff
          b1 is strict MSSubAlgebra of a2;
end;

:: MSUALG_2:def 20
theorem
for b1 being non empty non void ManySortedSign
for b2 being MSAlgebra over b1
for b3 being set holds
      b3 = MSSub b2
   iff
      for b4 being set holds
            b4 in b3
         iff
            b4 is strict MSSubAlgebra of b2;

:: MSUALG_2:funcreg 11
registration
  let a1 be non empty non void ManySortedSign;
  let a2 be MSAlgebra over a1;
  cluster MSSub a2 -> non empty;
end;

:: MSUALG_2:funcnot 15 => MSUALG_2:func 15
definition
  let a1 be non empty non void ManySortedSign;
  let a2 be non-empty MSAlgebra over a1;
  func MSAlg_join A2 -> Function-like quasi_total Relation of [:MSSub a2,MSSub a2:],MSSub a2 means
    for b1, b2 being Element of MSSub a2
    for b3, b4 being strict MSSubAlgebra of a2
          st b1 = b3 & b2 = b4
       holds it .(b1,b2) = b3 "\/" b4;
end;

:: MSUALG_2:def 21
theorem
for b1 being non empty non void ManySortedSign
for b2 being non-empty MSAlgebra over b1
for b3 being Function-like quasi_total Relation of [:MSSub b2,MSSub b2:],MSSub b2 holds
      b3 = MSAlg_join b2
   iff
      for b4, b5 being Element of MSSub b2
      for b6, b7 being strict MSSubAlgebra of b2
            st b4 = b6 & b5 = b7
         holds b3 .(b4,b5) = b6 "\/" b7;

:: MSUALG_2:funcnot 16 => MSUALG_2:func 16
definition
  let a1 be non empty non void ManySortedSign;
  let a2 be non-empty MSAlgebra over a1;
  func MSAlg_meet A2 -> Function-like quasi_total Relation of [:MSSub a2,MSSub a2:],MSSub a2 means
    for b1, b2 being Element of MSSub a2
    for b3, b4 being strict MSSubAlgebra of a2
          st b1 = b3 & b2 = b4
       holds it .(b1,b2) = b3 /\ b4;
end;

:: MSUALG_2:def 22
theorem
for b1 being non empty non void ManySortedSign
for b2 being non-empty MSAlgebra over b1
for b3 being Function-like quasi_total Relation of [:MSSub b2,MSSub b2:],MSSub b2 holds
      b3 = MSAlg_meet b2
   iff
      for b4, b5 being Element of MSSub b2
      for b6, b7 being strict MSSubAlgebra of b2
            st b4 = b6 & b5 = b7
         holds b3 .(b4,b5) = b6 /\ b7;

:: MSUALG_2:th 30
theorem
for b1 being non empty non void ManySortedSign
for b2 being non-empty MSAlgebra over b1 holds
   MSAlg_join b2 is commutative(MSSub b2);

:: MSUALG_2:th 31
theorem
for b1 being non empty non void ManySortedSign
for b2 being non-empty MSAlgebra over b1 holds
   MSAlg_join b2 is associative(MSSub b2);

:: MSUALG_2:th 32
theorem
for b1 being non empty non void ManySortedSign
for b2 being non-empty MSAlgebra over b1 holds
   MSAlg_meet b2 is commutative(MSSub b2);

:: MSUALG_2:th 33
theorem
for b1 being non empty non void ManySortedSign
for b2 being non-empty MSAlgebra over b1 holds
   MSAlg_meet b2 is associative(MSSub b2);

:: MSUALG_2:funcnot 17 => MSUALG_2:func 17
definition
  let a1 be non empty non void ManySortedSign;
  let a2 be non-empty MSAlgebra over a1;
  func MSSubAlLattice A2 -> non empty strict Lattice-like LattStr equals
    LattStr(#MSSub a2,MSAlg_join a2,MSAlg_meet a2#);
end;

:: MSUALG_2:def 23
theorem
for b1 being non empty non void ManySortedSign
for b2 being non-empty MSAlgebra over b1 holds
   MSSubAlLattice b2 = LattStr(#MSSub b2,MSAlg_join b2,MSAlg_meet b2#);

:: MSUALG_2:th 34
theorem
for b1 being non empty non void ManySortedSign
for b2 being non-empty MSAlgebra over b1 holds
   MSSubAlLattice b2 is bounded;

:: MSUALG_2:funcreg 12
registration
  let a1 be non empty non void ManySortedSign;
  let a2 be non-empty MSAlgebra over a1;
  cluster MSSubAlLattice a2 -> non empty strict Lattice-like bounded;
end;

:: MSUALG_2:th 35
theorem
for b1 being non empty non void ManySortedSign
for b2 being non-empty MSAlgebra over b1 holds
   Bottom MSSubAlLattice b2 = GenMSAlg Constants b2;

:: MSUALG_2:th 36
theorem
for b1 being non empty non void ManySortedSign
for b2 being non-empty MSAlgebra over b1
for b3 being ManySortedSubset of the Sorts of b2
      st b3 = the Sorts of b2
   holds Top MSSubAlLattice b2 = GenMSAlg b3;

:: MSUALG_2:th 37
theorem
for b1 being non empty non void ManySortedSign
for b2 being strict non-empty MSAlgebra over b1 holds
   Top MSSubAlLattice b2 = b2;

:: MSUALG_2:th 38
theorem
for b1 being non empty non void ManySortedSign
for b2 being MSAlgebra over b1 holds
   MSAlgebra(#the Sorts of b2,the Charact of b2#) is MSSubAlgebra of b2;

:: MSUALG_2:th 40
theorem
for b1 being non empty non void ManySortedSign
for b2 being MSAlgebra over b1
for b3 being ManySortedSubset of the Sorts of b2 holds
   the Sorts of b2 in SubSort b3;

:: MSUALG_2:th 41
theorem
for b1 being non empty non void ManySortedSign
for b2 being MSAlgebra over b1
for b3 being ManySortedSubset of the Sorts of b2 holds
   SubSort b3 c= SubSort b2;