| import Mathlib |
|
|
| namespace OAI |
|
|
| /-! Normal local rings, height-one orders, divisors and descent of rational functions. -/ |
|
|
| noncomputable section |
| open AlgebraicGeometry CategoryTheory CategoryTheory.Limits TopologicalSpace Order Polynomial |
| open scoped TensorProduct WithZero |
| universe u |
|
|
| namespace RelativeDenominators |
|
|
| open IsLocalRing |
|
|
| |
| theorem maximalIdeal_isPrincipal_of_fraction_witness |
| {R K : Type*} [CommRing R] [IsDomain R] [IsNoetherianRing R] |
| [IsLocalRing R] [IsIntegrallyClosed R] |
| [Field K] [Algebra R K] [IsFractionRing R K] |
| (x : K) (hx : ∀ r : R, algebraMap R K r ≠ x) |
| (hxM : ∀ m ∈ maximalIdeal R, |
| ∃ r : R, algebraMap R K r = x * algebraMap R K m) : |
| (maximalIdeal R).IsPrincipal := by |
| classical |
| by_cases hbot : maximalIdeal R = ⊥ |
| · rw [hbot] |
| infer_instance |
| obtain ⟨a, ha, ha0⟩ : ∃ a ∈ maximalIdeal R, a ≠ (0 : R) := by |
| by_contra! h |
| apply hbot |
| rwa [Submodule.eq_bot_iff] |
| let M := Submodule.map (Algebra.linearMap R K) (maximalIdeal R) |
| have hM : M ≠ ⊥ := by |
| rw [Submodule.ne_bot_iff] |
| exact ⟨_, ⟨a, ha, rfl⟩, |
| (IsFractionRing.to_map_eq_zero_iff (K := K)).not.mpr ha0⟩ |
| have hfg : M.FG := Submodule.FG.map _ (IsNoetherian.noetherian _) |
| by_cases hclosed : ∀ y ∈ M, x * y ∈ M |
| · have hi := isIntegral_of_smul_mem_submodule M hM hfg x hclosed |
| obtain ⟨r, hr⟩ := IsIntegrallyClosed.algebraMap_eq_of_integral hi |
| exact (hx r hr).elim |
| have htop : |
| (M.map (DistribSMul.toLinearMap R K x)).comap (Algebra.linearMap R K) = ⊤ := by |
| contrapose! hclosed with h |
| rintro m' ⟨m, hm, rfl : algebraMap R K m = m'⟩ |
| obtain ⟨k, hk⟩ := hxM m hm |
| exact ⟨k, le_maximalIdeal h ⟨_, ⟨_, hm, rfl⟩, hk.symm⟩, hk⟩ |
| obtain ⟨y, hy, hxy⟩ : ∃ y ∈ maximalIdeal R, x * algebraMap R K y = 1 := by |
| rw [Ideal.eq_top_iff_one, Submodule.mem_comap] at htop |
| obtain ⟨_, ⟨y, hy, rfl⟩, hy'⟩ := htop |
| exact ⟨y, hy, by simpa using hy'⟩ |
| refine ⟨⟨y, ?_⟩⟩ |
| apply le_antisymm |
| · intro m hm |
| obtain ⟨k, hk⟩ := hxM m hm |
| apply Ideal.mem_span_singleton'.mpr |
| refine ⟨k, IsFractionRing.injective R K ?_⟩ |
| rw [map_mul, hk] |
| calc x * algebraMap R K m * algebraMap R K y = |
| algebraMap R K m * (x * algebraMap R K y) := by ring |
| _ = algebraMap R K m := by rw [hxy, mul_one] |
| · rwa [Submodule.span_le, Set.singleton_subset_iff] |
|
|
| |
| theorem exists_prime_colon_over |
| {R M : Type*} [CommRing R] [AddCommGroup M] [Module R M] |
| [H : IsNoetherianRing R] (N : Submodule R M) (x : M) (hx : x ∉ N) : |
| ∃ (P : Ideal R) (y : M), P.IsPrime ∧ P = N.colon {y} ∧ N.colon {x} ≤ P := by |
| classical |
| obtain ⟨P, ⟨hle, hne, y, rfl⟩, hmax⟩ := |
| set_has_maximal_iff_noetherian.mpr H |
| { P | N.colon {x} ≤ P ∧ P ≠ ⊤ ∧ ∃ y : M, P = N.colon {y} } |
| ⟨_, le_rfl, by simpa [Submodule.colon_eq_top_iff_subset] using hx, x, rfl⟩ |
| refine ⟨_, y, ⟨hne, ?_⟩, rfl, hle⟩ |
| intro a b hab |
| rw [or_iff_not_imp_left] |
| intro ha |
| rw [Submodule.mem_colon_singleton] at ha hab |
| have hle' : N.colon {y} ≤ N.colon {a • y} := by |
| intro c hc |
| rw [Submodule.mem_colon_singleton] at hc ⊢ |
| rw [smul_comm] |
| exact N.smul_mem a hc |
| rw [hle'.eq_of_not_lt (hmax _ ⟨hle.trans hle', |
| by simpa [Submodule.colon_eq_top_iff_subset] using ha, _, rfl⟩), |
| Submodule.mem_colon_singleton, smul_comm, smul_smul] |
| exact hab |
|
|
| section HeightOne |
|
|
| variable {R K : Type*} [CommRing R] [IsDomain R] |
| [Field K] [Algebra R K] [IsFractionRing R K] |
|
|
| |
|
|
| theorem mem_localization_iff_denominator (P : Ideal R) [P.IsPrime] (x : K) : |
| x ∈ Localization.subalgebra.ofField K P.primeCompl P.primeCompl_le_nonZeroDivisors ↔ |
| ∃ s : R, s ∉ P ∧ s ∈ (Algebra.linearMap R K).range.colon {x} := by |
| constructor |
| · rintro ⟨a, s, hs, hx⟩ |
| refine ⟨s, hs, ?_⟩ |
| rw [Submodule.mem_colon_singleton, Algebra.smul_def] |
| refine ⟨a, ?_⟩ |
| change algebraMap R K a = algebraMap R K s * x |
| have hs0 : algebraMap R K s ≠ 0 := |
| IsFractionRing.to_map_ne_zero_of_mem_nonZeroDivisors |
| (P.primeCompl_le_nonZeroDivisors hs) |
| rw [hx, mul_left_comm, mul_inv_cancel₀ hs0, mul_one] |
| · rintro ⟨s, hs, h⟩ |
| obtain ⟨a, ha⟩ := (Submodule.mem_colon_singleton.mp h) |
| refine ⟨a, s, hs, ?_⟩ |
| have hs0 : algebraMap R K s ≠ 0 := |
| IsFractionRing.to_map_ne_zero_of_mem_nonZeroDivisors |
| (P.primeCompl_le_nonZeroDivisors hs) |
| simp only [Algebra.linearMap_apply, Algebra.smul_def] at ha |
| rw [← div_eq_mul_inv, eq_div_iff hs0, mul_comm] |
| exact ha.symm |
|
|
| |
| theorem height_eq_one_of_prime_denominator_ideal |
| [IsNoetherianRing R] [IsIntegrallyClosed R] |
| (P : Ideal R) [P.IsPrime] (y : K) |
| (hP : P = (Algebra.linearMap R K).range.colon {y}) : P.height = 1 := by |
| classical |
| let A := Localization.subalgebra.ofField K P.primeCompl P.primeCompl_le_nonZeroDivisors |
| let : IsLocalRing A := IsLocalization.AtPrime.isLocalRing A P |
| let : IsNoetherianRing A := IsLocalization.isNoetherianRing P.primeCompl A inferInstance |
| let : IsIntegrallyClosed A := isIntegrallyClosed_of_isLocalization A |
| P.primeCompl P.primeCompl_le_nonZeroDivisors |
| have hy : y ∉ A := by |
| rw [mem_localization_iff_denominator] |
| rintro ⟨s, hs, hd⟩ |
| exact hs (hP ▸ hd) |
| have hmul : ∀ m ∈ maximalIdeal A, |
| ∃ r : A, algebraMap A K r = y * algebraMap A K m := by |
| intro m hm |
| obtain ⟨a, s, hs, he⟩ := m.property |
| have hs0 : algebraMap R K s ≠ 0 := |
| IsFractionRing.to_map_ne_zero_of_mem_nonZeroDivisors |
| (P.primeCompl_le_nonZeroDivisors hs) |
| have hma : algebraMap R A a = algebraMap R A s * m := by |
| apply Subtype.ext |
| change algebraMap R K a = algebraMap R K s * (m : K) |
| rw [he, mul_left_comm, mul_inv_cancel₀ hs0, mul_one] |
| have ha : a ∈ P := (IsLocalization.AtPrime.to_map_mem_maximal_iff A P a).mp (by |
| rw [hma] |
| exact (maximalIdeal A).mul_mem_left _ hm) |
| rw [hP, Submodule.mem_colon_singleton] at ha |
| obtain ⟨k, hk⟩ := ha |
| simp only [Algebra.linearMap_apply, Algebra.smul_def] at hk |
| refine ⟨⟨algebraMap R K k * (algebraMap R K s)⁻¹, k, s, hs, rfl⟩, ?_⟩ |
| change algebraMap R K k * (algebraMap R K s)⁻¹ = y * (m : K) |
| rw [he, hk] |
| ring |
| have : (maximalIdeal A).IsPrincipal := |
| maximalIdeal_isPrincipal_of_fraction_witness y |
| (fun r h => hy (h ▸ r.property)) hmul |
| have hle : P.height ≤ 1 := by |
| rw [← IsLocalization.AtPrime.under_maximalIdeal A P, |
| IsLocalization.height_under P.primeCompl] |
| exact Ideal.height_le_one_of_isPrincipal_of_mem_minimalPrimes |
| (maximalIdeal A) (maximalIdeal A) (by simp [Ideal.minimalPrimes_eq_subsingleton_self]) |
| have hne : P ≠ ⊥ := by |
| obtain ⟨a, b, hb, he⟩ := IsFractionRing.div_surjective R y |
| have hbP : b ∈ P := by |
| rw [hP, Submodule.mem_colon_singleton, Algebra.smul_def] |
| refine ⟨a, ?_⟩ |
| change algebraMap R K a = algebraMap R K b * y |
| rw [← he, mul_div_cancel₀ _ |
| (IsFractionRing.to_map_ne_zero_of_mem_nonZeroDivisors hb)] |
| intro hbot |
| rw [hbot, Submodule.mem_bot] at hbP |
| exact nonZeroDivisors.ne_zero hb hbP |
| exact le_antisymm hle (Order.one_le_iff_ne_zero.mpr |
| (Ideal.height_eq_zero_iff_eq_bot.not.mpr hne)) |
|
|
| |
|
|
| theorem exists_algebraMap_eq_of_mem_height_one_localizations |
| [IsNoetherianRing R] [IsIntegrallyClosed R] (x : K) |
| (hx : ∀ (P : Ideal R) [P.IsPrime], P.height = 1 → |
| x ∈ Localization.subalgebra.ofField K P.primeCompl P.primeCompl_le_nonZeroDivisors) : |
| ∃ r : R, algebraMap R K r = x := by |
| classical |
| by_contra h |
| have hx' : x ∉ (Algebra.linearMap R K).range := h |
| obtain ⟨P, y, hprime, hP, hle⟩ := |
| exists_prime_colon_over (Algebra.linearMap R K).range x hx' |
| have : P.IsPrime := hprime |
| have hheight : P.height = 1 := height_eq_one_of_prime_denominator_ideal P y hP |
| obtain ⟨s, hs, hd⟩ := (mem_localization_iff_denominator P x).mp (hx P hheight) |
| exact hs (hle hd) |
|
|
| end HeightOne |
|
|
| |
|
|
| open AlgebraicGeometry TopologicalSpace Order CategoryTheory |
|
|
| |
|
|
| theorem integrallyClosed_affine_sections |
| (X : Scheme) [IsIntegral X] |
| (hNormal : ∀ x : X, IsIntegrallyClosed (X.presheaf.stalk x)) |
| (U : X.Opens) (hU : IsAffineOpen U) [Nonempty U] : |
| IsIntegrallyClosed Γ(X, U) := by |
| apply IsIntegrallyClosed.of_localization_maximal |
| intro p hp hpmax |
| let y : PrimeSpectrum Γ(X, U) := ⟨p, inferInstance⟩ |
| let S := X.presheaf.stalk (hU.fromSpec y) |
| let : Algebra Γ(X, U) S := |
| X.presheaf.algebra_section_stalk ⟨hU.fromSpec y, (hU.isoSpec.inv y).2⟩ |
| let : IsLocalization.AtPrime S p := hU.isLocalization_stalk' y (hU.isoSpec.inv y).2 |
| let : IsIntegrallyClosed S := hNormal _ |
| exact IsIntegrallyClosed.of_equiv |
| (IsLocalization.algEquiv p.primeCompl S (Localization.AtPrime p)).toRingEquiv |
|
|
| |
|
|
| theorem dvr_stalk_of_normal_codimOne |
| (X : Scheme) [IsIntegral X] [IsLocallyNoetherian X] |
| (x : X) (hx : coheight x = 1) [IsIntegrallyClosed (X.presheaf.stalk x)] : |
| IsDiscreteValuationRing (X.presheaf.stalk x) := by |
| let R := X.presheaf.stalk x |
| have hdim : ringKrullDim R = 1 := by |
| rw [ringKrullDim_stalk_eq_coheight, hx] |
| rfl |
| have hnf : ¬ IsField R := by |
| intro h |
| have hzero := ringKrullDim_eq_zero_of_isField h |
| rw [hdim] at hzero |
| exact one_ne_zero hzero |
| let : Ring.KrullDimLE 1 R := krullDimLE_of_coheight_le hx.le |
| apply ((IsDiscreteValuationRing.TFAE R hnf).out 1 4).mpr |
| refine ⟨inferInstance, IsLocalRing.maximalIdeal R, ⟨?_, inferInstance⟩, ?_⟩ |
| · exact IsLocalRing.isField_iff_maximalIdeal_eq.not.mp hnf |
| · intro P hP |
| exact IsLocalRing.eq_maximalIdeal (hP.2.isMaximal_of_ne_bot hP.1) |
|
|
| |
|
|
| |
| abbrev PrimeDivisor (X : Scheme) := {x : X // coheight x = 1} |
|
|
| |
| abbrev WeilDivisor (X : Scheme) := PrimeDivisor X →₀ ℤ |
|
|
| |
|
|
| theorem finite_codimOne_outside_open (X : Scheme) [IsIntegral X] [IsNoetherian X] |
| (U : X.Opens) [Nonempty U] : |
| {x : X | coheight x = 1 ∧ x ∉ U}.Finite := by |
| classical |
| obtain ⟨S, hSf, hSc, hSi, hSU⟩ := |
| NoetherianSpace.exists_finite_set_isClosed_irreducible U.isOpen.isClosed_compl |
| let g : S → X := fun s => (hSi s.1 s.2).genericPoint |
| let : Finite S := hSf.to_subtype |
| apply (Set.finite_range g).subset |
| intro x hx |
| obtain ⟨s, hsS, hxs⟩ : ∃ s ∈ S, x ∈ s := by |
| have hxS : x ∈ ⋃₀ S := by rw [← hSU]; exact hx.2 |
| exact Set.mem_sUnion.mp hxS |
| refine ⟨⟨s, hsS⟩, ?_⟩ |
| have hg : IsGenericPoint (g ⟨s, hsS⟩) s := |
| (hSi s hsS).isGenericPoint_genericPoint (hSc s hsS) |
| have hle : x ≤ g ⟨s, hsS⟩ := hg.specializes hxs |
| have hgnU : g ⟨s, hsS⟩ ∉ U := by |
| have hgS : g ⟨s, hsS⟩ ∈ ⋃₀ S := Set.mem_sUnion.mpr ⟨s, hsS, hg.mem⟩ |
| rwa [← hSU] at hgS |
| have huet : genericPoint X ∈ U := by |
| apply (genericPoint_spec X).mem_open_set_iff U.isOpen |>.mpr |
| simpa using Set.nonempty_coe_sort.mp (inferInstance : Nonempty U) |
| have hback : g ⟨s, hsS⟩ ≤ x := by |
| by_contra hn |
| have hlt : x < g ⟨s, hsS⟩ := lt_iff_le_not_ge.mpr ⟨hle, hn⟩ |
| have hheight : coheight (g ⟨s, hsS⟩) = 0 := by |
| apply Order.lt_one_iff.mp |
| exact (coheight_le_coe_iff.mp (by simpa using hx.1.le)) _ hlt |
| have hmax : IsMax (g ⟨s, hsS⟩) := coheight_eq_zero.mp hheight |
| have hgeneric : genericPoint X ≤ g ⟨s, hsS⟩ := |
| hmax (genericPoint_specializes _) |
| exact hgnU (hgeneric.mem_open U.isOpen huet) |
| exact ((show g ⟨s, hsS⟩ ⤳ x from hle).antisymm |
| (show x ⤳ g ⟨s, hsS⟩ from hback)).eq |
|
|
| |
| theorem finite_support_ord (X : Scheme) [IsIntegral X] [IsNoetherian X] |
| (f : X.functionField) (hf : f ≠ 0) : |
| (Function.support fun x : PrimeDivisor X => X.ord f x.1).Finite := by |
| obtain ⟨U, hUaff, f', hUne, hf', hf'unit⟩ := exists_isUnit_germ_eq X f hf |
| let : Nonempty U := hUne |
| have hfinite := finite_codimOne_outside_open X U |
| apply (hfinite.preimage Subtype.val_injective.injOn).subset |
| intro x hx |
| refine ⟨x.2, ?_⟩ |
| intro hxU |
| have hz : X.ord f x.1 = 0 := by |
| rw [← hf'] |
| exact X.ord_of_isUnit hf'unit hxU |
| exact hx hz |
|
|
| |
| noncomputable def principalDivisor (X : Scheme) [IsIntegral X] [IsNoetherian X] |
| (f : X.functionFieldˣ) : WeilDivisor X := |
| Finsupp.ofSupportFinite (fun x => X.ord (f : X.functionField) x.1) |
| (finite_support_ord X (f : X.functionField) (Units.ne_zero f)) |
|
|
| @[simp] theorem principalDivisor_apply (X : Scheme) [IsIntegral X] [IsNoetherian X] |
| (f : X.functionFieldˣ) (x : PrimeDivisor X) : |
| principalDivisor X f x = X.ord (f : X.functionField) x.1 := rfl |
|
|
| |
|
|
| theorem exists_stalk_unit_of_ord_eq_zero |
| (X : Scheme) [IsIntegral X] [IsLocallyNoetherian X] |
| (x : X) (hx : coheight x = 1) [IsIntegrallyClosed (X.presheaf.stalk x)] |
| (f : X.functionField) (hf : f ≠ 0) (hord : X.ord f x = 0) : |
| ∃ s : X.presheaf.stalk x, IsUnit s ∧ algebraMap _ X.functionField s = f := by |
| let : IsDiscreteValuationRing (X.presheaf.stalk x) := |
| dvr_stalk_of_normal_codimOne X x hx |
| have h : Ring.ordFrac (X.presheaf.stalk x) f = 1 := by |
| simpa [Scheme.ordHom] using (X.ord_eq_iff hx hf).mp hord |
| change f ∈ MonoidHom.mker (Ring.ordFrac (X.presheaf.stalk x)) at h |
| rw [Ring.mker_ordFrac_eq_isUnitSubmonoid] at h |
| exact h |
|
|
| |
|
|
| theorem exists_affine_section_of_ord_eq_zero |
| (X : Scheme) [IsIntegral X] [IsNoetherian X] |
| (hNormal : ∀ x : X, IsIntegrallyClosed (X.presheaf.stalk x)) |
| (U : X.Opens) (hU : IsAffineOpen U) [Nonempty U] |
| (f : X.functionField) (hf : f ≠ 0) |
| (hord : ∀ x : X, x ∈ U → coheight x = 1 → X.ord f x = 0) : |
| ∃ s : Γ(X, U), algebraMap Γ(X, U) X.functionField s = f := by |
| let : IsIntegrallyClosed Γ(X, U) := integrallyClosed_affine_sections X hNormal U hU |
| let : IsNoetherianRing Γ(X, U) := IsLocallyNoetherian.component_noetherian ⟨U, hU⟩ |
| let : IsFractionRing Γ(X, U) X.functionField := |
| functionField_isFractionRing_of_isAffineOpen X U hU |
| apply exists_algebraMap_eq_of_mem_height_one_localizations |
| intro P hP hheight |
| let y : PrimeSpectrum Γ(X, U) := ⟨P, hP⟩ |
| let z : X := hU.fromSpec y |
| have hzU : z ∈ U := (hU.isoSpec.inv y).2 |
| have hz : coheight z = 1 := by |
| change coheight (hU.fromSpec y) = 1 |
| erw [coheight_eq_of_isOpenImmersion hU.fromSpec, |
| ← idealHeight_eq_coheight Γ(X, U) y] |
| exact hheight |
| let : IsIntegrallyClosed (X.presheaf.stalk z) := hNormal z |
| obtain ⟨s, hsunit, hs⟩ := exists_stalk_unit_of_ord_eq_zero X z hz f hf (hord z hzU hz) |
| let : Algebra Γ(X, U) (X.presheaf.stalk z) := |
| X.presheaf.algebra_section_stalk ⟨z, hzU⟩ |
| let : IsLocalization.AtPrime (X.presheaf.stalk z) P := hU.isLocalization_stalk' y hzU |
| have : IsScalarTower Γ(X, U) (X.presheaf.stalk z) X.functionField := |
| functionField_isScalarTower X U ⟨z, hzU⟩ |
| obtain ⟨a, b, he⟩ := IsLocalization.exists_mk'_eq P.primeCompl s |
| rw [mem_localization_iff_denominator] |
| refine ⟨b, b.property, ?_⟩ |
| rw [Submodule.mem_colon_singleton, Algebra.smul_def] |
| refine ⟨a, ?_⟩ |
| change algebraMap Γ(X, U) X.functionField a = algebraMap Γ(X, U) X.functionField b * f |
| rw [← hs, IsScalarTower.algebraMap_apply Γ(X, U) (X.presheaf.stalk z) X.functionField b, |
| ← map_mul, ← he, IsLocalization.mk'_spec', |
| ← IsScalarTower.algebraMap_apply Γ(X, U) (X.presheaf.stalk z) X.functionField] |
|
|
| |
| theorem germToFunctionField_map |
| (X : Scheme) [IsIntegral X] {U V : X.Opens} [Nonempty U] [Nonempty V] |
| (i : U ⟶ V) (s : Γ(X, V)) : |
| X.germToFunctionField U (X.presheaf.map i.op s) = X.germToFunctionField V s := by |
| change X.presheaf.germ U _ _ (X.presheaf.map i.op s) = X.presheaf.germ V _ _ s |
| rw [← ConcreteCategory.comp_apply, X.presheaf.germ_res] |
|
|
| |
| instance nonempty_top_of_integral (X : Scheme) [IsIntegral X] : Nonempty (⊤ : X.Opens) := |
| ⟨⟨genericPoint X, trivial⟩⟩ |
|
|
| |
| theorem exists_section_of_ord_eq_zero |
| (X : Scheme) [IsIntegral X] [IsNoetherian X] |
| (hNormal : ∀ x : X, IsIntegrallyClosed (X.presheaf.stalk x)) |
| (V : X.Opens) [hV : Nonempty V] |
| (f : X.functionField) (hf : f ≠ 0) |
| (hord : ∀ x : X, x ∈ V → coheight x = 1 → X.ord f x = 0) : |
| ∃ s : Γ(X, V), algebraMap Γ(X, V) X.functionField s = f := by |
| classical |
| choose U hU hxU hUV using fun x : V => exists_isAffineOpen_mem_and_subset x.property |
| let : ∀ x : V, Nonempty (U x) := fun x => ⟨⟨x, hxU x⟩⟩ |
| choose s hs using fun x : V => exists_affine_section_of_ord_eq_zero X hNormal (U x) (hU x) |
| f hf (fun y hy => hord y (hUV x hy)) |
| have hgen : ∀ x : V, genericPoint X ∈ U x := fun x => |
| ((genericPoint_spec X).mem_open_set_iff (U x).isOpen).mpr ⟨x, trivial, hxU x⟩ |
| have hcover : V ≤ iSup U := by |
| intro x hx |
| exact Opens.mem_iSup.mpr ⟨⟨x, hx⟩, hxU ⟨x, hx⟩⟩ |
| have hcompat : TopCat.Presheaf.IsCompatible X.presheaf U s := by |
| intro i j |
| let : Nonempty ((U i ⊓ U j : X.Opens) : Set X) := |
| ⟨⟨genericPoint X, hgen i, hgen j⟩⟩ |
| apply @Scheme.germToFunctionField_injective X _ (U i ⊓ U j) |
| ⟨⟨genericPoint X, hgen i, hgen j⟩⟩ |
| rw [germToFunctionField_map, germToFunctionField_map] |
| exact (hs i).trans (hs j).symm |
| obtain ⟨g, hg, _⟩ := X.sheaf.existsUnique_gluing' U V |
| (fun x => homOfLE (hUV x)) hcover s hcompat |
| refine ⟨g, ?_⟩ |
| let x : V := hV.some |
| have he := hg x |
| have he' := congrArg (X.germToFunctionField (U x)) he |
| change X.germToFunctionField (U x) |
| (X.presheaf.map (homOfLE (hUV x)).op g) = |
| X.germToFunctionField (U x) (s x) at he' |
| erw [germToFunctionField_map] at he' |
| exact he'.trans (hs x) |
|
|
| |
| theorem exists_global_section_of_ord_eq_zero |
| (X : Scheme) [IsIntegral X] [IsNoetherian X] |
| (hNormal : ∀ x : X, IsIntegrallyClosed (X.presheaf.stalk x)) |
| (f : X.functionField) (hf : f ≠ 0) |
| (hord : ∀ x : X, coheight x = 1 → X.ord f x = 0) : |
| ∃ s : Γ(X, ⊤), algebraMap Γ(X, ⊤) X.functionField s = f := |
| exists_section_of_ord_eq_zero X hNormal ⊤ f hf (fun x _ => hord x) |
|
|
| |
| theorem exists_section_unit_of_ord_eq_zero |
| (X : Scheme) [IsIntegral X] [IsNoetherian X] |
| (hNormal : ∀ x : X, IsIntegrallyClosed (X.presheaf.stalk x)) |
| (V : X.Opens) [hV : Nonempty V] |
| (f : X.functionFieldˣ) |
| (hord : ∀ x : X, x ∈ V → coheight x = 1 → X.ord (f : X.functionField) x = 0) : |
| ∃ u : Γ(X, V)ˣ, algebraMap Γ(X, V) X.functionField (u : Γ(X, V)) = |
| (f : X.functionField) := by |
| have hordinv : ∀ x : X, x ∈ V → coheight x = 1 → |
| X.ord (f : X.functionField)⁻¹ x = 0 := by |
| intro x hxV hx |
| rw [X.ord_eq_iff hx (inv_ne_zero (Units.ne_zero f))] |
| have h := (X.ord_eq_iff hx (Units.ne_zero f)).mp (hord x hxV hx) |
| change X.ordHom x hx (f : X.functionField)⁻¹ = 1 |
| change X.ordHom x hx (f : X.functionField) = 1 at h |
| rw [map_inv₀, h, inv_one] |
| obtain ⟨s, hs⟩ := exists_section_of_ord_eq_zero X hNormal V _ (Units.ne_zero f) hord |
| obtain ⟨t, ht⟩ := exists_section_of_ord_eq_zero X hNormal V _ |
| (inv_ne_zero (Units.ne_zero f)) hordinv |
| have hst : s * t = 1 := by |
| apply X.germToFunctionField_injective V |
| change algebraMap Γ(X, V) X.functionField (s * t) = algebraMap Γ(X, V) X.functionField 1 |
| rw [map_mul, hs, ht, mul_inv_cancel₀ (Units.ne_zero f), map_one] |
| exact ⟨⟨s, t, hst, by rw [mul_comm, hst]⟩, hs⟩ |
|
|
| |
|
|
| theorem rational_function_eq_global_unit_of_divisor_zero |
| (X : Scheme) [IsIntegral X] [IsNoetherian X] |
| (hNormal : ∀ x : X, IsIntegrallyClosed (X.presheaf.stalk x)) |
| (f : X.functionFieldˣ) (hdiv : principalDivisor X f = 0) : |
| ∃ u : Γ(X, ⊤)ˣ, algebraMap Γ(X, ⊤) X.functionField (u : Γ(X, ⊤)) = |
| (f : X.functionField) := by |
| apply exists_section_unit_of_ord_eq_zero X hNormal ⊤ f |
| intro x _ hx |
| simpa using congrArg (fun D : WeilDivisor X => D ⟨x, hx⟩) hdiv |
|
|
| |
|
|
| theorem genericPoint_eq_of_dominant |
| {X Z : Scheme} [IsIntegral X] [IsIntegral Z] |
| (f : X ⟶ Z) [IsDominant f] : f (genericPoint X) = genericPoint Z := by |
| apply IsGenericPoint.eq _ (genericPoint_spec Z) |
| simpa [Set.image_univ, f.denseRange.closure_range] using |
| (genericPoint_spec X).image f.continuous |
|
|
| |
| noncomputable def functionFieldPullback |
| {X Z : Scheme} [IsIntegral X] [IsIntegral Z] |
| (f : X ⟶ Z) [IsDominant f] : Z.functionField →+* X.functionField := |
| (Z.presheaf.stalkSpecializes (specializes_of_eq (genericPoint_eq_of_dominant f)) ≫ |
| f.stalkMap (genericPoint X)).hom |
|
|
| instance nonempty_preimage_of_dominant |
| {X Z : Scheme} [IsIntegral X] [IsIntegral Z] |
| (f : X ⟶ Z) [IsDominant f] (U : Z.Opens) [Nonempty U] : |
| Nonempty (f ⁻¹ᵁ U) := by |
| refine ⟨⟨genericPoint X, ?_⟩⟩ |
| change f (genericPoint X) ∈ U |
| rw [genericPoint_eq_of_dominant f] |
| apply ((genericPoint_spec Z).mem_open_set_iff U.isOpen).mpr |
| simpa using Set.nonempty_coe_sort.mp (inferInstance : Nonempty U) |
|
|
| |
| theorem functionFieldPullback_germ |
| {X Z : Scheme} [IsIntegral X] [IsIntegral Z] |
| (f : X ⟶ Z) [IsDominant f] (U : Z.Opens) [Nonempty U] (s : Γ(Z, U)) : |
| functionFieldPullback f (Z.germToFunctionField U s) = |
| X.germToFunctionField (f ⁻¹ᵁ U) (f.app U s) := by |
| have he : Z.germToFunctionField U ≫ |
| CommRingCat.ofHom (functionFieldPullback f) = |
| f.app U ≫ X.germToFunctionField (f ⁻¹ᵁ U) := by |
| change Z.presheaf.germ U _ _ ≫ |
| (Z.presheaf.stalkSpecializes _ ≫ f.stalkMap _) = _ |
| rw [← Category.assoc, Z.presheaf.germ_stalkSpecializes, f.germ_stalkMap] |
| exact congrArg (fun h => h s) he |
|
|
| |
|
|
| def IsVerticalDivisor {X Z : Scheme} [IsIntegral Z] |
| (f : X ⟶ Z) (D : WeilDivisor X) : Prop := |
| ∀ p : PrimeDivisor X, D p ≠ 0 → f p.1 ≠ genericPoint Z |
|
|
| |
|
|
| theorem exists_open_avoiding_vertical_divisor |
| {X Z : Scheme} [IsIntegral Z] (f : X ⟶ Z) (D : WeilDivisor X) |
| (hvert : IsVerticalDivisor f D) : |
| ∃ U : Z.Opens, genericPoint Z ∈ U ∧ |
| ∀ p : PrimeDivisor X, f p.1 ∈ U → D p = 0 := by |
| classical |
| let B : Set Z := ⋃ p ∈ D.support, closure ({f p.1} : Set Z) |
| have hclosed : IsClosed B := isClosed_biUnion_finset (fun _ _ => isClosed_closure) |
| let U : Z.Opens := ⟨Bᶜ, hclosed.isOpen_compl⟩ |
| refine ⟨U, ?_, ?_⟩ |
| · intro h |
| obtain ⟨p, hp, hmem⟩ := Set.mem_iUnion₂.mp h |
| have hspec : f p.1 ⤳ genericPoint Z := specializes_iff_mem_closure.mpr hmem |
| exact hvert p (Finsupp.mem_support_iff.mp hp) |
| (hspec.antisymm (genericPoint_specializes _)).eq |
| · intro p hp |
| by_contra hn |
| exact hp (Set.mem_iUnion₂.mpr ⟨p, Finsupp.mem_support_iff.mpr hn, |
| subset_closure (Set.mem_singleton _)⟩) |
|
|
| |
|
|
| theorem rational_function_descends_of_vertical_divisor |
| {X Z : Scheme} [IsIntegral X] [IsIntegral Z] [IsNoetherian X] |
| (hNormal : ∀ x : X, IsIntegrallyClosed (X.presheaf.stalk x)) |
| (f : X ⟶ Z) [IsDominant f] [IsIso f.c] |
| (u : X.functionFieldˣ) (hvert : IsVerticalDivisor f (principalDivisor X u)) : |
| ∃ v : Z.functionFieldˣ, |
| functionFieldPullback f (v : Z.functionField) = (u : X.functionField) := by |
| obtain ⟨U, hgen, hU⟩ := exists_open_avoiding_vertical_divisor f _ hvert |
| let : Nonempty U := ⟨⟨genericPoint Z, hgen⟩⟩ |
| obtain ⟨s, hs⟩ := exists_section_unit_of_ord_eq_zero X hNormal (f ⁻¹ᵁ U) u |
| (fun x hx hcodim => hU ⟨x, hcodim⟩ hx) |
| let t : Γ(Z, U)ˣ := Units.map (inv (f.app U)).hom.toMonoidHom s |
| have ht : f.app U (t : Γ(Z, U)) = (s : Γ(X, f ⁻¹ᵁ U)) := by |
| change f.app U (inv (f.app U) (s : Γ(X, f ⁻¹ᵁ U))) = _ |
| exact congrArg (fun g => g (s : Γ(X, f ⁻¹ᵁ U))) (IsIso.inv_hom_id (f.app U)) |
| refine ⟨Units.map (Z.germToFunctionField U).hom.toMonoidHom t, ?_⟩ |
| change functionFieldPullback f (Z.germToFunctionField U (t : Γ(Z, U))) = _ |
| rw [functionFieldPullback_germ, ht] |
| exact hs |
|
|
| end RelativeDenominators |
| end |
|
|
| end OAI |
|
|
