Article RADIX_2, MML version 4.99.1005

:: RADIX_2:th 1
theorem
for b1 being natural set holds
   b1 mod 1 = 0;

:: RADIX_2:th 2
theorem
for b1, b2 being integer set
for b3 being natural set
      st 0 < b3
   holds ((b1 mod b3) + (b2 mod b3)) mod b3 = (b1 + (b2 mod b3)) mod b3;

:: RADIX_2:th 3
theorem
for b1, b2 being integer set
for b3 being natural set
      st 0 < b3
   holds (b1 * b2) mod b3 = (b1 * (b2 mod b3)) mod b3;

:: RADIX_2:th 4
theorem
for b1, b2, b3 being natural set
      st 1 <= b3 & 0 < b2
   holds (b1 mod (b2 |^ b3)) div (b2 |^ (b3 -' 1)) = (b1 div (b2 |^ (b3 -' 1))) mod b2;

:: RADIX_2:th 5
theorem
for b1, b2 being natural set
      st b1 in Seg b2
   holds b1 + 1 in Seg (b2 + 1);

:: RADIX_2:th 6
theorem
for b1 being natural set holds
   0 < Radix b1;

:: RADIX_2:th 7
theorem
for b1 being natural set
for b2 being Element of 1 -tuples_on (b1 -SD) holds
   SDDec b2 = DigA(b2,1);

:: RADIX_2:th 8
theorem
for b1 being natural set
for b2 being integer set holds
   (SD_Add_Data(b2,b1)) + ((SD_Add_Carry b2) * Radix b1) = b2;

:: RADIX_2:th 9
theorem
for b1, b2 being natural set
for b3 being Element of (b2 + 1) -tuples_on (b1 -SD)
for b4 being Element of b2 -tuples_on (b1 -SD)
      st for b5 being natural set
              st b5 in Seg b2
           holds b3 . b5 = b4 . b5
   holds Sum DigitSD b3 = Sum ((DigitSD b4) ^ <*SubDigit(b3,b2 + 1,b1)*>);

:: RADIX_2:th 10
theorem
for b1, b2 being natural set
for b3 being Element of (b2 + 1) -tuples_on (b1 -SD)
for b4 being Element of b2 -tuples_on (b1 -SD)
      st for b5 being natural set
              st b5 in Seg b2
           holds b3 . b5 = b4 . b5
   holds (SDDec b4) + (((Radix b1) |^ b2) * DigA(b3,b2 + 1)) = SDDec b3;

:: RADIX_2:th 11
theorem
for b1, b2 being natural set
   st 1 <= b2
for b3, b4 being Element of b2 -tuples_on (b1 -SD)
      st 2 <= b1
   holds (SDDec (b3 '+' b4)) + ((SD_Add_Carry ((DigA(b3,b2)) + DigA(b4,b2))) * ((Radix b1) |^ b2)) = (SDDec b3) + SDDec b4;

:: RADIX_2:funcnot 1 => RADIX_2:func 1
definition
  let a1, a2, a3 be natural set;
  let a4 be Element of a3 -tuples_on NAT;
  func SubDigit2(A4,A1,A2) -> Element of NAT equals
    ((Radix a2) |^ (a1 -' 1)) * (a4 . a1);
end;

:: RADIX_2:def 1
theorem
for b1, b2, b3 being natural set
for b4 being Element of b3 -tuples_on NAT holds
   SubDigit2(b4,b1,b2) = ((Radix b2) |^ (b1 -' 1)) * (b4 . b1);

:: RADIX_2:funcnot 2 => RADIX_2:func 2
definition
  let a1, a2 be natural set;
  let a3 be Element of a1 -tuples_on NAT;
  func DigitSD2(A3,A2) -> Element of a1 -tuples_on NAT means
    for b1 being natural set
          st b1 in Seg a1
       holds it /. b1 = SubDigit2(a3,b1,a2);
end;

:: RADIX_2:def 2
theorem
for b1, b2 being natural set
for b3, b4 being Element of b1 -tuples_on NAT holds
   b4 = DigitSD2(b3,b2)
iff
   for b5 being natural set
         st b5 in Seg b1
      holds b4 /. b5 = SubDigit2(b3,b5,b2);

:: RADIX_2:funcnot 3 => RADIX_2:func 3
definition
  let a1, a2 be natural set;
  let a3 be Element of a1 -tuples_on NAT;
  func SDDec2(A3,A2) -> Element of NAT equals
    Sum DigitSD2(a3,a2);
end;

:: RADIX_2:def 3
theorem
for b1, b2 being natural set
for b3 being Element of b1 -tuples_on NAT holds
   SDDec2(b3,b2) = Sum DigitSD2(b3,b2);

:: RADIX_2:funcnot 4 => RADIX_2:func 4
definition
  let a1, a2, a3 be natural set;
  func DigitDC2(A3,A1,A2) -> Element of NAT equals
    (a3 mod ((Radix a2) |^ a1)) div ((Radix a2) |^ (a1 -' 1));
end;

:: RADIX_2:def 4
theorem
for b1, b2, b3 being natural set holds
DigitDC2(b3,b1,b2) = (b3 mod ((Radix b2) |^ b1)) div ((Radix b2) |^ (b1 -' 1));

:: RADIX_2:funcnot 5 => RADIX_2:func 5
definition
  let a1, a2, a3 be natural set;
  func DecSD2(A3,A2,A1) -> Element of a2 -tuples_on NAT means
    for b1 being natural set
          st b1 in Seg a2
       holds it . b1 = DigitDC2(a3,b1,a1);
end;

:: RADIX_2:def 5
theorem
for b1, b2, b3 being natural set
for b4 being Element of b2 -tuples_on NAT holds
      b4 = DecSD2(b3,b2,b1)
   iff
      for b5 being natural set
            st b5 in Seg b2
         holds b4 . b5 = DigitDC2(b3,b5,b1);

:: RADIX_2:th 12
theorem
for b1, b2 being natural set
for b3 being Element of b1 -tuples_on NAT
for b4 being Element of b1 -tuples_on (b2 -SD)
      st b3 = b4
   holds DigitSD2(b3,b2) = DigitSD b4;

:: RADIX_2:th 13
theorem
for b1, b2 being natural set
for b3 being Element of b1 -tuples_on NAT
for b4 being Element of b1 -tuples_on (b2 -SD)
      st b3 = b4
   holds SDDec2(b3,b2) = SDDec b4;

:: RADIX_2:th 14
theorem
for b1, b2, b3 being natural set holds
DecSD2(b1,b2,b3) = DecSD(b1,b2,b3);

:: RADIX_2:th 15
theorem
for b1 being natural set
   st 1 <= b1
for b2, b3 being natural set
      st b2 is_represented_by b1,b3
   holds b2 = SDDec2(DecSD2(b2,b1,b3),b3);

:: RADIX_2:funcnot 6 => RADIX_2:func 6
definition
  let a1 be integer set;
  let a2, a3, a4, a5 be natural set;
  let a6 be Element of a5 -tuples_on (a4 -SD);
  func Table1(A1,A6,A2,A3) -> integer set equals
    (a1 * DigA(a6,a3)) mod a2;
end;

:: RADIX_2:def 6
theorem
for b1 being integer set
for b2, b3, b4, b5 being natural set
for b6 being Element of b5 -tuples_on (b4 -SD) holds
   Table1(b1,b6,b2,b3) = (b1 * DigA(b6,b3)) mod b2;

:: RADIX_2:funcnot 7 => RADIX_2:func 7
definition
  let a1 be integer set;
  let a2, a3, a4 be natural set;
  let a5 be Element of a4 -tuples_on (a2 -SD);
  assume 1 <= a4;
  func Mul_mod(A1,A5,A3,A2) -> Element of a4 -tuples_on INT means
    it . 1 = Table1(a1,a5,a3,a4) &
     (for b1 being natural set
           st 1 <= b1 & b1 <= a4 - 1
        holds ex b2, b3 being integer set st
           b2 = it . b1 &
            b3 = it . (b1 + 1) &
            b3 = (((Radix a2) * b2) + Table1(a1,a5,a3,a4 -' b1)) mod a3);
end;

:: RADIX_2:def 7
theorem
for b1 being integer set
for b2, b3, b4 being natural set
for b5 being Element of b4 -tuples_on (b2 -SD)
   st 1 <= b4
for b6 being Element of b4 -tuples_on INT holds
      b6 = Mul_mod(b1,b5,b3,b2)
   iff
      b6 . 1 = Table1(b1,b5,b3,b4) &
       (for b7 being natural set
             st 1 <= b7 & b7 <= b4 - 1
          holds ex b8, b9 being integer set st
             b8 = b6 . b7 &
              b9 = b6 . (b7 + 1) &
              b9 = (((Radix b2) * b8) + Table1(b1,b5,b3,b4 -' b7)) mod b3);

:: RADIX_2:th 16
theorem
for b1 being natural set
   st 1 <= b1
for b2 being integer set
for b3, b4, b5 being natural set
   st b3 is_represented_by b1,b5 & 0 < b4
for b6 being Element of b1 -tuples_on (b5 -SD)
      st b6 = DecSD(b3,b1,b5)
   holds (Mul_mod(b2,b6,b4,b5)) . b1 = (b2 * b3) mod b4;

:: RADIX_2:funcnot 8 => RADIX_2:func 8
definition
  let a1, a2, a3, a4 be natural set;
  let a5 be Element of a1 -tuples_on NAT;
  func Table2(A4,A5,A2,A3) -> Element of NAT equals
    (a4 |^ (a5 /. a3)) mod a2;
end;

:: RADIX_2:def 8
theorem
for b1, b2, b3, b4 being natural set
for b5 being Element of b1 -tuples_on NAT holds
   Table2(b4,b5,b2,b3) = (b4 |^ (b5 /. b3)) mod b2;

:: RADIX_2:funcnot 9 => RADIX_2:func 9
definition
  let a1, a2, a3, a4 be natural set;
  let a5 be Element of a4 -tuples_on NAT;
  assume 1 <= a4;
  func Pow_mod(A3,A5,A2,A1) -> Element of a4 -tuples_on NAT means
    it . 1 = Table2(a3,a5,a2,a4) &
     (for b1 being natural set
           st 1 <= b1 & b1 <= a4 - 1
        holds ex b2, b3 being natural set st
           b2 = it . b1 &
            b3 = it . (b1 + 1) &
            b3 = (((b2 |^ Radix a1) mod a2) * Table2(a3,a5,a2,a4 -' b1)) mod a2);
end;

:: RADIX_2:def 9
theorem
for b1, b2, b3, b4 being natural set
for b5 being Element of b4 -tuples_on NAT
   st 1 <= b4
for b6 being Element of b4 -tuples_on NAT holds
      b6 = Pow_mod(b3,b5,b2,b1)
   iff
      b6 . 1 = Table2(b3,b5,b2,b4) &
       (for b7 being natural set
             st 1 <= b7 & b7 <= b4 - 1
          holds ex b8, b9 being natural set st
             b8 = b6 . b7 &
              b9 = b6 . (b7 + 1) &
              b9 = (((b8 |^ Radix b1) mod b2) * Table2(b3,b5,b2,b4 -' b7)) mod b2);

:: RADIX_2:th 17
theorem
for b1 being natural set
   st 1 <= b1
for b2, b3, b4, b5 being natural set
   st b5 is_represented_by b1,b3 & 0 < b4
for b6 being Element of b1 -tuples_on NAT
      st b6 = DecSD2(b5,b1,b3)
   holds (Pow_mod(b2,b6,b4,b3)) . b1 = (b2 |^ b5) mod b4;