AlgebraicAnalysis/Module/FilteredTwoTermPageEquivalences.lean

AlgebraicAnalysis library · bbbbf3fc358ca8100b158cec4cf47f336ab70163

1 module
2 public import AlgebraicAnalysis.Module.FilteredTwoTermPages
3 public import Mathlib.LinearAlgebra.Isomorphisms
4 
5 @[expose] public section
6 
7 /-!
8 # Successor equivalences for the filtered two-term pages
9 
10 This file proves, from the concrete representative definitions in
11 `FilteredTwoTermPages`, that the next source page is the kernel of the page
12 differential and that the next target page is its cokernel.
13 -/
14 
15 namespace AlgebraicAnalysis.FilteredTwoTermPages
16 
17 universe u v
18 
19 variable {k : Type u} [Ring k]
20 variable {M : Type v} [AddCommGroup M] [Module k M]
21 
22 namespace FilteredTwoTerm
23 
24 variable (K : FilteredTwoTerm k M)
25 
26 abbrev sourceDenominator (r : ℕ) (p : ℤ) :
27     Submodule k (K.cycles r p) :=
28   (K.G (p + 1)).comap (K.cycles r p).subtype
29 
30 abbrev targetDenominator (r : ℕ) (p : ℤ) :
31     Submodule k (K.G p) :=
32   (K.boundaries r p).comap (K.G p).subtype
33 
34 def sourceSuccInclusion (r : ℕ) (p : ℤ) :
35     K.cycles (r + 1) p →ₗ[k] K.cycles r p :=
36   Submodule.inclusion (K.cycles_succ_le r p)
37 
38 theorem sourceSuccInclusion_denominator (r : ℕ) (p : ℤ) :
39     K.sourceDenominator (r + 1) p ≤
40       (K.sourceDenominator r p).comap (K.sourceSuccInclusion r p) := by
41   intro x hx
42   exact hx
43 
44 /-- The map from the next source page to the current source page. -/
45 def sourceSuccMap (r : ℕ) (p : ℤ) :
46     K.SourcePage (r + 1) p →ₗ[k] K.SourcePage r p :=
47   Submodule.mapQ _ _ (K.sourceSuccInclusion r p)
48     (K.sourceSuccInclusion_denominator r p)
49 
50 @[simp] theorem sourceSuccMap_mk (r : ℕ) (p : ℤ)
51     (x : K.cycles (r + 1) p) :
52     K.sourceSuccMap r p (Submodule.Quotient.mk x) =
53       Submodule.Quotient.mk (K.sourceSuccInclusion r p x) :=
54   Submodule.mapQ_apply _ _ _ _
55 
56 theorem drop_sourceSuccMap_eq_zero (r : ℕ) (p : ℤ)
57     (x : K.SourcePage (r + 1) p) :
58     K.drop r p (K.sourceSuccMap r p x) = 0 := by
59   refine Submodule.Quotient.induction_on (K.sourceDenominator (r + 1) p) x ?_
60   intro z
61   rw [K.sourceSuccMap_mk]
62   exact K.drop_mk_eq_zero_of_mem_cycles_succ r p
63     (K.sourceSuccInclusion r p z) z.property
64 
65 /-- The canonical map from the next source page into the kernel of `d_r`. -/
66 def sourceSuccKernelMap (r : ℕ) (p : ℤ) :
67     K.SourcePage (r + 1) p →ₗ[k] LinearMap.ker (K.drop r p) :=
68   (K.sourceSuccMap r p).codRestrict (LinearMap.ker (K.drop r p))
69     (K.drop_sourceSuccMap_eq_zero r p)
70 
71 theorem sourceSuccMap_injective (r : ℕ) (p : ℤ) :
72     Function.Injective (K.sourceSuccMap r p) := by
73   intro a b
74   revert b
75   refine Submodule.Quotient.induction_on (K.sourceDenominator (r + 1) p) a ?_
76   intro x b
77   refine Submodule.Quotient.induction_on (K.sourceDenominator (r + 1) p) b ?_
78   intro y hab
79   rw [K.sourceSuccMap_mk, K.sourceSuccMap_mk] at hab
80   apply (Submodule.Quotient.eq (K.sourceDenominator (r + 1) p)).2
81   have hmem :=
82     (Submodule.Quotient.eq (K.sourceDenominator r p)).1 hab
83   exact hmem
84 
85 theorem sourceSuccKernelMap_surjective (r : ℕ) (p : ℤ) :
86     Function.Surjective (K.sourceSuccKernelMap r p) := by
87   rintro ⟨y, hy⟩
88   obtain ⟨x, rfl⟩ := Submodule.Quotient.mk_surjective
89     (K.sourceDenominator r p) y
90   have hxzero : K.drop r p (Submodule.Quotient.mk x) = 0 := hy
91   obtain ⟨z, hz, hxz⟩ :=
92     K.exists_cycles_succ_rep_of_drop_mk_eq_zero r p x hxzero
93   let w : K.cycles (r + 1) p := ⟨(x : M) - z, hxz⟩
94   refine ⟨Submodule.Quotient.mk w, Subtype.ext ?_⟩
95   rw [show ((K.sourceSuccKernelMap r p
96       (Submodule.Quotient.mk w) : LinearMap.ker (K.drop r p)) :
97         K.SourcePage r p) = K.sourceSuccMap r p (Submodule.Quotient.mk w) from rfl]
98   rw [K.sourceSuccMap_mk]
99   apply (Submodule.Quotient.eq (K.sourceDenominator r p)).2
100   change ((w : M) - (x : M)) ∈ K.G (p + 1)
101   simpa [w] using (K.G (p + 1)).neg_mem hz
102 
103 /-- On the source, the next page is the kernel of the current page
104 differential. -/
105 noncomputable def sourceSuccEquivKerDrop (r : ℕ) (p : ℤ) :
106     K.SourcePage (r + 1) p ≃ₗ[k] LinearMap.ker (K.drop r p) :=
107   LinearEquiv.ofBijective (K.sourceSuccKernelMap r p)
108     ⟨fun _ _ h => K.sourceSuccMap_injective r p (congrArg Subtype.val h),
109       K.sourceSuccKernelMap_surjective r p⟩
110 
111 /-- The quotient map from a target page to its successor page. -/
112 def targetSuccMap (r : ℕ) (p : ℤ) :
113     K.TargetPage r p →ₗ[k] K.TargetPage (r + 1) p :=
114   Submodule.mapQ _ _ LinearMap.id (by
115     intro x hx
116     exact K.boundaries_le_succ r p hx)
117 
118 @[simp] theorem targetSuccMap_mk (r : ℕ) (p : ℤ)
119     (x : K.G p) :
120     K.targetSuccMap r p (Submodule.Quotient.mk x) =
121       Submodule.Quotient.mk x :=
122   Submodule.mapQ_apply _ _ _ _
123 
124 theorem targetSuccMap_surjective (r : ℕ) (p : ℤ) :
125     Function.Surjective (K.targetSuccMap r p) := by
126   intro y
127   obtain ⟨x, rfl⟩ := Submodule.Quotient.mk_surjective
128     (K.targetDenominator (r + 1) p) y
129   exact ⟨Submodule.Quotient.mk x, K.targetSuccMap_mk r p x⟩
130 
131 theorem targetSuccMap_drop_eq_zero (r : ℕ) (p : ℤ)
132     (x : K.SourcePage r p) :
133     K.targetSuccMap r (p + r) (K.drop r p x) = 0 := by
134   refine Submodule.Quotient.induction_on (K.sourceDenominator r p) x ?_
135   intro z
136   rw [K.drop_mk, K.targetSuccMap_mk, Submodule.Quotient.mk_eq_zero]
137   change K.f (z : M) ∈ K.boundaries (r + 1) (p + r)
138   apply Submodule.mem_sup.mpr
139   refine ⟨K.f (z : M), ⟨z.property.2, ?_⟩,
140     0, Submodule.zero_mem _, by simp⟩
141   refine ⟨(z : M), ?_, rfl⟩
142   have hind : p + (r : ℤ) - ((r + 1 : ℕ) : ℤ) + 1 = p := by
143     push_cast
144     omega
145   rw [hind]
146   exact z.property.1
147 
148 theorem range_drop_le_ker_targetSuccMap (r : ℕ) (p : ℤ) :
149     LinearMap.range (K.drop r p) ≤
150       LinearMap.ker (K.targetSuccMap r (p + r)) := by
151   rintro _ ⟨x, rfl⟩
152   exact LinearMap.mem_ker.mpr (K.targetSuccMap_drop_eq_zero r p x)
153 
154 theorem ker_targetSuccMap_le_range_drop (r : ℕ) (p : ℤ) :
155     LinearMap.ker (K.targetSuccMap r (p + r)) ≤
156       LinearMap.range (K.drop r p) := by
157   intro y hy
158   change K.targetSuccMap r (p + r) y = 0 at hy
159   revert hy
160   refine Submodule.Quotient.induction_on (K.targetDenominator r (p + r)) y ?_
161   intro y hy
162   rw [K.targetSuccMap_mk, Submodule.Quotient.mk_eq_zero] at hy
163   change (y : M) ∈ K.boundaries (r + 1) (p + r) at hy
164   obtain ⟨z, hz, e, he, hsum⟩ := K.mem_boundaries_succ_rep r (p + r) hy
165   have hindex : p + (r : ℤ) - (r : ℤ) = p := by omega
166   have hzp : z ∈ K.G p := by simpa [hindex] using hz
167   have he' : e ∈ K.G (p + r) := K.next_le (p + r) he
168   have hfz : K.f z ∈ K.G (p + r) := by
169     have : K.f z = (y : M) - e := by rw [hsum]; simp
170     rw [this]
171     exact Submodule.sub_mem _ y.property he'
172   let x : K.cycles r p := ⟨z, hzp, hfz⟩
173   refine ⟨Submodule.Quotient.mk x, ?_⟩
174   rw [K.drop_mk]
175   apply (Submodule.Quotient.eq (K.targetDenominator r (p + r))).2
176   change K.f z - (y : M) ∈ K.boundaries r (p + r)
177   have hdifference : K.f z - (y : M) = -e := by
178     rw [hsum]
179     abel
180   rw [hdifference]
181   apply (K.boundaries r (p + r)).neg_mem
182   exact Submodule.mem_sup.mpr
183     ⟨0, Submodule.zero_mem _, e, he, by simp⟩
184 
185 theorem ker_targetSuccMap_eq_range_drop (r : ℕ) (p : ℤ) :
186     LinearMap.ker (K.targetSuccMap r (p + r)) =
187       LinearMap.range (K.drop r p) :=
188   le_antisymm (K.ker_targetSuccMap_le_range_drop r p)
189     (K.range_drop_le_ker_targetSuccMap r p)
190 
191 /-- The map from the cokernel of `d_r` to the next target page. -/
192 def targetCokernelMap (r : ℕ) (p : ℤ) :
193     (K.TargetPage r (p + r) ⧸ LinearMap.range (K.drop r p)) →ₗ[k]
194       K.TargetPage (r + 1) (p + r) :=
195   (LinearMap.range (K.drop r p)).liftQ (K.targetSuccMap r (p + r))
196     (K.range_drop_le_ker_targetSuccMap r p)
197 
198 theorem targetCokernelMap_injective (r : ℕ) (p : ℤ) :
199     Function.Injective (K.targetCokernelMap r p) := by
200   rw [← LinearMap.ker_eq_bot]
201   exact Submodule.ker_liftQ_eq_bot _ _
202     (K.range_drop_le_ker_targetSuccMap r p)
203     (K.ker_targetSuccMap_eq_range_drop r p).le
204 
205 theorem targetCokernelMap_surjective (r : ℕ) (p : ℤ) :
206     Function.Surjective (K.targetCokernelMap r p) := by
207   intro y
208   obtain ⟨x, rfl⟩ := K.targetSuccMap_surjective r (p + r) y
209   exact ⟨Submodule.Quotient.mk x, Submodule.liftQ_apply _ _ _⟩
210 
211 /-- On the target, the next page is the cokernel of the current page
212 differential. -/
213 noncomputable def targetSuccEquivCokerDrop (r : ℕ) (p : ℤ) :
214     K.TargetPage (r + 1) (p + r) ≃ₗ[k]
215       K.TargetPage r (p + r) ⧸ LinearMap.range (K.drop r p) :=
216   (LinearEquiv.ofBijective (K.targetCokernelMap r p)
217     ⟨K.targetCokernelMap_injective r p,
218       K.targetCokernelMap_surjective r p⟩).symm
219 
220 #print axioms sourceSuccEquivKerDrop
221 #print axioms targetSuccEquivCokerDrop
222 
223 end FilteredTwoTerm
224 
225 end AlgebraicAnalysis.FilteredTwoTermPages
226