File size: 6,664 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
import OAI.Geometry.ComplexBall.ArithmeticQuotientEquationsData
import OAI.NumberTheory.ArithmeticGroups.Lattice

/-! # Levels -/

namespace OAI.Geometry.ComplexBall.Levels.ArithmeticQuotient

noncomputable section

/-! The exact matrix principal levels in ArithmeticQuotient agree with the full-lattice
conditions needed to apply the supplied TorsionFreeLevel proposition. -/

open scoped BigOperators Classical
open OAI.Geometry.ComplexBall.ArithmeticQuotientEquationsData

variable {E : Type*} [Field E] [NumberField E] [Algebra β„š E]
  [NumberField.IsCMField E]

/-- The supplied first TorsionFreeLevel proposition, kept as an explicit input. -/
def TorsionFreeLevelsInput (E : Type*) [Field E] [NumberField E] [Algebra β„š E]
    [NumberField.IsCMField E] : Prop :=
  βˆ€ (b : E) (Ξ› : Submodule β„€ (ArithmeticQuotientEquationsData.Vec E)), NumberTheory.ArithmeticGroups.Data.CongruenceLevel.FullStableLattice Ξ› β†’
    βˆ€ Nβ‚€ : β„•, 0 < Nβ‚€ β†’
      βˆƒ N : β„•, 3 ≀ N ∧ Nβ‚€ ∣ N ∧
        βˆ€ M : β„•, 0 < M β†’ N ∣ M β†’
          βˆ€ g : ArithmeticQuotientEquationsData.Vec E ≃ₗ[E] ArithmeticQuotientEquationsData.Vec E,
            NumberTheory.ArithmeticGroups.Data.CongruenceLevel.PrincipalLevel b Ξ› M g β†’
            βˆ€ k : β„•, 0 < k β†’ g ^ k = 1 β†’ g = 1

omit [NumberField E] [Algebra β„š E] [NumberField.IsCMField E] in
lemma integral_adjugate (g : ArithmeticQuotientEquationsData.Mat E) (hg : βˆ€ i j, IsIntegral β„€ (g i j)) :
    βˆ€ i j, IsIntegral β„€ (g.adjugate i j) := by
  let A : ArithmeticQuotientEquationsData.Mat (NumberField.RingOfIntegers E) := fun i j => ⟨g i j, hg i j⟩
  have hm := (algebraMap (NumberField.RingOfIntegers E) E).map_adjugate A
  intro i j
  have hij := congrArg (fun M : ArithmeticQuotientEquationsData.Mat E => M i j) hm
  change (A.adjugate i j : E) = g.adjugate i j at hij
  rw [← hij]
  exact (A.adjugate i j).property

omit [NumberField E] [Algebra β„š E] [NumberField.IsCMField E] in
lemma integral_mulVec (g : ArithmeticQuotientEquationsData.Mat E) (hg : βˆ€ i j, IsIntegral β„€ (g i j))
    (x : ArithmeticQuotientEquationsData.Vec E) (hx : βˆ€ i, IsIntegral β„€ (x i)) :
    βˆ€ i, IsIntegral β„€ (g.mulVec x i) := by
  intro i
  change IsIntegral β„€ (βˆ‘ j, g i j * x j)
  exact IsIntegral.sum _ (fun j _ => (hg i j).mul (hx j))

omit [Algebra β„š E] in
lemma principal_entries_integral (b : E) (N : β„•) (g : ArithmeticQuotientEquationsData.Mat E)
    (hg : ArithmeticQuotientEquationsData.principalLevel b N g) : βˆ€ i j, IsIntegral β„€ (g i j) := by
  obtain ⟨B, hB⟩ := hg.2.2
  intro i j
  have hi : IsIntegral β„€ ((1 : ArithmeticQuotientEquationsData.Mat E) i j) := by
    by_cases h : i = j
    Β· simpa only [Matrix.one_apply, ite_eq_left h] using (isIntegral_one : IsIntegral β„€ (1 : E))
    Β· simpa only [Matrix.one_apply, ite_eq_right h] using (isIntegral_zero : IsIntegral β„€ (0 : E))
  have hn : IsIntegral β„€ (N : E) := isIntegral_natCast N
  rw [(sub_eq_iff_eq_add).mp (hB i j)]
  exact (hn.mul (B i j).property).add hi

omit [Algebra β„š E] in
lemma matrixPrincipalLevel_to_lattice (b : E) (N : β„•) (g : ArithmeticQuotientEquationsData.Mat E)
    (hg : ArithmeticQuotientEquationsData.principalLevel b N g) :
    NumberTheory.ArithmeticGroups.Data.CongruenceLevel.PrincipalLevel b (NumberTheory.ArithmeticGroups.Lattice.CongruenceLevel.standardLattice (E := E)) N
      (Matrix.SpecialLinearGroup.toLin' (⟨g, hg.1⟩ : ArithmeticQuotientEquationsData.SL E)) := by
  let s : ArithmeticQuotientEquationsData.SL E := ⟨g, hg.1⟩
  have hint := principal_entries_integral b N g hg
  refine ⟨hg.2.1, ?_, ?_⟩
  Β· intro x
    constructor
    Β· intro hx
      exact (NumberTheory.ArithmeticGroups.Lattice.CongruenceLevel.mem_standardLattice _).mpr
        (integral_mulVec g hint x ((NumberTheory.ArithmeticGroups.Lattice.CongruenceLevel.mem_standardLattice _).mp hx))
    Β· intro hx
      have hinv := integral_mulVec g.adjugate (integral_adjugate g hint)
        (g.mulVec x) ((NumberTheory.ArithmeticGroups.Lattice.CongruenceLevel.mem_standardLattice _).mp hx)
      have hc : g.adjugate.mulVec (g.mulVec x) = x := by
        change Matrix.SpecialLinearGroup.toLin' s⁻¹
          (Matrix.SpecialLinearGroup.toLin' s x) = x
        rw [← LinearEquiv.mul_apply, ← map_mul, inv_mul_cancel, map_one]
        rfl
      rw [hc] at hinv
      exact (NumberTheory.ArithmeticGroups.Lattice.CongruenceLevel.mem_standardLattice _).mpr hinv
  Β· intro x hx
    obtain ⟨B, hB⟩ := hg.2.2
    let B' : ArithmeticQuotientEquationsData.Mat E := fun i j => (B i j : E)
    refine ⟨B'.mulVec x, ?_, ?_⟩
    Β· exact (NumberTheory.ArithmeticGroups.Lattice.CongruenceLevel.mem_standardLattice _).mpr
        (integral_mulVec B' (fun i j => (B i j).property) x
          ((NumberTheory.ArithmeticGroups.Lattice.CongruenceLevel.mem_standardLattice _).mp hx))
    Β· have hm : g - 1 = (N : E) β€’ B' := by
        ext i j
        exact hB i j
      change g.mulVec x - x = (N : β„€) β€’ B'.mulVec x
      calc
        g.mulVec x - x = (g - 1).mulVec x := by rw [Matrix.sub_mulVec, Matrix.one_mulVec]
        _ = ((N : E) β€’ B').mulVec x := by rw [hm]
        _ = (N : β„€) β€’ B'.mulVec x := by
          rw [Matrix.smul_mulVec]
          ext i
          simp [smul_eq_mul]

/-- Arbitrarily deep torsion-free levels in the exact matrix formulation. -/
theorem matrix_levels_torsion_free (hTorsionFreeLevel : TorsionFreeLevelsInput E)
    (b : E) (Nβ‚€ : β„•) (hNβ‚€ : 0 < Nβ‚€) :
    βˆƒ N : β„•, 0 < N ∧ Nβ‚€ ∣ N ∧
      βˆ€ g : ArithmeticQuotientEquationsData.Mat E, ArithmeticQuotientEquationsData.principalLevel b N g β†’
        βˆ€ k : β„•, 0 < k β†’ g ^ k = 1 β†’ g = 1 := by
  obtain ⟨N, hN, hdiv, ht⟩ := hTorsionFreeLevel b (NumberTheory.ArithmeticGroups.Lattice.CongruenceLevel.standardLattice (E := E))
    NumberTheory.ArithmeticGroups.Lattice.CongruenceLevel.standardLattice_full_stable Nβ‚€ hNβ‚€
  refine ⟨N, by omega, hdiv, ?_⟩
  intro g hg k hk hpow
  let s : ArithmeticQuotientEquationsData.SL E := ⟨g, hg.1⟩
  have hspow : s ^ k = 1 := Subtype.ext hpow
  have hlpow : (Matrix.SpecialLinearGroup.toLin' s) ^ k = 1 := by
    simpa only [map_pow, map_one] using
      congrArg Matrix.SpecialLinearGroup.toLin' hspow
  have he := ht N (by omega) (dvd_refl N) (Matrix.SpecialLinearGroup.toLin' s)
    (matrixPrincipalLevel_to_lattice b N g hg) k hk hlpow
  have hs : s = 1 := Matrix.SpecialLinearGroup.toLin'_injective (by simpa using he)
  exact congrArg (fun a : ArithmeticQuotientEquationsData.SL E => (a : ArithmeticQuotientEquationsData.Mat E)) hs

end

end OAI.Geometry.ComplexBall.Levels.ArithmeticQuotient