math / data /lean /OAI /NumberTheory /CMField /NormOneApproximation.lean
introvoyz045's picture
Migrated from GitHub
4a56cd6 verified
Raw History Blame Contribute Delete
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