Download data/lean/OAI/AlgebraicGeometry/PELModuli/CMPoints/BlockDecomposition.lean from introvoyz045/math: direct link, hf CLI and curl.
- Browser
- Download file 8.49 kB
-
https://huggingface.co/datasets/introvoyz045/math/resolve/main/data/lean/OAI/AlgebraicGeometry/PELModuli/CMPoints/BlockDecomposition.lean
- Command line
-
hf download hf://datasets/introvoyz045/math/data/lean/OAI/AlgebraicGeometry/PELModuli/CMPoints/BlockDecomposition.lean
-
curl -L -o BlockDecomposition.lean https://huggingface.co/datasets/introvoyz045/math/resolve/main/data/lean/OAI/AlgebraicGeometry/PELModuli/CMPoints/BlockDecomposition.lean
8.49 kB
| import OAI.AlgebraicGeometry.PELModuli.CMPoints.BlocksProjectors | |
| /-! # Block Decomposition -/ | |
| namespace OAI.AlgebraicGeometry.PELModuli.CMPoints.BlockDecomposition | |
| noncomputable section | |
| /-! The split integral projectors give a product decomposition of actual | |
| torsion points on every test scheme, including nonreduced schemes. -/ | |
| open _root_.CategoryTheory _root_.AlgebraicGeometry | |
| open scoped _root_.CategoryTheory.MonObj | |
| variable {S : Scheme} {g : β} | |
| {E K : Type} [Field E] [NumberField E] [Algebra β E] | |
| [Field K] [NumberField K] {ΞΊ : K β+* β} {q : β} [Fact q.Prime] | |
| (j : Arithmetic.QadicChoice K ΞΊ q) (iota : E β+* K) (hsplit : j.HasSplitCoordinates iota) | |
| (A : AbelianModuli.HilbertConstruction.Abelian.Schemes.AbelianScheme g S) | |
| (Ο : AbelianModuli.ReferenceFamily.ActionData.IntegralAction (NumberField.RingOfIntegers E) A) | |
| include hsplit in | |
| theorem action_eq_of_coordinates (n : β) | |
| (b c : NumberField.RingOfIntegers E) | |
| (hbc : j.residueCoordinates iota n b = j.residueCoordinates iota n c) | |
| (T : Over S) (x : T βΆ A.scheme) (hx : x ^ (q ^ n) = 1) : | |
| x β« Ο.map b = x β« Ο.map c := by | |
| apply BlocksProjectors.action_eq_of_congruence A Ο b c (q ^ n) _ T x hx | |
| rw [Nat.cast_pow, β (hsplit n).2] | |
| change j.residueCoordinates iota n (b - c) = 0 | |
| rw [map_sub, hbc, sub_self] | |
| theorem projector_idempotent_on_torsion (n : β) (Ο : Gal(E/β)) | |
| (T : Over S) (x : T βΆ A.scheme) (hx : x ^ (q ^ n) = 1) : | |
| (x β« Ο.map (j.projector iota hsplit n Ο)) β« | |
| Ο.map (j.projector iota hsplit n Ο) = x β« Ο.map (j.projector iota hsplit n Ο) := by | |
| classical | |
| rw [Category.assoc, β Ο.map_mul] | |
| apply action_eq_of_coordinates j iota hsplit A Ο n _ _ _ T x hx | |
| rw [map_mul, j.projector_coordinates] | |
| ext Ο | |
| by_cases h : Ο = Ο <;> simp [h] | |
| theorem projector_orthogonal_on_torsion (n : β) (Ο Ο : Gal(E/β)) (h : Ο β Ο ) | |
| (T : Over S) (x : T βΆ A.scheme) (hx : x ^ (q ^ n) = 1) : | |
| (x β« Ο.map (j.projector iota hsplit n Ο)) β« | |
| Ο.map (j.projector iota hsplit n Ο ) = 1 := by | |
| classical | |
| rw [Category.assoc, β Ο.map_mul] | |
| have he : j.residueCoordinates iota n | |
| (j.projector iota hsplit n Ο * j.projector iota hsplit n Ο) = | |
| j.residueCoordinates iota n 0 := by | |
| rw [map_mul, j.projector_coordinates, j.projector_coordinates, map_zero] | |
| ext Ξ½ | |
| by_cases hΞ½ : Ξ½ = Ο | |
| Β· subst Ξ½ | |
| simp [h] | |
| Β· simp [hΞ½] | |
| rw [action_eq_of_coordinates j iota hsplit A Ο n _ 0 he T x hx, | |
| Ο.map_zero, MonObj.comp_one] | |
| def torsionProjection (n : β) (Ο : Gal(E/β)) (T : Over S) : | |
| A.torsionPoints (q ^ n) T β* BlocksProjectors.blockPoints A Ο (j.localCharacter iota Ο) n T where | |
| toFun x := β¨x.val β« Ο.map (j.projector iota hsplit n Ο), | |
| (BlocksProjectors.mem_block_iff_fixed j iota hsplit A Ο n Ο T _).mpr β¨by | |
| have hx : x.val ^ (q ^ n) = 1 := x.property | |
| rw [β MonObj.pow_comp, hx, MonObj.one_comp], | |
| projector_idempotent_on_torsion j iota hsplit A Ο n Ο T x.val x.propertyβ©β© | |
| map_one' := Subtype.ext (MonObj.one_comp _) | |
| map_mul' x y := Subtype.ext (MonObj.mul_comp x.val y.val _) | |
| theorem block_projector_self (n : β) (Ο : Gal(E/β)) (T : Over S) | |
| (x : BlocksProjectors.blockPoints A Ο (j.localCharacter iota Ο) n T) : | |
| x.val β« Ο.map (j.projector iota hsplit n Ο) = x.val := | |
| ((BlocksProjectors.mem_block_iff_fixed j iota hsplit A Ο n Ο T x.val).mp x.property).2 | |
| theorem block_projector_other (n : β) (Ο Ο : Gal(E/β)) (h : Ο β Ο ) | |
| (T : Over S) (x : BlocksProjectors.blockPoints A Ο (j.localCharacter iota Ο) n T) : | |
| x.val β« Ο.map (j.projector iota hsplit n Ο ) = 1 := by | |
| have hx := projector_orthogonal_on_torsion j iota hsplit A Ο n Ο Ο h T x.val x.property.1 | |
| rw [block_projector_self j iota hsplit A Ο n Ο T x] at hx | |
| exact hx | |
| omit [NumberField E] [Algebra β E] in | |
| theorem integralAction_sum_on_points {Idx : Type*} (s : Finset Idx) | |
| (b : Idx β NumberField.RingOfIntegers E) (T : Over S) (x : T βΆ A.scheme) : | |
| x β« Ο.map (β i β s, b i) = β i β s, x β« Ο.map (b i) := by | |
| classical | |
| induction s using Finset.induction_on with | |
| | empty => simp only [Finset.sum_empty, Finset.prod_empty, Ο.map_zero, MonObj.comp_one] | |
| | @insert i s hi ih => | |
| rw [Finset.sum_insert hi, Finset.prod_insert hi, Ο.map_add, MonObj.comp_mul, ih] | |
| theorem torsion_projectors_sum (n : β) (T : Over S) | |
| (x : T βΆ A.scheme) (hx : x ^ (q ^ n) = 1) : | |
| (β Ο : Gal(E/β), x β« Ο.map (j.projector iota hsplit n Ο)) = x := by | |
| classical | |
| rw [β integralAction_sum_on_points A Ο] | |
| have hs : j.residueCoordinates iota n (β Ο, j.projector iota hsplit n Ο) = | |
| j.residueCoordinates iota n 1 := by | |
| simp only [map_sum, j.projector_coordinates, map_one] | |
| ext Ο | |
| simp [Finset.sum_apply, Pi.single_apply] | |
| rw [action_eq_of_coordinates j iota hsplit A Ο n _ 1 hs T x hx, Ο.map_one, Category.comp_id] | |
| def assembleBlocks (n : β) (T : Over S) : | |
| (β Ο : Gal(E/β), BlocksProjectors.blockPoints A Ο (j.localCharacter iota Ο) n T) β* | |
| A.torsionPoints (q ^ n) T where | |
| toFun x := β¨β Ο, (x Ο).val, by | |
| change (β Ο, (x Ο).val) ^ (q ^ n) = 1 | |
| rw [β Finset.prod_pow] | |
| simp only [(x _).property.1, Finset.prod_const_one]β© | |
| map_one' := by apply Subtype.ext; exact Finset.prod_const_one | |
| map_mul' x y := by apply Subtype.ext; exact Finset.prod_mul_distrib | |
| theorem assemble_torsionProjections (n : β) (T : Over S) | |
| (x : A.torsionPoints (q ^ n) T) : | |
| assembleBlocks j iota A Ο n T (fun Ο => torsionProjection j iota hsplit A Ο n Ο T x) = x := by | |
| apply Subtype.ext | |
| exact torsion_projectors_sum j iota hsplit A Ο n T x.val x.property | |
| theorem torsionProjection_assemble (n : β) (T : Over S) | |
| (x : β Ο : Gal(E/β), BlocksProjectors.blockPoints A Ο (j.localCharacter iota Ο) n T) (Ο : Gal(E/β)) : | |
| torsionProjection j iota hsplit A Ο n Ο T (assembleBlocks j iota A Ο n T x) = x Ο := by | |
| classical | |
| apply Subtype.ext | |
| let f : (T βΆ A.scheme) β* (T βΆ A.scheme) := { | |
| toFun a := a β« Ο.map (j.projector iota hsplit n Ο ) | |
| map_one' := MonObj.one_comp _ | |
| map_mul' a b := MonObj.mul_comp a b _ } | |
| change f (β Ο, (x Ο).val) = (x Ο ).val | |
| rw [map_prod] | |
| rw [Finset.prod_eq_single Ο ] | |
| Β· exact block_projector_self j iota hsplit A Ο n Ο T (x Ο ) | |
| Β· intro Ο _ hΟ | |
| exact block_projector_other j iota hsplit A Ο n Ο Ο hΟ T (x Ο) | |
| Β· simp | |
| /-- The product decomposition is an isomorphism of actual groups of | |
| torsion points, uniformly over every test scheme. -/ | |
| def torsionBlockEquiv (n : β) (T : Over S) : | |
| A.torsionPoints (q ^ n) T β* | |
| (β Ο : Gal(E/β), BlocksProjectors.blockPoints A Ο (j.localCharacter iota Ο) n T) where | |
| toFun x Ο := torsionProjection j iota hsplit A Ο n Ο T x | |
| invFun := assembleBlocks j iota A Ο n T | |
| left_inv := assemble_torsionProjections j iota hsplit A Ο n T | |
| right_inv x := funext (torsionProjection_assemble j iota hsplit A Ο n T x) | |
| map_mul' x y := funext (fun Ο => (torsionProjection j iota hsplit A Ο n Ο T).map_mul x y) | |
| def productBlockFunctor (n : β) : (Over S)α΅α΅ β₯€ GrpCat where | |
| obj T := GrpCat.of (β Ο : Gal(E/β), BlocksProjectors.blockPoints A Ο (j.localCharacter iota Ο) n T.unop) | |
| map f := GrpCat.ofHom { | |
| toFun x Ο := BlocksProjectors.blockPullback A Ο (j.localCharacter iota Ο) n f.unop (x Ο) | |
| map_one' := funext (fun Ο => (BlocksProjectors.blockPullback A Ο (j.localCharacter iota Ο) n f.unop).map_one) | |
| map_mul' x y := funext (fun Ο => | |
| (BlocksProjectors.blockPullback A Ο (j.localCharacter iota Ο) n f.unop).map_mul (x Ο) (y Ο)) } | |
| map_id T := by | |
| apply GrpCat.hom_ext | |
| apply MonoidHom.ext | |
| intro x | |
| funext Ο | |
| exact Subtype.ext (Category.id_comp (x Ο).val) | |
| map_comp f h := by | |
| apply GrpCat.hom_ext | |
| apply MonoidHom.ext | |
| intro x | |
| funext Ο | |
| exact Subtype.ext (Category.assoc _ _ (x Ο).val) | |
| /-- The product decomposition is natural on the entire big test category. -/ | |
| def torsionBlockIso (n : β) : | |
| A.torsionFunctor (q ^ n) β productBlockFunctor j iota A Ο n := | |
| NatIso.ofComponents (fun T => (torsionBlockEquiv j iota hsplit A Ο n T.unop).toGrpIso) (by | |
| intro T U f | |
| apply GrpCat.hom_ext | |
| apply MonoidHom.ext | |
| intro x | |
| funext Ο | |
| exact Subtype.ext (Category.assoc _ _ _)) | |
| end | |
| end OAI.AlgebraicGeometry.PELModuli.CMPoints.BlockDecomposition | |