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