Article LATTICE3, MML version 4.99.1005

:: LATTICE3:funcnot 1 => LATTICE3:func 1
definition
  let a1 be set;
  func BooleLatt A1 -> strict LattStr means
    the carrier of it = bool a1 &
     (for b1, b2 being Element of bool a1 holds
     (the L_join of it) .(b1,b2) = b1 \/ b2 & (the L_meet of it) .(b1,b2) = b1 /\ b2);
end;

:: LATTICE3:def 1
theorem
for b1 being set
for b2 being strict LattStr holds
      b2 = BooleLatt b1
   iff
      the carrier of b2 = bool b1 &
       (for b3, b4 being Element of bool b1 holds
       (the L_join of b2) .(b3,b4) = b3 \/ b4 & (the L_meet of b2) .(b3,b4) = b3 /\ b4);

:: LATTICE3:funcreg 1
registration
  let a1 be set;
  cluster BooleLatt a1 -> non empty strict;
end;

:: LATTICE3:th 1
theorem
for b1 being set
for b2, b3 being Element of the carrier of BooleLatt b1 holds
b2 "\/" b3 = b2 \/ b3 & b2 "/\" b3 = b2 /\ b3;

:: LATTICE3:th 2
theorem
for b1 being set
for b2, b3 being Element of the carrier of BooleLatt b1 holds
   b2 [= b3
iff
   b2 c= b3;

:: LATTICE3:funcreg 2
registration
  let a1 be set;
  cluster BooleLatt a1 -> strict Lattice-like;
end;

:: LATTICE3:th 3
theorem
for b1 being set holds
   BooleLatt b1 is lower-bounded & Bottom BooleLatt b1 = {};

:: LATTICE3:th 4
theorem
for b1 being set holds
   BooleLatt b1 is upper-bounded & Top BooleLatt b1 = b1;

:: LATTICE3:funcreg 3
registration
  let a1 be set;
  cluster BooleLatt a1 -> strict Boolean;
end;

:: LATTICE3:th 5
theorem
for b1 being set
for b2 being Element of the carrier of BooleLatt b1 holds
   b2 ` = b1 \ b2;

:: LATTICE3:funcnot 2 => LATTICE3:func 2
definition
  let a1 be non empty Lattice-like LattStr;
  redefine func LattRel a1 -> reflexive antisymmetric transitive total Relation of the carrier of a1,the carrier of a1;
end;

:: LATTICE3:funcnot 3 => LATTICE3:func 3
definition
  let a1 be non empty Lattice-like LattStr;
  func LattPOSet A1 -> strict reflexive transitive antisymmetric RelStr equals
    RelStr(#the carrier of a1,LattRel a1#);
end;

:: LATTICE3:def 2
theorem
for b1 being non empty Lattice-like LattStr holds
   LattPOSet b1 = RelStr(#the carrier of b1,LattRel b1#);

:: LATTICE3:funcreg 4
registration
  let a1 be non empty Lattice-like LattStr;
  cluster LattPOSet a1 -> non empty strict reflexive transitive antisymmetric;
end;

:: LATTICE3:th 6
theorem
for b1, b2 being non empty Lattice-like LattStr
      st LattPOSet b1 = LattPOSet b2
   holds LattStr(#the carrier of b1,the L_join of b1,the L_meet of b1#) = LattStr(#the carrier of b2,the L_join of b2,the L_meet of b2#);

:: LATTICE3:funcnot 4 => LATTICE3:func 4
definition
  let a1 be non empty Lattice-like LattStr;
  let a2 be Element of the carrier of a1;
  func A2 % -> Element of the carrier of LattPOSet a1 equals
    a2;
end;

:: LATTICE3:def 3
theorem
for b1 being non empty Lattice-like LattStr
for b2 being Element of the carrier of b1 holds
   b2 % = b2;

:: LATTICE3:funcnot 5 => LATTICE3:func 5
definition
  let a1 be non empty Lattice-like LattStr;
  let a2 be Element of the carrier of LattPOSet a1;
  func % A2 -> Element of the carrier of a1 equals
    a2;
end;

:: LATTICE3:def 4
theorem
for b1 being non empty Lattice-like LattStr
for b2 being Element of the carrier of LattPOSet b1 holds
   % b2 = b2;

:: LATTICE3:th 7
theorem
for b1 being non empty Lattice-like LattStr
for b2, b3 being Element of the carrier of b1 holds
   b2 [= b3
iff
   b2 % <= b3 %;

:: LATTICE3:funcnot 6 => LATTICE3:func 6
definition
  let a1 be set;
  let a2 be reflexive antisymmetric transitive total Relation of a1,a1;
  redefine func a2 ~ -> reflexive antisymmetric transitive total Relation of a1,a1;
  involutiveness;
::  for a1 being set
::  for a2 being reflexive antisymmetric transitive total Relation of a1,a1 holds
::     a2 ~ ~ = a2;
end;

:: LATTICE3:funcnot 7 => LATTICE3:func 7
definition
  let a1 be RelStr;
  func A1 ~ -> strict RelStr equals
    RelStr(#the carrier of a1,(the InternalRel of a1) ~#);
end;

:: LATTICE3:def 5
theorem
for b1 being RelStr holds
   b1 ~ = RelStr(#the carrier of b1,(the InternalRel of b1) ~#);

:: LATTICE3:funcreg 5
registration
  let a1 be reflexive transitive antisymmetric RelStr;
  cluster a1 ~ -> strict reflexive transitive antisymmetric;
end;

:: LATTICE3:funcreg 6
registration
  let a1 be non empty RelStr;
  cluster a1 ~ -> non empty strict;
end;

:: LATTICE3:th 8
theorem
for b1 being RelStr holds
   b1 ~ ~ = RelStr(#the carrier of b1,the InternalRel of b1#);

:: LATTICE3:funcnot 8 => LATTICE3:func 8
definition
  let a1 be RelStr;
  let a2 be Element of the carrier of a1;
  func A2 ~ -> Element of the carrier of a1 ~ equals
    a2;
end;

:: LATTICE3:def 6
theorem
for b1 being RelStr
for b2 being Element of the carrier of b1 holds
   b2 ~ = b2;

:: LATTICE3:funcnot 9 => LATTICE3:func 9
definition
  let a1 be RelStr;
  let a2 be Element of the carrier of a1 ~;
  func ~ A2 -> Element of the carrier of a1 equals
    a2;
end;

:: LATTICE3:def 7
theorem
for b1 being RelStr
for b2 being Element of the carrier of b1 ~ holds
   ~ b2 = b2;

:: LATTICE3:th 9
theorem
for b1 being RelStr
for b2, b3 being Element of the carrier of b1 holds
   b2 <= b3
iff
   b3 ~ <= b2 ~;

:: LATTICE3:prednot 1 => LATTICE3:pred 1
definition
  let a1 be RelStr;
  let a2 be set;
  let a3 be Element of the carrier of a1;
  pred A3 is_<=_than A2 means
    for b1 being Element of the carrier of a1
          st b1 in a2
       holds a3 <= b1;
end;

:: LATTICE3:dfs 8
definiens
  let a1 be RelStr;
  let a2 be set;
  let a3 be Element of the carrier of a1;
To prove
     a3 is_<=_than a2
it is sufficient to prove
  thus for b1 being Element of the carrier of a1
          st b1 in a2
       holds a3 <= b1;

:: LATTICE3:def 8
theorem
for b1 being RelStr
for b2 being set
for b3 being Element of the carrier of b1 holds
      b3 is_<=_than b2
   iff
      for b4 being Element of the carrier of b1
            st b4 in b2
         holds b3 <= b4;

:: LATTICE3:prednot 2 => LATTICE3:pred 2
definition
  let a1 be RelStr;
  let a2 be set;
  let a3 be Element of the carrier of a1;
  pred A2 is_<=_than A3 means
    for b1 being Element of the carrier of a1
          st b1 in a2
       holds b1 <= a3;
end;

:: LATTICE3:dfs 9
definiens
  let a1 be RelStr;
  let a2 be set;
  let a3 be Element of the carrier of a1;
To prove
     a2 is_<=_than a3
it is sufficient to prove
  thus for b1 being Element of the carrier of a1
          st b1 in a2
       holds b1 <= a3;

:: LATTICE3:def 9
theorem
for b1 being RelStr
for b2 being set
for b3 being Element of the carrier of b1 holds
      b2 is_<=_than b3
   iff
      for b4 being Element of the carrier of b1
            st b4 in b2
         holds b4 <= b3;

:: LATTICE3:prednot 3 => LATTICE3:pred 1
notation
  let a1 be RelStr;
  let a2 be set;
  let a3 be Element of the carrier of a1;
  synonym a2 is_>=_than a3 for a3 is_<=_than a2;
end;

:: LATTICE3:prednot 4 => LATTICE3:pred 2
notation
  let a1 be RelStr;
  let a2 be set;
  let a3 be Element of the carrier of a1;
  synonym a3 is_>=_than a2 for a2 is_<=_than a3;
end;

:: LATTICE3:attrnot 1 => LATTICE3:attr 1
definition
  let a1 be RelStr;
  attr a1 is with_suprema means
    for b1, b2 being Element of the carrier of a1 holds
    ex b3 being Element of the carrier of a1 st
       b1 <= b3 &
        b2 <= b3 &
        (for b4 being Element of the carrier of a1
              st b1 <= b4 & b2 <= b4
           holds b3 <= b4);
end;

:: LATTICE3:dfs 10
definiens
  let a1 be RelStr;
To prove
     a1 is with_suprema
it is sufficient to prove
  thus for b1, b2 being Element of the carrier of a1 holds
    ex b3 being Element of the carrier of a1 st
       b1 <= b3 &
        b2 <= b3 &
        (for b4 being Element of the carrier of a1
              st b1 <= b4 & b2 <= b4
           holds b3 <= b4);

:: LATTICE3:def 10
theorem
for b1 being RelStr holds
      b1 is with_suprema
   iff
      for b2, b3 being Element of the carrier of b1 holds
      ex b4 being Element of the carrier of b1 st
         b2 <= b4 &
          b3 <= b4 &
          (for b5 being Element of the carrier of b1
                st b2 <= b5 & b3 <= b5
             holds b4 <= b5);

:: LATTICE3:attrnot 2 => LATTICE3:attr 2
definition
  let a1 be RelStr;
  attr a1 is with_infima means
    for b1, b2 being Element of the carrier of a1 holds
    ex b3 being Element of the carrier of a1 st
       b3 <= b1 &
        b3 <= b2 &
        (for b4 being Element of the carrier of a1
              st b4 <= b1 & b4 <= b2
           holds b4 <= b3);
end;

:: LATTICE3:dfs 11
definiens
  let a1 be RelStr;
To prove
     a1 is with_infima
it is sufficient to prove
  thus for b1, b2 being Element of the carrier of a1 holds
    ex b3 being Element of the carrier of a1 st
       b3 <= b1 &
        b3 <= b2 &
        (for b4 being Element of the carrier of a1
              st b4 <= b1 & b4 <= b2
           holds b4 <= b3);

:: LATTICE3:def 11
theorem
for b1 being RelStr holds
      b1 is with_infima
   iff
      for b2, b3 being Element of the carrier of b1 holds
      ex b4 being Element of the carrier of b1 st
         b4 <= b2 &
          b4 <= b3 &
          (for b5 being Element of the carrier of b1
                st b5 <= b2 & b5 <= b3
             holds b5 <= b4);

:: LATTICE3:condreg 1
registration
  cluster with_suprema -> non empty (RelStr);
end;

:: LATTICE3:condreg 2
registration
  cluster with_infima -> non empty (RelStr);
end;

:: LATTICE3:th 10
theorem
for b1 being RelStr holds
      b1 is with_suprema
   iff
      b1 ~ is with_infima;

:: LATTICE3:th 11
theorem
for b1 being non empty Lattice-like LattStr holds
   LattPOSet b1 is with_suprema & LattPOSet b1 is with_infima;

:: LATTICE3:attrnot 3 => LATTICE3:attr 3
definition
  let a1 be RelStr;
  attr a1 is complete means
    for b1 being set holds
       ex b2 being Element of the carrier of a1 st
          b1 is_<=_than b2 &
           (for b3 being Element of the carrier of a1
                 st b1 is_<=_than b3
              holds b2 <= b3);
end;

:: LATTICE3:dfs 12
definiens
  let a1 be RelStr;
To prove
     a1 is complete
it is sufficient to prove
  thus for b1 being set holds
       ex b2 being Element of the carrier of a1 st
          b1 is_<=_than b2 &
           (for b3 being Element of the carrier of a1
                 st b1 is_<=_than b3
              holds b2 <= b3);

:: LATTICE3:def 12
theorem
for b1 being RelStr holds
      b1 is complete
   iff
      for b2 being set holds
         ex b3 being Element of the carrier of b1 st
            b2 is_<=_than b3 &
             (for b4 being Element of the carrier of b1
                   st b2 is_<=_than b4
                holds b3 <= b4);

:: LATTICE3:exreg 1
registration
  cluster non empty strict total reflexive transitive antisymmetric complete RelStr;
end;

:: LATTICE3:th 12
theorem
for b1 being non empty RelStr
      st b1 is complete
   holds b1 is with_suprema & b1 is with_infima;

:: LATTICE3:exreg 2
registration
  cluster non empty strict total reflexive transitive antisymmetric with_suprema with_infima complete RelStr;
end;

:: LATTICE3:funcnot 10 => LATTICE3:func 10
definition
  let a1 be RelStr;
  let a2, a3 be Element of the carrier of a1;
  assume a1 is antisymmetric &
     (ex b1 being Element of the carrier of a1 st
        a2 <= b1 &
         a3 <= b1 &
         (for b2 being Element of the carrier of a1
               st a2 <= b2 & a3 <= b2
            holds b1 <= b2));
  func A2 "\/" A3 -> Element of the carrier of a1 means
    a2 <= it &
     a3 <= it &
     (for b1 being Element of the carrier of a1
           st a2 <= b1 & a3 <= b1
        holds it <= b1);
end;

:: LATTICE3:def 13
theorem
for b1 being RelStr
   st b1 is antisymmetric
for b2, b3 being Element of the carrier of b1
   st ex b4 being Element of the carrier of b1 st
        b2 <= b4 &
         b3 <= b4 &
         (for b5 being Element of the carrier of b1
               st b2 <= b5 & b3 <= b5
            holds b4 <= b5)
for b4 being Element of the carrier of b1 holds
      b4 = b2 "\/" b3
   iff
      b2 <= b4 &
       b3 <= b4 &
       (for b5 being Element of the carrier of b1
             st b2 <= b5 & b3 <= b5
          holds b4 <= b5);

:: LATTICE3:funcnot 11 => LATTICE3:func 11
definition
  let a1 be RelStr;
  let a2, a3 be Element of the carrier of a1;
  assume a1 is antisymmetric &
     (ex b1 being Element of the carrier of a1 st
        b1 <= a2 &
         b1 <= a3 &
         (for b2 being Element of the carrier of a1
               st b2 <= a2 & b2 <= a3
            holds b2 <= b1));
  func A2 "/\" A3 -> Element of the carrier of a1 means
    it <= a2 &
     it <= a3 &
     (for b1 being Element of the carrier of a1
           st b1 <= a2 & b1 <= a3
        holds b1 <= it);
end;

:: LATTICE3:def 14
theorem
for b1 being RelStr
   st b1 is antisymmetric
for b2, b3 being Element of the carrier of b1
   st ex b4 being Element of the carrier of b1 st
        b4 <= b2 &
         b4 <= b3 &
         (for b5 being Element of the carrier of b1
               st b5 <= b2 & b5 <= b3
            holds b5 <= b4)
for b4 being Element of the carrier of b1 holds
      b4 = b2 "/\" b3
   iff
      b4 <= b2 &
       b4 <= b3 &
       (for b5 being Element of the carrier of b1
             st b5 <= b2 & b5 <= b3
          holds b5 <= b4);

:: LATTICE3:th 13
theorem
for b1 being antisymmetric with_suprema RelStr
for b2, b3 being Element of the carrier of b1 holds
b2 "\/" b3 = b3 "\/" b2;

:: LATTICE3:th 14
theorem
for b1 being antisymmetric with_suprema RelStr
for b2, b3, b4 being Element of the carrier of b1
      st b1 is transitive
   holds (b2 "\/" b3) "\/" b4 = b2 "\/" (b3 "\/" b4);

:: LATTICE3:th 15
theorem
for b1 being antisymmetric with_infima RelStr
for b2, b3 being Element of the carrier of b1 holds
b2 "/\" b3 = b3 "/\" b2;

:: LATTICE3:th 16
theorem
for b1 being antisymmetric with_infima RelStr
for b2, b3, b4 being Element of the carrier of b1
      st b1 is transitive
   holds (b2 "/\" b3) "/\" b4 = b2 "/\" (b3 "/\" b4);

:: LATTICE3:funcnot 12 => LATTICE3:func 12
definition
  let a1 be antisymmetric with_infima RelStr;
  let a2, a3 be Element of the carrier of a1;
  redefine func a2 "/\" a3 -> Element of the carrier of a1;
  commutativity;
::  for a1 being antisymmetric with_infima RelStr
::  for a2, a3 being Element of the carrier of a1 holds
::  a2 "/\" a3 = a3 "/\" a2;
end;

:: LATTICE3:funcnot 13 => LATTICE3:func 13
definition
  let a1 be antisymmetric with_suprema RelStr;
  let a2, a3 be Element of the carrier of a1;
  redefine func a2 "\/" a3 -> Element of the carrier of a1;
  commutativity;
::  for a1 being antisymmetric with_suprema RelStr
::  for a2, a3 being Element of the carrier of a1 holds
::  a2 "\/" a3 = a3 "\/" a2;
end;

:: LATTICE3:th 17
theorem
for b1 being reflexive antisymmetric with_suprema with_infima RelStr
for b2, b3 being Element of the carrier of b1 holds
(b2 "/\" b3) "\/" b3 = b3;

:: LATTICE3:th 18
theorem
for b1 being reflexive antisymmetric with_suprema with_infima RelStr
for b2, b3 being Element of the carrier of b1 holds
b2 "/\" (b2 "\/" b3) = b2;

:: LATTICE3:th 19
theorem
for b1 being reflexive transitive antisymmetric with_suprema with_infima RelStr holds
   ex b2 being non empty strict Lattice-like LattStr st
      RelStr(#the carrier of b1,the InternalRel of b1#) = LattPOSet b2;

:: LATTICE3:funcnot 14 => LATTICE3:func 14
definition
  let a1 be RelStr;
  assume a1 is reflexive transitive antisymmetric with_suprema with_infima RelStr;
  func latt A1 -> non empty strict Lattice-like LattStr means
    RelStr(#the carrier of a1,the InternalRel of a1#) = LattPOSet it;
end;

:: LATTICE3:def 15
theorem
for b1 being RelStr
   st b1 is reflexive transitive antisymmetric with_suprema with_infima RelStr
for b2 being non empty strict Lattice-like LattStr holds
      b2 = latt b1
   iff
      RelStr(#the carrier of b1,the InternalRel of b1#) = LattPOSet b2;

:: LATTICE3:th 20
theorem
for b1 being non empty Lattice-like LattStr holds
   (LattRel b1) ~ = LattRel (b1 .:) & (LattPOSet b1) ~ = LattPOSet (b1 .:);

:: LATTICE3:prednot 5 => LATTICE3:pred 3
definition
  let a1 be non empty LattStr;
  let a2 be Element of the carrier of a1;
  let a3 be set;
  pred A2 is_less_than A3 means
    for b1 being Element of the carrier of a1
          st b1 in a3
       holds a2 [= b1;
end;

:: LATTICE3:dfs 16
definiens
  let a1 be non empty LattStr;
  let a2 be Element of the carrier of a1;
  let a3 be set;
To prove
     a2 is_less_than a3
it is sufficient to prove
  thus for b1 being Element of the carrier of a1
          st b1 in a3
       holds a2 [= b1;

:: LATTICE3:def 16
theorem
for b1 being non empty LattStr
for b2 being Element of the carrier of b1
for b3 being set holds
      b2 is_less_than b3
   iff
      for b4 being Element of the carrier of b1
            st b4 in b3
         holds b2 [= b4;

:: LATTICE3:prednot 6 => LATTICE3:pred 4
definition
  let a1 be non empty LattStr;
  let a2 be Element of the carrier of a1;
  let a3 be set;
  pred A3 is_less_than A2 means
    for b1 being Element of the carrier of a1
          st b1 in a3
       holds b1 [= a2;
end;

:: LATTICE3:dfs 17
definiens
  let a1 be non empty LattStr;
  let a2 be Element of the carrier of a1;
  let a3 be set;
To prove
     a3 is_less_than a2
it is sufficient to prove
  thus for b1 being Element of the carrier of a1
          st b1 in a3
       holds b1 [= a2;

:: LATTICE3:def 17
theorem
for b1 being non empty LattStr
for b2 being Element of the carrier of b1
for b3 being set holds
      b3 is_less_than b2
   iff
      for b4 being Element of the carrier of b1
            st b4 in b3
         holds b4 [= b2;

:: LATTICE3:prednot 7 => LATTICE3:pred 3
notation
  let a1 be non empty LattStr;
  let a2 be Element of the carrier of a1;
  let a3 be set;
  synonym a3 is_greater_than a2 for a2 is_less_than a3;
end;

:: LATTICE3:prednot 8 => LATTICE3:pred 4
notation
  let a1 be non empty LattStr;
  let a2 be Element of the carrier of a1;
  let a3 be set;
  synonym a2 is_greater_than a3 for a3 is_less_than a2;
end;

:: LATTICE3:th 21
theorem
for b1 being non empty Lattice-like LattStr
for b2, b3, b4 being Element of the carrier of b1 holds
   b2 is_less_than {b3,b4}
iff
   b2 [= b3 "/\" b4;

:: LATTICE3:th 22
theorem
for b1 being non empty Lattice-like LattStr
for b2, b3, b4 being Element of the carrier of b1 holds
   {b3,b4} is_less_than b2
iff
   b3 "\/" b4 [= b2;

:: LATTICE3:attrnot 4 => LATTICE3:attr 4
definition
  let a1 be non empty LattStr;
  attr a1 is complete means
    for b1 being set holds
       ex b2 being Element of the carrier of a1 st
          b1 is_less_than b2 &
           (for b3 being Element of the carrier of a1
                 st b1 is_less_than b3
              holds b2 [= b3);
end;

:: LATTICE3:dfs 18
definiens
  let a1 be non empty LattStr;
To prove
     a1 is complete
it is sufficient to prove
  thus for b1 being set holds
       ex b2 being Element of the carrier of a1 st
          b1 is_less_than b2 &
           (for b3 being Element of the carrier of a1
                 st b1 is_less_than b3
              holds b2 [= b3);

:: LATTICE3:def 18
theorem
for b1 being non empty LattStr holds
      b1 is complete
   iff
      for b2 being set holds
         ex b3 being Element of the carrier of b1 st
            b2 is_less_than b3 &
             (for b4 being Element of the carrier of b1
                   st b2 is_less_than b4
                holds b3 [= b4);

:: LATTICE3:attrnot 5 => LATTICE3:attr 5
definition
  let a1 be non empty LattStr;
  attr a1 is \/-distributive means
    for b1 being set
    for b2, b3, b4 being Element of the carrier of a1
          st b1 is_less_than b2 &
             (for b5 being Element of the carrier of a1
                   st b1 is_less_than b5
                holds b2 [= b5) &
             {b3 "/\" b5 where b5 is Element of the carrier of a1: b5 in b1} is_less_than b4 &
             (for b5 being Element of the carrier of a1
                   st {b3 "/\" b6 where b6 is Element of the carrier of a1: b6 in b1} is_less_than b5
                holds b4 [= b5)
       holds b3 "/\" b2 [= b4;
end;

:: LATTICE3:dfs 19
definiens
  let a1 be non empty LattStr;
To prove
     a1 is \/-distributive
it is sufficient to prove
  thus for b1 being set
    for b2, b3, b4 being Element of the carrier of a1
          st b1 is_less_than b2 &
             (for b5 being Element of the carrier of a1
                   st b1 is_less_than b5
                holds b2 [= b5) &
             {b3 "/\" b5 where b5 is Element of the carrier of a1: b5 in b1} is_less_than b4 &
             (for b5 being Element of the carrier of a1
                   st {b3 "/\" b6 where b6 is Element of the carrier of a1: b6 in b1} is_less_than b5
                holds b4 [= b5)
       holds b3 "/\" b2 [= b4;

:: LATTICE3:def 19
theorem
for b1 being non empty LattStr holds
      b1 is \/-distributive
   iff
      for b2 being set
      for b3, b4, b5 being Element of the carrier of b1
            st b2 is_less_than b3 &
               (for b6 being Element of the carrier of b1
                     st b2 is_less_than b6
                  holds b3 [= b6) &
               {b4 "/\" b6 where b6 is Element of the carrier of b1: b6 in b2} is_less_than b5 &
               (for b6 being Element of the carrier of b1
                     st {b4 "/\" b7 where b7 is Element of the carrier of b1: b7 in b2} is_less_than b6
                  holds b5 [= b6)
         holds b4 "/\" b3 [= b5;

:: LATTICE3:attrnot 6 => LATTICE3:attr 6
definition
  let a1 be non empty LattStr;
  attr a1 is /\-distributive means
    for b1 being set
    for b2, b3, b4 being Element of the carrier of a1
          st b2 is_less_than b1 &
             (for b5 being Element of the carrier of a1
                   st b5 is_less_than b1
                holds b5 [= b2) &
             b4 is_less_than {b3 "\/" b5 where b5 is Element of the carrier of a1: b5 in b1} &
             (for b5 being Element of the carrier of a1
                   st b5 is_less_than {b3 "\/" b6 where b6 is Element of the carrier of a1: b6 in b1}
                holds b5 [= b4)
       holds b4 [= b3 "\/" b2;
end;

:: LATTICE3:dfs 20
definiens
  let a1 be non empty LattStr;
To prove
     a1 is /\-distributive
it is sufficient to prove
  thus for b1 being set
    for b2, b3, b4 being Element of the carrier of a1
          st b2 is_less_than b1 &
             (for b5 being Element of the carrier of a1
                   st b5 is_less_than b1
                holds b5 [= b2) &
             b4 is_less_than {b3 "\/" b5 where b5 is Element of the carrier of a1: b5 in b1} &
             (for b5 being Element of the carrier of a1
                   st b5 is_less_than {b3 "\/" b6 where b6 is Element of the carrier of a1: b6 in b1}
                holds b5 [= b4)
       holds b4 [= b3 "\/" b2;

:: LATTICE3:def 20
theorem
for b1 being non empty LattStr holds
      b1 is /\-distributive
   iff
      for b2 being set
      for b3, b4, b5 being Element of the carrier of b1
            st b3 is_less_than b2 &
               (for b6 being Element of the carrier of b1
                     st b6 is_less_than b2
                  holds b6 [= b3) &
               b5 is_less_than {b4 "\/" b6 where b6 is Element of the carrier of b1: b6 in b2} &
               (for b6 being Element of the carrier of b1
                     st b6 is_less_than {b4 "\/" b7 where b7 is Element of the carrier of b1: b7 in b2}
                  holds b6 [= b5)
         holds b5 [= b4 "\/" b3;

:: LATTICE3:th 23
theorem
for b1 being set
for b2 being non empty Lattice-like Boolean LattStr
for b3 being Element of the carrier of b2 holds
      b1 is_less_than b3
   iff
      b3 ` is_less_than {b4 ` where b4 is Element of the carrier of b2: b4 in b1};

:: LATTICE3:th 24
theorem
for b1 being set
for b2 being non empty Lattice-like Boolean LattStr
for b3 being Element of the carrier of b2 holds
      b3 is_less_than b1
   iff
      {b4 ` where b4 is Element of the carrier of b2: b4 in b1} is_less_than b3 `;

:: LATTICE3:th 25
theorem
for b1 being set holds
   BooleLatt b1 is complete;

:: LATTICE3:funcreg 7
registration
  let a1 be set;
  cluster BooleLatt a1 -> strict complete;
end;

:: LATTICE3:th 26
theorem
for b1 being set holds
   BooleLatt b1 is \/-distributive;

:: LATTICE3:th 27
theorem
for b1 being set holds
   BooleLatt b1 is /\-distributive;

:: LATTICE3:exreg 3
registration
  cluster non empty strict join-commutative join-associative meet-commutative meet-associative meet-absorbing join-absorbing Lattice-like complete \/-distributive /\-distributive LattStr;
end;

:: LATTICE3:th 28
theorem
for b1 being set
for b2 being non empty Lattice-like LattStr
for b3 being Element of the carrier of b2 holds
      b3 is_less_than b1
   iff
      b3 % is_<=_than b1;

:: LATTICE3:th 29
theorem
for b1 being set
for b2 being non empty Lattice-like LattStr
for b3 being Element of the carrier of LattPOSet b2 holds
      b3 is_<=_than b1
   iff
      % b3 is_less_than b1;

:: LATTICE3:th 30
theorem
for b1 being set
for b2 being non empty Lattice-like LattStr
for b3 being Element of the carrier of b2 holds
      b1 is_less_than b3
   iff
      b1 is_<=_than b3 %;

:: LATTICE3:th 31
theorem
for b1 being set
for b2 being non empty Lattice-like LattStr
for b3 being Element of the carrier of LattPOSet b2 holds
      b1 is_<=_than b3
   iff
      b1 is_less_than % b3;

:: LATTICE3:funcreg 8
registration
  let a1 be non empty reflexive transitive antisymmetric complete RelStr;
  cluster latt a1 -> non empty strict Lattice-like complete;
end;

:: LATTICE3:funcnot 15 => LATTICE3:func 15
definition
  let a1 be non empty LattStr;
  let a2 be set;
  assume a1 is non empty Lattice-like complete LattStr;
  func "\/"(A2,A1) -> Element of the carrier of a1 means
    a2 is_less_than it &
     (for b1 being Element of the carrier of a1
           st a2 is_less_than b1
        holds it [= b1);
end;

:: LATTICE3:def 21
theorem
for b1 being non empty LattStr
   st b1 is non empty Lattice-like complete LattStr
for b2 being set
for b3 being Element of the carrier of b1 holds
      b3 = "\/"(b2,b1)
   iff
      b2 is_less_than b3 &
       (for b4 being Element of the carrier of b1
             st b2 is_less_than b4
          holds b3 [= b4);

:: LATTICE3:funcnot 16 => LATTICE3:func 16
definition
  let a1 be non empty LattStr;
  let a2 be set;
  func "/\"(A2,A1) -> Element of the carrier of a1 equals
    "\/"({b1 where b1 is Element of the carrier of a1: b1 is_less_than a2},a1);
end;

:: LATTICE3:def 22
theorem
for b1 being non empty LattStr
for b2 being set holds
   "/\"(b2,b1) = "\/"({b3 where b3 is Element of the carrier of b1: b3 is_less_than b2},b1);

:: LATTICE3:funcnot 17 => LATTICE3:func 15
notation
  let a1 be non empty LattStr;
  let a2 be Element of bool the carrier of a1;
  synonym "\/" a2 for "\/"(a2,a1);
end;

:: LATTICE3:funcnot 18 => LATTICE3:func 16
notation
  let a1 be non empty LattStr;
  let a2 be Element of bool the carrier of a1;
  synonym "/\" a2 for "/\"(a2,a1);
end;

:: LATTICE3:th 32
theorem
for b1 being non empty Lattice-like complete LattStr
for b2 being Element of the carrier of b1
for b3 being set holds
   "\/"({b2 "/\" b4 where b4 is Element of the carrier of b1: b4 in b3},b1) [= b2 "/\" "\/"(b3,b1);

:: LATTICE3:th 33
theorem
for b1 being non empty Lattice-like complete LattStr holds
      b1 is \/-distributive
   iff
      for b2 being set
      for b3 being Element of the carrier of b1 holds
         b3 "/\" "\/"(b2,b1) [= "\/"({b3 "/\" b4 where b4 is Element of the carrier of b1: b4 in b2},b1);

:: LATTICE3:th 34
theorem
for b1 being non empty Lattice-like complete LattStr
for b2 being Element of the carrier of b1
for b3 being set holds
      b2 = "/\"(b3,b1)
   iff
      b2 is_less_than b3 &
       (for b4 being Element of the carrier of b1
             st b4 is_less_than b3
          holds b4 [= b2);

:: LATTICE3:th 35
theorem
for b1 being non empty Lattice-like complete LattStr
for b2 being Element of the carrier of b1
for b3 being set holds
   b2 "\/" "/\"(b3,b1) [= "/\"({b2 "\/" b4 where b4 is Element of the carrier of b1: b4 in b3},b1);

:: LATTICE3:th 36
theorem
for b1 being non empty Lattice-like complete LattStr holds
      b1 is /\-distributive
   iff
      for b2 being set
      for b3 being Element of the carrier of b1 holds
         "/\"({b3 "\/" b4 where b4 is Element of the carrier of b1: b4 in b2},b1) [= b3 "\/" "/\"(b2,b1);

:: LATTICE3:th 37
theorem
for b1 being non empty Lattice-like complete LattStr
for b2 being set holds
   "\/"(b2,b1) = "/\"({b3 where b3 is Element of the carrier of b1: b2 is_less_than b3},b1);

:: LATTICE3:th 38
theorem
for b1 being non empty Lattice-like complete LattStr
for b2 being Element of the carrier of b1
for b3 being set
      st b2 in b3
   holds b2 [= "\/"(b3,b1) & "/\"(b3,b1) [= b2;

:: LATTICE3:th 40
theorem
for b1 being non empty Lattice-like complete LattStr
for b2 being Element of the carrier of b1
for b3 being set
      st b2 is_less_than b3
   holds b2 [= "/\"(b3,b1);

:: LATTICE3:th 41
theorem
for b1 being non empty Lattice-like complete LattStr
for b2 being Element of the carrier of b1
for b3 being set
      st b2 in b3 & b3 is_less_than b2
   holds "\/"(b3,b1) = b2;

:: LATTICE3:th 42
theorem
for b1 being non empty Lattice-like complete LattStr
for b2 being Element of the carrier of b1
for b3 being set
      st b2 in b3 & b2 is_less_than b3
   holds "/\"(b3,b1) = b2;

:: LATTICE3:th 43
theorem
for b1 being non empty Lattice-like complete LattStr
for b2 being Element of the carrier of b1 holds
   "\/"({b2},b1) = b2 & "/\"({b2},b1) = b2;

:: LATTICE3:th 44
theorem
for b1 being non empty Lattice-like complete LattStr
for b2, b3 being Element of the carrier of b1 holds
b2 "\/" b3 = "\/"({b2,b3},b1) &
 b2 "/\" b3 = "/\"({b2,b3},b1);

:: LATTICE3:th 45
theorem
for b1 being non empty Lattice-like complete LattStr
for b2 being Element of the carrier of b1 holds
   b2 = "\/"({b3 where b3 is Element of the carrier of b1: b3 [= b2},b1) &
    b2 = "/\"({b3 where b3 is Element of the carrier of b1: b2 [= b3},b1);

:: LATTICE3:th 46
theorem
for b1 being non empty Lattice-like complete LattStr
for b2, b3 being set
      st b2 c= b3
   holds "\/"(b2,b1) [= "\/"(b3,b1) & "/\"(b3,b1) [= "/\"(b2,b1);

:: LATTICE3:th 47
theorem
for b1 being non empty Lattice-like complete LattStr
for b2 being set holds
   "\/"(b2,b1) = "\/"({b3 where b3 is Element of the carrier of b1: ex b4 being Element of the carrier of b1 st
       b3 [= b4 & b4 in b2},b1) &
    "/\"(b2,b1) = "/\"({b3 where b3 is Element of the carrier of b1: ex b4 being Element of the carrier of b1 st
       b4 [= b3 & b4 in b2},b1);

:: LATTICE3:th 48
theorem
for b1 being non empty Lattice-like complete LattStr
for b2, b3 being set
      st for b4 being Element of the carrier of b1
              st b4 in b2
           holds ex b5 being Element of the carrier of b1 st
              b4 [= b5 & b5 in b3
   holds "\/"(b2,b1) [= "\/"(b3,b1);

:: LATTICE3:th 49
theorem
for b1 being non empty Lattice-like complete LattStr
for b2 being set
      st b2 c= bool the carrier of b1
   holds "\/"(union b2,b1) = "\/"({"\/"(b3,b1) where b3 is Element of bool the carrier of b1: b3 in b2},b1);

:: LATTICE3:th 50
theorem
for b1 being non empty Lattice-like complete LattStr holds
   b1 is non empty Lattice-like lower-bounded LattStr & Bottom b1 = "\/"({},b1);

:: LATTICE3:th 51
theorem
for b1 being non empty Lattice-like complete LattStr holds
   b1 is non empty Lattice-like upper-bounded LattStr & Top b1 = "\/"(the carrier of b1,b1);

:: LATTICE3:th 52
theorem
for b1 being non empty Lattice-like complete LattStr
for b2, b3 being Element of the carrier of b1
      st b1 is non empty Lattice-like implicative LattStr
   holds b2 => b3 = "\/"({b4 where b4 is Element of the carrier of b1: b2 "/\" b4 [= b3},b1);

:: LATTICE3:th 53
theorem
for b1 being non empty Lattice-like complete LattStr
      st b1 is non empty Lattice-like implicative LattStr
   holds b1 is \/-distributive;

:: LATTICE3:th 54
theorem
for b1 being set
for b2 being non empty Lattice-like complete \/-distributive LattStr
for b3 being Element of the carrier of b2 holds
   b3 "/\" "\/"(b1,b2) = "\/"({b3 "/\" b4 where b4 is Element of the carrier of b2: b4 in b1},b2) &
    ("\/"(b1,b2)) "/\" b3 = "\/"({b4 "/\" b3 where b4 is Element of the carrier of b2: b4 in b1},b2);

:: LATTICE3:th 55
theorem
for b1 being set
for b2 being non empty Lattice-like complete /\-distributive LattStr
for b3 being Element of the carrier of b2 holds
   b3 "\/" "/\"(b1,b2) = "/\"({b3 "\/" b4 where b4 is Element of the carrier of b2: b4 in b1},b2) &
    ("/\"(b1,b2)) "\/" b3 = "/\"({b4 "\/" b3 where b4 is Element of the carrier of b2: b4 in b1},b2);

:: LATTICE3:sch 1
scheme LATTICE3:sch 1
{F1 -> set,
  F2 -> non empty set}:
{F1() where b1 is Element of F2(): P1[b1]} = {F1()}
provided
   ex b1 being Element of F2() st
      P1[b1];


:: LATTICE3:sch 2
scheme LATTICE3:sch 2
{F1 -> non empty set,
  F2 -> non empty set,
  F3 -> Element of F2(),
  F4 -> Relation-like Function-like set}:
F4() .: {F3(b1) where b1 is Element of F1(): P1[b1]} = {F4() . F3(b1) where b1 is Element of F1(): P1[b1]}
provided
   F2() c= proj1 F4();


:: LATTICE3:th 56
theorem
for b1 being non empty set
for b2 being Function-like quasi_total Relation of bool b1,b1
      st (for b3 being Element of b1 holds
            b2 . {b3} = b3) &
         (for b3 being Element of bool bool b1 holds
            b2 . (b2 .: b3) = b2 . union b3)
   holds ex b3 being non empty strict Lattice-like complete LattStr st
      the carrier of b3 = b1 &
       (for b4 being Element of bool the carrier of b3 holds
          "\/"(b4,b3) = b2 . b4);