Millennium Problems / 04

Hodge conjecture

Formalized in Lean, piece by piece: 58 theorems, 0 sorries, and the Lefschetz (1,1) case reduced to exactly two named missing inputs.

Program
The Millennium Lab
Rounds
1, 2, 3, 4, 5
Theorems
58 checked
Sorries
0
Receipts
66, head bdebd1e7
Date
Nov 20-21, 2026
Status
NOT SOLVED
Toolchain
Lean 4.13.0, mathlib v4.13.0
NOT SOLVED. Nothing on this page solves the problem, proves it, or disproves it. This is research: measurements, rejections, and partial formalizations, each with a receipt. The problem belongs to the mathematicians who stated it and the researchers who have worked it for decades. This program adds a small computational exploration on top of their work and claims no credit for theirs.

01The problem, in plain words

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.

02What the lab actually ran

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.

RoundFileNew theorems CheckedBuildPiece formalized
1 (Nov 20)Hodge/Basic.lean44 compiledStatement, Lefschetz (1,1) conditional on hsurj and hreality
2 (Nov 20)Hodge/Exponential.lean99 3060/3060Exponential sequence of abelian groups 0 to Z to C to C* to 1, exact at every term
3 (Nov 20-21)Hodge/SheafOX.lean1313 3842/3842Sheaf of holomorphic functions O_X and its sheaf of units O_X*
4 (Nov 20-21)Hodge/Dolbeault.lean1423 1497/1497 module, 4550 fullDegree-zero Dolbeault, as far as mathlib allows; c1 construction recovered and re-verified
5 (Nov 21)Hodge/LongExactSequence.lean1818 4584/4584Sheaf 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.

51015204Round 14 checked9Round 29 checked13Round 313 checked14Round 423 checked18Round 518 checkednew theorems proved, 0 sorries
Figure 1. New theorems proved per round, all with 0 sorries: 4, 9, 13, 14, 18. Round 4 also re-verified 9 recovered ChernClass theorems, so 23 were checked that round. Computed from hodge.json, hodge_r2.json, hodge_r3.json, hodge_r4.json, hodge_r5.json.
The exponential sequence of sheaves (proved short exact, round 5)0ZO_XO_X*0incl. 2pi i nexpIts long exact sequence in sheaf cohomology, with c1 as the connecting map (proved, round 5)H^1(X, O_X*)H^2(X, Z)H^2(X, O_X)H^{0,2}(X)c1, exact at both joints, surjects onto kernelinduced by inclusionBLOCKEDStill blocked: the two analytic inputs the Lefschetz bridge needs(1) Dolbeault isomorphism H^q(X, O_X) = H^{0,q}(X). Cannot be stated: mathlib v4.13.0 has nodifferential forms on manifolds, no exterior derivative, no de Rham or Dolbeault cohomology.(2) Hodge decomposition for H^2(X, C), which would discharge hreality and identify H^2(X, O_X)with H^{0,2}(X). Both verified absent by fresh mathlib searches in round 4.
Figure 2. The exponential sequence and its long exact sequence, as formalized. The top row is the short exact sequence of sheaves 0 to Z to O_X to O_X* to 0, proved short exact in round 5. The bottom row is its long exact sequence in sheaf cohomology, with c1 as the connecting homomorphism, exact at both joints and surjecting onto the kernel of H2(Z) to H2(O_X). The identification of H2(X, O_X) with H0,2(X) is the blocked Dolbeault isomorphism, marked red. Structure from hodge_r5.json and hodge_formalization.md.

03Round by round

Round 1: the statement, and the conditional Lefschetz (1,1)

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.

Round 2: the exponential sequence, at the group level

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.

Round 3: O_X is tractable, the round 2 assessment was wrong

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.

Round 4: degree-zero Dolbeault, as far as mathlib allows

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.

Round 5: the sheaf long exact sequence, for the actual sequence

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.

04What we found

05Limits and blind spots

06Receipts

Receipt chain: 66 receipts, chain valid, head bdebd1e7d93dd108bffe0ba01d499e603db81a8c17027bb0aad36a70f73dacdd (verification receipt rcpt_0066). Hodge receipts:

ReceiptWhat it covers
rcpt_0036Round 1: Lean 4.13.0 + mathlib v4.13.0, compiled; Lefschetz (1,1) proved conditionally, kernel-checked, no sorry
rcpt_0041Round 2: exponential sequence 0 to Z to C to C* to 1 proved exact at every term
rcpt_0047Round 3: sheaf O_X IS tractable, overturning the round 2 assessment; holomorphic sheaf built
rcpt_0051Round 4: degree-zero Dolbeault formalized as far as mathlib allows; d-bar derivative and type decomposition
rcpt_0057Round 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.

07Next attack

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.

08What we found, in plain language

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.

09What we did not find

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.

The Millennium Lab. Research pages, November 2026. All numbers trace to the lab data files; every receipt is listed on the page. Nothing solved.