| import Mathlib | |
| import OAI.RingTheory.Multiplicity.PowerSeriesFinDimension | |
| namespace OAI | |
| section | |
| noncomputable section | |
| open MvPowerSeries | |
| open scoped Classical | |
| open scoped TensorProduct | |
| open IsLocalRing | |
| open MvPowerSeries IsLocalRing | |
| open scoped ENNReal | |
| open scoped ENNReal TensorProduct Classical DirectSum | |
| open TensorProduct | |
| open scoped TensorProduct nonZeroDivisors | |
| open scoped nonZeroDivisors | |
| open scoped BigOperators | |
| open scoped nonZeroDivisors TensorProduct | |
| open scoped Classical Pointwise | |
| open CategoryTheory CategoryTheory.Limits | |
| open CochainComplex CochainComplex.HomComplex | |
| open scoped ENNReal ZeroObject | |
| open CategoryTheory CategoryTheory.Limits HomologicalComplex CochainComplex | |
| open CategoryTheory CategoryTheory.Limits HomologicalComplex | |
| open CategoryTheory CategoryTheory.Limits CategoryTheory.ComposableArrows | |
| open HomologicalComplex HomologicalComplex.HomologySequence CategoryTheory.Abelian | |
| open CategoryTheory | |
| namespace Lech.CoefficientField | |
| variable (R : Type*) [CommRing R] [IsDomain R] [IsLocalRing R] | |
| (p : ℕ) [Fact p.Prime] [CharP R p] | |
| [PerfectRing (IsLocalRing.ResidueField R) p] | |
| [IsAdicComplete (IsLocalRing.maximalIdeal R) R] | |
| def localSection : IsLocalRing.ResidueField R →+* R := by | |
| let : CharP (R ⧸ IsLocalRing.maximalIdeal R) p := | |
| CharP.of_ringHom_of_ne_zero (Ideal.Quotient.mk _) p (Nat.Prime.ne_zero Fact.out) | |
| let : PerfectRing (R ⧸ IsLocalRing.maximalIdeal R) p := | |
| inferInstanceAs (PerfectRing (IsLocalRing.ResidueField R) p) | |
| exact sectionMap R (IsLocalRing.maximalIdeal R) p | |
| lemma localSection_rightInverse : | |
| Function.RightInverse (localSection R p) (IsLocalRing.residue R) := by | |
| let : CharP (R ⧸ IsLocalRing.maximalIdeal R) p := | |
| CharP.of_ringHom_of_ne_zero (Ideal.Quotient.mk _) p (Nat.Prime.ne_zero Fact.out) | |
| let : PerfectRing (R ⧸ IsLocalRing.maximalIdeal R) p := | |
| inferInstanceAs (PerfectRing (IsLocalRing.ResidueField R) p) | |
| exact sectionMap_rightInverse R (IsLocalRing.maximalIdeal R) p | |
| lemma localSection_injective : Function.Injective (localSection R p) := | |
| (localSection_rightInverse R p).injective | |
| end Lech.CoefficientField | |
| namespace Lech.Normalization | |
| open IsLocalRing MvPowerSeries | |
| variable {σ k D : Type*} [Fintype σ] [Field k] [CommRing D] [IsLocalRing D] | |
| [IsNoetherianRing D] [IsAdicComplete (maximalIdeal D) D] | |
| (φ : k →+* D) (hφ : Function.Surjective ((residue D).comp φ)) | |
| (z : σ → D) (hz : ∀ i, z i ∈ maximalIdeal D) | |
| include hφ in | |
| lemma parameter_eval_finite (hprim : (Ideal.span (Set.range z)).radical = maximalIdeal D) : | |
| (Lech.PowerSeries.eval φ (maximalIdeal D) z hz).Finite := | |
| finite_parameter_algebra φ hφ z hz hprim | |
| include hφ in | |
| lemma parameter_eval_injective (hprim : (Ideal.span (Set.range z)).radical = maximalIdeal D) | |
| (hdim : (Fintype.card σ : WithBot ℕ∞) ≤ ringKrullDim D) : | |
| Function.Injective (Lech.PowerSeries.eval φ (maximalIdeal D) z hz) := by | |
| let : IsDomain (MvPowerSeries σ k) := NoZeroDivisors.to_isDomain _ | |
| let ψ := Lech.PowerSeries.eval φ (maximalIdeal D) z hz | |
| let : Algebra (MvPowerSeries σ k) D := ψ.toAlgebra | |
| let : Module.Finite (MvPowerSeries σ k) D := finite_parameter_algebra φ hφ z hz hprim | |
| exact injective_of_integral_dimension ψ (Algebra.IsIntegral.isIntegral) | |
| hdim (Lech.PowerSeries.dimension_le_variables σ k) | |
| end Lech.Normalization | |
| namespace Lech.Normalization | |
| open IsLocalRing MvPowerSeries | |
| variable (D : Type*) [CommRing D] [IsDomain D] [IsNoetherianRing D] [IsLocalRing D] | |
| [IsAdicComplete (maximalIdeal D) D] | |
| (p : ℕ) [Fact p.Prime] [CharP D p] [PerfectRing (ResidueField D) p] | |
| include p in | |
| theorem exists_finite_powerSeries_normalization : | |
| ∃ (n : ℕ) (ψ : MvPowerSeries (Fin n) (ResidueField D) →+* D), | |
| Function.Injective ψ ∧ ψ.Finite ∧ IsLocalHom ψ ∧ | |
| Function.Surjective ((residue D).comp ψ) ∧ ringKrullDim D = n := by | |
| obtain ⟨n,z,hz,hprim,hdim⟩ := exists_parameters D | |
| let φ := Lech.CoefficientField.localSection D p | |
| have hφ : Function.Surjective ((residue D).comp φ) := | |
| fun a => ⟨a,Lech.CoefficientField.localSection_rightInverse D p a⟩ | |
| let ψ := Lech.PowerSeries.eval φ (maximalIdeal D) z hz | |
| have hfin : ψ.Finite := parameter_eval_finite φ hφ z hz hprim | |
| have hinj : Function.Injective ψ := parameter_eval_injective φ hφ z hz hprim (by | |
| simpa only [Fintype.card_fin,hdim] using (le_refl (n : WithBot ℕ∞))) | |
| have hint : ψ.IsIntegral := by | |
| let : Algebra (MvPowerSeries (Fin n) (ResidueField D)) D := ψ.toAlgebra | |
| let : Module.Finite (MvPowerSeries (Fin n) (ResidueField D)) D := hfin | |
| exact Algebra.IsIntegral.isIntegral | |
| refine ⟨n,ψ,hinj,hfin,hint.isLocalHom hinj,?_,hdim⟩ | |
| intro a | |
| refine ⟨C a,?_⟩ | |
| change residue D (Lech.PowerSeries.eval φ (maximalIdeal D) z hz (C a)) = a | |
| rw [Lech.PowerSeries.eval_C] | |
| exact Lech.CoefficientField.localSection_rightInverse D p a | |
| end Lech.Normalization | |
| namespace Lech.Normalization | |
| open IsLocalRing MvPowerSeries Filter | |
| open scoped Topology | |
| variable {k D : Type*} [Field k] [CommRing D] [IsLocalRing D] [IsNoetherianRing D] | |
| [IsAdicComplete (maximalIdeal D) D] | |
| theorem parameter_powers_multiplicity (h : ℕ) (hh : 0 < h) | |
| (hdim : Lech.dimension D = h) (φ : k →+* D) | |
| (hφ : Function.Surjective ((residue D).comp φ)) (z : Fin h → D) | |
| (hprim : (Ideal.span (Set.range z)).radical = maximalIdeal D) : | |
| Tendsto (fun q : ℕ => ((Module.length D | |
| (D ⧸ Ideal.span (Set.range fun i : Fin h => z i^q))).toNat : ℝ) / (q : ℝ)^h) | |
| atTop (𝓝 (Lech.Primary.multiplicity (Ideal.span (Set.range z)))) := by | |
| have hz : ∀ i, z i ∈ maximalIdeal D := fun i => by | |
| rw [← hprim] | |
| exact Ideal.le_radical (Ideal.subset_span ⟨i,rfl⟩) | |
| let A := MvPowerSeries (Fin h) k | |
| let ψ := Lech.PowerSeries.eval φ (maximalIdeal D) z hz | |
| let : Algebra A D := ψ.toAlgebra | |
| let : Module.Finite A D := parameter_eval_finite φ hφ z hz hprim | |
| have hinj : Function.Injective ψ := parameter_eval_injective φ hφ z hz hprim (by | |
| rw [Fintype.card_fin,← hdim,Lech.dimension_cast]) | |
| let : IsLocalHom (algebraMap A D) := | |
| RingHom.IsIntegral.isLocalHom (f := ψ) Algebra.IsIntegral.isIntegral hinj | |
| have hres : Function.Surjective (algebraMap (ResidueField A) (ResidueField D)) := by | |
| intro b | |
| obtain ⟨a,ha⟩ := hφ b | |
| refine ⟨residue A (C a),?_⟩ | |
| rw [ResidueField.algebraMap_residue] | |
| change residue D (ψ (C a)) = b | |
| rw [Lech.PowerSeries.eval_C] | |
| exact ha | |
| have hm : (maximalIdeal A).map (algebraMap A D) = Ideal.span (Set.range z) := by | |
| rw [Lech.PowerSeries.maximalIdeal_eq_variables,Ideal.map_span,← Set.range_comp] | |
| apply congrArg Ideal.span | |
| apply congrArg Set.range | |
| funext i | |
| exact Lech.PowerSeries.eval_X φ (maximalIdeal D) z hz i | |
| have hp (q : ℕ) : (Ideal.span (Set.range fun i : Fin h => (X i : A)^q)).map | |
| (algebraMap A D) = Ideal.span (Set.range fun i => z i^q) := by | |
| rw [Ideal.map_span,← Set.range_comp] | |
| apply congrArg Ideal.span | |
| apply congrArg Set.range | |
| funext i | |
| change ψ ((MvPowerSeries.X i)^q) = z i^q | |
| rw [map_pow,Lech.PowerSeries.eval_X] | |
| have ht := Lech.PowerSeries.parameter_powers_limit (k := k) (D := D) h hh hdim hres | |
| (by rwa [hm]) | |
| change Tendsto (fun q : ℕ => ((Module.length D | |
| (D ⧸ (Ideal.span (Set.range fun i : Fin h => (X i : A)^q)).map | |
| (algebraMap A D))).toNat : ℝ) / (q : ℝ)^h) atTop | |
| (𝓝 (Lech.Primary.multiplicity ((maximalIdeal A).map (algebraMap A D)))) at ht | |
| rw [hm] at ht | |
| apply ht.congr | |
| intro q | |
| rw [hp q] | |
| end Lech.Normalization | |
| namespace Lech.Normalization | |
| open IsLocalRing Filter | |
| open scoped Topology ENNReal | |
| variable {k D : Type*} [Field k] [CommRing D] [IsLocalRing D] [IsNoetherianRing D] | |
| [IsAdicComplete (maximalIdeal D) D] | |
| omit [Field k] [IsLocalRing D] [IsNoetherianRing D] | |
| [IsAdicComplete (maximalIdeal D) D] in | |
| lemma radical_span_powers {ι : Type*} (z : ι → D) (q : ℕ) (hq : q ≠ 0) : | |
| (Ideal.span (Set.range fun i => z i^q)).radical = | |
| (Ideal.span (Set.range z)).radical := by | |
| apply le_antisymm | |
| · apply Ideal.radical_mono | |
| apply Ideal.span_le.mpr | |
| rintro _ ⟨i,rfl⟩ | |
| exact Ideal.pow_mem_of_mem _ (Ideal.subset_span (Set.mem_range_self i)) q (Nat.pos_of_ne_zero hq) | |
| · apply Ideal.radical_le_radical_iff.mpr | |
| apply Ideal.span_le.mpr | |
| rintro _ ⟨i,rfl⟩ | |
| exact ⟨q,Ideal.subset_span ⟨i,rfl⟩⟩ | |
| theorem parameter_powers_multiplicity_enn (h : ℕ) (hh : 0 < h) | |
| (hdim : Lech.dimension D = h) (φ : k →+* D) | |
| (hφ : Function.Surjective ((residue D).comp φ)) (z : Fin h → D) | |
| (hprim : (Ideal.span (Set.range z)).radical = maximalIdeal D) : | |
| Tendsto (fun q : ℕ => ((q : ℝ≥0∞)^h)⁻¹ * (Module.length D | |
| (D ⧸ Ideal.span (Set.range fun i : Fin h => z i^q))).toENNReal) | |
| atTop (𝓝 (ENNReal.ofReal (Lech.Primary.multiplicity (Ideal.span (Set.range z))))) := by | |
| have ht := ENNReal.continuous_ofReal.continuousAt.tendsto.comp | |
| (parameter_powers_multiplicity h hh hdim φ hφ z hprim) | |
| simp only [Function.comp_def] at ht | |
| apply ht.congr' | |
| filter_upwards [eventually_ge_atTop 1] with q hq | |
| have hf : Module.length D (D ⧸ Ideal.span (Set.range fun i => z i^q)) ≠ ⊤ := by | |
| have hf := Lech.Primary.length_ne_top | |
| (Ideal.span (Set.range fun i => z i^q)) | |
| ((radical_span_powers z q (by omega)).trans hprim) 1 | |
| rw [pow_one] at hf | |
| exact hf | |
| rw [ENNReal.ofReal_div_of_pos (by positivity),ENNReal.ofReal_pow (by positivity), | |
| ENNReal.ofReal_natCast,ENNReal.ofReal_natCast,div_eq_mul_inv,mul_comm] | |
| congr 1 | |
| exact congrArg ENat.toENNReal (ENat.natCast_toNat hf) | |
| theorem parameter_frobenius_multiplicity_enn (h : ℕ) (hh : 0 < h) | |
| (hdim : Lech.dimension D = h) (φ : k →+* D) | |
| (hφ : Function.Surjective ((residue D).comp φ)) (z : Fin h → D) | |
| (hprim : (Ideal.span (Set.range z)).radical = maximalIdeal D) | |
| (a : ℕ) (ha : 0 < a) (p : ℕ) [Fact p.Prime] [CharP D p] : | |
| Tendsto (fun n : ℕ => ((p : ℝ≥0∞)^(n*h))⁻¹ * (Module.length D | |
| (D ⧸ (Ideal.span (Set.range fun i : Fin h => z i^a)).map | |
| (iterateFrobenius D p n))).toENNReal) atTop | |
| (𝓝 ((a : ℝ≥0∞)^h * ENNReal.ofReal | |
| (Lech.Primary.multiplicity (Ideal.span (Set.range z))))) := by | |
| have hp : Tendsto (fun n : ℕ => a*p^n) atTop atTop := by | |
| apply Filter.Tendsto.const_mul_atTop' ha | |
| exact tendsto_pow_atTop_atTop_of_one_lt (Fact.out : p.Prime).one_lt | |
| have ht := ENNReal.Tendsto.const_mul (a := (a : ℝ≥0∞)^h) | |
| ((parameter_powers_multiplicity_enn h hh hdim φ hφ z hprim).comp hp) | |
| (Or.inr (by finiteness)) | |
| apply ht.congr | |
| intro n | |
| dsimp only [Function.comp_def] | |
| have he : (Ideal.span (Set.range fun i : Fin h => z i^a)).map | |
| (iterateFrobenius D p n) = Ideal.span (Set.range fun i : Fin h => z i^(a*p^n)) := by | |
| rw [Ideal.map_span,← Set.range_comp] | |
| apply congrArg Ideal.span | |
| apply congrArg Set.range | |
| funext i | |
| exact (pow_mul (z i) a (p^n)).symm | |
| rw [he,Nat.cast_mul,Nat.cast_pow,mul_pow,ENNReal.mul_inv (Or.inr (by finiteness)) (Or.inl (by finiteness)),← pow_mul] | |
| rw [← mul_assoc,← mul_assoc,ENNReal.mul_inv_cancel (by positivity) (by finiteness),one_mul] | |
| end Lech.Normalization | |
| namespace Lech | |
| theorem finite_module_colength_error_pos (A M : Type*) [CommRing A] [IsDomain A] | |
| [IsNoetherianRing A] [AddCommGroup M] [Module A M] [Module.Finite A M] | |
| (hfaithful : ∀ g : A, g ≠ 0 → g • (LinearMap.id : M →ₗ[A] M) ≠ 0) : | |
| ∃ (n c : ℕ) (g : A), 0 < n ∧ g ≠ 0 ∧ ∀ I : Ideal A, | |
| Module.length A (A ⧸ I) ≠ ⊤ → | |
| |((Module.length A (M ⧸ I • (⊤ : Submodule A M))).toNat : ℝ) - | |
| (n : ℝ) * ((Module.length A (A ⧸ I)).toNat : ℝ)| ≤ | |
| (c : ℝ) * ((Module.length A (A ⧸ (I ⊔ Ideal.span {g}))).toNat : ℝ) := by | |
| obtain ⟨n,c,g,hn,hg,h⟩ := finite_module_colength_compare_pos A M hfaithful | |
| refine ⟨n,c+n,g,hn,hg,fun I hI => ?_⟩ | |
| obtain ⟨h₁,h₂⟩ := h I hI | |
| have hG : Module.length A (A ⧸ (I ⊔ Ideal.span {g})) ≠ ⊤ := by | |
| apply ne_top_of_le_ne_top hI | |
| let f := I.mapQ (I ⊔ Ideal.span {g}) LinearMap.id le_sup_left | |
| apply Module.length_le_of_surjective f | |
| intro x | |
| obtain ⟨a,rfl⟩ := (I ⊔ Ideal.span {g}).mkQ_surjective x | |
| exact ⟨I.mkQ a,rfl⟩ | |
| have hM : Module.length A (M ⧸ I • (⊤ : Submodule A M)) ≠ ⊤ := by | |
| apply ne_top_of_le_ne_top _ h₁ | |
| exact WithTop.add_ne_top.mpr ⟨WithTop.mul_ne_top (ENat.natCast_ne_top _) hI, | |
| WithTop.mul_ne_top (ENat.natCast_ne_top _) hG⟩ | |
| rw [← ENat.natCast_toNat hM, ← ENat.natCast_toNat hI, | |
| ← ENat.natCast_toNat hG] at h₁ h₂ | |
| have hr₁ : ((Module.length A (M ⧸ I • (⊤ : Submodule A M))).toNat : ℝ) ≤ | |
| (n : ℝ) * (Module.length A (A ⧸ I)).toNat + | |
| (c : ℝ) * (Module.length A (A ⧸ (I ⊔ Ideal.span {g}))).toNat := by | |
| exact_mod_cast h₁ | |
| have hr₂ : (n : ℝ) * (Module.length A (A ⧸ I)).toNat ≤ | |
| ((Module.length A (M ⧸ I • (⊤ : Submodule A M))).toNat : ℝ) + | |
| (n : ℝ) * (Module.length A (A ⧸ (I ⊔ Ideal.span {g}))).toNat := by | |
| exact_mod_cast h₂ | |
| have hgn : (0 : ℝ) ≤ (Module.length A (A ⧸ (I ⊔ Ideal.span {g}))).toNat := by positivity | |
| have hcn : (0 : ℝ) ≤ c := by positivity | |
| have hnn : (0 : ℝ) ≤ n := by positivity | |
| rw [Nat.cast_add,abs_le] | |
| constructor <;> nlinarith | |
| open Filter | |
| open scoped Topology | |
| theorem finite_module_asymptotic_pos (A M : Type*) [CommRing A] [IsDomain A] | |
| [IsNoetherianRing A] [AddCommGroup M] [Module A M] [Module.Finite A M] | |
| (hfaithful : ∀ g : A, g ≠ 0 → g • (LinearMap.id : M →ₗ[A] M) ≠ 0) : | |
| ∃ n : ℕ, 0 < n ∧ ∀ (I : ℕ → Ideal A) (u : ℕ → ℝ) (a : ℝ), | |
| (∀ᶠ q in atTop, Module.length A (A ⧸ I q) ≠ ⊤) → | |
| (∀ᶠ q in atTop, 0 < u q) → | |
| Tendsto (fun q => ((Module.length A (A ⧸ I q)).toNat : ℝ) / u q) atTop (𝓝 a) → | |
| (∀ g : A, g ≠ 0 → Tendsto (fun q => | |
| ((Module.length A (A ⧸ (I q ⊔ Ideal.span {g}))).toNat : ℝ) / u q) atTop (𝓝 0)) → | |
| Tendsto (fun q => ((Module.length A (M ⧸ I q • (⊤ : Submodule A M))).toNat : ℝ) / u q) | |
| atTop (𝓝 ((n : ℝ) * a)) := by | |
| obtain ⟨n,c,g,hn,hg,h⟩ := finite_module_colength_error_pos A M hfaithful | |
| refine ⟨n,hn,fun I u a hI hu hA hG => ?_⟩ | |
| apply tendsto_of_abs_sub_le (hA.const_mul (n : ℝ)) | |
| (show Tendsto (fun q => (c : ℝ) * | |
| (((Module.length A (A ⧸ (I q ⊔ Ideal.span {g}))).toNat : ℝ) / u q)) atTop (𝓝 0) from by | |
| simpa using (hG g hg).const_mul (c : ℝ)) | |
| filter_upwards [hI,hu] with q hI hu | |
| have hh := div_le_div_of_nonneg_right (h (I q) hI) hu.le | |
| simpa only [← mul_div_assoc,← sub_div,abs_div,abs_of_pos hu] using hh | |
| end Lech | |
| namespace Lech.PowerSeries | |
| open MvPowerSeries IsLocalRing Filter | |
| open scoped Topology nonZeroDivisors | |
| variable {k : Type*} [Field k] | |
| theorem finite_module_two_limits_pos (h : ℕ) (hh : 0 < h) (M : Type*) [AddCommGroup M] | |
| [Module (MvPowerSeries (Fin h) k) M] [Module.Finite (MvPowerSeries (Fin h) k) M] | |
| (hfaithful : ∀ g : MvPowerSeries (Fin h) k, g ≠ 0 → g • (LinearMap.id : M →ₗ[MvPowerSeries (Fin h) k] M) ≠ 0) : | |
| ∃ n : ℕ, 0 < n ∧ | |
| Tendsto (fun q : ℕ => (h.factorial : ℝ) * | |
| ((Module.length (MvPowerSeries (Fin h) k) | |
| (M ⧸ (maximalIdeal (MvPowerSeries (Fin h) k))^q • (⊤ : Submodule (MvPowerSeries (Fin h) k) M))).toNat : ℝ) / (q : ℝ)^h) | |
| atTop (𝓝 (n : ℝ)) ∧ | |
| Tendsto (fun q : ℕ => | |
| ((Module.length (MvPowerSeries (Fin h) k) | |
| (M ⧸ Ideal.span (Set.range (fun i : Fin h => (X i : MvPowerSeries (Fin h) k)^q)) • (⊤ : Submodule (MvPowerSeries (Fin h) k) M))).toNat : ℝ) / | |
| (q : ℝ)^h) atTop (𝓝 (n : ℝ)) := by | |
| let A := MvPowerSeries (Fin h) k | |
| let : IsDomain A := NoZeroDivisors.to_isDomain _ | |
| let m := maximalIdeal A | |
| let J (q : ℕ) : Ideal A := Ideal.span (Set.range fun i : Fin h => (X i : A)^q) | |
| obtain ⟨n,hpos,hn⟩ := Lech.finite_module_asymptotic_pos A M hfaithful | |
| refine ⟨n,hpos,?_,?_⟩ | |
| · have hbase : Tendsto (fun q : ℕ => | |
| ((Module.length A (A ⧸ m^q)).toNat : ℝ) / ((q : ℝ)^h / h.factorial)) atTop (𝓝 1) := by | |
| apply (Lech.binomial_normalized_tendsto h).congr' | |
| filter_upwards [eventually_gt_atTop 0] with q hq | |
| rw [maximal_power_colength h hh q hq] | |
| simp only [ENat.toNat_natCast,div_div_eq_mul_div] | |
| ring | |
| have herr (g : A) (hg : g ≠ 0) : Tendsto (fun q : ℕ => | |
| ((Module.length A (A ⧸ (m^q ⊔ Ideal.span {g}))).toNat : ℝ) / | |
| ((q : ℝ)^h / h.factorial)) atTop (𝓝 0) := by | |
| have ht := FrobeniusGrowth.ordinary_error_tendsto m | |
| (Ideal.IsPrime.radical inferInstance) (mem_nonZeroDivisors_iff_ne_zero.mpr hg) | |
| rw [fin_dimension_nat] at ht | |
| convert ht.const_mul (h.factorial : ℝ) using 1 | |
| · ext q | |
| simp only [div_div_eq_mul_div] | |
| ring | |
| · simp | |
| have ht := hn (fun q => m^q) (fun q => (q : ℝ)^h / h.factorial) 1 | |
| (Eventually.of_forall (fun q => Lech.quotient_length_ne_top A q)) | |
| ((eventually_gt_atTop 0).mono (fun q hq => by positivity)) hbase herr | |
| simp only [mul_one] at ht | |
| convert ht using 1 | |
| ext q | |
| simp only [div_div_eq_mul_div] | |
| ring | |
| · have hbase : Tendsto (fun q : ℕ => | |
| ((Module.length A (A ⧸ J q)).toNat : ℝ) / (q : ℝ)^h) atTop (𝓝 1) := by | |
| apply tendsto_const_nhds.congr' | |
| filter_upwards [eventually_gt_atTop 0] with q hq | |
| let : NeZero q := ⟨hq.ne'⟩ | |
| have he := RootTower.variable_powers_colength (σ := Fin h) (k := k) q | |
| change Module.length A (A ⧸ J q) = _ at he | |
| rw [he] | |
| simp only [Fintype.card_fin] | |
| rw [← Nat.cast_pow, ENat.toNat_natCast, Nat.cast_pow] | |
| simp [hq.ne'] | |
| have hfinite : ∀ᶠ q in atTop, Module.length A (A ⧸ J q) ≠ ⊤ := by | |
| filter_upwards [eventually_gt_atTop 0] with q hq | |
| let : NeZero q := ⟨hq.ne'⟩ | |
| have he := RootTower.variable_powers_colength (σ := Fin h) (k := k) q | |
| change Module.length A (A ⧸ J q) = _ at he | |
| rw [he] | |
| exact ENat.natCast_ne_top _ | |
| have herr (g : A) (hg : g ≠ 0) : Tendsto (fun q : ℕ => | |
| ((Module.length A (A ⧸ (J q ⊔ Ideal.span {g}))).toNat : ℝ) / (q : ℝ)^h) | |
| atTop (𝓝 0) := by | |
| have ht := FrobeniusGrowth.parameter_error_tendsto h hh (X : Fin h → A) | |
| maximalIdeal_eq_variables.symm (mem_nonZeroDivisors_iff_ne_zero.mpr hg) | |
| rwa [fin_dimension_nat] at ht | |
| have ht := hn J (fun q => (q : ℝ)^h) 1 hfinite | |
| ((eventually_gt_atTop 0).mono (fun q hq => by positivity)) hbase herr | |
| simpa only [mul_one] using ht | |
| end Lech.PowerSeries | |
| namespace Lech.PowerSeries | |
| open MvPowerSeries IsLocalRing Filter | |
| open scoped Topology | |
| variable {k D : Type*} [Field k] [CommRing D] [IsLocalRing D] [IsNoetherianRing D] | |
| (h : ℕ) [Algebra (MvPowerSeries (Fin h) k) D] | |
| [IsLocalHom (algebraMap (MvPowerSeries (Fin h) k) D)] | |
| [Module.Finite (MvPowerSeries (Fin h) k) D] | |
| theorem exists_parameter_multiplicity_pos (hh : 0 < h) (hdim : Lech.dimension D = h) | |
| (hinj : Function.Injective (algebraMap (MvPowerSeries (Fin h) k) D)) | |
| (hres : Function.Surjective (algebraMap (ResidueField (MvPowerSeries (Fin h) k)) | |
| (ResidueField D))) | |
| (hprim : ((maximalIdeal (MvPowerSeries (Fin h) k)).map | |
| (algebraMap (MvPowerSeries (Fin h) k) D)).radical = maximalIdeal D) : | |
| ∃ n : ℕ, 0 < n ∧ Lech.Primary.multiplicity ((maximalIdeal (MvPowerSeries (Fin h) k)).map | |
| (algebraMap (MvPowerSeries (Fin h) k) D)) = n := by | |
| obtain ⟨n,hn,ht,_⟩ := finite_module_two_limits_pos (k := k) h hh D (by | |
| intro g hg he | |
| apply hg | |
| apply hinj | |
| have he' := LinearMap.congr_fun he (1 : D) | |
| change g • (1 : D) = 0 at he' | |
| simpa only [Algebra.smul_def,mul_one,map_zero] using he') | |
| refine ⟨n,hn,?_⟩ | |
| apply tendsto_nhds_unique (Lech.Primary.multiplicity_is_limit _ hprim) | |
| apply ht.congr | |
| intro q | |
| rw [Lech.LocalAlgebra.quotient_length_eq _ _ _ hres,Ideal.map_pow] | |
| simp only [Lech.Primary.normalizedColength,Lech.Primary.colength,hdim] | |
| end Lech.PowerSeries | |
| namespace Lech.Normalization | |
| open IsLocalRing MvPowerSeries | |
| variable {k D : Type*} [Field k] [CommRing D] [IsLocalRing D] [IsNoetherianRing D] | |
| [IsAdicComplete (maximalIdeal D) D] | |
| theorem parameter_multiplicity_pos (h : ℕ) (hh : 0 < h) | |
| (hdim : Lech.dimension D = h) (φ : k →+* D) | |
| (hφ : Function.Surjective ((residue D).comp φ)) (z : Fin h → D) | |
| (hprim : (Ideal.span (Set.range z)).radical = maximalIdeal D) : | |
| 0 < Lech.Primary.multiplicity (Ideal.span (Set.range z)) := by | |
| have hz : ∀ i, z i ∈ maximalIdeal D := fun i => by | |
| rw [← hprim] | |
| exact Ideal.le_radical (Ideal.subset_span ⟨i,rfl⟩) | |
| let A := MvPowerSeries (Fin h) k | |
| let ψ := Lech.PowerSeries.eval φ (maximalIdeal D) z hz | |
| let : Algebra A D := ψ.toAlgebra | |
| let : Module.Finite A D := parameter_eval_finite φ hφ z hz hprim | |
| have hinj : Function.Injective ψ := parameter_eval_injective φ hφ z hz hprim (by | |
| rw [Fintype.card_fin,← hdim,Lech.dimension_cast]) | |
| let : IsLocalHom (algebraMap A D) := | |
| RingHom.IsIntegral.isLocalHom (f := ψ) Algebra.IsIntegral.isIntegral hinj | |
| have hres : Function.Surjective (algebraMap (ResidueField A) (ResidueField D)) := by | |
| intro b | |
| obtain ⟨a,ha⟩ := hφ b | |
| refine ⟨residue A (C a),?_⟩ | |
| rw [ResidueField.algebraMap_residue] | |
| change residue D (ψ (C a)) = b | |
| rw [Lech.PowerSeries.eval_C] | |
| exact ha | |
| have hm : (maximalIdeal A).map (algebraMap A D) = Ideal.span (Set.range z) := by | |
| rw [Lech.PowerSeries.maximalIdeal_eq_variables,Ideal.map_span,← Set.range_comp] | |
| apply congrArg Ideal.span | |
| apply congrArg Set.range | |
| funext i | |
| exact Lech.PowerSeries.eval_X φ (maximalIdeal D) z hz i | |
| obtain ⟨n,hn,hnum⟩ := Lech.PowerSeries.exists_parameter_multiplicity_pos | |
| (k := k) (D := D) h hh hdim hinj hres (by rwa [hm]) | |
| rw [hm] at hnum | |
| rw [hnum] | |
| exact_mod_cast hn | |
| end Lech.Normalization | |
| end | |
| end | |
| end OAI | |