| import OAI.AlgebraicGeometry.SurfaceCones.ModelSheaf |
|
|
| namespace OAI |
|
|
|
|
| /-! Reflexivity and punctured pullback of a finite module of depth three. -/ |
| noncomputable section |
| open CategoryTheory _root_.AlgebraicGeometry _root_.OAI.AlgebraicGeometry Scheme.Modules |
| namespace ExplicitCone |
| lemma module_reflexive_from_depth_three (M : Type) [AddCommGroup M] |
| [Module completedRing M] [Module.Finite completedRing M] [Nontrivial M] |
| (hdepth : SmallCM.localDepth completedRing M = 3) : |
| Module.IsReflexive completedRing M := by |
| let := actualCompletion_noetherian |
| let := (module_properties_from_depth_three M hdepth).1 |
| obtain ⟨rs, hm, hr, hl⟩ := |
| SmallCM.exists_regularSequence_of_localDepth_eq (n := 2) hdepth |
| exact CMReflexivity.reflexive_of_regular_three completedRing_dimension rs hm hr hl |
| end ExplicitCone |
| namespace SourceConeMorphism |
| open KummerSourceModel |
| abbrev punctureInclusion := (p ⁻¹ᵁ ExplicitCone.completedPunctureOpen).ι |
|
|
| instance punctureInclusion_comp_p_openImmersion : IsOpenImmersion (punctureInclusion ≫ p) := by |
| rw [← puncturedIso_hom_ι] |
| infer_instance |
|
|
| def E_punctureIso (M : ModuleCat.{0} ExplicitCone.completedRing) |
| [Module.Finite ExplicitCone.completedRing M] [Nontrivial M] |
| (hdepth : SmallCM.localDepth ExplicitCone.completedRing M = 3) : |
| (pullback punctureInclusion).obj (E M) ≅ |
| (pullback (p ∣_ ExplicitCone.completedPunctureOpen)).obj |
| ((pullback ExplicitCone.completedPunctureOpen.ι).obj (tilde M)) := by |
| letI := ExplicitCone.actualCompletion_noetherian |
| letI := ExplicitCone.module_reflexive_from_depth_three M hdepth |
| exact CMReflexiveSheaf.punctureEIso (R := CommRingCat.of ExplicitCone.completedRing) M p ExplicitCone.completedPunctureOpen |
| end SourceConeMorphism |
|
|
| end |
|
|
| noncomputable section |
| open CategoryTheory CategoryTheory.Limits Opposite _root_.AlgebraicGeometry _root_.OAI.AlgebraicGeometry |
| namespace CoherentBaseChange |
| open Scheme.Modules |
| variable {X Y : Scheme.{0}} (f : X ⟶ Y) (U : Y.Opens) (M : X.Modules) |
|
|
| def pushforwardRestrictSource : U.toScheme.Modules := |
| (restrictFunctor U.ι).obj ((pushforward f).obj M) |
|
|
| def pushforwardRestrictTarget : U.toScheme.Modules := |
| (pushforward (f ∣_ U)).obj ((restrictFunctor (f ⁻¹ᵁ U).ι).obj M) |
|
|
| /-- Finite-open restriction of pushforward, on sections. -/ |
| def pushforwardRestrictAppIso (V : U.toScheme.Opens) : |
| ((pushforwardRestrictSource f U M).val.obj (op V)) ≅ |
| ((pushforwardRestrictTarget f U M).val.obj (op V)) := by |
| refine ModuleCat.isoMk |
| (M.presheaf.mapIso (eqToIso (image_morphismRestrict_preimage f U V)).op) ?_ |
| intro r |
| change M.presheaf.map (eqToHom (image_morphismRestrict_preimage f U V)).op ≫ |
| M.smul (((f ⁻¹ᵁ U).ι.appIso _).inv ((f ∣_ U).app V r)) = |
| M.smul (f.app _ ((U.ι.appIso V).inv r)) ≫ |
| M.presheaf.map (eqToHom (image_morphismRestrict_preimage f U V)).op |
| simp only [Scheme.Opens.ι_appIso, Iso.refl_inv] |
| rw [morphismRestrict_app] |
| exact (M.map_comp_smul (eqToHom (image_morphismRestrict_preimage f U V)) |
| (f.app _ r)).symm |
|
|
| lemma pushforwardRestrictAppIso_naturality {V W : U.toScheme.Opensᵒᵖ} (g : V ⟶ W) : |
| (pushforwardRestrictSource f U M).val.map g ≫ |
| (ModuleCat.restrictScalars (U.toScheme.ringCatSheaf.obj.map g).hom).map |
| (pushforwardRestrictAppIso f U M W.unop).hom = |
| (pushforwardRestrictAppIso f U M V.unop).hom ≫ |
| (pushforwardRestrictTarget f U M).val.map g := by |
| apply ModuleCat.hom_ext |
| apply LinearMap.ext |
| intro x |
| change (M.presheaf.map ((TopologicalSpace.Opens.map f.base).map |
| (U.ι.opensFunctor.map g.unop)).op ≫ |
| M.presheaf.map (eqToHom (image_morphismRestrict_preimage f U W.unop)).op) x = |
| (M.presheaf.map (eqToHom (image_morphismRestrict_preimage f U V.unop)).op ≫ |
| M.presheaf.map ((f ⁻¹ᵁ U).ι.opensFunctor.map |
| ((TopologicalSpace.Opens.map (f ∣_ U).base).map g.unop)).op) x |
| rw [← M.presheaf.map_comp, ← M.presheaf.map_comp] |
| congr 2 |
|
|
| /-- Open base change for sheaves of modules; no assumption of flat base change or quasicoherence is |
| needed for restriction to an open. -/ |
| def pushforwardRestrictIso : |
| (restrictFunctor U.ι).obj ((pushforward f).obj M) ≅ |
| (pushforward (f ∣_ U)).obj ((restrictFunctor (f ⁻¹ᵁ U).ι).obj M) := |
| (SheafOfModules.fullyFaithfulForget _).preimageIso |
| (PresheafOfModules.isoMk (fun V => pushforwardRestrictAppIso f U M V.unop) |
| (fun _ _ g => pushforwardRestrictAppIso_naturality f U M g)) |
| end CoherentBaseChange |
|
|
| end |
|
|
| noncomputable section |
| open CategoryTheory CategoryTheory.Limits _root_.AlgebraicGeometry _root_.OAI.AlgebraicGeometry |
| namespace CoherentGlobal |
| open Scheme.Modules |
|
|
| /-- A finite global presentation on an affine scheme is the associated sheaf of a finite module, via |
| the finite cokernel of its presentation. -/ |
| lemma exists_finite_module_of_presentation {R : CommRingCat} |
| (M : (Spec R).Modules) (P : M.Presentation) [P.IsFinite] : |
| ∃ N : ModuleCat R, Module.Finite R N ∧ Nonempty (tilde N ≅ M) := by |
| let : Finite P.generators.I := |
| (SheafOfModules.Presentation.IsFinite.isFiniteType_generators (p := P)).finite |
| let A := ModuleCat.of R (P.relations.I →₀ R) |
| let B := ModuleCat.of R (P.generators.I →₀ R) |
| let f : SheafOfModules.free P.relations.I ⟶ SheafOfModules.free P.generators.I := |
| P.relations.π ≫ kernel.ι P.generators.π |
| let g : A ⟶ B := (tilde.functor R).preimage |
| ((tildeFinsupp P.relations.I).hom ≫ f ≫ (tildeFinsupp P.generators.I).inv) |
| let N := ModuleCat.of R (B ⧸ g.hom.range) |
| have : Module.Finite R B := inferInstanceAs (Module.Finite R (P.generators.I →₀ R)) |
| refine ⟨N, inferInstance, ⟨?_⟩⟩ |
| let e : cokernel ((tilde.functor R).map g) ≅ cokernel f := by |
| refine cokernel.mapIso _ _ (tildeFinsupp _) (tildeFinsupp _) ?_ |
| change (tilde.functor R).map g ≫ (tildeFinsupp P.generators.I).hom = |
| (tildeFinsupp P.relations.I).hom ≫ f |
| have hg : (tilde.functor R).map g = |
| (tildeFinsupp P.relations.I).hom ≫ f ≫ (tildeFinsupp P.generators.I).inv := |
| (tilde.functor R).map_preimage _ |
| exact (congrArg (fun k => k ≫ (tildeFinsupp P.generators.I).hom) hg).trans |
| (by |
| have cancel {X Y Z T : (Spec R).Modules} |
| (u : X ⟶ Y) (v : Y ⟶ Z) (e : T ≅ Z) : |
| (u ≫ v ≫ e.inv) ≫ e.hom = u ≫ v := by |
| simp only [Category.assoc, Iso.inv_hom_id, Category.comp_id] |
| exact cancel (tildeFinsupp P.relations.I).hom f (tildeFinsupp P.generators.I)) |
| exact (tilde.functor R).mapIso (ModuleCat.cokernelIsoRangeQuotient g).symm ≪≫ |
| PreservesCokernel.iso (tilde.functor R) g ≪≫ e ≪≫ |
| IsColimit.coconePointUniqueUpToIso (colimit.isColimit _) P.isColimit |
|
|
| lemma exists_presentation_kernel_of_presentations {R : CommRingCat} [IsNoetherianRing R] |
| {M N : (Spec R).Modules} (f : M ⟶ N) |
| (PM : M.Presentation) [PM.IsFinite] (PN : N.Presentation) [PN.IsFinite] : |
| ∃ P : (kernel f).Presentation, P.IsFinite := by |
| obtain ⟨A, hA, ⟨eA⟩⟩ := exists_finite_module_of_presentation M PM |
| obtain ⟨B, hB, ⟨eB⟩⟩ := exists_finite_module_of_presentation N PN |
| let := hA |
| let := hB |
| let g := eA.hom ≫ f ≫ eB.inv |
| let e : kernel f ≅ kernel g := CoherentDual.kernelConjugateIso f eA.symm eB.symm |
| exact exists_presentation_iso e.symm (exists_presentation_kernel g) |
|
|
| lemma exists_presentation_cokernel_tilde {R : CommRingCat} |
| [IsNoetherianRing R] {M N : ModuleCat R} [Module.Finite R N] (f : M ⟶ N) : |
| ∃ P : (cokernel (tilde.map f)).Presentation, P.IsFinite := by |
| let e : cokernel (tilde.map f) ≅ tilde (ModuleCat.of R (N ⧸ f.hom.range)) := |
| (PreservesCokernel.iso (tilde.functor R) f).symm ≪≫ |
| (tilde.functor R).mapIso (ModuleCat.cokernelIsoRangeQuotient f) |
| exact exists_presentation_iso e.symm (exists_presentation_tilde _) |
|
|
| lemma exists_presentation_cokernel_of_presentations {R : CommRingCat} [IsNoetherianRing R] |
| {M N : (Spec R).Modules} (f : M ⟶ N) |
| (PM : M.Presentation) [PM.IsFinite] (PN : N.Presentation) [PN.IsFinite] : |
| ∃ P : (cokernel f).Presentation, P.IsFinite := by |
| obtain ⟨A, hA, ⟨eA⟩⟩ := exists_finite_module_of_presentation M PM |
| obtain ⟨B, hB, ⟨eB⟩⟩ := exists_finite_module_of_presentation N PN |
| let := hA |
| let := hB |
| let g := eA.hom ≫ f ≫ eB.inv |
| let h := (tilde.functor R).preimage g |
| have hg : (tilde.functor R).map h = g := (tilde.functor R).map_preimage g |
| let e : cokernel f ≅ cokernel g := |
| cokernel.mapIso _ _ eA.symm eB.symm (by simp [g]) |
| let e' : cokernel ((tilde.functor R).map h) ≅ cokernel g := |
| cokernel.mapIso _ _ (Iso.refl _) (Iso.refl _) (by |
| change (tilde.functor R).map h = g |
| exact hg) |
| exact exists_presentation_iso (e' ≪≫ e.symm) (exists_presentation_cokernel_tilde h) |
|
|
| /-- Refine any one finite presentation chart to an arbitrary affine open inside it. This is used to |
| put two coherent sheaves in finite module form on the same affine cover, without assuming global |
| finite generation. -/ |
| lemma exists_presentation_affine_below {X : Scheme} (M : X.Modules) (U : X.Opens) |
| (P : (M.over U).Presentation) [P.IsFinite] (V : X.affineOpens) (hV : V.1 ≤ U) : |
| ∃ Q : ((restrictFunctor (V.2.isoSpec.inv ≫ V.1.ι)).obj M).Presentation, |
| Q.IsFinite := by |
| let h : Spec Γ(X, V.1) ⟶ U.toScheme := V.2.isoSpec.inv ≫ X.homOfLE hV |
| let F : SheafOfModules (X.ringCatSheaf.over U) ⥤ |
| SheafOfModules (Spec Γ(X, V.1)).ringCatSheaf := |
| (overEquiv U).functor ⋙ restrictFunctor h |
| have : F.IsLeftAdjoint := inferInstanceAs |
| ((overEquiv U).functor ⋙ restrictFunctor h).IsLeftAdjoint |
| let e : SheafOfModules.unit (Spec Γ(X, V.1)).ringCatSheaf ≅ |
| F.obj (SheafOfModules.unit (X.ringCatSheaf.over U)) := |
| (restrictUnitIso h).symm ≪≫ (restrictFunctor h).mapIso |
| (TopologicalSpace.Opens.sheafOfModulesEquivOverUnit U X.ringCatSheaf).symm |
| let q : F.obj (M.over U) ≅ (restrictFunctor (V.2.isoSpec.inv ≫ V.1.ι)).obj M := |
| (restrictFunctor h).mapIso ((overFunctorEquiv U).app M) ≪≫ |
| ((restrictFunctorComp h U.ι).app M).symm ≪≫ |
| (restrictFunctorCongr (by dsimp [h]; simp)).app M |
| exact exists_presentation_iso q ⟨P.map F e, inferInstance⟩ |
|
|
| lemma exists_presentation_prod_of_presentations {R : CommRingCat} [IsNoetherianRing R] |
| (M N : (Spec R).Modules) |
| (PM : M.Presentation) [PM.IsFinite] (PN : N.Presentation) [PN.IsFinite] : |
| ∃ P : (M ⨯ N).Presentation, P.IsFinite := by |
| obtain ⟨A, hA, ⟨eA⟩⟩ := exists_finite_module_of_presentation M PM |
| obtain ⟨B, hB, ⟨eB⟩⟩ := exists_finite_module_of_presentation N PN |
| let := hA |
| let := hB |
| let e : ModuleCat.of R (A × B) ≅ A ⨯ B := |
| IsLimit.conePointUniqueUpToIso (ModuleCat.binaryProductLimitCone A B).isLimit |
| (limit.isLimit _) |
| let q : tilde (ModuleCat.of R (A × B)) ≅ M ⨯ N := |
| (tilde.functor R).mapIso e ≪≫ PreservesLimitPair.iso (tilde.functor R) A B ≪≫ |
| prod.mapIso eA eB |
| exact exists_presentation_iso q (exists_presentation_tilde _) |
|
|
| end CoherentGlobal |
|
|
| end |
|
|
| noncomputable section |
| open CategoryTheory CategoryTheory.Limits _root_.AlgebraicGeometry _root_.OAI.AlgebraicGeometry |
| namespace CoherentGlobal |
| open Scheme.Modules |
|
|
| /-- An affine common refinement of any two open covers. -/ |
| lemma exists_common_affine_refinement {X : Scheme.{0}} {I J : Type} |
| (A : I → X.Opens) (B : J → X.Opens) |
| (hA : (⨆ i, A i) = ⊤) (hB : (⨆ j, B j) = ⊤) : |
| ∃ (K : Type) (U : K → X.affineOpens), (⨆ k, (U k).1) = ⊤ ∧ |
| ∀ k, ∃ i j, (U k).1 ≤ A i ∧ (U k).1 ≤ B j := by |
| let K := {V : X.affineOpens // ∃ i j, V.1 ≤ A i ∧ V.1 ≤ B j} |
| refine ⟨K, fun V => V.1, ?_, fun V => V.property⟩ |
| apply le_antisymm le_top |
| intro x _ |
| obtain ⟨i, hi⟩ := TopologicalSpace.Opens.mem_iSup.mp |
| (show x ∈ ⨆ i, A i by rw [hA]; trivial) |
| obtain ⟨j, hj⟩ := TopologicalSpace.Opens.mem_iSup.mp |
| (show x ∈ ⨆ j, B j by rw [hB]; trivial) |
| obtain ⟨V, hV, hxV, hsub⟩ := exists_isAffineOpen_mem_and_subset |
| (U := A i ⊓ B j) (x := x) ⟨hi, hj⟩ |
| let v : K := ⟨⟨V, hV⟩, i, j, fun y hy => (hsub hy).1, fun y hy => (hsub hy).2⟩ |
| exact TopologicalSpace.Opens.mem_iSup.mpr ⟨v, hxV⟩ |
|
|
| /-- Two coherent sheaves admit finite module presentations on the same affine open cover. No global |
| generation assumption is imposed. -/ |
| lemma exists_common_affine_presentations {X : Scheme.{0}} (M N : X.Modules) |
| [M.IsFinitePresentation] [N.IsFinitePresentation] : |
| ∃ (I : Type) (U : I → X.affineOpens), |
| (⨆ i, (U i).1) = ⊤ ∧ ∀ i, |
| (∃ P : ((restrictFunctor ((U i).2.isoSpec.inv ≫ (U i).1.ι)).obj M).Presentation, |
| P.IsFinite) ∧ |
| (∃ P : ((restrictFunctor ((U i).2.isoSpec.inv ≫ (U i).1.ι)).obj N).Presentation, |
| P.IsFinite) := by |
| obtain ⟨DM, hDM⟩ := SheafOfModules.IsFinitePresentation.exists_quasicoherentData M |
| obtain ⟨DN, hDN⟩ := SheafOfModules.IsFinitePresentation.exists_quasicoherentData N |
| let := hDM |
| let := hDN |
| obtain ⟨I, U, hU, hsub⟩ := exists_common_affine_refinement DM.X DN.X |
| ((Opens.coversTop_iff X _).mp DM.coversTop) |
| ((Opens.coversTop_iff X _).mp DN.coversTop) |
| refine ⟨I, U, hU, ?_⟩ |
| intro k |
| obtain ⟨i, j, hi, hj⟩ := hsub k |
| let : (DM.presentation i).IsFinite := hDM.isFinite_presentation i |
| let : (DN.presentation j).IsFinite := hDN.isFinite_presentation j |
| exact ⟨exists_presentation_affine_below M (DM.X i) (DM.presentation i) (U k) hi, |
| exists_presentation_affine_below N (DN.X j) (DN.presentation j) (U k) hj⟩ |
|
|
| /-- The coherent sheaves on a locally Noetherian scheme are closed under kernels. The proof works on |
| a common affine cover and descends. -/ |
| lemma coherent_kernel {X : Scheme} [IsLocallyNoetherian X] |
| {M N : X.Modules} [M.IsFinitePresentation] [N.IsFinitePresentation] (f : M ⟶ N) : |
| (kernel f).IsFinitePresentation := by |
| obtain ⟨I, U, hU, hP⟩ := exists_common_affine_presentations M N |
| have hlocal (i : I) : ((kernel f).over (U i).1).IsFinitePresentation := by |
| let h := (U i).2.isoSpec.inv ≫ (U i).1.ι |
| let F : X.Modules ⥤ (Spec Γ(X, (U i).1)).Modules := restrictFunctor h |
| have : F.IsLeftAdjoint := inferInstanceAs (restrictFunctor h).IsLeftAdjoint |
| have : PreservesFiniteLimits F := CoherentRestriction.preservesFiniteLimits h |
| have : IsNoetherianRing Γ(X, (U i).1) := IsLocallyNoetherian.component_noetherian (U i) |
| obtain ⟨PM, hPM⟩ := (hP i).1 |
| obtain ⟨PN, hPN⟩ := (hP i).2 |
| let := hPM |
| let := hPN |
| have hp := exists_presentation_kernel_of_presentations (F.map f) PM PN |
| have hp' := exists_presentation_iso (PreservesKernel.iso F f).symm hp |
| obtain ⟨P, hfin⟩ := exists_presentation_affine_over (kernel f) (U i) hp' |
| let := hfin |
| exact CoherentLocality.finitePresentation_of_presentation P |
| exact @CoherentLocality.finitePresentation_of_coversTop _ _ _ _ _ _ _ _ |
| (kernel f) I (fun i => (U i).1) ((Opens.coversTop_iff X _).mpr hU) hlocal |
|
|
| lemma coherent_cokernel {X : Scheme} [IsLocallyNoetherian X] |
| {M N : X.Modules} [M.IsFinitePresentation] [N.IsFinitePresentation] (f : M ⟶ N) : |
| (cokernel f).IsFinitePresentation := by |
| obtain ⟨I, U, hU, hP⟩ := exists_common_affine_presentations M N |
| have hlocal (i : I) : ((cokernel f).over (U i).1).IsFinitePresentation := by |
| let h := (U i).2.isoSpec.inv ≫ (U i).1.ι |
| let F : X.Modules ⥤ (Spec Γ(X, (U i).1)).Modules := restrictFunctor h |
| have : F.IsLeftAdjoint := inferInstanceAs (restrictFunctor h).IsLeftAdjoint |
| have : IsNoetherianRing Γ(X, (U i).1) := IsLocallyNoetherian.component_noetherian (U i) |
| obtain ⟨PM, hPM⟩ := (hP i).1 |
| obtain ⟨PN, hPN⟩ := (hP i).2 |
| let := hPM |
| let := hPN |
| have hp := exists_presentation_cokernel_of_presentations (F.map f) PM PN |
| have hp' := exists_presentation_iso (PreservesCokernel.iso F f).symm hp |
| obtain ⟨P, hfin⟩ := exists_presentation_affine_over (cokernel f) (U i) hp' |
| let := hfin |
| exact CoherentLocality.finitePresentation_of_presentation P |
| exact @CoherentLocality.finitePresentation_of_coversTop _ _ _ _ _ _ _ _ |
| (cokernel f) I (fun i => (U i).1) ((Opens.coversTop_iff X _).mpr hU) hlocal |
| lemma coherent_prod {X : Scheme} [IsLocallyNoetherian X] |
| (M N : X.Modules) [M.IsFinitePresentation] [N.IsFinitePresentation] : |
| (M ⨯ N).IsFinitePresentation := by |
| obtain ⟨I, U, hU, hP⟩ := exists_common_affine_presentations M N |
| have hlocal (i : I) : ((M ⨯ N).over (U i).1).IsFinitePresentation := by |
| let h := (U i).2.isoSpec.inv ≫ (U i).1.ι |
| let F : X.Modules ⥤ (Spec Γ(X, (U i).1)).Modules := restrictFunctor h |
| have : F.IsLeftAdjoint := inferInstanceAs (restrictFunctor h).IsLeftAdjoint |
| have : PreservesFiniteLimits F := CoherentRestriction.preservesFiniteLimits h |
| have : IsNoetherianRing Γ(X, (U i).1) := IsLocallyNoetherian.component_noetherian (U i) |
| obtain ⟨PM, hPM⟩ := (hP i).1 |
| obtain ⟨PN, hPN⟩ := (hP i).2 |
| let := hPM |
| let := hPN |
| have hp := exists_presentation_prod_of_presentations (F.obj M) (F.obj N) PM PN |
| have hp' := exists_presentation_iso (PreservesLimitPair.iso F M N).symm hp |
| obtain ⟨P, hfin⟩ := exists_presentation_affine_over (M ⨯ N) (U i) hp' |
| let := hfin |
| exact CoherentLocality.finitePresentation_of_presentation P |
| exact @CoherentLocality.finitePresentation_of_coversTop _ _ _ _ _ _ _ _ |
| (M ⨯ N) I (fun i => (U i).1) ((Opens.coversTop_iff X _).mpr hU) hlocal |
|
|
| instance coherentContainsZero {X : Scheme} [IsLocallyNoetherian X] : |
| (SheafOfModules.isFinitePresentation X.ringCatSheaf).ContainsZero := by |
| let F : X.Modules := SheafOfModules.free PUnit |
| exact ⟨kernel (𝟙 F), isZero_kernel_of_mono _, coherent_kernel_free (𝟙 F)⟩ |
|
|
| instance coherentClosedKernels {X : Scheme} [IsLocallyNoetherian X] : |
| (SheafOfModules.isFinitePresentation X.ringCatSheaf).IsClosedUnderKernels where |
| kernels_le := by |
| rintro Y ⟨f, k, hk, hM, hN⟩ |
| let := hM |
| let := hN |
| exact (SheafOfModules.isFinitePresentation X.ringCatSheaf).prop_of_iso |
| (IsLimit.conePointUniqueUpToIso (kernelIsKernel f) hk) (coherent_kernel f) |
|
|
| instance coherentClosedCokernels {X : Scheme} [IsLocallyNoetherian X] : |
| (SheafOfModules.isFinitePresentation X.ringCatSheaf).IsClosedUnderCokernels where |
| cokernels_le := by |
| rintro Y ⟨f, k, hk, hM, hN⟩ |
| let := hM |
| let := hN |
| exact (SheafOfModules.isFinitePresentation X.ringCatSheaf).prop_of_iso |
| (IsColimit.coconePointUniqueUpToIso (cokernelIsCokernel f) hk) (coherent_cokernel f) |
|
|
| instance coherentClosedBinaryProducts {X : Scheme} [IsLocallyNoetherian X] : |
| (SheafOfModules.isFinitePresentation X.ringCatSheaf).IsClosedUnderBinaryProducts := by |
| apply ObjectProperty.IsClosedUnderLimitsOfShape.mk' |
| rintro Y ⟨F, hF⟩ |
| let := hF ⟨WalkingPair.left⟩ |
| let := hF ⟨WalkingPair.right⟩ |
| exact (SheafOfModules.isFinitePresentation X.ringCatSheaf).prop_of_iso |
| (HasLimit.isoOfNatIso (diagramIsoPair F)).symm |
| (coherent_prod (F.obj ⟨WalkingPair.left⟩) (F.obj ⟨WalkingPair.right⟩)) |
|
|
| instance coherentClosedFiniteProducts {X : Scheme} [IsLocallyNoetherian X] : |
| (SheafOfModules.isFinitePresentation X.ringCatSheaf).IsClosedUnderFiniteProducts := |
| ObjectProperty.IsClosedUnderFiniteProducts.mk' |
|
|
| /-- The abelian category of coherent structure-sheaf modules. -/ |
| abbrev Coh (X : Scheme) := |
| (SheafOfModules.isFinitePresentation X.ringCatSheaf).FullSubcategory |
|
|
| instance {X : Scheme} [IsLocallyNoetherian X] : Abelian (Coh X) := inferInstance |
|
|
| end CoherentGlobal |
|
|
|
|
| end |
|
|
| noncomputable section |
| open CategoryTheory CategoryTheory.Limits Opposite _root_.AlgebraicGeometry _root_.OAI.AlgebraicGeometry |
| namespace CoherentGlobal |
| open Scheme.Modules |
| lemma coherent_restrict {X Y : Scheme.{0}} (f : X ⟶ Y) [IsOpenImmersion f] |
| (M : Y.Modules) [M.IsFinitePresentation] : |
| ((restrictFunctor f).obj M).IsFinitePresentation := by |
| have (U : X.Opens) : (Over.post (X := U) f.opensFunctor).IsContinuous |
| ((Opens.grothendieckTopology X).over U) |
| ((Opens.grothendieckTopology Y).over (f ''ᵁ U)) := by |
| infer_instance |
| let α : X.presheaf ⟶ f.opensFunctor.op ⋙ Y.presheaf := |
| { app U := (f.appIso U.unop).inv } |
| let φ : X.ringCatSheaf ⟶ |
| (f.opensFunctor.sheafPushforwardContinuous RingCat.{0} |
| (Opens.grothendieckTopology X) (Opens.grothendieckTopology Y)).obj Y.ringCatSheaf := |
| ⟨Functor.whiskerRight α (forget₂ CommRingCat RingCat)⟩ |
| have : IsIso α := NatIso.isIso_of_isIso_app _ |
| have : IsIso ((sheafToPresheaf _ _).map φ) := by |
| change IsIso (Functor.whiskerRight α (forget₂ CommRingCat RingCat)) |
| infer_instance |
| have hφ : IsIso φ := |
| (fullyFaithfulSheafToPresheaf (Opens.grothendieckTopology X) RingCat).isIso_of_isIso_map φ |
| exact @CoherentLocality.finitePresentation_pushforward_of_isLeftAdjoint |
| _ _ _ _ _ _ _ _ _ _ _ _ f.opensFunctor _ _ φ (restrictUnitIso f) _ _ hφ _ _ M _ |
| end CoherentGlobal |
|
|
| namespace CoherentGlobal |
| open Scheme.Modules |
| lemma coherent_over_of_restrict {X : Scheme.{0}} (U : X.Opens) (M : X.Modules) |
| [((restrictFunctor U.ι).obj M).IsFinitePresentation] : |
| (M.over U).IsFinitePresentation := by |
| have : ((overEquiv U).inverse.obj ((restrictFunctor U.ι).obj M)).IsFinitePresentation := |
| finitePresentation_overEquiv_inverse U _ |
| let e : M.over U ≅ (overEquiv U).inverse.obj ((restrictFunctor U.ι).obj M) := |
| (overEquiv U).unitIso.app _ ≪≫ |
| (overEquiv U).inverse.mapIso ((overFunctorEquiv U).app M) |
| exact (SheafOfModules.isFinitePresentation (X.ringCatSheaf.over U)).prop_of_iso e.symm |
| inferInstance |
|
|
| lemma coherent_of_affine_restrict {X : Scheme.{0}} (M : X.Modules) |
| (h : ∀ U : X.affineOpens, ((restrictFunctor U.1.ι).obj M).IsFinitePresentation) : |
| M.IsFinitePresentation := by |
| have (U : X.affineOpens) : (M.over U.1).IsFinitePresentation := by |
| let := h U |
| exact coherent_over_of_restrict U.1 M |
| exact CoherentLocality.finitePresentation_of_coversTop M (fun U : X.affineOpens => U.1) |
| ((Opens.coversTop_iff X _).mpr (iSup_affineOpens_eq_top X)) |
| end CoherentGlobal |
|
|
| end |
|
|
| noncomputable section |
| open CategoryTheory |
| open scoped TensorProduct |
| namespace ModuleCat |
| open scoped _root_.ModuleCat |
| variable {R S : Type} [CommRing R] [CommRing S] [Algebra R S] |
| def restrictScalarsAlgebraEquiv : |
| ((_root_.ModuleCat.restrictScalars (algebraMap R S)).obj (_root_.ModuleCat.of S S)) ≃ₗ[R] S where |
| __ := Equiv.refl S |
| map_add' _ _ := rfl |
| map_smul' r s := by |
| exact (@Algebra.smul_def R S _ _ _ r s).symm |
|
|
| def extendScalarsTensorEquiv (M : ModuleCat R) : |
| ((_root_.ModuleCat.extendScalars (algebraMap R S)).obj M) ≃ₗ[S] TensorProduct R S M where |
| __ := (TensorProduct.congr (restrictScalarsAlgebraEquiv (R := R) (S := S)) |
| (LinearEquiv.refl R M)).toAddEquiv |
| map_smul' s x := by |
| induction x using TensorProduct.inductionOn with |
| | add x y hx hy => |
| change ((_root_.ModuleCat.extendScalars (algebraMap R S)).obj M) at x y |
| let e : ((_root_.ModuleCat.extendScalars (algebraMap R S)).obj M) ≃+ TensorProduct R S M := |
| (TensorProduct.congr (restrictScalarsAlgebraEquiv (R := R) (S := S)) |
| (LinearEquiv.refl R M)).toAddEquiv |
| change e (s • (x + y)) = s • e (x + y) |
| calc |
| _ = e (s • x + s • y) := congrArg e (smul_add s x y) |
| _ = e (s • x) + e (s • y) := e.map_add _ _ |
| _ = s • e x + s • e y := congrArg₂ (· + ·) hx hy |
| _ = s • (e x + e y) := (smul_add s _ _).symm |
| _ = s • e (x + y) := congrArg (s • ·) (e.map_add x y).symm |
| | tmul t m => |
| erw [ModuleCat.ExtendScalars.smul_tmul (algebraMap R S)] |
| rfl |
| end ModuleCat |
|
|
| end |
|
|
| noncomputable section |
| open CategoryTheory CategoryTheory.Limits Opposite _root_.AlgebraicGeometry _root_.OAI.AlgebraicGeometry |
| namespace CoherentGlobal |
| open Scheme.Modules |
|
|
| lemma finiteGamma_of_presentation {R : CommRingCat.{0}} (M : (Spec R).Modules) |
| (P : M.Presentation) [P.IsFinite] : Module.Finite R (moduleSpecΓFunctor.obj M) := by |
| obtain ⟨N, hN, ⟨e⟩⟩ := exists_finite_module_of_presentation M P |
| let := hN |
| let e' : N ≅ moduleSpecΓFunctor.obj M := |
| tilde.toTildeΓNatIso.app N ≪≫ moduleSpecΓFunctor.mapIso e |
| exact Module.Finite.equiv e'.toLinearEquiv |
|
|
| lemma exists_presentation_restrict_below {X Y : Scheme.{0}} (M : X.Modules) |
| (U : X.Opens) (P : (M.over U).Presentation) [P.IsFinite] |
| (f : Y ⟶ U.toScheme) [IsOpenImmersion f] : |
| ∃ Q : ((restrictFunctor (f ≫ U.ι)).obj M).Presentation, Q.IsFinite := by |
| let F : SheafOfModules (X.ringCatSheaf.over U) ⥤ SheafOfModules Y.ringCatSheaf := |
| (overEquiv U).functor ⋙ restrictFunctor f |
| have : F.IsLeftAdjoint := inferInstanceAs |
| ((overEquiv U).functor ⋙ restrictFunctor f).IsLeftAdjoint |
| have : PreservesColimitsOfSize.{0, 0} F := |
| (Adjunction.ofIsLeftAdjoint F).leftAdjoint_preservesColimits |
| let e : SheafOfModules.unit Y.ringCatSheaf ≅ |
| F.obj (SheafOfModules.unit (X.ringCatSheaf.over U)) := |
| (restrictUnitIso f).symm ≪≫ (restrictFunctor f).mapIso |
| (TopologicalSpace.Opens.sheafOfModulesEquivOverUnit U X.ringCatSheaf).symm |
| let q : F.obj (M.over U) ≅ (restrictFunctor (f ≫ U.ι)).obj M := |
| (restrictFunctor f).mapIso ((overFunctorEquiv U).app M) ≪≫ |
| ((restrictFunctorComp f U.ι).app M).symm |
| exact exists_presentation_iso q ⟨P.map F e, inferInstance⟩ |
|
|
| lemma exists_presentation_basicOpen_below {R : CommRingCat.{0}} (M : (Spec R).Modules) |
| (U : (Spec R).Opens) (P : (M.over U).Presentation) [P.IsFinite] |
| (g : R) (hg : PrimeSpectrum.basicOpen g ≤ U) : |
| let f : R ⟶ CommRingCat.of (Localization.Away g) := CommRingCat.ofHom (algebraMap _ _) |
| ∃ Q : ((restrictFunctor (Spec.map f)).obj M).Presentation, Q.IsFinite := by |
| dsimp only |
| let t := (Spec R).homOfLE hg |
| let h := (basicOpenIsoSpecAway g).inv ≫ t |
| have : IsOpenImmersion t := |
| AlgebraicGeometry.instIsOpenImmersionHomOfLE (Spec R) hg |
| have : IsOpenImmersion h := IsOpenImmersion.comp _ _ |
| obtain ⟨Q, hQ⟩ := exists_presentation_restrict_below M U P h |
| let := hQ |
| have he : h ≫ U.ι = Spec.map (CommRingCat.ofHom (algebraMap R (Localization.Away g))) := by |
| let e := basicOpenIsoSpecAway g |
| calc |
| _ = e.inv ≫ (t ≫ U.ι) := Category.assoc _ _ _ |
| _ = e.inv ≫ Scheme.Opens.ι (X := Spec R) (PrimeSpectrum.basicOpen g) := |
| congrArg (e.inv ≫ ·) ((Spec R).homOfLE_ι hg) |
| _ = e.inv ≫ (e.hom ≫ Spec.map (CommRingCat.ofHom |
| (algebraMap R (Localization.Away g)))) := |
| congrArg (e.inv ≫ ·) (basicOpenIsoSpecAway_hom_SpecMap g).symm |
| _ = _ := (Category.assoc _ _ _).symm.trans |
| ((congrArg (· ≫ Spec.map (CommRingCat.ofHom |
| (algebraMap R (Localization.Away g)))) e.inv_hom_id).trans (Category.id_comp _)) |
| let e := (restrictFunctorCongr he).app M |
| exact exists_presentation_iso e ⟨Q, inferInstance⟩ |
|
|
| end CoherentGlobal |
|
|
| namespace CoherentGlobal |
| open Scheme.Modules |
| /-- Affine pullback on a quasicoherent sheaf, on global sections. -/ |
| def affinePullbackGammaIso {R S : CommRingCat.{0}} (f : R ⟶ S) |
| (M : (Spec R).Modules) [M.IsQuasicoherent] : |
| moduleSpecΓFunctor.obj ((Scheme.Modules.pullback (Spec.map f)).obj M) ≅ |
| (ModuleCat.extendScalars f.hom).obj (moduleSpecΓFunctor.obj M) := |
| moduleSpecΓFunctor.mapIso |
| ((Scheme.Modules.pullback (Spec.map f)).mapIso (asIso (Scheme.Modules.fromTildeΓ M)).symm ≪≫ |
| (AffinePullback.pullbackTildeIso f).app _) ≪≫ |
| (tilde.toTildeΓNatIso.app _).symm |
|
|
| lemma finite_extendScalarsGamma_of_restrict_presentation {R S : CommRingCat.{0}} |
| (f : R ⟶ S) [IsOpenImmersion (Spec.map f)] |
| (M : (Spec R).Modules) [M.IsQuasicoherent] |
| (P : ((restrictFunctor (Spec.map f)).obj M).Presentation) [P.IsFinite] : |
| Module.Finite S ((ModuleCat.extendScalars f.hom).obj (moduleSpecΓFunctor.obj M)) := by |
| have : Module.Finite S |
| (moduleSpecΓFunctor.obj ((restrictFunctor (Spec.map f)).obj M)) := |
| finiteGamma_of_presentation _ P |
| let e := moduleSpecΓFunctor.mapIso ((restrictFunctorIsoPullback (Spec.map f)).app M) ≪≫ |
| affinePullbackGammaIso f M |
| exact Module.Finite.equiv e.toLinearEquiv |
|
|
| lemma finite_localizedModule_of_extendScalars {R : CommRingCat.{0}} (M : ModuleCat R) |
| (g : R) [Module.Finite (Localization.Away g) |
| ((ModuleCat.extendScalars (algebraMap R (Localization.Away g))).obj M)] : |
| Module.Finite (Localization.Away g) (LocalizedModule.Away g M) := |
| by |
| have : Module.Finite (Localization.Away g) (TensorProduct R (Localization.Away g) M) := |
| Module.Finite.equiv (ModuleCat.extendScalarsTensorEquiv M) |
| exact Module.Finite.equiv (LocalizedModule.equivTensorProduct (Submonoid.powers g) M).symm |
|
|
| lemma finite_localizedGamma_of_basicOpen_presentation {R : CommRingCat.{0}} |
| (M : (Spec R).Modules) [M.IsQuasicoherent] (g : R) |
| (P : ((restrictFunctor (Spec.map (CommRingCat.ofHom |
| (algebraMap R (Localization.Away g))))).obj M).Presentation) [P.IsFinite] : |
| Module.Finite (Localization.Away g) |
| (LocalizedModule.Away g (moduleSpecΓFunctor.obj M)) := by |
| let f : R ⟶ CommRingCat.of (Localization.Away g) := CommRingCat.ofHom (algebraMap _ _) |
| let := finite_extendScalarsGamma_of_restrict_presentation f M P |
| exact finite_localizedModule_of_extendScalars (moduleSpecΓFunctor.obj M) g |
|
|
| /-- A basis of principal opens subordinate to any open cover spans the unit ideal. -/ |
| lemma basicOpen_refinement_span {R : CommRingCat.{0}} {I : Type} |
| (U : I → (Spec R).Opens) (hU : (⨆ i, U i) = ⊤) : |
| Ideal.span {g : R | ∃ i, PrimeSpectrum.basicOpen g ≤ U i} = ⊤ := by |
| apply PrimeSpectrum.iSup_basicOpen_eq_top_iff'.mp |
| apply top_unique |
| intro x _ |
| obtain ⟨i, hi⟩ := TopologicalSpace.Opens.mem_iSup.mp |
| (show x ∈ ⨆ i, U i by rw [hU]; trivial) |
| obtain ⟨_, ⟨_, ⟨g, rfl⟩, rfl⟩, hxg, hg⟩ := |
| PrimeSpectrum.isBasis_basic_opens.exists_subset_of_mem_open hi (U i).isOpen |
| exact TopologicalSpace.Opens.mem_iSup.mpr ⟨g, |
| TopologicalSpace.Opens.mem_iSup.mpr ⟨⟨i, hg⟩, hxg⟩⟩ |
|
|
| /-- Every coherent sheaf on an affine scheme has a finite module of sections. Finiteness is |
| descended from its finite local presentations, not assumed from an abstract equivalence with |
| finite modules. -/ |
| lemma finiteGamma_of_coherent {R : CommRingCat.{0}} (M : (Spec R).Modules) |
| [M.IsFinitePresentation] : Module.Finite R (moduleSpecΓFunctor.obj M) := by |
| have : M.IsQuasicoherent := |
| (SheafOfModules.IsFinitePresentation.exists_quasicoherentData M).choose.isQuasicoherent |
| obtain ⟨D, hD⟩ := SheafOfModules.IsFinitePresentation.exists_quasicoherentData M |
| let := hD |
| let s : Set R := {g | ∃ i, PrimeSpectrum.basicOpen g ≤ D.X i} |
| have hs : Ideal.span s = ⊤ := basicOpen_refinement_span D.X |
| ((Opens.coversTop_iff (Spec R) _).mp D.coversTop) |
| apply Module.Finite.of_localizationSpan s hs |
| intro g |
| obtain ⟨i, hi⟩ := g.property |
| let : (D.presentation i).IsFinite := hD.isFinite_presentation i |
| obtain ⟨P, hP⟩ := exists_presentation_basicOpen_below M (D.X i) (D.presentation i) g hi |
| let := hP |
| exact finite_localizedGamma_of_basicOpen_presentation M g P |
| end CoherentGlobal |
|
|
| end |
|
|
| noncomputable section |
| open CategoryTheory CategoryTheory.Limits Opposite _root_.AlgebraicGeometry _root_.OAI.AlgebraicGeometry |
| namespace CoherentGlobal |
| open Scheme.Modules |
| lemma finite_restrictScalars {A B : CommRingCat.{0}} (f : A ⟶ B) (hf : f.hom.Finite) |
| (M : ModuleCat B) [Module.Finite B M] : |
| Module.Finite A ((ModuleCat.restrictScalars f.hom).obj M) := by |
| let := f.hom.toAlgebra |
| have : Module.Finite A B := hf |
| have : IsScalarTower A B ((ModuleCat.restrictScalars f.hom).obj M) := |
| IsScalarTower.restrictScalars A B M |
| have : Module.Finite B ((ModuleCat.restrictScalars f.hom).obj M) := |
| inferInstanceAs (Module.Finite B M) |
| exact Module.Finite.trans B ((ModuleCat.restrictScalars f.hom).obj M) |
|
|
| /-- Finite pushforward of a coherent sheaf on an affine scheme is coherent, proved from its affine |
| module of sections. -/ |
| lemma coherent_affinePushforward {A B : CommRingCat.{0}} [IsNoetherianRing A] |
| (f : A ⟶ B) (hf : f.hom.Finite) (M : (Spec B).Modules) [M.IsFinitePresentation] : |
| ((Scheme.Modules.pushforward (Spec.map f)).obj M).IsFinitePresentation := by |
| let := finiteGamma_of_coherent M |
| let := finite_restrictScalars f hf (moduleSpecΓFunctor.obj M) |
| let N := (ModuleCat.restrictScalars f.hom).obj (moduleSpecΓFunctor.obj M) |
| obtain ⟨P, hP⟩ := exists_presentation_tilde N |
| let := hP |
| have hN : (tilde N).IsFinitePresentation := |
| CoherentLocality.finitePresentation_of_presentation P |
| have : M.IsQuasicoherent := |
| (SheafOfModules.IsFinitePresentation.exists_quasicoherentData M).choose.isQuasicoherent |
| have : IsIso (Scheme.Modules.fromTildeΓ M) := |
| Scheme.Modules.isIso_fromTildeΓ_of_isQuasicoherent M |
| let e := (Scheme.Modules.pushforward (Spec.map f)).mapIso |
| (asIso (Scheme.Modules.fromTildeΓ M)).symm ≪≫ |
| AffinePullback.pushforwardTildeIso f (moduleSpecΓFunctor.obj M) |
| exact (SheafOfModules.isFinitePresentation (Spec A).ringCatSheaf).prop_of_iso e.symm hN |
| end CoherentGlobal |
|
|
| end |
|
|
| noncomputable section |
| open CategoryTheory CategoryTheory.Limits Opposite _root_.AlgebraicGeometry _root_.OAI.AlgebraicGeometry |
| namespace CoherentGlobal |
| open Scheme.Modules |
| /-- Pushforward under a scheme isomorphism is restriction along its inverse. -/ |
| def pushforwardIsoRestrict {X Y : Scheme.{0}} (e : X ≅ Y) : |
| pushforward e.hom ≅ restrictFunctor e.inv := by |
| let a : restrictFunctor e.hom ⋙ restrictFunctor e.inv ≅ 𝟭 Y.Modules := |
| (restrictFunctorComp e.inv e.hom).symm ≪≫ |
| restrictFunctorCongr e.inv_hom_id ≪≫ restrictFunctorId |
| exact (Functor.rightUnitor _).symm ≪≫ |
| Functor.isoWhiskerLeft (pushforward e.hom) a.symm ≪≫ |
| (Functor.associator _ _ _).symm ≪≫ |
| Functor.isoWhiskerRight (restrictFunctorAdjCounitIso e.hom) (restrictFunctor e.inv) ≪≫ |
| Functor.leftUnitor _ |
|
|
| lemma coherent_pushforward_iso {X Y : Scheme.{0}} (e : X ≅ Y) |
| (M : X.Modules) [M.IsFinitePresentation] : |
| ((pushforward e.hom).obj M).IsFinitePresentation := |
| (SheafOfModules.isFinitePresentation Y.ringCatSheaf).prop_of_iso |
| ((pushforwardIsoRestrict e).app M).symm (coherent_restrict e.inv M) |
|
|
| /-- Affine charts, without assuming that the affine schemes are definitionally Spec. -/ |
| lemma coherent_pushforward_affine {X Y : Scheme.{0}} [IsAffine X] [IsAffine Y] |
| [IsLocallyNoetherian Y] (f : X ⟶ Y) [IsFinite f] |
| (M : X.Modules) [M.IsFinitePresentation] : |
| ((pushforward f).obj M).IsFinitePresentation := by |
| have : IsNoetherianRing Γ(Y, ⊤) := IsLocallyNoetherian.component_noetherian ⟨⊤, isAffineOpen_top Y⟩ |
| have : ((pushforward X.isoSpec.hom).obj M).IsFinitePresentation := |
| coherent_pushforward_iso X.isoSpec M |
| have : ((pushforward (Spec.map f.appTop)).obj |
| ((pushforward X.isoSpec.hom).obj M)).IsFinitePresentation := |
| coherent_affinePushforward f.appTop f.finite_appTop _ |
| have hM : ((pushforward Y.isoSpec.inv).obj |
| ((pushforward (Spec.map f.appTop)).obj |
| ((pushforward X.isoSpec.hom).obj M))).IsFinitePresentation := |
| coherent_pushforward_iso Y.isoSpec.symm _ |
| have he : X.isoSpec.hom ≫ Spec.map f.appTop ≫ Y.isoSpec.inv = f := by |
| rw [← Category.assoc, Scheme.isoSpec_hom_naturality] |
| simp |
| let e := (pushforwardComp (Spec.map f.appTop) Y.isoSpec.inv).app |
| ((pushforward X.isoSpec.hom).obj M) ≪≫ |
| (pushforwardComp X.isoSpec.hom (Spec.map f.appTop ≫ Y.isoSpec.inv)).app M ≪≫ |
| (pushforwardCongr he).app M |
| exact (SheafOfModules.isFinitePresentation Y.ringCatSheaf).prop_of_iso e hM |
| /-- Finite pushforward preserves the coherent category. -/ |
| lemma coherent_pushforward {X Y : Scheme.{0}} [IsLocallyNoetherian Y] |
| (f : X ⟶ Y) [IsFinite f] (M : X.Modules) [M.IsFinitePresentation] : |
| ((pushforward f).obj M).IsFinitePresentation := by |
| apply coherent_of_affine_restrict |
| intro U |
| have : IsAffine U.1.toScheme := U.2 |
| have : IsFinite (f ∣_ U.1) := inferInstance |
| have : IsAffine (f ⁻¹ᵁ U.1).toScheme := U.2.preimage f |
| have : ((restrictFunctor (f ⁻¹ᵁ U.1).ι).obj M).IsFinitePresentation := |
| coherent_restrict _ _ |
| have hN := coherent_pushforward_affine (f ∣_ U.1) |
| ((restrictFunctor (f ⁻¹ᵁ U.1).ι).obj M) |
| exact (SheafOfModules.isFinitePresentation U.1.toScheme.ringCatSheaf).prop_of_iso |
| (CoherentBaseChange.pushforwardRestrictIso f U.1 M).symm hN |
| end CoherentGlobal |
|
|
| end |
|
|
| noncomputable section |
| open CategoryTheory CategoryTheory.Limits Opposite _root_.AlgebraicGeometry _root_.OAI.AlgebraicGeometry |
| namespace CoherentGlobal |
| open Scheme.Modules |
|
|
| instance affineGamma_additive {R : CommRingCat.{0}} : |
| (show (Spec R).Modules ⥤ ModuleCat R from moduleSpecΓFunctor (R := R)).Additive where |
| map_add := by intros; rfl |
|
|
| /-- The affine module/sheaf comparison respects short complexes. -/ |
| def shortComplexTildeIso {R : CommRingCat.{0}} (S : ShortComplex (Spec R).Modules) |
| [IsIso (fromTildeΓ S.X₁)] [IsIso (fromTildeΓ S.X₂)] [IsIso (fromTildeΓ S.X₃)] : |
| (S.map (moduleSpecΓFunctor (R := R))).map (tilde.functor R) ≅ S := |
| ShortComplex.isoMk |
| (@asIso _ _ _ _ (fromTildeΓ S.X₁) (inferInstanceAs (IsIso (fromTildeΓ S.X₁)))) |
| (@asIso _ _ _ _ (fromTildeΓ S.X₂) (inferInstanceAs (IsIso (fromTildeΓ S.X₂)))) |
| (@asIso _ _ _ _ (fromTildeΓ S.X₃) (inferInstanceAs (IsIso (fromTildeΓ S.X₃)))) |
| (fromTildeΓNatTrans.naturality S.f).symm |
| (fromTildeΓNatTrans.naturality S.g).symm |
|
|
| lemma exact_iff_affineGamma {R : CommRingCat.{0}} (S : ShortComplex (Spec R).Modules) |
| [IsIso (fromTildeΓ S.X₁)] [IsIso (fromTildeΓ S.X₂)] [IsIso (fromTildeΓ S.X₃)] : |
| S.Exact ↔ (S.map (moduleSpecΓFunctor (R := R))).Exact := by |
| rw [← ShortComplex.exact_iff_of_iso (shortComplexTildeIso S)] |
| exact (S.map (moduleSpecΓFunctor (R := R))).exact_map_iff_of_faithful (tilde.functor R) |
|
|
| /-- Affine pushforward is exact on the quasicoherent sheaves; there is no claim that arbitrary sheaf |
| pushforward is exact. -/ |
| lemma exact_affinePushforward {A B : CommRingCat.{0}} (f : A ⟶ B) |
| (S : ShortComplex (Spec B).Modules) |
| [S.X₁.IsQuasicoherent] [S.X₂.IsQuasicoherent] [S.X₃.IsQuasicoherent] |
| (hS : S.Exact) : (S.map (pushforward (Spec.map f))).Exact := by |
| have : IsIso (fromTildeΓ ((pushforward (Spec.map f)).obj S.X₁)) := |
| isIso_fromTildeΓ_pushforward f S.X₁ |
| have : IsIso (fromTildeΓ ((pushforward (Spec.map f)).obj S.X₂)) := |
| isIso_fromTildeΓ_pushforward f S.X₂ |
| have : IsIso (fromTildeΓ ((pushforward (Spec.map f)).obj S.X₃)) := |
| isIso_fromTildeΓ_pushforward f S.X₃ |
| have : IsIso (fromTildeΓ (S.map (pushforward (Spec.map f))).X₁) := |
| isIso_fromTildeΓ_pushforward f S.X₁ |
| have : IsIso (fromTildeΓ (S.map (pushforward (Spec.map f))).X₂) := |
| isIso_fromTildeΓ_pushforward f S.X₂ |
| have : IsIso (fromTildeΓ (S.map (pushforward (Spec.map f))).X₃) := |
| isIso_fromTildeΓ_pushforward f S.X₃ |
| apply (exact_iff_affineGamma (S.map (pushforward (Spec.map f)))).mpr |
| exact ShortComplex.exact_of_iso (S.mapNatIso (AffinePullback.pushforwardGammaIso f).symm) |
| (((exact_iff_affineGamma S).mp hS).map (ModuleCat.restrictScalars f.hom)) |
|
|
| end CoherentGlobal |
|
|
| end |
|
|
| noncomputable section |
| open CategoryTheory CategoryTheory.Limits Opposite _root_.AlgebraicGeometry _root_.OAI.AlgebraicGeometry |
| namespace CoherentGlobal |
| open Scheme.Modules |
|
|
| /-- Affine opens below a fixed open form an open cover of that open. -/ |
| lemma affine_below_cover {X : Scheme.{0}} (U : X.Opens) : |
| U ≤ ⨆ V : {V : X.affineOpens // V.1 ≤ U}, V.1.1 := by |
| intro x hx |
| obtain ⟨V, hV, hxV, hVU⟩ := exists_isAffineOpen_mem_and_subset (x := x) hx |
| exact TopologicalSpace.Opens.mem_iSup.mpr ⟨⟨⟨V, hV⟩, hVU⟩, hxV⟩ |
|
|
| lemma hom_ext_affine {X : Scheme.{0}} {M N : X.Modules} {f g : M ⟶ N} |
| (h : ∀ U : X.affineOpens, (restrictFunctor U.1.ι).map f = |
| (restrictFunctor U.1.ι).map g) : f = g := by |
| have hApp (U : X.affineOpens) : f.app U.1 = g.app U.1 := by |
| have hh := congrArg (fun z => z.app ⊤) (h U) |
| change f.app (U.1.ι ''ᵁ ⊤) = g.app (U.1.ι ''ᵁ ⊤) at hh |
| have hh' : f.mapPresheaf.app (op (U.1.ι ''ᵁ ⊤)) = |
| g.mapPresheaf.app (op (U.1.ι ''ᵁ ⊤)) := hh |
| rw [U.1.ι_image_top] at hh' |
| exact hh' |
| apply Scheme.Modules.hom_ext |
| intro U |
| apply AddCommGrpCat.ext |
| intro x |
| let V : {V : X.affineOpens // V.1 ≤ U} → X.Opens := fun V => V.1.1 |
| let Q : TopCat.Sheaf AddCommGrpCat X := (SheafOfModules.toSheaf X.ringCatSheaf).obj N |
| apply Q.eq_of_locally_eq' V U (fun V => homOfLE V.2) (affine_below_cover U) |
| intro W |
| have hf := f.mapPresheaf.naturality (homOfLE W.2).op |
| have hg := g.mapPresheaf.naturality (homOfLE W.2).op |
| change N.presheaf.map (homOfLE W.2).op (f.app U x) = |
| N.presheaf.map (homOfLE W.2).op (g.app U x) |
| simp only [mapPresheaf_app] at hf hg |
| rw [← ConcreteCategory.comp_apply, ← ConcreteCategory.comp_apply, ← hf, ← hg, |
| hApp W.1] |
|
|
| lemma isZero_of_affine_restrict {X : Scheme.{0}} (M : X.Modules) |
| (h : ∀ U : X.affineOpens, IsZero ((restrictFunctor U.1.ι).obj M)) : IsZero M := by |
| apply (IsZero.iff_id_eq_zero M).mpr |
| apply hom_ext_affine |
| intro U |
| exact (h U).eq_of_src _ _ |
|
|
| /-- Exactness of module sheaves is local on affine opens. -/ |
| lemma exact_of_affine_restrict {X : Scheme.{0}} (S : ShortComplex X.Modules) |
| (h : ∀ U : X.affineOpens, (S.map (restrictFunctor U.1.ι)).Exact) : S.Exact := by |
| rw [ShortComplex.exact_iff_isZero_homology] |
| apply isZero_of_affine_restrict |
| intro U |
| have : PreservesFiniteLimits (restrictFunctor U.1.ι) := |
| CoherentRestriction.preservesFiniteLimits U.1.ι |
| exact ((S.map (restrictFunctor U.1.ι)).exact_iff_isZero_homology.mp (h U)).of_iso |
| (ShortComplex.mapHomologyIso S (restrictFunctor U.1.ι)).symm |
| end CoherentGlobal |
|
|
| end |
|
|
| end OAI |
|
|
