| import Mathlib |
| import OAI.GroupTheory.SimpleAmenable.Simplicial.BarRowFiniteness |
|
|
| namespace OAI |
|
|
| section |
| open _root_.CategoryTheory _root_.OAI.CategoryTheory Limits MonoidalCategory Simplicial Opposite |
| namespace IntervalBar.Diagram |
|
|
| section |
| open NerveComponents FreeChains |
|
|
| variable {C:Type} [Groupoid.{0} C] [MonoidalCategory C] [SymmetricCategory C] |
| lemma single_eqToHom {P:Type} [Monoid P] {x y:SingleObj P} (h:x=y) : eqToHom h=(1:P) := by subst y; rfl |
| noncomputable def componentSimplex {n:ℕ} (D:Diagram C (Fin (n+1))) : |
| ComposableArrows (SingleObj (Skeleton C)) n where |
| obj _ := SingleObj.star _ |
| map {i j} f := toSkeleton (D.obj i j (leOfHom f)) |
| map_id i := congr_toSkeleton_of_iso (D.unit i) |
| map_comp {i j k} f g := by |
| change toSkeleton (D.obj i k _) = toSkeleton (D.obj j k _) * toSkeleton (D.obj i j _) |
| rw [mul_comm,←Skeleton.toSkeleton_tensorObj] |
| exact (congr_toSkeleton_of_iso (D.cut i j k (leOfHom f) (leOfHom g))).symm |
| lemma componentSimplex_iso {n:ℕ} {D E:Diagram C (Fin (n+1))} (e:D≅E) : |
| componentSimplex D=componentSimplex E := by |
| apply ComposableArrows.ext (F:=componentSimplex D) (G:=componentSimplex E) (fun _=>rfl) |
| intro i hi |
| simp only [single_eqToHom,SingleObj.comp_as_mul,one_mul,mul_one] |
| exact congr_toSkeleton_of_iso (asIso (e.hom.app _ _ _)) |
| noncomputable def skeletonSimplex (n:ℕ) : Skeleton (Diagram C (Fin (n+1))) → |
| ComposableArrows (SingleObj (Skeleton C)) n := |
| Quotient.lift componentSimplex (by rintro D E ⟨e⟩; exact componentSimplex_iso e) |
| @[simp] lemma skeletonSimplex_mk {n:ℕ} (D:Diagram C (Fin (n+1))) : |
| skeletonSimplex n (toSkeleton D)=componentSimplex D := rfl |
| lemma componentSimplex_reindex {n m:ℕ} (u:⦋m⦌⟶⦋n⦌) (D:Diagram C (Fin (n+1))) : |
| componentSimplex ((reindex u.toOrderHom).obj D)= |
| (nerve (SingleObj (Skeleton C))).map u.op (componentSimplex D) := rfl |
| lemma skeletonSimplex_natural {n m:ℕ} (u:⦋m⦌⟶⦋n⦌) (p:Skeleton (Diagram C (Fin (n+1)))) : |
| skeletonSimplex m (NerveComponents.map (reindex u.toOrderHom) p)= |
| (nerve (SingleObj (Skeleton C))).map u.op (skeletonSimplex n p) := by |
| obtain ⟨D,rfl⟩ := Quotient.exists_rep p |
| rfl |
| lemma skeletonSimplex_injective (n:ℕ) : Function.Injective (skeletonSimplex (C:=C) n) := by |
| intro D E h |
| obtain ⟨D,rfl⟩ := Quotient.exists_rep D |
| obtain ⟨E,rfl⟩ := Quotient.exists_rep E |
| apply congr_toSkeleton_of_iso |
| apply (eval n).preimageIso |
| refine { hom := fun i=>?_,inv:=fun i=>?_,hom_inv_id:=?_,inv_hom_id:=?_ } |
| · exact (Skeleton.isoOfEq (congrArg (fun s:ComposableArrows (SingleObj (Skeleton C)) n=> |
| s.map (homOfLE (Fin.castSucc_le_succ i))) h)).hom |
| · exact (Skeleton.isoOfEq (congrArg (fun s:ComposableArrows (SingleObj (Skeleton C)) n=> |
| s.map (homOfLE (Fin.castSucc_le_succ i))) h)).inv |
| · funext i; exact Iso.hom_inv_id _ |
| · funext i; exact Iso.inv_hom_id _ |
| lemma skeletonSimplex_surjective (n:ℕ) : Function.Surjective (skeletonSimplex (C:=C) n) := by |
| intro s |
| let U : Fin n → C := fun i=>(fromSkeleton C).obj (s.map (homOfLE (Fin.castSucc_le_succ i))) |
| refine ⟨toSkeleton ((eval n).objPreimage U),?_⟩ |
| apply ComposableArrows.ext (fun _=>Subsingleton.elim _ _) |
| intro i hi |
| have e := ((eval n).objObjPreimageIso U) |
| simp only [single_eqToHom,SingleObj.comp_as_mul,one_mul,mul_one] |
| exact (congr_toSkeleton_of_iso (asIso (e.hom ⟨i,hi⟩))).trans (toSkeleton_fromSkeleton_obj _) |
| noncomputable def skeletonSimplexEquiv (n:ℕ) : Skeleton (Diagram C (Fin (n+1))) ≃ |
| ComposableArrows (SingleObj (Skeleton C)) n := |
| Equiv.ofBijective (skeletonSimplex n) ⟨skeletonSimplex_injective n,skeletonSimplex_surjective n⟩ |
| noncomputable def componentsZeroIso (n:ℕ) : |
| (nerve (Diagram C (Fin (n+1)))).homology Z 0 ≅ |
| (ModuleCat.free ℤ).obj ((nerve (SingleObj (Skeleton C))).obj (op ⦋n⦌)) := |
| NerveComponents.zeroIso ≪≫ (ModuleCat.free ℤ).mapIso (skeletonSimplexEquiv n).toIso |
| end |
|
|
| open NerveComponents FreeChains AlgebraicTopology |
|
|
| variable {C:Type} [Groupoid.{0} C] [MonoidalCategory C] [SymmetricCategory C] |
| lemma componentsZeroIso_natural {n m:ℕ} (u:⦋m⦌⟶⦋n⦌) : |
| SSet.homologyMap (nerveMap (reindex (C:=C) u.toOrderHom)) Z 0 ≫ (componentsZeroIso m).hom = |
| (componentsZeroIso n).hom ≫ (ModuleCat.free ℤ).map ((nerve (SingleObj (Skeleton C))).map u.op) := by |
| change SSet.homologyMap (nerveMap (reindex (C:=C) u.toOrderHom)) Z 0 ≫ |
| ((zeroIso (C:=Diagram C (Fin (m+1)))).hom ≫ |
| (ModuleCat.free ℤ).map (skeletonSimplexEquiv m).toIso.hom) = |
| ((zeroIso (C:=Diagram C (Fin (n+1)))).hom ≫ |
| (ModuleCat.free ℤ).map (skeletonSimplexEquiv n).toIso.hom) ≫ |
| (ModuleCat.free ℤ).map ((nerve (SingleObj (Skeleton C))).map u.op) |
| rw [←Category.assoc,NerveComponents.zeroIso_natural,Category.assoc,←Functor.map_comp, |
| Category.assoc] |
| erw [←Functor.map_comp] |
| congr 2 |
| apply ConcreteCategory.hom_ext |
| intro p |
| exact skeletonSimplex_natural u p |
| noncomputable def componentRowIso : |
| simplicial (C:=C) ⋙ nerveFunctor ⋙ SSet.homologyFunctor Z 0 ≅ |
| nerve (SingleObj (Skeleton C)) ⋙ ModuleCat.free ℤ := |
| NatIso.ofComponents (fun p=>componentsZeroIso p.unop.len) (fun {_ _} u=>componentsZeroIso_natural u.unop) |
| noncomputable def componentRowChainIso : |
| AlternatingFaceMapComplex.obj (simplicial (C:=C) ⋙ nerveFunctor ⋙ SSet.homologyFunctor Z 0) ≅ |
| FreeChains.complex (nerve (SingleObj (Skeleton C))) := |
| (alternatingFaceMapComplex A).mapIso componentRowIso |
| end IntervalBar.Diagram |
|
|
| end |
|
|
| open _root_.CategoryTheory _root_.OAI.CategoryTheory Limits Simplicial Opposite |
| namespace FilteredNerve |
| open FreeChains |
|
|
| variable (C:Type) [Category.{0} C] |
| def diagram : C ⥤ SSet := Over.mapFunctor C ⋙ nerveFunctor |
| def cocone : Cocone (diagram C) where |
| pt := nerve C |
| ι := { app x := nerveMap (Over.forget x) |
| naturality x y f := by change nerveMap (Over.map f ⋙ Over.forget y)=_; rfl } |
| def lastCocone {n:ℕ} (s:ComposableArrows C n) : s ⟶ (Functor.const _).obj s.right where |
| app i := s.map (homOfLE (Fin.le_last i)) |
| naturality i j f := by |
| change s.map f ≫ s.map (homOfLE (Fin.le_last j)) = s.map (homOfLE (Fin.le_last i)) ≫ 𝟙 _ |
| rw [Category.comp_id,←s.map_comp] |
| congr 1 |
| def lift {n:ℕ} (s:ComposableArrows C n) : ComposableArrows (Over s.right) n := |
| Over.lift s (lastCocone C s) |
| lemma lift_forget {n:ℕ} (s:ComposableArrows C n) : lift C s ⋙ Over.forget s.right=s := rfl |
| lemma lift_map {n:ℕ} {x:C} (s:ComposableArrows (Over x) n) : |
| lift C (s ⋙ Over.forget x) ⋙ Over.map s.right.hom=s := by |
| apply CategoryTheory.Functor.ext |
| case h_obj => |
| intro i |
| refine Comma.ext (x:=(lift C (s ⋙ Over.forget x) ⋙ Over.map s.right.hom).obj i) |
| (y:=s.obj i) rfl (Subsingleton.elim _ _) ?_ |
| apply heq_of_eq |
| change (s.map (homOfLE (Fin.le_last i))).left ≫ s.right.hom=(s.obj i).hom |
| exact (s.map (homOfLE (Fin.le_last i))).w |
| case h_map => |
| intro i j f |
| apply Over.OverMorphism.ext |
| simp only [Functor.comp_map,Over.comp_left] |
| erw [Over.eqToHom_left,Over.eqToHom_left] |
| simp [lift,Over.lift] |
| erw [eqToHom_refl,Category.id_comp] |
| noncomputable def pointwiseIsColimit (n:ℕ) : |
| IsColimit (((evaluation _ (Type)).obj (op ⦋n⦌)).mapCocone (cocone C)) where |
| desc d := ↾fun s => d.ι.app s.right (lift C s) |
| fac d x := by |
| ext s |
| have h:=congrArg (fun k => k (lift C (s ⋙ Over.forget x))) (d.w s.right.hom) |
| change d.ι.app x (lift C (s ⋙ Over.forget x) ⋙ Over.map s.right.hom)=_ at h |
| erw [lift_map] at h |
| exact h.symm |
| uniq d m hm := by |
| ext s |
| have h:=congrArg (fun k => k (lift C s)) (hm s.right) |
| exact h |
| noncomputable def isColimit : IsColimit (cocone C) := |
| evaluationJointlyReflectsColimits _ (fun n => pointwiseIsColimit C n.unop.len) |
| lemma terminal_acyclic {D:Type} [Category.{0} D] (d:D) (hd:IsTerminal d) |
| (n:ℕ) (hn:n≠0) : IsZero ((nerve D).homology Z n) := by |
| let α : 𝟭 D ⟶ (Functor.const D).obj d := |
| { app x := hd.from x |
| naturality x y f := hd.hom_ext _ _ } |
| have h := (NerveHomotopy.ofNatTrans α).congr_homologyMap Z n |
| change SSet.homologyMap (𝟙 (nerve D)) Z n = SSet.homologyMap (nerveMap ((Functor.const D).obj d)) Z n at h |
| rw [SSet.homologyMap_id,CategoryTheory.nerve.const_map] at h |
| erw [ConnectedProduct.const_homology_zero _ n hn] at h |
| exact (IsZero.iff_id_eq_zero _).mpr h |
| instance connected [IsFiltered C] : (nerve C).IsConnected where |
| allEq u v := by |
| obtain ⟨x,rfl⟩ := SSet.π₀.mk_surjective u |
| obtain ⟨y,rfl⟩ := SSet.π₀.mk_surjective v |
| let a := nerveEquiv x |
| let b := nerveEquiv y |
| have h₁ := SSet.π₀.sound (nerve.edgeMk (IsFiltered.leftToMax a b)) |
| have h₂ := SSet.π₀.sound (nerve.edgeMk (IsFiltered.rightToMax a b)) |
| have component_eq := h₁.trans h₂.symm |
| change SSet.π₀.mk (X:=nerve C) (nerveEquiv.symm (nerveEquiv x)) = |
| SSet.π₀.mk (X:=nerve C) (nerveEquiv.symm (nerveEquiv y)) at component_eq |
| erw [Equiv.symm_apply_apply,Equiv.symm_apply_apply] at component_eq |
| exact component_eq |
| nonempty := by |
| let := IsFiltered.nonempty (C:=C) |
| exact ⟨nerveEquiv.symm (Classical.arbitrary C)⟩ |
| lemma positive_acyclic [IsFiltered C] (n:ℕ) (hn:n≠0) : IsZero ((nerve C).homology Z n) := by |
| let h:=isColimitOfPreserves (SSet.homologyFunctor Z n) (isColimit C) |
| apply (IsZero.iff_id_eq_zero _).mpr |
| apply h.hom_ext |
| intro x |
| have hz : IsZero ((nerve (Over x)).homology Z n) := |
| terminal_acyclic (Over.mk (𝟙 x)) Over.mkIdTerminal n hn |
| exact hz.eq_of_src _ _ |
| end FilteredNerve |
|
|
| end OAI |
|
|
