Article LATTICES, MML version 4.99.1005

:: LATTICES:structnot 1 => LATTICES:struct 1
definition
  struct(1-sorted) /\-SemiLattStr(#
    carrier -> set,
    L_meet -> Function-like quasi_total Relation of [:the carrier of it,the carrier of it:],the carrier of it
  #);
end;

:: LATTICES:attrnot 1 => LATTICES:attr 1
definition
  let a1 be /\-SemiLattStr;
  attr a1 is strict;
end;

:: LATTICES:exreg 1
registration
  cluster strict /\-SemiLattStr;
end;

:: LATTICES:aggrnot 1 => LATTICES:aggr 1
definition
  let a1 be set;
  let a2 be Function-like quasi_total Relation of [:a1,a1:],a1;
  aggr /\-SemiLattStr(#a1,a2#) -> strict /\-SemiLattStr;
end;

:: LATTICES:selnot 1 => LATTICES:sel 1
definition
  let a1 be /\-SemiLattStr;
  sel the L_meet of a1 -> Function-like quasi_total Relation of [:the carrier of a1,the carrier of a1:],the carrier of a1;
end;

:: LATTICES:structnot 2 => LATTICES:struct 2
definition
  struct(1-sorted) \/-SemiLattStr(#
    carrier -> set,
    L_join -> Function-like quasi_total Relation of [:the carrier of it,the carrier of it:],the carrier of it
  #);
end;

:: LATTICES:attrnot 2 => LATTICES:attr 2
definition
  let a1 be \/-SemiLattStr;
  attr a1 is strict;
end;

:: LATTICES:exreg 2
registration
  cluster strict \/-SemiLattStr;
end;

:: LATTICES:aggrnot 2 => LATTICES:aggr 2
definition
  let a1 be set;
  let a2 be Function-like quasi_total Relation of [:a1,a1:],a1;
  aggr \/-SemiLattStr(#a1,a2#) -> strict \/-SemiLattStr;
end;

:: LATTICES:selnot 2 => LATTICES:sel 2
definition
  let a1 be \/-SemiLattStr;
  sel the L_join of a1 -> Function-like quasi_total Relation of [:the carrier of a1,the carrier of a1:],the carrier of a1;
end;

:: LATTICES:structnot 3 => LATTICES:struct 3
definition
  struct(/\-SemiLattStr\/-SemiLattStr) LattStr(#
    carrier -> set,
    L_join -> Function-like quasi_total Relation of [:the carrier of it,the carrier of it:],the carrier of it,
    L_meet -> Function-like quasi_total Relation of [:the carrier of it,the carrier of it:],the carrier of it
  #);
end;

:: LATTICES:attrnot 3 => LATTICES:attr 3
definition
  let a1 be LattStr;
  attr a1 is strict;
end;

:: LATTICES:exreg 3
registration
  cluster strict LattStr;
end;

:: LATTICES:aggrnot 3 => LATTICES:aggr 3
definition
  let a1 be set;
  let a2, a3 be Function-like quasi_total Relation of [:a1,a1:],a1;
  aggr LattStr(#a1,a2,a3#) -> strict LattStr;
end;

:: LATTICES:funcreg 1
registration
  let a1 be non empty set;
  let a2 be Function-like quasi_total Relation of [:a1,a1:],a1;
  cluster \/-SemiLattStr(#a1,a2#) -> non empty strict;
end;

:: LATTICES:funcreg 2
registration
  let a1 be non empty set;
  let a2 be Function-like quasi_total Relation of [:a1,a1:],a1;
  cluster /\-SemiLattStr(#a1,a2#) -> non empty strict;
end;

:: LATTICES:funcreg 3
registration
  let a1 be non empty set;
  let a2, a3 be Function-like quasi_total Relation of [:a1,a1:],a1;
  cluster LattStr(#a1,a2,a3#) -> non empty strict;
end;

:: LATTICES:exreg 4
registration
  cluster non empty strict \/-SemiLattStr;
end;

:: LATTICES:exreg 5
registration
  cluster non empty strict /\-SemiLattStr;
end;

:: LATTICES:exreg 6
registration
  cluster non empty strict LattStr;
end;

:: LATTICES:funcnot 1 => LATTICES:func 1
definition
  let a1 be non empty \/-SemiLattStr;
  let a2, a3 be Element of the carrier of a1;
  func A2 "\/" A3 -> Element of the carrier of a1 equals
    (the L_join of a1) .(a2,a3);
end;

:: LATTICES:def 1
theorem
for b1 being non empty \/-SemiLattStr
for b2, b3 being Element of the carrier of b1 holds
b2 "\/" b3 = (the L_join of b1) .(b2,b3);

:: LATTICES:funcnot 2 => LATTICES:func 2
definition
  let a1 be non empty /\-SemiLattStr;
  let a2, a3 be Element of the carrier of a1;
  func A2 "/\" A3 -> Element of the carrier of a1 equals
    (the L_meet of a1) .(a2,a3);
end;

:: LATTICES:def 2
theorem
for b1 being non empty /\-SemiLattStr
for b2, b3 being Element of the carrier of b1 holds
b2 "/\" b3 = (the L_meet of b1) .(b2,b3);

:: LATTICES:prednot 1 => LATTICES:pred 1
definition
  let a1 be non empty \/-SemiLattStr;
  let a2, a3 be Element of the carrier of a1;
  pred A2 [= A3 means
    a2 "\/" a3 = a3;
end;

:: LATTICES:dfs 3
definiens
  let a1 be non empty \/-SemiLattStr;
  let a2, a3 be Element of the carrier of a1;
To prove
     a2 [= a3
it is sufficient to prove
  thus a2 "\/" a3 = a3;

:: LATTICES:def 3
theorem
for b1 being non empty \/-SemiLattStr
for b2, b3 being Element of the carrier of b1 holds
   b2 [= b3
iff
   b2 "\/" b3 = b3;

:: LATTICES:attrnot 4 => LATTICES:attr 4
definition
  let a1 be non empty \/-SemiLattStr;
  attr a1 is join-commutative means
    for b1, b2 being Element of the carrier of a1 holds
    b1 "\/" b2 = b2 "\/" b1;
end;

:: LATTICES:dfs 4
definiens
  let a1 be non empty \/-SemiLattStr;
To prove
     a1 is join-commutative
it is sufficient to prove
  thus for b1, b2 being Element of the carrier of a1 holds
    b1 "\/" b2 = b2 "\/" b1;

:: LATTICES:def 4
theorem
for b1 being non empty \/-SemiLattStr holds
      b1 is join-commutative
   iff
      for b2, b3 being Element of the carrier of b1 holds
      b2 "\/" b3 = b3 "\/" b2;

:: LATTICES:attrnot 5 => LATTICES:attr 5
definition
  let a1 be non empty \/-SemiLattStr;
  attr a1 is join-associative means
    for b1, b2, b3 being Element of the carrier of a1 holds
    b1 "\/" (b2 "\/" b3) = (b1 "\/" b2) "\/" b3;
end;

:: LATTICES:dfs 5
definiens
  let a1 be non empty \/-SemiLattStr;
To prove
     a1 is join-associative
it is sufficient to prove
  thus for b1, b2, b3 being Element of the carrier of a1 holds
    b1 "\/" (b2 "\/" b3) = (b1 "\/" b2) "\/" b3;

:: LATTICES:def 5
theorem
for b1 being non empty \/-SemiLattStr holds
      b1 is join-associative
   iff
      for b2, b3, b4 being Element of the carrier of b1 holds
      b2 "\/" (b3 "\/" b4) = (b2 "\/" b3) "\/" b4;

:: LATTICES:attrnot 6 => LATTICES:attr 6
definition
  let a1 be non empty /\-SemiLattStr;
  attr a1 is meet-commutative means
    for b1, b2 being Element of the carrier of a1 holds
    b1 "/\" b2 = b2 "/\" b1;
end;

:: LATTICES:dfs 6
definiens
  let a1 be non empty /\-SemiLattStr;
To prove
     a1 is meet-commutative
it is sufficient to prove
  thus for b1, b2 being Element of the carrier of a1 holds
    b1 "/\" b2 = b2 "/\" b1;

:: LATTICES:def 6
theorem
for b1 being non empty /\-SemiLattStr holds
      b1 is meet-commutative
   iff
      for b2, b3 being Element of the carrier of b1 holds
      b2 "/\" b3 = b3 "/\" b2;

:: LATTICES:attrnot 7 => LATTICES:attr 7
definition
  let a1 be non empty /\-SemiLattStr;
  attr a1 is meet-associative means
    for b1, b2, b3 being Element of the carrier of a1 holds
    b1 "/\" (b2 "/\" b3) = (b1 "/\" b2) "/\" b3;
end;

:: LATTICES:dfs 7
definiens
  let a1 be non empty /\-SemiLattStr;
To prove
     a1 is meet-associative
it is sufficient to prove
  thus for b1, b2, b3 being Element of the carrier of a1 holds
    b1 "/\" (b2 "/\" b3) = (b1 "/\" b2) "/\" b3;

:: LATTICES:def 7
theorem
for b1 being non empty /\-SemiLattStr holds
      b1 is meet-associative
   iff
      for b2, b3, b4 being Element of the carrier of b1 holds
      b2 "/\" (b3 "/\" b4) = (b2 "/\" b3) "/\" b4;

:: LATTICES:attrnot 8 => LATTICES:attr 8
definition
  let a1 be non empty LattStr;
  attr a1 is meet-absorbing means
    for b1, b2 being Element of the carrier of a1 holds
    (b1 "/\" b2) "\/" b2 = b2;
end;

:: LATTICES:dfs 8
definiens
  let a1 be non empty LattStr;
To prove
     a1 is meet-absorbing
it is sufficient to prove
  thus for b1, b2 being Element of the carrier of a1 holds
    (b1 "/\" b2) "\/" b2 = b2;

:: LATTICES:def 8
theorem
for b1 being non empty LattStr holds
      b1 is meet-absorbing
   iff
      for b2, b3 being Element of the carrier of b1 holds
      (b2 "/\" b3) "\/" b3 = b3;

:: LATTICES:attrnot 9 => LATTICES:attr 9
definition
  let a1 be non empty LattStr;
  attr a1 is join-absorbing means
    for b1, b2 being Element of the carrier of a1 holds
    b1 "/\" (b1 "\/" b2) = b1;
end;

:: LATTICES:dfs 9
definiens
  let a1 be non empty LattStr;
To prove
     a1 is join-absorbing
it is sufficient to prove
  thus for b1, b2 being Element of the carrier of a1 holds
    b1 "/\" (b1 "\/" b2) = b1;

:: LATTICES:def 9
theorem
for b1 being non empty LattStr holds
      b1 is join-absorbing
   iff
      for b2, b3 being Element of the carrier of b1 holds
      b2 "/\" (b2 "\/" b3) = b2;

:: LATTICES:attrnot 10 => LATTICES:attr 10
definition
  let a1 be non empty LattStr;
  attr a1 is Lattice-like means
    a1 is join-commutative & a1 is join-associative & a1 is meet-absorbing & a1 is meet-commutative & a1 is meet-associative & a1 is join-absorbing;
end;

:: LATTICES:dfs 10
definiens
  let a1 be non empty LattStr;
To prove
     a1 is Lattice-like
it is sufficient to prove
  thus a1 is join-commutative & a1 is join-associative & a1 is meet-absorbing & a1 is meet-commutative & a1 is meet-associative & a1 is join-absorbing;

:: LATTICES:def 10
theorem
for b1 being non empty LattStr holds
      b1 is Lattice-like
   iff
      b1 is join-commutative & b1 is join-associative & b1 is meet-absorbing & b1 is meet-commutative & b1 is meet-associative & b1 is join-absorbing;

:: LATTICES:condreg 1
registration
  cluster non empty Lattice-like -> join-commutative join-associative meet-commutative meet-associative meet-absorbing join-absorbing (LattStr);
end;

:: LATTICES:condreg 2
registration
  cluster non empty join-commutative join-associative meet-commutative meet-associative meet-absorbing join-absorbing -> Lattice-like (LattStr);
end;

:: LATTICES:exreg 7
registration
  cluster non empty strict join-commutative join-associative \/-SemiLattStr;
end;

:: LATTICES:exreg 8
registration
  cluster non empty strict meet-commutative meet-associative /\-SemiLattStr;
end;

:: LATTICES:exreg 9
registration
  cluster non empty strict Lattice-like LattStr;
end;

:: LATTICES:modenot 1
definition
  mode Lattice is non empty Lattice-like LattStr;
end;

:: LATTICES:funcnot 3 => LATTICES:func 3
definition
  let a1 be non empty join-commutative \/-SemiLattStr;
  let a2, a3 be Element of the carrier of a1;
  redefine func a2 "\/" a3 -> Element of the carrier of a1;
  commutativity;
::  for a1 being non empty join-commutative \/-SemiLattStr
::  for a2, a3 being Element of the carrier of a1 holds
::  a2 "\/" a3 = a3 "\/" a2;
end;

:: LATTICES:funcnot 4 => LATTICES:func 4
definition
  let a1 be non empty meet-commutative /\-SemiLattStr;
  let a2, a3 be Element of the carrier of a1;
  redefine func a2 "/\" a3 -> Element of the carrier of a1;
  commutativity;
::  for a1 being non empty meet-commutative /\-SemiLattStr
::  for a2, a3 being Element of the carrier of a1 holds
::  a2 "/\" a3 = a3 "/\" a2;
end;

:: LATTICES:attrnot 11 => LATTICES:attr 11
definition
  let a1 be non empty LattStr;
  attr a1 is distributive means
    for b1, b2, b3 being Element of the carrier of a1 holds
    b1 "/\" (b2 "\/" b3) = (b1 "/\" b2) "\/" (b1 "/\" b3);
end;

:: LATTICES:dfs 11
definiens
  let a1 be non empty LattStr;
To prove
     a1 is distributive
it is sufficient to prove
  thus for b1, b2, b3 being Element of the carrier of a1 holds
    b1 "/\" (b2 "\/" b3) = (b1 "/\" b2) "\/" (b1 "/\" b3);

:: LATTICES:def 11
theorem
for b1 being non empty LattStr holds
      b1 is distributive
   iff
      for b2, b3, b4 being Element of the carrier of b1 holds
      b2 "/\" (b3 "\/" b4) = (b2 "/\" b3) "\/" (b2 "/\" b4);

:: LATTICES:attrnot 12 => LATTICES:attr 12
definition
  let a1 be non empty LattStr;
  attr a1 is modular means
    for b1, b2, b3 being Element of the carrier of a1
          st b1 [= b3
       holds b1 "\/" (b2 "/\" b3) = (b1 "\/" b2) "/\" b3;
end;

:: LATTICES:dfs 12
definiens
  let a1 be non empty LattStr;
To prove
     a1 is modular
it is sufficient to prove
  thus for b1, b2, b3 being Element of the carrier of a1
          st b1 [= b3
       holds b1 "\/" (b2 "/\" b3) = (b1 "\/" b2) "/\" b3;

:: LATTICES:def 12
theorem
for b1 being non empty LattStr holds
      b1 is modular
   iff
      for b2, b3, b4 being Element of the carrier of b1
            st b2 [= b4
         holds b2 "\/" (b3 "/\" b4) = (b2 "\/" b3) "/\" b4;

:: LATTICES:attrnot 13 => LATTICES:attr 13
definition
  let a1 be non empty /\-SemiLattStr;
  attr a1 is lower-bounded means
    ex b1 being Element of the carrier of a1 st
       for b2 being Element of the carrier of a1 holds
          b1 "/\" b2 = b1 & b2 "/\" b1 = b1;
end;

:: LATTICES:dfs 13
definiens
  let a1 be non empty /\-SemiLattStr;
To prove
     a1 is lower-bounded
it is sufficient to prove
  thus ex b1 being Element of the carrier of a1 st
       for b2 being Element of the carrier of a1 holds
          b1 "/\" b2 = b1 & b2 "/\" b1 = b1;

:: LATTICES:def 13
theorem
for b1 being non empty /\-SemiLattStr holds
      b1 is lower-bounded
   iff
      ex b2 being Element of the carrier of b1 st
         for b3 being Element of the carrier of b1 holds
            b2 "/\" b3 = b2 & b3 "/\" b2 = b2;

:: LATTICES:attrnot 14 => LATTICES:attr 14
definition
  let a1 be non empty \/-SemiLattStr;
  attr a1 is upper-bounded means
    ex b1 being Element of the carrier of a1 st
       for b2 being Element of the carrier of a1 holds
          b1 "\/" b2 = b1 & b2 "\/" b1 = b1;
end;

:: LATTICES:dfs 14
definiens
  let a1 be non empty \/-SemiLattStr;
To prove
     a1 is upper-bounded
it is sufficient to prove
  thus ex b1 being Element of the carrier of a1 st
       for b2 being Element of the carrier of a1 holds
          b1 "\/" b2 = b1 & b2 "\/" b1 = b1;

:: LATTICES:def 14
theorem
for b1 being non empty \/-SemiLattStr holds
      b1 is upper-bounded
   iff
      ex b2 being Element of the carrier of b1 st
         for b3 being Element of the carrier of b1 holds
            b2 "\/" b3 = b2 & b3 "\/" b2 = b2;

:: LATTICES:exreg 10
registration
  cluster non empty strict join-commutative join-associative meet-commutative meet-associative meet-absorbing join-absorbing Lattice-like distributive modular lower-bounded upper-bounded LattStr;
end;

:: LATTICES:modenot 2
definition
  mode D_Lattice is non empty Lattice-like distributive LattStr;
end;

:: LATTICES:modenot 3
definition
  mode M_Lattice is non empty Lattice-like modular LattStr;
end;

:: LATTICES:modenot 4
definition
  mode 0_Lattice is non empty Lattice-like lower-bounded LattStr;
end;

:: LATTICES:modenot 5
definition
  mode 1_Lattice is non empty Lattice-like upper-bounded LattStr;
end;

:: LATTICES:attrnot 15 => LATTICES:attr 15
definition
  let a1 be non empty LattStr;
  attr a1 is bounded means
    a1 is lower-bounded & a1 is upper-bounded;
end;

:: LATTICES:dfs 15
definiens
  let a1 be non empty LattStr;
To prove
     a1 is bounded
it is sufficient to prove
  thus a1 is lower-bounded & a1 is upper-bounded;

:: LATTICES:def 15
theorem
for b1 being non empty LattStr holds
      b1 is bounded
   iff
      b1 is lower-bounded & b1 is upper-bounded;

:: LATTICES:condreg 3
registration
  cluster non empty lower-bounded upper-bounded -> bounded (LattStr);
end;

:: LATTICES:condreg 4
registration
  cluster non empty bounded -> lower-bounded upper-bounded (LattStr);
end;

:: LATTICES:exreg 11
registration
  cluster non empty strict join-commutative join-associative meet-commutative meet-associative meet-absorbing join-absorbing Lattice-like bounded LattStr;
end;

:: LATTICES:modenot 6
definition
  mode 01_Lattice is non empty Lattice-like bounded LattStr;
end;

:: LATTICES:funcnot 5 => LATTICES:func 5
definition
  let a1 be non empty /\-SemiLattStr;
  assume a1 is lower-bounded;
  func Bottom A1 -> Element of the carrier of a1 means
    for b1 being Element of the carrier of a1 holds
       it "/\" b1 = it & b1 "/\" it = it;
end;

:: LATTICES:def 16
theorem
for b1 being non empty /\-SemiLattStr
   st b1 is lower-bounded
for b2 being Element of the carrier of b1 holds
      b2 = Bottom b1
   iff
      for b3 being Element of the carrier of b1 holds
         b2 "/\" b3 = b2 & b3 "/\" b2 = b2;

:: LATTICES:funcnot 6 => LATTICES:func 6
definition
  let a1 be non empty \/-SemiLattStr;
  assume a1 is upper-bounded;
  func Top A1 -> Element of the carrier of a1 means
    for b1 being Element of the carrier of a1 holds
       it "\/" b1 = it & b1 "\/" it = it;
end;

:: LATTICES:def 17
theorem
for b1 being non empty \/-SemiLattStr
   st b1 is upper-bounded
for b2 being Element of the carrier of b1 holds
      b2 = Top b1
   iff
      for b3 being Element of the carrier of b1 holds
         b2 "\/" b3 = b2 & b3 "\/" b2 = b2;

:: LATTICES:prednot 2 => LATTICES:pred 2
definition
  let a1 be non empty LattStr;
  let a2, a3 be Element of the carrier of a1;
  pred A2 is_a_complement_of A3 means
    a2 "\/" a3 = Top a1 & a3 "\/" a2 = Top a1 & a2 "/\" a3 = Bottom a1 & a3 "/\" a2 = Bottom a1;
end;

:: LATTICES:dfs 18
definiens
  let a1 be non empty LattStr;
  let a2, a3 be Element of the carrier of a1;
To prove
     a2 is_a_complement_of a3
it is sufficient to prove
  thus a2 "\/" a3 = Top a1 & a3 "\/" a2 = Top a1 & a2 "/\" a3 = Bottom a1 & a3 "/\" a2 = Bottom a1;

:: LATTICES:def 18
theorem
for b1 being non empty LattStr
for b2, b3 being Element of the carrier of b1 holds
   b2 is_a_complement_of b3
iff
   b2 "\/" b3 = Top b1 & b3 "\/" b2 = Top b1 & b2 "/\" b3 = Bottom b1 & b3 "/\" b2 = Bottom b1;

:: LATTICES:attrnot 16 => LATTICES:attr 16
definition
  let a1 be non empty LattStr;
  attr a1 is complemented means
    for b1 being Element of the carrier of a1 holds
       ex b2 being Element of the carrier of a1 st
          b2 is_a_complement_of b1;
end;

:: LATTICES:dfs 19
definiens
  let a1 be non empty LattStr;
To prove
     a1 is complemented
it is sufficient to prove
  thus for b1 being Element of the carrier of a1 holds
       ex b2 being Element of the carrier of a1 st
          b2 is_a_complement_of b1;

:: LATTICES:def 19
theorem
for b1 being non empty LattStr holds
      b1 is complemented
   iff
      for b2 being Element of the carrier of b1 holds
         ex b3 being Element of the carrier of b1 st
            b3 is_a_complement_of b2;

:: LATTICES:exreg 12
registration
  cluster non empty strict join-commutative join-associative meet-commutative meet-associative meet-absorbing join-absorbing Lattice-like bounded complemented LattStr;
end;

:: LATTICES:modenot 7
definition
  mode C_Lattice is non empty Lattice-like bounded complemented LattStr;
end;

:: LATTICES:attrnot 17 => LATTICES:attr 17
definition
  let a1 be non empty LattStr;
  attr a1 is Boolean means
    a1 is bounded & a1 is complemented & a1 is distributive;
end;

:: LATTICES:dfs 20
definiens
  let a1 be non empty LattStr;
To prove
     a1 is Boolean
it is sufficient to prove
  thus a1 is bounded & a1 is complemented & a1 is distributive;

:: LATTICES:def 20
theorem
for b1 being non empty LattStr holds
      b1 is Boolean
   iff
      b1 is bounded & b1 is complemented & b1 is distributive;

:: LATTICES:condreg 5
registration
  cluster non empty Boolean -> distributive bounded complemented (LattStr);
end;

:: LATTICES:condreg 6
registration
  cluster non empty distributive bounded complemented -> Boolean (LattStr);
end;

:: LATTICES:exreg 13
registration
  cluster non empty strict join-commutative join-associative meet-commutative meet-associative meet-absorbing join-absorbing Lattice-like Boolean LattStr;
end;

:: LATTICES:modenot 8
definition
  mode B_Lattice is non empty Lattice-like Boolean LattStr;
end;

:: LATTICES:th 17
theorem
for b1 being non empty meet-commutative meet-absorbing join-absorbing LattStr
for b2 being Element of the carrier of b1 holds
   b2 "\/" b2 = b2;

:: LATTICES:th 18
theorem
for b1 being non empty meet-commutative meet-absorbing join-absorbing LattStr
for b2 being Element of the carrier of b1 holds
   b2 "/\" b2 = b2;

:: LATTICES:th 19
theorem
for b1 being non empty Lattice-like LattStr holds
      for b2, b3, b4 being Element of the carrier of b1 holds
      b2 "/\" (b3 "\/" b4) = (b2 "/\" b3) "\/" (b2 "/\" b4)
   iff
      for b2, b3, b4 being Element of the carrier of b1 holds
      b2 "\/" (b3 "/\" b4) = (b2 "\/" b3) "/\" (b2 "\/" b4);

:: LATTICES:th 21
theorem
for b1 being non empty meet-absorbing join-absorbing LattStr
for b2, b3 being Element of the carrier of b1 holds
   b2 [= b3
iff
   b2 "/\" b3 = b2;

:: LATTICES:th 22
theorem
for b1 being non empty join-associative meet-commutative meet-absorbing join-absorbing LattStr
for b2, b3 being Element of the carrier of b1 holds
b2 [= b2 "\/" b3;

:: LATTICES:th 23
theorem
for b1 being non empty meet-commutative meet-absorbing LattStr
for b2, b3 being Element of the carrier of b1 holds
b2 "/\" b3 [= b2;

:: LATTICES:prednot 3 => LATTICES:pred 3
definition
  let a1 be non empty meet-commutative meet-absorbing join-absorbing LattStr;
  let a2, a3 be Element of the carrier of a1;
  redefine pred a2 [= a3;
  reflexivity;
::  for a1 being non empty meet-commutative meet-absorbing join-absorbing LattStr
::  for a2 being Element of the carrier of a1 holds
::     a2 [= a2;
end;

:: LATTICES:th 25
theorem
for b1 being non empty join-associative \/-SemiLattStr
for b2, b3, b4 being Element of the carrier of b1
      st b2 [= b3 & b3 [= b4
   holds b2 [= b4;

:: LATTICES:th 26
theorem
for b1 being non empty join-commutative \/-SemiLattStr
for b2, b3 being Element of the carrier of b1
      st b2 [= b3 & b3 [= b2
   holds b2 = b3;

:: LATTICES:th 27
theorem
for b1 being non empty meet-associative meet-absorbing join-absorbing LattStr
for b2, b3, b4 being Element of the carrier of b1
      st b2 [= b3
   holds b2 "/\" b4 [= b3 "/\" b4;

:: LATTICES:th 29
theorem
for b1 being non empty Lattice-like LattStr
      st for b2, b3, b4 being Element of the carrier of b1 holds
        ((b2 "/\" b3) "\/" (b3 "/\" b4)) "\/" (b4 "/\" b2) = ((b2 "\/" b3) "/\" (b3 "\/" b4)) "/\" (b4 "\/" b2)
   holds b1 is distributive;

:: LATTICES:th 31
theorem
for b1 being non empty Lattice-like distributive LattStr
for b2, b3, b4 being Element of the carrier of b1 holds
b2 "\/" (b3 "/\" b4) = (b2 "\/" b3) "/\" (b2 "\/" b4);

:: LATTICES:th 32
theorem
for b1 being non empty Lattice-like distributive LattStr
for b2, b3, b4 being Element of the carrier of b1
      st b2 "/\" b3 = b2 "/\" b4 & b2 "\/" b3 = b2 "\/" b4
   holds b3 = b4;

:: LATTICES:th 34
theorem
for b1 being non empty Lattice-like distributive LattStr
for b2, b3, b4 being Element of the carrier of b1 holds
((b2 "\/" b3) "/\" (b3 "\/" b4)) "/\" (b4 "\/" b2) = ((b2 "/\" b3) "\/" (b3 "/\" b4)) "\/" (b4 "/\" b2);

:: LATTICES:condreg 7
registration
  cluster non empty Lattice-like distributive -> modular (LattStr);
end;

:: LATTICES:th 39
theorem
for b1 being non empty Lattice-like lower-bounded LattStr
for b2 being Element of the carrier of b1 holds
   (Bottom b1) "\/" b2 = b2;

:: LATTICES:th 40
theorem
for b1 being non empty Lattice-like lower-bounded LattStr
for b2 being Element of the carrier of b1 holds
   (Bottom b1) "/\" b2 = Bottom b1;

:: LATTICES:th 41
theorem
for b1 being non empty Lattice-like lower-bounded LattStr
for b2 being Element of the carrier of b1 holds
   Bottom b1 [= b2;

:: LATTICES:th 43
theorem
for b1 being non empty Lattice-like upper-bounded LattStr
for b2 being Element of the carrier of b1 holds
   (Top b1) "/\" b2 = b2;

:: LATTICES:th 44
theorem
for b1 being non empty Lattice-like upper-bounded LattStr
for b2 being Element of the carrier of b1 holds
   (Top b1) "\/" b2 = Top b1;

:: LATTICES:th 45
theorem
for b1 being non empty Lattice-like upper-bounded LattStr
for b2 being Element of the carrier of b1 holds
   b2 [= Top b1;

:: LATTICES:funcnot 7 => LATTICES:func 7
definition
  let a1 be non empty LattStr;
  let a2 be Element of the carrier of a1;
  assume a1 is non empty Lattice-like distributive complemented LattStr;
  func A2 ` -> Element of the carrier of a1 means
    it is_a_complement_of a2;
end;

:: LATTICES:def 21
theorem
for b1 being non empty LattStr
for b2 being Element of the carrier of b1
   st b1 is non empty Lattice-like distributive complemented LattStr
for b3 being Element of the carrier of b1 holds
      b3 = b2 `
   iff
      b3 is_a_complement_of b2;

:: LATTICES:th 47
theorem
for b1 being non empty Lattice-like Boolean LattStr
for b2 being Element of the carrier of b1 holds
   b2 ` "/\" b2 = Bottom b1;

:: LATTICES:th 48
theorem
for b1 being non empty Lattice-like Boolean LattStr
for b2 being Element of the carrier of b1 holds
   b2 ` "\/" b2 = Top b1;

:: LATTICES:th 49
theorem
for b1 being non empty Lattice-like Boolean LattStr
for b2 being Element of the carrier of b1 holds
   b2 ` ` = b2;

:: LATTICES:th 50
theorem
for b1 being non empty Lattice-like Boolean LattStr
for b2, b3 being Element of the carrier of b1 holds
(b2 "/\" b3) ` = b2 ` "\/" (b3 `);

:: LATTICES:th 51
theorem
for b1 being non empty Lattice-like Boolean LattStr
for b2, b3 being Element of the carrier of b1 holds
(b2 "\/" b3) ` = b2 ` "/\" (b3 `);

:: LATTICES:th 52
theorem
for b1 being non empty Lattice-like Boolean LattStr
for b2, b3 being Element of the carrier of b1 holds
   b2 "/\" b3 = Bottom b1
iff
   b2 [= b3 `;

:: LATTICES:th 53
theorem
for b1 being non empty Lattice-like Boolean LattStr
for b2, b3 being Element of the carrier of b1
      st b2 [= b3
   holds b3 ` [= b2 `;