Using Structure Synthesis

Overview

A structure generator that also judges its own output is not a generator — it is a policy wearing a generator's clothes.

This pack is for the class of system where a model's output is not a number or a label but an object with topology: a candidate neural-network subgraph, a program in a typed intermediate representation, a molecule graph, a circuit netlist, a level layout graph — anything a generator emits as a small directed graph over a constrained vocabulary of typed operators. The generation problem and the verification problem look similar (both touch the same graph) but they answer different questions, and collapsing them is the single most common failure mode this pack exists to prevent:

• Generation answers "what structures are plausible." A generator proposes. It may propose badly. It may mode-collapse. It may hallucinate topology that violates the grammar. None of that is fatal on its own.
• Structural verification answers "is this candidate legal." Shape-correct, cycle-free, contract-respecting, within budget. This is checkable by rule, not by taste, and it must not consume any signal about whether the candidate is useful.
• Utility judgement answers "does this candidate help." That question belongs to whatever evaluates the candidate against real outcomes — a counterfactual trial, a benchmark, a downstream reward. This pack does not answer it and does not ship the machinery to answer it.

The failure this pack is built around: a generator that filters its own best-of-K pool by predicted task performance is grading its own examination. A verifier that rejects a legal candidate because it looks unpromising has let policy leak into what should be a rule-driven gate. Both failures are invisible in a demo and catastrophic at scale, because they silently narrow the search space to whatever the current model already believes is good — which is exactly the thing generation was supposed to explore past.

Key tensions this pack resolves, sheet by sheet: expressiveness vs. verifiability (bigger grammars generate more, cost more to check), validity-by-construction vs. generate-then-verify (cheaper to decode legally, but you still need a verifier), raw diversity vs. functional diversity (a pool that looks different byte-for-byte may be one candidate after canonicalisation), simple generator vs. simple in the wrong sense (start deterministic/latent-conditioned; escalate to flows or diffusion only when that demonstrably fails).

When to Use

Use this pack when: