File: Mathlib/CategoryTheory/Monoidal/Opposite.lean

full_name: CategoryTheory.MonoidalOpposite
code: /-- The type of objects of the opposite (or "reverse") monoidal category.
Use the notation `Cᴹᵒᵖ`. -/
-- @[nolint has_nonempty_instance] -- Porting note(#5171): This linter does not exist yet.
structure MonoidalOpposite (C : Type u₁) where
  /-- The object of `MonoidalOpposite C` that represents `x : C`. -/ mop ::
  /-- The object of `C` represented by `x : MonoidalOpposite C`. -/ unmop : C
goal: Type u₁

full_name: CategoryTheory.MonoidalOpposite.mop
code: /-- The type of objects of the opposite (or "reverse") monoidal category.
Use the notation `Cᴹᵒᵖ`. -/
-- @[nolint has_nonempty_instance] -- Porting note(#5171): This linter does not exist yet.
structure MonoidalOpposite (C : Type u₁) where
  /-- The object of `MonoidalOpposite C` that represents `x : C`. -/ mop ::
  /-- The object of `C` represented by `x : MonoidalOpposite C`. -/ unmop : C
goal: Cᴹᵒᵖ

full_name: CategoryTheory.MonoidalOpposite.unmop
code: /-- The type of objects of the opposite (or "reverse") monoidal category.
Use the notation `Cᴹᵒᵖ`. -/
-- @[nolint has_nonempty_instance] -- Porting note(#5171): This linter does not exist yet.
structure MonoidalOpposite (C : Type u₁) where
  /-- The object of `MonoidalOpposite C` that represents `x : C`. -/ mop ::
  /-- The object of `C` represented by `x : MonoidalOpposite C`. -/ unmop : C
goal: C

full_name: CategoryTheory.MonoidalOpposite.«_aux_Mathlib_CategoryTheory_Monoidal_Opposite___macroRules_CategoryTheory_MonoidalOpposite_term_ᴹᵒᵖ_1»
code: @[inherit_doc]
notation:max C "ᴹᵒᵖ" => MonoidalOpposite C
goal: Lean.Macro

full_name: CategoryTheory.MonoidalOpposite._aux_Mathlib_CategoryTheory_Monoidal_Opposite___unexpand_CategoryTheory_MonoidalOpposite_1
code: @[inherit_doc]
notation:max C "ᴹᵒᵖ" => MonoidalOpposite C
goal: Lean.PrettyPrinter.Unexpander

full_name: CategoryTheory.MonoidalOpposite.mop_injective
code: theorem mop_injective : Function.Injective (mop : C → Cᴹᵒᵖ) 
goal: Function.Injective CategoryTheory.MonoidalOpposite.mop

full_name: CategoryTheory.MonoidalOpposite.unmop_injective
code: theorem unmop_injective : Function.Injective (unmop : Cᴹᵒᵖ → C) 
goal: Function.Injective CategoryTheory.MonoidalOpposite.unmop

full_name: CategoryTheory.MonoidalOpposite.mop_inj_iff
code: theorem mop_inj_iff (x y : C) : mop x = mop y ↔ x = y 
goal: { unmop := x } = { unmop := y } ↔ x = y

full_name: CategoryTheory.MonoidalOpposite.unmop_inj_iff
code: @[simp]
theorem unmop_inj_iff (x y : Cᴹᵒᵖ) : unmop x = unmop y ↔ x = y 
goal: x.unmop = y.unmop ↔ x = y

full_name: CategoryTheory.MonoidalOpposite.mop_unmop
code: @[simp]
theorem mop_unmop (X : Cᴹᵒᵖ) : mop (unmop X) = X 
goal: { unmop := X.unmop } = X

full_name: CategoryTheory.MonoidalOpposite.unmop_mop
code: theorem unmop_mop (X : C) : unmop (mop X) = X 
goal: { unmop := X }.unmop = X

full_name: CategoryTheory.MonoidalOpposite.monoidalOppositeCategory
code: instance monoidalOppositeCategory [Category.{v₁} C] : Category Cᴹᵒᵖ 
goal: CategoryTheory.Category.{v₁, u₁} Cᴹᵒᵖ

full_name: Quiver.Hom.mop
code: /-- The monoidal opposite of a morphism `f : X ⟶ Y` is just `f`, thought of as `mop X ⟶ mop Y`. -/
def Quiver.Hom.mop {X Y : C} (f : X ⟶ Y) : mop X ⟶ mop Y 
goal: { unmop := X } ⟶ { unmop := Y }

full_name: Quiver.Hom.unmop
code: /-- We can think of a morphism `f : mop X ⟶ mop Y` as a morphism `X ⟶ Y`. -/
def Quiver.Hom.unmop {X Y : Cᴹᵒᵖ} (f : X ⟶ Y) : unmop X ⟶ unmop Y 
goal: X.unmop ⟶ Y.unmop

full_name: Quiver.Hom.mop_inj
code: theorem mop_inj {X Y : C} :
    Function.Injective (Quiver.Hom.mop : (X ⟶ Y) → (mop' X ⟶ mop' Y)) 
goal: Function.Injective Quiver.Hom.mop

full_name: Quiver.Hom.unmop_inj
code: theorem unmop_inj {X Y : Cᴹᵒᵖ} :
    Function.Injective (Quiver.Hom.unmop : (X ⟶ Y) → (unmop' X ⟶ unmop' Y)) 
goal: Function.Injective Quiver.Hom.unmop

full_name: Quiver.Hom.unmop_mop
code: @[simp]
theorem unmop_mop {X Y : C} {f : X ⟶ Y} : f.mop.unmop = f 
goal: f.mop.unmop = f

full_name: Quiver.Hom.mop_unmop
code: @[simp]
theorem mop_unmop {X Y : Cᴹᵒᵖ} {f : X ⟶ Y} : f.unmop.mop = f 
goal: f.unmop.mop = f

full_name: CategoryTheory.mop_comp
code: @[simp]
theorem mop_comp {X Y Z : C} {f : X ⟶ Y} {g : Y ⟶ Z} :
    (f ≫ g).mop = f.mop ≫ g.mop 
goal: (f ≫ g).mop = f.mop ≫ g.mop

full_name: CategoryTheory.mop_id
code: @[simp]
theorem mop_id {X : C} : (𝟙 X).mop = 𝟙 (mop X) 
goal: (𝟙 X).mop = 𝟙 { unmop := X }

full_name: CategoryTheory.unmop_comp
code: @[simp]
theorem unmop_comp {X Y Z : Cᴹᵒᵖ} {f : X ⟶ Y} {g : Y ⟶ Z} :
    (f ≫ g).unmop = f.unmop ≫ g.unmop 
goal: (f ≫ g).unmop = f.unmop ≫ g.unmop

full_name: CategoryTheory.unmop_id
code: @[simp]
theorem unmop_id {X : Cᴹᵒᵖ} : (𝟙 X).unmop = 𝟙 (unmop X) 
goal: (𝟙 X).unmop = 𝟙 X.unmop

full_name: CategoryTheory.unmop_id_mop
code: @[simp]
theorem unmop_id_mop {X : C} : (𝟙 (mop X)).unmop = 𝟙 X 
goal: (𝟙 { unmop := X }).unmop = 𝟙 X

full_name: CategoryTheory.mop_id_unmop
code: @[simp]
theorem mop_id_unmop {X : Cᴹᵒᵖ} : (𝟙 (unmop X)).mop = 𝟙 X 
goal: (𝟙 X.unmop).mop = 𝟙 X

full_name: CategoryTheory.mopFunctor_obj
code: /-- The identity functor on `C`, viewed as a functor from `C` to its monoidal opposite. -/
@[simps obj map] -- need to specify `obj, map` or else we generate `mopFunctor_obj_unmop`
def mopFunctor : C ⥤ Cᴹᵒᵖ 
goal: (CategoryTheory.mopFunctor C).obj unmop = { unmop := unmop }

full_name: CategoryTheory.mopFunctor
code: /-- The identity functor on `C`, viewed as a functor from `C` to its monoidal opposite. -/
@[simps obj map] -- need to specify `obj, map` or else we generate `mopFunctor_obj_unmop`
def mopFunctor : C ⥤ Cᴹᵒᵖ 
goal: C ⥤ Cᴹᵒᵖ

full_name: CategoryTheory.mopFunctor_map
code: /-- The identity functor on `C`, viewed as a functor from `C` to its monoidal opposite. -/
@[simps obj map] -- need to specify `obj, map` or else we generate `mopFunctor_obj_unmop`
def mopFunctor : C ⥤ Cᴹᵒᵖ 
goal: ∀ {X Y : C} (f : X ⟶ Y), (CategoryTheory.mopFunctor C).map f = f.mop

full_name: CategoryTheory.unmopFunctor
code: /-- The identity functor on `C`, viewed as a functor from the monoidal opposite of `C` to `C`. -/
@[simps obj map] -- not necessary but the symmetry with `mopFunctor` looks nicer
def unmopFunctor : Cᴹᵒᵖ ⥤ C 
goal: Cᴹᵒᵖ ⥤ C

full_name: CategoryTheory.unmopFunctor_obj
code: /-- The identity functor on `C`, viewed as a functor from the monoidal opposite of `C` to `C`. -/
@[simps obj map] -- not necessary but the symmetry with `mopFunctor` looks nicer
def unmopFunctor : Cᴹᵒᵖ ⥤ C 
goal: (CategoryTheory.unmopFunctor C).obj self = self.unmop

full_name: CategoryTheory.unmopFunctor_map
code: /-- The identity functor on `C`, viewed as a functor from the monoidal opposite of `C` to `C`. -/
@[simps obj map] -- not necessary but the symmetry with `mopFunctor` looks nicer
def unmopFunctor : Cᴹᵒᵖ ⥤ C 
goal: ∀ {X Y : Cᴹᵒᵖ} (f : X ⟶ Y), (CategoryTheory.unmopFunctor C).map f = f.unmop

full_name: CategoryTheory.Iso.mop
code: /-- An isomorphism in `C` gives an isomorphism in `Cᴹᵒᵖ`. -/
abbrev mop {X Y : C} (f : X ≅ Y) : mop X ≅ mop Y 
goal: { unmop := X } ≅ { unmop := Y }

full_name: CategoryTheory.Iso.unmop
code: /-- An isomorphism in `Cᴹᵒᵖ` gives an isomorphism in `C`. -/
abbrev unmop {X Y : Cᴹᵒᵖ} (f : X ≅ Y) : unmop X ≅ unmop Y 
goal: X.unmop ≅ Y.unmop

full_name: CategoryTheory.IsIso.instMonoidalOppositeMop
code: instance {X Y : C} (f : X ⟶ Y) [IsIso f] : IsIso f.mop 
goal: CategoryTheory.IsIso f.mop

full_name: CategoryTheory.IsIso.instUnmopOfMonoidalOpposite
code: instance {X Y : Cᴹᵒᵖ} (f : X ⟶ Y) [IsIso f] : IsIso f.unmop 
goal: CategoryTheory.IsIso f.unmop

full_name: CategoryTheory.monoidalCategoryOp
code: instance monoidalCategoryOp : MonoidalCategory Cᵒᵖ 
goal: CategoryTheory.MonoidalCategory Cᵒᵖ

full_name: CategoryTheory.op_tensorObj
code: @[simp] lemma op_tensorObj (X Y : C) : op (X ⊗ Y) = op X ⊗ op Y 
goal: Opposite.op (CategoryTheory.MonoidalCategory.tensorObj X Y) =
  CategoryTheory.MonoidalCategory.tensorObj (Opposite.op X) (Opposite.op Y)

full_name: CategoryTheory.unop_tensorObj
code: @[simp] lemma unop_tensorObj (X Y : Cᵒᵖ) : unop (X ⊗ Y) = unop X ⊗ unop Y 
goal: Opposite.unop (CategoryTheory.MonoidalCategory.tensorObj X Y) =
  CategoryTheory.MonoidalCategory.tensorObj (Opposite.unop X) (Opposite.unop Y)

full_name: CategoryTheory.op_tensorUnit
code: @[simp] lemma op_tensorUnit : op (𝟙_ C) = 𝟙_ Cᵒᵖ 
goal: Opposite.op (𝟙_ C) = 𝟙_ Cᵒᵖ

full_name: CategoryTheory.unop_tensorUnit
code: @[simp] lemma unop_tensorUnit : unop (𝟙_ Cᵒᵖ) = 𝟙_ C 
goal: Opposite.unop (𝟙_ Cᵒᵖ) = 𝟙_ C

full_name: CategoryTheory.op_tensorHom
code: @[simp] lemma op_tensorHom {X₁ Y₁ X₂ Y₂ : C} (f : X₁ ⟶ Y₁) (g : X₂ ⟶ Y₂) :
    (f ⊗ g).op = f.op ⊗ g.op 
goal: (CategoryTheory.MonoidalCategory.tensorHom f g).op = CategoryTheory.MonoidalCategory.tensorHom f.op g.op

full_name: CategoryTheory.unop_tensorHom
code: @[simp] lemma unop_tensorHom {X₁ Y₁ X₂ Y₂ : Cᵒᵖ} (f : X₁ ⟶ Y₁) (g : X₂ ⟶ Y₂) :
    (f ⊗ g).unop = f.unop ⊗ g.unop 
goal: (CategoryTheory.MonoidalCategory.tensorHom f g).unop = CategoryTheory.MonoidalCategory.tensorHom f.unop g.unop

full_name: CategoryTheory.op_whiskerLeft
code: @[simp] lemma op_whiskerLeft (X : C) {Y Z : C} (f : Y ⟶ Z) :
    (X ◁ f).op = op X ◁ f.op 
goal: (CategoryTheory.MonoidalCategory.whiskerLeft X f).op = CategoryTheory.MonoidalCategory.whiskerLeft (Opposite.op X) f.op

full_name: CategoryTheory.unop_whiskerLeft
code: @[simp] lemma unop_whiskerLeft (X : Cᵒᵖ) {Y Z : Cᵒᵖ} (f : Y ⟶ Z) :
    (X ◁ f).unop =  unop X ◁ f.unop 
goal: (CategoryTheory.MonoidalCategory.whiskerLeft X f).unop =
  CategoryTheory.MonoidalCategory.whiskerLeft (Opposite.unop X) f.unop

full_name: CategoryTheory.op_whiskerRight
code: @[simp] lemma op_whiskerRight {X Y : C} (f : X ⟶ Y) (Z : C) :
    (f ▷ Z).op = f.op ▷ op Z 
goal: (CategoryTheory.MonoidalCategory.whiskerRight f Z).op =
  CategoryTheory.MonoidalCategory.whiskerRight f.op (Opposite.op Z)

full_name: CategoryTheory.unop_whiskerRight
code: @[simp] lemma unop_whiskerRight {X Y : Cᵒᵖ} (f : X ⟶ Y) (Z : Cᵒᵖ) :
    (f ▷ Z).unop = f.unop ▷ unop Z 
goal: (CategoryTheory.MonoidalCategory.whiskerRight f Z).unop =
  CategoryTheory.MonoidalCategory.whiskerRight f.unop (Opposite.unop Z)

full_name: CategoryTheory.op_associator
code: @[simp] lemma op_associator (X Y Z : C) :
    (α_ X Y Z).op = (α_ (op X) (op Y) (op Z)).symm 
goal: (CategoryTheory.MonoidalCategory.associator X Y Z).op =
  (CategoryTheory.MonoidalCategory.associator (Opposite.op X) (Opposite.op Y) (Opposite.op Z)).symm

full_name: CategoryTheory.unop_associator
code: @[simp] lemma unop_associator (X Y Z : Cᵒᵖ) :
    (α_ X Y Z).unop = (α_ (unop X) (unop Y) (unop Z)).symm 
goal: (CategoryTheory.MonoidalCategory.associator X Y Z).unop =
  (CategoryTheory.MonoidalCategory.associator (Opposite.unop X) (Opposite.unop Y) (Opposite.unop Z)).symm

full_name: CategoryTheory.op_hom_associator
code: @[simp] lemma op_hom_associator (X Y Z : C) :
    (α_ X Y Z).hom.op = (α_ (op X) (op Y) (op Z)).inv 
goal: (CategoryTheory.MonoidalCategory.associator X Y Z).hom.op =
  (CategoryTheory.MonoidalCategory.associator (Opposite.op X) (Opposite.op Y) (Opposite.op Z)).inv

full_name: CategoryTheory.unop_hom_associator
code: @[simp] lemma unop_hom_associator (X Y Z : Cᵒᵖ) :
    (α_ X Y Z).hom.unop = (α_ (unop X) (unop Y) (unop Z)).inv 
goal: (CategoryTheory.MonoidalCategory.associator X Y Z).hom.unop =
  (CategoryTheory.MonoidalCategory.associator (Opposite.unop X) (Opposite.unop Y) (Opposite.unop Z)).inv

full_name: CategoryTheory.op_inv_associator
code: @[simp] lemma op_inv_associator (X Y Z : C) :
    (α_ X Y Z).inv.op = (α_ (op X) (op Y) (op Z)).hom 
goal: (CategoryTheory.MonoidalCategory.associator X Y Z).inv.op =
  (CategoryTheory.MonoidalCategory.associator (Opposite.op X) (Opposite.op Y) (Opposite.op Z)).hom

full_name: CategoryTheory.unop_inv_associator
code: @[simp] lemma unop_inv_associator (X Y Z : Cᵒᵖ) :
    (α_ X Y Z).inv.unop = (α_ (unop X) (unop Y) (unop Z)).hom 
goal: (CategoryTheory.MonoidalCategory.associator X Y Z).inv.unop =
  (CategoryTheory.MonoidalCategory.associator (Opposite.unop X) (Opposite.unop Y) (Opposite.unop Z)).hom

full_name: CategoryTheory.op_leftUnitor
code: @[simp] lemma op_leftUnitor (X : C) : (λ_ X).op = (λ_ (op X)).symm 
goal: (CategoryTheory.MonoidalCategory.leftUnitor X).op = (CategoryTheory.MonoidalCategory.leftUnitor (Opposite.op X)).symm

full_name: CategoryTheory.unop_leftUnitor
code: @[simp] lemma unop_leftUnitor (X : Cᵒᵖ) : (λ_ X).unop = (λ_ (unop X)).symm 
goal: (CategoryTheory.MonoidalCategory.leftUnitor X).unop =
  (CategoryTheory.MonoidalCategory.leftUnitor (Opposite.unop X)).symm

full_name: CategoryTheory.op_hom_leftUnitor
code: @[simp] lemma op_hom_leftUnitor (X : C) : (λ_ X).hom.op = (λ_ (op X)).inv 
goal: (CategoryTheory.MonoidalCategory.leftUnitor X).hom.op = (CategoryTheory.MonoidalCategory.leftUnitor (Opposite.op X)).inv

full_name: CategoryTheory.unop_hom_leftUnitor
code: @[simp] lemma unop_hom_leftUnitor (X : Cᵒᵖ) : (λ_ X).hom.unop = (λ_ (unop X)).inv 
goal: (CategoryTheory.MonoidalCategory.leftUnitor X).hom.unop =
  (CategoryTheory.MonoidalCategory.leftUnitor (Opposite.unop X)).inv

full_name: CategoryTheory.op_inv_leftUnitor
code: @[simp] lemma op_inv_leftUnitor (X : C) : (λ_ X).inv.op = (λ_ (op X)).hom 
goal: (CategoryTheory.MonoidalCategory.leftUnitor X).inv.op = (CategoryTheory.MonoidalCategory.leftUnitor (Opposite.op X)).hom

full_name: CategoryTheory.unop_inv_leftUnitor
code: @[simp] lemma unop_inv_leftUnitor (X : Cᵒᵖ) : (λ_ X).inv.unop = (λ_ (unop X)).hom 
goal: (CategoryTheory.MonoidalCategory.leftUnitor X).inv.unop =
  (CategoryTheory.MonoidalCategory.leftUnitor (Opposite.unop X)).hom

full_name: CategoryTheory.op_rightUnitor
code: @[simp] lemma op_rightUnitor (X : C) : (ρ_ X).op = (ρ_ (op X)).symm 
goal: (CategoryTheory.MonoidalCategory.rightUnitor X).op = (CategoryTheory.MonoidalCategory.rightUnitor (Opposite.op X)).symm

full_name: CategoryTheory.unop_rightUnitor
code: @[simp] lemma unop_rightUnitor (X : Cᵒᵖ) : (ρ_ X).unop = (ρ_ (unop X)).symm 
goal: (CategoryTheory.MonoidalCategory.rightUnitor X).unop =
  (CategoryTheory.MonoidalCategory.rightUnitor (Opposite.unop X)).symm

full_name: CategoryTheory.op_hom_rightUnitor
code: @[simp] lemma op_hom_rightUnitor (X : C) : (ρ_ X).hom.op = (ρ_ (op X)).inv 
goal: (CategoryTheory.MonoidalCategory.rightUnitor X).hom.op =
  (CategoryTheory.MonoidalCategory.rightUnitor (Opposite.op X)).inv

full_name: CategoryTheory.unop_hom_rightUnitor
code: @[simp] lemma unop_hom_rightUnitor (X : Cᵒᵖ) : (ρ_ X).hom.unop = (ρ_ (unop X)).inv 
goal: (CategoryTheory.MonoidalCategory.rightUnitor X).hom.unop =
  (CategoryTheory.MonoidalCategory.rightUnitor (Opposite.unop X)).inv

full_name: CategoryTheory.op_inv_rightUnitor
code: @[simp] lemma op_inv_rightUnitor (X : C) : (ρ_ X).inv.op = (ρ_ (op X)).hom 
goal: (CategoryTheory.MonoidalCategory.rightUnitor X).inv.op =
  (CategoryTheory.MonoidalCategory.rightUnitor (Opposite.op X)).hom

full_name: CategoryTheory.unop_inv_rightUnitor
code: @[simp] lemma unop_inv_rightUnitor (X : Cᵒᵖ) : (ρ_ X).inv.unop = (ρ_ (unop X)).hom 
goal: (CategoryTheory.MonoidalCategory.rightUnitor X).inv.unop =
  (CategoryTheory.MonoidalCategory.rightUnitor (Opposite.unop X)).hom

full_name: CategoryTheory.op_tensor_op
code: theorem op_tensor_op {W X Y Z : C} (f : W ⟶ X) (g : Y ⟶ Z) : f.op ⊗ g.op = (f ⊗ g).op 
goal: CategoryTheory.MonoidalCategory.tensorHom f.op g.op = (CategoryTheory.MonoidalCategory.tensorHom f g).op

full_name: CategoryTheory.unop_tensor_unop
code: theorem unop_tensor_unop {W X Y Z : Cᵒᵖ} (f : W ⟶ X) (g : Y ⟶ Z) :
    f.unop ⊗ g.unop = (f ⊗ g).unop 
goal: CategoryTheory.MonoidalCategory.tensorHom f.unop g.unop = (CategoryTheory.MonoidalCategory.tensorHom f g).unop

full_name: CategoryTheory.monoidalCategoryMop
code: instance monoidalCategoryMop : MonoidalCategory Cᴹᵒᵖ 
goal: CategoryTheory.MonoidalCategory Cᴹᵒᵖ

full_name: CategoryTheory.mop_tensorObj
code: @[simp] lemma mop_tensorObj (X Y : C) : mop (X ⊗ Y) = mop Y ⊗ mop X 
goal: { unmop := CategoryTheory.MonoidalCategory.tensorObj X Y } =
  CategoryTheory.MonoidalCategory.tensorObj { unmop := Y } { unmop := X }

full_name: CategoryTheory.unmop_tensorObj
code: @[simp] lemma unmop_tensorObj (X Y : Cᴹᵒᵖ) : unmop (X ⊗ Y) = unmop Y ⊗ unmop X 
goal: (CategoryTheory.MonoidalCategory.tensorObj X Y).unmop = CategoryTheory.MonoidalCategory.tensorObj Y.unmop X.unmop

full_name: CategoryTheory.mop_tensorUnit
code: @[simp] lemma mop_tensorUnit : mop (𝟙_ C) = 𝟙_ Cᴹᵒᵖ 
goal: { unmop := 𝟙_ C } = 𝟙_ Cᴹᵒᵖ

full_name: CategoryTheory.unmop_tensorUnit
code: @[simp] lemma unmop_tensorUnit : unmop (𝟙_ Cᴹᵒᵖ) = 𝟙_ C 
goal: (𝟙_ Cᴹᵒᵖ).unmop = 𝟙_ C

full_name: CategoryTheory.mop_tensorHom
code: @[simp] lemma mop_tensorHom {X₁ Y₁ X₂ Y₂ : C} (f : X₁ ⟶ Y₁) (g : X₂ ⟶ Y₂) :
    (f ⊗ g).mop = g.mop ⊗ f.mop 
goal: (CategoryTheory.MonoidalCategory.tensorHom f g).mop = CategoryTheory.MonoidalCategory.tensorHom g.mop f.mop

full_name: CategoryTheory.unmop_tensorHom
code: @[simp] lemma unmop_tensorHom {X₁ Y₁ X₂ Y₂ : Cᴹᵒᵖ} (f : X₁ ⟶ Y₁) (g : X₂ ⟶ Y₂) :
    (f ⊗ g).unmop = g.unmop ⊗ f.unmop 
goal: (CategoryTheory.MonoidalCategory.tensorHom f g).unmop = CategoryTheory.MonoidalCategory.tensorHom g.unmop f.unmop

full_name: CategoryTheory.mop_whiskerLeft
code: @[simp] lemma mop_whiskerLeft (X : C) {Y Z : C} (f : Y ⟶ Z) :
    (X ◁ f).mop = f.mop ▷ mop X 
goal: (CategoryTheory.MonoidalCategory.whiskerLeft X f).mop =
  CategoryTheory.MonoidalCategory.whiskerRight f.mop { unmop := X }

full_name: CategoryTheory.unmop_whiskerLeft
code: @[simp] lemma unmop_whiskerLeft (X : Cᴹᵒᵖ) {Y Z : Cᴹᵒᵖ} (f : Y ⟶ Z) :
    (X ◁ f).unmop = f.unmop ▷ unmop X 
goal: (CategoryTheory.MonoidalCategory.whiskerLeft X f).unmop = CategoryTheory.MonoidalCategory.whiskerRight f.unmop X.unmop

full_name: CategoryTheory.mop_whiskerRight
code: @[simp] lemma mop_whiskerRight {X Y : C} (f : X ⟶ Y) (Z : C) :
    (f ▷ Z).mop = mop Z ◁ f.mop 
goal: (CategoryTheory.MonoidalCategory.whiskerRight f Z).mop =
  CategoryTheory.MonoidalCategory.whiskerLeft { unmop := Z } f.mop

full_name: CategoryTheory.unmop_whiskerRight
code: @[simp] lemma unmop_whiskerRight {X Y : Cᴹᵒᵖ} (f : X ⟶ Y) (Z : Cᴹᵒᵖ) :
    (f ▷ Z).unmop = unmop Z ◁ f.unmop 
goal: (CategoryTheory.MonoidalCategory.whiskerRight f Z).unmop = CategoryTheory.MonoidalCategory.whiskerLeft Z.unmop f.unmop

full_name: CategoryTheory.mop_associator
code: @[simp] lemma mop_associator (X Y Z : C) :
    (α_ X Y Z).mop = (α_ (mop Z) (mop Y) (mop X)).symm 
goal: (CategoryTheory.MonoidalCategory.associator X Y Z).mop =
  (CategoryTheory.MonoidalCategory.associator { unmop := Z } { unmop := Y } { unmop := X }).symm

full_name: CategoryTheory.unmop_associator
code: @[simp] lemma unmop_associator (X Y Z : Cᴹᵒᵖ) :
    (α_ X Y Z).unmop = (α_ (unmop Z) (unmop Y) (unmop X)).symm 
goal: (CategoryTheory.MonoidalCategory.associator X Y Z).unmop =
  (CategoryTheory.MonoidalCategory.associator Z.unmop Y.unmop X.unmop).symm

full_name: CategoryTheory.mop_hom_associator
code: @[simp] lemma mop_hom_associator (X Y Z : C) :
    (α_ X Y Z).hom.mop = (α_ (mop Z) (mop Y) (mop X)).inv 
goal: (CategoryTheory.MonoidalCategory.associator X Y Z).hom.mop =
  (CategoryTheory.MonoidalCategory.associator { unmop := Z } { unmop := Y } { unmop := X }).inv

full_name: CategoryTheory.unmop_hom_associator
code: @[simp] lemma unmop_hom_associator (X Y Z : Cᴹᵒᵖ) :
    (α_ X Y Z).hom.unmop = (α_ (unmop Z) (unmop Y) (unmop X)).inv 
goal: (CategoryTheory.MonoidalCategory.associator X Y Z).hom.unmop =
  (CategoryTheory.MonoidalCategory.associator Z.unmop Y.unmop X.unmop).inv

full_name: CategoryTheory.mop_inv_associator
code: @[simp] lemma mop_inv_associator (X Y Z : C) :
    (α_ X Y Z).inv.mop = (α_ (mop Z) (mop Y) (mop X)).hom 
goal: (CategoryTheory.MonoidalCategory.associator X Y Z).inv.mop =
  (CategoryTheory.MonoidalCategory.associator { unmop := Z } { unmop := Y } { unmop := X }).hom

full_name: CategoryTheory.unmop_inv_associator
code: @[simp] lemma unmop_inv_associator (X Y Z : Cᴹᵒᵖ) :
    (α_ X Y Z).inv.unmop = (α_ (unmop Z) (unmop Y) (unmop X)).hom 
goal: (CategoryTheory.MonoidalCategory.associator X Y Z).inv.unmop =
  (CategoryTheory.MonoidalCategory.associator Z.unmop Y.unmop X.unmop).hom

full_name: CategoryTheory.mop_leftUnitor
code: @[simp] lemma mop_leftUnitor (X : C) : (λ_ X).mop = (ρ_ (mop X)) 
goal: (CategoryTheory.MonoidalCategory.leftUnitor X).mop = CategoryTheory.MonoidalCategory.rightUnitor { unmop := X }

full_name: CategoryTheory.unmop_leftUnitor
code: @[simp] lemma unmop_leftUnitor (X : Cᴹᵒᵖ) : (λ_ X).unmop = ρ_ (unmop X) 
goal: (CategoryTheory.MonoidalCategory.leftUnitor X).unmop = CategoryTheory.MonoidalCategory.rightUnitor X.unmop

full_name: CategoryTheory.mop_hom_leftUnitor
code: @[simp] lemma mop_hom_leftUnitor (X : C) : (λ_ X).hom.mop = (ρ_ (mop X)).hom 
goal: (CategoryTheory.MonoidalCategory.leftUnitor X).hom.mop =
  (CategoryTheory.MonoidalCategory.rightUnitor { unmop := X }).hom

full_name: CategoryTheory.unmop_hom_leftUnitor
code: @[simp] lemma unmop_hom_leftUnitor (X : Cᴹᵒᵖ) : (λ_ X).hom.unmop = (ρ_ (unmop X)).hom 
goal: (CategoryTheory.MonoidalCategory.leftUnitor X).hom.unmop = (CategoryTheory.MonoidalCategory.rightUnitor X.unmop).hom

full_name: CategoryTheory.mop_inv_leftUnitor
code: @[simp] lemma mop_inv_leftUnitor (X : C) : (λ_ X).inv.mop = (ρ_ (mop X)).inv 
goal: (CategoryTheory.MonoidalCategory.leftUnitor X).inv.mop =
  (CategoryTheory.MonoidalCategory.rightUnitor { unmop := X }).inv

full_name: CategoryTheory.unmop_inv_leftUnitor
code: @[simp] lemma unmop_inv_leftUnitor (X : Cᴹᵒᵖ) : (λ_ X).inv.unmop = (ρ_ (unmop X)).inv 
goal: (CategoryTheory.MonoidalCategory.leftUnitor X).inv.unmop = (CategoryTheory.MonoidalCategory.rightUnitor X.unmop).inv

full_name: CategoryTheory.mop_rightUnitor
code: @[simp] lemma mop_rightUnitor (X : C) : (ρ_ X).mop = (λ_ (mop X)) 
goal: (CategoryTheory.MonoidalCategory.rightUnitor X).mop = CategoryTheory.MonoidalCategory.leftUnitor { unmop := X }

full_name: CategoryTheory.unmop_rightUnitor
code: @[simp] lemma unmop_rightUnitor (X : Cᴹᵒᵖ) : (ρ_ X).unmop = λ_ (unmop X) 
goal: (CategoryTheory.MonoidalCategory.rightUnitor X).unmop = CategoryTheory.MonoidalCategory.leftUnitor X.unmop

full_name: CategoryTheory.mop_hom_rightUnitor
code: @[simp] lemma mop_hom_rightUnitor (X : C) : (ρ_ X).hom.mop = (λ_ (mop X)).hom 
goal: (CategoryTheory.MonoidalCategory.rightUnitor X).hom.mop =
  (CategoryTheory.MonoidalCategory.leftUnitor { unmop := X }).hom

full_name: CategoryTheory.unmop_hom_rightUnitor
code: @[simp] lemma unmop_hom_rightUnitor (X : Cᴹᵒᵖ) : (ρ_ X).hom.unmop = (λ_ (unmop X)).hom 
goal: (CategoryTheory.MonoidalCategory.rightUnitor X).hom.unmop = (CategoryTheory.MonoidalCategory.leftUnitor X.unmop).hom

full_name: CategoryTheory.mop_inv_rightUnitor
code: @[simp] lemma mop_inv_rightUnitor (X : C) : (ρ_ X).inv.mop = (λ_ (mop X)).inv 
goal: (CategoryTheory.MonoidalCategory.rightUnitor X).inv.mop =
  (CategoryTheory.MonoidalCategory.leftUnitor { unmop := X }).inv

full_name: CategoryTheory.unmop_inv_rightUnitor
code: @[simp] lemma unmop_inv_rightUnitor (X : Cᴹᵒᵖ) : (ρ_ X).inv.unmop = (λ_ (unmop X)).inv 
goal: (CategoryTheory.MonoidalCategory.rightUnitor X).inv.unmop = (CategoryTheory.MonoidalCategory.leftUnitor X.unmop).inv

full_name: CategoryTheory.MonoidalOpposite.mopEquiv
code: /-- The (identity) equivalence between `C` and its monoidal opposite. -/
@[simps] def MonoidalOpposite.mopEquiv : C ≌ Cᴹᵒᵖ 
goal: C ≌ Cᴹᵒᵖ

full_name: CategoryTheory.MonoidalOpposite.mopEquiv_inverse
code: /-- The (identity) equivalence between `C` and its monoidal opposite. -/
@[simps] def MonoidalOpposite.mopEquiv : C ≌ Cᴹᵒᵖ 
goal: (CategoryTheory.MonoidalOpposite.mopEquiv C).inverse = CategoryTheory.unmopFunctor C

full_name: CategoryTheory.MonoidalOpposite.mopEquiv_counitIso
code: /-- The (identity) equivalence between `C` and its monoidal opposite. -/
@[simps] def MonoidalOpposite.mopEquiv : C ≌ Cᴹᵒᵖ 
goal: (CategoryTheory.MonoidalOpposite.mopEquiv C).counitIso =
  CategoryTheory.Iso.refl (CategoryTheory.unmopFunctor C ⋙ CategoryTheory.mopFunctor C)

full_name: CategoryTheory.MonoidalOpposite.mopEquiv_functor
code: /-- The (identity) equivalence between `C` and its monoidal opposite. -/
@[simps] def MonoidalOpposite.mopEquiv : C ≌ Cᴹᵒᵖ 
goal: (CategoryTheory.MonoidalOpposite.mopEquiv C).functor = CategoryTheory.mopFunctor C

full_name: CategoryTheory.MonoidalOpposite.mopEquiv_unitIso
code: /-- The (identity) equivalence between `C` and its monoidal opposite. -/
@[simps] def MonoidalOpposite.mopEquiv : C ≌ Cᴹᵒᵖ 
goal: (CategoryTheory.MonoidalOpposite.mopEquiv C).unitIso = CategoryTheory.Iso.refl (𝟭 C)

full_name: CategoryTheory.MonoidalOpposite.unmopEquiv_unitIso_inv_app_unmop
code: /-- The (identity) equivalence between `Cᴹᵒᵖ` and `C`. -/
@[simps!] def MonoidalOpposite.unmopEquiv : Cᴹᵒᵖ ≌ C 
goal: ((CategoryTheory.MonoidalOpposite.unmopEquiv C).unitIso.inv.app X).unmop = 𝟙 X.unmop

full_name: CategoryTheory.MonoidalOpposite.unmopEquiv
code: /-- The (identity) equivalence between `Cᴹᵒᵖ` and `C`. -/
@[simps!] def MonoidalOpposite.unmopEquiv : Cᴹᵒᵖ ≌ C 
goal: Cᴹᵒᵖ ≌ C

full_name: CategoryTheory.MonoidalOpposite.unmopEquiv_inverse_obj_unmop
code: /-- The (identity) equivalence between `Cᴹᵒᵖ` and `C`. -/
@[simps!] def MonoidalOpposite.unmopEquiv : Cᴹᵒᵖ ≌ C 
goal: ((CategoryTheory.MonoidalOpposite.unmopEquiv C).inverse.obj unmop).unmop = unmop

full_name: CategoryTheory.MonoidalOpposite.unmopEquiv_inverse_map_unmop
code: /-- The (identity) equivalence between `Cᴹᵒᵖ` and `C`. -/
@[simps!] def MonoidalOpposite.unmopEquiv : Cᴹᵒᵖ ≌ C 
goal: ∀ {X Y : C} (f : X ⟶ Y), ((CategoryTheory.MonoidalOpposite.unmopEquiv C).inverse.map f).unmop = f

full_name: CategoryTheory.MonoidalOpposite.unmopEquiv_functor_map
code: /-- The (identity) equivalence between `Cᴹᵒᵖ` and `C`. -/
@[simps!] def MonoidalOpposite.unmopEquiv : Cᴹᵒᵖ ≌ C 
goal: ∀ {X Y : Cᴹᵒᵖ} (f : X ⟶ Y), (CategoryTheory.MonoidalOpposite.unmopEquiv C).functor.map f = f.unmop

full_name: CategoryTheory.MonoidalOpposite.unmopEquiv_counitIso_inv_app
code: /-- The (identity) equivalence between `Cᴹᵒᵖ` and `C`. -/
@[simps!] def MonoidalOpposite.unmopEquiv : Cᴹᵒᵖ ≌ C 
goal: (CategoryTheory.MonoidalOpposite.unmopEquiv C).counitIso.inv.app X = 𝟙 X

full_name: CategoryTheory.MonoidalOpposite.unmopEquiv_unitIso_hom_app_unmop
code: /-- The (identity) equivalence between `Cᴹᵒᵖ` and `C`. -/
@[simps!] def MonoidalOpposite.unmopEquiv : Cᴹᵒᵖ ≌ C 
goal: ((CategoryTheory.MonoidalOpposite.unmopEquiv C).unitIso.hom.app X).unmop = 𝟙 X.unmop

full_name: CategoryTheory.MonoidalOpposite.unmopEquiv_functor_obj
code: /-- The (identity) equivalence between `Cᴹᵒᵖ` and `C`. -/
@[simps!] def MonoidalOpposite.unmopEquiv : Cᴹᵒᵖ ≌ C 
goal: (CategoryTheory.MonoidalOpposite.unmopEquiv C).functor.obj self = self.unmop

full_name: CategoryTheory.MonoidalOpposite.unmopEquiv_counitIso_hom_app
code: /-- The (identity) equivalence between `Cᴹᵒᵖ` and `C`. -/
@[simps!] def MonoidalOpposite.unmopEquiv : Cᴹᵒᵖ ≌ C 
goal: (CategoryTheory.MonoidalOpposite.unmopEquiv C).counitIso.hom.app X = 𝟙 X

full_name: CategoryTheory.MonoidalOpposite.mopMopEquivalence_functor_map
code: /-- The equivalence between `C` and its monoidal opposite's monoidal opposite. -/
@[simps!] def MonoidalOpposite.mopMopEquivalence : Cᴹᵒᵖᴹᵒᵖ ≌ C 
goal: ∀ {X Y : Cᴹᵒᵖᴹᵒᵖ} (f : X ⟶ Y), (CategoryTheory.MonoidalOpposite.mopMopEquivalence C).functor.map f = f.unmop.unmop

full_name: CategoryTheory.MonoidalOpposite.mopMopEquivalence
code: /-- The equivalence between `C` and its monoidal opposite's monoidal opposite. -/
@[simps!] def MonoidalOpposite.mopMopEquivalence : Cᴹᵒᵖᴹᵒᵖ ≌ C 
goal: Cᴹᵒᵖᴹᵒᵖ ≌ C

full_name: CategoryTheory.MonoidalOpposite.mopMopEquivalence_unitIso_hom_app_unmop_unmop
code: /-- The equivalence between `C` and its monoidal opposite's monoidal opposite. -/
@[simps!] def MonoidalOpposite.mopMopEquivalence : Cᴹᵒᵖᴹᵒᵖ ≌ C 
goal: ((CategoryTheory.MonoidalOpposite.mopMopEquivalence C).unitIso.hom.app X).unmop.unmop = (𝟙 X.unmop).unmop

full_name: CategoryTheory.MonoidalOpposite.mopMopEquivalence_counitIso_hom_app
code: /-- The equivalence between `C` and its monoidal opposite's monoidal opposite. -/
@[simps!] def MonoidalOpposite.mopMopEquivalence : Cᴹᵒᵖᴹᵒᵖ ≌ C 
goal: (CategoryTheory.MonoidalOpposite.mopMopEquivalence C).counitIso.hom.app X = 𝟙 X

full_name: CategoryTheory.MonoidalOpposite.mopMopEquivalence_inverse_obj_unmop_unmop
code: /-- The equivalence between `C` and its monoidal opposite's monoidal opposite. -/
@[simps!] def MonoidalOpposite.mopMopEquivalence : Cᴹᵒᵖᴹᵒᵖ ≌ C 
goal: ((CategoryTheory.MonoidalOpposite.mopMopEquivalence C).inverse.obj X).unmop.unmop = X

full_name: CategoryTheory.MonoidalOpposite.mopMopEquivalence_inverse_map_unmop_unmop
code: /-- The equivalence between `C` and its monoidal opposite's monoidal opposite. -/
@[simps!] def MonoidalOpposite.mopMopEquivalence : Cᴹᵒᵖᴹᵒᵖ ≌ C 
goal: ∀ {X Y : C} (f : X ⟶ Y), ((CategoryTheory.MonoidalOpposite.mopMopEquivalence C).inverse.map f).unmop.unmop = f

full_name: CategoryTheory.MonoidalOpposite.mopMopEquivalence_counitIso_inv_app
code: /-- The equivalence between `C` and its monoidal opposite's monoidal opposite. -/
@[simps!] def MonoidalOpposite.mopMopEquivalence : Cᴹᵒᵖᴹᵒᵖ ≌ C 
goal: (CategoryTheory.MonoidalOpposite.mopMopEquivalence C).counitIso.inv.app X = 𝟙 X

full_name: CategoryTheory.MonoidalOpposite.mopMopEquivalence_unitIso_inv_app_unmop_unmop
code: /-- The equivalence between `C` and its monoidal opposite's monoidal opposite. -/
@[simps!] def MonoidalOpposite.mopMopEquivalence : Cᴹᵒᵖᴹᵒᵖ ≌ C 
goal: ((CategoryTheory.MonoidalOpposite.mopMopEquivalence C).unitIso.inv.app X).unmop.unmop = (𝟙 X.unmop).unmop

full_name: CategoryTheory.MonoidalOpposite.mopMopEquivalence_functor_obj
code: /-- The equivalence between `C` and its monoidal opposite's monoidal opposite. -/
@[simps!] def MonoidalOpposite.mopMopEquivalence : Cᴹᵒᵖᴹᵒᵖ ≌ C 
goal: (CategoryTheory.MonoidalOpposite.mopMopEquivalence C).functor.obj X = X.unmop.unmop

full_name: CategoryTheory.MonoidalOpposite.tensorIso
code: /-- The identification `mop X ⊗ mop Y = mop (Y ⊗ X)` as a natural isomorphism. -/
@[simps!]
def MonoidalOpposite.tensorIso :
    tensor Cᴹᵒᵖ ≅ (unmopFunctor C).prod (unmopFunctor C) ⋙
      Prod.swap C C ⋙ tensor C ⋙ mopFunctor C 
goal: CategoryTheory.MonoidalCategory.tensor Cᴹᵒᵖ ≅
  (CategoryTheory.unmopFunctor C).prod (CategoryTheory.unmopFunctor C) ⋙
    CategoryTheory.Prod.swap C C ⋙ CategoryTheory.MonoidalCategory.tensor C ⋙ CategoryTheory.mopFunctor C

full_name: CategoryTheory.MonoidalOpposite.tensorIso_hom_app_unmop
code: /-- The identification `mop X ⊗ mop Y = mop (Y ⊗ X)` as a natural isomorphism. -/
@[simps!]
def MonoidalOpposite.tensorIso :
    tensor Cᴹᵒᵖ ≅ (unmopFunctor C).prod (unmopFunctor C) ⋙
      Prod.swap C C ⋙ tensor C ⋙ mopFunctor C 
goal: ((CategoryTheory.MonoidalOpposite.tensorIso C).hom.app X).unmop =
  𝟙 (CategoryTheory.MonoidalCategory.tensorObj X.2.unmop X.1.unmop)

full_name: CategoryTheory.MonoidalOpposite.tensorIso_inv_app_unmop
code: /-- The identification `mop X ⊗ mop Y = mop (Y ⊗ X)` as a natural isomorphism. -/
@[simps!]
def MonoidalOpposite.tensorIso :
    tensor Cᴹᵒᵖ ≅ (unmopFunctor C).prod (unmopFunctor C) ⋙
      Prod.swap C C ⋙ tensor C ⋙ mopFunctor C 
goal: ((CategoryTheory.MonoidalOpposite.tensorIso C).inv.app X).unmop =
  𝟙 (CategoryTheory.MonoidalCategory.tensorObj X.2.unmop X.1.unmop)

full_name: CategoryTheory.MonoidalOpposite.tensorLeftIso_hom_app_unmop
code: /-- The identification `X ⊗ - = mop (- ⊗ unmop X)` as a natural isomorphism. -/
@[simps!]
def MonoidalOpposite.tensorLeftIso (X : Cᴹᵒᵖ) :
    tensorLeft X ≅ unmopFunctor C ⋙ tensorRight (unmop X) ⋙ mopFunctor C 
goal: ∀ (X_1 : Cᴹᵒᵖ), (X.tensorLeftIso.hom.app X_1).unmop = 𝟙 (CategoryTheory.MonoidalCategory.tensorObj X_1.unmop X.unmop)

full_name: CategoryTheory.MonoidalOpposite.tensorLeftIso_inv_app_unmop
code: /-- The identification `X ⊗ - = mop (- ⊗ unmop X)` as a natural isomorphism. -/
@[simps!]
def MonoidalOpposite.tensorLeftIso (X : Cᴹᵒᵖ) :
    tensorLeft X ≅ unmopFunctor C ⋙ tensorRight (unmop X) ⋙ mopFunctor C 
goal: ∀ (X_1 : Cᴹᵒᵖ), (X.tensorLeftIso.inv.app X_1).unmop = 𝟙 (CategoryTheory.MonoidalCategory.tensorObj X_1.unmop X.unmop)

full_name: CategoryTheory.MonoidalOpposite.tensorLeftIso
code: /-- The identification `X ⊗ - = mop (- ⊗ unmop X)` as a natural isomorphism. -/
@[simps!]
def MonoidalOpposite.tensorLeftIso (X : Cᴹᵒᵖ) :
    tensorLeft X ≅ unmopFunctor C ⋙ tensorRight (unmop X) ⋙ mopFunctor C 
goal: CategoryTheory.MonoidalCategory.tensorLeft X ≅
  CategoryTheory.unmopFunctor C ⋙ CategoryTheory.MonoidalCategory.tensorRight X.unmop ⋙ CategoryTheory.mopFunctor C

full_name: CategoryTheory.MonoidalOpposite.tensorLeftMopIso
code: /-- The identification `mop X ⊗ - = mop (- ⊗ X)` as a natural isomorphism. -/
@[simps!]
def MonoidalOpposite.tensorLeftMopIso (X : C) :
    tensorLeft (mop X) ≅ unmopFunctor C ⋙ tensorRight X ⋙ mopFunctor C 
goal: CategoryTheory.MonoidalCategory.tensorLeft { unmop := X } ≅
  CategoryTheory.unmopFunctor C ⋙ CategoryTheory.MonoidalCategory.tensorRight X ⋙ CategoryTheory.mopFunctor C

full_name: CategoryTheory.MonoidalOpposite.tensorLeftMopIso_hom_app_unmop
code: /-- The identification `mop X ⊗ - = mop (- ⊗ X)` as a natural isomorphism. -/
@[simps!]
def MonoidalOpposite.tensorLeftMopIso (X : C) :
    tensorLeft (mop X) ≅ unmopFunctor C ⋙ tensorRight X ⋙ mopFunctor C 
goal: ∀ (X_1 : Cᴹᵒᵖ),
  ((CategoryTheory.MonoidalOpposite.tensorLeftMopIso X).hom.app X_1).unmop =
    𝟙 (CategoryTheory.MonoidalCategory.tensorObj X_1.unmop X)

full_name: CategoryTheory.MonoidalOpposite.tensorLeftMopIso_inv_app_unmop
code: /-- The identification `mop X ⊗ - = mop (- ⊗ X)` as a natural isomorphism. -/
@[simps!]
def MonoidalOpposite.tensorLeftMopIso (X : C) :
    tensorLeft (mop X) ≅ unmopFunctor C ⋙ tensorRight X ⋙ mopFunctor C 
goal: ∀ (X_1 : Cᴹᵒᵖ),
  ((CategoryTheory.MonoidalOpposite.tensorLeftMopIso X).inv.app X_1).unmop =
    𝟙 (CategoryTheory.MonoidalCategory.tensorObj X_1.unmop X)

full_name: CategoryTheory.MonoidalOpposite.tensorLeftUnmopIso
code: /-- The identification `unmop X ⊗ - = unmop (mop - ⊗ X)` as a natural isomorphism. -/
@[simps!]
def MonoidalOpposite.tensorLeftUnmopIso (X : Cᴹᵒᵖ) :
    tensorLeft (unmop X) ≅ mopFunctor C ⋙ tensorRight X ⋙ unmopFunctor C 
goal: CategoryTheory.MonoidalCategory.tensorLeft X.unmop ≅
  CategoryTheory.mopFunctor C ⋙ CategoryTheory.MonoidalCategory.tensorRight X ⋙ CategoryTheory.unmopFunctor C

full_name: CategoryTheory.MonoidalOpposite.tensorLeftUnmopIso_hom_app
code: /-- The identification `unmop X ⊗ - = unmop (mop - ⊗ X)` as a natural isomorphism. -/
@[simps!]
def MonoidalOpposite.tensorLeftUnmopIso (X : Cᴹᵒᵖ) :
    tensorLeft (unmop X) ≅ mopFunctor C ⋙ tensorRight X ⋙ unmopFunctor C 
goal: ∀ (X_1 : C), X.tensorLeftUnmopIso.hom.app X_1 = 𝟙 (CategoryTheory.MonoidalCategory.tensorObj X.unmop X_1)

full_name: CategoryTheory.MonoidalOpposite.tensorLeftUnmopIso_inv_app
code: /-- The identification `unmop X ⊗ - = unmop (mop - ⊗ X)` as a natural isomorphism. -/
@[simps!]
def MonoidalOpposite.tensorLeftUnmopIso (X : Cᴹᵒᵖ) :
    tensorLeft (unmop X) ≅ mopFunctor C ⋙ tensorRight X ⋙ unmopFunctor C 
goal: ∀ (X_1 : C), X.tensorLeftUnmopIso.inv.app X_1 = 𝟙 (CategoryTheory.MonoidalCategory.tensorObj X.unmop X_1)

full_name: CategoryTheory.MonoidalOpposite.tensorRightIso
code: /-- The identification `- ⊗ X = mop (unmop X ⊗ -)` as a natural isomorphism. -/
@[simps!]
def MonoidalOpposite.tensorRightIso (X : Cᴹᵒᵖ) :
    tensorRight X ≅ unmopFunctor C ⋙ tensorLeft (unmop X) ⋙ mopFunctor C 
goal: CategoryTheory.MonoidalCategory.tensorRight X ≅
  CategoryTheory.unmopFunctor C ⋙ CategoryTheory.MonoidalCategory.tensorLeft X.unmop ⋙ CategoryTheory.mopFunctor C

full_name: CategoryTheory.MonoidalOpposite.tensorRightIso_inv_app_unmop
code: /-- The identification `- ⊗ X = mop (unmop X ⊗ -)` as a natural isomorphism. -/
@[simps!]
def MonoidalOpposite.tensorRightIso (X : Cᴹᵒᵖ) :
    tensorRight X ≅ unmopFunctor C ⋙ tensorLeft (unmop X) ⋙ mopFunctor C 
goal: ∀ (X_1 : Cᴹᵒᵖ), (X.tensorRightIso.inv.app X_1).unmop = 𝟙 (CategoryTheory.MonoidalCategory.tensorObj X.unmop X_1.unmop)

full_name: CategoryTheory.MonoidalOpposite.tensorRightIso_hom_app_unmop
code: /-- The identification `- ⊗ X = mop (unmop X ⊗ -)` as a natural isomorphism. -/
@[simps!]
def MonoidalOpposite.tensorRightIso (X : Cᴹᵒᵖ) :
    tensorRight X ≅ unmopFunctor C ⋙ tensorLeft (unmop X) ⋙ mopFunctor C 
goal: ∀ (X_1 : Cᴹᵒᵖ), (X.tensorRightIso.hom.app X_1).unmop = 𝟙 (CategoryTheory.MonoidalCategory.tensorObj X.unmop X_1.unmop)

full_name: CategoryTheory.MonoidalOpposite.tensorRightMopIso
code: /-- The identification `- ⊗ mop X = mop (- ⊗ unmop X)` as a natural isomorphism. -/
@[simps!]
def MonoidalOpposite.tensorRightMopIso (X : C) :
    tensorRight (mop X) ≅ unmopFunctor C ⋙ tensorLeft X ⋙ mopFunctor C 
goal: CategoryTheory.MonoidalCategory.tensorRight { unmop := X } ≅
  CategoryTheory.unmopFunctor C ⋙ CategoryTheory.MonoidalCategory.tensorLeft X ⋙ CategoryTheory.mopFunctor C

full_name: CategoryTheory.MonoidalOpposite.tensorRightMopIso_inv_app_unmop
code: /-- The identification `- ⊗ mop X = mop (- ⊗ unmop X)` as a natural isomorphism. -/
@[simps!]
def MonoidalOpposite.tensorRightMopIso (X : C) :
    tensorRight (mop X) ≅ unmopFunctor C ⋙ tensorLeft X ⋙ mopFunctor C 
goal: ∀ (X_1 : Cᴹᵒᵖ),
  ((CategoryTheory.MonoidalOpposite.tensorRightMopIso X).inv.app X_1).unmop =
    𝟙 (CategoryTheory.MonoidalCategory.tensorObj X X_1.unmop)

full_name: CategoryTheory.MonoidalOpposite.tensorRightMopIso_hom_app_unmop
code: /-- The identification `- ⊗ mop X = mop (- ⊗ unmop X)` as a natural isomorphism. -/
@[simps!]
def MonoidalOpposite.tensorRightMopIso (X : C) :
    tensorRight (mop X) ≅ unmopFunctor C ⋙ tensorLeft X ⋙ mopFunctor C 
goal: ∀ (X_1 : Cᴹᵒᵖ),
  ((CategoryTheory.MonoidalOpposite.tensorRightMopIso X).hom.app X_1).unmop =
    𝟙 (CategoryTheory.MonoidalCategory.tensorObj X X_1.unmop)

full_name: CategoryTheory.MonoidalOpposite.tensorRightUnmopIso_inv_app
code: /-- The identification `- ⊗ unmop X = unmop (X ⊗ mop -)` as a natural isomorphism. -/
@[simps!]
def MonoidalOpposite.tensorRightUnmopIso (X : Cᴹᵒᵖ) :
    tensorRight (unmop X) ≅ mopFunctor C ⋙ tensorLeft X ⋙ unmopFunctor C 
goal: ∀ (X_1 : C), X.tensorRightUnmopIso.inv.app X_1 = 𝟙 (CategoryTheory.MonoidalCategory.tensorObj X_1 X.unmop)

full_name: CategoryTheory.MonoidalOpposite.tensorRightUnmopIso_hom_app
code: /-- The identification `- ⊗ unmop X = unmop (X ⊗ mop -)` as a natural isomorphism. -/
@[simps!]
def MonoidalOpposite.tensorRightUnmopIso (X : Cᴹᵒᵖ) :
    tensorRight (unmop X) ≅ mopFunctor C ⋙ tensorLeft X ⋙ unmopFunctor C 
goal: ∀ (X_1 : C), X.tensorRightUnmopIso.hom.app X_1 = 𝟙 (CategoryTheory.MonoidalCategory.tensorObj X_1 X.unmop)

full_name: CategoryTheory.MonoidalOpposite.tensorRightUnmopIso
code: /-- The identification `- ⊗ unmop X = unmop (X ⊗ mop -)` as a natural isomorphism. -/
@[simps!]
def MonoidalOpposite.tensorRightUnmopIso (X : Cᴹᵒᵖ) :
    tensorRight (unmop X) ≅ mopFunctor C ⋙ tensorLeft X ⋙ unmopFunctor C 
goal: CategoryTheory.MonoidalCategory.tensorRight X.unmop ≅
  CategoryTheory.mopFunctor C ⋙ CategoryTheory.MonoidalCategory.tensorLeft X ⋙ CategoryTheory.unmopFunctor C