ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
-- CategoryTheory.GrothendieckTopology.Cover.Arrow.precompRelation_g₁
@[simps]
def Arrow.precompRelation {S : J.Cover X} (I : S.Arrow) {Z : C} (g : Z ⟶ I.Y) :
    (I.precomp g).Relation I 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] {X : C} {J : CategoryTheory.GrothendieckTopology C} {S : J.Cover X} (I : S.Arrow) {Z : C} (g : Z ⟶ I.Y)
Goal: (I.precompRelation g).g₁ = CategoryTheory.CategoryStruct.id (I.precomp g).Y
-- CategoryTheory.GrothendieckTopology.Cover.Arrow.precompRelation_g₂
@[simps]
def Arrow.precompRelation {S : J.Cover X} (I : S.Arrow) {Z : C} (g : Z ⟶ I.Y) :
    (I.precomp g).Relation I 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] {X : C} {J : CategoryTheory.GrothendieckTopology C} {S : J.Cover X} (I : S.Arrow) {Z : C} (g : Z ⟶ I.Y)
Goal: (I.precompRelation g).g₂ = g
-- CategoryTheory.GrothendieckTopology.Cover.Arrow.precompRelation_Z
@[simps]
def Arrow.precompRelation {S : J.Cover X} (I : S.Arrow) {Z : C} (g : Z ⟶ I.Y) :
    (I.precomp g).Relation I 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] {X : C} {J : CategoryTheory.GrothendieckTopology C} {S : J.Cover X} (I : S.Arrow) {Z : C} (g : Z ⟶ I.Y)
Goal: (I.precompRelation g).Z = (I.precomp g).Y
-- CategoryTheory.GrothendieckTopology.Cover.Arrow.map_Y
@[simps]
def Arrow.map {S T : J.Cover X} (I : S.Arrow) (f : S ⟶ T) : T.Arrow 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] {X : C} {J : CategoryTheory.GrothendieckTopology C} {S T : J.Cover X} (I : S.Arrow) (f : S ⟶ T)
Goal: (I.map f).Y = I.Y
-- CategoryTheory.GrothendieckTopology.Cover.Arrow.map_f
@[simps]
def Arrow.map {S T : J.Cover X} (I : S.Arrow) (f : S ⟶ T) : T.Arrow 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] {X : C} {J : CategoryTheory.GrothendieckTopology C} {S T : J.Cover X} (I : S.Arrow) (f : S ⟶ T)
Goal: (I.map f).f = I.f
-- CategoryTheory.GrothendieckTopology.Cover.Arrow.Relation.map_g₂
@[simps]
def Arrow.Relation.map {S T : J.Cover X} {I₁ I₂ : S.Arrow}
    (r : I₁.Relation I₂) (f : S ⟶ T) : (I₁.map f).Relation (I₂.map f) 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] {X : C} {J : CategoryTheory.GrothendieckTopology C} {S T : J.Cover X} {I₁ I₂ : S.Arrow} (r : I₁.Relation I₂) (f : S ⟶ T)
Goal: (r.map f).g₂ = r.g₂
-- CategoryTheory.GrothendieckTopology.Cover.Arrow.Relation.map_g₁
@[simps]
def Arrow.Relation.map {S T : J.Cover X} {I₁ I₂ : S.Arrow}
    (r : I₁.Relation I₂) (f : S ⟶ T) : (I₁.map f).Relation (I₂.map f) 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] {X : C} {J : CategoryTheory.GrothendieckTopology C} {S T : J.Cover X} {I₁ I₂ : S.Arrow} (r : I₁.Relation I₂) (f : S ⟶ T)
Goal: (r.map f).g₁ = r.g₁
-- CategoryTheory.GrothendieckTopology.Cover.Arrow.Relation.map_Z
@[simps]
def Arrow.Relation.map {S T : J.Cover X} {I₁ I₂ : S.Arrow}
    (r : I₁.Relation I₂) (f : S ⟶ T) : (I₁.map f).Relation (I₂.map f) 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] {X : C} {J : CategoryTheory.GrothendieckTopology C} {S T : J.Cover X} {I₁ I₂ : S.Arrow} (r : I₁.Relation I₂) (f : S ⟶ T)
Goal: (r.map f).Z = r.Z
-- CategoryTheory.GrothendieckTopology.Cover.Arrow.base_Y
@[simps]
def Arrow.base {f : Y ⟶ X} {S : J.Cover X} (I : (S.pullback f).Arrow) : S.Arrow 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] {X Y : C} {J : CategoryTheory.GrothendieckTopology C} {f : Y ⟶ X} {S : J.Cover X} (I : (S.pullback f).Arrow)
Goal: I.base.Y = I.Y
-- CategoryTheory.GrothendieckTopology.Cover.Arrow.base_f
@[simps]
def Arrow.base {f : Y ⟶ X} {S : J.Cover X} (I : (S.pullback f).Arrow) : S.Arrow 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] {X Y : C} {J : CategoryTheory.GrothendieckTopology C} {f : Y ⟶ X} {S : J.Cover X} (I : (S.pullback f).Arrow)
Goal: I.base.f = CategoryTheory.CategoryStruct.comp I.f f
-- CategoryTheory.GrothendieckTopology.Cover.coe_pullback
@[simp]
theorem coe_pullback {Z : C} (f : Y ⟶ X) (g : Z ⟶ Y) (S : J.Cover X) :
    (S.pullback f) g ↔ S (g ≫ f) 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] {X Y : C} {J : CategoryTheory.GrothendieckTopology C} {Z : C} (f : Y ⟶ X) (g : Z ⟶ Y) (S : J.Cover X)
Goal: (S.pullback f).sieve.arrows g ↔ S.sieve.arrows (CategoryTheory.CategoryStruct.comp g f)
-- CategoryTheory.GrothendieckTopology.Cover.Arrow.from_middle_condition
theorem Arrow.from_middle_condition {X : C} {S : J.Cover X} {T : ∀ I : S.Arrow, J.Cover I.Y}
    (I : (S.bind T).Arrow) : S I.fromMiddleHom 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] {J : CategoryTheory.GrothendieckTopology C} {X : C} {S : J.Cover X} {T : (I : S.Arrow) → J.Cover I.Y} (I : (S.bind T).Arrow)
Goal: S.sieve.arrows I.fromMiddleHom
-- CategoryTheory.GrothendieckTopology.Cover.Arrow.to_middle_condition
theorem Arrow.to_middle_condition {X : C} {S : J.Cover X} {T : ∀ I : S.Arrow, J.Cover I.Y}
    (I : (S.bind T).Arrow) : (T I.fromMiddle) I.toMiddleHom 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] {J : CategoryTheory.GrothendieckTopology C} {X : C} {S : J.Cover X} {T : (I : S.Arrow) → J.Cover I.Y} (I : (S.bind T).Arrow)
Goal: (T I.fromMiddle).sieve.arrows I.toMiddleHom
-- CategoryTheory.GrothendieckTopology.Cover.Arrow.middle_spec
theorem Arrow.middle_spec {X : C} {S : J.Cover X} {T : ∀ I : S.Arrow, J.Cover I.Y}
    (I : (S.bind T).Arrow) : I.toMiddleHom ≫ I.fromMiddleHom = I.f 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] {J : CategoryTheory.GrothendieckTopology C} {X : C} {S : J.Cover X} {T : (I : S.Arrow) → J.Cover I.Y} (I : (S.bind T).Arrow)
Goal: CategoryTheory.CategoryStruct.comp I.toMiddleHom I.fromMiddleHom = I.f
-- CategoryTheory.GrothendieckTopology.Cover.Relation.mk'_r
@[simps]
def Relation.mk' {S : J.Cover X} {fst snd : S.Arrow} (r : fst.Relation snd) :
    S.Relation 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] {X : C} {J : CategoryTheory.GrothendieckTopology C} {S : J.Cover X} {fst snd : S.Arrow} (r : fst.Relation snd)
Goal: (CategoryTheory.GrothendieckTopology.Cover.Relation.mk' r).r = r
-- CategoryTheory.GrothendieckTopology.Cover.Relation.mk'_fst
@[simps]
def Relation.mk' {S : J.Cover X} {fst snd : S.Arrow} (r : fst.Relation snd) :
    S.Relation 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] {X : C} {J : CategoryTheory.GrothendieckTopology C} {S : J.Cover X} {fst snd : S.Arrow} (r : fst.Relation snd)
Goal: (CategoryTheory.GrothendieckTopology.Cover.Relation.mk' r).fst = fst
-- CategoryTheory.GrothendieckTopology.Cover.Relation.mk'_snd
@[simps]
def Relation.mk' {S : J.Cover X} {fst snd : S.Arrow} (r : fst.Relation snd) :
    S.Relation 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] {X : C} {J : CategoryTheory.GrothendieckTopology C} {S : J.Cover X} {fst snd : S.Arrow} (r : fst.Relation snd)
Goal: (CategoryTheory.GrothendieckTopology.Cover.Relation.mk' r).snd = snd
-- CategoryTheory.GrothendieckTopology.Cover.index_sndTo
@[simps]
def index {D : Type u₁} [Category.{v₁} D] (S : J.Cover X) (P : Cᵒᵖ ⥤ D) :
    Limits.MulticospanIndex D 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] {X : C} {J : CategoryTheory.GrothendieckTopology C} {D : Type u₁} [CategoryTheory.Category.{v₁, u₁} D] (S : J.Cover X) (P : CategoryTheory.Functor Cᵒᵖ D) (I : S.Relation)
Goal: (S.index P).sndTo I = I.snd
-- CategoryTheory.GrothendieckTopology.Cover.index_snd
@[simps]
def index {D : Type u₁} [Category.{v₁} D] (S : J.Cover X) (P : Cᵒᵖ ⥤ D) :
    Limits.MulticospanIndex D 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] {X : C} {J : CategoryTheory.GrothendieckTopology C} {D : Type u₁} [CategoryTheory.Category.{v₁, u₁} D] (S : J.Cover X) (P : CategoryTheory.Functor Cᵒᵖ D) (I : S.Relation)
Goal: (S.index P).snd I = P.map I.r.g₂.op
-- CategoryTheory.GrothendieckTopology.Cover.index_fst
@[simps]
def index {D : Type u₁} [Category.{v₁} D] (S : J.Cover X) (P : Cᵒᵖ ⥤ D) :
    Limits.MulticospanIndex D 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] {X : C} {J : CategoryTheory.GrothendieckTopology C} {D : Type u₁} [CategoryTheory.Category.{v₁, u₁} D] (S : J.Cover X) (P : CategoryTheory.Functor Cᵒᵖ D) (I : S.Relation)
Goal: (S.index P).fst I = P.map I.r.g₁.op
-- CategoryTheory.GrothendieckTopology.Cover.index_R
@[simps]
def index {D : Type u₁} [Category.{v₁} D] (S : J.Cover X) (P : Cᵒᵖ ⥤ D) :
    Limits.MulticospanIndex D 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] {X : C} {J : CategoryTheory.GrothendieckTopology C} {D : Type u₁} [CategoryTheory.Category.{v₁, u₁} D] (S : J.Cover X) (P : CategoryTheory.Functor Cᵒᵖ D)
Goal: (S.index P).R = S.Relation
-- CategoryTheory.GrothendieckTopology.Cover.index_fstTo
@[simps]
def index {D : Type u₁} [Category.{v₁} D] (S : J.Cover X) (P : Cᵒᵖ ⥤ D) :
    Limits.MulticospanIndex D 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] {X : C} {J : CategoryTheory.GrothendieckTopology C} {D : Type u₁} [CategoryTheory.Category.{v₁, u₁} D] (S : J.Cover X) (P : CategoryTheory.Functor Cᵒᵖ D) (I : S.Relation)
Goal: (S.index P).fstTo I = I.fst
-- CategoryTheory.GrothendieckTopology.Cover.index_right
@[simps]
def index {D : Type u₁} [Category.{v₁} D] (S : J.Cover X) (P : Cᵒᵖ ⥤ D) :
    Limits.MulticospanIndex D 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] {X : C} {J : CategoryTheory.GrothendieckTopology C} {D : Type u₁} [CategoryTheory.Category.{v₁, u₁} D] (S : J.Cover X) (P : CategoryTheory.Functor Cᵒᵖ D) (I : S.Relation)
Goal: (S.index P).right I = P.obj (Opposite.op I.r.Z)
-- CategoryTheory.GrothendieckTopology.Cover.index_L
@[simps]
def index {D : Type u₁} [Category.{v₁} D] (S : J.Cover X) (P : Cᵒᵖ ⥤ D) :
    Limits.MulticospanIndex D 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] {X : C} {J : CategoryTheory.GrothendieckTopology C} {D : Type u₁} [CategoryTheory.Category.{v₁, u₁} D] (S : J.Cover X) (P : CategoryTheory.Functor Cᵒᵖ D)
Goal: (S.index P).L = S.Arrow
-- CategoryTheory.GrothendieckTopology.Cover.index_left
@[simps]
def index {D : Type u₁} [Category.{v₁} D] (S : J.Cover X) (P : Cᵒᵖ ⥤ D) :
    Limits.MulticospanIndex D 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] {X : C} {J : CategoryTheory.GrothendieckTopology C} {D : Type u₁} [CategoryTheory.Category.{v₁, u₁} D] (S : J.Cover X) (P : CategoryTheory.Functor Cᵒᵖ D) (I : S.Arrow)
Goal: (S.index P).left I = P.obj (Opposite.op I.Y)
-- CategoryTheory.GrothendieckTopology.pullback_obj
@[simps obj]
def pullback (f : Y ⟶ X) : J.Cover X ⥤ J.Cover Y 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] {X Y : C} (J : CategoryTheory.GrothendieckTopology C) (f : Y ⟶ X) (S : J.Cover X)
Goal: (J.pullback f).obj S = S.pullback f
-- CategoryTheory.Equivalence.functor_unitIso_comp
@[ext]
structure Equivalence (C : Type u₁) (D : Type u₂) [Category.{v₁} C] [Category.{v₂} D] where mk' ::
    functor : C ⥤ D
    inverse : D ⥤ C
    unitIso : 𝟭 C ≅ functor ⋙ inverse
    counitIso : inverse ⋙ functor ≅ 𝟭 D
    functor_unitIso_comp :
    ∀ X : C, functor.map (unitIso.hom.app X) ≫ counitIso.hom.app (functor.obj X) =
      𝟙 (functor.obj X) := by aesop_cat
Arguments: {C : Type u₁} {D : Type u₂} [CategoryTheory.Category.{v₁, u₁} C] [CategoryTheory.Category.{v₂, u₂} D] (self : C ≌ D) (X : C)
Goal: CategoryTheory.CategoryStruct.comp (self.functor.map (self.unitIso.hom.app X))
    (self.counitIso.hom.app (self.functor.obj X)) =
  CategoryTheory.CategoryStruct.id (self.functor.obj X)
-- CategoryTheory.Equivalence.Equivalence_mk'_unit
@[simp]
theorem Equivalence_mk'_unit (functor inverse unit_iso counit_iso f) :
    (⟨functor, inverse, unit_iso, counit_iso, f⟩ : C ≌ D).unit = unit_iso.hom 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [CategoryTheory.Category.{v₂, u₂} D] (functor : CategoryTheory.Functor C D) (inverse : CategoryTheory.Functor D C) (unit_iso : CategoryTheory.Functor.id C ≅ functor.comp inverse) (counit_iso : inverse.comp functor ≅ CategoryTheory.Functor.id D) (f :
  ∀ (X : C),
    CategoryTheory.CategoryStruct.comp (functor.map (unit_iso.hom.app X)) (counit_iso.hom.app (functor.obj X)) =
      CategoryTheory.CategoryStruct.id (functor.obj X))
Goal: { functor := functor, inverse := inverse, unitIso := unit_iso, counitIso := counit_iso,
      functor_unitIso_comp := f }.unit =
  unit_iso.hom
-- CategoryTheory.Equivalence.Equivalence_mk'_counit
@[simp]
theorem Equivalence_mk'_counit (functor inverse unit_iso counit_iso f) :
    (⟨functor, inverse, unit_iso, counit_iso, f⟩ : C ≌ D).counit = counit_iso.hom 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [CategoryTheory.Category.{v₂, u₂} D] (functor : CategoryTheory.Functor C D) (inverse : CategoryTheory.Functor D C) (unit_iso : CategoryTheory.Functor.id C ≅ functor.comp inverse) (counit_iso : inverse.comp functor ≅ CategoryTheory.Functor.id D) (f :
  ∀ (X : C),
    CategoryTheory.CategoryStruct.comp (functor.map (unit_iso.hom.app X)) (counit_iso.hom.app (functor.obj X)) =
      CategoryTheory.CategoryStruct.id (functor.obj X))
Goal: { functor := functor, inverse := inverse, unitIso := unit_iso, counitIso := counit_iso,
      functor_unitIso_comp := f }.counit =
  counit_iso.hom
-- CategoryTheory.Equivalence.Equivalence_mk'_unitInv
@[simp]
theorem Equivalence_mk'_unitInv (functor inverse unit_iso counit_iso f) :
    (⟨functor, inverse, unit_iso, counit_iso, f⟩ : C ≌ D).unitInv = unit_iso.inv 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [CategoryTheory.Category.{v₂, u₂} D] (functor : CategoryTheory.Functor C D) (inverse : CategoryTheory.Functor D C) (unit_iso : CategoryTheory.Functor.id C ≅ functor.comp inverse) (counit_iso : inverse.comp functor ≅ CategoryTheory.Functor.id D) (f :
  ∀ (X : C),
    CategoryTheory.CategoryStruct.comp (functor.map (unit_iso.hom.app X)) (counit_iso.hom.app (functor.obj X)) =
      CategoryTheory.CategoryStruct.id (functor.obj X))
Goal: { functor := functor, inverse := inverse, unitIso := unit_iso, counitIso := counit_iso,
      functor_unitIso_comp := f }.unitInv =
  unit_iso.inv
-- CategoryTheory.Equivalence.Equivalence_mk'_counitInv
@[simp]
theorem Equivalence_mk'_counitInv (functor inverse unit_iso counit_iso f) :
    (⟨functor, inverse, unit_iso, counit_iso, f⟩ : C ≌ D).counitInv = counit_iso.inv 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [CategoryTheory.Category.{v₂, u₂} D] (functor : CategoryTheory.Functor C D) (inverse : CategoryTheory.Functor D C) (unit_iso : CategoryTheory.Functor.id C ≅ functor.comp inverse) (counit_iso : inverse.comp functor ≅ CategoryTheory.Functor.id D) (f :
  ∀ (X : C),
    CategoryTheory.CategoryStruct.comp (functor.map (unit_iso.hom.app X)) (counit_iso.hom.app (functor.obj X)) =
      CategoryTheory.CategoryStruct.id (functor.obj X))
Goal: { functor := functor, inverse := inverse, unitIso := unit_iso, counitIso := counit_iso,
      functor_unitIso_comp := f }.counitInv =
  counit_iso.inv
-- CategoryTheory.Equivalence.functor_unit_comp
@[reassoc (attr := simp)]
theorem functor_unit_comp (e : C ≌ D) (X : C) :
    e.functor.map (e.unit.app X) ≫ e.counit.app (e.functor.obj X) = 𝟙 (e.functor.obj X) 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [CategoryTheory.Category.{v₂, u₂} D] (e : C ≌ D) (X : C)
Goal: CategoryTheory.CategoryStruct.comp (e.functor.map (e.unit.app X)) (e.counit.app (e.functor.obj X)) =
  CategoryTheory.CategoryStruct.id (e.functor.obj X)
-- CategoryTheory.Equivalence.counitInv_functor_comp
@[reassoc (attr := simp)]
theorem counitInv_functor_comp (e : C ≌ D) (X : C) :
    e.counitInv.app (e.functor.obj X) ≫ e.functor.map (e.unitInv.app X) = 𝟙 (e.functor.obj X) 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [CategoryTheory.Category.{v₂, u₂} D] (e : C ≌ D) (X : C)
Goal: CategoryTheory.CategoryStruct.comp (e.counitInv.app (e.functor.obj X)) (e.functor.map (e.unitInv.app X)) =
  CategoryTheory.CategoryStruct.id (e.functor.obj X)
-- CategoryTheory.Equivalence.counitInv_app_functor
theorem counitInv_app_functor (e : C ≌ D) (X : C) :
    e.counitInv.app (e.functor.obj X) = e.functor.map (e.unit.app X) 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [CategoryTheory.Category.{v₂, u₂} D] (e : C ≌ D) (X : C)
Goal: e.counitInv.app (e.functor.obj X) = e.functor.map (e.unit.app X)
-- CategoryTheory.Equivalence.counit_app_functor
theorem counit_app_functor (e : C ≌ D) (X : C) :
    e.counit.app (e.functor.obj X) = e.functor.map (e.unitInv.app X) 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [CategoryTheory.Category.{v₂, u₂} D] (e : C ≌ D) (X : C)
Goal: e.counit.app (e.functor.obj X) = e.functor.map (e.unitInv.app X)
-- CategoryTheory.Equivalence.unit_inverse_comp
@[reassoc (attr := simp)]
theorem unit_inverse_comp (e : C ≌ D) (Y : D) :
    e.unit.app (e.inverse.obj Y) ≫ e.inverse.map (e.counit.app Y) = 𝟙 (e.inverse.obj Y) 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [CategoryTheory.Category.{v₂, u₂} D] (e : C ≌ D) (Y : D)
Goal: CategoryTheory.CategoryStruct.comp (e.unit.app (e.inverse.obj Y)) (e.inverse.map (e.counit.app Y)) =
  CategoryTheory.CategoryStruct.id (e.inverse.obj Y)
-- CategoryTheory.Equivalence.inverse_counitInv_comp
@[reassoc (attr := simp)]
theorem inverse_counitInv_comp (e : C ≌ D) (Y : D) :
    e.inverse.map (e.counitInv.app Y) ≫ e.unitInv.app (e.inverse.obj Y) = 𝟙 (e.inverse.obj Y) 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [CategoryTheory.Category.{v₂, u₂} D] (e : C ≌ D) (Y : D)
Goal: CategoryTheory.CategoryStruct.comp (e.inverse.map (e.counitInv.app Y)) (e.unitInv.app (e.inverse.obj Y)) =
  CategoryTheory.CategoryStruct.id (e.inverse.obj Y)
-- CategoryTheory.Equivalence.unit_app_inverse
theorem unit_app_inverse (e : C ≌ D) (Y : D) :
    e.unit.app (e.inverse.obj Y) = e.inverse.map (e.counitInv.app Y) 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [CategoryTheory.Category.{v₂, u₂} D] (e : C ≌ D) (Y : D)
Goal: e.unit.app (e.inverse.obj Y) = e.inverse.map (e.counitInv.app Y)
-- CategoryTheory.Equivalence.unitInv_app_inverse
theorem unitInv_app_inverse (e : C ≌ D) (Y : D) :
    e.unitInv.app (e.inverse.obj Y) = e.inverse.map (e.counit.app Y) 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [CategoryTheory.Category.{v₂, u₂} D] (e : C ≌ D) (Y : D)
Goal: e.unitInv.app (e.inverse.obj Y) = e.inverse.map (e.counit.app Y)
-- CategoryTheory.Equivalence.fun_inv_map
@[reassoc, simp]
theorem fun_inv_map (e : C ≌ D) (X Y : D) (f : X ⟶ Y) :
    e.functor.map (e.inverse.map f) = e.counit.app X ≫ f ≫ e.counitInv.app Y 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [CategoryTheory.Category.{v₂, u₂} D] (e : C ≌ D) (X Y : D) (f : X ⟶ Y)
Goal: e.functor.map (e.inverse.map f) =
  CategoryTheory.CategoryStruct.comp (e.counit.app X) (CategoryTheory.CategoryStruct.comp f (e.counitInv.app Y))
-- CategoryTheory.Equivalence.inv_fun_map
@[reassoc, simp]
theorem inv_fun_map (e : C ≌ D) (X Y : C) (f : X ⟶ Y) :
    e.inverse.map (e.functor.map f) = e.unitInv.app X ≫ f ≫ e.unit.app Y 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [CategoryTheory.Category.{v₂, u₂} D] (e : C ≌ D) (X Y : C) (f : X ⟶ Y)
Goal: e.inverse.map (e.functor.map f) =
  CategoryTheory.CategoryStruct.comp (e.unitInv.app X) (CategoryTheory.CategoryStruct.comp f (e.unit.app Y))
-- CategoryTheory.Equivalence.adjointify_η_ε
@[reassoc]
theorem adjointify_η_ε (X : C) :
    F.map ((adjointifyη η ε).hom.app X) ≫ ε.hom.app (F.obj X) = 𝟙 (F.obj X) 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [CategoryTheory.Category.{v₂, u₂} D] {F : CategoryTheory.Functor C D} {G : CategoryTheory.Functor D C} (η : CategoryTheory.Functor.id C ≅ F.comp G) (ε : G.comp F ≅ CategoryTheory.Functor.id D) (X : C)
Goal: CategoryTheory.CategoryStruct.comp (F.map ((CategoryTheory.Equivalence.adjointifyη η ε).hom.app X))
    (ε.hom.app (F.obj X)) =
  CategoryTheory.CategoryStruct.id (F.obj X)
-- CategoryTheory.Equivalence.refl_unitIso
@[refl, simps]
def refl : C ≌ C 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C]
Goal: CategoryTheory.Equivalence.refl.unitIso = CategoryTheory.Iso.refl (CategoryTheory.Functor.id C)
-- CategoryTheory.Equivalence.refl_inverse
@[refl, simps]
def refl : C ≌ C 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C]
Goal: CategoryTheory.Equivalence.refl.inverse = CategoryTheory.Functor.id C
-- CategoryTheory.Equivalence.refl_counitIso
@[refl, simps]
def refl : C ≌ C 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C]
Goal: CategoryTheory.Equivalence.refl.counitIso =
  CategoryTheory.Iso.refl ((CategoryTheory.Functor.id C).comp (CategoryTheory.Functor.id C))
-- CategoryTheory.Equivalence.refl_functor
@[refl, simps]
def refl : C ≌ C 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C]
Goal: CategoryTheory.Equivalence.refl.functor = CategoryTheory.Functor.id C
-- CategoryTheory.Equivalence.symm_unitIso
@[symm, simps]
def symm (e : C ≌ D) : D ≌ C 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [CategoryTheory.Category.{v₂, u₂} D] (e : C ≌ D)
Goal: e.symm.unitIso = e.counitIso.symm
-- CategoryTheory.Equivalence.symm_counitIso
@[symm, simps]
def symm (e : C ≌ D) : D ≌ C 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [CategoryTheory.Category.{v₂, u₂} D] (e : C ≌ D)
Goal: e.symm.counitIso = e.unitIso.symm
-- CategoryTheory.Equivalence.symm_functor
@[symm, simps]
def symm (e : C ≌ D) : D ≌ C 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [CategoryTheory.Category.{v₂, u₂} D] (e : C ≌ D)
Goal: e.symm.functor = e.inverse
-- CategoryTheory.Equivalence.symm_inverse
@[symm, simps]
def symm (e : C ≌ D) : D ≌ C 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [CategoryTheory.Category.{v₂, u₂} D] (e : C ≌ D)
Goal: e.symm.inverse = e.functor
-- CategoryTheory.Equivalence.trans_unitIso
@[trans, simps]
def trans (e : C ≌ D) (f : D ≌ E) : C ≌ E 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [CategoryTheory.Category.{v₂, u₂} D] {E : Type u₃} [CategoryTheory.Category.{v₃, u₃} E] (e : C ≌ D) (f : D ≌ E)
Goal: (e.trans f).unitIso =
  e.unitIso ≪≫ CategoryTheory.isoWhiskerLeft e.functor (CategoryTheory.isoWhiskerRight f.unitIso e.inverse)
-- CategoryTheory.Equivalence.trans_inverse
@[trans, simps]
def trans (e : C ≌ D) (f : D ≌ E) : C ≌ E 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [CategoryTheory.Category.{v₂, u₂} D] {E : Type u₃} [CategoryTheory.Category.{v₃, u₃} E] (e : C ≌ D) (f : D ≌ E)
Goal: (e.trans f).inverse = f.inverse.comp e.inverse
-- CategoryTheory.Equivalence.trans_functor
@[trans, simps]
def trans (e : C ≌ D) (f : D ≌ E) : C ≌ E 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [CategoryTheory.Category.{v₂, u₂} D] {E : Type u₃} [CategoryTheory.Category.{v₃, u₃} E] (e : C ≌ D) (f : D ≌ E)
Goal: (e.trans f).functor = e.functor.comp f.functor
-- CategoryTheory.Equivalence.trans_counitIso
@[trans, simps]
def trans (e : C ≌ D) (f : D ≌ E) : C ≌ E 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [CategoryTheory.Category.{v₂, u₂} D] {E : Type u₃} [CategoryTheory.Category.{v₃, u₃} E] (e : C ≌ D) (f : D ≌ E)
Goal: (e.trans f).counitIso =
  CategoryTheory.isoWhiskerLeft f.inverse (CategoryTheory.isoWhiskerRight e.counitIso f.functor) ≪≫ f.counitIso
-- CategoryTheory.Equivalence.funInvIdAssoc_hom_app
@[simp]
theorem funInvIdAssoc_hom_app (e : C ≌ D) (F : C ⥤ E) (X : C) :
    (funInvIdAssoc e F).hom.app X = F.map (e.unitInv.app X) 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [CategoryTheory.Category.{v₂, u₂} D] {E : Type u₃} [CategoryTheory.Category.{v₃, u₃} E] (e : C ≌ D) (F : CategoryTheory.Functor C E) (X : C)
Goal: (e.funInvIdAssoc F).hom.app X = F.map (e.unitInv.app X)
-- CategoryTheory.Equivalence.funInvIdAssoc_inv_app
@[simp]
theorem funInvIdAssoc_inv_app (e : C ≌ D) (F : C ⥤ E) (X : C) :
    (funInvIdAssoc e F).inv.app X = F.map (e.unit.app X) 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [CategoryTheory.Category.{v₂, u₂} D] {E : Type u₃} [CategoryTheory.Category.{v₃, u₃} E] (e : C ≌ D) (F : CategoryTheory.Functor C E) (X : C)
Goal: (e.funInvIdAssoc F).inv.app X = F.map (e.unit.app X)