P vs NP. Recognition is not generation.

The standard P vs NP question isolates the exact place where two operations might or might not collapse under polynomial time: reading a finished cut versus forming the cut from the unresolved field. Complexity theory has known these are different-looking operations since Cook (1971). The open question is whether the difference is asymptotically essential — whether some polynomial-time algorithm could, in principle, close the gap.

The framework gives a structural reason to expect the gap holds. Recognition and generation are not the same operation. A finished Sudoku grid, proof, route, assignment, or schedule is a stabilized contrast. Once it is handed to you, the boundary is visible — you can scan it and confirm it satisfies the constraints. But producing that stabilized contrast from the unresolved field is a different act on the substrate.

The framework gives a structural reason not to treat collapse as the default: verification scans an already-formed boundary; solving forms the boundary from a field of unresolved possible cuts. Whether that difference becomes an unavoidable asymptotic gap is the formal content of P vs NP.

P is the class of cuts whose resolution path is internally available. The system does not need the environment to hand it the missing boundary — it can form the boundary itself, deterministically and in polynomial time.

NP is the class of cuts that can be verified once the environment supplies the witness. The witness is not a detail; the witness IS the missing boundary. Without it, the system is unresolved. With it, verification is a polynomial scan.

Cook's verifier definition makes this explicit: an unresolved system w plus an environment-supplied witness y, checked by a polynomial-time relation R(w,y). In framework vocabulary:

• w = unresolved system
• y = environment-supplied cut
• R(w,y) = boundary-compatibility test

P ⊆ NP follows trivially: any system that can form its own boundary can have that boundary checked. A self-resolving cut is also verifiable. The hard direction is the reverse — does verifiable imply self-resolving? That is P vs NP.

Take satisfiability. You have a Boolean formula. A truth assignment is the witness. Given the assignment, checking is easy: plug in the values, verify the formula is satisfied. SAT and 3-SAT are the canonical NP-complete problems.

In framework vocabulary:

• Formula = unresolved constraint field
• Satisfying assignment = compatible global cut
• Verification = local scan of the proposed cut
• Solving (yes) = finding a compatible cut
• Solving (no) = certifying no compatible cut exists

The assignment is information whose function is to complete the formula's geometry. It is a finite string of bits, mathematically. Structurally, it acts as the global cut that makes the formula resolvable. Once the assignment is supplied, the formula becomes legible. Before it is supplied, the formula is a field of unresolved possible cuts.

For unsatisfiable formulas, the missing boundary does not exist at all. Solving here is not forming a hidden cut — it is certifying that the constraint field admits no compatible cut. NP privileges polynomial verification of presence; decision asks for both presence and absence to be efficiently settled. That is the full P vs NP question.

NP-complete problems are not just hard. They are structurally universal. Cook–Levin shows every NP language reduces to SAT in polynomial time. SAT is a universal arena for unresolved contrast — a cut shape into which every other NP cut can be translated. If SAT self-resolves efficiently, every NP witness-boundary can be internally generated efficiently. That would be P = NP.

If P = NP, every witness that appears to come from outside would actually be recoverable from inside by polynomial propagation. The environment would add no essential boundary. The system would already contain an efficient path to every witness that can be efficiently checked.

In framework language:

• readable = generable
• witnessed = constructible
• environment-supplied = efficiently recoverable by the system

That collapse would erase the polarity between the system and what surrounds it — at least at the computational layer. Verification and generation would become two readings of the same underlying operation, the way system and environment are two readings of one boundary at every other scale.

The framework treats this as a strong structural claim, not the neutral default. The system/environment polarity is the framework's foundational move. P = NP would be that polarity collapsing in a specific domain — which would require the cascade's integration topology to have a structure complexity theory has spent fifty years not finding.

P = NP demands one universal procedure strong enough to recover, in polynomial time, every existential witness across every polynomially verifiable constraint geometry. Global structure alone is not the barrier — many globally constrained problems sit comfortably in P. The framework rejects the universal version: no single efficient recovery principle is known to stretch across every NP-complete shape.

Some cuts are easy to recognize once formed but cannot be efficiently formed from within the system. That is the natural framework output, because legibility does not imply generability.

A state of global equilibrium is easy to read once stabilized; that does not mean the unformed substrate contains a low-curvature gradient to reach it. A proof is a fixed-point path verified by local propagation; finding the proof requires navigating an unmapped field of competing cuts. Legibility is a passive scan of a boundary; generation is the active mechanics of the cut.

The engine's prediction:

• NP = polynomial boundary verification
• P = polynomial boundary formation
• P ≠ NP = verification does not generally collapse into formation

P vs NP asks whether the map can generate the territory just because it can recognize the destination. The framework says no.

Recognition is a surface read; construction is the becoming of the cut.