| import OAI.AlgebraicGeometry.SurfaceCones.CoherentGlobalHom |
|
|
| namespace OAI |
|
|
| section |
|
|
| noncomputable section |
| open CategoryTheory CategoryTheory.Limits Opposite AlgebraicGeometry |
| open scoped TensorProduct |
| namespace CoherentModelActual |
| open CoherentDual Scheme.Modules |
| variable {A B C : CommRingCat.{0}} [IsNoetherianRing B] |
| (f : A ⟶ B) (M : ModuleCat A) [Module.Finite A M] |
|
|
| /-- The actual section module of a restriction of the affine double-dual |
| model extension, expressed as an honest scalar extension of the double dual. -/ |
| def affineEPullbackGammaIso (q : B ⟶ C) : |
| (moduleSpecΓFunctor (R := C)).obj |
| ((Scheme.Modules.pullback (Spec.map q)).obj (E (Spec.map f) M)) ≅ |
| (ModuleCat.extendScalars q.hom).obj |
| (ModuleCat.of B (Module.Dual B (Module.Dual B (affineModule f M)))) := |
| moduleSpecΓFunctor.mapIso ((Scheme.Modules.pullback (Spec.map q)).mapIso |
| (affineEIso f M) ≪≫ (AffinePullback.pullbackTildeIso q).app _) ≪≫ |
| (tilde.toTildeΓNatIso.app _).symm |
|
|
| variable [IsDomain A] [IsNoetherianRing A] [IsDomain B] |
| [Module.IsTorsionFree A M] [Nontrivial M] |
|
|
| omit [IsNoetherianRing B] [IsDomain B] in |
| lemma affineDoubleDual_nontrivial (hf : Function.Injective f) : |
| Nontrivial (Module.Dual B (Module.Dual B (affineModule f M))) := by |
| let : Algebra A B := f.hom.toAlgebra |
| have := Module.finitePresentation_of_finite A M |
| exact FiniteDomainDual.doubleDual_baseChange_nontrivial B hf |
|
|
| /-- The arbitrary ungraded input module gives a NONZERO restriction of its |
| literal affine model extension at every prime divisor. -/ |
| theorem affineE_prime_restriction_nontrivial (hf : Function.Injective f) |
| (p : Ideal B) [p.IsPrime] : |
| let q : B ⟶ CommRingCat.of (B ⧸ p) := CommRingCat.ofHom (Ideal.Quotient.mk p) |
| Nontrivial ((moduleSpecΓFunctor (R := CommRingCat.of (B ⧸ p))).obj |
| ((Scheme.Modules.pullback (Spec.map q)).obj (E (Spec.map f) M))) := by |
| dsimp only |
| let q : B ⟶ CommRingCat.of (B ⧸ p) := CommRingCat.ofHom (Ideal.Quotient.mk p) |
| let N := Module.Dual B (Module.Dual B (affineModule f M)) |
| have : Nontrivial N := affineDoubleDual_nontrivial f M hf |
| have : IsNoetherian B N := isNoetherian_linearMap B B (Module.Dual B (affineModule f M)) |
| have : Module.Finite B N := ⟨IsNoetherian.noetherian ⊤⟩ |
| have : Nontrivial ((ModuleCat.extendScalars q.hom).obj (ModuleCat.of B N)) := |
| FiniteDomainDual.prime_fiber_nontrivial (M := N) p |
| exact (affineEPullbackGammaIso f M q).toLinearEquiv.nontrivial |
|
|
| /-- The restriction has strictly positive generic rank on the integral |
| Cartier divisor. Positivity is deduced from M≠0, not assumed for the sheaf. -/ |
| theorem affineE_cartier_rank_pos (hf : Function.Injective f) |
| (t : B) (ht : IsSMulRegular B t) [(Ideal.span ({t} : Set B)).IsPrime] : |
| let q : B ⟶ CommRingCat.of (B ⧸ Ideal.span ({t} : Set B)) := |
| CommRingCat.ofHom (Ideal.Quotient.mk _) |
| 0 < Module.finrank (B ⧸ Ideal.span ({t} : Set B)) |
| ((moduleSpecΓFunctor (R := CommRingCat.of (B ⧸ Ideal.span ({t} : Set B)))).obj |
| ((Scheme.Modules.pullback (Spec.map q)).obj (E (Spec.map f) M))) := by |
| dsimp only |
| let p := Ideal.span ({t} : Set B) |
| let q : B ⟶ CommRingCat.of (B ⧸ p) := CommRingCat.ofHom (Ideal.Quotient.mk p) |
| have := affineE_prime_restriction_nontrivial f M hf p |
| have := affineE_cartier_torsionFree f M t ht |
| let N := Module.Dual B (Module.Dual B (affineModule f M)) |
| have : IsNoetherian B N := isNoetherian_linearMap B B (Module.Dual B (affineModule f M)) |
| have : Module.Finite B N := ⟨IsNoetherian.noetherian ⊤⟩ |
| have : Module.Finite (B ⧸ p) ((ModuleCat.extendScalars q.hom).obj (ModuleCat.of B N)) := by |
| change Module.Finite (B ⧸ p) ((B ⧸ p) ⊗[B] N) |
| infer_instance |
| have : Module.Finite (B ⧸ p) |
| ((moduleSpecΓFunctor (R := CommRingCat.of (B ⧸ p))).obj |
| ((Scheme.Modules.pullback (Spec.map q)).obj (E (Spec.map f) M))) := |
| Module.Finite.of_surjective (affineEPullbackGammaIso f M q).toLinearEquiv.symm.toLinearMap |
| (affineEPullbackGammaIso f M q).toLinearEquiv.symm.surjective |
| exact Module.finrank_pos |
| end CoherentModelActual |
|
|
| end |
|
|
| end |
|
|
| section |
| noncomputable section |
| open CategoryTheory CategoryTheory.Limits Opposite AlgebraicGeometry |
| namespace CoherentDual |
|
|
| /-- Sections of an actual sheaf dual on an integral scheme are torsion-free. |
| This does not postulate a torsion-free coherent object: it is proved pointwise |
| on the local linear transformations defining the internal Hom. -/ |
| lemma dual_sections_torsionFree {X : Scheme.{0}} [IsIntegral X] |
| (M : X.Modules) (U : X.Opens) : |
| @Module.IsTorsionFree Γ(X, U) |
| ((homSheaf.{0,0,0,0} X.sheaf M (SheafOfModules.unit _)).val.obj (op U)) _ _ |
| ((homSheaf.{0,0,0,0} X.sheaf M (SheafOfModules.unit _)).val.obj (op U)).isModule := by |
| let : Module Γ(X, U) |
| ((homSheaf.{0,0,0,0} X.sheaf M (SheafOfModules.unit _)).val.obj (op U)) := |
| ((homSheaf.{0,0,0,0} X.sheaf M (SheafOfModules.unit _)).val.obj (op U)).isModule |
| refine @Module.IsTorsionFree.mk _ _ _ _ this ?_ |
| · intro r hr f g hfg |
| apply Subtype.ext |
| apply local_ext |
| intro V x |
| by_cases hV : Nonempty V.unop.left |
| · let := hV |
| have hU : Nonempty U := by |
| obtain ⟨v⟩ := hV |
| exact ⟨⟨v.1, leOfHom V.unop.hom v.2⟩⟩ |
| let := hU |
| have hr0 : r ≠ 0 := isRegular_iff_ne_zero.mp hr |
| have hs : X.presheaf.map V.unop.hom.op r ≠ 0 := by |
| intro hs |
| exact hr0 (map_injective_of_isIntegral X V.unop.hom (by simpa using hs)) |
| let a : Γ(X, V.unop.left) := localApp f.val V x |
| let b : Γ(X, V.unop.left) := localApp g.val V x |
| let s : Γ(X, V.unop.left) := X.presheaf.map V.unop.hom.op r |
| have hh := congrArg (fun z => localApp z.val V x) hfg |
| change s * a = s * b at hh |
| exact mul_left_cancel₀ (M₀ := Γ(X, V.unop.left)) hs hh |
| · have hz : V.unop.left = ⊥ := by |
| ext v |
| change v ∈ V.unop.left ↔ False |
| exact ⟨fun hv => hV ⟨⟨v, hv⟩⟩, False.elim⟩ |
| have : Subsingleton Γ(X, V.unop.left) := |
| CommRingCat.subsingleton_of_isTerminal (X.sheaf.isTerminalOfEqEmpty hz) |
| exact Subsingleton.elim (α := Γ(X, V.unop.left)) _ _ |
|
|
| end CoherentDual |
|
|
| end |
|
|
| end |
|
|
| section |
| noncomputable section |
| open CategoryTheory CategoryTheory.Functor Opposite |
| namespace ModuleReindex |
| universe u |
| variable {C D : Type u} [Category.{u} C] [Category.{u} D] |
|
|
| /-- Reindexing along an equivalence does not discard module morphisms. The |
| linearity of the inverse natural transformation is transported through the |
| counit isomorphism, rather than postulated. -/ |
| instance pushforwardZero_full (F : C ⥤ D) [F.IsEquivalence] |
| (R : Dᵒᵖ ⥤ RingCat.{u}) : (PresheafOfModules.pushforward₀.{u} F R).Full where |
| map_surjective {M N} f := by |
| let W := (whiskeringLeft Cᵒᵖ Dᵒᵖ AddCommGrpCat.{u}).obj F.op |
| let g : M.presheaf ⟶ N.presheaf := |
| W.preimage ((PresheafOfModules.toPresheaf _).map f) |
| have hg (U : Cᵒᵖ) : g.app (F.op.obj U) = |
| (forget₂ _ AddCommGrpCat).map (f.app U) := |
| congrArg (fun z => z.app U) (W.map_preimage (X := M.presheaf) (Y := N.presheaf) ((PresheafOfModules.toPresheaf _).map f)) |
| let g' : M ⟶ N := PresheafOfModules.homMk g (by |
| intro U r x |
| let e : F.op.obj (F.asEquivalence.op.inverse.obj U) ≅ U := |
| F.asEquivalence.op.counitIso.app U |
| apply (ConcreteCategory.bijective_of_isIso (N.presheaf.map e.inv)).1 |
| have hn (y : M.obj U) : |
| N.map e.inv ((g.app U).hom y) = |
| (g.app (F.op.obj (F.asEquivalence.op.inverse.obj U))).hom (M.map e.inv y) := |
| (ConcreteCategory.congr_hom (g.naturality e.inv) y).symm |
| change N.map e.inv ((g.app U).hom (r • x)) = |
| N.map e.inv (r • (g.app U).hom x) |
| erw [hn, N.map_smul, M.map_smul, hn, hg] |
| exact (f.app _).hom.map_smul (R.map e.inv r) (M.map e.inv x)) |
| refine ⟨g', ?_⟩ |
| ext U x |
| exact ConcreteCategory.congr_hom (hg U) x |
|
|
| instance pushforwardZero_faithful (F : C ⥤ D) [F.IsEquivalence] |
| (R : Dᵒᵖ ⥤ RingCat.{u}) : (PresheafOfModules.pushforward₀.{u} F R).Faithful where |
| map_injective {M N} f g h := by |
| apply (PresheafOfModules.toPresheaf R).map_injective |
| apply ((whiskeringLeft Cᵒᵖ Dᵒᵖ AddCommGrpCat.{u}).obj F.op).map_injective |
| exact congrArg ((PresheafOfModules.toPresheaf _).map) h |
|
|
| /-- Restriction through an isomorphism of the coefficient presheaves is full. -/ |
| instance restrictScalars_full {R S : Cᵒᵖ ⥤ RingCat.{u}} |
| (φ : R ⟶ S) [IsIso φ] : (PresheafOfModules.restrictScalars.{u} φ).Full where |
| map_surjective {M N} f := by |
| let g₀ : M.presheaf ⟶ N.presheaf := (PresheafOfModules.toPresheaf R).map f |
| let g : M ⟶ N := PresheafOfModules.homMk g₀ (by |
| intro U r x |
| let s := (inv φ).app U r |
| have hs : φ.app U s = r := by |
| exact ConcreteCategory.congr_hom ((asIso φ).inv_hom_id_app U) r |
| have hl := (f.app U).hom.map_smul s x |
| change (g₀.app U).hom (φ.app U s • x) = φ.app U s • (g₀.app U).hom x at hl |
| simpa only [hs] using hl) |
| exact ⟨g, by ext U x; rfl⟩ |
| |
| /-- Actual reindexing plus coefficient isomorphism is fully faithful. -/ |
| def pushforward_fullyFaithful (F : C ⥤ D) [F.IsEquivalence] |
| {R : Dᵒᵖ ⥤ RingCat.{u}} {S : Cᵒᵖ ⥤ RingCat.{u}} |
| (φ : S ⟶ F.op ⋙ R) [IsIso φ] : |
| (PresheafOfModules.pushforward.{u} φ).FullyFaithful := by |
| change (PresheafOfModules.pushforward₀ F R ⋙ PresheafOfModules.restrictScalars φ).FullyFaithful |
| exact Functor.FullyFaithful.ofFullyFaithful _ |
| end ModuleReindex |
|
|
| end |
|
|
| end |
|
|
| section |
| noncomputable section |
| open CategoryTheory Opposite |
| namespace CoherentDual |
| section Reindex |
| universe u |
| variable {C D : Type u} [Category.{u} C] [Category.{u} D] |
| (F : C ⥤ D) {R : Dᵒᵖ ⥤ CommRingCat.{u}} {S : Cᵒᵖ ⥤ CommRingCat.{u}} |
| (φ : S ⟶ F.op ⋙ R) |
| (M N : PresheafOfModules.{u} (R ⋙ forget₂ CommRingCat RingCat)) |
|
|
| def homReindexApp (X : C) : |
| ((PresheafOfModules.pushforward (Functor.whiskerRight φ (forget₂ CommRingCat RingCat))).obj |
| (homPresheaf (R := R) (M := M) (N := N))).obj (op X) →ₗ[S.obj (op X)] |
| (homPresheaf (R := S) |
| (M := (PresheafOfModules.pushforward (Functor.whiskerRight φ (forget₂ CommRingCat RingCat))).obj M) |
| (N := (PresheafOfModules.pushforward (Functor.whiskerRight φ (forget₂ CommRingCat RingCat))).obj N)).obj (op X) where |
| toFun f := ⟨Functor.whiskerLeft (Over.post (X := X) F).op f.val, |
| fun Y r x => f.property ((Over.post F).op.obj Y) (φ.app (op Y.unop.left) r) x⟩ |
| map_add' f g := rfl |
| map_smul' r f := by |
| apply Subtype.ext |
| apply local_ext |
| intro Y x |
| exact congrArg (fun s : R.obj (op ((Over.post (X := X) F).obj Y.unop).left) => |
| s • localApp f.val ((Over.post F).op.obj Y) x) |
| (ConcreteCategory.congr_hom (φ.naturality Y.unop.hom.op) r).symm |
|
|
| lemma homReindexApp_bijective [IsIso φ] (X : C) |
| [(Over.post (X := X) F).IsEquivalence] : |
| Function.Bijective (homReindexApp F φ M N X) := by |
| let φ₀ := Functor.whiskerRight φ (forget₂ CommRingCat RingCat) |
| let ψ := Functor.whiskerLeft (Over.forget X).op φ₀ |
| have hψ : IsIso ψ := (Functor.isoWhiskerLeft (Over.forget X).op |
| (Functor.isoWhiskerRight (asIso φ) (forget₂ CommRingCat RingCat))).isIso_hom |
| let FF := @ModuleReindex.pushforward_fullyFaithful _ _ _ _ (Over.post (X := X) F) _ |
| ((Over.forget (F.obj X)).op ⋙ (R ⋙ forget₂ CommRingCat RingCat)) |
| ((Over.forget X).op ⋙ (S ⋙ forget₂ CommRingCat RingCat)) ψ hψ |
| let e := (localHomEquiv (R := R) (M := M) (N := N) (F.obj X)).trans |
| (FF.homEquiv.trans (localHomEquiv (R := S) |
| (M := (PresheafOfModules.pushforward φ₀).obj M) |
| (N := (PresheafOfModules.pushforward φ₀).obj N) X).symm) |
| change Function.Bijective e |
| exact e.bijective |
|
|
| /-- Internal linear Hom is preserved by coefficient isomorphisms and a |
| reindexing functor that is an equivalence on every slice. -/ |
| def homReindexPresheafIso [IsIso φ] |
| (hF : ∀ X, (Over.post (X := X) F).IsEquivalence) : |
| (PresheafOfModules.pushforward (Functor.whiskerRight φ (forget₂ CommRingCat RingCat))).obj |
| (homPresheaf (R := R) (M := M) (N := N)) ≅ |
| homPresheaf (R := S) |
| (M := (PresheafOfModules.pushforward (Functor.whiskerRight φ (forget₂ CommRingCat RingCat))).obj M) |
| (N := (PresheafOfModules.pushforward (Functor.whiskerRight φ (forget₂ CommRingCat RingCat))).obj N) := by |
| have (X : C) : (Over.post (X := X) F).IsEquivalence := hF X |
| exact PresheafOfModules.isoMk (fun X => |
| (LinearEquiv.ofBijective (homReindexApp F φ M N X.unop) |
| (homReindexApp_bijective F φ M N X.unop)).toModuleIso) (by |
| intro X Y g |
| ext f |
| apply Subtype.ext |
| apply local_ext |
| intro Z x |
| change localApp f.val (op (Over.mk (F.map Z.unop.hom ≫ F.map g.unop))) x = |
| localApp f.val (op (Over.mk (F.map (Z.unop.hom ≫ g.unop)))) x |
| rw [F.map_comp]) |
| end Reindex |
| end CoherentDual |
|
|
| end |
|
|
| end |
|
|
| section |
| noncomputable section |
| open CategoryTheory CategoryTheory.Limits CategoryTheory.MonoidalCategory |
| namespace ActualSheafTensor |
| universe u |
| variable {C : Type u} [Category.{u} C] {J : GrothendieckTopology C} |
| (R : Sheaf J CommRingCat.{u}) |
| [HasSheafify J AddCommGrpCat.{u}] [J.WEqualsLocallyBijective AddCommGrpCat.{u}] |
|
|
| abbrev ringSheaf : Sheaf J RingCat.{u} := (sheafCompose J (forget₂ CommRingCat RingCat)).obj R |
|
|
| local instance : MonoidalCategory (PresheafOfModules.{u} (ringSheaf R).obj) := |
| inferInstanceAs (MonoidalCategory (PresheafOfModules.{u} |
| (R.obj ⋙ forget₂ CommRingCat RingCat))) |
|
|
| /-- The actual tensor sheaf: sheafification of the objectwise tensor product |
| of presheaves of modules. It will provide the Cartier line-bundle twists. -/ |
| def tensor (M N : SheafOfModules.{u} (ringSheaf R)) : SheafOfModules.{u} (ringSheaf R) := |
| (PresheafOfModules.sheafification (𝟙 (ringSheaf R).obj)).obj (PresheafOfModulesOfCommRing.Monoidal.tensorObj (R := R.obj) M.val N.val) |
|
|
| /-- Tensoring with a fixed sheaf, on both objects and morphisms. -/ |
| def tensorLeft (M : SheafOfModules.{u} (ringSheaf R)) : |
| SheafOfModules.{u} (ringSheaf R) ⥤ SheafOfModules.{u} (ringSheaf R) := |
| SheafOfModules.forget _ ⋙ CategoryTheory.MonoidalCategory.tensorLeft (M.val : PresheafOfModules (R.obj ⋙ forget₂ CommRingCat RingCat)) ⋙ |
| PresheafOfModules.sheafification (𝟙 (ringSheaf R).obj) |
|
|
| /-- Tensoring the structure sheaf is canonically the identity, not a |
| postulated operation on formal Chern data. -/ |
| def leftUnitIso (M : SheafOfModules.{u} (ringSheaf R)) : |
| tensor R (SheafOfModules.unit _) M ≅ M := |
| (PresheafOfModules.sheafification (𝟙 (ringSheaf R).obj)).mapIso (λ_ (M.val : PresheafOfModules (R.obj ⋙ forget₂ CommRingCat RingCat))) ≪≫ |
| (asIso (PresheafOfModules.sheafificationAdjunction (𝟙 (ringSheaf R).obj)).counit).app M |
|
|
| /-- The analogous canonical right unit isomorphism. -/ |
| def rightUnitIso (M : SheafOfModules.{u} (ringSheaf R)) : |
| tensor R M (SheafOfModules.unit _) ≅ M := |
| (PresheafOfModules.sheafification (𝟙 (ringSheaf R).obj)).mapIso (ρ_ (M.val : PresheafOfModules (R.obj ⋙ forget₂ CommRingCat RingCat))) ≪≫ |
| (asIso (PresheafOfModules.sheafificationAdjunction (𝟙 (ringSheaf R).obj)).counit).app M |
|
|
| end ActualSheafTensor |
|
|
| end |
|
|
| end |
|
|
| section |
| noncomputable section |
| open CategoryTheory CategoryTheory.Limits CategoryTheory.MonoidalCategory Opposite |
| namespace CoherentDual |
| universe u |
| variable {C : Type u} [Category.{u} C] {R : Cᵒᵖ ⥤ CommRingCat.{u}} |
| {M N P : PresheafOfModules.{u} (R ⋙ forget₂ CommRingCat RingCat)} |
|
|
| /-- A bilinear map of actual presheaves defines local linear maps by restricting |
| its second argument. -/ |
| def tensorCurryAt (f : M ⊗ N ⟶ P) (U : C) (y : N.obj (op U)) (V : Over U) : |
| M.obj (op V.left) →+ P.obj (op V.left) where |
| toFun x := f.app (op V.left) (x ⊗ₜ[R.obj (op V.left)] N.map V.hom.op y) |
| map_zero' := by |
| erw [TensorProduct.zero_tmul, map_zero] |
| map_add' _ _ := by |
| erw [TensorProduct.add_tmul, map_add] |
|
|
| /-- The sectionwise tensor-Hom adjunction on a slice. -/ |
| def tensorCurryLocal (f : M ⊗ N ⟶ P) (U : C) (y : N.obj (op U)) : |
| linearLocalHom (R := R) (M := M) (N := P) U := by |
| refine ⟨{ app := fun V => AddCommGrpCat.ofHom (tensorCurryAt f U y V.unop) |
| naturality := ?_ }, ?_⟩ |
| · intro V W g |
| ext x |
| change f.app (op W.unop.left) |
| (M.map g.unop.left.op x ⊗ₜ[R.obj (op W.unop.left)] N.map W.unop.hom.op y) = |
| P.map g.unop.left.op (f.app (op V.unop.left) |
| (x ⊗ₜ[R.obj (op V.unop.left)] N.map V.unop.hom.op y)) |
| have h := PresheafOfModules.naturality_apply f g.unop.left.op |
| (x ⊗ₜ[R.obj (op V.unop.left)] N.map V.unop.hom.op y) |
| erw [PresheafOfModulesOfCommRing.Monoidal.tensorObj_map_tmul] at h |
| rw [← h] |
| congr 2 |
| rw [← PresheafOfModules.map_comp_apply, ← op_comp, Over.w] |
| · intro V a x |
| change f.app (op V.unop.left) |
| ((a • x) ⊗ₜ[R.obj (op V.unop.left)] N.map V.unop.hom.op y) = |
| a • f.app (op V.unop.left) |
| (x ⊗ₜ[R.obj (op V.unop.left)] N.map V.unop.hom.op y) |
| erw [← TensorProduct.smul_tmul', (f.app _).hom.map_smul] |
|
|
| def tensorCurryLinear (f : M ⊗ N ⟶ P) (U : C) : |
| N.obj (op U) →ₗ[R.obj (op U)] linearLocalHom (R := R) (M := M) (N := P) U where |
| toFun := tensorCurryLocal f U |
| map_add' y z := by |
| apply Subtype.ext |
| apply local_ext |
| intro V x |
| change f.app (op V.unop.left) (x ⊗ₜ[R.obj (op V.unop.left)] N.map V.unop.hom.op (y+z)) = _ |
| erw [map_add, TensorProduct.tmul_add, map_add] |
| rfl |
| map_smul' a y := by |
| apply Subtype.ext |
| apply local_ext |
| intro V x |
| change f.app (op V.unop.left) (x ⊗ₜ[R.obj (op V.unop.left)] N.map V.unop.hom.op (a • y)) = |
| R.map V.unop.hom.op a • f.app (op V.unop.left) |
| (x ⊗ₜ[R.obj (op V.unop.left)] N.map V.unop.hom.op y) |
| have hy : (N.map V.unop.hom.op (a • y) : N.obj (op V.unop.left)) = |
| (R.map V.unop.hom.op a) • (N.map V.unop.hom.op y : N.obj (op V.unop.left)) := |
| N.map_smul _ a y |
| rw [hy] |
| let b : R.obj (op V.unop.left) := R.map V.unop.hom.op a |
| let z : N.obj (op V.unop.left) := N.map V.unop.hom.op y |
| let q : TensorProduct (R.obj (op V.unop.left)) (M.obj (op V.unop.left)) (N.obj (op V.unop.left)) |
| →ₗ[R.obj (op V.unop.left)] P.obj (op V.unop.left) := (f.app _).hom |
| change q (x ⊗ₜ[R.obj (op V.unop.left)] (b • z)) = |
| b • q (x ⊗ₜ[R.obj (op V.unop.left)] z) |
| rw [TensorProduct.tmul_smul, q.map_smul] |
|
|
| /-- Currying is a morphism of genuine presheaves of modules. -/ |
| def tensorCurry (f : M ⊗ N ⟶ P) : N ⟶ homPresheaf (R := R) (M := M) (N := P) where |
| app U := ModuleCat.ofHom (tensorCurryLinear f U.unop) |
| naturality {U V} g := by |
| ext y |
| apply Subtype.ext |
| apply local_ext |
| intro W x |
| change f.app (op W.unop.left) |
| (x ⊗ₜ[R.obj (op W.unop.left)] N.map W.unop.hom.op (N.map g y)) = |
| f.app (op W.unop.left) |
| (x ⊗ₜ[R.obj (op W.unop.left)] N.map (W.unop.hom ≫ g.unop).op y) |
| rw [op_comp, PresheafOfModules.map_comp_apply] |
| rfl |
|
|
| /-- Evaluation gives the inverse to currying on each object. -/ |
| def tensorUncurryApp (f : N ⟶ homPresheaf (R := R) (M := M) (N := P)) (U : Cᵒᵖ) : |
| M.obj U ⊗ N.obj U ⟶ P.obj U := |
| ModuleCat.MonoidalCategory.tensorLift (R := R.obj U) |
| (fun x y => localApp (f.app U y).val (op (Over.mk (𝟙 U.unop))) x) |
| (fun x z y => (localApp (f.app U y).val (op (Over.mk (𝟙 U.unop)))).map_add x z) |
| (fun a x y => (f.app U y).property (op (Over.mk (𝟙 U.unop))) a x) |
| (fun x y z => by |
| have h := (f.app U).hom.map_add y z |
| change localApp (f.app U (y+z)).val (op (Over.mk (𝟙 U.unop))) x = _ |
| rw [h] |
| rfl) |
| (fun a x y => by |
| have h := (f.app U).hom.map_smul a y |
| change localApp (f.app U (a • y)).val (op (Over.mk (𝟙 U.unop))) x = _ |
| rw [h] |
| change (R.map (𝟙 U.unop).op a) • localApp (f.app U y).val (op (Over.mk (𝟙 U.unop))) x = _ |
| rw [op_id, Functor.map_id_apply]) |
|
|
| @[simp] lemma tensorUncurryApp_tmul |
| (f : N ⟶ homPresheaf (R := R) (M := M) (N := P)) |
| (U : Cᵒᵖ) (x : M.obj U) (y : N.obj U) : |
| tensorUncurryApp f U (x ⊗ₜ[R.obj U] y) = |
| localApp (f.app U y).val (op (Over.mk (𝟙 U.unop))) x := rfl |
|
|
| /-- Uncurrying is compatible with restriction maps. -/ |
| def tensorUncurry (f : N ⟶ homPresheaf (R := R) (M := M) (N := P)) : M ⊗ N ⟶ P where |
| app U := tensorUncurryApp f U |
| naturality {U V} g := by |
| apply ModuleCat.MonoidalCategory.tensor_ext |
| intro x y |
| change tensorUncurryApp f V ((M ⊗ N).map g (x ⊗ₜ[R.obj U] y)) = |
| P.map g (tensorUncurryApp f U (x ⊗ₜ[R.obj U] y)) |
| have ht := PresheafOfModulesOfCommRing.Monoidal.tensorObj_map_tmul |
| (R := R) (M₁ := M) (M₂ := N) g x y |
| erw [ht] |
| erw [tensorUncurryApp_tmul f V (M.map g x) (N.map g y), |
| tensorUncurryApp_tmul f U x y] |
| change localApp (f.app V (N.map g y)).val (op (Over.mk (𝟙 V.unop))) |
| (M.map g x) = |
| P.map g (localApp (f.app U y).val (op (Over.mk (𝟙 U.unop))) x) |
| have h := PresheafOfModules.naturality_apply f g y |
| change f.app V (N.map g y) = _ at h |
| rw [h] |
| change localApp (f.app U y).val (op (Over.mk ((𝟙 V.unop) ≫ g.unop))) |
| (M.map g x) = _ |
| rw [Category.id_comp] |
| let k : Over.mk g.unop ⟶ Over.mk (𝟙 U.unop) := Over.homMk g.unop (by simp) |
| exact (local_naturality (f.app U y).val k x).symm |
|
|
| lemma tensorUncurryCurry (f : M ⊗ N ⟶ P) : tensorUncurry (tensorCurry f) = f := by |
| apply PresheafOfModules.hom_ext |
| intro U |
| apply ModuleCat.MonoidalCategory.tensor_ext |
| intro x y |
| change f.app U (x ⊗ₜ[R.obj U] N.map (𝟙 U.unop).op y) = f.app U (x ⊗ₜ[R.obj U] y) |
| simp only [op_id, PresheafOfModules.map_id] |
| rfl |
|
|
| lemma tensorCurryUncurry (f : N ⟶ homPresheaf (R := R) (M := M) (N := P)) : |
| tensorCurry (tensorUncurry f) = f := by |
| ext U y |
| apply Subtype.ext |
| apply local_ext |
| intro V x |
| change localApp (f.app (op V.unop.left) (N.map V.unop.hom.op y)).val |
| (op (Over.mk (𝟙 V.unop.left))) x = localApp (f.app U y).val V x |
| have h := PresheafOfModules.naturality_apply f V.unop.hom.op y |
| change f.app (op V.unop.left) (N.map V.unop.hom.op y) = _ at h |
| rw [h] |
| change localApp (f.app U y).val (op (Over.mk ((𝟙 V.unop.left) ≫ V.unop.hom))) x = _ |
| rw [Category.id_comp] |
| rfl |
|
|
| /-- Actual tensor-Hom equivalence for presheaves. -/ |
| def tensorHomEquiv : (M ⊗ N ⟶ P) ≃ (N ⟶ homPresheaf (R := R) (M := M) (N := P)) where |
| toFun := tensorCurry |
| invFun := tensorUncurry |
| left_inv := tensorUncurryCurry |
| right_inv := tensorCurryUncurry |
|
|
| end CoherentDual |
|
|
| end |
|
|
| end |
|
|
| section |
| noncomputable section |
| open CategoryTheory CategoryTheory.Limits CategoryTheory.MonoidalCategory Opposite |
| namespace CoherentDual |
| universe u |
| variable {C : Type u} [Category.{u} C] {J : GrothendieckTopology C} |
| (R : Sheaf J CommRingCat.{u}) |
| [HasSheafify J AddCommGrpCat.{u}] [J.WEqualsLocallyBijective AddCommGrpCat.{u}] |
| (M N P : SheafOfModules.{u} ((sheafCompose J (forget₂ CommRingCat RingCat)).obj R)) |
|
|
| /-- The tensor-Hom equivalence for actual module sheaves. The domain is the |
| sheafification of the genuine sectionwise tensor product, and the codomain |
| is the sheaf of local linear transformations proved to satisfy descent. -/ |
| def sheafTensorHomEquiv : |
| (ActualSheafTensor.tensor R M N ⟶ P) ≃ (N ⟶ homSheaf R M P) := |
| ((PresheafOfModules.sheafificationAdjunction |
| (𝟙 ((sheafCompose J (forget₂ CommRingCat RingCat)).obj R).obj)).homEquiv _ _).trans |
| ((tensorHomEquiv (R := R.obj) (M := M.val) (N := N.val) (P := P.val)).trans |
| ((SheafOfModules.fullyFaithfulForget _).homEquiv (X := N) (Y := homSheaf R M P)).symm) |
|
|
| lemma tensorCurry_naturality_left |
| {R' : Cᵒᵖ ⥤ CommRingCat.{u}} |
| {M' N' N'' P' : PresheafOfModules.{u} (R' ⋙ forget₂ CommRingCat RingCat)} |
| (f : N'' ⟶ N') (g : M' ⊗ N' ⟶ P') : |
| tensorCurry ((CategoryTheory.MonoidalCategory.tensorLeft M').map f ≫ g) = |
| f ≫ tensorCurry g := by |
| ext U y |
| apply Subtype.ext |
| apply local_ext |
| intro V x |
| change g.app (op V.unop.left) |
| (x ⊗ₜ[R'.obj (op V.unop.left)] f.app (op V.unop.left) (N''.map V.unop.hom.op y)) = |
| g.app (op V.unop.left) |
| (x ⊗ₜ[R'.obj (op V.unop.left)] N'.map V.unop.hom.op (f.app U y)) |
| rw [PresheafOfModules.naturality_apply] |
|
|
| lemma sheafTensorHomEquiv_val |
| (g : ActualSheafTensor.tensor R M N ⟶ P) : |
| (sheafTensorHomEquiv R M N P g).val = |
| tensorCurry (R := R.obj) (M := M.val) (N := N.val) (P := P.val) |
| ((PresheafOfModules.sheafificationAdjunction |
| (𝟙 ((sheafCompose J (forget₂ CommRingCat RingCat)).obj R).obj)).homEquiv |
| (PresheafOfModulesOfCommRing.Monoidal.tensorObj (R := R.obj) M.val N.val) P g) := rfl |
|
|
| lemma sheafTensorHomEquiv_naturality_left |
| {N' : SheafOfModules.{u} ((sheafCompose J (forget₂ CommRingCat RingCat)).obj R)} |
| (f : N' ⟶ N) (g : ActualSheafTensor.tensor R M N ⟶ P) : |
| sheafTensorHomEquiv R M N' P ((ActualSheafTensor.tensorLeft R M).map f ≫ g) = |
| f ≫ sheafTensorHomEquiv R M N P g := by |
| apply (SheafOfModules.forget _).map_injective |
| simp only [SheafOfModules.forget_map, SheafOfModules.comp_val, |
| sheafTensorHomEquiv_val] |
| let adj := PresheafOfModules.sheafificationAdjunction |
| (𝟙 ((sheafCompose J (forget₂ CommRingCat RingCat)).obj R).obj) |
| let F := CategoryTheory.MonoidalCategory.tensorLeft |
| (C := PresheafOfModules (R.obj ⋙ forget₂ CommRingCat RingCat)) (M.val : PresheafOfModules (R.obj ⋙ forget₂ CommRingCat RingCat)) |
| have h := adj.homEquiv_naturality_left (F.map f.val) g |
| erw [h] |
| exact tensorCurry_naturality_left (R' := R.obj) (M' := M.val) |
| (N' := N.val) (N'' := N'.val) (P' := P.val) f.val (adj.homEquiv _ _ g) |
|
|
| /-- Actual tensor sheaves are a left adjoint, so tensoring is right exact. -/ |
| def tensorHomAdjunction : ActualSheafTensor.tensorLeft R M ⊣ |
| Adjunction.rightAdjointOfEquiv (F := ActualSheafTensor.tensorLeft R M) (fun N P => sheafTensorHomEquiv R M N P) |
| (fun _ _ _ f g => sheafTensorHomEquiv_naturality_left R M _ _ f g) := |
| Adjunction.adjunctionOfEquivRight (F := ActualSheafTensor.tensorLeft R M) (fun N P => sheafTensorHomEquiv R M N P) |
| (fun _ _ _ f g => sheafTensorHomEquiv_naturality_left R M _ _ f g) |
|
|
| instance tensorLeft_preservesColimits : PreservesColimits (ActualSheafTensor.tensorLeft R M) := |
| (tensorHomAdjunction R M).leftAdjoint_preservesColimits |
|
|
| end CoherentDual |
|
|
| end |
|
|
| end |
|
|
| section |
| noncomputable section |
| open CategoryTheory CategoryTheory.Limits AlgebraicGeometry Opposite |
| namespace CoherentDual |
| open Scheme.Modules |
|
|
| instance opensPost_essSurj {X Y : Scheme.{0}} (f : X ⟶ Y) [IsOpenImmersion f] |
| (U : X.Opens) : (Over.post (X := U) f.opensFunctor).EssSurj where |
| mem_essImage V := by |
| have hpre : f ⁻¹ᵁ V.left ≤ U := by |
| have h := leOfHom ((TopologicalSpace.Opens.map f.base).map V.hom) |
| exact h.trans (le_of_eq (f.preimage_image_eq U)) |
| have himage : f ''ᵁ (f ⁻¹ᵁ V.left) = V.left := by |
| rw [f.image_preimage_eq_opensRange_inf] |
| exact inf_eq_right.mpr ((leOfHom V.hom).trans (f.image_le_opensRange U)) |
| refine ⟨Over.mk (homOfLE hpre), ⟨Over.isoMk (eqToIso himage)⟩⟩ |
|
|
| instance opensPost_isEquivalence {X Y : Scheme.{0}} (f : X ⟶ Y) [IsOpenImmersion f] |
| (U : X.Opens) : (Over.post (X := U) f.opensFunctor).IsEquivalence := {} |
|
|
| /-- The actual internal linear Hom commutes with restriction to an open |
| subscheme, including the non-definitional coefficient-ring isomorphism. -/ |
| def homSchemeRestrictionIso {X Y : Scheme.{0}} (f : X ⟶ Y) [IsOpenImmersion f] |
| (M N : Y.Modules) : |
| (restrictFunctor f).obj (homSheaf Y.sheaf M N) ≅ |
| homSheaf X.sheaf ((restrictFunctor f).obj M) ((restrictFunctor f).obj N) := by |
| let φ : X.presheaf ⟶ f.opensFunctor.op ⋙ Y.presheaf := |
| { app U := (f.appIso U.unop).inv } |
| have : IsIso φ := NatIso.isIso_of_isIso_app _ |
| apply (SheafOfModules.fullyFaithfulForget _).preimageIso |
| exact homReindexPresheafIso f.opensFunctor φ M.val N.val (fun U => inferInstance) |
|
|
| /-- Covariant functoriality in the target of the actual internal Hom. -/ |
| abbrev homSheafCovFunctor {C : Type} [Category C] {J : GrothendieckTopology C} |
| (R : Sheaf J CommRingCat.{0}) |
| [HasSheafify J AddCommGrpCat.{0}] [J.WEqualsLocallyBijective AddCommGrpCat.{0}] |
| (M : SheafOfModules.{0} ((sheafCompose J (forget₂ CommRingCat RingCat)).obj R)) := |
| Adjunction.rightAdjointOfEquiv (F := ActualSheafTensor.tensorLeft R M) |
| (fun N P => sheafTensorHomEquiv R M N P) |
| (fun _ _ _ f g => sheafTensorHomEquiv_naturality_left R M _ _ f g) |
|
|
| /-- In particular the genuine coherent dual restricts to the genuine dual |
| of the restricted sheaf; no formal identification of section rings is used. -/ |
| def dualSchemeRestrictionIso {X Y : Scheme.{0}} (f : X ⟶ Y) [IsOpenImmersion f] |
| (M : Y.Modules) : |
| (restrictFunctor f).obj (homSheaf Y.sheaf M (SheafOfModules.unit _)) ≅ |
| homSheaf X.sheaf ((restrictFunctor f).obj M) (SheafOfModules.unit _) := |
| homSchemeRestrictionIso f M (SheafOfModules.unit _) ≪≫ |
| (homSheafCovFunctor X.sheaf ((restrictFunctor f).obj M)).mapIso (restrictUnitIso f) |
| end CoherentDual |
|
|
| end |
|
|
| end |
|
|
| section |
|
|
| noncomputable section |
| open CategoryTheory AlgebraicGeometry |
| namespace CoherentModelActual |
| open CoherentDual Scheme.Modules |
|
|
| /-- Functoriality of the literal structure-sheaf double dual. -/ |
| def doubleDualIso {X : Scheme.{0}} {M N : X.Modules} (e : M ≅ N) : |
| homSheaf X.sheaf (homSheaf X.sheaf M (SheafOfModules.unit _)) |
| (SheafOfModules.unit _) ≅ |
| homSheaf X.sheaf (homSheaf X.sheaf N (SheafOfModules.unit _)) |
| (SheafOfModules.unit _) := |
| (homSheafFunctor X.sheaf (SheafOfModules.unit _)).mapIso |
| (((homSheafFunctor X.sheaf (SheafOfModules.unit _)).mapIso e.op).op) |
|
|
| /-- The global double-dual model is the actual double-dual model on EACH |
| open affine chart. It is not an independently chosen local replacement. -/ |
| def openPullbackEIso {A : CommRingCat.{0}} {V W : Scheme.{0}} |
| (j : V ⟶ W) [IsOpenImmersion j] (p : W ⟶ Spec A) (M : ModuleCat A) : |
| (pullback j).obj (E p M) ≅ E (j ≫ p) M := by |
| let L := (pullback p).obj (tilde M) |
| let D := homSheaf W.sheaf L (SheafOfModules.unit _) |
| let F := homSheafFunctor V.sheaf (SheafOfModules.unit _) |
| let e : (restrictFunctor j).obj (E p M) ≅ |
| homSheaf V.sheaf |
| (homSheaf V.sheaf ((restrictFunctor j).obj L) (SheafOfModules.unit _)) |
| (SheafOfModules.unit _) := |
| dualSchemeRestrictionIso j D ≪≫ |
| (F.mapIso (dualSchemeRestrictionIso j L).op).symm |
| exact ((restrictFunctorIsoPullback j).app (E p M)).symm ≪≫ e ≪≫ |
| doubleDualIso ((restrictFunctorIsoPullback j).app L ≪≫ |
| (pullbackComp j p).app (tilde M)) |
|
|
| /-- The same comparison with a specified structural map on the chart. -/ |
| def openPullbackEIsoOfComp {A : CommRingCat.{0}} {V W : Scheme.{0}} |
| (j : V ⟶ W) [IsOpenImmersion j] (p : W ⟶ Spec A) |
| (q : V ⟶ Spec A) (h : j ≫ p = q) (M : ModuleCat A) : |
| (pullback j).obj (E p M) ≅ E q M := |
| openPullbackEIso j p M ≪≫ |
| doubleDualIso ((pullbackCongr h).app (tilde M)) |
| end CoherentModelActual |
|
|
| end |
|
|
| end |
|
|
| end OAI |
|
|
