Contents and sources 1 sections
Key points
- Researchers from CertiK and Columbia examine whether optimized GPU code meets explicit correctness requirements.
Fast computation still has to be correct
Behind an AI model’s response are small GPU programs that repeatedly move data and perform calculations. They divide work among hardware threads and try to keep expensive processors busy. A program can finish without crashing while still returning an unexpected result, leaving subsequent training or inference to build on an error that was never obvious to its operators.
PANews reports that researchers at CertiK and Columbia University developed TensorLean to apply formal verification to GPU kernels used in AI workloads. The team examined 149 compiled kernel instances and proved that 83 conformed to their corresponding Lean specifications. It also reported 38 correctness issues across six libraries. Those figures describe the team’s experiment, not verification of every GPU program or model.
The examined implementations included DeepSeek’s DeepGEMM and the FlashAttention library. According to the report, two of the identified issues were in DeepGEMM and 23 were in FlashAttention. The overall count spans six libraries and should not be read as a count affecting every version of either product.
Ordinary tests run selected inputs and compare what happens with the expected outcome. They can expose a problem when a test happens to exercise it. Formal verification starts by writing down what a program should do and the assumptions under which that requirement applies, then attempts to prove that executions satisfying those assumptions meet the specification. The strength of that result depends on the specification as well as the proof.
Real GPU kernels are difficult subjects because performance improvements change how work is arranged. Programs may overlap data movement with computation, split work among threads, rearrange memory or use lower-precision arithmetic. These techniques can improve throughput, while making synchronization and numerical error harder to reason about. The researchers say TensorLean works on compiled PTX code and checks results within stated conditions and error tolerances.
CertiK’s technical explanation says the proofs are developed in Lean and can be checked by machine. For a development team, the potential workflow is iterative: specify the computation and its assumptions, optimize an implementation, then check the new version against those requirements. Similar computations can reuse specifications, but a change in permitted inputs or numerical tolerance requires the requirements themselves to be reconsidered.
Finding an issue does not mean a repair is complete. Developers still need to locate the fault, change the code and check the revised version against its specification. If a revision changes the computation or input range, an earlier proof may no longer apply. Verification therefore needs to follow software updates rather than happen only once before a release.
A successful proof has a boundary. It says that the checked program meets the written specification under its stated assumptions; it does not automatically establish that the specification captures every desired behavior, that the whole model is free of errors, or that every hardware configuration was examined. Knowing which versions, inputs and tolerances were covered is therefore part of interpreting the result.
The researchers offer a hypothetical illustration of cost: if a $100 million training run had to repeat 1% of its computation because of errors, the extra compute would amount to about $1 million. This is an illustrative scenario, not a reported loss. The practical value of TensorLean will depend on further evaluation across codebases and on the effort needed to maintain specifications as implementations change.
Sources & further reading
(2)
When checking a claim, compare the source date, measurement period and conditions. Some linked pages change over time.
For information and education, not investment advice. Crypto assets are volatile. Verify independently.



