l3lab/ntp-mathlib huggingface dataset:
/-- `tensorRightHomEquiv` commutes with tensoring on the left -/
theorem tensorRightHomEquiv_tensor {X X' Y Y' Z Z' : C} [ExactPairing Y Y'] (f : X ⟶ Z ⊗ Y')
    (g : X' ⟶ Z') :
    (tensorRightHomEquiv (X' ⊗ X) Y Y' (Z' ⊗ Z)).symm ((g ⊗ f) ≫ (α_ _ _ _).inv) =
      (α_ _ _ _).hom ≫ (g ⊗ (tensorRightHomEquiv X Y Y' Z).symm f) := by
  dsimp [tensorRightHomEquiv]
  

Proof state:
C : Type u₁
inst✝² : Category.{v₁, u₁} C
inst✝¹ : MonoidalCategory C
X X' Y Y' Z Z' : C
inst✝ : ExactPairing Y Y'
f : X ⟶ Z ⊗ Y'
g : X' ⟶ Z'
⊢ ((g ⊗ f) ≫ (α_ Z' Z Y').inv ⊗ 𝟙 Y) ≫ (α_ (Z' ⊗ Z) Y' Y).hom ≫ (𝟙 (Z' ⊗ Z) ⊗ ε_ Y Y') ≫ (ρ_ (Z' ⊗ Z)).hom =
    (α_ X' X Y).hom ≫ (g ⊗ (f ⊗ 𝟙 Y) ≫ (α_ Z Y' Y).hom ≫ (𝟙 Z ⊗ ε_ Y Y') ≫ (ρ_ Z).hom)

Next tactic:
simp only [comp_tensor_id]
/-- `tensorRightHomEquiv` commutes with tensoring on the left -/
theorem tensorRightHomEquiv_tensor {X X' Y Y' Z Z' : C} [ExactPairing Y Y'] (f : X ⟶ Z ⊗ Y')
    (g : X' ⟶ Z') :
    (tensorRightHomEquiv (X' ⊗ X) Y Y' (Z' ⊗ Z)).symm ((g ⊗ f) ≫ (α_ _ _ _).inv) =
      (α_ _ _ _).hom ≫ (g ⊗ (tensorRightHomEquiv X Y Y' Z).symm f) := by
  dsimp [tensorRightHomEquiv]
  simp only [comp_tensor_id]
  

Proof state:
C : Type u₁
inst✝² : Category.{v₁, u₁} C
inst✝¹ : MonoidalCategory C
X X' Y Y' Z Z' : C
inst✝ : ExactPairing Y Y'
f : X ⟶ Z ⊗ Y'
g : X' ⟶ Z'
⊢ (((g ⊗ f) ⊗ 𝟙 Y) ≫ ((α_ Z' Z Y').inv ⊗ 𝟙 Y)) ≫ (α_ (Z' ⊗ Z) Y' Y).hom ≫ (𝟙 (Z' ⊗ Z) ⊗ ε_ Y Y') ≫ (ρ_ (Z' ⊗ Z)).hom =
    (α_ X' X Y).hom ≫ (g ⊗ (f ⊗ 𝟙 Y) ≫ (α_ Z Y' Y).hom ≫ (𝟙 Z ⊗ ε_ Y Y') ≫ (ρ_ Z).hom)

Next tactic:
simp only [associator_conjugation]
/-- `tensorRightHomEquiv` commutes with tensoring on the left -/
theorem tensorRightHomEquiv_tensor {X X' Y Y' Z Z' : C} [ExactPairing Y Y'] (f : X ⟶ Z ⊗ Y')
    (g : X' ⟶ Z') :
    (tensorRightHomEquiv (X' ⊗ X) Y Y' (Z' ⊗ Z)).symm ((g ⊗ f) ≫ (α_ _ _ _).inv) =
      (α_ _ _ _).hom ≫ (g ⊗ (tensorRightHomEquiv X Y Y' Z).symm f) := by
  dsimp [tensorRightHomEquiv]
  simp only [comp_tensor_id]
  simp only [associator_conjugation]
  

Proof state:
C : Type u₁
inst✝² : Category.{v₁, u₁} C
inst✝¹ : MonoidalCategory C
X X' Y Y' Z Z' : C
inst✝ : ExactPairing Y Y'
f : X ⟶ Z ⊗ Y'
g : X' ⟶ Z'
⊢ (((α_ X' X Y).hom ≫ (g ⊗ f ⊗ 𝟙 Y) ≫ (α_ Z' (Z ⊗ Y') Y).inv) ≫ ((α_ Z' Z Y').inv ⊗ 𝟙 Y)) ≫
      (α_ (Z' ⊗ Z) Y' Y).hom ≫ (𝟙 (Z' ⊗ Z) ⊗ ε_ Y Y') ≫ (ρ_ (Z' ⊗ Z)).hom =
    (α_ X' X Y).hom ≫ (g ⊗ (f ⊗ 𝟙 Y) ≫ (α_ Z Y' Y).hom ≫ (𝟙 Z ⊗ ε_ Y Y') ≫ (ρ_ Z).hom)

Next tactic:
slice_lhs 2 2 => rw [← tensor_id_comp_id_tensor]
/-- `tensorRightHomEquiv` commutes with tensoring on the left -/
theorem tensorRightHomEquiv_tensor {X X' Y Y' Z Z' : C} [ExactPairing Y Y'] (f : X ⟶ Z ⊗ Y')
    (g : X' ⟶ Z') :
    (tensorRightHomEquiv (X' ⊗ X) Y Y' (Z' ⊗ Z)).symm ((g ⊗ f) ≫ (α_ _ _ _).inv) =
      (α_ _ _ _).hom ≫ (g ⊗ (tensorRightHomEquiv X Y Y' Z).symm f) := by
  dsimp [tensorRightHomEquiv]
  simp only [comp_tensor_id]
  simp only [associator_conjugation]
  slice_lhs 2 2 => 

Proof state:
case a.a.a.a.a.a
C : Type u₁
inst✝² : Category.{v₁, u₁} C
inst✝¹ : MonoidalCategory C
X X' Y Y' Z Z' : C
inst✝ : ExactPairing Y Y'
f : X ⟶ Z ⊗ Y'
g : X' ⟶ Z'
| g ⊗ f ⊗ 𝟙 Y
case a.a.a.a.a.a
C : Type u₁
inst✝² : Category.{v₁, u₁} C
inst✝¹ : MonoidalCategory C
X X' Y Y' Z Z' : C
inst✝ : ExactPairing Y Y'
f : X ⟶ Z ⊗ Y'
g : X' ⟶ Z'
| (α_ Z' (Z ⊗ Y') Y).inv
case a.a.a.a.a
C : Type u₁
inst✝² : Category.{v₁, u₁} C
inst✝¹ : MonoidalCategory C
X X' Y Y' Z Z' : C
inst✝ : ExactPairing Y Y'
f : X ⟶ Z ⊗ Y'
g : X' ⟶ Z'
| (α_ Z' Z Y').inv ⊗ 𝟙 Y
case a.a.a.a
C : Type u₁
inst✝² : Category.{v₁, u₁} C
inst✝¹ : MonoidalCategory C
X X' Y Y' Z Z' : C
inst✝ : ExactPairing Y Y'
f : X ⟶ Z ⊗ Y'
g : X' ⟶ Z'
| (α_ (Z' ⊗ Z) Y' Y).hom
case a.a.a
C : Type u₁
inst✝² : Category.{v₁, u₁} C
inst✝¹ : MonoidalCategory C
X X' Y Y' Z Z' : C
inst✝ : ExactPairing Y Y'
f : X ⟶ Z ⊗ Y'
g : X' ⟶ Z'
| 𝟙 (Z' ⊗ Z) ⊗ ε_ Y Y'
case a.a
C : Type u₁
inst✝² : Category.{v₁, u₁} C
inst✝¹ : MonoidalCategory C
X X' Y Y' Z Z' : C
inst✝ : ExactPairing Y Y'
f : X ⟶ Z ⊗ Y'
g : X' ⟶ Z'
| (ρ_ (Z' ⊗ Z)).hom
case a
C : Type u₁
inst✝² : Category.{v₁, u₁} C
inst✝¹ : MonoidalCategory C
X X' Y Y' Z Z' : C
inst✝ : ExactPairing Y Y'
f : X ⟶ Z ⊗ Y'
g : X' ⟶ Z'
| (α_ X' X Y).hom

Next tactic:
rw [← tensor_id_comp_id_tensor]
/-- `tensorRightHomEquiv` commutes with tensoring on the left -/
theorem tensorRightHomEquiv_tensor {X X' Y Y' Z Z' : C} [ExactPairing Y Y'] (f : X ⟶ Z ⊗ Y')
    (g : X' ⟶ Z') :
    (tensorRightHomEquiv (X' ⊗ X) Y Y' (Z' ⊗ Z)).symm ((g ⊗ f) ≫ (α_ _ _ _).inv) =
      (α_ _ _ _).hom ≫ (g ⊗ (tensorRightHomEquiv X Y Y' Z).symm f) := by
  dsimp [tensorRightHomEquiv]
  simp only [comp_tensor_id]
  simp only [associator_conjugation]
  slice_lhs 2 2 => rw [← tensor_id_comp_id_tensor]
  

Proof state:
C : Type u₁
inst✝² : Category.{v₁, u₁} C
inst✝¹ : MonoidalCategory C
X X' Y Y' Z Z' : C
inst✝ : ExactPairing Y Y'
f : X ⟶ Z ⊗ Y'
g : X' ⟶ Z'
⊢ (α_ X' X Y).hom ≫
      ((((((g ⊗ 𝟙 (X ⊗ Y)) ≫ (𝟙 Z' ⊗ f ⊗ 𝟙 Y)) ≫ (α_ Z' (Z ⊗ Y') Y).inv) ≫ ((α_ Z' Z Y').inv ⊗ 𝟙 Y)) ≫
            (α_ (Z' ⊗ Z) Y' Y).hom) ≫
          (𝟙 (Z' ⊗ Z) ⊗ ε_ Y Y')) ≫
        (ρ_ (Z' ⊗ Z)).hom =
    (α_ X' X Y).hom ≫ (g ⊗ (f ⊗ 𝟙 Y) ≫ (α_ Z Y' Y).hom ≫ (𝟙 Z ⊗ ε_ Y Y') ≫ (ρ_ Z).hom)

Next tactic:
conv_rhs => rw [← tensor_id_comp_id_tensor, id_tensor_comp, id_tensor_comp]
/-- `tensorRightHomEquiv` commutes with tensoring on the left -/
theorem tensorRightHomEquiv_tensor {X X' Y Y' Z Z' : C} [ExactPairing Y Y'] (f : X ⟶ Z ⊗ Y')
    (g : X' ⟶ Z') :
    (tensorRightHomEquiv (X' ⊗ X) Y Y' (Z' ⊗ Z)).symm ((g ⊗ f) ≫ (α_ _ _ _).inv) =
      (α_ _ _ _).hom ≫ (g ⊗ (tensorRightHomEquiv X Y Y' Z).symm f) := by
  dsimp [tensorRightHomEquiv]
  simp only [comp_tensor_id]
  simp only [associator_conjugation]
  slice_lhs 2 2 => rw [← tensor_id_comp_id_tensor]
  conv_rhs => 

Proof state:
C : Type u₁
inst✝² : Category.{v₁, u₁} C
inst✝¹ : MonoidalCategory C
X X' Y Y' Z Z' : C
inst✝ : ExactPairing Y Y'
f : X ⟶ Z ⊗ Y'
g : X' ⟶ Z'
| (α_ X' X Y).hom ≫ (g ⊗ (f ⊗ 𝟙 Y) ≫ (α_ Z Y' Y).hom ≫ (𝟙 Z ⊗ ε_ Y Y') ≫ (ρ_ Z).hom)

Next tactic:
rw [← tensor_id_comp_id_tensor, id_tensor_comp, id_tensor_comp]
/-- `tensorRightHomEquiv` commutes with tensoring on the left -/
theorem tensorRightHomEquiv_tensor {X X' Y Y' Z Z' : C} [ExactPairing Y Y'] (f : X ⟶ Z ⊗ Y')
    (g : X' ⟶ Z') :
    (tensorRightHomEquiv (X' ⊗ X) Y Y' (Z' ⊗ Z)).symm ((g ⊗ f) ≫ (α_ _ _ _).inv) =
      (α_ _ _ _).hom ≫ (g ⊗ (tensorRightHomEquiv X Y Y' Z).symm f) := by
  dsimp [tensorRightHomEquiv]
  simp only [comp_tensor_id]
  simp only [associator_conjugation]
  slice_lhs 2 2 => rw [← tensor_id_comp_id_tensor]
  conv_rhs => rw [← tensor_id_comp_id_tensor, id_tensor_comp, id_tensor_comp]
  

Proof state:
C : Type u₁
inst✝² : Category.{v₁, u₁} C
inst✝¹ : MonoidalCategory C
X X' Y Y' Z Z' : C
inst✝ : ExactPairing Y Y'
f : X ⟶ Z ⊗ Y'
g : X' ⟶ Z'
⊢ (α_ X' X Y).hom ≫
      ((((((g ⊗ 𝟙 (X ⊗ Y)) ≫ (𝟙 Z' ⊗ f ⊗ 𝟙 Y)) ≫ (α_ Z' (Z ⊗ Y') Y).inv) ≫ ((α_ Z' Z Y').inv ⊗ 𝟙 Y)) ≫
            (α_ (Z' ⊗ Z) Y' Y).hom) ≫
          (𝟙 (Z' ⊗ Z) ⊗ ε_ Y Y')) ≫
        (ρ_ (Z' ⊗ Z)).hom =
    (α_ X' X Y).hom ≫
      (g ⊗ 𝟙 (X ⊗ Y)) ≫ (𝟙 Z' ⊗ f ⊗ 𝟙 Y) ≫ (𝟙 Z' ⊗ (α_ Z Y' Y).hom) ≫ (𝟙 Z' ⊗ (𝟙 Z ⊗ ε_ Y Y') ≫ (ρ_ Z).hom)

Next tactic:
simp only [← tensor_id, associator_conjugation]
/-- `tensorRightHomEquiv` commutes with tensoring on the left -/
theorem tensorRightHomEquiv_tensor {X X' Y Y' Z Z' : C} [ExactPairing Y Y'] (f : X ⟶ Z ⊗ Y')
    (g : X' ⟶ Z') :
    (tensorRightHomEquiv (X' ⊗ X) Y Y' (Z' ⊗ Z)).symm ((g ⊗ f) ≫ (α_ _ _ _).inv) =
      (α_ _ _ _).hom ≫ (g ⊗ (tensorRightHomEquiv X Y Y' Z).symm f) := by
  dsimp [tensorRightHomEquiv]
  simp only [comp_tensor_id]
  simp only [associator_conjugation]
  slice_lhs 2 2 => rw [← tensor_id_comp_id_tensor]
  conv_rhs => rw [← tensor_id_comp_id_tensor, id_tensor_comp, id_tensor_comp]
  simp only [← tensor_id, associator_conjugation]
  

Proof state:
C : Type u₁
inst✝² : Category.{v₁, u₁} C
inst✝¹ : MonoidalCategory C
X X' Y Y' Z Z' : C
inst✝ : ExactPairing Y Y'
f : X ⟶ Z ⊗ Y'
g : X' ⟶ Z'
⊢ (α_ X' X Y).hom ≫
      ((((((g ⊗ 𝟙 X ⊗ 𝟙 Y) ≫ (𝟙 Z' ⊗ f ⊗ 𝟙 Y)) ≫ (α_ Z' (Z ⊗ Y') Y).inv) ≫ ((α_ Z' Z Y').inv ⊗ 𝟙 Y)) ≫
            (α_ (Z' ⊗ Z) Y' Y).hom) ≫
          (α_ Z' Z (Y' ⊗ Y)).hom ≫ (𝟙 Z' ⊗ 𝟙 Z ⊗ ε_ Y Y') ≫ (α_ Z' Z (𝟙_ C)).inv) ≫
        (ρ_ (Z' ⊗ Z)).hom =
    (α_ X' X Y).hom ≫
      (g ⊗ 𝟙 X ⊗ 𝟙 Y) ≫ (𝟙 Z' ⊗ f ⊗ 𝟙 Y) ≫ (𝟙 Z' ⊗ (α_ Z Y' Y).hom) ≫ (𝟙 Z' ⊗ (𝟙 Z ⊗ ε_ Y Y') ≫ (ρ_ Z).hom)

Next tactic:
simp
/-- `tensorRightHomEquiv` commutes with tensoring on the left -/
theorem tensorRightHomEquiv_tensor {X X' Y Y' Z Z' : C} [ExactPairing Y Y'] (f : X ⟶ Z ⊗ Y')
    (g : X' ⟶ Z') :
    (tensorRightHomEquiv (X' ⊗ X) Y Y' (Z' ⊗ Z)).symm ((g ⊗ f) ≫ (α_ _ _ _).inv) =
      (α_ _ _ _).hom ≫ (g ⊗ (tensorRightHomEquiv X Y Y' Z).symm f) := by
  dsimp [tensorRightHomEquiv]
  simp only [comp_tensor_id]
  simp only [associator_conjugation]
  slice_lhs 2 2 => rw [← tensor_id_comp_id_tensor]
  conv_rhs => rw [← tensor_id_comp_id_tensor, id_tensor_comp, id_tensor_comp]
  simp only [← tensor_id, associator_conjugation]
  simp; 

Proof state:
C : Type u₁
inst✝² : Category.{v₁, u₁} C
inst✝¹ : MonoidalCategory C
X X' Y Y' Z Z' : C
inst✝ : ExactPairing Y Y'
f : X ⟶ Z ⊗ Y'
g : X' ⟶ Z'
⊢ (g ⊗ f ⊗ 𝟙 Y) ≫
      (α_ Z' (Z ⊗ Y') Y).inv ≫
        ((α_ Z' Z Y').inv ⊗ 𝟙 Y) ≫
          (α_ (Z' ⊗ Z) Y' Y).hom ≫ (α_ Z' Z (Y' ⊗ Y)).hom ≫ (𝟙 Z' ⊗ 𝟙 Z ⊗ ε_ Y Y') ≫ (𝟙 Z' ⊗ (ρ_ Z).hom) =
    (g ⊗ f ⊗ 𝟙 Y) ≫ (𝟙 Z' ⊗ (α_ Z Y' Y).hom) ≫ (𝟙 Z' ⊗ 𝟙 Z ⊗ ε_ Y Y') ≫ (𝟙 Z' ⊗ (ρ_ Z).hom)

Next tactic:
coherence
@[simp]
theorem tensorLeftHomEquiv_symm_coevaluation_comp_id_tensor {Y Y' Z : C} [ExactPairing Y Y']
    (f : Y' ⟶ Z) : (tensorLeftHomEquiv _ _ _ _).symm (η_ _ _ ≫ (𝟙 Y ⊗ f)) = (ρ_ _).hom ≫ f := by
  

Proof state:
C : Type u₁
inst✝² : Category.{v₁, u₁} C
inst✝¹ : MonoidalCategory C
Y Y' Z : C
inst✝ : ExactPairing Y Y'
f : Y' ⟶ Z
⊢ (tensorLeftHomEquiv (𝟙_ C) Y Y' Z).symm (η_ Y Y' ≫ (𝟙 Y ⊗ f)) = (ρ_ Y').hom ≫ f

Next tactic:
dsimp [tensorLeftHomEquiv]
@[simp]
theorem tensorLeftHomEquiv_symm_coevaluation_comp_id_tensor {Y Y' Z : C} [ExactPairing Y Y']
    (f : Y' ⟶ Z) : (tensorLeftHomEquiv _ _ _ _).symm (η_ _ _ ≫ (𝟙 Y ⊗ f)) = (ρ_ _).hom ≫ f := by
  dsimp [tensorLeftHomEquiv]
  

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

Next tactic:
rw [id_tensor_comp]
@[simp]
theorem tensorLeftHomEquiv_symm_coevaluation_comp_id_tensor {Y Y' Z : C} [ExactPairing Y Y']
    (f : Y' ⟶ Z) : (tensorLeftHomEquiv _ _ _ _).symm (η_ _ _ ≫ (𝟙 Y ⊗ f)) = (ρ_ _).hom ≫ f := by
  dsimp [tensorLeftHomEquiv]
  rw [id_tensor_comp]
  

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

Next tactic:
slice_lhs 2 3 => rw [associator_inv_naturality]
@[simp]
theorem tensorLeftHomEquiv_symm_coevaluation_comp_id_tensor {Y Y' Z : C} [ExactPairing Y Y']
    (f : Y' ⟶ Z) : (tensorLeftHomEquiv _ _ _ _).symm (η_ _ _ ≫ (𝟙 Y ⊗ f)) = (ρ_ _).hom ≫ f := by
  dsimp [tensorLeftHomEquiv]
  rw [id_tensor_comp]
  slice_lhs 2 3 => 

Proof state:
case a.a.a
C : Type u₁
inst✝² : Category.{v₁, u₁} C
inst✝¹ : MonoidalCategory C
Y Y' Z : C
inst✝ : ExactPairing Y Y'
f : Y' ⟶ Z
| (𝟙 Y' ⊗ 𝟙 Y ⊗ f) ≫ (α_ Y' Y Z).inv
case a.a.a
C : Type u₁
inst✝² : Category.{v₁, u₁} C
inst✝¹ : MonoidalCategory C
Y Y' Z : C
inst✝ : ExactPairing Y Y'
f : Y' ⟶ Z
| ε_ Y Y' ⊗ 𝟙 Z
case a.a
C : Type u₁
inst✝² : Category.{v₁, u₁} C
inst✝¹ : MonoidalCategory C
Y Y' Z : C
inst✝ : ExactPairing Y Y'
f : Y' ⟶ Z
| (λ_ Z).hom
case a
C : Type u₁
inst✝² : Category.{v₁, u₁} C
inst✝¹ : MonoidalCategory C
Y Y' Z : C
inst✝ : ExactPairing Y Y'
f : Y' ⟶ Z
| 𝟙 Y' ⊗ η_ Y Y'

Next tactic:
rw [associator_inv_naturality]
@[simp]
theorem tensorLeftHomEquiv_symm_coevaluation_comp_id_tensor {Y Y' Z : C} [ExactPairing Y Y']
    (f : Y' ⟶ Z) : (tensorLeftHomEquiv _ _ _ _).symm (η_ _ _ ≫ (𝟙 Y ⊗ f)) = (ρ_ _).hom ≫ f := by
  dsimp [tensorLeftHomEquiv]
  rw [id_tensor_comp]
  slice_lhs 2 3 => rw [associator_inv_naturality]
  

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

Next tactic:
slice_lhs 3 4 => rw [tensor_id, id_tensor_comp_tensor_id, ← tensor_id_comp_id_tensor]
@[simp]
theorem tensorLeftHomEquiv_symm_coevaluation_comp_id_tensor {Y Y' Z : C} [ExactPairing Y Y']
    (f : Y' ⟶ Z) : (tensorLeftHomEquiv _ _ _ _).symm (η_ _ _ ≫ (𝟙 Y ⊗ f)) = (ρ_ _).hom ≫ f := by
  dsimp [tensorLeftHomEquiv]
  rw [id_tensor_comp]
  slice_lhs 2 3 => rw [associator_inv_naturality]
  slice_lhs 3 4 => 

Proof state:
case a.a.a
C : Type u₁
inst✝² : Category.{v₁, u₁} C
inst✝¹ : MonoidalCategory C
Y Y' Z : C
inst✝ : ExactPairing Y Y'
f : Y' ⟶ Z
| ((𝟙 Y' ⊗ 𝟙 Y) ⊗ f) ≫ (ε_ Y Y' ⊗ 𝟙 Z)
case a.a.a
C : Type u₁
inst✝² : Category.{v₁, u₁} C
inst✝¹ : MonoidalCategory C
Y Y' Z : C
inst✝ : ExactPairing Y Y'
f : Y' ⟶ Z
| (λ_ Z).hom
case a
C : Type u₁
inst✝² : Category.{v₁, u₁} C
inst✝¹ : MonoidalCategory C
Y Y' Z : C
inst✝ : ExactPairing Y Y'
f : Y' ⟶ Z
| 𝟙 Y' ⊗ η_ Y Y'
case a.a
C : Type u₁
inst✝² : Category.{v₁, u₁} C
inst✝¹ : MonoidalCategory C
Y Y' Z : C
inst✝ : ExactPairing Y Y'
f : Y' ⟶ Z
| (α_ Y' Y Y').inv

Next tactic:
rw [tensor_id, id_tensor_comp_tensor_id, ← tensor_id_comp_id_tensor]
@[simp]
theorem tensorLeftHomEquiv_symm_coevaluation_comp_id_tensor {Y Y' Z : C} [ExactPairing Y Y']
    (f : Y' ⟶ Z) : (tensorLeftHomEquiv _ _ _ _).symm (η_ _ _ ≫ (𝟙 Y ⊗ f)) = (ρ_ _).hom ≫ f := by
  dsimp [tensorLeftHomEquiv]
  rw [id_tensor_comp]
  slice_lhs 2 3 => rw [associator_inv_naturality]
  slice_lhs 3 4 => rw [tensor_id, id_tensor_comp_tensor_id, ← tensor_id_comp_id_tensor]
  

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

Next tactic:
slice_lhs 1 3 => rw [coevaluation_evaluation]
@[simp]
theorem tensorLeftHomEquiv_symm_coevaluation_comp_id_tensor {Y Y' Z : C} [ExactPairing Y Y']
    (f : Y' ⟶ Z) : (tensorLeftHomEquiv _ _ _ _).symm (η_ _ _ ≫ (𝟙 Y ⊗ f)) = (ρ_ _).hom ≫ f := by
  dsimp [tensorLeftHomEquiv]
  rw [id_tensor_comp]
  slice_lhs 2 3 => rw [associator_inv_naturality]
  slice_lhs 3 4 => rw [tensor_id, id_tensor_comp_tensor_id, ← tensor_id_comp_id_tensor]
  slice_lhs 1 3 => 

Proof state:
case a.a
C : Type u₁
inst✝² : Category.{v₁, u₁} C
inst✝¹ : MonoidalCategory C
Y Y' Z : C
inst✝ : ExactPairing Y Y'
f : Y' ⟶ Z
| (𝟙 Y' ⊗ η_ Y Y') ≫ (α_ Y' Y Y').inv ≫ (ε_ Y Y' ⊗ 𝟙 Y')
case a.a
C : Type u₁
inst✝² : Category.{v₁, u₁} C
inst✝¹ : MonoidalCategory C
Y Y' Z : C
inst✝ : ExactPairing Y Y'
f : Y' ⟶ Z
| 𝟙 (𝟙_ C) ⊗ f
case a
C : Type u₁
inst✝² : Category.{v₁, u₁} C
inst✝¹ : MonoidalCategory C
Y Y' Z : C
inst✝ : ExactPairing Y Y'
f : Y' ⟶ Z
| (λ_ Z).hom

Next tactic:
rw [coevaluation_evaluation]
@[simp]
theorem tensorLeftHomEquiv_symm_coevaluation_comp_id_tensor {Y Y' Z : C} [ExactPairing Y Y']
    (f : Y' ⟶ Z) : (tensorLeftHomEquiv _ _ _ _).symm (η_ _ _ ≫ (𝟙 Y ⊗ f)) = (ρ_ _).hom ≫ f := by
  dsimp [tensorLeftHomEquiv]
  rw [id_tensor_comp]
  slice_lhs 2 3 => rw [associator_inv_naturality]
  slice_lhs 3 4 => rw [tensor_id, id_tensor_comp_tensor_id, ← tensor_id_comp_id_tensor]
  slice_lhs 1 3 => rw [coevaluation_evaluation]
  

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

Next tactic:
simp
@[simp]
theorem tensorLeftHomEquiv_symm_coevaluation_comp_tensor_id {X Y : C} [HasRightDual X]
    [HasRightDual Y] (f : X ⟶ Y) :
    (tensorLeftHomEquiv _ _ _ _).symm (η_ _ _ ≫ (f ⊗ 𝟙 (Xᘁ))) = (ρ_ _).hom ≫ fᘁ := by
  

Proof state:
C : Type u₁
inst✝³ : Category.{v₁, u₁} C
inst✝² : MonoidalCategory C
X Y : C
inst✝¹ : HasRightDual X
inst✝ : HasRightDual Y
f : X ⟶ Y
⊢ (tensorLeftHomEquiv (𝟙_ C) Y Yᘁ Xᘁ).symm (η_ X Xᘁ ≫ (f ⊗ 𝟙 Xᘁ)) = (ρ_ Yᘁ).hom ≫ fᘁ

Next tactic:
dsimp [tensorLeftHomEquiv, rightAdjointMate]
@[simp]
theorem tensorLeftHomEquiv_symm_coevaluation_comp_tensor_id {X Y : C} [HasRightDual X]
    [HasRightDual Y] (f : X ⟶ Y) :
    (tensorLeftHomEquiv _ _ _ _).symm (η_ _ _ ≫ (f ⊗ 𝟙 (Xᘁ))) = (ρ_ _).hom ≫ fᘁ := by
  dsimp [tensorLeftHomEquiv, rightAdjointMate]
  

Proof state:
C : Type u₁
inst✝³ : Category.{v₁, u₁} C
inst✝² : MonoidalCategory C
X Y : C
inst✝¹ : HasRightDual X
inst✝ : HasRightDual Y
f : X ⟶ Y
⊢ (𝟙 Yᘁ ⊗ η_ X Xᘁ ≫ (f ⊗ 𝟙 Xᘁ)) ≫ (α_ Yᘁ Y Xᘁ).inv ≫ (ε_ Y Yᘁ ⊗ 𝟙 Xᘁ) ≫ (λ_ Xᘁ).hom =
    (ρ_ Yᘁ).hom ≫ (ρ_ Yᘁ).inv ≫ (𝟙 Yᘁ ⊗ η_ X Xᘁ) ≫ (𝟙 Yᘁ ⊗ f ⊗ 𝟙 Xᘁ) ≫ (α_ Yᘁ Y Xᘁ).inv ≫ (ε_ Y Yᘁ ⊗ 𝟙 Xᘁ) ≫ (λ_ Xᘁ).hom

Next tactic:
simp
@[simp]
theorem tensorRightHomEquiv_symm_coevaluation_comp_id_tensor {X Y : C} [HasLeftDual X]
    [HasLeftDual Y] (f : X ⟶ Y) :
    (tensorRightHomEquiv _ (ᘁY) _ _).symm (η_ (ᘁX) X ≫ (𝟙 (ᘁX) ⊗ f)) = (λ_ _).hom ≫ ᘁf := by
  

Proof state:
C : Type u₁
inst✝³ : Category.{v₁, u₁} C
inst✝² : MonoidalCategory C
X Y : C
inst✝¹ : HasLeftDual X
inst✝ : HasLeftDual Y
f : X ⟶ Y
⊢ (tensorRightHomEquiv (𝟙_ C) (ᘁY) Y ᘁX).symm (η_ (ᘁX) X ≫ (𝟙 ᘁX ⊗ f)) = (λ_ ᘁY).hom ≫ ᘁf

Next tactic:
dsimp [tensorRightHomEquiv, leftAdjointMate]
@[simp]
theorem tensorRightHomEquiv_symm_coevaluation_comp_id_tensor {X Y : C} [HasLeftDual X]
    [HasLeftDual Y] (f : X ⟶ Y) :
    (tensorRightHomEquiv _ (ᘁY) _ _).symm (η_ (ᘁX) X ≫ (𝟙 (ᘁX) ⊗ f)) = (λ_ _).hom ≫ ᘁf := by
  dsimp [tensorRightHomEquiv, leftAdjointMate]
  

Proof state:
C : Type u₁
inst✝³ : Category.{v₁, u₁} C
inst✝² : MonoidalCategory C
X Y : C
inst✝¹ : HasLeftDual X
inst✝ : HasLeftDual Y
f : X ⟶ Y
⊢ (η_ (ᘁX) X ≫ (𝟙 ᘁX ⊗ f) ⊗ 𝟙 ᘁY) ≫ (α_ (ᘁX) Y ᘁY).hom ≫ (𝟙 ᘁX ⊗ ε_ (ᘁY) Y) ≫ (ρ_ ᘁX).hom =
    (λ_ ᘁY).hom ≫
      (λ_ ᘁY).inv ≫ (η_ (ᘁX) X ⊗ 𝟙 ᘁY) ≫ ((𝟙 ᘁX ⊗ f) ⊗ 𝟙 ᘁY) ≫ (α_ (ᘁX) Y ᘁY).hom ≫ (𝟙 ᘁX ⊗ ε_ (ᘁY) Y) ≫ (ρ_ ᘁX).hom

Next tactic:
simp
@[simp]
theorem tensorRightHomEquiv_symm_coevaluation_comp_tensor_id {Y Y' Z : C} [ExactPairing Y Y']
    (f : Y ⟶ Z) : (tensorRightHomEquiv _ Y _ _).symm (η_ Y Y' ≫ (f ⊗ 𝟙 Y')) = (λ_ _).hom ≫ f := by
  

Proof state:
C : Type u₁
inst✝² : Category.{v₁, u₁} C
inst✝¹ : MonoidalCategory C
Y Y' Z : C
inst✝ : ExactPairing Y Y'
f : Y ⟶ Z
⊢ (tensorRightHomEquiv (𝟙_ C) Y Y' Z).symm (η_ Y Y' ≫ (f ⊗ 𝟙 Y')) = (λ_ Y).hom ≫ f

Next tactic:
dsimp [tensorRightHomEquiv]
@[simp]
theorem tensorRightHomEquiv_symm_coevaluation_comp_tensor_id {Y Y' Z : C} [ExactPairing Y Y']
    (f : Y ⟶ Z) : (tensorRightHomEquiv _ Y _ _).symm (η_ Y Y' ≫ (f ⊗ 𝟙 Y')) = (λ_ _).hom ≫ f := by
  dsimp [tensorRightHomEquiv]
  

Proof state:
C : Type u₁
inst✝² : Category.{v₁, u₁} C
inst✝¹ : MonoidalCategory C
Y Y' Z : C
inst✝ : ExactPairing Y Y'
f : Y ⟶ Z
⊢ (η_ Y Y' ≫ (f ⊗ 𝟙 Y') ⊗ 𝟙 Y) ≫ (α_ Z Y' Y).hom ≫ (𝟙 Z ⊗ ε_ Y Y') ≫ (ρ_ Z).hom = (λ_ Y).hom ≫ f

Next tactic:
rw [comp_tensor_id]
@[simp]
theorem tensorRightHomEquiv_symm_coevaluation_comp_tensor_id {Y Y' Z : C} [ExactPairing Y Y']
    (f : Y ⟶ Z) : (tensorRightHomEquiv _ Y _ _).symm (η_ Y Y' ≫ (f ⊗ 𝟙 Y')) = (λ_ _).hom ≫ f := by
  dsimp [tensorRightHomEquiv]
  rw [comp_tensor_id]
  

Proof state:
C : Type u₁
inst✝² : Category.{v₁, u₁} C
inst✝¹ : MonoidalCategory C
Y Y' Z : C
inst✝ : ExactPairing Y Y'
f : Y ⟶ Z
⊢ ((η_ Y Y' ⊗ 𝟙 Y) ≫ ((f ⊗ 𝟙 Y') ⊗ 𝟙 Y)) ≫ (α_ Z Y' Y).hom ≫ (𝟙 Z ⊗ ε_ Y Y') ≫ (ρ_ Z).hom = (λ_ Y).hom ≫ f

Next tactic:
slice_lhs 2 3 => rw [associator_naturality]
@[simp]
theorem tensorRightHomEquiv_symm_coevaluation_comp_tensor_id {Y Y' Z : C} [ExactPairing Y Y']
    (f : Y ⟶ Z) : (tensorRightHomEquiv _ Y _ _).symm (η_ Y Y' ≫ (f ⊗ 𝟙 Y')) = (λ_ _).hom ≫ f := by
  dsimp [tensorRightHomEquiv]
  rw [comp_tensor_id]
  slice_lhs 2 3 => 

Proof state:
case a.a.a
C : Type u₁
inst✝² : Category.{v₁, u₁} C
inst✝¹ : MonoidalCategory C
Y Y' Z : C
inst✝ : ExactPairing Y Y'
f : Y ⟶ Z
| ((f ⊗ 𝟙 Y') ⊗ 𝟙 Y) ≫ (α_ Z Y' Y).hom
case a.a.a
C : Type u₁
inst✝² : Category.{v₁, u₁} C
inst✝¹ : MonoidalCategory C
Y Y' Z : C
inst✝ : ExactPairing Y Y'
f : Y ⟶ Z
| 𝟙 Z ⊗ ε_ Y Y'
case a.a
C : Type u₁
inst✝² : Category.{v₁, u₁} C
inst✝¹ : MonoidalCategory C
Y Y' Z : C
inst✝ : ExactPairing Y Y'
f : Y ⟶ Z
| (ρ_ Z).hom
case a
C : Type u₁
inst✝² : Category.{v₁, u₁} C
inst✝¹ : MonoidalCategory C
Y Y' Z : C
inst✝ : ExactPairing Y Y'
f : Y ⟶ Z
| η_ Y Y' ⊗ 𝟙 Y

Next tactic:
rw [associator_naturality]
@[simp]
theorem tensorRightHomEquiv_symm_coevaluation_comp_tensor_id {Y Y' Z : C} [ExactPairing Y Y']
    (f : Y ⟶ Z) : (tensorRightHomEquiv _ Y _ _).symm (η_ Y Y' ≫ (f ⊗ 𝟙 Y')) = (λ_ _).hom ≫ f := by
  dsimp [tensorRightHomEquiv]
  rw [comp_tensor_id]
  slice_lhs 2 3 => rw [associator_naturality]
  

Proof state:
C : Type u₁
inst✝² : Category.{v₁, u₁} C
inst✝¹ : MonoidalCategory C
Y Y' Z : C
inst✝ : ExactPairing Y Y'
f : Y ⟶ Z
⊢ (η_ Y Y' ⊗ 𝟙 Y) ≫ (((α_ Y Y' Y).hom ≫ (f ⊗ 𝟙 Y' ⊗ 𝟙 Y)) ≫ (𝟙 Z ⊗ ε_ Y Y')) ≫ (ρ_ Z).hom = (λ_ Y).hom ≫ f

Next tactic:
slice_lhs 3 4 => rw [tensor_id, tensor_id_comp_id_tensor, ← id_tensor_comp_tensor_id]
@[simp]
theorem tensorRightHomEquiv_symm_coevaluation_comp_tensor_id {Y Y' Z : C} [ExactPairing Y Y']
    (f : Y ⟶ Z) : (tensorRightHomEquiv _ Y _ _).symm (η_ Y Y' ≫ (f ⊗ 𝟙 Y')) = (λ_ _).hom ≫ f := by
  dsimp [tensorRightHomEquiv]
  rw [comp_tensor_id]
  slice_lhs 2 3 => rw [associator_naturality]
  slice_lhs 3 4 => 

Proof state:
case a.a.a
C : Type u₁
inst✝² : Category.{v₁, u₁} C
inst✝¹ : MonoidalCategory C
Y Y' Z : C
inst✝ : ExactPairing Y Y'
f : Y ⟶ Z
| (f ⊗ 𝟙 Y' ⊗ 𝟙 Y) ≫ (𝟙 Z ⊗ ε_ Y Y')
case a.a.a
C : Type u₁
inst✝² : Category.{v₁, u₁} C
inst✝¹ : MonoidalCategory C
Y Y' Z : C
inst✝ : ExactPairing Y Y'
f : Y ⟶ Z
| (ρ_ Z).hom
case a
C : Type u₁
inst✝² : Category.{v₁, u₁} C
inst✝¹ : MonoidalCategory C
Y Y' Z : C
inst✝ : ExactPairing Y Y'
f : Y ⟶ Z
| η_ Y Y' ⊗ 𝟙 Y
case a.a
C : Type u₁
inst✝² : Category.{v₁, u₁} C
inst✝¹ : MonoidalCategory C
Y Y' Z : C
inst✝ : ExactPairing Y Y'
f : Y ⟶ Z
| (α_ Y Y' Y).hom

Next tactic:
rw [tensor_id, tensor_id_comp_id_tensor, ← id_tensor_comp_tensor_id]
@[simp]
theorem tensorRightHomEquiv_symm_coevaluation_comp_tensor_id {Y Y' Z : C} [ExactPairing Y Y']
    (f : Y ⟶ Z) : (tensorRightHomEquiv _ Y _ _).symm (η_ Y Y' ≫ (f ⊗ 𝟙 Y')) = (λ_ _).hom ≫ f := by
  dsimp [tensorRightHomEquiv]
  rw [comp_tensor_id]
  slice_lhs 2 3 => rw [associator_naturality]
  slice_lhs 3 4 => rw [tensor_id, tensor_id_comp_id_tensor, ← id_tensor_comp_tensor_id]
  

Proof state:
C : Type u₁
inst✝² : Category.{v₁, u₁} C
inst✝¹ : MonoidalCategory C
Y Y' Z : C
inst✝ : ExactPairing Y Y'
f : Y ⟶ Z
⊢ (η_ Y Y' ⊗ 𝟙 Y) ≫ (α_ Y Y' Y).hom ≫ ((𝟙 Y ⊗ ε_ Y Y') ≫ (f ⊗ 𝟙 (𝟙_ C))) ≫ (ρ_ Z).hom = (λ_ Y).hom ≫ f

Next tactic:
slice_lhs 1 3 => rw [evaluation_coevaluation]
@[simp]
theorem tensorRightHomEquiv_symm_coevaluation_comp_tensor_id {Y Y' Z : C} [ExactPairing Y Y']
    (f : Y ⟶ Z) : (tensorRightHomEquiv _ Y _ _).symm (η_ Y Y' ≫ (f ⊗ 𝟙 Y')) = (λ_ _).hom ≫ f := by
  dsimp [tensorRightHomEquiv]
  rw [comp_tensor_id]
  slice_lhs 2 3 => rw [associator_naturality]
  slice_lhs 3 4 => rw [tensor_id, tensor_id_comp_id_tensor, ← id_tensor_comp_tensor_id]
  slice_lhs 1 3 => 

Proof state:
case a.a
C : Type u₁
inst✝² : Category.{v₁, u₁} C
inst✝¹ : MonoidalCategory C
Y Y' Z : C
inst✝ : ExactPairing Y Y'
f : Y ⟶ Z
| (η_ Y Y' ⊗ 𝟙 Y) ≫ (α_ Y Y' Y).hom ≫ (𝟙 Y ⊗ ε_ Y Y')
case a.a
C : Type u₁
inst✝² : Category.{v₁, u₁} C
inst✝¹ : MonoidalCategory C
Y Y' Z : C
inst✝ : ExactPairing Y Y'
f : Y ⟶ Z
| f ⊗ 𝟙 (𝟙_ C)
case a
C : Type u₁
inst✝² : Category.{v₁, u₁} C
inst✝¹ : MonoidalCategory C
Y Y' Z : C
inst✝ : ExactPairing Y Y'
f : Y ⟶ Z
| (ρ_ Z).hom

Next tactic:
rw [evaluation_coevaluation]
@[simp]
theorem tensorRightHomEquiv_symm_coevaluation_comp_tensor_id {Y Y' Z : C} [ExactPairing Y Y']
    (f : Y ⟶ Z) : (tensorRightHomEquiv _ Y _ _).symm (η_ Y Y' ≫ (f ⊗ 𝟙 Y')) = (λ_ _).hom ≫ f := by
  dsimp [tensorRightHomEquiv]
  rw [comp_tensor_id]
  slice_lhs 2 3 => rw [associator_naturality]
  slice_lhs 3 4 => rw [tensor_id, tensor_id_comp_id_tensor, ← id_tensor_comp_tensor_id]
  slice_lhs 1 3 => rw [evaluation_coevaluation]
  

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

Next tactic:
simp