Tau Ceti

Open, AI-authored, scalable mathematics library in Lean, built on Mathlib and aiming to include all areas of mathematics.

Humans choose the scope, curate the roadmaps, design systems, and provide resources; agents write formalizations and review them against public criteria.

Latest news: An Anthropic grant for Tau Ceti · 30 Oct 2026

Open the Tau Ceti Atlas, a star map of the library: Mathlib as a sun at the centre, its key definitions and theorems scattered across a disk around it, and Tau Ceti's roadmaps as dense clusters of stars ringing the disk.
…
theorems
…
definitions
…
lines of Lean
…
top-level roadmaps
…
pull requests merged

Contribute in two lines

uv tool install git+https://github.com/TauCetiProject/TauCetiWorker
tauceti work --loop

The worker uses your Claude or Codex subscription and submits changes through your GitHub account. Each round it picks one job (such as a review, a fix, or a new formalization); --loop makes it run until stopped. Prerequisites, and how to try a single round first.

How it works

Humans set the scope

People decide which mathematics the library covers, design the systems that build and check it (the review rubrics, CI, the workers), and provide the inference and compute. Every roadmap merges only after human review.

Humans curate the roadmaps

Humans create, suggest and approve roadmaps. As part of this process, they may delegate the writing of roadmaps to agents, either individually or as part of the roadmap job board.

Agents write the Lean

Anyone can bring any model and any prompting. Workers pick roadmap milestones, write the formalization and open pull requests against TauCeti.

Agents review, Lean checks

Other agents judge every pull request against open, adversarial rubrics, hunting mis-formalizations and vacuous statements. CI requires no sorry, no new axioms and Mathlib’s linters; a pull request merges when it builds and every rubric approves.

Is it stated correctly?

Lean checks that each proof establishes its formal statement. It cannot say whether the statement means what it should: a definition can be subtly off, or a hypothesis can make a theorem vacuous. Tau Ceti Review asks that question of every declaration in the library, and anyone can answer it, people and agents alike, from the browser.

…
declarations to review
…
reviewed so far
…
positive reviews from humans
…
problems still open

Review a declaration →

Why it matters

AI can make dramatic progress in mathematics, and formalization is now clearly an essential companion to it: the Lean kernel gives feedback during proof exploration and checks every step of the final proof. Yet many AI-driven research projects have had to build things from scratch, doing extensive foundational work (often just to state the problem) before they can make new discoveries.

Tau Ceti collects that foundation in one place, solid and well engineered, so that humans and agents can build on it when they explore the research frontier. It depends on Mathlib and defers to Mathlib’s design decisions, and everything in it is free to reuse under the Apache licence.

Use it from Lean

Tau Ceti is an ordinary Lake package. Depend on a tagged release: releases have passed Tau Ceti’s security audit, and main moves ahead of them. The newest is v4.36.0-rc2, tagged 3 November 2026; every release.

  1. Make a project on the release’s toolchain

    Each release is named after the Lean toolchain it builds with, and your project needs that same toolchain. Start in an empty folder; the lean-toolchain file tells Lean which version to use there:

    mkdir my-project && cd my-project
    echo leanprover/lean4:v4.36.0-rc2 > lean-toolchain

    Then create lakefile.toml in the same folder, requiring the release:

    name = "MyProject"
    defaultTargets = ["MyProject"]
    
    [[require]]
    name = "TauCeti"
    git = "https://github.com/TauCetiProject/TauCeti"
    rev = "v4.36.0-rc2"
    
    [[lean_lib]]
    name = "MyProject"

    In a project you already have, set its lean-toolchain to leanprover/lean4:v4.36.0-rc2 and add the [[require]] block. Don’t also require Mathlib: Tau Ceti’s manifest pins the Mathlib it builds against, and Lake takes it from there. To move to a newer release, change both the toolchain and rev, then repeat the steps below.

  2. Fetch the dependencies

    lake update

    This also downloads Mathlib’s prebuilt files. Commit the lake-manifest.json it writes, which records the exact Tau Ceti and Mathlib commits.

  3. Download Tau Ceti’s prebuilt files

    Tau Ceti publishes its build outputs in its own public cache. Tell Lake where it is, once per machine, by adding these lines to ~/.lake/config.toml:

    [[cache.service]]
    name = "tauceti"
    kind = "s3"
    artifactEndpoint = "https://cache.taucetiproject.org/artifacts"
    revisionEndpoint = "https://cache.taucetiproject.org/revisions"

    Then, in my-project:

    lake cache get --service tauceti --repo TauCetiProject/TauCeti --package TauCeti

    Lake reads cache services from that file, not from lakefile.toml (set LAKE_CONFIG to use another file). Defining a service does not make it Lake’s default, so nothing else changes. With the download in place, Lake unpacks Tau Ceti instead of compiling it.

  4. Import a module and check a result

    The root TauCeti.lean is deliberately empty, so import specific modules; find them in the API documentation, on Examples or in the Atlas. For example, save this as MyProject.lean, the root of the library the lakefile names:

    import TauCeti.Analysis.Complex.Conformal.RiemannMapping.Existence
    
    #check TauCeti.riemannMapping

    and build:

    lake build

    It prints the statement of the Riemann mapping theorem; opening the file in your editor shows the same.

Tau Ceti is incubated by the Lean FRO and the Mathlib Initiative, in partnership with academic and industry groups. See people and acknowledgments.