| import OAI.AlgebraicGeometry.SurfaceCones.CartierGluing |
|
|
| namespace OAI |
|
|
| private local instance factorizationSectionModule {Z : AlgebraicGeometry.Scheme.{0}} |
| (M : Z.Modules) (U : Z.Opensᵒᵖ) : Module (Z.sheaf.obj.obj U) (M.val.obj U) := |
| (M.val.obj U).isModule |
|
|
| private local instance factorizationCoherentSectionModule {Z : AlgebraicGeometry.Scheme.{0}} |
| (M : CoherentGlobal.Coh Z) (U : Z.Opensᵒᵖ) : Module (Z.sheaf.obj.obj U) (M.obj.val.obj U) := |
| (M.obj.val.obj U).isModule |
|
|
| private noncomputable local instance factorizationFreeSectionModule (Z : AlgebraicGeometry.Scheme.{0}) |
| (I : Type) (U : Z.Opensᵒᵖ) : |
| Module (Z.sheaf.obj.obj U) ((SheafOfModules.free (R := Z.ringCatSheaf) I).val.obj U) := |
| ((SheafOfModules.free (R := Z.ringCatSheaf) I).val.obj U).isModule |
|
|
| /-! |
| # Cartier lattices on completed surface cones |
|
|
| This development accompanies *A Complete Local Domain without a Small |
| Cohen–Macaulay Module* (OpenAI, 2026). |
| -/ |
|
|
| noncomputable section |
| open CategoryTheory CategoryTheory.Limits _root_.AlgebraicGeometry _root_.OAI.AlgebraicGeometry |
| namespace ActualCartier |
| open ActualSheafTensor CartierImageFiltration CoherentGlobal Scheme.Modules |
| variable {X Y : Scheme.{0}} [IsLocallyNoetherian Y] |
| (g : X ⟶ Y) [IsClosedImmersion g] [CompactSpace Y] |
| (d : LineTrivialization Y.sheaf (idealSheaf g)) |
| include d |
|
|
| /-- The two cleared maps are inverse up to the indicated ideal power. |
| Torsion freeness extends the equality from the puncture to the whole scheme. -/ |
| lemma global_power_sandwich_factorization |
| (n : ℕ) {M N : Y.Modules} [N.IsFinitePresentation] |
| (hN : ∀ U, Module.IsTorsionFree (Y.sheaf.obj.obj U) (N.val.obj U)) |
| (e : M.over (ActualOpenSupport.complement g) ≅ |
| N.over (ActualOpenSupport.complement g)) |
| (f : (power (tensorLeft Y.sheaf (idealSheaf g)) n).obj M ⟶ N) |
| (a : (power (tensorLeft Y.sheaf (idealSheaf g)) n).obj N ⟶ M) |
| (hf : f.over (ActualOpenSupport.complement g) = |
| ((powerAction (tensorLeft Y.sheaf (idealSheaf g)) |
| (idealAction Y.sheaf (idealι g)) n).app M).over |
| (ActualOpenSupport.complement g) ≫ e.hom) |
| (ha : a.over (ActualOpenSupport.complement g) = |
| ((powerAction (tensorLeft Y.sheaf (idealSheaf g)) |
| (idealAction Y.sheaf (idealι g)) n).app N).over |
| (ActualOpenSupport.complement g) ≫ e.inv) : |
| (powerAddIso (tensorLeft Y.sheaf (idealSheaf g)) n n N).hom ≫ |
| (power (tensorLeft Y.sheaf (idealSheaf g)) n).map a ≫ f = |
| (powerAction (tensorLeft Y.sheaf (idealSheaf g)) |
| (idealAction Y.sheaf (idealι g)) (n + n)).app N := by |
| let T := tensorLeft Y.sheaf (idealSheaf g) |
| let act := idealAction Y.sheaf (idealι g) |
| let U := ActualOpenSupport.complement g |
| let A : Coh Y := ⟨(power T (n + n)).obj N, |
| coherent_power_tensor_line (idealSheaf g) d (n + n) N⟩ |
| let B : Coh Y := ⟨N, inferInstance⟩ |
| let p : A ⟶ B := ObjectProperty.homMk |
| ((powerAddIso T n n N).hom ≫ (power T n).map a ≫ f) |
| let q : A ⟶ B := ObjectProperty.homMk ((powerAction T act (n + n)).app N) |
| have hpq : p = q := by |
| apply hom_ext_of_puncture g d p q hN |
| have hh : p.hom.over U = q.hom.over U := |
| power_sandwich_map T act (SheafOfModules.overFunctor Y.ringCatSheaf U) |
| n e f a hf ha |
| have : Epi ((overFunctorEquiv U).hom.app A.obj) := |
| @IsIso.epi_of_iso _ _ _ _ _ ((overFunctorEquiv U).app A.obj).isIso_hom |
| apply (cancel_epi ((overFunctorEquiv U).hom.app A.obj)).mp |
| calc |
| _ = (overEquiv U).functor.map (p.hom.over U) ≫ |
| (overFunctorEquiv U).hom.app B.obj := |
| ((overFunctorEquiv U).hom.naturality p.hom).symm |
| _ = (overEquiv U).functor.map (q.hom.over U) ≫ |
| (overFunctorEquiv U).hom.app B.obj := by rw [hh] |
| _ = _ := (overFunctorEquiv U).hom.naturality q.hom |
| exact congrArg (fun k : A ⟶ B => k.hom) hpq |
| end ActualCartier |
|
|
| end |
|
|
| noncomputable section |
| open CategoryTheory CategoryTheory.Limits _root_.AlgebraicGeometry _root_.OAI.AlgebraicGeometry |
| namespace ActualCartier |
| open ActualSheafTensor CartierImageFiltration CoherentGlobal CoherentK0 Scheme.Modules |
| variable {X Y : Scheme.{0}} [IsLocallyNoetherian X] [IsLocallyNoetherian Y] |
| (g : X ⟶ Y) [IsClosedImmersion g] [CompactSpace Y] |
| (d : LineTrivialization Y.sheaf (idealSheaf g)) |
|
|
| omit [IsLocallyNoetherian X] [IsClosedImmersion g] [CompactSpace Y] in |
| /-- An ideal-power factorization annihilates the coherent quotient by the same exponent. -/ |
| lemma idealMultiple_isZero_of_raw_factorization |
| {S : ShortComplex (Coh Y)} (hS : S.ShortExact) (n : ℕ) |
| (a : (power (tensorLeft Y.sheaf (idealSheaf g)) n).obj S.X₂.obj ⟶ S.X₁.obj) |
| (ha : a ≫ S.f.hom = |
| (powerAction (tensorLeft Y.sheaf (idealSheaf g)) |
| (idealAction Y.sheaf (idealι g)) n).app S.X₂.obj) : |
| IsZero (idealMultiple g d n S.X₃) := by |
| let T := coherentTensorLine (idealSheaf g) d |
| let V : Y.Modules ⥤ Y.Modules := tensorLeft Y.sheaf (idealSheaf g) |
| have : PreservesColimits V := CoherentDual.tensorLeft_preservesColimits _ _ |
| have : V.PreservesEpimorphisms := preservesEpimorphisms_of_preservesColimitsOfShape V |
| let F := cohInclusion Y |
| let c : T ⋙ F ≅ F ⋙ V := Iso.refl _ |
| have : Mono S.f := hS.mono_f |
| have : Epi S.g := hS.epi_g |
| apply iterated_isZero_of_powerAction_zero |
| apply F.map_injective |
| rw [Functor.map_zero] |
| apply map_powerAction_zero_of_comparison T V F c (action g d) |
| (idealAction Y.sheaf (idealι g)) (fun _ => Category.id_comp _) n S.X₃ |
| exact powerAction_quotient_zero V (idealAction Y.sheaf (idealι g)) |
| (hS.map F) n a ha |
|
|
| /-- The coherent lattice construction with the twice-clearing exponent, |
| conormal-layer epimorphisms and divisor Grothendieck identity. -/ |
| lemma exists_cleared_lattice_twice_bound |
| (M N : Y.Modules) [M.IsFinitePresentation] [N.IsFinitePresentation] |
| (hM : ∀ U, Module.IsTorsionFree (Y.sheaf.obj.obj U) (M.val.obj U)) |
| (hN : ∀ U, Module.IsTorsionFree (Y.sheaf.obj.obj U) (N.val.obj U)) |
| (e : M.over (ActualOpenSupport.complement g) ≅ |
| N.over (ActualOpenSupport.complement g)) : |
| let L : Coh Y := ⟨N, inferInstance⟩ |
| ∃ k : ℕ, ∀ n : ℕ, k ≤ n → |
| ∃ a : clearedLattice g d n M ⟶ L, |
| Mono a ∧ |
| ((cohInclusion Y).map a).over (ActualOpenSupport.complement g) = |
| ((powerAction (tensorLeft Y.sheaf (idealSheaf g)) |
| (idealAction Y.sheaf (idealι g)) n).app M).over |
| (ActualOpenSupport.complement g) ≫ e.hom ∧ |
| IsZero (idealMultiple g d (n + n) (cokernel a)) ∧ |
| cls ((restriction g d).obj (clearedLattice g d n M)) = |
| cls ((restriction g d).obj L) + |
| ((idealLayers g d (n + n) (cokernel a)).map fun Q => |
| cls (conormalTensor g d Q) - cls Q).sum ∧ |
| ∀ j : ℕ, Epi (twistedLayerQuotient g d (cokernel.π a) j) := by |
| dsimp only |
| let L : Coh Y := ⟨N, inferInstance⟩ |
| obtain ⟨k, hk⟩ := exists_global_power_sandwich g d M N hM hN e |
| refine ⟨k, fun n hn => ?_⟩ |
| obtain ⟨a, b, ha, hb, hae, hbe, hai, hbi⟩ := hk n hn |
| let := ha |
| let a' : clearedLattice g d n M ⟶ L := ObjectProperty.homMk a |
| have ha' : Mono a' := (cohInclusion Y).mono_of_mono_map (f := a') (by |
| change Mono a |
| infer_instance) |
| let S : ShortComplex (Coh Y) := |
| ShortComplex.mk a' (cokernel.π a') (cokernel.condition a') |
| have hS : S.ShortExact := { exact := ShortComplex.exact_cokernel a' } |
| have hnil : IsZero (idealMultiple g d (n + n) (cokernel a')) := by |
| apply idealMultiple_isZero_of_raw_factorization g d hS (n + n) |
| ((powerAddIso (tensorLeft Y.sheaf (idealSheaf g)) n n N).hom ≫ |
| (power (tensorLeft Y.sheaf (idealSheaf g)) n).map b) |
| exact (Category.assoc _ _ _).trans |
| (global_power_sandwich_factorization g d n hN e a b hae hbe) |
| refine ⟨a', ha', hae, hnil, ?_, fun _ => inferInstance⟩ |
| apply lattice_nilpotent_identity g d hS _ hN (n + n) hnil |
| exact SheafTorsion.subobject ((cohInclusion Y).map a') hN |
| end ActualCartier |
|
|
| end |
|
|
| noncomputable section |
| open CategoryTheory CategoryTheory.Limits _root_.AlgebraicGeometry _root_.OAI.AlgebraicGeometry |
| namespace ActualCartier |
| open ActualSheafTensor CartierImageFiltration CoherentGlobal CoherentK0 Scheme.Modules |
|
|
| /-- The finite free coherent module sheaf. -/ |
| def coherentFree (Y : Scheme.{0}) (I : Type) [Finite I] : Coh Y := |
| ⟨SheafOfModules.free (R := Y.ringCatSheaf) I, |
| CoherentLocality.finitePresentation_free Y.ringCatSheaf I⟩ |
|
|
| /-- On an integral scheme, the finite free sheaf is sectionwise |
| torsion free, including empty opens. -/ |
| lemma free_sections_torsionFree (Y : Scheme.{0}) [IsIntegral Y] |
| (I : Type) [Finite I] (U : Y.Opensᵒᵖ) : |
| Module.IsTorsionFree (Y.sheaf.obj.obj U) |
| ((SheafOfModules.free (R := Y.ringCatSheaf) I).val.obj U) := by |
| let e := CoherentDual.dualFiniteFreeIso Y.sheaf I |
| have hm : Mono e.inv := @IsIso.mono_of_iso _ _ _ _ _ e.isIso_inv |
| exact @SheafTorsion.subobject _ _ _ e.inv hm |
| (fun V => CoherentDual.dual_sections_torsionFree _ V.unop) U |
|
|
| variable {X Y : Scheme.{0}} [IsLocallyNoetherian X] [IsLocallyNoetherian Y] |
| (g : X ⟶ Y) [IsClosedImmersion g] |
| (d : LineTrivialization Y.sheaf (idealSheaf g)) |
|
|
| /-- The coherent restriction used by the Cartier resolution sends |
| the finite free sheaf to the same finite free sheaf on the divisor. -/ |
| def restriction_freeIso (I : Type) [Finite I] : |
| (restriction g d).obj (coherentFree Y I) ≅ coherentFree X I := |
| by |
| let : (SheafOfModules.pushforward g.toRingCatSheafHom).IsRightAdjoint := |
| (Scheme.Modules.pullbackPushforwardAdjunction g).isRightAdjoint |
| let F := TopologicalSpace.Opens.map g.base |
| let : F.Final := Functor.final_of_exists_of_isFiltered F |
| (fun U => ⟨⊤, ⟨homOfLE (by change U ≤ ⊤; exact le_top)⟩⟩) |
| (fun {U V} s t => ⟨V, 𝟙 _, Subsingleton.elim _ _⟩) |
| exact ObjectProperty.isoMk _ ((restrictionPullbackIso g d (coherentFree Y I)).symm ≪≫ |
| SheafOfModules.pullbackObjFreeIso g.toRingCatSheafHom I) |
| |
| /-- The quotient map from the jth conormal twist of O_D^N to the jth quotient layer. -/ |
| def freeTwistedLayerQuotient {Q : Coh Y} {I : Type} [Finite I] |
| (q : coherentFree Y I ⟶ Q) (j : ℕ) : |
| (power (conormalFunctor g d) j).obj (coherentFree X I) ⟶ layer g d j Q := |
| (power (conormalFunctor g d) j).map (restriction_freeIso g d I).inv ≫ |
| twistedLayerQuotient g d q j |
|
|
| instance freeTwistedLayerQuotient_epi {Q : Coh Y} {I : Type} [Finite I] |
| (q : coherentFree Y I ⟶ Q) [Epi q] (j : ℕ) : |
| Epi (freeTwistedLayerQuotient g d q j) := by |
| dsimp only [freeTwistedLayerQuotient] |
| infer_instance |
|
|
| /-- The sheaf-theoretic content of the divisor lattice construction for the finite |
| free ambient lattice: a fixed puncture trivialization constructs the |
| embedding, the finite twice-bound filtration, the divisor K₀ identity, |
| and all the required quotients of conormal-twisted free sheaves. -/ |
| lemma exists_free_cleared_lattice [CompactSpace Y] [IsIntegral Y] |
| (M : Y.Modules) [M.IsFinitePresentation] |
| (hM : ∀ U, Module.IsTorsionFree (Y.sheaf.obj.obj U) (M.val.obj U)) |
| (N : ℕ) |
| (e : M.over (ActualOpenSupport.complement g) ≅ |
| (SheafOfModules.free (R := Y.ringCatSheaf) (Fin N)).over |
| (ActualOpenSupport.complement g)) : |
| ∃ k : ℕ, ∀ n : ℕ, k ≤ n → |
| ∃ a : clearedLattice g d n M ⟶ coherentFree Y (Fin N), |
| Mono a ∧ |
| ((cohInclusion Y).map a).over (ActualOpenSupport.complement g) = |
| ((powerAction (tensorLeft Y.sheaf (idealSheaf g)) |
| (idealAction Y.sheaf (idealι g)) n).app M).over |
| (ActualOpenSupport.complement g) ≫ e.hom ∧ |
| IsZero (idealMultiple g d (n + n) (cokernel a)) ∧ |
| cls ((restriction g d).obj (clearedLattice g d n M)) = |
| cls (coherentFree X (Fin N)) + |
| ((idealLayers g d (n + n) (cokernel a)).map fun Q => |
| cls (conormalTensor g d Q) - cls Q).sum ∧ |
| ∀ j : ℕ, Epi (freeTwistedLayerQuotient g d (cokernel.π a) j) := by |
| let L := SheafOfModules.free (R := Y.ringCatSheaf) (Fin N) |
| let : L.IsFinitePresentation := |
| CoherentLocality.finitePresentation_free Y.ringCatSheaf (Fin N) |
| obtain ⟨k, hk⟩ := exists_cleared_lattice_twice_bound g d M L hM |
| (free_sections_torsionFree Y (Fin N)) e |
| refine ⟨k, fun n hn => ?_⟩ |
| obtain ⟨a, ha, hae, hnil, heq, hepi⟩ := hk n hn |
| refine ⟨a, ha, hae, hnil, ?_, fun j => ?_⟩ |
| · exact heq.trans (congrArg (fun z => z + _) |
| (cls_iso (restriction_freeIso g d (Fin N)))) |
| · have hπ : Epi (cokernel.π a) := |
| inferInstanceAs (Epi (cokernel.π (C := Coh Y) a)) |
| exact @freeTwistedLayerQuotient_epi X Y _ _ g _ d _ _ _ (cokernel.π a) hπ j |
| end ActualCartier |
|
|
| end |
|
|
| /-! The framed open is the complement of the completed exceptional plane. -/ |
| noncomputable section |
| open CategoryTheory CategoryTheory.Limits _root_.AlgebraicGeometry _root_.OAI.AlgebraicGeometry Scheme.Modules |
| namespace SourceZeroSections |
| open KummerSourceModel SourceConeMorphism |
|
|
| lemma seriesOrigin_kernel : RingHom.ker (MvPowerSeries.constantCoeff : A →+* ℂ) = |
| Ideal.span (Set.range (MvPowerSeries.X : Fin 3 → A)) := by |
| apply le_antisymm |
| · intro a ha |
| exact mvPowerSeries_constantCoeff_zero_mem_vars a ha |
| · apply Ideal.span_le.mpr |
| rintro _ ⟨i, rfl⟩ |
| exact MvPowerSeries.constantCoeff_X i |
|
|
| lemma seriesOrigin_range_compl : (Set.range seriesOrigin)ᶜ = (seriesPuncture : Set (Spec (.of A))) := by |
| change (Set.range (PrimeSpectrum.comap (MvPowerSeries.constantCoeff : A →+* ℂ)))ᶜ = _ |
| rw [range_comap_of_surjective ℂ _ |
| (fun a => ⟨MvPowerSeries.C a, MvPowerSeries.constantCoeff_C a⟩), seriesOrigin_kernel, |
| PrimeSpectrum.zeroLocus_span] |
| ext q |
| simp only [Set.mem_compl_iff, PrimeSpectrum.mem_zeroLocus, Set.range_subset_iff, |
| SetLike.mem_coe, seriesPuncture] |
| simp only [not_forall] |
| erw [TopologicalSpace.Opens.mem_iSup] |
| rfl |
|
|
| lemma completedPlaneZero_range : Set.range completedPlaneZero = |
| completedBlowdown ⁻¹' Set.range seriesOrigin := by |
| have he : Set.range completedPlaneZero = |
| Set.range (pullback.fst completedBlowdown seriesOrigin) := by |
| let e := completedPlaneZero_isPullback.isoPullback |
| ext x |
| constructor |
| · rintro ⟨y, rfl⟩ |
| refine ⟨e.hom y, ?_⟩ |
| change (e.hom ≫ pullback.fst completedBlowdown seriesOrigin) y = _ |
| rw [IsPullback.isoPullback_hom_fst] |
| · rintro ⟨y, rfl⟩ |
| refine ⟨e.inv y, ?_⟩ |
| change (e.inv ≫ completedPlaneZero) y = _ |
| rw [IsPullback.isoPullback_inv_fst] |
| rw [he, Scheme.Pullback.range_fst] |
|
|
| lemma planeComplement_eq : ActualOpenSupport.complement completedPlaneZero = baseModelPuncture := by |
| apply TopologicalSpace.Opens.ext |
| change (Set.range completedPlaneZero)ᶜ = completedBlowdown ⁻¹' (seriesPuncture : Set (Spec (.of A))) |
| rw [completedPlaneZero_range, ← Set.preimage_compl, seriesOrigin_range_compl] |
| end SourceZeroSections |
| namespace SourceConeMorphism |
| open KummerSourceModel SourcePullbackChart SourceZeroSections |
| variable (M : ModuleCat.{0} ExplicitCone.completedRing) |
| [Module.Finite ExplicitCone.completedRing M] [Nontrivial M] |
| (hdepth : SmallCM.localDepth ExplicitCone.completedRing M = 3) |
|
|
| def modelPushforwardComplementFreeIso : |
| (restrictFunctor (ActualOpenSupport.complement completedPlaneZero).ι).obj (modelPushforward M) ≅ |
| SheafOfModules.free (basisIndex M hdepth) := by |
| rw [planeComplement_eq] |
| exact modelPushforwardFreeIso M hdepth |
|
|
| /-- The slice-site framing for the generic lattice construction. -/ |
| def modelPushforwardOverFreeIso : |
| (modelPushforward M).over (ActualOpenSupport.complement completedPlaneZero) ≅ |
| (SheafOfModules.free (R := V.ringCatSheaf) (basisIndex M hdepth)).over |
| (ActualOpenSupport.complement completedPlaneZero) := by |
| let U := ActualOpenSupport.complement completedPlaneZero |
| exact (overEquiv U).functor.preimageIso |
| ((overFunctorEquiv U).app (modelPushforward M) ≪≫ |
| modelPushforwardComplementFreeIso M hdepth ≪≫ |
| (IsoPuncturePushforward.restrictFreeIso U.ι _).symm ≪≫ |
| ((overFunctorEquiv U).app (SheafOfModules.free (R := V.ringCatSheaf) (basisIndex M hdepth))).symm) |
| end SourceConeMorphism |
|
|
| end |
|
|
| /-! The kernel ideal of the completed plane zero section is invertible. -/ |
| noncomputable section |
| open _root_.AlgebraicGeometry _root_.OAI.AlgebraicGeometry CategoryTheory CategoryTheory.Limits Opposite |
| namespace SourceZeroSections |
| open KummerSourceModel SourcePullbackChart Scheme.Modules ActualCartier ActualSheafTensor |
| attribute [local instance] originChartCommRing originChartSemiring originPlaneCommRing originPlaneSemiring |
| chartBaseAlgebra planeOriginAlgebra baseChartModule baseChartAction baseChartSMul baseChartTower |
| planeOriginModule completedBlowupCommRing completedBlowupSemiring completedBlowupAlgebra |
|
|
| def planeIdealChartIso (i : Fin 3) : |
| (restrictFunctor (completedBlowupIota i)).obj (idealSheaf completedPlaneZero) ≅ |
| SheafOfModules.unit (Spec (.of (completedBlowupChart i))).ringCatSheaf := |
| chartAffinePrincipalIdealUnitIso completedPlaneZero |
| (CommRingCat.ofHom (completedPlaneEvaluation i)) (planeIota i) (completedBlowupIota i) |
| (planeIota_completedPlaneZero i) (by |
| simpa only [Scheme.Hom.image_top_eq_opensRange] using (planeZero_chart_preimage i).symm) |
| (completedBlowupFiber i) (completedBlowupFiber_regular i) |
| (completedPlaneEvaluation_kernel i) |
|
|
| def planeIdealLine : LineTrivialization V.sheaf (idealSheaf completedPlaneZero) := |
| lineTrivializationOfCharts _ (fun i => Spec (.of (completedBlowupChart i))) |
| completedBlowupIota completedBlowupCover planeIdealChartIso |
|
|
| lemma planeIdeal_coherent : (idealSheaf completedPlaneZero).IsFinitePresentation := |
| idealSheaf_coherent _ |
| end SourceZeroSections |
|
|
| end |
|
|
| /-! Coherent lattices for full-depth modules on the completed cone, |
| with their conormal layers and Cartier restriction identity. -/ |
| noncomputable section |
| open CategoryTheory CategoryTheory.Limits _root_.AlgebraicGeometry _root_.OAI.AlgebraicGeometry Scheme.Modules |
| namespace SourceConeMorphism |
| open KummerSourceModel SourcePullbackChart SourceZeroSections |
| ActualCartier ActualSheafTensor CartierImageFiltration CoherentK0 CoherentGlobal |
|
|
| attribute [local instance] originPlaneCommRing originPlaneSemiring |
|
|
| local instance planeChart_noetherian (i : Fin 3) : IsNoetherianRing (planeChart i) := |
| isNoetherianRing_of_surjective KummerSourceModel.S (planeChart i) |
| (SectionCompletion.polynomialChartDehom i).toRingHom (polynomialChartDehom_surjective i) |
|
|
| instance sourcePlane_noetherian : IsLocallyNoetherian ExplicitCone.plane := by |
| have (i : planeCover.I₀) : IsLocallyNoetherian (planeCover.X i) := by |
| change Fin 3 at i |
| change IsLocallyNoetherian (Spec (.of (planeChart i))) |
| infer_instance |
| exact (isLocallyNoetherian_iff_openCover planeCover).mpr (fun i => inferInstance) |
|
|
| instance sourceV_compact : CompactSpace V := |
| QuasiCompact.compactSpace_of_compactSpace completedBlowdown |
|
|
| variable (M : ModuleCat.{0} ExplicitCone.completedRing) |
| [Module.Finite ExplicitCone.completedRing M] [Nontrivial M] |
| (hdepth : SmallCM.localDepth ExplicitCone.completedRing M = 3) |
|
|
| local instance pushforward_coherent : (modelPushforward M).IsFinitePresentation := |
| modelPushforward_coherent M |
|
|
| noncomputable instance basisIndex_fintype : Fintype (basisIndex M hdepth) := Fintype.ofFinite _ |
| abbrev sourceFreeRank : ℕ := Fintype.card (basisIndex M hdepth) |
|
|
| lemma sourceFreeRank_pos : 0 < sourceFreeRank M hdepth := by |
| let := parameterModule_free M hdepth |
| let : Nontrivial (parameterModule M) := show Nontrivial M from inferInstance |
| have : Nonempty (basisIndex M hdepth) := |
| (Module.Free.chooseBasis A (parameterModule M)).index_nonempty |
| exact Fintype.card_pos_iff.mpr this |
|
|
| def modelPushforwardOverFinIso : |
| (modelPushforward M).over (ActualOpenSupport.complement completedPlaneZero) ≅ |
| (SheafOfModules.free (R := V.ringCatSheaf) (Fin (sourceFreeRank M hdepth))).over |
| (ActualOpenSupport.complement completedPlaneZero) := |
| modelPushforwardOverFreeIso M hdepth ≪≫ |
| (SheafOfModules.overFunctor V.ringCatSheaf (ActualOpenSupport.complement completedPlaneZero)).mapIso |
| (SheafOfModules.freeFunctor.mapIso (Fintype.equivFin (basisIndex M hdepth)).toIso) |
|
|
| /-- Coherent lattice, finite conormal layers, K₀ identity, and |
| quotients of conormal-twisted free sheaves for the finite pushforward. |
| Every premise of the reused lattice theorem is supplied by the source. -/ |
| theorem exists_source_free_lattice : |
| ∃ k : ℕ, ∀ n : ℕ, k ≤ n → |
| ∃ a : clearedLattice completedPlaneZero planeIdealLine n (modelPushforward M) ⟶ |
| coherentFree V (Fin (sourceFreeRank M hdepth)), |
| Mono a ∧ |
| ((cohInclusion V).map a).over (ActualOpenSupport.complement completedPlaneZero) = |
| ((powerAction (tensorLeft V.sheaf (idealSheaf completedPlaneZero)) |
| (idealAction V.sheaf (idealι completedPlaneZero)) n).app (modelPushforward M)).over |
| (ActualOpenSupport.complement completedPlaneZero) ≫ |
| (modelPushforwardOverFinIso M hdepth).hom ∧ |
| IsZero (idealMultiple completedPlaneZero planeIdealLine (n + n) (cokernel a)) ∧ |
| cls ((restriction completedPlaneZero planeIdealLine).obj |
| (clearedLattice completedPlaneZero planeIdealLine n (modelPushforward M))) = |
| cls (coherentFree ExplicitCone.plane (Fin (sourceFreeRank M hdepth))) + |
| ((idealLayers completedPlaneZero planeIdealLine (n + n) (cokernel a)).map fun Q => |
| cls (conormalTensor completedPlaneZero planeIdealLine Q) - cls Q).sum ∧ |
| ∀ j : ℕ, Epi (freeTwistedLayerQuotient completedPlaneZero planeIdealLine (cokernel.π a) j) := by |
| let := modelPushforward_coherent M |
| exact exists_free_cleared_lattice completedPlaneZero planeIdealLine (modelPushforward M) |
| (modelPushforward_torsionFree M) (sourceFreeRank M hdepth) (modelPushforwardOverFinIso M hdepth) |
| end SourceConeMorphism |
|
|
| end |
|
|
| /-! Elementary transformations along the exceptional divisor of the completed model. -/ |
| noncomputable section |
| open CategoryTheory CategoryTheory.Limits _root_.AlgebraicGeometry _root_.OAI.AlgebraicGeometry Opposite |
| namespace SourceConeMorphism |
| open KummerSourceModel SourceZeroSections CoherentGlobal ActualCartier ActualSheafTensor |
| Scheme.Modules |
| instance sourceSurface_noetherian : IsLocallyNoetherian ExplicitCone.projectiveSurface := |
| LocallyOfFiniteType.isLocallyNoetherian completedSourceZero |
|
|
| abbrev sourceRestriction := restriction completedSourceZero sourceIdealLine |
| abbrev coherentModel (M : ModuleCat ExplicitCone.completedRing) |
| [Module.Finite ExplicitCone.completedRing M] : Coh W := ⟨E M, E_coherent M⟩ |
|
|
| def sourceRestrictionIso (B : Coh W) : |
| (Scheme.Modules.pullback completedSourceZero).obj B.obj ≅ (sourceRestriction.obj B).obj := |
| restrictionPullbackIso completedSourceZero sourceIdealLine B |
|
|
| lemma modelRestriction_torsionFree (M : ModuleCat ExplicitCone.completedRing) |
| [Module.Finite ExplicitCone.completedRing M] (U : ExplicitCone.projectiveSurface.Opensᵒᵖ) : |
| Module.IsTorsionFree (ExplicitCone.projectiveSurface.sheaf.obj.obj U) |
| ((sourceRestriction.obj (coherentModel M)).obj.val.obj U) := |
| @SheafTorsion.subobject _ _ _ (sourceRestrictionIso (coherentModel M)).inv |
| (@IsIso.mono_of_iso _ _ _ _ _ (sourceRestrictionIso (coherentModel M)).isIso_inv) |
| (fun V => SourceExceptionalRestriction.P_torsionFree M V.unop) U |
|
|
| abbrev elementaryTransform {B : Coh W} {G : Coh ExplicitCone.projectiveSurface} |
| (q : sourceRestriction.obj B ⟶ G) : Coh W := |
| kernel (modificationMap completedSourceZero sourceIdealLine q) |
|
|
| lemma elementaryTransform_torsionFree {B : Coh W} {G : Coh ExplicitCone.projectiveSurface} |
| (q : sourceRestriction.obj B ⟶ G) |
| (hB : ∀ U, Module.IsTorsionFree (W.sheaf.obj.obj U) (B.obj.val.obj U)) |
| (U : W.Opensᵒᵖ) : Module.IsTorsionFree (W.sheaf.obj.obj U) |
| ((elementaryTransform q).obj.val.obj U) := |
| SheafTorsion.subobject ((cohInclusion W).map |
| (kernel.ι (modificationMap completedSourceZero sourceIdealLine q))) hB U |
|
|
| /-- The divisor restriction of an elementary transform is torsion-free |
| when the chosen quotient is torsion-free. -/ |
| lemma elementaryTransform_restriction_torsionFree |
| {B : Coh W} {G : Coh ExplicitCone.projectiveSurface} |
| (q : sourceRestriction.obj B ⟶ G) [Epi q] |
| (hB : ∀ U, Module.IsTorsionFree (W.sheaf.obj.obj U) (B.obj.val.obj U)) |
| (hP : ∀ U, Module.IsTorsionFree (ExplicitCone.projectiveSurface.sheaf.obj.obj U) |
| ((sourceRestriction.obj B).obj.val.obj U)) |
| (hG : ∀ U, Module.IsTorsionFree (ExplicitCone.projectiveSurface.sheaf.obj.obj U) |
| (G.obj.val.obj U)) |
| (U : ExplicitCone.projectiveSurface.Opensᵒᵖ) : |
| Module.IsTorsionFree (ExplicitCone.projectiveSurface.sheaf.obj.obj U) |
| ((sourceRestriction.obj (elementaryTransform q)).obj.val.obj U) := by |
| let S := transformSequence completedSourceZero sourceIdealLine q |
| have hs := transformSequence_shortExact completedSourceZero sourceIdealLine q hB |
| have : Mono S.f := hs.mono_f |
| apply SheafTorsion.coherent_extension S hs.exact |
| · intro V |
| exact SheafTorsion.tensor_line _ _ |
| (sourceIdealLine.pullback completedSourceZero _) hG V |
| · intro V |
| exact SheafTorsion.subobject ((cohInclusion ExplicitCone.projectiveSurface).map |
| (kernel.ι q)) hP V |
|
|
| lemma elementaryTransform_puncture {B : Coh W} {G : Coh ExplicitCone.projectiveSurface} |
| (q : sourceRestriction.obj B ⟶ G) [Epi q] : |
| IsIso ((restrictFunctor (ActualOpenSupport.complement completedSourceZero).ι).map |
| ((cohInclusion W).map (kernel.ι |
| (modificationMap completedSourceZero sourceIdealLine q)))) := by |
| apply modification_puncture_isIso completedSourceZero sourceIdealLine q |
| exact ActualCartier.preimage_complement _ |
| end SourceConeMorphism |
|
|
| end |
|
|
| /-! Extensions obtained by successive elementary transformations in the balancing argument. -/ |
| noncomputable section |
| open CategoryTheory CategoryTheory.Limits _root_.AlgebraicGeometry _root_.OAI.AlgebraicGeometry Opposite |
| namespace SourceConeMorphism |
| open KummerSourceModel SourceZeroSections SourcePullbackChart CoherentGlobal ActualCartier |
| ActualSheafTensor Scheme.Modules |
| abbrev sourceFramedOpen : W.Opens := g ⁻¹ᵁ ActualOpenSupport.complement completedPlaneZero |
| lemma sourceZero_preimage_framed : completedSourceZero ⁻¹ᵁ sourceFramedOpen = ⊥ := by |
| change completedSourceZero ⁻¹ᵁ (g ⁻¹ᵁ ActualOpenSupport.complement completedPlaneZero) = ⊥ |
| rw [← Scheme.Hom.comp_preimage, completedSourceZero_isPullback.w, Scheme.Hom.comp_preimage, |
| ActualCartier.preimage_complement, Scheme.Hom.preimage_bot] |
|
|
| structure ExtensionState (M : ModuleCat ExplicitCone.completedRing) where |
| sheaf : Coh W |
| ambient_tf : ∀ U, Module.IsTorsionFree (W.sheaf.obj.obj U) (sheaf.obj.val.obj U) |
| divisor_tf : ∀ U, Module.IsTorsionFree (ExplicitCone.projectiveSurface.sheaf.obj.obj U) |
| ((sourceRestriction.obj sheaf).obj.val.obj U) |
| punctureIso : (restrictFunctor sourceFramedOpen.ι).obj sheaf.obj ≅ |
| (restrictFunctor sourceFramedOpen.ι).obj (E M) |
|
|
| namespace ExtensionState |
| variable {M : ModuleCat ExplicitCone.completedRing} |
|
|
| def initial [Module.Finite ExplicitCone.completedRing M] : ExtensionState M where |
| sheaf := coherentModel M |
| ambient_tf U := E_torsionFree M U.unop |
| divisor_tf := modelRestriction_torsionFree M |
| punctureIso := Iso.refl _ |
|
|
| /-- The elementary transform constructs another admissible extension |
| and preserves its punctured framing. -/ |
| def transform (B : ExtensionState M) {G : Coh ExplicitCone.projectiveSurface} |
| (q : sourceRestriction.obj B.sheaf ⟶ G) [Epi q] |
| (hG : ∀ U, Module.IsTorsionFree (ExplicitCone.projectiveSurface.sheaf.obj.obj U) |
| (G.obj.val.obj U)) : ExtensionState M where |
| sheaf := elementaryTransform q |
| ambient_tf := elementaryTransform_torsionFree q B.ambient_tf |
| divisor_tf := elementaryTransform_restriction_torsionFree q B.ambient_tf B.divisor_tf hG |
| punctureIso := by |
| have := modification_puncture_isIso completedSourceZero sourceIdealLine q |
| sourceFramedOpen sourceZero_preimage_framed |
| exact asIso ((restrictFunctor sourceFramedOpen.ι).map |
| ((cohInclusion W).map (kernel.ι |
| (modificationMap completedSourceZero sourceIdealLine q)))) ≪≫ B.punctureIso |
|
|
| def pushforward (B : ExtensionState M) : Coh V := (cohPushforward g).obj B.sheaf |
|
|
| lemma pushforward_torsionFree (B : ExtensionState M) (U : V.Opensᵒᵖ) : |
| Module.IsTorsionFree (V.sheaf.obj.obj U) (B.pushforward.obj.val.obj U) := |
| SheafTorsion.pushforward g B.sheaf.obj B.ambient_tf U |
|
|
| variable [Module.Finite ExplicitCone.completedRing M] [Nontrivial M] |
| (hdepth : SmallCM.localDepth ExplicitCone.completedRing M = 3) |
|
|
| def pushforwardFraming (B : ExtensionState M) : |
| (restrictFunctor (ActualOpenSupport.complement completedPlaneZero).ι).obj B.pushforward.obj ≅ |
| SheafOfModules.free (basisIndex M hdepth) := |
| CoherentBaseChange.pushforwardRestrictIso g _ B.sheaf.obj ≪≫ |
| (Scheme.Modules.pushforward (g ∣_ ActualOpenSupport.complement completedPlaneZero)).mapIso |
| B.punctureIso ≪≫ |
| (CoherentBaseChange.pushforwardRestrictIso g _ (E M)).symm ≪≫ |
| modelPushforwardComplementFreeIso M hdepth |
|
|
| def pushforwardOverFinIso (B : ExtensionState M) : |
| B.pushforward.obj.over (ActualOpenSupport.complement completedPlaneZero) ≅ |
| (SheafOfModules.free (R := V.ringCatSheaf) (Fin (sourceFreeRank M hdepth))).over |
| (ActualOpenSupport.complement completedPlaneZero) := by |
| let U := ActualOpenSupport.complement completedPlaneZero |
| exact (overEquiv U).functor.preimageIso |
| ((overFunctorEquiv U).app B.pushforward.obj ≪≫ |
| B.pushforwardFraming hdepth ≪≫ |
| SheafOfModules.freeFunctor.mapIso (Fintype.equivFin (basisIndex M hdepth)).toIso ≪≫ |
| (IsoPuncturePushforward.restrictFreeIso U.ι _).symm ≪≫ |
| ((overFunctorEquiv U).app (SheafOfModules.free |
| (R := V.ringCatSheaf) (Fin (sourceFreeRank M hdepth)))).symm) |
| end ExtensionState |
| end SourceConeMorphism |
|
|
| end |
|
|
| /-! Lattices associated to extensions obtained by elementary transformations. -/ |
| noncomputable section |
| open CategoryTheory CategoryTheory.Limits _root_.AlgebraicGeometry _root_.OAI.AlgebraicGeometry Scheme.Modules |
| namespace SourceConeMorphism.ExtensionState |
| open KummerSourceModel SourceZeroSections ActualCartier ActualSheafTensor CoherentGlobal |
| CartierImageFiltration CoherentK0 |
| variable {M : ModuleCat.{0} ExplicitCone.completedRing} |
| [Module.Finite ExplicitCone.completedRing M] [Nontrivial M] |
| (hdepth : SmallCM.localDepth ExplicitCone.completedRing M = 3) |
|
|
| local instance (B : ExtensionState M) : B.pushforward.obj.IsFinitePresentation := |
| B.pushforward.property |
|
|
| /-- The exact coherent K₀ statement and conormal-twisted quotient |
| layers needed by the lattice inequality, for any constructed extension. -/ |
| theorem exists_free_lattice (B : ExtensionState M) : |
| ∃ k : ℕ, ∀ n : ℕ, k ≤ n → |
| ∃ a : clearedLattice completedPlaneZero planeIdealLine n B.pushforward.obj ⟶ |
| coherentFree V (Fin (sourceFreeRank M hdepth)), |
| Mono a ∧ |
| ((cohInclusion V).map a).over (ActualOpenSupport.complement completedPlaneZero) = |
| ((powerAction (tensorLeft V.sheaf (idealSheaf completedPlaneZero)) |
| (idealAction V.sheaf (idealι completedPlaneZero)) n).app B.pushforward.obj).over |
| (ActualOpenSupport.complement completedPlaneZero) ≫ |
| (B.pushforwardOverFinIso hdepth).hom ∧ |
| IsZero (idealMultiple completedPlaneZero planeIdealLine (n + n) (cokernel a)) ∧ |
| cls ((restriction completedPlaneZero planeIdealLine).obj |
| (clearedLattice completedPlaneZero planeIdealLine n B.pushforward.obj)) = |
| cls (coherentFree ExplicitCone.plane (Fin (sourceFreeRank M hdepth))) + |
| ((idealLayers completedPlaneZero planeIdealLine (n + n) (cokernel a)).map fun Q => |
| cls (conormalTensor completedPlaneZero planeIdealLine Q) - cls Q).sum ∧ |
| ∀ j : ℕ, Epi (freeTwistedLayerQuotient completedPlaneZero planeIdealLine (cokernel.π a) j) := by |
| exact exists_free_cleared_lattice completedPlaneZero planeIdealLine B.pushforward.obj |
| B.pushforward_torsionFree (sourceFreeRank M hdepth) (B.pushforwardOverFinIso hdepth) |
| end SourceConeMorphism.ExtensionState |
|
|
| end |
|
|
| /-! Finite pushforward commutes with restriction for every admissible extension, |
| identifying the restricted lattice with the pushforward of the exceptional sheaf. -/ |
| noncomputable section |
| open CategoryTheory CategoryTheory.Limits _root_.AlgebraicGeometry _root_.OAI.AlgebraicGeometry Scheme.Modules |
| namespace SourceConeMorphism.ExtensionState |
| open KummerSourceModel SourceZeroSections SourcePullbackChart CoherentGlobal ActualCartier |
| CoherentK0 |
| attribute [local instance] ExplicitCone.projectiveNormalization_finite |
| variable {M : ModuleCat ExplicitCone.completedRing} (B : ExtensionState M) |
|
|
| def restrictionPushforwardIso : |
| (restriction completedPlaneZero planeIdealLine).obj B.pushforward ≅ |
| (cohPushforward ExplicitCone.projectiveNormalization).obj (sourceRestriction.obj B.sheaf) := by |
| have := B.sheaf.property |
| exact ObjectProperty.isoMk _ |
| ((restrictionPullbackIso completedPlaneZero planeIdealLine B.pushforward).symm ≪≫ |
| actualClosedBaseChangeIso B.sheaf.obj ≪≫ |
| (Scheme.Modules.pushforward ExplicitCone.projectiveNormalization).mapIso (sourceRestrictionIso B.sheaf)) |
|
|
| lemma restrictionPushforward_class : |
| cls ((restriction completedPlaneZero planeIdealLine).obj B.pushforward) = |
| cls ((cohPushforward ExplicitCone.projectiveNormalization).obj (sourceRestriction.obj B.sheaf)) := |
| cls_iso (restrictionPushforwardIso B) |
| end SourceConeMorphism.ExtensionState |
|
|
| end |
|
|
| /-! Compatibility of canonical mates with object maps in a Cartier base-change square. -/ |
| noncomputable section |
| open CategoryTheory |
| namespace ActualMateUnit |
| universe v₁ v₂ v₃ v₄ u₁ u₂ u₃ u₄ |
| variable {C₁ : Type u₁} {D₁ : Type u₂} {C₂ : Type u₃} {D₂ : Type u₄} |
| [Category.{v₁} C₁] [Category.{v₂} D₁] [Category.{v₃} C₂] [Category.{v₄} D₂] |
| {L₁ : C₁ ⥤ D₁} {R₁ : D₁ ⥤ C₁} {L₂ : C₂ ⥤ D₂} {R₂ : D₂ ⥤ C₂} |
| (a₁ : L₁ ⊣ R₁) (a₂ : L₂ ⊣ R₂) {T : C₁ ⥤ C₂} {B : D₁ ⥤ D₂} |
| (δ : R₁ ⋙ T ⟶ B ⋙ R₂) |
|
|
| lemma chosen_units {M : C₁} {N : C₂} {P : D₁} {Q : D₂} |
| (a : N ⟶ T.obj M) (b : Q ⟶ B.obj P) (e₁ : L₁.obj M ⟶ P) (e₂ : L₂.obj N ⟶ Q) |
| (h : a ≫ T.map (a₁.unit.app M ≫ R₁.map e₁) ≫ δ.app P = |
| (a₂.unit.app N ≫ R₂.map e₂) ≫ R₂.map b) : |
| L₂.map a ≫ (((mateEquiv a₁ a₂).symm (TwoSquare.mk _ _ _ _ δ)).natTrans.app M) ≫ |
| B.map e₁ = e₂ ≫ b := by |
| apply (a₂.homEquiv _ _).injective |
| simp only [Adjunction.homEquiv_unit, Functor.map_comp] |
| rw [a₂.unit_naturality_assoc a] |
| rw [← reassoc_of% (unit_mateEquiv_symm a₁ a₂ (TwoSquare.mk _ _ _ _ δ) M)] |
| change a ≫ T.map (a₁.unit.app M) ≫ δ.app (L₁.obj M) ≫ R₂.map (B.map e₁) = _ |
| erw [← δ.naturality e₁] |
| simp only [Functor.comp_map] |
| rw [← reassoc_of% (T.map_comp (a₁.unit.app M) (R₁.map e₁))] |
| simpa only [Category.assoc] using h |
| lemma three_iso_chain {C : Type*} [Category C] {A B D E F G : C} |
| (s : A ⟶ B) (t : B ⟶ D) (e : D ≅ E) (k : E ≅ F) (l : G ≅ F) |
| (u : A ⟶ G) (x : A ⟶ E) (y : A ⟶ F) |
| (hc : s ≫ t ≫ e.hom = x) (hk : x ≫ k.hom = y) (hl : u ≫ l.hom = y) : |
| s ≫ t ≫ (e.hom ≫ k.hom ≫ l.inv) = u := by |
| apply (cancel_mono l.hom).mp |
| simp only [Category.assoc, l.inv_hom_id, Category.comp_id] |
| rw [← Category.assoc t, ← Category.assoc s, hc, hk, hl] |
|
|
| end ActualMateUnit |
|
|
| end |
|
|
| /-! The base-change mate respects the structure-sheaf maps, |
| identifying the source Cartier ideal with the pullback of the base Cartier ideal. -/ |
| noncomputable section |
| open _root_.AlgebraicGeometry _root_.OAI.AlgebraicGeometry CategoryTheory CategoryTheory.Limits Opposite |
| namespace ActualCartier |
| open Scheme.Modules ActualSheafTensor ActualSheafBaseChange |
| variable {B C D E : Scheme.{0}} |
|
|
| lemma structure_comp (f : C ⟶ B) (w : E ⟶ C) : |
| structureMap f ≫ (pushforward f).map (structureMap w) ≫ |
| (pushforwardComp w f).hom.app (SheafOfModules.unit _) = structureMap (w ≫ f) := by |
| apply Scheme.Modules.hom_ext |
| intro U |
| apply AddCommGrpCat.ext |
| intro r |
| rfl |
|
|
| lemma structure_congr {f g : C ⟶ B} (h : f = g) : |
| structureMap f ≫ (pushforwardCongr h).hom.app (SheafOfModules.unit _) = |
| structureMap g := by |
| subst g |
| apply Scheme.Modules.hom_ext |
| intro U |
| apply AddCommGrpCat.ext |
| intro r |
| change C.presheaf.map (eqToHom (rfl : f ⁻¹ᵁ U = f ⁻¹ᵁ U)).op (f.app U r) = f.app U r |
| simp |
|
|
| lemma structure_square (f : C ⟶ B) (z : D ⟶ B) (w : E ⟶ C) (q : E ⟶ D) |
| (h : w ≫ f = q ≫ z) : |
| structureMap f ≫ (pushforward f).map (structureMap w) ≫ |
| (rightIso f z w q h).hom.app (SheafOfModules.unit _) = |
| structureMap z ≫ (pushforward z).map (structureMap q) := by |
| exact ActualMateUnit.three_iso_chain (structureMap f) |
| ((pushforward f).map (structureMap w)) ((pushforwardComp w f).app _) |
| ((pushforwardCongr h).app _) ((pushforwardComp q z).app _) |
| (structureMap z ≫ (pushforward z).map (structureMap q)) |
| (structureMap (w ≫ f)) (structureMap (q ≫ z)) |
| (structure_comp f w) (structure_congr h) (by |
| change (structureMap z ≫ (pushforward z).map (structureMap q)) ≫ |
| (pushforwardComp q z).hom.app (SheafOfModules.unit _) = _ |
| exact (Category.assoc _ _ _).trans (structure_comp z q)) |
|
|
| lemma pullbackUnit_adj (z : D ⟶ B) : |
| (pullbackPushforwardAdjunction z).unit.app (SheafOfModules.unit _) ≫ |
| (pushforward z).map (sheafPullbackUnitIso z).hom = structureMap z := by |
| apply Scheme.Modules.hom_ext |
| intro U |
| apply AddCommGrpCat.ext |
| intro r |
| exact sheafPullbackUnitIso_unit z U r |
|
|
| lemma baseChange_structure (f : C ⟶ B) (z : D ⟶ B) (w : E ⟶ C) (q : E ⟶ D) |
| (h : w ≫ f = q ≫ z) : |
| (Scheme.Modules.pullback z).map (structureMap f) ≫ |
| (mate f z w q h).app (SheafOfModules.unit _) ≫ |
| (pushforward q).map (sheafPullbackUnitIso w).hom = |
| (sheafPullbackUnitIso z).hom ≫ structureMap q := by |
| apply ActualMateUnit.chosen_units (pullbackPushforwardAdjunction w) |
| (pullbackPushforwardAdjunction z) (rightIso f z w q h).hom |
| (structureMap f) (structureMap q) |
| (sheafPullbackUnitIso w).hom (sheafPullbackUnitIso z).hom |
| rw [pullbackUnit_adj, pullbackUnit_adj] |
| exact structure_square f z w q h |
|
|
| end ActualCartier |
|
|
| end |
|
|
| /-! The closed structure map is an epimorphism by the cokernel property of Cartier restriction. -/ |
| noncomputable section |
| open _root_.AlgebraicGeometry _root_.OAI.AlgebraicGeometry CategoryTheory CategoryTheory.Limits |
| namespace ActualCartier |
| open Scheme.Modules CoherentGlobal ActualSheafTensor |
| variable {X Y : Scheme.{0}} [IsLocallyNoetherian Y] |
| (f : X ⟶ Y) [IsClosedImmersion f] |
| (d : LineTrivialization Y.sheaf (idealSheaf f)) |
|
|
| lemma restrictionPullbackIso_unit (M : Coh Y) : |
| (pullbackPushforwardAdjunction f).unit.app M.obj ≫ |
| (pushforward f).map (restrictionPullbackIso f d M).hom = |
| ((restrictionUnit f d).app M).hom := by |
| change (pullbackPushforwardAdjunction f).unit.app M.obj ≫ |
| (pushforward f).map |
| (((pullbackPushforwardAdjunction f).homEquiv M.obj _).symm |
| ((restrictionUnit f d).app M).hom) = _ |
| exact ((pullbackPushforwardAdjunction f).homEquiv M.obj _).apply_symm_apply _ |
|
|
| include d in |
| lemma coherent_adjUnit_epi (M : Coh Y) : |
| Epi ((pullbackPushforwardAdjunction f).unit.app M.obj) := by |
| have : Epi ((cohInclusion Y).map ((restrictionUnit f d).app M)) := inferInstance |
| have hE : Epi (((restrictionUnit f d).app M).hom) := this |
| have he := restrictionPullbackIso_unit f d M |
| have hI : IsIso ((pushforward f).map (restrictionPullbackIso f d M).hom) := |
| ((pushforward f).mapIso (restrictionPullbackIso f d M)).isIso_hom |
| have hc : Epi ((pullbackPushforwardAdjunction f).unit.app M.obj ≫ |
| (pushforward f).map (restrictionPullbackIso f d M).hom) := he.symm ▸ hE |
| exact (epi_comp_iff_of_isIso _ |
| ((pushforward f).map (restrictionPullbackIso f d M).hom)).mp hc |
|
|
| include d in |
| lemma structureMap_epi : Epi (structureMap f) := by |
| let M : Coh Y := ⟨SheafOfModules.unit _, CoherentLocality.finitePresentation_unit _⟩ |
| have hE : Epi ((pullbackPushforwardAdjunction f).unit.app (SheafOfModules.unit _)) := |
| coherent_adjUnit_epi f d M |
| have hI : IsIso ((pushforward f).map (sheafPullbackUnitIso f).hom) := |
| ((pushforward f).mapIso (sheafPullbackUnitIso f)).isIso_hom |
| have hc := epi_comp' hE (@IsIso.epi_of_iso _ _ _ _ _ hI) |
| erw [pullbackUnit_adj] at hc |
| exact hc |
| end ActualCartier |
|
|
| end |
|
|
| /-! A right-exact pullback induces an epimorphism of kernel ideals |
| when the quotient square is identified. -/ |
| noncomputable section |
| open CategoryTheory CategoryTheory.Limits |
| namespace ActualRightExactIdeal |
| universe v₁ v₂ u₁ u₂ |
| variable {C : Type u₁} {D : Type u₂} [Category.{v₁} C] [Category.{v₂} D] |
| [Abelian C] [Abelian D] (F : C ⥤ D) [F.PreservesZeroMorphisms] |
| [PreservesFiniteColimits F] |
|
|
| lemma kernelComparison_epi {X Y : C} (f : X ⟶ Y) [Epi f] : |
| Epi (kernelComparison f F) := by |
| let S := ShortComplex.mk (kernel.ι f) f (kernel.condition f) |
| have hc : IsColimit (CokernelCofork.ofπ S.g S.zero) := |
| (ShortComplex.exact_kernel f).gIsCokernel |
| have he : (S.map F).Exact := |
| ShortComplex.exact_of_g_is_cokernel _ (CokernelCofork.mapIsColimit _ hc F) |
| exact ((S.map F).exact_iff_epi_kernel_lift).mp he |
|
|
| def comparison {X Y : C} (f : X ⟶ Y) {X' Y' : D} (g : X' ⟶ Y') |
| (a : F.obj X ≅ X') (b : F.obj Y ≅ Y') (h : F.map f ≫ b.hom = a.hom ≫ g) : |
| F.obj (kernel f) ⟶ kernel g := |
| kernelComparison f F ≫ (kernel.mapIso (F.map f) g a b h).hom |
|
|
| instance comparison_epi {X Y : C} (f : X ⟶ Y) [Epi f] {X' Y' : D} (g : X' ⟶ Y') |
| (a : F.obj X ≅ X') (b : F.obj Y ≅ Y') (h : F.map f ≫ b.hom = a.hom ≫ g) : |
| Epi (comparison F f g a b h) := by |
| have := kernelComparison_epi F f |
| dsimp only [comparison] |
| infer_instance |
|
|
| omit [PreservesFiniteColimits F] in |
| lemma comparison_ι {X Y : C} (f : X ⟶ Y) {X' Y' : D} (g : X' ⟶ Y') |
| (a : F.obj X ≅ X') (b : F.obj Y ≅ Y') (h : F.map f ≫ b.hom = a.hom ≫ g) : |
| comparison F f g a b h ≫ kernel.ι g = F.map (kernel.ι f) ≫ a.hom := by |
| simp [comparison] |
| end ActualRightExactIdeal |
|
|
| end |
|
|
| end OAI |
|
|
