| import Mathlib |
| import OAI.Algebra.FiniteTensor.CohomologyReduction |
| import OAI.Algebra.FiniteTensor.OddTensors |
|
|
| namespace OAI |
|
|
| /-! Tensor representatives, kernel support and projected operator reduction. -/ |
|
|
| noncomputable section |
| open scoped BigOperators |
|
|
| namespace PD4Tensor |
| noncomputable section |
| variable {K V : Type*} [Field K] [AddCommGroup V] [Module K V] |
| namespace SuperReduction |
| variable (C : SuperReduction K V) |
|
|
| |
| abbrev Representatives := LinearMap.range C.p |
|
|
| def repProject : V →ₗ[K] Representatives C := C.p.rangeRestrict |
|
|
| def repInclude : Representatives C →ₗ[K] V := (LinearMap.range C.p).subtype |
|
|
| @[simp] theorem repProject_apply (v : V) : (repProject C v : V)=C.p v := rfl |
| @[simp] theorem repInclude_apply (v : Representatives C) : repInclude C v=(v:V) := rfl |
|
|
| @[simp] theorem project_include (v : Representatives C) : repProject C (repInclude C v)=v := by |
| apply Subtype.ext |
| obtain ⟨w,hw⟩ := v.property |
| change C.p (v:V)=(v:V) |
| rw [← hw,C.pp] |
|
|
| @[simp] theorem d_include (v : Representatives C) : C.d (repInclude C v)=0 := by |
| obtain ⟨w,hw⟩ := v.property |
| change C.d (v:V)=0 |
| rw [← hw,C.dp] |
|
|
| @[simp] theorem project_d (v : V) : repProject C (C.d v)=0 := by |
| apply Subtype.ext |
| exact C.pd v |
|
|
| |
| theorem project_map_project (f : V →ₗ[K] V) |
| (hf : ∀ v, C.p (f (C.d v))=0) (v : V) (hv : C.d v=0) : |
| repProject C (f (C.p v))=repProject C (f v) := by |
| apply Subtype.ext |
| change C.p (f (C.p v))=C.p (f v) |
| have h := C.hom v |
| rw [hv,map_zero,add_zero] at h |
| have hh := congrArg (fun x => C.p (f x)) h |
| rw [hf,map_sub,map_sub] at hh |
| exact (sub_eq_zero.mp hh.symm).symm |
|
|
| def repMap (f : V →ₗ[K] V) : Representatives C →ₗ[K] Representatives C := |
| (repProject C).comp (f.comp (repInclude C)) |
|
|
| @[simp] theorem repMap_apply (f : V →ₗ[K] V) (v : Representatives C) : |
| repMap C f v=repProject C (f (v:V)) := rfl |
|
|
| @[simp] theorem repMap_zero : repMap C (0 : V →ₗ[K] V)=0 := by |
| apply LinearMap.ext; intro v; simp |
|
|
| @[simp] theorem repMap_id : repMap C (LinearMap.id : V →ₗ[K] V)=LinearMap.id := by |
| apply LinearMap.ext; intro v |
| exact project_include C v |
|
|
| @[simp] theorem repMap_add (f g : V →ₗ[K] V) : repMap C (f+g)=repMap C f+repMap C g := by |
| apply LinearMap.ext; intro v; simp |
|
|
| @[simp] theorem repMap_neg (f : V →ₗ[K] V) : repMap C (-f) = -repMap C f := by |
| apply LinearMap.ext; intro v; simp |
|
|
| |
| theorem repMap_comp (f g : V →ₗ[K] V) |
| (hf : ∀ v, C.p (f (C.d v))=0) |
| (hg : ∀ v, C.d v=0 → C.d (g v)=0) : |
| (repMap C f).comp (repMap C g)=repMap C (f.comp g) := by |
| apply LinearMap.ext; intro v |
| change repProject C (f (C.p (g (v:V))))=repProject C (f (g (v:V))) |
| exact project_map_project C f hf _ (hg _ (d_include C v)) |
|
|
| |
|
|
| theorem exists_induced_reduction [Invertible (2:K)] |
| (d b g : V →ₗ[K] V) |
| (hdd : ∀ v, d (d v)=0) (hgg : ∀ v, g (g v)=v) |
| (hdg : ∀ v, d (g v) = -g (d v)) |
| (hδd : ∀ v, C.d (d v) = -d (C.d v)) |
| (hδg : ∀ v, C.d (g v) = -g (C.d v)) |
| (hδb : ∀ v, C.d (b v) = b (C.d v)) |
| (hbg : ∀ v, b (g v)=g (b v)) : |
| ∃ E : SuperReduction K (Representatives C), |
| E.d=repMap C d ∧ E.g=repMap C g ∧ |
| ∀ v, repMap C b v=0 → repMap C b (E.p v)=0 := by |
| have dcycle : ∀ v, C.d v=0 → C.d (d v)=0 := by |
| intro v hv; rw [hδd,hv,map_zero,neg_zero] |
| have gcycle : ∀ v, C.d v=0 → C.d (g v)=0 := by |
| intro v hv; rw [hδg,hv,map_zero,neg_zero] |
| have bcycle : ∀ v, C.d v=0 → C.d (b v)=0 := by |
| intro v hv; rw [hδb,hv,map_zero] |
| have dbound : ∀ v, C.p (d (C.d v))=0 := by |
| intro v |
| have h := congrArg C.p (hδd v) |
| rw [C.pd,map_neg] at h |
| exact neg_eq_zero.mp h.symm |
| have gbound : ∀ v, C.p (g (C.d v))=0 := by |
| intro v |
| have h := congrArg C.p (hδg v) |
| rw [C.pd,map_neg] at h |
| exact neg_eq_zero.mp h.symm |
| have bbound : ∀ v, C.p (b (C.d v))=0 := by |
| intro v |
| have h := congrArg C.p (hδb v) |
| rw [C.pd] at h |
| exact h.symm |
| have dd : ∀ v, repMap C d (repMap C d v)=0 := by |
| have hh : d.comp d=0 := LinearMap.ext hdd |
| intro v |
| have h := LinearMap.congr_fun (repMap_comp C d d dbound dcycle) v |
| simpa only [LinearMap.comp_apply,hh,repMap_zero,LinearMap.zero_apply] using h |
| have gg : ∀ v, repMap C g (repMap C g v)=v := by |
| have hh : g.comp g=LinearMap.id := LinearMap.ext hgg |
| intro v |
| have h := LinearMap.congr_fun (repMap_comp C g g gbound gcycle) v |
| simpa only [LinearMap.comp_apply,hh,repMap_id,LinearMap.id_apply] using h |
| have dg : ∀ v, repMap C d (repMap C g v) = -repMap C g (repMap C d v) := by |
| have hh : d.comp g= -(g.comp d) := LinearMap.ext hdg |
| intro v |
| have h₁ := LinearMap.congr_fun (repMap_comp C d g dbound gcycle) v |
| have h₂ := LinearMap.congr_fun (repMap_comp C g d gbound dcycle) v |
| rw [hh,repMap_neg] at h₁ |
| exact h₁.trans (congrArg Neg.neg h₂.symm) |
| have bg : ∀ v, repMap C b (repMap C g v)=repMap C g (repMap C b v) := by |
| have hh : b.comp g=g.comp b := LinearMap.ext hbg |
| intro v |
| have h₁ := LinearMap.congr_fun (repMap_comp C b g bbound gcycle) v |
| have h₂ := LinearMap.congr_fun (repMap_comp C g b gbound bcycle) v |
| exact h₁.trans (hh ▸ h₂.symm) |
| obtain ⟨E,hEd,hEg,hEp⟩ := exists_superReduction (repMap C d) (repMap C g) |
| dd gg dg (LinearMap.ker (repMap C b)) (by |
| intro v hv |
| change repMap C b (repMap C g v)=0 |
| rw [bg,hv,map_zero]) |
| exact ⟨E,hEd,hEg,hEp⟩ |
|
|
| end SuperReduction |
| end |
| end PD4Tensor |
|
|
| |
|
|
| namespace PD4Tensor |
| noncomputable section |
| open scoped TensorProduct |
|
|
| variable {K V W X : Type*} [Field K] |
| variable [AddCommGroup V] [Module K V] [AddCommGroup W] [Module K W] |
| variable [AddCommGroup X] [Module K X] |
|
|
| |
| theorem factor_of_ker_le (f : V →ₗ[K] W) (g : V →ₗ[K] X) |
| (h : LinearMap.ker f ≤ LinearMap.ker g) : |
| ∃ l : W →ₗ[K] X, l.comp f = g := by |
| let a : LinearMap.range f →ₗ[K] X := |
| ((LinearMap.ker f).liftQ g h).comp f.quotKerEquivRange.symm.toLinearMap |
| obtain ⟨l, hl⟩ := a.exists_extend |
| refine ⟨l, ?_⟩ |
| ext v |
| have hv := LinearMap.congr_fun hl ⟨f v, LinearMap.mem_range_self f v⟩ |
| simpa [a] using hv |
|
|
| variable {ι : Type*} [Fintype ι] [DecidableEq ι] |
| variable (E : ι → Type*) [∀ i, AddCommGroup (E i)] [∀ i, Module K (E i)] |
|
|
| |
| def partialTensor (b : ∀ i, E i →ₗ[K] E i) (S : Finset ι) : |
| (⨂[K] i, E i) →ₗ[K] (⨂[K] i, E i) := |
| PiTensorProduct.map (fun i => if i ∈ S then b i else LinearMap.id) |
|
|
| |
| def kernelSupport (b : ∀ i, E i →ₗ[K] E i) (r : ℕ) : |
| Submodule K (⨂[K] i, E i) := |
| Submodule.span K {v | ∃ (f : ∀ i, E i) (S : Finset ι), |
| S.card ≤ r ∧ (∀ i ∉ S, b i (f i) = 0) ∧ PiTensorProduct.tprod K f = v} |
|
|
| |
| theorem triple_kernel_support (b : ∀ i, E i →ₗ[K] E i) |
| (v : ⨂[K] i, E i) |
| (hv : ∀ S : Finset ι, S.card = 3 → partialTensor E b S v = 0) : |
| v ∈ kernelSupport E b 2 := by |
| classical |
| |
| choose C hC using fun i => (LinearMap.ker (b i)).exists_isCompl |
| let P : ∀ i, E i →ₗ[K] E i := fun i => |
| (LinearMap.ker (b i)).subtype.comp |
| ((LinearMap.ker (b i)).projectionOnto (C i) (hC i)) |
| let Q : ∀ i, E i →ₗ[K] E i := fun i => LinearMap.id - P i |
| have hP (i : ι) (x : E i) : b i (P i x) = 0 := |
| ((LinearMap.ker (b i)).projectionOnto (C i) (hC i) x).property |
| have hQ (i : ι) : LinearMap.ker (b i) ≤ LinearMap.ker (Q i) := by |
| intro x hx |
| simp only [LinearMap.mem_ker, Q, LinearMap.sub_apply, LinearMap.id_apply] |
| change x - ((LinearMap.ker (b i)).projectionOnto (C i) (hC i) x : E i) = 0 |
| rw [Submodule.projectionOnto_apply_of_mem_left (hC i) hx] |
| exact sub_self _ |
| choose L hL using fun i => factor_of_ker_le (b i) (Q i) (hQ i) |
| have hsum : (∑ S : Finset ι, PiTensorProduct.map (S.piecewise Q P)) = |
| (LinearMap.id : (⨂[K] i, E i) →ₗ[K] (⨂[K] i, E i)) := by |
| have h := (PiTensorProduct.mapMultilinear K E E).map_add_univ Q P |
| have hQP : Q + P = fun i => LinearMap.id := by |
| funext i |
| simp [Q] |
| rw [hQP] at h |
| exact h.symm.trans PiTensorProduct.map_id |
| have hsmall (S : Finset ι) (hS : S.card ≤ 2) : |
| PiTensorProduct.map (S.piecewise Q P) v ∈ kernelSupport E b 2 := by |
| have hrange : LinearMap.range (PiTensorProduct.map (S.piecewise Q P)) ≤ |
| kernelSupport E b 2 := by |
| rw [PiTensorProduct.map_range_eq_span_tprod] |
| apply Submodule.span_le.mpr |
| rintro z ⟨f, rfl⟩ |
| apply Submodule.subset_span |
| refine ⟨fun i => S.piecewise Q P i (f i), S, hS, ?_, rfl⟩ |
| intro i hi |
| simpa [Finset.piecewise, hi] using hP i (f i) |
| exact hrange (LinearMap.mem_range_self _ v) |
| have hlarge (S : Finset ι) (hS : 2 < S.card) : |
| PiTensorProduct.map (S.piecewise Q P) v = 0 := by |
| obtain ⟨R, hRS, hR⟩ := Finset.exists_subset_card_eq (show 3 ≤ S.card by omega) |
| let D : ∀ i, E i →ₗ[K] E i := fun i => |
| if i ∈ R then L i else S.piecewise Q P i |
| have hfactor : PiTensorProduct.map (S.piecewise Q P) = |
| (PiTensorProduct.map D).comp (partialTensor E b R) := by |
| rw [partialTensor, ← PiTensorProduct.map_comp] |
| congr 1 |
| funext i |
| by_cases hi : i ∈ R |
| · simpa [D, Finset.piecewise, hi, hRS hi] using (hL i).symm |
| · simp [D, hi] |
| rw [hfactor, LinearMap.comp_apply, hv R hR, map_zero] |
| have heq := LinearMap.congr_fun hsum v |
| rw [LinearMap.sum_apply, LinearMap.id_apply] at heq |
| rw [← heq] |
| apply Submodule.sum_mem |
| intro S _ |
| by_cases hS : S.card ≤ 2 |
| · exact hsmall S hS |
| · rw [hlarge S (by omega)] |
| exact Submodule.zero_mem _ |
|
|
| end |
| end PD4Tensor |
|
|
| namespace PD4Tensor |
| noncomputable section |
| open scoped TensorProduct |
| variable {K V : Type*} [Field K] [AddCommGroup V] [Module K V] |
| namespace SuperReduction |
|
|
| |
| theorem cycle_of_project_zero (C : SuperReduction K V) (v : V) |
| (hd : C.d v=0) (hp : repProject C v=0) : v ∈ LinearMap.range C.d := by |
| refine ⟨C.h v, ?_⟩ |
| have h := C.hom v |
| have hp' : C.p v=0 := congrArg Subtype.val hp |
| simpa only [hd,hp',map_zero,add_zero,sub_zero] using h |
|
|
| end SuperReduction |
|
|
| namespace CohomologyTensor |
| open SuperReduction |
| variable {ι : Type*} [Fintype ι] [LinearOrder ι] |
| variable {E : ι → Type*} [∀ i, AddCommGroup (E i)] [∀ i, Module K (E i)] |
| variable (C : ∀ i, SuperReduction K (E i)) |
|
|
| abbrev Factors (i : ι) := Representatives (C i) |
|
|
| def project : (⨂[K] i, E i) →ₗ[K] (⨂[K] i, Factors C i) := |
| PiTensorProduct.map (fun i => repProject (C i)) |
|
|
| def embed : (⨂[K] i, Factors C i) →ₗ[K] (⨂[K] i, E i) := |
| PiTensorProduct.map (fun i => repInclude (C i)) |
|
|
| omit [Fintype ι] [LinearOrder ι] in |
| @[simp] theorem project_include (v : ⨂[K] i, Factors C i) : project C (embed C v)=v := by |
| have h : (project C).comp (embed C)=LinearMap.id := by |
| rw [project,embed,← PiTensorProduct.map_comp] |
| have hmap : (fun i => (repProject (C i)).comp (repInclude (C i))) = |
| fun i => (LinearMap.id : Factors C i →ₗ[K] Factors C i) := by |
| funext i |
| apply LinearMap.ext; intro v |
| exact SuperReduction.project_include (C i) v |
| rw [hmap,PiTensorProduct.map_id] |
| exact LinearMap.congr_fun h v |
|
|
| omit [Fintype ι] [LinearOrder ι] in |
| @[simp] theorem include_project (v : ⨂[K] i, E i) : embed C (project C v)=finiteP C v := by |
| have h : (embed C).comp (project C)=finiteP C := by |
| rw [embed,project,← PiTensorProduct.map_comp] |
| rfl |
| exact LinearMap.congr_fun h v |
|
|
| theorem finiteD_eq : finiteD C=oddTensor (fun i => (C i).g) (fun i => (C i).d) := rfl |
|
|
| @[simp] theorem project_d (v : ⨂[K] i, E i) : project C (finiteD C v)=0 := by |
| exact LinearMap.congr_fun (tensorMap_oddTensor_zero (fun i => (C i).g) |
| (fun i => (C i).d) (fun i => repProject (C i)) (fun i => SuperReduction.project_d (C i))) v |
|
|
| @[simp] theorem d_include (v : ⨂[K] i, Factors C i) : finiteD C (embed C v)=0 := by |
| exact LinearMap.congr_fun (oddTensor_tensorMap_zero (fun i => (C i).g) |
| (fun i => (C i).d) (fun i => repInclude (C i)) (fun i => SuperReduction.d_include (C i))) v |
|
|
| |
| theorem odd_sandwich (d : ∀ i, E i →ₗ[K] E i) (v : ⨂[K] i, Factors C i) : |
| project C (oddTensor (fun i => (C i).g) d (embed C v)) = |
| oddTensor (fun i => repMap (C i) (C i).g) (fun i => repMap (C i) (d i)) v := by |
| exact LinearMap.congr_fun (oddTensor_sandwich (fun i => (C i).g) d |
| (fun i => repProject (C i)) (fun i => repInclude (C i)) |
| (fun i => SuperReduction.project_include (C i))) v |
|
|
| |
| omit [Fintype ι] in |
| theorem partial_sandwich (b : ∀ i, E i →ₗ[K] E i) (S : Finset ι) |
| (v : ⨂[K] i, Factors C i) : |
| project C (partialTensor E b S (embed C v)) = |
| partialTensor (fun i => ↥(Factors C i)) (fun i => repMap (C i) (b i)) S v := by |
| have h : (project C).comp ((partialTensor E b S).comp (embed C)) = |
| partialTensor (fun i => ↥(Factors C i)) (fun i => repMap (C i) (b i)) S := by |
| apply PiTensorProduct.ext |
| apply MultilinearMap.ext |
| intro f |
| simp only [project,embed,partialTensor,LinearMap.compMultilinearMap_apply, |
| LinearMap.comp_apply,PiTensorProduct.map_tprod] |
| congr 1 |
| funext i |
| by_cases hi : i∈S |
| · simp only [hi,ite_true,repMap_apply,repInclude_apply] |
| · simp only [hi,ite_false,LinearMap.id_apply,SuperReduction.project_include] |
| exact LinearMap.congr_fun h v |
|
|
| |
| theorem partial_commute (b : ∀ i, E i →ₗ[K] E i) |
| (hbd : ∀ i v, b i ((C i).d v)=(C i).d (b i v)) |
| (hbg : ∀ i v, b i ((C i).g v)=(C i).g (b i v)) |
| (S : Finset ι) (v : ⨂[K] i, E i) : |
| partialTensor E b S (finiteD C v)=finiteD C (partialTensor E b S v) := by |
| apply LinearMap.congr_fun (oddTensor_naturality (fun i => (C i).g) (fun i => (C i).d) |
| (fun i => (C i).g) (fun i => (C i).d) (fun i => if i∈S then b i else LinearMap.id) ?_ ?_) v |
| · intro i w; by_cases hi : i∈S <;> simp [hi,hbg] |
| · intro i w; by_cases hi : i∈S <;> simp [hi,hbd] |
|
|
| |
|
|
| theorem pairing_projection (L : (⨂[K] i, E i) →ₗ[K] K) |
| (hL : ∀ v, L (finiteD C v)=0) (v : ⨂[K] i, E i) (hv : finiteD C v=0) : |
| L (embed C (project C v))=L v := by |
| obtain ⟨w,hw⟩ := finite_cycle_mod_projection C v hv |
| have hh := congrArg L hw |
| rw [hL,map_sub] at hh |
| rw [include_project] |
| exact (sub_eq_zero.mp hh.symm).symm |
|
|
| |
|
|
| theorem operator_projection (f : (⨂[K] i, E i) →ₗ[K] (⨂[K] i, E i)) |
| (hf : ∀ v, project C (f (finiteD C v))=0) |
| (v : ⨂[K] i, E i) (hv : finiteD C v=0) : |
| project C (f (embed C (project C v)))=project C (f v) := by |
| obtain ⟨w,hw⟩ := finite_cycle_mod_projection C v hv |
| have hh := congrArg (fun z => project C (f z)) hw |
| rw [hf,map_sub,map_sub] at hh |
| rw [include_project] |
| exact (sub_eq_zero.mp hh.symm).symm |
|
|
| end CohomologyTensor |
| end |
| end PD4Tensor |
| end |
|
|
| end OAI |
|
|
