Research Journal of Mathematics and Statistics 3(2): 72-76, 2011
ISSN: 2040-7505
© Maxwell Scientific Organization, 2011
Received: January 08, 2011
Accepted: February 03, 2011
Published: May 25, 2011
Proving the Computer Science Theory P = NP? With the General
Term of the Riemann Zeta Function
M.V. Atovigba
Department of Curriculum and Teaching, Benue State University,
P.M.B. 102119 Makurdi, Nigeria
Abstract: The study aims at showing that the general term or sequence of the Riemann zeta function is a
polynomial time algorithm or Turing machine M which is used to resolve the computer science theory: P = NP?
>(s)depends on the set of analytic zeros s = F+it as raw materials while s depends on t, where t and Fare real
numbers. The work shows that in polynomial time S(|t|) and for all strings of integer values n $ 1, M is closed
and bounded of real values: [0, 1]. The algorithm M satisfies Cook’s theorem which is an NP-Complete
problem. Hence, M is NP-Hard and hence NP-Complete and thus resolves the P = NP? problem at polynomial
time s(|t|).
Key words: Algorithm, closed bounded real values, complex variable, real-valued function, polynomial time,
riemann zeta function, turing machine
is too big to be efficient in practice. The
consequences, both positive and negative, arise since
various NP-complete problems are fundamental in
many fields. …There are enormous positive
consequences that would follow from rendering
tractable many currently mathematically intractable
problems. For instance, many problems in operations
research are NP-complete, such as some types of
integer programming, and the travelling salesman
problem, to name two of the most famous examples.
Efficient solutions to these problems would have
enormous implications for logistics. Many other
important problems, such as some problems in
protein structure prediction, are also NP-complete; if
these problems were efficiently solvable it could spur
considerable advances in biology.
INTRODUCTION
The computer science theory: P = NP? is a
computation complexity problem aimed at locating
whether there exists a polynomial time algorithm which
a well configured computer can undertake both a
deterministic task P and other nondeterministic processes
NP at the polynomial time (Wikipedia, 2010a).
It has already been observed that all algorithms in P
are also in NP (Tordable, 2010); but the open problem is
whether P = NP or not. The Wikipedia (2010b) notes that
the P versus NP problem is a major unsolved problem in
computer science which asks whether every problem
whose solution can be efficiently checked by a computer
can also be efficiently solved by a computer.
A problem is said to be in the NP class if it is solvable in
polynomial time by a nondeterministic Turing machine,
and a P problem whose time is bounded by a polynomial
is always NP, while a problem is considered NP-hard if an
algorithm for solving it can be translated into one for
solving any other NP-problem, and a problem which is
both NP and NP-hard is called an NP-complete problem
(Weisstein, 2010).
The proof of the P = NP? Theory will have estimated
consequences (Wikipedia, 2010b):
This research, however, aims at resolving the P =
NP? problem using the general term (or sequence) of the
Riemann zeta function:
∞
ζ ( s) = ∑ n − s
(1)
1
where
s = σ + it
A proof that P = NP could have stunning practical
consequences, if the proof leads to efficient methods
for solving some of the important problems in NP. It
is also possible that a proof would not lead to
efficient methods, perhaps if the proof is nonconstructive, or the size of the bounding polynomial
(2)
where i is imaginary and F, are real and specificallyF is a
constant while t is variable.
This is shown using absolute convergence of the
general term of (1). Thus if for some sequence un(x):
72
Res. J. Math. Stat., 3(2): 72-76, 2011
Lim
x→ ∞
µn+ 1( x )
< 1 (Spiegel, 2005)
µn ( x )
To prove (a) requires firstly to establish that there
exists a polynomial time algorithm or Turing machine M
as a verifier with a language L being in NP satisfying the
condition: if and only if there exist some polynomials p
and q, and a deterministic machine M, such that:
Now, since (2)Y s(t) and (1)Y H(s)=H(F+it) with F a
constant (predetermined) real number, the general term
for (1) is:
µn (t ) = n − (σ + it )
( )
Criterion i: For all x and y, M runs in time p x
input (x, y).
(3)
Criterion ii: For all x in L, there exists a string y of
( )
length q x
The research will focus on showing that (3) is a
polynomial time algorithm M which is NP, NP-Hard, and
hence NP-Complete and thus answers the P = NP?
complexity problem.
q( x ) , M(x, y) = 0 (Wikipedia, 2010a).
To satisfy these criteria, let x = t and y = n and
suppose that:
This research was started since September 5, 2010
along with this researcher’s work towards proving the
Riemann Hypothesis. This was because this researcher
strongly believed the Riemann zeta function of raw
materials s=F+it , to be a polynomial time algorithm M,
NP-Hard and NP-Complete and can be used to prove the
computer science theory: P = NP?
The materials used in this work include the Riemann
zeta function:
ς ( s) = ∑ n
−s
such that M(x, y) = 1.
Criterion iii: For all x not in L and all strings y of length
MATERIALS AND METHODS
∞
on
M = n− s
(4)
which is the general term (3) of the sequence
generated from the Riemann zeta function (1) such that
for polynomials p and q:
p( x ) = s( t ) = σ + i t
(5)
or
p= σ +it
(1)
1
and
where s = F+it , for t real and i imaginary, while
n = 1, 2, … .
s t
σ +i t )
q ( x ) = n ( ) = n(
= np
or
The method used in the work is proving for infinite
series absolute convergence, establishing existence of at
least one string n which generates the value of unity (1)
for the Turing machine M in some defined time range L,
establishing that M uniquely produces 0 for all n string
outside L, and showing that M can be applied to solve any
existing NP-Complete task.
q = np
( )
Criterion i holds since M runs in time s t
on input
(t, n).
Criterion ii also holds: ∀ t ∈ L: − ∞ ≤ L < ∞ , there exists
σ +i t )
a string n = 1 of length q t = n(
( )
Proof of the P = NP theory: To prove the computer
science theory entails identifying a polynomial time
algorithm M such that at polynomial time S, P = NP
(Wikipedia, 2010a) which requires proving that:
M=n
⎛1 ⎞
− ⎜ + it ⎟
⎝2 ⎠
such that
= 1 since 1 raised to any number returns 1.
Criterion iii also holds since for t ∉ L ⇒ t → ∞ , and
a)
M can, as a verifier, perform a deterministic process
P and also perform other nondeterministic processes
NP,
b) M can perform both processes at the same
polynomial time, and
c) M can be used to solve any existing NP-Complete
problem.
σ +i t )
all strings n of length q t = n(
, M(x,y) = 0. This
( )
is because t ∉ L ⇒ t → ∞ generates M = 0 as the
sequence absolutely converges to 0, that is:
By the ratio test for absolute convergence of the
general term of the sequence:
73
Res. J. Math. Stat., 3(2): 72-76, 2011
µn (t ) = n −(σ +it ) or
Within the range -4#L<4, for any t in L, if n = 1, M = 1.
Outside of this range,
1 1
1 ⎛ 1⎞
µn (t ) = σ . it = σ .⎜ t ⎟
n n
n ⎝n ⎠
i
(7)
t = ∞ ⇒ p→ ∞ ⇒ q→ ∞ ⇒ M = 0
Thus with p and q polynomials making M as a
verifier to have closed bounded real values [0,1], and
since M implies the existence of polynomials p and q,
then M is a verifier with a language L being in NP.
To prove (b), whether M can perform both processes
of solving a problem and verifying the solution at the
same polynomial (fast) time, so that P = NP at the said
polynomial time: We are to prove that M is NP-Hard and
hence NP-Complete. By NP-Hard requires that M is used
to solve at least one of the NP-Complete problems
(Weisstein, 2010). It is noted that Candidate M solves an
NP-Complete problem, namely, Cook’s theorem, which
goes by:
which converges absolutely to 0 since:
Lim
t→ ∞
µn+ 1(t )
<1
µn (t )
(8)
implying convergence of the sequence.
This is done taking n = 1 and n + 1 = 2
So that:
p = σ + it and q = n p
(11)
i
⎧⎛
⎞ ⎫
⎪⎜ 1 ⎟ ⎪
⎪⎪ ⎜⎝ (n + 1)t ⎟⎠ ⎪⎪
i
⎨
σ ⎬
⎛ 1⎞
⎧⎪ (0)i ⎫⎪
⎪ (n + 1) ⎪
⎜ t⎟
⎧ 0 ⎫
⎝
⎠
2
⎪
⎪
⎨ σ ⎬
⎨ σ⎬
2
σ
⎪⎩
⎪⎭
⎪
⎪
µn+1 (t )
⎩
⎭ = ⎩2 ⎭ = 0 = 0< 1
2
Lim
Lim
= Lim
=
=
i
t →∞ µn ( t )
t →∞
t →∞ ⎛ 1 ⎞
1
⎧⎛ 1 ⎞i ⎫
⎧ 1i ⎫
{1}
⎟
⎜
⎨ ⎬
⎪⎜ t ⎟ ⎪
t
⎝1 ⎠
⎪⎝ n ⎠ ⎪
⎩ 1⎭
⎨ σ ⎬
σ
1
⎪ n ⎪
⎪⎩
⎪⎭
Thus M = 0 for t not in L, which satisfies Criterion iii.
pair S, M. Prove that the algorithm for generating E(S, M)
runs in polynomial time. By polynomial time algorithm is
meant if the polynomial’s running time is upper bounded
by a polynomial in the size of the input for the
algorithm so that some T(n) = O(nk) for some constant k
(Wikipedia, 2010d).
1
The factor σ in (7) diminishes slower than small o:T(n)
n
= o(nk) = o(n-t) where t=4 as o(nk) = n-4 Hence, M is
bounded with small o:T(n) = o(nk) where k = -4 as o(nk)
= n-4 This makes the numerator to be zero and hence the
entire sequence halts to zero. Hence M is a polynomial
time algorithm.
Reversing the process (to satisfy the if and if only
condition), Let:
M = n − (σ + it ) = n − p =
1
1
p =
q
n
(9)
Now, rewriting Cook’s theorem so that:
E ( S , M ): s = σ + it , M = n − (σ + it )
(12)
the algorithm M runs in polynomial time so that for all,
(10)
σ +i t )
there exists n = 1 of length q t = n(
( )
and
M = n − (σ + it ) = 1 , and t ∉ L ⇒ t → ∞ , and all string n
Then (10) implies the existence of polynomials p
and q:
Given a string S and a Non-Deterministic Turing
machine M, create a CNF expression E(S, M) which is
satisfiable if and only if M accepts S in polynomial time.
Demonstrate an algorithm for generating E(S, M) for any
σ +i t )
> 1 of length q(|x|) = q t = n(
, M = 0 because
( )
t ∉ L ⇒ t → ∞ generates M = 0 as the sequence
converges absolutely to 0, that is:
74
Res. J. Math. Stat., 3(2): 72-76, 2011
Thus a computer can be constructed to take any
suitable real F value and an accompanying t complex
M’s convergence to 0 also with absolute convergence
of the general term of the sequence µn (t ) = n
− (σ + it )
values and execute the programme M = n − (σ + it ) so that
within − ∞ ≤ t < ∞ , the computer’s tape takes t = iσ
for all string n > 1 and returns 1. Else the computer takes t = ∞
and returns 0 whenever n>1. The summary of the
which converges absolutely to 0 as demonstrated in (8)
and (9).
Thus E is satisfiable since M accepts S in polynomial
time producing 1 at n = 1 when t ∈ L:− ∞ ≤ L < ∞ and 0
at t = 4
Reversing the process to satisfy the if and only if
algorithm M = n − (σ + it ) will then be:
condition, let M = n − (σ + it ) and let M = 1, then:
If n = 1, then M = 1
if n > 1, then
− σ + it
1 = n ( ) and
1
⎛
⎞
1
⎟
− ⎜⎜
−
+
σ
it
) ⎟⎠
⎝ (
⎧1:−∞ ≤ t < ∞ , t = iσ
M=⎨
⎩ 0: t = ∞
=n
RESULTS AND DISCUSSION
Hence; n = 1
The research has found out that there exists a
Also, M = 0 ⇒ 0 = n − (σ + it ) =
which is only possible if
1
(n )
t i
n − it
nσ
polynomial time algorithm M = n − (σ + it ) which is the
general term of the Riemann zeta function, which is
verified to be NP-Hard, NP-Complete and hence resolves
the P = NP? problem. Hence the computer might be
instructed to execute:
⎛
⎞
⎜ 1 ⎟
⎜⎜ t i ⎟⎟
⎝ n ⎠
=
nσ
( )
i
⎛ 1⎞
= ⎜ t ⎟ = 0⇒ t = ∞
⎝n ⎠
Thus M accepts S in polynomial time, given the small
( )
C
C
Programme P = NP
Input n: integer 1,2,… and t: real
C
Output M: Boolean: ⎨
⎧1: n = 1;−∞ ≤ t < ∞
⎩ 0: n > 1, t = ∞
o nk = n− ∞ = 0
M = M = n − (σ + it ) satisfies Cook’s theorem and can
hence be used to solve many other NP-Complete
problems.
The findings show that the algorithm explains the
very foundations of Boolean algebra in that the values of
the Riemann zeta function oscillate between 1 and 0 given
two distinct regions, respectively L1: − ∞ ≤ t < ∞ and
L2: t = ∞ . If t complex values are taken in L1, then the
value of the algorithm for all n string is 1 when t = iσ ,
and if t be in L2 the value of the algorithm is 0 as t moves
to infinity. Thus the Riemann zeta function, for all n
positive integer values, has finite closed bounded lower
and upper real-value bounds [0, 1] and is defined on the
entire complex continuum: − ∞ ≤ t ≤ ∞ .
For the computer to work in Boolean order with the
only two digits 0 and1, the computer could then be
programmed so that it will obey the instruction:
Consequently, M satisfies Cook’s theorem which is
NP-Complete. Hence M is NP-Hard and is a polynomial
time algorithm that resolves the P = NP? problem.
Corollary:
Suppose that (2) is a complex-valued function of a
complex variable t then M = 1 always for all string n at
t = iσ and M = 0 at t = ∞ .
Proof:
t = iσ makes s = F+ it = 0, hence for all n > 1
M = n0 = 1.
Hence for string n of solving P and string n + k
(k = 1, 2, …) of verifying the solution NP, M = 1
implying that P = NP = 1 always at t = iσ
Remark to the corollary:
To have s = F+ it as a complex-valued function of a
complex variable t is simply to take time to be imaginary
as used by quantum physicists and cosmologists
(Wikipedia, 2010c) as complex time is geometrically
posited to be on the vertical axis and perpendicularly
crosses the real time horizontal axis.
input n:= integer
⎧1:−∞ ≤ t < ∞ , t = iσ
⎩ 0: t = ∞
output M: Boolean ⎨
verified with: M = n − (σ + it )
75
Res. J. Math. Stat., 3(2): 72-76, 2011
P = NP? problem. A corollary to the proof exists by
extending the algorithm’s raw materials s = F + it from
the z-plane transformed into the w-plane by letting t to be
complex thus producing t complex values which makes
P = NP at t = (iF, 4) and the algorithm M generates closed
bounded real binary values [1, 0] on the set of first
complex entries (-4, 4) .
In fact it will be sufficient to configure some computer to
efficiently work or perform any instruction in time s(t):
t = iσ , for all string n. Hence P is performed at the same
time as NP. The computer will function if programmed:
Given a verifier M = n − (σ + it ) and string n = 1, 2, 3,
… for any operation,
input t = (iσ , ∞ )
output
REFERENCES
Spiegel, M.R., 2005. Advanced Mathematics for
Engineers and Scientists. Tata McGraw-Hill, New
Delhi.
Tordable, J., 2010. P versus NP. Retrieved from:
http://www.javiertordable.com. (Accessed on:
December 02, 2010.)
Weisstein, E.W., 2010. NP-Problem. From MathWorld A Wolfram web resource. Retrieved from:
http://mathworld.wolfram.com/NP-Problem.html,
(Accessed on: December 02, 2010).
Wikipedia, 2010a. NP complexity. Retrieved from:
http://en.wikipedia.org/wiki/NP_(complexity),
(Accessed on: November 11, 2010).
Wikipedia, 2010b. P versus NP Problem. Retrieved from:
http://en.wikipedia.org/wiki/P_versus_NP_problem,
(Accessed on: November 11, 2010).
Wikipedia, 2010c. Imaginary time. Retrieved from:
http://en.wikipedia.org/wiki/imaginary_time,
(Accessed on: November 15, 2010).
Wikipedia, 2010d. Polynomial time. Retrieved from:
http://en.wikipedia.org/wiki/Polynomial_time#Poly
nomiql_time, (Accessed on: November 15, 2010).
⎧1: t = iσ ∀n
M ( t , n) = ⎨
⎩0: t = ∞ ∀n > 1
The Turing machine M(t, n) performs both P and NP
operations at s = F + it polynomial time where for
t = iσ , P = NP = 1 for all n > 1, and for t = 4, P = NP =
(0, 1): 0 if n … 1 and 1 if n = 1.
The findings have educational value of expanding the
range of mathematical experiences with which to broaden
the curriculum and which can afford the learner a higher
level of solving complexity and other computational
problems. The study provides added experiences from
which mathematics and computer science education
curriculum could select supplementary items.
CONCLUSION
The work set out to and has established that
M (t , n) = n − (σ + it ) the general term of the Riemann zeta
function is a polynomial time algorithm that resolves the
76