File size: 10,381 Bytes
4a56cd6
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
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