| import Mathlib |
| import OAI.AlgebraicGeometry.NumericalDimension.NormalizationStalks |
|
|
| namespace OAI |
|
|
| /-! Intersection Lengths. -/ |
|
|
| open AlgebraicGeometry CategoryTheory |
| open scoped TensorProduct nonZeroDivisors |
| open scoped TensorProduct |
| open AlgebraicGeometry CategoryTheory TopologicalSpace |
| open CategoryTheory Opposite AlgebraicGeometry TopologicalSpace |
|
|
| namespace NumericalDimensionOne |
| namespace FiniteColength |
| variable {R M : Type*} [CommRing R] [AddCommGroup M] [Module R M] |
|
|
| lemma length_quotient_chain (N L : Submodule R M) (hNL : N ≤ L) : |
| Module.length R (M ⧸ N) = |
| Module.length R (L ⧸ N.comap L.subtype) + Module.length R (M ⧸ L) := by |
| let i := (N.comap L.subtype).mapQ N L.subtype le_rfl |
| have hi : Function.Injective i := by |
| rw [← LinearMap.ker_eq_bot, Submodule.ker_mapQ, Submodule.mkQ_map_self] |
| have he : Function.Exact i (Submodule.factor hNL) := by |
| intro x |
| induction x using Submodule.Quotient.induction_on with |
| | _ x => |
| change Submodule.Quotient.mk x = (0 : M ⧸ L) ↔ _ |
| rw [Submodule.Quotient.mk_eq_zero] |
| constructor |
| · intro hx |
| exact ⟨Submodule.Quotient.mk (⟨x, hx⟩ : L), rfl⟩ |
| · rintro ⟨y, hy⟩ |
| induction y using Submodule.Quotient.induction_on with |
| | _ y => |
| have hxy : (y : M) - x ∈ N := (Submodule.Quotient.eq N).mp hy |
| exact (L.sub_mem y.property (hNL hxy)) |> (by simpa using ·) |
| exact Module.length_eq_add_of_exact i (Submodule.factor hNL) hi |
| (Submodule.factor_surjective hNL) he |
|
|
| lemma length_quotient_image (f : M →ₗ[R] M) (hf : Function.Injective f) |
| (L : Submodule R M) : |
| Module.length R (M ⧸ L.map f) = |
| Module.length R (M ⧸ L) + Module.length R (M ⧸ LinearMap.range f) := by |
| let i := L.mapQ (L.map f) f (Submodule.le_comap_map _ _) |
| have hi : Function.Injective i := by |
| rw [← LinearMap.ker_eq_bot, Submodule.ker_mapQ, |
| Submodule.comap_map_eq_of_injective hf, Submodule.mkQ_map_self] |
| have hle : L.map f ≤ LinearMap.range f := by |
| rintro _ ⟨y, _, rfl⟩ |
| exact ⟨y, rfl⟩ |
| have he : Function.Exact i (Submodule.factor hle) := by |
| intro x |
| induction x using Submodule.Quotient.induction_on with |
| | _ x => |
| change Submodule.Quotient.mk x = (0 : M ⧸ LinearMap.range f) ↔ _ |
| rw [Submodule.Quotient.mk_eq_zero, LinearMap.mem_range] |
| constructor |
| · rintro ⟨y, rfl⟩ |
| exact ⟨Submodule.Quotient.mk y, rfl⟩ |
| · rintro ⟨y, hy⟩ |
| induction y using Submodule.Quotient.induction_on with |
| | _ y => |
| have hxy : f y - x ∈ L.map f := (Submodule.Quotient.eq _).mp hy |
| have hz : f y - x ∈ LinearMap.range f := hle hxy |
| have hz' := (LinearMap.range f).sub_mem (LinearMap.mem_range_self f y) hz |
| exact LinearMap.mem_range.mp (by simpa only [sub_sub_cancel] using hz') |
| exact Module.length_eq_add_of_exact i (Submodule.factor hle) hi |
| (Submodule.factor_surjective hle) he |
|
|
| theorem length_cokernel_restriction (f : M →ₗ[R] M) (hf : Function.Injective f) |
| (L : Submodule R M) (hL : L.map f ≤ L) (hfin : IsFiniteLength R (M ⧸ L)) : |
| Module.length R (M ⧸ LinearMap.range f) = |
| Module.length R (L ⧸ (L.map f).comap L.subtype) := by |
| have h₁ := length_quotient_image f hf L |
| have h₂ := length_quotient_chain (L.map f) L hL |
| have he : Module.length R (M ⧸ L) + Module.length R (M ⧸ LinearMap.range f) = |
| Module.length R (M ⧸ L) + |
| Module.length R (L ⧸ (L.map f).comap L.subtype) := by |
| rw [← h₁, h₂, add_comm] |
| exact ENat.add_right_injective_of_ne_top (Module.length_ne_top_iff.mpr hfin) he |
| end FiniteColength |
| end NumericalDimensionOne |
|
|
| open AlgebraicGeometry CategoryTheory |
| open scoped TensorProduct nonZeroDivisors |
| open scoped TensorProduct |
| open AlgebraicGeometry CategoryTheory TopologicalSpace |
| open CategoryTheory Opposite AlgebraicGeometry TopologicalSpace |
|
|
| namespace NumericalDimensionOne |
| namespace TorsionLength |
| variable {R M : Type*} [CommRing R] [AddCommGroup M] [Module R M] |
| [IsNoetherianRing R] [Ring.KrullDimLE 1 R] [Module.Finite R M] |
|
|
| theorem finiteLength_of_torsion (hM : Module.IsTorsion R M) : IsFiniteLength R M := by |
| obtain ⟨c, hc, hcnz⟩ := Submodule.annihilator_top_inter_nonZeroDivisors hM |
| have hkill : Module.IsTorsionBySet R M (Ideal.span {c}) := by |
| rw [Module.isTorsionBySet_span_singleton_iff] |
| intro x |
| exact Submodule.mem_annihilator.mp hc x (Submodule.mem_top) |
| let : Module (R ⧸ Ideal.span {c}) M := hkill.module |
| have : IsScalarTower R (R ⧸ Ideal.span {c}) M := hkill.isScalarTower |
| have : Module.Finite (R ⧸ Ideal.span {c}) M := |
| Module.Finite.of_restrictScalars_finite R _ _ |
| have hquot := isFiniteLength_quotient_span_singleton R hcnz |
| have : IsArtinian R (R ⧸ Ideal.span {c}) := |
| (isFiniteLength_iff_isNoetherian_isArtinian.mp hquot).2 |
| have : IsArtinianRing (R ⧸ Ideal.span {c}) := isArtinian_of_tower R inferInstance |
| have : IsArtinian (R ⧸ Ideal.span {c}) M := inferInstance |
| exact isFiniteLength_iff_isNoetherian_isArtinian.mpr |
| ⟨inferInstance, isArtinian_of_surjective_algebraMap |
| (R := R ⧸ Ideal.span {c}) (M := M) (S := R) Ideal.Quotient.mk_surjective⟩ |
|
|
| variable {K : Type*} [Field K] [Algebra R K] [IsFractionRing R K] |
|
|
| theorem finiteLength_birational_quotient (B : Subalgebra R K) [Module.Finite R B] : |
| IsFiniteLength R (B ⧸ (Algebra.linearMap R B).range) := by |
| apply finiteLength_of_torsion |
| intro x |
| induction x using Submodule.Quotient.induction_on with |
| | _ x => |
| obtain ⟨c, r, hr⟩ := IsLocalization.exists_integer_multiple (nonZeroDivisors R) (x : K) |
| refine ⟨c, ?_⟩ |
| change Submodule.Quotient.mk ((c : R) • x) = 0 |
| rw [Submodule.Quotient.mk_eq_zero] |
| refine ⟨r, ?_⟩ |
| apply Subtype.ext |
| exact hr |
| end TorsionLength |
| end NumericalDimensionOne |
|
|
| open AlgebraicGeometry CategoryTheory |
| open scoped TensorProduct nonZeroDivisors |
| open scoped TensorProduct |
| open AlgebraicGeometry CategoryTheory TopologicalSpace |
| open CategoryTheory Opposite AlgebraicGeometry TopologicalSpace |
|
|
| namespace NumericalDimensionOne |
| namespace BirationalOrder |
| variable {R M : Type*} [CommRing R] [AddCommGroup M] [Module R M] |
|
|
| theorem length_scalar_cokernel (j : R →ₗ[R] M) (hj : Function.Injective j) |
| (a : R) (ha : Function.Injective (a • (LinearMap.id : M →ₗ[R] M))) |
| (hfin : IsFiniteLength R (M ⧸ j.range)) : |
| Module.length R (M ⧸ (a • (LinearMap.id : M →ₗ[R] M)).range) = Ring.ord R a := by |
| let f : M →ₗ[R] M := a • LinearMap.id |
| let L := j.range |
| have hL : L.map f ≤ L := by |
| rintro _ ⟨x, hx, rfl⟩ |
| exact L.smul_mem a hx |
| have heq := FiniteColength.length_cokernel_restriction f ha L hL hfin |
| let e : R ≃ₗ[R] L := LinearEquiv.ofBijective j.rangeRestrict |
| ⟨(LinearMap.injective_rangeRestrict_iff j).mpr hj, j.surjective_rangeRestrict⟩ |
| have hmap : Submodule.map e.toLinearMap (Ideal.span {a}) = (L.map f).comap L.subtype := by |
| ext x |
| constructor |
| · rintro ⟨y, hy, rfl⟩ |
| obtain ⟨r, rfl⟩ := Ideal.mem_span_singleton.mp hy |
| change j (a * r) ∈ L.map f |
| exact ⟨j r, LinearMap.mem_range_self _ _, by simp [f, ← map_smul, smul_eq_mul]⟩ |
| · rintro ⟨y, hy, hxy⟩ |
| obtain ⟨r, rfl⟩ := hy |
| refine ⟨a * r, Ideal.mem_span_singleton.mpr ⟨r, rfl⟩, ?_⟩ |
| apply Subtype.ext |
| change j (a * r) = (x : M) |
| simpa only [f, LinearMap.smul_apply, LinearMap.id_apply, ← map_smul, |
| smul_eq_mul, Submodule.subtype_apply] using hxy |
| exact heq.trans (Submodule.Quotient.equiv _ _ e hmap).length_eq.symm |
|
|
| variable {K : Type*} [Field K] [Algebra R K] [IsFractionRing R K] |
| [IsNoetherianRing R] [Ring.KrullDimLE 1 R] |
|
|
| theorem length_birational (B : Subalgebra R K) [Module.Finite R B] (a : R) (ha : a ≠ 0) : |
| Module.length R (B ⧸ (Ideal.span {algebraMap R B a}).restrictScalars R) = |
| Ring.ord R a := by |
| let j := Algebra.linearMap R B |
| have hj : Function.Injective j := by |
| intro x y h |
| apply IsFractionRing.injective R K |
| exact congrArg (fun z : B => (z : K)) h |
| have hmul : Function.Injective (a • (LinearMap.id : B →ₗ[R] B)) := by |
| intro x y h |
| apply Subtype.ext |
| have hz := congrArg (fun z : B => (z : K)) h |
| have hz' : algebraMap R K a * (x : K) = algebraMap R K a * (y : K) := by |
| simpa [LinearMap.smul_apply, LinearMap.id_apply, Algebra.smul_def] using hz |
| exact mul_left_cancel₀ ((map_ne_zero_iff _ (IsFractionRing.injective R K)).mpr ha) hz' |
| have heq := length_scalar_cokernel j hj a hmul |
| (TorsionLength.finiteLength_birational_quotient B) |
| have hrange : (a • (LinearMap.id : B →ₗ[R] B)).range = |
| (Ideal.span {algebraMap R B a}).restrictScalars R := by |
| ext x |
| change (∃ y : B, a • y = x) ↔ x ∈ Ideal.span {algebraMap R B a} |
| rw [Ideal.mem_span_singleton] |
| simp only [Algebra.smul_def, dvd_def, eq_comm] |
| rwa [hrange] at heq |
| end BirationalOrder |
| end NumericalDimensionOne |
|
|
| open AlgebraicGeometry CategoryTheory |
| open scoped TensorProduct nonZeroDivisors |
| open scoped TensorProduct |
| open AlgebraicGeometry CategoryTheory TopologicalSpace |
| open CategoryTheory Opposite AlgebraicGeometry TopologicalSpace |
|
|
| namespace NumericalDimensionOne |
| namespace LocalLengthDecomposition |
| open scoped BigOperators |
| open TensorProduct |
| variable {R B : Type*} [CommRing R] [CommRing B] [Algebra R B] |
|
|
| noncomputable def quotientLocalization (I : Ideal B) (p : PrimeSpectrum (B ⧸ I)) : |
| Localization.AtPrime p.asIdeal ≃ₐ[B ⧸ I] |
| (Localization.AtPrime (p.asIdeal.comap (Ideal.Quotient.mk I)) ⧸ |
| I.map (algebraMap B (Localization.AtPrime (p.asIdeal.comap (Ideal.Quotient.mk I))))) := by |
| let q := p.asIdeal.comap (Ideal.Quotient.mk I) |
| have heq : Algebra.algebraMapSubmonoid (B ⧸ I) q.primeCompl = p.asIdeal.primeCompl := |
| Ideal.map_primeCompl_comap_of_surjective (Ideal.Quotient.mk I) |
| Ideal.Quotient.mk_surjective p.asIdeal |
| let S := Localization.AtPrime q |
| have hloc : IsLocalization p.asIdeal.primeCompl (S ⧸ I.map (algebraMap B S)) := |
| heq ▸ inferInstance |
| exact IsLocalization.algEquiv p.asIdeal.primeCompl _ _ |
|
|
| theorem length_quotient_decomposition (I : Ideal B) [IsArtinianRing (B ⧸ I)] |
| [Fintype (PrimeSpectrum (B ⧸ I))] : |
| Module.length R (B ⧸ I) = |
| ∑ p : PrimeSpectrum (B ⧸ I), |
| Module.length R (Localization.AtPrime (p.asIdeal.comap (Ideal.Quotient.mk I)) ⧸ |
| I.map (algebraMap B (Localization.AtPrime (p.asIdeal.comap (Ideal.Quotient.mk I))))) := by |
| have heq := ((PrimeSpectrum.toPiLocalizationEquiv (B ⧸ I)).restrictScalars R).toLinearEquiv.length_eq |
| change Module.length R (B ⧸ I) = Module.length R |
| (∀ p : PrimeSpectrum (B ⧸ I), Localization.AtPrime p.asIdeal) at heq |
| rw [Module.length_pi_of_fintype] at heq |
| refine heq.trans (Finset.sum_congr rfl ?_) |
| intro p _ |
| let S := Localization.AtPrime (p.asIdeal.comap (Ideal.Quotient.mk I)) |
| have : IsScalarTower R (B ⧸ I) (S ⧸ I.map (algebraMap B S)) := |
| IsScalarTower.of_algebraMap_eq fun _ => rfl |
| exact ((quotientLocalization I p).restrictScalars R).toLinearEquiv.length_eq |
| end LocalLengthDecomposition |
| end NumericalDimensionOne |
|
|
| open AlgebraicGeometry CategoryTheory |
| open scoped TensorProduct nonZeroDivisors |
| open scoped TensorProduct |
| open AlgebraicGeometry CategoryTheory TopologicalSpace |
| open CategoryTheory Opposite AlgebraicGeometry TopologicalSpace |
|
|
| namespace NumericalDimensionOne |
| namespace LocalResidueLength |
| open IsLocalRing |
| variable {R B : Type*} [CommRing R] [CommRing B] [Algebra R B] |
| [IsLocalRing R] [Module.Finite R B] |
|
|
| theorem isLocalHom_atPrime (q : Ideal B) [q.IsMaximal] : |
| IsLocalHom (algebraMap R (Localization.AtPrime q)) := by |
| apply ((local_hom_TFAE _).out 1 5).mpr |
| rw [IsScalarTower.algebraMap_eq R B (Localization.AtPrime q), ← Ideal.comap_comap] |
| rw [show (maximalIdeal (Localization.AtPrime q)).comap (algebraMap B (Localization.AtPrime q)) = q |
| from IsLocalization.AtPrime.under_maximalIdeal (Localization.AtPrime q) q] |
| exact eq_maximalIdeal (Ideal.IsMaximal.under R q) |
|
|
| theorem length_atPrime_restrict (q : Ideal B) [q.IsMaximal] |
| [IsAlgClosed (ResidueField R)] (M : Type*) [AddCommGroup M] |
| [Module R M] [Module (Localization.AtPrime q) M] |
| [IsScalarTower R (Localization.AtPrime q) M] : |
| Module.length R M = Module.length (Localization.AtPrime q) M := by |
| have := isLocalHom_atPrime (R := R) q |
| have : Module.Finite R q.ResidueField := Module.Finite.trans B q.ResidueField |
| have : Module.Finite (ResidueField R) q.ResidueField := |
| Module.Finite.of_restrictScalars_finite R _ _ |
| have hdeg : Module.length (ResidueField R) q.ResidueField = 1 := by |
| rw [Module.length_eq_finrank] |
| simp only [Module.finrank_of_bijective_algebraMap |
| IsAlgClosed.algebraMap_bijective_of_isIntegral, Nat.cast_one] |
| rw [IsLocalRing.length_restrictScalars R (Localization.AtPrime q) M] |
| rw [hdeg, mul_one] |
|
|
| theorem principal_length_atPrime (q : Ideal B) [q.IsMaximal] |
| [IsAlgClosed (ResidueField R)] (a : B) : |
| Module.length R (Localization.AtPrime q ⧸ |
| (Ideal.span {a}).map (algebraMap B (Localization.AtPrime q))) = |
| Ring.ord (Localization.AtPrime q) (algebraMap B _ a) := by |
| rw [length_atPrime_restrict (R := R) q] |
| rw [Ideal.map_span, Set.image_singleton] |
| rfl |
| end LocalResidueLength |
| end NumericalDimensionOne |
|
|
| open AlgebraicGeometry CategoryTheory |
| open scoped TensorProduct nonZeroDivisors |
| open scoped TensorProduct |
| open AlgebraicGeometry CategoryTheory TopologicalSpace |
| open CategoryTheory Opposite AlgebraicGeometry TopologicalSpace |
|
|
| namespace NumericalDimensionOne |
| namespace NormalizedLocalIntersection |
| open scoped BigOperators |
| variable {R K : Type*} [CommRing R] [IsDomain R] [Field K] |
| [Algebra R K] [IsFractionRing R K] [IsNoetherianRing R] [Ring.KrullDimLE 1 R] |
| (B : Subalgebra R K) [Module.Finite R B] |
|
|
| theorem artinian_principal_quotient (a : R) (ha : a ≠ 0) : |
| IsArtinianRing (B ⧸ Ideal.span {algebraMap R B a}) := by |
| have heq : Module.length R (B ⧸ Ideal.span {algebraMap R B a}) = Ring.ord R a := |
| BirationalOrder.length_birational B a ha |
| have hfin := Module.length_ne_top_iff.mp (heq ▸ Ring.ord_ne_top |
| (mem_nonZeroDivisors_iff_ne_zero.mpr ha)) |
| have : IsArtinian R (B ⧸ Ideal.span {algebraMap R B a}) := |
| (isFiniteLength_iff_isNoetherian_isArtinian.mp hfin).2 |
| exact isArtinian_of_tower R inferInstance |
|
|
| theorem ord_eq_sum [IsLocalRing R] [IsAlgClosed (IsLocalRing.ResidueField R)] |
| (a : R) (ha : a ≠ 0) |
| [Fintype (PrimeSpectrum (B ⧸ Ideal.span {algebraMap R B a}))] : |
| Ring.ord R a = ∑ p : PrimeSpectrum (B ⧸ Ideal.span {algebraMap R B a}), |
| Ring.ord (Localization.AtPrime |
| (p.asIdeal.comap (Ideal.Quotient.mk (Ideal.span {algebraMap R B a})))) |
| (algebraMap R _ a) := by |
| let I : Ideal B := Ideal.span {algebraMap R B a} |
| have : IsArtinianRing (B ⧸ I) := artinian_principal_quotient B a ha |
| have hbir : Module.length R (B ⧸ I) = Ring.ord R a := |
| BirationalOrder.length_birational B a ha |
| apply hbir.symm.trans |
| apply (LocalLengthDecomposition.length_quotient_decomposition (R := R) I).trans |
| apply Finset.sum_congr rfl |
| intro p _ |
| let q := p.asIdeal.comap (Ideal.Quotient.mk I) |
| have : p.asIdeal.IsMaximal := inferInstance |
| have : q.IsMaximal := Ideal.comap_isMaximal_of_surjective _ Ideal.Quotient.mk_surjective |
| have heq := LocalResidueLength.principal_length_atPrime (R := R) q (algebraMap R B a) |
| exact heq.trans (congrArg (Ring.ord (Localization.AtPrime q)) |
| (IsScalarTower.algebraMap_apply R B (Localization.AtPrime q) a).symm) |
| end NormalizedLocalIntersection |
| end NumericalDimensionOne |
|
|
| open AlgebraicGeometry CategoryTheory |
| open scoped TensorProduct nonZeroDivisors |
| open scoped TensorProduct |
| open AlgebraicGeometry CategoryTheory TopologicalSpace |
| open CategoryTheory Opposite AlgebraicGeometry TopologicalSpace |
|
|
| namespace NumericalDimensionOne |
| open AlgebraicGeometry CategoryTheory |
| variable {X : Scheme} [IsIntegral X] [IsLocallyNoetherian X] |
|
|
| abbrev NormalizedStalkBranches (x : X) (a : X.presheaf.stalk x) := |
| PrimeSpectrum (integralClosure (X.presheaf.stalk x) X.functionField ⧸ |
| Ideal.span {algebraMap (X.presheaf.stalk x) |
| (integralClosure (X.presheaf.stalk x) X.functionField) a}) |
|
|
| theorem finite_normalizedStalkBranches (sX : X ⟶ Spec (.of ℂ)) |
| [LocallyOfFiniteType sX] (x : X) (hdim : Order.coheight x ≤ 1) |
| (a : X.presheaf.stalk x) (ha : a ≠ 0) : |
| Finite (NormalizedStalkBranches x a) := by |
| let R := X.presheaf.stalk x |
| let B := integralClosure R X.functionField |
| have : Ring.KrullDimLE 1 R := krullDimLE_of_coheight_le hdim |
| have : Module.Finite R B := finite_integralClosure_stalk sX x |
| have : IsArtinianRing (B ⧸ Ideal.span {algebraMap R B a}) := |
| NormalizedLocalIntersection.artinian_principal_quotient B a ha |
| infer_instance |
|
|
| theorem localOrder_eq_normalizedBranches (sX : X ⟶ Spec (.of ℂ)) |
| [LocallyOfFiniteType sX] (x : X) (hx : IsClosed ({x} : Set X)) |
| (hdim : Order.coheight x ≤ 1) (a : X.presheaf.stalk x) (ha : a ≠ 0) : |
| Ring.ord (X.presheaf.stalk x) a = |
| ∑ᶠ q : NormalizedStalkBranches x a, |
| Ring.ord (Localization.AtPrime (q.asIdeal.comap (Ideal.Quotient.mk |
| (Ideal.span {algebraMap (X.presheaf.stalk x) |
| (integralClosure (X.presheaf.stalk x) X.functionField) a})))) |
| (algebraMap (X.presheaf.stalk x) _ a) := by |
| classical |
| let R := X.presheaf.stalk x |
| let B := integralClosure R X.functionField |
| have : Ring.KrullDimLE 1 R := krullDimLE_of_coheight_le hdim |
| have : Module.Finite R B := finite_integralClosure_stalk sX x |
| have : IsAlgClosed (IsLocalRing.ResidueField R) := |
| IsAlgClosed.of_ringEquiv ℂ _ |
| (Iso.commRingCatIsoToRingEquiv (residueFieldIsoBase sX x hx)).symm |
| have : Finite (NormalizedStalkBranches x a) := |
| finite_normalizedStalkBranches sX x hdim a ha |
| let : Fintype (NormalizedStalkBranches x a) := Fintype.ofFinite _ |
| rw [finsum_eq_sum_of_fintype] |
| exact NormalizedLocalIntersection.ord_eq_sum B a ha |
| end NumericalDimensionOne |
|
|
| open AlgebraicGeometry CategoryTheory |
| open scoped TensorProduct nonZeroDivisors |
| open scoped TensorProduct |
| open AlgebraicGeometry CategoryTheory TopologicalSpace |
| open CategoryTheory Opposite AlgebraicGeometry TopologicalSpace |
|
|
| namespace NumericalDimensionOne |
| open IsLocalRing |
| variable (R B : Type*) [CommRing R] [CommRing B] [Algebra R B] |
| [IsDomain R] [IsLocalRing R] [Ring.KrullDimLE 1 R] |
| (a : R) (ha : a ≠ 0) (hau : ¬ IsUnit a) |
|
|
| noncomputable def principalFiberPrimeEquiv : |
| PrimeSpectrum (B ⧸ Ideal.span {algebraMap R B a}) ≃ (maximalIdeal R).primesOver B := by |
| let I : Ideal B := Ideal.span {algebraMap R B a} |
| let e := I.primeSpectrumQuotientOrderIsoZeroLocus |
| let e' : PrimeSpectrum.zeroLocus (I : Set B) ≃ (maximalIdeal R).primesOver B := |
| { toFun := fun q => ⟨q.1.asIdeal, q.1.isPrime, ⟨by |
| have ha' : a ∈ q.1.asIdeal.under R := q.2 (Ideal.subset_span rfl) |
| have hn : q.1.asIdeal.under R ≠ ⊥ := by |
| intro he |
| exact ha ((he ▸ ha' : a ∈ (⊥ : Ideal R))) |
| exact (eq_maximalIdeal (Ideal.isMaximal_of_isPrime_of_ne_bot _ hn)).symm⟩⟩ |
| invFun := fun q => ⟨⟨q.1,q.2.1⟩, by |
| apply (Ideal.span_singleton_le_iff_mem _).mpr |
| exact (q.1.mem_of_liesOver (maximalIdeal R) a).mp |
| (mem_nonunits_iff.mpr hau)⟩ |
| left_inv := fun q => by |
| apply Subtype.ext |
| rfl |
| right_inv := fun q => by |
| apply Subtype.ext |
| rfl } |
| exact e.toEquiv.trans e' |
|
|
| lemma principalFiberPrimeEquiv_asIdeal |
| (q : PrimeSpectrum (B ⧸ Ideal.span {algebraMap R B a})) : |
| (principalFiberPrimeEquiv R B a ha hau q).1 = |
| q.asIdeal.comap (Ideal.Quotient.mk (Ideal.span {algebraMap R B a})) := by |
| rfl |
| end NumericalDimensionOne |
|
|
| open AlgebraicGeometry CategoryTheory |
| open scoped TensorProduct nonZeroDivisors |
| open scoped TensorProduct |
| open AlgebraicGeometry CategoryTheory TopologicalSpace |
| open CategoryTheory Opposite AlgebraicGeometry TopologicalSpace |
|
|
| namespace NumericalDimensionOne |
| namespace NormalizedLocalIntersection |
| open scoped BigOperators |
| variable {R K : Type*} [CommRing R] [IsDomain R] [Field K] |
| [Algebra R K] [IsFractionRing R K] [IsNoetherianRing R] [Ring.KrullDimLE 1 R] |
| [IsLocalRing R] [IsAlgClosed (IsLocalRing.ResidueField R)] |
| (B : Subalgebra R K) [Module.Finite R B] |
|
|
| theorem ord_eq_finsum_branches (a : R) (ha : a ≠ 0) : |
| Ring.ord R a = ∑ᶠ q : (IsLocalRing.maximalIdeal R).primesOver B, |
| Ring.ord (Localization.AtPrime q.1) (algebraMap R _ a) := by |
| classical |
| by_cases hu : IsUnit a |
| · rw [Ring.ord_of_isUnit hu] |
| symm |
| apply finsum_eq_zero_of_forall_eq_zero |
| intro q |
| exact Ring.ord_of_isUnit (hu.map (algebraMap R _)) |
| · have : IsArtinianRing (B ⧸ Ideal.span {algebraMap R B a}) := |
| artinian_principal_quotient B a ha |
| let : Fintype (PrimeSpectrum (B ⧸ Ideal.span {algebraMap R B a})) := Fintype.ofFinite _ |
| rw [← finsum_comp_equiv (principalFiberPrimeEquiv R B a ha hu), |
| finsum_eq_sum_of_fintype] |
| exact ord_eq_sum B a ha |
| end NormalizedLocalIntersection |
| end NumericalDimensionOne |
|
|
| open AlgebraicGeometry CategoryTheory |
| open scoped TensorProduct nonZeroDivisors |
| open scoped TensorProduct |
| open AlgebraicGeometry CategoryTheory TopologicalSpace |
| open CategoryTheory Opposite AlgebraicGeometry TopologicalSpace |
|
|
| namespace NumericalDimensionOne |
|
|
| theorem ringOrder_equiv {R S : Type*} [CommRing R] [CommRing S] |
| (e : R ≃+* S) (a : R) : Ring.ord S (e a) = Ring.ord R a := by |
| rw [Ring.ord, Ring.ord, Module.length_quotient, Module.length_quotient] |
| simpa only [Ideal.comap_symm, Ideal.map_span, Set.image_singleton] using |
| Ideal.coheight_comap_of_surjective e.symm e.symm.surjective (Ideal.span {a}) |
|
|
| theorem scheme_order_of_stalk_element {C : Scheme} [IsIntegral C] |
| [IsLocallyNoetherian C] (x : C) (hx : Order.coheight x = 1) |
| (a : C.presheaf.stalk x) (ha : a ≠ 0) : |
| C.ord (algebraMap (C.presheaf.stalk x) C.functionField a) x = |
| ((Ring.ord (C.presheaf.stalk x) a).toNat : ℤ) := by |
| let : Ring.KrullDimLE 1 (C.presheaf.stalk x) := krullDimLE_of_coheight_le hx.le |
| have ha' : algebraMap (C.presheaf.stalk x) C.functionField a ≠ 0 := by |
| simpa only [map_zero] using (IsFractionRing.injective (C.presheaf.stalk x) C.functionField).ne ha |
| apply (C.ord_eq_iff hx ha').mpr |
| change Ring.ordFrac (C.presheaf.stalk x) _ = _ |
| rw [Ring.ordFrac_eq_ord _ ha] |
| exact Ring.ordMonoidWithZeroHom_eq_coe (C.presheaf.stalk x) (mem_nonZeroDivisors_of_ne_zero ha) |
| (ENat.natCast_toNat (Ring.ord_ne_top (mem_nonZeroDivisors_of_ne_zero ha))).symm |
|
|
| theorem scheme_order_on_affine_chart {C : Scheme} [IsIntegral C] |
| [IsLocallyNoetherian C] {U : C.Opens} [Nonempty U] (hU : IsAffineOpen U) |
| (x : U) (hx : Order.coheight (x : C) = 1) (t : Γ(C, U)) (ht : t ≠ 0) : |
| C.ord (C.germToFunctionField U t) x = |
| ((Ring.ord (Localization.AtPrime (hU.primeIdealOf x).asIdeal) |
| (algebraMap Γ(C, U) (Localization.AtPrime (hU.primeIdealOf x).asIdeal) t)).toNat : ℤ) := by |
| let := C.presheaf.algebra_section_stalk x |
| let := hU.isLocalization_stalk x |
| let e := IsLocalization.algEquiv (hU.primeIdealOf x).asIdeal.primeCompl |
| (Localization.AtPrime (hU.primeIdealOf x).asIdeal) (C.presheaf.stalk x) |
| have ht' : (C.presheaf.germ U (x : C) x.2).hom t ≠ 0 := by |
| simpa only [map_zero] using (germ_injective_of_isIntegral C x x.2).ne ht |
| have ho := scheme_order_of_stalk_element (C := C) (x : C) hx ((C.presheaf.germ U (x : C) x.2).hom t) ht' |
| rw [C.algebraMap_germ_eq_germToFunctionField x.2 t] at ho |
| apply ho.trans |
| have he := ringOrder_equiv e.toRingEquiv |
| (algebraMap Γ(C, U) (Localization.AtPrime (hU.primeIdealOf x).asIdeal) t) |
| have hc : e.toRingEquiv |
| (algebraMap Γ(C, U) (Localization.AtPrime (hU.primeIdealOf x).asIdeal) t) = |
| (C.presheaf.germ U (x : C) x.2).hom t := e.commutes t |
| rw [hc] at he |
| exact congrArg (fun n : ℕ∞ => (n.toNat : ℤ)) he |
|
|
| end NumericalDimensionOne |
|
|
| open AlgebraicGeometry CategoryTheory |
| open scoped TensorProduct nonZeroDivisors |
| open scoped TensorProduct |
| open AlgebraicGeometry CategoryTheory TopologicalSpace |
| open CategoryTheory Opposite AlgebraicGeometry TopologicalSpace |
|
|
| namespace NumericalDimensionOne |
| open AlgebraicGeometry CategoryTheory |
| open scoped BigOperators |
| variable {X : Scheme} [IsIntegral X] [IsLocallyNoetherian X] |
|
|
| theorem localOrder_eq_normalizationFiber (sX : X ⟶ Spec (.of ℂ)) |
| [LocallyOfFiniteType sX] (x : X) (hx : IsClosed ({x} : Set X)) |
| (hdim : Order.coheight x ≤ 1) (a : X.presheaf.stalk x) (ha : a ≠ 0) : |
| let N := (X.fromSpecStalk (genericPoint X)).normalization |
| let f := (X.fromSpecStalk (genericPoint X)).fromNormalization |
| Ring.ord (X.presheaf.stalk x) a = |
| ∑ᶠ y : {y : N // f y = x}, |
| Ring.ord (N.presheaf.stalk y.1) (fiberStalkMap f x y a) := by |
| let N := (X.fromSpecStalk (genericPoint X)).normalization |
| let f := (X.fromSpecStalk (genericPoint X)).fromNormalization |
| let R := X.presheaf.stalk x |
| let K := X.functionField |
| let B := integralClosure R K |
| have : Ring.KrullDimLE 1 R := krullDimLE_of_coheight_le hdim |
| have : Module.Finite R B := finite_integralClosure_stalk sX x |
| have : IsAlgClosed (IsLocalRing.ResidueField R) := |
| IsAlgClosed.of_ringEquiv ℂ _ |
| (Iso.commRingCatIsoToRingEquiv (residueFieldIsoBase sX x hx)).symm |
| obtain ⟨U,hU,hxU,_⟩ := exists_isAffineOpen_mem_and_subset |
| (show x ∈ (⊤ : X.Opens) from trivial) |
| let E := genericNormalizationFiberEquiv U hU ⟨x,hxU⟩ |
| have hsum := NormalizedLocalIntersection.ord_eq_finsum_branches B a ha |
| rw [← finsum_comp_equiv E.symm] at hsum |
| apply hsum.trans |
| apply finsum_congr |
| intro y |
| let S := N.presheaf.stalk y.1 |
| let hf := genericNormalization_bijective_functionField (X := X) |
| let : Algebra R S := (fiberStalkMap f x y).toAlgebra |
| let : Algebra S K := (birationalStalkToField f hf y.1).toAlgebra |
| have : IsFractionRing S K := birationalStalk_isFractionRing f hf y.1 |
| have : IsScalarTower R S K := birationalFiberStalk_tower f hf x y |
| have : IsIntegrallyClosed S := (genericNormalization_stalk y.1).2 |
| let : Algebra B S := (integralClosureToNormal R S K).toRingHom.toAlgebra |
| have : IsLocalization.AtPrime S (E.symm y).1 := |
| genericNormalization_stalk_atPrime sX U hU ⟨x,hxU⟩ y |
| let e := IsLocalization.algEquiv (E.symm y).1.primeCompl |
| (Localization.AtPrime (E.symm y).1) S |
| have he : e.toRingEquiv (algebraMap R (Localization.AtPrime (E.symm y).1) a) = |
| fiberStalkMap f x y a := by |
| change e (algebraMap R (Localization.AtPrime (E.symm y).1) a) = _ |
| rw [IsScalarTower.algebraMap_apply R B (Localization.AtPrime (E.symm y).1), |
| e.commutes] |
| exact (integralClosureToNormal R S K).commutes a |
| have ho := ringOrder_equiv e.toRingEquiv |
| (algebraMap R (Localization.AtPrime (E.symm y).1) a) |
| rw [he] at ho |
| exact ho.symm |
|
|
| end NumericalDimensionOne |
|
|
| open AlgebraicGeometry CategoryTheory |
| open scoped TensorProduct nonZeroDivisors |
| open scoped TensorProduct |
| open AlgebraicGeometry CategoryTheory TopologicalSpace |
| open CategoryTheory Opposite AlgebraicGeometry TopologicalSpace |
|
|
| namespace NumericalDimensionOne |
| open AlgebraicGeometry CategoryTheory |
| open scoped BigOperators |
| variable {X : Scheme} [IsIntegral X] [IsLocallyNoetherian X] |
|
|
| theorem localOrder_int_eq_normalizationFiber (sX : X ⟶ Spec (.of ℂ)) |
| [LocallyOfFiniteType sX] (x : X) (hx : IsClosed ({x} : Set X)) |
| (hdim : Order.coheight x ≤ 1) (a : X.presheaf.stalk x) (ha : a ≠ 0) : |
| let N := (X.fromSpecStalk (genericPoint X)).normalization |
| let f := (X.fromSpecStalk (genericPoint X)).fromNormalization |
| ((Ring.ord (X.presheaf.stalk x) a).toNat : ℤ) = |
| ∑ᶠ y : {y : N // f y = x}, |
| ((Ring.ord (N.presheaf.stalk y.1) (fiberStalkMap f x y a)).toNat : ℤ) := by |
| classical |
| let N := (X.fromSpecStalk (genericPoint X)).normalization |
| let f := (X.fromSpecStalk (genericPoint X)).fromNormalization |
| have : AlgebraicGeometry.IsFinite f := finite_genericNormalization sX |
| have hfin : ({y : N | f y = x}).Finite := f.finite_preimage_singleton x |
| have : Finite {y : N // f y = x} := hfin.to_subtype |
| let : Fintype {y : N // f y = x} := Fintype.ofFinite _ |
| have : Ring.KrullDimLE 1 (X.presheaf.stalk x) := krullDimLE_of_coheight_le hdim |
| have heq := localOrder_eq_normalizationFiber sX x hx hdim a ha |
| dsimp only at heq ⊢ |
| rw [finsum_eq_sum_of_fintype] at heq ⊢ |
| have htop : (∑ y : {y : N // f y = x}, |
| Ring.ord (N.presheaf.stalk y.1) (fiberStalkMap f x y a)) ≠ ⊤ := by |
| rw [← heq] |
| exact Ring.ord_ne_top (mem_nonZeroDivisors_iff_ne_zero.mpr ha) |
| have hn := congrArg ENat.toNat heq |
| rw [ENat.toNat_sum (ENat.sum_ne_top.mp htop)] at hn |
| exact_mod_cast hn |
| end NumericalDimensionOne |
|
|
| end OAI |
|
|
