AlgebraicAnalysis/Module/FilteredTwoTermSuccessorNaturality.lean

AlgebraicAnalysis library · bbbbf3fc358ca8100b158cec4cf47f336ab70163

1 module
2 public import AlgebraicAnalysis.Module.FilteredTwoTermTotalActions
3 
4 @[expose] public section
5 
6 /-!
7 # Naturality of the total successor maps
8 
9 The concrete successor maps on the source and target pages commute with the
10 page action.  The proof is by direct-sum induction and quotient
11 representatives; no abstract successor-page interface is used.
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 namespace PageOperator
24 
25 variable {K : FilteredTwoTerm k M} {d : ℤ} (P : K.PageOperator d)
26 
27 theorem sourceTotalSuccMap_naturality (r : ℕ) :
28     K.sourceTotalSuccMap r ∘ₗ P.sourceTotalMap (r + 1) =
29       P.sourceTotalMap r ∘ₗ K.sourceTotalSuccMap r := by
30   apply LinearMap.ext
31   intro x
32   induction x using DirectSum.induction_on with
33   | zero => simp
34   | of p x =>
35       rw [show DirectSum.of (fun q : ℤ => K.SourcePage (r + 1) q) p x =
36         DirectSum.lof k ℤ (fun q : ℤ => K.SourcePage (r + 1) q) p x from rfl]
37       rw [LinearMap.comp_apply, LinearMap.comp_apply]
38       simp only [sourceTotalSuccMap, DirectSum.lmap_lof]
39       rw [P.sourceTotalMap_lof]
40       change K.sourceTotalSuccMap r
41           (DirectSum.lof k ℤ (fun q : ℤ => K.SourcePage (r + 1) q) (p - d)
42             (P.sourceMap (r + 1) p x)) =
43         P.sourceTotalMap r
44           (DirectSum.lof k ℤ (fun q : ℤ => K.SourcePage r q) p
45             (K.sourceSuccMap r p x))
46       rw [sourceTotalSuccMap, DirectSum.lmap_lof]
47       rw [P.sourceTotalMap_lof]
48       apply congrArg (fun z =>
49         DirectSum.lof k ℤ (fun q : ℤ => K.SourcePage r q) (p - d) z)
50       refine Submodule.Quotient.induction_on
51         ((K.G (p + 1)).comap (K.cycles (r + 1) p).subtype) x ?_
52       intro z
53       rw [K.sourceSuccMap_mk, P.sourceMap_mk]
54       simp [sourceSuccEquivKerDrop, sourceSuccKernelMap, sourceSuccMap]
55       apply (Submodule.Quotient.eq _).2
56       change P.g (z : M) - P.g (z : M) ∈ K.G (p - d + 1)
57       simp
58   | add x y hx hy => simpa using congrArg₂ (· + ·) hx hy
59 
60 theorem targetTotalSuccMap_naturality (r : ℕ) :
61     K.targetTotalSuccMap r ∘ₗ P.targetTotalMap r =
62       P.targetTotalMap (r + 1) ∘ₗ K.targetTotalSuccMap r := by
63   apply LinearMap.ext
64   intro x
65   induction x using DirectSum.induction_on with
66   | zero => simp
67   | of p x =>
68       rw [show DirectSum.of (fun q : ℤ => K.TargetPage r q) p x =
69         DirectSum.lof k ℤ (fun q : ℤ => K.TargetPage r q) p x from rfl]
70       rw [LinearMap.comp_apply, LinearMap.comp_apply]
71       simp only [targetTotalSuccMap, DirectSum.lmap_lof]
72       rw [P.targetTotalMap_lof]
73       change K.targetTotalSuccMap r
74           (DirectSum.lof k ℤ (fun q : ℤ => K.TargetPage r q) (p - d)
75             (P.targetMap r p x)) =
76         P.targetTotalMap (r + 1)
77           (DirectSum.lof k ℤ (fun q : ℤ => K.TargetPage (r + 1) q) p
78             (K.targetSuccMap r p x))
79       rw [targetTotalSuccMap, DirectSum.lmap_lof]
80       rw [P.targetTotalMap_lof]
81       apply congrArg (fun z =>
82         DirectSum.lof k ℤ (fun q : ℤ => K.TargetPage (r + 1) q) (p - d) z)
83       refine Submodule.Quotient.induction_on
84         ((K.boundaries r p).comap (K.G p).subtype) x ?_
85       intro z
86       rw [P.targetMap_mk]
87       change K.targetSuccMap r (p - d)
88           (Submodule.Quotient.mk (P.targetRestricted p z)) =
89         Submodule.Quotient.mk (P.targetRestricted p z)
90       rw [targetSuccMap, Submodule.mapQ_apply]
91       rfl
92   | add x y hx hy => simpa using congrArg₂ (· + ·) hx hy
93 
94 end PageOperator
95 
96 end FilteredTwoTerm
97 
98 end AlgebraicAnalysis.FilteredTwoTermPages
99