| import Mathlib |
| import OAI.AlgebraicGeometry.RelativeTriviality.FiniteSections |
|
|
| namespace OAI |
|
|
| noncomputable section |
|
|
| namespace CampanaPeternellSix.RelativeCech |
| section |
| open CategoryTheory AlgebraicGeometry Limits Opposite TopologicalSpace |
| universe u v w |
| variable {C : Type v} [Category.{w} C] {J : GrothendieckTopology C} |
| variable (𝒪 : Sheaf J RingCat.{u}) |
| variable [HasSheafify J AddCommGrpCat.{u}] [J.WEqualsLocallyBijective AddCommGrpCat.{u}] |
|
|
| lemma free_free_evaluation (I : Type u) [Finite I] (U : Cᵒᵖ) : |
| Module.Free (𝒪.obj.obj U) ((SheafOfModules.evaluation 𝒪 U).obj |
| (SheafOfModules.free I)) := by |
| classical |
| let := Fintype.ofFinite I |
| let F := SheafOfModules.evaluation 𝒪 U |
| let f : I → SheafOfModules 𝒪 := fun _ ↦ SheafOfModules.unit 𝒪 |
| let : HasBiproduct f := HasBiproduct.of_hasProduct f |
| let i₁ : SheafOfModules.free I ≅ ∏ᶜ f := |
| (biproduct.isoCoproduct f).symm ≪≫ biproduct.isoProduct f |
| let i₂ := F.mapIso i₁ ≪≫ asIso (piComparison F f) ≪≫ ModuleCat.piIsoPi (F.obj ∘ f) |
| have : Module.Free (𝒪.obj.obj U) (ModuleCat.of (𝒪.obj.obj U) ((i : I) → (F.obj (f i)))) := by |
| change Module.Free (𝒪.obj.obj U) (I → (𝒪.obj.obj U)) |
| infer_instance |
| exact Module.Free.of_equiv' this i₂.symm.toLinearEquiv |
|
|
| lemma free_sections_of_le_frame (X : Scheme.{u}) (E : X.Modules) |
| (q : E.LocalGeneratorsData) [q.IsLocallyFreeData] [q.IsFiniteType] |
| (i : q.I) (V : X.Opens) (hV : V ≤ q.X i) : Module.Free Γ(X,V) Γ(E,V) := by |
| have := SheafOfModules.LocalGeneratorsData.IsFiniteType.isFiniteType (p := q) i |
| have := SheafOfModules.LocalGeneratorsData.IsLocallyFreeData.isIso (q := q) i |
| let a : Over (q.X i) := Over.mk (homOfLE hV) |
| let F := SheafOfModules.evaluation (X.ringCatSheaf.over (q.X i)) (op a) |
| have := free_free_evaluation (X.ringCatSheaf.over (q.X i)) (q.generators i).I (op a) |
| let : CommRing ((X.ringCatSheaf.over (q.X i)).obj.obj (op a)) := |
| inferInstanceAs (CommRing Γ(X,V)) |
| change Module.Free ((X.ringCatSheaf.over (q.X i)).obj.obj (op a)) |
| (F.obj (E.over (q.X i))) |
| exact Module.Free.of_equiv |
| (R := ↑((X.ringCatSheaf.over (q.X i)).obj.obj (op a))) |
| (F.mapIso (asIso (q.generators i).π)).toLinearEquiv |
|
|
| end |
|
|
| section |
| attribute [local instance] RingHomInvPair.of_ringEquiv RingHomInvPair.of_ringEquiv_symm |
| universe u v w z |
| lemma flat_of_semilinearEquiv {R : Type u} {S : Type v} [CommRing R] [CommRing S] |
| {M : Type w} {N : Type z} [AddCommGroup M] [AddCommGroup N] [Module R M] [Module S N] |
| (e : R ≃+* S) (f : LinearEquiv (e : R →+* S) (σ' := (e.symm : S →+* R)) M N) [Module.Flat R M] : Module.Flat S N := by |
| let : Algebra S R := e.symm.toRingHom.toAlgebra |
| let er : S ≃ₗ[S] R := { e.symm with map_smul' := fun a b => e.symm.map_mul a b } |
| have : Module.Flat S R := Module.Flat.of_linearEquiv er.symm |
| let : Module R N := Module.compHom N e.toRingHom |
| let fl : M ≃ₗ[R] N := { f.toAddEquiv with map_smul' := f.map_smul' } |
| have : Module.Flat R N := Module.Flat.of_linearEquiv fl.symm |
| let : IsScalarTower S R N := ⟨fun s r n => by |
| change e (e.symm s * r) • n = s • e r • n |
| rw [map_mul, e.apply_symm_apply, mul_smul]⟩ |
| exact Module.Flat.trans S R N |
| end |
|
|
| section |
| attribute [local instance] RingHomInvPair.of_ringEquiv RingHomInvPair.of_ringEquiv_symm |
| open CategoryTheory AlgebraicGeometry Limits Opposite TopologicalSpace |
| universe u |
| lemma free_restriction_sections (X Y : Scheme.{u}) (E : Y.Modules) |
| (f : X ⟶ Y) [IsOpenImmersion f] (U : X.Opens) |
| [Module.Free Γ(Y, f ''ᵁ U) Γ(E, f ''ᵁ U)] : |
| Module.Free Γ(X,U) Γ(E.restrict f,U) := by |
| let e := (f.appIso U).commRingCatIsoToRingEquiv |
| let g : LinearEquiv (e : Γ(Y,f ''ᵁ U) →+* Γ(X,U)) (σ' := (e.symm : Γ(X,U) →+* Γ(Y,f ''ᵁ U))) Γ(E, f ''ᵁ U) Γ(E.restrict f,U) := { |
| toFun := (E.restrictAppIso f U).inv |
| invFun := (E.restrictAppIso f U).hom |
| left_inv := fun _ => rfl |
| right_inv := fun _ => rfl |
| map_add' := map_add _ |
| map_smul' := fun r m ↦ by |
| exact Scheme.Modules.smul_restrictAppIso_inv_apply f E U r m |
| } |
| exact Module.Free.of_equiv g |
|
|
| theorem flat_affine_restriction (R : CommRingCat.{u}) (X : Scheme.{u}) |
| (E : X.Modules) |
| (hE : ∃ q : E.LocalGeneratorsData, q.IsLocallyFreeData ∧ q.IsFiniteType) |
| (f : Spec R ⟶ X) [IsOpenImmersion f] : |
| Module.Flat R (moduleSpecΓFunctor.obj (E.restrict f)) := by |
| classical |
| obtain ⟨q, hq, ht⟩ := hE |
| let := hq |
| let := ht |
| let := q.isLocallyFree |
| have : E.IsQuasicoherent := q.quasiCoherentData.isQuasicoherent |
| let T : Set R := {r | ∃ i, f ''ᵁ (PrimeSpectrum.basicOpen r) ≤ q.X i} |
| have hT : Ideal.span T = ⊤ := by |
| have he : Set.range (fun r : T ↦ (r : R)) = T := by ext r; simp |
| rw [← he, ← PrimeSpectrum.iSup_basicOpen_eq_top_iff] |
| apply top_unique |
| intro x hx |
| have hcov := (Opens.coversTop_iff _ _).mp q.coversTop |
| obtain ⟨i, hi⟩ := Opens.mem_iSup.mp (show f x ∈ ⨆ i, q.X i from by rw [hcov]; trivial) |
| obtain ⟨V, ⟨r, rfl⟩, hxV, hV⟩ := |
| PrimeSpectrum.isTopologicalBasis_basic_opens.exists_subset_of_mem_open hi |
| (f ⁻¹ᵁ (q.X i)).isOpen |
| refine Opens.mem_iSup.mpr ⟨⟨r, i, ?_⟩, hxV⟩ |
| rintro y ⟨z, hz, rfl⟩ |
| exact hV hz |
| let E' := E.restrict f |
| let M := modulesSpecToSheaf.obj E' |
| let D (r : R) : (Spec R).Opens := PrimeSpectrum.basicOpen r |
| have : E'.IsQuasicoherent := Scheme.Modules.isQuasicoherent_restrictFunctor f E |
| have : IsIso E'.fromTildeΓ := Scheme.Modules.isIso_fromTildeΓ_of_isQuasicoherent E' |
| let res (r : T) : moduleSpecΓFunctor.obj E' →ₗ[R] Γ(E', D r.val) := |
| (M.obj.map (show (Spec R).Opens from PrimeSpectrum.basicOpen r.val).leTop.op).hom |
| have (r : T) : IsLocalizedModule.Away r.val (res r) := |
| (isIso_fromTildeΓ_iff_isLocalizing E').mp inferInstance r.val |
| let : IsScalarTower R R (moduleSpecΓFunctor.obj E') := ⟨mul_smul⟩ |
| apply Module.flat_of_isLocalized_span (R := R) R (moduleSpecΓFunctor.obj E') T hT |
| (fun r => Γ(E', D r.val)) res |
| intro r |
| obtain ⟨i, hi⟩ := r.property |
| have := free_sections_of_le_frame X E q i _ hi |
| have := free_restriction_sections (Spec R) X E f (PrimeSpectrum.basicOpen r.val) |
| have : Module.Flat R Γ(Spec R, D r.val) := |
| IsLocalization.flat _ (Submonoid.powers r.val) |
| exact Module.Flat.trans R Γ(Spec R, D r.val) |
| Γ(E', D r.val) |
|
|
| lemma flat_affine_image (R : CommRingCat.{u}) (X : Scheme.{u}) |
| (E : X.Modules) |
| (hE : ∃ q : E.LocalGeneratorsData, q.IsLocallyFreeData ∧ q.IsFiniteType) |
| (f : Spec R ⟶ X) [IsOpenImmersion f] : |
| Module.Flat Γ(X,f ''ᵁ ⊤) Γ(E, f ''ᵁ ⊤) := by |
| have := flat_affine_restriction R X E hE f |
| let e := ((Scheme.ΓSpecIso R).symm ≪≫ (f.appIso ⊤).symm).commRingCatIsoToRingEquiv |
| let m : LinearEquiv (e : R →+* Γ(X,f ''ᵁ ⊤)) (σ' := (e.symm : Γ(X,f ''ᵁ ⊤) →+* R)) (moduleSpecΓFunctor.obj (E.restrict f)) Γ(E,f ''ᵁ ⊤) := { |
| toFun := (E.restrictAppIso f ⊤).hom |
| invFun := (E.restrictAppIso f ⊤).inv |
| left_inv := fun _ => rfl |
| right_inv := fun _ => rfl |
| map_add' := map_add _ |
| map_smul' := fun r m ↦ by |
| exact Scheme.Modules.smul_restrictAppIso_hom_apply f E ⊤ |
| ((Scheme.ΓSpecIso R).inv r) m |
| } |
| exact flat_of_semilinearEquiv e m |
|
|
| lemma flat_affine_open (X : Scheme.{u}) (E : X.Modules) |
| (hE : ∃ q : E.LocalGeneratorsData, q.IsLocallyFreeData ∧ q.IsFiniteType) |
| (U : X.Opens) (hU : IsAffineOpen U) : Module.Flat Γ(X,U) Γ(E,U) := by |
| have h := flat_affine_image Γ(X,U) X E hE hU.fromSpec |
| rw [hU.fromSpec.image_top_eq_opensRange, hU.opensRange_fromSpec] at h |
| exact h |
| end |
|
|
| open CategoryTheory AlgebraicGeometry Limits Opposite TopologicalSpace |
| universe u |
| theorem finitePresentation_affine_restriction (R : CommRingCat.{u}) (X : Scheme.{u}) |
| (E : X.Modules) |
| (hE : ∃ q : E.LocalGeneratorsData, q.IsLocallyFreeData ∧ q.IsFiniteType) |
| (f : Spec R ⟶ X) [IsOpenImmersion f] : |
| Module.FinitePresentation R (moduleSpecΓFunctor.obj (E.restrict f)) := by |
| classical |
| obtain ⟨q, hq, ht⟩ := hE |
| let := hq |
| let := ht |
| let := q.isLocallyFree |
| have : E.IsQuasicoherent := q.quasiCoherentData.isQuasicoherent |
| let T : Set R := {r | ∃ i, f ''ᵁ (PrimeSpectrum.basicOpen r) ≤ q.X i} |
| have hT : Ideal.span T = ⊤ := by |
| have he : Set.range (fun r : T ↦ (r : R)) = T := by ext r; simp |
| rw [← he, ← PrimeSpectrum.iSup_basicOpen_eq_top_iff] |
| apply top_unique |
| intro x hx |
| have hcov := (Opens.coversTop_iff _ _).mp q.coversTop |
| obtain ⟨i, hi⟩ := Opens.mem_iSup.mp (show f x ∈ ⨆ i, q.X i from by rw [hcov]; trivial) |
| obtain ⟨V, ⟨r, rfl⟩, hxV, hV⟩ := |
| PrimeSpectrum.isTopologicalBasis_basic_opens.exists_subset_of_mem_open hi |
| (f ⁻¹ᵁ (q.X i)).isOpen |
| refine Opens.mem_iSup.mpr ⟨⟨r, i, ?_⟩, hxV⟩ |
| rintro y ⟨z, hz, rfl⟩ |
| exact hV hz |
| let E' := E.restrict f |
| let M := modulesSpecToSheaf.obj E' |
| let D (r : R) : (Spec R).Opens := PrimeSpectrum.basicOpen r |
| have : E'.IsQuasicoherent := Scheme.Modules.isQuasicoherent_restrictFunctor f E |
| have : IsIso E'.fromTildeΓ := Scheme.Modules.isIso_fromTildeΓ_of_isQuasicoherent E' |
| let res (r : T) : moduleSpecΓFunctor.obj E' →ₗ[R] Γ(E', D r.val) := |
| (M.obj.map (show (Spec R).Opens from PrimeSpectrum.basicOpen r.val).leTop.op).hom |
| have (r : T) : IsLocalizedModule.Away r.val (res r) := |
| (isIso_fromTildeΓ_iff_isLocalizing E').mp inferInstance r.val |
| apply Module.FinitePresentation.of_localizationSpan' T hT |
| (Rₚ := fun r => Γ(Spec R, D r.val)) res |
| intro r |
| obtain ⟨i, hi⟩ := r.property |
| have := free_sections_of_le_frame X E q i _ hi |
| have := finite_sections_of_le_frame X E q i _ hi |
| have := free_restriction_sections (Spec R) X E f (PrimeSpectrum.basicOpen r.val) |
| have := finite_restriction_sections (Spec R) X E f (PrimeSpectrum.basicOpen r.val) |
| exact Module.finitePresentation_of_projective _ _ |
|
|
| end CampanaPeternellSix.RelativeCech |
|
|
| end |
|
|
| end OAI |
|
|
