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)));