GPT-5.6 Verifies 30-Year Convex Optimization Bound

An LLM just spent 148 minutes in a single session and verified a mathematical bound in convex optimization that's been open for thirty years. That's not a "helpful assistant" summarizing a PDF. It's a machine solving a problem that humans couldn't crack for three decades.

I've spent years watching AI hype cycles move from "it can write a poem" to "it can do your job," but this feels different. Most of the time, these models are just guessing the next token based on a massive pile of internet data. But when you're dealing with a rigorous mathematical proof, there's no room for "hallucinations." It's either right or it's wrong.

The real question is whether this was a fluke of a very specific prompt or if we've finally hit a wall where human intuition is simply slower than a long-context window. I want to look at how the session actually unfolded and whether the logic holds up under scrutiny.

The 30-Year Mathematical Gap

The core problem with zero-order bounds is that they rely on estimating a function's behavior without knowing its gradient. For 30 years, researchers struggled to prove tight bounds because traditional proofs couldn't handle the noise introduced by these approximations. This gap meant we were essentially guessing the efficiency of optimization algorithms in high-dimensional spaces, which is a frustrating way to do math.

This part is genuinely confusing because the gap isn't about a missing formula, but about the inability to verify that certain bounds hold across all possible smooth functions. The verification process is grueling. In the Lean formalization of these bounds, a single session took 148 minutes to complete.

-- A simplified representation of a zero-order gradient estimate
def zero_order_grad (f : ℝ → ℝ) (x : ℝ) (δ : ℝ) : ℝ :=
  (f (x + δ) - f (x - δ)) / (2 * δ)
-- This estimate approximates the derivative without using the actual gradient

The verification proves that the error in these estimates doesn't explode as the number of dimensions increases. It's a relief to finally have a formal proof, but it's also a bit humbling that it took three decades and a machine-checked proof to settle a problem that felt intuitive to most practitioners.

Analyzing the 148-Minute Session

The 148-minute session duration is the most revealing part of this process. It's not a single, long calculation, but a grueling iterative loop of prompting and verifying. To reach full accuracy, the system has to guess, fail, and refine its approach over and over. This isn't a "one-shot" solve; it's a conversation between a proposer and a verifier where the verifier is incredibly pedantic.

The process is genuinely confusing because it's hard to tell if the LLM is actually "reasoning" or just brute-forcing its way through the search space of possible Lean proofs. You're essentially watching a machine struggle with the gap between a high-level mathematical intuition and the rigid syntax required by a formal verifier.

To get this working, you need the Lean 4 toolchain and the specific project dependencies:

elan init
lake build

The session's length comes from the fact that formal verification is binary. A proof is either correct or it isn't. There's no "close enough" in Lean. If the system misses a single edge case in a bound, the whole proof fails, and the loop starts again. This creates a high-latency feedback loop that makes the 148-minute mark feel like a victory, even if the actual "thinking" time is only a fraction of that.

The Verification Process

The community is leaning into the idea that since AI has commoditized the "how" of coding, the value now sits with the "what" and "why." I think this is a fair assessment, but it ignores the messy reality of technical debt. It's easy to say that high-level conceptual thinking is the new premium, but conceptual brilliance doesn't fix a race condition or a memory leak in a production environment. We're risking a gap where we have people who can architect a system at 30,000 feet but can't actually debug the implementation when the AI hallucinations hit the fan.

For senior engineers, this shift is less about a change in "value" and more about a change in the bottleneck. The bottleneck isn't writing the boilerplate anymore; it's the verification process. I suspect we'll see a period of frustration where the speed of generation far outpaces our ability to actually audit the output. We're basically trading typing time for review time.

I'm genuinely curious if "stratified inputs"—the ability to guide an AI through complex, layered prompts—is actually a sustainable skill or just a temporary workaround until the models get better at inferring intent. If the latter is true, the "domain expertise" argument becomes the only real moat left.

Formal Proofs vs. LLM Intuition

The community is leaning into the idea that we're moving from an era of "how" to an era of "what." The argument is that as LLMs handle the rote implementation—the actual typing of the code—the value shifts to the person who can define the constraints and provide the high-level conceptual framework. I think this is a half-truth. While the barrier to entry for shipping a feature is lower, the cost of a mistake in the "stratified input" phase is actually higher because we're generating volume faster than we can realistically audit it.

I suspect we're overestimating how much "domain expertise" can replace formal rigor. There is a fundamental gap between a sophisticated prompt and a formal proof. Intuition is great for prototyping, but it's a liability when you're building systems where a single edge case can crash a production cluster. We are trading precision for velocity.

The real question is whether we'll actually see a return to formal methods to check the LLM's work, or if we'll just accept a baseline level of "mostly correct" software because the speed of iteration is too addictive to give up.

Conclusion

The fact that a 30-year-old gap in convex optimization was closed in a 148-minute session is a weird milestone. It suggests that the "intuition" in GPT-5.6 is finally hitting a threshold where it can bridge the gap between a vague mathematical hunch and the rigid requirements of a Lean formal proof.

I'm still not convinced we've solved the "black box" problem of AI reasoning, but the result is concrete. We have a verified bound that humans couldn't nail down for three decades, and we have it because a model spent two and a half hours grinding through Lean tactics.

Is this the end of the era where we need humans to manually bridge the gap between a whiteboard sketch and a formal proof, or did we just get lucky with a specific set of bounds?