Formalized in Lean, piece by piece: 58 theorems, 0 sorries, and the Lefschetz (1,1) case reduced to exactly two named missing inputs.
Let X be a smooth projective variety over the complex numbers: a geometric space cut out by polynomial equations, with no singularities, sitting in projective space. Algebraic cycles on X are formal combinations of subvarieties. Each cycle has a cycle class in the integral cohomology group H2p(X, Z), where p is the codimension. Complex cohomology in degree 2p splits into Hodge pieces, and a class whose image lies in the middle (p, p) piece is a Hodge class. The Hodge conjecture says every Hodge class is algebraic: it is the cycle class of some algebraic cycle. The case p = 1 is the Lefschetz (1,1) theorem, proved in the 1920s. The conjecture is open for every p at least 2. This lab formalizes the (1,1) case in Lean, piece by piece, against the actual state of mathlib, to find exactly where the formalization stops.
Toolchain: Lean 4.13.0 (commit 6d22e0e5cc5a), mathlib v4.13.0 (commit
d7317655e2826dc1f1de9a0c138db2775c4bb841), project under
lean/. Every round ends with lake build exiting 0
and an axiom audit (lake env lean CheckAxioms*.lean) confirming
every declaration depends only on the standard axioms
propext, Classical.choice, Quot.sound,
with no sorryAx anywhere. The conjecture itself is stated as a
formal proposition, HodgeConjecture, over abstract data carried
by the structure HodgeData. It is a statement, not a proof.
| Round | File | New theorems | Checked | Build | Piece formalized |
|---|---|---|---|---|---|
| 1 (Nov 20) | Hodge/Basic.lean | 4 | 4 | compiled | Statement, Lefschetz (1,1) conditional on hsurj and hreality |
| 2 (Nov 20) | Hodge/Exponential.lean | 9 | 9 | 3060/3060 | Exponential sequence of abelian groups 0 to Z to C to C* to 1, exact at every term |
| 3 (Nov 20-21) | Hodge/SheafOX.lean | 13 | 13 | 3842/3842 | Sheaf of holomorphic functions O_X and its sheaf of units O_X* |
| 4 (Nov 20-21) | Hodge/Dolbeault.lean | 14 | 23 | 1497/1497 module, 4550 full | Degree-zero Dolbeault, as far as mathlib allows; c1 construction recovered and re-verified |
| 5 (Nov 21) | Hodge/LongExactSequence.lean | 18 | 18 | 4584/4584 | Sheaf long exact sequence with c1 for the actual exponential sequence |
Round 4 checked 23 theorems: 14 new Dolbeault theorems plus 9 ChernClass theorems recovered from a previous agent's file after a VM restart killed the first attempt, and re-verified. Round 5 checked 18: 17 new theorems plus the balanced-abelian-category instance. Total across the five rounds: 58 theorems checked, 0 sorries.
hodge.json, hodge_r2.json, hodge_r3.json,
hodge_r4.json, hodge_r5.json.hodge_r5.json and hodge_formalization.md.Four theorems, in Hodge/Basic.lean. The closest checkable
statement is the conditional Lefschetz (1,1) theorem
(Hodge.lefschetz_one_one): in the abstract Hodge setting, given
the first Chern class map c1 from the Picard group, the comparison map from
integral to complex cohomology, and the hypothesis hsurj that c1
surjects onto the kernel of the (0,2) projection, every Hodge class of type
(1,1) is algebraic. Proved and kernel-checked with no sorry. The companion
lemma Hodge.hodge_class_iff_vanishing, conditional on
hreality, shows the Hodge (1,1) condition is equivalent to
(0,2)-vanishing for real classes, and Hodge.real_vanishing proves
the underlying linear algebra unconditionally: a real vector whose (0,2)
component vanishes also has vanishing (2,0) component, because conjugation
swaps the two outer pieces. The round 1 gap list records 10 items mathlib
v4.13.0 does not have, including singular cohomology, the Hodge
decomposition, the cycle class map, the first Chern class, divisors and the
Picard group, the exponential sequence and its long exact sequence, de Rham
cohomology, GAGA, and projective morphisms.
Nine theorems, in Hodge/Exponential.lean. The exponential
sequence of abelian groups 0 to Z to C to C* to 1 is exact at every term
(Hodge.expSeq_exact): exp(0) = 1, exp(z + w) = exp(z) exp(w),
exp(z) = 1 exactly when z = n (2 pi i), every nonzero complex number has a
logarithm, and the inclusion n to 2 pi i n is injective. The Lefschetz
theorem is restated with hsurj as Function.Exact exactness
(Hodge.lefschetz_one_one_of_exact). The sheaf-level sequence was
assessed not tractable in mathlib v4.13.0: no sheaf of holomorphic functions
O_X exists to sheafify with. First build attempt failed with 2 errors (both
fixable); rebuild exits 0. First build took about 11 minutes because the new
import chain required compiling mathlib native objects round 1 had not built.
Thirteen theorems, in Hodge/SheafOX.lean. O_X is built from
mathlib's LocalInvariantProp sheaf machinery, the same way as the smooth sheaf
in Mathlib.Geometry.Manifold.Sheaf.Smooth, using
differentiableWithinAt_localInvariantProp with target model I(C, C).
holomorphicSheaf (O_X as a sheaf of types, sections exactly the
MDifferentiable functions), holomorphicSheafCommRing (O_X as a
sheaf of commutative rings), MDifferentiableAt.inv and
MDifferentiable.inv (the inverse of a nowhere-zero holomorphic
function is holomorphic), holomorphic_isUnit_iff,
holomorphicSheafUnits (O_X* as a sheaf of abelian groups),
mdifferentiable_exp and holomorphic_exp,
holomorphicExpSheafHom (exp as a sheaf morphism O_X to O_X*).
Build: lake build exit 0, 3842/3842 targets. The (1,1) case is
now conditional on the sheaf long exact sequence rather than on O_X existing.
Still blocked: the sheaf exponential sequence as sheaves, the long exact
sequence with c1, Dolbeault, and the Hodge decomposition.
Fourteen new theorems, in Hodge/Dolbeault.lean, plus the
recovered c1 construction. Part A, degree-zero Dolbeault on C: the Wirtinger
d-bar derivative dbarDeriv f z = (fderiv R f z 1 + I fderiv R f z I) / 2, with
the theorem that a real differentiable f : C to C is complex differentiable
at z exactly when its d-bar derivative vanishes. That is the kernel of d-bar
equals O_X, pointwise on C. Also the global form, the forward and converse
directions separately, the Cauchy-Riemann characterization, and the
df/dz plus df/dzbar split. Proved from mathlib's
differentiableAt_iff_restrictScalars. Part B, the type decomposition of the
differential: for L : E toL[R] C on a normed space E over C, holPart is
C-linear, dbarPart is C-antilinear, they sum to L, and dbarPart vanishes
exactly when L is C-linear. The bridge: dbarDeriv is the dbarPart of the real
differential, and complex differentiability holds exactly when the (0,1) part
of the real differential vanishes. Also recovered and verified: the c1
construction in Hodge/ChernClass.lean, 9 theorems, exact at both
joints in an abstract abelian category, surjecting onto the kernel, plus the
sheaf-category version and Lefschetz (1,1) from the sheaf long exact sequence,
conditional on the Dolbeault isomorphism and the Hodge decomposition. Build:
lake build Hodge.Dolbeault exit 0, 1497/1497 targets; full build
exit 0, 4550 targets. Where the Dolbeault isomorphism stops, verified by
fresh mathlib searches: no differential forms on manifolds, no exterior
derivative, no de Rham cohomology; grep for dolbeault, de rham, chern,
wirtinger returns only two false positives (Chernoff bound, matcherName).
Still missing: the sheaves A0,q of smooth (0,q)-forms, the d-bar
operator between them, Dolbeault cohomology groups, and the fine-sheaf
acyclicity identifying Hq(X, O_X) with Dolbeault cohomology.
Eighteen theorems, in Hodge/LongExactSequence.lean. The
exponential sequence is short exact (expSeq_shortExact): 0 to Z
to O_X to O_X* to 0 as sheaves of abelian groups on the opens site.
Exactness at O_X comes from the two analytic inputs: exp f = 1 implies f is
locally constant in 2 pi i Z (continuity plus discreteness of Z), and every
nowhere-zero holomorphic section has a local logarithm
(differentiableAt_log on the slit plane). The kernel is proved categorically,
and the exponential map is an epimorphism by local surjectivity. c1 is the
connecting homomorphism (expSeq_chernClass), exact at both joints
and surjecting onto the kernel of H2(Z) to H2(O_X). The
Lefschetz bridge (lefschetz_one_one_of_expSeq) now runs with the
abstract sequence replaced by the exponential sequence, conditional only on
the Dolbeault isomorphism and the Hodge decomposition. Byproduct: every
abelian category is balanced (in any abelian category, a monomorphism that is
also an epimorphism is an isomorphism; mathlib v4.13.0 does not provide this
instance). Build: lake build exit 0, 4584/4584 targets.
hreality (integral classes are real) is still a hypothesis.Receipt chain: 66 receipts, chain valid, head
bdebd1e7d93dd108bffe0ba01d499e603db81a8c17027bb0aad36a70f73dacdd
(verification receipt rcpt_0066). Hodge receipts:
| Receipt | What it covers |
|---|---|
| rcpt_0036 | Round 1: Lean 4.13.0 + mathlib v4.13.0, compiled; Lefschetz (1,1) proved conditionally, kernel-checked, no sorry |
| rcpt_0041 | Round 2: exponential sequence 0 to Z to C to C* to 1 proved exact at every term |
| rcpt_0047 | Round 3: sheaf O_X IS tractable, overturning the round 2 assessment; holomorphic sheaf built |
| rcpt_0051 | Round 4: degree-zero Dolbeault formalized as far as mathlib allows; d-bar derivative and type decomposition |
| rcpt_0057 | Round 5: sheaf long exact sequence WITH c1 for the actual exponential sequence, 18 theorems |
Data files: data/hodge.json,
hodge_formalization.md, hodge_r2.json,
hodge_r2.md, hodge_r3.json,
hodge_r4.json, hodge_r5.json. Lean sources:
lean/Hodge/Basic.lean, Exponential.lean,
SheafOX.lean, Dolbeault.lean,
ChernClass.lean, LongExactSequence.lean; axiom
audits in lean/axioms*.log.
The two analytic inputs, in order. First, differential forms on manifolds in Lean: without them the Dolbeault groups cannot be stated, and the isomorphism cannot even be written down. That is a mathlib-scale build, not a one-round piece. Second, the Hodge decomposition for H2. Until those exist, the honest next move is to keep formalizing the surrounding machinery that mathlib does support, and to keep the bridge theorem exactly conditional on the two named inputs, so the gap stays measured rather than assumed away.
We are writing the Hodge conjecture into Lean, the proof-checking language, one piece at a time, and checking each piece with the machine. Five rounds in, we have proved 58 small theorems with zero gaps, and we have reduced the famous (1,1) case to exactly two missing pieces: a way to compare two kinds of cohomology (Dolbeault), and the decomposition theorem that splits complex cohomology into its Hodge parts. Both are missing from the Lean math library, not just from our work. We proved everything around them, and we can now say precisely what is left.
No proof of the Hodge conjecture, no proof of the (1,1) case without assumptions, and no work at all on codimension 2 or higher. We formalized the scaffolding and measured the gap; the gap is still there, and it is exactly two named theorems wide.