An AI Closed a Convex-Optimization Gap Open Since 1996. This Time, the Proof Compiles.

TL;DR

On July 14, UC Berkeley optimization researcher Phillip Kerger posted a proof that closes a query-complexity gap open since 1996: minimizing a convex, 1-Lipschitz function over a d-dimensional ball using only its values, no gradients, takes on the order of d² evaluations, not the linear count the old lower bound could guarantee. He is unusually blunt about how it happened. GPT-5.6 Sol Pro did the mathematics, and, in his words, "the AI model used solved the problem, not the author." What makes this different from the AI-proof headlines you have learned to distrust is the last step: he shipped a Lean proof of the core bound that a machine, not a hopeful reader, checks.

What Actually Got Proved

The setting is derivative-free convex optimization, the corner of the field where you never get to see a gradient. You hand the algorithm a black box, it picks a point, and the box returns exactly one number: the function's value there. No slope, no direction, just altitude. Picture being dropped into a dark valley where the only instrument is an altimeter that beeps your current height. You want the lowest point, and every beep costs you.

The question Kerger settled is how many beeps you need in the worst case. For a convex, 1-Lipschitz function on the unit ball in d dimensions, his answer is Ω(d²/log(d+1)) queries, near-quadratic in the dimension. That matters because the ceiling has been known for three decades: Protasov's 1996 algorithm hits the target in O(d² log² d) evaluations. The floor, though, sat stubbornly at Ω(d), linear. So for thirty years the honest answer to "how hard is this really" was "somewhere between d and d², we cannot say." Kerger's lower bound lifts the floor to the ceiling, up to logarithmic dust.

He also lifts it into the mixed-integer world: with n discrete and d continuous variables, value-only optimization needs on the order of 2ⁿ·d² queries. If you build black-box or simulation-based optimizers, that is the part with teeth. It says the exponential blowup in the integer variables and the quadratic blowup in the continuous ones stack, and no clever value-only method escapes either.

"The AI Model Solved the Problem, Not the Author"

That sentence is a direct quote from the paper, section 1.4, and it is not false modesty. Kerger ran GPT-5.6 Sol Pro using the same workflow OpenAI published for its Cycle Double Cover proof a week earlier. The first run chewed for 148 minutes and returned an Ω(d²) lower bound. A second run, fed the initial proof plus a similar prompt, thought for another 230 minutes and sharpened the accuracy regime to the clean d^-1/2 statement in the paper. The full prompts and chat transcripts are in the appendix, which is its own small act of courage.

Kerger is not a bystander who got lucky with a chatbot. His PhD, under Amitabh Basu at Johns Hopkins, was on exactly this: the information complexity of convex and mixed-integer optimization. He knew precisely which gap was open, why prior transcript-compression arguments stalled, and what a valid resisting-oracle construction had to look like. The model supplied the argument; the expert supplied the problem, the judgment, and, per the paper, "full responsibility for every statement and proof."

Why This One Counts and the CDC Proof Still Doesn't

Here is the context a builder should hold onto. On July 10, OpenAI announced that GPT-5.6 Sol Ultra, running 64 parallel subagents, had proved the Cycle Double Cover conjecture in under an hour and posted a three-page manuscript. It is short enough to read over coffee and, so far, impossible to confirm: no peer review, no machine-checkable version, and a decades-long graveyard of plausible-looking CDC proofs that later cracked. The math world is still squinting.

Kerger's paper answers that skepticism directly, calling it "well-warranted," and then does something about it. He formally verified the core Ω(d²) lower bound in Lean 4, with the whole development public on GitHub. Lean does not care whether a human or a language model wrote the argument. It compiles the proof against mathlib from first principles or it rejects it, no partial credit, no vibes. Think of it as cargo build for a theorem: green means the logic type-checks, and green is the only thing that counts.

He is honest about the limits, too. The Lean-verified statement is the near-quadratic lower bound at the coarser accuracy the first run produced; the tighter d^-1/2 refinement leans on convex-geometry machinery (Urysohn's inequality) that Lean's libraries do not yet carry, so that piece rests on human review for now. It is a close cousin of the recent Nesterov AI-assisted convergence proof, but scoped more carefully, which is the whole point.

What This Means If You Ship With LLMs

Strip away the math and the lesson is about verification, not genius. Frontier models can now produce genuinely novel, correct arguments at the edge of a specialist field. They can also produce confident, beautiful, wrong ones, and from the outside the two look identical. The differentiator is not the model or the prompt. It is whether the output lands in a system that mechanically rejects the wrong ones.

For a theorem that system is Lean. For your code it is types, tests, and a CI gate that a hallucinated function signature cannot talk its way past. Kerger's paper is a preview of the working pattern for AI-assisted expert work: let the model do the hard reasoning, keep a domain expert steering, and route the result through a checker that does not grade on charisma.

Key Takeaways

• Phillip Kerger closed a convex-optimization query-complexity gap open since 1996, proving a near-quadratic Ω(d²/log(d+1)) lower bound for value-only minimization over the unit ball.
• GPT-5.6 Sol Pro produced the argument across two runs (148 then 230 minutes); the author states plainly that the AI, not he, solved the problem.
• The core Ω(d²) bound is formally verified in Lean 4, with the development public on GitHub, the credibility step recent AI-proof headlines skipped.
• Contrast with OpenAI's July 10 Cycle Double Cover "proof," which remains unverified, unrefereed, and unconfirmed.
• The tighter d^-1/2 refinement is not yet Lean-verified (missing convex-geometry libraries) and rests on human review, which the paper states openly.
• The builder takeaway: pair LLM reasoning with a domain expert and a mechanical verifier; the checker, not the model, is what makes the output trustworthy.

Sources: Kerger, "Closing the Oracle-Complexity Gap in Derivative-Free Convex Optimization" (arXiv:2607.13335), Lean verification repository, OpenAI GPT-5.6, OpenAI, Cycle Double Cover proof, Jang and Ryu, AI-assisted proof for Nesterov's method, Hacker News discussion