# Hodge conjecture: formalization

The Lean build completed. `lake build` in `~/workspace/millennium-lab/lean/` exits 0 with no errors, no warnings, and no `sorry` anywhere in the file. The Lean file is `~/workspace/millennium-lab/lean/Hodge/Basic.lean`, Lean 4.13.0, mathlib v4.13.0. An axiom audit (`lake env lean CheckAxioms.lean`, log in `lean/axioms.log`) confirms the four theorems depend only on the standard axiom `propext` or on no axioms at all, and none depends on `sorryAx`.

## The statement

Let X be a smooth projective variety over the complex numbers. For each codimension p, algebraic cycles of codimension p on X have a cycle class in the integral cohomology group H^{2p}(X, Z). The Hodge conjecture says that every Hodge class is algebraic: every class in H^{2p}(X, Z) whose image in complex cohomology H^{2p}(X, C) lies in the (p,p) piece of the Hodge decomposition is the cycle class of an algebraic cycle.

In the Lean file this is stated as a formal proposition, `HodgeConjecture`, over abstract data carried by the structure `HodgeData`: a family of integral cohomology groups H, a family of cycle groups, a cycle class map for each p, and a predicate marking the Hodge classes. It is a statement, not a proof. It is open for every p at least 2, and the file does not claim to prove it.

## The cycle class map

The cycle class map sends an algebraic cycle Z of codimension p to a cohomology class cl(Z) in H^{2p}(X, Z). In degree 2, the cycles are divisors, the relevant group is the Picard group Pic(X) of line bundles (or divisors modulo linear equivalence), and the cycle class map is the first Chern class map c1: Pic(X) to H^2(X, Z). In the file, `IsAlgebraic` defines a class in H^2(X, Z) to be algebraic when it lies in the image of c1, and `IsHodge11` defines a class to be a Hodge class of type (1,1) when its image in complex cohomology has vanishing (2,0) and (0,2) components.

## What a Hodge class is

Complex cohomology in degree 2 splits into Hodge pieces: H^2(X, C) = H^{2,0} plus H^{1,1} plus H^{0,2}. A class in H^2(X, Z) is a Hodge class of type (1,1) when its image in H^2(X, C) lies in the middle piece H^{1,1}, equivalently when its (2,0) and (0,2) components both vanish. The file models this split as a product of three abstract additive groups, W20 times W11 times W02, and models complex conjugation as maps between the pieces: conj20 sends H^{2,0} to H^{0,2}, conj02 sends it back, and conj11 preserves H^{1,1}. Integral classes are real, meaning fixed by conjugation.

## The Lefschetz (1,1) case, checked

The Lefschetz (1,1) theorem is the proved case of the conjecture in degree 2: every Hodge class of type (1,1) is algebraic. The file proves it as `Hodge.lefschetz_one_one`, checked by the Lean kernel with no sorry, conditional on one named hypothesis, `hsurj`: the first Chern class map surjects onto the kernel of H^2(X, Z) to H^{0,2}(X). In reality that surjectivity is the long exact sequence of the exponential sequence 0 to Z to O_X to O_X^* to 0 in sheaf cohomology.

The proof has two parts. First, the linear algebra heart, `Hodge.real_vanishing`, proved unconditionally from the definitions: a real vector whose (0,2) component vanishes also has vanishing (2,0) component, because conjugation swaps the two outer pieces. Second, the companion lemma `Hodge.hodge_class_iff_vanishing`, conditional on the reality hypothesis `hreality`, shows that for a real class the Hodge (1,1) condition is equivalent to the vanishing of the (0,2) component alone. The main theorem then applies `hsurj` to that vanishing. A fourth checked theorem, `Hodge.hodgeConj_involutive`, records that conjugation is an involution.

## What blocks the unconditional case

The (1,1) case is proved conditionally, not unconditionally, because mathlib v4.13.0 does not yet have the cohomology theory the two analytic inputs rest on. The exact blocking piece is the exponential sequence and its long exact sequence in sheaf cohomology, together with the Hodge decomposition identifying H^2(X, O_X) with H^{0,2}(X). That is what would discharge `hsurj`. The reality hypothesis `hreality` would be discharged by the Hodge decomposition theorem for H^2(X, C).

Full gap list, each item verified by searching the mathlib v4.13.0 source:

1. Singular cohomology groups H^n(X, Z) for topological spaces and complex manifolds: absent. Mathlib has `AlgebraicTopology.SingularSet` (simplicial sets) but no singular cohomology or homology groups.
2. Hodge decomposition theorem for H^n(X, C) of a smooth projective variety: absent. A grep for "hodge" over mathlib finds only an unrelated hit in ModelTheory/Fraisse.lean.
3. Cycle class map for algebraic cycles, and Chow groups: absent. No hits for "cycle class" in mathlib.
4. First Chern class of a line bundle: absent. No hits for "chern" in mathlib.
5. Weil and Cartier divisors, and the Picard group and Picard scheme: absent. No divisor files under Mathlib/AlgebraicGeometry; "picard" hits are only the Picard-Lindelof ODE theorem.
6. Exponential sequence of sheaves 0 to Z to O_X to O_X^* to 0 and its long exact sequence: absent. No hits for "exponential sequence" or "gaga" in mathlib.
7. De Rham cohomology: absent. No hits for "de rham" in mathlib.
8. GAGA, the comparison between algebraic and analytic geometry: absent.
9. Projective morphism of schemes: absent as a named notion. Mathlib/AlgebraicGeometry/Morphisms has Smooth but no Projective file; only the Proj spectrum construction exists. So "smooth projective variety" itself has no direct mathlib definition to attach the statement to.

What mathlib does have, and a future unconditional formalization can build on: abstract sheaf cohomology (`CategoryTheory.Sheaf.H`, Ext-groups on a site), complex manifolds (`Geometry.Manifold.Complex`, analytic manifolds over C), smooth morphisms of schemes, the Proj construction, and derived functors.

## Toolchain notes

Elan was installed from the GitHub-hosted installer (elan.lean-lang.org returned 404). Lean 4.13.0 was installed as the default toolchain. The mathlib cache fetch initially failed because the cache tool extracts the leantar binary with tar, and tar running as root in this container cannot change file ownership to the uid and gid recorded in the tarball; the fix was to extract leantar manually with `tar --no-same-owner` and place it at `~/.cache/mathlib/leantar-0.1.14`, after which `lake exe cache get` downloaded 5,366 files successfully. The build then compiled the needed mathlib modules from the cached oleans plus locally built native objects. Two rounds of errors in the first drafts of the Lean file were fixed: conjugation must be given as explicit maps between the Hodge pieces (a per-piece star operation cannot swap pieces), and the product instances for the additive group structure need the `Mathlib.Algebra.Group.Prod` import. Nothing in /tmp was used for the install; everything lives under the home directory.
