Home·The theorem·The proof in one reading·Architecture·Units·Manuscript·Glossary·FAQ·Work items·Data·Method·Provenance·Changes
This site is generated from revision 86d5be3 (2026-11-17) of the source repository.

Yang–Mills informalization

Contents

Where do the ideas come from? 2

The manuscript: third draft \(\cdot\) how it is written 2

Trishen Gunaratnam's revision: HumanizeYM_v2 2

The proof at five levels of detail 2

In collaboration with Humanise Yang–Mills 4

The theorem, in brief 4

The proof at a glance 5

How the map was made 6

Status 7

Compiled Lean files 7

How to cite 7

License 8

A map of OpenAI's Lean proof of the construction of four-dimensional Yang–Mills theory, and a natural-language outline built from it.

This repository is maintained by Scott Armstrong (CNRS and Sorbonne Université; Courant Institute, New York University), in collaboration with Martin Hairer's humanise-yang-mills project (details below). Source: github.com/scottnarmstrong/yang-mills-informalization. For reading on screen, an HTML version generated automatically from this repository by Massimiliano Gubinelli is at mgubi.github.io/yang-mills-informalization.

In October 2026 OpenAI announced a proof, formalized in Lean 4, that four-dimensional quantum Yang–Mills theory can be constructed as a scaling limit of Wilson lattice gauge theory. On 11 November 2026 the Lean source (OpenAI-YM-20261028) was released.

The source is about one million lines of Lean in 9,477 files. No informal proof accompanies it. The code uses arbitrary nicknames for its objects (Treasury, Jewel, Sheet, sails…), and its folders record the history of its development rather than its mathematical structure.

This repository is an attempt to make that proof readable. Using AI agents, we:

  1. map the proof: we compute its dependency graph from the main theorem down, and divide it into eight parts and thirty-two units;

  2. outline it in natural language, at several levels of detail, from a short account of the whole proof down to an outline of each unit with every statement linked to the Lean;

  3. write a complete natural-language account of the proof on that skeleton: a manuscript, written in public. A third draft is now available (PDF, 278 pages, draft of 13 November 2026); it is still being revised.

The outline is a rough draft written by machines. Its purpose is to be checked, corrected and rewritten by people.

Where do the ideas come from?

A component-by-component analysis of which parts of the proof follow Balaban's programme for lattice gauge theories, which follow OpenAI's 2026 papers on two-dimensional sigma models, which come from other constructive work (Gawędzki–Kupiainen, Brydges–Yau, Magnen–Rivasseau–Sénéor), which are standard, and which appear new, with the evidence on both sides. Read the analysis →

The manuscript: third draft · how it is written

A third draft of the full proof is now available (PDF, 278 pages): Part I states the theorem and the architecture of its proof, Part II gives the proofs. It was written entirely by AI agents from the Lean code, and is still being revised. Statements are fixed first and kept short. Every statement is reviewed against the Lean by a separate reviewer, a fresh reader and a sentence-by-sentence truth check, and every finding is recorded with its decision. The process, what it has caught so far, and what it does not establish →

Trishen Gunaratnam's revision: HumanizeYM_v2

A revision of the third draft by Trishen Gunaratnam, written with AI assistance (PDF, 306 pages, 17 November 2026). It corrects several local arguments, among them the free two-form transfer in Section 11, adapts material from humanise-yang-mills, and adds figures of a blocking step, observable transport and the cutoff comparison. Its proof-status note lists the estimates whose written proofs are still to be supplied; sources and licenses.

The proof at five levels of detail

The repository presents the same proof at five levels of detail. Each level links down to the next, and everything from level 3 down is linked to the exact lines of the Lean source. Start at the top and go down as far as you need.

level what you get
1 The main theorem What is proved: the Lean statement verbatim, a commentary in words, and the full statement in ordinary mathematics, with what is and is not claimed.
2 The proof in one reading A high-level account of the whole proof: the strategy, the key mechanism of each part, what is new, where the difficulty lies.
3 The architecture The eight parts of the proof, from the lattice setting through the renormalization group to the identification as Yang–Mills; what each part hands to the next; the interface between the ultraviolet construction and the infinite-volume limit.
4 The units The proof divided into thirty-two units, mathematically coherent pieces grouped by part. Each unit has its own page with its outline (about three to ten pages: the propositions it proves, what it uses, the strategy, the main steps), a link to its detailed notes (the full account, with a proof sketch for every step), and its Lean map: the source and the key statements in plain language, each linked to its exact lines. In all, 989 key statements cover the 413,000 lines of source attributed to the units.
5 The full proof (third draft) A complete manuscript (PDF, draft of 13 November 2026): Part I, the theorem and the architecture of its proof (about 45 pages, main theorem on p. 15), and Part II, the proofs (about 230 pages), written for a mathematician in constructive field theory or probability. Every section has been through its review cycle; revisions continue, by the process described in how the manuscript is written.

All in one PDF. Levels 2–4 — the proof in one reading, the architecture and the thirty-two unit outlines — as a single PDF (164 pages; LaTeX source). The detailed notes of all units are a separate PDF (595 pages). Links to the Lean point to the exact lines, as on the web pages.

Reference material, used at every level:

Where the ideas come from Which parts of the proof follow Balaban's programme, which follow OpenAI's 2026 papers on two-dimensional sigma models, which are standard, and which appear new; component by component, with the evidence on both sides.
Glossary The code's nicknames (Treasury, Jewel, Sheet, …) translated into mathematics.
The work items The code's own decomposition of the limit theory into about one hundred stated obligations, each with what it proves.
How this was made Method, checks against OpenAI's compiled record, the review rounds, and how far each level can be trusted.
FAQ and evidence guide Questions about the result, its limits and what each check establishes.
Changes Publications, corrections and changes to the mathematical account.
Data Tables of the units, the unit of every declaration, and the key statements, with links.

The exact statement and the unit outlines have different review scopes. Each unit displays its current status and remaining limitations. See how the map was made and what was checked.

All links to Lean point to the fixed commit 3456e5e of the released source.

In collaboration with Humanise Yang–Mills

This project is carried out in collaboration with Martin Hairer's humanise-yang-mills, a crowd-sourced effort to turn the Lean formalization into a human-readable monograph whose statements and arguments can be traced to a fixed version of the code.

The map, the units, the glossary and the links collected here are meant as input to that effort: a first pass at its "start at the final theorem and work backwards to a graph of mathematical results".

The theorem, in brief

For every compact matrix group G whose Lie algebra is simple and nonabelian (for instance SU(N), N ⩾ 2), the Lean proof constructs the following.

Not claimed: uniqueness or subsequence-independence of the infinite-volume limit, clustering of the full limit, a mass gap, or agreement with perturbation theory to all orders.

The proof at a glance

The map divides the source into eight parts. The data record the declaration assignments and size estimates; these counts should be distinguished from the declarations reached by the seventeen verification results.

part what it does share
I Setting Lattice tori, compact gauge groups, the Wilson measure and its lattice symmetries. <1%
II Data of the construction Field labels and their lattice representatives; polymer activities and their norms; the Wilson family of spacings, volumes and couplings; reflection-positive cells. 4%
III Ultraviolet construction A Balaban-type renormalization group at fixed volume: block-spin steps with a gauge fixing compatible with the lattice symmetries, Gaussian integration and determinants, cluster expansions, a background field matched to the Wilson action, the flow of the coupling, bounds on irrelevant terms, and the order in which all constants are chosen. It proves bounds uniform in the volume and convergence as the lattice spacing tends to zero. 70%
IV Infinite volume Extraction of a subsequence of volumes along which all correlations converge, from the uniform bounds and reflection positivity; the Euclidean axioms of the limit. 2%
V Phases and reconstruction Decomposition of the limit into phases; Osterwalder–Schrader reconstruction of a Wightman theory for each phase. 4%
VI Symmetry Ward identities, a conserved stress tensor, the rotation and boost actions. 5%
VII Identification as Yang–Mills Comparison with free Maxwell fields at short distance; the trace anomaly and non-freeness; the running coupling; the operator product expansion and contact extensions. 11%
VIII Assembly The main theorem. 3%

The ultraviolet and infinite-volume parts meet in a short, clean interface. For a fine enough lattice:

These bounds and reflection positivity support the infinite-volume extraction. Reconstruction and identification also use thin-slab bounds, Ward identities, rotation and boost constructions, and comparison with free Maxwell fields. Parts IV–VI are organised in the code itself as about seventy numbered work items, each stating one obligation and proving it in its own file. They are a ready-made skeleton for an exposition.

How the map was made

The dependency graph is computed from the compiled Lean: for every declaration, every declaration its elaborated statement and proof use, including the dependencies Lean inserts silently (2.26 million references).

We compared the declarations reached from the release's seventeen named verification results with OpenAI's compiled record: the two sets differ by 50 of about 74,000 declarations after auxiliary constants are attributed to their owners. This comparison does not check every edge or the English explanations; see the exact scope.

The graph is then reduced in steps:

Two independent AI readers read every candidate statement and judged its importance (main result, key result, technical lemma, bookkeeping). They wrote a one-sentence plain-language summary of each. Their importance labels had Cohen's κ = 0.72; this measures agreement on those labels, not mathematical correctness. Before being applied here, each step was tested on an earlier OpenAI formalization (finite-time blow-up for Navier–Stokes) whose human-written structure is known. Details and caveats are in method.md.

Status

Dependency structure Computed from the compiled Lean; reachable sets for seventeen named results compared with OpenAI's record (scope and limits).
Units Computed from the dependency graph, then cut along the mathematics.
Plain-language summaries and glossary AI-written. Glossary readings are marked certain, probable or tentative; these labels do not apply to every summary and are separate from unit review status.
Precise statement of the main theorem Published: the public theorem compared definition by definition with the Lean. Some additional construction clauses remain summarized; see review scope.
Unit outlines All 32 are published; each is marked draft, checked or edited. See the status meanings and each unit's limitations.

Report a correction: include the page and heading, quote the sentence, and give a proposed correction or a Lean source link.

Compiled Lean files

To load the pinned Lean source with precompiled project files, download the compiled build of commit 3456e5e. The commands below check the download checksum and reuse the compiled files; they do not rebuild the proof from source:

git clone https://github.com/yang-mills-group/OpenAI-YM-20261028 && cd OpenAI-YM-20261028
git checkout 3456e5e75cf8d4cd558955a5c7638fba2d68f464
lake exe cache get                                   # Mathlib, from the official cache
gh release download lean-build-3456e5e -R scottnarmstrong/yang-mills-informalization -p 'ym-build-*' -p SHA256SUMS
cat ym-build-3456e5e.tgz.part0 ym-build-3456e5e.tgz.part1 > ym-build-3456e5e.tgz && sha256sum -c SHA256SUMS
lake unpack ym-build-3456e5e.tgz
lake build WilsonReference WilsonConstruction        # all targets up to date: nothing is recompiled

The archive is 2.2 GB, in two parts, and unpacks to 8.8 GB. The release notes also give a download with curl.

How to cite

Use the metadata in CITATION.cff. Include the revision of this repository you consulted, the unit and result identifiers when relevant, and the fixed Lean source commit 3456e5e75cf8d4cd558955a5c7638fba2d68f464. The citation describes this map and outline; cite the Lean source separately when referring to the formal proof.

License

This repository is licensed under the Apache License 2.0. The Lean source it describes is © OpenAI, also released under the Apache License 2.0; see the source repository.