Article RADIX_1, MML version 4.99.1005
:: RADIX_1:th 2
theorem
for b1, b2 being natural set
st b1 mod b2 = b2 - 1
holds (b1 + 1) mod b2 = 0;
:: RADIX_1:th 3
theorem
for b1, b2 being natural set
st b1 <> 0 & b2 mod b1 < b1 - 1
holds (b2 + 1) mod b1 = (b2 mod b1) + 1;
:: RADIX_1:th 4
theorem
for b1, b2, b3 being natural set
st b1 <> 0
holds (b2 mod (b1 * b3)) mod b3 = b2 mod b3;
:: RADIX_1:th 5
theorem
for b1, b2 being natural set
st b1 <> 0 & (b2 + 1) mod b1 <> 0
holds (b2 + 1) mod b1 = (b2 mod b1) + 1;
:: RADIX_1:th 6
theorem
for b1, b2, b3 being natural set
st b1 <> 0 & b2 <> 0
holds (b3 mod (b1 |^ b2)) div (b1 |^ (b2 -' 1)) < b1;
:: RADIX_1:th 7
theorem
for b1, b2, b3 being natural set
st b1 <= b2
holds b3 |^ b1 divides b3 |^ b2;
:: RADIX_1:th 8
theorem
for b1, b2, b3 being integer set
st 0 < b1 & 0 <= b2
holds (b3 mod (b1 * b2)) mod b2 = b3 mod b2;
:: RADIX_1:funcnot 1 => RADIX_1:func 1
definition
let a1 be natural set;
func Radix A1 -> Element of NAT equals
2 to_power a1;
end;
:: RADIX_1:def 1
theorem
for b1 being natural set holds
Radix b1 = 2 to_power b1;
:: RADIX_1:funcnot 2 => RADIX_1:func 2
definition
let a1 be natural set;
func A1 -SD -> set equals
{b1 where b1 is Element of INT: b1 <= (Radix a1) - 1 & (- Radix a1) + 1 <= b1};
end;
:: RADIX_1:def 2
theorem
for b1 being natural set holds
b1 -SD = {b2 where b2 is Element of INT: b2 <= (Radix b1) - 1 & (- Radix b1) + 1 <= b2};
:: RADIX_1:th 10
theorem
for b1 being set holds
b1 in 0 -SD
iff
b1 = 0;
:: RADIX_1:th 11
theorem
0 -SD = {0};
:: RADIX_1:th 12
theorem
for b1 being natural set holds
b1 -SD c= (b1 + 1) -SD;
:: RADIX_1:th 13
theorem
for b1 being set
for b2 being natural set
st b1 in b2 -SD
holds b1 is integer set;
:: RADIX_1:th 14
theorem
for b1 being natural set holds
b1 -SD c= INT;
:: RADIX_1:th 15
theorem
for b1 being integer set
for b2 being natural set
st b1 in b2 -SD
holds b1 <= (Radix b2) - 1 & (- Radix b2) + 1 <= b1;
:: RADIX_1:th 16
theorem
for b1 being natural set holds
0 in b1 -SD;
:: RADIX_1:funcreg 1
registration
let a1 be natural set;
cluster a1 -SD -> non empty;
end;
:: RADIX_1:funcnot 3 => RADIX_1:func 3
definition
let a1 be natural set;
redefine func a1 -SD -> non empty Element of bool INT;
end;
:: RADIX_1:th 18
theorem
for b1, b2, b3 being natural set
for b4 being Element of b2 -tuples_on (b3 -SD)
st b1 in Seg b2
holds b4 . b1 is Element of b3 -SD;
:: RADIX_1:funcnot 4 => RADIX_1:func 4
definition
let a1, a2, a3 be natural set;
let a4 be Element of a3 -tuples_on (a2 -SD);
func DigA(A4,A1) -> integer set equals
a4 . a1
if a1 in Seg a3
otherwise case a1 = 0;
thus 0;
end;
;
end;
:: RADIX_1:def 3
theorem
for b1, b2, b3 being natural set
for b4 being Element of b3 -tuples_on (b2 -SD) holds
(b1 in Seg b3 implies DigA(b4,b1) = b4 . b1) &
(b1 = 0 implies DigA(b4,b1) = 0);
:: RADIX_1:funcnot 5 => RADIX_1:func 5
definition
let a1, a2, a3 be natural set;
let a4 be Element of a3 -tuples_on (a2 -SD);
func DigB(A4,A1) -> Element of INT equals
DigA(a4,a1);
end;
:: RADIX_1:def 4
theorem
for b1, b2, b3 being natural set
for b4 being Element of b3 -tuples_on (b2 -SD) holds
DigB(b4,b1) = DigA(b4,b1);
:: RADIX_1:th 19
theorem
for b1, b2, b3 being natural set
for b4 being Element of b2 -tuples_on (b3 -SD)
st b1 in Seg b2
holds DigA(b4,b1) is Element of b3 -SD;
:: RADIX_1:th 20
theorem
for b1 being natural set
for b2 being Element of 1 -tuples_on INT
st b2 /. 1 = b1
holds b2 = <*b1*>;
:: RADIX_1:funcnot 6 => RADIX_1:func 6
definition
let a1, a2, a3 be natural set;
let a4 be Element of a3 -tuples_on (a2 -SD);
func SubDigit(A4,A1,A2) -> Element of INT equals
((Radix a2) |^ (a1 -' 1)) * DigB(a4,a1);
end;
:: RADIX_1:def 5
theorem
for b1, b2, b3 being natural set
for b4 being Element of b3 -tuples_on (b2 -SD) holds
SubDigit(b4,b1,b2) = ((Radix b2) |^ (b1 -' 1)) * DigB(b4,b1);
:: RADIX_1:funcnot 7 => RADIX_1:func 7
definition
let a1, a2 be natural set;
let a3 be Element of a1 -tuples_on (a2 -SD);
func DigitSD A3 -> Element of a1 -tuples_on INT means
for b1 being natural set
st b1 in Seg a1
holds it /. b1 = SubDigit(a3,b1,a2);
end;
:: RADIX_1:def 6
theorem
for b1, b2 being natural set
for b3 being Element of b1 -tuples_on (b2 -SD)
for b4 being Element of b1 -tuples_on INT holds
b4 = DigitSD b3
iff
for b5 being natural set
st b5 in Seg b1
holds b4 /. b5 = SubDigit(b3,b5,b2);
:: RADIX_1:funcnot 8 => RADIX_1:func 8
definition
let a1, a2 be natural set;
let a3 be Element of a1 -tuples_on (a2 -SD);
func SDDec A3 -> integer set equals
Sum DigitSD a3;
end;
:: RADIX_1:def 7
theorem
for b1, b2 being natural set
for b3 being Element of b1 -tuples_on (b2 -SD) holds
SDDec b3 = Sum DigitSD b3;
:: RADIX_1:funcnot 9 => RADIX_1:func 9
definition
let a1, a2, a3 be natural set;
func DigitDC(A3,A1,A2) -> Element of a2 -SD equals
(a3 mod ((Radix a2) |^ a1)) div ((Radix a2) |^ (a1 -' 1));
end;
:: RADIX_1:def 8
theorem
for b1, b2, b3 being natural set holds
DigitDC(b3,b1,b2) = (b3 mod ((Radix b2) |^ b1)) div ((Radix b2) |^ (b1 -' 1));
:: RADIX_1:funcnot 10 => RADIX_1:func 10
definition
let a1, a2, a3 be natural set;
func DecSD(A3,A2,A1) -> Element of a2 -tuples_on (a1 -SD) means
for b1 being natural set
st b1 in Seg a2
holds DigA(it,b1) = DigitDC(a3,b1,a1);
end;
:: RADIX_1:def 9
theorem
for b1, b2, b3 being natural set
for b4 being Element of b2 -tuples_on (b1 -SD) holds
b4 = DecSD(b3,b2,b1)
iff
for b5 being natural set
st b5 in Seg b2
holds DigA(b4,b5) = DigitDC(b3,b5,b1);
:: RADIX_1:funcnot 11 => RADIX_1:func 11
definition
let a1 be integer set;
func SD_Add_Carry A1 -> integer set equals
1
if 2 < a1,
- 1
if a1 < - 2
otherwise 0;
end;
:: RADIX_1:def 10
theorem
for b1 being integer set holds
(b1 <= 2 or SD_Add_Carry b1 = 1) &
(- 2 <= b1 or SD_Add_Carry b1 = - 1) &
(b1 <= 2 & - 2 <= b1 implies SD_Add_Carry b1 = 0);
:: RADIX_1:th 21
theorem
SD_Add_Carry 0 = 0;
:: RADIX_1:funcnot 12 => RADIX_1:func 12
definition
let a1 be integer set;
let a2 be natural set;
func SD_Add_Data(A1,A2) -> integer set equals
a1 - ((SD_Add_Carry a1) * Radix a2);
end;
:: RADIX_1:def 11
theorem
for b1 being integer set
for b2 being natural set holds
SD_Add_Data(b1,b2) = b1 - ((SD_Add_Carry b1) * Radix b2);
:: RADIX_1:th 22
theorem
for b1 being natural set holds
SD_Add_Data(0,b1) = 0;
:: RADIX_1:th 23
theorem
for b1, b2 being integer set
for b3 being natural set
st 2 <= b3 & b1 in b3 -SD & b2 in b3 -SD
holds (- Radix b3) + 2 <= SD_Add_Data(b1 + b2,b3) &
SD_Add_Data(b1 + b2,b3) <= (Radix b3) - 2;
:: RADIX_1:prednot 1 => RADIX_1:pred 1
definition
let a1, a2, a3 be natural set;
pred A2 is_represented_by A1,A3 means
a2 < (Radix a3) |^ a1;
end;
:: RADIX_1:dfs 12
definiens
let a1, a2, a3 be natural set;
To prove
a2 is_represented_by a1,a3
it is sufficient to prove
thus a2 < (Radix a3) |^ a1;
:: RADIX_1:def 12
theorem
for b1, b2, b3 being natural set holds
b2 is_represented_by b1,b3
iff
b2 < (Radix b3) |^ b1;
:: RADIX_1:th 24
theorem
for b1, b2 being natural set
st b1 is_represented_by 1,b2
holds DigA(DecSD(b1,1,b2),1) = b1;
:: RADIX_1:th 25
theorem
for b1, b2 being natural set
st 1 <= b2
for b3 being natural set
st b3 is_represented_by b2,b1
holds b3 = SDDec DecSD(b3,b2,b1);
:: RADIX_1:th 26
theorem
for b1, b2, b3 being natural set
st 2 <= b1 & b2 is_represented_by 1,b1 & b3 is_represented_by 1,b1
holds SD_Add_Carry ((DigA(DecSD(b2,1,b1),1)) + DigA(DecSD(b3,1,b1),1)) = SD_Add_Carry (b2 + b3);
:: RADIX_1:th 27
theorem
for b1, b2, b3 being natural set
st b1 is_represented_by b2 + 1,b3
holds DigA(DecSD(b1,b2 + 1,b3),b2 + 1) = b1 div ((Radix b3) |^ b2);
:: RADIX_1:funcnot 13 => RADIX_1:func 13
definition
let a1, a2, a3 be natural set;
let a4, a5 be Element of a3 -tuples_on (a1 -SD);
assume a2 in Seg a3 & 2 <= a1;
func Add(A4,A5,A2,A1) -> Element of a1 -SD equals
(SD_Add_Data((DigA(a4,a2)) + DigA(a5,a2),a1)) + SD_Add_Carry ((DigA(a4,a2 -' 1)) + DigA(a5,a2 -' 1));
end;
:: RADIX_1:def 13
theorem
for b1, b2, b3 being natural set
for b4, b5 being Element of b3 -tuples_on (b1 -SD)
st b2 in Seg b3 & 2 <= b1
holds Add(b4,b5,b2,b1) = (SD_Add_Data((DigA(b4,b2)) + DigA(b5,b2),b1)) + SD_Add_Carry ((DigA(b4,b2 -' 1)) + DigA(b5,b2 -' 1));
:: RADIX_1:funcnot 14 => RADIX_1:func 14
definition
let a1, a2 be natural set;
let a3, a4 be Element of a1 -tuples_on (a2 -SD);
func A3 '+' A4 -> Element of a1 -tuples_on (a2 -SD) means
for b1 being natural set
st b1 in Seg a1
holds DigA(it,b1) = Add(a3,a4,b1,a2);
end;
:: RADIX_1:def 14
theorem
for b1, b2 being natural set
for b3, b4, b5 being Element of b1 -tuples_on (b2 -SD) holds
b5 = b3 '+' b4
iff
for b6 being natural set
st b6 in Seg b1
holds DigA(b5,b6) = Add(b3,b4,b6,b2);
:: RADIX_1:th 28
theorem
for b1, b2, b3 being natural set
st 2 <= b1 & b2 is_represented_by 1,b1 & b3 is_represented_by 1,b1
holds SDDec ((DecSD(b2,1,b1)) '+' DecSD(b3,1,b1)) = SD_Add_Data(b2 + b3,b1);
:: RADIX_1:th 29
theorem
for b1 being natural set
st 1 <= b1
for b2, b3, b4 being natural set
st 2 <= b2 & b3 is_represented_by b1,b2 & b4 is_represented_by b1,b2
holds b3 + b4 = (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)));