| import Mathlib |
| import OAI.Algebra.FrobeniusObstruction.TensorCohomology |
| import OAI.Algebra.FrobeniusObstruction.CycleTransfer |
|
|
| namespace OAI |
|
|
| noncomputable section |
| open scoped BigOperators TensorProduct |
|
|
| namespace BoundaryOnly.FormalObstruction |
|
|
| variable {k : Type*} [Field k] |
|
|
| private theorem generalized_inverse {V : Type*} [AddCommGroup V] [Module k V] |
| (S : V →ₗ[k] V) : ∃ L : V →ₗ[k] V, ∀ x, S (L (S x)) = S x := by |
| obtain ⟨g,hg⟩ := S.rangeRestrict.exists_rightInverse_of_surjective S.range_rangeRestrict |
| obtain ⟨h,hh⟩ := S.range.subtype.exists_leftInverse_of_injective S.range.ker_subtype |
| refine ⟨g.comp h, fun x => ?_⟩ |
| have hx : h (S x) = S.rangeRestrict x := |
| LinearMap.congr_fun hh (S.rangeRestrict x) |
| change S (g (h (S x))) = S x |
| rw [hx] |
| exact congrArg Subtype.val (LinearMap.congr_fun hg (S.rangeRestrict x)) |
|
|
| variable {ι : Type*} [Fintype ι] [DecidableEq ι] |
| variable (V : ι → Type*) [∀ i, AddCommGroup (V i)] [∀ i, Module k (V i)] |
|
|
| |
| |
| def kernelTensorSpace (S : ∀ i, V i →ₗ[k] V i) (J : Finset ι) : |
| Submodule k (⨂[k] i, V i) := |
| Submodule.span k {z | ∃ m : ∀ i, V i, |
| (∀ i ∈ J, S i (m i) = 0) ∧ PiTensorProduct.tprod k m = z} |
|
|
| |
| def tensorAction (S : ∀ i, V i →ₗ[k] V i) (I : Finset ι) : |
| (⨂[k] i, V i) →ₗ[k] (⨂[k] i, V i) := |
| PiTensorProduct.map fun i => if i ∈ I then S i else LinearMap.id |
|
|
| |
| |
| |
| theorem joint_tensor_kernel (S : ∀ i, V i →ₗ[k] V i) (active : Finset ι) : |
| (⨅ (I : Finset ι) (_ : I ⊆ active) (_ : I.card = 3), |
| LinearMap.ker (tensorAction V S I)) = |
| (⨆ (J : Finset ι) (_ : J ⊆ active) (_ : (active \ J).card ≤ 2), |
| kernelTensorSpace V S J) := by |
| classical |
| let R := ⨆ (J : Finset ι) (_ : J ⊆ active) (_ : (active \ J).card ≤ 2), |
| kernelTensorSpace V S J |
| have hR (J : Finset ι) (hJ : J ⊆ active) (hc : (active \ J).card ≤ 2) : |
| kernelTensorSpace V S J ≤ R := le_iSup_of_le J (le_iSup_of_le hJ (le_iSup_of_le hc le_rfl)) |
| apply le_antisymm |
| · intro x hx |
| have hz (I : Finset ι) (hI : I ⊆ active) (hcard : I.card = 3) : |
| tensorAction V S I x = 0 := by |
| exact ((Submodule.mem_iInf _).mp ((Submodule.mem_iInf _).mp ((Submodule.mem_iInf _).mp hx I) hI) hcard) |
| choose L hL using fun i => generalized_inverse (S i) |
| let Q (i : ι) := (L i).comp (S i) |
| let P (i : ι) := LinearMap.id - Q i |
| have hSP (i : ι) (v : V i) : S i (P i v) = 0 := by |
| change S i (v - L i (S i v)) = 0 |
| rw [map_sub, hL, sub_self] |
| let F (A : Finset ι) := PiTensorProduct.map fun i => if i ∈ A then Q i else P i |
| have hsum : ∑ A : Finset ι, F A = LinearMap.id := by |
| apply PiTensorProduct.ext |
| ext m |
| simp only [LinearMap.compMultilinearMap_apply, LinearMap.sum_apply, LinearMap.id_apply] |
| simp only [F, PiTensorProduct.map_tprod] |
| have hm : (fun i => Q i (m i)) + (fun i => P i (m i)) = m := by |
| funext i |
| change Q i (m i) + (m i - Q i (m i)) = m i |
| abel |
| conv_rhs => rw [← hm, (PiTensorProduct.tprod k).map_add_univ] |
| apply Finset.sum_congr rfl |
| intro A ha |
| congr 1 |
| funext i |
| simp only [Finset.piecewise] |
| split_ifs <;> rfl |
| have hFx (A : Finset ι) : F A x ∈ R := by |
| by_cases hc : (active ∩ A).card ≤ 2 |
| · let J := active \ A |
| have hJ : J ⊆ active := Finset.sdiff_subset |
| have hjc : (active \ J).card ≤ 2 := by |
| simpa only [J, Finset.sdiff_sdiff_self_left] using hc |
| apply hR J hJ hjc |
| clear hx hz |
| induction x using PiTensorProduct.induction_on with |
| | smul_tprod c m => |
| rw [map_smul] |
| apply Submodule.smul_mem |
| apply Submodule.subset_span |
| refine ⟨fun i => (if i ∈ A then Q i else P i) (m i), ?_, ?_⟩ |
| · intro i hi |
| have hiA : i ∉ A := (Finset.mem_sdiff.mp hi).2 |
| simpa only [ite_eq_right hiA] using hSP i (m i) |
| · exact (PiTensorProduct.map_tprod _ _).symm |
| | add x y hx hy => |
| rw [map_add] |
| exact Submodule.add_mem _ hx hy |
| · have hc' : 3 ≤ (active ∩ A).card := by omega |
| obtain ⟨I,hI,hcard⟩ := Finset.exists_subset_card_eq hc' |
| have hIa : I ⊆ active := fun i hi => (Finset.mem_inter.mp (hI hi)).1 |
| have hIA : I ⊆ A := fun i hi => (Finset.mem_inter.mp (hI hi)).2 |
| let H := PiTensorProduct.map fun i => |
| if i ∈ I then L i else if i ∈ A then Q i else P i |
| have hcomp : F A = H.comp (tensorAction V S I) := by |
| dsimp only [F, H, tensorAction] |
| rw [← PiTensorProduct.map_comp] |
| congr 1 |
| funext i |
| by_cases hi : i ∈ I |
| · simp only [ite_eq_left hi, ite_eq_left (hIA hi), Q] |
| · simp only [ite_eq_right hi, LinearMap.comp_id] |
| rw [hcomp, LinearMap.comp_apply, hz I hIa hcard, map_zero] |
| exact R.zero_mem |
| change x ∈ R |
| have hsx := LinearMap.congr_fun hsum x |
| simp only [LinearMap.sum_apply, LinearMap.id_apply] at hsx |
| rw [← hsx] |
| exact Submodule.sum_mem R (fun A _ => hFx A) |
| · refine iSup_le fun J => iSup_le fun hJ => iSup_le fun hc => ?_ |
| refine le_iInf fun I => le_iInf fun hI => le_iInf fun hcard => ?_ |
| apply Submodule.span_le.mpr |
| rintro z ⟨m,hm,rfl⟩ |
| have hex : ∃ i ∈ I, i ∈ J := by |
| by_contra hn |
| have hsub : I ⊆ active \ J := by |
| intro i hi |
| exact Finset.mem_sdiff.mpr ⟨hI hi, fun hij => hn ⟨i,hi,hij⟩⟩ |
| have := Finset.card_le_card hsub |
| omega |
| obtain ⟨i,hiI,hiJ⟩ := hex |
| change tensorAction V S I (PiTensorProduct.tprod k m) = 0 |
| rw [tensorAction, PiTensorProduct.map_tprod] |
| apply (PiTensorProduct.tprod k).map_coord_zero i |
| simpa only [ite_eq_left hiI] using hm i hiJ |
|
|
| end BoundaryOnly.FormalObstruction |
|
|
| namespace BoundaryOnly.FormalObstruction |
| open scoped BigOperators TensorProduct |
|
|
| variable {k ι : Type*} [Field k] [Fintype ι] [LinearOrder ι] |
| variable {V : ι → Type*} [∀ i, AddCommGroup (V i)] [∀ i, Module k (V i)] |
|
|
| |
| |
| |
| theorem select_special_fiber_tensor |
| (S P D r h : SignedTensor.EndFamily (k := k) V) |
| (active : Finset ι) (hcard : 5 ≤ active.card) |
| (hP2 : ∀ i, P i * P i = 1) |
| (hDP : ∀ i, D i * P i = -(P i * D i)) |
| (hDr : ∀ i, D i * r i = r i * D i) |
| (hPr : ∀ i, P i * r i = r i * P i) |
| (hPh : ∀ i, P i * h i = -(h i * P i)) |
| (hDh : ∀ i, D i * h i + h i * D i = 1 - r i) |
| (hNr : ∀ i ∈ active, ∀ x, S i x = 0 → |
| S i (r i x) = 0 ∧ S i (D i (r i x)) = 0) |
| (φ : (⨂[k] i, V i) →ₗ[k] k) |
| (hφD : ∀ x, φ (SignedTensor.differential V P D x) = 0) |
| (z : ⨂[k] i, V i) |
| (hDz : SignedTensor.differential V P D z = 0) |
| (hφz : φ z ≠ 0) |
| (hz : ∀ I : Finset ι, I ⊆ active → I.card = 3 → tensorAction V S I z = 0) : |
| ∃ (J : Finset ι) (m : ∀ i, V i), |
| J ⊆ active ∧ 3 ≤ J.card ∧ |
| (∀ i ∈ J, S i (m i) = 0 ∧ S i (D i (m i)) = 0) ∧ |
| φ (PiTensorProduct.tprod k m) ≠ 0 := by |
| classical |
| let Good : Set (⨂[k] i, V i) := {x | ∃ (J : Finset ι) (m : ∀ i, V i), |
| J ⊆ active ∧ (active \ J).card ≤ 2 ∧ |
| (∀ i ∈ J, S i (m i) = 0 ∧ S i (D i (m i)) = 0) ∧ |
| PiTensorProduct.tprod k m = x} |
| let T := Submodule.span k Good |
| have hm : (⨅ (I : Finset ι) (_ : I ⊆ active) (_ : I.card = 3), |
| LinearMap.ker (tensorAction V S I)) ≤ T.comap (PiTensorProduct.map r) := by |
| rw [joint_tensor_kernel] |
| refine iSup_le fun J => iSup_le fun hJ => iSup_le fun hJc => ?_ |
| apply Submodule.span_le.mpr |
| rintro _ ⟨m,hm,rfl⟩ |
| change PiTensorProduct.map r (PiTensorProduct.tprod k m) ∈ T |
| rw [PiTensorProduct.map_tprod] |
| apply Submodule.subset_span |
| refine ⟨J,fun i => r i (m i),hJ,hJc,?_,rfl⟩ |
| intro i hi |
| exact hNr i (hJ hi) (m i) (hm i hi) |
| have hzmem : z ∈ (⨅ (I : Finset ι) (_ : I ⊆ active) (_ : I.card = 3), |
| LinearMap.ker (tensorAction V S I)) := by |
| simp only [Submodule.mem_iInf, LinearMap.mem_ker] |
| exact hz |
| have hRz : PiTensorProduct.map r z ∈ T := hm hzmem |
| have hpair : φ (PiTensorProduct.map r z) = φ z := by |
| have H := LinearMap.congr_fun |
| (SignedTensor.tensor_homotopy P D r h hP2 hDP hDr hPr hPh hDh) z |
| change SignedTensor.differential V P D (SignedTensor.homotopy V P r h z) + |
| SignedTensor.homotopy V P r h (SignedTensor.differential V P D z) = |
| z - PiTensorProduct.map r z at H |
| have Hφ := congrArg φ H |
| rw [hDz, map_zero, add_zero, hφD, map_sub] at Hφ |
| exact (sub_eq_zero.mp Hφ.symm).symm |
| have hex : ∃ x ∈ Good, φ x ≠ 0 := by |
| by_contra hn |
| have hle : T ≤ LinearMap.ker φ := by |
| apply Submodule.span_le.mpr |
| intro x hx |
| change φ x = 0 |
| by_contra hnx |
| exact hn ⟨x,hx,hnx⟩ |
| apply hφz |
| rw [← hpair] |
| exact hle hRz |
| obtain ⟨_,⟨J,m,hJ,hJc,hm,rfl⟩,hp⟩ := hex |
| refine ⟨J,m,hJ,?_,hm,hp⟩ |
| have hc := Finset.card_sdiff_of_subset hJ |
| have hle := Finset.card_le_card hJ |
| omega |
|
|
| end BoundaryOnly.FormalObstruction |
|
|
| end |
|
|
| end OAI |
|
|
