:: BINARI_4 semantic presentation

theorem Th1: :: BINARI_4:1
for b1 being Nat st b1 > 0 holds
b1 * 2 >= b1 + 1
proof end;

theorem Th2: :: BINARI_4:2
for b1 being Nat holds 2 to_power b1 >= b1
proof end;

theorem Th3: :: BINARI_4:3
for b1 being Nat holds (0* b1) + (0* b1) = 0* b1
proof end;

theorem Th4: :: BINARI_4:4
for b1, b2, b3 being Nat st b3 <= b1 & b1 <= b2 & not b3 = b1 holds
( b3 + 1 <= b1 & b1 <= b2 )
proof end;

theorem Th5: :: BINARI_4:5
for b1 being non empty Nat
for b2, b3 being Tuple of b1,BOOLEAN st b2 = 0* b1 & b3 = 0* b1 holds
carry b2,b3 = 0* b1
proof end;

theorem Th6: :: BINARI_4:6
for b1 being non empty Nat
for b2, b3 being Tuple of b1,BOOLEAN st b2 = 0* b1 & b3 = 0* b1 holds
b2 + b3 = 0* b1
proof end;

theorem Th7: :: BINARI_4:7
for b1 being non empty Nat
for b2 being Tuple of b1,BOOLEAN st b2 = 0* b1 holds
Intval b2 = 0
proof end;

theorem Th8: :: BINARI_4:8
for b1, b2, b3 being Nat st b1 + b2 <= b3 - 1 holds
( b1 < b3 & b2 < b3 )
proof end;

theorem Th9: :: BINARI_4:9
for b1, b2, b3 being Integer st b1 <= b2 + b3 & b2 < 0 & b3 < 0 holds
( b1 < b2 & b1 < b3 )
proof end;

theorem Th10: :: BINARI_4:10
for b1 being non empty Nat
for b2, b3 being Nat st b2 + b3 <= (2 to_power b1) - 1 holds
add_ovfl (b1 -BinarySequence b2),(b1 -BinarySequence b3) = FALSE
proof end;

theorem Th11: :: BINARI_4:11
for b1 being non empty Nat
for b2, b3 being Nat st b2 + b3 <= (2 to_power b1) - 1 holds
Absval ((b1 -BinarySequence b2) + (b1 -BinarySequence b3)) = b2 + b3
proof end;

theorem Th12: :: BINARI_4:12
for b1 being non empty Nat
for b2 being Tuple of b1,BOOLEAN st b2 /. b1 = TRUE holds
Absval b2 >= 2 to_power (b1 -' 1)
proof end;

theorem Th13: :: BINARI_4:13
for b1 being non empty Nat
for b2, b3 being Nat st b2 + b3 <= (2 to_power (b1 -' 1)) - 1 holds
(carry (b1 -BinarySequence b2),(b1 -BinarySequence b3)) /. b1 = FALSE
proof end;

theorem Th14: :: BINARI_4:14
for b1, b2 being Nat
for b3 being non empty Nat st b1 + b2 <= (2 to_power (b3 -' 1)) - 1 holds
Intval ((b3 -BinarySequence b1) + (b3 -BinarySequence b2)) = b1 + b2
proof end;

theorem Th15: :: BINARI_4:15
for b1 being Tuple of 1,BOOLEAN st b1 = <*TRUE *> holds
Intval b1 = - 1
proof end;

theorem Th16: :: BINARI_4:16
for b1 being Tuple of 1,BOOLEAN st b1 = <*FALSE *> holds
Intval b1 = 0
proof end;

theorem Th17: :: BINARI_4:17
for b1 being boolean set holds TRUE 'or' b1 = TRUE
proof end;

theorem Th18: :: BINARI_4:18
for b1 being non empty Nat holds
( 0 <= (2 to_power (b1 -' 1)) - 1 & - (2 to_power (b1 -' 1)) <= 0 )
proof end;

theorem Th19: :: BINARI_4:19
for b1 being non empty Nat
for b2, b3 being Tuple of b1,BOOLEAN st b2 = 0* b1 & b3 = 0* b1 holds
b2,b3 are_summable
proof end;

theorem Th20: :: BINARI_4:20
for b1 being non empty Nat
for b2 being Integer holds (b2 * b1) mod b1 = 0
proof end;

definition
let c1, c2 be Nat;
func MajP c1,c2 -> Nat means :Def1: :: BINARI_4:def 1
( 2 to_power a3 >= a2 & a3 >= a1 & ( for b1 being Nat st 2 to_power b1 >= a2 & b1 >= a1 holds
b1 >= a3 ) );
existence
ex b1 being Nat st
( 2 to_power b1 >= c2 & b1 >= c1 & ( for b2 being Nat st 2 to_power b2 >= c2 & b2 >= c1 holds
b2 >= b1 ) )
proof end;
uniqueness
for b1, b2 being Nat st 2 to_power b1 >= c2 & b1 >= c1 & ( for b3 being Nat st 2 to_power b3 >= c2 & b3 >= c1 holds
b3 >= b1 ) & 2 to_power b2 >= c2 & b2 >= c1 & ( for b3 being Nat st 2 to_power b3 >= c2 & b3 >= c1 holds
b3 >= b2 ) holds
b1 = b2
proof end;
end;

:: deftheorem Def1 defines MajP BINARI_4:def 1 :
for b1, b2, b3 being Nat holds
( b3 = MajP b1,b2 iff ( 2 to_power b3 >= b2 & b3 >= b1 & ( for b4 being Nat st 2 to_power b4 >= b2 & b4 >= b1 holds
b4 >= b3 ) ) );

theorem Th21: :: BINARI_4:21
for b1, b2, b3 being Nat st b1 >= b2 holds
MajP b3,b1 >= MajP b3,b2
proof end;

theorem Th22: :: BINARI_4:22
for b1, b2, b3 being Nat st b1 >= b2 holds
MajP b1,b3 >= MajP b2,b3
proof end;

theorem Th23: :: BINARI_4:23
for b1 being Nat st b1 >= 1 holds
MajP b1,1 = b1
proof end;

theorem Th24: :: BINARI_4:24
for b1, b2 being Nat st b1 <= 2 to_power b2 holds
MajP b2,b1 = b2
proof end;

theorem Th25: :: BINARI_4:25
for b1, b2 being Nat st b1 > 2 to_power b2 holds
MajP b2,b1 > b2
proof end;

definition
let c1 be Nat;
let c2 be Integer;
func 2sComplement c1,c2 -> Tuple of a1,BOOLEAN equals :Def2: :: BINARI_4:def 2
a1 -BinarySequence (abs ((2 to_power (MajP a1,(abs a2))) + a2)) if a2 < 0
otherwise a1 -BinarySequence (abs a2);
correctness
coherence
( ( c2 < 0 implies c1 -BinarySequence (abs ((2 to_power (MajP c1,(abs c2))) + c2)) is Tuple of c1,BOOLEAN ) & ( not c2 < 0 implies c1 -BinarySequence (abs c2) is Tuple of c1,BOOLEAN ) )
;
consistency
for b1 being Tuple of c1,BOOLEAN holds verum
;
;
end;

:: deftheorem Def2 defines 2sComplement BINARI_4:def 2 :
for b1 being Nat
for b2 being Integer holds
( ( b2 < 0 implies 2sComplement b1,b2 = b1 -BinarySequence (abs ((2 to_power (MajP b1,(abs b2))) + b2)) ) & ( not b2 < 0 implies 2sComplement b1,b2 = b1 -BinarySequence (abs b2) ) );

theorem Th26: :: BINARI_4:26
for b1 being Nat holds 2sComplement b1,0 = 0* b1
proof end;

theorem Th27: :: BINARI_4:27
for b1 being non empty Nat
for b2 being Integer st b2 <= (2 to_power (b1 -' 1)) - 1 & - (2 to_power (b1 -' 1)) <= b2 holds
Intval (2sComplement b1,b2) = b2
proof end;

Lemma19: for b1 being non empty Nat
for b2, b3 being Nat st b2 mod b1 = b3 mod b1 & b2 > b3 holds
ex b4 being Integer st b2 = b3 + (b4 * b1)
proof end;

Lemma20: for b1 being non empty Nat
for b2, b3 being Nat st b2 mod b1 = b3 mod b1 holds
ex b4 being Integer st b2 = b3 + (b4 * b1)
proof end;

Lemma21: for b1 being non empty Nat
for b2, b3, b4 being Nat st b4 < b1 & b2 mod (2 to_power b1) = b3 mod (2 to_power b1) holds
(b2 div (2 to_power b4)) mod 2 = (b3 div (2 to_power b4)) mod 2
proof end;

Lemma22: for b1 being non empty Nat
for b2, b3 being Integer st b2 mod (2 to_power b1) = b3 mod (2 to_power b1) holds
((2 to_power (MajP b1,(abs b2))) + b2) mod (2 to_power b1) = ((2 to_power (MajP b1,(abs b3))) + b3) mod (2 to_power b1)
proof end;

Lemma23: for b1 being non empty Nat
for b2, b3 being Integer st b2 >= 0 & b3 >= 0 & b2 mod (2 to_power b1) = b3 mod (2 to_power b1) holds
2sComplement b1,b2 = 2sComplement b1,b3
proof end;

Lemma24: for b1 being non empty Nat
for b2, b3 being Integer st b2 < 0 & b3 < 0 & b2 mod (2 to_power b1) = b3 mod (2 to_power b1) holds
2sComplement b1,b2 = 2sComplement b1,b3
proof end;

theorem Th28: :: BINARI_4:28
for b1 being non empty Nat
for b2, b3 being Integer st ( ( b2 >= 0 & b3 >= 0 ) or ( b2 < 0 & b3 < 0 ) ) & b2 mod (2 to_power b1) = b3 mod (2 to_power b1) holds
2sComplement b1,b2 = 2sComplement b1,b3 by Lemma23, Lemma24;

theorem Th29: :: BINARI_4:29
for b1 being non empty Nat
for b2, b3 being Integer st ( ( b2 >= 0 & b3 >= 0 ) or ( b2 < 0 & b3 < 0 ) ) & b2,b3 are_congruent_mod 2 to_power b1 holds
2sComplement b1,b2 = 2sComplement b1,b3
proof end;

theorem Th30: :: BINARI_4:30
for b1 being non empty Nat
for b2, b3 being Nat st b2 mod (2 to_power b1) = b3 mod (2 to_power b1) holds
b1 -BinarySequence b2 = b1 -BinarySequence b3
proof end;

theorem Th31: :: BINARI_4:31
for b1 being non empty Nat
for b2, b3 being Nat st b2,b3 are_congruent_mod 2 to_power b1 holds
b1 -BinarySequence b2 = b1 -BinarySequence b3
proof end;

theorem Th32: :: BINARI_4:32
for b1 being non empty Nat
for b2 being Integer
for b3 being Nat st 1 <= b3 & b3 <= b1 holds
(2sComplement (b1 + 1),b2) /. b3 = (2sComplement b1,b2) /. b3
proof end;

theorem Th33: :: BINARI_4:33
for b1 being Nat
for b2 being Integer ex b3 being Element of BOOLEAN st 2sComplement (b1 + 1),b2 = (2sComplement b1,b2) ^ <*b3*>
proof end;

theorem Th34: :: BINARI_4:34
for b1, b2 being Nat ex b3 being Element of BOOLEAN st (b1 + 1) -BinarySequence b2 = (b1 -BinarySequence b2) ^ <*b3*>
proof end;

theorem Th35: :: BINARI_4:35
for b1, b2 being Integer
for b3 being non empty Nat st - (2 to_power b3) <= b1 + b2 & b1 < 0 & b2 < 0 & - (2 to_power (b3 -' 1)) <= b1 & - (2 to_power (b3 -' 1)) <= b2 holds
(carry (2sComplement (b3 + 1),b1),(2sComplement (b3 + 1),b2)) /. (b3 + 1) = TRUE
proof end;

theorem Th36: :: BINARI_4:36
for b1, b2 being Integer
for b3 being non empty Nat st - (2 to_power (b3 -' 1)) <= b1 + b2 & b1 + b2 <= (2 to_power (b3 -' 1)) - 1 & b1 >= 0 & b2 >= 0 holds
Intval ((2sComplement b3,b1) + (2sComplement b3,b2)) = b1 + b2
proof end;

theorem Th37: :: BINARI_4:37
for b1, b2 being Integer
for b3 being non empty Nat st - (2 to_power ((b3 + 1) -' 1)) <= b1 + b2 & b1 + b2 <= (2 to_power ((b3 + 1) -' 1)) - 1 & b1 < 0 & b2 < 0 & - (2 to_power (b3 -' 1)) <= b1 & - (2 to_power (b3 -' 1)) <= b2 holds
Intval ((2sComplement (b3 + 1),b1) + (2sComplement (b3 + 1),b2)) = b1 + b2
proof end;

theorem Th38: :: BINARI_4:38
for b1, b2 being Integer
for b3 being non empty Nat st - (2 to_power (b3 -' 1)) <= b1 & b1 <= (2 to_power (b3 -' 1)) - 1 & - (2 to_power (b3 -' 1)) <= b2 & b2 <= (2 to_power (b3 -' 1)) - 1 & - (2 to_power (b3 -' 1)) <= b1 + b2 & b1 + b2 <= (2 to_power (b3 -' 1)) - 1 & ( ( b1 >= 0 & b2 < 0 ) or ( b1 < 0 & b2 >= 0 ) ) holds
Intval ((2sComplement b3,b1) + (2sComplement b3,b2)) = b1 + b2
proof end;