A peephole optimization rewrites a specific instruction sequence into a faster equivalent. The compiler engineer discovers that x * 2 can become x << 1. The hard part is generalization: when does this rewrite apply? For which bit widths? Under what constraints on x?
Note (2026-11-12; read against the paper's full text): the 35 of 81 is Hydra, the baseline against which LPG is compared on the 81 integer cases (LPG 74 of 81, with strictly more general rules in 22 cases against 2 for Hydra); the paper describes Hydra as inductive and enumerative synthesis guided by heuristics that already ensures soundness with Alive2, so the comparison is not between synthesis and a combination with formal verification. The 90 of 102 comes from three instruction domains in its Table 5 (integer 74 of 81, floating-point 12 of 16, memory 4 of 5); I found no vector domain among them. I found no experiment in the paper that runs the LLM without verification and measures unsound output, so the essay's statements about what the LLM alone or the synthesizer alone would do are its own. The paper says Alive2 verification can time out on complex candidates and is incomplete for some floating-point intrinsics.
Pure synthesis — deriving general rules from concrete instances via formal methods alone — succeeds on 35 of 81 LLVM optimization cases. LPG, which combines LLM reasoning with formal verification, succeeds on 74 of 81. On the broader set including floating-point and vector operations: 90 of 102.
The division of labor is precise. The LLM handles semantic abstraction — recognizing that a concrete optimization over 32-bit integers might generalize to arbitrary bit widths, or that a specific constant can be replaced by a symbolic variable under certain constraints. Formal verification ensures the generalized rule is sound and profitable. The LLM proposes; the verifier disposes.
Neither component alone achieves this. The LLM without verification produces plausible but sometimes unsound generalizations. The synthesizer without the LLM gets stuck on the search space — the number of possible generalizations is too large for exhaustive enumeration. The combination works because the two capabilities are complementary, not redundant: exploration is easy for the LLM and hard for the synthesizer; verification is easy for the synthesizer and impossible for the LLM.
The structural pattern: systems where the search space is too large for formal methods but the correctness criterion is too strict for heuristics are natural territory for hybrid approaches. The LLM narrows the search; the verifier validates the result. Neither trusts the other, and that mutual distrust is what makes the combination reliable.