Article NAT_D, MML version 4.99.1005

:: NAT_D:funcnot 1 => NAT_D:func 1
definition
  let a1, a2 be natural set;
  redefine func A1 div A2 -> natural set means
    (for b1 being natural set
          st a1 = (a2 * it) + b1
       holds a2 <= b1) implies it = 0 & a2 = 0;
end;

:: NAT_D:def 1
theorem
for b1, b2, b3 being natural set holds
   b3 = b1 div b2
iff
   (for b4 being natural set
         st b1 = (b2 * b3) + b4
      holds b2 <= b4 implies b3 = 0 & b2 = 0);

:: NAT_D:funcnot 2 => NAT_D:func 2
definition
  let a1, a2 be natural set;
  redefine func A1 mod A2 -> natural set means
    (for b1 being natural set
          st a1 = (a2 * b1) + it
       holds a2 <= it) implies it = 0 & a2 = 0;
end;

:: NAT_D:def 2
theorem
for b1, b2, b3 being natural set holds
   b3 = b1 mod b2
iff
   (for b4 being natural set
         st b1 = (b2 * b4) + b3
      holds b2 <= b3 implies b3 = 0 & b2 = 0);

:: NAT_D:funcnot 3 => NAT_D:func 3
definition
  let a1, a2 be natural set;
  redefine func a1 div a2 -> Element of NAT;
end;

:: NAT_D:funcnot 4 => NAT_D:func 4
definition
  let a1, a2 be natural set;
  redefine func a1 mod a2 -> Element of NAT;
end;

:: NAT_D:th 1
theorem
for b1, b2 being natural set
      st 0 < b1
   holds b2 mod b1 < b1;

:: NAT_D:th 2
theorem
for b1, b2 being natural set
      st 0 < b1
   holds b2 = (b1 * (b2 div b1)) + (b2 mod b1);

:: NAT_D:prednot 1 => NAT_D:pred 1
definition
  let a1, a2 be natural set;
  redefine pred A1 divides A2 means
    ex b1 being natural set st
       a2 = a1 * b1;
  reflexivity;
::  for a1 being natural set holds
::     a1 divides a1;
end;

:: NAT_D:dfs 3
definiens
  let a1, a2 be natural set;
To prove
     a1 divides a2
it is sufficient to prove
  thus ex b1 being natural set st
       a2 = a1 * b1;

:: NAT_D:def 3
theorem
for b1, b2 being natural set holds
   b1 divides b2
iff
   ex b3 being natural set st
      b2 = b1 * b3;

:: NAT_D:th 3
theorem
for b1, b2 being natural set holds
   b1 divides b2
iff
   b2 = b1 * (b2 div b1);

:: NAT_D:th 4
theorem
for b1, b2, b3 being natural set
      st b1 divides b2 & b2 divides b3
   holds b1 divides b3;

:: NAT_D:th 5
theorem
for b1, b2 being natural set
      st b1 divides b2 & b2 divides b1
   holds b1 = b2;

:: NAT_D:th 6
theorem
for b1 being natural set holds
   b1 divides 0 & 1 divides b1;

:: NAT_D:th 7
theorem
for b1, b2 being natural set
      st 0 < b1 & b2 divides b1
   holds b2 <= b1;

:: NAT_D:th 8
theorem
for b1, b2, b3 being natural set
      st b1 divides b2 & b1 divides b3
   holds b1 divides b2 + b3;

:: NAT_D:th 9
theorem
for b1, b2, b3 being natural set
      st b1 divides b2
   holds b1 divides b2 * b3;

:: NAT_D:th 10
theorem
for b1, b2, b3 being natural set
      st b1 divides b2 & b1 divides b2 + b3
   holds b1 divides b3;

:: NAT_D:th 11
theorem
for b1, b2, b3 being natural set
      st b1 divides b2 & b1 divides b3
   holds b1 divides b2 mod b3;

:: NAT_D:funcnot 5 => INT_2:func 2
definition
  let a1, a2 be integer set;
  func A1 lcm A2 -> natural set means
    a1 divides it &
     a2 divides it &
     (for b1 being natural set
           st a1 divides b1 & a2 divides b1
        holds it divides b1);
  commutativity;
::  for a1, a2 being integer set holds
::  a1 lcm a2 = a2 lcm a1;
end;

:: NAT_D:def 4
theorem
for b1, b2, b3 being natural set holds
   b3 = b1 lcm b2
iff
   b1 divides b3 &
    b2 divides b3 &
    (for b4 being natural set
          st b1 divides b4 & b2 divides b4
       holds b3 divides b4);

:: NAT_D:funcnot 6 => NAT_D:func 5
definition
  let a1, a2 be natural set;
  redefine func a1 lcm a2 -> Element of NAT;
  commutativity;
::  for a1, a2 being natural set holds
::  a1 lcm a2 = a2 lcm a1;
end;

:: NAT_D:funcnot 7 => INT_2:func 3
notation
  let a1, a2 be natural set;
  synonym a1 hcf a2 for a1 gcd a2;
end;

:: NAT_D:funcnot 8 => INT_2:func 3
definition
  let a1, a2 be integer set;
  func A1 hcf A2 -> natural set means
    it divides a1 &
     it divides a2 &
     (for b1 being natural set
           st b1 divides a1 & b1 divides a2
        holds b1 divides it);
  commutativity;
::  for a1, a2 being integer set holds
::  a1 gcd a2 = a2 gcd a1;
end;

:: NAT_D:def 5
theorem
for b1, b2, b3 being natural set holds
   b3 = b1 gcd b2
iff
   b3 divides b1 &
    b3 divides b2 &
    (for b4 being natural set
          st b4 divides b1 & b4 divides b2
       holds b4 divides b3);

:: NAT_D:funcnot 9 => NAT_D:func 6
definition
  let a1, a2 be natural set;
  redefine func a1 hcf a2 -> Element of NAT;
  commutativity;
::  for a1, a2 being natural set holds
::  a1 hcf a2 = a2 hcf a1;
end;

:: NAT_D:sch 1
scheme NAT_D:sch 1
{F1 -> natural set,
  F2 -> natural set,
  F3 -> natural set}:
ex b1 being Element of NAT st
   F1(b1) = F2() hcf F3() & F1(b1 + 1) = 0
provided
   0 < F3() & F3() < F2()
and
   F1(0) = F2() & F1(1) = F3()
and
   for b1 being Element of NAT holds
      F1(b1 + 2) = F1(b1) mod F1(b1 + 1);


:: NAT_D:th 12
theorem
for b1 being natural set
      st b1 mod 2 <> 0
   holds b1 mod 2 = 1;

:: NAT_D:th 13
theorem
for b1, b2 being natural set holds
(b1 * b2) mod b1 = 0;

:: NAT_D:th 14
theorem
for b1 being natural set
      st 1 < b1
   holds 1 mod b1 = 1;

:: NAT_D:th 15
theorem
for b1, b2, b3, b4 being natural set
      st b1 mod b2 = 0 & b3 = b1 - (b4 * b2)
   holds b3 mod b2 = 0;

:: NAT_D:th 16
theorem
for b1, b2, b3 being natural set
      st b1 <> 0 & b2 mod b1 = 0 & b3 < b1
   holds (b2 + b3) mod b1 = b3;

:: NAT_D:th 17
theorem
for b1, b2, b3 being natural set
      st b1 mod b2 = 0
   holds (b1 + b3) mod b2 = b3 mod b2;

:: NAT_D:th 18
theorem
for b1, b2 being natural set
      st b1 <> 0
   holds (b1 * b2) div b1 = b2;

:: NAT_D:th 19
theorem
for b1, b2, b3 being natural set
      st b1 mod b2 = 0
   holds (b1 + b3) div b2 = (b1 div b2) + (b3 div b2);

:: NAT_D:th 20
theorem
for b1, b2 being natural set
      st b1 <> 0
   holds (b2 * b1) div b1 = b2;

:: NAT_D:th 21
theorem
for b1, b2, b3 being natural set holds
b1 mod b2 = ((b2 * b3) + b1) mod b2;

:: NAT_D:th 22
theorem
for b1, b2, b3 being natural set holds
(b1 + b2) mod b3 = ((b1 mod b3) + b2) mod b3;

:: NAT_D:th 23
theorem
for b1, b2, b3 being natural set holds
(b1 + b2) mod b3 = (b1 + (b2 mod b3)) mod b3;

:: NAT_D:th 24
theorem
for b1, b2 being natural set
      st b1 < b2
   holds b1 mod b2 = b1;

:: NAT_D:th 25
theorem
for b1 being natural set holds
   b1 mod b1 = 0;

:: NAT_D:th 26
theorem
for b1 being natural set holds
   0 = 0 mod b1;

:: NAT_D:th 27
theorem
for b1, b2 being natural set
      st b1 < b2
   holds b1 div b2 = 0;

:: NAT_D:th 28
theorem
for b1, b2 being natural set
      st 0 < b1
   holds b2 hcf b1 = b1 hcf (b2 mod b1);

:: NAT_D:sch 2
scheme NAT_D:sch 2
{F1 -> Element of NAT,
  F2 -> Element of NAT}:
P1[F2()]
provided
   P1[0]
and
   0 < F1()
and
   for b1, b2 being natural set
         st P1[F1() * b1] & b2 <> 0 & b2 <= F1()
      holds P1[(F1() * b1) + b2];


:: NAT_D:th 29
theorem
for b1, b2 being natural set holds
b1 * b2 = (b1 lcm b2) * (b1 hcf b2);

:: NAT_D:th 30
theorem
for b1, b2 being integer set
      st 0 <= b1 & 0 < b2
   holds b1 gcd b2 = b2 gcd (b1 mod b2);

:: NAT_D:th 31
theorem
for b1 being natural set holds
   b1 lcm b1 = b1;

:: NAT_D:th 32
theorem
for b1 being natural set holds
   b1 gcd b1 = b1;