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
|