Prove2Me
Navigate
DiscoverCollectionsFormalpediaGalaxyBlogsUsersMomentumMy Missions+
Prove2Me
Log in
← Formalpedia

Sections and direct image over a closed immersion

Definition
AlgebraicGeometry_EtaleClosedImmersionSections

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

algebraic-geometryetale-cohomology

Étale lifting through thickenings, full faithfulness for closed direct images, and restriction of global sections.

Definition code
import Definitions.Def_AlgebraicGeometry_EtaleModeledCech
import Definitions.Def_AlgebraicGeometry_EtalePullbackAcyclicResolution
import Mathlib
import Mathlib.AlgebraicGeometry.IdealSheaf.Subscheme
import Mathlib.AlgebraicGeometry.Limits
import Mathlib.AlgebraicGeometry.Morphisms.Etale
import Mathlib.AlgebraicGeometry.Morphisms.Finite
import Mathlib.AlgebraicGeometry.Morphisms.FlatMono
import Mathlib.AlgebraicGeometry.Morphisms.Proper
import Mathlib.AlgebraicGeometry.Morphisms.UniversallyOpen
import Mathlib.AlgebraicGeometry.Scheme
import Mathlib.AlgebraicGeometry.Sites.Etale
import Mathlib.AlgebraicGeometry.Sites.EtalePoint
import Mathlib.CategoryTheory.Abelian.Exact
import Mathlib.CategoryTheory.Abelian.GrothendieckCategory.HasExt
import Mathlib.CategoryTheory.Adjunction.FullyFaithful
import Mathlib.CategoryTheory.Adjunction.Unique
import Mathlib.CategoryTheory.Limits.Types.Equalizers
import Mathlib.CategoryTheory.Sites.EpiMono
import Mathlib.CategoryTheory.Sites.Point.Skyscraper
import Mathlib.CategoryTheory.Sites.PreservesLimits
import Mathlib.CategoryTheory.Sites.SheafCohomology.Basic
import Mathlib.FieldTheory.IsAlgClosed.AlgebraicClosure
import Mathlib.FieldTheory.IsAlgClosed.Basic
import Mathlib.FieldTheory.PurelyInseparable.Basic
import Mathlib.RingTheory.Henselian
import Mathlib.RingTheory.Ideal.GoingUp
import Mathlib.RingTheory.Idempotents
import Mathlib.RingTheory.LocalRing.MaximalIdeal.Basic
import Mathlib.RingTheory.Spectrum.Prime.Topology
import Mathlib.RingTheory.Unramified.LocalStructure
import Mathlib.Topology.LocallyConstant.Basic
import Mathlib.Topology.Sheaves.Functors
import Mathlib.Topology.Sheaves.SheafCondition.UniqueGluing
import Mathlib.Topology.Sheaves.Sheafify
import Mathlib.Topology.Sheaves.Stalks
import Mathlib.Topology.Spectral.ConstructibleTopology
import Theorems.Thm_AlgebraicGeometry_Scheme_exists_finite_zariski_refinement_of_surjective_etale

noncomputable section

section

section

set_option autoImplicit false
set_option backward.isDefEq.respectTransparency false

open AlgebraicGeometry CategoryTheory CategoryTheory.Limits ZeroObject


namespace PhilipponEtaleGeometricStalks

universe u

/-- An algebraically closed geometric point over the given scheme point. -/
def algebraicallyClosedGeometricMap {X : Scheme.{u}} (x : X) :
    Spec (CommRingCat.of (AlgebraicClosure (X.residueField x))) ⟶ X :=
  (Scheme.SpecToEquivOfField (AlgebraicClosure (X.residueField x)) X).2
    ⟨x, CommRingCat.ofHom (algebraMap (X.residueField x) _)⟩

@[simp] theorem algebraicallyClosedGeometricMap_apply {X : Scheme.{u}} (x : X) :
    algebraicallyClosedGeometricMap x default = x := by
  simp [algebraicallyClosedGeometricMap, Scheme.SpecToEquivOfField]

/-- Stalks at the algebraic closures of the residue fields detect
isomorphisms of étale sheaves. -/
theorem algebraicallyClosedGeometricPoints_conservative (X : Scheme.{u}) :
    (ObjectProperty.ofObj (fun x : X => Scheme.pointSmallEtale
      (algebraicallyClosedGeometricMap x))).IsConservativeFamilyOfPoints := by
  apply Scheme.isConservative_pointSmallEtale
  ext x
  simp only [Set.mem_iUnion, Set.mem_range, Set.mem_univ, iff_true]
  exact ⟨x, default, algebraicallyClosedGeometricMap_apply x⟩

end PhilipponEtaleGeometricStalks

end

section

set_option autoImplicit false

open AlgebraicGeometry CategoryTheory CategoryTheory.Limits Opposite
open PhilipponEtaleGeometricStalks (geometricMap geometricMap_apply geometricPoint)


namespace PhilipponEtaleClosedFiberCovers

universe u

variable {R : Type u} [CommRing R] [IsLocalRing R] {Y : Scheme.{u}}

/-- Each point closure in a proper scheme over a local ring meets the
closed fiber. -/
theorem closedFiber_inter_closure_nonempty (f : Y ⟶ Spec (CommRingCat.of R)) [IsProper f]
    (y : Y) :
    (f ⁻¹' {IsLocalRing.closedPoint R} ∩ closure ({y} : Set Y)).Nonempty := by
  have hc : IsClosed (f '' closure ({y} : Set Y)) := f.isClosedMap _ isClosed_closure
  have hy : f y ∈ f '' closure ({y} : Set Y) := ⟨y, subset_closure rfl, rfl⟩
  obtain ⟨z, hz, he⟩ := (IsLocalRing.specializes_closedPoint (f y)).mem_closed hc hy
  exact ⟨z, Set.mem_singleton_iff.mpr he, hz⟩

/-- An open subset of a scheme proper over a local ring contains the whole
scheme if it contains the fiber over the closed point. -/
theorem eq_univ_of_contains_closedFiber (f : Y ⟶ Spec (CommRingCat.of R)) [IsProper f]
    {U : Set Y} (hU : IsOpen U)
    (h : f ⁻¹' {IsLocalRing.closedPoint R} ⊆ U) : U = Set.univ := by
  have hClosed : IsClosed (f '' Uᶜ) := f.isClosedMap _ hU.isClosed_compl
  have hc : IsLocalRing.closedPoint R ∈ (f '' Uᶜ)ᶜ := by
    rintro ⟨y, hy, hyc⟩
    exact hy (h (Set.mem_singleton_iff.mpr hyc))
  apply Set.eq_univ_of_forall
  intro y
  by_contra hy
  have hy' : f y ∈ (f '' Uᶜ)ᶜ :=
    (IsLocalRing.specializes_closedPoint (f y)).mem_open hClosed.isOpen_compl hc
  exact hy' ⟨y, hy, rfl⟩

/-- A family of étale maps to a scheme proper over a local ring is a cover
as soon as its image contains the fiber over the closed point. -/
theorem covering_of_contains_closedFiber (f : Y ⟶ Spec (CommRingCat.of R)) [IsProper f]
    {ι : Type u} (V : ι → Y.Etale)
    (g : ∀ a, V a ⟶ Scheme.Etale.mk (𝟙 Y))
    (h : f ⁻¹' {IsLocalRing.closedPoint R} ⊆ ⋃ a, Set.range (g a).left) :
    Sieve.ofArrows V g ∈ Y.smallEtaleTopology (Scheme.Etale.mk (𝟙 Y)) := by
  apply (Scheme.ofArrows_mem_smallEtaleTopology_iff g).mpr
  exact eq_univ_of_contains_closedFiber f
    (isOpen_iUnion fun a => (g a).left.isOpenMap.isOpen_range) h

private abbrev terminalChart (Y : Scheme.{u}) := Scheme.Etale.mk (𝟙 Y)

private def terminalPoint (y : Y) : (geometricPoint y).fiber.obj (terminalChart Y) :=
  Over.homMk (geometricMap y) (Category.comp_id _)

/-- Global sections of an étale sheaf on a proper scheme over a local ring
are determined by their germs along the closed fiber. -/
theorem globalSections_eq_of_germs_eq_along_closedFiber
    (f : Y ⟶ Spec (CommRingCat.of R)) [IsProper f]
    (F : Sheaf Y.smallEtaleTopology AddCommGrpCat.{u})
    (a b : ↥(F.obj.obj (op (terminalChart Y))))
    (h : ∀ y : Y, f y = IsLocalRing.closedPoint R →
      (geometricPoint y).toPresheafFiber (terminalChart Y) (terminalPoint y) F.obj a =
        (geometricPoint y).toPresheafFiber (terminalChart Y) (terminalPoint y) F.obj b) :
    a = b := by
  classical
  let T := terminalChart Y
  let S := Presheaf.equalizerSieve (F := F.obj) (X := op T) a b
  have hRefine (y : Y) (hy : f y = IsLocalRing.closedPoint R) :
      ∃ (V : Y.Etale) (g : V ⟶ T), S g ∧ y ∈ Set.range g.left := by
    obtain ⟨V, g, t, ht, he⟩ :=
      ((geometricPoint y).toPresheafFiber_eq_iff' T (terminalPoint y) a b).mp (h y hy)
    have hcomp : t.left ≫ g.left = geometricMap y :=
      congrArg Over.Hom.left ht
    let z : Spec (CommRingCat.of (SeparableClosure (Y.residueField y))) := default
    refine ⟨V, g, he, t.left z, ?_⟩
    let k : V.left ⟶ Y := g.left
    change k (t.left z) = y
    calc
      k (t.left z) = (t.left ≫ k) z := (Scheme.Hom.comp_apply _ _ _).symm
      _ = geometricMap y z := congrArg (fun m : _ ⟶ Y => m z) hcomp
      _ = y := geometricMap_apply y
  let Q := {y : Y // f y = IsLocalRing.closedPoint R}
  choose V g hg hy using fun y : Q => hRefine y.val y.property
  have hCover := covering_of_contains_closedFiber f V g (fun y hy' =>
    Set.mem_iUnion.mpr ⟨⟨y, hy'⟩, hy ⟨y, hy'⟩⟩)
  have hS : S ∈ Y.smallEtaleTopology T :=
    Y.smallEtaleTopology.superset_covering
      ((Sieve.generate_le_iff _ _).mpr (by
        rintro _ _ ⟨j⟩
        exact hg j)) hCover
  have hSheaf := Presheaf.isSheaf_comp_of_isSheaf Y.smallEtaleTopology F.obj
    (CategoryTheory.forget AddCommGrpCat) F.property
  exact ((isSheaf_iff_isSheaf_of_type _ _).mp hSheaf _ hS).isSeparatedFor.ext
    (fun _ _ hab => hab)

end PhilipponEtaleClosedFiberCovers

end

section

set_option autoImplicit false
set_option maxHeartbeats 850000
set_option linter.style.haveILetI false

open AlgebraicGeometry CategoryTheory CategoryTheory.Limits Opposite TopologicalSpace
open Polynomial
open scoped TensorProduct


namespace PhilipponEtaleThickeningLifts

universe u

/- The local algebra and scheme lifting arguments are adapted from the
Prove2Me Fermat's Last Theorem development. The chartwise nilpotence argument
uses local Noetherianity and surjectivity of the closed immersion. -/
private theorem eq_of_comp_eq_of_surjective {X Y T T₀ : Scheme.{u}} (q : Y ⟶ X)
    [FormallyUnramified q] [LocallyOfFiniteType q]
    (k : T₀ ⟶ T) [Surjective k] {s₁ s₂ : T ⟶ Y}
    (hq : s₁ ≫ q = s₂ ≫ q) (hk : k ≫ s₁ = k ≫ s₂) : s₁ = s₂ := by

  haveI : IsOpenImmersion (pullback.diagonal q) := inferInstance
  haveI : IsOpenImmersion (pullback.fst (pullback.lift s₁ s₂ hq) (pullback.diagonal q)) := inferInstance

  have hfac : k ≫ pullback.lift s₁ s₂ hq = (k ≫ s₁) ≫ pullback.diagonal q := by
    apply pullback.hom_ext
    · simp only [Category.assoc, pullback.lift_fst, pullback.diagonal_fst, Category.comp_id]
    · simp only [Category.assoc, pullback.lift_snd, pullback.diagonal_snd, Category.comp_id, hk]
  have hk' : pullback.lift k (k ≫ s₁) hfac ≫ pullback.fst (pullback.lift s₁ s₂ hq) (pullback.diagonal q) = k :=
    pullback.lift_fst _ _ _
  haveI : Surjective (pullback.lift k (k ≫ s₁) hfac ≫
      pullback.fst (pullback.lift s₁ s₂ hq) (pullback.diagonal q)) := by rw [hk']; infer_instance
  haveI : Surjective (pullback.fst (pullback.lift s₁ s₂ hq) (pullback.diagonal q)) :=
    Surjective.of_comp (pullback.lift k (k ≫ s₁) hfac) _
  haveI : IsIso (pullback.fst (pullback.lift s₁ s₂ hq) (pullback.diagonal q)) :=
    (isIso_iff_isOpenImmersion_and_surjective _).mpr ⟨inferInstance, inferInstance⟩

  have hp : pullback.lift s₁ s₂ hq =
      inv (pullback.fst (pullback.lift s₁ s₂ hq) (pullback.diagonal q)) ≫
        pullback.snd (pullback.lift s₁ s₂ hq) (pullback.diagonal q) ≫ pullback.diagonal q := by
    rw [← pullback.condition, IsIso.inv_hom_id_assoc]
  have h1 : s₁ = inv (pullback.fst (pullback.lift s₁ s₂ hq) (pullback.diagonal q)) ≫
      pullback.snd (pullback.lift s₁ s₂ hq) (pullback.diagonal q) := by
    calc s₁ = pullback.lift s₁ s₂ hq ≫ pullback.fst q q := (pullback.lift_fst _ _ _).symm
      _ = (inv (pullback.fst (pullback.lift s₁ s₂ hq) (pullback.diagonal q)) ≫
            pullback.snd (pullback.lift s₁ s₂ hq) (pullback.diagonal q) ≫ pullback.diagonal q) ≫
              pullback.fst q q := by rw [← hp]
      _ = _ := by simp only [Category.assoc, pullback.diagonal_fst, Category.comp_id]
  have h2 : s₂ = inv (pullback.fst (pullback.lift s₁ s₂ hq) (pullback.diagonal q)) ≫
      pullback.snd (pullback.lift s₁ s₂ hq) (pullback.diagonal q) := by
    calc s₂ = pullback.lift s₁ s₂ hq ≫ pullback.snd q q := (pullback.lift_snd _ _ _).symm
      _ = (inv (pullback.fst (pullback.lift s₁ s₂ hq) (pullback.diagonal q)) ≫
            pullback.snd (pullback.lift s₁ s₂ hq) (pullback.diagonal q) ≫ pullback.diagonal q) ≫
              pullback.snd q q := by rw [← hp]
      _ = _ := by simp only [Category.assoc, pullback.diagonal_snd, Category.comp_id]
  rw [h1, ← h2]

private theorem affine_kernel_nilpotent {T T₀ : Scheme.{u}} [IsLocallyNoetherian T]
    (k : T₀ ⟶ T) [IsClosedImmersion k] [Surjective k] (U : T.affineOpens) :
    IsNilpotent (RingHom.ker (k.app U.val).hom) := by
  have hsupport : k.ker.support = ⊤ := by
    ext1
    rw [Scheme.Hom.support_ker, k.surjective.range_eq]
    simp
  have hle := Scheme.IdealSheafData.le_radical k.ker
  rw [← Scheme.IdealSheafData.vanishingIdeal_support, hsupport,
    Scheme.IdealSheafData.vanishingIdeal_top] at hle
  have hU := hle U
  rw [Scheme.Hom.ker_apply] at hU
  haveI := IsLocallyNoetherian.component_noetherian U
  exact (Ideal.FG.isNilpotent_iff_le_nilradical (IsNoetherian.noetherian _)).mpr hU

private theorem exists_of_forall_exists_nhd {X Y T T₀ : Scheme.{u}} (q : Y ⟶ X)
    [FormallyUnramified q] [LocallyOfFiniteType q]
    (k : T₀ ⟶ T) [Surjective k] (t : T ⟶ X) (s₀ : T₀ ⟶ Y)
    (H : ∀ p : T, ∃ (U : T.Opens) (_ : p ∈ U) (sU : (U : Scheme.{u}) ⟶ Y),
      sU ≫ q = U.ι ≫ t ∧ (k ∣_ U) ≫ sU = (k ⁻¹ᵁ U).ι ≫ s₀) :
    ∃ s : T ⟶ Y, s ≫ q = t ∧ k ≫ s = s₀ := by
  choose U hpU sU hsUq hsUk using H
  let 𝒰 : T.OpenCover :=
    { I₀ := T, X := fun i => (U i), f := fun i => (U i).ι,
      mem₀ := by
        rw [Scheme.presieve₀_mem_precoverage_iff]
        refine ⟨fun x ↦ ⟨x, by simpa using hpU x⟩, inferInstance⟩ }

  have hcompat : ∀ i j : T, pullback.fst (𝒰.f i) (𝒰.f j) ≫ sU i = pullback.snd (𝒰.f i) (𝒰.f j) ≫ sU j := by
    intro i j
    let g : pullback (𝒰.f i) (𝒰.f j) ⟶ T := pullback.fst (𝒰.f i) (𝒰.f j) ≫ (U i).ι
    have hg : pullback.snd (𝒰.f i) (𝒰.f j) ≫ (U j).ι = g := (pullback.condition).symm

    have key : ∀ (l : T) (m : pullback (𝒰.f i) (𝒰.f j) ⟶ (U l : Scheme.{u})) (hm : m ≫ (U l).ι = g),
        pullback.snd k g ≫ m ≫ sU l = pullback.fst k g ≫ s₀ := by
      intro l m hm
      have w : (pullback.snd k g ≫ m) ≫ (U l).ι = pullback.fst k g ≫ k := by
        rw [Category.assoc, hm, pullback.condition]
      let n := (isPullback_morphismRestrict k (U l)).lift (pullback.snd k g ≫ m) (pullback.fst k g) w
      have hn1 : n ≫ (k ∣_ U l) = pullback.snd k g ≫ m := IsPullback.lift_fst _ _ _ _
      have hn2 : n ≫ (k ⁻¹ᵁ U l).ι = pullback.fst k g := IsPullback.lift_snd _ _ _ _
      rw [← Category.assoc, ← hn1, Category.assoc, hsUk, ← Category.assoc, hn2]
    haveI : Surjective (pullback.snd k g) := inferInstance
    refine eq_of_comp_eq_of_surjective q (pullback.snd k g) ?_ ?_
    · rw [Category.assoc, hsUq, Category.assoc, hsUq, ← Category.assoc, ← Category.assoc, pullback.condition]
    · rw [key i (pullback.fst (𝒰.f i) (𝒰.f j)) rfl, key j (pullback.snd (𝒰.f i) (𝒰.f j)) hg]
  refine ⟨𝒰.glueMorphisms sU hcompat, ?_, ?_⟩
  · refine Scheme.Cover.hom_ext 𝒰 _ _ fun i ↦ ?_
    rw [Scheme.Cover.ι_glueMorphisms_assoc, hsUq]
  ·
    let 𝒱 : T₀.OpenCover :=
      { I₀ := T, X := fun i => (k ⁻¹ᵁ U i), f := fun i => (k ⁻¹ᵁ U i).ι,
        mem₀ := by
          rw [Scheme.presieve₀_mem_precoverage_iff]
          refine ⟨fun x ↦ ⟨k.base x, by simpa using hpU (k.base x)⟩, inferInstance⟩ }
    refine Scheme.Cover.hom_ext 𝒱 _ _ fun i ↦ ?_
    show (k ⁻¹ᵁ U i).ι ≫ k ≫ 𝒰.glueMorphisms sU hcompat = (k ⁻¹ᵁ U i).ι ≫ s₀
    rw [← morphismRestrict_ι_assoc, show (U i).ι = 𝒰.f i from rfl, Scheme.Cover.ι_glueMorphisms, hsUk]

private theorem appLE_congr_hom {X Y : Scheme.{u}} {f g : X ⟶ Y} (h : f = g) (U : Y.Opens) (V : X.Opens)
    (e : V ≤ f ⁻¹ᵁ U) (e' : V ≤ g ⁻¹ᵁ U) : f.appLE U V e = g.appLE U V e' := by
  subst h; rfl

private theorem exists_nhd_lift {X Y T T₀ : Scheme.{u}} (q : Y ⟶ X) [Etale q]
    (k : T₀ ⟶ T) [IsClosedImmersion k] [Surjective k] [IsLocallyNoetherian T]
    (t : T ⟶ X) (s₀ : T₀ ⟶ Y) (hs₀ : s₀ ≫ q = k ≫ t) (p : T) :
    ∃ (U : T.Opens) (_ : p ∈ U) (sU : (U : Scheme.{u}) ⟶ Y),
      sU ≫ q = U.ι ≫ t ∧ (k ∣_ U) ≫ sU = (k ⁻¹ᵁ U).ι ≫ s₀ := by
  obtain ⟨p₀, hp₀⟩ := k.surjective p

  obtain ⟨_, ⟨R', hR', rfl⟩, hpR', -⟩ :=
    X.isBasis_affineOpens.exists_subset_of_mem_open (Set.mem_univ (t.base p)) isOpen_univ

  have hqs : q.base (s₀.base p₀) = t.base p := by
    have := congrArg (fun f : T₀ ⟶ X => f.base p₀) hs₀
    simpa [hp₀] using this
  have hy : s₀.base p₀ ∈ q ⁻¹ᵁ R' := by
    show q.base (s₀.base p₀) ∈ R'
    rw [hqs]; exact hpR'
  obtain ⟨_, ⟨W, hW, rfl⟩, hyW, hWR'⟩ :=
    Y.isBasis_affineOpens.exists_subset_of_mem_open hy (q ⁻¹ᵁ R').isOpen
  change W ≤ q ⁻¹ᵁ R' at hWR'

  let O : T.Opens := ⟨(k.base '' ((s₀ ⁻¹ᵁ W : T₀.Opens) : Set T₀)ᶜ)ᶜ, by
    rw [isOpen_compl_iff]
    exact k.isClosedEmbedding.isClosedMap _ (isClosed_compl_iff.mpr (s₀ ⁻¹ᵁ W).isOpen)⟩
  have hpO : p ∈ O := by
    rintro ⟨x, hx, hxp⟩
    apply hx
    have : x = p₀ := k.isClosedEmbedding.injective (hxp.trans hp₀.symm)
    subst this
    exact hyW

  obtain ⟨_, ⟨U, hU, rfl⟩, hpU, hUle⟩ := T.isBasis_affineOpens.exists_subset_of_mem_open
    (show p ∈ ((t ⁻¹ᵁ R' ⊓ O : T.Opens) : Set T) from ⟨hpR', hpO⟩) (t ⁻¹ᵁ R' ⊓ O).isOpen
  have hUR' : U ≤ t ⁻¹ᵁ R' := fun x hx => (hUle hx).1
  have hkUW : k ⁻¹ᵁ U ≤ s₀ ⁻¹ᵁ W := by
    intro x hx
    by_contra hxW
    exact (hUle hx).2 ⟨x, hxW, rfl⟩
  have hkU : IsAffineOpen (k ⁻¹ᵁ U) := hU.preimage k
  have hkUR' : k ⁻¹ᵁ U ≤ (k ≫ t) ⁻¹ᵁ R' := fun x hx => hUR' hx

  have hφ : (q.appLE R' W hWR').hom.Etale :=
    HasRingHomProperty.appLE (P := @Etale) q inferInstance ⟨R', hR'⟩ ⟨W, hW⟩ hWR'
  algebraize [(q.appLE R' W hWR').hom, (t.appLE R' U hUR').hom, ((k ≫ t).appLE R' (k ⁻¹ᵁ U) hkUR').hom]
  let σ : Γ(Y, W) →ₐ[Γ(X, R')] Γ(T₀, k ⁻¹ᵁ U) := ⟨(s₀.appLE W (k ⁻¹ᵁ U) hkUW).hom, fun r ↦ by
    simp only [RingHom.algebraMap_toAlgebra, ← CommRingCat.comp_apply, Scheme.Hom.appLE_comp_appLE,
      RingHom.toMonoidHom_eq_coe, OneHom.toFun_eq_coe, MonoidHom.toOneHom_coe, MonoidHom.coe_coe]
    rw [appLE_congr_hom hs₀]⟩
  let κ : Γ(T, U) →ₐ[Γ(X, R')] Γ(T₀, k ⁻¹ᵁ U) := ⟨(k.appLE U (k ⁻¹ᵁ U) le_rfl).hom, fun r ↦ by
    simp only [RingHom.algebraMap_toAlgebra, ← CommRingCat.comp_apply, Scheme.Hom.appLE_comp_appLE,
      RingHom.toMonoidHom_eq_coe, OneHom.toFun_eq_coe, MonoidHom.toOneHom_coe, MonoidHom.coe_coe]⟩
  have hκs : Function.Surjective κ := by
    show Function.Surjective (k.appLE U (k ⁻¹ᵁ U) le_rfl).hom
    rw [← Scheme.Hom.app_eq_appLE]
    exact k.app_surjective U hU
  have hκn : IsNilpotent (RingHom.ker (κ : Γ(T, U) →+* Γ(T₀, k ⁻¹ᵁ U))) := by
    show IsNilpotent (RingHom.ker (k.appLE U (k ⁻¹ᵁ U) le_rfl).hom)
    rw [← Scheme.Hom.app_eq_appLE]
    exact affine_kernel_nilpotent k ⟨U, hU⟩
  let ψ : Γ(Y, W) →ₐ[Γ(X, R')] Γ(T, U) := Algebra.FormallySmooth.liftOfSurjective σ κ hκs hκn
  have hψ : κ.comp ψ = σ := Algebra.FormallySmooth.comp_liftOfSurjective σ κ hκs hκn

  refine ⟨U, hpU, hU.isoSpec.hom ≫ Spec.map (CommRingCat.ofHom ψ.toRingHom) ≫ hW.fromSpec, ?_, ?_⟩
  ·
    have h1 : q.appLE R' W hWR' ≫ CommRingCat.ofHom ψ.toRingHom = t.appLE R' U hUR' := by
      ext r
      change ψ (algebraMap Γ(X, R') Γ(Y, W) r) = algebraMap Γ(X, R') Γ(T, U) r
      exact ψ.commutes r
    rw [Category.assoc, Category.assoc, ← IsAffineOpen.SpecMap_appLE_fromSpec q hR' hW hWR',
      ← Spec.map_comp_assoc, h1, IsAffineOpen.SpecMap_appLE_fromSpec t hR' hU hUR',
      ← hU.isoSpec_inv_ι]
    simp only [Category.assoc, Iso.hom_inv_id_assoc]
  ·
    have h2 : CommRingCat.ofHom ψ.toRingHom ≫ k.appLE U (k ⁻¹ᵁ U) le_rfl = s₀.appLE W (k ⁻¹ᵁ U) hkUW := by
      ext a
      change κ (ψ a) = σ a
      rw [← hψ]; rfl
    have h3 : Spec.map (k.appLE U (k ⁻¹ᵁ U) le_rfl) ≫ hU.isoSpec.inv = hkU.isoSpec.inv ≫ (k ∣_ U) := by
      rw [← cancel_mono (Scheme.Opens.ι U), Category.assoc, Category.assoc, hU.isoSpec_inv_ι, morphismRestrict_ι,
        IsAffineOpen.SpecMap_appLE_fromSpec k hU hkU le_rfl, ← hkU.isoSpec_inv_ι, Category.assoc]
    rw [← cancel_epi hkU.isoSpec.inv, ← Category.assoc, ← h3, Category.assoc, Iso.inv_hom_id_assoc,
      ← Spec.map_comp_assoc, h2, IsAffineOpen.SpecMap_appLE_fromSpec s₀ hW hkU hkUW, ← Category.assoc, hkU.isoSpec_inv_ι]

theorem existsUnique_lift {X Y T T₀ : Scheme.{u}} (q : Y ⟶ X) [Etale q]
    (k : T₀ ⟶ T) [IsClosedImmersion k] [Surjective k] [IsLocallyNoetherian T]
    (t : T ⟶ X) (s₀ : T₀ ⟶ Y) (hs₀ : s₀ ≫ q = k ≫ t) :
    ∃! s : T ⟶ Y, s ≫ q = t ∧ k ≫ s = s₀ := by
  obtain ⟨s, hs, hks⟩ := exists_of_forall_exists_nhd q k t s₀ (exists_nhd_lift q k t s₀ hs₀)
  refine ⟨s, ⟨hs, hks⟩, fun s' hs' => ?_⟩
  exact eq_of_comp_eq_of_surjective q k (hs'.1.trans hs.symm) (hs'.2.trans hks.symm)

private theorem lift_standardEtale
    {C C₀ : Type u} [CommRing C] [CommRing C₀] [Algebra C C₀] (hC : Function.Surjective (algebraMap C C₀))
    (S₀ : Type u) [CommRing S₀] [Algebra C₀ S₀] [Algebra.IsStandardEtale C₀ S₀] :
    ∃ (S : Type u) (_ : CommRing S) (_ : Algebra C S), Algebra.IsStandardEtale C S ∧ Nonempty (C₀ ⊗[C] S ≃ₐ[C₀] S₀) := by
  classical
  obtain ⟨P₀⟩ := Algebra.IsStandardEtale.nonempty_standardEtalePresentation (R := C₀) (S := S₀)
  rcases subsingleton_or_nontrivial C₀ with hC₀ | hC₀
  ·
    haveI : Subsingleton S₀ := Module.subsingleton C₀ S₀
    refine ⟨C, inferInstance, inferInstance, inferInstance, ⟨?_⟩⟩
    exact AlgEquiv.ofBijective ((Algebra.ofId C₀ S₀).comp (Algebra.TensorProduct.rid C C₀ C₀).toAlgHom)
      ⟨Function.injective_of_subsingleton _, Function.surjective_to_subsingleton _⟩

  set φ : C →+* C₀ := algebraMap C C₀ with hφ
  obtain ⟨f, hf, -, hfm⟩ :=
    Polynomial.lifts_and_degree_eq_and_monic (f := φ) ((mem_lifts _).mpr (map_surjective φ hC P₀.f)) P₀.monic_f
  obtain ⟨p₁, p₂, n, hP⟩ := P₀.cond
  obtain ⟨g, hg⟩ := map_surjective φ hC P₀.g
  obtain ⟨q₁, hq₁⟩ := map_surjective φ hC p₁
  obtain ⟨q₂, hq₂⟩ := map_surjective φ hC p₂
  let P : StandardEtalePair C :=
    { f := f, monic_f := hfm, g := g * (derivative f * q₁ + f * q₂), cond := ⟨g * q₁, g * q₂, 1, by ring⟩ }
  have hPf : P.f.map φ = P₀.f := hf
  have hPg : P.g.map φ = P₀.g ^ (n + 1) := by
    show (g * (derivative f * q₁ + f * q₂)).map φ = P₀.g ^ (n + 1)
    simp only [Polynomial.map_mul, Polynomial.map_add, ← Polynomial.derivative_map, hf, hg, hq₁, hq₂, hP]
    ring

  letI : Algebra C S₀ := ((algebraMap C₀ S₀).comp φ).toAlgebra
  haveI : IsScalarTower C C₀ S₀ := IsScalarTower.of_algebraMap_eq (fun _ => rfl)

  have key : ∀ (T : Type u) [CommRing T] [Algebra C₀ T] [Algebra C T] [IsScalarTower C C₀ T] (t : T),
      P.HasMap t ↔ P₀.HasMap t := by
    intro T _ _ _ _ t
    simp only [StandardEtalePair.HasMap]
    rw [← aeval_map_algebraMap C₀ t P.f, ← aeval_map_algebraMap C₀ t P.g, ← hφ, hPf, hPg, map_pow,
      isUnit_pow_iff (Nat.succ_ne_zero n)]
  have h1 : P.HasMap P₀.x := (key S₀ P₀.x).mpr P₀.hasMap
  have h2' : P.HasMap ((1 : C₀) ⊗ₜ[C] P.X) :=
    (StandardEtalePair.hasMap_X (P := P)).map
      (Algebra.TensorProduct.includeRight (R := C) (A := C₀) (B := P.Ring))
  have h2 : P₀.HasMap ((1 : C₀) ⊗ₜ[C] P.X) := (key (C₀ ⊗[C] P.Ring) _).mp h2'
  let F : C₀ ⊗[C] P.Ring →ₐ[C₀] S₀ :=
    Algebra.TensorProduct.lift (Algebra.ofId C₀ S₀) (P.lift P₀.x h1) (fun _ _ => .all _ _)
  let G : S₀ →ₐ[C₀] C₀ ⊗[C] P.Ring := (P₀.lift ((1 : C₀) ⊗ₜ[C] P.X) h2).comp P₀.equivRing.toAlgHom
  have hF : F ((1 : C₀) ⊗ₜ[C] P.X) = P₀.x := by
    simp [F, Algebra.TensorProduct.lift_tmul, StandardEtalePair.lift_X]
  have hG : G P₀.x = (1 : C₀) ⊗ₜ[C] P.X := by
    simp [G, StandardEtalePresentation.equivRing_x, StandardEtalePair.lift_X]
  refine ⟨P.Ring, inferInstance, inferInstance, inferInstance, ⟨AlgEquiv.ofAlgHom F G ?_ ?_⟩⟩
  · apply P₀.hom_ext
    simp only [AlgHom.comp_apply, AlgHom.id_apply, hG, hF]
  · apply Algebra.TensorProduct.ext
    · exact Subsingleton.elim _ _
    · apply StandardEtalePair.hom_ext
      simp only [AlgHom.comp_apply, AlgHom.restrictScalars_apply, Algebra.TensorProduct.includeRight_apply,
        AlgHom.id_apply, hF, hG]

theorem exists_local_model
    {X X₀ Y₀ : Scheme.{u}} (i : X₀ ⟶ X) [IsClosedImmersion i] (q₀ : Y₀ ⟶ X₀) [Etale q₀] (y : Y₀) :
    ∃ (V₀ : Y₀.Opens) (_ : y ∈ V₀) (V : Scheme.{u}) (qV : V ⟶ X) (_ : Etale qV) (jV : (V₀ : Scheme.{u}) ⟶ V),
      IsPullback jV (V₀.ι ≫ q₀) qV i := by
  classical

  obtain ⟨U, hUa, hxU, -⟩ := (Opens.isBasis_iff_nbhd.mp X.isBasis_affineOpens)
    (show i (q₀ y) ∈ (⊤ : X.Opens) from trivial)
  replace hUa : IsAffineOpen U := hUa

  have hU₀a : IsAffineOpen (i ⁻¹ᵁ U) := hUa.preimage i

  obtain ⟨W, hWa, hyW, hWle⟩ := (Opens.isBasis_iff_nbhd.mp Y₀.isBasis_affineOpens)
    (show y ∈ q₀ ⁻¹ᵁ (i ⁻¹ᵁ U) from hxU)
  replace hWa : IsAffineOpen W := hWa

  letI algA : Algebra Γ(X, U) Γ(X₀, i ⁻¹ᵁ U) := (i.appLE U (i ⁻¹ᵁ U) le_rfl).hom.toAlgebra
  letI algB : Algebra Γ(X₀, i ⁻¹ᵁ U) Γ(Y₀, W) := (q₀.appLE (i ⁻¹ᵁ U) W hWle).hom.toAlgebra
  have ha : Function.Surjective (algebraMap Γ(X, U) Γ(X₀, i ⁻¹ᵁ U)) := by
    show Function.Surjective (i.appLE U (i ⁻¹ᵁ U) le_rfl).hom
    rw [← Scheme.Hom.app_eq_appLE]
    exact i.app_surjective U hUa
  have hEt : Algebra.Etale Γ(X₀, i ⁻¹ᵁ U) Γ(Y₀, W) := Etale.etale_appLE q₀ hU₀a hWa hWle
  haveI := hEt.formallyEtale
  haveI := hEt.finitePresentation

  set p : PrimeSpectrum Γ(Y₀, W) := hWa.primeIdealOf ⟨y, hyW⟩ with hp
  obtain ⟨g, hgp, hstd⟩ := Algebra.IsEtaleAt.exists_isStandardEtale (R := Γ(X₀, i ⁻¹ᵁ U)) p.asIdeal
  have hV₀a : IsAffineOpen (Y₀.basicOpen g) := hWa.basicOpen g
  have hV₀le : Y₀.basicOpen g ≤ q₀ ⁻¹ᵁ (i ⁻¹ᵁ U) := (Y₀.basicOpen_le g).trans hWle
  have hyV₀ : y ∈ Y₀.basicOpen g := by
    have h1 : hWa.fromSpec p = y := hWa.fromSpec_primeIdealOf ⟨y, hyW⟩
    rw [← h1]
    show p ∈ hWa.fromSpec ⁻¹ᵁ Y₀.basicOpen g
    rw [hWa.fromSpec_preimage_basicOpen]
    exact hgp
  letI algS₀ : Algebra Γ(X₀, i ⁻¹ᵁ U) Γ(Y₀, Y₀.basicOpen g) :=
    (q₀.appLE (i ⁻¹ᵁ U) (Y₀.basicOpen g) hV₀le).hom.toAlgebra
  haveI : IsScalarTower Γ(X₀, i ⁻¹ᵁ U) Γ(Y₀, W) Γ(Y₀, Y₀.basicOpen g) :=
    IsScalarTower.of_algebraMap_eq (fun r => by
      show (q₀.appLE (i ⁻¹ᵁ U) (Y₀.basicOpen g) hV₀le).hom r =
        (Y₀.presheaf.map (homOfLE (Y₀.basicOpen_le g)).op).hom ((q₀.appLE (i ⁻¹ᵁ U) W hWle).hom r)
      rw [← CommRingCat.comp_apply, Scheme.Hom.appLE_map])
  haveI : IsLocalization.Away g Γ(Y₀, Y₀.basicOpen g) := hWa.isLocalization_basicOpen g
  haveI : Algebra.IsStandardEtale Γ(X₀, i ⁻¹ᵁ U) Γ(Y₀, Y₀.basicOpen g) :=
    Algebra.IsStandardEtale.of_equiv
      ((IsLocalization.algEquiv (.powers g) (Localization.Away g) Γ(Y₀, Y₀.basicOpen g)).restrictScalars
        Γ(X₀, i ⁻¹ᵁ U))

  obtain ⟨S, _, _, hS, ⟨e⟩⟩ :=
    lift_standardEtale ha
      Γ(Y₀, Y₀.basicOpen g)
  have hSe : (algebraMap Γ(X, U) S).Etale := RingHom.etale_algebraMap.mpr inferInstance
  haveI : Etale (Spec.map (CommRingCat.ofHom (algebraMap Γ(X, U) S))) := HasRingHomProperty.Spec_iff.mpr hSe
  let ψ : S →+* Γ(Y₀, Y₀.basicOpen g) :=
    e.toRingEquiv.toRingHom.comp (Algebra.TensorProduct.includeRight (R := Γ(X, U)) (A := Γ(X₀, i ⁻¹ᵁ U)) (B := S))
  refine ⟨Y₀.basicOpen g, hyV₀, Spec (.of S),
    Spec.map (CommRingCat.ofHom (algebraMap Γ(X, U) S)) ≫ hUa.fromSpec, inferInstance,
    hV₀a.isoSpec.hom ≫ Spec.map (CommRingCat.ofHom ψ), ?_⟩

  have top : IsPullback (Spec.map (CommRingCat.ofHom ψ))
      (Spec.map (CommRingCat.ofHom (algebraMap Γ(X₀, i ⁻¹ᵁ U) Γ(Y₀, Y₀.basicOpen g))))
      (Spec.map (CommRingCat.ofHom (algebraMap Γ(X, U) S)))
      (Spec.map (CommRingCat.ofHom (algebraMap Γ(X, U) Γ(X₀, i ⁻¹ᵁ U)))) := by
    have H := (IsPullback.of_hasPullback (Spec.map (CommRingCat.ofHom (algebraMap Γ(X, U) Γ(X₀, i ⁻¹ᵁ U))))
      (Spec.map (CommRingCat.ofHom (algebraMap Γ(X, U) S)))).flip
    refine H.of_iso
      (pullbackSpecIso Γ(X, U) Γ(X₀, i ⁻¹ᵁ U) S ≪≫ Scheme.Spec.mapIso e.symm.toRingEquiv.toCommRingCatIso.op)
      (Iso.refl _) (Iso.refl _) (Iso.refl _) ?_ ?_ (by simp) (by simp)
    · simp only [Iso.refl_hom, Category.comp_id, Iso.trans_hom, Functor.mapIso_hom, Iso.op_hom,
        Scheme.Spec_map, Quiver.Hom.unop_op, Category.assoc]
      rw [← Spec.map_comp, ← pullbackSpecIso_hom_snd]
      congr 2
      ext x
      symm
      change e.symm (e (Algebra.TensorProduct.includeRight x)) = Algebra.TensorProduct.includeRight x
      exact e.symm_apply_apply _
    · simp only [Iso.refl_hom, Category.comp_id, Iso.trans_hom, Functor.mapIso_hom, Iso.op_hom,
        Scheme.Spec_map, Quiver.Hom.unop_op, Category.assoc]
      rw [← Spec.map_comp, ← pullbackSpecIso_hom_fst]
      congr 2
      ext x
      symm
      change e.symm (algebraMap _ _ x) = Algebra.TensorProduct.includeLeftRingHom x
      rw [e.symm.commutes x]
      rfl
  have bot : IsPullback (Spec.map (CommRingCat.ofHom (algebraMap Γ(X, U) Γ(X₀, i ⁻¹ᵁ U))))
      hU₀a.fromSpec hUa.fromSpec i := by
    have e1 : CommRingCat.ofHom (algebraMap Γ(X, U) Γ(X₀, i ⁻¹ᵁ U)) = i.appLE U (i ⁻¹ᵁ U) le_rfl := rfl
    rw [e1]
    have comm : Spec.map (i.appLE U (i ⁻¹ᵁ U) le_rfl) ≫ hUa.isoSpec.inv = hU₀a.isoSpec.inv ≫ (i ∣_ U) := by
      rw [← cancel_mono (Scheme.Opens.ι U), Category.assoc, Category.assoc, IsAffineOpen.isoSpec_inv_ι, morphismRestrict_ι,
        ← Category.assoc, IsAffineOpen.isoSpec_inv_ι, IsAffineOpen.SpecMap_appLE_fromSpec]
    have sq : IsPullback (Spec.map (i.appLE U (i ⁻¹ᵁ U) le_rfl)) hU₀a.isoSpec.inv hUa.isoSpec.inv (i ∣_ U) :=
      IsPullback.of_vert_isIso ⟨comm⟩
    have := sq.paste_vert (isPullback_morphismRestrict i U)
    simpa only [IsAffineOpen.isoSpec_inv_ι] using this
  have big := top.paste_vert bot
  refine big.of_iso hV₀a.isoSpec.symm (Iso.refl _) (Iso.refl _) (Iso.refl _) (by simp) ?_ (by simp) (by simp)
  have e2 : CommRingCat.ofHom (algebraMap Γ(X₀, i ⁻¹ᵁ U) Γ(Y₀, Y₀.basicOpen g)) =
      q₀.appLE (i ⁻¹ᵁ U) (Y₀.basicOpen g) hV₀le := rfl
  simp only [Iso.refl_hom, Category.comp_id, Iso.symm_hom]
  rw [e2, IsAffineOpen.SpecMap_appLE_fromSpec q₀ hU₀a hV₀a hV₀le, ← Category.assoc, IsAffineOpen.isoSpec_inv_ι]

end PhilipponEtaleThickeningLifts

end

section

set_option autoImplicit false
set_option backward.isDefEq.respectTransparency false
set_option backward.isDefEq.respectTransparency.types false
set_option maxHeartbeats 800000

open AlgebraicGeometry CategoryTheory CategoryTheory.Limits Opposite
open PhilipponEtaleBaseChangeComparison


namespace PhilipponEtaleClosedPushforward

universe u
variable {X Z : Scheme.{u}} (i : Z ⟶ X)

/-- Étale neighborhoods over the closed subscheme can be refined at each
point by pullbacks of étale neighborhoods over the original scheme. -/
theorem exists_neighborhood_lift [IsClosedImmersion i]
    {V : X.Etale} {W : Z.Etale} (g : W ⟶ (baseChange i).obj V) (w : W.left) :
    ∃ (U : X.Etale) (a : U ⟶ V) (b : (baseChange i).obj U ⟶ W)
      (z : ((baseChange i).obj U).left), b ≫ g = (baseChange i).map a ∧ b.left z = w := by
  let k := pullback.fst V.hom i
  have : IsClosedImmersion k := inferInstanceAs (IsClosedImmersion (pullback.fst V.hom i))
  have : Etale g.left := inferInstance
  obtain ⟨D, hw, T, q, hq, j, hp⟩ :=
    PhilipponEtaleThickeningLifts.exists_local_model k g.left w
  let U := Scheme.Etale.mk (q ≫ V.hom)
  let a : U ⟶ V := MorphismProperty.Over.homMk q rfl trivial
  let sq := map_isPullback i a
  let e := hp.isoIsPullback _ _ sq
  have hmap : e.inv ≫ (D.ι ≫ g.left) = ((baseChange i).map a).left :=
    hp.isoIsPullback_inv_snd _ _ sq
  have hg : (D.ι ≫ g.left) ≫ ((baseChange i).obj V).hom = D.ι ≫ W.hom :=
    (Category.assoc _ _ _).trans (congrArg (D.ι ≫ ·) (MorphismProperty.Over.w g))
  let b : (baseChange i).obj U ⟶ W := MorphismProperty.Over.homMk (e.inv ≫ D.ι) (by
    calc
      (e.inv ≫ D.ι) ≫ W.hom = e.inv ≫ (D.ι ≫ W.hom) := Category.assoc _ _ _
      _ = e.inv ≫ ((D.ι ≫ g.left) ≫ ((baseChange i).obj V).hom) :=
        congrArg (e.inv ≫ ·) hg.symm
      _ = ((baseChange i).map a).left ≫ ((baseChange i).obj V).hom :=
        (Category.assoc _ _ _).symm.trans (congrArg (· ≫ _) hmap)
      _ = _ := MorphismProperty.Over.w ((baseChange i).map a)) trivial
  refine ⟨U, a, b, e.hom ⟨w, hw⟩, ?_, ?_⟩
  · apply MorphismProperty.Over.Hom.ext
    change (e.inv ≫ D.ι) ≫ g.left = _
    rw [Category.assoc, hmap]
  · change (e.inv ≫ D.ι) (e.hom ⟨w, hw⟩) = w
    rw [← Scheme.Hom.comp_apply, Iso.hom_inv_id_assoc]
    rfl

private theorem covers_iff_at_points {B : Scheme.{u}} {V : B.Etale} (R : Sieve V) :
    R ∈ B.smallEtaleTopology V ↔
      ∀ x : V.left, ∃ (W : B.Etale) (a : W ⟶ V) (w : W.left), R a ∧ a.left w = x := by
  have h := Scheme.ofArrows_mem_smallEtaleTopology_iff
    (fun (g : R.arrows.category) => g.obj.hom)
  rw [Sieve.ofArrows_category] at h
  rw [h]
  simp only [Set.eq_univ_iff_forall, Set.mem_iUnion, Set.mem_range]
  refine ⟨fun hc x => ?_, fun hc x => ?_⟩
  · obtain ⟨g, w, hw⟩ := hc x
    exact ⟨g.obj.left, g.obj.hom, w, g.property, hw⟩
  · obtain ⟨W, a, w, ha, hw⟩ := hc x
    exact ⟨⟨Over.mk a, ha⟩, w, hw⟩

private instance : PreservesFiniteLimits (baseChange i) :=
  inferInstanceAs (PreservesFiniteLimits (MorphismProperty.Over.pullback (@Etale) ⊤ i))

instance [IsClosedImmersion i] : (baseChange i).IsCoverDense Z.smallEtaleTopology where
  is_cover W := by
    let T := Scheme.Etale.mk (𝟙 X)
    let hT : IsTerminal T :=
      IsTerminal.isTerminalOfObj (Scheme.Etale.forget X) _ Over.mkIdTerminal
    let hB : IsTerminal ((baseChange i).obj T) :=
      IsTerminal.isTerminalObj (baseChange i) _ hT
    apply (covers_iff_at_points _).mpr
    intro w
    obtain ⟨U, _, b, z, _, hz⟩ := exists_neighborhood_lift i (hB.from W) w
    exact ⟨(baseChange i).obj U, b, z, Presieve.in_coverByImage (baseChange i) b, hz⟩

/-- Maps between the reductions of two étale charts lift after an étale
refinement of the source chart. -/
instance [IsClosedImmersion i] : (baseChange i).IsLocallyFull Z.smallEtaleTopology where
  functorPushforward_imageSieve_mem {U V} g := by
    let B := baseChange i
    let P := U ⨯ V
    let a : P ⟶ U := prod.fst
    let b : P ⟶ V := prod.snd
    let e := PreservesLimitPair.iso B U V
    let k : B.obj U ⟶ B.obj P := prod.lift (𝟙 _) g ≫ e.inv
    have hk₁ : k ≫ B.map a = 𝟙 (B.obj U) := by
      simp only [k, e, a, Category.assoc, PreservesLimitPair.iso_inv_fst]
      exact prod.lift_fst (𝟙 (B.obj U)) g
    have hk₂ : k ≫ B.map b = g := by
      simp only [k, e, b, Category.assoc, PreservesLimitPair.iso_inv_snd, prod.lift_snd]
    have hk₁' : k.left ≫ (B.map a).left = 𝟙 (B.obj U).left :=
      congrArg (fun m => m.left) hk₁
    have hk₂' : k.left ≫ (B.map b).left = g.left :=
      congrArg (fun m => m.left) hk₂
    have : Mono k.left := mono_of_mono_fac hk₁'
    have : Etale k.left := inferInstance
    have : IsOpenImmersion k.left := IsOpenImmersion.of_flat_of_mono _
    let p := pullback.fst P.hom i
    have : IsClosedImmersion p := inferInstanceAs
      (IsClosedImmersion (pullback.fst P.hom i))
    obtain ⟨D, hD, hpre⟩ := p.isClosedEmbedding.isInducing.isOpen_iff.mp
      k.left.isOpenMap.isOpen_range
    let O : P.left.Opens := ⟨D, hD⟩
    let Q := Scheme.Etale.mk (O.ι ≫ P.hom)
    let r : Q ⟶ P := MorphismProperty.Over.homMk O.ι rfl trivial
    have hr : Set.range (B.map r).left = Set.range k.left := by
      have h := Scheme.image_preimage_eq_of_isPullback (map_isPullback i r)
        (Set.univ : Set Q.left)
      simp only [Set.preimage_univ, Set.image_univ] at h
      change Set.range (B.map r).left = p ⁻¹' Set.range O.ι at h
      rw [Scheme.Opens.range_ι] at h
      exact h.trans hpre
    let l := IsOpenImmersion.lift k.left (B.map r).left hr.le
    have hl : l ≫ k.left = (B.map r).left := IsOpenImmersion.lift_fac _ _ _
    have ha : (B.map (r ≫ a)).left = l := by
      rw [B.map_comp]
      change (B.map r).left ≫ (B.map a).left = l
      rw [← hl, Category.assoc, hk₁', Category.comp_id]
    have hb : B.map (r ≫ b) = B.map (r ≫ a) ≫ g := by
      apply MorphismProperty.Over.Hom.ext
      rw [B.map_comp]
      change (B.map r).left ≫ (B.map b).left = (B.map (r ≫ a)).left ≫ g.left
      rw [← hl, Category.assoc, hk₂', ha]
    apply (covers_iff_at_points _).mpr
    intro y
    obtain ⟨z, hz⟩ := hr.symm.le (Set.mem_range_self (f := k.left) y)
    refine ⟨B.obj Q, B.map (r ≫ a), z, ?_, ?_⟩
    · exact Sieve.image_mem_functorPushforward B _ ⟨r ≫ b, hb⟩
    · rw [B.map_comp]
      change (B.map a).left ((B.map r).left z) = y
      rw [hz, ← Scheme.Hom.comp_apply, hk₁']
      rfl

/-- Direct image along a closed immersion is fully faithful on étale
abelian sheaves. -/
def fullyFaithfulPushforward [IsClosedImmersion i] : (pushforward i).FullyFaithful := by
  unfold pushforward
  exact Functor.FullyFaithful.ofFullyFaithful _

private theorem exists_empty_neighborhood [IsClosedImmersion i]
    (V : X.Etale) (x : V.left) (hx : x ∉ Set.range (pullback.fst V.hom i)) :
    ∃ (U : X.Etale) (a : U ⟶ V) (y : U.left),
      IsEmpty ((baseChange i).obj U).left ∧ a.left y = x := by
  let k := pullback.fst V.hom i
  have : IsClosedImmersion k := inferInstanceAs (IsClosedImmersion (pullback.fst V.hom i))
  let D : V.left.Opens := ⟨(Set.range k)ᶜ, k.isClosedEmbedding.isClosed_range.isOpen_compl⟩
  let U := Scheme.Etale.mk (D.ι ≫ V.hom)
  let a : U ⟶ V := MorphismProperty.Over.homMk D.ι rfl trivial
  refine ⟨U, a, ⟨x, hx⟩, ⟨fun z => ?_⟩, rfl⟩
  let y : D := pullback.fst U.hom i z
  have e := congrArg (fun s : ((baseChange i).obj U).left ⟶ V.left => s z)
    (map_isPullback i a).w
  exact y.property ⟨((baseChange i).map a).left z, e.symm⟩

/-- The direct image has zero stalk at every geometric point outside a
closed immersion's image. -/
theorem isZero_stalk_pushforward_of_not_mem_range [IsClosedImmersion i]
    {K : Type u} [Field K] [IsSepClosed K] (s : Spec (CommRingCat.of K) ⟶ X)
    (hs : s default ∉ Set.range i) (G : Sheaf Z.smallEtaleTopology AddCommGrpCat.{u}) :
    IsZero ((Scheme.pointSmallEtale s).sheafFiber.obj ((pushforward i).obj G)) := by
  let Φ := Scheme.pointSmallEtale s
  let P := ((pushforward i).obj G).obj
  change IsZero (Φ.presheafFiber.obj P)
  apply AddCommGrpCat.isZero_iff_subsingleton.mpr
  suffices h : ∀ z : ↥(Φ.presheafFiber.obj P), z = 0 from
    ⟨fun a b => (h a).trans (h b).symm⟩
  intro z
  obtain ⟨V, t, a, rfl⟩ := Φ.toPresheafFiber_jointly_surjective z
  let z₀ : Spec (CommRingCat.of K) := default
  have hx : t.left z₀ ∉ Set.range (pullback.fst V.hom i) := by
    rw [Scheme.Pullback.range_fst]
    have ht : V.hom (t.left z₀) = s default :=
      (Scheme.pointSmallEtaleFiberObjToPreimage s rfl t).property
    change V.hom (t.left z₀) ∉ Set.range i
    rwa [ht]
  obtain ⟨U, e, y, hU, hy⟩ := exists_empty_neighborhood i V (t.left z₀) hx
  obtain ⟨l, hl, _⟩ := Scheme.exists_fac_of_etale_of_isSepClosed e.left t.left y hy
  let v : Φ.fiber.obj U := Over.homMk l (by
    change l ≫ U.hom = s
    rw [← MorphismProperty.Over.w e, ← Category.assoc, hl]
    exact Over.w t)
  have hv : Φ.fiber.map e v = t :=
    Over.OverMorphism.ext hl
  have hzero : P.map e.op a = 0 := by
    change G.obj.map ((baseChange i).map e).op a = 0
    exact (Scheme.subsingleton_sections_of_isEmpty hU G).elim _ _
  rw [← hv, ← Φ.toPresheafFiber_w_apply, hzero, map_zero]

end PhilipponEtaleClosedPushforward

end

section

set_option autoImplicit false
set_option backward.isDefEq.respectTransparency false
set_option backward.isDefEq.respectTransparency.types false

open AlgebraicGeometry CategoryTheory CategoryTheory.Abelian CategoryTheory.Limits Opposite
open PhilipponEtaleBaseChangeComparison (baseChange)
open PhilipponEtaleClosedPushforward (pushforward)
open PhilipponEtaleSmallSite (pullbackSheaves pullbackAdjunction)


namespace PhilipponEtaleAcyclicCohomology

universe u

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

private abbrev terminal (X : Scheme.{u}) : X.Etale := Scheme.Etale.mk (𝟙 X)

private def isTerminal (X : Scheme.{u}) : IsTerminal (terminal X) :=
  IsTerminal.isTerminalOfObj (Scheme.Etale.forget X) _ Over.mkIdTerminal

private def terminalComparison {X Y : Scheme.{u}} (f : Y ⟶ X) :
    (baseChange f).obj (terminal X) ≅ terminal Y := by
  have : PreservesFiniteLimits (baseChange f) :=
    inferInstanceAs (PreservesFiniteLimits (MorphismProperty.Over.pullback (@Etale) ⊤ f))
  exact (IsTerminal.isTerminalObj (baseChange f) _ (isTerminal X)).uniqueUpToIso (isTerminal Y)

/-- Evaluation of the direct-image comparison uses the unique arrow
to the base change of the terminal chart. -/
theorem globalSectionsIso_hom_app_eq_map {X Y : Scheme.{u}} (f : Y ⟶ X)
    (F : AbelianSheaves Y) (k : terminal Y ⟶ (baseChange f).obj (terminal X)) :
    (globalSectionsIso f).hom.app F = F.obj.map k.op := by
  have ht := (isTerminal Y).ofIso (terminalComparison f).symm
  rw [ht.hom_ext k (terminalComparison f).inv]
  rfl

end PhilipponEtaleAcyclicCohomology

end

section

set_option autoImplicit false
set_option backward.isDefEq.respectTransparency false
set_option backward.isDefEq.respectTransparency.types false

open AlgebraicGeometry CategoryTheory CategoryTheory.Abelian CategoryTheory.Limits
open PhilipponEtaleAcyclicCohomology (globalSections globalSectionsIso)
open PhilipponEtaleBaseChangeMap (stalkToFiberSections stalkOfHigherImageIso)
open PhilipponEtaleClosedPushforward (pushforward)
open PhilipponEtaleSmallSite (pullbackSheaves pullbackAdjunction)


namespace PhilipponEtalePullbackResolution

universe u

/-- Restrict global sections along the unit of étale inverse image. -/
def restrictGlobalSections {X Y : Scheme.{u}} (f : Y ⟶ X) :
    globalSections X ⟶ pullbackSheaves f ⋙ globalSections Y :=
  (Functor.leftUnitor (globalSections X)).inv ≫
    Functor.whiskerRight (pullbackAdjunction f).unit (globalSections X) ≫
    (Functor.associator (pullbackSheaves f) (pushforward f) (globalSections X)).hom ≫
    (Functor.isoWhiskerLeft (pullbackSheaves f) (globalSectionsIso f)).hom

end PhilipponEtalePullbackResolution

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