Article SHEFFER1, MML version 4.99.1005

:: SHEFFER1: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 `);

:: SHEFFER1:attrnot 1 => SHEFFER1:attr 1
definition
  let a1 be non empty LattStr;
  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 = b2 & b2 "/\" b1 = b2;
end;

:: SHEFFER1:dfs 1
definiens
  let a1 be non empty LattStr;
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 = b2 & b2 "/\" b1 = b2;

:: SHEFFER1:def 1
theorem
for b1 being non empty LattStr 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 = b3 & b3 "/\" b2 = b3;

:: SHEFFER1:funcnot 1 => SHEFFER1:func 1
definition
  let a1 be non empty LattStr;
  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 = b1 & b1 "/\" it = b1;
end;

:: SHEFFER1:def 2
theorem
for b1 being non empty LattStr
   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 = b3 & b3 "/\" b2 = b3;

:: SHEFFER1:attrnot 2 => SHEFFER1:attr 2
definition
  let a1 be non empty LattStr;
  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 = b2 & b2 "\/" b1 = b2;
end;

:: SHEFFER1:dfs 3
definiens
  let a1 be non empty LattStr;
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 = b2 & b2 "\/" b1 = b2;

:: SHEFFER1:def 3
theorem
for b1 being non empty LattStr 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 = b3 & b3 "\/" b2 = b3;

:: SHEFFER1:funcnot 2 => SHEFFER1:func 2
definition
  let a1 be non empty LattStr;
  assume a1 is lower-bounded';
  func Bot' A1 -> Element of the carrier of a1 means
    for b1 being Element of the carrier of a1 holds
       it "\/" b1 = b1 & b1 "\/" it = b1;
end;

:: SHEFFER1:def 4
theorem
for b1 being non empty LattStr
   st b1 is lower-bounded'
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 = b3 & b3 "\/" b2 = b3;

:: SHEFFER1:attrnot 3 => SHEFFER1:attr 3
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;

:: SHEFFER1:dfs 5
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);

:: SHEFFER1:def 5
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);

:: SHEFFER1:prednot 1 => SHEFFER1:pred 1
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
    a3 "\/" a2 = Top' a1 & a2 "\/" a3 = Top' a1 & a3 "/\" a2 = Bot' a1 & a2 "/\" a3 = Bot' a1;
end;

:: SHEFFER1:dfs 6
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 a3 "\/" a2 = Top' a1 & a2 "\/" a3 = Top' a1 & a3 "/\" a2 = Bot' a1 & a2 "/\" a3 = Bot' a1;

:: SHEFFER1:def 6
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
   b3 "\/" b2 = Top' b1 & b2 "\/" b3 = Top' b1 & b3 "/\" b2 = Bot' b1 & b2 "/\" b3 = Bot' b1;

:: SHEFFER1:attrnot 4 => SHEFFER1:attr 4
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;

:: SHEFFER1:dfs 7
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;

:: SHEFFER1:def 7
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;

:: SHEFFER1:funcnot 3 => SHEFFER1:func 3
definition
  let a1 be non empty LattStr;
  let a2 be Element of the carrier of a1;
  assume a1 is complemented' & a1 is distributive & a1 is upper-bounded' & a1 is meet-commutative;
  func A2 `# -> Element of the carrier of a1 means
    it is_a_complement'_of a2;
end;

:: SHEFFER1:def 8
theorem
for b1 being non empty LattStr
for b2 being Element of the carrier of b1
   st b1 is complemented' & b1 is distributive & b1 is upper-bounded' & b1 is meet-commutative
for b3 being Element of the carrier of b1 holds
      b3 = b2 `#
   iff
      b3 is_a_complement'_of b2;

:: SHEFFER1:exreg 1
registration
  cluster non empty Lattice-like Boolean join-idempotent upper-bounded' lower-bounded' distributive' complemented' LattStr;
end;

:: SHEFFER1:th 3
theorem
for b1 being non empty join-commutative meet-commutative distributive upper-bounded' distributive' complemented' LattStr
for b2 being Element of the carrier of b1 holds
   b2 "\/" (b2 `#) = Top' b1;

:: SHEFFER1:th 4
theorem
for b1 being non empty join-commutative meet-commutative distributive upper-bounded' distributive' complemented' LattStr
for b2 being Element of the carrier of b1 holds
   b2 "/\" (b2 `#) = Bot' b1;

:: SHEFFER1:th 5
theorem
for b1 being non empty join-commutative meet-commutative distributive join-idempotent upper-bounded' distributive' complemented' LattStr
for b2 being Element of the carrier of b1 holds
   b2 "\/" Top' b1 = Top' b1;

:: SHEFFER1:th 6
theorem
for b1 being non empty join-commutative meet-commutative distributive join-idempotent upper-bounded' lower-bounded' distributive' complemented' LattStr
for b2 being Element of the carrier of b1 holds
   b2 "/\" Bot' b1 = Bot' b1;

:: SHEFFER1:th 7
theorem
for b1 being non empty join-commutative meet-commutative meet-absorbing join-absorbing distributive join-idempotent LattStr
for b2, b3, b4 being Element of the carrier of b1 holds
((b2 "\/" b3) "\/" b4) "/\" b2 = b2;

:: SHEFFER1:th 8
theorem
for b1 being non empty join-commutative meet-commutative meet-absorbing join-absorbing join-idempotent distributive' LattStr
for b2, b3, b4 being Element of the carrier of b1 holds
((b2 "/\" b3) "/\" b4) "\/" b2 = b2;

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

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

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

:: SHEFFER1:th 9
theorem
for b1 being non empty join-commutative meet-commutative distributive upper-bounded' lower-bounded' distributive' complemented' LattStr holds
   b1 is meet-idempotent;

:: SHEFFER1:th 10
theorem
for b1 being non empty join-commutative meet-commutative distributive upper-bounded' lower-bounded' distributive' complemented' LattStr holds
   b1 is join-idempotent;

:: SHEFFER1:th 11
theorem
for b1 being non empty join-commutative meet-commutative distributive join-idempotent upper-bounded' distributive' complemented' LattStr holds
   b1 is meet-absorbing;

:: SHEFFER1:th 12
theorem
for b1 being non empty join-commutative meet-commutative distributive join-idempotent upper-bounded' lower-bounded' distributive' complemented' LattStr holds
   b1 is join-absorbing;

:: SHEFFER1:th 13
theorem
for b1 being non empty join-commutative meet-commutative distributive join-idempotent upper-bounded' lower-bounded' distributive' complemented' LattStr holds
   b1 is upper-bounded;

:: SHEFFER1:th 14
theorem
for b1 being non empty Lattice-like Boolean LattStr holds
   b1 is upper-bounded';

:: SHEFFER1:th 15
theorem
for b1 being non empty join-commutative meet-commutative distributive join-idempotent upper-bounded' lower-bounded' distributive' complemented' LattStr holds
   b1 is lower-bounded;

:: SHEFFER1:th 16
theorem
for b1 being non empty Lattice-like Boolean LattStr holds
   b1 is lower-bounded';

:: SHEFFER1:th 17
theorem
for b1 being non empty join-commutative meet-commutative meet-absorbing join-absorbing distributive join-idempotent LattStr holds
   b1 is join-associative;

:: SHEFFER1:th 18
theorem
for b1 being non empty join-commutative meet-commutative meet-absorbing join-absorbing join-idempotent distributive' LattStr holds
   b1 is meet-associative;

:: SHEFFER1:th 19
theorem
for b1 being non empty join-commutative meet-commutative distributive join-idempotent upper-bounded' lower-bounded' distributive' complemented' LattStr holds
   Top b1 = Top' b1;

:: SHEFFER1:th 20
theorem
for b1 being non empty join-commutative meet-commutative distributive join-idempotent upper-bounded' lower-bounded' distributive' complemented' LattStr holds
   Bottom b1 = Bot' b1;

:: SHEFFER1:th 21
theorem
for b1 being non empty Lattice-like Boolean distributive' LattStr holds
   Top b1 = Top' b1;

:: SHEFFER1:th 22
theorem
for b1 being non empty Lattice-like distributive lower-bounded upper-bounded complemented Boolean distributive' LattStr holds
   Bottom b1 = Bot' b1;

:: SHEFFER1:th 23
theorem
for b1 being non empty join-commutative meet-commutative distributive join-idempotent upper-bounded' lower-bounded' distributive' complemented' LattStr
for b2, b3 being Element of the carrier of b1 holds
   b2 is_a_complement'_of b3
iff
   b2 is_a_complement_of b3;

:: SHEFFER1:th 24
theorem
for b1 being non empty join-commutative meet-commutative distributive join-idempotent upper-bounded' lower-bounded' distributive' complemented' LattStr holds
   b1 is complemented;

:: SHEFFER1:th 25
theorem
for b1 being non empty Lattice-like Boolean upper-bounded' lower-bounded' distributive' LattStr holds
   b1 is complemented';

:: SHEFFER1:th 26
theorem
for b1 being non empty LattStr holds
      b1 is non empty Lattice-like Boolean LattStr
   iff
      b1 is lower-bounded' & b1 is upper-bounded' & b1 is join-commutative & b1 is meet-commutative & b1 is distributive & b1 is distributive' & b1 is complemented';

:: SHEFFER1:condreg 1
registration
  cluster non empty Lattice-like Boolean -> join-commutative meet-commutative distributive upper-bounded' lower-bounded' distributive' complemented' (LattStr);
end;

:: SHEFFER1:condreg 2
registration
  cluster non empty join-commutative meet-commutative distributive upper-bounded' lower-bounded' distributive' complemented' -> Lattice-like Boolean (LattStr);
end;

:: SHEFFER1:structnot 1 => SHEFFER1:struct 1
definition
  struct(1-sorted) ShefferStr(#
    carrier -> set,
    stroke -> Function-like quasi_total Relation of [:the carrier of it,the carrier of it:],the carrier of it
  #);
end;

:: SHEFFER1:attrnot 6 => SHEFFER1:attr 6
definition
  let a1 be ShefferStr;
  attr a1 is strict;
end;

:: SHEFFER1:exreg 2
registration
  cluster strict ShefferStr;
end;

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

:: SHEFFER1:selnot 1 => SHEFFER1:sel 1
definition
  let a1 be ShefferStr;
  sel the stroke of a1 -> Function-like quasi_total Relation of [:the carrier of a1,the carrier of a1:],the carrier of a1;
end;

:: SHEFFER1:structnot 2 => SHEFFER1:struct 2
definition
  struct(ShefferStrLattStr) ShefferLattStr(#
    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,
    stroke -> Function-like quasi_total Relation of [:the carrier of it,the carrier of it:],the carrier of it
  #);
end;

:: SHEFFER1:attrnot 7 => SHEFFER1:attr 7
definition
  let a1 be ShefferLattStr;
  attr a1 is strict;
end;

:: SHEFFER1:exreg 3
registration
  cluster strict ShefferLattStr;
end;

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

:: SHEFFER1:structnot 3 => SHEFFER1:struct 3
definition
  struct(ShefferStrOrthoLattStr) ShefferOrthoLattStr(#
    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,
    stroke -> Function-like quasi_total Relation of [:the carrier of it,the carrier of it:],the carrier of it
  #);
end;

:: SHEFFER1:attrnot 8 => SHEFFER1:attr 8
definition
  let a1 be ShefferOrthoLattStr;
  attr a1 is strict;
end;

:: SHEFFER1:exreg 4
registration
  cluster strict ShefferOrthoLattStr;
end;

:: SHEFFER1:aggrnot 3 => SHEFFER1: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;
  let a5 be Function-like quasi_total Relation of [:a1,a1:],a1;
  aggr ShefferOrthoLattStr(#a1,a2,a3,a4,a5#) -> strict ShefferOrthoLattStr;
end;

:: SHEFFER1:funcnot 4 => SHEFFER1:func 4
definition
  func TrivShefferOrthoLattStr -> ShefferOrthoLattStr equals
    ShefferOrthoLattStr(#1,op2,op2,op1,op2#);
end;

:: SHEFFER1:def 10
theorem
TrivShefferOrthoLattStr = ShefferOrthoLattStr(#1,op2,op2,op1,op2#);

:: SHEFFER1:exreg 5
registration
  cluster non empty ShefferStr;
end;

:: SHEFFER1:exreg 6
registration
  cluster non empty ShefferLattStr;
end;

:: SHEFFER1:exreg 7
registration
  cluster non empty ShefferOrthoLattStr;
end;

:: SHEFFER1:funcnot 5 => SHEFFER1:func 5
definition
  let a1 be non empty ShefferStr;
  let a2, a3 be Element of the carrier of a1;
  func A2 | A3 -> Element of the carrier of a1 equals
    (the stroke of a1) .(a2,a3);
end;

:: SHEFFER1:def 11
theorem
for b1 being non empty ShefferStr
for b2, b3 being Element of the carrier of b1 holds
b2 | b3 = (the stroke of b1) .(b2,b3);

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

:: SHEFFER1:dfs 12
definiens
  let a1 be non empty ShefferOrthoLattStr;
To prove
     a1 is properly_defined
it is sufficient to prove
  thus (for b1 being Element of the carrier of a1 holds
        b1 | b1 = b1 `) &
     (for b1, b2 being Element of the carrier of a1 holds
     b1 "\/" b2 = (b1 | b1) | (b2 | b2)) &
     (for b1, b2 being Element of the carrier of a1 holds
     b1 "/\" b2 = (b1 | b2) | (b1 | b2)) &
     (for b1, b2 being Element of the carrier of a1 holds
     b1 | b2 = b1 ` "\/" (b2 `));

:: SHEFFER1:def 12
theorem
for b1 being non empty ShefferOrthoLattStr holds
      b1 is properly_defined
   iff
      (for b2 being Element of the carrier of b1 holds
          b2 | b2 = b2 `) &
       (for b2, b3 being Element of the carrier of b1 holds
       b2 "\/" b3 = (b2 | b2) | (b3 | b3)) &
       (for b2, b3 being Element of the carrier of b1 holds
       b2 "/\" b3 = (b2 | b3) | (b2 | b3)) &
       (for b2, b3 being Element of the carrier of b1 holds
       b2 | b3 = b2 ` "\/" (b3 `));

:: SHEFFER1:attrnot 10 => SHEFFER1:attr 10
definition
  let a1 be non empty ShefferStr;
  attr a1 is satisfying_Sheffer_1 means
    for b1 being Element of the carrier of a1 holds
       (b1 | b1) | (b1 | b1) = b1;
end;

:: SHEFFER1:dfs 13
definiens
  let a1 be non empty ShefferStr;
To prove
     a1 is satisfying_Sheffer_1
it is sufficient to prove
  thus for b1 being Element of the carrier of a1 holds
       (b1 | b1) | (b1 | b1) = b1;

:: SHEFFER1:def 13
theorem
for b1 being non empty ShefferStr holds
      b1 is satisfying_Sheffer_1
   iff
      for b2 being Element of the carrier of b1 holds
         (b2 | b2) | (b2 | b2) = b2;

:: SHEFFER1:attrnot 11 => SHEFFER1:attr 11
definition
  let a1 be non empty ShefferStr;
  attr a1 is satisfying_Sheffer_2 means
    for b1, b2 being Element of the carrier of a1 holds
    b1 | (b2 | (b2 | b2)) = b1 | b1;
end;

:: SHEFFER1:dfs 14
definiens
  let a1 be non empty ShefferStr;
To prove
     a1 is satisfying_Sheffer_2
it is sufficient to prove
  thus for b1, b2 being Element of the carrier of a1 holds
    b1 | (b2 | (b2 | b2)) = b1 | b1;

:: SHEFFER1:def 14
theorem
for b1 being non empty ShefferStr holds
      b1 is satisfying_Sheffer_2
   iff
      for b2, b3 being Element of the carrier of b1 holds
      b2 | (b3 | (b3 | b3)) = b2 | b2;

:: SHEFFER1:attrnot 12 => SHEFFER1:attr 12
definition
  let a1 be non empty ShefferStr;
  attr a1 is satisfying_Sheffer_3 means
    for b1, b2, b3 being Element of the carrier of a1 holds
    (b1 | (b2 | b3)) | (b1 | (b2 | b3)) = ((b2 | b2) | b1) | ((b3 | b3) | b1);
end;

:: SHEFFER1:dfs 15
definiens
  let a1 be non empty ShefferStr;
To prove
     a1 is satisfying_Sheffer_3
it is sufficient to prove
  thus for b1, b2, b3 being Element of the carrier of a1 holds
    (b1 | (b2 | b3)) | (b1 | (b2 | b3)) = ((b2 | b2) | b1) | ((b3 | b3) | b1);

:: SHEFFER1:def 15
theorem
for b1 being non empty ShefferStr holds
      b1 is satisfying_Sheffer_3
   iff
      for b2, b3, b4 being Element of the carrier of b1 holds
      (b2 | (b3 | b4)) | (b2 | (b3 | b4)) = ((b3 | b3) | b2) | ((b4 | b4) | b2);

:: SHEFFER1:condreg 3
registration
  cluster non empty trivial -> satisfying_Sheffer_1 satisfying_Sheffer_2 satisfying_Sheffer_3 (ShefferStr);
end;

:: SHEFFER1:condreg 4
registration
  cluster non empty trivial -> join-commutative join-associative (\/-SemiLattStr);
end;

:: SHEFFER1:condreg 5
registration
  cluster non empty trivial -> meet-commutative meet-associative (/\-SemiLattStr);
end;

:: SHEFFER1:condreg 6
registration
  cluster non empty trivial -> meet-absorbing join-absorbing Boolean (LattStr);
end;

:: SHEFFER1:funcreg 1
registration
  cluster TrivShefferOrthoLattStr -> non empty;
end;

:: SHEFFER1:funcreg 2
registration
  cluster TrivShefferOrthoLattStr -> trivial;
end;

:: SHEFFER1:funcreg 3
registration
  cluster TrivShefferOrthoLattStr -> well-complemented properly_defined;
end;

:: SHEFFER1:exreg 8
registration
  cluster non empty Lattice-like Boolean well-complemented properly_defined satisfying_Sheffer_1 satisfying_Sheffer_2 satisfying_Sheffer_3 ShefferOrthoLattStr;
end;

:: SHEFFER1:th 27
theorem
for b1 being non empty Lattice-like Boolean well-complemented properly_defined ShefferOrthoLattStr holds
   b1 is satisfying_Sheffer_1;

:: SHEFFER1:th 28
theorem
for b1 being non empty Lattice-like Boolean well-complemented properly_defined ShefferOrthoLattStr holds
   b1 is satisfying_Sheffer_2;

:: SHEFFER1:th 29
theorem
for b1 being non empty Lattice-like Boolean well-complemented properly_defined ShefferOrthoLattStr holds
   b1 is satisfying_Sheffer_3;

:: SHEFFER1:funcnot 6 => SHEFFER1:func 6
definition
  let a1 be non empty ShefferStr;
  let a2 be Element of the carrier of a1;
  func A2 " -> Element of the carrier of a1 equals
    a2 | a2;
end;

:: SHEFFER1:def 16
theorem
for b1 being non empty ShefferStr
for b2 being Element of the carrier of b1 holds
   b2 " = b2 | b2;

:: SHEFFER1:th 30
theorem
for b1 being non empty satisfying_Sheffer_3 ShefferOrthoLattStr
for b2, b3, b4 being Element of the carrier of b1 holds
(b2 | (b3 | b4)) " = (b3 " | b2) | (b4 " | b2);

:: SHEFFER1:th 31
theorem
for b1 being non empty satisfying_Sheffer_1 ShefferOrthoLattStr
for b2 being Element of the carrier of b1 holds
   b2 = b2 " ";

:: SHEFFER1:th 32
theorem
for b1 being non empty properly_defined satisfying_Sheffer_1 satisfying_Sheffer_2 satisfying_Sheffer_3 ShefferOrthoLattStr
for b2, b3 being Element of the carrier of b1 holds
b2 | b3 = b3 | b2;

:: SHEFFER1:th 33
theorem
for b1 being non empty properly_defined satisfying_Sheffer_1 satisfying_Sheffer_2 satisfying_Sheffer_3 ShefferOrthoLattStr
for b2, b3 being Element of the carrier of b1 holds
b2 | (b2 | b2) = b3 | (b3 | b3);

:: SHEFFER1:th 34
theorem
for b1 being non empty properly_defined satisfying_Sheffer_1 satisfying_Sheffer_2 satisfying_Sheffer_3 ShefferOrthoLattStr holds
   b1 is join-commutative;

:: SHEFFER1:th 35
theorem
for b1 being non empty properly_defined satisfying_Sheffer_1 satisfying_Sheffer_2 satisfying_Sheffer_3 ShefferOrthoLattStr holds
   b1 is meet-commutative;

:: SHEFFER1:th 36
theorem
for b1 being non empty properly_defined satisfying_Sheffer_1 satisfying_Sheffer_2 satisfying_Sheffer_3 ShefferOrthoLattStr holds
   b1 is distributive;

:: SHEFFER1:th 37
theorem
for b1 being non empty properly_defined satisfying_Sheffer_1 satisfying_Sheffer_2 satisfying_Sheffer_3 ShefferOrthoLattStr holds
   b1 is distributive';

:: SHEFFER1:th 38
theorem
for b1 being non empty properly_defined satisfying_Sheffer_1 satisfying_Sheffer_2 satisfying_Sheffer_3 ShefferOrthoLattStr holds
   b1 is non empty Lattice-like Boolean LattStr;