What are polynomial-time machines?
If the number of machines needed to solve a complex problem is polynomial, we call it a polynomial-time machine.
Huge cloud computing platforms are available in today’s world. When we can run millions of tokens at once, what problem remains?
Why do we still need P=NP computation on traditional machines? Why not ask P= NP on modern machines? We have advanced systems that can run processes; we have upcoming Quantum goals that make computation more achievable. How many machines or threads are required to prove P=NP? And then decide which machines to allocate.
Yes, sometimes we need to run an algorithm in an isolated environment; in that case, we still need to ask whether P=NP on a secluded system. But now, with cloud computing, we need to just rethink P=NP in the times of the Computing Revolution.
Now we need to prove that, for the satisfiability problem, n² threads are required, and hence P=NP under the infinite-machine model.
Here, for satisfiability problem:
- Number of assignments with exactly 0 True variables (all False): nC0
- Number of assignments with exactly 1 True variable: nC1
- Number of assignments with exactly 2 True variables: nC2
- Number of assignments with exactly k True variables: nCk
- Number of assignments with exactly n True variables (all True): nCn
These are n terms; each goes to an infinite machine. The order matters too.
We can divide these n into two replicas of n/2 each.
Repeating the above steps on a size n/2 problem, we have 2 . n/2 = n problems.
Dividing these n/2 problems and sending them to threads, we have 4. n/4 = n problems.
So we keep on doing till only one problem is left.
Hence we have n+2.(n/2)+4.(n/4)+….+n.1=n²
Hence, we require n² threads to solve P=NP and then use Cook’s Theorem.
That is, satisfiability can be achieved on the infinite machine defined above.
By Cook’s Theorem, P=NP.
It’s time we think about how to use modern machines on old problems, whether it’s the knapsack problem, directed Hamiltonian cycle, code generation, chromatic number decision problem, scheduling problems, the traveling salesman problem, or more!
Why don’t you find polynomial-time machine solutions to problems that were originally NP-hard? Run it on threads, see how many threads you need, and what complexity that requires! See how you share memory among threads!
These questions help you derive upper bounds on complexity in the age of Infinite Machines.
Try it! With the computing revolution, upper bounds on computation must change in terms of the number of threads needed to solve problems. Is the number of threads needed polynomial?
Let me know your thoughts on polynomial-time machines.
Thank you for reading.
Subscribe.
