lean/OAI/AlgebraicGeometry/RelativeTriviality/Cech.lean

import Mathlib
import OAI.AlgebraicGeometry.RelativeTriviality.Charts
import OAI.AlgebraicGeometry.RelativeTriviality.GlobalFunctions
import OAI.AlgebraicGeometry.RelativeTriviality.FiniteSections
import OAI.AlgebraicGeometry.RelativeTriviality.LaurentCech

namespace OAI

namespace CampanaPeternellSix.ActualCech
noncomputable section
open CategoryTheory AlgebraicGeometry Opposite TopologicalSpace Limits
open RelativeLineCharts
universe u
variable (R : Type u) [CommRing R]
 
def coefficientSheaf (E : (scheme R).Modules) :
    TopCat.Sheaf (ModuleCat.{u} R) (scheme R) := by
  let F := ModuleCat.restrictScalars.{u} (RelativeLineGlobalFunctions.scalars R)
  letI : F.IsRightAdjoint := (ModuleCat.extendRestrictScalarsAdj
    (RelativeLineGlobalFunctions.scalars R)).isRightAdjoint
  letI : (Opens.grothendieckTopology (scheme R)).HasSheafCompose F :=
    CategoryTheory.hasSheafCompose_of_preservesLimitsOfSize (F := F) _
  exact (sheafCompose (Opens.grothendieckTopology (scheme R)) F).obj
    ((SheafOfModules.forgetToSheafModuleCat (scheme R).ringCatSheaf (.op ⊤)
      (initialOpOfTerminal isTerminalTop)).obj E)
abbrev overlapModule (E : (scheme R).Modules) : ModuleCat R :=
  (coefficientSheaf R E).obj.obj (op (leftOpen R ⊓ rightOpen R))
def leftImage (E : (scheme R).Modules) : Submodule R (overlapModule R E) :=
  LinearMap.range ((coefficientSheaf R E).obj.map (homOfLE inf_le_left).op).hom
def rightImage (E : (scheme R).Modules) : Submodule R (overlapModule R E) :=
  LinearMap.range ((coefficientSheaf R E).obj.map (homOfLE inf_le_right).op).hom
 

abbrev quotient (E : (scheme R).Modules) :=
  overlapModule R E ⧸ (leftImage R E ⊔ rightImage R E)

open scoped Polynomial LaurentPolynomial
attribute [local instance] MvPolynomial.gradedAlgebra

def leftInclusion : Spec (.of (ChartRing R)) ⟶ scheme R :=
  Proj.awayι (grading R) (x₀ R) (x₀_mem R) (by decide : 0 < 1)
def rightInclusion : Spec (.of (RightChartRing R)) ⟶ scheme R :=
  Proj.awayι (grading R) (x₁ R) (x₁_mem R) (by decide : 0 < 1)
private lemma isOpenImmersion_iso_inv_comp {X Y Z : Scheme} (e : X ≅ Y)
    (f : X ⟶ Z) [IsOpenImmersion f] : IsOpenImmersion (e.inv ≫ f) :=
  IsOpenImmersion.comp _ _

instance : IsOpenImmersion (leftInclusion R) :=
  isOpenImmersion_iso_inv_comp
    (Proj.basicOpenIsoSpec (grading R) (x₀ R) (x₀_mem R) (by decide : 0 < 1))
    (Proj.basicOpen (grading R) (x₀ R)).ι
instance : IsOpenImmersion (rightInclusion R) :=
  isOpenImmersion_iso_inv_comp
    (Proj.basicOpenIsoSpec (grading R) (x₁ R) (x₁_mem R) (by decide : 0 < 1))
    (Proj.basicOpen (grading R) (x₁ R)).ι
lemma left_range : (leftInclusion R).opensRange = leftOpen R :=
  Proj.opensRange_awayι _ _ _ _
lemma right_range : (rightInclusion R).opensRange = rightOpen R :=
  Proj.opensRange_awayι _ _ _ _
lemma left_image_overlap :
    leftInclusion R ''ᵁ (PrimeSpectrum.basicOpen (coordinate R)) = leftOpen R ⊓ rightOpen R := by
  have hpre : leftInclusion R ⁻¹ᵁ rightOpen R = PrimeSpectrum.basicOpen (coordinate R) := by
    convert! Proj.awayι_preimage_basicOpen (grading R) (x₀_mem R) (by decide : 0 < 1)
      (x₁_mem R) (by decide : 0 < 1) using 1
    simp [leftInclusion, rightOpen, coordinate, HomogeneousLocalization.Away.isLocalizationElem]
    rfl
  rw [← hpre, Scheme.Hom.image_preimage_eq_opensRange_inf, left_range]
lemma right_image_overlap :
    rightInclusion R ''ᵁ (PrimeSpectrum.basicOpen (rightCoordinate R)) = leftOpen R ⊓ rightOpen R := by
  have hpre : rightInclusion R ⁻¹ᵁ leftOpen R = PrimeSpectrum.basicOpen (rightCoordinate R) := by
    convert! Proj.awayι_preimage_basicOpen (grading R) (x₁_mem R) (by decide : 0 < 1)
      (x₀_mem R) (by decide : 0 < 1) using 1
    simp [rightInclusion, leftOpen, rightCoordinate, HomogeneousLocalization.Away.isLocalizationElem]
    rfl
  rw [← hpre, Scheme.Hom.image_preimage_eq_opensRange_inf, right_range, inf_comm]

lemma actual_left_spans (E : (scheme R).Modules) [E.IsQuasicoherent] :
    Submodule.span Γ(scheme R,leftOpen R ⊓ rightOpen R)
      (Set.range (E.presheaf.map (homOfLE (show leftOpen R ⊓ rightOpen R ≤ leftOpen R from inf_le_left)).op)) = ⊤ := by
  have h := RelativeCech.affine_image_restriction_spans (.of (ChartRing R)) (scheme R) E
    (leftInclusion R) (coordinate R)
  rw [left_image_overlap, Scheme.Hom.image_top_eq_opensRange, left_range] at h
  exact h _
lemma actual_right_spans (E : (scheme R).Modules) [E.IsQuasicoherent] :
    Submodule.span Γ(scheme R,leftOpen R ⊓ rightOpen R)
      (Set.range (E.presheaf.map (homOfLE (show leftOpen R ⊓ rightOpen R ≤ rightOpen R from inf_le_right)).op)) = ⊤ := by
  have h := RelativeCech.affine_image_restriction_spans (.of (RightChartRing R)) (scheme R) E
    (rightInclusion R) (rightCoordinate R)
  rw [right_image_overlap, Scheme.Hom.image_top_eq_opensRange, right_range] at h
  exact h _

lemma scalar_overlap (a : R) :
    overlapSectionEquiv R ((scheme R).presheaf.map
      (homOfLE (show leftOpen R ⊓ rightOpen R ≤ ⊤ from le_top)).op
      (RelativeLineGlobalFunctions.scalars R a)) = LaurentPolynomial.C a := by
  erw [show (homOfLE (show leftOpen R ⊓ rightOpen R ≤ ⊤ from le_top)) =
    (homOfLE inf_le_left) ≫ (homOfLE (show leftOpen R ≤ ⊤ from le_top)) from rfl,
    op_comp, (scheme R).presheaf.map_comp, CommRingCat.comp_apply,
    (standard_section_restrictions R).1, RelativeLineGlobalFunctions.scalars_left,
    Polynomial.toLaurent_C]

lemma finite_overlap (E : (scheme R).Modules)
    (hE : ∃ q : E.LocalGeneratorsData, q.IsLocallyFreeData ∧ q.IsFiniteType) :
    Module.Finite Γ(scheme R,leftOpen R ⊓ rightOpen R) Γ(E,leftOpen R ⊓ rightOpen R) := by
  apply RelativeCech.finite_affine_open (scheme R) E hE
  rw [overlap_eq_basic]
  exact Proj.isAffineOpen_basicOpen (grading R) (x₀ R * x₁ R)
    (SetLike.mul_mem_graded (x₀_mem R) (x₁_mem R)) (by decide : 0 < 1+1)

instance overlapAction (E : (scheme R).Modules) :
    Module Γ(scheme R,leftOpen R ⊓ rightOpen R) (overlapModule R E) :=
  (E.val.obj (op (leftOpen R ⊓ rightOpen R))).isModule

instance laurentAction (E : (scheme R).Modules) : Module R[T;T⁻¹] (overlapModule R E) :=
  Module.compHom _ (overlapSectionEquiv R).symm.toRingHom

lemma base_smul (E : (scheme R).Modules) (r : R) (m : overlapModule R E) :
    r • m = (LaurentPolynomial.C r) • m := by
  change ((scheme R).presheaf.map (homOfLE (show leftOpen R ⊓ rightOpen R ≤ ⊤ from le_top)).op
    (RelativeLineGlobalFunctions.scalars R r)) • m =
    (overlapSectionEquiv R).symm (LaurentPolynomial.C r) • m
  congr 1
  apply (overlapSectionEquiv R).injective
  rw [RingEquiv.apply_symm_apply, scalar_overlap]

instance laurentTower (E : (scheme R).Modules) :
    IsScalarTower R R[T;T⁻¹] (overlapModule R E) where
  smul_assoc r a m := by
    calc
      (r • a) • m = (LaurentPolynomial.C r * a) • m :=
        congrArg (fun b : R[T;T⁻¹] => b • m) (Algebra.smul_def r a)
      _ = (LaurentPolynomial.C r) • (a • m) := mul_smul _ _ _
      _ = r • (a • m) := (base_smul R E r (a • m)).symm

lemma finite_laurent (E : (scheme R).Modules)
    (hE : ∃ q : E.LocalGeneratorsData, q.IsLocallyFreeData ∧ q.IsFiniteType) :
    Module.Finite R[T;T⁻¹] (overlapModule R E) := by
  let := finite_overlap R E hE
  let f : Γ(E,leftOpen R ⊓ rightOpen R) →ₛₗ[(overlapSectionEquiv R).toRingHom]
      (overlapModule R E) :=
    { toFun := fun m => m
      map_add' := fun _ _ => rfl
      map_smul' := fun a m => by
        change a • m = (overlapSectionEquiv R).symm (overlapSectionEquiv R a) • m
        rw [RingEquiv.symm_apply_apply] }
  exact Module.Finite.of_surjective f Function.surjective_id

lemma laurent_span_top (E : (scheme R).Modules) (S : Set (overlapModule R E))
    (h : Submodule.span Γ(scheme R,leftOpen R ⊓ rightOpen R) S = ⊤) :
    Submodule.span R[T;T⁻¹] S = ⊤ := by
  apply top_unique
  intro m hm
  clear hm
  have hm' : m ∈ Submodule.span Γ(scheme R,leftOpen R ⊓ rightOpen R) S := by rw [h]; trivial
  induction hm' using Submodule.span_induction with
  | mem x hx => exact Submodule.subset_span hx
  | zero => exact Submodule.zero_mem _
  | add x y hx hy ihx ihy => exact Submodule.add_mem _ ihx ihy
  | smul a x hx ih =>
      have he : a • x = (overlapSectionEquiv R a) • x := by
        change a • x = (overlapSectionEquiv R).symm (overlapSectionEquiv R a) • x
        rw [RingEquiv.symm_apply_apply]
      rw [he]
      exact Submodule.smul_mem _ _ ih

lemma left_laurent_spans (E : (scheme R).Modules) [E.IsQuasicoherent] :
    Submodule.span R[T;T⁻¹] (leftImage R E : Set (overlapModule R E)) = ⊤ := by
  apply laurent_span_top
  exact actual_left_spans R E
lemma right_laurent_spans (E : (scheme R).Modules) [E.IsQuasicoherent] :
    Submodule.span R[T;T⁻¹] (rightImage R E : Set (overlapModule R E)) = ⊤ := by
  apply laurent_span_top
  exact actual_right_spans R E

lemma left_stable (E : (scheme R).Modules) (m : overlapModule R E)
    (hm : m ∈ leftImage R E) : LaurentPolynomial.T (R := R) 1 • m ∈ leftImage R E := by
  obtain ⟨y, rfl⟩ := hm
  change Γ(E,leftOpen R) at y
  refine ⟨(leftSectionEquiv R).symm Polynomial.X • y, ?_⟩
  change E.val.map (homOfLE (show leftOpen R ⊓ rightOpen R ≤ leftOpen R from inf_le_left)).op ((leftSectionEquiv R).symm Polynomial.X • y) =
    @SMul.smul Γ(scheme R,leftOpen R ⊓ rightOpen R) Γ(E,leftOpen R ⊓ rightOpen R)
      inferInstance ((overlapSectionEquiv R).symm (LaurentPolynomial.T 1))
      (E.val.map (homOfLE (show leftOpen R ⊓ rightOpen R ≤ leftOpen R from inf_le_left)).op y :
        Γ(E,leftOpen R ⊓ rightOpen R))
  erw [E.val.map_smul]
  congr 1
  apply (overlapSectionEquiv R).injective
  change overlapSectionEquiv R ((scheme R).presheaf.map
    (homOfLE (show leftOpen R ⊓ rightOpen R ≤ leftOpen R from inf_le_left)).op
    ((leftSectionEquiv R).symm Polynomial.X)) =
    overlapSectionEquiv R ((overlapSectionEquiv R).symm (LaurentPolynomial.T 1))
  rw [RingEquiv.apply_symm_apply, (standard_section_restrictions R).1,
    RingEquiv.apply_symm_apply, Polynomial.toLaurent_X]

lemma right_stable (E : (scheme R).Modules) (m : overlapModule R E)
    (hm : m ∈ rightImage R E) : LaurentPolynomial.T (R := R) (-1) • m ∈ rightImage R E := by
  obtain ⟨y, rfl⟩ := hm
  change Γ(E,rightOpen R) at y
  refine ⟨(rightSectionEquiv R).symm Polynomial.X • y, ?_⟩
  change E.val.map (homOfLE (show leftOpen R ⊓ rightOpen R ≤ rightOpen R from inf_le_right)).op ((rightSectionEquiv R).symm Polynomial.X • y) =
    @SMul.smul Γ(scheme R,leftOpen R ⊓ rightOpen R) Γ(E,leftOpen R ⊓ rightOpen R)
      inferInstance ((overlapSectionEquiv R).symm (LaurentPolynomial.T (-1)))
      (E.val.map (homOfLE (show leftOpen R ⊓ rightOpen R ≤ rightOpen R from inf_le_right)).op y :
        Γ(E,leftOpen R ⊓ rightOpen R))
  erw [E.val.map_smul]
  congr 1
  apply (overlapSectionEquiv R).injective
  change overlapSectionEquiv R ((scheme R).presheaf.map
    (homOfLE (show leftOpen R ⊓ rightOpen R ≤ rightOpen R from inf_le_right)).op
    ((rightSectionEquiv R).symm Polynomial.X)) =
    overlapSectionEquiv R ((overlapSectionEquiv R).symm (LaurentPolynomial.T (-1)))
  rw [RingEquiv.apply_symm_apply, (standard_section_restrictions R).2,
    RingEquiv.apply_symm_apply, Polynomial.toLaurent_X, LaurentPolynomial.invert_T]

theorem finite_actual_cech (E : (scheme R).Modules)
    (hE : ∃ q : E.LocalGeneratorsData, q.IsLocallyFreeData ∧ q.IsFiniteType) :
    Module.Finite R (quotient R E) := by
  have := finite_laurent R E hE
  obtain ⟨q, hq, ht⟩ := hE
  let := hq
  let := ht
  let := q.isLocallyFree
  have : E.IsQuasicoherent := q.quasiCoherentData.isQuasicoherent
  exact RelativeCech.finite_cech_cokernel R (overlapModule R E) (leftImage R E) (rightImage R E)
    (left_stable R E) (right_stable R E) (left_laurent_spans R E) (right_laurent_spans R E)

end
end CampanaPeternellSix.ActualCech

end OAI