Article NEWTON, MML version 4.99.1005

:: NEWTON:th 3
theorem
for b1, b2 being Relation-like Function-like FinSequence-like set
      st len b1 = len b2 &
         (for b3 being natural set
               st b3 in dom b1
            holds b1 . b3 = b2 . b3)
   holds b1 = b2;

:: NEWTON:th 5
theorem
for b1 being natural set
      st 1 <= b1
   holds Seg b1 = ({1} \/ {b2 where b2 is Element of NAT: 1 < b2 & b2 < b1}) \/ {b1};

:: NEWTON:th 6
theorem
for b1 being real set
for b2 being FinSequence of REAL holds
   len (b1 * b2) = len b2;

:: NEWTON:th 7
theorem
for b1 being real set
for b2 being FinSequence of REAL holds
   dom b2 = dom (b1 * b2);

:: NEWTON:funcnot 1 => NEWTON:func 1
definition
  let a1 be natural set;
  let a2 be real set;
  redefine func a1 |-> a2 -> FinSequence of REAL;
end;

:: NEWTON:funcreg 1
registration
  let a1 be complex set;
  let a2 be natural set;
  cluster a2 |-> a1 -> Relation-like Function-like FinSequence-like complex-valued;
end;

:: NEWTON:funcnot 2 => NEWTON:func 2
definition
  let a1 be complex set;
  let a2 be natural set;
  func A1 |^ A2 -> set equals
    Product (a2 |-> a1);
end;

:: NEWTON:def 1
theorem
for b1 being complex set
for b2 being natural set holds
   b1 |^ b2 = Product (b2 |-> b1);

:: NEWTON:funcreg 2
registration
  let a1 be real set;
  let a2 be natural set;
  cluster a1 |^ a2 -> real;
end;

:: NEWTON:funcnot 3 => NEWTON:func 3
definition
  let a1 be Element of REAL;
  let a2 be natural set;
  redefine func a1 |^ a2 -> Element of REAL;
end;

:: NEWTON:th 9
theorem
for b1 being complex set holds
   b1 |^ 0 = 1;

:: NEWTON:funcreg 3
registration
  let a1 be complex set;
  let a2 be natural set;
  cluster a1 |^ a2 -> complex;
end;

:: NEWTON:th 10
theorem
for b1 being complex set holds
   b1 |^ 1 = b1;

:: NEWTON:th 11
theorem
for b1 being natural set
for b2 being complex set holds
   b2 |^ (b1 + 1) = (b2 |^ b1) * b2;

:: NEWTON:funcreg 4
registration
  let a1, a2 be natural set;
  cluster a1 |^ a2 -> natural;
end;

:: NEWTON:th 12
theorem
for b1 being natural set
for b2, b3 being complex set holds
(b2 * b3) |^ b1 = (b2 |^ b1) * (b3 |^ b1);

:: NEWTON:th 13
theorem
for b1, b2 being natural set
for b3 being complex set holds
   b3 |^ (b1 + b2) = (b3 |^ b1) * (b3 |^ b2);

:: NEWTON:th 14
theorem
for b1, b2 being natural set
for b3 being complex set holds
   (b3 |^ b1) |^ b2 = b3 |^ (b1 * b2);

:: NEWTON:th 15
theorem
for b1 being natural set holds
   1 |^ b1 = 1;

:: NEWTON:th 16
theorem
for b1 being natural set
      st 1 <= b1
   holds 0 |^ b1 = 0;

:: NEWTON:funcnot 4 => NEWTON:func 4
definition
  let a1 be natural set;
  redefine func idseq a1 -> FinSequence of REAL;
end;

:: NEWTON:funcnot 5 => NEWTON:func 5
definition
  let a1 be natural set;
  func A1 ! -> Element of REAL equals
    Product idseq a1;
end;

:: NEWTON:def 2
theorem
for b1 being natural set holds
   b1 ! = Product idseq b1;

:: NEWTON:funcreg 5
registration
  let a1 be natural set;
  cluster a1 ! -> real;
end;

:: NEWTON:funcnot 6 => NEWTON:func 6
definition
  let a1 be natural set;
  redefine func a1 ! -> Element of REAL;
end;

:: NEWTON:th 18
theorem
0 ! = 1;

:: NEWTON:th 19
theorem
1 ! = 1;

:: NEWTON:th 20
theorem
2 ! = 2;

:: NEWTON:th 21
theorem
for b1 being natural set holds
   (b1 + 1) ! = b1 ! * (b1 + 1);

:: NEWTON:th 22
theorem
for b1 being natural set holds
   b1 ! is Element of NAT;

:: NEWTON:th 23
theorem
for b1 being natural set holds
   0 < b1 !;

:: NEWTON:th 25
theorem
for b1, b2 being natural set holds
b1 ! * (b2 !) <> 0;

:: NEWTON:funcnot 7 => NEWTON:func 7
definition
  let a1, a2 be natural set;
  func A2 choose A1 -> set means
    for b1 being natural set
          st b1 = a2 - a1
       holds it = a2 ! / (a1 ! * (b1 !))
    if a1 <= a2
    otherwise it = 0;
end;

:: NEWTON:def 3
theorem
for b1, b2 being natural set
for b3 being set holds
   (b1 <= b2 implies    (b3 = b2 choose b1
    iff
       for b4 being natural set
             st b4 = b2 - b1
          holds b3 = b2 ! / (b1 ! * (b4 !)))) &
    (b1 <= b2 or    (b3 = b2 choose b1
    iff
       b3 = 0));

:: NEWTON:funcreg 6
registration
  let a1, a2 be natural set;
  cluster a2 choose a1 -> real;
end;

:: NEWTON:funcnot 8 => NEWTON:func 8
definition
  let a1, a2 be natural set;
  redefine func a2 choose a1 -> Element of REAL;
end;

:: NEWTON:th 27
theorem
0 choose 0 = 1;

:: NEWTON:th 29
theorem
for b1 being natural set holds
   b1 choose 0 = 1;

:: NEWTON:th 30
theorem
for b1, b2 being natural set
   st b2 <= b1
for b3 being natural set
      st b3 = b1 - b2
   holds b1 choose b2 = b1 choose b3;

:: NEWTON:th 31
theorem
for b1 being natural set holds
   b1 choose b1 = 1;

:: NEWTON:th 32
theorem
for b1, b2 being natural set holds
(b1 + 1) choose (b2 + 1) = (b1 choose (b2 + 1)) + (b1 choose b2);

:: NEWTON:th 33
theorem
for b1 being natural set
      st 1 <= b1
   holds b1 choose 1 = b1;

:: NEWTON:th 34
theorem
for b1, b2 being natural set
      st 1 <= b1 & b2 = b1 - 1
   holds b1 choose b2 = b1;

:: NEWTON:th 35
theorem
for b1, b2 being natural set holds
b1 choose b2 is Element of NAT;

:: NEWTON:th 36
theorem
for b1, b2 being natural set
for b3 being FinSequence of REAL
      st b2 <> 0 &
         len b3 = b2 &
         (for b4, b5 being natural set
               st b4 in dom b3 & b5 = (b1 + b4) - 1
            holds b3 . b4 = b5 choose b1)
   holds Sum b3 = (b1 + b2) choose (b1 + 1);

:: NEWTON:funcreg 7
registration
  let a1, a2 be natural set;
  cluster a2 choose a1 -> natural;
end;

:: NEWTON:funcnot 9 => NEWTON:func 9
definition
  let a1, a2 be natural set;
  redefine func a2 choose a1 -> Element of NAT;
end;

:: NEWTON:funcnot 10 => NEWTON:func 10
definition
  let a1, a2 be real set;
  let a3 be natural set;
  func (A1,A2)In_Power A3 -> FinSequence of REAL means
    len it = a3 + 1 &
     (for b1, b2, b3 being natural set
           st b1 in dom it & b3 = b1 - 1 & b2 = a3 - b3
        holds it . b1 = ((a3 choose b3) * (a1 |^ b2)) * (a2 |^ b3));
end;

:: NEWTON:def 4
theorem
for b1, b2 being real set
for b3 being natural set
for b4 being FinSequence of REAL holds
      b4 = (b1,b2)In_Power b3
   iff
      len b4 = b3 + 1 &
       (for b5, b6, b7 being natural set
             st b5 in dom b4 & b7 = b5 - 1 & b6 = b3 - b7
          holds b4 . b5 = ((b3 choose b7) * (b1 |^ b6)) * (b2 |^ b7));

:: NEWTON:th 38
theorem
for b1, b2 being real set holds
(b1,b2)In_Power 0 = <*1*>;

:: NEWTON:th 39
theorem
for b1 being natural set
for b2, b3 being real set holds
((b2,b3)In_Power b1) . 1 = b2 |^ b1;

:: NEWTON:th 40
theorem
for b1 being natural set
for b2, b3 being real set holds
((b2,b3)In_Power b1) . (b1 + 1) = b3 |^ b1;

:: NEWTON:th 41
theorem
for b1 being natural set
for b2, b3 being real set holds
(b2 + b3) |^ b1 = Sum ((b2,b3)In_Power b1);

:: NEWTON:funcnot 11 => NEWTON:func 11
definition
  let a1 be natural set;
  func Newton_Coeff A1 -> FinSequence of REAL means
    len it = a1 + 1 &
     (for b1, b2 being natural set
           st b1 in dom it & b2 = b1 - 1
        holds it . b1 = a1 choose b2);
end;

:: NEWTON:def 5
theorem
for b1 being natural set
for b2 being FinSequence of REAL holds
      b2 = Newton_Coeff b1
   iff
      len b2 = b1 + 1 &
       (for b3, b4 being natural set
             st b3 in dom b2 & b4 = b3 - 1
          holds b2 . b3 = b1 choose b4);

:: NEWTON:th 43
theorem
for b1 being natural set holds
   Newton_Coeff b1 = (1,1)In_Power b1;

:: NEWTON:th 44
theorem
for b1 being natural set holds
   2 |^ b1 = Sum Newton_Coeff b1;

:: NEWTON:th 45
theorem
for b1, b2 being natural set
      st 1 <= b1
   holds b2 <= b2 * b1;

:: NEWTON:th 46
theorem
for b1, b2, b3 being natural set
      st 1 <= b1 & b3 * b1 <= b2
   holds b3 <= b2;

:: NEWTON:funcnot 12 => NEWTON:func 12
definition
  let a1 be natural set;
  redefine func a1 ! -> Element of NAT;
end;

:: NEWTON:th 47
theorem
for b1 being natural set
      st b1 <> 0
   holds b1 divides b1 !;

:: NEWTON:th 48
theorem
for b1 being natural set
      st b1 <> 0
   holds 1 < (b1 + 1) / b1;

:: NEWTON:th 49
theorem
for b1 being natural set holds
   b1 / (b1 + 1) < 1;

:: NEWTON:th 50
theorem
for b1 being natural set holds
   b1 <= b1 !;

:: NEWTON:th 51
theorem
for b1, b2 being natural set
      st b1 <> 1 & b1 divides b2
   holds not b1 divides b2 + 1;

:: NEWTON:th 52
theorem
for b1, b2 being natural set holds
   b1 divides b2 & b1 divides b2 + 1
iff
   b1 = 1;

:: NEWTON:th 53
theorem
for b1, b2 being natural set
      st b1 <> 0
   holds b1 divides (b1 + b2) !;

:: NEWTON:th 54
theorem
for b1, b2 being natural set
      st b1 <= b2 & b1 <> 0
   holds b1 divides b2 !;

:: NEWTON:th 55
theorem
for b1, b2 being natural set
      st b1 <> 1 & b1 <> 0 & b1 divides b2 ! + 1
   holds b2 < b1;

:: NEWTON:th 56
theorem
for b1, b2, b3 being natural set holds
b1 lcm (b2 lcm b3) = (b1 lcm b2) lcm b3;

:: NEWTON:th 57
theorem
for b1, b2 being natural set holds
   b1 divides b2
iff
   b1 lcm b2 = b2;

:: NEWTON:th 58
theorem
for b1, b2, b3 being natural set holds
   b1 divides b2 & b3 divides b2
iff
   b1 lcm b3 divides b2;

:: NEWTON:th 59
theorem
for b1 being natural set holds
   b1 lcm 1 = b1;

:: NEWTON:th 60
theorem
for b1, b2 being natural set holds
b1 lcm b2 divides b1 * b2;

:: NEWTON:th 61
theorem
for b1, b2, b3 being natural set holds
b1 hcf (b2 hcf b3) = (b1 hcf b2) hcf b3;

:: NEWTON:th 62
theorem
for b1, b2 being natural set
      st b1 divides b2
   holds b1 hcf b2 = b1;

:: NEWTON:th 63
theorem
for b1, b2, b3 being natural set holds
   b1 divides b2 & b1 divides b3
iff
   b1 divides b2 hcf b3;

:: NEWTON:th 64
theorem
for b1 being natural set holds
   b1 hcf 1 = 1;

:: NEWTON:th 65
theorem
for b1 being natural set holds
   b1 hcf 0 = b1;

:: NEWTON:th 66
theorem
for b1, b2 being natural set holds
(b1 hcf b2) lcm b2 = b2;

:: NEWTON:th 67
theorem
for b1, b2 being natural set holds
b1 hcf (b1 lcm b2) = b1;

:: NEWTON:th 68
theorem
for b1, b2 being natural set holds
b1 hcf (b1 lcm b2) = (b2 hcf b1) lcm b1;

:: NEWTON:th 69
theorem
for b1, b2, b3 being natural set
      st b1 divides b2
   holds b1 hcf b3 divides b2 hcf b3;

:: NEWTON:th 70
theorem
for b1, b2, b3 being natural set
      st b1 divides b2
   holds b3 hcf b1 divides b3 hcf b2;

:: NEWTON:th 71
theorem
for b1, b2 being natural set
      st 0 < b1
   holds 0 < b1 hcf b2;

:: NEWTON:th 73
theorem
for b1, b2 being natural set
      st 0 < b1 & 0 < b2
   holds 0 < b1 lcm b2;

:: NEWTON:th 74
theorem
for b1, b2, b3 being natural set holds
(b1 hcf b2) lcm (b1 hcf b3) divides b1 hcf (b2 lcm b3);

:: NEWTON:th 75
theorem
for b1, b2, b3 being natural set
      st b1 divides b2
   holds b1 lcm (b3 hcf b2) divides (b1 lcm b3) hcf b2;

:: NEWTON:th 76
theorem
for b1, b2 being natural set holds
b1 hcf b2 divides b1 lcm b2;

:: NEWTON:th 77
theorem
for b1, b2 being natural set
      st 0 < b1
   holds b2 mod b1 = b2 - (b1 * (b2 div b1));

:: NEWTON:th 78
theorem
for b1, b2 being integer set
      st 0 <= b1
   holds 0 <= b2 mod b1;

:: NEWTON:th 79
theorem
for b1, b2 being integer set
      st 0 < b1
   holds b2 mod b1 < b1;

:: NEWTON:th 80
theorem
for b1, b2 being integer set
      st b1 <> 0
   holds b2 = ((b2 div b1) * b1) + (b2 mod b1);

:: NEWTON:th 81
theorem
for b1, b2 being natural set
      st (b1 <= 0 implies 0 < b2)
   holds ex b3, b4 being integer set st
      (b3 * b1) + (b4 * b2) = b1 hcf b2;

:: NEWTON:funcnot 13 => NEWTON:func 13
definition
  func SetPrimes -> Element of bool NAT means
    for b1 being natural set holds
          b1 in it
       iff
          b1 is prime;
end;

:: NEWTON:def 6
theorem
for b1 being Element of bool NAT holds
      b1 = SetPrimes
   iff
      for b2 being natural set holds
            b2 in b1
         iff
            b2 is prime;

:: NEWTON:exreg 1
registration
  cluster epsilon-transitive epsilon-connected ordinal natural complex real ext-real non negative integer prime rational complex-membered ext-real-membered real-membered rational-membered integer-membered natural-membered Element of NAT;
end;

:: NEWTON:exreg 2
registration
  cluster epsilon-transitive epsilon-connected ordinal natural complex real ext-real non negative integer prime set;
end;

:: NEWTON:modenot 1
definition
  mode Prime is natural prime set;
end;

:: NEWTON:funcnot 14 => NEWTON:func 14
definition
  let a1 be natural set;
  func SetPrimenumber A1 -> Element of bool NAT means
    for b1 being natural set holds
          b1 in it
       iff
          b1 < a1 & b1 is prime;
end;

:: NEWTON:def 7
theorem
for b1 being natural set
for b2 being Element of bool NAT holds
      b2 = SetPrimenumber b1
   iff
      for b3 being natural set holds
            b3 in b2
         iff
            b3 < b1 & b3 is prime;

:: NEWTON:th 82
theorem
for b1 being natural set holds
   SetPrimenumber b1 c= SetPrimes;

:: NEWTON:th 83
theorem
for b1, b2 being natural set
      st b1 <= b2
   holds SetPrimenumber b1 c= SetPrimenumber b2;

:: NEWTON:th 84
theorem
for b1 being natural set holds
   SetPrimenumber b1 c= Seg b1;

:: NEWTON:th 85
theorem
for b1 being natural set holds
   SetPrimenumber b1 is finite;

:: NEWTON:funcreg 8
registration
  let a1 be natural set;
  cluster SetPrimenumber a1 -> finite;
end;

:: NEWTON:th 86
theorem
for b1 being natural set holds
   ex b2 being natural prime set st
      b2 is prime & b1 < b2;

:: NEWTON:th 87
theorem
SetPrimes <> {};

:: NEWTON:th 88
theorem
SetPrimenumber 2 = {};

:: NEWTON:funcreg 9
registration
  cluster SetPrimenumber 2 -> empty;
end;

:: NEWTON:th 89
theorem
for b1 being natural set holds
   SetPrimenumber b1 c= NAT;

:: NEWTON:th 90
theorem
for b1 being natural set holds
   SetPrimenumber b1 c= Seg b1;

:: NEWTON:th 91
theorem
for b1 being natural set holds
   SetPrimenumber b1 is finite;

:: NEWTON:th 92
theorem
for b1, b2 being natural set
      st b2 <= b1
   holds not b1 in SetPrimenumber b2;

:: NEWTON:th 93
theorem
for b1 being natural set holds
   (SetPrimenumber b1) \/ {b1} is finite;

:: NEWTON:th 94
theorem
for b1 being natural prime set
for b2 being natural set
      st b1 < b2
   holds (SetPrimenumber b1) \/ {b1} c= SetPrimenumber b2;

:: NEWTON:th 95
theorem
for b1, b2 being natural set
      st b2 <= b1
   holds not b1 in SetPrimenumber b2;

:: NEWTON:funcnot 15 => NEWTON:func 15
definition
  let a1 be natural set;
  func primenumber A1 -> prime Element of NAT means
    a1 = card SetPrimenumber it;
end;

:: NEWTON:def 8
theorem
for b1 being natural set
for b2 being prime Element of NAT holds
      b2 = primenumber b1
   iff
      b1 = card SetPrimenumber b2;

:: NEWTON:th 96
theorem
for b1 being natural set holds
   SetPrimenumber b1 = {b2 where b2 is Element of NAT: b2 < b1 & b2 is prime};

:: NEWTON:th 97
theorem
SetPrimes is infinite;

:: NEWTON:funcreg 10
registration
  cluster SetPrimes -> non empty infinite;
end;

:: NEWTON:th 98
theorem
for b1 being natural set
   st b1 is prime
for b2, b3 being natural set
      st b1 divides b2 * b3 & not b1 divides b2
   holds b1 divides b3;

:: NEWTON:th 100
theorem
for b1 being real set holds
   b1 |^ 2 = b1 * b1 & b1 ^2 = b1 |^ 2;

:: NEWTON:th 101
theorem
for b1, b2 being natural set holds
b1 div b2 = b1 div b2 & b1 mod b2 = b1 mod b2;

:: NEWTON:th 102
theorem
for b1 being natural set
for b2 being real set
      st 0 < b2
   holds 0 < b2 |^ b1;

:: NEWTON:th 103
theorem
for b1 being natural set
      st 0 < b1
   holds 0 |^ b1 = 0;

:: NEWTON:funcnot 16 => NEWTON:func 16
definition
  let a1, a2 be Element of NAT;
  redefine func a1 |^ a2 -> Element of NAT;
end;

:: NEWTON:th 104
theorem
for b1 being natural set holds
   b1 + 1 <= 2 |^ b1;

:: NEWTON:th 105
theorem
for b1 being natural set holds
   b1 < 2 |^ b1;

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