File size: 8,001 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
import Mathlib

/-! # Arithmetic -/

namespace OAI.AlgebraicGeometry.PELModuli.CMPoints.Arithmetic

noncomputable section

section

/-!
Arithmetic choices for CMPoints. The completion is an actual adic completion,
and the comparison with Q_q commutes with the embeddings in algebraic
closures. Integral embeddings are specified by a commuting square, not by
an ordinary-reduction condition. Existence remains a theorem conclusion.
-/

open scoped Classical

open _root_.NumberField IsDedekindDomain

def SplitsCompletelyAt (K : Type*) [Field K] [NumberField K] (q : β„•) : Prop :=
  Nonempty ((RingOfIntegers K β§Έ
    Ideal.span ({(q : RingOfIntegers K)} : Set (RingOfIntegers K))) ≃+*
      (Fin (Module.finrank β„š K) β†’ ZMod q))

/-- CM conjugation, explicitly restricted to rational scalars. -/
def rationalConjugation (E : Type*) [Field E] [NumberField E] [Algebra β„š E]
    [NumberField.IsCMField E] : Gal(E/β„š) :=
  (NumberField.IsCMField.complexConj E).restrictScalars β„š

/-- A chosen embedding into Qqbar, with the chosen completion literally
identified with Q_q. None of the fields asserts ordinary reduction. -/
structure QadicChoice (K : Type) [Field K] [NumberField K]
    (ΞΊ : K β†’+* β„‚) (q : β„•) [Fact q.Prime] where
  complexClosure : AlgebraicClosure β„š β†’+* β„‚
  fieldInClosure : K β†’+* AlgebraicClosure β„š
  complex_compatibility : complexClosure.comp fieldInClosure = ΞΊ
  iota : AlgebraicClosure β„š β†’+* AlgebraicClosure (Padic q)
  prime : HeightOneSpectrum (RingOfIntegers K)
  liesOver : (q : RingOfIntegers K) ∈ prime.asIdeal
  completion : prime.adicCompletion K ≃+* Padic q
  completion_continuous : Continuous completion
  completion_inverse_continuous : Continuous completion.symm
  closure_compatibility :
    iota.comp fieldInClosure =
      (algebraMap (Padic q) (AlgebraicClosure (Padic q))).comp
        (completion.toRingHom.comp (NumberField.FinitePlace.embedding prime))
  integralEmbedding : RingOfIntegers K β†’+* PadicInt q
  integral_compatibility :
    PadicInt.Coe.ringHom.comp integralEmbedding =
      (completion.toRingHom.comp (NumberField.FinitePlace.embedding prime)).comp
        (algebraMap (RingOfIntegers K) K)

namespace QadicChoice

variable {K : Type} [Field K] [NumberField K] {ΞΊ : K β†’+* β„‚}
  {q : β„•} [Fact q.Prime] (j : QadicChoice K ΞΊ q)

def residue : RingOfIntegers K β†’+* ZMod q :=
  PadicInt.toZMod.comp j.integralEmbedding

def localCharacter {E : Type} [Field E] [NumberField E] [Algebra β„š E] (iota : E β†’+* K)
    (Ο„ : E ≃ₐ[β„š] E) : RingOfIntegers E β†’+* PadicInt q :=
  j.integralEmbedding.comp
    (NumberField.RingOfIntegers.mapRingHom (iota.comp Ο„.toRingHom))

def residueCharacter {E : Type} [Field E] [NumberField E] [Algebra β„š E] (iota : E β†’+* K)
    (Ο„ : E ≃ₐ[β„š] E) (n : β„•) : RingOfIntegers E β†’+* ZMod (q ^ n) :=
  (PadicInt.toZModPow n).comp (j.localCharacter iota Ο„)

theorem residueCharacter_compatible {E : Type} [Field E] [NumberField E] [Algebra β„š E]
    (iota : E β†’+* K) (Ο„ : E ≃ₐ[β„š] E) (m n : β„•) (h : m ≀ n) :
    (ZMod.castHom (pow_dvd_pow q h) (ZMod (q ^ m))).comp
      (j.residueCharacter iota Ο„ n) = j.residueCharacter iota Ο„ m := by
  rw [QadicChoice.residueCharacter, ← RingHom.comp_assoc, PadicInt.zmod_cast_comp_toZModPow m n h]
  rfl

/-- The actual prime of E determined by iota composed with Ο„. -/
def place {E : Type} [Field E] [NumberField E] [Algebra β„š E] (iota : E β†’+* K)
    (Ο„ : Gal(E/β„š)) : HeightOneSpectrum (RingOfIntegers E) where
  asIdeal := RingHom.ker (PadicInt.toZMod.comp (j.localCharacter iota Ο„))
  isPrime := RingHom.ker_isPrime _
  ne_bot := by
    intro h
    have hq : (q : RingOfIntegers E) ∈
        RingHom.ker (PadicInt.toZMod.comp (j.localCharacter iota Ο„)) := by
      change (PadicInt.toZMod.comp (j.localCharacter iota Ο„)) q = 0
      simp
    rw [h, Ideal.mem_bot] at hq
    exact (Nat.cast_ne_zero.mpr (Fact.out : q.Prime).ne_zero) hq

def residueCoordinates {E : Type} [Field E] [NumberField E] [Algebra β„š E]
    (iota : E β†’+* K) (n : β„•) : RingOfIntegers E β†’+* (Gal(E/β„š) β†’ ZMod (q ^ n)) where
  toFun a Ο„ := j.residueCharacter iota Ο„ n a
  map_one' := by ext Ο„; exact map_one _
  map_mul' a b := by ext Ο„; exact map_mul _ a b
  map_zero' := by ext Ο„; exact map_zero _
  map_add' a b := by ext Ο„; exact map_add _ a b

/-- Literal splitting modulo every q-power, with the embedding labels fixed.
This is an arithmetic conclusion, never a hypothesis about ordinary fibers. -/
def HasSplitCoordinates {E : Type} [Field E] [NumberField E] [Algebra β„š E]
    (iota : E β†’+* K) : Prop :=
  βˆ€ n : β„•, Function.Surjective (j.residueCoordinates iota n) ∧
    RingHom.ker (j.residueCoordinates iota n) =
      Ideal.span ({(q ^ n : RingOfIntegers E)} : Set (RingOfIntegers E))

def projector {E : Type} [Field E] [NumberField E] [Algebra β„š E]
    (iota : E β†’+* K) (hsplit : j.HasSplitCoordinates iota)
    (n : β„•) (Ο„ : Gal(E/β„š)) : RingOfIntegers E :=
  ((hsplit n).1 (Pi.single Ο„ 1)).choose

theorem projector_coordinates {E : Type} [Field E] [NumberField E] [Algebra β„š E]
    (iota : E β†’+* K) (hsplit : j.HasSplitCoordinates iota)
    (n : β„•) (Ο„ : Gal(E/β„š)) :
    j.residueCoordinates iota n (j.projector iota hsplit n Ο„) = Pi.single Ο„ 1 :=
  ((hsplit n).1 (Pi.single Ο„ 1)).choose_spec

end QadicChoice

/-- The exact SplitPrimes input, as a named proposition rather than a theorem stub. -/
def SplitPrimesInput : Prop :=
  βˆ€ (L : Type) [Field L] [NumberField L] [IsGalois β„š L]
    (excluded : Finset β„•),
    Set.Infinite {q : β„• | q.Prime ∧ q βˆ‰ excluded ∧ SplitsCompletelyAt L q}

theorem exists_split_prime_above (hSplitPrimes : SplitPrimesInput)
    (L : Type) [Field L] [NumberField L] [IsGalois β„š L]
    (excluded : Finset β„•) (bound : β„•) :
    βˆƒ q : β„•, q.Prime ∧ bound < q ∧ q βˆ‰ excluded ∧ SplitsCompletelyAt L q := by
  obtain ⟨q, hq, hbound⟩ := Set.infinite_iff_exists_gt.mp (hSplitPrimes L excluded) bound
  exact ⟨q, hq.1, hbound, hq.2⟩

end

/-! The exact kernel is forced by surjectivity and the actual cardinality
of the ring of integers modulo an integer. -/

open _root_.NumberField

theorem coordinate_kernel_of_surjective
    {E : Type} [Field E] [NumberField E] [Algebra β„š E] [IsGalois β„š E]
    (m : β„•) (hm : m β‰  0)
    (Ο† : RingOfIntegers E β†’+* (Gal(E/β„š) β†’ ZMod m))
    (hφ : Function.Surjective φ) :
    RingHom.ker Ο† = Ideal.span ({(m : RingOfIntegers E)} : Set (RingOfIntegers E)) := by
  let : NeZero m := ⟨hm⟩
  let I : Ideal (RingOfIntegers E) := Ideal.span {(m : RingOfIntegers E)}
  have hI : I ≀ RingHom.ker Ο† := by
    apply Ideal.span_le.mpr
    intro x hx
    obtain rfl := Set.mem_singleton_iff.mp hx
    change Ο† (m : RingOfIntegers E) = 0
    ext Ο„
    simp
  let H (a : RingOfIntegers E) (ha : a ∈ I) : Ο† a = 0 := hI ha
  let F := Ideal.Quotient.lift I Ο† H
  have hcard : Nat.card (RingOfIntegers E β§Έ I) = m ^ Module.finrank β„š E := by
    have h := Ideal.absNorm_span_natCast (S := RingOfIntegers E) m
    rw [RingOfIntegers.rank] at h
    have hA : (inferInstance : Algebra β„š E) =
        (DivisionRing.toRatAlgebra : Algebra β„š E) := Subsingleton.elim _ _
    have hdim := congrArg (fun A : Algebra β„š E =>
      @Module.finrank β„š E _ _ (@Algebra.toModule β„š E _ _ A)) hA
    rw [hdim]
    exact h
  let : Finite (RingOfIntegers E β§Έ I) :=
    Nat.finite_of_card_ne_zero (hcard β–Έ pow_ne_zero _ hm)
  have htarget : Nat.card (Gal(E/β„š) β†’ ZMod m) = m ^ Module.finrank β„š E := by
    rw [Nat.card_fun, Nat.card_eq_fintype_card (Ξ± := ZMod m), ZMod.card,
      IsGalois.card_aut_eq_finrank]
  have hsurj : Function.Surjective F := Ideal.Quotient.lift_surjective_of_surjective I H hφ
  have hinj : Function.Injective F :=
    ((Nat.bijective_iff_surjective_and_card F).mpr
      ⟨hsurj, hcard.trans htarget.symm⟩).1
  exact (Ideal.injective_lift_iff H).mp hinj

end

end OAI.AlgebraicGeometry.PELModuli.CMPoints.Arithmetic