| import Mathlib |
| import OAI.GroupTheory.SimpleAmenable.Configurations.BooleanStages |
|
|
| namespace OAI |
|
|
| section |
|
|
| section |
|
|
| open CategoryTheory Classical MonoidalCategory |
| namespace SimpleAmenable.PolygonObject |
|
|
| namespace Labelled |
| variable {a n : ℕ} |
|
|
| noncomputable abbrev sum (U V : Labelled a n) : Labelled a n where |
| polygon := PolygonObject.sum U.polygon V.polygon |
| label := Fin.addCases U.label V.label |
| reduced j i := by |
| refine Fin.addCases ?_ ?_ j |
| · intro k; simpa only [Fin.addCases_left] using U.reduced k i |
| · intro k; simpa only [Fin.addCases_right] using V.reduced k i |
| |
| noncomputable abbrev empty : Labelled a n where |
| polygon := PolygonObject.empty |
| label := Fin.elim0 |
| reduced := fun j => Fin.elim0 j |
|
|
| @[simp] lemma sum_label_left (U V : Labelled a n) (x : U.polygon.Point) : |
| (sum U V).label (sumPointEquiv U.polygon V.polygon (.inl x)).val.1=U.label x.val.1 := by |
| simp [sumPointEquiv_inl] |
| @[simp] lemma sum_label_right (U V : Labelled a n) (x : V.polygon.Point) : |
| (sum U V).label (sumPointEquiv U.polygon V.polygon (.inr x)).val.1=V.label x.val.1 := by |
| simp [sumPointEquiv_inr] |
|
|
| noncomputable def sumHom {U V W Z : Labelled a n} (f : U ⟶ W) (g : V ⟶ Z) : |
| sum U V ⟶ sum W Z where |
| arrow := sumArrow f.arrow g.arrow |
| positional := sumArrow_positional f.positional g.positional |
| labelled x := by |
| obtain ⟨y,rfl⟩ := (sumPointEquiv U.polygon V.polygon).surjective x |
| cases y with |
| | inl y => simpa only [sumArrow_inl,sumPointEquiv_inl,Fin.addCases_left] using f.labelled y |
| | inr y => simpa only [sumArrow_inr,sumPointEquiv_inr,Fin.addCases_right] using g.labelled y |
|
|
| noncomputable def assocHom (U V W : Labelled a n) : sum (sum U V) W ⟶ sum U (sum V W) where |
| arrow := sumAssoc U.polygon V.polygon W.polygon |
| positional := sumAssoc_positional _ _ _ |
| labelled x := by |
| obtain ⟨y,rfl⟩ := (sumPointEquiv (sum U V).polygon W.polygon).surjective x |
| cases y with |
| | inl y => |
| obtain ⟨z,rfl⟩ := (sumPointEquiv U.polygon V.polygon).surjective y |
| cases z <;> simp only [sumAssoc_apply,sumAssocEquiv_left,sumAssocEquiv_mid, |
| sumPointEquiv_inl,sumPointEquiv_inr] <;> |
| simp only [PolygonObject.sum,Fin.addCases_left,Fin.addCases_right] |
| | inr y => |
| simp only [sumAssoc_apply,sumAssocEquiv_right,sumPointEquiv_inr] |
| simp only [PolygonObject.sum,Fin.addCases_right] |
| |
| noncomputable def leftHom (U : Labelled a n) : sum empty U ⟶ U where |
| arrow := leftUnit U.polygon |
| positional := leftUnit_positional _ |
| labelled x := by |
| obtain ⟨y,rfl⟩ := (sumPointEquiv PolygonObject.empty U.polygon).surjective x |
| cases y with |
| | inl y => exact isEmptyElim y |
| | inr y => |
| simp only [leftUnit_apply,leftUnitEquiv_apply,sumPointEquiv_inr] |
| simp only [PolygonObject.empty,Fin.addCases_right] |
|
|
| noncomputable def rightHom (U : Labelled a n) : sum U empty ⟶ U where |
| arrow := rightUnit U.polygon |
| positional := rightUnit_positional _ |
| labelled x := by |
| obtain ⟨y,rfl⟩ := (sumPointEquiv U.polygon PolygonObject.empty).surjective x |
| cases y with |
| | inl y => |
| simp only [rightUnit_apply,rightUnitEquiv_apply,sumPointEquiv_inl] |
| simp only [PolygonObject.empty,Fin.addCases_left] |
| | inr y => exact isEmptyElim y |
|
|
| noncomputable def swapHom (U V : Labelled a n) : sum U V ⟶ sum V U where |
| arrow := sumSwap U.polygon V.polygon |
| positional := sumSwap_positional _ _ |
| labelled x := by |
| obtain ⟨y,rfl⟩ := (sumPointEquiv U.polygon V.polygon).surjective x |
| cases y <;> simp only [sumSwap_apply,sumSwapEquiv_inl,sumSwapEquiv_inr, |
| sumPointEquiv_inl,sumPointEquiv_inr,Fin.addCases_left,Fin.addCases_right] |
| |
| instance : (forget (a:=a) (n:=n)).Faithful where |
| map_injective h := Hom.ext _ _ h |
|
|
| noncomputable instance : MonoidalCategoryStruct (Labelled a n) where |
| tensorObj := sum |
| tensorHom := sumHom |
| whiskerLeft U _ _ f := sumHom (𝟙 U) f |
| whiskerRight f U := sumHom f (𝟙 U) |
| tensorUnit := empty |
| associator U V W := asIso (assocHom U V W) |
| leftUnitor U := asIso (leftHom U) |
| rightUnitor U := asIso (rightHom U) |
|
|
| noncomputable def inducing : Monoidal.InducingFunctorData (forget (a:=a) (n:=n)) where |
| μIso _ _ := Iso.refl _ |
| εIso := Iso.refl _ |
| whiskerLeft_eq := by intros; simp only [Iso.refl_hom,Iso.refl_inv]; rfl |
| whiskerRight_eq := by intros; simp only [Iso.refl_hom,Iso.refl_inv]; rfl |
| tensorHom_eq := by intros; simp only [Iso.refl_hom,Iso.refl_inv]; rfl |
| associator_eq := by |
| intro U V W |
| change sumAssoc U.polygon V.polygon W.polygon = |
| (𝟙 _ ≫ sumArrow (𝟙 _) (𝟙 _)) ≫ sumAssoc U.polygon V.polygon W.polygon ≫ |
| (sumArrow (𝟙 _) (𝟙 _) ≫ 𝟙 _) |
| simp only [sumArrow_id,Category.id_comp,Category.comp_id] |
| leftUnitor_eq := by |
| intro U |
| change leftUnit U.polygon = (𝟙 _ ≫ sumArrow (𝟙 _) (𝟙 _)) ≫ leftUnit U.polygon |
| rw [sumArrow_id,Category.id_comp,Category.id_comp] |
| rightUnitor_eq := by |
| intro U |
| change rightUnit U.polygon = (𝟙 _ ≫ sumArrow (𝟙 _) (𝟙 _)) ≫ rightUnit U.polygon |
| rw [sumArrow_id,Category.id_comp,Category.id_comp] |
|
|
| noncomputable instance : MonoidalCategory (Labelled a n) := Monoidal.induced forget inducing |
| noncomputable instance : (forget (a:=a) (n:=n)).Monoidal := |
| Functor.CoreMonoidal.toMonoidal (Monoidal.fromInducedCoreMonoidal forget inducing) |
|
|
| noncomputable instance : BraidedCategory (Labelled a n) where |
| braiding U V := asIso (swapHom U V) |
| braiding_naturality_left := by |
| intro U V f W |
| apply forget.map_injective |
| exact BraidedCategory.braiding_naturality_left f.arrow W.polygon |
| braiding_naturality_right := by |
| intro U V W f |
| apply forget.map_injective |
| exact BraidedCategory.braiding_naturality_right U.polygon f.arrow |
| hexagon_forward := by |
| intro U V W |
| apply forget.map_injective |
| exact BraidedCategory.hexagon_forward U.polygon V.polygon W.polygon |
| hexagon_reverse := by |
| intro U V W |
| apply forget.map_injective |
| change (inv (assocHom U V W)).arrow ≫ (swapHom (sum U V) W).arrow ≫ |
| (inv (assocHom W U V)).arrow = |
| sumArrow (𝟙 U.polygon) (swapHom V W).arrow ≫ (inv (assocHom U W V)).arrow ≫ |
| sumArrow (swapHom U W).arrow (𝟙 V.polygon) |
| simp only [inv_arrow] |
| exact BraidedCategory.hexagon_reverse U.polygon V.polygon W.polygon |
|
|
| noncomputable instance : SymmetricCategory (Labelled a n) where |
| symmetry U V := by |
| apply forget.map_injective |
| exact SymmetricCategory.symmetry U.polygon V.polygon |
|
|
| end Labelled |
| end SimpleAmenable.PolygonObject |
|
|
| end |
|
|
| end |
|
|
| end OAI |
|
|
