introvoyz045's picture
Migrated from GitHub
4a56cd6 verified
Raw History Blame Contribute Delete
7.52 kB
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