There's a quiet thrill in watching someone piece together how these new math-solving systems actually work. The user who posted this isn't asking for a product demo or a benchmark table. They're asking about architecture, about the loop between a language model, a formal proof checker like LEAN, and the slow accretion of verified facts. That's the right question to ask. Most of the public conversation around AI and mathematics is still stuck on "look what it solved," when the more interesting story is "how does it even decide what to try next?" The description they've pieced together, generate statements, submit them to a compiler, feed the results back as facts, is essentially a closed-loop search with a formal referee. It's not magic. It's just very patient, very structured trial and error, where every successful step becomes a foundation stone.
What stands out here is the humility in the post. The user admits they're struggling to compose larger ideas from smaller ones, and that's not a failure of imagination. It's the core problem. Anyone who has tried to build something meaningful with a language model knows that generating a correct step is easy. Generating a correct *sequence* of steps that builds toward a nontrivial theorem is a different beast entirely. The papers they mention, some running hundreds of pages, suggest the systems aren't thinking in terms of grand narratives. They're assembling proofs piece by piece, checking each piece against a formal system, and only then stitching the pieces together. That's a useful mental model for anyone trying to build their own version. It also connects to a broader lesson we've touched on before in our exploration of real-world computer vision systems: the gap between a model that can recognize a pattern and a system that can be trusted to act on it reliably is enormous. In vision, you deal with noisy inputs and ambiguous outputs. Here, the rules are crisp, but the search space is brutally large.
So is this a fool's errand without a warehouse of GPUs? Not necessarily, but the hardware question is a distraction. The real constraint isn't compute. It's how you manage the "facts" the model accumulates. If you're generating statements and checking them, you need a way to decide which facts are worth keeping, which ones are too specific, and which ones might be useful later. That's not a hardware problem. It's a memory and retrieval problem. And it's the same kind of challenge we've seen in other domains, like when we looked at how verifying an AI’s understanding of tax season rules requires more than just asking the model if it's sure. You need an external check. LEAN is that check here. The model proposes, the compiler disposes. The user's instinct to build a janky version is actually the right one. Start small. Pick a domain where the rules are explicit, like higher-dimensional geometry, and see if you can get a loop going where the model generates a lemma, LEAN verifies it, and the system moves on. You'll learn more from that failure than from reading another paper about what's possible.
What we'd tell this user directly: don't wait for the perfect framework. The gap between "I can generate a true statement" and "I can build a proof" is the same gap between knowing a few chords and playing a song. The way you close it is by playing badly for a while. Their question about composing larger ideas from smaller ones is the right one, and it's worth asking it with a concrete example in hand. Try to prove something small, something you already know is true, and then see how the system behaves when it has to chain together multiple verified steps. The answer might surprise you. It might also reveal that the bottleneck isn't the model's reasoning but the way you're framing the problem. One specific thing to watch: how the system decides when a partial proof is worth extending. That's where the real design insight lies, and it's the detail most write-ups skip.