AlgebraicAnalysis/Module/FilteredTwoTermTotalActions.lean

AlgebraicAnalysis library · bbbbf3fc358ca8100b158cec4cf47f336ab70163

1 module
2 public import AlgebraicAnalysis.Module.FilteredTwoTermTotalPages
3 
4 @[expose] public section
5 
6 /-!
7 # Total direct-sum actions on filtered two-term pages
8 
9 This file packages the source and target page actions of a filtered operator
10 into maps on the total direct sums.  The index shift is part of the map: an
11 operator of degree `d` sends the summand at `p` to the summand at `p - d`.
12 -/
13 
14 namespace AlgebraicAnalysis.FilteredTwoTermPages
15 
16 universe u v
17 
18 variable {k : Type u} [Ring k]
19 variable {M : Type v} [AddCommGroup M] [Module k M]
20 
21 namespace FilteredTwoTerm
22 
23 variable (K : FilteredTwoTerm k M)
24 
25 namespace PageOperator
26 
27 variable {K} {d : ℤ} (P : K.PageOperator d)
28 
29 private theorem target_lof_transport (r : ℕ) {p q : ℤ} (h : p = q)
30     (x : K.TargetPage r p) :
31     DirectSum.lof k ℤ (fun i : ℤ => K.TargetPage r i) p x =
32       DirectSum.lof k ℤ (fun i : ℤ => K.TargetPage r i) q (h ▸ x) := by
33   subst q
34   rfl
35 
36 private theorem targetPageCast_eq_cast (r : ℕ) {p q : ℤ} (h : p = q)
37     (x : K.TargetPage r p) :
38     targetPageCast (K := K) r h x = h ▸ x := by
39   refine Submodule.Quotient.induction_on
40     ((K.boundaries r p).comap (K.G p).subtype) x ?_
41   intro z
42   rw [targetPageCast_mk]
43   cases h
44   rfl
45 
46 /-- The source-page action on the total direct sum. -/
47 def sourceTotalMap (r : ℕ) : K.SourceTotal r →ₗ[k] K.SourceTotal r :=
48   DirectSum.toModule k ℤ (K.SourceTotal r) (fun p : ℤ =>
49     (DirectSum.lof k ℤ (fun q : ℤ => K.SourcePage r q) (p - d)).comp
50       (P.sourceMap r p))
51 
52 /-- The target-page action on the total direct sum. -/
53 def targetTotalMap (r : ℕ) : K.TargetTotal r →ₗ[k] K.TargetTotal r :=
54   DirectSum.toModule k ℤ (K.TargetTotal r) (fun p : ℤ =>
55     (DirectSum.lof k ℤ (fun q : ℤ => K.TargetPage r q) (p - d)).comp
56       (P.targetMap r p))
57 
58 @[simp] theorem sourceTotalMap_lof (r : ℕ) (p : ℤ) (x : K.SourcePage r p) :
59     P.sourceTotalMap r
60         (DirectSum.lof k ℤ (fun q : ℤ => K.SourcePage r q) p x) =
61       DirectSum.lof k ℤ (fun q : ℤ => K.SourcePage r q) (p - d)
62         (P.sourceMap r p x) := by
63   rw [sourceTotalMap, DirectSum.toModule_lof]
64   rfl
65 
66 @[simp] theorem targetTotalMap_lof (r : ℕ) (p : ℤ) (x : K.TargetPage r p) :
67     P.targetTotalMap r
68         (DirectSum.lof k ℤ (fun q : ℤ => K.TargetPage r q) p x) =
69       DirectSum.lof k ℤ (fun q : ℤ => K.TargetPage r q) (p - d)
70         (P.targetMap r p x) := by
71   rw [targetTotalMap, DirectSum.toModule_lof]
72   rfl
73 
74 /-- The total action intertwines the total page differential. -/
75 theorem totalDrop_intertwines (r : ℕ) :
76     K.totalDrop r ∘ₗ P.sourceTotalMap r =
77       P.targetTotalMap r ∘ₗ K.totalDrop r := by
78   apply LinearMap.ext
79   intro x
80   induction x using DirectSum.induction_on with
81   | zero => simp
82   | of p y =>
83       rw [show DirectSum.of (fun q : ℤ => K.SourcePage r q) p y =
84         DirectSum.lof k ℤ (fun q : ℤ => K.SourcePage r q) p y from rfl]
85       change K.totalDrop r (P.sourceTotalMap r
86         (DirectSum.lof k ℤ (fun q : ℤ => K.SourcePage r q) p y)) =
87         P.targetTotalMap r (K.totalDrop r
88           (DirectSum.lof k ℤ (fun q : ℤ => K.SourcePage r q) p y))
89       rw [P.sourceTotalMap_lof, K.totalDrop_lof, K.totalDrop_lof,
90         P.targetTotalMap_lof]
91       have h : p + (r : ℤ) - d = p - d + (r : ℤ) := by omega
92       rw [target_lof_transport (K := K) r h]
93       congr 1
94       symm
95       convert P.targetMap_drop r p y using 1
96       exact (targetPageCast_eq_cast (K := K) r _ _).symm
97   | add x y hx hy => simpa using congrArg₂ (· + ·) hx hy
98 
99 
100 private theorem source_lof_mk_eq_of_lower (r : ℕ) {p q : ℤ} (h : p = q)
101     (x : K.cycles r p) (y : K.cycles r q)
102     (hxy : (x : M) - (y : M) ∈ K.G (p + 1)) :
103     DirectSum.lof k ℤ (fun i => K.SourcePage r i) p (Submodule.Quotient.mk x) =
104       DirectSum.lof k ℤ (fun i => K.SourcePage r i) q (Submodule.Quotient.mk y) := by
105   subst q
106   congr 1
107   apply (Submodule.Quotient.eq _).2
108   exact hxy
109 
110 private theorem target_lof_mk_eq_of_lower (r : ℕ) {p q : ℤ} (h : p = q)
111     (x : K.G p) (y : K.G q)
112     (hxy : (x : M) - (y : M) ∈ K.G (p + 1)) :
113     DirectSum.lof k ℤ (fun i => K.TargetPage r i) p (Submodule.Quotient.mk x) =
114       DirectSum.lof k ℤ (fun i => K.TargetPage r i) q (Submodule.Quotient.mk y) := by
115   subst q
116   congr 1
117   apply (Submodule.Quotient.eq _).2
118   exact Submodule.mem_sup.mpr ⟨0, Submodule.zero_mem _,
119     (x : M) - y, hxy, by simp⟩
120 
121 /-- Lower-order commutators vanish in the total source symbol action. -/
122 theorem sourceTotalMap_commute_of_commutator_lowers {e : ℤ}
123     (Q : K.PageOperator e)
124     (hlower : ∀ p z, z ∈ K.G p →
125       P.g (Q.g z) - Q.g (P.g z) ∈ K.G (p - d - e + 1)) (r : ℕ) :
126     Commute (P.sourceTotalMap r) (Q.sourceTotalMap r) := by
127   apply LinearMap.ext
128   intro z
129   induction z using DirectSum.induction_on with
130   | zero => simp
131   | of p z =>
132     change P.sourceTotalMap r (Q.sourceTotalMap r
133       (DirectSum.lof k ℤ (fun i => K.SourcePage r i) p z)) =
134       Q.sourceTotalMap r (P.sourceTotalMap r
135       (DirectSum.lof k ℤ (fun i => K.SourcePage r i) p z))
136     rw [Q.sourceTotalMap_lof, P.sourceTotalMap_lof,
137       P.sourceTotalMap_lof, Q.sourceTotalMap_lof]
138     induction z using Submodule.Quotient.induction_on with
139     | _ z =>
140       rw [Q.sourceMap_mk, P.sourceMap_mk, P.sourceMap_mk, Q.sourceMap_mk]
141       apply source_lof_mk_eq_of_lower (K := K) r (by omega)
142       change P.g (Q.g (z : M)) - Q.g (P.g (z : M)) ∈ K.G (p - e - d + 1)
143       simpa only [sub_sub, add_comm] using hlower p (z : M) z.property.1
144   | add x y hx hy => simpa using congrArg₂ (· + ·) hx hy
145 
146 /-- Lower-order commutators vanish in the total target symbol action. -/
147 theorem targetTotalMap_commute_of_commutator_lowers {e : ℤ}
148     (Q : K.PageOperator e)
149     (hlower : ∀ p z, z ∈ K.G p →
150       P.g (Q.g z) - Q.g (P.g z) ∈ K.G (p - d - e + 1)) (r : ℕ) :
151     Commute (P.targetTotalMap r) (Q.targetTotalMap r) := by
152   apply LinearMap.ext
153   intro z
154   induction z using DirectSum.induction_on with
155   | zero => simp
156   | of p z =>
157     change P.targetTotalMap r (Q.targetTotalMap r
158       (DirectSum.lof k ℤ (fun i => K.TargetPage r i) p z)) =
159       Q.targetTotalMap r (P.targetTotalMap r
160       (DirectSum.lof k ℤ (fun i => K.TargetPage r i) p z))
161     rw [Q.targetTotalMap_lof, P.targetTotalMap_lof,
162       P.targetTotalMap_lof, Q.targetTotalMap_lof]
163     induction z using Submodule.Quotient.induction_on with
164     | _ z =>
165       rw [Q.targetMap_mk, P.targetMap_mk, P.targetMap_mk, Q.targetMap_mk]
166       apply target_lof_mk_eq_of_lower (K := K) r (by omega)
167       change P.g (Q.g (z : M)) - Q.g (P.g (z : M)) ∈ K.G (p - e - d + 1)
168       simpa only [sub_sub, add_comm] using hlower p (z : M) z.property
169   | add x y hx hy => simpa using congrArg₂ (· + ·) hx hy
170 
171 #print axioms sourceTotalMap_commute_of_commutator_lowers
172 #print axioms targetTotalMap_commute_of_commutator_lowers
173 
174 end PageOperator
175 
176 end FilteredTwoTerm
177 
178 end AlgebraicAnalysis.FilteredTwoTermPages
179