l3lab/ntp-mathlib huggingface dataset:
/-- Auxiliary definition for the `MonoidalCategory` instance on `Center C`. -/
@[simps]
def tensorObj (X Y : Center C) : Center C :=
  ⟨X.1 ⊗ Y.1,
    { β := fun U =>
        α_ _ _ _ ≪≫
          (Iso.refl X.1 ⊗ Y.2.β U) ≪≫ (α_ _ _ _).symm ≪≫ (X.2.β U ⊗ Iso.refl Y.1) ≪≫ α_ _ _ _
      monoidal := fun U U' => by
        dsimp
        simp only [comp_tensor_id, id_tensor_comp, Category.assoc, HalfBraiding.monoidal]
        -- On the RHS, we'd like to commute `((X.snd.β U).hom ⊗ 𝟙 Y.fst) ⊗ 𝟙 U'`
        -- and `𝟙 U ⊗ 𝟙 X.fst ⊗ (Y.snd.β U').hom` past each other,
        -- but there are some associators we need to get out of the way first.
        slice_rhs 6 8 => rw [pentagon]
        slice_rhs 5 6 => rw [associator_naturality]
        slice_rhs 7 8 => rw [← associator_naturality]
        slice_rhs 6 7 =>
          rw [tensor_id, tensor_id, tensor_id_comp_id_tensor, ← id_tensor_comp_tensor_id,
            ← tensor_id, ← tensor_id]
        -- Now insert associators as needed to make the four half-braidings look identical
        slice_rhs 10 10 => rw [associator_inv_conjugation]
        

Proof state:
C : Type u₁
inst✝¹ : Category.{v₁, u₁} C
inst✝ : MonoidalCategory C
X Y : Center C
U U' : C
⊢ (α_ X.fst Y.fst (U ⊗ U')).hom ≫
      (𝟙 X.fst ⊗ (α_ Y.fst U U').inv) ≫
        (𝟙 X.fst ⊗ (HalfBraiding.β Y.snd U).hom ⊗ 𝟙 U') ≫
          (𝟙 X.fst ⊗ (α_ U Y.fst U').hom) ≫
            (𝟙 X.fst ⊗ 𝟙 U ⊗ (HalfBraiding.β Y.snd U').hom) ≫
              (𝟙 X.fst ⊗ (α_ U U' Y.fst).inv) ≫
                (α_ X.fst (U ⊗ U') Y.fst).inv ≫
                  ((α_ X.fst U U').inv ⊗ 𝟙 Y.fst) ≫
                    (((HalfBraiding.β X.snd U).hom ⊗ 𝟙 U') ⊗ 𝟙 Y.fst) ≫
                      ((α_ U X.fst U').hom ⊗ 𝟙 Y.fst) ≫
                        ((𝟙 U ⊗ (HalfBraiding.β X.snd U').hom) ⊗ 𝟙 Y.fst) ≫
                          ((α_ U U' X.fst).inv ⊗ 𝟙 Y.fst) ≫ (α_ (U ⊗ U') X.fst Y.fst).hom =
    (α_ (X.fst ⊗ Y.fst) U U').inv ≫
      ((α_ X.fst Y.fst U).hom ⊗ 𝟙 U') ≫
        ((𝟙 X.fst ⊗ (HalfBraiding.β Y.snd U).hom) ⊗ 𝟙 U') ≫
          ((α_ X.fst U Y.fst).inv ⊗ 𝟙 U') ≫
            (α_ (X.fst ⊗ U) Y.fst U').hom ≫
              ((𝟙 X.fst ⊗ 𝟙 U) ⊗ (HalfBraiding.β Y.snd U').hom) ≫
                ((HalfBraiding.β X.snd U).hom ⊗ 𝟙 U' ⊗ 𝟙 Y.fst) ≫
                  (α_ U X.fst (U' ⊗ Y.fst)).hom ≫
                    (𝟙 U ⊗ (α_ X.fst U' Y.fst).inv) ≫
                      (((α_ U (X.fst ⊗ U') Y.fst).inv ≫
                            ((𝟙 U ⊗ (HalfBraiding.β X.snd U').hom) ⊗ 𝟙 Y.fst) ≫ (α_ U (U' ⊗ X.fst) Y.fst).hom) ≫
                          (𝟙 U ⊗ (α_ U' X.fst Y.fst).hom)) ≫
                        (α_ U U' (X.fst ⊗ Y.fst)).inv

Next tactic:
slice_rhs 7 7 => rw [associator_inv_conjugation]
/-- Auxiliary definition for the `MonoidalCategory` instance on `Center C`. -/
@[simps]
def tensorObj (X Y : Center C) : Center C :=
  ⟨X.1 ⊗ Y.1,
    { β := fun U =>
        α_ _ _ _ ≪≫
          (Iso.refl X.1 ⊗ Y.2.β U) ≪≫ (α_ _ _ _).symm ≪≫ (X.2.β U ⊗ Iso.refl Y.1) ≪≫ α_ _ _ _
      monoidal := fun U U' => by
        dsimp
        simp only [comp_tensor_id, id_tensor_comp, Category.assoc, HalfBraiding.monoidal]
        -- On the RHS, we'd like to commute `((X.snd.β U).hom ⊗ 𝟙 Y.fst) ⊗ 𝟙 U'`
        -- and `𝟙 U ⊗ 𝟙 X.fst ⊗ (Y.snd.β U').hom` past each other,
        -- but there are some associators we need to get out of the way first.
        slice_rhs 6 8 => rw [pentagon]
        slice_rhs 5 6 => rw [associator_naturality]
        slice_rhs 7 8 => rw [← associator_naturality]
        slice_rhs 6 7 =>
          rw [tensor_id, tensor_id, tensor_id_comp_id_tensor, ← id_tensor_comp_tensor_id,
            ← tensor_id, ← tensor_id]
        -- Now insert associators as needed to make the four half-braidings look identical
        slice_rhs 10 10 => rw [associator_inv_conjugation]
        slice_rhs 7 7 => rw [associator_inv_conjugation]
        

Proof state:
C : Type u₁
inst✝¹ : Category.{v₁, u₁} C
inst✝ : MonoidalCategory C
X Y : Center C
U U' : C
⊢ (α_ X.fst Y.fst (U ⊗ U')).hom ≫
      (𝟙 X.fst ⊗ (α_ Y.fst U U').inv) ≫
        (𝟙 X.fst ⊗ (HalfBraiding.β Y.snd U).hom ⊗ 𝟙 U') ≫
          (𝟙 X.fst ⊗ (α_ U Y.fst U').hom) ≫
            (𝟙 X.fst ⊗ 𝟙 U ⊗ (HalfBraiding.β Y.snd U').hom) ≫
              (𝟙 X.fst ⊗ (α_ U U' Y.fst).inv) ≫
                (α_ X.fst (U ⊗ U') Y.fst).inv ≫
                  ((α_ X.fst U U').inv ⊗ 𝟙 Y.fst) ≫
                    (((HalfBraiding.β X.snd U).hom ⊗ 𝟙 U') ⊗ 𝟙 Y.fst) ≫
                      ((α_ U X.fst U').hom ⊗ 𝟙 Y.fst) ≫
                        ((𝟙 U ⊗ (HalfBraiding.β X.snd U').hom) ⊗ 𝟙 Y.fst) ≫
                          ((α_ U U' X.fst).inv ⊗ 𝟙 Y.fst) ≫ (α_ (U ⊗ U') X.fst Y.fst).hom =
    (α_ (X.fst ⊗ Y.fst) U U').inv ≫
      ((α_ X.fst Y.fst U).hom ⊗ 𝟙 U') ≫
        ((𝟙 X.fst ⊗ (HalfBraiding.β Y.snd U).hom) ⊗ 𝟙 U') ≫
          ((α_ X.fst U Y.fst).inv ⊗ 𝟙 U') ≫
            (α_ (X.fst ⊗ U) Y.fst U').hom ≫
              ((𝟙 X.fst ⊗ 𝟙 U) ⊗ (HalfBraiding.β Y.snd U').hom) ≫
                ((((((((α_ (X.fst ⊗ U) U' Y.fst).inv ≫
                                (((HalfBraiding.β X.snd U).hom ⊗ 𝟙 U') ⊗ 𝟙 Y.fst) ≫ (α_ (U ⊗ X.fst) U' Y.fst).hom) ≫
                              (α_ U X.fst (U' ⊗ Y.fst)).hom) ≫
                            (𝟙 U ⊗ (α_ X.fst U' Y.fst).inv)) ≫
                          (α_ U (X.fst ⊗ U') Y.fst).inv) ≫
                        ((𝟙 U ⊗ (HalfBraiding.β X.snd U').hom) ⊗ 𝟙 Y.fst)) ≫
                      (α_ U (U' ⊗ X.fst) Y.fst).hom) ≫
                    (𝟙 U ⊗ (α_ U' X.fst Y.fst).hom)) ≫
                  (α_ U U' (X.fst ⊗ Y.fst)).inv

Next tactic:
slice_rhs 6 6 => rw [associator_conjugation]
/-- Auxiliary definition for the `MonoidalCategory` instance on `Center C`. -/
@[simps]
def tensorObj (X Y : Center C) : Center C :=
  ⟨X.1 ⊗ Y.1,
    { β := fun U =>
        α_ _ _ _ ≪≫
          (Iso.refl X.1 ⊗ Y.2.β U) ≪≫ (α_ _ _ _).symm ≪≫ (X.2.β U ⊗ Iso.refl Y.1) ≪≫ α_ _ _ _
      monoidal := fun U U' => by
        dsimp
        simp only [comp_tensor_id, id_tensor_comp, Category.assoc, HalfBraiding.monoidal]
        -- On the RHS, we'd like to commute `((X.snd.β U).hom ⊗ 𝟙 Y.fst) ⊗ 𝟙 U'`
        -- and `𝟙 U ⊗ 𝟙 X.fst ⊗ (Y.snd.β U').hom` past each other,
        -- but there are some associators we need to get out of the way first.
        slice_rhs 6 8 => rw [pentagon]
        slice_rhs 5 6 => rw [associator_naturality]
        slice_rhs 7 8 => rw [← associator_naturality]
        slice_rhs 6 7 =>
          rw [tensor_id, tensor_id, tensor_id_comp_id_tensor, ← id_tensor_comp_tensor_id,
            ← tensor_id, ← tensor_id]
        -- Now insert associators as needed to make the four half-braidings look identical
        slice_rhs 10 10 => rw [associator_inv_conjugation]
        slice_rhs 7 7 => rw [associator_inv_conjugation]
        slice_rhs 6 6 => rw [associator_conjugation]
        

Proof state:
C : Type u₁
inst✝¹ : Category.{v₁, u₁} C
inst✝ : MonoidalCategory C
X Y : Center C
U U' : C
⊢ (α_ X.fst Y.fst (U ⊗ U')).hom ≫
      (𝟙 X.fst ⊗ (α_ Y.fst U U').inv) ≫
        (𝟙 X.fst ⊗ (HalfBraiding.β Y.snd U).hom ⊗ 𝟙 U') ≫
          (𝟙 X.fst ⊗ (α_ U Y.fst U').hom) ≫
            (𝟙 X.fst ⊗ 𝟙 U ⊗ (HalfBraiding.β Y.snd U').hom) ≫
              (𝟙 X.fst ⊗ (α_ U U' Y.fst).inv) ≫
                (α_ X.fst (U ⊗ U') Y.fst).inv ≫
                  ((α_ X.fst U U').inv ⊗ 𝟙 Y.fst) ≫
                    (((HalfBraiding.β X.snd U).hom ⊗ 𝟙 U') ⊗ 𝟙 Y.fst) ≫
                      ((α_ U X.fst U').hom ⊗ 𝟙 Y.fst) ≫
                        ((𝟙 U ⊗ (HalfBraiding.β X.snd U').hom) ⊗ 𝟙 Y.fst) ≫
                          ((α_ U U' X.fst).inv ⊗ 𝟙 Y.fst) ≫ (α_ (U ⊗ U') X.fst Y.fst).hom =
    (α_ (X.fst ⊗ Y.fst) U U').inv ≫
      ((α_ X.fst Y.fst U).hom ⊗ 𝟙 U') ≫
        ((𝟙 X.fst ⊗ (HalfBraiding.β Y.snd U).hom) ⊗ 𝟙 U') ≫
          ((α_ X.fst U Y.fst).inv ⊗ 𝟙 U') ≫
            (α_ (X.fst ⊗ U) Y.fst U').hom ≫
              (((((((((((α_ X.fst U (Y.fst ⊗ U')).hom ≫
                                    (𝟙 X.fst ⊗ 𝟙 U ⊗ (HalfBraiding.β Y.snd U').hom) ≫ (α_ X.fst U (U' ⊗ Y.fst)).inv) ≫
                                  (α_ (X.fst ⊗ U) U' Y.fst).inv) ≫
                                (((HalfBraiding.β X.snd U).hom ⊗ 𝟙 U') ⊗ 𝟙 Y.fst)) ≫
                              (α_ (U ⊗ X.fst) U' Y.fst).hom) ≫
                            (α_ U X.fst (U' ⊗ Y.fst)).hom) ≫
                          (𝟙 U ⊗ (α_ X.fst U' Y.fst).inv)) ≫
                        (α_ U (X.fst ⊗ U') Y.fst).inv) ≫
                      ((𝟙 U ⊗ (HalfBraiding.β X.snd U').hom) ⊗ 𝟙 Y.fst)) ≫
                    (α_ U (U' ⊗ X.fst) Y.fst).hom) ≫
                  (𝟙 U ⊗ (α_ U' X.fst Y.fst).hom)) ≫
                (α_ U U' (X.fst ⊗ Y.fst)).inv

Next tactic:
slice_rhs 3 3 => rw [associator_conjugation]
/-- Auxiliary definition for the `MonoidalCategory` instance on `Center C`. -/
@[simps]
def tensorObj (X Y : Center C) : Center C :=
  ⟨X.1 ⊗ Y.1,
    { β := fun U =>
        α_ _ _ _ ≪≫
          (Iso.refl X.1 ⊗ Y.2.β U) ≪≫ (α_ _ _ _).symm ≪≫ (X.2.β U ⊗ Iso.refl Y.1) ≪≫ α_ _ _ _
      monoidal := fun U U' => by
        dsimp
        simp only [comp_tensor_id, id_tensor_comp, Category.assoc, HalfBraiding.monoidal]
        -- On the RHS, we'd like to commute `((X.snd.β U).hom ⊗ 𝟙 Y.fst) ⊗ 𝟙 U'`
        -- and `𝟙 U ⊗ 𝟙 X.fst ⊗ (Y.snd.β U').hom` past each other,
        -- but there are some associators we need to get out of the way first.
        slice_rhs 6 8 => rw [pentagon]
        slice_rhs 5 6 => rw [associator_naturality]
        slice_rhs 7 8 => rw [← associator_naturality]
        slice_rhs 6 7 =>
          rw [tensor_id, tensor_id, tensor_id_comp_id_tensor, ← id_tensor_comp_tensor_id,
            ← tensor_id, ← tensor_id]
        -- Now insert associators as needed to make the four half-braidings look identical
        slice_rhs 10 10 => rw [associator_inv_conjugation]
        slice_rhs 7 7 => rw [associator_inv_conjugation]
        slice_rhs 6 6 => rw [associator_conjugation]
        slice_rhs 3 3 => rw [associator_conjugation]
        -- Finish with an application of the coherence theorem.
        coherence
      naturality := fun f => by
        

Proof state:
C : Type u₁
inst✝¹ : Category.{v₁, u₁} C
inst✝ : MonoidalCategory C
X Y : Center C
U✝ U'✝ : C
f : U✝ ⟶ U'✝
⊢ (𝟙 (X.fst ⊗ Y.fst) ⊗ f) ≫
      ((fun U =>
            α_ X.fst Y.fst U ≪≫
              (Iso.refl X.fst ⊗ HalfBraiding.β Y.snd U) ≪≫
                (α_ X.fst U Y.fst).symm ≪≫ (HalfBraiding.β X.snd U ⊗ Iso.refl Y.fst) ≪≫ α_ U X.fst Y.fst)
          U'✝).hom =
    ((fun U =>
            α_ X.fst Y.fst U ≪≫
              (Iso.refl X.fst ⊗ HalfBraiding.β Y.snd U) ≪≫
                (α_ X.fst U Y.fst).symm ≪≫ (HalfBraiding.β X.snd U ⊗ Iso.refl Y.fst) ≪≫ α_ U X.fst Y.fst)
          U✝).hom ≫
      (f ⊗ 𝟙 (X.fst ⊗ Y.fst))

Next tactic:
dsimp
/-- Auxiliary definition for the `MonoidalCategory` instance on `Center C`. -/
@[simps]
def tensorObj (X Y : Center C) : Center C :=
  ⟨X.1 ⊗ Y.1,
    { β := fun U =>
        α_ _ _ _ ≪≫
          (Iso.refl X.1 ⊗ Y.2.β U) ≪≫ (α_ _ _ _).symm ≪≫ (X.2.β U ⊗ Iso.refl Y.1) ≪≫ α_ _ _ _
      monoidal := fun U U' => by
        dsimp
        simp only [comp_tensor_id, id_tensor_comp, Category.assoc, HalfBraiding.monoidal]
        -- On the RHS, we'd like to commute `((X.snd.β U).hom ⊗ 𝟙 Y.fst) ⊗ 𝟙 U'`
        -- and `𝟙 U ⊗ 𝟙 X.fst ⊗ (Y.snd.β U').hom` past each other,
        -- but there are some associators we need to get out of the way first.
        slice_rhs 6 8 => rw [pentagon]
        slice_rhs 5 6 => rw [associator_naturality]
        slice_rhs 7 8 => rw [← associator_naturality]
        slice_rhs 6 7 =>
          rw [tensor_id, tensor_id, tensor_id_comp_id_tensor, ← id_tensor_comp_tensor_id,
            ← tensor_id, ← tensor_id]
        -- Now insert associators as needed to make the four half-braidings look identical
        slice_rhs 10 10 => rw [associator_inv_conjugation]
        slice_rhs 7 7 => rw [associator_inv_conjugation]
        slice_rhs 6 6 => rw [associator_conjugation]
        slice_rhs 3 3 => rw [associator_conjugation]
        -- Finish with an application of the coherence theorem.
        coherence
      naturality := fun f => by
        dsimp
        

Proof state:
C : Type u₁
inst✝¹ : Category.{v₁, u₁} C
inst✝ : MonoidalCategory C
X Y : Center C
U✝ U'✝ : C
f : U✝ ⟶ U'✝
⊢ (𝟙 (X.fst ⊗ Y.fst) ⊗ f) ≫
      (α_ X.fst Y.fst U'✝).hom ≫
        (𝟙 X.fst ⊗ (HalfBraiding.β Y.snd U'✝).hom) ≫
          (α_ X.fst U'✝ Y.fst).inv ≫ ((HalfBraiding.β X.snd U'✝).hom ⊗ 𝟙 Y.fst) ≫ (α_ U'✝ X.fst Y.fst).hom =
    ((α_ X.fst Y.fst U✝).hom ≫
        (𝟙 X.fst ⊗ (HalfBraiding.β Y.snd U✝).hom) ≫
          (α_ X.fst U✝ Y.fst).inv ≫ ((HalfBraiding.β X.snd U✝).hom ⊗ 𝟙 Y.fst) ≫ (α_ U✝ X.fst Y.fst).hom) ≫
      (f ⊗ 𝟙 (X.fst ⊗ Y.fst))

Next tactic:
rw [Category.assoc, Category.assoc, Category.assoc, Category.assoc,
          id_tensor_associator_naturality_assoc, ← id_tensor_comp_assoc, HalfBraiding.naturality,
          id_tensor_comp_assoc, associator_inv_naturality_assoc, ← comp_tensor_id_assoc,
          HalfBraiding.naturality, comp_tensor_id_assoc, associator_naturality, ← tensor_id]
/-- Auxiliary definition for the `MonoidalCategory` instance on `Center C`. -/
@[simps]
def tensorHom {X₁ Y₁ X₂ Y₂ : Center C} (f : X₁ ⟶ Y₁) (g : X₂ ⟶ Y₂) :
    tensorObj X₁ X₂ ⟶ tensorObj Y₁ Y₂ where
  f := f.f ⊗ g.f
  comm U := by
    

Proof state:
C : Type u₁
inst✝¹ : Category.{v₁, u₁} C
inst✝ : MonoidalCategory C
X₁ Y₁ X₂ Y₂ : Center C
f : X₁ ⟶ Y₁
g : X₂ ⟶ Y₂
U : C
⊢ ((f.f ⊗ g.f) ⊗ 𝟙 U) ≫ (HalfBraiding.β (tensorObj Y₁ Y₂).snd U).hom =
    (HalfBraiding.β (tensorObj X₁ X₂).snd U).hom ≫ (𝟙 U ⊗ f.f ⊗ g.f)

Next tactic:
dsimp
/-- Auxiliary definition for the `MonoidalCategory` instance on `Center C`. -/
@[simps]
def tensorHom {X₁ Y₁ X₂ Y₂ : Center C} (f : X₁ ⟶ Y₁) (g : X₂ ⟶ Y₂) :
    tensorObj X₁ X₂ ⟶ tensorObj Y₁ Y₂ where
  f := f.f ⊗ g.f
  comm U := by
    dsimp
    

Proof state:
C : Type u₁
inst✝¹ : Category.{v₁, u₁} C
inst✝ : MonoidalCategory C
X₁ Y₁ X₂ Y₂ : Center C
f : X₁ ⟶ Y₁
g : X₂ ⟶ Y₂
U : C
⊢ ((f.f ⊗ g.f) ⊗ 𝟙 U) ≫
      (α_ Y₁.fst Y₂.fst U).hom ≫
        (𝟙 Y₁.fst ⊗ (HalfBraiding.β Y₂.snd U).hom) ≫
          (α_ Y₁.fst U Y₂.fst).inv ≫ ((HalfBraiding.β Y₁.snd U).hom ⊗ 𝟙 Y₂.fst) ≫ (α_ U Y₁.fst Y₂.fst).hom =
    ((α_ X₁.fst X₂.fst U).hom ≫
        (𝟙 X₁.fst ⊗ (HalfBraiding.β X₂.snd U).hom) ≫
          (α_ X₁.fst U X₂.fst).inv ≫ ((HalfBraiding.β X₁.snd U).hom ⊗ 𝟙 X₂.fst) ≫ (α_ U X₁.fst X₂.fst).hom) ≫
      (𝟙 U ⊗ f.f ⊗ g.f)

Next tactic:
rw [Category.assoc, Category.assoc, Category.assoc, Category.assoc, associator_naturality_assoc,
      ← tensor_id_comp_id_tensor, Category.assoc, ← id_tensor_comp_assoc, g.comm,
      id_tensor_comp_assoc, tensor_id_comp_id_tensor_assoc, ← id_tensor_comp_tensor_id,
      Category.assoc, associator_inv_naturality_assoc, id_tensor_associator_inv_naturality_assoc,
      tensor_id, id_tensor_comp_tensor_id_assoc, ← tensor_id_comp_id_tensor g.f, Category.assoc,
      ← comp_tensor_id_assoc, f.comm, comp_tensor_id_assoc, id_tensor_associator_naturality,
      associator_naturality_assoc, ← id_tensor_comp, tensor_id_comp_id_tensor]
/-- Auxiliary definition for the `MonoidalCategory` instance on `Center C`. -/
@[simps]
def tensorUnit : Center C :=
  ⟨𝟙_ C,
    { β := fun U => λ_ U ≪≫ (ρ_ U).symm
      monoidal := fun U U' => by 

Proof state:
C : Type u₁
inst✝¹ : Category.{v₁, u₁} C
inst✝ : MonoidalCategory C
U U' : C
⊢ ((fun U => λ_ U ≪≫ (ρ_ U).symm) (U ⊗ U')).hom =
    (α_ (𝟙_ C) U U').inv ≫
      (((fun U => λ_ U ≪≫ (ρ_ U).symm) U).hom ⊗ 𝟙 U') ≫
        (α_ U (𝟙_ C) U').hom ≫ (𝟙 U ⊗ ((fun U => λ_ U ≪≫ (ρ_ U).symm) U').hom) ≫ (α_ U U' (𝟙_ C)).inv

Next tactic:
simp
/-- Auxiliary definition for the `MonoidalCategory` instance on `Center C`. -/
@[simps]
def tensorUnit : Center C :=
  ⟨𝟙_ C,
    { β := fun U => λ_ U ≪≫ (ρ_ U).symm
      monoidal := fun U U' => by simp
      naturality := fun f => by
        

Proof state:
C : Type u₁
inst✝¹ : Category.{v₁, u₁} C
inst✝ : MonoidalCategory C
U✝ U'✝ : C
f : U✝ ⟶ U'✝
⊢ (𝟙 (𝟙_ C) ⊗ f) ≫ ((fun U => λ_ U ≪≫ (ρ_ U).symm) U'✝).hom = ((fun U => λ_ U ≪≫ (ρ_ U).symm) U✝).hom ≫ (f ⊗ 𝟙 (𝟙_ C))

Next tactic:
dsimp
/-- Auxiliary definition for the `MonoidalCategory` instance on `Center C`. -/
@[simps]
def tensorUnit : Center C :=
  ⟨𝟙_ C,
    { β := fun U => λ_ U ≪≫ (ρ_ U).symm
      monoidal := fun U U' => by simp
      naturality := fun f => by
        dsimp
        

Proof state:
C : Type u₁
inst✝¹ : Category.{v₁, u₁} C
inst✝ : MonoidalCategory C
U✝ U'✝ : C
f : U✝ ⟶ U'✝
⊢ (𝟙 (𝟙_ C) ⊗ f) ≫ (λ_ U'✝).hom ≫ (ρ_ U'✝).inv = ((λ_ U✝).hom ≫ (ρ_ U✝).inv) ≫ (f ⊗ 𝟙 (𝟙_ C))

Next tactic:
rw [leftUnitor_naturality_assoc, rightUnitor_inv_naturality, Category.assoc]
/-- Auxiliary definition for the `MonoidalCategory` instance on `Center C`. -/
def associator (X Y Z : Center C) : tensorObj (tensorObj X Y) Z ≅ tensorObj X (tensorObj Y Z) :=
  isoMk
    ⟨(α_ X.1 Y.1 Z.1).hom, fun U => by
      

Proof state:
C : Type u₁
inst✝¹ : Category.{v₁, u₁} C
inst✝ : MonoidalCategory C
X Y Z : Center C
U : C
⊢ ((α_ X.fst Y.fst Z.fst).hom ⊗ 𝟙 U) ≫ (HalfBraiding.β (tensorObj X (tensorObj Y Z)).snd U).hom =
    (HalfBraiding.β (tensorObj (tensorObj X Y) Z).snd U).hom ≫ (𝟙 U ⊗ (α_ X.fst Y.fst Z.fst).hom)

Next tactic:
dsimp
/-- Auxiliary definition for the `MonoidalCategory` instance on `Center C`. -/
def associator (X Y Z : Center C) : tensorObj (tensorObj X Y) Z ≅ tensorObj X (tensorObj Y Z) :=
  isoMk
    ⟨(α_ X.1 Y.1 Z.1).hom, fun U => by
      dsimp
      

Proof state:
C : Type u₁
inst✝¹ : Category.{v₁, u₁} C
inst✝ : MonoidalCategory C
X Y Z : Center C
U : C
⊢ ((α_ X.fst Y.fst Z.fst).hom ⊗ 𝟙 U) ≫
      (α_ X.fst (Y.fst ⊗ Z.fst) U).hom ≫
        (𝟙 X.fst ⊗
            (α_ Y.fst Z.fst U).hom ≫
              (𝟙 Y.fst ⊗ (HalfBraiding.β Z.snd U).hom) ≫
                (α_ Y.fst U Z.fst).inv ≫ ((HalfBraiding.β Y.snd U).hom ⊗ 𝟙 Z.fst) ≫ (α_ U Y.fst Z.fst).hom) ≫
          (α_ X.fst U (Y.fst ⊗ Z.fst)).inv ≫
            ((HalfBraiding.β X.snd U).hom ⊗ 𝟙 (Y.fst ⊗ Z.fst)) ≫ (α_ U X.fst (Y.fst ⊗ Z.fst)).hom =
    ((α_ (X.fst ⊗ Y.fst) Z.fst U).hom ≫
        (𝟙 (X.fst ⊗ Y.fst) ⊗ (HalfBraiding.β Z.snd U).hom) ≫
          (α_ (X.fst ⊗ Y.fst) U Z.fst).inv ≫
            ((α_ X.fst Y.fst U).hom ≫
                  (𝟙 X.fst ⊗ (HalfBraiding.β Y.snd U).hom) ≫
                    (α_ X.fst U Y.fst).inv ≫ ((HalfBraiding.β X.snd U).hom ⊗ 𝟙 Y.fst) ≫ (α_ U X.fst Y.fst).hom ⊗
                𝟙 Z.fst) ≫
              (α_ U (X.fst ⊗ Y.fst) Z.fst).hom) ≫
      (𝟙 U ⊗ (α_ X.fst Y.fst Z.fst).hom)

Next tactic:
simp only [comp_tensor_id, id_tensor_comp, ← tensor_id, associator_conjugation]
/-- Auxiliary definition for the `MonoidalCategory` instance on `Center C`. -/
def associator (X Y Z : Center C) : tensorObj (tensorObj X Y) Z ≅ tensorObj X (tensorObj Y Z) :=
  isoMk
    ⟨(α_ X.1 Y.1 Z.1).hom, fun U => by
      dsimp
      simp only [comp_tensor_id, id_tensor_comp, ← tensor_id, associator_conjugation]
      

Proof state:
C : Type u₁
inst✝¹ : Category.{v₁, u₁} C
inst✝ : MonoidalCategory C
X Y Z : Center C
U : C
⊢ ((α_ X.fst Y.fst Z.fst).hom ⊗ 𝟙 U) ≫
      (α_ X.fst (Y.fst ⊗ Z.fst) U).hom ≫
        ((𝟙 X.fst ⊗ (α_ Y.fst Z.fst U).hom) ≫
            (𝟙 X.fst ⊗ 𝟙 Y.fst ⊗ (HalfBraiding.β Z.snd U).hom) ≫
              (𝟙 X.fst ⊗ (α_ Y.fst U Z.fst).inv) ≫
                (𝟙 X.fst ⊗ (HalfBraiding.β Y.snd U).hom ⊗ 𝟙 Z.fst) ≫ (𝟙 X.fst ⊗ (α_ U Y.fst Z.fst).hom)) ≫
          (α_ X.fst U (Y.fst ⊗ Z.fst)).inv ≫
            ((HalfBraiding.β X.snd U).hom ⊗ 𝟙 Y.fst ⊗ 𝟙 Z.fst) ≫ (α_ U X.fst (Y.fst ⊗ Z.fst)).hom =
    ((α_ (X.fst ⊗ Y.fst) Z.fst U).hom ≫
        ((α_ X.fst Y.fst (Z.fst ⊗ U)).hom ≫
            (𝟙 X.fst ⊗ 𝟙 Y.fst ⊗ (HalfBraiding.β Z.snd U).hom) ≫ (α_ X.fst Y.fst (U ⊗ Z.fst)).inv) ≫
          (α_ (X.fst ⊗ Y.fst) U Z.fst).inv ≫
            (((α_ X.fst Y.fst U).hom ⊗ 𝟙 Z.fst) ≫
                ((α_ X.fst (Y.fst ⊗ U) Z.fst).hom ≫
                    (𝟙 X.fst ⊗ (HalfBraiding.β Y.snd U).hom ⊗ 𝟙 Z.fst) ≫ (α_ X.fst (U ⊗ Y.fst) Z.fst).inv) ≫
                  ((α_ X.fst U Y.fst).inv ⊗ 𝟙 Z.fst) ≫
                    ((α_ (X.fst ⊗ U) Y.fst Z.fst).hom ≫
                        ((HalfBraiding.β X.snd U).hom ⊗ 𝟙 Y.fst ⊗ 𝟙 Z.fst) ≫ (α_ (U ⊗ X.fst) Y.fst Z.fst).inv) ≫
                      ((α_ U X.fst Y.fst).hom ⊗ 𝟙 Z.fst)) ≫
              (α_ U (X.fst ⊗ Y.fst) Z.fst).hom) ≫
      (𝟙 U ⊗ (α_ X.fst Y.fst Z.fst).hom)

Next tactic:
coherence
/-- Auxiliary definition for the `MonoidalCategory` instance on `Center C`. -/
def leftUnitor (X : Center C) : tensorObj tensorUnit X ≅ X :=
  isoMk
    ⟨(λ_ X.1).hom, fun U => by
      

Proof state:
C : Type u₁
inst✝¹ : Category.{v₁, u₁} C
inst✝ : MonoidalCategory C
X : Center C
U : C
⊢ ((λ_ X.fst).hom ⊗ 𝟙 U) ≫ (HalfBraiding.β X.snd U).hom =
    (HalfBraiding.β (tensorObj tensorUnit X).snd U).hom ≫ (𝟙 U ⊗ (λ_ X.fst).hom)

Next tactic:
dsimp
/-- Auxiliary definition for the `MonoidalCategory` instance on `Center C`. -/
def leftUnitor (X : Center C) : tensorObj tensorUnit X ≅ X :=
  isoMk
    ⟨(λ_ X.1).hom, fun U => by
      dsimp
      

Proof state:
C : Type u₁
inst✝¹ : Category.{v₁, u₁} C
inst✝ : MonoidalCategory C
X : Center C
U : C
⊢ ((λ_ X.fst).hom ⊗ 𝟙 U) ≫ (HalfBraiding.β X.snd U).hom =
    ((α_ (𝟙_ C) X.fst U).hom ≫
        (𝟙 (𝟙_ C) ⊗ (HalfBraiding.β X.snd U).hom) ≫
          (α_ (𝟙_ C) U X.fst).inv ≫ ((λ_ U).hom ≫ (ρ_ U).inv ⊗ 𝟙 X.fst) ≫ (α_ U (𝟙_ C) X.fst).hom) ≫
      (𝟙 U ⊗ (λ_ X.fst).hom)

Next tactic:
simp only [Category.comp_id, Category.assoc, tensor_inv_hom_id, comp_tensor_id,
        tensor_id_comp_id_tensor, triangle_assoc_comp_right_inv]
/-- Auxiliary definition for the `MonoidalCategory` instance on `Center C`. -/
def leftUnitor (X : Center C) : tensorObj tensorUnit X ≅ X :=
  isoMk
    ⟨(λ_ X.1).hom, fun U => by
      dsimp
      simp only [Category.comp_id, Category.assoc, tensor_inv_hom_id, comp_tensor_id,
        tensor_id_comp_id_tensor, triangle_assoc_comp_right_inv]
      

Proof state:
C : Type u₁
inst✝¹ : Category.{v₁, u₁} C
inst✝ : MonoidalCategory C
X : Center C
U : C
⊢ ((λ_ X.fst).hom ⊗ 𝟙 U) ≫ (HalfBraiding.β X.snd U).hom =
    (α_ (𝟙_ C) X.fst U).hom ≫
      (𝟙 (𝟙_ C) ⊗ (HalfBraiding.β X.snd U).hom) ≫ (α_ (𝟙_ C) U X.fst).inv ≫ ((λ_ U).hom ⊗ 𝟙 X.fst)

Next tactic:
rw [← leftUnitor_tensor, leftUnitor_naturality, leftUnitor_tensor'_assoc]
/-- Auxiliary definition for the `MonoidalCategory` instance on `Center C`. -/
def rightUnitor (X : Center C) : tensorObj X tensorUnit ≅ X :=
  isoMk
    ⟨(ρ_ X.1).hom, fun U => by
      

Proof state:
C : Type u₁
inst✝¹ : Category.{v₁, u₁} C
inst✝ : MonoidalCategory C
X : Center C
U : C
⊢ ((ρ_ X.fst).hom ⊗ 𝟙 U) ≫ (HalfBraiding.β X.snd U).hom =
    (HalfBraiding.β (tensorObj X tensorUnit).snd U).hom ≫ (𝟙 U ⊗ (ρ_ X.fst).hom)

Next tactic:
dsimp
/-- Auxiliary definition for the `MonoidalCategory` instance on `Center C`. -/
def rightUnitor (X : Center C) : tensorObj X tensorUnit ≅ X :=
  isoMk
    ⟨(ρ_ X.1).hom, fun U => by
      dsimp
      

Proof state:
C : Type u₁
inst✝¹ : Category.{v₁, u₁} C
inst✝ : MonoidalCategory C
X : Center C
U : C
⊢ ((ρ_ X.fst).hom ⊗ 𝟙 U) ≫ (HalfBraiding.β X.snd U).hom =
    ((α_ X.fst (𝟙_ C) U).hom ≫
        (𝟙 X.fst ⊗ (λ_ U).hom ≫ (ρ_ U).inv) ≫
          (α_ X.fst U (𝟙_ C)).inv ≫ ((HalfBraiding.β X.snd U).hom ⊗ 𝟙 (𝟙_ C)) ≫ (α_ U X.fst (𝟙_ C)).hom) ≫
      (𝟙 U ⊗ (ρ_ X.fst).hom)

Next tactic:
simp only [tensor_id_comp_id_tensor_assoc, triangle_assoc, id_tensor_comp, Category.assoc]
/-- Auxiliary definition for the `MonoidalCategory` instance on `Center C`. -/
def rightUnitor (X : Center C) : tensorObj X tensorUnit ≅ X :=
  isoMk
    ⟨(ρ_ X.1).hom, fun U => by
      dsimp
      simp only [tensor_id_comp_id_tensor_assoc, triangle_assoc, id_tensor_comp, Category.assoc]
      

Proof state:
C : Type u₁
inst✝¹ : Category.{v₁, u₁} C
inst✝ : MonoidalCategory C
X : Center C
U : C
⊢ ((ρ_ X.fst).hom ⊗ 𝟙 U) ≫ (HalfBraiding.β X.snd U).hom =
    ((ρ_ X.fst).hom ⊗ (ρ_ U).inv) ≫
      (α_ X.fst U (𝟙_ C)).inv ≫
        ((HalfBraiding.β X.snd U).hom ⊗ 𝟙 (𝟙_ C)) ≫ (α_ U X.fst (𝟙_ C)).hom ≫ (𝟙 U ⊗ (ρ_ X.fst).hom)

Next tactic:
rw [← tensor_id_comp_id_tensor_assoc (ρ_ U).inv, cancel_epi, ← rightUnitor_tensor_inv_assoc,
        ← rightUnitor_inv_naturality_assoc]