File: Mathlib/CategoryTheory/Opposites.lean

full_name: Quiver.Hom.op_inj
code: theorem Quiver.Hom.op_inj {X Y : C} :
    Function.Injective (Quiver.Hom.op : (X ⟶ Y) → (Opposite.op Y ⟶ Opposite.op X)) 
goal: Function.Injective Quiver.Hom.op

full_name: Quiver.Hom.unop_inj
code: theorem Quiver.Hom.unop_inj {X Y : Cᵒᵖ} :
    Function.Injective (Quiver.Hom.unop : (X ⟶ Y) → (Opposite.unop Y ⟶ Opposite.unop X)) 
goal: Function.Injective Quiver.Hom.unop

full_name: Quiver.Hom.unop_op
code: @[simp]
theorem Quiver.Hom.unop_op {X Y : C} (f : X ⟶ Y) : f.op.unop = f 
goal: f.op.unop = f

full_name: Quiver.Hom.unop_op'
code: @[simp]
theorem Quiver.Hom.unop_op' {X Y : Cᵒᵖ} {x} :
    @Quiver.Hom.unop C _ X Y no_index (Opposite.op (unop := x)) = x 
goal: Quiver.Hom.unop (Opposite.op x) = x

full_name: Quiver.Hom.op_unop
code: @[simp]
theorem Quiver.Hom.op_unop {X Y : Cᵒᵖ} (f : X ⟶ Y) : f.unop.op = f 
goal: f.unop.op = f

full_name: Quiver.Hom.unop_mk
code: @[simp] theorem Quiver.Hom.unop_mk {X Y : Cᵒᵖ} (f : X ⟶ Y) : Quiver.Hom.unop {unop := f} = f 
goal: Quiver.Hom.unop (Opposite.op f) = f

full_name: CategoryTheory.Category.opposite
code: /-- The opposite category.

See <https://stacks.math.columbia.edu/tag/001M>.
-/
instance Category.opposite : Category.{v₁} Cᵒᵖ 
goal: CategoryTheory.Category.{v₁, u₁} Cᵒᵖ

full_name: CategoryTheory.op_comp
code: @[simp, reassoc]
theorem op_comp {X Y Z : C} {f : X ⟶ Y} {g : Y ⟶ Z} : (f ≫ g).op = g.op ≫ f.op 
goal: (CategoryTheory.CategoryStruct.comp f g).op = CategoryTheory.CategoryStruct.comp g.op f.op

full_name: CategoryTheory.op_id
code: @[simp]
theorem op_id {X : C} : (𝟙 X).op = 𝟙 (op X) 
goal: (CategoryTheory.CategoryStruct.id X).op = CategoryTheory.CategoryStruct.id (Opposite.op X)

full_name: CategoryTheory.unop_comp
code: @[simp, reassoc]
theorem unop_comp {X Y Z : Cᵒᵖ} {f : X ⟶ Y} {g : Y ⟶ Z} : (f ≫ g).unop = g.unop ≫ f.unop 
goal: (CategoryTheory.CategoryStruct.comp f g).unop = CategoryTheory.CategoryStruct.comp g.unop f.unop

full_name: CategoryTheory.unop_id
code: @[simp]
theorem unop_id {X : Cᵒᵖ} : (𝟙 X).unop = 𝟙 (unop X) 
goal: (CategoryTheory.CategoryStruct.id X).unop = CategoryTheory.CategoryStruct.id (Opposite.unop X)

full_name: CategoryTheory.unop_id_op
code: @[simp]
theorem unop_id_op {X : C} : (𝟙 (op X)).unop = 𝟙 X 
goal: (CategoryTheory.CategoryStruct.id (Opposite.op X)).unop = CategoryTheory.CategoryStruct.id X

full_name: CategoryTheory.op_id_unop
code: @[simp]
theorem op_id_unop {X : Cᵒᵖ} : (𝟙 (unop X)).op = 𝟙 X 
goal: (CategoryTheory.CategoryStruct.id (Opposite.unop X)).op = CategoryTheory.CategoryStruct.id X

full_name: CategoryTheory.unopUnop
code: /-- The functor from the double-opposite of a category to the underlying category. -/
@[simps]
def unopUnop : Cᵒᵖᵒᵖ ⥤ C 
goal: CategoryTheory.Functor Cᵒᵖᵒᵖ C

full_name: CategoryTheory.unopUnop_obj
code: /-- The functor from the double-opposite of a category to the underlying category. -/
@[simps]
def unopUnop : Cᵒᵖᵒᵖ ⥤ C 
goal: (CategoryTheory.unopUnop C).obj X = Opposite.unop (Opposite.unop X)

full_name: CategoryTheory.unopUnop_map
code: /-- The functor from the double-opposite of a category to the underlying category. -/
@[simps]
def unopUnop : Cᵒᵖᵒᵖ ⥤ C 
goal: ∀ {X Y : Cᵒᵖᵒᵖ} (f : X ⟶ Y), (CategoryTheory.unopUnop C).map f = f.unop.unop

full_name: CategoryTheory.opOp
code: /-- The functor from a category to its double-opposite.  -/
@[simps]
def opOp : C ⥤ Cᵒᵖᵒᵖ 
goal: CategoryTheory.Functor C Cᵒᵖᵒᵖ

full_name: CategoryTheory.opOp_map
code: /-- The functor from a category to its double-opposite.  -/
@[simps]
def opOp : C ⥤ Cᵒᵖᵒᵖ 
goal: ∀ {X Y : C} (f : X ⟶ Y), (CategoryTheory.opOp C).map f = f.op.op

full_name: CategoryTheory.opOp_obj
code: /-- The functor from a category to its double-opposite.  -/
@[simps]
def opOp : C ⥤ Cᵒᵖᵒᵖ 
goal: (CategoryTheory.opOp C).obj X = Opposite.op (Opposite.op X)

full_name: CategoryTheory.opOpEquivalence_inverse
code: /-- The double opposite category is equivalent to the original. -/
@[simps]
def opOpEquivalence : Cᵒᵖᵒᵖ ≌ C 
goal: (CategoryTheory.opOpEquivalence C).inverse = CategoryTheory.opOp C

full_name: CategoryTheory.opOpEquivalence_counitIso
code: /-- The double opposite category is equivalent to the original. -/
@[simps]
def opOpEquivalence : Cᵒᵖᵒᵖ ≌ C 
goal: (CategoryTheory.opOpEquivalence C).counitIso =
  CategoryTheory.Iso.refl ((CategoryTheory.opOp C).comp (CategoryTheory.unopUnop C))

full_name: CategoryTheory.opOpEquivalence
code: /-- The double opposite category is equivalent to the original. -/
@[simps]
def opOpEquivalence : Cᵒᵖᵒᵖ ≌ C 
goal: Cᵒᵖᵒᵖ ≌ C

full_name: CategoryTheory.opOpEquivalence_unitIso
code: /-- The double opposite category is equivalent to the original. -/
@[simps]
def opOpEquivalence : Cᵒᵖᵒᵖ ≌ C 
goal: (CategoryTheory.opOpEquivalence C).unitIso = CategoryTheory.Iso.refl (CategoryTheory.Functor.id Cᵒᵖᵒᵖ)

full_name: CategoryTheory.opOpEquivalence_functor
code: /-- The double opposite category is equivalent to the original. -/
@[simps]
def opOpEquivalence : Cᵒᵖᵒᵖ ≌ C 
goal: (CategoryTheory.opOpEquivalence C).functor = CategoryTheory.unopUnop C

full_name: CategoryTheory.isIso_op
code: /-- If `f` is an isomorphism, so is `f.op` -/
instance isIso_op {X Y : C} (f : X ⟶ Y) [IsIso f] : IsIso f.op 
goal: CategoryTheory.IsIso f.op

full_name: CategoryTheory.isIso_of_op
code: /-- If `f.op` is an isomorphism `f` must be too.
(This cannot be an instance as it would immediately loop!)
-/
theorem isIso_of_op {X Y : C} (f : X ⟶ Y) [IsIso f.op] : IsIso f 
goal: CategoryTheory.IsIso f

full_name: CategoryTheory.isIso_op_iff
code: theorem isIso_op_iff {X Y : C} (f : X ⟶ Y) : IsIso f.op ↔ IsIso f 
goal: CategoryTheory.IsIso f.op ↔ CategoryTheory.IsIso f

full_name: CategoryTheory.isIso_unop_iff
code: theorem isIso_unop_iff {X Y : Cᵒᵖ} (f : X ⟶ Y) : IsIso f.unop ↔ IsIso f 
goal: CategoryTheory.IsIso f.unop ↔ CategoryTheory.IsIso f

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

full_name: CategoryTheory.op_inv
code: @[simp]
theorem op_inv {X Y : C} (f : X ⟶ Y) [IsIso f] : (inv f).op = inv f.op 
goal: (CategoryTheory.inv f).op = CategoryTheory.inv f.op

full_name: CategoryTheory.unop_inv
code: @[simp]
theorem unop_inv {X Y : Cᵒᵖ} (f : X ⟶ Y) [IsIso f] : (inv f).unop = inv f.unop 
goal: (CategoryTheory.inv f).unop = CategoryTheory.inv f.unop

full_name: CategoryTheory.Functor.op
code: /-- The opposite of a functor, i.e. considering a functor `F : C ⥤ D` as a functor `Cᵒᵖ ⥤ Dᵒᵖ`.
In informal mathematics no distinction is made between these. -/
@[simps]
protected def op (F : C ⥤ D) : Cᵒᵖ ⥤ Dᵒᵖ 
goal: CategoryTheory.Functor Cᵒᵖ Dᵒᵖ

full_name: CategoryTheory.Functor.op_obj
code: /-- The opposite of a functor, i.e. considering a functor `F : C ⥤ D` as a functor `Cᵒᵖ ⥤ Dᵒᵖ`.
In informal mathematics no distinction is made between these. -/
@[simps]
protected def op (F : C ⥤ D) : Cᵒᵖ ⥤ Dᵒᵖ 
goal: F.op.obj X = Opposite.op (F.obj (Opposite.unop X))

full_name: CategoryTheory.Functor.op_map
code: /-- The opposite of a functor, i.e. considering a functor `F : C ⥤ D` as a functor `Cᵒᵖ ⥤ Dᵒᵖ`.
In informal mathematics no distinction is made between these. -/
@[simps]
protected def op (F : C ⥤ D) : Cᵒᵖ ⥤ Dᵒᵖ 
goal: ∀ {X Y : Cᵒᵖ} (f : X ⟶ Y), F.op.map f = (F.map f.unop).op

full_name: CategoryTheory.Functor.unop_map
code: /-- Given a functor `F : Cᵒᵖ ⥤ Dᵒᵖ` we can take the "unopposite" functor `F : C ⥤ D`.
In informal mathematics no distinction is made between these.
-/
@[simps]
protected def unop (F : Cᵒᵖ ⥤ Dᵒᵖ) : C ⥤ D 
goal: ∀ {X Y : C} (f : X ⟶ Y), F.unop.map f = (F.map f.op).unop

full_name: CategoryTheory.Functor.unop
code: /-- Given a functor `F : Cᵒᵖ ⥤ Dᵒᵖ` we can take the "unopposite" functor `F : C ⥤ D`.
In informal mathematics no distinction is made between these.
-/
@[simps]
protected def unop (F : Cᵒᵖ ⥤ Dᵒᵖ) : C ⥤ D 
goal: CategoryTheory.Functor C D

full_name: CategoryTheory.Functor.unop_obj
code: /-- Given a functor `F : Cᵒᵖ ⥤ Dᵒᵖ` we can take the "unopposite" functor `F : C ⥤ D`.
In informal mathematics no distinction is made between these.
-/
@[simps]
protected def unop (F : Cᵒᵖ ⥤ Dᵒᵖ) : C ⥤ D 
goal: F.unop.obj X = Opposite.unop (F.obj (Opposite.op X))

full_name: CategoryTheory.Functor.opUnopIso_inv_app
code: /-- The isomorphism between `F.op.unop` and `F`. -/
@[simps!]
def opUnopIso (F : C ⥤ D) : F.op.unop ≅ F 
goal: F.opUnopIso.inv.app X = CategoryTheory.CategoryStruct.id (F.obj X)

full_name: CategoryTheory.Functor.opUnopIso
code: /-- The isomorphism between `F.op.unop` and `F`. -/
@[simps!]
def opUnopIso (F : C ⥤ D) : F.op.unop ≅ F 
goal: F.op.unop ≅ F

full_name: CategoryTheory.Functor.opUnopIso_hom_app
code: /-- The isomorphism between `F.op.unop` and `F`. -/
@[simps!]
def opUnopIso (F : C ⥤ D) : F.op.unop ≅ F 
goal: F.opUnopIso.hom.app X = CategoryTheory.CategoryStruct.id (F.obj X)

full_name: CategoryTheory.Functor.unopOpIso
code: /-- The isomorphism between `F.unop.op` and `F`. -/
@[simps!]
def unopOpIso (F : Cᵒᵖ ⥤ Dᵒᵖ) : F.unop.op ≅ F 
goal: F.unop.op ≅ F

full_name: CategoryTheory.Functor.unopOpIso_hom_app
code: /-- The isomorphism between `F.unop.op` and `F`. -/
@[simps!]
def unopOpIso (F : Cᵒᵖ ⥤ Dᵒᵖ) : F.unop.op ≅ F 
goal: F.unopOpIso.hom.app X = CategoryTheory.CategoryStruct.id (F.obj X)

full_name: CategoryTheory.Functor.unopOpIso_inv_app
code: /-- The isomorphism between `F.unop.op` and `F`. -/
@[simps!]
def unopOpIso (F : Cᵒᵖ ⥤ Dᵒᵖ) : F.unop.op ≅ F 
goal: F.unopOpIso.inv.app X = CategoryTheory.CategoryStruct.id (F.obj X)

full_name: CategoryTheory.Functor.opHom_obj
code: /-- Taking the opposite of a functor is functorial.
-/
@[simps]
def opHom : (C ⥤ D)ᵒᵖ ⥤ Cᵒᵖ ⥤ Dᵒᵖ 
goal: (CategoryTheory.Functor.opHom C D).obj F = (Opposite.unop F).op

full_name: CategoryTheory.Functor.opHom_map_app
code: /-- Taking the opposite of a functor is functorial.
-/
@[simps]
def opHom : (C ⥤ D)ᵒᵖ ⥤ Cᵒᵖ ⥤ Dᵒᵖ 
goal: ∀ {X Y : (CategoryTheory.Functor C D)ᵒᵖ} (α : X ⟶ Y) (X_1 : Cᵒᵖ),
  ((CategoryTheory.Functor.opHom C D).map α).app X_1 = (α.unop.app (Opposite.unop X_1)).op

full_name: CategoryTheory.Functor.opHom
code: /-- Taking the opposite of a functor is functorial.
-/
@[simps]
def opHom : (C ⥤ D)ᵒᵖ ⥤ Cᵒᵖ ⥤ Dᵒᵖ 
goal: CategoryTheory.Functor (CategoryTheory.Functor C D)ᵒᵖ (CategoryTheory.Functor Cᵒᵖ Dᵒᵖ)

full_name: CategoryTheory.Functor.opInv_map
code: /-- Take the "unopposite" of a functor is functorial.
-/
@[simps]
def opInv : (Cᵒᵖ ⥤ Dᵒᵖ) ⥤ (C ⥤ D)ᵒᵖ 
goal: ∀ {X Y : CategoryTheory.Functor Cᵒᵖ Dᵒᵖ} (α : X ⟶ Y),
  (CategoryTheory.Functor.opInv C D).map α =
    Quiver.Hom.op { app := fun X_1 => (α.app (Opposite.op X_1)).unop, naturality := ⋯ }

full_name: CategoryTheory.Functor.opInv_obj
code: /-- Take the "unopposite" of a functor is functorial.
-/
@[simps]
def opInv : (Cᵒᵖ ⥤ Dᵒᵖ) ⥤ (C ⥤ D)ᵒᵖ 
goal: (CategoryTheory.Functor.opInv C D).obj F = Opposite.op F.unop

full_name: CategoryTheory.Functor.opInv
code: /-- Take the "unopposite" of a functor is functorial.
-/
@[simps]
def opInv : (Cᵒᵖ ⥤ Dᵒᵖ) ⥤ (C ⥤ D)ᵒᵖ 
goal: CategoryTheory.Functor (CategoryTheory.Functor Cᵒᵖ Dᵒᵖ) (CategoryTheory.Functor C D)ᵒᵖ

full_name: CategoryTheory.Functor.leftOp_obj
code: /--
Another variant of the opposite of functor, turning a functor `C ⥤ Dᵒᵖ` into a functor `Cᵒᵖ ⥤ D`.
In informal mathematics no distinction is made.
-/
@[simps]
protected def leftOp (F : C ⥤ Dᵒᵖ) : Cᵒᵖ ⥤ D 
goal: F.leftOp.obj X = Opposite.unop (F.obj (Opposite.unop X))

full_name: CategoryTheory.Functor.leftOp
code: /--
Another variant of the opposite of functor, turning a functor `C ⥤ Dᵒᵖ` into a functor `Cᵒᵖ ⥤ D`.
In informal mathematics no distinction is made.
-/
@[simps]
protected def leftOp (F : C ⥤ Dᵒᵖ) : Cᵒᵖ ⥤ D 
goal: CategoryTheory.Functor Cᵒᵖ D

full_name: CategoryTheory.Functor.leftOp_map
code: /--
Another variant of the opposite of functor, turning a functor `C ⥤ Dᵒᵖ` into a functor `Cᵒᵖ ⥤ D`.
In informal mathematics no distinction is made.
-/
@[simps]
protected def leftOp (F : C ⥤ Dᵒᵖ) : Cᵒᵖ ⥤ D 
goal: ∀ {X Y : Cᵒᵖ} (f : X ⟶ Y), F.leftOp.map f = (F.map f.unop).unop

full_name: CategoryTheory.Functor.rightOp_obj
code: /--
Another variant of the opposite of functor, turning a functor `Cᵒᵖ ⥤ D` into a functor `C ⥤ Dᵒᵖ`.
In informal mathematics no distinction is made.
-/
@[simps]
protected def rightOp (F : Cᵒᵖ ⥤ D) : C ⥤ Dᵒᵖ 
goal: F.rightOp.obj X = Opposite.op (F.obj (Opposite.op X))

full_name: CategoryTheory.Functor.rightOp_map
code: /--
Another variant of the opposite of functor, turning a functor `Cᵒᵖ ⥤ D` into a functor `C ⥤ Dᵒᵖ`.
In informal mathematics no distinction is made.
-/
@[simps]
protected def rightOp (F : Cᵒᵖ ⥤ D) : C ⥤ Dᵒᵖ 
goal: ∀ {X Y : C} (f : X ⟶ Y), F.rightOp.map f = (F.map f.op).op

full_name: CategoryTheory.Functor.rightOp
code: /--
Another variant of the opposite of functor, turning a functor `Cᵒᵖ ⥤ D` into a functor `C ⥤ Dᵒᵖ`.
In informal mathematics no distinction is made.
-/
@[simps]
protected def rightOp (F : Cᵒᵖ ⥤ D) : C ⥤ Dᵒᵖ 
goal: CategoryTheory.Functor C Dᵒᵖ

full_name: CategoryTheory.Functor.rightOp_map_unop
code: lemma rightOp_map_unop {F : Cᵒᵖ ⥤ D} {X Y} (f : X ⟶ Y) :
    (F.rightOp.map f).unop = F.map f.op 
goal: (F.rightOp.map f).unop = F.map f.op

full_name: CategoryTheory.Functor.instFullOppositeOp
code: instance {F : C ⥤ D} [Full F] : Full F.op 
goal: F.op.Full

full_name: CategoryTheory.Functor.instFaithfulOppositeOp
code: instance {F : C ⥤ D} [Faithful F] : Faithful F.op 
goal: F.op.Faithful

full_name: CategoryTheory.Functor.rightOp_faithful
code: /-- If F is faithful then the right_op of F is also faithful. -/
instance rightOp_faithful {F : Cᵒᵖ ⥤ D} [Faithful F] : Faithful F.rightOp 
goal: F.rightOp.Faithful

full_name: CategoryTheory.Functor.leftOp_faithful
code: /-- If F is faithful then the left_op of F is also faithful. -/
instance leftOp_faithful {F : C ⥤ Dᵒᵖ} [Faithful F] : Faithful F.leftOp 
goal: F.leftOp.Faithful

full_name: CategoryTheory.Functor.rightOp_full
code: instance rightOp_full {F : Cᵒᵖ ⥤ D} [Full F] : Full F.rightOp 
goal: F.rightOp.Full

full_name: CategoryTheory.Functor.leftOp_full
code: instance leftOp_full {F : C ⥤ Dᵒᵖ} [Full F] : Full F.leftOp 
goal: F.leftOp.Full

full_name: CategoryTheory.Functor.leftOpRightOpIso
code: /-- The isomorphism between `F.leftOp.rightOp` and `F`. -/
@[simps!]
def leftOpRightOpIso (F : C ⥤ Dᵒᵖ) : F.leftOp.rightOp ≅ F 
goal: F.leftOp.rightOp ≅ F

full_name: CategoryTheory.Functor.leftOpRightOpIso_hom_app
code: /-- The isomorphism between `F.leftOp.rightOp` and `F`. -/
@[simps!]
def leftOpRightOpIso (F : C ⥤ Dᵒᵖ) : F.leftOp.rightOp ≅ F 
goal: F.leftOpRightOpIso.hom.app X = CategoryTheory.CategoryStruct.id (F.obj X)

full_name: CategoryTheory.Functor.leftOpRightOpIso_inv_app
code: /-- The isomorphism between `F.leftOp.rightOp` and `F`. -/
@[simps!]
def leftOpRightOpIso (F : C ⥤ Dᵒᵖ) : F.leftOp.rightOp ≅ F 
goal: F.leftOpRightOpIso.inv.app X = CategoryTheory.CategoryStruct.id (F.obj X)

full_name: CategoryTheory.Functor.rightOpLeftOpIso_inv_app
code: /-- The isomorphism between `F.rightOp.leftOp` and `F`. -/
@[simps!]
def rightOpLeftOpIso (F : Cᵒᵖ ⥤ D) : F.rightOp.leftOp ≅ F 
goal: F.rightOpLeftOpIso.inv.app X = CategoryTheory.CategoryStruct.id (F.obj X)

full_name: CategoryTheory.Functor.rightOpLeftOpIso_hom_app
code: /-- The isomorphism between `F.rightOp.leftOp` and `F`. -/
@[simps!]
def rightOpLeftOpIso (F : Cᵒᵖ ⥤ D) : F.rightOp.leftOp ≅ F 
goal: F.rightOpLeftOpIso.hom.app X = CategoryTheory.CategoryStruct.id (F.obj X)

full_name: CategoryTheory.Functor.rightOpLeftOpIso
code: /-- The isomorphism between `F.rightOp.leftOp` and `F`. -/
@[simps!]
def rightOpLeftOpIso (F : Cᵒᵖ ⥤ D) : F.rightOp.leftOp ≅ F 
goal: F.rightOp.leftOp ≅ F

full_name: CategoryTheory.Functor.rightOp_leftOp_eq
code: /-- Whenever possible, it is advisable to use the isomorphism `rightOpLeftOpIso`
instead of this equality of functors. -/
theorem rightOp_leftOp_eq (F : Cᵒᵖ ⥤ D) : F.rightOp.leftOp = F 
goal: F.rightOp.leftOp = F

full_name: CategoryTheory.NatTrans.op
code: /-- The opposite of a natural transformation. -/
@[simps]
protected def op (α : F ⟶ G) : G.op ⟶ F.op 
goal: G.op ⟶ F.op

full_name: CategoryTheory.NatTrans.op_app
code: /-- The opposite of a natural transformation. -/
@[simps]
protected def op (α : F ⟶ G) : G.op ⟶ F.op 
goal: (CategoryTheory.NatTrans.op α).app X = (α.app (Opposite.unop X)).op

full_name: CategoryTheory.NatTrans.op_id
code: @[simp]
theorem op_id (F : C ⥤ D) : NatTrans.op (𝟙 F) = 𝟙 F.op 
goal: CategoryTheory.NatTrans.op (CategoryTheory.CategoryStruct.id F) = CategoryTheory.CategoryStruct.id F.op

full_name: CategoryTheory.NatTrans.unop_app
code: /-- The "unopposite" of a natural transformation. -/
@[simps]
protected def unop {F G : Cᵒᵖ ⥤ Dᵒᵖ} (α : F ⟶ G) : G.unop ⟶ F.unop 
goal: (CategoryTheory.NatTrans.unop α).app X = (α.app (Opposite.op X)).unop

full_name: CategoryTheory.NatTrans.unop
code: /-- The "unopposite" of a natural transformation. -/
@[simps]
protected def unop {F G : Cᵒᵖ ⥤ Dᵒᵖ} (α : F ⟶ G) : G.unop ⟶ F.unop 
goal: G.unop ⟶ F.unop

full_name: CategoryTheory.NatTrans.unop_id
code: @[simp]
theorem unop_id (F : Cᵒᵖ ⥤ Dᵒᵖ) : NatTrans.unop (𝟙 F) = 𝟙 F.unop 
goal: CategoryTheory.NatTrans.unop (CategoryTheory.CategoryStruct.id F) = CategoryTheory.CategoryStruct.id F.unop

full_name: CategoryTheory.NatTrans.removeOp_app
code: /-- Given a natural transformation `α : F.op ⟶ G.op`,
we can take the "unopposite" of each component obtaining a natural transformation `G ⟶ F`.
-/
@[simps]
protected def removeOp (α : F.op ⟶ G.op) : G ⟶ F 
goal: (CategoryTheory.NatTrans.removeOp α).app X = (α.app (Opposite.op X)).unop

full_name: CategoryTheory.NatTrans.removeOp
code: /-- Given a natural transformation `α : F.op ⟶ G.op`,
we can take the "unopposite" of each component obtaining a natural transformation `G ⟶ F`.
-/
@[simps]
protected def removeOp (α : F.op ⟶ G.op) : G ⟶ F 
goal: G ⟶ F

full_name: CategoryTheory.NatTrans.removeOp_id
code: @[simp]
theorem removeOp_id (F : C ⥤ D) : NatTrans.removeOp (𝟙 F.op) = 𝟙 F 
goal: CategoryTheory.NatTrans.removeOp (CategoryTheory.CategoryStruct.id F.op) = CategoryTheory.CategoryStruct.id F

full_name: CategoryTheory.NatTrans.removeUnop
code: /-- Given a natural transformation `α : F.unop ⟶ G.unop`, we can take the opposite of each
component obtaining a natural transformation `G ⟶ F`. -/
@[simps]
protected def removeUnop {F G : Cᵒᵖ ⥤ Dᵒᵖ} (α : F.unop ⟶ G.unop) : G ⟶ F 
goal: G ⟶ F

full_name: CategoryTheory.NatTrans.removeUnop_app
code: /-- Given a natural transformation `α : F.unop ⟶ G.unop`, we can take the opposite of each
component obtaining a natural transformation `G ⟶ F`. -/
@[simps]
protected def removeUnop {F G : Cᵒᵖ ⥤ Dᵒᵖ} (α : F.unop ⟶ G.unop) : G ⟶ F 
goal: (CategoryTheory.NatTrans.removeUnop α).app X = (α.app (Opposite.unop X)).op

full_name: CategoryTheory.NatTrans.removeUnop_id
code: @[simp]
theorem removeUnop_id (F : Cᵒᵖ ⥤ Dᵒᵖ) : NatTrans.removeUnop (𝟙 F.unop) = 𝟙 F 
goal: CategoryTheory.NatTrans.removeUnop (CategoryTheory.CategoryStruct.id F.unop) = CategoryTheory.CategoryStruct.id F

full_name: CategoryTheory.NatTrans.leftOp_app
code: /-- Given a natural transformation `α : F ⟶ G`, for `F G : C ⥤ Dᵒᵖ`,
taking `unop` of each component gives a natural transformation `G.leftOp ⟶ F.leftOp`.
-/
@[simps]
protected def leftOp (α : F ⟶ G) : G.leftOp ⟶ F.leftOp 
goal: (CategoryTheory.NatTrans.leftOp α).app X = (α.app (Opposite.unop X)).unop

full_name: CategoryTheory.NatTrans.leftOp
code: /-- Given a natural transformation `α : F ⟶ G`, for `F G : C ⥤ Dᵒᵖ`,
taking `unop` of each component gives a natural transformation `G.leftOp ⟶ F.leftOp`.
-/
@[simps]
protected def leftOp (α : F ⟶ G) : G.leftOp ⟶ F.leftOp 
goal: G.leftOp ⟶ F.leftOp

full_name: CategoryTheory.NatTrans.leftOp_id
code: @[simp]
theorem leftOp_id : NatTrans.leftOp (𝟙 F : F ⟶ F) = 𝟙 F.leftOp 
goal: CategoryTheory.NatTrans.leftOp (CategoryTheory.CategoryStruct.id F) = CategoryTheory.CategoryStruct.id F.leftOp

full_name: CategoryTheory.NatTrans.leftOp_comp
code: @[simp]
theorem leftOp_comp (α : F ⟶ G) (β : G ⟶ H) : NatTrans.leftOp (α ≫ β) =
    NatTrans.leftOp β ≫ NatTrans.leftOp α 
goal: CategoryTheory.NatTrans.leftOp (CategoryTheory.CategoryStruct.comp α β) =
  CategoryTheory.CategoryStruct.comp (CategoryTheory.NatTrans.leftOp β) (CategoryTheory.NatTrans.leftOp α)

full_name: CategoryTheory.NatTrans.removeLeftOp_app
code: /-- Given a natural transformation `α : F.leftOp ⟶ G.leftOp`, for `F G : C ⥤ Dᵒᵖ`,
taking `op` of each component gives a natural transformation `G ⟶ F`.
-/
@[simps]
protected def removeLeftOp (α : F.leftOp ⟶ G.leftOp) : G ⟶ F 
goal: (CategoryTheory.NatTrans.removeLeftOp α).app X = (α.app (Opposite.op X)).op

full_name: CategoryTheory.NatTrans.removeLeftOp
code: /-- Given a natural transformation `α : F.leftOp ⟶ G.leftOp`, for `F G : C ⥤ Dᵒᵖ`,
taking `op` of each component gives a natural transformation `G ⟶ F`.
-/
@[simps]
protected def removeLeftOp (α : F.leftOp ⟶ G.leftOp) : G ⟶ F 
goal: G ⟶ F

full_name: CategoryTheory.NatTrans.removeLeftOp_id
code: @[simp]
theorem removeLeftOp_id : NatTrans.removeLeftOp (𝟙 F.leftOp) = 𝟙 F 
goal: CategoryTheory.NatTrans.removeLeftOp (CategoryTheory.CategoryStruct.id F.leftOp) = CategoryTheory.CategoryStruct.id F

full_name: CategoryTheory.NatTrans.rightOp
code: /-- Given a natural transformation `α : F ⟶ G`, for `F G : Cᵒᵖ ⥤ D`,
taking `op` of each component gives a natural transformation `G.rightOp ⟶ F.rightOp`.
-/
@[simps]
protected def rightOp (α : F ⟶ G) : G.rightOp ⟶ F.rightOp 
goal: G.rightOp ⟶ F.rightOp

full_name: CategoryTheory.NatTrans.rightOp_app
code: /-- Given a natural transformation `α : F ⟶ G`, for `F G : Cᵒᵖ ⥤ D`,
taking `op` of each component gives a natural transformation `G.rightOp ⟶ F.rightOp`.
-/
@[simps]
protected def rightOp (α : F ⟶ G) : G.rightOp ⟶ F.rightOp 
goal: (CategoryTheory.NatTrans.rightOp α).app X = (α.app (Opposite.op X)).op

full_name: CategoryTheory.NatTrans.rightOp_id
code: @[simp]
theorem rightOp_id : NatTrans.rightOp (𝟙 F : F ⟶ F) = 𝟙 F.rightOp 
goal: CategoryTheory.NatTrans.rightOp (CategoryTheory.CategoryStruct.id F) = CategoryTheory.CategoryStruct.id F.rightOp

full_name: CategoryTheory.NatTrans.rightOp_comp
code: @[simp]
theorem rightOp_comp (α : F ⟶ G) (β : G ⟶ H) : NatTrans.rightOp (α ≫ β) =
    NatTrans.rightOp β ≫ NatTrans.rightOp α 
goal: CategoryTheory.NatTrans.rightOp (CategoryTheory.CategoryStruct.comp α β) =
  CategoryTheory.CategoryStruct.comp (CategoryTheory.NatTrans.rightOp β) (CategoryTheory.NatTrans.rightOp α)

full_name: CategoryTheory.NatTrans.removeRightOp_app
code: /-- Given a natural transformation `α : F.rightOp ⟶ G.rightOp`, for `F G : Cᵒᵖ ⥤ D`,
taking `unop` of each component gives a natural transformation `G ⟶ F`.
-/
@[simps]
protected def removeRightOp (α : F.rightOp ⟶ G.rightOp) : G ⟶ F 
goal: (CategoryTheory.NatTrans.removeRightOp α).app X = (α.app (Opposite.unop X)).unop

full_name: CategoryTheory.NatTrans.removeRightOp
code: /-- Given a natural transformation `α : F.rightOp ⟶ G.rightOp`, for `F G : Cᵒᵖ ⥤ D`,
taking `unop` of each component gives a natural transformation `G ⟶ F`.
-/
@[simps]
protected def removeRightOp (α : F.rightOp ⟶ G.rightOp) : G ⟶ F 
goal: G ⟶ F

full_name: CategoryTheory.NatTrans.removeRightOp_id
code: @[simp]
theorem removeRightOp_id : NatTrans.removeRightOp (𝟙 F.rightOp) = 𝟙 F 
goal: CategoryTheory.NatTrans.removeRightOp (CategoryTheory.CategoryStruct.id F.rightOp) = CategoryTheory.CategoryStruct.id F

full_name: CategoryTheory.Iso.op_inv
code: /-- The opposite isomorphism.
-/
@[simps]
protected def op (α : X ≅ Y) : op Y ≅ op X 
goal: α.op.inv = α.inv.op

full_name: CategoryTheory.Iso.op
code: /-- The opposite isomorphism.
-/
@[simps]
protected def op (α : X ≅ Y) : op Y ≅ op X 
goal: Opposite.op Y ≅ Opposite.op X

full_name: CategoryTheory.Iso.op_hom
code: /-- The opposite isomorphism.
-/
@[simps]
protected def op (α : X ≅ Y) : op Y ≅ op X 
goal: α.op.hom = α.hom.op

full_name: CategoryTheory.Iso.unop
code: /-- The isomorphism obtained from an isomorphism in the opposite category. -/
@[simps]
def unop {X Y : Cᵒᵖ} (f : X ≅ Y) : Y.unop ≅ X.unop 
goal: Opposite.unop Y ≅ Opposite.unop X

full_name: CategoryTheory.Iso.unop_hom
code: /-- The isomorphism obtained from an isomorphism in the opposite category. -/
@[simps]
def unop {X Y : Cᵒᵖ} (f : X ≅ Y) : Y.unop ≅ X.unop 
goal: f.unop.hom = f.hom.unop

full_name: CategoryTheory.Iso.unop_inv
code: /-- The isomorphism obtained from an isomorphism in the opposite category. -/
@[simps]
def unop {X Y : Cᵒᵖ} (f : X ≅ Y) : Y.unop ≅ X.unop 
goal: f.unop.inv = f.inv.unop

full_name: CategoryTheory.Iso.unop_op
code: @[simp]
theorem unop_op {X Y : Cᵒᵖ} (f : X ≅ Y) : f.unop.op = f 
goal: f.unop.op = f

full_name: CategoryTheory.Iso.op_unop
code: @[simp]
theorem op_unop {X Y : C} (f : X ≅ Y) : f.op.unop = f 
goal: f.op.unop = f

full_name: CategoryTheory.Iso.unop_hom_inv_id_app
code: @[reassoc (attr := simp)]
lemma unop_hom_inv_id_app : (e.hom.app X).unop ≫ (e.inv.app X).unop = 𝟙 _ 
goal: CategoryTheory.CategoryStruct.comp (e.hom.app X).unop (e.inv.app X).unop =
  CategoryTheory.CategoryStruct.id (Opposite.unop (G.obj X))

full_name: CategoryTheory.Iso.unop_inv_hom_id_app
code: @[reassoc (attr := simp)]
lemma unop_inv_hom_id_app : (e.inv.app X).unop ≫ (e.hom.app X).unop = 𝟙 _ 
goal: CategoryTheory.CategoryStruct.comp (e.inv.app X).unop (e.hom.app X).unop =
  CategoryTheory.CategoryStruct.id (Opposite.unop (F.obj X))

full_name: CategoryTheory.NatIso.op
code: /-- The natural isomorphism between opposite functors `G.op ≅ F.op` induced by a natural
isomorphism between the original functors `F ≅ G`. -/
@[simps]
protected def op (α : F ≅ G) : G.op ≅ F.op 
goal: G.op ≅ F.op

full_name: CategoryTheory.NatIso.op_inv
code: /-- The natural isomorphism between opposite functors `G.op ≅ F.op` induced by a natural
isomorphism between the original functors `F ≅ G`. -/
@[simps]
protected def op (α : F ≅ G) : G.op ≅ F.op 
goal: (CategoryTheory.NatIso.op α).inv = CategoryTheory.NatTrans.op α.inv

full_name: CategoryTheory.NatIso.op_hom
code: /-- The natural isomorphism between opposite functors `G.op ≅ F.op` induced by a natural
isomorphism between the original functors `F ≅ G`. -/
@[simps]
protected def op (α : F ≅ G) : G.op ≅ F.op 
goal: (CategoryTheory.NatIso.op α).hom = CategoryTheory.NatTrans.op α.hom

full_name: CategoryTheory.NatIso.removeOp_inv
code: /-- The natural isomorphism between functors `G ≅ F` induced by a natural isomorphism
between the opposite functors `F.op ≅ G.op`. -/
@[simps]
protected def removeOp (α : F.op ≅ G.op) : G ≅ F 
goal: (CategoryTheory.NatIso.removeOp α).inv = CategoryTheory.NatTrans.removeOp α.inv

full_name: CategoryTheory.NatIso.removeOp
code: /-- The natural isomorphism between functors `G ≅ F` induced by a natural isomorphism
between the opposite functors `F.op ≅ G.op`. -/
@[simps]
protected def removeOp (α : F.op ≅ G.op) : G ≅ F 
goal: G ≅ F

full_name: CategoryTheory.NatIso.removeOp_hom
code: /-- The natural isomorphism between functors `G ≅ F` induced by a natural isomorphism
between the opposite functors `F.op ≅ G.op`. -/
@[simps]
protected def removeOp (α : F.op ≅ G.op) : G ≅ F 
goal: (CategoryTheory.NatIso.removeOp α).hom = CategoryTheory.NatTrans.removeOp α.hom

full_name: CategoryTheory.NatIso.unop
code: /-- The natural isomorphism between functors `G.unop ≅ F.unop` induced by a natural isomorphism
between the original functors `F ≅ G`. -/
@[simps]
protected def unop {F G : Cᵒᵖ ⥤ Dᵒᵖ} (α : F ≅ G) : G.unop ≅ F.unop 
goal: G.unop ≅ F.unop

full_name: CategoryTheory.NatIso.unop_inv
code: /-- The natural isomorphism between functors `G.unop ≅ F.unop` induced by a natural isomorphism
between the original functors `F ≅ G`. -/
@[simps]
protected def unop {F G : Cᵒᵖ ⥤ Dᵒᵖ} (α : F ≅ G) : G.unop ≅ F.unop 
goal: (CategoryTheory.NatIso.unop α).inv = CategoryTheory.NatTrans.unop α.inv

full_name: CategoryTheory.NatIso.unop_hom
code: /-- The natural isomorphism between functors `G.unop ≅ F.unop` induced by a natural isomorphism
between the original functors `F ≅ G`. -/
@[simps]
protected def unop {F G : Cᵒᵖ ⥤ Dᵒᵖ} (α : F ≅ G) : G.unop ≅ F.unop 
goal: (CategoryTheory.NatIso.unop α).hom = CategoryTheory.NatTrans.unop α.hom

full_name: CategoryTheory.Equivalence.op_unitIso
code: /-- An equivalence between categories gives an equivalence between the opposite categories.
-/
@[simps]
def op (e : C ≌ D) : Cᵒᵖ ≌ Dᵒᵖ 
goal: e.op.unitIso = (CategoryTheory.NatIso.op e.unitIso).symm

full_name: CategoryTheory.Equivalence.op_functor
code: /-- An equivalence between categories gives an equivalence between the opposite categories.
-/
@[simps]
def op (e : C ≌ D) : Cᵒᵖ ≌ Dᵒᵖ 
goal: e.op.functor = e.functor.op

full_name: CategoryTheory.Equivalence.op
code: /-- An equivalence between categories gives an equivalence between the opposite categories.
-/
@[simps]
def op (e : C ≌ D) : Cᵒᵖ ≌ Dᵒᵖ 
goal: Cᵒᵖ ≌ Dᵒᵖ

full_name: CategoryTheory.Equivalence.op_inverse
code: /-- An equivalence between categories gives an equivalence between the opposite categories.
-/
@[simps]
def op (e : C ≌ D) : Cᵒᵖ ≌ Dᵒᵖ 
goal: e.op.inverse = e.inverse.op

full_name: CategoryTheory.Equivalence.op_counitIso
code: /-- An equivalence between categories gives an equivalence between the opposite categories.
-/
@[simps]
def op (e : C ≌ D) : Cᵒᵖ ≌ Dᵒᵖ 
goal: e.op.counitIso = (CategoryTheory.NatIso.op e.counitIso).symm

full_name: CategoryTheory.Equivalence.unop
code: /-- An equivalence between opposite categories gives an equivalence between the original categories.
-/
@[simps]
def unop (e : Cᵒᵖ ≌ Dᵒᵖ) : C ≌ D 
goal: C ≌ D

full_name: CategoryTheory.Equivalence.unop_functor
code: /-- An equivalence between opposite categories gives an equivalence between the original categories.
-/
@[simps]
def unop (e : Cᵒᵖ ≌ Dᵒᵖ) : C ≌ D 
goal: e.unop.functor = e.functor.unop

full_name: CategoryTheory.Equivalence.unop_unitIso
code: /-- An equivalence between opposite categories gives an equivalence between the original categories.
-/
@[simps]
def unop (e : Cᵒᵖ ≌ Dᵒᵖ) : C ≌ D 
goal: e.unop.unitIso = (CategoryTheory.NatIso.unop e.unitIso).symm

full_name: CategoryTheory.Equivalence.unop_counitIso
code: /-- An equivalence between opposite categories gives an equivalence between the original categories.
-/
@[simps]
def unop (e : Cᵒᵖ ≌ Dᵒᵖ) : C ≌ D 
goal: e.unop.counitIso = (CategoryTheory.NatIso.unop e.counitIso).symm

full_name: CategoryTheory.Equivalence.unop_inverse
code: /-- An equivalence between opposite categories gives an equivalence between the original categories.
-/
@[simps]
def unop (e : Cᵒᵖ ≌ Dᵒᵖ) : C ≌ D 
goal: e.unop.inverse = e.inverse.unop

full_name: CategoryTheory.opEquiv
code: /-- The equivalence between arrows of the form `A ⟶ B` and `B.unop ⟶ A.unop`. Useful for building
adjunctions.
Note that this (definitionally) gives variants
```
def opEquiv' (A : C) (B : Cᵒᵖ) : (Opposite.op A ⟶ B) ≃ (B.unop ⟶ A) :=
  opEquiv _ _

def opEquiv'' (A : Cᵒᵖ) (B : C) : (A ⟶ Opposite.op B) ≃ (B ⟶ A.unop) :=
  opEquiv _ _

def opEquiv''' (A B : C) : (Opposite.op A ⟶ Opposite.op B) ≃ (B ⟶ A) :=
  opEquiv _ _
```
-/
@[simps]
def opEquiv (A B : Cᵒᵖ) : (A ⟶ B) ≃ (B.unop ⟶ A.unop) 
goal: (A ⟶ B) ≃ (Opposite.unop B ⟶ Opposite.unop A)

full_name: CategoryTheory.opEquiv_apply
code: /-- The equivalence between arrows of the form `A ⟶ B` and `B.unop ⟶ A.unop`. Useful for building
adjunctions.
Note that this (definitionally) gives variants
```
def opEquiv' (A : C) (B : Cᵒᵖ) : (Opposite.op A ⟶ B) ≃ (B.unop ⟶ A) :=
  opEquiv _ _

def opEquiv'' (A : Cᵒᵖ) (B : C) : (A ⟶ Opposite.op B) ≃ (B ⟶ A.unop) :=
  opEquiv _ _

def opEquiv''' (A B : C) : (Opposite.op A ⟶ Opposite.op B) ≃ (B ⟶ A) :=
  opEquiv _ _
```
-/
@[simps]
def opEquiv (A B : Cᵒᵖ) : (A ⟶ B) ≃ (B.unop ⟶ A.unop) 
goal: (CategoryTheory.opEquiv A B) f = f.unop

full_name: CategoryTheory.opEquiv_symm_apply
code: /-- The equivalence between arrows of the form `A ⟶ B` and `B.unop ⟶ A.unop`. Useful for building
adjunctions.
Note that this (definitionally) gives variants
```
def opEquiv' (A : C) (B : Cᵒᵖ) : (Opposite.op A ⟶ B) ≃ (B.unop ⟶ A) :=
  opEquiv _ _

def opEquiv'' (A : Cᵒᵖ) (B : C) : (A ⟶ Opposite.op B) ≃ (B ⟶ A.unop) :=
  opEquiv _ _

def opEquiv''' (A B : C) : (Opposite.op A ⟶ Opposite.op B) ≃ (B ⟶ A) :=
  opEquiv _ _
```
-/
@[simps]
def opEquiv (A B : Cᵒᵖ) : (A ⟶ B) ≃ (B.unop ⟶ A.unop) 
goal: (CategoryTheory.opEquiv A B).symm g = g.op

full_name: CategoryTheory.subsingleton_of_unop
code: instance subsingleton_of_unop (A B : Cᵒᵖ) [Subsingleton (unop B ⟶ unop A)] : Subsingleton (A ⟶ B) 
goal: Subsingleton (A ⟶ B)

full_name: CategoryTheory.decidableEqOfUnop
code: instance decidableEqOfUnop (A B : Cᵒᵖ) [DecidableEq (unop B ⟶ unop A)] : DecidableEq (A ⟶ B) 
goal: DecidableEq (A ⟶ B)

full_name: CategoryTheory.isoOpEquiv_symm_apply
code: /-- The equivalence between isomorphisms of the form `A ≅ B` and `B.unop ≅ A.unop`.

Note this is definitionally the same as the other three variants:
* `(Opposite.op A ≅ B) ≃ (B.unop ≅ A)`
* `(A ≅ Opposite.op B) ≃ (B ≅ A.unop)`
* `(Opposite.op A ≅ Opposite.op B) ≃ (B ≅ A)`
-/
@[simps]
def isoOpEquiv (A B : Cᵒᵖ) : (A ≅ B) ≃ (B.unop ≅ A.unop) 
goal: (CategoryTheory.isoOpEquiv A B).symm g = g.op

full_name: CategoryTheory.isoOpEquiv_apply
code: /-- The equivalence between isomorphisms of the form `A ≅ B` and `B.unop ≅ A.unop`.

Note this is definitionally the same as the other three variants:
* `(Opposite.op A ≅ B) ≃ (B.unop ≅ A)`
* `(A ≅ Opposite.op B) ≃ (B ≅ A.unop)`
* `(Opposite.op A ≅ Opposite.op B) ≃ (B ≅ A)`
-/
@[simps]
def isoOpEquiv (A B : Cᵒᵖ) : (A ≅ B) ≃ (B.unop ≅ A.unop) 
goal: (CategoryTheory.isoOpEquiv A B) f = f.unop

full_name: CategoryTheory.isoOpEquiv
code: /-- The equivalence between isomorphisms of the form `A ≅ B` and `B.unop ≅ A.unop`.

Note this is definitionally the same as the other three variants:
* `(Opposite.op A ≅ B) ≃ (B.unop ≅ A)`
* `(A ≅ Opposite.op B) ≃ (B ≅ A.unop)`
* `(Opposite.op A ≅ Opposite.op B) ≃ (B ≅ A)`
-/
@[simps]
def isoOpEquiv (A B : Cᵒᵖ) : (A ≅ B) ≃ (B.unop ≅ A.unop) 
goal: (A ≅ B) ≃ (Opposite.unop B ≅ Opposite.unop A)

full_name: CategoryTheory.Functor.opUnopEquiv_unitIso
code: /-- The equivalence of functor categories induced by `op` and `unop`.
-/
@[simps]
def opUnopEquiv : (C ⥤ D)ᵒᵖ ≌ Cᵒᵖ ⥤ Dᵒᵖ 
goal: (CategoryTheory.Functor.opUnopEquiv C D).unitIso =
  CategoryTheory.NatIso.ofComponents (fun F => (Opposite.unop F).opUnopIso.op) ⋯

full_name: CategoryTheory.Functor.opUnopEquiv_inverse
code: /-- The equivalence of functor categories induced by `op` and `unop`.
-/
@[simps]
def opUnopEquiv : (C ⥤ D)ᵒᵖ ≌ Cᵒᵖ ⥤ Dᵒᵖ 
goal: (CategoryTheory.Functor.opUnopEquiv C D).inverse = CategoryTheory.Functor.opInv C D

full_name: CategoryTheory.Functor.opUnopEquiv_counitIso
code: /-- The equivalence of functor categories induced by `op` and `unop`.
-/
@[simps]
def opUnopEquiv : (C ⥤ D)ᵒᵖ ≌ Cᵒᵖ ⥤ Dᵒᵖ 
goal: (CategoryTheory.Functor.opUnopEquiv C D).counitIso = CategoryTheory.NatIso.ofComponents (fun F => F.unopOpIso) ⋯

full_name: CategoryTheory.Functor.opUnopEquiv_functor
code: /-- The equivalence of functor categories induced by `op` and `unop`.
-/
@[simps]
def opUnopEquiv : (C ⥤ D)ᵒᵖ ≌ Cᵒᵖ ⥤ Dᵒᵖ 
goal: (CategoryTheory.Functor.opUnopEquiv C D).functor = CategoryTheory.Functor.opHom C D

full_name: CategoryTheory.Functor.opUnopEquiv
code: /-- The equivalence of functor categories induced by `op` and `unop`.
-/
@[simps]
def opUnopEquiv : (C ⥤ D)ᵒᵖ ≌ Cᵒᵖ ⥤ Dᵒᵖ 
goal: (CategoryTheory.Functor C D)ᵒᵖ ≌ CategoryTheory.Functor Cᵒᵖ Dᵒᵖ

full_name: CategoryTheory.Functor.leftOpRightOpEquiv_inverse_map
code: /-- The equivalence of functor categories induced by `leftOp` and `rightOp`.
-/
@[simps!]
def leftOpRightOpEquiv : (Cᵒᵖ ⥤ D)ᵒᵖ ≌ C ⥤ Dᵒᵖ 
goal: ∀ {X Y : CategoryTheory.Functor C Dᵒᵖ} (η : X ⟶ Y),
  (CategoryTheory.Functor.leftOpRightOpEquiv C D).inverse.map η = (CategoryTheory.NatTrans.leftOp η).op

full_name: CategoryTheory.Functor.leftOpRightOpEquiv_unitIso_inv_app
code: /-- The equivalence of functor categories induced by `leftOp` and `rightOp`.
-/
@[simps!]
def leftOpRightOpEquiv : (Cᵒᵖ ⥤ D)ᵒᵖ ≌ C ⥤ Dᵒᵖ 
goal: (CategoryTheory.Functor.leftOpRightOpEquiv C D).unitIso.inv.app X = (Opposite.unop X).rightOpLeftOpIso.inv.op

full_name: CategoryTheory.Functor.leftOpRightOpEquiv
code: /-- The equivalence of functor categories induced by `leftOp` and `rightOp`.
-/
@[simps!]
def leftOpRightOpEquiv : (Cᵒᵖ ⥤ D)ᵒᵖ ≌ C ⥤ Dᵒᵖ 
goal: (CategoryTheory.Functor Cᵒᵖ D)ᵒᵖ ≌ CategoryTheory.Functor C Dᵒᵖ

full_name: CategoryTheory.Functor.leftOpRightOpEquiv_counitIso_hom_app_app
code: /-- The equivalence of functor categories induced by `leftOp` and `rightOp`.
-/
@[simps!]
def leftOpRightOpEquiv : (Cᵒᵖ ⥤ D)ᵒᵖ ≌ C ⥤ Dᵒᵖ 
goal: ∀ (X_1 : C),
  ((CategoryTheory.Functor.leftOpRightOpEquiv C D).counitIso.hom.app X).app X_1 =
    CategoryTheory.CategoryStruct.id (X.obj X_1)

full_name: CategoryTheory.Functor.leftOpRightOpEquiv_inverse_obj
code: /-- The equivalence of functor categories induced by `leftOp` and `rightOp`.
-/
@[simps!]
def leftOpRightOpEquiv : (Cᵒᵖ ⥤ D)ᵒᵖ ≌ C ⥤ Dᵒᵖ 
goal: (CategoryTheory.Functor.leftOpRightOpEquiv C D).inverse.obj F = Opposite.op F.leftOp

full_name: CategoryTheory.Functor.leftOpRightOpEquiv_counitIso_inv_app_app
code: /-- The equivalence of functor categories induced by `leftOp` and `rightOp`.
-/
@[simps!]
def leftOpRightOpEquiv : (Cᵒᵖ ⥤ D)ᵒᵖ ≌ C ⥤ Dᵒᵖ 
goal: ∀ (X_1 : C),
  ((CategoryTheory.Functor.leftOpRightOpEquiv C D).counitIso.inv.app X).app X_1 =
    CategoryTheory.CategoryStruct.id (X.obj X_1)

full_name: CategoryTheory.Functor.leftOpRightOpEquiv_functor_obj_obj
code: /-- The equivalence of functor categories induced by `leftOp` and `rightOp`.
-/
@[simps!]
def leftOpRightOpEquiv : (Cᵒᵖ ⥤ D)ᵒᵖ ≌ C ⥤ Dᵒᵖ 
goal: ((CategoryTheory.Functor.leftOpRightOpEquiv C D).functor.obj F).obj X =
  Opposite.op ((Opposite.unop F).obj (Opposite.op X))

full_name: CategoryTheory.Functor.leftOpRightOpEquiv_functor_obj_map
code: /-- The equivalence of functor categories induced by `leftOp` and `rightOp`.
-/
@[simps!]
def leftOpRightOpEquiv : (Cᵒᵖ ⥤ D)ᵒᵖ ≌ C ⥤ Dᵒᵖ 
goal: ∀ {X Y : C} (f : X ⟶ Y),
  ((CategoryTheory.Functor.leftOpRightOpEquiv C D).functor.obj F).map f = ((Opposite.unop F).map f.op).op

full_name: CategoryTheory.Functor.leftOpRightOpEquiv_functor_map_app
code: /-- The equivalence of functor categories induced by `leftOp` and `rightOp`.
-/
@[simps!]
def leftOpRightOpEquiv : (Cᵒᵖ ⥤ D)ᵒᵖ ≌ C ⥤ Dᵒᵖ 
goal: ∀ {X Y : (CategoryTheory.Functor Cᵒᵖ D)ᵒᵖ} (η : X ⟶ Y) (X_1 : C),
  ((CategoryTheory.Functor.leftOpRightOpEquiv C D).functor.map η).app X_1 = (η.unop.app (Opposite.op X_1)).op

full_name: CategoryTheory.Functor.leftOpRightOpEquiv_unitIso_hom_app
code: /-- The equivalence of functor categories induced by `leftOp` and `rightOp`.
-/
@[simps!]
def leftOpRightOpEquiv : (Cᵒᵖ ⥤ D)ᵒᵖ ≌ C ⥤ Dᵒᵖ 
goal: (CategoryTheory.Functor.leftOpRightOpEquiv C D).unitIso.hom.app X = (Opposite.unop X).rightOpLeftOpIso.hom.op

full_name: CategoryTheory.Functor.instEssSurjOppositeOp
code: instance {F : C ⥤ D} [EssSurj F] : EssSurj F.op 
goal: F.op.EssSurj

full_name: CategoryTheory.Functor.instEssSurjOppositeRightOp
code: instance {F : Cᵒᵖ ⥤ D} [EssSurj F] : EssSurj F.rightOp 
goal: F.rightOp.EssSurj

full_name: CategoryTheory.Functor.instEssSurjOppositeLeftOp
code: instance {F : C ⥤ Dᵒᵖ} [EssSurj F] : EssSurj F.leftOp 
goal: F.leftOp.EssSurj

full_name: CategoryTheory.Functor.instIsEquivalenceOppositeOp
code: instance {F : C ⥤ D} [IsEquivalence F] : IsEquivalence F.op 
goal: F.op.IsEquivalence

full_name: CategoryTheory.Functor.instIsEquivalenceOppositeRightOp
code: instance {F : Cᵒᵖ ⥤ D} [IsEquivalence F] : IsEquivalence F.rightOp 
goal: F.rightOp.IsEquivalence

full_name: CategoryTheory.Functor.instIsEquivalenceOppositeLeftOp
code: instance {F : C ⥤ Dᵒᵖ} [IsEquivalence F] : IsEquivalence F.leftOp 
goal: F.leftOp.IsEquivalence