Article ROBBINS3, MML version 4.99.1005

:: ROBBINS3:attrnot 1 => ROBBINS3:attr 1
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) = b2 "\/" (b1 "\/" b3);
end;

:: ROBBINS3:dfs 1
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) = b2 "\/" (b1 "\/" b3);

:: ROBBINS3:def 1
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) = b3 "\/" (b2 "\/" b4);

:: ROBBINS3:attrnot 2 => ROBBINS3:attr 2
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) = b2 "/\" (b1 "/\" b3);
end;

:: ROBBINS3:dfs 2
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) = b2 "/\" (b1 "/\" b3);

:: ROBBINS3:def 2
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) = b3 "/\" (b2 "/\" b4);

:: ROBBINS3:attrnot 3 => ROBBINS3:attr 3
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 "\/" (b1 "/\" b2) = b1;
end;

:: ROBBINS3:dfs 3
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 "\/" (b1 "/\" b2) = b1;

:: ROBBINS3:def 3
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 "\/" (b2 "/\" b3) = b2;

:: ROBBINS3:th 1
theorem
for b1 being non empty LattStr
      st b1 is meet-Associative & b1 is join-Associative & b1 is meet-Absorbing & b1 is join-absorbing
   holds b1 is meet-idempotent & b1 is join-idempotent;

:: ROBBINS3:th 2
theorem
for b1 being non empty LattStr
      st b1 is meet-Associative & b1 is join-Associative & b1 is meet-Absorbing & b1 is join-absorbing
   holds b1 is meet-commutative & b1 is join-commutative;

:: ROBBINS3:th 3
theorem
for b1 being non empty LattStr
      st b1 is meet-Associative & b1 is join-Associative & b1 is meet-Absorbing & b1 is join-absorbing
   holds b1 is meet-absorbing;

:: ROBBINS3:th 4
theorem
for b1 being non empty LattStr
      st b1 is meet-Associative & b1 is join-Associative & b1 is meet-Absorbing & b1 is join-absorbing
   holds b1 is meet-associative & b1 is join-associative;

:: ROBBINS3:th 5
theorem
for b1 being non empty LattStr holds
      b1 is Lattice-like
   iff
      b1 is meet-Associative & b1 is join-Associative & b1 is meet-Absorbing & b1 is join-absorbing;

:: ROBBINS3:condreg 1
registration
  cluster non empty Lattice-like -> meet-absorbing join-absorbing join-Associative meet-Associative (LattStr);
end;

:: ROBBINS3:condreg 2
registration
  cluster non empty join-absorbing join-Associative meet-Associative meet-Absorbing -> Lattice-like (LattStr);
end;

:: ROBBINS3:condreg 3
registration
  cluster non empty PartialOrdered OrderInvolutive -> Dneg (OrthoRelStr);
end;

:: ROBBINS3:th 6
theorem
for b1 being non empty Dneg OrthoRelStr
for b2 being Element of the carrier of b1 holds
   b2 ` ` = b2;

:: ROBBINS3:th 7
theorem
for b1 being non empty PartialOrdered OrderInvolutive OrthoRelStr
for b2, b3 being Element of the carrier of b1
      st b2 <= b3
   holds b3 ` <= b2 `;

:: ROBBINS3:exreg 1
registration
  cluster non empty reflexive transitive antisymmetric with_suprema with_infima strict Dneg SubAntisymmetric SubTransitive SubPartialOrdered PartialOrdered Pure OrderInvolutive OrthoRelStr;
end;

:: ROBBINS3:funcnot 1 => LATTICES:func 1
notation
  let a1 be non empty \/-SemiLattStr;
  let a2, a3 be Element of the carrier of a1;
  synonym a2 |_| a3 for a2 "\/" a3;
end;

:: ROBBINS3:funcnot 2 => LATTICES:func 2
notation
  let a1 be non empty /\-SemiLattStr;
  let a2, a3 be Element of the carrier of a1;
  synonym a2 |^| a3 for a2 "/\" a3;
end;

:: ROBBINS3:funcnot 3 => LATTICE3:func 11
notation
  let a1 be non empty RelStr;
  let a2, a3 be Element of the carrier of a1;
  synonym a2 "|^|" a3 for a2 "/\" a3;
end;

:: ROBBINS3:funcnot 4 => LATTICE3:func 10
notation
  let a1 be non empty RelStr;
  let a2, a3 be Element of the carrier of a1;
  synonym a2 "|_|" a3 for a2 "\/" a3;
end;

:: ROBBINS3:structnot 1 => ROBBINS3:struct 1
definition
  struct(\/-SemiLattStrRelStr) \/-SemiLattRelStr(#
    carrier -> set,
    L_join -> Function-like quasi_total Relation of [:the carrier of it,the carrier of it:],the carrier of it,
    InternalRel -> Relation of the carrier of it,the carrier of it
  #);
end;

:: ROBBINS3:attrnot 4 => ROBBINS3:attr 4
definition
  let a1 be \/-SemiLattRelStr;
  attr a1 is strict;
end;

:: ROBBINS3:exreg 2
registration
  cluster strict \/-SemiLattRelStr;
end;

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

:: ROBBINS3:structnot 2 => ROBBINS3:struct 2
definition
  struct(/\-SemiLattStrRelStr) /\-SemiLattRelStr(#
    carrier -> set,
    L_meet -> Function-like quasi_total Relation of [:the carrier of it,the carrier of it:],the carrier of it,
    InternalRel -> Relation of the carrier of it,the carrier of it
  #);
end;

:: ROBBINS3:attrnot 5 => ROBBINS3:attr 5
definition
  let a1 be /\-SemiLattRelStr;
  attr a1 is strict;
end;

:: ROBBINS3:exreg 3
registration
  cluster strict /\-SemiLattRelStr;
end;

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

:: ROBBINS3:structnot 3 => ROBBINS3:struct 3
definition
  struct(/\-SemiLattRelStr\/-SemiLattRelStrLattStr) LattRelStr(#
    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,
    InternalRel -> Relation of the carrier of it,the carrier of it
  #);
end;

:: ROBBINS3:attrnot 6 => ROBBINS3:attr 6
definition
  let a1 be LattRelStr;
  attr a1 is strict;
end;

:: ROBBINS3:exreg 4
registration
  cluster strict LattRelStr;
end;

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

:: ROBBINS3:funcnot 5 => ROBBINS3:func 1
definition
  func TrivLattRelStr -> LattRelStr equals
    LattRelStr(#1,op2,op2,id 1#);
end;

:: ROBBINS3:def 4
theorem
TrivLattRelStr = LattRelStr(#1,op2,op2,id 1#);

:: ROBBINS3:funcreg 1
registration
  cluster TrivLattRelStr -> non empty trivial;
end;

:: ROBBINS3:exreg 5
registration
  cluster non empty \/-SemiLattRelStr;
end;

:: ROBBINS3:exreg 6
registration
  cluster non empty /\-SemiLattRelStr;
end;

:: ROBBINS3:exreg 7
registration
  cluster non empty LattRelStr;
end;

:: ROBBINS3:th 8
theorem
for b1 being non empty RelStr
      st the InternalRel of b1 is_reflexive_in the carrier of b1 & the InternalRel of b1 is antisymmetric & the InternalRel of b1 is transitive
   holds b1 is reflexive & b1 is antisymmetric & b1 is transitive;

:: ROBBINS3:funcreg 2
registration
  cluster TrivLattRelStr -> reflexive;
end;

:: ROBBINS3:exreg 8
registration
  cluster reflexive transitive antisymmetric with_suprema with_infima LattRelStr;
end;

:: ROBBINS3:funcreg 3
registration
  cluster TrivLattRelStr -> meet-Absorbing;
end;

:: ROBBINS3:exreg 9
registration
  cluster non empty Lattice-like LattRelStr;
end;

:: ROBBINS3:funcnot 6 => ROBBINS3: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;

:: ROBBINS3:structnot 4 => ROBBINS3:struct 4
definition
  struct(LattRelStrOrthoLattStrOrthoRelStr) OrthoLattRelStr(#
    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,
    InternalRel -> Relation of the carrier of it,the carrier of it,
    Compl -> Function-like quasi_total Relation of the carrier of it,the carrier of it
  #);
end;

:: ROBBINS3:attrnot 7 => ROBBINS3:attr 7
definition
  let a1 be OrthoLattRelStr;
  attr a1 is strict;
end;

:: ROBBINS3:exreg 10
registration
  cluster strict OrthoLattRelStr;
end;

:: ROBBINS3:aggrnot 4 => ROBBINS3:aggr 4
definition
  let a1 be set;
  let a2, a3 be Function-like quasi_total Relation of [:a1,a1:],a1;
  let a4 be Relation of a1,a1;
  let a5 be Function-like quasi_total Relation of a1,a1;
  aggr OrthoLattRelStr(#a1,a2,a3,a4,a5#) -> strict OrthoLattRelStr;
end;

:: ROBBINS3:funcnot 7 => ROBBINS3:func 3
definition
  func TrivCLRelStr -> OrthoLattRelStr equals
    OrthoLattRelStr(#1,op2,op2,id 1,op1#);
end;

:: ROBBINS3:def 5
theorem
TrivCLRelStr = OrthoLattRelStr(#1,op2,op2,id 1,op1#);

:: ROBBINS3:attrnot 8 => ROBBINS3:attr 8
definition
  let a1 be non empty ComplStr;
  attr a1 is involutive means
    for b1 being Element of the carrier of a1 holds
       b1 ` ` = b1;
end;

:: ROBBINS3:dfs 6
definiens
  let a1 be non empty ComplStr;
To prove
     a1 is involutive
it is sufficient to prove
  thus for b1 being Element of the carrier of a1 holds
       b1 ` ` = b1;

:: ROBBINS3:def 6
theorem
for b1 being non empty ComplStr holds
      b1 is involutive
   iff
      for b2 being Element of the carrier of b1 holds
         b2 ` ` = b2;

:: ROBBINS3:attrnot 9 => ROBBINS3:attr 9
definition
  let a1 be non empty ComplLattStr;
  attr a1 is with_Top means
    for b1, b2 being Element of the carrier of a1 holds
    b1 "\/" (b1 `) = b2 "\/" (b2 `);
end;

:: ROBBINS3:dfs 7
definiens
  let a1 be non empty ComplLattStr;
To prove
     a1 is with_Top
it is sufficient to prove
  thus for b1, b2 being Element of the carrier of a1 holds
    b1 "\/" (b1 `) = b2 "\/" (b2 `);

:: ROBBINS3:def 7
theorem
for b1 being non empty ComplLattStr holds
      b1 is with_Top
   iff
      for b2, b3 being Element of the carrier of b1 holds
      b2 "\/" (b2 `) = b3 "\/" (b3 `);

:: ROBBINS3:funcreg 4
registration
  cluster TrivOrtLat -> strict involutive with_Top;
end;

:: ROBBINS3:funcreg 5
registration
  cluster TrivCLRelStr -> non empty trivial;
end;

:: ROBBINS3:funcreg 6
registration
  cluster TrivCLRelStr -> reflexive;
end;

:: ROBBINS3:funcreg 7
registration
  cluster TrivCLRelStr -> involutive with_Top;
end;

:: ROBBINS3:exreg 11
registration
  cluster non empty Lattice-like de_Morgan involutive with_Top OrthoLattStr;
end;

:: ROBBINS3:modenot 1
definition
  mode Ortholattice is non empty Lattice-like de_Morgan involutive with_Top OrthoLattStr;
end;

:: ROBBINS3:th 9
theorem
for b1, b2 being non empty LattStr
      st 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#) &
         b1 is join-commutative
   holds b2 is join-commutative;

:: ROBBINS3:th 10
theorem
for b1, b2 being non empty LattStr
      st 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#) &
         b1 is meet-commutative
   holds b2 is meet-commutative;

:: ROBBINS3:th 11
theorem
for b1, b2 being non empty LattStr
      st 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#) &
         b1 is join-associative
   holds b2 is join-associative;

:: ROBBINS3:th 12
theorem
for b1, b2 being non empty LattStr
      st 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#) &
         b1 is meet-associative
   holds b2 is meet-associative;

:: ROBBINS3:th 13
theorem
for b1, b2 being non empty LattStr
      st 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#) &
         b1 is join-absorbing
   holds b2 is join-absorbing;

:: ROBBINS3:th 14
theorem
for b1, b2 being non empty LattStr
      st 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#) &
         b1 is meet-absorbing
   holds b2 is meet-absorbing;

:: ROBBINS3:th 15
theorem
for b1, b2 being non empty LattStr
      st 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#) &
         b1 is Lattice-like
   holds b2 is Lattice-like;

:: ROBBINS3:th 16
theorem
for b1, b2 being non empty \/-SemiLattStr
   st \/-SemiLattStr(#the carrier of b1,the L_join of b1#) = \/-SemiLattStr(#the carrier of b2,the L_join of b2#)
for b3, b4 being Element of the carrier of b1
for b5, b6 being Element of the carrier of b2
      st b3 = b5 & b4 = b6
   holds b3 "\/" b4 = b5 "\/" b6;

:: ROBBINS3:th 17
theorem
for b1, b2 being non empty /\-SemiLattStr
   st /\-SemiLattStr(#the carrier of b1,the L_meet of b1#) = /\-SemiLattStr(#the carrier of b2,the L_meet of b2#)
for b3, b4 being Element of the carrier of b1
for b5, b6 being Element of the carrier of b2
      st b3 = b5 & b4 = b6
   holds b3 "/\" b4 = b5 "/\" b6;

:: ROBBINS3:th 18
theorem
for b1, b2 being non empty ComplStr
for b3 being Element of the carrier of b1
for b4 being Element of the carrier of b2
      st the Compl of b1 = the Compl of b2 & b3 = b4
   holds b3 ` = b4 `;

:: ROBBINS3:th 19
theorem
for b1, b2 being non empty ComplLattStr
      st ComplLattStr(#the carrier of b1,the L_join of b1,the Compl of b1#) = ComplLattStr(#the carrier of b2,the L_join of b2,the Compl of b2#) &
         b1 is with_Top
   holds b2 is with_Top;

:: ROBBINS3:th 20
theorem
for b1, b2 being non empty OrthoLattStr
      st OrthoLattStr(#the carrier of b1,the L_join of b1,the L_meet of b1,the Compl of b1#) = OrthoLattStr(#the carrier of b2,the L_join of b2,the L_meet of b2,the Compl of b2#) &
         b1 is de_Morgan
   holds b2 is de_Morgan;

:: ROBBINS3:th 21
theorem
for b1, b2 being non empty OrthoLattStr
      st OrthoLattStr(#the carrier of b1,the L_join of b1,the L_meet of b1,the Compl of b1#) = OrthoLattStr(#the carrier of b2,the L_join of b2,the L_meet of b2,the Compl of b2#) &
         b1 is involutive
   holds b2 is involutive;

:: ROBBINS3:modenot 2 => ROBBINS3:mode 1
definition
  let a1 be RelStr;
  mode RelAugmentation of A1 -> LattRelStr means
    RelStr(#the carrier of it,the InternalRel of it#) = RelStr(#the carrier of a1,the InternalRel of a1#);
end;

:: ROBBINS3:dfs 8
definiens
  let a1 be RelStr;
  let a2 be LattRelStr;
To prove
     a2 is RelAugmentation of a1
it is sufficient to prove
  thus RelStr(#the carrier of a2,the InternalRel of a2#) = RelStr(#the carrier of a1,the InternalRel of a1#);

:: ROBBINS3:def 8
theorem
for b1 being RelStr
for b2 being LattRelStr holds
      b2 is RelAugmentation of b1
   iff
      RelStr(#the carrier of b2,the InternalRel of b2#) = RelStr(#the carrier of b1,the InternalRel of b1#);

:: ROBBINS3:modenot 3 => ROBBINS3:mode 2
definition
  let a1 be LattStr;
  mode LatAugmentation of A1 -> LattRelStr means
    LattStr(#the carrier of it,the L_join of it,the L_meet of it#) = LattStr(#the carrier of a1,the L_join of a1,the L_meet of a1#);
end;

:: ROBBINS3:dfs 9
definiens
  let a1 be LattStr;
  let a2 be LattRelStr;
To prove
     a2 is LatAugmentation of a1
it is sufficient to prove
  thus LattStr(#the carrier of a2,the L_join of a2,the L_meet of a2#) = LattStr(#the carrier of a1,the L_join of a1,the L_meet of a1#);

:: ROBBINS3:def 9
theorem
for b1 being LattStr
for b2 being LattRelStr holds
      b2 is LatAugmentation of b1
   iff
      LattStr(#the carrier of b2,the L_join of b2,the L_meet of b2#) = LattStr(#the carrier of b1,the L_join of b1,the L_meet of b1#);

:: ROBBINS3:condreg 4
registration
  let a1 be non empty LattStr;
  cluster -> non empty (LatAugmentation of a1);
end;

:: ROBBINS3:condreg 5
registration
  let a1 be non empty meet-associative LattStr;
  cluster -> meet-associative (LatAugmentation of a1);
end;

:: ROBBINS3:condreg 6
registration
  let a1 be non empty join-associative LattStr;
  cluster -> join-associative (LatAugmentation of a1);
end;

:: ROBBINS3:condreg 7
registration
  let a1 be non empty meet-commutative LattStr;
  cluster -> meet-commutative (LatAugmentation of a1);
end;

:: ROBBINS3:condreg 8
registration
  let a1 be non empty join-commutative LattStr;
  cluster -> join-commutative (LatAugmentation of a1);
end;

:: ROBBINS3:condreg 9
registration
  let a1 be non empty join-absorbing LattStr;
  cluster -> join-absorbing (LatAugmentation of a1);
end;

:: ROBBINS3:condreg 10
registration
  let a1 be non empty meet-absorbing LattStr;
  cluster -> meet-absorbing (LatAugmentation of a1);
end;

:: ROBBINS3:attrnot 10 => ROBBINS3:attr 10
definition
  let a1 be non empty \/-SemiLattRelStr;
  attr a1 is naturally_sup-generated means
    for b1, b2 being Element of the carrier of a1 holds
       b1 <= b2
    iff
       b1 "\/" b2 = b2;
end;

:: ROBBINS3:dfs 10
definiens
  let a1 be non empty \/-SemiLattRelStr;
To prove
     a1 is naturally_sup-generated
it is sufficient to prove
  thus for b1, b2 being Element of the carrier of a1 holds
       b1 <= b2
    iff
       b1 "\/" b2 = b2;

:: ROBBINS3:def 10
theorem
for b1 being non empty \/-SemiLattRelStr holds
      b1 is naturally_sup-generated
   iff
      for b2, b3 being Element of the carrier of b1 holds
         b2 <= b3
      iff
         b2 "\/" b3 = b3;

:: ROBBINS3:attrnot 11 => ROBBINS3:attr 11
definition
  let a1 be non empty /\-SemiLattRelStr;
  attr a1 is naturally_inf-generated means
    for b1, b2 being Element of the carrier of a1 holds
       b1 <= b2
    iff
       b1 "/\" b2 = b1;
end;

:: ROBBINS3:dfs 11
definiens
  let a1 be non empty /\-SemiLattRelStr;
To prove
     a1 is naturally_inf-generated
it is sufficient to prove
  thus for b1, b2 being Element of the carrier of a1 holds
       b1 <= b2
    iff
       b1 "/\" b2 = b1;

:: ROBBINS3:def 11
theorem
for b1 being non empty /\-SemiLattRelStr holds
      b1 is naturally_inf-generated
   iff
      for b2, b3 being Element of the carrier of b1 holds
         b2 <= b3
      iff
         b2 "/\" b3 = b2;

:: ROBBINS3:exreg 12
registration
  let a1 be non empty Lattice-like LattStr;
  cluster non empty join-commutative join-associative meet-commutative meet-associative meet-absorbing join-absorbing Lattice-like join-Associative meet-Associative naturally_sup-generated naturally_inf-generated LatAugmentation of a1;
end;

:: ROBBINS3:exreg 13
registration
  cluster non empty trivial reflexive LattRelStr;
end;

:: ROBBINS3:exreg 14
registration
  cluster non empty trivial reflexive OrthoLattRelStr;
end;

:: ROBBINS3:exreg 15
registration
  cluster non empty trivial reflexive OrthoRelStr;
end;

:: ROBBINS3:condreg 11
registration
  cluster non empty trivial -> well-complemented de_Morgan involutive with_Top (OrthoLattStr);
end;

:: ROBBINS3:condreg 12
registration
  cluster non empty trivial reflexive -> PartialOrdered Pure OrderInvolutive (OrthoRelStr);
end;

:: ROBBINS3:condreg 13
registration
  cluster non empty trivial reflexive -> naturally_sup-generated naturally_inf-generated (LattRelStr);
end;

:: ROBBINS3:exreg 16
registration
  cluster non empty Lattice-like with_suprema with_infima de_Morgan PartialOrdered Pure OrderInvolutive naturally_sup-generated naturally_inf-generated OrthoLattRelStr;
end;

:: ROBBINS3:exreg 17
registration
  cluster non empty Lattice-like with_suprema with_infima naturally_sup-generated naturally_inf-generated LattRelStr;
end;

:: ROBBINS3:th 22
theorem
for b1 being non empty naturally_sup-generated LattRelStr
for b2, b3 being Element of the carrier of b1 holds
   b2 <= b3
iff
   b2 [= b3;

:: ROBBINS3:th 23
theorem
for b1 being non empty Lattice-like naturally_sup-generated LattRelStr holds
   RelStr(#the carrier of b1,the InternalRel of b1#) = LattPOSet b1;

:: ROBBINS3:condreg 14
registration
  cluster non empty Lattice-like naturally_sup-generated -> with_suprema with_infima (LattRelStr);
end;

:: ROBBINS3:modenot 4 => ROBBINS3:mode 3
definition
  let a1 be OrthoLattStr;
  mode CLatAugmentation of A1 -> OrthoLattRelStr means
    OrthoLattStr(#the carrier of it,the L_join of it,the L_meet of it,the Compl of it#) = OrthoLattStr(#the carrier of a1,the L_join of a1,the L_meet of a1,the Compl of a1#);
end;

:: ROBBINS3:dfs 12
definiens
  let a1 be OrthoLattStr;
  let a2 be OrthoLattRelStr;
To prove
     a2 is CLatAugmentation of a1
it is sufficient to prove
  thus OrthoLattStr(#the carrier of a2,the L_join of a2,the L_meet of a2,the Compl of a2#) = OrthoLattStr(#the carrier of a1,the L_join of a1,the L_meet of a1,the Compl of a1#);

:: ROBBINS3:def 12
theorem
for b1 being OrthoLattStr
for b2 being OrthoLattRelStr holds
      b2 is CLatAugmentation of b1
   iff
      OrthoLattStr(#the carrier of b2,the L_join of b2,the L_meet of b2,the Compl of b2#) = OrthoLattStr(#the carrier of b1,the L_join of b1,the L_meet of b1,the Compl of b1#);

:: ROBBINS3:condreg 15
registration
  let a1 be non empty OrthoLattStr;
  cluster -> non empty (CLatAugmentation of a1);
end;

:: ROBBINS3:condreg 16
registration
  let a1 be non empty meet-associative OrthoLattStr;
  cluster -> meet-associative (CLatAugmentation of a1);
end;

:: ROBBINS3:condreg 17
registration
  let a1 be non empty join-associative OrthoLattStr;
  cluster -> join-associative (CLatAugmentation of a1);
end;

:: ROBBINS3:condreg 18
registration
  let a1 be non empty meet-commutative OrthoLattStr;
  cluster -> meet-commutative (CLatAugmentation of a1);
end;

:: ROBBINS3:condreg 19
registration
  let a1 be non empty join-commutative OrthoLattStr;
  cluster -> join-commutative (CLatAugmentation of a1);
end;

:: ROBBINS3:condreg 20
registration
  let a1 be non empty meet-absorbing OrthoLattStr;
  cluster -> meet-absorbing (CLatAugmentation of a1);
end;

:: ROBBINS3:condreg 21
registration
  let a1 be non empty join-absorbing OrthoLattStr;
  cluster -> join-absorbing (CLatAugmentation of a1);
end;

:: ROBBINS3:condreg 22
registration
  let a1 be non empty with_Top OrthoLattStr;
  cluster -> with_Top (CLatAugmentation of a1);
end;

:: ROBBINS3:exreg 18
registration
  let a1 be non empty Lattice-like de_Morgan involutive with_Top OrthoLattStr;
  cluster non empty join-commutative join-associative meet-commutative meet-associative meet-absorbing join-absorbing Lattice-like join-Associative meet-Associative with_Top naturally_sup-generated naturally_inf-generated CLatAugmentation of a1;
end;

:: ROBBINS3:exreg 19
registration
  cluster non empty Lattice-like well-complemented de_Morgan involutive with_Top naturally_sup-generated OrthoLattRelStr;
end;

:: ROBBINS3:th 24
theorem
for b1 being non empty with_suprema with_infima PartialOrdered OrthoRelStr
for b2, b3 being Element of the carrier of b1
      st b2 <= b3
   holds b3 = b2 "\/" b3 & b2 = b2 "/\" b3;

:: ROBBINS3:funcnot 8 => ROBBINS3: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;

:: ROBBINS3:funcnot 9 => ROBBINS3:func 5
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;

:: ROBBINS3:condreg 23
registration
  cluster non empty meet-commutative meet-absorbing join-absorbing naturally_sup-generated -> reflexive (LattRelStr);
end;

:: ROBBINS3:condreg 24
registration
  cluster non empty join-associative naturally_sup-generated -> transitive (LattRelStr);
end;

:: ROBBINS3:condreg 25
registration
  cluster non empty join-commutative naturally_sup-generated -> antisymmetric (LattRelStr);
end;

:: ROBBINS3:th 25
theorem
for b1 being non empty Lattice-like with_suprema with_infima naturally_sup-generated OrthoLattRelStr
for b2, b3 being Element of the carrier of b1 holds
b2 "\/" b3 = b2 |_| b3;

:: ROBBINS3:th 26
theorem
for b1 being non empty Lattice-like with_suprema with_infima naturally_sup-generated OrthoLattRelStr
for b2, b3 being Element of the carrier of b1 holds
b2 "/\" b3 = b2 |^| b3;

:: ROBBINS3:th 27
theorem
for b1 being non empty Lattice-like with_suprema with_infima PartialOrdered OrderInvolutive naturally_sup-generated naturally_inf-generated OrthoLattRelStr holds
   b1 is de_Morgan;

:: ROBBINS3:condreg 26
registration
  let a1 be non empty Lattice-like de_Morgan involutive with_Top OrthoLattStr;
  cluster -> involutive (CLatAugmentation of a1);
end;

:: ROBBINS3:condreg 27
registration
  let a1 be non empty Lattice-like de_Morgan involutive with_Top OrthoLattStr;
  cluster -> de_Morgan (CLatAugmentation of a1);
end;

:: ROBBINS3:th 28
theorem
for b1 being non empty OrthoLattRelStr
      st b1 is involutive & b1 is with_Top & b1 is de_Morgan & b1 is Lattice-like & b1 is naturally_sup-generated
   holds b1 is Orthocomplemented & b1 is PartialOrdered;

:: ROBBINS3:th 29
theorem
for b1 being non empty Lattice-like de_Morgan involutive with_Top OrthoLattStr
for b2 being naturally_sup-generated CLatAugmentation of b1 holds
   b2 is Orthocomplemented;

:: ROBBINS3:condreg 28
registration
  let a1 be non empty Lattice-like de_Morgan involutive with_Top OrthoLattStr;
  cluster naturally_sup-generated -> Orthocomplemented (CLatAugmentation of a1);
end;

:: ROBBINS3:th 30
theorem
for b1 being non empty OrthoLattStr
      st b1 is Boolean & b1 is well-complemented & b1 is Lattice-like
   holds b1 is non empty Lattice-like de_Morgan involutive with_Top OrthoLattStr;

:: ROBBINS3:condreg 29
registration
  cluster non empty Lattice-like Boolean well-complemented -> de_Morgan involutive with_Top (OrthoLattStr);
end;