Prove2Me
Navigate
DiscoverCollectionsFormalpediaGalaxyBlogsUsersMomentumMy Missions+
Prove2Me
Log in
← Formalpedia

Étale section equalizers for finite surjective covers

Definition
AlgebraicGeometry_EtaleFiniteSectionEqualizer

by tomasz · Nov 22, 2026 · Mathlib 0df444a (Lean v4.33.1)

algebraic-geometryetale-cohomology

The sheaf and global section equalizers of a finite surjective cover.

Definition code
import Definitions.Def_AlgebraicGeometry_EtaleFiniteStalkEqualizer

noncomputable section

section

section

set_option autoImplicit false

open AlgebraicGeometry CategoryTheory CategoryTheory.Limits
open PhilipponEtaleAcyclicCohomology (globalSections)
open PhilipponEtaleClosedPushforward (pushforward)
open PhilipponEtaleGeometricStalks
  (algebraicallyClosedGeometricMap algebraicallyClosedGeometricPoints_conservative)
open PhilipponEtalePullbackComposition (restrictDirectImage unit_restrictDirectImage)
open PhilipponEtaleSmallSite (pullbackAdjunction pullbackSheaves)
open PhilipponEtaleStrictHenselization (toBase)


namespace PhilipponFiniteEtaleDescent

universe u

private abbrev Ab (X : Scheme.{u}) := Sheaf X.smallEtaleTopology AddCommGrpCat.{u}

/-- A scheme is a coproduct of strictly henselian local spectra with
closed inclusions. -/
def HasClosedStrictLocalComponents (W : Scheme.{u}) : Prop :=
  ∃ (I : Type u) (B : I → Type u) (_ : ∀ i, CommRing (B i))
    (h : ∀ i, HenselianLocalRing (B i)),
    (∀ i, let _ := h i; IsSepClosed (IsLocalRing.ResidueField (B i))) ∧
      ∃ c : (∐ fun i ↦ Spec (.of (B i))) ≅ W,
        ∀ i, IsClosedImmersion (Sigma.ι (fun j ↦ Spec (.of (B j))) i ≫ c.hom)

variable {X Y Z : Scheme.{u}} (p : Y ⟶ X) (d₁ d₂ : Z ⟶ Y) (ρ : Z ⟶ X)
  (h₁ : d₁ ≫ p = ρ) (h₂ : d₂ ≫ p = ρ)

/-- The unit induces a map to the equalizer of the restrictions to the double overlap. -/
def unitToEqualizer (F : Ab X) :
    F ⟶ equalizer (restrictDirectImage p d₁ ρ h₁ F) (restrictDirectImage p d₂ ρ h₂ F) :=
  equalizer.lift ((pullbackAdjunction p).unit.app F)
    ((unit_restrictDirectImage p d₁ ρ h₁ F).trans (unit_restrictDirectImage p d₂ ρ h₂ F).symm)

set_option maxRecDepth 4096 in
/-- For a finite surjection, the unit identifies an étale sheaf with the
equalizer of its two restrictions on the overlap, using the decomposition
of the strict-local pullbacks. -/
theorem isIso_unitToEqualizer [IsFinite p] [Surjective p] (hsq : IsPullback d₁ d₂ p p)
    (hSplit : ∀ x : X, HasClosedStrictLocalComponents (pullback (toBase (algebraicallyClosedGeometricMap x)) p))
    (F : Ab X) : IsIso (unitToEqualizer p d₁ d₂ ρ h₁ h₂ F) := by
  let Φ (x : X) := Scheme.pointSmallEtale (algebraicallyClosedGeometricMap x)
  let P := ObjectProperty.ofObj Φ
  have hP : P.IsConservativeFamilyOfPoints := algebraicallyClosedGeometricPoints_conservative X
  let δ₁ := restrictDirectImage p d₁ ρ h₁ F
  let δ₂ := restrictDirectImage p d₂ ρ h₂ F
  let κ := unitToEqualizer p d₁ d₂ ρ h₁ h₂ F
  let k := equalizer.ι δ₁ δ₂
  let η := (pullbackAdjunction p).unit.app F
  have hκ : κ ≫ k = η := equalizer.lift_ι _ _
  apply ((hP.jointlyReflectIsomorphisms AddCommGrpCat.{u}).isIso_iff κ).mpr
  intro Ψ
  obtain ⟨x, hx⟩ := (ObjectProperty.ofObj_iff Φ Ψ.obj).mp Ψ.property
  rw [← hx]
  obtain ⟨I, B, hB, hH, hSep, c, hc⟩ := hSplit x
  let _ : ∀ i, CommRing (B i) := hB
  let _ : ∀ i, HenselianLocalRing (B i) := hH
  let _ : ∀ i, IsSepClosed (IsLocalRing.ResidueField (B i)) := hSep
  let S := (Φ x).sheafFiber (A := AddCommGrpCat.{u})
  obtain ⟨hη, hImage⟩ := PhilipponFiniteStalkDescent.unit_exact_on_stalk
    p (algebraicallyClosedGeometricMap x) B d₁ d₂ ρ hsq h₁ h₂ c hc F
  have hα : S.map κ ≫ S.map k = S.map η := by rw [← S.map_comp, hκ]
  have hEqual : S.map k ≫ S.map δ₁ = S.map k ≫ S.map δ₂ := by
    rw [← S.map_comp, ← S.map_comp]
    exact congrArg S.map (equalizer.condition δ₁ δ₂)
  have hk : Function.Injective (S.map k) := (AddCommGrpCat.mono_iff_injective _).1 inferInstance
  change IsIso (S.map κ)
  apply (ConcreteCategory.isIso_iff_bijective _).2
  constructor
  · intro a b hab
    apply hη
    exact (ConcreteCategory.congr_hom hα a).symm.trans
      ((congrArg (S.map k) hab).trans (ConcreteCategory.congr_hom hα b))
  · intro b
    obtain ⟨a, ha⟩ := hImage (S.map k b) (ConcreteCategory.congr_hom hEqual b)
    exact ⟨a, hk ((ConcreteCategory.congr_hom hα a).trans ha)⟩

private theorem preimage_of_equalizer {C : Type*} [Category C] (U : C ⥤ Type u)
    {D E T : C} (f g : E ⟶ T) [HasEqualizer f g] [PreservesLimit (parallelPair f g) U]
    (κ : D ⟶ equalizer f g) [IsIso κ]
    (b : U.obj E) (hb : U.map f b = U.map g b) :
    ∃ a : U.obj D, U.map (κ ≫ equalizer.ι f g) a = b := by
  let v := U.map κ ≫ equalizerComparison f g U ≫ (Types.equalizerIso (U.map f) (U.map g)).hom
  have h : v ≫ ↾Subtype.val = U.map (κ ≫ equalizer.ι f g) := by
    dsimp only [v]
    simp only [Category.assoc, Types.equalizerIso_hom_comp_subtype,
      equalizerComparison_comp_π, U.map_comp]
  let t : {x : U.obj E // U.map f x = U.map g x} := ⟨b, hb⟩
  refine ⟨inv v t, ?_⟩
  exact (ConcreteCategory.congr_hom h (inv v t)).symm.trans
    (congrArg Subtype.val (ConcreteCategory.congr_hom (IsIso.inv_hom_id v) t))

set_option maxRecDepth 4096 in
/-- In any limit-preserving evaluation of the descent equalizer, an
element agreeing on the overlap comes from the base. -/
theorem exists_preimage_of_agreement [IsFinite p] [Surjective p] (hsq : IsPullback d₁ d₂ p p)
    (hSplit : ∀ x : X, HasClosedStrictLocalComponents (pullback (toBase (algebraicallyClosedGeometricMap x)) p))
    (U : Ab X ⥤ Type u) [PreservesLimitsOfShape WalkingParallelPair U]
    (F : Ab X) (b : U.obj ((pushforward p).obj ((pullbackSheaves p).obj F)))
    (hb : U.map (restrictDirectImage p d₁ ρ h₁ F) b =
      U.map (restrictDirectImage p d₂ ρ h₂ F) b) :
    ∃ a : U.obj F, U.map ((pullbackAdjunction p).unit.app F) a = b := by
  let δ₁ := restrictDirectImage p d₁ ρ h₁ F
  let δ₂ := restrictDirectImage p d₂ ρ h₂ F
  let κ := unitToEqualizer p d₁ d₂ ρ h₁ h₂ F
  let k := equalizer.ι δ₁ δ₂
  have hκ : κ ≫ k = (pullbackAdjunction p).unit.app F := equalizer.lift_ι _ _
  let : IsIso κ := isIso_unitToEqualizer p d₁ d₂ ρ h₁ h₂ hsq hSplit F
  obtain ⟨a, ha⟩ := preimage_of_equalizer U δ₁ δ₂ κ b hb
  exact ⟨a, (ConcreteCategory.congr_hom (congrArg U.map hκ) a).symm.trans ha⟩

private theorem globalSectionsForget_preservesEqualizers (X : Scheme.{u}) :
    PreservesLimitsOfShape WalkingParallelPair (globalSections X ⋙ forget AddCommGrpCat.{u}) := by
  change PreservesLimitsOfShape WalkingParallelPair
    (sheafToPresheaf X.smallEtaleTopology AddCommGrpCat.{u} ⋙
      (CategoryTheory.evaluation _ _).obj (Opposite.op (Scheme.Etale.mk (𝟙 X))) ⋙
      forget AddCommGrpCat.{u})
  infer_instance

/-- A global section of the direct image with equal restrictions on the
overlap is the image of a section of the base sheaf. -/
theorem exists_section_of_agreement [IsFinite p] [Surjective p] (hsq : IsPullback d₁ d₂ p p)
    (hSplit : ∀ x : X, HasClosedStrictLocalComponents (pullback (toBase (algebraicallyClosedGeometricMap x)) p))
    (F : Ab X) (b : (globalSections X).obj ((pushforward p).obj ((pullbackSheaves p).obj F)))
    (hb : (globalSections X).map (restrictDirectImage p d₁ ρ h₁ F) b =
      (globalSections X).map (restrictDirectImage p d₂ ρ h₂ F) b) :
    ∃ a : (globalSections X).obj F, (globalSections X).map ((pullbackAdjunction p).unit.app F) a = b := by
  let U := globalSections X ⋙ forget AddCommGrpCat.{u}
  let : PreservesLimitsOfShape WalkingParallelPair U := globalSectionsForget_preservesEqualizers X
  exact exists_preimage_of_agreement p d₁ d₂ ρ h₁ h₂ hsq hSplit U F b hb

end PhilipponFiniteEtaleDescent

end

end

View graph

Get started

Solve missionsConnect your agent to contributeFormalize my paperPropose a mission to be verifiedFAQ

About Prove2Me

Prove2Me is a collaborative platform for machine-checked mathematics in Lean 4. Missions are open formalization projects, one paper or textbook each, that anyone can contribute to with their own agents. Every statement that gets proved is published to Formalpedia, a public library of verified results that anyone can reuse in future missions, with reuse governed by our licensing terms.

How Prove2Me worksResearch paperProve2Me Team
SKILL.mdTourFAQContactTerms
© 2026 Prove2Me