Article ROBBINS1, MML version 4.99.1005

:: ROBBINS1:structnot 1 => ROBBINS1:struct 1
definition
  struct(1-sorted) ComplStr(#
    carrier -> set,
    Compl -> Function-like quasi_total Relation of the carrier of it,the carrier of it
  #);
end;

:: ROBBINS1:attrnot 1 => ROBBINS1:attr 1
definition
  let a1 be ComplStr;
  attr a1 is strict;
end;

:: ROBBINS1:exreg 1
registration
  cluster strict ComplStr;
end;

:: ROBBINS1:aggrnot 1 => ROBBINS1:aggr 1
definition
  let a1 be set;
  let a2 be Function-like quasi_total Relation of a1,a1;
  aggr ComplStr(#a1,a2#) -> strict ComplStr;
end;

:: ROBBINS1:selnot 1 => ROBBINS1:sel 1
definition
  let a1 be ComplStr;
  sel the Compl of a1 -> Function-like quasi_total Relation of the carrier of a1,the carrier of a1;
end;

:: ROBBINS1:structnot 2 => ROBBINS1:struct 2
definition
  struct(\/-SemiLattStrComplStr) ComplLattStr(#
    carrier -> set,
    L_join -> Function-like quasi_total Relation of [:the carrier of it,the carrier of it:],the carrier of it,
    Compl -> Function-like quasi_total Relation of the carrier of it,the carrier of it
  #);
end;

:: ROBBINS1:attrnot 2 => ROBBINS1:attr 2
definition
  let a1 be ComplLattStr;
  attr a1 is strict;
end;

:: ROBBINS1:exreg 2
registration
  cluster strict ComplLattStr;
end;

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

:: ROBBINS1:structnot 3 => ROBBINS1:struct 3
definition
  struct(ComplLattStrLattStr) OrthoLattStr(#
    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,
    Compl -> Function-like quasi_total Relation of the carrier of it,the carrier of it
  #);
end;

:: ROBBINS1:attrnot 3 => ROBBINS1:attr 3
definition
  let a1 be OrthoLattStr;
  attr a1 is strict;
end;

:: ROBBINS1:exreg 3
registration
  cluster strict OrthoLattStr;
end;

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

:: ROBBINS1:funcnot 1 => ROBBINS1:func 1
definition
  func TrivComplLat -> strict ComplLattStr equals
    ComplLattStr(#1,op2,op1#);
end;

:: ROBBINS1:def 1
theorem
TrivComplLat = ComplLattStr(#1,op2,op1#);

:: ROBBINS1:funcnot 2 => ROBBINS1:func 2
definition
  func TrivOrtLat -> strict OrthoLattStr equals
    OrthoLattStr(#1,op2,op2,op1#);
end;

:: ROBBINS1:def 2
theorem
TrivOrtLat = OrthoLattStr(#1,op2,op2,op1#);

:: ROBBINS1:funcreg 1
registration
  cluster TrivComplLat -> non empty trivial strict;
end;

:: ROBBINS1:funcreg 2
registration
  cluster TrivOrtLat -> non empty trivial strict;
end;

:: ROBBINS1:exreg 4
registration
  cluster non empty trivial strict OrthoLattStr;
end;

:: ROBBINS1:exreg 5
registration
  cluster non empty trivial strict ComplLattStr;
end;

:: ROBBINS1:funcreg 3
registration
  let a1 be non empty trivial ComplLattStr;
  cluster ComplStr(#the carrier of a1,the Compl of a1#) -> non empty trivial strict;
end;

:: ROBBINS1:exreg 6
registration
  cluster non empty trivial strict ComplStr;
end;

:: ROBBINS1:funcnot 3 => ROBBINS1:func 3
definition
  let a1 be non empty ComplStr;
  let a2 be Element of the carrier of a1;
  func A2 ` -> Element of the carrier of a1 equals
    (the Compl of a1) . a2;
end;

:: ROBBINS1:def 3
theorem
for b1 being non empty ComplStr
for b2 being Element of the carrier of b1 holds
   b2 ` = (the Compl of b1) . b2;

:: ROBBINS1:funcnot 4 => LATTICES:func 1
notation
  let a1 be non empty ComplLattStr;
  let a2, a3 be Element of the carrier of a1;
  synonym a2 + a3 for a2 "\/" a3;
end;

:: ROBBINS1:funcnot 5 => ROBBINS1:func 4
definition
  let a1 be non empty ComplLattStr;
  let a2, a3 be Element of the carrier of a1;
  func A2 *' A3 -> Element of the carrier of a1 equals
    (a2 ` "\/" (a3 `)) `;
end;

:: ROBBINS1:def 4
theorem
for b1 being non empty ComplLattStr
for b2, b3 being Element of the carrier of b1 holds
b2 *' b3 = (b2 ` "\/" (b3 `)) `;

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

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

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

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

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

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

:: ROBBINS1:attrnot 6 => ROBBINS1:attr 6
definition
  let a1 be non empty \/-SemiLattStr;
  attr a1 is join-idempotent means
    for b1 being Element of the carrier of a1 holds
       b1 "\/" b1 = b1;
end;

:: ROBBINS1:dfs 7
definiens
  let a1 be non empty \/-SemiLattStr;
To prove
     a1 is join-idempotent
it is sufficient to prove
  thus for b1 being Element of the carrier of a1 holds
       b1 "\/" b1 = b1;

:: ROBBINS1:def 7
theorem
for b1 being non empty \/-SemiLattStr holds
      b1 is join-idempotent
   iff
      for b2 being Element of the carrier of b1 holds
         b2 "\/" b2 = b2;

:: ROBBINS1:funcreg 4
registration
  cluster TrivComplLat -> join-commutative join-associative strict Robbins Huntington join-idempotent;
end;

:: ROBBINS1:funcreg 5
registration
  cluster TrivOrtLat -> join-commutative join-associative strict Robbins Huntington;
end;

:: ROBBINS1:funcreg 6
registration
  cluster TrivOrtLat -> meet-commutative meet-associative meet-absorbing join-absorbing strict;
end;

:: ROBBINS1:exreg 7
registration
  cluster non empty join-commutative join-associative strict Robbins Huntington join-idempotent ComplLattStr;
end;

:: ROBBINS1:exreg 8
registration
  cluster non empty Lattice-like strict Robbins Huntington OrthoLattStr;
end;

:: ROBBINS1:funcnot 6 => ROBBINS1:func 5
definition
  let a1 be non empty join-commutative ComplLattStr;
  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 ComplLattStr
::  for a2, a3 being Element of the carrier of a1 holds
::  a2 + a3 = a3 + a2;
end;

:: ROBBINS1:th 1
theorem
for b1 being non empty join-commutative join-associative Huntington ComplLattStr
for b2, b3 being Element of the carrier of b1 holds
(b2 *' b3) + (b2 *' (b3 `)) = b2;

:: ROBBINS1:th 2
theorem
for b1 being non empty join-commutative join-associative Huntington ComplLattStr
for b2 being Element of the carrier of b1 holds
   b2 + (b2 `) = b2 ` + (b2 ` `);

:: ROBBINS1:th 3
theorem
for b1 being non empty join-commutative join-associative Huntington ComplLattStr
for b2 being Element of the carrier of b1 holds
   b2 ` ` = b2;

:: ROBBINS1:th 4
theorem
for b1 being non empty join-commutative join-associative Huntington ComplLattStr
for b2, b3 being Element of the carrier of b1 holds
b2 + (b2 `) = b3 + (b3 `);

:: ROBBINS1:th 5
theorem
for b1 being non empty join-commutative join-associative Huntington join-idempotent ComplLattStr holds
   ex b2 being Element of the carrier of b1 st
      for b3 being Element of the carrier of b1 holds
         b2 + b3 = b2 & b3 + (b3 `) = b2;

:: ROBBINS1:th 6
theorem
for b1 being non empty join-commutative join-associative Huntington join-idempotent ComplLattStr holds
   b1 is upper-bounded;

:: ROBBINS1:condreg 1
registration
  cluster non empty join-commutative join-associative Huntington join-idempotent -> upper-bounded (ComplLattStr);
end;

:: ROBBINS1:funcnot 7 => LATTICES:func 6
definition
  let a1 be non empty \/-SemiLattStr;
  func Top A1 -> Element of the carrier of a1 means
    ex b1 being Element of the carrier of a1 st
       it = b1 + (b1 `);
end;

:: ROBBINS1:def 8
theorem
for b1 being non empty join-commutative join-associative Huntington join-idempotent ComplLattStr
for b2 being Element of the carrier of b1 holds
      b2 = Top b1
   iff
      ex b3 being Element of the carrier of b1 st
         b2 = b3 + (b3 `);

:: ROBBINS1:th 7
theorem
for b1 being non empty join-commutative join-associative Huntington join-idempotent ComplLattStr holds
   ex b2 being Element of the carrier of b1 st
      for b3 being Element of the carrier of b1 holds
         b2 *' b3 = b2 & (b3 + (b3 `)) ` = b2;

:: ROBBINS1:th 8
theorem
for b1 being non empty join-commutative join-associative ComplLattStr
for b2, b3 being Element of the carrier of b1 holds
b2 *' b3 = b3 *' b2;

:: ROBBINS1:funcnot 8 => ROBBINS1:func 6
definition
  let a1 be non empty join-commutative join-associative ComplLattStr;
  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 join-associative ComplLattStr
::  for a2, a3 being Element of the carrier of a1 holds
::  a2 *' a3 = a3 *' a2;
end;

:: ROBBINS1:funcnot 9 => ROBBINS1:func 7
definition
  let a1 be non empty join-commutative join-associative Huntington join-idempotent ComplLattStr;
  func Bot A1 -> Element of the carrier of a1 means
    for b1 being Element of the carrier of a1 holds
       it *' b1 = it;
end;

:: ROBBINS1:def 9
theorem
for b1 being non empty join-commutative join-associative Huntington join-idempotent ComplLattStr
for b2 being Element of the carrier of b1 holds
      b2 = Bot b1
   iff
      for b3 being Element of the carrier of b1 holds
         b2 *' b3 = b2;

:: ROBBINS1:th 9
theorem
for b1 being non empty join-commutative join-associative Huntington join-idempotent ComplLattStr
for b2 being Element of the carrier of b1 holds
   Bot b1 = (b2 + (b2 `)) `;

:: ROBBINS1:th 10
theorem
for b1 being non empty join-commutative join-associative Huntington join-idempotent ComplLattStr holds
   (Top b1) ` = Bot b1 & Top b1 = (Bot b1) `;

:: ROBBINS1:th 11
theorem
for b1 being non empty join-commutative join-associative Huntington ComplLattStr
for b2, b3 being Element of the carrier of b1
      st b2 ` = b3 `
   holds b2 = b3;

:: ROBBINS1:th 12
theorem
for b1 being non empty join-commutative join-associative Huntington ComplLattStr
for b2, b3 being Element of the carrier of b1 holds
b2 + ((b3 + (b3 `)) `) = b2;

:: ROBBINS1:th 13
theorem
for b1 being non empty join-commutative join-associative Huntington ComplLattStr
for b2 being Element of the carrier of b1 holds
   b2 + b2 = b2;

:: ROBBINS1:condreg 2
registration
  cluster non empty join-commutative join-associative Huntington -> join-idempotent (ComplLattStr);
end;

:: ROBBINS1:th 14
theorem
for b1 being non empty join-commutative join-associative Huntington ComplLattStr
for b2 being Element of the carrier of b1 holds
   b2 + Bot b1 = b2;

:: ROBBINS1:th 15
theorem
for b1 being non empty join-commutative join-associative Huntington ComplLattStr
for b2 being Element of the carrier of b1 holds
   b2 *' Top b1 = b2;

:: ROBBINS1:th 16
theorem
for b1 being non empty join-commutative join-associative Huntington ComplLattStr
for b2 being Element of the carrier of b1 holds
   b2 *' (b2 `) = Bot b1;

:: ROBBINS1:th 17
theorem
for b1 being non empty join-commutative join-associative Huntington ComplLattStr
for b2, b3, b4 being Element of the carrier of b1 holds
b2 *' (b3 *' b4) = (b2 *' b3) *' b4;

:: ROBBINS1:th 18
theorem
for b1 being non empty join-commutative join-associative Huntington ComplLattStr
for b2, b3 being Element of the carrier of b1 holds
b2 + b3 = (b2 ` *' (b3 `)) `;

:: ROBBINS1:th 19
theorem
for b1 being non empty join-commutative join-associative Huntington ComplLattStr
for b2 being Element of the carrier of b1 holds
   b2 *' b2 = b2;

:: ROBBINS1:th 20
theorem
for b1 being non empty join-commutative join-associative Huntington ComplLattStr
for b2 being Element of the carrier of b1 holds
   b2 + Top b1 = Top b1;

:: ROBBINS1:th 21
theorem
for b1 being non empty join-commutative join-associative Huntington ComplLattStr
for b2, b3 being Element of the carrier of b1 holds
b2 + (b2 *' b3) = b2;

:: ROBBINS1:th 22
theorem
for b1 being non empty join-commutative join-associative Huntington ComplLattStr
for b2, b3 being Element of the carrier of b1 holds
b2 *' (b2 + b3) = b2;

:: ROBBINS1:th 23
theorem
for b1 being non empty join-commutative join-associative Huntington ComplLattStr
for b2, b3 being Element of the carrier of b1
      st b2 ` + b3 = Top b1 & b3 ` + b2 = Top b1
   holds b2 = b3;

:: ROBBINS1:th 24
theorem
for b1 being non empty join-commutative join-associative Huntington ComplLattStr
for b2, b3 being Element of the carrier of b1
      st b2 + b3 = Top b1 & b2 *' b3 = Bot b1
   holds b2 ` = b3;

:: ROBBINS1:th 25
theorem
for b1 being non empty join-commutative join-associative Huntington ComplLattStr
for b2, b3, b4 being Element of the carrier of b1 holds
((((((((b2 *' b3) *' b4) + ((b2 *' b3) *' (b4 `))) + ((b2 *' (b3 `)) *' b4)) + ((b2 *' (b3 `)) *' (b4 `))) + ((b2 ` *' b3) *' b4)) + ((b2 ` *' b3) *' (b4 `))) + ((b2 ` *' (b3 `)) *' b4)) + ((b2 ` *' (b3 `)) *' (b4 `)) = Top b1;

:: ROBBINS1:th 26
theorem
for b1 being non empty join-commutative join-associative Huntington ComplLattStr
for b2, b3, b4 being Element of the carrier of b1 holds
(b2 *' b4) *' (b3 *' (b4 `)) = Bot b1 &
 ((b2 *' b3) *' b4) *' ((b2 ` *' b3) *' b4) = Bot b1 &
 ((b2 *' (b3 `)) *' b4) *' ((b2 ` *' b3) *' b4) = Bot b1 &
 ((b2 *' b3) *' b4) *' ((b2 ` *' (b3 `)) *' b4) = Bot b1 &
 ((b2 *' b3) *' (b4 `)) *' ((b2 ` *' (b3 `)) *' (b4 `)) = Bot b1;

:: ROBBINS1:th 27
theorem
for b1 being non empty join-commutative join-associative Huntington ComplLattStr
for b2, b3, b4 being Element of the carrier of b1 holds
(b2 *' b3) + (b2 *' b4) = (((b2 *' b3) *' b4) + ((b2 *' b3) *' (b4 `))) + ((b2 *' (b3 `)) *' b4);

:: ROBBINS1:th 28
theorem
for b1 being non empty join-commutative join-associative Huntington ComplLattStr
for b2, b3, b4 being Element of the carrier of b1 holds
(b2 *' (b3 + b4)) ` = (((((b2 *' (b3 `)) *' (b4 `)) + ((b2 ` *' b3) *' b4)) + ((b2 ` *' b3) *' (b4 `))) + ((b2 ` *' (b3 `)) *' b4)) + ((b2 ` *' (b3 `)) *' (b4 `));

:: ROBBINS1:th 29
theorem
for b1 being non empty join-commutative join-associative Huntington ComplLattStr
for b2, b3, b4 being Element of the carrier of b1 holds
((b2 *' b3) + (b2 *' b4)) + ((b2 *' (b3 + b4)) `) = Top b1;

:: ROBBINS1:th 30
theorem
for b1 being non empty join-commutative join-associative Huntington ComplLattStr
for b2, b3, b4 being Element of the carrier of b1 holds
((b2 *' b3) + (b2 *' b4)) *' ((b2 *' (b3 + b4)) `) = Bot b1;

:: ROBBINS1:th 31
theorem
for b1 being non empty join-commutative join-associative Huntington ComplLattStr
for b2, b3, b4 being Element of the carrier of b1 holds
b2 *' (b3 + b4) = (b2 *' b3) + (b2 *' b4);

:: ROBBINS1:th 32
theorem
for b1 being non empty join-commutative join-associative Huntington ComplLattStr
for b2, b3, b4 being Element of the carrier of b1 holds
b2 + (b3 *' b4) = (b2 + b3) *' (b2 + b4);

:: ROBBINS1:attrnot 7 => ROBBINS1:attr 7
definition
  let a1 be non empty OrthoLattStr;
  attr a1 is well-complemented means
    for b1 being Element of the carrier of a1 holds
       b1 ` is_a_complement_of b1;
end;

:: ROBBINS1:dfs 10
definiens
  let a1 be non empty OrthoLattStr;
To prove
     a1 is well-complemented
it is sufficient to prove
  thus for b1 being Element of the carrier of a1 holds
       b1 ` is_a_complement_of b1;

:: ROBBINS1:def 10
theorem
for b1 being non empty OrthoLattStr holds
      b1 is well-complemented
   iff
      for b2 being Element of the carrier of b1 holds
         b2 ` is_a_complement_of b2;

:: ROBBINS1:funcreg 7
registration
  cluster TrivOrtLat -> Boolean strict well-complemented;
end;

:: ROBBINS1:modenot 1
definition
  mode preOrthoLattice is non empty Lattice-like OrthoLattStr;
end;

:: ROBBINS1:exreg 9
registration
  cluster non empty join-commutative join-associative meet-commutative meet-associative meet-absorbing join-absorbing Lattice-like Boolean strict well-complemented OrthoLattStr;
end;

:: ROBBINS1:th 33
theorem
for b1 being non empty Lattice-like distributive well-complemented OrthoLattStr
for b2 being Element of the carrier of b1 holds
   b2 ` ` = b2;

:: ROBBINS1:th 34
theorem
for b1 being non empty Lattice-like distributive bounded well-complemented OrthoLattStr
for b2, b3 being Element of the carrier of b1 holds
b2 "/\" b3 = (b2 ` "\/" (b3 `)) `;

:: ROBBINS1:funcnot 10 => ROBBINS1:func 8
definition
  let a1 be non empty ComplLattStr;
  func CLatt A1 -> strict OrthoLattStr means
    the carrier of it = the carrier of a1 &
     the L_join of it = the L_join of a1 &
     the Compl of it = the Compl of a1 &
     (for b1, b2 being Element of the carrier of a1 holds
     (the L_meet of it) .(b1,b2) = b1 *' b2);
end;

:: ROBBINS1:def 11
theorem
for b1 being non empty ComplLattStr
for b2 being strict OrthoLattStr holds
      b2 = CLatt b1
   iff
      the carrier of b2 = the carrier of b1 &
       the L_join of b2 = the L_join of b1 &
       the Compl of b2 = the Compl of b1 &
       (for b3, b4 being Element of the carrier of b1 holds
       (the L_meet of b2) .(b3,b4) = b3 *' b4);

:: ROBBINS1:funcreg 8
registration
  let a1 be non empty ComplLattStr;
  cluster CLatt a1 -> non empty strict;
end;

:: ROBBINS1:funcreg 9
registration
  let a1 be non empty join-commutative ComplLattStr;
  cluster CLatt a1 -> join-commutative strict;
end;

:: ROBBINS1:funcreg 10
registration
  let a1 be non empty join-associative ComplLattStr;
  cluster CLatt a1 -> join-associative strict;
end;

:: ROBBINS1:funcreg 11
registration
  let a1 be non empty join-commutative join-associative ComplLattStr;
  cluster CLatt a1 -> meet-commutative strict;
end;

:: ROBBINS1:th 35
theorem
for b1 being non empty ComplLattStr
for b2, b3 being Element of the carrier of b1
for b4, b5 being Element of the carrier of CLatt b1
      st b2 = b4 & b3 = b5
   holds b2 *' b3 = b4 "/\" b5 & b2 "\/" b3 = b4 "\/" b5 & b2 ` = b4 `;

:: ROBBINS1:funcreg 12
registration
  let a1 be non empty join-commutative join-associative Huntington ComplLattStr;
  cluster CLatt a1 -> meet-associative meet-absorbing join-absorbing strict;
end;

:: ROBBINS1:funcreg 13
registration
  let a1 be non empty Huntington ComplLattStr;
  cluster CLatt a1 -> strict Huntington;
end;

:: ROBBINS1:funcreg 14
registration
  let a1 be non empty join-commutative join-associative Huntington ComplLattStr;
  cluster CLatt a1 -> lower-bounded strict;
end;

:: ROBBINS1:th 36
theorem
for b1 being non empty join-commutative join-associative Huntington ComplLattStr holds
   Bot b1 = Bottom CLatt b1;

:: ROBBINS1:funcreg 15
registration
  let a1 be non empty join-commutative join-associative Huntington ComplLattStr;
  cluster CLatt a1 -> distributive bounded complemented strict;
end;

:: ROBBINS1:funcnot 11 => ROBBINS1:func 3
notation
  let a1 be non empty ComplLattStr;
  let a2 be Element of the carrier of a1;
  synonym - a2 for a2 `;
end;

:: ROBBINS1:attrnot 8 => ROBBINS1:attr 5
definition
  let a1 be non empty ComplLattStr;
  attr a1 is Huntington means
    for b1, b2 being Element of the carrier of a1 holds
    (b1 ` + (b2 `)) ` + ((b1 + (b2 `)) `) = b2;
end;

:: ROBBINS1:dfs 12
definiens
  let a1 be non empty join-commutative ComplLattStr;
To prove
     a1 is Huntington
it is sufficient to prove
  thus for b1, b2 being Element of the carrier of a1 holds
    (b1 ` + (b2 `)) ` + ((b1 + (b2 `)) `) = b2;

:: ROBBINS1:def 12
theorem
for b1 being non empty join-commutative ComplLattStr holds
      b1 is Huntington
   iff
      for b2, b3 being Element of the carrier of b1 holds
      (b2 ` + (b3 `)) ` + ((b2 + (b3 `)) `) = b3;

:: ROBBINS1:attrnot 9 => ROBBINS1:attr 8
definition
  let a1 be non empty ComplLattStr;
  attr a1 is with_idempotent_element means
    ex b1 being Element of the carrier of a1 st
       b1 "\/" b1 = b1;
end;

:: ROBBINS1:dfs 13
definiens
  let a1 be non empty ComplLattStr;
To prove
     a1 is with_idempotent_element
it is sufficient to prove
  thus ex b1 being Element of the carrier of a1 st
       b1 "\/" b1 = b1;

:: ROBBINS1:def 13
theorem
for b1 being non empty ComplLattStr holds
      b1 is with_idempotent_element
   iff
      ex b2 being Element of the carrier of b1 st
         b2 "\/" b2 = b2;

:: ROBBINS1:funcnot 12 => ROBBINS1:func 9
definition
  let a1 be non empty ComplLattStr;
  let a2, a3 be Element of the carrier of a1;
  func \delta(A2,A3) -> Element of the carrier of a1 equals
    (a2 ` "\/" a3) `;
end;

:: ROBBINS1:def 14
theorem
for b1 being non empty ComplLattStr
for b2, b3 being Element of the carrier of b1 holds
\delta(b2,b3) = (b2 ` "\/" b3) `;

:: ROBBINS1:funcnot 13 => ROBBINS1:func 10
definition
  let a1 be non empty ComplLattStr;
  let a2, a3 be Element of the carrier of a1;
  func Expand(A2,A3) -> Element of the carrier of a1 equals
    \delta(a2 "\/" a3,\delta(a2,a3));
end;

:: ROBBINS1:def 15
theorem
for b1 being non empty ComplLattStr
for b2, b3 being Element of the carrier of b1 holds
Expand(b2,b3) = \delta(b2 "\/" b3,\delta(b2,b3));

:: ROBBINS1:funcnot 14 => ROBBINS1:func 11
definition
  let a1 be non empty ComplLattStr;
  let a2 be Element of the carrier of a1;
  func A2 _0 -> Element of the carrier of a1 equals
    (a2 ` "\/" a2) `;
end;

:: ROBBINS1:def 16
theorem
for b1 being non empty ComplLattStr
for b2 being Element of the carrier of b1 holds
   b2 _0 = (b2 ` "\/" b2) `;

:: ROBBINS1:funcnot 15 => ROBBINS1:func 12
definition
  let a1 be non empty ComplLattStr;
  let a2 be Element of the carrier of a1;
  func Double A2 -> Element of the carrier of a1 equals
    a2 "\/" a2;
end;

:: ROBBINS1:def 17
theorem
for b1 being non empty ComplLattStr
for b2 being Element of the carrier of b1 holds
   Double b2 = b2 "\/" b2;

:: ROBBINS1:funcnot 16 => ROBBINS1:func 13
definition
  let a1 be non empty ComplLattStr;
  let a2 be Element of the carrier of a1;
  func A2 _1 -> Element of the carrier of a1 equals
    a2 _0 "\/" a2;
end;

:: ROBBINS1:def 18
theorem
for b1 being non empty ComplLattStr
for b2 being Element of the carrier of b1 holds
   b2 _1 = b2 _0 "\/" b2;

:: ROBBINS1:funcnot 17 => ROBBINS1:func 14
definition
  let a1 be non empty ComplLattStr;
  let a2 be Element of the carrier of a1;
  func A2 _2 -> Element of the carrier of a1 equals
    a2 _0 "\/" Double a2;
end;

:: ROBBINS1:def 19
theorem
for b1 being non empty ComplLattStr
for b2 being Element of the carrier of b1 holds
   b2 _2 = b2 _0 "\/" Double b2;

:: ROBBINS1:funcnot 18 => ROBBINS1:func 15
definition
  let a1 be non empty ComplLattStr;
  let a2 be Element of the carrier of a1;
  func A2 _3 -> Element of the carrier of a1 equals
    a2 _0 "\/" ((Double a2) "\/" a2);
end;

:: ROBBINS1:def 20
theorem
for b1 being non empty ComplLattStr
for b2 being Element of the carrier of b1 holds
   b2 _3 = b2 _0 "\/" ((Double b2) "\/" b2);

:: ROBBINS1:funcnot 19 => ROBBINS1:func 16
definition
  let a1 be non empty ComplLattStr;
  let a2 be Element of the carrier of a1;
  func A2 _4 -> Element of the carrier of a1 equals
    a2 _0 "\/" ((Double a2) "\/" Double a2);
end;

:: ROBBINS1:def 21
theorem
for b1 being non empty ComplLattStr
for b2 being Element of the carrier of b1 holds
   b2 _4 = b2 _0 "\/" ((Double b2) "\/" Double b2);

:: ROBBINS1:th 37
theorem
for b1 being non empty join-commutative join-associative Robbins ComplLattStr
for b2, b3 being Element of the carrier of b1 holds
\delta(b2 + b3,\delta(b2,b3)) = b3;

:: ROBBINS1:th 38
theorem
for b1 being non empty join-commutative join-associative Robbins ComplLattStr
for b2, b3 being Element of the carrier of b1 holds
Expand(b2,b3) = b3;

:: ROBBINS1:th 39
theorem
for b1 being non empty join-commutative join-associative Robbins ComplLattStr
for b2, b3, b4 being Element of the carrier of b1 holds
\delta(b2 ` + b3,b4) = ((\delta(b2,b3)) + b4) `;

:: ROBBINS1:th 40
theorem
for b1 being non empty join-commutative join-associative Robbins ComplLattStr
for b2 being Element of the carrier of b1 holds
   \delta(b2,b2) = b2 _0;

:: ROBBINS1:th 41
theorem
for b1 being non empty join-commutative join-associative Robbins ComplLattStr
for b2 being Element of the carrier of b1 holds
   \delta(Double b2,b2 _0) = b2;

:: ROBBINS1:th 42
theorem
for b1 being non empty join-commutative join-associative Robbins ComplLattStr
for b2 being Element of the carrier of b1 holds
   \delta(b2 _2,b2) = b2 _0;

:: ROBBINS1:th 44
theorem
for b1 being non empty join-commutative join-associative Robbins ComplLattStr
for b2 being Element of the carrier of b1 holds
   b2 _4 + (b2 _0) = b2 _3 + (b2 _1);

:: ROBBINS1:th 45
theorem
for b1 being non empty join-commutative join-associative Robbins ComplLattStr
for b2 being Element of the carrier of b1 holds
   b2 _3 + (b2 _0) = b2 _2 + (b2 _1);

:: ROBBINS1:th 46
theorem
for b1 being non empty join-commutative join-associative Robbins ComplLattStr
for b2 being Element of the carrier of b1 holds
   b2 _3 + b2 = b2 _4;

:: ROBBINS1:th 47
theorem
for b1 being non empty join-commutative join-associative Robbins ComplLattStr
for b2 being Element of the carrier of b1 holds
   \delta(b2 _3,b2 _0) = b2;

:: ROBBINS1:th 48
theorem
for b1 being non empty join-commutative join-associative Robbins ComplLattStr
for b2, b3, b4 being Element of the carrier of b1
      st b2 ` = b3 `
   holds \delta(b2,b4) = \delta(b3,b4);

:: ROBBINS1:th 49
theorem
for b1 being non empty join-commutative join-associative Robbins ComplLattStr
for b2, b3 being Element of the carrier of b1 holds
\delta(b2,b3 `) = \delta(b3,b2 `);

:: ROBBINS1:th 50
theorem
for b1 being non empty join-commutative join-associative Robbins ComplLattStr
for b2 being Element of the carrier of b1 holds
   \delta(b2 _3,b2) = b2 _0;

:: ROBBINS1:th 51
theorem
for b1 being non empty join-commutative join-associative Robbins ComplLattStr
for b2 being Element of the carrier of b1 holds
   \delta(b2 _1 + (b2 _3),b2) = b2 _0;

:: ROBBINS1:th 52
theorem
for b1 being non empty join-commutative join-associative Robbins ComplLattStr
for b2 being Element of the carrier of b1 holds
   \delta(b2 _1 + (b2 _2),b2) = b2 _0;

:: ROBBINS1:th 53
theorem
for b1 being non empty join-commutative join-associative Robbins ComplLattStr
for b2 being Element of the carrier of b1 holds
   \delta(b2 _1 + (b2 _3),b2 _0) = b2;

:: ROBBINS1:funcnot 20 => ROBBINS1:func 17
definition
  let a1 be non empty join-commutative join-associative Robbins ComplLattStr;
  let a2 be Element of the carrier of a1;
  func \beta A2 -> Element of the carrier of a1 equals
    ((a2 _1 + (a2 _3)) ` + a2) + (a2 _3 `);
end;

:: ROBBINS1:def 22
theorem
for b1 being non empty join-commutative join-associative Robbins ComplLattStr
for b2 being Element of the carrier of b1 holds
   \beta b2 = ((b2 _1 + (b2 _3)) ` + b2) + (b2 _3 `);

:: ROBBINS1:th 54
theorem
for b1 being non empty join-commutative join-associative Robbins ComplLattStr
for b2 being Element of the carrier of b1 holds
   \delta(\beta b2,b2) = b2 _3 `;

:: ROBBINS1:th 55
theorem
for b1 being non empty join-commutative join-associative Robbins ComplLattStr
for b2 being Element of the carrier of b1 holds
   \delta(\beta b2,b2) = (b2 _1 + (b2 _3)) `;

:: ROBBINS1:th 56
theorem
for b1 being non empty join-commutative join-associative Robbins ComplLattStr holds
   ex b2, b3 being Element of the carrier of b1 st
      (b2 + b3) ` = b3 `;

:: ROBBINS1:th 57
theorem
for b1 being non empty join-commutative join-associative Robbins ComplLattStr
      st for b2 being Element of the carrier of b1 holds
           b2 ` ` = b2
   holds b1 is Huntington;

:: ROBBINS1:th 58
theorem
for b1 being non empty join-commutative join-associative Robbins ComplLattStr
      st b1 is with_idempotent_element
   holds b1 is Huntington;

:: ROBBINS1:funcreg 16
registration
  cluster TrivComplLat -> strict with_idempotent_element;
end;

:: ROBBINS1:condreg 3
registration
  cluster non empty join-commutative join-associative Robbins with_idempotent_element -> Huntington (ComplLattStr);
end;

:: ROBBINS1:th 59
theorem
for b1 being non empty join-commutative join-associative Robbins ComplLattStr
      st ex b2, b3 being Element of the carrier of b1 st
           b2 + b3 = b2
   holds b1 is Huntington;

:: ROBBINS1:th 60
theorem
for b1 being non empty join-commutative join-associative Robbins ComplLattStr holds
   ex b2, b3 being Element of the carrier of b1 st
      b2 + b3 = b3;

:: ROBBINS1:condreg 4
registration
  cluster non empty join-commutative join-associative Robbins -> Huntington (ComplLattStr);
end;

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

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

:: ROBBINS1:def 23
theorem
for b1 being non empty OrthoLattStr holds
      b1 is de_Morgan
   iff
      for b2, b3 being Element of the carrier of b1 holds
      b2 "/\" b3 = (b2 ` "\/" (b3 `)) `;

:: ROBBINS1:funcreg 17
registration
  let a1 be non empty ComplLattStr;
  cluster CLatt a1 -> strict de_Morgan;
end;

:: ROBBINS1:th 61
theorem
for b1 being non empty join-commutative meet-commutative well-complemented OrthoLattStr
for b2 being Element of the carrier of b1 holds
   b2 + (b2 `) = Top b1 & b2 "/\" (b2 `) = Bottom b1;

:: ROBBINS1:th 62
theorem
for b1 being non empty Lattice-like distributive bounded well-complemented OrthoLattStr holds
   (Top b1) ` = Bottom b1;

:: ROBBINS1:funcreg 18
registration
  cluster TrivOrtLat -> strict de_Morgan;
end;

:: ROBBINS1:exreg 10
registration
  cluster non empty join-commutative join-associative meet-commutative meet-associative meet-absorbing join-absorbing Lattice-like Boolean strict Robbins Huntington de_Morgan OrthoLattStr;
end;

:: ROBBINS1:condreg 5
registration
  cluster non empty join-commutative join-associative de_Morgan -> meet-commutative (OrthoLattStr);
end;

:: ROBBINS1:th 63
theorem
for b1 being non empty Lattice-like Huntington de_Morgan OrthoLattStr holds
   Bot b1 = Bottom b1;

:: ROBBINS1:condreg 6
registration
  cluster non empty Lattice-like Boolean well-complemented -> Huntington (OrthoLattStr);
end;

:: ROBBINS1:condreg 7
registration
  cluster non empty Lattice-like Huntington de_Morgan -> Boolean (OrthoLattStr);
end;

:: ROBBINS1:condreg 8
registration
  cluster non empty Lattice-like Robbins de_Morgan -> Boolean (OrthoLattStr);
end;

:: ROBBINS1:condreg 9
registration
  cluster non empty Lattice-like Boolean well-complemented -> Robbins (OrthoLattStr);
end;