CSLib: The Lean Computer Science Library

We introduce CSLib, an open-source framework for proving computer-science-related theorems and writing formally verified code in the Lean proof assistant. CSLib aims to be for computer science what Lean’s Mathlib is for mathematics. Mathlib has been tremendously impactful: it is a key reason for Lean’s popularity within the mathematics research community, and it has also played a critical role in the training of AI systems for mathematical reasoning. However, the base of computer science knowledge in Lean is currently quite limited. CSLib will vastly enhance this knowledge base and provide infrastructure for using this knowledge in real-world verification projects. By doing so, CSLib will (1) enable the broad use of Lean in computer science education and research, and (2) facilitate the manual and AI-aided engineering of large-scale formally verified systems.

💡 Research Summary

The paper presents CSLib, an ambitious open‑source project that aims to bring the success of Lean’s Mathlib to the whole of computer science. CSLib is organized around two “pillars”. Pillar 1 is the systematic formalization of core computer‑science concepts in Lean: models of computation (deterministic, nondeterministic, probabilistic, quantum Turing machines, λ‑calculus, etc.), specification logics (temporal, Hoare, separation, linear, etc.), complexity classes, and a broad collection of algorithms and data structures. The authors illustrate this pillar with concrete Lean definitions of labeled transition systems (LTS) and bisimulation, together with a theorem that the inverse of a bisimulation is again a bisimulation. They also introduce a lightweight monadic API called TimeM for attaching a “time cost” to functional computations, and demonstrate its use by implementing merge‑sort, proving both functional correctness and an upper bound on the number of comparisons (n·⌈log₂ n⌉). This shows how correctness and complexity analysis can be kept orthogonal yet proved together in Lean.

Pillar 2 addresses the gap between formal verification and everyday imperative programming. CSLib defines an intermediate language named Boole that mixes classical imperative constructs with Lean specifications. Boole programs are automatically translated into Lean verification conditions, allowing the existing Lean proof engine to discharge them. The authors envision a pipeline where code written in mainstream languages such as Rust, C++, or Python is first compiled to Boole and then verified in Lean, effectively turning the verification of real‑world code into a theorem‑proving task. This approach builds on prior intermediate verification languages (IVLs) but leverages Lean’s rich mathematical library and interactive proof facilities.

The paper discusses three major impacts. First, CSLib provides a unified repository of high‑quality formalized CS knowledge that can serve as training data for AI models. The authors argue that, just as Mathlib enabled AI‑driven advances in pure mathematics, CSLib could enable AI agents to discover new algorithms, prove open claims, or assist in code verification across domains. Second, CSLib lowers the barrier for CS education and research: students and researchers can quickly prototype algorithms, reason about their properties, and obtain machine‑checked proofs without building the underlying formalizations from scratch. Third, CSLib promises substantial cost savings for industrial verification. The authors contrast the 20 person‑year effort required for the seL4 verified kernel with the modular, reusable components that CSLib would provide, suggesting that large‑scale systems could be built compositionally from pre‑verified libraries, dramatically reducing human effort.

Technical details include a taxonomy of models and logics (Figure 1‑a), a taxonomy of algorithms and data structures (Figure 1‑b), and concrete Lean code snippets for LTS, bisimulation, the TimeM monad, and merge‑sort. The authors acknowledge limitations of the current lightweight complexity framework (manual tick annotations, inability to prove lower bounds) and outline a roadmap that includes heavier-weight RAM‑model based analyses. They also discuss the symbiotic relationship with Mathlib: CSLib will reuse Mathlib’s big‑O, probability, and combinatorial lemmas, while contributing CS‑specific mathematical results back to Mathlib when appropriate.

In summary, CSLib proposes a comprehensive, Lean‑based infrastructure that unifies formalized theory, verified algorithms, and an imperative‑code verification pipeline. By doing so, it aims to make formal verification practical for education, research, and industry, while also creating a fertile ground for AI‑assisted proof generation and discovery in computer science.