Download data/lean/OAI/AlgebraicGeometry/ComplexMultiplication/CommonCMField.lean from introvoyz045/math: direct link, hf CLI and curl.
- Browser
- Download file 7.52 kB
-
https://huggingface.co/datasets/introvoyz045/math/resolve/main/data/lean/OAI/AlgebraicGeometry/ComplexMultiplication/CommonCMField.lean
- Command line
-
hf download hf://datasets/introvoyz045/math/data/lean/OAI/AlgebraicGeometry/ComplexMultiplication/CommonCMField.lean
-
curl -L -o CommonCMField.lean https://huggingface.co/datasets/introvoyz045/math/resolve/main/data/lean/OAI/AlgebraicGeometry/ComplexMultiplication/CommonCMField.lean
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 | |