| import Mathlib |
| import OAI.AlgebraicGeometry.SectionFields.FlatDescent |
|
|
| namespace OAI |
|
|
| /-! Generic-fibre geometry, function fields and principal presentations. -/ |
|
|
| noncomputable section |
| open AlgebraicGeometry CategoryTheory CategoryTheory.Limits TopologicalSpace Order Polynomial |
| open scoped TensorProduct WithZero |
| universe u |
|
|
| namespace RelativeDenominators |
|
|
| |
|
|
| theorem flat_fromSpecStalk (X : Scheme.{u}) (x : X) : Flat (X.fromSpecStalk x) := by |
| let U : X.Opens := (X.affineCover.f (X.affineCover.idx x)).opensRange |
| have hU : IsAffineOpen U := isAffineOpen_opensRange _ |
| have hx : x ∈ U := X.affineCover.covers x |
| rw [← hU.fromSpecStalk_eq_fromSpecStalk hx] |
| dsimp [IsAffineOpen.fromSpecStalk] |
| have : Flat (Spec.map (X.presheaf.germ U x hx)) := by |
| rw [Flat.SpecMap_iff] |
| let : Algebra Γ(X, U) (X.presheaf.stalk x) := |
| (X.presheaf.germ U x hx).hom.toAlgebra |
| let := hU.isLocalization_stalk ⟨x, hx⟩ |
| exact IsLocalization.flat (X.presheaf.stalk x) (hU.primeIdealOf ⟨x, hx⟩).asIdeal.primeCompl |
| infer_instance |
|
|
| |
|
|
| theorem isIso_stalkMap_of_flat_preimmersion |
| {X Y : Scheme.{u}} (f : X ⟶ Y) [Flat f] [IsPreimmersion f] (x : X) : |
| IsIso (f.stalkMap x) := by |
| let : Algebra (Y.presheaf.stalk (f x)) (X.presheaf.stalk x) := |
| (f.stalkMap x).hom.toAlgebra |
| let : Module.FaithfullyFlat (Y.presheaf.stalk (f x)) (X.presheaf.stalk x) := |
| @Module.FaithfullyFlat.of_flat_of_isLocalHom _ _ _ _ _ _ _ |
| (Flat.stalkMap f x) (f.toLRSHom.prop x) |
| apply (ConcreteCategory.isIso_iff_bijective _).mpr |
| exact ⟨FaithfulSMul.algebraMap_injective (Y.presheaf.stalk (f x)) |
| (X.presheaf.stalk x), f.stalkMap_surjective x⟩ |
|
|
| |
|
|
| abbrev genericFiber {X Z : Scheme.{u}} [IsIntegral Z] (f : X ⟶ Z) : Scheme.{u} := |
| pullback f (Z.fromSpecStalk (genericPoint Z)) |
|
|
| abbrev genericFiberι {X Z : Scheme.{u}} [IsIntegral Z] (f : X ⟶ Z) : |
| genericFiber f ⟶ X := pullback.fst _ _ |
|
|
| abbrev genericFiberToSpec {X Z : Scheme.{u}} [IsIntegral Z] (f : X ⟶ Z) : |
| genericFiber f ⟶ Spec Z.functionField := pullback.snd _ _ |
|
|
| instance genericFiberι_flat {X Z : Scheme.{u}} [IsIntegral Z] (f : X ⟶ Z) : |
| Flat (genericFiberι f) := by |
| let := flat_fromSpecStalk Z (genericPoint Z) |
| change Flat (pullback.fst f (Z.fromSpecStalk (genericPoint Z))) |
| infer_instance |
|
|
| instance genericFiberι_preimmersion {X Z : Scheme.{u}} [IsIntegral Z] (f : X ⟶ Z) : |
| IsPreimmersion (genericFiberι f) := inferInstanceAs (IsPreimmersion (pullback.fst _ _)) |
|
|
| instance genericFiberι_stalk_iso {X Z : Scheme.{u}} [IsIntegral Z] |
| (f : X ⟶ Z) (x : genericFiber f) : IsIso ((genericFiberι f).stalkMap x) := |
| isIso_stalkMap_of_flat_preimmersion _ _ |
|
|
| lemma range_fromSpecStalk_generic (Z : Scheme.{u}) [IsIntegral Z] : |
| Set.range (Z.fromSpecStalk (genericPoint Z)) = {genericPoint Z} := by |
| rw [Scheme.range_fromSpecStalk] |
| ext z |
| exact ⟨fun h => (h.antisymm ((genericPoint_spec Z).specializes trivial)).eq, |
| fun h => h ▸ specializes_rfl⟩ |
|
|
| lemma range_genericFiberι {X Z : Scheme.{u}} [IsIntegral Z] (f : X ⟶ Z) : |
| Set.range (genericFiberι f) = f ⁻¹' {genericPoint Z} := by |
| rw [genericFiberι, Scheme.Pullback.range_fst, range_fromSpecStalk_generic] |
| |
| lemma genericPoint_mem_range_genericFiberι |
| {X Z : Scheme.{u}} [IsIntegral X] [IsIntegral Z] |
| (f : X ⟶ Z) [IsDominant f] : genericPoint X ∈ Set.range (genericFiberι f) := by |
| rw [range_genericFiberι] |
| change f (genericPoint X) = genericPoint Z |
| apply IsGenericPoint.eq _ (genericPoint_spec Z) |
| simpa [Set.image_univ, f.denseRange.closure_range] using |
| (genericPoint_spec X).image f.continuous |
| |
| instance genericFiberι_dominant |
| {X Z : Scheme.{u}} [IsIntegral X] [IsIntegral Z] |
| (f : X ⟶ Z) [IsDominant f] : IsDominant (genericFiberι f) := by |
| constructor |
| intro x |
| apply closure_mono (Set.singleton_subset_iff.mpr (genericPoint_mem_range_genericFiberι f)) |
| rw [(genericPoint_spec X).def] |
| trivial |
| |
| instance genericFiber_irreducible |
| {X Z : Scheme.{u}} [IsIntegral X] [IsIntegral Z] |
| (f : X ⟶ Z) [IsDominant f] : IrreducibleSpace (genericFiber f) := by |
| obtain ⟨y, hy⟩ := genericPoint_mem_range_genericFiberι f |
| have hg : IsGenericPoint y Set.univ := by |
| rw [isGenericPoint_iff_specializes] |
| intro z |
| simp only [Set.mem_univ, iff_true] |
| apply (genericFiberι f).isEmbedding.isInducing.specializes_iff.mp |
| rw [hy] |
| exact (genericPoint_spec X).specializes trivial |
| exact (irreducibleSpace_def _).mpr hg.isIrreducible |
| |
| instance genericFiber_reduced |
| {X Z : Scheme.{u}} [IsIntegral X] [IsIntegral Z] |
| (f : X ⟶ Z) : AlgebraicGeometry.IsReduced (genericFiber f) := by |
| let (x : genericFiber f) : _root_.IsReduced ((genericFiber f).presheaf.stalk x) := |
| isReduced_of_injective (asIso ((genericFiberι f).stalkMap x)).inv.hom |
| (ConcreteCategory.bijective_of_isIso _).1 |
| exact isReduced_of_isReduced_stalk _ |
| |
| instance genericFiber_integral |
| {X Z : Scheme.{u}} [IsIntegral X] [IsIntegral Z] |
| (f : X ⟶ Z) [IsDominant f] : IsIntegral (genericFiber f) := |
| isIntegral_of_irreducibleSpace_of_isReduced _ |
| |
| theorem genericFiber_normal |
| {X Z : Scheme.{u}} [IsIntegral X] [IsIntegral Z] |
| (f : X ⟶ Z) (hNX : ∀ x : X, IsIntegrallyClosed (X.presheaf.stalk x)) |
| (x : genericFiber f) : IsIntegrallyClosed ((genericFiber f).presheaf.stalk x) := by |
| let := hNX (genericFiberι f x) |
| exact IsIntegrallyClosed.of_equiv |
| (asIso ((genericFiberι f).stalkMap x)).commRingCatIsoToRingEquiv |
| |
| instance genericFiber_isNoetherian |
| {X Z : Scheme.{u}} [IsIntegral Z] (f : X ⟶ Z) [LocallyOfFiniteType f] [QuasiCompact f] : |
| IsNoetherian (genericFiber f) := by |
| have : LocallyOfFiniteType (genericFiberToSpec f) := |
| inferInstanceAs (LocallyOfFiniteType (pullback.snd _ _)) |
| have : QuasiCompact (genericFiberToSpec f) := |
| inferInstanceAs (QuasiCompact (pullback.snd _ _)) |
| have : IsLocallyNoetherian (genericFiber f) := |
| LocallyOfFiniteType.isLocallyNoetherian (genericFiberToSpec f) |
| have : CompactSpace (genericFiber f) := |
| QuasiCompact.compactSpace_of_compactSpace (genericFiberToSpec f) |
| exact {} |
| |
| open Order TopologicalSpace |
| |
| |
| |
| noncomputable def genericFiberFunctionFieldEquiv |
| {X Z : Scheme.{u}} [IsIntegral X] [IsIntegral Z] |
| (f : X ⟶ Z) [IsDominant f] : |
| X.functionField ≃+* (genericFiber f).functionField := by |
| apply RingEquiv.ofBijective (functionFieldPullback (genericFiberι f)) |
| let e := X.presheaf.stalkCongr |
| (Inseparable.of_eq (genericPoint_eq_of_dominant (genericFiberι f))) |
| have he : X.presheaf.stalkSpecializes |
| (specializes_of_eq (genericPoint_eq_of_dominant (genericFiberι f))) = e.inv := rfl |
| have : IsIso (X.presheaf.stalkSpecializes |
| (specializes_of_eq (genericPoint_eq_of_dominant (genericFiberι f)))) := by |
| rw [he]; infer_instance |
| exact ConcreteCategory.bijective_of_isIso |
| (X.presheaf.stalkSpecializes |
| (specializes_of_eq (genericPoint_eq_of_dominant (genericFiberι f))) ≫ |
| (genericFiberι f).stalkMap (genericPoint (genericFiber f))) |
| |
| |
| |
| theorem pullbackQCartier_eq_zero_at_of_mem_range |
| {X Z : Scheme} [IsIntegral X] [IsIntegral Z] [IsNoetherian X] [IsNoetherian Z] |
| (hNX : ∀ x : X, IsIntegrallyClosed (X.presheaf.stalk x)) |
| (hNZ : ∀ z : Z, IsIntegrallyClosed (Z.presheaf.stalk z)) |
| (f : X ⟶ Z) [IsDominant f] [Flat f] |
| (D : RationalWeilDivisor Z) (hD : IsQCartier Z D) |
| (hzero : pullbackQCartier hNZ f D hD = 0) |
| (p : PrimeDivisor Z) (hp : p.1 ∈ Set.range f) : D p = 0 := by |
| let c := hD.data |
| obtain ⟨x, hx⟩ := hp |
| have hord : ∀ y : X, f y ∈ c.chart p.1 → coheight y = 1 → |
| X.ord (functionFieldPullback f (c.equation p.1 : Z.functionField)) y = 0 := by |
| intro y hy hc |
| have h := pullbackQCartier_apply_of_local hNZ f D hD c.index c.index_pos |
| (c.chart p.1) (c.equation p.1) (c.ord_eq p.1) ⟨y, hc⟩ hy |
| rw [hzero, Finsupp.zero_apply] at h |
| have hz : (X.ord (functionFieldPullback f (c.equation p.1 : Z.functionField)) y : ℚ) = 0 := by |
| exact (div_eq_zero_iff).mp h.symm |>.resolve_right (by exact_mod_cast c.index_pos.ne') |
| exact_mod_cast hz |
| obtain ⟨r, hr⟩ := stalk_unit_of_flat_pullback_ord_zero hNX f (c.chart p.1) |
| (c.equation p.1) hord x (by simpa only [hx] using c.mem_chart p.1) |
| have hz : Z.ord (c.equation p.1 : Z.functionField) (f x) = 0 := by |
| rw [← hr] |
| exact ord_eq_zero_of_stalk_unit Z (f x) (by rw [hx]; exact p.2) r |
| rw [hx] at hz |
| have he := c.ord_eq p.1 p (c.mem_chart p.1) |
| rw [hz, Int.cast_zero] at he |
| exact (mul_eq_zero.mp he).resolve_left (by exact_mod_cast c.index_pos.ne') |
| |
| |
| |
| theorem isVertical_of_genericFiber_pullback_zero |
| {X Z : Scheme.{u}} [IsIntegral X] [IsIntegral Z] [IsNoetherian X] |
| (hNX : ∀ x : X, IsIntegrallyClosed (X.presheaf.stalk x)) |
| (f : X ⟶ Z) [IsDominant f] [LocallyOfFiniteType f] [QuasiCompact f] |
| (D : RationalWeilDivisor X) (hD : IsQCartier X D) |
| (hzero : pullbackQCartier hNX (genericFiberι f) D hD = 0) : |
| IsVerticalRationalDivisor f D := by |
| intro p hp he |
| apply hp |
| apply pullbackQCartier_eq_zero_at_of_mem_range (genericFiber_normal f hNX) |
| hNX (genericFiberι f) D hD hzero p |
| rw [range_genericFiberι] |
| exact he |
| |
| |
| |
| theorem exists_vertical_principalization_of_genericFiber |
| {X Z : Scheme.{u}} [IsIntegral X] [IsIntegral Z] [IsNoetherian X] |
| (hNX : ∀ x : X, IsIntegrallyClosed (X.presheaf.stalk x)) |
| (f : X ⟶ Z) [IsDominant f] [LocallyOfFiniteType f] [QuasiCompact f] |
| (A : RationalWeilDivisor X) (hA : IsQCartier X A) (p : ℕ) |
| (u : (genericFiber f).functionFieldˣ) |
| (hu : (p : ℚ) • pullbackQCartier hNX (genericFiberι f) A hA + |
| rationalPrincipalDivisor (genericFiber f) u = 0) : |
| ∃ ψ : X.functionFieldˣ, |
| IsVerticalRationalDivisor f ((p : ℚ) • A + rationalPrincipalDivisor X ψ) := by |
| let e := genericFiberFunctionFieldEquiv f |
| let ψ := Units.map e.symm.toMonoidHom u |
| have hψ : Units.map (functionFieldPullback (genericFiberι f)).toMonoidHom ψ = u := by |
| apply Units.ext |
| exact e.apply_symm_apply (u : (genericFiber f).functionField) |
| refine ⟨ψ, isVertical_of_genericFiber_pullback_zero hNX f _ |
| (isQCartier_add (isQCartier_smul hA (p : ℚ)) (isQCartier_principal X ψ)) ?_⟩ |
| rw [pullbackQCartier_add hNX (genericFiberι f) |
| (isQCartier_smul hA (p : ℚ)) (isQCartier_principal X ψ), |
| pullbackQCartier_smul hNX (genericFiberι f) hA, |
| pullbackQCartier_principal hNX (genericFiberι f), hψ] |
| exact hu |
| |
| |
| |
| theorem relative_exact_presentation_of_genericFiber_principalization |
| {X Z : Scheme.{u}} [IsIntegral X] [IsIntegral Z] [IsNoetherian X] [IsNoetherian Z] |
| (hNX : ∀ x : X, IsIntegrallyClosed (X.presheaf.stalk x)) |
| (hNZ : ∀ z : Z, IsIntegrallyClosed (Z.presheaf.stalk z)) |
| (f : X ⟶ Z) [IsDominant f] [IsIso f.c] [LocallyOfFiniteType f] [QuasiCompact f] |
| (A : RationalWeilDivisor X) (hA : IsQCartier X A) |
| (D : RationalWeilDivisor Z) (hD : IsQCartier Z D) |
| (p a : ℕ) (hp : 0 < p) (ha : 0 < a) (hpa : p ∣ a) |
| (u : (genericFiber f).functionFieldˣ) |
| (hu : (p : ℚ) • pullbackQCartier hNX (genericFiberι f) A hA + |
| rationalPrincipalDivisor (genericFiber f) u = 0) |
| (φ : X.functionFieldˣ) |
| (hlinear : (a : ℚ) • A + rationalPrincipalDivisor X φ = |
| pullbackQCartier hNZ f ((a : ℚ) • D) (isQCartier_smul hD (a : ℚ))) : |
| ∃ (ψ : X.functionFieldˣ) (DZ : RationalWeilDivisor Z) (hDZ : IsQCartier Z DZ), |
| RationallyLinearlyEquivalent Z DZ D ∧ |
| A + (p : ℚ)⁻¹ • rationalPrincipalDivisor X ψ = pullbackQCartier hNZ f DZ hDZ := by |
| obtain ⟨ψ, hψ⟩ := exists_vertical_principalization_of_genericFiber hNX f A hA p u hu |
| obtain ⟨DZ, hDZ, hlin, heq⟩ := relative_exact_presentation_of_vertical_principalization |
| hNX hNZ f A D hD p a hp ha hpa ψ φ hψ hlinear |
| exact ⟨ψ, DZ, hDZ, hlin, heq⟩ |
| |
| end RelativeDenominators |
| end |
| |
| end OAI |
| |
