Article UNIALG_2, MML version 4.99.1005

:: UNIALG_2:th 1
theorem
for b1 being natural set
for b2 being non empty set
for b3 being non empty Element of bool b2 holds
   (b1 -tuples_on b2) /\ (b1 -tuples_on b3) = b1 -tuples_on b3;

:: UNIALG_2:th 2
theorem
for b1 being non empty set
for b2 being non empty Function-like homogeneous quasi_total Relation of b1 *,b1 holds
   proj1 b2 = (arity b2) -tuples_on b1;

:: UNIALG_2:modenot 1 => UNIALG_2:mode 1
definition
  let a1 be non empty set;
  mode PFuncsDomHQN of A1 -> non empty set means
    for b1 being Element of it holds
       b1 is non empty Function-like homogeneous quasi_total Relation of a1 *,a1;
end;

:: UNIALG_2:dfs 1
definiens
  let a1, a2 be non empty set;
To prove
     a2 is PFuncsDomHQN of a1
it is sufficient to prove
  thus for b1 being Element of a2 holds
       b1 is non empty Function-like homogeneous quasi_total Relation of a1 *,a1;

:: UNIALG_2:def 1
theorem
for b1, b2 being non empty set holds
   b2 is PFuncsDomHQN of b1
iff
   for b3 being Element of b2 holds
      b3 is non empty Function-like homogeneous quasi_total Relation of b1 *,b1;

:: UNIALG_2:modenot 2 => UNIALG_2:mode 2
definition
  let a1 be non empty set;
  let a2 be PFuncsDomHQN of a1;
  redefine mode Element of a2 -> non empty Function-like homogeneous quasi_total Relation of a1 *,a1;
end;

:: UNIALG_2:modenot 3
definition
  let a1 be non empty partial quasi_total non-empty UAStr;
  mode PFuncsDomHQN of a1 is PFuncsDomHQN of the carrier of a1;
end;

:: UNIALG_2:modenot 4
definition
  let a1 be UAStr;
  mode PartFunc of a1 is Function-like Relation of (the carrier of a1) *,the carrier of a1;
end;

:: UNIALG_2:prednot 1 => UNIALG_2:pred 1
definition
  let a1, a2 be non empty partial quasi_total non-empty UAStr;
  pred A1,A2 are_similar means
    signature a1 = signature a2;
  symmetry;
::  for a1, a2 being non empty partial quasi_total non-empty UAStr
::        st a1,a2 are_similar
::     holds a2,a1 are_similar;
  reflexivity;
::  for a1 being non empty partial quasi_total non-empty UAStr holds
::     a1,a1 are_similar;
end;

:: UNIALG_2:dfs 2
definiens
  let a1, a2 be non empty partial quasi_total non-empty UAStr;
To prove
     a1,a2 are_similar
it is sufficient to prove
  thus signature a1 = signature a2;

:: UNIALG_2:def 2
theorem
for b1, b2 being non empty partial quasi_total non-empty UAStr holds
   b1,b2 are_similar
iff
   signature b1 = signature b2;

:: UNIALG_2:th 3
theorem
for b1, b2 being non empty partial quasi_total non-empty UAStr
      st b1,b2 are_similar
   holds len the charact of b1 = len the charact of b2;

:: UNIALG_2:th 4
theorem
for b1, b2, b3 being non empty partial quasi_total non-empty UAStr
      st b1,b2 are_similar & b2,b3 are_similar
   holds b1,b3 are_similar;

:: UNIALG_2:th 5
theorem
for b1 being non empty partial quasi_total non-empty UAStr holds
   proj2 the charact of b1 is non empty Element of bool PFuncs((the carrier of b1) *,the carrier of b1);

:: UNIALG_2:funcnot 1 => UNIALG_2:func 1
definition
  let a1 be non empty partial quasi_total non-empty UAStr;
  func Operations A1 -> PFuncsDomHQN of the carrier of a1 equals
    proj2 the charact of a1;
end;

:: UNIALG_2:def 3
theorem
for b1 being non empty partial quasi_total non-empty UAStr holds
   Operations b1 = proj2 the charact of b1;

:: UNIALG_2:modenot 5
definition
  let a1 be non empty partial quasi_total non-empty UAStr;
  mode operation of a1 is Element of Operations a1;
end;

:: UNIALG_2:prednot 2 => UNIALG_2:pred 2
definition
  let a1 be non empty partial quasi_total non-empty UAStr;
  let a2 be Element of bool the carrier of a1;
  let a3 be Element of Operations a1;
  pred A2 is_closed_on A3 means
    for b1 being FinSequence of a2
          st len b1 = arity a3
       holds a3 . b1 in a2;
end;

:: UNIALG_2:dfs 4
definiens
  let a1 be non empty partial quasi_total non-empty UAStr;
  let a2 be Element of bool the carrier of a1;
  let a3 be Element of Operations a1;
To prove
     a2 is_closed_on a3
it is sufficient to prove
  thus for b1 being FinSequence of a2
          st len b1 = arity a3
       holds a3 . b1 in a2;

:: UNIALG_2:def 4
theorem
for b1 being non empty partial quasi_total non-empty UAStr
for b2 being Element of bool the carrier of b1
for b3 being Element of Operations b1 holds
      b2 is_closed_on b3
   iff
      for b4 being FinSequence of b2
            st len b4 = arity b3
         holds b3 . b4 in b2;

:: UNIALG_2:attrnot 1 => UNIALG_2:attr 1
definition
  let a1 be non empty partial quasi_total non-empty UAStr;
  let a2 be Element of bool the carrier of a1;
  attr a2 is opers_closed means
    for b1 being Element of Operations a1 holds
       a2 is_closed_on b1;
end;

:: UNIALG_2:dfs 5
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 opers_closed
it is sufficient to prove
  thus for b1 being Element of Operations a1 holds
       a2 is_closed_on b1;

:: UNIALG_2: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 opers_closed(b1)
   iff
      for b3 being Element of Operations b1 holds
         b2 is_closed_on b3;

:: UNIALG_2:funcnot 2 => UNIALG_2:func 2
definition
  let a1 be non empty partial quasi_total non-empty UAStr;
  let a2 be non empty Element of bool the carrier of a1;
  let a3 be Element of Operations a1;
  assume a2 is_closed_on a3;
  func A3 /. A2 -> non empty Function-like homogeneous quasi_total Relation of a2 *,a2 equals
    a3 | ((arity a3) -tuples_on a2);
end;

:: UNIALG_2:def 6
theorem
for b1 being non empty partial quasi_total non-empty UAStr
for b2 being non empty Element of bool the carrier of b1
for b3 being Element of Operations b1
      st b2 is_closed_on b3
   holds b3 /. b2 = b3 | ((arity b3) -tuples_on b2);

:: UNIALG_2:funcnot 3 => UNIALG_2:func 3
definition
  let a1 be non empty partial quasi_total non-empty UAStr;
  let a2 be non empty Element of bool the carrier of a1;
  func Opers(A1,A2) -> FinSequence of PFuncs(a2 *,a2) means
    dom it = dom the charact of a1 &
     (for b1 being set
     for b2 being Element of Operations a1
           st b1 in dom it & b2 = (the charact of a1) . b1
        holds it . b1 = b2 /. a2);
end;

:: UNIALG_2:def 7
theorem
for b1 being non empty partial quasi_total non-empty UAStr
for b2 being non empty Element of bool the carrier of b1
for b3 being FinSequence of PFuncs(b2 *,b2) holds
      b3 = Opers(b1,b2)
   iff
      dom b3 = dom the charact of b1 &
       (for b4 being set
       for b5 being Element of Operations b1
             st b4 in dom b3 & b5 = (the charact of b1) . b4
          holds b3 . b4 = b5 /. b2);

:: UNIALG_2:th 7
theorem
for b1 being non empty partial quasi_total non-empty UAStr
for b2 being non empty Element of bool the carrier of b1
      st b2 = the carrier of b1
   holds b2 is opers_closed(b1) &
    (for b3 being Element of Operations b1 holds
       b3 /. b2 = b3);

:: UNIALG_2:th 8
theorem
for b1 being non empty partial quasi_total non-empty UAStr
for b2 being non empty Element of bool the carrier of b1
for b3 being Element of Operations b1
      st b2 is_closed_on b3
   holds arity (b3 /. b2) = arity b3;

:: UNIALG_2:modenot 6 => UNIALG_2:mode 3
definition
  let a1 be non empty partial quasi_total non-empty UAStr;
  mode SubAlgebra of A1 -> non empty partial quasi_total non-empty UAStr means
    the carrier of it is Element of bool the carrier of a1 &
     (for b1 being non empty Element of bool the carrier of a1
           st b1 = the carrier of it
        holds the charact of it = Opers(a1,b1) & b1 is opers_closed(a1));
end;

:: UNIALG_2:dfs 8
definiens
  let a1, a2 be non empty partial quasi_total non-empty UAStr;
To prove
     a2 is SubAlgebra of a1
it is sufficient to prove
  thus the carrier of a2 is Element of bool the carrier of a1 &
     (for b1 being non empty Element of bool the carrier of a1
           st b1 = the carrier of a2
        holds the charact of a2 = Opers(a1,b1) & b1 is opers_closed(a1));

:: UNIALG_2:def 8
theorem
for b1, b2 being non empty partial quasi_total non-empty UAStr holds
   b2 is SubAlgebra of b1
iff
   the carrier of b2 is Element of bool the carrier of b1 &
    (for b3 being non empty Element of bool the carrier of b1
          st b3 = the carrier of b2
       holds the charact of b2 = Opers(b1,b3) & b3 is opers_closed(b1));

:: UNIALG_2:exreg 1
registration
  let a1 be non empty partial quasi_total non-empty UAStr;
  cluster non empty strict partial quasi_total non-empty SubAlgebra of a1;
end;

:: UNIALG_2:th 9
theorem
for b1, b2 being non empty partial quasi_total non-empty UAStr
for b3 being Element of Operations b1
for b4 being Element of Operations b2
for b5 being natural set
      st b1 is SubAlgebra of b2 & b5 in dom the charact of b1 & b3 = (the charact of b1) . b5 & b4 = (the charact of b2) . b5
   holds arity b3 = arity b4;

:: UNIALG_2:th 10
theorem
for b1, b2 being non empty partial quasi_total non-empty UAStr
      st b1 is SubAlgebra of b2
   holds dom the charact of b1 = dom the charact of b2;

:: UNIALG_2:th 11
theorem
for b1 being non empty partial quasi_total non-empty UAStr holds
   b1 is SubAlgebra of b1;

:: UNIALG_2:th 12
theorem
for b1, b2, b3 being non empty partial quasi_total non-empty UAStr
      st b1 is SubAlgebra of b2 & b2 is SubAlgebra of b3
   holds b1 is SubAlgebra of b3;

:: UNIALG_2:th 13
theorem
for b1, b2 being non empty partial quasi_total non-empty UAStr
      st b1 is strict SubAlgebra of b2 & b2 is strict SubAlgebra of b1
   holds b1 = b2;

:: UNIALG_2:th 14
theorem
for b1 being non empty partial quasi_total non-empty UAStr
for b2, b3 being SubAlgebra of b1
      st the carrier of b2 c= the carrier of b3
   holds b2 is SubAlgebra of b3;

:: UNIALG_2:th 15
theorem
for b1 being non empty partial quasi_total non-empty UAStr
for b2, b3 being strict SubAlgebra of b1
      st the carrier of b2 = the carrier of b3
   holds b2 = b3;

:: UNIALG_2:th 16
theorem
for b1, b2 being non empty partial quasi_total non-empty UAStr
      st b1 is SubAlgebra of b2
   holds b1,b2 are_similar;

:: UNIALG_2:th 17
theorem
for b1 being non empty partial quasi_total non-empty UAStr
for b2 being non empty Element of bool the carrier of b1 holds
   UAStr(#b2,Opers(b1,b2)#) is non empty strict partial quasi_total non-empty UAStr;

:: UNIALG_2:funcnot 4 => UNIALG_2:func 4
definition
  let a1 be non empty partial quasi_total non-empty UAStr;
  let a2 be non empty Element of bool the carrier of a1;
  assume a2 is opers_closed(a1);
  func UniAlgSetClosed A2 -> strict SubAlgebra of a1 equals
    UAStr(#a2,Opers(a1,a2)#);
end;

:: UNIALG_2:def 9
theorem
for b1 being non empty partial quasi_total non-empty UAStr
for b2 being non empty Element of bool the carrier of b1
      st b2 is opers_closed(b1)
   holds UniAlgSetClosed b2 = UAStr(#b2,Opers(b1,b2)#);

:: UNIALG_2:funcnot 5 => UNIALG_2:func 5
definition
  let a1 be non empty partial quasi_total non-empty UAStr;
  let a2, a3 be SubAlgebra of a1;
  assume the carrier of a2 meets the carrier of a3;
  func A2 /\ A3 -> strict SubAlgebra of a1 means
    the carrier of it = (the carrier of a2) /\ the carrier of a3 &
     (for b1 being non empty Element of bool the carrier of a1
           st b1 = the carrier of it
        holds the charact of it = Opers(a1,b1) & b1 is opers_closed(a1));
end;

:: UNIALG_2:def 10
theorem
for b1 being non empty partial quasi_total non-empty UAStr
for b2, b3 being SubAlgebra of b1
   st the carrier of b2 meets the carrier of b3
for b4 being strict SubAlgebra of b1 holds
      b4 = b2 /\ b3
   iff
      the carrier of b4 = (the carrier of b2) /\ the carrier of b3 &
       (for b5 being non empty Element of bool the carrier of b1
             st b5 = the carrier of b4
          holds the charact of b4 = Opers(b1,b5) & b5 is opers_closed(b1));

:: UNIALG_2:funcnot 6 => UNIALG_2:func 6
definition
  let a1 be non empty partial quasi_total non-empty UAStr;
  func Constants A1 -> Element of bool the carrier of a1 equals
    {b1 where b1 is Element of the carrier of a1: ex b2 being Element of Operations a1 st
       arity b2 = 0 & b1 in proj2 b2};
end;

:: UNIALG_2:def 11
theorem
for b1 being non empty partial quasi_total non-empty UAStr holds
   Constants b1 = {b2 where b2 is Element of the carrier of b1: ex b3 being Element of Operations b1 st
      arity b3 = 0 & b2 in proj2 b3};

:: UNIALG_2:attrnot 2 => UNIALG_2:attr 2
definition
  let a1 be non empty partial quasi_total non-empty UAStr;
  attr a1 is with_const_op means
    ex b1 being Element of Operations a1 st
       arity b1 = 0;
end;

:: UNIALG_2:dfs 12
definiens
  let a1 be non empty partial quasi_total non-empty UAStr;
To prove
     a1 is with_const_op
it is sufficient to prove
  thus ex b1 being Element of Operations a1 st
       arity b1 = 0;

:: UNIALG_2:def 12
theorem
for b1 being non empty partial quasi_total non-empty UAStr holds
      b1 is with_const_op
   iff
      ex b2 being Element of Operations b1 st
         arity b2 = 0;

:: UNIALG_2:exreg 2
registration
  cluster non empty strict partial quasi_total non-empty with_const_op UAStr;
end;

:: UNIALG_2:funcreg 1
registration
  let a1 be non empty partial quasi_total non-empty with_const_op UAStr;
  cluster Constants a1 -> non empty;
end;

:: UNIALG_2:th 18
theorem
for b1 being non empty partial quasi_total non-empty UAStr
for b2 being SubAlgebra of b1 holds
   Constants b1 is Element of bool the carrier of b2;

:: UNIALG_2:th 19
theorem
for b1 being non empty partial quasi_total non-empty with_const_op UAStr
for b2 being SubAlgebra of b1 holds
   Constants b1 is non empty Element of bool the carrier of b2;

:: UNIALG_2:th 20
theorem
for b1 being non empty partial quasi_total non-empty with_const_op UAStr
for b2, b3 being SubAlgebra of b1 holds
the carrier of b2 meets the carrier of b3;

:: UNIALG_2:funcnot 7 => UNIALG_2:func 7
definition
  let a1 be non empty partial quasi_total non-empty UAStr;
  let a2 be Element of bool the carrier of a1;
  assume (Constants a1 = {} implies a2 <> {});
  func GenUnivAlg A2 -> strict SubAlgebra of a1 means
    a2 c= the carrier of it &
     (for b1 being SubAlgebra of a1
           st a2 c= the carrier of b1
        holds it is SubAlgebra of b1);
end;

:: UNIALG_2:def 13
theorem
for b1 being non empty partial quasi_total non-empty UAStr
for b2 being Element of bool the carrier of b1
   st (Constants b1 = {} implies b2 <> {})
for b3 being strict SubAlgebra of b1 holds
      b3 = GenUnivAlg b2
   iff
      b2 c= the carrier of b3 &
       (for b4 being SubAlgebra of b1
             st b2 c= the carrier of b4
          holds b3 is SubAlgebra of b4);

:: UNIALG_2:th 21
theorem
for b1 being non empty strict partial quasi_total non-empty UAStr holds
   GenUnivAlg [#] the carrier of b1 = b1;

:: UNIALG_2:th 22
theorem
for b1 being non empty partial quasi_total non-empty UAStr
for b2 being strict SubAlgebra of b1
for b3 being non empty Element of bool the carrier of b1
      st b3 = the carrier of b2
   holds GenUnivAlg b3 = b2;

:: UNIALG_2:funcnot 8 => UNIALG_2:func 8
definition
  let a1 be non empty partial quasi_total non-empty UAStr;
  let a2, a3 be SubAlgebra of a1;
  func A2 "\/" A3 -> strict SubAlgebra of a1 means
    for b1 being non empty Element of bool the carrier of a1
          st b1 = (the carrier of a2) \/ the carrier of a3
       holds it = GenUnivAlg b1;
end;

:: UNIALG_2:def 14
theorem
for b1 being non empty partial quasi_total non-empty UAStr
for b2, b3 being SubAlgebra of b1
for b4 being strict SubAlgebra of b1 holds
      b4 = b2 "\/" b3
   iff
      for b5 being non empty Element of bool the carrier of b1
            st b5 = (the carrier of b2) \/ the carrier of b3
         holds b4 = GenUnivAlg b5;

:: UNIALG_2:th 23
theorem
for b1 being non empty partial quasi_total non-empty UAStr
for b2 being SubAlgebra of b1
for b3, b4 being Element of bool the carrier of b1
      st (b3 = {} implies Constants b1 <> {}) & b4 = b3 \/ the carrier of b2
   holds (GenUnivAlg b3) "\/" b2 = GenUnivAlg b4;

:: UNIALG_2:th 24
theorem
for b1 being non empty partial quasi_total non-empty UAStr
for b2, b3 being SubAlgebra of b1 holds
b2 "\/" b3 = b3 "\/" b2;

:: UNIALG_2:th 25
theorem
for b1 being non empty partial quasi_total non-empty with_const_op UAStr
for b2, b3 being strict SubAlgebra of b1 holds
b2 /\ (b2 "\/" b3) = b2;

:: UNIALG_2:th 26
theorem
for b1 being non empty partial quasi_total non-empty with_const_op UAStr
for b2, b3 being strict SubAlgebra of b1 holds
(b2 /\ b3) "\/" b3 = b3;

:: UNIALG_2:funcnot 9 => UNIALG_2:func 9
definition
  let a1 be non empty partial quasi_total non-empty UAStr;
  func Sub A1 -> set means
    for b1 being set holds
          b1 in it
       iff
          b1 is strict SubAlgebra of a1;
end;

:: UNIALG_2:def 15
theorem
for b1 being non empty partial quasi_total non-empty UAStr
for b2 being set holds
      b2 = Sub b1
   iff
      for b3 being set holds
            b3 in b2
         iff
            b3 is strict SubAlgebra of b1;

:: UNIALG_2:funcreg 2
registration
  let a1 be non empty partial quasi_total non-empty UAStr;
  cluster Sub a1 -> non empty;
end;

:: UNIALG_2:funcnot 10 => UNIALG_2:func 10
definition
  let a1 be non empty partial quasi_total non-empty UAStr;
  func UniAlg_join A1 -> Function-like quasi_total Relation of [:Sub a1,Sub a1:],Sub a1 means
    for b1, b2 being Element of Sub a1
    for b3, b4 being strict SubAlgebra of a1
          st b1 = b3 & b2 = b4
       holds it .(b1,b2) = b3 "\/" b4;
end;

:: UNIALG_2:def 16
theorem
for b1 being non empty partial quasi_total non-empty UAStr
for b2 being Function-like quasi_total Relation of [:Sub b1,Sub b1:],Sub b1 holds
      b2 = UniAlg_join b1
   iff
      for b3, b4 being Element of Sub b1
      for b5, b6 being strict SubAlgebra of b1
            st b3 = b5 & b4 = b6
         holds b2 .(b3,b4) = b5 "\/" b6;

:: UNIALG_2:funcnot 11 => UNIALG_2:func 11
definition
  let a1 be non empty partial quasi_total non-empty UAStr;
  func UniAlg_meet A1 -> Function-like quasi_total Relation of [:Sub a1,Sub a1:],Sub a1 means
    for b1, b2 being Element of Sub a1
    for b3, b4 being strict SubAlgebra of a1
          st b1 = b3 & b2 = b4
       holds it .(b1,b2) = b3 /\ b4;
end;

:: UNIALG_2:def 17
theorem
for b1 being non empty partial quasi_total non-empty UAStr
for b2 being Function-like quasi_total Relation of [:Sub b1,Sub b1:],Sub b1 holds
      b2 = UniAlg_meet b1
   iff
      for b3, b4 being Element of Sub b1
      for b5, b6 being strict SubAlgebra of b1
            st b3 = b5 & b4 = b6
         holds b2 .(b3,b4) = b5 /\ b6;

:: UNIALG_2:th 27
theorem
for b1 being non empty partial quasi_total non-empty UAStr holds
   UniAlg_join b1 is commutative(Sub b1);

:: UNIALG_2:th 28
theorem
for b1 being non empty partial quasi_total non-empty UAStr holds
   UniAlg_join b1 is associative(Sub b1);

:: UNIALG_2:th 29
theorem
for b1 being non empty partial quasi_total non-empty with_const_op UAStr holds
   UniAlg_meet b1 is commutative(Sub b1);

:: UNIALG_2:th 30
theorem
for b1 being non empty partial quasi_total non-empty with_const_op UAStr holds
   UniAlg_meet b1 is associative(Sub b1);

:: UNIALG_2:funcnot 12 => UNIALG_2:func 12
definition
  let a1 be non empty partial quasi_total non-empty with_const_op UAStr;
  func UnSubAlLattice A1 -> non empty strict Lattice-like LattStr equals
    LattStr(#Sub a1,UniAlg_join a1,UniAlg_meet a1#);
end;

:: UNIALG_2:def 18
theorem
for b1 being non empty partial quasi_total non-empty with_const_op UAStr holds
   UnSubAlLattice b1 = LattStr(#Sub b1,UniAlg_join b1,UniAlg_meet b1#);