P vs NP, a primer

Sat, 03 Oct 2026 00:00:00 GMT

What the question asks

P vs NP asks whether every problem whose answer is easy to check is also easy to find. Nobody knows, and the question has been open since Stephen Cook posed it in 1971 (Cook, 1971).

Sudoku is the easy way in. Checking a filled grid takes a minute: scan every row, column and box. Filling an empty grid can take far longer (and for bigger grids, it seems to explode).

The two letters name two kinds of problems:

P: problems a computer can solve in polynomial time, i.e. the work grows like n² or n³ as the input grows (rather than like 2ⁿ).

NP: problems where a proposed answer can be checked in polynomial time (NP).

Every P problem is also an NP problem (if you can solve it fast, you can check it fast). The open question is whether the reverse holds. One caveat worth keeping in mind: “polynomial” is a theoretical stand-in for “fast”. An algorithm that takes n¹⁰⁰ steps is technically polynomial and practically useless.

Why it matters

The answer decides whether searching is fundamentally harder than recognizing. That reaches well past computer science.

If P = NP (with a practical algorithm): most public-key cryptography breaks; hard scheduling, routing and design problems become routine. The underrated part is mathematics itself. Finding a proof short enough to check would become about as easy as checking one.

If P ≠ NP: search stays hard, which is the world most experts believe we live in. (Cryptography actually needs more than P ≠ NP to be safe, so a proof would not settle that question on its own.)

The Clay Mathematics Institute offers $1 million for a proof either way; it is one of the seven Millennium Prize Problems named in 2000. In Bill Gasarch’s 2019 poll of researchers, 88% expected P ≠ NP (Gasarch, SIGACT News).

An amateur’s intuition: choices that interact

My hunch from years of writing code: easy problems have choices that stay independent, and hard problems have choices that interact. It turns out the field has studied this from several angles.

Here is how I picture it. Any optimization problem is a set of unordered things that must be arranged to satisfy rules (positive or negative), with some quality score to maximize or minimize. An algorithm is a series of transformations of that set; each step costs some effort and nudges the quality up or down.

In sorting, moving one item into place does not change whether the other items meet the rules. Each fix stands alone. The traveling salesman problem is the opposite: picking one road changes which roads make sense later. You can’t know your future choices in advance without exploring the combinations.

The field captures this idea three ways:

Greedy algorithms: a classic theorem (Rado and Edmonds) pins down exactly when taking the locally best step, every time, is guaranteed to reach the global best. Those structures are called matroids. They are my “transformations that don’t harm future choices”, made precise.

How much of the past you must remember: this is the dynamic programming view. The table below shows how that memory grows.

Problem	What you must remember to continue correctly	Known status
Sorting	Nothing	Easy (P)
Shortest path	Where you are now	Easy (P)
Traveling salesman	Which cities you’ve already visited (2ⁿ possibilities)	Hard (NP-hard)

That last row is why the best exact salesman algorithm (Held and Karp, 1962) still takes exponential time.

Frustration: physicists use this word for constraints that can’t all be satisfied at once (geometrical frustration). It makes the “energy landscape” rugged: full of dead ends where every small change looks worse, yet you are not at the best answer. Sorting has no such dead ends. Each swap of an out-of-order neighbouring pair fixes exactly one problem. Finding the lowest-energy state of a 3D spin glass (a frustrated magnet) is NP-hard (Barahona, 1982).

Where the intuition breaks

Interacting choices don’t, on their own, make a problem hard. Some of the most tangled problems turn out to be easy.

2-SAT: every choice forces other choices through a chain of implications. Still, 2-SAT can be solved in linear time. Its close cousin 3-SAT is NP-complete.

Matching: pairing people or tasks so as many as possible are matched is full of interacting choices. But Jack Edmonds found a polynomial algorithm in 1965, in the same paper that proposed polynomial time as the definition of an “efficient” algorithm (Edmonds, 1965).

Linear programming: every variable interacts with every other, yet linear programming is solvable in polynomial time. Its landscape has no false peaks (any local best is the global best). Even so, the classic method that climbs it can take exponential time (Klee–Minty); the first polynomial algorithm, the ellipsoid method, came in 1979.

In each case, a clever change of viewpoint made the interaction stop mattering. That is the real gap. Proving P ≠ NP means showing no such viewpoint exists for any NP-complete problem, against every possible algorithm (including ones nobody has imagined yet).

So my intuition is a decent guide to which problems feel hard. It can’t be the proof.

Why a proof is so hard

Three proven “barrier” results rule out most of the proof techniques we know. Any serious attempt has to explain how it gets around all three.

Barrier	Who and when	What it rules out
Relativization	Baker, Gill and Solovay, 1975	Arguments that still work when every machine gets the same magic helper (an “oracle”); this includes diagonalization, the trick behind the halting problem
Natural proofs	Razborov and Rudich, 1994	Most circuit lower-bound arguments; one strong enough to separate P from NP would also break cryptography we believe is secure
Algebrization	Aaronson and Wigderson, 2008	Turning logic into polynomials (the trick that cracked other big results) is not enough on its own either

The natural proofs barrier is my favourite: believing that hard problems exist is exactly what stops you from proving that hard problems exist.

The live research programs (geometric complexity theory, proof complexity, meta-complexity) are all attempts to find a path around these walls. Lance Fortnow, who has tracked the problem for decades, wrote in June 2026 that there is not yet even a viable approach (Computational Complexity blog).

The “verified proof” mirage

A Lean proof guarantees every step follows from the last. It does not guarantee the theorem means what its title says.

Lean is a proof assistant: a small trusted program (the kernel) checks each step of a proof. Lean’s own documentation separates two questions: did Lean accept a proof of the formal statement, and does that statement actually mean what the author claims? Only the first is automatic.

There are three common ways a “verified” proof goes wrong:

Definitions: P and NP get defined as something simpler (or meaningless) that is easier to prove things about.

Premises: the hard part sits as an assumption inside the theorem’s own statement. Lean’s #print axioms report does not flag these.

Axioms: big cited results are assumed rather than proved.

The June 2026 paper claiming a Lean-verified proof that P = NP (arXiv 2606.03194) is a live example. According to a PostQuantum report, a GitHub issue opened the next day showed its top-level proposition was first defined as True. It was later revised to an axiom never formally connected to real complexity classes. Meanwhile, a separate Lean package claims a machine-verified proof that P ≠ NP. Both can’t be right.

In September, a company called AIX Global claimed to have solved all six remaining Millennium Prize Problems. Its own audit script marked the P ≠ NP result as conditional on unproven premises (same report).

The Clay Institute guards against all of this by design. It accepts no direct submissions; a solution must be published in a qualifying outlet, survive two years of scrutiny, and win general acceptance.

Sudoku: the whole primer in one puzzle

Sudoku holds every idea above in miniature: easy to check, hard to fill, and full of interacting choices.

Check vs. find: verifying a finished grid is quick; finding the answer from scratch can mean a lot of trial and error.

Interacting choices: every digit you place constrains its row, its column and its box. That is my sorting-vs-salesman intuition at kitchen-table scale.

Where hardness actually lives: Yato and Seta proved in 2003 that Sudoku generalized to any size (n² × n² grids) is NP-complete (mathematics of Sudoku). The ordinary 9 × 9 grid is a fixed size, so a computer solves it in an instant. Complexity is about how the work grows, which is easy to forget.

Propagation vs. search: most newspaper puzzles fall to pure deduction (constraint propagation: each placement forces the next). The hardest ones need guessing and backtracking. That split mirrors 2-SAT and 3-SAT: when forced moves run out, you are left searching.

To watch that search happen, Sudoku Search Lab shades every cell by how often the solver touched it and counts the backtracks.

Latent Mirror — math