:: RADIX_1 semantic presentation
theorem Th1: :: RADIX_1:1
canceled;
theorem Th2: :: RADIX_1:2
for b
1, b
2 being
Nat holds
( b
1 mod b
2 = b
2 - 1 implies
(b1 + 1) mod b
2 = 0 )
theorem Th3: :: RADIX_1:3
for b
1, b
2 being
Nat holds
( b
1 <> 0 & b
2 mod b
1 < b
1 - 1 implies
(b2 + 1) mod b
1 = (b2 mod b1) + 1 )
theorem Th4: :: RADIX_1:4
for b
1, b
2, b
3 being
Nat holds
( b
1 <> 0 implies
(b2 mod (b1 * b3)) mod b
3 = b
2 mod b
3 )
theorem Th5: :: RADIX_1:5
for b
1, b
2 being
Nat holds
not ( b
1 <> 0 & not
(b2 + 1) mod b
1 = 0 & not
(b2 + 1) mod b
1 = (b2 mod b1) + 1 )
theorem Th6: :: RADIX_1:6
for b
1, b
2, b
3 being
Nat holds
not ( b
1 <> 0 & b
2 <> 0 & not
(b3 mod (b1 |^ b2)) div (b1 |^ (b2 -' 1)) < b
1 )
theorem Th7: :: RADIX_1:7
theorem Th8: :: RADIX_1:8
:: deftheorem Def1 defines Radix RADIX_1:def 1 :
:: deftheorem Def2 defines -SD RADIX_1:def 2 :
theorem Th9: :: RADIX_1:9
Lemma7:
for b1 being Nat holds
( b1 >= 2 implies Radix b1 >= 2 + 2 )
theorem Th10: :: RADIX_1:10
for b
1 being
set holds
( b
1 in 0
-SD iff b
1 = 0 )
theorem Th11: :: RADIX_1:11
theorem Th12: :: RADIX_1:12
theorem Th13: :: RADIX_1:13
theorem Th14: :: RADIX_1:14
theorem Th15: :: RADIX_1:15
theorem Th16: :: RADIX_1:16
theorem Th17: :: RADIX_1:17
canceled;
theorem Th18: :: RADIX_1:18
:: deftheorem Def3 defines DigA RADIX_1:def 3 :
for b
1, b
2, b
3 being
Natfor b
4 being
Tuple of b
3,
(b2 -SD ) holds
( ( b
1 in Seg b
3 implies
DigA b
4,b
1 = b
4 . b
1 ) & ( b
1 = 0 implies
DigA b
4,b
1 = 0 ) );
:: deftheorem Def4 defines DigB RADIX_1:def 4 :
theorem Th19: :: RADIX_1:19
theorem Th20: :: RADIX_1:20
:: deftheorem Def5 defines SubDigit RADIX_1:def 5 :
definition
let c
1, c
2 be
Nat;
let c
3 be
Tuple of c
1,
(c2 -SD );
func DigitSD c
3 -> Tuple of a
1,
INT means :
Def6:
:: RADIX_1:def 6
for b
1 being
Nat holds
( b
1 in Seg a
1 implies a
4 /. b
1 = SubDigit a
3,b
1,a
2 );
existence
ex b1 being Tuple of c1,INT st
for b2 being Nat holds
( b2 in Seg c1 implies b1 /. b2 = SubDigit c3,b2,c2 )
uniqueness
for b1, b2 being Tuple of c1,INT holds
( ( for b3 being Nat holds
( b3 in Seg c1 implies b1 /. b3 = SubDigit c3,b3,c2 ) ) & ( for b3 being Nat holds
( b3 in Seg c1 implies b2 /. b3 = SubDigit c3,b3,c2 ) ) implies b1 = b2 )
end;
:: deftheorem Def6 defines DigitSD RADIX_1:def 6 :
:: deftheorem Def7 defines SDDec RADIX_1:def 7 :
:: deftheorem Def8 defines DigitDC RADIX_1:def 8 :
definition
let c
1, c
2, c
3 be
Nat;
func DecSD c
3,c
2,c
1 -> Tuple of a
2,
(a1 -SD ) means :
Def9:
:: RADIX_1:def 9
for b
1 being
Nat holds
( b
1 in Seg a
2 implies
DigA a
4,b
1 = DigitDC a
3,b
1,a
1 );
existence
ex b1 being Tuple of c2,(c1 -SD ) st
for b2 being Nat holds
( b2 in Seg c2 implies DigA b1,b2 = DigitDC c3,b2,c1 )
uniqueness
for b1, b2 being Tuple of c2,(c1 -SD ) holds
( ( for b3 being Nat holds
( b3 in Seg c2 implies DigA b1,b3 = DigitDC c3,b3,c1 ) ) & ( for b3 being Nat holds
( b3 in Seg c2 implies DigA b2,b3 = DigitDC c3,b3,c1 ) ) implies b1 = b2 )
end;
:: deftheorem Def9 defines DecSD RADIX_1:def 9 :
:: deftheorem Def10 defines SD_Add_Carry RADIX_1:def 10 :
theorem Th21: :: RADIX_1:21
Lemma22:
for b1 being Integer holds
( - 1 <= SD_Add_Carry b1 & SD_Add_Carry b1 <= 1 )
:: deftheorem Def11 defines SD_Add_Data RADIX_1:def 11 :
theorem Th22: :: RADIX_1:22
theorem Th23: :: RADIX_1:23
:: deftheorem Def12 defines is_represented_by RADIX_1:def 12 :
theorem Th24: :: RADIX_1:24
theorem Th25: :: RADIX_1:25
theorem Th26: :: RADIX_1:26
for b
1, b
2, b
3 being
Nat holds
( b
1 >= 2 & b
2 is_represented_by 1,b
1 & b
3 is_represented_by 1,b
1 implies
SD_Add_Carry ((DigA (DecSD b2,1,b1),1) + (DigA (DecSD b3,1,b1),1)) = SD_Add_Carry (b2 + b3) )
Lemma27:
for b1, b2, b3, b4 being Nat holds
( b4 in Seg b1 implies DigA (DecSD b2,(b1 + 1),b3),b4 = DigA (DecSD (b2 mod ((Radix b3) |^ b1)),b1,b3),b4 )
theorem Th27: :: RADIX_1:27
definition
let c
1, c
2, c
3 be
Nat;
let c
4, c
5 be
Tuple of c
3,
(c1 -SD );
assume E29:
( c
2 in Seg c
3 & c
1 >= 2 )
;
func Add c
4,c
5,c
2,c
1 -> Element of a
1 -SD equals :
Def13:
:: RADIX_1:def 13
(SD_Add_Data ((DigA a4,a2) + (DigA a5,a2)),a1) + (SD_Add_Carry ((DigA a4,(a2 -' 1)) + (DigA a5,(a2 -' 1))));
coherence
(SD_Add_Data ((DigA c4,c2) + (DigA c5,c2)),c1) + (SD_Add_Carry ((DigA c4,(c2 -' 1)) + (DigA c5,(c2 -' 1)))) is Element of c1 -SD
end;
:: deftheorem Def13 defines Add RADIX_1:def 13 :
for b
1, b
2, b
3 being
Natfor b
4, b
5 being
Tuple of b
3,
(b1 -SD ) holds
( b
2 in Seg b
3 & b
1 >= 2 implies
Add b
4,b
5,b
2,b
1 = (SD_Add_Data ((DigA b4,b2) + (DigA b5,b2)),b1) + (SD_Add_Carry ((DigA b4,(b2 -' 1)) + (DigA b5,(b2 -' 1)))) );
definition
let c
1, c
2 be
Nat;
let c
3, c
4 be
Tuple of c
1,
(c2 -SD );
func c
3 '+' c
4 -> Tuple of a
1,
(a2 -SD ) means :
Def14:
:: RADIX_1:def 14
for b
1 being
Nat holds
( b
1 in Seg a
1 implies
DigA a
5,b
1 = Add a
3,a
4,b
1,a
2 );
existence
ex b1 being Tuple of c1,(c2 -SD ) st
for b2 being Nat holds
( b2 in Seg c1 implies DigA b1,b2 = Add c3,c4,b2,c2 )
uniqueness
for b1, b2 being Tuple of c1,(c2 -SD ) holds
( ( for b3 being Nat holds
( b3 in Seg c1 implies DigA b1,b3 = Add c3,c4,b3,c2 ) ) & ( for b3 being Nat holds
( b3 in Seg c1 implies DigA b2,b3 = Add c3,c4,b3,c2 ) ) implies b1 = b2 )
end;
:: deftheorem Def14 defines '+' RADIX_1:def 14 :
for b
1, b
2 being
Natfor b
3, b
4, b
5 being
Tuple of b
1,
(b2 -SD ) holds
( b
5 = b
3 '+' b
4 iff for b
6 being
Nat holds
( b
6 in Seg b
1 implies
DigA b
5,b
6 = Add b
3,b
4,b
6,b
2 ) );
theorem Th28: :: RADIX_1:28
theorem Th29: :: RADIX_1:29
for b
1 being
Nat holds
( b
1 >= 1 implies for b
2, b
3, b
4 being
Nat holds
( b
2 >= 2 & b
3 is_represented_by b
1,b
2 & b
4 is_represented_by b
1,b
2 implies b
3 + b
4 = (SDDec ((DecSD b3,b1,b2) '+' (DecSD b4,b1,b2))) + (((Radix b2) |^ b1) * (SD_Add_Carry ((DigA (DecSD b3,b1,b2),b1) + (DigA (DecSD b4,b1,b2),b1)))) ) )