Article GATE_1, MML version 4.99.1005

:: GATE_1:prednot 1 => not XBOOLE_0:attr 1
notation
  let a1 be set;
  antonym $ a1 for empty;
end;

:: GATE_1:th 1
theorem
{{}} is not empty;

:: GATE_1:funcnot 1 => GATE_1:func 1
definition
  let a1 be set;
  func NOT1 A1 -> set equals
    {}
    if a1 is not empty
    otherwise {{}};
end;

:: GATE_1:def 1
theorem
for b1 being set holds
   (b1 is empty or NOT1 b1 = {}) &
    (b1 is empty implies NOT1 b1 = {{}});

:: GATE_1:th 3
theorem
NOT1 {{}} = {} & NOT1 {} = {{}};

:: GATE_1:th 4
theorem
for b1 being set holds
      NOT1 b1 is not empty
   iff
      b1 is empty;

:: GATE_1:th 5
theorem
NOT1 {} is not empty;

:: GATE_1:funcnot 2 => GATE_1:func 2
definition
  let a1, a2 be set;
  func AND2(A1,A2) -> set equals
    NOT1 {}
    if a1 is not empty & a2 is not empty
    otherwise {};
  commutativity;
::  for a1, a2 being set holds
::  AND2(a1,a2) = AND2(a2,a1);
end;

:: GATE_1:def 2
theorem
for b1, b2 being set holds
(b1 is not empty & b2 is not empty implies AND2(b1,b2) = NOT1 {}) &
 (b1 is not empty & b2 is not empty or AND2(b1,b2) = {});

:: GATE_1:th 6
theorem
for b1, b2 being set holds
   AND2(b1,b2) is not empty
iff
   b1 is not empty & b2 is not empty;

:: GATE_1:funcnot 3 => GATE_1:func 3
definition
  let a1, a2 be set;
  func OR2(A1,A2) -> set equals
    NOT1 {}
    if (a1 is empty implies a2 is not empty)
    otherwise {};
  commutativity;
::  for a1, a2 being set holds
::  OR2(a1,a2) = OR2(a2,a1);
end;

:: GATE_1:def 3
theorem
for b1, b2 being set holds
(b1 is empty & b2 is empty or OR2(b1,b2) = NOT1 {}) &
 (b1 is empty & b2 is empty implies OR2(b1,b2) = {});

:: GATE_1:th 7
theorem
for b1, b2 being set holds
   OR2(b1,b2) is not empty
iff
   (b1 is empty implies b2 is not empty);

:: GATE_1:funcnot 4 => GATE_1:func 4
definition
  let a1, a2 be set;
  func XOR2(A1,A2) -> set equals
    NOT1 {}
    if (a1 is not empty & a2 is empty or a1 is empty & a2 is not empty)
    otherwise {};
  commutativity;
::  for a1, a2 being set holds
::  XOR2(a1,a2) = XOR2(a2,a1);
end;

:: GATE_1:def 4
theorem
for b1, b2 being set holds
((b1 is not empty implies b2 is not empty) & (b1 is empty implies b2 is empty) or XOR2(b1,b2) = NOT1 {}) &
 ((b1 is not empty implies b2 is not empty) & (b1 is empty implies b2 is empty) implies XOR2(b1,b2) = {});

:: GATE_1:th 8
theorem
for b1, b2 being set holds
   XOR2(b1,b2) is not empty
iff
   (b1 is not empty & b2 is empty or b1 is empty & b2 is not empty);

:: GATE_1:th 9
theorem
for b1 being set holds
   XOR2(b1,b1) is empty;

:: GATE_1:th 10
theorem
for b1 being set holds
      XOR2(b1,{}) is not empty
   iff
      b1 is not empty;

:: GATE_1:th 11
theorem
for b1, b2 being set holds
   XOR2(b1,b2) is not empty
iff
   XOR2(b2,b1) is not empty;

:: GATE_1:funcnot 5 => GATE_1:func 5
definition
  let a1, a2 be set;
  func EQV2(A1,A2) -> set equals
    NOT1 {}
    if    (a1 is not empty
    iff
       a2 is not empty)
    otherwise {};
  commutativity;
::  for a1, a2 being set holds
::  EQV2(a1,a2) = EQV2(a2,a1);
end;

:: GATE_1:def 5
theorem
for b1, b2 being set holds
(   b1 is not empty
 iff
    b2 is not empty implies EQV2(b1,b2) = NOT1 {}) &
 (   b1 is not empty
 iff
    b2 is not empty or EQV2(b1,b2) = {});

:: GATE_1:th 12
theorem
for b1, b2 being set holds
   EQV2(b1,b2) is not empty
iff
      b1 is not empty
   iff
      b2 is not empty;

:: GATE_1:th 13
theorem
for b1, b2 being set holds
   EQV2(b1,b2) is not empty
iff
   XOR2(b1,b2) is empty;

:: GATE_1:funcnot 6 => GATE_1:func 6
definition
  let a1, a2 be set;
  func NAND2(A1,A2) -> set equals
    NOT1 {}
    if (a1 is empty or a2 is empty)
    otherwise {};
  commutativity;
::  for a1, a2 being set holds
::  NAND2(a1,a2) = NAND2(a2,a1);
end;

:: GATE_1:def 6
theorem
for b1, b2 being set holds
(b1 is not empty & b2 is not empty or NAND2(b1,b2) = NOT1 {}) &
 (b1 is not empty & b2 is not empty implies NAND2(b1,b2) = {});

:: GATE_1:th 14
theorem
for b1, b2 being set holds
   NAND2(b1,b2) is not empty
iff
   (b1 is empty or b2 is empty);

:: GATE_1:funcnot 7 => GATE_1:func 7
definition
  let a1, a2 be set;
  func NOR2(A1,A2) -> set equals
    NOT1 {}
    if a1 is empty & a2 is empty
    otherwise {};
  commutativity;
::  for a1, a2 being set holds
::  NOR2(a1,a2) = NOR2(a2,a1);
end;

:: GATE_1:def 7
theorem
for b1, b2 being set holds
(b1 is empty & b2 is empty implies NOR2(b1,b2) = NOT1 {}) &
 (b1 is empty & b2 is empty or NOR2(b1,b2) = {});

:: GATE_1:th 15
theorem
for b1, b2 being set holds
   NOR2(b1,b2) is not empty
iff
   b1 is empty & b2 is empty;

:: GATE_1:funcnot 8 => GATE_1:func 8
definition
  let a1, a2, a3 be set;
  func AND3(A1,A2,A3) -> set equals
    NOT1 {}
    if a1 is not empty & a2 is not empty & a3 is not empty
    otherwise {};
end;

:: GATE_1:def 8
theorem
for b1, b2, b3 being set holds
(b1 is not empty & b2 is not empty & b3 is not empty implies AND3(b1,b2,b3) = NOT1 {}) &
 (b1 is not empty & b2 is not empty & b3 is not empty or AND3(b1,b2,b3) = {});

:: GATE_1:th 16
theorem
for b1, b2, b3 being set holds
   AND3(b1,b2,b3) is not empty
iff
   b1 is not empty & b2 is not empty & b3 is not empty;

:: GATE_1:funcnot 9 => GATE_1:func 9
definition
  let a1, a2, a3 be set;
  func OR3(A1,A2,A3) -> set equals
    NOT1 {}
    if (a1 is empty & a2 is empty implies a3 is not empty)
    otherwise {};
end;

:: GATE_1:def 9
theorem
for b1, b2, b3 being set holds
(b1 is empty & b2 is empty & b3 is empty or OR3(b1,b2,b3) = NOT1 {}) &
 (b1 is empty & b2 is empty & b3 is empty implies OR3(b1,b2,b3) = {});

:: GATE_1:th 17
theorem
for b1, b2, b3 being set holds
   OR3(b1,b2,b3) is not empty
iff
   (b1 is empty & b2 is empty implies b3 is not empty);

:: GATE_1:funcnot 10 => GATE_1:func 10
definition
  let a1, a2, a3 be set;
  func XOR3(A1,A2,A3) -> set equals
    NOT1 {}
    if ((a1 is not empty & a2 is empty or a1 is empty & a2 is not empty) &
     a3 is empty or (a1 is not empty implies a2 is not empty) & (a1 is empty implies a2 is empty) & a3 is not empty)
    otherwise {};
end;

:: GATE_1:def 10
theorem
for b1, b2, b3 being set holds
(((b1 is not empty & b2 is empty or b1 is empty & b2 is not empty) implies b3 is not empty) &
  ((b1 is not empty implies b2 is not empty) & (b1 is empty implies b2 is empty) implies b3 is empty) or XOR3(b1,b2,b3) = NOT1 {}) &
 (((b1 is not empty & b2 is empty or b1 is empty & b2 is not empty) implies b3 is not empty) &
  ((b1 is not empty implies b2 is not empty) & (b1 is empty implies b2 is empty) implies b3 is empty) implies XOR3(b1,b2,b3) = {});

:: GATE_1:th 18
theorem
for b1, b2, b3 being set holds
   XOR3(b1,b2,b3) is not empty
iff
   ((b1 is not empty & b2 is empty or b1 is empty & b2 is not empty) &
    b3 is empty or (b1 is not empty implies b2 is not empty) & (b1 is empty implies b2 is empty) & b3 is not empty);

:: GATE_1:funcnot 11 => GATE_1:func 11
definition
  let a1, a2, a3 be set;
  func MAJ3(A1,A2,A3) -> set equals
    NOT1 {}
    if ((a1 is empty or a2 is empty) & (a2 is empty or a3 is empty) implies a3 is not empty & a1 is not empty)
    otherwise {};
end;

:: GATE_1:def 11
theorem
for b1, b2, b3 being set holds
((b1 is empty or b2 is empty) & (b2 is empty or b3 is empty) & (b3 is empty or b1 is empty) or MAJ3(b1,b2,b3) = NOT1 {}) &
 ((b1 is empty or b2 is empty) & (b2 is empty or b3 is empty) & (b3 is empty or b1 is empty) implies MAJ3(b1,b2,b3) = {});

:: GATE_1:th 19
theorem
for b1, b2, b3 being set holds
   MAJ3(b1,b2,b3) is not empty
iff
   ((b1 is empty or b2 is empty) & (b2 is empty or b3 is empty) implies b3 is not empty & b1 is not empty);

:: GATE_1:funcnot 12 => GATE_1:func 12
definition
  let a1, a2, a3 be set;
  func NAND3(A1,A2,A3) -> set equals
    NOT1 {}
    if (a1 is not empty & a2 is not empty implies a3 is empty)
    otherwise {};
end;

:: GATE_1:def 12
theorem
for b1, b2, b3 being set holds
(b1 is not empty & b2 is not empty & b3 is not empty or NAND3(b1,b2,b3) = NOT1 {}) &
 (b1 is not empty & b2 is not empty & b3 is not empty implies NAND3(b1,b2,b3) = {});

:: GATE_1:th 20
theorem
for b1, b2, b3 being set holds
   NAND3(b1,b2,b3) is not empty
iff
   (b1 is not empty & b2 is not empty implies b3 is empty);

:: GATE_1:funcnot 13 => GATE_1:func 13
definition
  let a1, a2, a3 be set;
  func NOR3(A1,A2,A3) -> set equals
    NOT1 {}
    if a1 is empty & a2 is empty & a3 is empty
    otherwise {};
end;

:: GATE_1:def 13
theorem
for b1, b2, b3 being set holds
(b1 is empty & b2 is empty & b3 is empty implies NOR3(b1,b2,b3) = NOT1 {}) &
 (b1 is empty & b2 is empty & b3 is empty or NOR3(b1,b2,b3) = {});

:: GATE_1:th 21
theorem
for b1, b2, b3 being set holds
   NOR3(b1,b2,b3) is not empty
iff
   b1 is empty & b2 is empty & b3 is empty;

:: GATE_1:funcnot 14 => GATE_1:func 14
definition
  let a1, a2, a3, a4 be set;
  func AND4(A1,A2,A3,A4) -> set equals
    NOT1 {}
    if a1 is not empty & a2 is not empty & a3 is not empty & a4 is not empty
    otherwise {};
end;

:: GATE_1:def 14
theorem
for b1, b2, b3, b4 being set holds
(b1 is not empty & b2 is not empty & b3 is not empty & b4 is not empty implies AND4(b1,b2,b3,b4) = NOT1 {}) &
 (b1 is not empty & b2 is not empty & b3 is not empty & b4 is not empty or AND4(b1,b2,b3,b4) = {});

:: GATE_1:th 22
theorem
for b1, b2, b3, b4 being set holds
   AND4(b1,b2,b3,b4) is not empty
iff
   b1 is not empty & b2 is not empty & b3 is not empty & b4 is not empty;

:: GATE_1:funcnot 15 => GATE_1:func 15
definition
  let a1, a2, a3, a4 be set;
  func OR4(A1,A2,A3,A4) -> set equals
    NOT1 {}
    if (a1 is empty & a2 is empty & a3 is empty implies a4 is not empty)
    otherwise {};
end;

:: GATE_1:def 15
theorem
for b1, b2, b3, b4 being set holds
(b1 is empty & b2 is empty & b3 is empty & b4 is empty or OR4(b1,b2,b3,b4) = NOT1 {}) &
 (b1 is empty & b2 is empty & b3 is empty & b4 is empty implies OR4(b1,b2,b3,b4) = {});

:: GATE_1:th 23
theorem
for b1, b2, b3, b4 being set holds
   OR4(b1,b2,b3,b4) is not empty
iff
   (b1 is empty & b2 is empty & b3 is empty implies b4 is not empty);

:: GATE_1:funcnot 16 => GATE_1:func 16
definition
  let a1, a2, a3, a4 be set;
  func NAND4(A1,A2,A3,A4) -> set equals
    NOT1 {}
    if (a1 is not empty & a2 is not empty & a3 is not empty implies a4 is empty)
    otherwise {};
end;

:: GATE_1:def 16
theorem
for b1, b2, b3, b4 being set holds
(b1 is not empty & b2 is not empty & b3 is not empty & b4 is not empty or NAND4(b1,b2,b3,b4) = NOT1 {}) &
 (b1 is not empty & b2 is not empty & b3 is not empty & b4 is not empty implies NAND4(b1,b2,b3,b4) = {});

:: GATE_1:th 24
theorem
for b1, b2, b3, b4 being set holds
   NAND4(b1,b2,b3,b4) is not empty
iff
   (b1 is not empty & b2 is not empty & b3 is not empty implies b4 is empty);

:: GATE_1:funcnot 17 => GATE_1:func 17
definition
  let a1, a2, a3, a4 be set;
  func NOR4(A1,A2,A3,A4) -> set equals
    NOT1 {}
    if a1 is empty & a2 is empty & a3 is empty & a4 is empty
    otherwise {};
end;

:: GATE_1:def 17
theorem
for b1, b2, b3, b4 being set holds
(b1 is empty & b2 is empty & b3 is empty & b4 is empty implies NOR4(b1,b2,b3,b4) = NOT1 {}) &
 (b1 is empty & b2 is empty & b3 is empty & b4 is empty or NOR4(b1,b2,b3,b4) = {});

:: GATE_1:th 25
theorem
for b1, b2, b3, b4 being set holds
   NOR4(b1,b2,b3,b4) is not empty
iff
   b1 is empty & b2 is empty & b3 is empty & b4 is empty;

:: GATE_1:funcnot 18 => GATE_1:func 18
definition
  let a1, a2, a3, a4, a5 be set;
  func AND5(A1,A2,A3,A4,A5) -> set equals
    NOT1 {}
    if a1 is not empty & a2 is not empty & a3 is not empty & a4 is not empty & a5 is not empty
    otherwise {};
end;

:: GATE_1:def 18
theorem
for b1, b2, b3, b4, b5 being set holds
(b1 is not empty & b2 is not empty & b3 is not empty & b4 is not empty & b5 is not empty implies AND5(b1,b2,b3,b4,b5) = NOT1 {}) &
 (b1 is not empty & b2 is not empty & b3 is not empty & b4 is not empty & b5 is not empty or AND5(b1,b2,b3,b4,b5) = {});

:: GATE_1:th 26
theorem
for b1, b2, b3, b4, b5 being set holds
   AND5(b1,b2,b3,b4,b5) is not empty
iff
   b1 is not empty & b2 is not empty & b3 is not empty & b4 is not empty & b5 is not empty;

:: GATE_1:funcnot 19 => GATE_1:func 19
definition
  let a1, a2, a3, a4, a5 be set;
  func OR5(A1,A2,A3,A4,A5) -> set equals
    NOT1 {}
    if (a1 is empty & a2 is empty & a3 is empty & a4 is empty implies a5 is not empty)
    otherwise {};
end;

:: GATE_1:def 19
theorem
for b1, b2, b3, b4, b5 being set holds
(b1 is empty & b2 is empty & b3 is empty & b4 is empty & b5 is empty or OR5(b1,b2,b3,b4,b5) = NOT1 {}) &
 (b1 is empty & b2 is empty & b3 is empty & b4 is empty & b5 is empty implies OR5(b1,b2,b3,b4,b5) = {});

:: GATE_1:th 27
theorem
for b1, b2, b3, b4, b5 being set holds
   OR5(b1,b2,b3,b4,b5) is not empty
iff
   (b1 is empty & b2 is empty & b3 is empty & b4 is empty implies b5 is not empty);

:: GATE_1:funcnot 20 => GATE_1:func 20
definition
  let a1, a2, a3, a4, a5 be set;
  func NAND5(A1,A2,A3,A4,A5) -> set equals
    NOT1 {}
    if (a1 is not empty & a2 is not empty & a3 is not empty & a4 is not empty implies a5 is empty)
    otherwise {};
end;

:: GATE_1:def 20
theorem
for b1, b2, b3, b4, b5 being set holds
(b1 is not empty & b2 is not empty & b3 is not empty & b4 is not empty & b5 is not empty or NAND5(b1,b2,b3,b4,b5) = NOT1 {}) &
 (b1 is not empty & b2 is not empty & b3 is not empty & b4 is not empty & b5 is not empty implies NAND5(b1,b2,b3,b4,b5) = {});

:: GATE_1:th 28
theorem
for b1, b2, b3, b4, b5 being set holds
   NAND5(b1,b2,b3,b4,b5) is not empty
iff
   (b1 is not empty & b2 is not empty & b3 is not empty & b4 is not empty implies b5 is empty);

:: GATE_1:funcnot 21 => GATE_1:func 21
definition
  let a1, a2, a3, a4, a5 be set;
  func NOR5(A1,A2,A3,A4,A5) -> set equals
    NOT1 {}
    if a1 is empty & a2 is empty & a3 is empty & a4 is empty & a5 is empty
    otherwise {};
end;

:: GATE_1:def 21
theorem
for b1, b2, b3, b4, b5 being set holds
(b1 is empty & b2 is empty & b3 is empty & b4 is empty & b5 is empty implies NOR5(b1,b2,b3,b4,b5) = NOT1 {}) &
 (b1 is empty & b2 is empty & b3 is empty & b4 is empty & b5 is empty or NOR5(b1,b2,b3,b4,b5) = {});

:: GATE_1:th 29
theorem
for b1, b2, b3, b4, b5 being set holds
   NOR5(b1,b2,b3,b4,b5) is not empty
iff
   b1 is empty & b2 is empty & b3 is empty & b4 is empty & b5 is empty;

:: GATE_1:funcnot 22 => GATE_1:func 22
definition
  let a1, a2, a3, a4, a5, a6 be set;
  func AND6(A1,A2,A3,A4,A5,A6) -> set equals
    NOT1 {}
    if a1 is not empty & a2 is not empty & a3 is not empty & a4 is not empty & a5 is not empty & a6 is not empty
    otherwise {};
end;

:: GATE_1:def 22
theorem
for b1, b2, b3, b4, b5, b6 being set holds
(b1 is not empty & b2 is not empty & b3 is not empty & b4 is not empty & b5 is not empty & b6 is not empty implies AND6(b1,b2,b3,b4,b5,b6) = NOT1 {}) &
 (b1 is not empty & b2 is not empty & b3 is not empty & b4 is not empty & b5 is not empty & b6 is not empty or AND6(b1,b2,b3,b4,b5,b6) = {});

:: GATE_1:th 30
theorem
for b1, b2, b3, b4, b5, b6 being set holds
   AND6(b1,b2,b3,b4,b5,b6) is not empty
iff
   b1 is not empty & b2 is not empty & b3 is not empty & b4 is not empty & b5 is not empty & b6 is not empty;

:: GATE_1:funcnot 23 => GATE_1:func 23
definition
  let a1, a2, a3, a4, a5, a6 be set;
  func OR6(A1,A2,A3,A4,A5,A6) -> set equals
    NOT1 {}
    if (a1 is empty & a2 is empty & a3 is empty & a4 is empty & a5 is empty implies a6 is not empty)
    otherwise {};
end;

:: GATE_1:def 23
theorem
for b1, b2, b3, b4, b5, b6 being set holds
(b1 is empty & b2 is empty & b3 is empty & b4 is empty & b5 is empty & b6 is empty or OR6(b1,b2,b3,b4,b5,b6) = NOT1 {}) &
 (b1 is empty & b2 is empty & b3 is empty & b4 is empty & b5 is empty & b6 is empty implies OR6(b1,b2,b3,b4,b5,b6) = {});

:: GATE_1:th 31
theorem
for b1, b2, b3, b4, b5, b6 being set holds
   OR6(b1,b2,b3,b4,b5,b6) is not empty
iff
   (b1 is empty & b2 is empty & b3 is empty & b4 is empty & b5 is empty implies b6 is not empty);

:: GATE_1:funcnot 24 => GATE_1:func 24
definition
  let a1, a2, a3, a4, a5, a6 be set;
  func NAND6(A1,A2,A3,A4,A5,A6) -> set equals
    NOT1 {}
    if (a1 is not empty & a2 is not empty & a3 is not empty & a4 is not empty & a5 is not empty implies a6 is empty)
    otherwise {};
end;

:: GATE_1:def 24
theorem
for b1, b2, b3, b4, b5, b6 being set holds
(b1 is not empty & b2 is not empty & b3 is not empty & b4 is not empty & b5 is not empty & b6 is not empty or NAND6(b1,b2,b3,b4,b5,b6) = NOT1 {}) &
 (b1 is not empty & b2 is not empty & b3 is not empty & b4 is not empty & b5 is not empty & b6 is not empty implies NAND6(b1,b2,b3,b4,b5,b6) = {});

:: GATE_1:th 32
theorem
for b1, b2, b3, b4, b5, b6 being set holds
   NAND6(b1,b2,b3,b4,b5,b6) is not empty
iff
   (b1 is not empty & b2 is not empty & b3 is not empty & b4 is not empty & b5 is not empty implies b6 is empty);

:: GATE_1:funcnot 25 => GATE_1:func 25
definition
  let a1, a2, a3, a4, a5, a6 be set;
  func NOR6(A1,A2,A3,A4,A5,A6) -> set equals
    NOT1 {}
    if a1 is empty & a2 is empty & a3 is empty & a4 is empty & a5 is empty & a6 is empty
    otherwise {};
end;

:: GATE_1:def 25
theorem
for b1, b2, b3, b4, b5, b6 being set holds
(b1 is empty & b2 is empty & b3 is empty & b4 is empty & b5 is empty & b6 is empty implies NOR6(b1,b2,b3,b4,b5,b6) = NOT1 {}) &
 (b1 is empty & b2 is empty & b3 is empty & b4 is empty & b5 is empty & b6 is empty or NOR6(b1,b2,b3,b4,b5,b6) = {});

:: GATE_1:th 33
theorem
for b1, b2, b3, b4, b5, b6 being set holds
   NOR6(b1,b2,b3,b4,b5,b6) is not empty
iff
   b1 is empty & b2 is empty & b3 is empty & b4 is empty & b5 is empty & b6 is empty;

:: GATE_1:funcnot 26 => GATE_1:func 26
definition
  let a1, a2, a3, a4, a5, a6, a7 be set;
  func AND7(A1,A2,A3,A4,A5,A6,A7) -> set equals
    NOT1 {}
    if a1 is not empty & a2 is not empty & a3 is not empty & a4 is not empty & a5 is not empty & a6 is not empty & a7 is not empty
    otherwise {};
end;

:: GATE_1:def 26
theorem
for b1, b2, b3, b4, b5, b6, b7 being set holds
(b1 is not empty & b2 is not empty & b3 is not empty & b4 is not empty & b5 is not empty & b6 is not empty & b7 is not empty implies AND7(b1,b2,b3,b4,b5,b6,b7) = NOT1 {}) &
 (b1 is not empty & b2 is not empty & b3 is not empty & b4 is not empty & b5 is not empty & b6 is not empty & b7 is not empty or AND7(b1,b2,b3,b4,b5,b6,b7) = {});

:: GATE_1:th 34
theorem
for b1, b2, b3, b4, b5, b6, b7 being set holds
   AND7(b1,b2,b3,b4,b5,b6,b7) is not empty
iff
   b1 is not empty & b2 is not empty & b3 is not empty & b4 is not empty & b5 is not empty & b6 is not empty & b7 is not empty;

:: GATE_1:funcnot 27 => GATE_1:func 27
definition
  let a1, a2, a3, a4, a5, a6, a7 be set;
  func OR7(A1,A2,A3,A4,A5,A6,A7) -> set equals
    NOT1 {}
    if (a1 is empty & a2 is empty & a3 is empty & a4 is empty & a5 is empty & a6 is empty implies a7 is not empty)
    otherwise {};
end;

:: GATE_1:def 27
theorem
for b1, b2, b3, b4, b5, b6, b7 being set holds
(b1 is empty & b2 is empty & b3 is empty & b4 is empty & b5 is empty & b6 is empty & b7 is empty or OR7(b1,b2,b3,b4,b5,b6,b7) = NOT1 {}) &
 (b1 is empty & b2 is empty & b3 is empty & b4 is empty & b5 is empty & b6 is empty & b7 is empty implies OR7(b1,b2,b3,b4,b5,b6,b7) = {});

:: GATE_1:th 35
theorem
for b1, b2, b3, b4, b5, b6, b7 being set holds
   OR7(b1,b2,b3,b4,b5,b6,b7) is not empty
iff
   (b1 is empty & b2 is empty & b3 is empty & b4 is empty & b5 is empty & b6 is empty implies b7 is not empty);

:: GATE_1:funcnot 28 => GATE_1:func 28
definition
  let a1, a2, a3, a4, a5, a6, a7 be set;
  func NAND7(A1,A2,A3,A4,A5,A6,A7) -> set equals
    NOT1 {}
    if (a1 is not empty & a2 is not empty & a3 is not empty & a4 is not empty & a5 is not empty & a6 is not empty implies a7 is empty)
    otherwise {};
end;

:: GATE_1:def 28
theorem
for b1, b2, b3, b4, b5, b6, b7 being set holds
(b1 is not empty & b2 is not empty & b3 is not empty & b4 is not empty & b5 is not empty & b6 is not empty & b7 is not empty or NAND7(b1,b2,b3,b4,b5,b6,b7) = NOT1 {}) &
 (b1 is not empty & b2 is not empty & b3 is not empty & b4 is not empty & b5 is not empty & b6 is not empty & b7 is not empty implies NAND7(b1,b2,b3,b4,b5,b6,b7) = {});

:: GATE_1:th 36
theorem
for b1, b2, b3, b4, b5, b6, b7 being set holds
   NAND7(b1,b2,b3,b4,b5,b6,b7) is not empty
iff
   (b1 is not empty & b2 is not empty & b3 is not empty & b4 is not empty & b5 is not empty & b6 is not empty implies b7 is empty);

:: GATE_1:funcnot 29 => GATE_1:func 29
definition
  let a1, a2, a3, a4, a5, a6, a7 be set;
  func NOR7(A1,A2,A3,A4,A5,A6,A7) -> set equals
    NOT1 {}
    if a1 is empty & a2 is empty & a3 is empty & a4 is empty & a5 is empty & a6 is empty & a7 is empty
    otherwise {};
end;

:: GATE_1:def 29
theorem
for b1, b2, b3, b4, b5, b6, b7 being set holds
(b1 is empty & b2 is empty & b3 is empty & b4 is empty & b5 is empty & b6 is empty & b7 is empty implies NOR7(b1,b2,b3,b4,b5,b6,b7) = NOT1 {}) &
 (b1 is empty & b2 is empty & b3 is empty & b4 is empty & b5 is empty & b6 is empty & b7 is empty or NOR7(b1,b2,b3,b4,b5,b6,b7) = {});

:: GATE_1:th 37
theorem
for b1, b2, b3, b4, b5, b6, b7 being set holds
   NOR7(b1,b2,b3,b4,b5,b6,b7) is not empty
iff
   b1 is empty & b2 is empty & b3 is empty & b4 is empty & b5 is empty & b6 is empty & b7 is empty;

:: GATE_1:funcnot 30 => GATE_1:func 30
definition
  let a1, a2, a3, a4, a5, a6, a7, a8 be set;
  func AND8(A1,A2,A3,A4,A5,A6,A7,A8) -> set equals
    NOT1 {}
    if a1 is not empty & a2 is not empty & a3 is not empty & a4 is not empty & a5 is not empty & a6 is not empty & a7 is not empty & a8 is not empty
    otherwise {};
end;

:: GATE_1:def 30
theorem
for b1, b2, b3, b4, b5, b6, b7, b8 being set holds
(b1 is not empty & b2 is not empty & b3 is not empty & b4 is not empty & b5 is not empty & b6 is not empty & b7 is not empty & b8 is not empty implies AND8(b1,b2,b3,b4,b5,b6,b7,b8) = NOT1 {}) &
 (b1 is not empty & b2 is not empty & b3 is not empty & b4 is not empty & b5 is not empty & b6 is not empty & b7 is not empty & b8 is not empty or AND8(b1,b2,b3,b4,b5,b6,b7,b8) = {});

:: GATE_1:th 38
theorem
for b1, b2, b3, b4, b5, b6, b7, b8 being set holds
   AND8(b1,b2,b3,b4,b5,b6,b7,b8) is not empty
iff
   b1 is not empty & b2 is not empty & b3 is not empty & b4 is not empty & b5 is not empty & b6 is not empty & b7 is not empty & b8 is not empty;

:: GATE_1:funcnot 31 => GATE_1:func 31
definition
  let a1, a2, a3, a4, a5, a6, a7, a8 be set;
  func OR8(A1,A2,A3,A4,A5,A6,A7,A8) -> set equals
    NOT1 {}
    if (a1 is empty & a2 is empty & a3 is empty & a4 is empty & a5 is empty & a6 is empty & a7 is empty implies a8 is not empty)
    otherwise {};
end;

:: GATE_1:def 31
theorem
for b1, b2, b3, b4, b5, b6, b7, b8 being set holds
(b1 is empty & b2 is empty & b3 is empty & b4 is empty & b5 is empty & b6 is empty & b7 is empty & b8 is empty or OR8(b1,b2,b3,b4,b5,b6,b7,b8) = NOT1 {}) &
 (b1 is empty & b2 is empty & b3 is empty & b4 is empty & b5 is empty & b6 is empty & b7 is empty & b8 is empty implies OR8(b1,b2,b3,b4,b5,b6,b7,b8) = {});

:: GATE_1:th 39
theorem
for b1, b2, b3, b4, b5, b6, b7, b8 being set holds
   OR8(b1,b2,b3,b4,b5,b6,b7,b8) is not empty
iff
   (b1 is empty & b2 is empty & b3 is empty & b4 is empty & b5 is empty & b6 is empty & b7 is empty implies b8 is not empty);

:: GATE_1:funcnot 32 => GATE_1:func 32
definition
  let a1, a2, a3, a4, a5, a6, a7, a8 be set;
  func NAND8(A1,A2,A3,A4,A5,A6,A7,A8) -> set equals
    NOT1 {}
    if (a1 is not empty & a2 is not empty & a3 is not empty & a4 is not empty & a5 is not empty & a6 is not empty & a7 is not empty implies a8 is empty)
    otherwise {};
end;

:: GATE_1:def 32
theorem
for b1, b2, b3, b4, b5, b6, b7, b8 being set holds
(b1 is not empty & b2 is not empty & b3 is not empty & b4 is not empty & b5 is not empty & b6 is not empty & b7 is not empty & b8 is not empty or NAND8(b1,b2,b3,b4,b5,b6,b7,b8) = NOT1 {}) &
 (b1 is not empty & b2 is not empty & b3 is not empty & b4 is not empty & b5 is not empty & b6 is not empty & b7 is not empty & b8 is not empty implies NAND8(b1,b2,b3,b4,b5,b6,b7,b8) = {});

:: GATE_1:th 40
theorem
for b1, b2, b3, b4, b5, b6, b7, b8 being set holds
   NAND8(b1,b2,b3,b4,b5,b6,b7,b8) is not empty
iff
   (b1 is not empty & b2 is not empty & b3 is not empty & b4 is not empty & b5 is not empty & b6 is not empty & b7 is not empty implies b8 is empty);

:: GATE_1:funcnot 33 => GATE_1:func 33
definition
  let a1, a2, a3, a4, a5, a6, a7, a8 be set;
  func NOR8(A1,A2,A3,A4,A5,A6,A7,A8) -> set equals
    NOT1 {}
    if a1 is empty & a2 is empty & a3 is empty & a4 is empty & a5 is empty & a6 is empty & a7 is empty & a8 is empty
    otherwise {};
end;

:: GATE_1:def 33
theorem
for b1, b2, b3, b4, b5, b6, b7, b8 being set holds
(b1 is empty & b2 is empty & b3 is empty & b4 is empty & b5 is empty & b6 is empty & b7 is empty & b8 is empty implies NOR8(b1,b2,b3,b4,b5,b6,b7,b8) = NOT1 {}) &
 (b1 is empty & b2 is empty & b3 is empty & b4 is empty & b5 is empty & b6 is empty & b7 is empty & b8 is empty or NOR8(b1,b2,b3,b4,b5,b6,b7,b8) = {});

:: GATE_1:th 41
theorem
for b1, b2, b3, b4, b5, b6, b7, b8 being set holds
   NOR8(b1,b2,b3,b4,b5,b6,b7,b8) is not empty
iff
   b1 is empty & b2 is empty & b3 is empty & b4 is empty & b5 is empty & b6 is empty & b7 is empty & b8 is empty;

:: GATE_1:th 42
theorem
for b1, b2, b3, b4, b5, b6, b7, b8, b9, b10, b11, b12, b13, b14, b15, b16, b17, b18, b19 being set
      st (MAJ3(b2,b6,b1) is not empty implies b10 is not empty) & (MAJ3(b3,b7,b10) is not empty implies b11 is not empty) & (MAJ3(b4,b8,b11) is not empty implies b12 is not empty) & (MAJ3(b5,b9,b12) is not empty implies b13 is not empty) & (b14 is not empty implies OR2(b2,b6) is not empty) & (b15 is not empty implies OR2(b3,b7) is not empty) & (b16 is not empty implies OR2(b4,b8) is not empty) & (b17 is not empty implies OR2(b5,b9) is not empty) & (b18 is not empty implies AND5(b1,b14,b15,b16,b17) is not empty) & (b19 is not empty implies OR2(b13,b18) is not empty) & (OR2(b13,b18) is not empty implies b19 is not empty)
   holds    b13 is not empty
   iff
      b19 is not empty;

:: GATE_1:funcnot 34 => GATE_1:func 34
definition
  let a1, a2 be set;
  func MODADD2(A1,A2) -> set equals
    NOT1 {}
    if (a1 is empty implies a2 is not empty) & (a1 is empty or a2 is empty)
    otherwise {};
  commutativity;
::  for a1, a2 being set holds
::  MODADD2(a1,a2) = MODADD2(a2,a1);
end;

:: GATE_1:def 34
theorem
for b1, b2 being set holds
((b1 is empty implies b2 is not empty) & (b1 is empty or b2 is empty) implies MODADD2(b1,b2) = NOT1 {}) &
 ((b1 is empty implies b2 is not empty) & (b1 is empty or b2 is empty) or MODADD2(b1,b2) = {});

:: GATE_1:th 43
theorem
for b1, b2 being set holds
   MODADD2(b1,b2) is not empty
iff
   (b1 is empty implies b2 is not empty) & (b1 is empty or b2 is empty);

:: GATE_1:funcnot 35 => GATE_1:func 10
notation
  let a1, a2, a3 be set;
  synonym ADD1(a1,a2,a3) for XOR3(a1,a2,a3);
end;

:: GATE_1:funcnot 36 => GATE_1:func 11
notation
  let a1, a2, a3 be set;
  synonym CARR1(a1,a2,a3) for MAJ3(a1,a2,a3);
end;

:: GATE_1:funcnot 37 => GATE_1:func 35
definition
  let a1, a2, a3, a4, a5 be set;
  func ADD2(A3,A4,A1,A2,A5) -> set equals
    XOR3(a3,a4,MAJ3(a1,a2,a5));
end;

:: GATE_1:def 37
theorem
for b1, b2, b3, b4, b5 being set holds
ADD2(b3,b4,b1,b2,b5) = XOR3(b3,b4,MAJ3(b1,b2,b5));

:: GATE_1:funcnot 38 => GATE_1:func 36
definition
  let a1, a2, a3, a4, a5 be set;
  func CARR2(A3,A4,A1,A2,A5) -> set equals
    MAJ3(a3,a4,MAJ3(a1,a2,a5));
end;

:: GATE_1:def 38
theorem
for b1, b2, b3, b4, b5 being set holds
CARR2(b3,b4,b1,b2,b5) = MAJ3(b3,b4,MAJ3(b1,b2,b5));

:: GATE_1:funcnot 39 => GATE_1:func 37
definition
  let a1, a2, a3, a4, a5, a6, a7 be set;
  func ADD3(A5,A6,A3,A4,A1,A2,A7) -> set equals
    XOR3(a5,a6,CARR2(a3,a4,a1,a2,a7));
end;

:: GATE_1:def 39
theorem
for b1, b2, b3, b4, b5, b6, b7 being set holds
ADD3(b5,b6,b3,b4,b1,b2,b7) = XOR3(b5,b6,CARR2(b3,b4,b1,b2,b7));

:: GATE_1:funcnot 40 => GATE_1:func 38
definition
  let a1, a2, a3, a4, a5, a6, a7 be set;
  func CARR3(A5,A6,A3,A4,A1,A2,A7) -> set equals
    MAJ3(a5,a6,CARR2(a3,a4,a1,a2,a7));
end;

:: GATE_1:def 40
theorem
for b1, b2, b3, b4, b5, b6, b7 being set holds
CARR3(b5,b6,b3,b4,b1,b2,b7) = MAJ3(b5,b6,CARR2(b3,b4,b1,b2,b7));

:: GATE_1:funcnot 41 => GATE_1:func 39
definition
  let a1, a2, a3, a4, a5, a6, a7, a8, a9 be set;
  func ADD4(A7,A8,A5,A6,A3,A4,A1,A2,A9) -> set equals
    XOR3(a7,a8,CARR3(a5,a6,a3,a4,a1,a2,a9));
end;

:: GATE_1:def 41
theorem
for b1, b2, b3, b4, b5, b6, b7, b8, b9 being set holds
ADD4(b7,b8,b5,b6,b3,b4,b1,b2,b9) = XOR3(b7,b8,CARR3(b5,b6,b3,b4,b1,b2,b9));

:: GATE_1:funcnot 42 => GATE_1:func 40
definition
  let a1, a2, a3, a4, a5, a6, a7, a8, a9 be set;
  func CARR4(A7,A8,A5,A6,A3,A4,A1,A2,A9) -> set equals
    MAJ3(a7,a8,CARR3(a5,a6,a3,a4,a1,a2,a9));
end;

:: GATE_1:def 42
theorem
for b1, b2, b3, b4, b5, b6, b7, b8, b9 being set holds
CARR4(b7,b8,b5,b6,b3,b4,b1,b2,b9) = MAJ3(b7,b8,CARR3(b5,b6,b3,b4,b1,b2,b9));

:: GATE_1:th 44
theorem
for b1, b2, b3, b4, b5, b6, b7, b8, b9, b10, b11, b12, b13, b14, b15, b16, b17, b18, b19, b20, b21, b22, b23, b24, b25, b26, b27, b28, b29, b30, b31, b32, b33, b34, b35, b36, b37, b38, b39, b40, b41 being set
      st (b11 is not empty implies NOR2(b2,b3) is not empty) & (NOR2(b2,b3) is not empty implies b11 is not empty) & (b12 is not empty implies NAND2(b2,b3) is not empty) & (NAND2(b2,b3) is not empty implies b12 is not empty) & (b13 is not empty implies MODADD2(b2,b3) is not empty) & (MODADD2(b2,b3) is not empty implies b13 is not empty) & (b14 is not empty implies NOR2(b4,b5) is not empty) & (NOR2(b4,b5) is not empty implies b14 is not empty) & (b15 is not empty implies NAND2(b4,b5) is not empty) & (NAND2(b4,b5) is not empty implies b15 is not empty) & (b16 is not empty implies MODADD2(b4,b5) is not empty) & (MODADD2(b4,b5) is not empty implies b16 is not empty) & (b17 is not empty implies NOR2(b6,b7) is not empty) & (NOR2(b6,b7) is not empty implies b17 is not empty) & (b18 is not empty implies NAND2(b6,b7) is not empty) & (NAND2(b6,b7) is not empty implies b18 is not empty) & (b19 is not empty implies MODADD2(b6,b7) is not empty) & (MODADD2(b6,b7) is not empty implies b19 is not empty) & (b20 is not empty implies NOR2(b8,b9) is not empty) & (NOR2(b8,b9) is not empty implies b20 is not empty) & (b21 is not empty implies NAND2(b8,b9) is not empty) & (NAND2(b8,b9) is not empty implies b21 is not empty) & (b22 is not empty implies MODADD2(b8,b9) is not empty) & (MODADD2(b8,b9) is not empty implies b22 is not empty) & (b23 is not empty implies NOT1 b1 is not empty) & (NOT1 b1 is not empty implies b23 is not empty) & (b24 is not empty implies NOT1 b23 is not empty) & (NOT1 b23 is not empty implies b24 is not empty) & (b38 is not empty implies XOR2(b24,b13) is not empty) & (XOR2(b24,b13) is not empty implies b38 is not empty) & (b25 is not empty implies AND2(b23,b12) is not empty) & (AND2(b23,b12) is not empty implies b25 is not empty) & (b26 is not empty implies NOR2(b25,b11) is not empty) & (NOR2(b25,b11) is not empty implies b26 is not empty) & (b39 is not empty implies XOR2(b26,b16) is not empty) & (XOR2(b26,b16) is not empty implies b39 is not empty) & (b27 is not empty implies AND2(b11,b15) is not empty) & (AND2(b11,b15) is not empty implies b27 is not empty) & (b28 is not empty implies AND3(b15,b12,b23) is not empty) & (AND3(b15,b12,b23) is not empty implies b28 is not empty) & (b29 is not empty implies NOR3(b27,b28,b14) is not empty) & (NOR3(b27,b28,b14) is not empty implies b29 is not empty) & (b40 is not empty implies XOR2(b29,b19) is not empty) & (XOR2(b29,b19) is not empty implies b40 is not empty) & (b30 is not empty implies AND2(b14,b18) is not empty) & (AND2(b14,b18) is not empty implies b30 is not empty) & (b31 is not empty implies AND3(b11,b18,b15) is not empty) & (AND3(b11,b18,b15) is not empty implies b31 is not empty) & (b32 is not empty implies AND4(b18,b15,b12,b23) is not empty) & (AND4(b18,b15,b12,b23) is not empty implies b32 is not empty) & (b33 is not empty implies NOR4(b30,b31,b32,b17) is not empty) & (NOR4(b30,b31,b32,b17) is not empty implies b33 is not empty) & (b41 is not empty implies XOR2(b33,b22) is not empty) & (XOR2(b33,b22) is not empty implies b41 is not empty) & (b34 is not empty implies AND2(b17,b21) is not empty) & (AND2(b17,b21) is not empty implies b34 is not empty) & (b35 is not empty implies AND3(b14,b21,b18) is not empty) & (AND3(b14,b21,b18) is not empty implies b35 is not empty) & (b36 is not empty implies AND4(b11,b21,b18,b15) is not empty) & (AND4(b11,b21,b18,b15) is not empty implies b36 is not empty) & (b37 is not empty implies AND5(b21,b18,b15,b12,b23) is not empty) & (AND5(b21,b18,b15,b12,b23) is not empty implies b37 is not empty) & (b10 is not empty implies NOR5(b20,b34,b35,b36,b37) is not empty) & (NOR5(b20,b34,b35,b36,b37) is not empty implies b10 is not empty)
   holds (b38 is not empty implies XOR3(b2,b3,b1) is not empty) &
    (XOR3(b2,b3,b1) is not empty implies b38 is not empty) &
    (b39 is not empty implies ADD2(b4,b5,b2,b3,b1) is not empty) &
    (ADD2(b4,b5,b2,b3,b1) is not empty implies b39 is not empty) &
    (b40 is not empty implies ADD3(b6,b7,b4,b5,b2,b3,b1) is not empty) &
    (ADD3(b6,b7,b4,b5,b2,b3,b1) is not empty implies b40 is not empty) &
    (b41 is not empty implies ADD4(b8,b9,b6,b7,b4,b5,b2,b3,b1) is not empty) &
    (ADD4(b8,b9,b6,b7,b4,b5,b2,b3,b1) is not empty implies b41 is not empty) &
    (b10 is not empty implies CARR4(b8,b9,b6,b7,b4,b5,b2,b3,b1) is not empty) &
    (CARR4(b8,b9,b6,b7,b4,b5,b2,b3,b1) is not empty implies b10 is not empty);