Article BINARITH, MML version 4.99.1005

:: BINARITH:modenot 1
definition
  let a1 be natural set;
  let a2 be non empty set;
  mode Tuple of a1,a2 is Element of a1 -tuples_on a2;
end;

:: BINARITH:th 2
theorem
for b1, b2 being Element of NAT
for b3 being non empty set
for b4 being Element of b3
for b5 being Element of b2 -tuples_on b3
      st b1 in Seg b2
   holds (b5 ^ <*b4*>) /. b1 = b5 /. b1;

:: BINARITH:th 3
theorem
for b1 being Element of NAT
for b2 being non empty set
for b3 being Element of b2
for b4 being Element of b1 -tuples_on b2 holds
   (b4 ^ <*b3*>) /. (b1 + 1) = b3;

:: BINARITH:funcreg 1
registration
  let a1, a2 be boolean set;
  cluster a1 'xor' a2 -> boolean;
end;

:: BINARITH:funcnot 1 => BINARITH:func 1
definition
  let a1, a2 be Element of BOOLEAN;
  redefine func a1 'or' a2 -> Element of BOOLEAN;
  commutativity;
::  for a1, a2 being Element of BOOLEAN holds
::  a1 'or' a2 = a2 'or' a1;
  idempotence;
::  for a1 being Element of BOOLEAN holds
::     a1 'or' a1 = a1;
end;

:: BINARITH:funcnot 2 => BINARITH:func 2
definition
  let a1, a2 be Element of BOOLEAN;
  redefine func a1 'xor' a2 -> Element of BOOLEAN;
  commutativity;
::  for a1, a2 being Element of BOOLEAN holds
::  a1 'xor' a2 = a2 'xor' a1;
end;

:: BINARITH:th 7
theorem
for b1 being boolean set holds
   b1 'or' FALSE = b1;

:: BINARITH:th 9
theorem
for b1, b2 being boolean set holds
'not' (b1 '&' b2) = ('not' b1) 'or' 'not' b2;

:: BINARITH:th 10
theorem
for b1, b2 being boolean set holds
'not' (b1 'or' b2) = ('not' b1) '&' 'not' b2;

:: BINARITH:th 12
theorem
for b1, b2 being boolean set holds
b1 '&' b2 = 'not' (('not' b1) 'or' 'not' b2);

:: BINARITH:th 13
theorem
for b1 being boolean set holds
   TRUE 'xor' b1 = 'not' b1;

:: BINARITH:th 14
theorem
for b1 being boolean set holds
   FALSE 'xor' b1 = b1;

:: BINARITH:th 16
theorem
for b1 being boolean set holds
   b1 '&' b1 = b1;

:: BINARITH:th 19
theorem
for b1 being boolean set holds
   b1 'or' TRUE = TRUE;

:: BINARITH:th 20
theorem
for b1, b2, b3 being boolean set holds
(b1 'or' b2) 'or' b3 = b1 'or' (b2 'or' b3);

:: BINARITH:th 21
theorem
for b1 being boolean set holds
   b1 'or' b1 = b1;

:: BINARITH:th 33
theorem
TRUE 'xor' FALSE = TRUE;

:: BINARITH:funcnot 3 => BINARITH:func 3
definition
  let a1, a2 be natural set;
  func A1 -' A2 -> Element of NAT equals
    a1 - a2
    if 0 <= a1 - a2
    otherwise 0;
end;

:: BINARITH:def 3
theorem
for b1, b2 being natural set holds
(0 <= b1 - b2 implies b1 -' b2 = b1 - b2) &
 (0 <= b1 - b2 or b1 -' b2 = 0);

:: BINARITH:th 39
theorem
for b1, b2 being natural set holds
(b1 + b2) -' b2 = b1;

:: BINARITH:funcnot 4 => BINARITH:func 4
definition
  let a1 be Element of NAT;
  let a2 be Element of a1 -tuples_on BOOLEAN;
  func 'not' A2 -> Element of a1 -tuples_on BOOLEAN means
    for b1 being Element of NAT
          st b1 in Seg a1
       holds it /. b1 = 'not' (a2 /. b1);
end;

:: BINARITH:def 4
theorem
for b1 being Element of NAT
for b2, b3 being Element of b1 -tuples_on BOOLEAN holds
   b3 = 'not' b2
iff
   for b4 being Element of NAT
         st b4 in Seg b1
      holds b3 /. b4 = 'not' (b2 /. b4);

:: BINARITH:funcnot 5 => BINARITH:func 5
definition
  let a1 be non empty Element of NAT;
  let a2, a3 be Element of a1 -tuples_on BOOLEAN;
  func carry(A2,A3) -> Element of a1 -tuples_on BOOLEAN means
    it /. 1 = FALSE &
     (for b1 being Element of NAT
           st 1 <= b1 & b1 < a1
        holds it /. (b1 + 1) = (((a2 /. b1) '&' (a3 /. b1)) 'or' ((a2 /. b1) '&' (it /. b1))) 'or' ((a3 /. b1) '&' (it /. b1)));
end;

:: BINARITH:def 5
theorem
for b1 being non empty Element of NAT
for b2, b3, b4 being Element of b1 -tuples_on BOOLEAN holds
   b4 = carry(b2,b3)
iff
   b4 /. 1 = FALSE &
    (for b5 being Element of NAT
          st 1 <= b5 & b5 < b1
       holds b4 /. (b5 + 1) = (((b2 /. b5) '&' (b3 /. b5)) 'or' ((b2 /. b5) '&' (b4 /. b5))) 'or' ((b3 /. b5) '&' (b4 /. b5)));

:: BINARITH:funcnot 6 => BINARITH:func 6
definition
  let a1 be Element of NAT;
  let a2 be Element of a1 -tuples_on BOOLEAN;
  func Binary A2 -> Element of a1 -tuples_on NAT means
    for b1 being Element of NAT
          st b1 in Seg a1
       holds it /. b1 = IFEQ(a2 /. b1,FALSE,0,2 to_power (b1 -' 1));
end;

:: BINARITH:def 6
theorem
for b1 being Element of NAT
for b2 being Element of b1 -tuples_on BOOLEAN
for b3 being Element of b1 -tuples_on NAT holds
      b3 = Binary b2
   iff
      for b4 being Element of NAT
            st b4 in Seg b1
         holds b3 /. b4 = IFEQ(b2 /. b4,FALSE,0,2 to_power (b4 -' 1));

:: BINARITH:funcnot 7 => BINARITH:func 7
definition
  let a1 be Element of NAT;
  let a2 be Element of a1 -tuples_on BOOLEAN;
  func Absval A2 -> Element of NAT equals
    addnat "**" Binary a2;
end;

:: BINARITH:def 7
theorem
for b1 being Element of NAT
for b2 being Element of b1 -tuples_on BOOLEAN holds
   Absval b2 = addnat "**" Binary b2;

:: BINARITH:funcnot 8 => BINARITH:func 8
definition
  let a1 be non empty Element of NAT;
  let a2, a3 be Element of a1 -tuples_on BOOLEAN;
  func A2 + A3 -> Element of a1 -tuples_on BOOLEAN means
    for b1 being Element of NAT
          st b1 in Seg a1
       holds it /. b1 = ((a2 /. b1) 'xor' (a3 /. b1)) 'xor' ((carry(a2,a3)) /. b1);
end;

:: BINARITH:def 8
theorem
for b1 being non empty Element of NAT
for b2, b3, b4 being Element of b1 -tuples_on BOOLEAN holds
   b4 = b2 + b3
iff
   for b5 being Element of NAT
         st b5 in Seg b1
      holds b4 /. b5 = ((b2 /. b5) 'xor' (b3 /. b5)) 'xor' ((carry(b2,b3)) /. b5);

:: BINARITH:funcnot 9 => BINARITH:func 9
definition
  let a1 be non empty Element of NAT;
  let a2, a3 be Element of a1 -tuples_on BOOLEAN;
  func add_ovfl(A2,A3) -> Element of BOOLEAN equals
    (((a2 /. a1) '&' (a3 /. a1)) 'or' ((a2 /. a1) '&' ((carry(a2,a3)) /. a1))) 'or' ((a3 /. a1) '&' ((carry(a2,a3)) /. a1));
end;

:: BINARITH:def 9
theorem
for b1 being non empty Element of NAT
for b2, b3 being Element of b1 -tuples_on BOOLEAN holds
add_ovfl(b2,b3) = (((b2 /. b1) '&' (b3 /. b1)) 'or' ((b2 /. b1) '&' ((carry(b2,b3)) /. b1))) 'or' ((b3 /. b1) '&' ((carry(b2,b3)) /. b1));

:: BINARITH:sch 1
scheme BINARITH:sch 1
for b1 being non empty Element of NAT holds
   P1[b1]
provided
   P1[1]
and
   for b1 being non empty Element of NAT
         st P1[b1]
      holds P1[b1 + 1];


:: BINARITH:prednot 1 => BINARITH:pred 1
definition
  let a1 be non empty Element of NAT;
  let a2, a3 be Element of a1 -tuples_on BOOLEAN;
  pred A2,A3 are_summable means
    add_ovfl(a2,a3) = FALSE;
end;

:: BINARITH:dfs 8
definiens
  let a1 be non empty Element of NAT;
  let a2, a3 be Element of a1 -tuples_on BOOLEAN;
To prove
     a2,a3 are_summable
it is sufficient to prove
  thus add_ovfl(a2,a3) = FALSE;

:: BINARITH:def 10
theorem
for b1 being non empty Element of NAT
for b2, b3 being Element of b1 -tuples_on BOOLEAN holds
   b2,b3 are_summable
iff
   add_ovfl(b2,b3) = FALSE;

:: BINARITH:th 40
theorem
for b1 being Element of 1 -tuples_on BOOLEAN
      st b1 <> <*FALSE*>
   holds b1 = <*TRUE*>;

:: BINARITH:th 41
theorem
for b1 being Element of 1 -tuples_on BOOLEAN
      st b1 = <*FALSE*>
   holds Absval b1 = 0;

:: BINARITH:th 42
theorem
for b1 being Element of 1 -tuples_on BOOLEAN
      st b1 = <*TRUE*>
   holds Absval b1 = 1;

:: BINARITH:funcnot 10 => BINARITH:func 10
definition
  let a1 be non empty Element of NAT;
  let a2 be Element of NAT;
  let a3 be non empty set;
  let a4 be Element of a1 -tuples_on a3;
  let a5 be Element of a2 -tuples_on a3;
  redefine func a4 ^ a5 -> Element of (a1 + a2) -tuples_on a3;
end;

:: BINARITH:funcnot 11 => BINARITH:func 11
definition
  let a1 be non empty set;
  let a2 be Element of a1;
  redefine func <*a2*> -> Element of 1 -tuples_on a1;
end;

:: BINARITH:th 43
theorem
for b1 being non empty Element of NAT
for b2, b3 being Element of b1 -tuples_on BOOLEAN
for b4, b5 being Element of BOOLEAN
for b6 being Element of NAT
      st b6 in Seg b1
   holds (carry(b2 ^ <*b4*>,b3 ^ <*b5*>)) /. b6 = (carry(b2,b3)) /. b6;

:: BINARITH:th 44
theorem
for b1 being non empty Element of NAT
for b2, b3 being Element of b1 -tuples_on BOOLEAN
for b4, b5 being Element of BOOLEAN holds
add_ovfl(b2,b3) = (carry(b2 ^ <*b4*>,b3 ^ <*b5*>)) /. (b1 + 1);

:: BINARITH:th 45
theorem
for b1 being non empty Element of NAT
for b2, b3 being Element of b1 -tuples_on BOOLEAN
for b4, b5 being Element of BOOLEAN holds
(b2 ^ <*b4*>) + (b3 ^ <*b5*>) = (b2 + b3) ^ <*(b4 'xor' b5) 'xor' add_ovfl(b2,b3)*>;

:: BINARITH:th 46
theorem
for b1 being non empty Element of NAT
for b2 being Element of b1 -tuples_on BOOLEAN
for b3 being Element of BOOLEAN holds
   Absval (b2 ^ <*b3*>) = (Absval b2) + IFEQ(b3,FALSE,0,2 to_power b1);

:: BINARITH:th 47
theorem
for b1 being non empty Element of NAT
for b2, b3 being Element of b1 -tuples_on BOOLEAN holds
(Absval (b2 + b3)) + IFEQ(add_ovfl(b2,b3),FALSE,0,2 to_power b1) = (Absval b2) + Absval b3;

:: BINARITH:th 48
theorem
for b1 being non empty Element of NAT
for b2, b3 being Element of b1 -tuples_on BOOLEAN
      st b2,b3 are_summable
   holds Absval (b2 + b3) = (Absval b2) + Absval b3;

:: BINARITH:th 49
theorem
for b1, b2, b3 being natural set
      st b1 <= b2 & b1 <= b3 & b2 -' b1 = b3 -' b1
   holds b2 = b3;

:: BINARITH:th 50
theorem
for b1, b2 being natural set
      st b1 <= b2
   holds b2 -' b1 = b2 - b1;

:: BINARITH:th 51
theorem
for b1 being natural set holds
   b1 -' b1 = 0;

:: BINARITH:th 52
theorem
for b1, b2 being natural set holds
b1 -' b2 <= b1;

:: BINARITH:th 53
theorem
for b1, b2 being natural set
      st b2 <= b1
   holds (b1 -' b2) + b2 = b1;

:: BINARITH:th 54
theorem
for b1, b2 being natural set
      st b1 -' b2 = 0
   holds b1 <= b2;

:: BINARITH:th 55
theorem
for b1, b2, b3 being natural set
      st b1 <= b2
   holds (b2 + b3) -' b1 = (b2 + b3) - b1;

:: BINARITH:th 56
theorem
for b1, b2, b3 being natural set
      st b1 <= b2
   holds (b2 + b3) -' b1 = (b2 -' b1) + b3;

:: BINARITH:th 57
theorem
for b1, b2 being natural set
      st (1 <= b1 -' b2 or 1 <= b1 - b2)
   holds b1 -' b2 = b1 - b2;

:: BINARITH:th 58
theorem
for b1 being natural set holds
   b1 -' 0 = b1;

:: BINARITH:th 59
theorem
for b1, b2, b3 being natural set
      st b1 <= b2
   holds b3 -' b2 <= b3 -' b1;

:: BINARITH:th 60
theorem
for b1, b2, b3 being natural set
      st b1 <= b2
   holds b1 -' b3 <= b2 -' b3;

:: BINARITH:th 61
theorem
for b1, b2 being natural set
      st (1 <= b1 -' b2 or 1 <= b1 - b2)
   holds (b1 -' b2) + b2 = b1;

:: BINARITH:th 62
theorem
for b1, b2 being natural set
      st b1 <= b2
   holds b1 -' 1 <= b2;

:: BINARITH:th 63
theorem
for b1 being natural set holds
   b1 -' 2 = (b1 -' 1) -' 1;

:: BINARITH:th 64
theorem
for b1, b2 being natural set
      st b1 + 1 <= b2
   holds b1 -' 1 < b2 & b1 -' 2 < b2 & b1 <= b2;

:: BINARITH:th 65
theorem
for b1, b2 being natural set
      st (b1 + 2 <= b2 or (b1 + 1) + 1 <= b2)
   holds b1 + 1 < b2 &
    (b1 + 1) -' 1 < b2 &
    (b1 + 1) -' 2 < b2 &
    b1 + 1 <= b2 &
    (b1 -' 1) + 1 < b2 &
    ((b1 -' 1) + 1) -' 1 < b2 &
    b1 < b2 &
    b1 -' 1 < b2 &
    b1 -' 2 < b2 &
    b1 <= b2;

:: BINARITH:th 66
theorem
for b1, b2 being natural set
      st (b1 <= b2 or b1 <= b2 -' 1)
   holds b1 < b2 + 1 & b1 <= b2 + 1 & b1 < (b2 + 1) + 1 & b1 <= (b2 + 1) + 1 & b1 < b2 + 2 & b1 <= b2 + 2;

:: BINARITH:th 67
theorem
for b1, b2 being natural set
      st (b2 <= b1 implies b1 + 1 <= b2)
   holds b1 <= b2 -' 1;

:: BINARITH:th 68
theorem
for b1, b2, b3 being natural set
      st b2 <= b1
   holds b2 -' b3 <= b1;

:: BINARITH:th 69
theorem
for b1, b2 being natural set
      st 1 <= b1 & 1 <= b2 -' b1
   holds b2 -' b1 < b2;

:: BINARITH:th 70
theorem
for b1, b2, b3 being natural set
      st b1 -' b2 <= b3
   holds b1 <= b3 + b2;

:: BINARITH:th 71
theorem
for b1, b2, b3 being natural set
      st b1 <= b2 + b3
   holds b1 -' b3 <= b2;

:: BINARITH:th 72
theorem
for b1, b2, b3 being natural set
      st b1 <= b2 -' b3 & b3 <= b2
   holds b1 + b3 <= b2;

:: BINARITH:th 73
theorem
for b1, b2, b3 being natural set
      st b1 + b2 <= b3
   holds b2 <= b3 -' b1;

:: BINARITH:th 74
theorem
for b1, b2, b3 being natural set
      st b1 <= b2 & b2 < b3
   holds b2 -' b1 < b3 -' b1;

:: BINARITH:th 75
theorem
for b1, b2, b3 being natural set
      st b1 < b2 & b3 < b2
   holds b1 -' b3 < b2 -' b3;

:: BINARITH:th 76
theorem
for b1 being non empty set
for b2 being FinSequence of b1
for b3 being natural set holds
   len (b2 /^ b3) = (len b2) -' b3;