File size: 6,349 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
import OAI.AlgebraicGeometry.PELModuli.IntegralModel.CM.ActionGeneratorFaithfulness
import Mathlib.FieldTheory.Minpoly.IsIntegrallyClosed

/-! # Action From Generator -/

namespace OAI.AlgebraicGeometry.PELModuli.IntegralModel.CM

noncomputable section

section

/-! A root of the integral primitive generator's minimal polynomial satisfies
all its integral polynomial relations. In particular the fixed reconstruction
polynomials satisfy the unit, product, and generator identities needed to
recover an integral action after division by the fixed conductor. -/

open _root_.Polynomial

variable {E : Type} [Field E] [NumberField E] [Algebra ℚ E] [NumberField.IsCMField E]
  (D : GeneratorReconstruction.CMIntegralGeneratorData E) {R : Type*} [Ring R] (u : R)
  (hu : aeval u (minpoly ℤ (D.generator : E)) = 0)

include hu

theorem GeneratorReconstruction.CMIntegralGeneratorData.polynomial_relation_transfer
    {p q : ℤ[X]} (h : aeval (D.generator : E) p = aeval (D.generator : E) q) :
    aeval u p = aeval u q := by
  have hz : aeval (D.generator : E) (p - q) = 0 := by rw [map_sub, h, sub_self]
  have hd := minpoly.isIntegrallyClosed_dvd D.generator.isIntegral_coe hz
  have he := aeval_eq_zero_of_dvd_aeval_eq_zero hd hu
  rwa [map_sub, sub_eq_zero] at he

theorem GeneratorReconstruction.CMIntegralGeneratorData.reconstruction_unit_at_root :
    aeval u (D.polynomial 1) = (D.conductor : R) := by
  have h := D.polynomial_relation_transfer u hu
    (p := D.polynomial 1) (q := C (D.conductor : ℤ)) (by
      rw [D.reconstruction, aeval_C]
      simp)
  simpa only [aeval_C, Int.cast_natCast, map_natCast] using h

theorem GeneratorReconstruction.CMIntegralGeneratorData.reconstruction_mul_at_root
    (a b : NumberField.RingOfIntegers E) :
    (D.conductor : R) * aeval u (D.polynomial (a * b)) =
      aeval u (D.polynomial a) * aeval u (D.polynomial b) := by
  have h := D.polynomial_relation_transfer u hu
    (p := C (D.conductor : ℤ) * D.polynomial (a * b))
    (q := D.polynomial a * D.polynomial b) (by
      simp only [map_mul, map_natCast, D.reconstruction]
      ring)
  simpa only [map_mul, aeval_C, map_natCast, Int.cast_natCast] using h

theorem GeneratorReconstruction.CMIntegralGeneratorData.reconstruction_generator_at_root :
    aeval u (D.polynomial D.generator) = (D.conductor : R) * u := by
  have h := D.polynomial_relation_transfer u hu
    (p := D.polynomial D.generator) (q := C (D.conductor : ℤ) * X) (by
      simp only [D.reconstruction, map_mul, aeval_X, map_natCast])
  simpa only [map_mul, aeval_C, aeval_X, map_natCast, Int.cast_natCast] using h

end

/-! Reconstruct the entire integral CM action from one primitive generator.
Only its minimal-polynomial equation and division of finitely many fixed
polynomials by the conductor are required. Ring identities are proved. -/

open _root_.Polynomial _root_.Module

variable {E : Type} [Field E] [NumberField E] [Algebra ℚ E] [NumberField.IsCMField E]
  (D : GeneratorReconstruction.CMIntegralGeneratorData E) {R : Type*} [Ring R] (u : R)
  (hu : aeval u (minpoly ℤ (D.generator : E)) = 0)
  (hc : Function.Injective (fun r : R => (D.conductor : R) * r))

def GeneratorReconstruction.CMIntegralGeneratorData.ringActionOfPolynomialDivision
    (v : NumberField.RingOfIntegers E →ₗ[ℤ] R)
    (hv : ∀ a, (D.conductor : R) * v a = aeval u (D.polynomial a)) :
    NumberField.RingOfIntegers E →+* R where
  toFun := v
  map_zero' := map_zero v
  map_add' := map_add v
  map_one' := by
    apply hc
    change (D.conductor : R) * v 1 = (D.conductor : R) * 1
    rw [hv, D.reconstruction_unit_at_root u hu, mul_one]
  map_mul' a b := by
    apply hc
    apply hc
    change (D.conductor : R) * ((D.conductor : R) * v (a * b)) =
      (D.conductor : R) * ((D.conductor : R) * (v a * v b))
    rw [hv, D.reconstruction_mul_at_root u hu, ← hv a, ← hv b]
    calc
      (D.conductor : R) * v a * ((D.conductor : R) * v b) =
          (D.conductor : R) * (v a * ((D.conductor : R) * v b)) := mul_assoc _ _ _
      _ = (D.conductor : R) * ((v a * (D.conductor : R)) * v b) :=
        congrArg (fun z => (D.conductor : R) * z) (mul_assoc _ _ _).symm
      _ = (D.conductor : R) * (((D.conductor : R) * v a) * v b) := by
        rw [← Nat.cast_comm D.conductor (v a)]
      _ = (D.conductor : R) * ((D.conductor : R) * (v a * v b)) := by rw [mul_assoc]

theorem GeneratorReconstruction.CMIntegralGeneratorData.ringActionOfPolynomialDivision_generator
    (v : NumberField.RingOfIntegers E →ₗ[ℤ] R)
    (hv : ∀ a, (D.conductor : R) * v a = aeval u (D.polynomial a)) :
    D.ringActionOfPolynomialDivision u hu hc v hv D.generator = u := by
  apply hc
  exact (hv D.generator).trans (D.reconstruction_generator_at_root u hu)

theorem GeneratorReconstruction.CMIntegralGeneratorData.basis_division_extends
    {ι : Type*} (b : Basis ι ℤ (NumberField.RingOfIntegers E)) (v : ι → R)
    (hv : ∀ i, (D.conductor : R) * v i = aeval u (D.polynomial (b i))) :
    ∀ a, (D.conductor : R) * Finite.Actions.basisExtension b v a = aeval u (D.polynomial a) := by
  let L := Finite.Actions.basisExtension b v
  have he : (D.conductor : ℤ) • L = (aeval u : ℤ[X] →ₐ[ℤ] R).toLinearMap.comp D.polynomial := by
    apply b.ext
    intro i
    simpa only [L, LinearMap.smul_apply, Finite.Actions.basisExtension_basis, zsmul_eq_mul,
      Int.cast_natCast, LinearMap.comp_apply, AlgHom.toLinearMap_apply] using hv i
  intro a
  have h := LinearMap.congr_fun he a
  simpa only [LinearMap.smul_apply, zsmul_eq_mul, Int.cast_natCast,
    LinearMap.comp_apply, AlgHom.toLinearMap_apply] using h

include hu hc in
theorem GeneratorReconstruction.CMIntegralGeneratorData.existsUnique_ring_action_of_basis_division
    {ι : Type*} (b : Basis ι ℤ (NumberField.RingOfIntegers E)) (v : ι → R)
    (hv : ∀ i, (D.conductor : R) * v i = aeval u (D.polynomial (b i))) :
    ∃! ρ : NumberField.RingOfIntegers E →+* R, ρ D.generator = u := by
  let h := D.basis_division_extends u b v hv
  let ρ := D.ringActionOfPolynomialDivision u hu hc (Finite.Actions.basisExtension b v) h
  have hρ : ρ D.generator = u := D.ringActionOfPolynomialDivision_generator u hu hc _ h
  refine ⟨ρ, hρ, fun σ hσ => ?_⟩
  exact D.ring_action_eq_of_generator σ ρ hc (hσ.trans hρ.symm)

end

end OAI.AlgebraicGeometry.PELModuli.IntegralModel.CM