# Hodge conjecture: formalization, round 2

Date: 2026-11-20. Lean 4.13.0, mathlib v4.13.0. Project: `~/workspace/millennium-lab/lean/`. New file: `Hodge/Exponential.lean` (plus `Hodge.lean` now imports it and `CheckAxioms.lean` audits the new theorems).

## Which piece was formalized

Item 6 of the round 1 gap list, the exponential sequence, at the level mathlib v4.13.0 can actually reach: the exponential sequence of abelian groups 0 -> Z -> C -> C* -> 1, proved exact at every term. The sheaf level sequence 0 -> Z -> O_X -> O_X^* -> 0 was assessed first and is NOT tractable now: mathlib has complex manifolds and Ext based sheaf cohomology (`CategoryTheory/Sites/SheafCohomology/Basic.lean`, `Sheaf.H`), but it has no sheaf of holomorphic functions O_X and no sheaf of units, so there is nothing to sheafify with and no long exact sequence to take. The group level sequence is the pointwise (stalk level) content of the sheaf sequence, and it is the analytic heart of the (1,1) case: a holomorphic function has a local logarithm exactly when it is nowhere zero, and the logarithm is ambiguous by 2 pi i Z.

## What was proved (all kernel-checked, 0 sorries)

New theorems in `Hodge/Exponential.lean`, namespace `Hodge`:

1. `expUnits_zero`: exp(0) = 1 in C*.
2. `expUnits_add`: exp(z + w) = exp(z) * exp(w); the exponential map is a homomorphism from additive C to multiplicative C*.
3. `expUnits_eq_one_iff`: exp(z) = 1 iff z = n * (2 * pi * i) for some integer n. Proved from `Complex.exp_eq_one_iff`. This is exactness at C: the kernel of exp is the image of the inclusion of Z.
4. `expUnits_surjective`: every nonzero complex number has a logarithm. Proved from `Complex.exp_log`. This is exactness at C*: the map C -> C* is onto.
5. `twoPiIIncl_injective`: the inclusion n -> 2 pi i n is injective. Exactness at Z.
6. `expSeq_exact_at_C`: exp(z) = 1 iff z is in the image of the inclusion. The kernel equals the range, stated directly.
7. `expSeq_exact`: the headline conjunction. The sequence 0 -> Z -> C -> C* -> 1 is exact at every term: injective inclusion, kernel equals range, surjective exp.
8. `lefschetz_one_one_of_exact`: the bridge lemma. It restates the long exact sequence fragment at H^2(X, Z) as exactness of the pair (c1, projection to H^{0,2}) in mathlib's `Function.Exact` sense, and derives algebraicity of every Hodge class of type (1,1) from it by applying the round 1 theorem `lefschetz_one_one`. The hypothesis `hsurj` of round 1 is now stated as exactness, and the exponential exactness proved here is the local input that exactness rests on.
9. `real_eq_of_middle_and_02`: a real vector in the Hodge decomposition is determined by its (1,1) and (0,2) components, because conjugation recovers the (2,0) component from the (0,2) component. This is the abstract form of the step that lets the reality hypothesis `hreality` turn vanishing of the (0,2) component into a Hodge class of type (1,1). It does not prove `hreality` itself.

Definitions added: `expUnits` (the exponential map C -> C*), `twoPiIIncl` (the inclusion Z -> C), `proj02` (projection of the Hodge decomposition onto the (0,2) piece as an additive group homomorphism).

## What it discharges

- The local analytic input to `hsurj` is now proved: the exponential sequence is exact as a sequence of abelian groups. Previously `hsurj` was a bare named hypothesis; now it is stated as `Function.Exact` exactness (`lefschetz_one_one_of_exact`), and the group level exactness behind it is a theorem (`expSeq_exact`).
- The role of the reality hypothesis is now pinned down abstractly: `real_eq_of_middle_and_02` shows why a real class is fixed by its (1,1) and (0,2) components. `hreality` itself (integral classes are real) is still a hypothesis of `hodge_class_iff_vanishing`, since proving it needs the Hodge decomposition, which mathlib does not have.

## What remains blocked

The unconditional (1,1) case is still conditional, and the remaining gap is now precise:

1. Sheafify the proved group level sequence: build the sheaf of holomorphic functions O_X on a complex manifold and its sheaf of units O_X^*, and show 0 -> Z -> O_X -> O_X^* -> 0 is exact as sheaves. Blocked by missing O_X in mathlib. The local logarithm existence used here (`Complex.exp_log`) is the pointwise input; the sheaf statement additionally needs holomorphic logarithms on small open sets.
2. Take the long exact sequence in sheaf cohomology and identify the connecting homomorphism with c1. Mathlib has Ext based sheaf cohomology, but the LES machinery applied to this sequence is not built.
3. Identify H^2(X, O_X) with H^{0,2}(X) (Dolbeault). Mathlib has no de Rham or Dolbeault cohomology.
4. Prove `hreality` (the Hodge decomposition for H^2, giving the real structure). Still missing item 2 of the round 1 gap list.
5. Items 1, 3, 4, 5, 7, 8, 9 of the round 1 gap list are unchanged: no singular cohomology, no cycle class map or Chow groups, no Chern classes, no Picard group, no de Rham, no GAGA, no projective morphism.

## Build result

`lake build` exits 0, 3060/3060 targets, no errors, no warnings. First attempt exited 1 with two fixable errors (`twoPiIIncl` needed `noncomputable` because it depends on `Real.pi`, and `Function.Exact` needed `import Mathlib.Algebra.Exact`); both fixed, rebuild exits 0. The first build took about 11 minutes because the new import chain (`Mathlib.Analysis.SpecialFunctions.Complex.Log`) required compiling mathlib native objects that round 1 had not built; repeat builds are fast. No changes to the toolchain or cache were needed.

## Axiom audit

`lake env lean CheckAxioms.lean`, log in `lean/axioms.log` (also `lean/axioms_r2.log`). All 13 theorems audited (4 from round 1, 9 new). None depends on `sorryAx`. The new exponential theorems depend on the standard axioms [propext, Classical.choice, Quot.sound] (the `Complex.exp` and `Complex.log` machinery uses choice); `lefschetz_one_one_of_exact` depends on [propext, Quot.sound]; `real_eq_of_middle_and_02` depends on [propext]. Sorry count in project files: 0 (the word "sorry" appears only in comments describing the absence of sorry).
