Speaking of which, anybody have advice on how to simplify section 2 of this paper and can you please tell me how I’m fooling myself? https://drive.google.com/file/d/1ugJ9czd4EPUPlQO2uGQgsfc6EHW...
More generally, you seem to think that problems in P and those in NP are considered unrelated. In fact, for all of the NP-complete problems (SAT, Travelling Salesman, knapsack etc) verifying a single candidate solution is a problem in P. However, the best known algorithms for solving the full problem are to iterate over all candidate solutions and run the P algorithm for each - which is exponential time or worse for all of these problems.
To find a P algorithm that solves one of the NP-complete problems, you need to find an idea that is better than just trying solutions to see if they fit.
P, NP, 3-SAT and all the other terms you are using have formal mathematical definitions -- you can't just make stuff up.
It's complete nonsense.
> Abstract
Showing that all problems in NP are equivalent to problems in P is proving P = NP… but your abstract acts like that's a different thing. It's clear you don't even understand the question you're trying to answer. Most people would stop here.
Most people would stop here, because they have found that there are certain people who you cannot convince of their own work's invalidity. Because replying means you will be sent papers to "proof-read" for the rest of the crank's life. I'm going to try putting exercises-for-the-reader in this criticism, and see if that helps, but I haven't got my hopes up.
There is no "middle road". Either P = NP-Complete (the hardest problems in NP can be solved by algorithms in P), in which case P = NP; or P ∩ NP-Complete = ∅ (there is no P algorithm that can solve any NP-Complete problem). This is because all NP-Complete problems are equivalent with each other.
Exercise: reduce the clique problem to 3-SAT.
> Math IS Chemistry
Sounds like you're vaguely thinking of https://en.wikipedia.org/wiki/Entropy_in_thermodynamics_and_... at a surface level, except all of the details are wrong. That diagram is nonsense.
Exercise: calculate the minimum work required, in joules, to zero a 64-bit register with unknown contents at 20°C.
> Introduction
Equivalence relations have nothing to do with metrics. We are thinking clearly about the problem, and you aren't.
Exercise: reach the Algorithm world of the Lean4 Natural Number Game: https://adam.math.hhu.de/
> Words
That's not polynomial time: that's quadratic time. Polynomial time is O(n^k) for some k. ≠ means "is not completely the same": completely different (for sets) can be written "A ∩ B = ∅".
You're not even attempting to solve "P=NP?": you're tackling a different problem. There's no problem with that: the problem you've attempted should only take you about a year of proper study to learn how to solve, and I'd actually be interested to see you give a correct explanation. (You might find an answer more quickly than that.) The question is “Are there any quadratic-time algorithms in the class NP?”, and the correct explanation is about 3±2 sentences long.
Exercise: look up the standard meanings of the words you've used. (Where you've said 'category', you mean 'class'; and 'stuff' should be 'physical object' or 'body'.)
Exercise: derive Bayes' theorem.
> 1. An argument of universal freedom […] because the universe would not exist.
You have no reason to believe any of this: it's just baseless speculation.
Exercise: read The Open Society and Its Enemies, by Karl Popper. 1947 book, published in two volumes (though there are combined editions). If it's not in your local library, you can borrow it from the Internet Archive: (1) https://archive.org/details/in.ernet.dli.2015.59272 and (2) https://archive.org/details/in.ernet.dli.2015.77661
> What is the opposite of waste? Synthesis. A universe must generate stuff.
This really doesn't follow from anything you've said. It doesn't even have a clear meaning.
Exercise: practice deleting passages from your work. (If you can't bring yourself to do that, cutting-and-pasting them to a discard file is also acceptable, so long as you don't try to salvage them later.) Kill your darlings.
> Why? […] arrow of time.
Not entirely wrong! This whole tangent has nothing to do with P=NP, but it's kinda almost right!
Exercise: find an example of a physical conservation law, and learn why people believe it's a conserved quantity.
Exercise: find a physicist who thinks magnetic monopoles can exist, and a physicist who thinks they can't exist. Learn what their reasoning is. (Don't actually ask them directly: I mean find someone who's explained their reasoning already, and read what they wrote.) Think back on what you learned from The Open Society and Its Enemies: how does this relate to that?
> Would it be possible for a universe to spontaneously invert encryption, simply to increase freedom? I would argue, yes.
Exercise: find out what a "macrostate" is. Consider a discrete 52-card deck of cards, and a uniform shuffling procedure. Calculate the probability of the macrostate transitions (sorted → sorted, sorted → unsorted, unsorted → sorted, unsorted → unsorted). Consider the evolution of the system for the first five discrete time steps, starting at a sorted configuration.
> Is a "hack" […] Kinetics.
The mistakes you're making here should already be addressed by the earlier corrections.
Exercise: explain why what you've written here is wrong.
Exercise: learn what cybersecurity is.
> 2. An argument that “solve” is equivalent to “check”
First sentence is wrong. Third sentence (about “undecidable”) actually looks like computer science: I think your understanding here is correct.
> Therefore, it is almost surely possible to convert “np” problems into “p” problems: generate candidate solutions from the problem itself, then check them.
You can do this. However, you'll need to try exponentially-many candidate solutions, so the overall algorithm takes exponential time.
Exercise: calculate the asymptotic time complexity of bubble sort, and deterministic bogosort. Compare the two.
> For example, in 3-sat […] generate the candidate and check it.
The interesting part about 3-sat – the bit that makes it NP-hard – is the fact that you can't, actually, do that. You can't iteratively go from a incorrect candidate solution to a less incorrect solution: the candidate solution might be wrong in a fundamental way, partly-correct only by accident, with no way to improve it.
Exercise: understand that this is a metaphor for your paper. You can't make this paper correct by making iterative changes to it, because it's so fundamentally wrong that it can't ever be made correct.
> existing SAT solvers
… aren't in P. So you can't use them as part of a polynomial-time algorithm. Not even if you use a three-valued logic version of the SAT-solving algorithms: that doesn't change how fast they run, or really anything at all (since the algorithms, being two-valued logic algorithms, would just be ignoring one of the values of your three-valued logic).
> 3-Sat Problem = (-1, 2, 3), (-1, -2, 3) => Solution to Check = {1: False, 2: Maybe, 3: True}
This looks like the very beginnings of a heuristic (symbolic) 3-SAT solver. It's not polynomial-time, but it'd be slightly faster than the naïve brute-force approach. That's something to be proud of rediscovering!
Exercise: implement a naïve 3-SAT solver (tries all the possibilities), then add a heuristic to make it a bit faster.
> […] the solutions must share structure […] This means we can save incremental progress to speed up checks over time.
I can see why you might think that (I used to think that as well), but it isn't true.
Exercise: find a 3-SAT formula with two solutions that don't share structure. You probably changed your mind about what "structure" is half-way through, so now find a 3-SAT formula with two solutions that don't share your new definition of structure.
> However, if we truly understand our problem, […] shrinks the category of solutions dramatically.
Yes… if we just look at the first and last bit (the bit in the middle, about "Maybe", is wrong). And doing that is the hard part: we're trying to measure how long this process takes, when we're measuring the time complexity of an algorithm to solve a problem.
Exercise: try to implement a 3-SAT solver that works the way you describe in the middle bit, and see why it doesn't work.
> 3. An argument for universal search
This whole section is completely wrong.
Exercise: write an algorithm in P that verifies a solution to the Clique problem. (Finding a solution cannot be done in P, in the general case.)
Exercise: write an algorithm in P that finds a solution to some special-cases of the Clique problem. Show that it cannot solve all cases in P.
> Summary
Pretty good summary of your arguments. If you figure out how to stop writing nonsense, you might make a decent academic.
> Implications
Exercise: research the Principle of Explosion.
> References
I see you've got a Category Theory reference. You do not understand Category Theory, and you will not be ready to learn about Category Theory for a very very long time, if ever. Most pure mathematicians never learn category theory. It's got nothing to do with your "category" (which is usually called "class").
Other than that, this section is not bad!
Exercise: learn a convention for including inline citations. (optional)
Exercise: why are citations not usually URLs?
(But yeah, overall, this paper is worthless. I spent entirely too long reviewing it. I can see you're passionate, but it wasn't worth me reading it, and I knew that from the start.)
I think the main problem is you are using terms wrong. When i was reading i was substituting correct meanings in, and then getting confused when nothing you said made sense. Some examples:
* using incorrect/misleading definitions of terms, e.g. consider the first sentence of section 2:
> The difference between “p” and “np” hinges on the difference between solving problems without solutions, and checking if given solutions solve a problem
There is a certain sense this is true, but its very misleading because it doesn't mention time. The amount of time taken is very key here. If you don't account for that, there is no difference between np vs p.
As another example
> Therefore, it is almost surely possible to convert “np” problems into “p” problems: generate candidate solutions from the problem itself, then check them.
Suggests you don't know what NP means, since (speaking informally) one of the definitions of NP is the set of problems that could be solved that way in polynomial time if you had a computer that was good at guessing.
> The antithesis to “p != np” is “p equals np” which implies all “np” problems are exactly equally easy to solve as all “p” problems
This is just a straight up false statement. P=NP means that NP problems are no harder than the hardest problem in P. It doesn't mean exactly equal.
> We generate secret keys using problems we believe are easy to check, but hard to solve (“np”), because we support the thesis “p != np”
RSA is not known to be np-complete. P!=NP does not imply RSA is secure.
-----
Anyways, i think fundamentally you basically redefined np to be something that is equal to p, and used circular logic to prove that it was (e.g. you talk about generating a "category" of simple correct solutions to an NP problem, and just presume you can do that. Well obviously if you had a polynomial time algorithm to do that, P=NP because the entire question is whether it is possible to do such a thing)
Also it's funny this topic came up since i just watchd this a couple days ago - https://www.youtube.com/watch?v=pQsdygaYcE4&t=1039s
I updated the link on my bio to point to a simple code project instead. Thank you for pointing out the website was out of date and overly ambitious.
> - “np” - a category of problems which can be checked, but not solved, in O(n²)
These definitions are incorrect. Certainly there are other polynomials than just n². P is the complexity class wherein the problem can be solved on a Turing machine in a number of steps equal to some polynomial of the size of the input. For NP, replace "Turing machine" with "nondeterministic Turing machine" and otherwise it's the same. The 'size of the input' is the count of symbols on the machine's tape, allowing for the input to be written in any finite alphabet, chosen by the designer of the Turing machine.
Nondeterministic can mean different things in different contexts, so I want to clarify. Here, nondeterministic means that the machine does the 'impossible' thing of forking itself and running up to an infinite number of copies of the deterministic machines (including distinct copies of their state) at the same time, then if one of the computations succeeds then that computation is kept and the others are discarded (including the count of how many steps they spent). This is why, if you have a machine that can check a problem in P, you can make the machine to solve it in NP by wrapping your checker in "use nondeterminism to generate every possible input value" and simultaneously check them all.
I highly recommend the theory of computation course at MIT, which is freely available online:
https://ocw.mit.edu/courses/18-404j-theory-of-computation-fall-2020/
https://www.youtube.com/playlist?list=PLidiQIHRzpXIFFbyGrWkqXXVj0BztDcTF
> All information necessary to generate checkable solutions to any problem must be encoded in the problem itself, or the problem would be undecidable, because there would be no way to check a solution against a problem if the problem and solution were completely unrelated.
This is actually a great insight, but you must keep in mind that if I tell you that the solution to "a > b" is True, you cannot find a and b. You are touching on an important concept in computer science theory called "reversible computing". It's also related to information theory. If I have a machine that solves the travelling salesman problem that outputs "the fastest route is from B to C to A", then you must ask yourself whether there are multiple different inputs to the problem which can generate that output? (You don't always have the freedom to change the input type of the problem, or else I could factor integers in constant time by demanding that all integers must be input as a product of primes.)
When the values are computable from the other, the question remains about the number of steps it takes to do. You still have to show that it's bounded above by some polynomial, and then that this is true for all problems in NP. We already have ways to rewrite one NP problem into another, and so showing a single machine that takes polynomial steps to solve any of those NP problems would suffice to show that P = NP. This is how we've proven lots of complexity classes the same in the past. On the other hand, we have almost no techniques which prove that two complexity classes are distinct.