Article RADIX_3, MML version 4.99.1005

:: RADIX_3:funcnot 1 => RADIX_3:func 1
definition
  let a1 be natural set;
  func A1 -SD_Sub_S -> set equals
    {b1 where b1 is Element of INT: - Radix (a1 -' 1) <= b1 & b1 <= (Radix (a1 -' 1)) - 1};
end;

:: RADIX_3:def 1
theorem
for b1 being natural set holds
   b1 -SD_Sub_S = {b2 where b2 is Element of INT: - Radix (b1 -' 1) <= b2 & b2 <= (Radix (b1 -' 1)) - 1};

:: RADIX_3:funcnot 2 => RADIX_3:func 2
definition
  let a1 be natural set;
  func A1 -SD_Sub -> set equals
    {b1 where b1 is Element of INT: (- Radix (a1 -' 1)) - 1 <= b1 &
     b1 <= Radix (a1 -' 1)};
end;

:: RADIX_3:def 2
theorem
for b1 being natural set holds
   b1 -SD_Sub = {b2 where b2 is Element of INT: (- Radix (b1 -' 1)) - 1 <= b2 &
    b2 <= Radix (b1 -' 1)};

:: RADIX_3:th 2
theorem
for b1 being natural set
for b2 being integer set
      st b2 in b1 -SD_Sub
   holds (- Radix (b1 -' 1)) - 1 <= b2 &
    b2 <= Radix (b1 -' 1);

:: RADIX_3:th 3
theorem
for b1 being natural set holds
   b1 -SD_Sub_S c= b1 -SD_Sub;

:: RADIX_3:th 4
theorem
for b1 being natural set holds
   b1 -SD_Sub_S c= (b1 + 1) -SD_Sub_S;

:: RADIX_3:th 5
theorem
for b1 being natural set
      st 2 <= b1
   holds b1 -SD_Sub c= b1 -SD;

:: RADIX_3:th 6
theorem
0 in 0 -SD_Sub_S;

:: RADIX_3:th 7
theorem
for b1 being natural set holds
   0 in b1 -SD_Sub_S;

:: RADIX_3:th 8
theorem
for b1 being natural set holds
   0 in b1 -SD_Sub;

:: RADIX_3:th 9
theorem
for b1 being natural set
for b2 being set
      st b2 in b1 -SD_Sub
   holds b2 is integer set;

:: RADIX_3:th 10
theorem
for b1 being natural set holds
   b1 -SD_Sub c= INT;

:: RADIX_3:th 11
theorem
for b1 being natural set holds
   b1 -SD_Sub_S c= INT;

:: RADIX_3:funcreg 1
registration
  let a1 be natural set;
  cluster a1 -SD_Sub_S -> non empty;
end;

:: RADIX_3:funcreg 2
registration
  let a1 be natural set;
  cluster a1 -SD_Sub -> non empty;
end;

:: RADIX_3:funcnot 3 => RADIX_3:func 3
definition
  let a1 be natural set;
  redefine func a1 -SD_Sub_S -> non empty Element of bool INT;
end;

:: RADIX_3:funcnot 4 => RADIX_3:func 4
definition
  let a1 be natural set;
  redefine func a1 -SD_Sub -> non empty Element of bool INT;
end;

:: RADIX_3:th 12
theorem
for b1, b2, b3 being natural set
for b4 being Element of b2 -tuples_on (b3 -SD_Sub)
      st b1 in Seg b2
   holds b4 . b1 is Element of b3 -SD_Sub;

:: RADIX_3:funcnot 5 => RADIX_3:func 5
definition
  let a1 be integer set;
  let a2 be natural set;
  func SDSub_Add_Carry(A1,A2) -> integer set equals
    1
    if Radix (a2 -' 1) <= a1,
- 1
    if a1 < - Radix (a2 -' 1)
    otherwise 0;
end;

:: RADIX_3:def 3
theorem
for b1 being integer set
for b2 being natural set holds
   (Radix (b2 -' 1) <= b1 implies SDSub_Add_Carry(b1,b2) = 1) &
    (- Radix (b2 -' 1) <= b1 or SDSub_Add_Carry(b1,b2) = - 1) &
    (b1 < Radix (b2 -' 1) & - Radix (b2 -' 1) <= b1 implies SDSub_Add_Carry(b1,b2) = 0);

:: RADIX_3:funcnot 6 => RADIX_3:func 6
definition
  let a1 be integer set;
  let a2 be natural set;
  func SDSub_Add_Data(A1,A2) -> integer set equals
    a1 - ((Radix a2) * SDSub_Add_Carry(a1,a2));
end;

:: RADIX_3:def 4
theorem
for b1 being integer set
for b2 being natural set holds
   SDSub_Add_Data(b1,b2) = b1 - ((Radix b2) * SDSub_Add_Carry(b1,b2));

:: RADIX_3:th 13
theorem
for b1 being integer set
for b2 being natural set
      st 2 <= b2
   holds - 1 <= SDSub_Add_Carry(b1,b2) & SDSub_Add_Carry(b1,b2) <= 1;

:: RADIX_3:th 14
theorem
for b1 being natural set
for b2 being integer set
      st 2 <= b1 & b2 in b1 -SD
   holds - Radix (b1 -' 1) <= SDSub_Add_Data(b2,b1) &
    SDSub_Add_Data(b2,b1) <= (Radix (b1 -' 1)) - 1;

:: RADIX_3:th 15
theorem
for b1 being integer set
for b2 being natural set
      st 2 <= b2
   holds SDSub_Add_Carry(b1,b2) in b2 -SD_Sub_S;

:: RADIX_3:th 16
theorem
for b1 being natural set
for b2, b3 being integer set
      st 2 <= b1 & b2 in b1 -SD & b3 in b1 -SD
   holds (SDSub_Add_Data(b2,b1)) + SDSub_Add_Carry(b3,b1) in b1 -SD_Sub;

:: RADIX_3:th 17
theorem
for b1 being natural set
      st 2 <= b1
   holds SDSub_Add_Carry(0,b1) = 0;

:: RADIX_3:funcnot 7 => RADIX_3:func 7
definition
  let a1, a2, a3 be natural set;
  let a4 be Element of a3 -tuples_on (a2 -SD_Sub);
  func DigA_SDSub(A4,A1) -> integer set equals
    a4 . a1
    if a1 in Seg a3
    otherwise   case a1 = 0;
    thus 0;
  end;
;
end;

:: RADIX_3:def 5
theorem
for b1, b2, b3 being natural set
for b4 being Element of b3 -tuples_on (b2 -SD_Sub) holds
   (b1 in Seg b3 implies DigA_SDSub(b4,b1) = b4 . b1) &
    (b1 = 0 implies DigA_SDSub(b4,b1) = 0);

:: RADIX_3:funcnot 8 => RADIX_3:func 8
definition
  let a1, a2, a3 be natural set;
  let a4 be Element of a3 -tuples_on (a2 -SD);
  func SD2SDSubDigit(A4,A1,A2) -> integer set equals
    (SDSub_Add_Data(DigA(a4,a1),a2)) + SDSub_Add_Carry(DigA(a4,a1 -' 1),a2)
    if a1 in Seg a3,
SDSub_Add_Carry(DigA(a4,a1 -' 1),a2)
    if a1 = a3 + 1
    otherwise 0;
end;

:: RADIX_3:def 6
theorem
for b1, b2, b3 being natural set
for b4 being Element of b3 -tuples_on (b2 -SD) holds
   (b1 in Seg b3 implies SD2SDSubDigit(b4,b1,b2) = (SDSub_Add_Data(DigA(b4,b1),b2)) + SDSub_Add_Carry(DigA(b4,b1 -' 1),b2)) &
    (b1 = b3 + 1 implies SD2SDSubDigit(b4,b1,b2) = SDSub_Add_Carry(DigA(b4,b1 -' 1),b2)) &
    (not b1 in Seg b3 & b1 <> b3 + 1 implies SD2SDSubDigit(b4,b1,b2) = 0);

:: RADIX_3:th 18
theorem
for b1, b2, b3 being natural set
for b4 being Element of b3 -tuples_on (b1 -SD)
      st 2 <= b1 & b2 in Seg (b3 + 1)
   holds SD2SDSubDigit(b4,b2,b1) is Element of b1 -SD_Sub;

:: RADIX_3:funcnot 9 => RADIX_3:func 9
definition
  let a1, a2, a3 be natural set;
  let a4 be Element of a3 -tuples_on (a2 -SD);
  assume 2 <= a2 & a1 in Seg (a3 + 1);
  func SD2SDSubDigitS(A4,A1,A2) -> Element of a2 -SD_Sub equals
    SD2SDSubDigit(a4,a1,a2);
end;

:: RADIX_3:def 7
theorem
for b1, b2, b3 being natural set
for b4 being Element of b3 -tuples_on (b2 -SD)
      st 2 <= b2 & b1 in Seg (b3 + 1)
   holds SD2SDSubDigitS(b4,b1,b2) = SD2SDSubDigit(b4,b1,b2);

:: RADIX_3:funcnot 10 => RADIX_3:func 10
definition
  let a1, a2 be natural set;
  let a3 be Element of a1 -tuples_on (a2 -SD);
  func SD2SDSub A3 -> Element of (a1 + 1) -tuples_on (a2 -SD_Sub) means
    for b1 being natural set
          st b1 in Seg (a1 + 1)
       holds DigA_SDSub(it,b1) = SD2SDSubDigitS(a3,b1,a2);
end;

:: RADIX_3:def 8
theorem
for b1, b2 being natural set
for b3 being Element of b1 -tuples_on (b2 -SD)
for b4 being Element of (b1 + 1) -tuples_on (b2 -SD_Sub) holds
      b4 = SD2SDSub b3
   iff
      for b5 being natural set
            st b5 in Seg (b1 + 1)
         holds DigA_SDSub(b4,b5) = SD2SDSubDigitS(b3,b5,b2);

:: RADIX_3:th 19
theorem
for b1, b2, b3 being natural set
for b4 being Element of b2 -tuples_on (b3 -SD_Sub)
      st b1 in Seg b2
   holds DigA_SDSub(b4,b1) is Element of b3 -SD_Sub;

:: RADIX_3:th 20
theorem
for b1 being natural set
for b2, b3 being integer set
      st 2 <= b1 & b2 in b1 -SD & b3 in b1 -SD_Sub
   holds SDSub_Add_Data(b2 + b3,b1) in b1 -SD_Sub_S;

:: RADIX_3:funcnot 11 => RADIX_3:func 11
definition
  let a1, a2, a3 be natural set;
  let a4 be Element of a3 -tuples_on (a2 -SD_Sub);
  func DigB_SDSub(A4,A1) -> Element of INT equals
    DigA_SDSub(a4,a1);
end;

:: RADIX_3:def 9
theorem
for b1, b2, b3 being natural set
for b4 being Element of b3 -tuples_on (b2 -SD_Sub) holds
   DigB_SDSub(b4,b1) = DigA_SDSub(b4,b1);

:: RADIX_3:funcnot 12 => RADIX_3:func 12
definition
  let a1, a2, a3 be natural set;
  let a4 be Element of a3 -tuples_on (a2 -SD_Sub);
  func SDSub2INTDigit(A4,A1,A2) -> Element of INT equals
    ((Radix a2) |^ (a1 -' 1)) * DigB_SDSub(a4,a1);
end;

:: RADIX_3:def 10
theorem
for b1, b2, b3 being natural set
for b4 being Element of b3 -tuples_on (b2 -SD_Sub) holds
   SDSub2INTDigit(b4,b1,b2) = ((Radix b2) |^ (b1 -' 1)) * DigB_SDSub(b4,b1);

:: RADIX_3:funcnot 13 => RADIX_3:func 13
definition
  let a1, a2 be natural set;
  let a3 be Element of a1 -tuples_on (a2 -SD_Sub);
  func SDSub2INT A3 -> Element of a1 -tuples_on INT means
    for b1 being natural set
          st b1 in Seg a1
       holds it /. b1 = SDSub2INTDigit(a3,b1,a2);
end;

:: RADIX_3:def 11
theorem
for b1, b2 being natural set
for b3 being Element of b1 -tuples_on (b2 -SD_Sub)
for b4 being Element of b1 -tuples_on INT holds
      b4 = SDSub2INT b3
   iff
      for b5 being natural set
            st b5 in Seg b1
         holds b4 /. b5 = SDSub2INTDigit(b3,b5,b2);

:: RADIX_3:funcnot 14 => RADIX_3:func 14
definition
  let a1, a2 be natural set;
  let a3 be Element of a1 -tuples_on (a2 -SD_Sub);
  func SDSub2IntOut A3 -> integer set equals
    Sum SDSub2INT a3;
end;

:: RADIX_3:def 12
theorem
for b1, b2 being natural set
for b3 being Element of b1 -tuples_on (b2 -SD_Sub) holds
   SDSub2IntOut b3 = Sum SDSub2INT b3;

:: RADIX_3:th 21
theorem
for b1, b2, b3, b4 being natural set
      st b4 in Seg b1 & 2 <= b2
   holds DigA_SDSub(SD2SDSub DecSD(b3,b1 + 1,b2),b4) = DigA_SDSub(SD2SDSub DecSD(b3 mod ((Radix b2) |^ b1),b1,b2),b4);

:: RADIX_3:th 22
theorem
for b1 being natural set
   st 1 <= b1
for b2, b3 being natural set
      st 2 <= b2 & b3 is_represented_by b1,b2
   holds b3 = SDSub2IntOut SD2SDSub DecSD(b3,b1,b2);