:: NEWTON semantic presentation

theorem Th1: :: NEWTON:1
canceled;

theorem Th2: :: NEWTON:2
canceled;

theorem Th3: :: NEWTON:3
for F, G being FinSequence st len F = len G & ( for i being Element of NAT st i in dom F holds
F . i = G . i ) holds
F = G
proof end;

theorem Th4: :: NEWTON:4
canceled;

theorem Th5: :: NEWTON:5
for n being Element of NAT st n >= 1 holds
Seg n = ({1} \/ { k where k is Element of NAT : ( 1 < k & k < n ) } ) \/ {n}
proof end;

theorem Th6: :: NEWTON:6
for a being real number
for F being FinSequence of REAL holds len (a * F) = len F
proof end;

theorem Th7: :: NEWTON:7
for n being Element of NAT
for a being real number
for G being FinSequence of REAL holds
( n in dom G iff n in dom (a * G) )
proof end;

definition
let i be natural number ;
let x be real number ;
redefine func |-> as c1 |-> c2 -> FinSequence of REAL ;
coherence
i |-> x is FinSequence of REAL
proof end;
end;

registration
let x be complex number ;
let n be natural number ;
cluster a2 |-> a1 -> complex-yielding ;
coherence
n |-> x is complex-yielding
proof end;
end;

definition
let x be complex number ;
let n be natural number ;
func c1 |^ c2 -> set equals :: NEWTON:def 1
Product (n |-> x);
coherence
Product (n |-> x) is set
;
end;

:: deftheorem Def1 defines |^ NEWTON:def 1 :
for x being complex number
for n being natural number holds x |^ n = Product (n |-> x);

registration
let x be real number ;
let n be natural number ;
cluster a1 |^ a2 -> real ;
coherence
x |^ n is real
proof end;
end;

definition
let x be Real;
let n be natural number ;
redefine func |^ as c1 |^ c2 -> Real;
coherence
x |^ n is Real
by XREAL_0:def 1;
end;

theorem Th8: :: NEWTON:8
canceled;

theorem Th9: :: NEWTON:9
for z being complex number holds z |^ 0 = 1 by FINSEQ_2:72, RVSUM_1:124;

registration
let z be complex number ;
let n be natural number ;
cluster a1 |^ a2 -> complex ;
coherence
z |^ n is complex
;
end;

theorem Th10: :: NEWTON:10
for z being complex number holds z |^ 1 = z
proof end;

theorem Th11: :: NEWTON:11
for s being Nat
for z being complex number holds z |^ (s + 1) = (z |^ s) * z
proof end;

registration
let x be natural number , n be natural number ;
cluster a1 |^ a2 -> natural real ;
coherence
x |^ n is natural
proof end;
end;

theorem Th12: :: NEWTON:12
for s being Nat
for x, y being complex number holds (x * y) |^ s = (x |^ s) * (y |^ s)
proof end;

theorem Th13: :: NEWTON:13
for s, t being Nat
for x being complex number holds x |^ (s + t) = (x |^ s) * (x |^ t)
proof end;

theorem Th14: :: NEWTON:14
for s, t being Nat
for x being complex number holds (x |^ s) |^ t = x |^ (s * t)
proof end;

theorem Th15: :: NEWTON:15
for s being Nat holds 1 |^ s = 1
proof end;

theorem Th16: :: NEWTON:16
for s being Nat st s >= 1 holds
0 |^ s = 0
proof end;

definition
let n be natural number ;
redefine func idseq as idseq c1 -> FinSequence of REAL ;
coherence
idseq n is FinSequence of REAL
proof end;
end;

definition
let n be natural number ;
func c1 ! -> Real equals :: NEWTON:def 2
Product (idseq n);
coherence
Product (idseq n) is Real
by XREAL_0:def 1;
end;

:: deftheorem Def2 defines ! NEWTON:def 2 :
for n being natural number holds n ! = Product (idseq n);

registration
let n be natural number ;
cluster a1 ! -> real ;
coherence
n ! is real
;
end;

definition
let n be natural number ;
redefine func ! as c1 ! -> Real;
coherence
n ! is Real
;
end;

theorem Th17: :: NEWTON:17
canceled;

theorem Th18: :: NEWTON:18
0 ! = 1 by FINSEQ_2:58, RVSUM_1:124;

theorem Th19: :: NEWTON:19
1 ! = 1 by FINSEQ_2:59, RVSUM_1:125;

theorem Th20: :: NEWTON:20
2 ! = 2
proof end;

theorem Th21: :: NEWTON:21
for s being Nat holds (s + 1) ! = (s ! ) * (s + 1)
proof end;

theorem Th22: :: NEWTON:22
for s being Nat holds s ! is Element of NAT
proof end;

theorem Th23: :: NEWTON:23
for s being Nat holds s ! > 0
proof end;

theorem Th24: :: NEWTON:24
canceled;

theorem Th25: :: NEWTON:25
for s, t being Nat holds (s ! ) * (t ! ) <> 0
proof end;

definition
let k be natural number , n be natural number ;
func c2 choose c1 -> set means :Def3: :: NEWTON:def 3
for l being natural number st l = n - k holds
it = (n ! ) / ((k ! ) * (l ! )) if n >= k
otherwise it = 0;
consistency
for b1 being set holds verum
;
existence
( ( n >= k implies ex b1 being set st
for l being natural number st l = n - k holds
b1 = (n ! ) / ((k ! ) * (l ! )) ) & ( not n >= k implies ex b1 being set st b1 = 0 ) )
proof end;
uniqueness
for b1, b2 being set holds
( ( n >= k & ( for l being natural number st l = n - k holds
b1 = (n ! ) / ((k ! ) * (l ! )) ) & ( for l being natural number st l = n - k holds
b2 = (n ! ) / ((k ! ) * (l ! )) ) implies b1 = b2 ) & ( not n >= k & b1 = 0 & b2 = 0 implies b1 = b2 ) )
proof end;
end;

:: deftheorem Def3 defines choose NEWTON:def 3 :
for k, n being natural number
for b3 being set holds
( ( n >= k implies ( b3 = n choose k iff for l being natural number st l = n - k holds
b3 = (n ! ) / ((k ! ) * (l ! )) ) ) & ( not n >= k implies ( b3 = n choose k iff b3 = 0 ) ) );

registration
let k be natural number , n be natural number ;
cluster a2 choose a1 -> real ;
coherence
n choose k is real
proof end;
end;

definition
let k be natural number , n be natural number ;
redefine func choose as c2 choose c1 -> Real;
coherence
n choose k is Real
by XREAL_0:def 1;
end;

theorem Th26: :: NEWTON:26
canceled;

theorem Th27: :: NEWTON:27
0 choose 0 = 1
proof end;

theorem Th28: :: NEWTON:28
canceled;

theorem Th29: :: NEWTON:29
for s being Nat holds s choose 0 = 1
proof end;

theorem Th30: :: NEWTON:30
for s, t being Nat st s >= t holds
for r being Nat st r = s - t holds
s choose t = s choose r
proof end;

theorem Th31: :: NEWTON:31
for s being Nat holds s choose s = 1
proof end;

theorem Th32: :: NEWTON:32
for t, s being Nat holds (t + 1) choose (s + 1) = (t choose (s + 1)) + (t choose s)
proof end;

theorem Th33: :: NEWTON:33
for s being Nat st s >= 1 holds
s choose 1 = s
proof end;

theorem Th34: :: NEWTON:34
for s, t being Nat st s >= 1 & t = s - 1 holds
s choose t = s
proof end;

theorem Th35: :: NEWTON:35
for s, r being Nat holds s choose r is Element of NAT
proof end;

theorem Th36: :: NEWTON:36
for n, m being Element of NAT
for F being FinSequence of REAL st m <> 0 & len F = m & ( for i, l being Element of NAT st i in dom F & l = (n + i) - 1 holds
F . i = l choose n ) holds
Sum F = (n + m) choose (n + 1)
proof end;

registration
let k be natural number , n be natural number ;
cluster a2 choose a1 -> natural real ;
coherence
n choose k is natural
by ;
end;

definition
let k be natural number , n be natural number ;
redefine func choose as c2 choose c1 -> Element of NAT ;
coherence
n choose k is Element of NAT
by ORDINAL1:def 13;
end;

definition
let a be real number , b be real number ;
let n be natural number ;
func c1,c2 In_Power c3 -> FinSequence of REAL means :Def4: :: NEWTON:def 4
( len it = n + 1 & ( for i, l, m being natural number st i in dom it & m = i - 1 & l = n - m holds
it . i = ((n choose m) * (a |^ l)) * (b |^ m) ) );
existence
ex b1 being FinSequence of REAL st
( len b1 = n + 1 & ( for i, l, m being natural number st i in dom b1 & m = i - 1 & l = n - m holds
b1 . i = ((n choose m) * (a |^ l)) * (b |^ m) ) )
proof end;
uniqueness
for b1, b2 being FinSequence of REAL st len b1 = n + 1 & ( for i, l, m being natural number st i in dom b1 & m = i - 1 & l = n - m holds
b1 . i = ((n choose m) * (a |^ l)) * (b |^ m) ) & len b2 = n + 1 & ( for i, l, m being natural number st i in dom b2 & m = i - 1 & l = n - m holds
b2 . i = ((n choose m) * (a |^ l)) * (b |^ m) ) holds
b1 = b2
proof end;
end;

:: deftheorem Def4 defines In_Power NEWTON:def 4 :
for a, b being real number
for n being natural number
for b4 being FinSequence of REAL holds
( b4 = a,b In_Power n iff ( len b4 = n + 1 & ( for i, l, m being natural number st i in dom b4 & m = i - 1 & l = n - m holds
b4 . i = ((n choose m) * (a |^ l)) * (b |^ m) ) ) );

theorem Th37: :: NEWTON:37
canceled;

theorem Th38: :: NEWTON:38
for a, b being real number holds a,b In_Power 0 = <*1*>
proof end;

theorem Th39: :: NEWTON:39
for s being Nat
for a, b being real number holds (a,b In_Power s) . 1 = a |^ s
proof end;

theorem Th40: :: NEWTON:40
for s being Nat
for a, b being real number holds (a,b In_Power s) . (s + 1) = b |^ s
proof end;

theorem Th41: :: NEWTON:41
for a, b being real number
for s being Nat holds (a + b) |^ s = Sum (a,b In_Power s)
proof end;

definition
let n be natural number ;
func Newton_Coeff c1 -> FinSequence of REAL means :Def5: :: NEWTON:def 5
( len it = n + 1 & ( for i, k being natural number st i in dom it & k = i - 1 holds
it . i = n choose k ) );
existence
ex b1 being FinSequence of REAL st
( len b1 = n + 1 & ( for i, k being natural number st i in dom b1 & k = i - 1 holds
b1 . i = n choose k ) )
proof end;
uniqueness
for b1, b2 being FinSequence of REAL st len b1 = n + 1 & ( for i, k being natural number st i in dom b1 & k = i - 1 holds
b1 . i = n choose k ) & len b2 = n + 1 & ( for i, k being natural number st i in dom b2 & k = i - 1 holds
b2 . i = n choose k ) holds
b1 = b2
proof end;
end;

:: deftheorem Def5 defines Newton_Coeff NEWTON:def 5 :
for n being natural number
for b2 being FinSequence of REAL holds
( b2 = Newton_Coeff n iff ( len b2 = n + 1 & ( for i, k being natural number st i in dom b2 & k = i - 1 holds
b2 . i = n choose k ) ) );

theorem Th42: :: NEWTON:42
canceled;

theorem Th43: :: NEWTON:43
for s being Nat holds Newton_Coeff s = 1,1 In_Power s
proof end;

theorem Th44: :: NEWTON:44
for s being Nat holds 2 |^ s = Sum (Newton_Coeff s)
proof end;

theorem Th45: :: NEWTON:45
for l, k being Element of NAT st l >= 1 holds
k * l >= k
proof end;

theorem Th46: :: NEWTON:46
for l, n, k being Element of NAT st l >= 1 & n >= k * l holds
n >= k
proof end;

definition
let n be Element of NAT ;
redefine func ! as c1 ! -> Element of NAT ;
coherence
n ! is Element of NAT
by ;
end;

theorem Th47: :: NEWTON:47
for l being Element of NAT st l <> 0 holds
l divides l !
proof end;

theorem Th48: :: NEWTON:48
for n being Element of NAT st n <> 0 holds
(n + 1) / n > 1
proof end;

theorem Th49: :: NEWTON:49
for k being Element of NAT holds k / (k + 1) < 1
proof end;

theorem Th50: :: NEWTON:50
for l being Element of NAT holds l ! >= l
proof end;

theorem Th51: :: NEWTON:51
for m, n being Element of NAT st m <> 1 & m divides n holds
not m divides n + 1
proof end;

theorem Th52: :: NEWTON:52
for l, j being Element of NAT holds
( ( j divides l & j divides l + 1 ) iff j = 1 ) by , NAT_1:53;

theorem Th53: :: NEWTON:53
for k, j being Element of NAT st j <> 0 holds
j divides (j + k) !
proof end;

theorem Th54: :: NEWTON:54
for l, j being Element of NAT st j <= l & j <> 0 holds
j divides l !
proof end;

theorem Th55: :: NEWTON:55
for l, j being Element of NAT st j <> 1 & j <> 0 & j divides (l ! ) + 1 holds
j > l
proof end;

theorem Th56: :: NEWTON:56
for m, n, k being Element of NAT holds m lcm (n lcm k) = (m lcm n) lcm k
proof end;

theorem Th57: :: NEWTON:57
for m, n being Element of NAT holds
( m divides n iff m lcm n = n )
proof end;

theorem Th58: :: NEWTON:58
for n, m, k being Element of NAT holds
( ( n divides m & k divides m ) iff n lcm k divides m )
proof end;

theorem Th59: :: NEWTON:59
for m being Element of NAT holds m lcm 1 = m
proof end;

theorem Th60: :: NEWTON:60
for m, n being Element of NAT holds m lcm n divides m * n
proof end;

theorem Th61: :: NEWTON:61
for m, n, k being Element of NAT holds m hcf (n hcf k) = (m hcf n) hcf k
proof end;

theorem Th62: :: NEWTON:62
for n, m being Element of NAT st n divides m holds
n hcf m = n
proof end;

theorem Th63: :: NEWTON:63
for m, n, k being Element of NAT holds
( ( m divides n & m divides k ) iff m divides n hcf k )
proof end;

theorem Th64: :: NEWTON:64
for m being Element of NAT holds m hcf 1 = 1
proof end;

theorem Th65: :: NEWTON:65
for m being Element of NAT holds m hcf 0 = m
proof end;

theorem Th66: :: NEWTON:66
for m, n being Element of NAT holds (m hcf n) lcm n = n
proof end;

theorem Th67: :: NEWTON:67
for m, n being Element of NAT holds m hcf (m lcm n) = m
proof end;

theorem Th68: :: NEWTON:68
for m, n being Element of NAT holds m hcf (m lcm n) = (n hcf m) lcm m
proof end;

theorem Th69: :: NEWTON:69
for m, n, k being Element of NAT st m divides n holds
m hcf k divides n hcf k
proof end;

theorem Th70: :: NEWTON:70
for m, n, k being Element of NAT st m divides n holds
k hcf m divides k hcf n
proof end;

theorem Th71: :: NEWTON:71
for n, m being Element of NAT st n > 0 holds
n hcf m > 0
proof end;

theorem Th72: :: NEWTON:72
canceled;

theorem Th73: :: NEWTON:73
for m, n being Element of NAT st m > 0 & n > 0 holds
m lcm n > 0
proof end;

theorem Th74: :: NEWTON:74
for n, m, k being Element of NAT holds (n hcf m) lcm (n hcf k) divides n hcf (m lcm k)
proof end;

theorem Th75: :: NEWTON:75
for m, l, n being Element of NAT st m divides l holds
m lcm (n hcf l) divides (m lcm n) hcf l
proof end;

theorem Th76: :: NEWTON:76
for n, m being Element of NAT holds n hcf m divides n lcm m
proof end;

theorem Th77: :: NEWTON:77
for n, m being Element of NAT st 0 < m holds
n mod m = n - (m * (n div m))
proof end;

theorem Th78: :: NEWTON:78
for i2, i1 being Integer st i2 >= 0 holds
i1 mod i2 >= 0
proof end;

theorem Th79: :: NEWTON:79
for i2, i1 being Integer st i2 > 0 holds
i1 mod i2 < i2
proof end;

theorem Th80: :: NEWTON:80
for i2, i1 being Integer st i2 <> 0 holds
i1 = ((i1 div i2) * i2) + (i1 mod i2)
proof end;

theorem Th81: :: NEWTON:81
for m, n being Element of NAT st ( m > 0 or n > 0 ) holds
ex i, i1 being Integer st (i * m) + (i1 * n) = m hcf n
proof end;

definition
func SetPrimes -> Subset of NAT means :Def6: :: NEWTON:def 6
for n being Nat holds
( n in it iff n is prime );
existence
ex b1 being Subset of NAT st
for n being Nat holds
( n in b1 iff n is prime )
proof end;
uniqueness
for b1, b2 being Subset of NAT st ( for n being Nat holds
( n in b1 iff n is prime ) ) & ( for n being Nat holds
( n in b2 iff n is prime ) ) holds
b1 = b2
proof end;
end;

:: deftheorem Def6 defines SetPrimes NEWTON:def 6 :
for b1 being Subset of NAT holds
( b1 = SetPrimes iff for n being Nat holds
( n in b1 iff n is prime ) );

registration
cluster prime Element of NAT ;
existence
ex b1 being Element of NAT st b1 is prime
by INT_2:44;
cluster prime set ;
existence
ex b1 being Nat st b1 is prime
by INT_2:44;
end;

definition
mode Prime is prime Element of NAT ;
end;

definition
let p be Nat;
func SetPrimenumber c1 -> Subset of NAT means :Def7: :: NEWTON:def 7
for q being Nat holds
( q in it iff ( q < p & q is prime ) );
existence
ex b1 being Subset of NAT st
for q being Nat holds
( q in b1 iff ( q < p & q is prime ) )
proof end;
uniqueness
for b1, b2 being Subset of NAT st ( for q being Nat holds
( q in b1 iff ( q < p & q is prime ) ) ) & ( for q being Nat holds
( q in b2 iff ( q < p & q is prime ) ) ) holds
b1 = b2
proof end;
end;

:: deftheorem Def7 defines SetPrimenumber NEWTON:def 7 :
for p being Nat
for b2 being Subset of NAT holds
( b2 = SetPrimenumber p iff for q being Nat holds
( q in b2 iff ( q < p & q is prime ) ) );

theorem Th82: :: NEWTON:82
for p being Nat holds SetPrimenumber p c= SetPrimes
proof end;

theorem Th83: :: NEWTON:83
for p, q being Nat st p <= q holds
SetPrimenumber p c= SetPrimenumber q
proof end;

theorem Th84: :: NEWTON:84
for p being Nat holds SetPrimenumber p c= Seg p
proof end;

theorem Th85: :: NEWTON:85
for p being Nat holds SetPrimenumber p is finite
proof end;

registration
let n be Nat;
cluster SetPrimenumber a1 -> finite ;
coherence
SetPrimenumber n is finite
by Th6;
end;

theorem Th86: :: NEWTON:86
for l being Nat ex p being Prime st
( p is prime & p > l )
proof end;

theorem Th87: :: NEWTON:87
SetPrimes <> {} by , INT_2:44;

theorem Th88: :: NEWTON:88
SetPrimenumber 2 = {}
proof end;

registration
cluster SetPrimenumber 2 -> empty finite ;
coherence
SetPrimenumber 2 is empty
by ;
end;

theorem Th89: :: NEWTON:89
for n being Element of NAT holds SetPrimenumber n c= NAT ;

theorem Th90: :: NEWTON:90
for m being Element of NAT holds SetPrimenumber m c= Seg m
proof end;

theorem Th91: :: NEWTON:91
for n being Element of NAT holds SetPrimenumber n is finite ;

theorem Th92: :: NEWTON:92
for k, m being Element of NAT st k >= m holds
not k in SetPrimenumber m by ;

theorem Th93: :: NEWTON:93
for f being Nat holds (SetPrimenumber f) \/ {f} is finite ;

theorem Th94: :: NEWTON:94
for f being Prime
for g being Nat st f < g holds
(SetPrimenumber f) \/ {f} c= SetPrimenumber g
proof end;

theorem Th95: :: NEWTON:95
for k, m being Element of NAT st k >= m holds
not k in SetPrimenumber m by ;

Lemma195: for n being Element of NAT holds SetPrimenumber n = { k where k is Element of NAT : ( k < n & k is prime ) }
proof end;

definition
let n be Nat;
func primenumber c1 -> Prime means :Def8: :: NEWTON:def 8
n = card (SetPrimenumber it);
existence
ex b1 being Prime st n = card (SetPrimenumber b1)
proof end;
uniqueness
for b1, b2 being Prime st n = card (SetPrimenumber b1) & n = card (SetPrimenumber b2) holds
b1 = b2
proof end;
end;

:: deftheorem Def8 defines primenumber NEWTON:def 8 :
for n being Nat
for b2 being Prime holds
( b2 = primenumber n iff n = card (SetPrimenumber b2) );

theorem Th96: :: NEWTON:96
for n being Element of NAT holds SetPrimenumber n = { k where k is Element of NAT : ( k < n & k is prime ) } by ;

theorem Th97: :: NEWTON:97
not SetPrimes is finite
proof end;

registration
cluster SetPrimes -> non empty infinite ;
coherence
( not SetPrimes is empty & not SetPrimes is finite )
by ;
end;

Lemma201: for n being Element of NAT st n is prime holds
n > 0
by INT_2:def 5;

theorem Th98: :: NEWTON:98
for i being Nat st i is prime holds
for m, n being Nat holds
( not i divides m * n or i divides m or i divides n )
proof end;

theorem Th99: :: NEWTON:99
for n being Element of NAT
for m being Nat holds m |^ n is Element of NAT by ORDINAL1:def 13;

theorem Th100: :: NEWTON:100
for x being real number holds
( x |^ 2 = x * x & x ^2 = x |^ 2 )
proof end;

theorem Th101: :: NEWTON:101
for m, n being natural number holds
( m div n = m div n & m mod n = m mod n )
proof end;

theorem Th102: :: NEWTON:102
for k being Nat
for x being real number st x > 0 holds
x |^ k > 0
proof end;

theorem Th103: :: NEWTON:103
for n being Element of NAT st n > 0 holds
0 |^ n = 0
proof end;