AI model generates massive math proofs to check old code for hidden errors

Software developers in the Pacific Northwest and beyond may soon spend less time manually reviewing code for errors. A recent project suggests that artificial intelligence can now perform the heavy lifting of mathematical verification, a task that has historically been too costly and complex for most companies to attempt. This shift could change how ordinary users interact with digital tools by potentially making the software they rely on more robust against rare but critical failures.

The work was conducted by Anthropic’s Frontier Red Team in partnership with a company called Theorem. They utilized a model named Claude to verify existing open-source software rather than writing new applications from scratch. Over a period of just a few weeks, the system generated approximately 180 million lines of mathematical proof code. This effort covered 123 different libraries from Google’s OSS-Fuzz security project. The goal was to prove that the code behaves correctly under all possible conditions, a standard that is difficult to achieve with standard testing methods.

Traditionally, formal verification has been reserved for high-stakes environments like aviation systems due to its high cost. For context, a team of specialists required twenty person-years to verify the seL4 operating system kernel. In this new approach, Claude translated crash tests into mathematical problems and analyzed compiled machine code. An independent program named Rocq automatically checked the resulting proofs. Anthropic describes the process as fully autonomous, although human experts at Theorem built the underlying tools and formal foundations.

One of the most significant outcomes was the discovery of hundreds of bugs that conventional testing had missed. These errors often only appear under very specific circumstances, such as unusually large input files or specific sequences of data access. In one notable instance, the team found as many security bugs in a single week for a widely used PDF reader as are typically reported for that software in an entire year. In another case, the system identified a logical error that had remained undetected for more than a decade.

Despite these successes, the method has strict limitations. Anthropic clarifies that a formally verified status does not mean the software is entirely error-free. The proofs are only valid under specific conditions, including a particular processor architecture, single-threaded execution, and input files smaller than 64 megabytes. Since real-world software often runs on various hardware configurations, these constraints remain a significant practical hurdle.

The computational cost of this verification is also substantial, with individual proofs requiring hundreds of millions of tokens. However, the efficiency of newer models is improving. A smaller test run showed that Opus 5.5 can solve half the proofs with about 40 percent fewer tokens than its predecessor. If this trend continues, the cost of verification could drop significantly, making it a routine part of the software development cycle.

The project suggests a shift in how the industry views AI capabilities. The focus is moving from whether AI can write code to whether it can prove that code is safe. Anthropic expects this type of automated verification to become as standard as basic testing in the near future. Theorem’s roadmap already includes critical infrastructure libraries such as glibc, OpenSSL, and cURL, indicating a clear path toward broader adoption.