ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
-- CategoryTheory.Equivalence.preregular_isSheaf_iff
theorem preregular_isSheaf_iff (F : Cᵒᵖ ⥤ A) : haveI := e.preregular
    IsSheaf (regularTopology C) F ↔ IsSheaf (regularTopology D) (e.inverse.op ⋙ F) 
Arguments: {C : Type u_1} [CategoryTheory.Category.{u_4, u_1} C] {D : Type u_2} [CategoryTheory.Category.{u_6, u_2} D] (e : C ≌ D) [CategoryTheory.Preregular C] (A : Type u_3) [CategoryTheory.Category.{u_5, u_3} A] (F : CategoryTheory.Functor Cᵒᵖ A)
Goal: CategoryTheory.Presheaf.IsSheaf (CategoryTheory.regularTopology C) F ↔
  CategoryTheory.Presheaf.IsSheaf (CategoryTheory.regularTopology D) (e.inverse.op.comp F)
-- CategoryTheory.Equivalence.preregular_isSheaf_iff_of_essentiallySmall
theorem preregular_isSheaf_iff_of_essentiallySmall [EssentiallySmall C] (F : Cᵒᵖ ⥤ A) :
    IsSheaf (regularTopology C) F ↔ IsSheaf (regularTopology (SmallModel C))
    ((equivSmallModel C).inverse.op ⋙ F) 
Arguments: {C : Type u_1} [CategoryTheory.Category.{u_5, u_1} C] [CategoryTheory.Preregular C] (A : Type u_3) [CategoryTheory.Category.{u_6, u_3} A] [CategoryTheory.EssentiallySmall.{u_4, u_5, u_1} C] (F : CategoryTheory.Functor Cᵒᵖ A)
Goal: CategoryTheory.Presheaf.IsSheaf (CategoryTheory.regularTopology C) F ↔
  CategoryTheory.Presheaf.IsSheaf (CategoryTheory.regularTopology (CategoryTheory.SmallModel.{u_4, u_5, u_1} C))
    ((CategoryTheory.equivSmallModel C).inverse.op.comp F)
-- CategoryTheory.ExponentialIdeal.exp_closed
class ExponentialIdeal : Prop where
  exp_closed : ∀ {B}, B ∈ i.essImage → ∀ A, (A ⟹ B) ∈ i.essImage
Arguments: {C : Type u₁} {D : Type u₂} [CategoryTheory.Category.{v₁, u₁} C] [CategoryTheory.Category.{v₁, u₂} D] {i : CategoryTheory.Functor D C} [CategoryTheory.Limits.HasFiniteProducts C] [CategoryTheory.CartesianClosed C] [self : CategoryTheory.ExponentialIdeal i] {B : C}
Goal: B ∈ i.essImage → ∀ (A : C), (A ⟹ B) ∈ i.essImage
-- CategoryTheory.ExponentialIdeal.mk'
theorem ExponentialIdeal.mk' (h : ∀ (B : D) (A : C), (A ⟹ i.obj B) ∈ i.essImage) :
    ExponentialIdeal i 
Arguments: {C : Type u₁} {D : Type u₂} [CategoryTheory.Category.{v₁, u₁} C] [CategoryTheory.Category.{v₁, u₂} D] (i : CategoryTheory.Functor D C) [CategoryTheory.Limits.HasFiniteProducts C] [CategoryTheory.CartesianClosed C] (h : ∀ (B : D) (A : C), (A ⟹ i.obj B) ∈ i.essImage)
Goal: CategoryTheory.ExponentialIdeal i
-- CategoryTheory.ExponentialIdeal.mk_of_iso
theorem ExponentialIdeal.mk_of_iso [Reflective i]
    (h : ∀ A : C, i ⋙ exp A ⋙ reflector i ⋙ i ≅ i ⋙ exp A) : ExponentialIdeal i 
Arguments: {C : Type u₁} {D : Type u₂} [CategoryTheory.Category.{v₁, u₁} C] [CategoryTheory.Category.{v₁, u₂} D] (i : CategoryTheory.Functor D C) [CategoryTheory.Limits.HasFiniteProducts C] [CategoryTheory.CartesianClosed C] [CategoryTheory.Reflective i] (h :
  (A : C) → i.comp ((CategoryTheory.exp A).comp ((CategoryTheory.reflector i).comp i)) ≅ i.comp (CategoryTheory.exp A))
Goal: CategoryTheory.ExponentialIdeal i
-- CategoryTheory.reflective_products
theorem reflective_products [HasFiniteProducts C] [Reflective i] : HasFiniteProducts D 
Arguments: {C : Type u₁} {D : Type u₂} [CategoryTheory.Category.{v₁, u₁} C] [CategoryTheory.Category.{v₁, u₂} D] (i : CategoryTheory.Functor D C) [CategoryTheory.Limits.HasFiniteProducts C] [CategoryTheory.Reflective i]
Goal: CategoryTheory.Limits.HasFiniteProducts D
-- CategoryTheory.bijection_symm_apply_id
theorem bijection_symm_apply_id (A B : C) :
    (bijection i A B _).symm (𝟙 _) = prodComparison _ _ _ 
Arguments: {C : Type u₁} {D : Type u₂} [CategoryTheory.Category.{v₁, u₁} C] [CategoryTheory.Category.{v₁, u₂} D] (i : CategoryTheory.Functor D C) [CategoryTheory.Limits.HasFiniteProducts C] [CategoryTheory.Reflective i] [CategoryTheory.CartesianClosed C] [CategoryTheory.Limits.HasFiniteProducts D] [CategoryTheory.ExponentialIdeal i] (A B : C)
Goal: (CategoryTheory.bijection i A B ((CategoryTheory.reflector i).obj A ⨯ (CategoryTheory.reflector i).obj B)).symm
    (CategoryTheory.CategoryStruct.id ((CategoryTheory.reflector i).obj A ⨯ (CategoryTheory.reflector i).obj B)) =
  CategoryTheory.Limits.prodComparison (CategoryTheory.reflector i) A B
-- CategoryTheory.bijection_natural
theorem bijection_natural (A B : C) (X X' : D) (f : (reflector i).obj (A ⨯ B) ⟶ X) (g : X ⟶ X') :
    bijection i _ _ _ (f ≫ g) = bijection i _ _ _ f ≫ g 
Arguments: {C : Type u₁} {D : Type u₂} [CategoryTheory.Category.{v₁, u₁} C] [CategoryTheory.Category.{v₁, u₂} D] (i : CategoryTheory.Functor D C) [CategoryTheory.Limits.HasFiniteProducts C] [CategoryTheory.Reflective i] [CategoryTheory.CartesianClosed C] [CategoryTheory.Limits.HasFiniteProducts D] [CategoryTheory.ExponentialIdeal i] (A B : C) (X X' : D) (f : (CategoryTheory.reflector i).obj (A ⨯ B) ⟶ X) (g : X ⟶ X')
Goal: (CategoryTheory.bijection i A B X') (CategoryTheory.CategoryStruct.comp f g) =
  CategoryTheory.CategoryStruct.comp ((CategoryTheory.bijection i A B X) f) g
-- CategoryTheory.prodComparison_iso
theorem prodComparison_iso (A B : C) : IsIso (prodComparison (reflector i) A B) 
Arguments: {C : Type u₁} {D : Type u₂} [CategoryTheory.Category.{v₁, u₁} C] [CategoryTheory.Category.{v₁, u₂} D] (i : CategoryTheory.Functor D C) [CategoryTheory.Limits.HasFiniteProducts C] [CategoryTheory.Reflective i] [CategoryTheory.CartesianClosed C] [CategoryTheory.Limits.HasFiniteProducts D] [CategoryTheory.ExponentialIdeal i] (A B : C)
Goal: CategoryTheory.IsIso (CategoryTheory.Limits.prodComparison (CategoryTheory.reflector i) A B)
-- CategoryTheory.Precoherent.pullback
class Precoherent : Prop where
    pullback {B₁ B₂ : C} (f : B₂ ⟶ B₁) :
    ∀ (α : Type) [Finite α] (X₁ : α → C) (π₁ : (a : α) → (X₁ a ⟶ B₁)),
      EffectiveEpiFamily X₁ π₁ →
    ∃ (β : Type) (_ : Finite β) (X₂ : β → C) (π₂ : (b : β) → (X₂ b ⟶ B₂)),
      EffectiveEpiFamily X₂ π₂ ∧
      ∃ (i : β → α) (ι : (b :  β) → (X₂ b ⟶ X₁ (i b))),
      ∀ (b : β), ι b ≫ π₁ _ = π₂ _ ≫ f
Arguments: {C : Type u_1} [CategoryTheory.Category.{u_2, u_1} C] [self : CategoryTheory.Precoherent C] {B₁ B₂ : C} (f : B₂ ⟶ B₁) (α : Type) [Finite α] (X₁ : α → C) (π₁ : (a : α) → X₁ a ⟶ B₁)
Goal: CategoryTheory.EffectiveEpiFamily X₁ π₁ →
  ∃ β,
    ∃ (_ : Finite β),
      ∃ X₂ π₂,
        CategoryTheory.EffectiveEpiFamily X₂ π₂ ∧
          ∃ i ι,
            ∀ (b : β), CategoryTheory.CategoryStruct.comp (ι b) (π₁ (i b)) = CategoryTheory.CategoryStruct.comp (π₂ b) f
-- CategoryTheory.Preregular.exists_fac
class Preregular : Prop where
    exists_fac : ∀ {X Y Z : C} (f : X ⟶ Y) (g : Z ⟶ Y) [EffectiveEpi g],
    (∃ (W : C) (h : W ⟶ X) (_ : EffectiveEpi h) (i : W ⟶ Z), i ≫ g = h ≫ f)
Arguments: {C : Type u_1} [CategoryTheory.Category.{u_2, u_1} C] [self : CategoryTheory.Preregular C] {X Y Z : C} (f : X ⟶ Y) (g : Z ⟶ Y) [CategoryTheory.EffectiveEpi g]
Goal: ∃ W h,
  ∃ (_ : CategoryTheory.EffectiveEpi h),
    ∃ i, CategoryTheory.CategoryStruct.comp i g = CategoryTheory.CategoryStruct.comp h f
-- Quiver.Hom.op_inj
theorem Quiver.Hom.op_inj {X Y : C} :
    Function.Injective (Quiver.Hom.op : (X ⟶ Y) → (Opposite.op Y ⟶ Opposite.op X)) 
Arguments: {C : Type u₁} [Quiver C] {X Y : C}
Goal: Function.Injective Quiver.Hom.op
-- Quiver.Hom.unop_inj
theorem Quiver.Hom.unop_inj {X Y : Cᵒᵖ} :
    Function.Injective (Quiver.Hom.unop : (X ⟶ Y) → (Opposite.unop Y ⟶ Opposite.unop X)) 
Arguments: {C : Type u₁} [Quiver C] {X Y : Cᵒᵖ}
Goal: Function.Injective Quiver.Hom.unop
-- Quiver.Hom.unop_op
@[simp]
theorem Quiver.Hom.unop_op {X Y : C} (f : X ⟶ Y) : f.op.unop = f 
Arguments: {C : Type u₁} [Quiver C] {X Y : C} (f : X ⟶ Y)
Goal: f.op.unop = f
-- Quiver.Hom.unop_op'
@[simp]
theorem Quiver.Hom.unop_op' {X Y : Cᵒᵖ} {x} :
    @Quiver.Hom.unop C _ X Y no_index (Opposite.op (unop := x)) = x 
Arguments: {C : Type u₁} [Quiver C] {X Y : Cᵒᵖ} {x : Opposite.unop Y ⟶ Opposite.unop X}
Goal: Quiver.Hom.unop (Opposite.op x) = x
-- Quiver.Hom.op_unop
@[simp]
theorem Quiver.Hom.op_unop {X Y : Cᵒᵖ} (f : X ⟶ Y) : f.unop.op = f 
Arguments: {C : Type u₁} [Quiver C] {X Y : Cᵒᵖ} (f : X ⟶ Y)
Goal: f.unop.op = f
-- Quiver.Hom.unop_mk
@[simp] theorem Quiver.Hom.unop_mk {X Y : Cᵒᵖ} (f : X ⟶ Y) : Quiver.Hom.unop {unop := f} = f 
Arguments: {C : Type u₁} [Quiver C] {X Y : Cᵒᵖ} (f : X ⟶ Y)
Goal: Quiver.Hom.unop (Opposite.op f) = f
-- CategoryTheory.op_comp
@[simp, reassoc]
theorem op_comp {X Y Z : C} {f : X ⟶ Y} {g : Y ⟶ Z} : (f ≫ g).op = g.op ≫ f.op 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {X Y Z : C} {f : X ⟶ Y} {g : Y ⟶ Z}
Goal: (CategoryTheory.CategoryStruct.comp f g).op = CategoryTheory.CategoryStruct.comp g.op f.op
-- CategoryTheory.op_id
@[simp]
theorem op_id {X : C} : (𝟙 X).op = 𝟙 (op X) 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {X : C}
Goal: (CategoryTheory.CategoryStruct.id X).op = CategoryTheory.CategoryStruct.id (Opposite.op X)
-- CategoryTheory.unop_comp
@[simp, reassoc]
theorem unop_comp {X Y Z : Cᵒᵖ} {f : X ⟶ Y} {g : Y ⟶ Z} : (f ≫ g).unop = g.unop ≫ f.unop 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {X Y Z : Cᵒᵖ} {f : X ⟶ Y} {g : Y ⟶ Z}
Goal: (CategoryTheory.CategoryStruct.comp f g).unop = CategoryTheory.CategoryStruct.comp g.unop f.unop
-- CategoryTheory.unop_id
@[simp]
theorem unop_id {X : Cᵒᵖ} : (𝟙 X).unop = 𝟙 (unop X) 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {X : Cᵒᵖ}
Goal: (CategoryTheory.CategoryStruct.id X).unop = CategoryTheory.CategoryStruct.id (Opposite.unop X)
-- CategoryTheory.unop_id_op
@[simp]
theorem unop_id_op {X : C} : (𝟙 (op X)).unop = 𝟙 X 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {X : C}
Goal: (CategoryTheory.CategoryStruct.id (Opposite.op X)).unop = CategoryTheory.CategoryStruct.id X
-- CategoryTheory.op_id_unop
@[simp]
theorem op_id_unop {X : Cᵒᵖ} : (𝟙 (unop X)).op = 𝟙 X 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {X : Cᵒᵖ}
Goal: (CategoryTheory.CategoryStruct.id (Opposite.unop X)).op = CategoryTheory.CategoryStruct.id X
-- CategoryTheory.unopUnop_obj
@[simps]
def unopUnop : Cᵒᵖᵒᵖ ⥤ C 
Arguments: (C : Type u₁) [CategoryTheory.Category.{v₁, u₁} C] (X : Cᵒᵖᵒᵖ)
Goal: (CategoryTheory.unopUnop C).obj X = Opposite.unop (Opposite.unop X)
-- CategoryTheory.unopUnop_map
@[simps]
def unopUnop : Cᵒᵖᵒᵖ ⥤ C 
Arguments: (C : Type u₁) [CategoryTheory.Category.{v₁, u₁} C]
Goal: ∀ {X Y : Cᵒᵖᵒᵖ} (f : X ⟶ Y), (CategoryTheory.unopUnop C).map f = f.unop.unop
-- CategoryTheory.opOp_map
@[simps]
def opOp : C ⥤ Cᵒᵖᵒᵖ 
Arguments: (C : Type u₁) [CategoryTheory.Category.{v₁, u₁} C]
Goal: ∀ {X Y : C} (f : X ⟶ Y), (CategoryTheory.opOp C).map f = f.op.op
-- CategoryTheory.opOp_obj
@[simps]
def opOp : C ⥤ Cᵒᵖᵒᵖ 
Arguments: (C : Type u₁) [CategoryTheory.Category.{v₁, u₁} C] (X : C)
Goal: (CategoryTheory.opOp C).obj X = Opposite.op (Opposite.op X)
-- CategoryTheory.opOpEquivalence_inverse
@[simps]
def opOpEquivalence : Cᵒᵖᵒᵖ ≌ C 
Arguments: (C : Type u₁) [CategoryTheory.Category.{v₁, u₁} C]
Goal: (CategoryTheory.opOpEquivalence C).inverse = CategoryTheory.opOp C
-- CategoryTheory.opOpEquivalence_counitIso
@[simps]
def opOpEquivalence : Cᵒᵖᵒᵖ ≌ C 
Arguments: (C : Type u₁) [CategoryTheory.Category.{v₁, u₁} C]
Goal: (CategoryTheory.opOpEquivalence C).counitIso =
  CategoryTheory.Iso.refl ((CategoryTheory.opOp C).comp (CategoryTheory.unopUnop C))
-- CategoryTheory.opOpEquivalence_unitIso
@[simps]
def opOpEquivalence : Cᵒᵖᵒᵖ ≌ C 
Arguments: (C : Type u₁) [CategoryTheory.Category.{v₁, u₁} C]
Goal: (CategoryTheory.opOpEquivalence C).unitIso = CategoryTheory.Iso.refl (CategoryTheory.Functor.id Cᵒᵖᵒᵖ)
-- CategoryTheory.opOpEquivalence_functor
@[simps]
def opOpEquivalence : Cᵒᵖᵒᵖ ≌ C 
Arguments: (C : Type u₁) [CategoryTheory.Category.{v₁, u₁} C]
Goal: (CategoryTheory.opOpEquivalence C).functor = CategoryTheory.unopUnop C
-- CategoryTheory.isIso_of_op
theorem isIso_of_op {X Y : C} (f : X ⟶ Y) [IsIso f.op] : IsIso f 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {X Y : C} (f : X ⟶ Y) [CategoryTheory.IsIso f.op]
Goal: CategoryTheory.IsIso f
-- CategoryTheory.isIso_op_iff
theorem isIso_op_iff {X Y : C} (f : X ⟶ Y) : IsIso f.op ↔ IsIso f 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {X Y : C} (f : X ⟶ Y)
Goal: CategoryTheory.IsIso f.op ↔ CategoryTheory.IsIso f
-- CategoryTheory.isIso_unop_iff
theorem isIso_unop_iff {X Y : Cᵒᵖ} (f : X ⟶ Y) : IsIso f.unop ↔ IsIso f 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {X Y : Cᵒᵖ} (f : X ⟶ Y)
Goal: CategoryTheory.IsIso f.unop ↔ CategoryTheory.IsIso f
-- CategoryTheory.op_inv
@[simp]
theorem op_inv {X Y : C} (f : X ⟶ Y) [IsIso f] : (inv f).op = inv f.op 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {X Y : C} (f : X ⟶ Y) [CategoryTheory.IsIso f]
Goal: (CategoryTheory.inv f).op = CategoryTheory.inv f.op
-- CategoryTheory.unop_inv
@[simp]
theorem unop_inv {X Y : Cᵒᵖ} (f : X ⟶ Y) [IsIso f] : (inv f).unop = inv f.unop 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {X Y : Cᵒᵖ} (f : X ⟶ Y) [CategoryTheory.IsIso f]
Goal: (CategoryTheory.inv f).unop = CategoryTheory.inv f.unop
-- CategoryTheory.Functor.op_obj
@[simps]
protected def op (F : C ⥤ D) : Cᵒᵖ ⥤ Dᵒᵖ 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [CategoryTheory.Category.{v₂, u₂} D] (F : CategoryTheory.Functor C D) (X : Cᵒᵖ)
Goal: F.op.obj X = Opposite.op (F.obj (Opposite.unop X))
-- CategoryTheory.Functor.op_map
@[simps]
protected def op (F : C ⥤ D) : Cᵒᵖ ⥤ Dᵒᵖ 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [CategoryTheory.Category.{v₂, u₂} D] (F : CategoryTheory.Functor C D)
Goal: ∀ {X Y : Cᵒᵖ} (f : X ⟶ Y), F.op.map f = (F.map f.unop).op
-- CategoryTheory.Functor.unop_map
@[simps]
protected def unop (F : Cᵒᵖ ⥤ Dᵒᵖ) : C ⥤ D 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [CategoryTheory.Category.{v₂, u₂} D] (F : CategoryTheory.Functor Cᵒᵖ Dᵒᵖ)
Goal: ∀ {X Y : C} (f : X ⟶ Y), F.unop.map f = (F.map f.op).unop
-- CategoryTheory.Functor.unop_obj
@[simps]
protected def unop (F : Cᵒᵖ ⥤ Dᵒᵖ) : C ⥤ D 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [CategoryTheory.Category.{v₂, u₂} D] (F : CategoryTheory.Functor Cᵒᵖ Dᵒᵖ) (X : C)
Goal: F.unop.obj X = Opposite.unop (F.obj (Opposite.op X))
-- CategoryTheory.Functor.opUnopIso_inv_app
@[simps!]
def opUnopIso (F : C ⥤ D) : F.op.unop ≅ F 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [CategoryTheory.Category.{v₂, u₂} D] (F : CategoryTheory.Functor C D) (X : C)
Goal: F.opUnopIso.inv.app X = CategoryTheory.CategoryStruct.id (F.obj X)
-- CategoryTheory.Functor.opUnopIso_hom_app
@[simps!]
def opUnopIso (F : C ⥤ D) : F.op.unop ≅ F 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [CategoryTheory.Category.{v₂, u₂} D] (F : CategoryTheory.Functor C D) (X : C)
Goal: F.opUnopIso.hom.app X = CategoryTheory.CategoryStruct.id (F.obj X)
-- CategoryTheory.Functor.unopOpIso_hom_app
@[simps!]
def unopOpIso (F : Cᵒᵖ ⥤ Dᵒᵖ) : F.unop.op ≅ F 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [CategoryTheory.Category.{v₂, u₂} D] (F : CategoryTheory.Functor Cᵒᵖ Dᵒᵖ) (X : Cᵒᵖ)
Goal: F.unopOpIso.hom.app X = CategoryTheory.CategoryStruct.id (F.obj X)
-- CategoryTheory.Functor.unopOpIso_inv_app
@[simps!]
def unopOpIso (F : Cᵒᵖ ⥤ Dᵒᵖ) : F.unop.op ≅ F 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [CategoryTheory.Category.{v₂, u₂} D] (F : CategoryTheory.Functor Cᵒᵖ Dᵒᵖ) (X : Cᵒᵖ)
Goal: F.unopOpIso.inv.app X = CategoryTheory.CategoryStruct.id (F.obj X)
-- CategoryTheory.Functor.opHom_obj
@[simps]
def opHom : (C ⥤ D)ᵒᵖ ⥤ Cᵒᵖ ⥤ Dᵒᵖ 
Arguments: (C : Type u₁) [CategoryTheory.Category.{v₁, u₁} C] (D : Type u₂) [CategoryTheory.Category.{v₂, u₂} D] (F : (CategoryTheory.Functor C D)ᵒᵖ)
Goal: (CategoryTheory.Functor.opHom C D).obj F = (Opposite.unop F).op
-- CategoryTheory.Functor.opHom_map_app
@[simps]
def opHom : (C ⥤ D)ᵒᵖ ⥤ Cᵒᵖ ⥤ Dᵒᵖ 
Arguments: (C : Type u₁) [CategoryTheory.Category.{v₁, u₁} C] (D : Type u₂) [CategoryTheory.Category.{v₂, u₂} 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
-- CategoryTheory.Functor.opInv_map
@[simps]
def opInv : (Cᵒᵖ ⥤ Dᵒᵖ) ⥤ (C ⥤ D)ᵒᵖ 
Arguments: (C : Type u₁) [CategoryTheory.Category.{v₁, u₁} C] (D : Type u₂) [CategoryTheory.Category.{v₂, u₂} 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 := ⋯ }
-- CategoryTheory.Functor.opInv_obj
@[simps]
def opInv : (Cᵒᵖ ⥤ Dᵒᵖ) ⥤ (C ⥤ D)ᵒᵖ 
Arguments: (C : Type u₁) [CategoryTheory.Category.{v₁, u₁} C] (D : Type u₂) [CategoryTheory.Category.{v₂, u₂} D] (F : CategoryTheory.Functor Cᵒᵖ Dᵒᵖ)
Goal: (CategoryTheory.Functor.opInv C D).obj F = Opposite.op F.unop
-- CategoryTheory.Functor.leftOp_obj
@[simps]
protected def leftOp (F : C ⥤ Dᵒᵖ) : Cᵒᵖ ⥤ D 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [CategoryTheory.Category.{v₂, u₂} D] (F : CategoryTheory.Functor C Dᵒᵖ) (X : Cᵒᵖ)
Goal: F.leftOp.obj X = Opposite.unop (F.obj (Opposite.unop X))
-- CategoryTheory.Functor.leftOp_map
@[simps]
protected def leftOp (F : C ⥤ Dᵒᵖ) : Cᵒᵖ ⥤ D 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [CategoryTheory.Category.{v₂, u₂} D] (F : CategoryTheory.Functor C Dᵒᵖ)
Goal: ∀ {X Y : Cᵒᵖ} (f : X ⟶ Y), F.leftOp.map f = (F.map f.unop).unop
-- CategoryTheory.Functor.rightOp_obj
@[simps]
protected def rightOp (F : Cᵒᵖ ⥤ D) : C ⥤ Dᵒᵖ 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [CategoryTheory.Category.{v₂, u₂} D] (F : CategoryTheory.Functor Cᵒᵖ D) (X : C)
Goal: F.rightOp.obj X = Opposite.op (F.obj (Opposite.op X))
-- CategoryTheory.Functor.rightOp_map
@[simps]
protected def rightOp (F : Cᵒᵖ ⥤ D) : C ⥤ Dᵒᵖ 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [CategoryTheory.Category.{v₂, u₂} D] (F : CategoryTheory.Functor Cᵒᵖ D)
Goal: ∀ {X Y : C} (f : X ⟶ Y), F.rightOp.map f = (F.map f.op).op
-- CategoryTheory.Functor.rightOp_map_unop
lemma rightOp_map_unop {F : Cᵒᵖ ⥤ D} {X Y} (f : X ⟶ Y) :
    (F.rightOp.map f).unop = F.map f.op 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [CategoryTheory.Category.{v₂, u₂} D] {F : CategoryTheory.Functor Cᵒᵖ D} {X Y : C} (f : X ⟶ Y)
Goal: (F.rightOp.map f).unop = F.map f.op
-- CategoryTheory.Functor.leftOpRightOpIso_hom_app
@[simps!]
def leftOpRightOpIso (F : C ⥤ Dᵒᵖ) : F.leftOp.rightOp ≅ F 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [CategoryTheory.Category.{v₂, u₂} D] (F : CategoryTheory.Functor C Dᵒᵖ) (X : C)
Goal: F.leftOpRightOpIso.hom.app X = CategoryTheory.CategoryStruct.id (F.obj X)
-- CategoryTheory.Functor.leftOpRightOpIso_inv_app
@[simps!]
def leftOpRightOpIso (F : C ⥤ Dᵒᵖ) : F.leftOp.rightOp ≅ F 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [CategoryTheory.Category.{v₂, u₂} D] (F : CategoryTheory.Functor C Dᵒᵖ) (X : C)
Goal: F.leftOpRightOpIso.inv.app X = CategoryTheory.CategoryStruct.id (F.obj X)
-- CategoryTheory.Functor.rightOpLeftOpIso_inv_app
@[simps!]
def rightOpLeftOpIso (F : Cᵒᵖ ⥤ D) : F.rightOp.leftOp ≅ F 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [CategoryTheory.Category.{v₂, u₂} D] (F : CategoryTheory.Functor Cᵒᵖ D) (X : Cᵒᵖ)
Goal: F.rightOpLeftOpIso.inv.app X = CategoryTheory.CategoryStruct.id (F.obj X)
-- CategoryTheory.Functor.rightOpLeftOpIso_hom_app
@[simps!]
def rightOpLeftOpIso (F : Cᵒᵖ ⥤ D) : F.rightOp.leftOp ≅ F 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [CategoryTheory.Category.{v₂, u₂} D] (F : CategoryTheory.Functor Cᵒᵖ D) (X : Cᵒᵖ)
Goal: F.rightOpLeftOpIso.hom.app X = CategoryTheory.CategoryStruct.id (F.obj X)
-- CategoryTheory.Functor.rightOp_leftOp_eq
theorem rightOp_leftOp_eq (F : Cᵒᵖ ⥤ D) : F.rightOp.leftOp = F 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [CategoryTheory.Category.{v₂, u₂} D] (F : CategoryTheory.Functor Cᵒᵖ D)
Goal: F.rightOp.leftOp = F
-- CategoryTheory.NatTrans.op_app
@[simps]
protected def op (α : F ⟶ G) : G.op ⟶ F.op 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [CategoryTheory.Category.{v₂, u₂} D] {F G : CategoryTheory.Functor C D} (α : F ⟶ G) (X : Cᵒᵖ)
Goal: (CategoryTheory.NatTrans.op α).app X = (α.app (Opposite.unop X)).op
-- CategoryTheory.NatTrans.op_id
@[simp]
theorem op_id (F : C ⥤ D) : NatTrans.op (𝟙 F) = 𝟙 F.op 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [CategoryTheory.Category.{v₂, u₂} D] (F : CategoryTheory.Functor C D)
Goal: CategoryTheory.NatTrans.op (CategoryTheory.CategoryStruct.id F) = CategoryTheory.CategoryStruct.id F.op
-- CategoryTheory.NatTrans.unop_app
@[simps]
protected def unop {F G : Cᵒᵖ ⥤ Dᵒᵖ} (α : F ⟶ G) : G.unop ⟶ F.unop 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [CategoryTheory.Category.{v₂, u₂} D] {F G : CategoryTheory.Functor Cᵒᵖ Dᵒᵖ} (α : F ⟶ G) (X : C)
Goal: (CategoryTheory.NatTrans.unop α).app X = (α.app (Opposite.op X)).unop
-- CategoryTheory.NatTrans.unop_id
@[simp]
theorem unop_id (F : Cᵒᵖ ⥤ Dᵒᵖ) : NatTrans.unop (𝟙 F) = 𝟙 F.unop 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [CategoryTheory.Category.{v₂, u₂} D] (F : CategoryTheory.Functor Cᵒᵖ Dᵒᵖ)
Goal: CategoryTheory.NatTrans.unop (CategoryTheory.CategoryStruct.id F) = CategoryTheory.CategoryStruct.id F.unop
-- CategoryTheory.NatTrans.removeOp_app
@[simps]
protected def removeOp (α : F.op ⟶ G.op) : G ⟶ F 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [CategoryTheory.Category.{v₂, u₂} D] {F G : CategoryTheory.Functor C D} (α : F.op ⟶ G.op) (X : C)
Goal: (CategoryTheory.NatTrans.removeOp α).app X = (α.app (Opposite.op X)).unop
-- CategoryTheory.NatTrans.removeOp_id
@[simp]
theorem removeOp_id (F : C ⥤ D) : NatTrans.removeOp (𝟙 F.op) = 𝟙 F 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [CategoryTheory.Category.{v₂, u₂} D] (F : CategoryTheory.Functor C D)
Goal: CategoryTheory.NatTrans.removeOp (CategoryTheory.CategoryStruct.id F.op) = CategoryTheory.CategoryStruct.id F
-- CategoryTheory.NatTrans.removeUnop_app
@[simps]
protected def removeUnop {F G : Cᵒᵖ ⥤ Dᵒᵖ} (α : F.unop ⟶ G.unop) : G ⟶ F 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [CategoryTheory.Category.{v₂, u₂} D] {F G : CategoryTheory.Functor Cᵒᵖ Dᵒᵖ} (α : F.unop ⟶ G.unop) (X : Cᵒᵖ)
Goal: (CategoryTheory.NatTrans.removeUnop α).app X = (α.app (Opposite.unop X)).op
-- CategoryTheory.NatTrans.removeUnop_id
@[simp]
theorem removeUnop_id (F : Cᵒᵖ ⥤ Dᵒᵖ) : NatTrans.removeUnop (𝟙 F.unop) = 𝟙 F 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [CategoryTheory.Category.{v₂, u₂} D] (F : CategoryTheory.Functor Cᵒᵖ Dᵒᵖ)
Goal: CategoryTheory.NatTrans.removeUnop (CategoryTheory.CategoryStruct.id F.unop) = CategoryTheory.CategoryStruct.id F
-- CategoryTheory.NatTrans.leftOp_app
@[simps]
protected def leftOp (α : F ⟶ G) : G.leftOp ⟶ F.leftOp 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [CategoryTheory.Category.{v₂, u₂} D] {F G : CategoryTheory.Functor C Dᵒᵖ} (α : F ⟶ G) (X : Cᵒᵖ)
Goal: (CategoryTheory.NatTrans.leftOp α).app X = (α.app (Opposite.unop X)).unop
-- CategoryTheory.NatTrans.leftOp_id
@[simp]
theorem leftOp_id : NatTrans.leftOp (𝟙 F : F ⟶ F) = 𝟙 F.leftOp 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [CategoryTheory.Category.{v₂, u₂} D] {F : CategoryTheory.Functor C Dᵒᵖ}
Goal: CategoryTheory.NatTrans.leftOp (CategoryTheory.CategoryStruct.id F) = CategoryTheory.CategoryStruct.id F.leftOp
-- CategoryTheory.NatTrans.leftOp_comp
@[simp]
theorem leftOp_comp (α : F ⟶ G) (β : G ⟶ H) : NatTrans.leftOp (α ≫ β) =
    NatTrans.leftOp β ≫ NatTrans.leftOp α 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [CategoryTheory.Category.{v₂, u₂} D] {F G H : CategoryTheory.Functor C Dᵒᵖ} (α : F ⟶ G) (β : G ⟶ H)
Goal: CategoryTheory.NatTrans.leftOp (CategoryTheory.CategoryStruct.comp α β) =
  CategoryTheory.CategoryStruct.comp (CategoryTheory.NatTrans.leftOp β) (CategoryTheory.NatTrans.leftOp α)