An AI training run can keep consuming expensive computing time even when a small piece of its underlying software is producing the wrong result. Researchers at CertiK and Columbia University say they have brought mathematical proofs to that problem with TensorLean, a system for verifying production GPU kernels.
In a November 20 announcement supplied to Blockster, the team reports applying formal verification to more than 100 kernels across multiple generations of GPU architectures, including code from DeepSeek and FlashAttention. During the work, it says it found two bugs in DeepSeek kernels and 23 in FlashAttention.
Those are the researchers’ reported findings. They describe the work as the first formal verification of production AI kernels; Blockster has not independently established that priority claim. The practical question is easier to grasp: can developers make AI’s underlying calculations faster while proving that the changes preserve the required result?
The small programs behind the large models
GPU kernels are specialised programs that perform pieces of the computation involved in training a model or generating a response. They sit below the chat interface, where performance improvements can affect how efficiently a system uses its hardware.
Speed comes from careful engineering. A kernel may move data while another operation is still running, divide work differently depending on the task or use lower-precision arithmetic to do more calculations with the available resources.
Those choices create difficult correctness questions. Does a change still work for every supported input size? Are parallel operations properly coordinated? Is the numerical error introduced by a faster calculation still within the allowed tolerance?
Ordinary testing checks selected examples. A formal proof addresses a specified property across all inputs and executions covered by its assumptions. The difference matters when an unusual case can escape testing yet recur inside a much larger workload.
What TensorLean says it verifies
The team says TensorLean works directly with compiled PTX code and develops machine-checkable proofs in Lean. NVIDIA describes PTX as a low-level virtual instruction set that is subsequently translated for the target GPU. It is therefore important to distinguish verification at that level from a blanket guarantee covering every later software and hardware component.
According to the announcement, TensorLean accounts for overlapping data movement and computation, execution arrangements that vary with the task, and lower-precision arithmetic. These are the optimisations that make production code useful—and make a simplified proof of an idealised algorithm insufficient.
A successful proof means the verified implementation meets its stated requirements under the defined conditions and numerical tolerances. It does not mean an entire model is free of bugs, that hardware cannot fail or that every answer the model gives will be factually correct.
Finding the bug is only the first step
The proposed workflow is to specify the intended computation, optimise the code, then check whether the new implementation still satisfies the specification. If verification exposes a problem, developers repair the code and try again. Compatible later implementations can reuse the specification; changes to the assumptions or tolerances require corresponding updates.
That makes verification potentially useful as a recurring engineering check. It could help teams detect a regression close to the code change that introduced it, instead of discovering the problem after a large training run or deployment.
“For large-model developers, every performance improvement should be backed by reliable evidence of correctness.”
— Ronghui Gu, CertiK co-founder and Columbia University computer science professor, in the TensorLean announcement
The economic example in the release is explicitly hypothetical: repeating 1% of the computation in a $100 million training run would add $1 million in compute costs. It illustrates the stakes; it is not a measured TensorLean saving, a reported customer loss or a benchmark of the system’s cost-effectiveness.
AI verification is moving closer to production
The announcement follows a related but distinct October 22 project from Anthropic and Theorem. They used Claude to construct proofs of security properties for 123 open-source libraries, with explicit limits including modelled RISC-V execution and input sizes. That work used the Rocq proof checker; TensorLean’s announcement describes Lean proofs for GPU computations.
Post from @AnthropicAIView the original post on X↗
The connection is the push to make rigorous verification practical for real software. The two projects should not be collapsed into one claim: using an AI model to help construct software proofs is different from proving properties of the computing code that runs AI.
Blockster’s reporting on AI-assisted chip design at AMD examines another part of the efficiency race. TensorLean addresses the software running on the hardware. CertiK’s involvement also extends the assurance theme discussed in Blockster’s interview with its executive Angus Lee into AI infrastructure.
The release supplied to Blockster does not include a full bug-by-bug disclosure, reproducible proof package or verification-time benchmark. Those details would help developers assess coverage and the cost of repeating the process as code changes. For now, the reported result is a concrete claim about production kernels—not a certificate that all of AI has been made correct.
Reporting by Eric Spivak




