| import Mathlib |
| import OAI.GroupTheory.SimpleAmenable.Configurations.TrajectoryStages |
|
|
| namespace OAI |
|
|
| section |
|
|
| section |
|
|
| open CategoryTheory MonoidalCategory |
| namespace SimpleAmenable.PolygonObject.FiniteSetGroupoid |
|
|
| abbrev toEquiv {U V : FiniteSetGroupoid} (f : U ⟶ V) : Fin U.size ≃ Fin V.size := f |
| instance {U V : FiniteSetGroupoid} : CoeFun (U ⟶ V) (fun _ => Fin U.size → Fin V.size) := |
| ⟨fun f => toEquiv f⟩ |
| lemma hom_ext {U V : FiniteSetGroupoid} (f g : U ⟶ V) (h : ∀x,f x=g x) : f=g := Equiv.ext h |
| abbrev sum (U V : FiniteSetGroupoid) : FiniteSetGroupoid := ⟨U.size+V.size⟩ |
| abbrev empty : FiniteSetGroupoid := ⟨0⟩ |
| def sumEquiv (U V : FiniteSetGroupoid) : Fin U.size ⊕ Fin V.size ≃ Fin (sum U V).size := |
| finSumFinEquiv |
| |
| def sumHom {U V W Z : FiniteSetGroupoid} (f : U ⟶ W) (g : V ⟶ Z) : sum U V ⟶ sum W Z := |
| (sumEquiv U V).symm.trans ((Equiv.sumCongr f g).trans (sumEquiv W Z)) |
| def assoc (U V W : FiniteSetGroupoid) : sum (sum U V) W ⟶ sum U (sum V W) := |
| (sumEquiv (sum U V) W).symm.trans |
| ((Equiv.sumCongr (sumEquiv U V).symm (Equiv.refl _)).trans |
| ((Equiv.sumAssoc _ _ _).trans |
| ((Equiv.sumCongr (Equiv.refl _) (sumEquiv V W)).trans (sumEquiv U (sum V W))))) |
| def swap (U V : FiniteSetGroupoid) : sum U V ⟶ sum V U := |
| (sumEquiv U V).symm.trans ((Equiv.sumComm _ _).trans (sumEquiv V U)) |
| def left (U : FiniteSetGroupoid) : sum empty U ⟶ U := |
| (sumEquiv empty U).symm.trans (Equiv.emptySum _ _) |
| def right (U : FiniteSetGroupoid) : sum U empty ⟶ U := |
| (sumEquiv U empty).symm.trans (Equiv.sumEmpty _ _) |
| @[simp] lemma comp_eq {U V W : FiniteSetGroupoid} (f : U ⟶ V) (g : V ⟶ W) : |
| (f≫g : U ⟶ W) = (toEquiv f).trans (toEquiv g) := rfl |
| @[simp] lemma id_eq (U : FiniteSetGroupoid) : (𝟙 U : U ⟶ U) = Equiv.refl _ := rfl |
| @[simp] lemma comp_apply {U V W : FiniteSetGroupoid} (f : U ⟶ V) (g : V ⟶ W) (x : Fin U.size) : |
| (f≫g) x=g (f x) := rfl |
| @[simp] lemma id_apply (U : FiniteSetGroupoid) (x : Fin U.size) : (𝟙 U : U ⟶ U) x=x := rfl |
| @[simp] lemma sumHom_inl {U V W Z : FiniteSetGroupoid} (f : U ⟶ W) (g : V ⟶ Z) (x : Fin U.size) : |
| sumHom f g (sumEquiv U V (.inl x))=sumEquiv W Z (.inl (f x)) := by simp [sumHom] |
| @[simp] lemma sumHom_inr {U V W Z : FiniteSetGroupoid} (f : U ⟶ W) (g : V ⟶ Z) (x : Fin V.size) : |
| sumHom f g (sumEquiv U V (.inr x))=sumEquiv W Z (.inr (g x)) := by simp [sumHom] |
| @[simp] lemma assoc_left (U V W : FiniteSetGroupoid) (x : Fin U.size) : |
| assoc U V W (sumEquiv (sum U V) W (.inl (sumEquiv U V (.inl x))))= |
| sumEquiv U (sum V W) (.inl x) := by simp [assoc] |
| @[simp] lemma assoc_mid (U V W : FiniteSetGroupoid) (x : Fin V.size) : |
| assoc U V W (sumEquiv (sum U V) W (.inl (sumEquiv U V (.inr x))))= |
| sumEquiv U (sum V W) (.inr (sumEquiv V W (.inl x))) := by simp [assoc] |
| @[simp] lemma assoc_right (U V W : FiniteSetGroupoid) (x : Fin W.size) : |
| assoc U V W (sumEquiv (sum U V) W (.inr x))= |
| sumEquiv U (sum V W) (.inr (sumEquiv V W (.inr x))) := by simp [assoc] |
| @[simp] lemma swap_left (U V : FiniteSetGroupoid) (x : Fin U.size) : |
| swap U V (sumEquiv U V (.inl x))=sumEquiv V U (.inr x) := by simp [swap] |
| @[simp] lemma swap_right (U V : FiniteSetGroupoid) (x : Fin V.size) : |
| swap U V (sumEquiv U V (.inr x))=sumEquiv V U (.inl x) := by simp [swap] |
| @[simp] lemma left_apply (U : FiniteSetGroupoid) (x : Fin U.size) : |
| left U (sumEquiv empty U (.inr x))=x := by simp [left] |
| @[simp] lemma right_apply (U : FiniteSetGroupoid) (x : Fin U.size) : |
| right U (sumEquiv U empty (.inl x))=x := by simp [right] |
| lemma sumHom_id (U V : FiniteSetGroupoid) : sumHom (𝟙 U) (𝟙 V)=𝟙 (sum U V) := by |
| apply hom_ext; intro x |
| obtain ⟨x,rfl⟩ := (sumEquiv U V).surjective x |
| cases x <;> simp [toEquiv,sumHom] |
| lemma sumHom_comp {U V W X Y Z : FiniteSetGroupoid} (f : U ⟶ V) (f' : V ⟶ W) |
| (g : X ⟶ Y) (g' : Y ⟶ Z) : sumHom (f≫f') (g≫g')=sumHom f g ≫ sumHom f' g' := by |
| apply hom_ext; intro x |
| obtain ⟨x,rfl⟩ := (sumEquiv U X).surjective x |
| cases x <;> simp [toEquiv,sumHom] |
| |
| noncomputable abbrev monoidalStruct : MonoidalCategoryStruct FiniteSetGroupoid where |
| tensorObj := sum |
| tensorHom := sumHom |
| whiskerLeft U _ _ f := sumHom (𝟙 U) f |
| whiskerRight f U := sumHom f (𝟙 U) |
| tensorUnit := empty |
| associator U V W := asIso (assoc U V W) |
| leftUnitor U := asIso (left U) |
| rightUnitor U := asIso (right U) |
|
|
| attribute [instance] monoidalStruct |
|
|
| noncomputable instance monoidal : MonoidalCategory FiniteSetGroupoid := |
| MonoidalCategory.ofTensorHom |
| (id_tensorHom_id := sumHom_id) |
| (id_tensorHom := by intros; rfl) |
| (tensorHom_id := by intros; rfl) |
| (tensorHom_comp_tensorHom := fun f g f' g' => (sumHom_comp f f' g g').symm) |
| (associator_naturality := by |
| intro U V W U' V' W' f g h |
| change sumHom (sumHom f g) h ≫ assoc U' V' W' = assoc U V W ≫ sumHom f (sumHom g h) |
| apply hom_ext;intro x |
| obtain ⟨y,rfl⟩ := (sumEquiv (sum U V) W).surjective x |
| cases y with |
| | inl y => |
| obtain ⟨z,rfl⟩ := (sumEquiv U V).surjective y |
| cases z <;> simp [toEquiv,sumHom,assoc] |
| | inr y => simp [toEquiv,sumHom,assoc]) |
| (leftUnitor_naturality := by |
| intro U V f |
| change sumHom (𝟙 empty) f ≫ left V = left U ≫ f |
| apply hom_ext;intro x |
| obtain ⟨y,rfl⟩ := (sumEquiv empty U).surjective x |
| cases y with |
| | inl y => exact isEmptyElim y |
| | inr y => simp [toEquiv,sumHom,left]) |
| (rightUnitor_naturality := by |
| intro U V f |
| change sumHom f (𝟙 empty) ≫ right V = right U ≫ f |
| apply hom_ext;intro x |
| obtain ⟨y,rfl⟩ := (sumEquiv U empty).surjective x |
| cases y with |
| | inl y => simp [toEquiv,sumHom,right] |
| | inr y => exact isEmptyElim y) |
| (pentagon := by |
| intro U V W Z |
| change sumHom (assoc U V W) (𝟙 Z) ≫ assoc U (sum V W) Z ≫ sumHom (𝟙 U) (assoc V W Z) = |
| assoc (sum U V) W Z ≫ assoc U V (sum W Z) |
| apply hom_ext;intro x |
| obtain ⟨y,rfl⟩ := (sumEquiv (sum (sum U V) W) Z).surjective x |
| cases y with |
| | inl y => |
| obtain ⟨z,rfl⟩ := (sumEquiv (sum U V) W).surjective y |
| cases z with |
| | inl z => |
| obtain ⟨t,rfl⟩ := (sumEquiv U V).surjective z |
| cases t <;> simp [toEquiv,sumHom,assoc] |
| | inr z => simp [toEquiv,sumHom,assoc] |
| | inr y => simp [toEquiv,sumHom,assoc]) |
| (triangle := by |
| intro U V |
| change assoc U empty V ≫ sumHom (𝟙 U) (left V) = sumHom (right U) (𝟙 V) |
| apply hom_ext;intro x |
| obtain ⟨y,rfl⟩ := (sumEquiv (sum U empty) V).surjective x |
| cases y with |
| | inl y => |
| obtain ⟨z,rfl⟩ := (sumEquiv U empty).surjective y |
| cases z with |
| | inl z => simp [toEquiv,sumHom,assoc,left,right] |
| | inr z => exact isEmptyElim z |
| | inr y => simp [toEquiv,sumHom,assoc,left,right]) |
|
|
| @[simp] theorem assoc_symm_left (U V W : FiniteSetGroupoid) (x : Fin U.size) : |
| (toEquiv (assoc U V W)).symm (sumEquiv U (sum V W) (.inl x))= |
| sumEquiv (sum U V) W (.inl (sumEquiv U V (.inl x))) := |
| (Equiv.symm_apply_eq _).mpr (assoc_left U V W x).symm |
| @[simp] theorem assoc_symm_mid (U V W : FiniteSetGroupoid) (x : Fin V.size) : |
| (toEquiv (assoc U V W)).symm (sumEquiv U (sum V W) (.inr (sumEquiv V W (.inl x))))= |
| sumEquiv (sum U V) W (.inl (sumEquiv U V (.inr x))) := |
| (Equiv.symm_apply_eq _).mpr (assoc_mid U V W x).symm |
| @[simp] theorem assoc_symm_right (U V W : FiniteSetGroupoid) (x : Fin W.size) : |
| (toEquiv (assoc U V W)).symm (sumEquiv U (sum V W) (.inr (sumEquiv V W (.inr x))))= |
| sumEquiv (sum U V) W (.inr x) := |
| (Equiv.symm_apply_eq _).mpr (assoc_right U V W x).symm |
|
|
| @[simp] theorem associator_inv_apply (U V W : FiniteSetGroupoid) (x : Fin (sum U (sum V W)).size) : |
| (monoidalStruct.associator U V W).inv x=(toEquiv (assoc U V W)).symm x := by |
| change (CategoryTheory.inv (assoc U V W)) x=_ |
| rw [← Groupoid.inv_eq_inv] |
| rfl |
|
|
| @[simp] theorem inv_arrow_apply {U V : FiniteSetGroupoid} (f : U ⟶ V) (x : Fin V.size) : |
| (CategoryTheory.inv f) x = (toEquiv f).symm x := by |
| rw [← Groupoid.inv_eq_inv] |
| rfl |
|
|
| @[simp] lemma inv_eq {U V : FiniteSetGroupoid} (f : U ⟶ V) : |
| (CategoryTheory.inv f : V ⟶ U) = (toEquiv f).symm := by |
| rw [← Groupoid.inv_eq_inv] |
| rfl |
|
|
| noncomputable instance braided : BraidedCategory FiniteSetGroupoid where |
| braiding U V := asIso (swap U V) |
| braiding_naturality_right := by |
| intro U V W f |
| change sumHom (𝟙 U) f ≫ swap U W = swap U V ≫ sumHom f (𝟙 U) |
| apply hom_ext;intro x |
| obtain ⟨y,rfl⟩ := (sumEquiv U V).surjective x |
| cases y <;> simp [toEquiv,sumHom,swap] |
| braiding_naturality_left := by |
| intro U V f W |
| change sumHom f (𝟙 W) ≫ swap V W = swap U W ≫ sumHom (𝟙 W) f |
| apply hom_ext;intro x |
| obtain ⟨y,rfl⟩ := (sumEquiv U W).surjective x |
| cases y <;> simp [toEquiv,sumHom,swap] |
| hexagon_forward := by |
| intro U V W |
| change assoc U V W ≫ swap U (sum V W) ≫ assoc V W U = |
| sumHom (swap U V) (𝟙 W) ≫ assoc V U W ≫ sumHom (𝟙 V) (swap U W) |
| apply hom_ext;intro x |
| obtain ⟨y,rfl⟩ := (sumEquiv (sum U V) W).surjective x |
| cases y with |
| | inl y => |
| obtain ⟨z,rfl⟩ := (sumEquiv U V).surjective y |
| cases z <;> simp [toEquiv,sumHom,assoc,swap] |
| | inr y => simp [toEquiv,sumHom,assoc,swap] |
| hexagon_reverse := by |
| intro U V W |
| change (CategoryTheory.inv (assoc U V W)) ≫ swap (sum U V) W ≫ (CategoryTheory.inv (assoc W U V)) = |
| sumHom (𝟙 U) (swap V W) ≫ (CategoryTheory.inv (assoc U W V)) ≫ sumHom (swap U W) (𝟙 V) |
| apply hom_ext;intro x |
| obtain ⟨y,rfl⟩ := (sumEquiv U (sum V W)).surjective x |
| cases y with |
| | inl y => simp [toEquiv,sumHom,assoc,swap] |
| | inr y => |
| obtain ⟨z,rfl⟩ := (sumEquiv V W).surjective y |
| cases z <;> simp [toEquiv,sumHom,assoc,swap] |
|
|
| noncomputable instance symmetric : SymmetricCategory FiniteSetGroupoid where |
| symmetry U V := by |
| change swap U V ≫ swap V U = 𝟙 (sum U V) |
| apply hom_ext;intro x |
| obtain ⟨y,rfl⟩ := (sumEquiv U V).surjective x |
| cases y <;> simp [toEquiv,swap] |
|
|
| end SimpleAmenable.PolygonObject.FiniteSetGroupoid |
|
|
| end |
|
|
| end |
|
|
| end OAI |
|
|
