Download data/lean/OAI/NumberTheory/CMField/NormOneApproximation.lean from introvoyz045/math: direct link, hf CLI and curl.
- Browser
- Download file 10.4 kB
-
https://huggingface.co/datasets/introvoyz045/math/resolve/main/data/lean/OAI/NumberTheory/CMField/NormOneApproximation.lean
- Command line
-
hf download hf://datasets/introvoyz045/math/data/lean/OAI/NumberTheory/CMField/NormOneApproximation.lean
-
curl -L -o NormOneApproximation.lean https://huggingface.co/datasets/introvoyz045/math/resolve/main/data/lean/OAI/NumberTheory/CMField/NormOneApproximation.lean
10.4 kB
| import Mathlib.NumberTheory.NumberField.CMField | |
| import Mathlib.RingTheory.ClassGroup.Basic | |
| import Mathlib.RingTheory.DedekindDomain.AdicValuation | |
| import Mathlib.RingTheory.Ideal.Quotient.Nilpotent | |
| import Mathlib.RingTheory.Ideal.Quotient.HasFiniteQuotients.Basic | |
| import Mathlib.RingTheory.Ideal.Quotient.HasFiniteQuotients.Norm | |
| import OAI.NumberTheory.ClassGroup.Finiteness | |
| /-! # Norm One Approximation -/ | |
| namespace OAI.NumberTheory.CMField.NormOneApproximation.Construction | |
| noncomputable section | |
| /-! | |
| Proof of NormOneApproximation, retaining the conditional theorem for existing consumers. | |
| The final entrypoint `exists_norm_one_scalar_unconditional` supplies the | |
| named input `hFiniteness_classGroup_finite` from the proved Finiteness declaration. | |
| This is the first proposition of Statements/Finiteness.lean, specialized to E. Its | |
| fractional-ideal principalization assertion is redundant here. CMPoints, TensorDecomposition, | |
| and ElementaryDivisors are unnecessary for this arithmetic result with the two distinct | |
| conjugate primes already specified. No statement stub is imported. | |
| As in the specification, multiplicative valuation exp(-m) means additive | |
| order m. The local approximation clause concerns further positive powers. | |
| The manuscript's scalar assertion is in | |
| docs/hodge_cm_claimed_result_labeled.tex, lemma:norm-one-scalar (lines 353-361). | |
| -/ | |
| open _root_.NumberField IsDedekindDomain | |
| open scoped nonZeroDivisors | |
| variable {E : Type*} [Field E] [NumberField E] | |
| lemma principal_prime_power | |
| (hFiniteness_classGroup_finite : Finite (ClassGroup (π E))) | |
| (w : HeightOneSpectrum (π E)) : | |
| β (M : β) (a : π E), 0 < M β§ a β 0 β§ | |
| w.asIdeal ^ M = Ideal.span {a} := by | |
| let := hFiniteness_classGroup_finite | |
| let I : (Ideal (π E))β° := β¨w.asIdeal, mem_nonZeroDivisors_of_ne_zero w.ne_botβ© | |
| obtain β¨M, hM, heqβ© := (isOfFinOrder_of_finite (ClassGroup.mk0 I)).exists_pow_eq_one | |
| have hprincipal : (w.asIdeal ^ M).IsPrincipal := by | |
| apply (ClassGroup.mk0_eq_one_iff (pow_mem I.property M)).mp | |
| simpa only [I, β map_pow, SubmonoidClass.mk_pow] using heq | |
| obtain β¨a, haβ© := hprincipal.principal | |
| refine β¨M, a, hM, ?_, haβ© | |
| intro hzero | |
| have hpow : w.asIdeal ^ M β 0 := pow_ne_zero M w.prime.ne_zero | |
| apply hpow | |
| simpa [hzero] using ha | |
| lemma valuation_generator_self | |
| (w : HeightOneSpectrum (π E)) (M : β) (a : π E) | |
| (ha : a β 0) (hspan : w.asIdeal ^ M = Ideal.span {a}) : | |
| w.intValuation a = WithZero.exp (-(M : β€)) := by | |
| rw [w.intValuation_eq_exp_neg_multiplicity ha, β hspan, | |
| multiplicity_pow_self_of_prime w.prime] | |
| lemma valuation_generator_other | |
| (w p : HeightOneSpectrum (π E)) (M : β) (a : π E) | |
| (hspan : w.asIdeal ^ M = Ideal.span {a}) (hp : p β w) : | |
| p.intValuation a = 1 := by | |
| apply p.intValuation_eq_one_iff.mpr | |
| intro hmem | |
| have hdvd : p.asIdeal β£ w.asIdeal ^ M := by | |
| rw [hspan, Ideal.dvd_span_singleton] | |
| exact hmem | |
| have hle : w.asIdeal β€ p.asIdeal := | |
| Ideal.dvd_iff_le.mp (p.prime.dvd_of_dvd_pow hdvd) | |
| apply hp | |
| apply HeightOneSpectrum.asIdeal_injective | |
| exact ((w.isMaximal).eq_of_le (p.isPrime.ne_top) hle).symm | |
| /-- Simultaneous congruences for two integral elements which are units | |
| at every prime in S, using the finite product of residue-unit groups. -/ | |
| lemma simultaneous_power_congruence | |
| (S : Finset (HeightOneSpectrum (π E))) | |
| (depth : HeightOneSpectrum (π E) β β) | |
| (a b : π E) | |
| (ha : β p β S, a β p.asIdeal) | |
| (hb : β p β S, b β p.asIdeal) : | |
| β N : β, 0 < N β§ β p β S, | |
| a ^ N - b ^ N β p.asIdeal ^ depth p := by | |
| classical | |
| let Q (p : S) := π E β§Έ p.val.asIdeal ^ depth p.val | |
| let (p : S) : Finite (Q p) := | |
| Ring.HasFiniteQuotients.finiteQuotient | |
| (pow_ne_zero _ p.val.prime.ne_zero) | |
| let G := (p : S) β (Q p)Λ£ | |
| let ua : G := fun p => | |
| (Ideal.Quotient.isUnit_mk_pow_of_notMem p.val.asIdeal | |
| (ha p.val p.property)).unit | |
| let ub : G := fun p => | |
| (Ideal.Quotient.isUnit_mk_pow_of_notMem p.val.asIdeal | |
| (hb p.val p.property)).unit | |
| have hPow (g : G) (p : S) : g p ^ Nat.card G = 1 := | |
| congrFun (pow_card_eq_one' (x := g)) p | |
| refine β¨Nat.card G, Nat.card_pos, ?_β© | |
| intro p hp | |
| have hea := congrArg Units.val (hPow ua β¨p, hpβ©) | |
| have heb := congrArg Units.val (hPow ub β¨p, hpβ©) | |
| apply Ideal.Quotient.eq_zero_iff_mem.mp | |
| simp only [map_sub, map_pow] | |
| have hea' : Ideal.Quotient.mk (p.asIdeal ^ depth p) a ^ Nat.card G = 1 := by | |
| simpa only [Pi.pow_apply, Units.val_pow_eq_pow_val, Pi.one_apply, | |
| Units.val_one, ua, IsUnit.unit_spec] using hea | |
| have heb' : Ideal.Quotient.mk (p.asIdeal ^ depth p) b ^ Nat.card G = 1 := by | |
| simpa only [Pi.pow_apply, Units.val_pow_eq_pow_val, Pi.one_apply, | |
| Units.val_one, ub, IsUnit.unit_spec] using heb | |
| rw [hea', heb', sub_self] | |
| /-- The integral congruence becomes a valuation bound on the ratio. -/ | |
| lemma ratio_powers_approximate_one | |
| (S : Finset (HeightOneSpectrum (π E))) | |
| (depth : HeightOneSpectrum (π E) β β) | |
| (a b : π E) (hb0 : b β 0) | |
| (ha : β p β S, a β p.asIdeal) | |
| (hb : β p β S, b β p.asIdeal) : | |
| β N : β, 0 < N β§ β p β S, | |
| p.valuation E (((a : E) / (b : E)) ^ N - 1) β€ | |
| WithZero.exp (-(depth p : β€)) := by | |
| obtain β¨N, hN, hcongβ© := simultaneous_power_congruence S depth a b ha hb | |
| refine β¨N, hN, ?_β© | |
| intro p hp | |
| have hbE : (b : E) β 0 := by exact_mod_cast hb0 | |
| have hratio : ((a : E) / (b : E)) ^ N - 1 = | |
| ((a ^ N - b ^ N : π E) : E) / (b : E) ^ N := by | |
| push_cast | |
| rw [div_pow] | |
| field_simp | |
| have hbval : p.valuation E (b : E) = 1 := | |
| (p.valuation_eq_one_iff_notMem).mpr (hb p hp) | |
| rw [hratio, map_divβ, map_pow, hbval, one_pow, div_one, | |
| p.valuation_of_algebraMap] | |
| exact (p.intValuation_le_pow_iff_mem _ _).mpr (hcong p hp) | |
| /-- NormOneApproximation, conditional on the finiteness assertion of Finiteness. -/ | |
| theorem exists_norm_one_scalar | |
| [Algebra β E] [NumberField.IsCMField E] [IsGalois β E] | |
| (hFiniteness_classGroup_finite : Finite (ClassGroup (π E))) | |
| (w wbar : HeightOneSpectrum (π E)) | |
| (hconj : wbar.asIdeal = | |
| Ideal.map | |
| (NumberField.IsCMField.ringOfIntegersComplexConj E).toRingHom | |
| w.asIdeal) | |
| (hsplit : w β wbar) : | |
| β (r : EΛ£) (M : β), | |
| 0 < M β§ | |
| (r : E) * NumberField.IsCMField.complexConj E (r : E) = 1 β§ | |
| w.valuation E (r : E) = WithZero.exp (-(M : β€)) β§ | |
| wbar.valuation E (r : E) = WithZero.exp (M : β€) β§ | |
| (β p : HeightOneSpectrum (π E), | |
| p β w β p β wbar β p.valuation E (r : E) = 1) β§ | |
| (β (S : Finset (HeightOneSpectrum (π E))) | |
| (depth : HeightOneSpectrum (π E) β β), | |
| w β S β wbar β S β | |
| β N : β, 0 < N β§ | |
| β p β S, | |
| p.valuation E ((r : E) ^ N - 1) β€ | |
| WithZero.exp (-(depth p : β€))) := by | |
| obtain β¨M, a, hM, ha, hspanβ© := principal_prime_power hFiniteness_classGroup_finite w | |
| let b := NumberField.IsCMField.ringOfIntegersComplexConj E a | |
| have hb : b β 0 := by | |
| intro hz | |
| apply ha | |
| apply (NumberField.IsCMField.ringOfIntegersComplexConj E).injective | |
| simpa only [map_zero] using hz | |
| have hspanb : wbar.asIdeal ^ M = Ideal.span {b} := by | |
| rw [hconj, β Ideal.map_pow, hspan, Ideal.map_span, Set.image_singleton] | |
| rfl | |
| have haE : (a : E) β 0 := by exact_mod_cast ha | |
| have hbE : (b : E) β 0 := by exact_mod_cast hb | |
| let r : EΛ£ := Units.mk0 ((a : E) / (b : E)) (div_ne_zero haE hbE) | |
| have hca : NumberField.IsCMField.complexConj E (a : E) = (b : E) := rfl | |
| have hcb : NumberField.IsCMField.complexConj E (b : E) = (a : E) := by | |
| rw [β hca, NumberField.IsCMField.complexConj_apply_apply] | |
| have hwa := valuation_generator_self w M a ha hspan | |
| have hwb := valuation_generator_other wbar w M b hspanb hsplit | |
| have hwbara := valuation_generator_other w wbar M a hspan (Ne.symm hsplit) | |
| have hwbarb := valuation_generator_self wbar M b hb hspanb | |
| refine β¨r, M, hM, ?_, ?_, ?_, ?_, ?_β© | |
| Β· change (a : E) / (b : E) * | |
| NumberField.IsCMField.complexConj E ((a : E) / (b : E)) = 1 | |
| rw [map_divβ, hca, hcb] | |
| field_simp | |
| Β· change w.valuation E ((a : E) / (b : E)) = _ | |
| rw [map_divβ, w.valuation_of_algebraMap, w.valuation_of_algebraMap, | |
| hwa, hwb, div_one] | |
| Β· change wbar.valuation E ((a : E) / (b : E)) = _ | |
| rw [map_divβ, wbar.valuation_of_algebraMap, wbar.valuation_of_algebraMap, | |
| hwbara, hwbarb, one_div, WithZero.exp_neg, inv_inv] | |
| Β· intro p hpw hpwbar | |
| change p.valuation E ((a : E) / (b : E)) = 1 | |
| rw [map_divβ, p.valuation_of_algebraMap, p.valuation_of_algebraMap, | |
| valuation_generator_other w p M a hspan hpw, | |
| valuation_generator_other wbar p M b hspanb hpwbar, div_one] | |
| Β· intro S depth hwS hwbarS | |
| apply ratio_powers_approximate_one S depth a b hb | |
| Β· intro p hp | |
| apply p.intValuation_eq_one_iff.mp | |
| apply valuation_generator_other w p M a hspan | |
| rintro rfl | |
| exact hwS hp | |
| Β· intro p hp | |
| apply p.intValuation_eq_one_iff.mp | |
| apply valuation_generator_other wbar p M b hspanb | |
| rintro rfl | |
| exact hwbarS hp | |
| theorem exists_norm_one_scalar_unconditional | |
| [Algebra β E] [NumberField.IsCMField E] [IsGalois β E] | |
| (w wbar : HeightOneSpectrum (π E)) | |
| (hconj : wbar.asIdeal = | |
| Ideal.map | |
| (NumberField.IsCMField.ringOfIntegersComplexConj E).toRingHom | |
| w.asIdeal) | |
| (hsplit : w β wbar) : | |
| β (r : EΛ£) (M : β), | |
| 0 < M β§ | |
| (r : E) * NumberField.IsCMField.complexConj E (r : E) = 1 β§ | |
| w.valuation E (r : E) = WithZero.exp (-(M : β€)) β§ | |
| wbar.valuation E (r : E) = WithZero.exp (M : β€) β§ | |
| (β p : HeightOneSpectrum (π E), | |
| p β w β p β wbar β p.valuation E (r : E) = 1) β§ | |
| (β (S : Finset (HeightOneSpectrum (π E))) | |
| (depth : HeightOneSpectrum (π E) β β), | |
| w β S β wbar β S β | |
| β N : β, 0 < N β§ | |
| β p β S, | |
| p.valuation E ((r : E) ^ N - 1) β€ | |
| WithZero.exp (-(depth p : β€))) := by | |
| exact exists_norm_one_scalar | |
| (OAI.NumberTheory.ClassGroup.Finiteness.classGroup_finite E) w wbar hconj hsplit | |
| end | |
| end OAI.NumberTheory.CMField.NormOneApproximation.Construction | |