Why does NP bound a certificate's length by a polynomial instead of only requiring that some finite certificate exist?
answer
- polynomial in what, exactly
- a checker can only read so much
- the whole search log would qualify
- otherwise it is merely semi-decidable
- the cap is what makes it a resource class
basics
~20 sWithout the cap the class stops meaning anything: every semi-decidable problem qualifies, because the transcript of a halting computation is itself a finite certificate. The polynomial bound is what keeps the checker's work polynomial in the instance.
solid answer
~40 sThe length bound and the checker's time bound are the same constraint seen twice. A verifier running in time polynomial in `|x|` can read only polynomially many bits, so any certificate longer than that is mostly unread — which is why the definition is usually written as `|w| <= p(|x|)` with the verifier polynomial in the combined length. Drop the bound and allow any finite string with a checker polynomial in the certificate's own length, and you can hand over the full transcript of a halting computation; checking a transcript step by step is local and cheap. That admits every semi-decidable problem, with no time guarantee whatsoever on finding the certificate. The bound is not bookkeeping: it is the entire reason NP is a **resource** class.
go deeper
Hold on to one phrase: the proof has to be short compared with the question. A hint you could not finish reading is no help to a fast checker.
Explain the equivalence between capping the certificate length and bounding the checker in the instance size, and name which quantity the polynomial attaches to.
Show what is lost without the cap: the transcript of a halting run becomes a certificate, and the class degenerates to the semi-decidable problems with no time guarantee.
Carry the distinction into review practice: an artefact a reviewer can recheck independently is worth more than a complete log that can only be re-derived.
## Two ways to write the same definition Both phrasings appear in the literature and they describe the same class: | Phrasing | Certificate length | Verifier time budget | |---|---|---| | A | Unrestricted in the text | Polynomial in `|x|` alone | | B | `|w| <= p(|x|)` for a fixed polynomial `p` | Polynomial in `|x| + |w|` | Phrasing A restricts the length implicitly: a machine that runs for `q(|x|)` steps cannot read more than `q(|x|)` symbols of anything, so a longer certificate contributes nothing the verifier can see. Phrasing B restricts it explicitly and then permits the verifier to be measured against the combined size, which is harmless once the certificate is already polynomially capped. What you may **not** do is take phrasing B's time budget while dropping phrasing B's length cap. That combination is the trap this question is about. ## What dropping the cap actually admits Suppose the only requirement is that some finite certificate exists and that the checker runs in time polynomial in the certificate's own length. Then take any problem for which a procedure eventually halts and says yes on the yes-instances: 1. Let the certificate be the **complete transcript** of that halting computation: the sequence of configurations from the start to the accepting state. 2. The checker verifies the transcript locally — the first configuration matches the input, each configuration follows from its predecessor by one legal step, the last one accepts. 3. Each of those checks inspects a bounded neighbourhood, so the whole check is polynomial in the transcript's length. Every such problem now has a 'certificate'. The resulting class is the **semi-decidable** problems, and it contains problems with no algorithm that halts on the no-instances at all. Nothing about time or feasibility has been said; the word 'polynomial' in the definition has been made to do no work whatsoever. Allowing certificates that are merely exponentially long is less extreme but still fatal to the meaning: the class you get sits far above NP, and its problems need exponential time even to **read** the proof, let alone to find it. The polynomial cap is the line at which 'proof' still means something a machine bounded by the question's size can consume. ## The practical reading This is not only a definitional nicety. Picture a dependency resolver that must return, alongside its chosen version set, a proof artefact a reviewer can recheck by hand: - A **short** artefact — the chosen versions, plus which constraint each satisfies — is polynomial in the instance and a reviewer can walk it. - The **complete search log** is also a proof in the everyday sense: it really does establish the answer. But its size is not bounded by any polynomial in the instance, so 'rechecking' it means redoing the search. That artefact is not a certificate; it is the work. The distinction between a proof you can check and a proof you can only re-derive is precisely the distinction the polynomial bound draws. ## Two details worth having ready - **Which polynomial does not matter.** The definition fixes a polynomial per problem, and the class is the union over all of them. A certificate of size `n^5` is as legal as one of size `2n`; what is forbidden is a length that outgrows every polynomial. - **The bound is on the certificate, not on the number of certificates.** There are still up to `2^p(|x|)` strings of the permitted length. Bounding length keeps checking cheap; it does nothing to make searching cheap, and conflating the two is a separate error. ## How to spot the mistake in your own phrasing Whenever you describe NP, check which quantity the word 'polynomial' is attached to. 'The checker runs in polynomial time' is incomplete until you say **polynomial in what**. Measured against the instance, the definition is the intended one. Measured against the certificate alone, with the certificate unbounded, you have quietly defined the semi-decidable problems and lost every guarantee the class was invented to express.
- If the verifier's time were measured only against the certificate's own length, with no cap on that length, which problems would qualify?All the semi-decidable ones. Hand over the transcript of a halting accepting computation; checking that each configuration follows legally from the previous one is local and polynomial in the transcript. The class then carries no feasibility guarantee at all, which is why the cap is stated against the instance size.
- Does the definition require one specific polynomial for the certificate length?No. Each problem comes with its own fixed polynomial, and the class is the union over all of them, so `2n` and `n^5` are equally acceptable bounds. What is excluded is a certificate whose length outgrows every polynomial in the instance size.
- Does bounding the certificate length also bound how long searching takes?No, and conflating the two is a separate error. Strings of at most `p(n)` bits still number about `2^p(n)`, so the cap makes each check cheap and leaves the search exponential in the worst case. It bounds the proof, not the hunt for it.
saying these in an interview costs you the question
- Says any finite certificate is good enough
- Measures the checker's polynomial against the certificate's own length
- Thinks an overlong certificate is fine if the checker is fast
- Claims a checker can skim an exponential certificate in polynomial time
- Treats the cap as a convention with no consequence for the class