File size: 7,519 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
import OAI.AlgebraicGeometry.ComplexMultiplication.Decomposition
import Mathlib.FieldTheory.Normal.Closure

/-! # Common CM Field -/

namespace OAI.AlgebraicGeometry.ComplexMultiplication

noncomputable section

/-!
# A common Galois CM coefficient field

The compositum inside `β„‚` of the normal closures of a finite family of
number fields contains the images of all of their complex embeddings.
When the family is nonempty and consists of CM fields, this compositum is
CM: its restricted complex conjugation acts as conjugation under every
embedding, as can be checked on the generating CM subfields.
-/

open IntermediateField

variable {ΞΉ : Type*} (E : ΞΉ β†’ Type*) [βˆ€ i, Field (E i)] [βˆ€ i, Algebra β„š (E i)]

/-- The compositum of all conjugates of all fields in a family. -/
def CommonCMField.CM.conjugateCompositum : IntermediateField β„š β„‚ :=
  ⨆ i, normalClosure β„š (E i) β„‚

namespace CommonCMField.CM.conjugateCompositum

/-- Every complex embedding of a component lands in the compositum. -/
theorem fieldRange_le (i : ΞΉ) (Οƒ : E i →ₐ[β„š] β„‚) :
    Οƒ.fieldRange ≀ conjugateCompositum E :=
  Οƒ.fieldRange_le_normalClosure.trans (le_iSup (fun i => normalClosure β„š (E i) β„‚) i)

/-- An embedding of a component, with its codomain restricted to the common field. -/
def embedding (i : ΞΉ) (Οƒ : E i →ₐ[β„š] β„‚) : E i →ₐ[β„š] conjugateCompositum E :=
  Οƒ.codRestrict _ (fun x => fieldRange_le E i Οƒ ⟨x, rfl⟩)

@[simp]
theorem embedding_coe (i : ΞΉ) (Οƒ : E i →ₐ[β„š] β„‚) (x : E i) :
    (embedding E i Οƒ x : β„‚) = Οƒ x := rfl

/-- Maps from the common field are determined by the original embedding images. -/
theorem algHom_ext {L : Type*} [Field L] [Algebra β„š L]
    {f g : conjugateCompositum E →ₐ[β„š] L}
    (h : βˆ€ i Οƒ x, f (embedding E i Οƒ x) = g (embedding E i Οƒ x)) : f = g := by
  let J : IntermediateField β„š (conjugateCompositum E) :=
    { f.toRingHom.eqLocusField g.toRingHom with
      algebraMap_mem' := fun q => (f.commutes q).trans (g.commutes q).symm }
  have hle : conjugateCompositum E ≀ J.map (conjugateCompositum E).val := by
    apply iSup_le
    intro i
    apply normalClosure_le_iff.mpr
    intro Οƒ x hx
    obtain ⟨a, rfl⟩ := hx
    exact ⟨embedding E i Οƒ a, h i Οƒ a, rfl⟩
  ext x
  obtain ⟨y, hy, heq⟩ := hle x.property
  have hxy : y = x := Subtype.ext heq
  exact hxy β–Έ hy

variable [βˆ€ i, NumberField (E i)]

instance normal : Normal β„š (conjugateCompositum E) := by
  exact IntermediateField.normal_iSup β„š β„‚ _ (h := fun i =>
    (Algebra.IsAlgebraic.isNormalClosure_normalClosure
      (F := β„š) (K := E i) (L := β„‚) (fun _ => IsAlgClosed.splits _)).normal)

instance finiteDimensional [Finite ΞΉ] : FiniteDimensional β„š (conjugateCompositum E) :=
  IntermediateField.finiteDimensional_iSup_of_finite

instance numberField [Finite ΞΉ] : NumberField (conjugateCompositum E) :=
  NumberField.of_module_finite β„š _

instance isGalois : IsGalois β„š (conjugateCompositum E) := {}

/-- Complex conjugation restricted to the normal compositum. -/
def conjugation : Gal(conjugateCompositum E/β„š) :=
  (Complex.conjAe.restrictScalars β„š).restrictNormal (conjugateCompositum E)

@[simp]
theorem conjugation_coe (x : conjugateCompositum E) :
    (conjugation E x : β„‚) = star (x : β„‚) :=
  AlgEquiv.restrictNormal_commutes _ _ x

variable [βˆ€ i, NumberField.IsCMField (E i)]

/-- Conjugation restricts on each generating image to its intrinsic CM conjugation. -/
theorem conjugation_embedding (i : ΞΉ) (Οƒ : E i →ₐ[β„š] β„‚) (x : E i) :
    conjugation E (embedding E i Οƒ x) =
      embedding E i Οƒ (NumberField.IsCMField.complexConj (E i) x) := by
  apply Subtype.ext
  rw [conjugation_coe]
  exact (NumberField.IsCMField.complexEmbedding_complexConj
    (E i) Οƒ.toRingHom x).symm

/-- Every embedding sees the same conjugation on the compositum. -/
theorem embedding_conjugation (Ο† : conjugateCompositum E β†’+* β„‚)
    (x : conjugateCompositum E) :
    Ο† (conjugation E x) = star (Ο† x) := by
  let f : conjugateCompositum E →ₐ[β„š] β„‚ :=
    { Ο†.comp (conjugation E).toRingHom with
      commutes' := RingHom.map_rat_algebraMap _ }
  let g : conjugateCompositum E →ₐ[β„š] β„‚ :=
    { (starRingEnd β„‚).comp Ο† with
      commutes' := RingHom.map_rat_algebraMap _ }
  have heq : f = g := algHom_ext E (fun i Οƒ a => by
    change Ο† (conjugation E (embedding E i Οƒ a)) = star (Ο† (embedding E i Οƒ a))
    rw [conjugation_embedding]
    exact NumberField.IsCMField.complexEmbedding_complexConj (E i)
      (Ο†.comp (embedding E i Οƒ).toRingHom) a)
  exact congrArg (fun h : conjugateCompositum E →ₐ[β„š] β„‚ => h x) heq

theorem isConj_conjugation (Ο† : conjugateCompositum E β†’+* β„‚) :
    NumberField.ComplexEmbedding.IsConj Ο† (conjugation E) := by
  ext x
  exact (embedding_conjugation E Ο† x).symm

instance isTotallyComplex [Nonempty ΞΉ] :
    NumberField.IsTotallyComplex (conjugateCompositum E) := by
  let i : ΞΉ := Classical.arbitrary ΞΉ
  let Οƒ : E i →ₐ[β„š] β„‚ := IsAlgClosed.lift
  let : Algebra (E i) (conjugateCompositum E) := (embedding E i Οƒ).toAlgebra
  exact NumberField.isTotallyComplex_of_algebra (E i) _

/-- A nonempty compositum of conjugates of CM fields is itself CM. -/
instance isCMField [Nonempty ΞΉ] : NumberField.IsCMField (conjugateCompositum E) :=
  NumberField.IsCMField.of_forall_isConj _ (isConj_conjugation E)

end CommonCMField.CM.conjugateCompositum

/-- A finite family of CM fields has a common finite Galois CM field inside
`β„‚` containing every conjugate image. The family is allowed to be empty. -/
theorem CommonCMField.CM.exists_common_galois_cm_field [Finite ΞΉ] [βˆ€ i, NumberField (E i)]
    [βˆ€ i, NumberField.IsCMField (E i)] :
    βˆƒ K : IntermediateField β„š β„‚, NumberField K ∧ IsGalois β„š K ∧
      NumberField.IsCMField K ∧ βˆ€ i (Οƒ : E i →ₐ[β„š] β„‚), Οƒ.fieldRange ≀ K := by
  rcases isEmpty_or_nonempty ΞΉ with h | h
  Β· have := h
    let F := CyclotomicField 4 β„š
    have : IsCyclotomicExtension {4} β„š F := CyclotomicField.isCyclotomicExtension 4 β„š
    have : NumberField.IsCMField F :=
      IsCyclotomicExtension.Rat.isCMField F ⟨4, Set.mem_singleton 4, by norm_num⟩
    let K := CommonCMField.CM.conjugateCompositum (fun _ : Unit => F)
    refine ⟨K, inferInstance, inferInstance, inferInstance, ?_⟩
    exact fun i => isEmptyElim i
  Β· have := h
    exact ⟨CommonCMField.CM.conjugateCompositum E, inferInstance, inferInstance, inferInstance,
      CommonCMField.CM.conjugateCompositum.fieldRange_le E⟩

variable {U : Type*} [AddCommGroup U] [Module β„š U]
variable {H : WeightOne.CM.WeightOneHodgeStructure U} (D : Decomposition.CM.CMDecomposition H)

/-- The actual CM decomposition admits a common Galois CM coefficient field,
even when its summands have different fields or there are no summands. -/
theorem Decomposition.CM.CMDecomposition.exists_common_galois_cm_field :
    βˆƒ K : IntermediateField β„š β„‚, NumberField K ∧ IsGalois β„š K ∧
      NumberField.IsCMField K ∧
        βˆ€ i (Οƒ : (D.component i).field →ₐ[β„š] β„‚), Οƒ.fieldRange ≀ K := by
  let componentNumberFields : βˆ€ i, NumberField (D.component i).field :=
    fun i => (D.component i).cm.numberField
  let componentCMFields : βˆ€ i, NumberField.IsCMField (D.component i).field :=
    fun i => (D.component i).cm.cmField
  exact CommonCMField.CM.exists_common_galois_cm_field (fun i => (D.component i).field)

end

end OAI.AlgebraicGeometry.ComplexMultiplication