File: Mathlib/CategoryTheory/Monoidal/Rigid/Basic.lean

full_name: CategoryTheory.ExactPairing.coevaluation_evaluation'
code: /-- An exact pairing is a pair of objects `X Y : C` which admit
  a coevaluation and evaluation morphism which fulfill two triangle equalities. -/
class ExactPairing (X Y : C) where
  /-- Coevaluation of an exact pairing.

  Do not use directly. Use `ExactPairing.coevaluation` instead. -/
  coevaluation' : 𝟙_ C ⟶ X ⊗ Y
  /-- Evaluation of an exact pairing.

  Do not use directly. Use `ExactPairing.evaluation` instead. -/
  evaluation' : Y ⊗ X ⟶ 𝟙_ C
  coevaluation_evaluation' :
    Y ◁ coevaluation' ≫ (α_ _ _ _).inv ≫ evaluation' ▷ Y = (ρ_ Y).hom ≫ (λ_ Y).inv := by
    aesop_cat
  evaluation_coevaluation' :
    coevaluation' ▷ X ≫ (α_ _ _ _).hom ≫ X ◁ evaluation' = (λ_ X).hom ≫ (ρ_ X).inv := by
    aesop_cat
goal: Y ◁ CategoryTheory.ExactPairing.coevaluation' ≫ (α_ Y X Y).inv ≫ CategoryTheory.ExactPairing.evaluation' ▷ Y =
  (ρ_ Y).hom ≫ (λ_ Y).inv

full_name: CategoryTheory.ExactPairing.evaluation_coevaluation'
code: /-- An exact pairing is a pair of objects `X Y : C` which admit
  a coevaluation and evaluation morphism which fulfill two triangle equalities. -/
class ExactPairing (X Y : C) where
  /-- Coevaluation of an exact pairing.

  Do not use directly. Use `ExactPairing.coevaluation` instead. -/
  coevaluation' : 𝟙_ C ⟶ X ⊗ Y
  /-- Evaluation of an exact pairing.

  Do not use directly. Use `ExactPairing.evaluation` instead. -/
  evaluation' : Y ⊗ X ⟶ 𝟙_ C
  coevaluation_evaluation' :
    Y ◁ coevaluation' ≫ (α_ _ _ _).inv ≫ evaluation' ▷ Y = (ρ_ Y).hom ≫ (λ_ Y).inv := by
    aesop_cat
  evaluation_coevaluation' :
    coevaluation' ▷ X ≫ (α_ _ _ _).hom ≫ X ◁ evaluation' = (λ_ X).hom ≫ (ρ_ X).inv := by
    aesop_cat
goal: CategoryTheory.ExactPairing.coevaluation' ▷ X ≫ (α_ X Y X).hom ≫ X ◁ CategoryTheory.ExactPairing.evaluation' =
  (λ_ X).hom ≫ (ρ_ X).inv

full_name: CategoryTheory.ExactPairing.coevaluation'
code: /-- An exact pairing is a pair of objects `X Y : C` which admit
  a coevaluation and evaluation morphism which fulfill two triangle equalities. -/
class ExactPairing (X Y : C) where
  /-- Coevaluation of an exact pairing.

  Do not use directly. Use `ExactPairing.coevaluation` instead. -/
  coevaluation' : 𝟙_ C ⟶ X ⊗ Y
  /-- Evaluation of an exact pairing.

  Do not use directly. Use `ExactPairing.evaluation` instead. -/
  evaluation' : Y ⊗ X ⟶ 𝟙_ C
  coevaluation_evaluation' :
    Y ◁ coevaluation' ≫ (α_ _ _ _).inv ≫ evaluation' ▷ Y = (ρ_ Y).hom ≫ (λ_ Y).inv := by
    aesop_cat
  evaluation_coevaluation' :
    coevaluation' ▷ X ≫ (α_ _ _ _).hom ≫ X ◁ evaluation' = (λ_ X).hom ≫ (ρ_ X).inv := by
    aesop_cat
goal: 𝟙_ C ⟶ X ⊗ Y

full_name: CategoryTheory.ExactPairing
code: /-- An exact pairing is a pair of objects `X Y : C` which admit
  a coevaluation and evaluation morphism which fulfill two triangle equalities. -/
class ExactPairing (X Y : C) where
  /-- Coevaluation of an exact pairing.

  Do not use directly. Use `ExactPairing.coevaluation` instead. -/
  coevaluation' : 𝟙_ C ⟶ X ⊗ Y
  /-- Evaluation of an exact pairing.

  Do not use directly. Use `ExactPairing.evaluation` instead. -/
  evaluation' : Y ⊗ X ⟶ 𝟙_ C
  coevaluation_evaluation' :
    Y ◁ coevaluation' ≫ (α_ _ _ _).inv ≫ evaluation' ▷ Y = (ρ_ Y).hom ≫ (λ_ Y).inv := by
    aesop_cat
  evaluation_coevaluation' :
    coevaluation' ▷ X ≫ (α_ _ _ _).hom ≫ X ◁ evaluation' = (λ_ X).hom ≫ (ρ_ X).inv := by
    aesop_cat
goal: Type v₁

full_name: CategoryTheory.ExactPairing.evaluation'
code: /-- An exact pairing is a pair of objects `X Y : C` which admit
  a coevaluation and evaluation morphism which fulfill two triangle equalities. -/
class ExactPairing (X Y : C) where
  /-- Coevaluation of an exact pairing.

  Do not use directly. Use `ExactPairing.coevaluation` instead. -/
  coevaluation' : 𝟙_ C ⟶ X ⊗ Y
  /-- Evaluation of an exact pairing.

  Do not use directly. Use `ExactPairing.evaluation` instead. -/
  evaluation' : Y ⊗ X ⟶ 𝟙_ C
  coevaluation_evaluation' :
    Y ◁ coevaluation' ≫ (α_ _ _ _).inv ≫ evaluation' ▷ Y = (ρ_ Y).hom ≫ (λ_ Y).inv := by
    aesop_cat
  evaluation_coevaluation' :
    coevaluation' ▷ X ≫ (α_ _ _ _).hom ≫ X ◁ evaluation' = (λ_ X).hom ≫ (ρ_ X).inv := by
    aesop_cat
goal: Y ⊗ X ⟶ 𝟙_ C

full_name: CategoryTheory.ExactPairing.coevaluation
code: /-- Coevaluation of an exact pairing. -/
def coevaluation : 𝟙_ C ⟶ X ⊗ Y 
goal: 𝟙_ C ⟶ X ⊗ Y

full_name: CategoryTheory.ExactPairing.evaluation
code: /-- Evaluation of an exact pairing. -/
def evaluation : Y ⊗ X ⟶ 𝟙_ C 
goal: Y ⊗ X ⟶ 𝟙_ C

full_name: CategoryTheory.ExactPairing._aux_Mathlib_CategoryTheory_Monoidal_Rigid_Basic___macroRules_CategoryTheory_ExactPairing_termη__1
code: @[inherit_doc] notation "η_" => ExactPairing.coevaluation
goal: Lean.Macro

full_name: CategoryTheory.ExactPairing._aux_Mathlib_CategoryTheory_Monoidal_Rigid_Basic___unexpand_CategoryTheory_ExactPairing_coevaluation_1
code: @[inherit_doc] notation "η_" => ExactPairing.coevaluation
goal: Lean.PrettyPrinter.Unexpander

full_name: CategoryTheory.ExactPairing._aux_Mathlib_CategoryTheory_Monoidal_Rigid_Basic___unexpand_CategoryTheory_ExactPairing_evaluation_1
code: @[inherit_doc] notation "ε_" => ExactPairing.evaluation
goal: Lean.PrettyPrinter.Unexpander

full_name: CategoryTheory.ExactPairing._aux_Mathlib_CategoryTheory_Monoidal_Rigid_Basic___macroRules_CategoryTheory_ExactPairing_termε__1
code: @[inherit_doc] notation "ε_" => ExactPairing.evaluation
goal: Lean.Macro

full_name: CategoryTheory.ExactPairing.coevaluation_evaluation
code: lemma coevaluation_evaluation :
    Y ◁ η_ _ _ ≫ (α_ _ _ _).inv ≫ ε_ X _ ▷ Y = (ρ_ Y).hom ≫ (λ_ Y).inv 
goal: Y ◁ η_ X Y ≫ (α_ Y X Y).inv ≫ ε_ X Y ▷ Y = (ρ_ Y).hom ≫ (λ_ Y).inv

full_name: CategoryTheory.ExactPairing.evaluation_coevaluation
code: lemma evaluation_coevaluation :
    η_ _ _ ▷ X ≫ (α_ _ _ _).hom ≫ X ◁ ε_ _ Y = (λ_ X).hom ≫ (ρ_ X).inv 
goal: η_ X Y ▷ X ≫ (α_ X Y X).hom ≫ X ◁ ε_ X Y = (λ_ X).hom ≫ (ρ_ X).inv

full_name: CategoryTheory.ExactPairing.coevaluation_evaluation''
code: lemma coevaluation_evaluation'' :
    Y ◁ η_ X Y ⊗≫ ε_ X Y ▷ Y = ⊗𝟙 
goal: Y ◁ η_ X Y ⊗≫ ε_ X Y ▷ Y = ⊗𝟙

full_name: CategoryTheory.ExactPairing.evaluation_coevaluation''
code: lemma evaluation_coevaluation'' :
    η_ X Y ▷ X ⊗≫ X ◁ ε_ X Y = ⊗𝟙 
goal: η_ X Y ▷ X ⊗≫ X ◁ ε_ X Y = ⊗𝟙

full_name: CategoryTheory.exactPairingUnit
code: instance exactPairingUnit : ExactPairing (𝟙_ C) (𝟙_ C) 
goal: CategoryTheory.ExactPairing (𝟙_ C) (𝟙_ C)

full_name: CategoryTheory.HasRightDual.rightDual
code: /-- A class of objects which have a right dual. -/
class HasRightDual (X : C) where
  /-- The right dual of the object `X`. -/
  rightDual : C
  [exact : ExactPairing X rightDual]
goal: C

full_name: CategoryTheory.HasRightDual
code: /-- A class of objects which have a right dual. -/
class HasRightDual (X : C) where
  /-- The right dual of the object `X`. -/
  rightDual : C
  [exact : ExactPairing X rightDual]
goal: Type (max u₁ v₁)

full_name: CategoryTheory.HasRightDual.exact
code: /-- A class of objects which have a right dual. -/
class HasRightDual (X : C) where
  /-- The right dual of the object `X`. -/
  rightDual : C
  [exact : ExactPairing X rightDual]
goal: CategoryTheory.ExactPairing X Xᘁ

full_name: CategoryTheory.HasLeftDual.exact
code: /-- A class of objects which have a left dual. -/
class HasLeftDual (Y : C) where
  /-- The left dual of the object `X`. -/
  leftDual : C
  [exact : ExactPairing leftDual Y]
goal: CategoryTheory.ExactPairing (ᘁY) Y

full_name: CategoryTheory.HasLeftDual
code: /-- A class of objects which have a left dual. -/
class HasLeftDual (Y : C) where
  /-- The left dual of the object `X`. -/
  leftDual : C
  [exact : ExactPairing leftDual Y]
goal: Type (max u₁ v₁)

full_name: CategoryTheory.HasLeftDual.leftDual
code: /-- A class of objects which have a left dual. -/
class HasLeftDual (Y : C) where
  /-- The left dual of the object `X`. -/
  leftDual : C
  [exact : ExactPairing leftDual Y]
goal: C

full_name: CategoryTheory._aux_Mathlib_CategoryTheory_Monoidal_Rigid_Basic___unexpand_CategoryTheory_HasLeftDual_leftDual_1
code: @[inherit_doc] prefix:1024 "ᘁ" => leftDual
goal: Lean.PrettyPrinter.Unexpander

full_name: CategoryTheory.«_aux_Mathlib_CategoryTheory_Monoidal_Rigid_Basic___macroRules_CategoryTheory_termᘁ__1»
code: @[inherit_doc] prefix:1024 "ᘁ" => leftDual
goal: Lean.Macro

full_name: CategoryTheory._aux_Mathlib_CategoryTheory_Monoidal_Rigid_Basic___unexpand_CategoryTheory_HasRightDual_rightDual_1
code: @[inherit_doc] postfix:1024 "ᘁ" => rightDual
goal: Lean.PrettyPrinter.Unexpander

full_name: CategoryTheory.«_aux_Mathlib_CategoryTheory_Monoidal_Rigid_Basic___macroRules_CategoryTheory_term_ᘁ_1»
code: @[inherit_doc] postfix:1024 "ᘁ" => rightDual
goal: Lean.Macro

full_name: CategoryTheory.hasRightDualUnit
code: instance hasRightDualUnit : HasRightDual (𝟙_ C) 
goal: CategoryTheory.HasRightDual (𝟙_ C)

full_name: CategoryTheory.hasLeftDualUnit
code: instance hasLeftDualUnit : HasLeftDual (𝟙_ C) 
goal: CategoryTheory.HasLeftDual (𝟙_ C)

full_name: CategoryTheory.hasRightDualLeftDual
code: instance hasRightDualLeftDual {X : C} [HasLeftDual X] : HasRightDual ᘁX 
goal: CategoryTheory.HasRightDual ᘁX

full_name: CategoryTheory.hasLeftDualRightDual
code: instance hasLeftDualRightDual {X : C} [HasRightDual X] : HasLeftDual Xᘁ 
goal: CategoryTheory.HasLeftDual Xᘁ

full_name: CategoryTheory.leftDual_rightDual
code: @[simp]
theorem leftDual_rightDual {X : C} [HasRightDual X] : ᘁXᘁ = X 
goal: ᘁXᘁ = X

full_name: CategoryTheory.rightDual_leftDual
code: @[simp]
theorem rightDual_leftDual {X : C} [HasLeftDual X] : (ᘁX)ᘁ = X 
goal: (ᘁX)ᘁ = X

full_name: CategoryTheory.rightAdjointMate
code: /-- The right adjoint mate `fᘁ : Xᘁ ⟶ Yᘁ` of a morphism `f : X ⟶ Y`. -/
def rightAdjointMate {X Y : C} [HasRightDual X] [HasRightDual Y] (f : X ⟶ Y) : Yᘁ ⟶ Xᘁ 
goal: Yᘁ ⟶ Xᘁ

full_name: CategoryTheory.leftAdjointMate
code: /-- The left adjoint mate `ᘁf : ᘁY ⟶ ᘁX` of a morphism `f : X ⟶ Y`. -/
def leftAdjointMate {X Y : C} [HasLeftDual X] [HasLeftDual Y] (f : X ⟶ Y) : ᘁY ⟶ ᘁX 
goal: ᘁY ⟶ ᘁX

full_name: CategoryTheory.«_aux_Mathlib_CategoryTheory_Monoidal_Rigid_Basic___macroRules_CategoryTheory_term_ᘁ_1_1»
code: @[inherit_doc] notation f "ᘁ" => rightAdjointMate f
goal: Lean.Macro

full_name: CategoryTheory._aux_Mathlib_CategoryTheory_Monoidal_Rigid_Basic___unexpand_CategoryTheory_rightAdjointMate_1
code: @[inherit_doc] notation f "ᘁ" => rightAdjointMate f
goal: Lean.PrettyPrinter.Unexpander

full_name: CategoryTheory.«_aux_Mathlib_CategoryTheory_Monoidal_Rigid_Basic___macroRules_CategoryTheory_termᘁ__1_1»
code: @[inherit_doc] notation "ᘁ" f => leftAdjointMate f
goal: Lean.Macro

full_name: CategoryTheory._aux_Mathlib_CategoryTheory_Monoidal_Rigid_Basic___unexpand_CategoryTheory_leftAdjointMate_1
code: @[inherit_doc] notation "ᘁ" f => leftAdjointMate f
goal: Lean.PrettyPrinter.Unexpander

full_name: CategoryTheory.rightAdjointMate_id
code: @[simp]
theorem rightAdjointMate_id {X : C} [HasRightDual X] : (𝟙 X)ᘁ = 𝟙 (Xᘁ) 
goal: 𝟙 Xᘁ = 𝟙 Xᘁ

full_name: CategoryTheory.leftAdjointMate_id
code: @[simp]
theorem leftAdjointMate_id {X : C} [HasLeftDual X] : (ᘁ(𝟙 X)) = 𝟙 (ᘁX) 
goal: (ᘁ𝟙 X) = 𝟙 ᘁX

full_name: CategoryTheory.rightAdjointMate_comp
code: theorem rightAdjointMate_comp {X Y Z : C} [HasRightDual X] [HasRightDual Y] {f : X ⟶ Y}
    {g : Xᘁ ⟶ Z} :
    fᘁ ≫ g =
      (ρ_ (Yᘁ)).inv ≫
        _ ◁ η_ X (Xᘁ) ≫ _ ◁ (f ⊗ g) ≫ (α_ (Yᘁ) Y Z).inv ≫ ε_ Y (Yᘁ) ▷ _ ≫ (λ_ Z).hom 
goal: fᘁ ≫ g = (ρ_ Yᘁ).inv ≫ Yᘁ ◁ η_ X Xᘁ ≫ Yᘁ ◁ (f ⊗ g) ≫ (α_ Yᘁ Y Z).inv ≫ ε_ Y Yᘁ ▷ Z ≫ (λ_ Z).hom

full_name: CategoryTheory.leftAdjointMate_comp
code: theorem leftAdjointMate_comp {X Y Z : C} [HasLeftDual X] [HasLeftDual Y] {f : X ⟶ Y}
    {g : (ᘁX) ⟶ Z} :
    (ᘁf) ≫ g =
      (λ_ _).inv ≫
        η_ (ᘁX) X ▷ _ ≫ (g ⊗ f) ▷ _ ≫ (α_ _ _ _).hom ≫ _ ◁ ε_ _ _ ≫ (ρ_ _).hom 
goal: (ᘁf) ≫ g = (λ_ ᘁY).inv ≫ η_ (ᘁX) X ▷ ᘁY ≫ (g ⊗ f) ▷ ᘁY ≫ (α_ Z Y ᘁY).hom ≫ Z ◁ ε_ (ᘁY) Y ≫ (ρ_ Z).hom

full_name: CategoryTheory.comp_rightAdjointMate
code: /-- The composition of right adjoint mates is the adjoint mate of the composition. -/
@[reassoc]
theorem comp_rightAdjointMate {X Y Z : C} [HasRightDual X] [HasRightDual Y] [HasRightDual Z]
    {f : X ⟶ Y} {g : Y ⟶ Z} : (f ≫ g)ᘁ = gᘁ ≫ fᘁ 
goal: (f ≫ g)ᘁ = gᘁ ≫ fᘁ

full_name: CategoryTheory.comp_leftAdjointMate
code: /-- The composition of left adjoint mates is the adjoint mate of the composition. -/
@[reassoc]
theorem comp_leftAdjointMate {X Y Z : C} [HasLeftDual X] [HasLeftDual Y] [HasLeftDual Z] {f : X ⟶ Y}
    {g : Y ⟶ Z} : (ᘁf ≫ g) = (ᘁg) ≫ ᘁf 
goal: (ᘁf ≫ g) = (ᘁg) ≫ ᘁf

full_name: CategoryTheory.tensorLeftHomEquiv
code: /-- Given an exact pairing on `Y Y'`,
we get a bijection on hom-sets `(Y' ⊗ X ⟶ Z) ≃ (X ⟶ Y ⊗ Z)`
by "pulling the string on the left" up or down.

This gives the adjunction `tensorLeftAdjunction Y Y' : tensorLeft Y' ⊣ tensorLeft Y`.

This adjunction is often referred to as "Frobenius reciprocity" in the
fusion categories / planar algebras / subfactors literature.
-/
def tensorLeftHomEquiv (X Y Y' Z : C) [ExactPairing Y Y'] : (Y' ⊗ X ⟶ Z) ≃ (X ⟶ Y ⊗ Z) 
goal: (Y' ⊗ X ⟶ Z) ≃ (X ⟶ Y ⊗ Z)

full_name: CategoryTheory.tensorRightHomEquiv
code: /-- Given an exact pairing on `Y Y'`,
we get a bijection on hom-sets `(X ⊗ Y ⟶ Z) ≃ (X ⟶ Z ⊗ Y')`
by "pulling the string on the right" up or down.
-/
def tensorRightHomEquiv (X Y Y' Z : C) [ExactPairing Y Y'] : (X ⊗ Y ⟶ Z) ≃ (X ⟶ Z ⊗ Y') 
goal: (X ⊗ Y ⟶ Z) ≃ (X ⟶ Z ⊗ Y')

full_name: CategoryTheory.tensorLeftHomEquiv_naturality
code: theorem tensorLeftHomEquiv_naturality {X Y Y' Z Z' : C} [ExactPairing Y Y'] (f : Y' ⊗ X ⟶ Z)
    (g : Z ⟶ Z') :
    (tensorLeftHomEquiv X Y Y' Z') (f ≫ g) = (tensorLeftHomEquiv X Y Y' Z) f ≫ Y ◁ g 
goal: (CategoryTheory.tensorLeftHomEquiv X Y Y' Z') (f ≫ g) = (CategoryTheory.tensorLeftHomEquiv X Y Y' Z) f ≫ Y ◁ g

full_name: CategoryTheory.tensorLeftHomEquiv_symm_naturality
code: theorem tensorLeftHomEquiv_symm_naturality {X X' Y Y' Z : C} [ExactPairing Y Y'] (f : X ⟶ X')
    (g : X' ⟶ Y ⊗ Z) :
    (tensorLeftHomEquiv X Y Y' Z).symm (f ≫ g) =
      _ ◁ f ≫ (tensorLeftHomEquiv X' Y Y' Z).symm g 
goal: (CategoryTheory.tensorLeftHomEquiv X Y Y' Z).symm (f ≫ g) =
  Y' ◁ f ≫ (CategoryTheory.tensorLeftHomEquiv X' Y Y' Z).symm g

full_name: CategoryTheory.tensorRightHomEquiv_naturality
code: theorem tensorRightHomEquiv_naturality {X Y Y' Z Z' : C} [ExactPairing Y Y'] (f : X ⊗ Y ⟶ Z)
    (g : Z ⟶ Z') :
    (tensorRightHomEquiv X Y Y' Z') (f ≫ g) = (tensorRightHomEquiv X Y Y' Z) f ≫ g ▷ Y' 
goal: (CategoryTheory.tensorRightHomEquiv X Y Y' Z') (f ≫ g) = (CategoryTheory.tensorRightHomEquiv X Y Y' Z) f ≫ g ▷ Y'

full_name: CategoryTheory.tensorRightHomEquiv_symm_naturality
code: theorem tensorRightHomEquiv_symm_naturality {X X' Y Y' Z : C} [ExactPairing Y Y'] (f : X ⟶ X')
    (g : X' ⟶ Z ⊗ Y') :
    (tensorRightHomEquiv X Y Y' Z).symm (f ≫ g) =
      f ▷ Y ≫ (tensorRightHomEquiv X' Y Y' Z).symm g 
goal: (CategoryTheory.tensorRightHomEquiv X Y Y' Z).symm (f ≫ g) =
  f ▷ Y ≫ (CategoryTheory.tensorRightHomEquiv X' Y Y' Z).symm g

full_name: CategoryTheory.tensorLeftAdjunction
code: /-- If `Y Y'` have an exact pairing,
then the functor `tensorLeft Y'` is left adjoint to `tensorLeft Y`.
-/
def tensorLeftAdjunction (Y Y' : C) [ExactPairing Y Y'] : tensorLeft Y' ⊣ tensorLeft Y 
goal: CategoryTheory.MonoidalCategory.tensorLeft Y' ⊣ CategoryTheory.MonoidalCategory.tensorLeft Y

full_name: CategoryTheory.tensorRightAdjunction
code: /-- If `Y Y'` have an exact pairing,
then the functor `tensor_right Y` is left adjoint to `tensor_right Y'`.
-/
def tensorRightAdjunction (Y Y' : C) [ExactPairing Y Y'] : tensorRight Y ⊣ tensorRight Y' 
goal: CategoryTheory.MonoidalCategory.tensorRight Y ⊣ CategoryTheory.MonoidalCategory.tensorRight Y'

full_name: CategoryTheory.closedOfHasLeftDual
code: /--
If `Y` has a left dual `ᘁY`, then it is a closed object, with the internal hom functor `Y ⟶[C] -`
given by left tensoring by `ᘁY`.
This has to be a definition rather than an instance to avoid diamonds, for example between
`category_theory.monoidal_closed.functor_closed` and
`CategoryTheory.Monoidal.functorHasLeftDual`. Moreover, in concrete applications there is often
a more useful definition of the internal hom object than `ᘁY ⊗ X`, in which case the closed
structure shouldn't come from `has_left_dual` (e.g. in the category `FinVect k`, it is more
convenient to define the internal hom as `Y →ₗ[k] X` rather than `ᘁY ⊗ X` even though these are
naturally isomorphic).
-/
def closedOfHasLeftDual (Y : C) [HasLeftDual Y] : Closed Y 
goal: CategoryTheory.Closed Y

full_name: CategoryTheory.tensorLeftHomEquiv_tensor
code: /-- `tensorLeftHomEquiv` commutes with tensoring on the right -/
theorem tensorLeftHomEquiv_tensor {X X' Y Y' Z Z' : C} [ExactPairing Y Y'] (f : X ⟶ Y ⊗ Z)
    (g : X' ⟶ Z') :
    (tensorLeftHomEquiv (X ⊗ X') Y Y' (Z ⊗ Z')).symm ((f ⊗ g) ≫ (α_ _ _ _).hom) =
      (α_ _ _ _).inv ≫ ((tensorLeftHomEquiv X Y Y' Z).symm f ⊗ g) 
goal: (CategoryTheory.tensorLeftHomEquiv (X ⊗ X') Y Y' (Z ⊗ Z')).symm ((f ⊗ g) ≫ (α_ Y Z Z').hom) =
  (α_ Y' X X').inv ≫ ((CategoryTheory.tensorLeftHomEquiv X Y Y' Z).symm f ⊗ g)

full_name: CategoryTheory.tensorRightHomEquiv_tensor
code: /-- `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) 
goal: (CategoryTheory.tensorRightHomEquiv (X' ⊗ X) Y Y' (Z' ⊗ Z)).symm ((g ⊗ f) ≫ (α_ Z' Z Y').inv) =
  (α_ X' X Y).hom ≫ (g ⊗ (CategoryTheory.tensorRightHomEquiv X Y Y' Z).symm f)

full_name: CategoryTheory.tensorLeftHomEquiv_symm_coevaluation_comp_whiskerLeft
code: @[simp]
theorem tensorLeftHomEquiv_symm_coevaluation_comp_whiskerLeft {Y Y' Z : C} [ExactPairing Y Y']
    (f : Y' ⟶ Z) : (tensorLeftHomEquiv _ _ _ _).symm (η_ _ _ ≫ Y ◁ f) = (ρ_ _).hom ≫ f 
goal: (CategoryTheory.tensorLeftHomEquiv (𝟙_ C) Y Y' Z).symm (η_ Y Y' ≫ Y ◁ f) = (ρ_ Y').hom ≫ f

full_name: CategoryTheory.tensorLeftHomEquiv_symm_coevaluation_comp_whiskerRight
code: @[simp]
theorem tensorLeftHomEquiv_symm_coevaluation_comp_whiskerRight {X Y : C} [HasRightDual X]
    [HasRightDual Y] (f : X ⟶ Y) :
    (tensorLeftHomEquiv _ _ _ _).symm (η_ _ _ ≫ f ▷ (Xᘁ)) = (ρ_ _).hom ≫ fᘁ 
goal: (CategoryTheory.tensorLeftHomEquiv (𝟙_ C) Y Yᘁ Xᘁ).symm (η_ X Xᘁ ≫ f ▷ Xᘁ) = (ρ_ Yᘁ).hom ≫ fᘁ

full_name: CategoryTheory.tensorRightHomEquiv_symm_coevaluation_comp_whiskerLeft
code: @[simp]
theorem tensorRightHomEquiv_symm_coevaluation_comp_whiskerLeft {X Y : C} [HasLeftDual X]
    [HasLeftDual Y] (f : X ⟶ Y) :
    (tensorRightHomEquiv _ (ᘁY) _ _).symm (η_ (ᘁX) X ≫ (ᘁX) ◁ f) = (λ_ _).hom ≫ ᘁf 
goal: (CategoryTheory.tensorRightHomEquiv (𝟙_ C) (ᘁY) Y ᘁX).symm (η_ (ᘁX) X ≫ ᘁX ◁ f) = (λ_ ᘁY).hom ≫ ᘁf

full_name: CategoryTheory.tensorRightHomEquiv_symm_coevaluation_comp_whiskerRight
code: @[simp]
theorem tensorRightHomEquiv_symm_coevaluation_comp_whiskerRight {Y Y' Z : C} [ExactPairing Y Y']
    (f : Y ⟶ Z) : (tensorRightHomEquiv _ Y _ _).symm (η_ Y Y' ≫ f ▷ Y') = (λ_ _).hom ≫ f 
goal: (CategoryTheory.tensorRightHomEquiv (𝟙_ C) Y Y' Z).symm (η_ Y Y' ≫ f ▷ Y') = (λ_ Y).hom ≫ f

full_name: CategoryTheory.tensorLeftHomEquiv_whiskerLeft_comp_evaluation
code: @[simp]
theorem tensorLeftHomEquiv_whiskerLeft_comp_evaluation {Y Z : C} [HasLeftDual Z] (f : Y ⟶ ᘁZ) :
    (tensorLeftHomEquiv _ _ _ _) (Z ◁ f ≫ ε_ _ _) = f ≫ (ρ_ _).inv 
goal: (CategoryTheory.tensorLeftHomEquiv Y (ᘁZ) Z (𝟙_ C)) (Z ◁ f ≫ ε_ (ᘁZ) Z) = f ≫ (ρ_ ᘁZ).inv

full_name: CategoryTheory.tensorLeftHomEquiv_whiskerRight_comp_evaluation
code: @[simp]
theorem tensorLeftHomEquiv_whiskerRight_comp_evaluation {X Y : C} [HasLeftDual X] [HasLeftDual Y]
    (f : X ⟶ Y) : (tensorLeftHomEquiv _ _ _ _) (f ▷ _ ≫ ε_ _ _) = (ᘁf) ≫ (ρ_ _).inv 
goal: (CategoryTheory.tensorLeftHomEquiv (ᘁY) (ᘁX) X (𝟙_ C)) (f ▷ ᘁY ≫ ε_ (ᘁY) Y) = (ᘁf) ≫ (ρ_ ᘁX).inv

full_name: CategoryTheory.tensorRightHomEquiv_whiskerLeft_comp_evaluation
code: @[simp]
theorem tensorRightHomEquiv_whiskerLeft_comp_evaluation {X Y : C} [HasRightDual X] [HasRightDual Y]
    (f : X ⟶ Y) : (tensorRightHomEquiv _ _ _ _) ((Yᘁ) ◁ f ≫ ε_ _ _) = fᘁ ≫ (λ_ _).inv 
goal: (CategoryTheory.tensorRightHomEquiv Yᘁ X Xᘁ (𝟙_ C)) (Yᘁ ◁ f ≫ ε_ Y Yᘁ) = fᘁ ≫ (λ_ Xᘁ).inv

full_name: CategoryTheory.tensorRightHomEquiv_whiskerRight_comp_evaluation
code: @[simp]
theorem tensorRightHomEquiv_whiskerRight_comp_evaluation {X Y : C} [HasRightDual X] (f : Y ⟶ Xᘁ) :
    (tensorRightHomEquiv _ _ _ _) (f ▷ X ≫ ε_ X (Xᘁ)) = f ≫ (λ_ _).inv 
goal: (CategoryTheory.tensorRightHomEquiv Y X Xᘁ (𝟙_ C)) (f ▷ X ≫ ε_ X Xᘁ) = f ≫ (λ_ Xᘁ).inv

full_name: CategoryTheory.coevaluation_comp_rightAdjointMate
code: @[reassoc]
theorem coevaluation_comp_rightAdjointMate {X Y : C} [HasRightDual X] [HasRightDual Y] (f : X ⟶ Y) :
    η_ Y (Yᘁ) ≫ _ ◁ (fᘁ) = η_ _ _ ≫ f ▷ _ 
goal: η_ Y Yᘁ ≫ Y ◁ fᘁ = η_ X Xᘁ ≫ f ▷ Xᘁ

full_name: CategoryTheory.leftAdjointMate_comp_evaluation
code: @[reassoc]
theorem leftAdjointMate_comp_evaluation {X Y : C} [HasLeftDual X] [HasLeftDual Y] (f : X ⟶ Y) :
    X ◁ (ᘁf) ≫ ε_ _ _ = f ▷ _ ≫ ε_ _ _ 
goal: (X ◁ ᘁf) ≫ ε_ (ᘁX) X = f ▷ ᘁY ≫ ε_ (ᘁY) Y

full_name: CategoryTheory.coevaluation_comp_leftAdjointMate
code: @[reassoc]
theorem coevaluation_comp_leftAdjointMate {X Y : C} [HasLeftDual X] [HasLeftDual Y] (f : X ⟶ Y) :
    η_ (ᘁY) Y ≫ (ᘁf) ▷ Y = η_ (ᘁX) X ≫ (ᘁX) ◁ f 
goal: η_ (ᘁY) Y ≫ (ᘁf) ▷ Y = η_ (ᘁX) X ≫ ᘁX ◁ f

full_name: CategoryTheory.rightAdjointMate_comp_evaluation
code: @[reassoc]
theorem rightAdjointMate_comp_evaluation {X Y : C} [HasRightDual X] [HasRightDual Y] (f : X ⟶ Y) :
    (fᘁ ▷ X) ≫ ε_ X (Xᘁ) = ((Yᘁ) ◁ f) ≫ ε_ Y (Yᘁ) 
goal: fᘁ ▷ X ≫ ε_ X Xᘁ = Yᘁ ◁ f ≫ ε_ Y Yᘁ

full_name: CategoryTheory.exactPairingCongrLeft
code: /-- Transport an exact pairing across an isomorphism in the first argument. -/
def exactPairingCongrLeft {X X' Y : C} [ExactPairing X' Y] (i : X ≅ X') : ExactPairing X Y 
goal: CategoryTheory.ExactPairing X Y

full_name: CategoryTheory.exactPairingCongrRight
code: /-- Transport an exact pairing across an isomorphism in the second argument. -/
def exactPairingCongrRight {X Y Y' : C} [ExactPairing X Y'] (i : Y ≅ Y') : ExactPairing X Y 
goal: CategoryTheory.ExactPairing X Y

full_name: CategoryTheory.exactPairingCongr
code: /-- Transport an exact pairing across isomorphisms. -/
def exactPairingCongr {X X' Y Y' : C} [ExactPairing X' Y'] (i : X ≅ X') (j : Y ≅ Y') :
    ExactPairing X Y 
goal: CategoryTheory.ExactPairing X Y

full_name: CategoryTheory.rightDualIso
code: /-- Right duals are isomorphic. -/
def rightDualIso {X Y₁ Y₂ : C} (p₁ : ExactPairing X Y₁) (p₂ : ExactPairing X Y₂) : Y₁ ≅ Y₂ 
goal: Y₁ ≅ Y₂

full_name: CategoryTheory.leftDualIso
code: /-- Left duals are isomorphic. -/
def leftDualIso {X₁ X₂ Y : C} (p₁ : ExactPairing X₁ Y) (p₂ : ExactPairing X₂ Y) : X₁ ≅ X₂ 
goal: X₁ ≅ X₂

full_name: CategoryTheory.rightDualIso_id
code: @[simp]
theorem rightDualIso_id {X Y : C} (p : ExactPairing X Y) : rightDualIso p p = Iso.refl Y 
goal: CategoryTheory.rightDualIso p p = CategoryTheory.Iso.refl Y

full_name: CategoryTheory.leftDualIso_id
code: @[simp]
theorem leftDualIso_id {X Y : C} (p : ExactPairing X Y) : leftDualIso p p = Iso.refl X 
goal: CategoryTheory.leftDualIso p p = CategoryTheory.Iso.refl X

full_name: CategoryTheory.RightRigidCategory
code: /-- A right rigid monoidal category is one in which every object has a right dual. -/
class RightRigidCategory (C : Type u) [Category.{v} C] [MonoidalCategory.{v} C] where
  [rightDual : ∀ X : C, HasRightDual X]
goal: Type (max u v)

full_name: CategoryTheory.RightRigidCategory.rightDual
code: /-- A right rigid monoidal category is one in which every object has a right dual. -/
class RightRigidCategory (C : Type u) [Category.{v} C] [MonoidalCategory.{v} C] where
  [rightDual : ∀ X : C, HasRightDual X]
goal: CategoryTheory.HasRightDual X

full_name: CategoryTheory.LeftRigidCategory
code: /-- A left rigid monoidal category is one in which every object has a right dual. -/
class LeftRigidCategory (C : Type u) [Category.{v} C] [MonoidalCategory.{v} C] where
  [leftDual : ∀ X : C, HasLeftDual X]
goal: Type (max u v)

full_name: CategoryTheory.LeftRigidCategory.leftDual
code: /-- A left rigid monoidal category is one in which every object has a right dual. -/
class LeftRigidCategory (C : Type u) [Category.{v} C] [MonoidalCategory.{v} C] where
  [leftDual : ∀ X : C, HasLeftDual X]
goal: CategoryTheory.HasLeftDual X

full_name: CategoryTheory.monoidalClosedOfLeftRigidCategory
code: /-- Any left rigid category is monoidal closed, with the internal hom `X ⟶[C] Y = ᘁX ⊗ Y`.
This has to be a definition rather than an instance to avoid diamonds, for example between
`category_theory.monoidal_closed.functor_category` and
`CategoryTheory.Monoidal.leftRigidFunctorCategory`. Moreover, in concrete applications there is
often a more useful definition of the internal hom object than `ᘁY ⊗ X`, in which case the monoidal
closed structure shouldn't come the rigid structure (e.g. in the category `FinVect k`, it is more
convenient to define the internal hom as `Y →ₗ[k] X` rather than `ᘁY ⊗ X` even though these are
naturally isomorphic). -/
def monoidalClosedOfLeftRigidCategory (C : Type u) [Category.{v} C] [MonoidalCategory.{v} C]
    [LeftRigidCategory C] : MonoidalClosed C 
goal: CategoryTheory.MonoidalClosed C

full_name: CategoryTheory.RigidCategory
code: /-- A rigid monoidal category is a monoidal category which is left rigid and right rigid. -/
class RigidCategory (C : Type u) [Category.{v} C] [MonoidalCategory.{v} C] extends
    RightRigidCategory C, LeftRigidCategory C
goal: Type (max u v)