:: XBOOLEAN semantic presentation

definition
func FALSE -> set equals :: XBOOLEAN:def 1
0;
coherence
0 is set
;
func TRUE -> set equals :: XBOOLEAN:def 2
1;
coherence
1 is set
;
end;

:: deftheorem Def1 defines FALSE XBOOLEAN:def 1 :
FALSE = 0;

:: deftheorem Def2 defines TRUE XBOOLEAN:def 2 :
TRUE = 1;

definition
let p be set ;
attr a1 is boolean means :Def3: :: XBOOLEAN:def 3
( p = FALSE or p = TRUE );
end;

:: deftheorem Def3 defines boolean XBOOLEAN:def 3 :
for p being set holds
( p is boolean iff ( p = FALSE or p = TRUE ) );

registration
cluster FALSE -> boolean ;
coherence
FALSE is boolean
by ;
cluster TRUE -> boolean ;
coherence
TRUE is boolean
by ;
cluster boolean set ;
existence
ex b1 being number st b1 is boolean
by ;
cluster boolean -> natural set ;
coherence
for b1 being number st b1 is boolean holds
b1 is natural
proof end;
end;

definition
let p be boolean number ;
func 'not' c1 -> boolean number equals :: XBOOLEAN:def 4
1 - p;
coherence
1 - p is boolean number
proof end;
involutiveness
for b1, b2 being boolean number st b1 = 1 - b2 holds
b2 = 1 - b1
;
let q be boolean number ;
func c1 '&' c2 -> set equals :: XBOOLEAN:def 5
p * q;
correctness
coherence
p * q is set
;
;
commutativity
for b1 being set
for p, q being boolean number st b1 = p * q holds
b1 = q * p
;
idempotence
for p being boolean number holds p = p * p
proof end;
end;

:: deftheorem Def4 defines 'not' XBOOLEAN:def 4 :
for p being boolean number holds 'not' p = 1 - p;

:: deftheorem Def5 defines '&' XBOOLEAN:def 5 :
for p, q being boolean number holds p '&' q = p * q;

registration
let p be boolean number ;
let q be boolean number ;
cluster a1 '&' a2 -> natural boolean ;
coherence
p '&' q is boolean
proof end;
end;

definition
let p be boolean number ;
let q be boolean number ;
func c1 'or' c2 -> set equals :: XBOOLEAN:def 6
'not' (('not' p) '&' ('not' q));
coherence
'not' (('not' p) '&' ('not' q)) is set
;
commutativity
for b1 being set
for p, q being boolean number st b1 = 'not' (('not' p) '&' ('not' q)) holds
b1 = 'not' (('not' q) '&' ('not' p))
;
idempotence
for p being boolean number holds p = 'not' (('not' p) '&' ('not' p))
;
end;

:: deftheorem Def6 defines 'or' XBOOLEAN:def 6 :
for p, q being boolean number holds p 'or' q = 'not' (('not' p) '&' ('not' q));

definition
let p be boolean number ;
let q be boolean number ;
func c1 => c2 -> set equals :: XBOOLEAN:def 7
('not' p) 'or' q;
coherence
('not' p) 'or' q is set
;
end;

:: deftheorem Def7 defines => XBOOLEAN:def 7 :
for p, q being boolean number holds p => q = ('not' p) 'or' q;

registration
let p be boolean number ;
let q be boolean number ;
cluster a1 'or' a2 -> natural boolean ;
coherence
p 'or' q is boolean
;
cluster a1 => a2 -> natural boolean ;
coherence
p => q is boolean
;
end;

definition
let p be boolean number ;
let q be boolean number ;
func c1 <=> c2 -> set equals :: XBOOLEAN:def 8
(p => q) '&' (q => p);
coherence
(p => q) '&' (q => p) is set
;
commutativity
for b1 being set
for p, q being boolean number st b1 = (p => q) '&' (q => p) holds
b1 = (q => p) '&' (p => q)
;
end;

:: deftheorem Def8 defines <=> XBOOLEAN:def 8 :
for p, q being boolean number holds p <=> q = (p => q) '&' (q => p);

registration
let p be boolean number ;
let q be boolean number ;
cluster a1 <=> a2 -> natural boolean ;
coherence
p <=> q is boolean
;
end;

definition
let p be boolean number ;
let q be boolean number ;
func c1 'nand' c2 -> set equals :: XBOOLEAN:def 9
'not' (p '&' q);
coherence
'not' (p '&' q) is set
;
commutativity
for b1 being set
for p, q being boolean number st b1 = 'not' (p '&' q) holds
b1 = 'not' (q '&' p)
;
func c1 'nor' c2 -> set equals :: XBOOLEAN:def 10
'not' (p 'or' q);
coherence
'not' (p 'or' q) is set
;
commutativity
for b1 being set
for p, q being boolean number st b1 = 'not' (p 'or' q) holds
b1 = 'not' (q 'or' p)
;
func c1 'xor' c2 -> set equals :: XBOOLEAN:def 11
'not' (p <=> q);
coherence
'not' (p <=> q) is set
;
commutativity
for b1 being set
for p, q being boolean number st b1 = 'not' (p <=> q) holds
b1 = 'not' (q <=> p)
;
func c1 '\' c2 -> set equals :: XBOOLEAN:def 12
p '&' ('not' q);
coherence
p '&' ('not' q) is set
;
end;

:: deftheorem Def9 defines 'nand' XBOOLEAN:def 9 :
for p, q being boolean number holds p 'nand' q = 'not' (p '&' q);

:: deftheorem Def10 defines 'nor' XBOOLEAN:def 10 :
for p, q being boolean number holds p 'nor' q = 'not' (p 'or' q);

:: deftheorem Def11 defines 'xor' XBOOLEAN:def 11 :
for p, q being boolean number holds p 'xor' q = 'not' (p <=> q);

:: deftheorem Def12 defines '\' XBOOLEAN:def 12 :
for p, q being boolean number holds p '\' q = p '&' ('not' q);

registration
let p be boolean number ;
let q be boolean number ;
cluster a1 'nand' a2 -> natural boolean ;
coherence
p 'nand' q is boolean
;
cluster a1 'nor' a2 -> natural boolean ;
coherence
p 'nor' q is boolean
;
cluster a1 'xor' a2 -> natural boolean ;
coherence
p 'xor' q is boolean
;
cluster a1 '\' a2 -> natural boolean ;
coherence
p '\' q is boolean
;
end;

theorem Th1: :: XBOOLEAN:1
for p being boolean number holds p '&' p = p ;

theorem Th2: :: XBOOLEAN:2
for p, q being boolean number holds p '&' (p '&' q) = p '&' q
proof end;

theorem Th3: :: XBOOLEAN:3
for p being boolean number holds p 'or' p = p ;

theorem Th4: :: XBOOLEAN:4
for p, q being boolean number holds p 'or' (p 'or' q) = p 'or' q
proof end;

theorem Th5: :: XBOOLEAN:5
for p, q being boolean number holds p 'or' (p '&' q) = p
proof end;

theorem Th6: :: XBOOLEAN:6
for p, q being boolean number holds p '&' (p 'or' q) = p
proof end;

theorem Th7: :: XBOOLEAN:7
for p, q being boolean number holds p '&' (p 'or' q) = p 'or' (p '&' q)
proof end;

theorem Th8: :: XBOOLEAN:8
for p, q, r being boolean number holds p '&' (q 'or' r) = (p '&' q) 'or' (p '&' r)
proof end;

theorem Th9: :: XBOOLEAN:9
for p, q, r being boolean number holds p 'or' (q '&' r) = (p 'or' q) '&' (p 'or' r)
proof end;

theorem Th10: :: XBOOLEAN:10
for p, q, r being boolean number holds ((p '&' q) 'or' (q '&' r)) 'or' (r '&' p) = ((p 'or' q) '&' (q 'or' r)) '&' (r 'or' p)
proof end;

theorem Th11: :: XBOOLEAN:11
for p, q being boolean number holds p '&' (('not' p) 'or' q) = p '&' q
proof end;

theorem Th12: :: XBOOLEAN:12
for p, q being boolean number holds p 'or' (('not' p) '&' q) = p 'or' q
proof end;

theorem Th13: :: XBOOLEAN:13
for p, q being boolean number holds p => (p => q) = p => q
proof end;

theorem Th14: :: XBOOLEAN:14
for p, q being boolean number holds p '&' (p => q) = p '&' q
proof end;

theorem Th15: :: XBOOLEAN:15
for p, q being boolean number holds p => (p '&' q) = p => q
proof end;

theorem Th16: :: XBOOLEAN:16
for p, q being boolean number holds p '&' ('not' (p => q)) = p '&' ('not' q)
proof end;

theorem Th17: :: XBOOLEAN:17
for p, q being boolean number holds ('not' p) 'or' (p => q) = p => q
proof end;

theorem Th18: :: XBOOLEAN:18
for p, q being boolean number holds ('not' p) '&' (p => q) = ('not' p) 'or' (('not' p) '&' q)
proof end;

theorem Th19: :: XBOOLEAN:19
for p, q, r being boolean number holds (p <=> q) <=> r = p <=> (q <=> r)
proof end;

theorem Th20: :: XBOOLEAN:20
for p, q being boolean number holds p '&' (p <=> q) = p '&' q
proof end;

theorem Th21: :: XBOOLEAN:21
for p, q being boolean number holds ('not' p) '&' (p <=> q) = ('not' p) '&' ('not' q)
proof end;

theorem Th22: :: XBOOLEAN:22
for p, q, r being boolean number holds p '&' (q <=> r) = (p '&' (('not' q) 'or' r)) '&' (('not' r) 'or' q) ;

theorem Th23: :: XBOOLEAN:23
for p, q, r being boolean number holds p 'or' (q <=> r) = ((p 'or' ('not' q)) 'or' r) '&' ((p 'or' ('not' r)) 'or' q)
proof end;

theorem Th24: :: XBOOLEAN:24
for p, q being boolean number holds ('not' p) '&' (p <=> q) = (('not' p) '&' ('not' q)) '&' (('not' p) 'or' q)
proof end;

theorem Th25: :: XBOOLEAN:25
for p, q, r being boolean number holds ('not' p) '&' (q <=> r) = (('not' p) '&' (('not' q) 'or' r)) '&' (('not' r) 'or' q) ;

theorem Th26: :: XBOOLEAN:26
for p, q being boolean number holds p => (p <=> q) = p => q
proof end;

theorem Th27: :: XBOOLEAN:27
for p, q being boolean number holds p => (p <=> q) = p => (p => q)
proof end;

theorem Th28: :: XBOOLEAN:28
for p, q being boolean number holds p 'or' (p <=> q) = q => p
proof end;

theorem Th29: :: XBOOLEAN:29
for p, q being boolean number holds ('not' p) 'or' (p <=> q) = p => q
proof end;

theorem Th30: :: XBOOLEAN:30
for p, q, r being boolean number holds p => (q <=> r) = ((('not' p) 'or' ('not' q)) 'or' r) '&' ((('not' p) 'or' q) 'or' ('not' r))
proof end;

theorem Th31: :: XBOOLEAN:31
for p being boolean number holds p 'nor' p = 'not' p ;

theorem Th32: :: XBOOLEAN:32
for p, q being boolean number holds p 'nor' (p '&' q) = 'not' p
proof end;

theorem Th33: :: XBOOLEAN:33
for p, q being boolean number holds p 'nor' (p 'or' q) = ('not' p) '&' ('not' q)
proof end;

theorem Th34: :: XBOOLEAN:34
for p, q being boolean number holds p 'nor' (p 'nor' q) = ('not' p) '&' q
proof end;

theorem Th35: :: XBOOLEAN:35
for p, q being boolean number holds p 'nor' (p '&' q) = 'not' p
proof end;

theorem Th36: :: XBOOLEAN:36
for p, q being boolean number holds p 'nor' (p 'or' q) = p 'nor' q
proof end;

theorem Th37: :: XBOOLEAN:37
for p, q being boolean number holds ('not' p) '&' (p 'nor' q) = p 'nor' q
proof end;

theorem Th38: :: XBOOLEAN:38
for p, q, r being boolean number holds p 'or' (q 'nor' r) = (p 'or' ('not' q)) '&' (p 'or' ('not' r))
proof end;

theorem Th39: :: XBOOLEAN:39
for p, q, r being boolean number holds p 'nor' (q 'nor' r) = (('not' p) '&' q) 'or' (('not' p) '&' r)
proof end;

theorem Th40: :: XBOOLEAN:40
for p, q, r being boolean number holds p 'nor' (q '&' r) = ('not' (p 'or' q)) 'or' ('not' (p 'or' r))
proof end;

theorem Th41: :: XBOOLEAN:41
for p, q, r being boolean number holds p '&' (q 'nor' r) = (p '&' ('not' q)) '&' ('not' r)
proof end;

theorem Th42: :: XBOOLEAN:42
for p, q being boolean number holds p => (p 'nor' q) = 'not' p
proof end;

theorem Th43: :: XBOOLEAN:43
for p, q, r being boolean number holds p => (q 'nor' r) = (p => ('not' q)) '&' (p => ('not' r))
proof end;

theorem Th44: :: XBOOLEAN:44
for p, q being boolean number holds p 'or' (p 'nor' q) = q => p
proof end;

theorem Th45: :: XBOOLEAN:45
for p, q, r being boolean number holds p 'or' (q 'nor' r) = (q => p) '&' (r => p)
proof end;

theorem Th46: :: XBOOLEAN:46
for p, q, r being boolean number holds p => (q 'nor' r) = (('not' p) 'or' ('not' q)) '&' (('not' p) 'or' ('not' r))
proof end;

theorem Th47: :: XBOOLEAN:47
for p, q being boolean number holds p 'nor' (p <=> q) = ('not' p) '&' q
proof end;

theorem Th48: :: XBOOLEAN:48
for p, q being boolean number holds ('not' p) '&' (p <=> q) = p 'nor' q
proof end;

theorem Th49: :: XBOOLEAN:49
for p, q, r being boolean number holds p 'nor' (q <=> r) = 'not' (((p 'or' ('not' q)) 'or' r) '&' ((p 'or' ('not' r)) 'or' q))
proof end;

theorem Th50: :: XBOOLEAN:50
for p, q being boolean number holds p <=> q = (p '&' q) 'or' (p 'nor' q)
proof end;

theorem Th51: :: XBOOLEAN:51
for p being boolean number holds p 'nand' p = 'not' p ;

theorem Th52: :: XBOOLEAN:52
for p, q being boolean number holds p '&' (p 'nand' q) = p '&' ('not' q)
proof end;

theorem Th53: :: XBOOLEAN:53
for p, q being boolean number holds p 'nand' (p '&' q) = 'not' (p '&' q)
proof end;

theorem Th54: :: XBOOLEAN:54
for p, q, r being boolean number holds p 'nand' (q 'nand' r) = (('not' p) 'or' q) '&' (('not' p) 'or' r)
proof end;

theorem Th55: :: XBOOLEAN:55
for p, q, r being boolean number holds p 'nand' (q 'or' r) = ('not' (p '&' q)) '&' ('not' (p '&' r))
proof end;

theorem Th56: :: XBOOLEAN:56
for p, q being boolean number holds p => (p 'nand' q) = p 'nand' q
proof end;

theorem Th57: :: XBOOLEAN:57
for p, q being boolean number holds p 'nand' (p 'nand' q) = p => q
proof end;

theorem Th58: :: XBOOLEAN:58
for p, q, r being boolean number holds p 'nand' (q 'nand' r) = (p => q) '&' (p => r)
proof end;

theorem Th59: :: XBOOLEAN:59
for p, q being boolean number holds p 'nand' (p => q) = 'not' (p '&' q)
proof end;

theorem Th60: :: XBOOLEAN:60
for p, q, r being boolean number holds p 'nand' (q => r) = (p => q) '&' (p => ('not' r))
proof end;

theorem Th61: :: XBOOLEAN:61
for p, q being boolean number holds ('not' p) 'or' (p 'nand' q) = p 'nand' q
proof end;

theorem Th62: :: XBOOLEAN:62
for p, q, r being boolean number holds p 'nand' (q => r) = (('not' p) 'or' q) '&' (('not' p) 'or' ('not' r))
proof end;

theorem Th63: :: XBOOLEAN:63
for p, q being boolean number holds ('not' p) '&' (p 'nand' q) = ('not' p) 'or' (('not' p) '&' ('not' q))
proof end;

theorem Th64: :: XBOOLEAN:64
for p, q, r being boolean number holds p '&' (q 'nand' r) = (p '&' ('not' q)) 'or' (p '&' ('not' r))
proof end;

theorem Th65: :: XBOOLEAN:65
for p, q being boolean number holds p 'nand' (p <=> q) = 'not' (p '&' q)
proof end;

theorem Th66: :: XBOOLEAN:66
for p, q, r being boolean number holds p 'nand' (q <=> r) = 'not' ((p '&' (('not' q) 'or' r)) '&' (('not' r) 'or' q)) ;

theorem Th67: :: XBOOLEAN:67
for p, q, r being boolean number holds p 'nand' (q 'nor' r) = (('not' p) 'or' q) 'or' r
proof end;

theorem Th68: :: XBOOLEAN:68
for p, q being boolean number holds (p '\' q) '\' q = p '\' q
proof end;

theorem Th69: :: XBOOLEAN:69
for p, q being boolean number holds p '&' (p '\' q) = p '\' q
proof end;

theorem Th70: :: XBOOLEAN:70
for p, q being boolean number holds p 'nor' (p <=> q) = q '\' p
proof end;

theorem Th71: :: XBOOLEAN:71
for p, q being boolean number holds p 'nor' (p 'nor' q) = q '\' p
proof end;

theorem Th72: :: XBOOLEAN:72
for p, q being boolean number holds p 'xor' (p 'xor' q) = q
proof end;

theorem Th73: :: XBOOLEAN:73
for p, q, r being boolean number holds (p 'xor' q) 'xor' r = p 'xor' (q 'xor' r)
proof end;

theorem Th74: :: XBOOLEAN:74
for p, q being boolean number holds 'not' (p 'xor' q) = ('not' p) 'xor' q
proof end;

theorem Th75: :: XBOOLEAN:75
for p, q, r being boolean number holds p '&' (q 'xor' r) = (p '&' q) 'xor' (p '&' r)
proof end;

theorem Th76: :: XBOOLEAN:76
for p, q being boolean number holds p '&' (p 'xor' q) = p '&' ('not' q)
proof end;

theorem Th77: :: XBOOLEAN:77
for p, q being boolean number holds p 'xor' (p '&' q) = p '&' ('not' q)
proof end;

theorem Th78: :: XBOOLEAN:78
for p, q being boolean number holds ('not' p) '&' (p 'xor' q) = ('not' p) '&' q
proof end;

theorem Th79: :: XBOOLEAN:79
for p, q being boolean number holds p 'or' (p 'xor' q) = p 'or' q
proof end;

theorem Th80: :: XBOOLEAN:80
for p, q being boolean number holds p 'or' (('not' p) 'xor' q) = p 'or' ('not' q)
proof end;

theorem Th81: :: XBOOLEAN:81
for p, q being boolean number holds p 'xor' (('not' p) '&' q) = p 'or' q
proof end;

theorem Th82: :: XBOOLEAN:82
for p, q being boolean number holds p 'xor' (p 'or' q) = ('not' p) '&' q
proof end;

theorem Th83: :: XBOOLEAN:83
for p, q, r being boolean number holds p 'xor' (q '&' r) = (p 'or' (q '&' r)) '&' (('not' p) 'or' ('not' (q '&' r)))
proof end;

theorem Th84: :: XBOOLEAN:84
for p, q being boolean number holds ('not' p) 'xor' (p => q) = p '&' q
proof end;

theorem Th85: :: XBOOLEAN:85
for p, q being boolean number holds p => (p 'xor' q) = ('not' p) 'or' ('not' q)
proof end;

theorem Th86: :: XBOOLEAN:86
for p, q being boolean number holds p 'xor' (p => q) = ('not' p) 'or' ('not' q)
proof end;

theorem Th87: :: XBOOLEAN:87
for p, q being boolean number holds ('not' p) 'xor' (q => p) = (p '&' (p 'or' ('not' q))) 'or' (('not' p) '&' q)
proof end;

theorem Th88: :: XBOOLEAN:88
for p, q being boolean number holds p 'xor' (p <=> q) = 'not' q
proof end;

theorem Th89: :: XBOOLEAN:89
for p, q being boolean number holds ('not' p) 'xor' (p <=> q) = q
proof end;

theorem Th90: :: XBOOLEAN:90
for p, q being boolean number holds p 'nor' (p 'xor' q) = ('not' p) '&' ('not' q)
proof end;

theorem Th91: :: XBOOLEAN:91
for p, q being boolean number holds p 'nor' (p 'xor' q) = p 'nor' q
proof end;

theorem Th92: :: XBOOLEAN:92
for p, q being boolean number holds p 'xor' (p 'nor' q) = q => p
proof end;

theorem Th93: :: XBOOLEAN:93
for p, q being boolean number holds p 'nand' (p 'xor' q) = p => q
proof end;

theorem Th94: :: XBOOLEAN:94
for p, q being boolean number holds p 'xor' (p 'nand' q) = p => q
proof end;

theorem Th95: :: XBOOLEAN:95
for p, q being boolean number holds p 'xor' (p => q) = p 'nand' q
proof end;

theorem Th96: :: XBOOLEAN:96
for p, q, r being boolean number holds p 'nand' (q 'xor' r) = (p '&' q) <=> (p '&' r)
proof end;

theorem Th97: :: XBOOLEAN:97
for p, q being boolean number holds p 'xor' (p '&' q) = p '\' q
proof end;

theorem Th98: :: XBOOLEAN:98
for p, q being boolean number holds p '&' (p 'xor' q) = p '\' q
proof end;

theorem Th99: :: XBOOLEAN:99
for p, q being boolean number holds ('not' p) '&' (p 'xor' q) = q '\' p
proof end;

theorem Th100: :: XBOOLEAN:100
for p, q being boolean number holds p 'xor' (p 'or' q) = q '\' p
proof end;

theorem Th101: :: XBOOLEAN:101
for p, q being boolean number st p '&' q = TRUE holds
( p = TRUE & q = TRUE )
proof end;

theorem Th102: :: XBOOLEAN:102
for p being boolean number holds 'not' (p '&' ('not' p)) = TRUE
proof end;

theorem Th103: :: XBOOLEAN:103
for p being boolean number holds p => p = TRUE
proof end;

theorem Th104: :: XBOOLEAN:104
for p, q being boolean number holds p => (q => p) = TRUE
proof end;

theorem Th105: :: XBOOLEAN:105
for p, q being boolean number holds p => ((p => q) => q) = TRUE
proof end;

theorem Th106: :: XBOOLEAN:106
for p, q, r being boolean number holds (p => q) => ((q => r) => (p => r)) = TRUE
proof end;

theorem Th107: :: XBOOLEAN:107
for p, q, r being boolean number holds (p => q) => ((r => p) => (r => q)) = TRUE
proof end;

theorem Th108: :: XBOOLEAN:108
for p, q being boolean number holds (p => (p => q)) => (p => q) = TRUE
proof end;

theorem Th109: :: XBOOLEAN:109
for p, q, r being boolean number holds (p => (q => r)) => ((p => q) => (p => r)) = TRUE
proof end;

theorem Th110: :: XBOOLEAN:110
for p, q, r being boolean number holds (p => (q => r)) => (q => (p => r)) = TRUE
proof end;

theorem Th111: :: XBOOLEAN:111
for p, q, r being boolean number holds ((p => q) => r) => (q => r) = TRUE
proof end;

theorem Th112: :: XBOOLEAN:112
for p being boolean number holds (TRUE => p) => p = TRUE
proof end;

theorem Th113: :: XBOOLEAN:113
for p, q, r being boolean number st p => q = TRUE holds
(q => r) => (p => r) = TRUE
proof end;

theorem Th114: :: XBOOLEAN:114
for p, q being boolean number st p => (p => q) = TRUE holds
p => q = TRUE
proof end;

theorem Th115: :: XBOOLEAN:115
for p, q, r being boolean number st p => (q => r) = TRUE holds
(p => q) => (p => r) = TRUE
proof end;

theorem Th116: :: XBOOLEAN:116
for p, q being boolean number st p => q = TRUE & q => p = TRUE holds
p = q
proof end;

theorem Th117: :: XBOOLEAN:117
for p, q, r being boolean number st p => q = TRUE & q => r = TRUE holds
p => r = TRUE
proof end;

theorem Th118: :: XBOOLEAN:118
for p being boolean number holds (('not' p) => p) => p = TRUE
proof end;

theorem Th119: :: XBOOLEAN:119
for p, q being boolean number st 'not' p = TRUE holds
p => q = TRUE ;

theorem Th120: :: XBOOLEAN:120
for p, q being boolean number st p => q = TRUE & p => ('not' q) = TRUE holds
'not' p = TRUE
proof end;

theorem Th121: :: XBOOLEAN:121
for p, q, r being boolean number holds (p => q) => (('not' (q '&' r)) => ('not' (p '&' r))) = TRUE
proof end;

theorem Th122: :: XBOOLEAN:122
for p, q being boolean number holds p 'or' (p => q) = TRUE
proof end;

theorem Th123: :: XBOOLEAN:123
for p, q being boolean number holds p => (p 'or' q) = TRUE
proof end;

theorem Th124: :: XBOOLEAN:124
for q, p being boolean number holds ('not' q) 'or' ((q => p) => p) = TRUE
proof end;

theorem Th125: :: XBOOLEAN:125
for p being boolean number holds p <=> p = TRUE
proof end;

theorem Th126: :: XBOOLEAN:126
for p, q, r being boolean number holds (((p <=> q) <=> r) <=> p) <=> (q <=> r) = TRUE
proof end;

theorem Th127: :: XBOOLEAN:127
for p, q, r being boolean number st p <=> q = TRUE & q <=> r = TRUE holds
p <=> r = TRUE
proof end;

theorem Th128: :: XBOOLEAN:128
for p, q, r, s being boolean number st p <=> q = TRUE & r <=> s = TRUE holds
(p <=> r) <=> (q <=> s) = TRUE
proof end;

theorem Th129: :: XBOOLEAN:129
for p being boolean number holds 'not' (p <=> ('not' p)) = TRUE
proof end;

theorem Th130: :: XBOOLEAN:130
for p, q, r, s being boolean number st p <=> q = TRUE & r <=> s = TRUE holds
(p '&' r) <=> (q '&' s) = TRUE
proof end;

theorem Th131: :: XBOOLEAN:131
for p, q, r, s being boolean number st p <=> q = TRUE & r <=> s = TRUE holds
(p 'or' r) <=> (q 'or' s) = TRUE
proof end;

theorem Th132: :: XBOOLEAN:132
for p, q being boolean number holds
( p <=> q = TRUE iff ( p => q = TRUE & q => p = TRUE ) )
proof end;

theorem Th133: :: XBOOLEAN:133
for p, q, r, s being boolean number st p <=> q = TRUE & r <=> s = TRUE holds
(p => r) <=> (q => s) = TRUE
proof end;

theorem Th134: :: XBOOLEAN:134
for p being boolean number holds 'not' (p 'nor' ('not' p)) = TRUE
proof end;

theorem Th135: :: XBOOLEAN:135
for p being boolean number holds p 'nand' ('not' p) = TRUE
proof end;

theorem Th136: :: XBOOLEAN:136
for p, q being boolean number holds p 'or' (p 'nand' q) = TRUE
proof end;

theorem Th137: :: XBOOLEAN:137
for p, q being boolean number holds p 'nand' (p 'nor' q) = TRUE
proof end;

theorem Th138: :: XBOOLEAN:138
for p being boolean number holds p '&' ('not' p) = FALSE
proof end;

theorem Th139: :: XBOOLEAN:139
for p being boolean number st p '&' p = FALSE holds
p = FALSE ;

theorem Th140: :: XBOOLEAN:140
for p, q being boolean number holds
( not p '&' q = FALSE or p = FALSE or q = FALSE )
proof end;

theorem Th141: :: XBOOLEAN:141
for p being boolean number holds 'not' (p => p) = FALSE
proof end;

theorem Th142: :: XBOOLEAN:142
for p being boolean number holds p <=> ('not' p) = FALSE
proof end;

theorem Th143: :: XBOOLEAN:143
for p being boolean number holds 'not' (p <=> p) = FALSE
proof end;

theorem Th144: :: XBOOLEAN:144
for p, q being boolean number holds p '&' (p 'nor' q) = FALSE
proof end;

theorem Th145: :: XBOOLEAN:145
for p, q being boolean number holds p 'nor' (p => q) = FALSE
proof end;

theorem Th146: :: XBOOLEAN:146
for p, q being boolean number holds p 'nor' (p 'nand' q) = FALSE
proof end;

theorem Th147: :: XBOOLEAN:147
for p being boolean number holds p 'xor' p = FALSE
proof end;