| import Mathlib |
| import OAI.GroupTheory.SimpleAmenable.Simplicial.IntervalFunctor |
|
|
| namespace OAI |
|
|
| namespace IntervalBar.Diagram |
| |
| section |
|
|
| open CategoryTheory MonoidalCategory BraidedCategory |
| open Functor.LaxMonoidal Functor.OplaxMonoidal |
| universe u v w |
|
|
| section |
|
|
| variable {C : Type u} [Groupoid.{v} C] [MonoidalCategory C] [SymmetricCategory C] |
| variable {I J K L : Type w} [Preorder I] [Preorder J] [Preorder K] [Preorder L] |
| @[simp] lemma map_reindex_id : |
| map (I:=I) (reindex (C:=C) (OrderHom.id (α:=J)))=𝟭 _ := by |
| refine CategoryTheory.Functor.ext (fun A => ?_) ?_ |
| · refine ext_heq ?_ ?_ ?_ |
| · rfl |
| · apply heq_of_eq |
| apply Iso.ext; apply Hom.ext; intro j k h |
| change (A.unit i).hom.app j k h ≫ 𝟙 _ = _ |
| exact Category.comp_id _ |
| · apply heq_of_eq |
| apply Iso.ext; apply Hom.ext; intro l m h |
| change 𝟙 _ ≫ (A.cut i j k hij hjk).hom.app l m h = _ |
| exact Category.id_comp _ |
| · intro A B f |
| apply Hom.ext; intro i j h |
| erw [comp_app, comp_app, eqToHom_app, eqToHom_app] |
| apply Hom.ext; intro l m hlm |
| erw [comp_app, comp_app, eqToHom_app, eqToHom_app] |
| simp [map,reindex] |
| change (f.app i j h).app l m hlm = 𝟙 _ ≫ (f.app i j h).app l m hlm ≫ 𝟙 _ |
| simp |
| @[simp] lemma map_reindex_comp (f : J →o K) (g : K →o L) : |
| map (I:=I) (reindex (C:=C) (g.comp f)) = map (reindex g) ⋙ map (reindex f) := by |
| refine CategoryTheory.Functor.ext (fun A => ?_) ?_ |
| · refine ext_heq ?_ ?_ ?_ |
| · rfl |
| · apply heq_of_eq |
| apply Iso.ext; apply Hom.ext; intro j k h |
| change (A.unit i).hom.app (g (f j)) (g (f k)) _ ≫ 𝟙 _ = |
| ((A.unit i).hom.app (g (f j)) (g (f k)) _ ≫ 𝟙 _) ≫ 𝟙 _ |
| simp |
| · apply heq_of_eq |
| apply Iso.ext; apply Hom.ext; intro l m h |
| change 𝟙 _ ≫ (A.cut i j k hij hjk).hom.app (g (f l)) (g (f m)) _ = |
| 𝟙 _ ≫ (𝟙 _ ≫ (A.cut i j k hij hjk).hom.app (g (f l)) (g (f m)) _) |
| simp |
| · intro A B h |
| apply Hom.ext; intro i j hij |
| erw [comp_app, comp_app, eqToHom_app, eqToHom_app] |
| apply Hom.ext; intro l m hlm |
| erw [comp_app, comp_app, eqToHom_app, eqToHom_app] |
| simp [map,reindex] |
| change (h.app i j hij).app (g (f l)) (g (f m)) _ = |
| 𝟙 _ ≫ (h.app i j hij).app (g (f l)) (g (f m)) _ ≫ 𝟙 _ |
| simp |
|
|
| noncomputable def reindex₂ (f : I →o J) (g : K →o L) : |
| Diagram (Diagram C L) J ⥤ Diagram (Diagram C K) I := |
| reindex f ⋙ map (reindex g) |
|
|
| @[simp] lemma reindex₂_id : |
| reindex₂ (C:=C) (OrderHom.id (α:=I)) (OrderHom.id (α:=J)) = 𝟭 _ := by |
| simp [reindex₂] |
|
|
| end |
|
|
| open CategoryTheory |
|
|
| variable {C : Type u} [Groupoid.{v} C] [MonoidalCategory C] [SymmetricCategory C] |
| variable {I₁ I₂ I₃ J₁ J₂ J₃ : Type w} |
| [Preorder I₁] [Preorder I₂] [Preorder I₃] [Preorder J₁] [Preorder J₂] [Preorder J₃] |
| |
| lemma reindex₂_comp (f₁ : I₁ →o I₂) (f₂ : I₂ →o I₃) |
| (g₁ : J₁ →o J₂) (g₂ : J₂ →o J₃) : |
| reindex₂ (C:=C) (f₂.comp f₁) (g₂.comp g₁) = |
| reindex₂ f₂ g₂ ⋙ reindex₂ f₁ g₁ := by |
| simp only [reindex₂,reindex_comp,map_reindex_comp,Functor.assoc] |
| rw [←Functor.assoc (map (reindex g₂)),←reindex_map,Functor.assoc] |
|
|
| open scoped Simplicial |
| noncomputable def bisimplicial : (SimplexCategoryᵒᵖ × SimplexCategoryᵒᵖ) ⥤ Cat.{v,max u v} where |
| obj n := Cat.of (Diagram (Diagram C (Fin (n.2.unop.len+1))) (Fin (n.1.unop.len+1))) |
| map f := (reindex₂ f.1.unop.toOrderHom f.2.unop.toOrderHom).toCatHom |
| map_id n := by apply Cat.ext; exact reindex₂_id |
| map_comp f g := by |
| apply Cat.ext |
| exact reindex₂_comp g.1.unop.toOrderHom f.1.unop.toOrderHom |
| g.2.unop.toOrderHom f.2.unop.toOrderHom |
| end |
|
|
| section |
|
|
| open CategoryTheory MonoidalCategory |
| universe u v w u₁ u₂ |
| variable {C : Type u} [Groupoid.{v} C] [MonoidalCategory C] |
| variable {I : Type w} [Preorder I] |
|
|
| omit [MonoidalCategory C] in |
| lemma iso_hext {X X' Y Y' : C} (hX : X=X') (hY : Y=Y') |
| (f : X ≅ Y) (g : X' ≅ Y') (h : HEq f.hom g.hom) : HEq f g := by |
| cases hX |
| exact heq_of_eq (Iso.ext (eq_of_heq h)) |
|
|
| lemma hom_hext {A A' B B' : Diagram C I} (hA : A=A') (hB : B=B') |
| (f : A ⟶ B) (g : A' ⟶ B') (h : ∀ i j hij, HEq (f.app i j hij) (g.app i j hij)) : |
| HEq f g := by |
| cases hA |
| exact heq_of_eq (Hom.ext (fun i j hij => eq_of_heq (h i j hij))) |
|
|
| lemma hfunext {α : Sort u₁} {β β' : α → Sort u₂} {f : ∀ a, β a} {g : ∀ a, β' a} |
| (h : ∀ a, HEq (f a) (g a)) : HEq f g := |
| Function.hfunext rfl (by intro a b hab |
| end |
|
|
| open CategoryTheory MonoidalCategory BraidedCategory |
| open Functor.LaxMonoidal Functor.OplaxMonoidal |
| universe u v w |
|
|
| variable {C : Type u} [Groupoid.{v} C] [MonoidalCategory C] [SymmetricCategory C] |
| variable {I J K : Type w} [Preorder I] [Preorder J] [Preorder K] |
|
|
| noncomputable instance reindex₂Braided {L : Type w} [Preorder L] |
| (f : I →o J) (g : K →o L) : (reindex₂ (C:=C) f g).Braided := by |
| unfold reindex₂ |
| infer_instance |
|
|
| @[simp] lemma map_ε_app {D : Type*} [Groupoid D] [MonoidalCategory D] [SymmetricCategory D] |
| (F : C ⥤ D) [F.Braided] (i j : I) (h : i≤j) : |
| (ε (map (I:=I) F)).app i j h = ε F := rfl |
|
|
| @[simp] lemma map_η_app {D : Type*} [Groupoid D] [MonoidalCategory D] [SymmetricCategory D] |
| (F : C ⥤ D) [F.Braided] (i j : I) (h : i≤j) : |
| (η (map (I:=I) F)).app i j h = η F := by |
| apply (cancel_mono (ε F)).mp |
| have hh := congrArg (fun f : (map (I:=I) F).obj (𝟙_ (Diagram C I)) ⟶ |
| (map (I:=I) F).obj (𝟙_ (Diagram C I)) => f.app i j h) |
| (Functor.Monoidal.η_ε (map (I:=I) F)) |
| simp only [comp_app,map_ε_app,id_app] at hh |
| simpa only [Functor.Monoidal.η_ε, map, mapObj, tensorUnit_obj] using hh |
|
|
| @[simp] lemma map_μ_app {D : Type*} [Groupoid D] [MonoidalCategory D] [SymmetricCategory D] |
| (F : C ⥤ D) [F.Braided] (A B : Diagram C I) (i j : I) (h : i≤j) : |
| (μ (map (I:=I) F) A B).app i j h = μ F (A.obj i j h) (B.obj i j h) := rfl |
|
|
| @[simp] lemma reindex_η_app (f : I →o J) (i j : I) (h : i≤j) : |
| (η (reindex (C:=C) f)).app i j h = 𝟙 _ := rfl |
|
|
| @[simp] lemma reindex_μ_app (f : I →o J) (A B : Diagram C J) (i j : I) (h : i≤j) : |
| (μ (reindex (C:=C) f) A B).app i j h = 𝟙 _ := rfl |
|
|
| omit [SymmetricCategory C] in |
| @[simp] lemma reindex_map_app (f : I →o J) {A B : Diagram C J} (g : A ⟶ B) |
| (i j : I) (h : i≤j) : ((reindex f).map g).app i j h = g.app (f i) (f j) (f.monotone h) := rfl |
|
|
| omit [SymmetricCategory C] in |
| @[simp] lemma map_map_app {D : Type*} [Groupoid D] [MonoidalCategory D] |
| (F : C ⥤ D) [F.Monoidal] {A B : Diagram C I} (g : A ⟶ B) |
| (i j : I) (h : i≤j) : ((map F).map g).app i j h = F.map (g.app i j h) := rfl |
|
|
| omit [SymmetricCategory C] in |
| @[simp] lemma map_obj {D : Type*} [Groupoid D] [MonoidalCategory D] |
| (F : C ⥤ D) [F.Monoidal] (A : Diagram C I) : (map F).obj A = mapObj F A := rfl |
|
|
| private lemma reindex₂_η_app {L : Type w} [Preorder L] |
| (f : I →o J) (g : K →o L) (i j : I) (h : i ≤ j) |
| (k l : K) (hkl : k ≤ l) : |
| ((η (reindex₂ (C:=C) f g)).app i j h).app k l hkl = 𝟙 _ := by |
| change (((map (reindex g)).map (η (reindex f)) ≫ η (map (reindex g))).app i j h).app k l hkl = _ |
| erw [comp_app, map_map_app (C:=Diagram C L) (I:=I) (reindex g), |
| map_η_app (C:=Diagram C L) (I:=I) (reindex g) i j h, |
| reindex_map_app (C:=C) g, reindex_η_app (C:=Diagram C L) f i j h, |
| reindex_η_app (C:=C) g k l hkl] |
| change 𝟙 (𝟙_ C) ≫ 𝟙 (𝟙_ C) = 𝟙 (𝟙_ C) |
| exact Category.id_comp _ |
|
|
| private lemma map_reindex₂_unit_app {J' K' : Type w} [Preorder J'] [Preorder K'] |
| (f : J →o J') (g : K →o K') (A : Diagram (Diagram (Diagram C K') J') I) |
| (i : I) (j k : J) (h : j ≤ k) (l m : K) (hlm : l ≤ m) : |
| ((((map (reindex₂ f g)).obj A).unit i).hom.app j k h).app l m hlm = |
| ((A.unit i).hom.app (f j) (f k) (f.monotone h)).app (g l) (g m) (g.monotone hlm) := by |
| change (((reindex₂ f g).map (A.unit i).hom ≫ η (reindex₂ f g)).app j k h).app l m hlm = _ |
| erw [comp_app, reindex₂_η_app] |
| change ((A.unit i).hom.app (f j) (f k) (f.monotone h)).app (g l) (g m) (g.monotone hlm) ≫ 𝟙 _ = _ |
| exact Category.comp_id _ |
|
|
| @[simp] lemma map_reindex₂_id : |
| map (I:=I) (reindex₂ (C:=C) (OrderHom.id (α:=J)) (OrderHom.id (α:=K)))=𝟭 _ := by |
| refine CategoryTheory.Functor.ext (fun A => ?_) ?_ |
| · refine ext_heq ?_ ?_ ?_ |
| · funext i j h |
| exact congrArg (fun F => F.obj (A.obj i j h)) reindex₂_id |
| · apply hfunext |
| apply iso_hext (congrArg (fun F => F.obj (A.obj i i le_rfl)) reindex₂_id) rfl |
| apply hom_hext (congrArg (fun F => F.obj (A.obj i i le_rfl)) reindex₂_id) rfl |
| intro j k h |
| apply hom_hext rfl rfl |
| intro l m hlm |
| apply heq_of_eq |
| exact map_reindex₂_unit_app (OrderHom.id (α:=J)) (OrderHom.id (α:=K)) A i j k h l m hlm |
| · apply hfunext |
| apply hfunext |
| apply hfunext |
| apply hfunext |
| apply hfunext |
| refine iso_hext ?_ ?_ _ _ ?_ |
| · exact congrArg₂ (fun X Y => X ⊗ Y) |
| (congrArg (fun F => F.obj (A.obj i j hij)) reindex₂_id) |
| (congrArg (fun F => F.obj (A.obj j k hjk)) reindex₂_id) |
| · exact congrArg (fun F => F.obj (A.obj i k (hij.trans hjk))) reindex₂_id |
| refine hom_hext ?_ ?_ _ _ ?_ |
| · exact congrArg₂ (fun X Y => X ⊗ Y) |
| (congrArg (fun F => F.obj (A.obj i j hij)) reindex₂_id) |
| (congrArg (fun F => F.obj (A.obj j k hjk)) reindex₂_id) |
| · exact congrArg (fun F => F.obj (A.obj i k (hij.trans hjk))) reindex₂_id |
| intro l m hlm |
| apply hom_hext rfl rfl |
| intro n p hnp |
| apply heq_of_eq |
| change (𝟙 _ ≫ 𝟙 _) ≫ ((A.cut i j k hij hjk).hom.app l m hlm).app n p hnp = |
| ((A.cut i j k hij hjk).hom.app l m hlm).app n p hnp |
| simp only [Category.id_comp] |
| · intro A B f |
| apply Hom.ext; intro i j h |
| erw [comp_app, comp_app, eqToHom_app, eqToHom_app] |
| apply Hom.ext; intro l m hlm |
| erw [comp_app, comp_app, eqToHom_app, eqToHom_app] |
| apply Hom.ext; intro n p hnp |
| erw [comp_app, comp_app, eqToHom_app, eqToHom_app] |
| simp only [map, reindex₂, reindex] |
| erw [Category.id_comp, Category.comp_id] |
| rfl |
|
|
| variable {J₁ J₂ J₃ K₁ K₂ K₃ : Type w} |
| [Preorder J₁] [Preorder J₂] [Preorder J₃] [Preorder K₁] [Preorder K₂] [Preorder K₃] |
| lemma map_reindex₂_comp (f₁ : J₁ →o J₂) (f₂ : J₂ →o J₃) |
| (g₁ : K₁ →o K₂) (g₂ : K₂ →o K₃) : |
| map (I:=I) (reindex₂ (C:=C) (f₂.comp f₁) (g₂.comp g₁)) = |
| map (reindex₂ f₂ g₂) ⋙ map (reindex₂ f₁ g₁) := by |
| have hF := reindex₂_comp (C:=C) f₁ f₂ g₁ g₂ |
| have hO (X : Diagram (Diagram C K₃) J₃) := congrArg (fun F => F.obj X) hF |
| refine CategoryTheory.Functor.ext (fun A => ?_) ?_ |
| · refine ext_heq ?_ ?_ ?_ |
| · funext i j h |
| · apply hfunext |
| refine iso_hext (hO (A.obj i i le_rfl)) rfl _ _ ?_ |
| refine hom_hext (hO (A.obj i i le_rfl)) rfl _ _ ?_ |
| intro j k h |
| apply hom_hext rfl rfl |
| intro l m hlm |
| apply heq_of_eq |
| change ((((map (reindex₂ (f₂.comp f₁) (g₂.comp g₁))).obj A).unit i).hom.app j k h).app l m hlm = |
| ((((map (reindex₂ f₁ g₁)).obj ((map (reindex₂ f₂ g₂)).obj A)).unit i).hom.app j k h).app l m hlm |
| erw [map_reindex₂_unit_app, map_reindex₂_unit_app, map_reindex₂_unit_app] |
| rfl |
| · apply hfunext |
| apply hfunext |
| apply hfunext |
| apply hfunext |
| apply hfunext |
| have hx := congrArg₂ (fun X Y => X⊗Y) (hO (A.obj i j hij)) (hO (A.obj j k hjk)) |
| have hy := hO (A.obj i k (hij.trans hjk)) |
| refine iso_hext hx hy _ _ ?_ |
| refine hom_hext hx hy _ _ ?_ |
| intro l m hlm |
| apply hom_hext rfl rfl |
| intro n p hnp |
| apply heq_of_eq |
| change (𝟙 _ ≫ 𝟙 _) ≫ |
| ((A.cut i j k hij hjk).hom.app (f₂ (f₁ l)) (f₂ (f₁ m)) _).app (g₂ (g₁ n)) (g₂ (g₁ p)) _ = |
| (𝟙 _ ≫ 𝟙 _) ≫ ((𝟙 _ ≫ 𝟙 _) ≫ |
| ((A.cut i j k hij hjk).hom.app (f₂ (f₁ l)) (f₂ (f₁ m)) _).app (g₂ (g₁ n)) (g₂ (g₁ p)) _) |
| simp |
| · intro A B f |
| apply Hom.ext; intro i j h |
| erw [comp_app, comp_app, eqToHom_app, eqToHom_app] |
| apply Hom.ext; intro l m hlm |
| erw [comp_app, comp_app, eqToHom_app, eqToHom_app] |
| apply Hom.ext; intro n p hnp |
| erw [comp_app, comp_app, eqToHom_app, eqToHom_app] |
| simp only [map, reindex₂, reindex] |
| erw [Category.id_comp, Category.comp_id] |
| rfl |
|
|
| noncomputable def reindex₃ (f : I →o J) (g : J₁ →o J₂) (h : K₁ →o K₂) : |
| Diagram (Diagram (Diagram C K₂) J₂) J ⥤ Diagram (Diagram (Diagram C K₁) J₁) I := |
| reindex f ⋙ map (reindex₂ g h) |
|
|
| @[simp] lemma reindex₃_id : reindex₃ (C:=C) (OrderHom.id (α:=I)) |
| (OrderHom.id (α:=J)) (OrderHom.id (α:=K))=𝟭 _ := by |
| simp [reindex₃] |
|
|
| variable {I₁ I₂ I₃ : Type w} [Preorder I₁] [Preorder I₂] [Preorder I₃] |
| lemma reindex₃_comp (e₁ : I₁ →o I₂) (e₂ : I₂ →o I₃) |
| (f₁ : J₁ →o J₂) (f₂ : J₂ →o J₃) (g₁ : K₁ →o K₂) (g₂ : K₂ →o K₃) : |
| reindex₃ (C:=C) (e₂.comp e₁) (f₂.comp f₁) (g₂.comp g₁) = |
| reindex₃ e₂ f₂ g₂ ⋙ reindex₃ e₁ f₁ g₁ := by |
| simp only [reindex₃,reindex_comp,map_reindex₂_comp,Functor.assoc] |
| rw [←Functor.assoc (map (reindex₂ f₂ g₂)),←reindex_map,Functor.assoc] |
|
|
| open scoped Simplicial |
| noncomputable def trisimplicial : |
| (SimplexCategoryᵒᵖ × SimplexCategoryᵒᵖ × SimplexCategoryᵒᵖ) ⥤ Cat.{v,max u v} where |
| obj n := Cat.of (Diagram (Diagram (Diagram C (Fin (n.2.2.unop.len+1))) |
| (Fin (n.2.1.unop.len+1))) (Fin (n.1.unop.len+1))) |
| map f := (reindex₃ f.1.unop.toOrderHom f.2.1.unop.toOrderHom f.2.2.unop.toOrderHom).toCatHom |
| map_id n := by apply Cat.ext; exact reindex₃_id |
| map_comp f g := by |
| apply Cat.ext |
| exact reindex₃_comp g.1.unop.toOrderHom f.1.unop.toOrderHom |
| g.2.1.unop.toOrderHom f.2.1.unop.toOrderHom |
| g.2.2.unop.toOrderHom f.2.2.unop.toOrderHom |
|
|
| end IntervalBar.Diagram |
| |
| end OAI |
|
|
