lean/OAI/AlgebraicGeometry/RelativeTriviality/CechBaseChange.lean

import Mathlib
import OAI.AlgebraicGeometry.RelativeTriviality.FreeCech
import OAI.AlgebraicGeometry.RelativeTriviality.BaseChange
import OAI.AlgebraicGeometry.RelativeTriviality.AffineSquare
import OAI.AlgebraicGeometry.RelativeTriviality.LocallyFree
import OAI.AlgebraicGeometry.RelativeTriviality.LaurentCech

namespace OAI

noncomputable section

namespace CampanaPeternellSix.ActualCech
section
open CategoryTheory AlgebraicGeometry Opposite
open RelativeLineCharts RelativeProjectiveBaseChange RelativePolynomialEvaluation
open Scheme.Modules
universe u
variable {R S : Type u} [CommRing R] [CommRing S] [Algebra R S]

lemma baseMap_scalars :
    CommRingCat.ofHom (RelativeLineGlobalFunctions.scalars R) ≫ (baseMap (algebraMap R S) 1).appTop =
      CommRingCat.ofHom (algebraMap R S) ≫ CommRingCat.ofHom (RelativeLineGlobalFunctions.scalars S) := by
  exact AffineSquare.baseScalars_natural (baseMap (algebraMap R S) 1) (toBase S 1) (toBase R 1)
    (CommRingCat.ofHom (algebraMap R S)) (baseMap_isPullback (algebraMap R S))

def actualUnit (E : (scheme R).Modules) (U : (scheme R).Opens) (V : (scheme S).Opens)
    (hV : V ≤ (baseMap (algebraMap R S) 1) ⁻¹ᵁ U) :
    let N := (coefficientSheaf S ((pullback (baseMap (algebraMap R S) 1)).obj E)).obj.obj (op V)
    letI : Module R N := Module.compHom N (algebraMap R S)
    ((coefficientSheaf R E).obj.obj (op U)) →ₗ[R] N := by
  let N := (coefficientSheaf S ((pullback (baseMap (algebraMap R S) 1)).obj E)).obj.obj (op V)
  letI : Module R N := Module.compHom N (algebraMap R S)
  let f := AffineSquare.coefficientUnit (baseMap (algebraMap R S) 1)
    (CommRingCat.ofHom (algebraMap R S))
    (@CommRingCat.ofHom R Γ(scheme R,⊤) inferInstance inferInstance (RelativeLineGlobalFunctions.scalars R))
    (@CommRingCat.ofHom S Γ(scheme S,⊤) inferInstance inferInstance (RelativeLineGlobalFunctions.scalars S)) baseMap_scalars E U V hV
  exact { toFun := f, map_add' := map_add f, map_smul' := f.map_smul' }

lemma actualUnit_isBaseChange (E : (scheme R).Modules) [E.IsQuasicoherent]
    (U : (scheme R).Opens) (V : (scheme S).Opens)
    (hUaff : IsAffineOpen U) (hVaff : IsAffineOpen V)
    (hUV : V = (baseMap (algebraMap R S) 1) ⁻¹ᵁ U) :
    let N := (coefficientSheaf S ((pullback (baseMap (algebraMap R S) 1)).obj E)).obj.obj (op V)
    letI : Module R N := Module.compHom N (algebraMap R S)
    letI : IsScalarTower R S N := IsScalarTower.of_algebraMap_smul (fun _ _ => rfl)
    IsBaseChange S (actualUnit E U V hUV.le) := by
  exact AffineSquare.coefficientUnit_isBaseChange_of_isPushout
    (X := scheme S) (Y := scheme R)
    (baseMap (algebraMap R S) 1)
    (@CommRingCat.ofHom R Γ(scheme R,⊤) inferInstance inferInstance (RelativeLineGlobalFunctions.scalars R))
    (@CommRingCat.ofHom S Γ(scheme S,⊤) inferInstance inferInstance (RelativeLineGlobalFunctions.scalars S)) baseMap_scalars U V hUV.le
    hUaff hVaff
    (AffineSquare.openBaseScalars_pushout (baseMap (algebraMap R S) 1) (toBase S 1) (toBase R 1)
      (CommRingCat.ofHom (algebraMap R S)) (baseMap_isPullback (algebraMap R S)) U V hUaff hVaff hUV) E

lemma actualUnit_naturality (E : (scheme R).Modules)
    (U₁ U₂ : (scheme R).Opens) (V₁ V₂ : (scheme S).Opens)
    (hU : U₁ ≤ U₂) (hV : V₁ ≤ V₂)
    (hv₁ : V₁ ≤ (baseMap (algebraMap R S) 1) ⁻¹ᵁ U₁)
    (hv₂ : V₂ ≤ (baseMap (algebraMap R S) 1) ⁻¹ᵁ U₂)
    (m : (coefficientSheaf R E).obj.obj (op U₂)) :
    actualUnit E U₁ V₁ hv₁ ((coefficientSheaf R E).obj.map (homOfLE hU).op m) =
    (coefficientSheaf S ((pullback (baseMap (algebraMap R S) 1)).obj E)).obj.map (homOfLE hV).op
      (actualUnit E U₂ V₂ hv₂ m) := by
  exact AffineSquare.coefficientUnit_naturality (baseMap (algebraMap R S) 1)
    (CommRingCat.ofHom (algebraMap R S))
    (@CommRingCat.ofHom R Γ(scheme R,⊤) inferInstance inferInstance (RelativeLineGlobalFunctions.scalars R))
    (@CommRingCat.ofHom S Γ(scheme S,⊤) inferInstance inferInstance (RelativeLineGlobalFunctions.scalars S)) baseMap_scalars E U₁ U₂ V₁ V₂ hU hV hv₁ hv₂ m
end

section
open CategoryTheory AlgebraicGeometry Opposite
open RelativeLineCharts
universe u
variable (R : Type u) [CommRing R]

lemma iso_ranges_top {E F : (scheme R).Modules} (e : E ≅ F)
    (hF : leftImage R F ⊔ rightImage R F = ⊤) :
    leftImage R E ⊔ rightImage R E = ⊤ := by
  apply top_unique
  intro m hm
  change Γ(E,leftOpen R ⊓ rightOpen R) at m
  let mf : overlapModule R F := e.hom.app (leftOpen R ⊓ rightOpen R) m
  have h : mf ∈ leftImage R F ⊔ rightImage R F := by
    rw [hF]
    trivial
  obtain ⟨a,⟨x,hx⟩,b,⟨y,hy⟩,hab⟩ := Submodule.mem_sup.mp h
  subst a
  subst b
  let x' := e.inv.app (leftOpen R) x
  let y' := e.inv.app (rightOpen R) y
  have hx' : e.inv.app (leftOpen R ⊓ rightOpen R)
      (F.presheaf.map (homOfLE (show leftOpen R ⊓ rightOpen R ≤ leftOpen R from inf_le_left)).op x) =
      E.presheaf.map (homOfLE (show leftOpen R ⊓ rightOpen R ≤ leftOpen R from inf_le_left)).op x' :=
    ConcreteCategory.congr_hom (e.inv.val.naturality (homOfLE (show leftOpen R ⊓ rightOpen R ≤ leftOpen R from inf_le_left)).op) x
  have hy' : e.inv.app (leftOpen R ⊓ rightOpen R)
      (F.presheaf.map (homOfLE (show leftOpen R ⊓ rightOpen R ≤ rightOpen R from inf_le_right)).op y) =
      E.presheaf.map (homOfLE (show leftOpen R ⊓ rightOpen R ≤ rightOpen R from inf_le_right)).op y' :=
    ConcreteCategory.congr_hom (e.inv.val.naturality (homOfLE (show leftOpen R ⊓ rightOpen R ≤ rightOpen R from inf_le_right)).op) y
  have he : e.inv.app (leftOpen R ⊓ rightOpen R) (e.hom.app (leftOpen R ⊓ rightOpen R) m) = m := by
    exact ConcreteCategory.congr_hom (congrArg (fun f => f.app (leftOpen R ⊓ rightOpen R)) e.hom_inv_id) m
  refine Submodule.mem_sup.mpr ⟨_,⟨x',rfl⟩,_,⟨y',rfl⟩,?_⟩
  have hs := congrArg (fun z => e.inv.app (leftOpen R ⊓ rightOpen R) z) hab
  change _ + _ = m
  change e.inv.app (leftOpen R ⊓ rightOpen R)
    (F.presheaf.map (homOfLE (show leftOpen R ⊓ rightOpen R ≤ leftOpen R from inf_le_left)).op x +
     F.presheaf.map (homOfLE (show leftOpen R ⊓ rightOpen R ≤ rightOpen R from inf_le_right)).op y) =
    e.inv.app (leftOpen R ⊓ rightOpen R) (e.hom.app (leftOpen R ⊓ rightOpen R) m) at hs
  rw [map_add,hx',hy',he] at hs
  exact hs

lemma trivial_ranges_top (E : (scheme R).Modules) (n : ℕ)
    (hf : Nonempty (E ≅ SheafOfModules.free (ULift.{u} (Fin n)))) :
    leftImage R E ⊔ rightImage R E = ⊤ := by
  obtain ⟨e⟩ := hf
  exact iso_ranges_top R e (free_ranges_top (ULift.{u} (Fin n)) R)
end

section
open CategoryTheory AlgebraicGeometry Opposite
open RelativeLineCharts RelativeProjectiveBaseChange
open Scheme.Modules
open scoped TensorProduct
universe u
attribute [local instance] MvPolynomial.gradedAlgebra
variable (R : Type u) [CommRing R]

lemma left_affine : IsAffineOpen (leftOpen R) :=
  Proj.isAffineOpen_basicOpen (grading R) (x₀ R) (x₀_mem R) (by decide : 0 < 1)
lemma right_affine : IsAffineOpen (rightOpen R) :=
  Proj.isAffineOpen_basicOpen (grading R) (x₁ R) (x₁_mem R) (by decide : 0 < 1)
lemma overlap_affine : IsAffineOpen (leftOpen R ⊓ rightOpen R) := by
  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)

variable {R} {S : Type u} [CommRing S] [Algebra R S]
lemma left_base_preimage : leftOpen S = (baseMap (algebraMap R S) 1) ⁻¹ᵁ leftOpen R := by
  dsimp only [leftOpen, baseMap, x₀]
  erw [Proj.map_preimage_basicOpen, coefficientMap_X]
lemma right_base_preimage : rightOpen S = (baseMap (algebraMap R S) 1) ⁻¹ᵁ rightOpen R := by
  dsimp only [rightOpen, baseMap, x₁]
  erw [Proj.map_preimage_basicOpen, coefficientMap_X]
lemma overlap_base_preimage : leftOpen S ⊓ rightOpen S =
    (baseMap (algebraMap R S) 1) ⁻¹ᵁ (leftOpen R ⊓ rightOpen R) := by
  erw [Scheme.Hom.preimage_inf]
  rw [← left_base_preimage, ← right_base_preimage]
  rfl

lemma tensor_actual_cech_vanish_of_trivial_pullback (E : (scheme R).Modules) [E.IsQuasicoherent]
    (n : ℕ) (hf : Nonempty ((pullback (baseMap (algebraMap R S) 1)).obj E ≅
      SheafOfModules.free (ULift.{u} (Fin n)))) :
    Subsingleton (S ⊗[R] quotient R E) := by
  let E' := (pullback (baseMap (algebraMap R S) 1)).obj E
  let P := (coefficientSheaf R E).obj.obj (op (leftOpen R))
  let Q := (coefficientSheaf R E).obj.obj (op (rightOpen R))
  let M := overlapModule R E
  let P' := (coefficientSheaf S E').obj.obj (op (leftOpen S))
  let Q' := (coefficientSheaf S E').obj.obj (op (rightOpen S))
  let M' := overlapModule S E'
  let : Module R P' := Module.compHom P' (algebraMap R S)
  let : Module R Q' := Module.compHom Q' (algebraMap R S)
  let : Module R M' := Module.compHom M' (algebraMap R S)
  let : IsScalarTower R S P' := IsScalarTower.of_algebraMap_smul (fun _ _ => rfl)
  let : IsScalarTower R S Q' := IsScalarTower.of_algebraMap_smul (fun _ _ => rfl)
  let : IsScalarTower R S M' := IsScalarTower.of_algebraMap_smul (fun _ _ => rfl)
  let a : P →ₗ[R] M := ((coefficientSheaf R E).obj.map (homOfLE inf_le_left).op).hom
  let b : Q →ₗ[R] M := ((coefficientSheaf R E).obj.map (homOfLE inf_le_right).op).hom
  let a' : P' →ₗ[S] M' := ((coefficientSheaf S E').obj.map (homOfLE inf_le_left).op).hom
  let b' : Q' →ₗ[S] M' := ((coefficientSheaf S E').obj.map (homOfLE inf_le_right).op).hom
  let p : P →ₗ[R] P' := actualUnit E _ _ left_base_preimage.le
  let q : Q →ₗ[R] Q' := actualUnit E _ _ right_base_preimage.le
  let m : M →ₗ[R] M' := actualUnit E _ _ overlap_base_preimage.le
  have hp : IsBaseChange S p := actualUnit_isBaseChange E _ _ (left_affine R) (left_affine S) left_base_preimage
  have hq : IsBaseChange S q := actualUnit_isBaseChange E _ _ (right_affine R) (right_affine S) right_base_preimage
  have hm : IsBaseChange S m := actualUnit_isBaseChange E _ _ (overlap_affine R) (overlap_affine S) overlap_base_preimage
  exact RelativeCech.tensor_cech_vanish R S P Q M P' Q' M' a b a' b' p q m hp hq hm
    (fun x => actualUnit_naturality E _ _ _ _ inf_le_left inf_le_left _ _ x)
    (fun x => actualUnit_naturality E _ _ _ _ inf_le_right inf_le_right _ _ x)
    (trivial_ranges_top S E' n hf)
end

open CategoryTheory AlgebraicGeometry Opposite
open RelativeLineCharts RelativeProjectiveBaseChange
universe u
variable (R : Type u) [CommRing R] (E : (scheme R).Modules)
abbrev globalModule : ModuleCat R := (coefficientSheaf R E).obj.obj (op ⊤)
abbrev pairModule := ((coefficientSheaf R E).obj.obj (op (leftOpen R))) ×
  ((coefficientSheaf R E).obj.obj (op (rightOpen R)))
def sectionPair : globalModule R E →ₗ[R] pairModule R E :=
  ((coefficientSheaf R E).obj.map (homOfLE (show leftOpen R ≤ ⊤ from le_top)).op).hom.prod
    ((coefficientSheaf R E).obj.map (homOfLE (show rightOpen R ≤ ⊤ from le_top)).op).hom
def difference : pairModule R E →ₗ[R] overlapModule R E :=
  ((coefficientSheaf R E).obj.map (homOfLE (show leftOpen R ⊓ rightOpen R ≤ leftOpen R from inf_le_left)).op).hom.comp (LinearMap.fst R _ _) -
    ((coefficientSheaf R E).obj.map (homOfLE (show leftOpen R ⊓ rightOpen R ≤ rightOpen R from inf_le_right)).op).hom.comp (LinearMap.snd R _ _)
lemma sectionPair_injective : Function.Injective (sectionPair R E) := by
  intro x y h
  exact (coefficientSheaf R E).eq_of_locally_eq₂
    (homOfLE le_top : leftOpen R ⟶ ⊤) (homOfLE le_top : rightOpen R ⟶ ⊤)
    (by rw [standard_cover R]) x y (congrArg Prod.fst h) (congrArg Prod.snd h)
lemma difference_sectionPair : (difference R E).comp (sectionPair R E) = 0 := by
  ext s
  change (coefficientSheaf R E).obj.map _ ((coefficientSheaf R E).obj.map _ s) -
    (coefficientSheaf R E).obj.map _ ((coefficientSheaf R E).obj.map _ s) = 0
  rw [← ConcreteCategory.comp_apply, ← ConcreteCategory.comp_apply,
    ← Functor.map_comp, ← Functor.map_comp]
  exact sub_self _
lemma sectionPair_exact : Function.Exact (sectionPair R E) (difference R E) := by
  intro x
  constructor
  · intro hx
    have hab : (coefficientSheaf R E).obj.map (homOfLE (show leftOpen R ⊓ rightOpen R ≤ leftOpen R from inf_le_left)).op x.1 =
      (coefficientSheaf R E).obj.map (homOfLE (show leftOpen R ⊓ rightOpen R ≤ rightOpen R from inf_le_right)).op x.2 :=
      sub_eq_zero.mp hx
    let U : Bool → (scheme R).Opens := fun i => if i then leftOpen R else rightOpen R
    let sf : ∀ i, (coefficientSheaf R E).obj.obj (op (U i)) := fun i =>
      if h : i then by simpa [U,h] using x.1 else by simpa [U,h] using x.2
    have hc : TopCat.Presheaf.IsCompatible (coefficientSheaf R E).obj U sf := by
      intro i j
      cases i <;> cases j
      · rfl
      · have he := congrArg ((coefficientSheaf R E).obj.map (eqToHom (inf_comm (rightOpen R) (leftOpen R))).op) hab
        simpa [U,sf, TopologicalSpace.Opens.infLELeft, TopologicalSpace.Opens.infLERight,
          ← ConcreteCategory.comp_apply, ← Functor.map_comp] using he.symm
      · exact hab
      · rfl
    obtain ⟨s,hs,_⟩ := (coefficientSheaf R E).existsUnique_gluing' U ⊤
      (fun _ => homOfLE le_top) (by
        rw [← standard_cover R]
        exact sup_le (le_iSup U true) (le_iSup U false)) sf hc
    refine ⟨s,?_⟩
    exact Prod.ext (hs true) (hs false)
  · rintro ⟨s,rfl⟩
    exact LinearMap.congr_fun (difference_sectionPair R E) s
end CampanaPeternellSix.ActualCech

namespace CampanaPeternellSix.RelativeCech
section
open scoped TensorProduct
open TensorProduct
universe u
variable {R : Type u} [CommRing R]
variable {M₁ M₂ M₃ : Type u} [AddCommGroup M₁] [AddCommGroup M₂] [AddCommGroup M₃]
  [Module R M₁] [Module R M₂] [Module R M₃]
lemma left_exact_residue_baseChange (p : PrimeSpectrum R)
    (f : M₁ →ₗ[R] M₂) (g : M₂ →ₗ[R] M₃)
    (hex : Function.Exact f g) (hinj : Function.Injective f)
    [Module.Flat R M₃] [Module.Finite R (M₃ ⧸ LinearMap.range g)]
    [Subsingleton (p.asIdeal.ResidueField ⊗[R] (M₃ ⧸ LinearMap.range g))] :
    Function.Exact (f.baseChange p.asIdeal.ResidueField) (g.baseChange p.asIdeal.ResidueField) ∧
      Function.Injective (f.baseChange p.asIdeal.ResidueField) := by
  let Q := M₃ ⧸ LinearMap.range g
  let Rp := Localization.AtPrime p.asIdeal
  let K := p.asIdeal.ResidueField
  have hnot : p ∉ Module.support R Q := by
    rw [Module.mem_support_iff_nontrivial_residueField_tensorProduct]
    exact not_nontrivial _
  let : Subsingleton (LocalizedModule p.asIdeal.primeCompl Q) := Module.notMem_support_iff.mp hnot
  let : Subsingleton (Rp ⊗[R] Q) :=
    (LocalizedModule.equivTensorProduct p.asIdeal.primeCompl Q).symm.injective.subsingleton
  have hQ : Function.Exact g (LinearMap.range g).mkQ := by
    intro x
    simp only [Submodule.mkQ_apply, Submodule.Quotient.mk_eq_zero, LinearMap.mem_range]
    rfl
  have hsurj : Function.Surjective (g.baseChange Rp) := by
    have h := lTensor_exact Rp hQ (LinearMap.range g).mkQ_surjective
    intro x
    exact (h x).mp (Subsingleton.elim _ _)
  have hRp : Function.Exact (f.baseChange Rp) (g.baseChange Rp) :=
    Module.Flat.lTensor_exact Rp hex
  have hinjRp : Function.Injective (f.baseChange Rp) :=
    Module.Flat.lTensor_preserves_injective_linearMap f hinj
  have hKK : Function.Exact ((f.baseChange Rp).baseChange K) ((g.baseChange Rp).baseChange K) :=
    lTensor_exact K hRp hsurj
  have hinjKK : Function.Injective ((f.baseChange Rp).baseChange K) :=
    LinearMap.lTensor_injective_of_exact_of_flat (g.baseChange Rp) hsurj
      (f.baseChange Rp) hinjRp hRp K
  let e₁ := AlgebraTensorModule.cancelBaseChange R Rp K K M₁
  let e₂ := AlgebraTensorModule.cancelBaseChange R Rp K K M₂
  let e₃ := AlgebraTensorModule.cancelBaseChange R Rp K K M₃
  have hc₁ : (f.baseChange K).comp e₁.toLinearMap =
      e₂.toLinearMap.comp ((f.baseChange Rp).baseChange K) := by
    exact AlgebraTensorModule.lTensor_comp_cancelBaseChange R Rp K f
  have hc₂ : (g.baseChange K).comp e₂.toLinearMap =
      e₃.toLinearMap.comp ((g.baseChange Rp).baseChange K) := by
    exact AlgebraTensorModule.lTensor_comp_cancelBaseChange R Rp K g
  refine ⟨Function.Exact.of_ladder_linearEquiv_of_exact hc₁ hc₂ hKK, ?_⟩
  intro x y hxy
  apply e₁.symm.injective
  apply hinjKK
  apply e₂.injective
  have hx := congrArg (fun l : (K ⊗[Rp] (Rp ⊗[R] M₁)) →ₗ[K] (K ⊗[R] M₂) => l (e₁.symm x)) hc₁
  have hy := congrArg (fun l : (K ⊗[Rp] (Rp ⊗[R] M₁)) →ₗ[K] (K ⊗[R] M₂) => l (e₁.symm y)) hc₁
  simp only [LinearMap.comp_apply, LinearEquiv.coe_coe, LinearEquiv.apply_symm_apply] at hx hy
  exact hx.symm.trans (hxy.trans hy)
end

open scoped TensorProduct
universe u
variable {R : Type u} [CommRing R] (p : PrimeSpectrum R)
variable {M₁ M₂ M₃ N₁ N₂ N₃ : Type u} [AddCommGroup M₁] [AddCommGroup M₂] [AddCommGroup M₃]
  [AddCommGroup N₁] [AddCommGroup N₂] [AddCommGroup N₃] [Module R M₁] [Module R M₂] [Module R M₃]
  [Module R N₁] [Module R N₂] [Module R N₃] [Module (p.asIdeal.ResidueField) N₁] [Module (p.asIdeal.ResidueField) N₂] [Module (p.asIdeal.ResidueField) N₃]
  [IsScalarTower R (p.asIdeal.ResidueField) N₁] [IsScalarTower R (p.asIdeal.ResidueField) N₂] [IsScalarTower R (p.asIdeal.ResidueField) N₃]
  (h₁ : M₁ →ₗ[R] N₁) (h₂ : M₂ →ₗ[R] N₂) (h₃ : M₃ →ₗ[R] N₃)
  {f : M₁ →ₗ[R] M₂} {g : M₂ →ₗ[R] M₃} {f' : N₁ →ₗ[(p.asIdeal.ResidueField)] N₂} {g' : N₂ →ₗ[(p.asIdeal.ResidueField)] N₃}
lemma isBaseChange_of_left_exact_at_prime
    (comm₁ : h₂.comp f = (f'.restrictScalars R).comp h₁)
    (comm₂ : h₃.comp g = (g'.restrictScalars R).comp h₂) [Module.Flat R M₃]
    [Module.Finite R (M₃ ⧸ LinearMap.range g)]
    [Subsingleton ((p.asIdeal.ResidueField) ⊗[R] (M₃ ⧸ LinearMap.range g))]
    (isb₂ : IsBaseChange (p.asIdeal.ResidueField) h₂) (isb₃ : IsBaseChange (p.asIdeal.ResidueField) h₃)
    (exact₁ : Function.Exact f g) (inj₁ : Function.Injective f)
    (exact₂ : Function.Exact f' g') (inj₂ : Function.Injective f') : IsBaseChange (p.asIdeal.ResidueField) h₁ := by
  simp only [IsBaseChange, IsTensorProduct] at isb₂ isb₃ ⊢
  refine LinearMap.bijective_of_bijective_of_injective_of_left_exact
    ((f.baseChange (p.asIdeal.ResidueField)).restrictScalars R) ((g.baseChange (p.asIdeal.ResidueField)).restrictScalars R)
    (f'.restrictScalars R) (g'.restrictScalars R) _ _ _ ?_ ?_ ?_ exact₂ isb₂ isb₃.1 ?_ inj₂
  · ext s m
    simpa using congr(s • ($comm₁ m)).symm
  · ext s m
    simpa using congr(s • ($comm₂ m)).symm
  · exact (left_exact_residue_baseChange p f g exact₁ inj₁).1
  · exact (left_exact_residue_baseChange p f g exact₁ inj₁).2
end CampanaPeternellSix.RelativeCech

namespace CampanaPeternellSix.ActualCech
section
open CategoryTheory AlgebraicGeometry Opposite
open RelativeLineCharts RelativeProjectiveBaseChange Scheme.Modules
open scoped TensorProduct
universe u
variable {R : Type u} [CommRing R] (x : PrimeSpectrum R)
lemma global_sections_base_change_prime_core (E : (scheme R).Modules) [E.IsQuasicoherent]
    [Module.Flat R (overlapModule R E)]
    [Module.Finite R ((overlapModule R E) ⧸ LinearMap.range (difference R E))]
    [Subsingleton ((x.asIdeal.ResidueField) ⊗[R] ((overlapModule R E) ⧸ LinearMap.range (difference R E)))] :
    let N := (coefficientSheaf (x.asIdeal.ResidueField) ((pullback (baseMap (algebraMap R (x.asIdeal.ResidueField)) 1)).obj E)).obj.obj (op ⊤)
    letI : Module R N := Module.compHom N (algebraMap R (x.asIdeal.ResidueField))
    letI : IsScalarTower R (x.asIdeal.ResidueField) N := IsScalarTower.of_algebraMap_smul (fun _ _ => rfl)
    IsBaseChange (x.asIdeal.ResidueField) (actualUnit (S := x.asIdeal.ResidueField) E ⊤ ⊤ (by intro z _; trivial)) := by
  let E' := (pullback (baseMap (algebraMap R (x.asIdeal.ResidueField)) 1)).obj E
  let P' := (coefficientSheaf (x.asIdeal.ResidueField) E').obj.obj (op (leftOpen (x.asIdeal.ResidueField)))
  let Q' := (coefficientSheaf (x.asIdeal.ResidueField) E').obj.obj (op (rightOpen (x.asIdeal.ResidueField)))
  let M' := overlapModule (x.asIdeal.ResidueField) E'
  let N := globalModule (x.asIdeal.ResidueField) E'
  let : Module R P' := Module.compHom P' (algebraMap R (x.asIdeal.ResidueField))
  let : Module R Q' := Module.compHom Q' (algebraMap R (x.asIdeal.ResidueField))
  let : Module R M' := Module.compHom M' (algebraMap R (x.asIdeal.ResidueField))
  let : Module R N := Module.compHom N (algebraMap R (x.asIdeal.ResidueField))
  let : IsScalarTower R (x.asIdeal.ResidueField) P' := IsScalarTower.of_algebraMap_smul (fun _ _ => rfl)
  let : IsScalarTower R (x.asIdeal.ResidueField) Q' := IsScalarTower.of_algebraMap_smul (fun _ _ => rfl)
  let : IsScalarTower R (x.asIdeal.ResidueField) M' := IsScalarTower.of_algebraMap_smul (fun _ _ => rfl)
  let : IsScalarTower R (x.asIdeal.ResidueField) N := IsScalarTower.of_algebraMap_smul (fun _ _ => rfl)
  let p : _ →ₗ[R] P' := actualUnit E _ _ left_base_preimage.le
  let q : _ →ₗ[R] Q' := actualUnit E _ _ right_base_preimage.le
  let m : overlapModule R E →ₗ[R] M' := actualUnit E _ _ overlap_base_preimage.le
  let g : globalModule R E →ₗ[R] N := actualUnit E ⊤ ⊤ (by intro z _; trivial)
  let pq : pairModule R E →ₗ[R] P' × Q' := p.prodMap q
  have hp : IsBaseChange (x.asIdeal.ResidueField) p := actualUnit_isBaseChange E _ _ (left_affine R) (left_affine (x.asIdeal.ResidueField)) left_base_preimage
  have hq : IsBaseChange (x.asIdeal.ResidueField) q := actualUnit_isBaseChange E _ _ (right_affine R) (right_affine (x.asIdeal.ResidueField)) right_base_preimage
  have hm : IsBaseChange (x.asIdeal.ResidueField) m := actualUnit_isBaseChange E _ _ (overlap_affine R) (overlap_affine (x.asIdeal.ResidueField)) overlap_base_preimage
  have hpq : IsBaseChange (x.asIdeal.ResidueField) pq := IsBaseChange.prodMap p q hp hq
  have hsec : pq.comp (sectionPair R E) = ((sectionPair (x.asIdeal.ResidueField) E').restrictScalars R).comp g := by
    apply LinearMap.ext
    intro s
    apply Prod.ext
    · exact actualUnit_naturality E (leftOpen R) ⊤ (leftOpen (x.asIdeal.ResidueField)) ⊤ le_top le_top _ _ s
    · exact actualUnit_naturality E (rightOpen R) ⊤ (rightOpen (x.asIdeal.ResidueField)) ⊤ le_top le_top _ _ s
  have hdiff : m.comp (difference R E) = ((difference (x.asIdeal.ResidueField) E').restrictScalars R).comp pq := by
    apply LinearMap.ext
    intro x
    change m (_ - _) = _ - _
    rw [map_sub]
    exact congrArg₂ (· - ·)
      (actualUnit_naturality E _ _ _ _ inf_le_left inf_le_left _ _ x.1)
      (actualUnit_naturality E _ _ _ _ inf_le_right inf_le_right _ _ x.2)
  exact RelativeCech.isBaseChange_of_left_exact_at_prime x g pq m hsec hdiff hpq hm
    (sectionPair_exact R E) (sectionPair_injective R E)
    (sectionPair_exact (x.asIdeal.ResidueField) E') (sectionPair_injective (x.asIdeal.ResidueField) E')
end

section
open CategoryTheory AlgebraicGeometry Opposite
open RelativeLineCharts RelativeProjectiveBaseChange
universe u
variable (R : Type u) [CommRing R] (E : (scheme R).Modules)
lemma difference_range : LinearMap.range (difference R E) = leftImage R E ⊔ rightImage R E := by
  apply le_antisymm
  · rintro _ ⟨⟨x,y⟩,rfl⟩
    apply Submodule.sub_mem
    · exact Submodule.mem_sup_left ⟨x,rfl⟩
    · exact Submodule.mem_sup_right ⟨y,rfl⟩
  · intro m hm
    obtain ⟨a,⟨x,rfl⟩,b,⟨y,rfl⟩,hab⟩ := Submodule.mem_sup.mp hm
    refine ⟨(x,-y),?_⟩
    change _ - ((coefficientSheaf R E).obj.map _).hom (-y) = m
    rw [map_neg, sub_neg_eq_add]
    exact hab
end

section
open CategoryTheory AlgebraicGeometry Opposite
open RelativeLineCharts RelativeProjectiveBaseChange
open scoped Polynomial LaurentPolynomial
universe u
variable (R : Type u) [CommRing R]
lemma flat_overlap_base (E : (scheme R).Modules)
    (hE : ∃ q : E.LocalGeneratorsData, q.IsLocallyFreeData ∧ q.IsFiniteType) :
    Module.Flat R (overlapModule R E) := by
  let A := Γ(scheme R,leftOpen R ⊓ rightOpen R)
  let r : R →+* A := ((scheme R).presheaf.map (homOfLE
    (show leftOpen R ⊓ rightOpen R ≤ ⊤ from le_top)).op).hom.comp
      (RelativeLineGlobalFunctions.scalars R)
  let : Algebra R A := r.toAlgebra
  let e : A ≃ₗ[R] R[T;T⁻¹] := { overlapSectionEquiv R with
    map_smul' := fun a b => by
      change overlapSectionEquiv R (a • b) = a • overlapSectionEquiv R b
      rw [Algebra.smul_def, Algebra.smul_def]
      change overlapSectionEquiv R (r a * b) = LaurentPolynomial.C a * overlapSectionEquiv R b
      rw [map_mul]
      exact congrArg (· * overlapSectionEquiv R b) (scalar_overlap R a) }
  have : Module.Flat R A := Module.Flat.of_linearEquiv e
  have : Module.Flat A (overlapModule R E) :=
    RelativeCech.flat_affine_open (scheme R) E hE _ (overlap_affine R)
  let : IsScalarTower R A (overlapModule R E) :=
    IsScalarTower.of_algebraMap_smul (fun _ _ => rfl)
  exact Module.Flat.trans R A (overlapModule R E)

lemma difference_surjective_of_cech_zero (E : (scheme R).Modules)
    [Subsingleton (quotient R E)] : Function.Surjective (difference R E) := by
  have ht : leftImage R E ⊔ rightImage R E = ⊤ :=
    Submodule.Quotient.subsingleton_iff.mp inferInstance
  intro m
  have hm : m ∈ leftImage R E ⊔ rightImage R E := by rw [ht]; trivial
  obtain ⟨a,⟨x,rfl⟩,b,⟨y,rfl⟩,hab⟩ := Submodule.mem_sup.mp hm
  refine ⟨(x,-y),?_⟩
  change _ - ((coefficientSheaf R E).obj.map _).hom (-y) = m
  rw [map_neg, sub_neg_eq_add]
  exact hab
end

open CategoryTheory AlgebraicGeometry Opposite
open RelativeLineCharts RelativeProjectiveBaseChange Scheme.Modules
open scoped TensorProduct
universe u
variable {R : Type u} [CommRing R]
theorem global_sections_base_change_at_trivial_fiber (E : (scheme R).Modules)
    (hE : ∃ q : E.LocalGeneratorsData, q.IsLocallyFreeData ∧ q.IsFiniteType)
    (p : PrimeSpectrum R) (n : ℕ)
    (hf : Nonempty ((pullback (baseMap (algebraMap R p.asIdeal.ResidueField) 1)).obj E ≅
      SheafOfModules.free (ULift.{u} (Fin n)))) :
    let S := p.asIdeal.ResidueField
    let N := (coefficientSheaf S ((pullback (baseMap (algebraMap R S) 1)).obj E)).obj.obj (op ⊤)
    letI : Module R N := Module.compHom N (algebraMap R S)
    letI : IsScalarTower R S N := IsScalarTower.of_algebraMap_smul (fun _ _ => rfl)
    IsBaseChange S (actualUnit (S := S) E ⊤ ⊤ (by intro z _; trivial)) := by
  have hfin := finite_actual_cech R E hE
  have hflat := flat_overlap_base R E hE
  obtain ⟨q,hq,ht⟩ := hE
  let := hq
  let := ht
  let : E.IsLocallyFree := q.isLocallyFree
  let : E.IsQuasicoherent := q.quasiCoherentData.isQuasicoherent
  have hzero := tensor_actual_cech_vanish_of_trivial_pullback E n hf
  let : Module.Flat R (overlapModule R E) := hflat
  let : Module.Finite R ((overlapModule R E) ⧸ LinearMap.range (difference R E)) := by
    rw [difference_range]
    exact hfin
  let : Subsingleton (p.asIdeal.ResidueField ⊗[R]
      ((overlapModule R E) ⧸ LinearMap.range (difference R E))) := by
    rw [difference_range]
    exact hzero
  exact global_sections_base_change_prime_core p E
end CampanaPeternellSix.ActualCech

end

end OAI