ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
-- CategoryTheory.Adjunction.adjunctionOfEquivLeft_counit_app
@[simps!]
def adjunctionOfEquivLeft : leftAdjointOfEquiv e he ⊣ G 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [CategoryTheory.Category.{v₂, u₂} D] {G : CategoryTheory.Functor D C} {F_obj : C → D} (e : (X : C) → (Y : D) → (F_obj X ⟶ Y) ≃ (X ⟶ G.obj Y)) (he :
  ∀ (X : C) (Y Y' : D) (g : Y ⟶ Y') (h : F_obj X ⟶ Y),
    (e X Y') (CategoryTheory.CategoryStruct.comp h g) = CategoryTheory.CategoryStruct.comp ((e X Y) h) (G.map g)) (Y : D)
Goal: (CategoryTheory.Adjunction.adjunctionOfEquivLeft e he).counit.app Y =
  (e (G.obj Y) Y).symm (CategoryTheory.CategoryStruct.id (G.obj Y))
-- CategoryTheory.Adjunction.adjunctionOfEquivLeft_unit_app
@[simps!]
def adjunctionOfEquivLeft : leftAdjointOfEquiv e he ⊣ G 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [CategoryTheory.Category.{v₂, u₂} D] {G : CategoryTheory.Functor D C} {F_obj : C → D} (e : (X : C) → (Y : D) → (F_obj X ⟶ Y) ≃ (X ⟶ G.obj Y)) (he :
  ∀ (X : C) (Y Y' : D) (g : Y ⟶ Y') (h : F_obj X ⟶ Y),
    (e X Y') (CategoryTheory.CategoryStruct.comp h g) = CategoryTheory.CategoryStruct.comp ((e X Y) h) (G.map g)) (X : C)
Goal: (CategoryTheory.Adjunction.adjunctionOfEquivLeft e he).unit.app X =
  (e X (F_obj X)) (CategoryTheory.CategoryStruct.id (F_obj X))
-- CategoryTheory.Adjunction.adjunctionOfEquivLeft_homEquiv
@[simps!]
def adjunctionOfEquivLeft : leftAdjointOfEquiv e he ⊣ G 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [CategoryTheory.Category.{v₂, u₂} D] {G : CategoryTheory.Functor D C} {F_obj : C → D} (e : (X : C) → (Y : D) → (F_obj X ⟶ Y) ≃ (X ⟶ G.obj Y)) (he :
  ∀ (X : C) (Y Y' : D) (g : Y ⟶ Y') (h : F_obj X ⟶ Y),
    (e X Y') (CategoryTheory.CategoryStruct.comp h g) = CategoryTheory.CategoryStruct.comp ((e X Y) h) (G.map g)) (X : C) (Y : D)
Goal: (CategoryTheory.Adjunction.adjunctionOfEquivLeft e he).homEquiv X Y = e X Y
-- _private.Mathlib.CategoryTheory.Adjunction.Basic.0.CategoryTheory.Adjunction.he''
private theorem he'' (he : ∀ X' X Y f g, e X' Y (F.map f ≫ g) = f ≫ e X Y g)
    {X' X Y} (f g) : F.map f ≫ (e X Y).symm g = (e X' Y).symm (f ≫ g) 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [CategoryTheory.Category.{v₂, u₂} D] {F : CategoryTheory.Functor C D} {G_obj : D → C} (e : (X : C) → (Y : D) → (F.obj X ⟶ Y) ≃ (X ⟶ G_obj Y)) (he :
  ∀ (X' X : C) (Y : D) (f : X' ⟶ X) (g : F.obj X ⟶ Y),
    (e X' Y) (CategoryTheory.CategoryStruct.comp (F.map f) g) = CategoryTheory.CategoryStruct.comp f ((e X Y) g)) {X' X : C} {Y : D} (f : X' ⟶ X) (g : X ⟶ G_obj Y)
Goal: CategoryTheory.CategoryStruct.comp (F.map f) ((e X Y).symm g) = (e X' Y).symm (CategoryTheory.CategoryStruct.comp f g)
-- CategoryTheory.Adjunction.rightAdjointOfEquiv_map
@[simps!]
def rightAdjointOfEquiv (he : ∀ X' X Y f g, e X' Y (F.map f ≫ g) = f ≫ e X Y g) : D ⥤ C 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [CategoryTheory.Category.{v₂, u₂} D] {F : CategoryTheory.Functor C D} {G_obj : D → C} (e : (X : C) → (Y : D) → (F.obj X ⟶ Y) ≃ (X ⟶ G_obj Y)) (he :
  ∀ (X' X : C) (Y : D) (f : X' ⟶ X) (g : F.obj X ⟶ Y),
    (e X' Y) (CategoryTheory.CategoryStruct.comp (F.map f) g) = CategoryTheory.CategoryStruct.comp f ((e X Y) g)) {Y Y' : D} (g : Y ⟶ Y')
Goal: (CategoryTheory.Adjunction.rightAdjointOfEquiv e he).map g =
  (e (G_obj Y) Y')
    (CategoryTheory.CategoryStruct.comp ((e (G_obj Y) Y).symm (CategoryTheory.CategoryStruct.id (G_obj Y))) g)
-- CategoryTheory.Adjunction.rightAdjointOfEquiv_obj
@[simps!]
def rightAdjointOfEquiv (he : ∀ X' X Y f g, e X' Y (F.map f ≫ g) = f ≫ e X Y g) : D ⥤ C 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [CategoryTheory.Category.{v₂, u₂} D] {F : CategoryTheory.Functor C D} {G_obj : D → C} (e : (X : C) → (Y : D) → (F.obj X ⟶ Y) ≃ (X ⟶ G_obj Y)) (he :
  ∀ (X' X : C) (Y : D) (f : X' ⟶ X) (g : F.obj X ⟶ Y),
    (e X' Y) (CategoryTheory.CategoryStruct.comp (F.map f) g) = CategoryTheory.CategoryStruct.comp f ((e X Y) g))
Goal: ∀ (a : D), (CategoryTheory.Adjunction.rightAdjointOfEquiv e he).obj a = G_obj a
-- CategoryTheory.Adjunction.adjunctionOfEquivRight_unit_app
@[simps!]
def adjunctionOfEquivRight (he : ∀ X' X Y f g, e X' Y (F.map f ≫ g) = f ≫ e X Y g) :
    F ⊣ (rightAdjointOfEquiv e he) 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [CategoryTheory.Category.{v₂, u₂} D] {F : CategoryTheory.Functor C D} {G_obj : D → C} (e : (X : C) → (Y : D) → (F.obj X ⟶ Y) ≃ (X ⟶ G_obj Y)) (he :
  ∀ (X' X : C) (Y : D) (f : X' ⟶ X) (g : F.obj X ⟶ Y),
    (e X' Y) (CategoryTheory.CategoryStruct.comp (F.map f) g) = CategoryTheory.CategoryStruct.comp f ((e X Y) g)) (X : C)
Goal: (CategoryTheory.Adjunction.adjunctionOfEquivRight e he).unit.app X =
  (e X (F.obj X)) (CategoryTheory.CategoryStruct.id (F.obj X))
-- CategoryTheory.Adjunction.adjunctionOfEquivRight_counit_app
@[simps!]
def adjunctionOfEquivRight (he : ∀ X' X Y f g, e X' Y (F.map f ≫ g) = f ≫ e X Y g) :
    F ⊣ (rightAdjointOfEquiv e he) 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [CategoryTheory.Category.{v₂, u₂} D] {F : CategoryTheory.Functor C D} {G_obj : D → C} (e : (X : C) → (Y : D) → (F.obj X ⟶ Y) ≃ (X ⟶ G_obj Y)) (he :
  ∀ (X' X : C) (Y : D) (f : X' ⟶ X) (g : F.obj X ⟶ Y),
    (e X' Y) (CategoryTheory.CategoryStruct.comp (F.map f) g) = CategoryTheory.CategoryStruct.comp f ((e X Y) g)) (Y : D)
Goal: (CategoryTheory.Adjunction.adjunctionOfEquivRight e he).counit.app Y =
  (e (G_obj Y) Y).symm (CategoryTheory.CategoryStruct.id (G_obj Y))
-- CategoryTheory.Adjunction.adjunctionOfEquivRight_homEquiv
@[simps!]
def adjunctionOfEquivRight (he : ∀ X' X Y f g, e X' Y (F.map f ≫ g) = f ≫ e X Y g) :
    F ⊣ (rightAdjointOfEquiv e he) 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [CategoryTheory.Category.{v₂, u₂} D] {F : CategoryTheory.Functor C D} {G_obj : D → C} (e : (X : C) → (Y : D) → (F.obj X ⟶ Y) ≃ (X ⟶ G_obj Y)) (he :
  ∀ (X' X : C) (Y : D) (f : X' ⟶ X) (g : F.obj X ⟶ Y),
    (e X' Y) (CategoryTheory.CategoryStruct.comp (F.map f) g) = CategoryTheory.CategoryStruct.comp f ((e X Y) g)) (X : C) (Y : D)
Goal: (CategoryTheory.Adjunction.adjunctionOfEquivRight e he).homEquiv X Y = e X Y
-- CategoryTheory.Adjunction.toEquivalence_functor
@[simps!]
noncomputable def toEquivalence (adj : F ⊣ G) [∀ X, IsIso (adj.unit.app X)]
    [∀ Y, IsIso (adj.counit.app Y)] : C ≌ D 
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} (adj : F ⊣ G) [∀ (X : C), CategoryTheory.IsIso (adj.unit.app X)] [∀ (Y : D), CategoryTheory.IsIso (adj.counit.app Y)]
Goal: adj.toEquivalence.functor = F
-- CategoryTheory.Adjunction.toEquivalence_unitIso_inv_app
@[simps!]
noncomputable def toEquivalence (adj : F ⊣ G) [∀ X, IsIso (adj.unit.app X)]
    [∀ Y, IsIso (adj.counit.app Y)] : C ≌ D 
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} (adj : F ⊣ G) [∀ (X : C), CategoryTheory.IsIso (adj.unit.app X)] [∀ (Y : D), CategoryTheory.IsIso (adj.counit.app Y)] (X : C)
Goal: adj.toEquivalence.unitIso.inv.app X = CategoryTheory.inv (adj.unit.app X)
-- CategoryTheory.Adjunction.toEquivalence_counitIso_inv_app
@[simps!]
noncomputable def toEquivalence (adj : F ⊣ G) [∀ X, IsIso (adj.unit.app X)]
    [∀ Y, IsIso (adj.counit.app Y)] : C ≌ D 
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} (adj : F ⊣ G) [∀ (X : C), CategoryTheory.IsIso (adj.unit.app X)] [∀ (Y : D), CategoryTheory.IsIso (adj.counit.app Y)] (X : D)
Goal: adj.toEquivalence.counitIso.inv.app X = CategoryTheory.inv (adj.counit.app X)
-- CategoryTheory.Adjunction.toEquivalence_inverse
@[simps!]
noncomputable def toEquivalence (adj : F ⊣ G) [∀ X, IsIso (adj.unit.app X)]
    [∀ Y, IsIso (adj.counit.app Y)] : C ≌ D 
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} (adj : F ⊣ G) [∀ (X : C), CategoryTheory.IsIso (adj.unit.app X)] [∀ (Y : D), CategoryTheory.IsIso (adj.counit.app Y)]
Goal: adj.toEquivalence.inverse = G
-- CategoryTheory.Adjunction.toEquivalence_unitIso_hom_app
@[simps!]
noncomputable def toEquivalence (adj : F ⊣ G) [∀ X, IsIso (adj.unit.app X)]
    [∀ Y, IsIso (adj.counit.app Y)] : C ≌ D 
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} (adj : F ⊣ G) [∀ (X : C), CategoryTheory.IsIso (adj.unit.app X)] [∀ (Y : D), CategoryTheory.IsIso (adj.counit.app Y)] (X : C)
Goal: adj.toEquivalence.unitIso.hom.app X = adj.unit.app X
-- CategoryTheory.Adjunction.toEquivalence_counitIso_hom_app
@[simps!]
noncomputable def toEquivalence (adj : F ⊣ G) [∀ X, IsIso (adj.unit.app X)]
    [∀ Y, IsIso (adj.counit.app Y)] : C ≌ D 
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} (adj : F ⊣ G) [∀ (X : C), CategoryTheory.IsIso (adj.unit.app X)] [∀ (Y : D), CategoryTheory.IsIso (adj.counit.app Y)] (X : D)
Goal: adj.toEquivalence.counitIso.hom.app X = adj.counit.app X
-- CategoryTheory.Functor.isEquivalence_of_isRightAdjoint
lemma Functor.isEquivalence_of_isRightAdjoint (G : C ⥤ D) [IsRightAdjoint G]
    [∀ X, IsIso ((Adjunction.ofIsRightAdjoint G).unit.app X)]
    [∀ Y, IsIso ((Adjunction.ofIsRightAdjoint G).counit.app Y)] : G.IsEquivalence 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [CategoryTheory.Category.{v₂, u₂} D] (G : CategoryTheory.Functor C D) [G.IsRightAdjoint] [∀ (X : D), CategoryTheory.IsIso ((CategoryTheory.Adjunction.ofIsRightAdjoint G).unit.app X)] [∀ (Y : C), CategoryTheory.IsIso ((CategoryTheory.Adjunction.ofIsRightAdjoint G).counit.app Y)]
Goal: G.IsEquivalence
-- CategoryTheory.Equivalence.toAdjunction_counit
@[simps! unit counit]
def toAdjunction : e.functor ⊣ e.inverse 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [CategoryTheory.Category.{v₂, u₂} D] (e : C ≌ D)
Goal: e.toAdjunction.counit = e.counit
-- CategoryTheory.Equivalence.toAdjunction_unit
@[simps! unit counit]
def toAdjunction : e.functor ⊣ e.inverse 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [CategoryTheory.Category.{v₂, u₂} D] (e : C ≌ D)
Goal: e.toAdjunction.unit = e.unit
-- CategoryTheory.Equivalence.isLeftAdjoint_functor
lemma isLeftAdjoint_functor : e.functor.IsLeftAdjoint 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [CategoryTheory.Category.{v₂, u₂} D] (e : C ≌ D)
Goal: e.functor.IsLeftAdjoint
-- CategoryTheory.Equivalence.isRightAdjoint_inverse
lemma isRightAdjoint_inverse : e.inverse.IsRightAdjoint 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [CategoryTheory.Category.{v₂, u₂} D] (e : C ≌ D)
Goal: e.inverse.IsRightAdjoint
-- CategoryTheory.Equivalence.isLeftAdjoint_inverse
lemma isLeftAdjoint_inverse : e.inverse.IsLeftAdjoint 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [CategoryTheory.Category.{v₂, u₂} D] (e : C ≌ D)
Goal: e.inverse.IsLeftAdjoint
-- CategoryTheory.Equivalence.isRightAdjoint_functor
lemma isRightAdjoint_functor : e.functor.IsRightAdjoint 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [CategoryTheory.Category.{v₂, u₂} D] (e : C ≌ D)
Goal: e.functor.IsRightAdjoint
-- CategoryTheory.Functor.isRightAdjoint_of_iso
lemma isRightAdjoint_of_iso {F G : C ⥤ D} (h : F ≅ G) [F.IsRightAdjoint] :
    IsRightAdjoint G 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [CategoryTheory.Category.{v₂, u₂} D] {F G : CategoryTheory.Functor C D} (h : F ≅ G) [F.IsRightAdjoint]
Goal: G.IsRightAdjoint
-- CategoryTheory.Functor.isLeftAdjoint_of_iso
lemma isLeftAdjoint_of_iso {F G : C ⥤ D} (h : F ≅ G) [IsLeftAdjoint F] :
    IsLeftAdjoint G 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [CategoryTheory.Category.{v₂, u₂} D] {F G : CategoryTheory.Functor C D} (h : F ≅ G) [F.IsLeftAdjoint]
Goal: G.IsLeftAdjoint
-- CategoryTheory.effectiveEpiFamilyStructOfEffectiveEpiDesc_aux
theorem effectiveEpiFamilyStructOfEffectiveEpiDesc_aux {B : C} {α : Type*} {X : α → C}
    {π : (a : α) → X a ⟶ B} [HasCoproduct X]
    [∀ {Z : C} (g : Z ⟶ ∐ X) (a : α), HasPullback g (Sigma.ι X a)]
    [∀ {Z : C} (g : Z ⟶ ∐ X), HasCoproduct fun a ↦ pullback g (Sigma.ι X a)]
    [∀ {Z : C} (g : Z ⟶ ∐ X), Epi (Sigma.desc fun a ↦ pullback.fst g (Sigma.ι X a))]
    {W : C} {e : (a : α) → X a ⟶ W} (h : ∀ {Z : C} (a₁ a₂ : α) (g₁ : Z ⟶ X a₁) (g₂ : Z ⟶ X a₂),
      g₁ ≫ π a₁ = g₂ ≫ π a₂ → g₁ ≫ e a₁ = g₂ ≫ e a₂) {Z : C}
    {g₁ g₂ : Z ⟶ ∐ fun b ↦ X b} (hg : g₁ ≫ Sigma.desc π = g₂ ≫ Sigma.desc π) :
    g₁ ≫ Sigma.desc e = g₂ ≫ Sigma.desc e 
Arguments: {C : Type u_1} [CategoryTheory.Category.{u_3, u_1} C] {B : C} {α : Type u_2} {X : α → C} {π : (a : α) → X a ⟶ B} [CategoryTheory.Limits.HasCoproduct X] [∀ {Z : C} (g : Z ⟶ ∐ X) (a : α), CategoryTheory.Limits.HasPullback g (CategoryTheory.Limits.Sigma.ι X a)] [∀ {Z : C} (g : Z ⟶ ∐ X),
    CategoryTheory.Limits.HasCoproduct fun a => CategoryTheory.Limits.pullback g (CategoryTheory.Limits.Sigma.ι X a)] [∀ {Z : C} (g : Z ⟶ ∐ X),
    CategoryTheory.Epi
      (CategoryTheory.Limits.Sigma.desc fun a =>
        CategoryTheory.Limits.pullback.fst g (CategoryTheory.Limits.Sigma.ι X a))] {W : C} {e : (a : α) → X a ⟶ W} (h :
  ∀ {Z : C} (a₁ a₂ : α) (g₁ : Z ⟶ X a₁) (g₂ : Z ⟶ X a₂),
    CategoryTheory.CategoryStruct.comp g₁ (π a₁) = CategoryTheory.CategoryStruct.comp g₂ (π a₂) →
      CategoryTheory.CategoryStruct.comp g₁ (e a₁) = CategoryTheory.CategoryStruct.comp g₂ (e a₂)) {Z : C} {g₁ g₂ : Z ⟶ ∐ fun b => X b} (hg :
  CategoryTheory.CategoryStruct.comp g₁ (CategoryTheory.Limits.Sigma.desc π) =
    CategoryTheory.CategoryStruct.comp g₂ (CategoryTheory.Limits.Sigma.desc π))
Goal: CategoryTheory.CategoryStruct.comp g₁ (CategoryTheory.Limits.Sigma.desc e) =
  CategoryTheory.CategoryStruct.comp g₂ (CategoryTheory.Limits.Sigma.desc e)
-- CategoryTheory.Groupoid.comp_inv
class Groupoid (obj : Type u) extends Category.{v} obj : Type max u (v + 1) where
    inv : ∀ {X Y : obj}, (X ⟶ Y) → (Y ⟶ X)
    inv_comp : ∀ {X Y : obj} (f : X ⟶ Y), comp (inv f) f = id Y := by aesop_cat
    comp_inv : ∀ {X Y : obj} (f : X ⟶ Y), comp f (inv f) = id X := by aesop_cat
Arguments: {obj : Type u} [self : CategoryTheory.Groupoid obj] {X Y : obj} (f : X ⟶ Y)
Goal: CategoryTheory.CategoryStruct.comp f (CategoryTheory.Groupoid.inv f) = CategoryTheory.CategoryStruct.id X
-- CategoryTheory.Groupoid.inv_comp
class Groupoid (obj : Type u) extends Category.{v} obj : Type max u (v + 1) where
    inv : ∀ {X Y : obj}, (X ⟶ Y) → (Y ⟶ X)
    inv_comp : ∀ {X Y : obj} (f : X ⟶ Y), comp (inv f) f = id Y := by aesop_cat
    comp_inv : ∀ {X Y : obj} (f : X ⟶ Y), comp f (inv f) = id X := by aesop_cat
Arguments: {obj : Type u} [self : CategoryTheory.Groupoid obj] {X Y : obj} (f : X ⟶ Y)
Goal: CategoryTheory.CategoryStruct.comp (CategoryTheory.Groupoid.inv f) f = CategoryTheory.CategoryStruct.id Y
-- CategoryTheory.Groupoid.inv_eq_inv
@[simp]
theorem Groupoid.inv_eq_inv (f : X ⟶ Y) : Groupoid.inv f = CategoryTheory.inv f 
Arguments: {C : Type u} [CategoryTheory.Groupoid C] {X Y : C} (f : X ⟶ Y)
Goal: CategoryTheory.Groupoid.inv f = CategoryTheory.inv f
-- CategoryTheory.Groupoid.invEquiv_apply
@[simps]
def Groupoid.invEquiv : (X ⟶ Y) ≃ (Y ⟶ X) 
Arguments: {C : Type u} [CategoryTheory.Groupoid C] {X Y : C}
Goal: ∀ (a : X ⟶ Y), CategoryTheory.Groupoid.invEquiv a = CategoryTheory.Groupoid.inv a
-- CategoryTheory.Groupoid.invEquiv_symm_apply
@[simps]
def Groupoid.invEquiv : (X ⟶ Y) ≃ (Y ⟶ X) 
Arguments: {C : Type u} [CategoryTheory.Groupoid C] {X Y : C}
Goal: ∀ (a : Y ⟶ X), CategoryTheory.Groupoid.invEquiv.symm a = CategoryTheory.Groupoid.inv a
-- CategoryTheory.Groupoid.reverse_eq_inv
@[simp]
theorem Groupoid.reverse_eq_inv (f : X ⟶ Y) : Quiver.reverse f = Groupoid.inv f 
Arguments: {C : Type u} [CategoryTheory.Groupoid C] {X Y : C} (f : X ⟶ Y)
Goal: Quiver.reverse f = CategoryTheory.Groupoid.inv f
-- CategoryTheory.Groupoid.invFunctor_obj
@[simps]
noncomputable def Groupoid.invFunctor : C ⥤ Cᵒᵖ 
Arguments: (C : Type u) [CategoryTheory.Groupoid C] (unop : C)
Goal: (CategoryTheory.Groupoid.invFunctor C).obj unop = Opposite.op unop
-- CategoryTheory.Groupoid.invFunctor_map
@[simps]
noncomputable def Groupoid.invFunctor : C ⥤ Cᵒᵖ 
Arguments: (C : Type u) [CategoryTheory.Groupoid C] {X Y : C} (f : X ⟶ Y)
Goal: (CategoryTheory.Groupoid.invFunctor C).map f = (CategoryTheory.Groupoid.inv f).op
-- CategoryTheory.Sigma.SigmaHom.comp_def
@[simp]
lemma comp_def (i : I) (X Y Z : C i) (f : X ⟶ Y) (g : Y ⟶ Z) : comp (mk f) (mk g) = mk (f ≫ g) 
Arguments: {I : Type w₁} {C : I → Type u₁} [(i : I) → CategoryTheory.Category.{v₁, u₁} (C i)] (i : I) (X Y Z : C i) (f : X ⟶ Y) (g : Y ⟶ Z)
Goal: (CategoryTheory.Sigma.SigmaHom.mk f).comp (CategoryTheory.Sigma.SigmaHom.mk g) =
  CategoryTheory.Sigma.SigmaHom.mk (CategoryTheory.CategoryStruct.comp f g)
-- CategoryTheory.Sigma.SigmaHom.assoc
lemma assoc : ∀ {X Y Z W : Σi, C i} (f : X ⟶ Y) (g : Y ⟶ Z) (h : Z ⟶ W), (f ≫ g) ≫ h = f ≫ g ≫ h
  
Arguments: {I : Type w₁} {C : I → Type u₁} [(i : I) → CategoryTheory.Category.{v₁, u₁} (C i)] {X Y Z W : (i : I) × C i} (f : X ⟶ Y) (g : Y ⟶ Z) (h : Z ⟶ W)
Goal: CategoryTheory.CategoryStruct.comp (CategoryTheory.CategoryStruct.comp f g) h =
  CategoryTheory.CategoryStruct.comp f (CategoryTheory.CategoryStruct.comp g h)
-- CategoryTheory.Sigma.SigmaHom.id_comp
lemma id_comp : ∀ {X Y : Σi, C i} (f : X ⟶ Y), 𝟙 X ≫ f = f
  
Arguments: {I : Type w₁} {C : I → Type u₁} [(i : I) → CategoryTheory.Category.{v₁, u₁} (C i)] {X Y : (i : I) × C i} (f : X ⟶ Y)
Goal: CategoryTheory.CategoryStruct.comp (CategoryTheory.CategoryStruct.id X) f = f
-- CategoryTheory.Sigma.SigmaHom.comp_id
lemma comp_id : ∀ {X Y : Σi, C i} (f : X ⟶ Y), f ≫ 𝟙 Y = f
  
Arguments: {I : Type w₁} {C : I → Type u₁} [(i : I) → CategoryTheory.Category.{v₁, u₁} (C i)] {X Y : (i : I) × C i} (f : X ⟶ Y)
Goal: CategoryTheory.CategoryStruct.comp f (CategoryTheory.CategoryStruct.id Y) = f
-- CategoryTheory.Sigma.incl_map
@[simps map]
def incl (i : I) : C i ⥤ Σi, C i 
Arguments: {I : Type w₁} {C : I → Type u₁} [(i : I) → CategoryTheory.Category.{v₁, u₁} (C i)] (i : I)
Goal: ∀ {X Y : C i} (a : X ⟶ Y), (CategoryTheory.Sigma.incl i).map a = CategoryTheory.Sigma.SigmaHom.mk a
-- CategoryTheory.Sigma.incl_obj
@[simp]
lemma incl_obj {i : I} (X : C i) : (incl i).obj X = ⟨i, X⟩ 
Arguments: {I : Type w₁} {C : I → Type u₁} [(i : I) → CategoryTheory.Category.{v₁, u₁} (C i)] {i : I} (X : C i)
Goal: (CategoryTheory.Sigma.incl i).obj X = ⟨i, X⟩
-- CategoryTheory.Sigma.natTrans_app
@[simp]
lemma natTrans_app {F G : (Σi, C i) ⥤ D} (h : ∀ i : I, incl i ⋙ F ⟶ incl i ⋙ G) (i : I)
    (X : C i) : (natTrans h).app ⟨i, X⟩ = (h i).app X 
Arguments: {I : Type w₁} {C : I → Type u₁} [(i : I) → CategoryTheory.Category.{v₁, u₁} (C i)] {D : Type u₂} [CategoryTheory.Category.{v₂, u₂} D] {F G : CategoryTheory.Functor ((i : I) × C i) D} (h : (i : I) → (CategoryTheory.Sigma.incl i).comp F ⟶ (CategoryTheory.Sigma.incl i).comp G) (i : I) (X : C i)
Goal: (CategoryTheory.Sigma.natTrans h).app ⟨i, X⟩ = (h i).app X
-- CategoryTheory.Sigma.desc_obj
@[simps obj]
def desc : (Σi, C i) ⥤ D 
Arguments: {I : Type w₁} {C : I → Type u₁} [(i : I) → CategoryTheory.Category.{v₁, u₁} (C i)] {D : Type u₂} [CategoryTheory.Category.{v₂, u₂} D] (F : (i : I) → CategoryTheory.Functor (C i) D) (X : (i : I) × C i)
Goal: (CategoryTheory.Sigma.desc F).obj X = (F X.fst).obj X.snd
-- CategoryTheory.Sigma.desc_map_mk
@[simp]
lemma desc_map_mk {i : I} (X Y : C i) (f : X ⟶ Y) : (desc F).map (SigmaHom.mk f) = (F i).map f 
Arguments: {I : Type w₁} {C : I → Type u₁} [(i : I) → CategoryTheory.Category.{v₁, u₁} (C i)] {D : Type u₂} [CategoryTheory.Category.{v₂, u₂} D] (F : (i : I) → CategoryTheory.Functor (C i) D) {i : I} (X Y : C i) (f : X ⟶ Y)
Goal: (CategoryTheory.Sigma.desc F).map (CategoryTheory.Sigma.SigmaHom.mk f) = (F i).map f
-- CategoryTheory.Sigma.inclDesc_hom_app
@[simp]
lemma inclDesc_hom_app (i : I) (X : C i) : (inclDesc F i).hom.app X = 𝟙 ((F i).obj X) 
Arguments: {I : Type w₁} {C : I → Type u₁} [(i : I) → CategoryTheory.Category.{v₁, u₁} (C i)] {D : Type u₂} [CategoryTheory.Category.{v₂, u₂} D] (F : (i : I) → CategoryTheory.Functor (C i) D) (i : I) (X : C i)
Goal: (CategoryTheory.Sigma.inclDesc F i).hom.app X = CategoryTheory.CategoryStruct.id ((F i).obj X)
-- CategoryTheory.Sigma.inclDesc_inv_app
@[simp]
lemma inclDesc_inv_app (i : I) (X : C i) : (inclDesc F i).inv.app X = 𝟙 ((F i).obj X) 
Arguments: {I : Type w₁} {C : I → Type u₁} [(i : I) → CategoryTheory.Category.{v₁, u₁} (C i)] {D : Type u₂} [CategoryTheory.Category.{v₂, u₂} D] (F : (i : I) → CategoryTheory.Functor (C i) D) (i : I) (X : C i)
Goal: (CategoryTheory.Sigma.inclDesc F i).inv.app X = CategoryTheory.CategoryStruct.id ((F i).obj X)
-- CategoryTheory.Sigma.descUniq_hom_app
@[simp]
lemma descUniq_hom_app (q : (Σi, C i) ⥤ D) (h : ∀ i, incl i ⋙ q ≅ F i) (i : I) (X : C i) :
    (descUniq F q h).hom.app ⟨i, X⟩ = (h i).hom.app X 
Arguments: {I : Type w₁} {C : I → Type u₁} [(i : I) → CategoryTheory.Category.{v₁, u₁} (C i)] {D : Type u₂} [CategoryTheory.Category.{v₂, u₂} D] (F : (i : I) → CategoryTheory.Functor (C i) D) (q : CategoryTheory.Functor ((i : I) × C i) D) (h : (i : I) → (CategoryTheory.Sigma.incl i).comp q ≅ F i) (i : I) (X : C i)
Goal: (CategoryTheory.Sigma.descUniq F q h).hom.app ⟨i, X⟩ = (h i).hom.app X
-- CategoryTheory.Sigma.descUniq_inv_app
@[simp]
lemma descUniq_inv_app (q : (Σi, C i) ⥤ D) (h : ∀ i, incl i ⋙ q ≅ F i) (i : I) (X : C i) :
    (descUniq F q h).inv.app ⟨i, X⟩ = (h i).inv.app X 
Arguments: {I : Type w₁} {C : I → Type u₁} [(i : I) → CategoryTheory.Category.{v₁, u₁} (C i)] {D : Type u₂} [CategoryTheory.Category.{v₂, u₂} D] (F : (i : I) → CategoryTheory.Functor (C i) D) (q : CategoryTheory.Functor ((i : I) × C i) D) (h : (i : I) → (CategoryTheory.Sigma.incl i).comp q ≅ F i) (i : I) (X : C i)
Goal: (CategoryTheory.Sigma.descUniq F q h).inv.app ⟨i, X⟩ = (h i).inv.app X
-- CategoryTheory.Sigma.natIso_inv
@[simps]
def natIso {q₁ q₂ : (Σi, C i) ⥤ D} (h : ∀ i, incl i ⋙ q₁ ≅ incl i ⋙ q₂) : q₁ ≅ q₂ 
Arguments: {I : Type w₁} {C : I → Type u₁} [(i : I) → CategoryTheory.Category.{v₁, u₁} (C i)] {D : Type u₂} [CategoryTheory.Category.{v₂, u₂} D] {q₁ q₂ : CategoryTheory.Functor ((i : I) × C i) D} (h : (i : I) → (CategoryTheory.Sigma.incl i).comp q₁ ≅ (CategoryTheory.Sigma.incl i).comp q₂)
Goal: (CategoryTheory.Sigma.natIso h).inv = CategoryTheory.Sigma.natTrans fun i => (h i).inv
-- CategoryTheory.Sigma.natIso_hom
@[simps]
def natIso {q₁ q₂ : (Σi, C i) ⥤ D} (h : ∀ i, incl i ⋙ q₁ ≅ incl i ⋙ q₂) : q₁ ≅ q₂ 
Arguments: {I : Type w₁} {C : I → Type u₁} [(i : I) → CategoryTheory.Category.{v₁, u₁} (C i)] {D : Type u₂} [CategoryTheory.Category.{v₂, u₂} D] {q₁ q₂ : CategoryTheory.Functor ((i : I) × C i) D} (h : (i : I) → (CategoryTheory.Sigma.incl i).comp q₁ ≅ (CategoryTheory.Sigma.incl i).comp q₂)
Goal: (CategoryTheory.Sigma.natIso h).hom = CategoryTheory.Sigma.natTrans fun i => (h i).hom
-- CategoryTheory.Sigma.map_obj
@[simp]
lemma map_obj (j : J) (X : C (g j)) : (Sigma.map C g).obj ⟨j, X⟩ = ⟨g j, X⟩ 
Arguments: {I : Type w₁} (C : I → Type u₁) [(i : I) → CategoryTheory.Category.{v₁, u₁} (C i)] {J : Type w₂} (g : J → I) (j : J) (X : C (g j))
Goal: (CategoryTheory.Sigma.map C g).obj ⟨j, X⟩ = ⟨g j, X⟩
-- CategoryTheory.Sigma.map_map
@[simp]
lemma map_map {j : J} {X Y : C (g j)} (f : X ⟶ Y) :
    (Sigma.map C g).map (SigmaHom.mk f) = SigmaHom.mk f 
Arguments: {I : Type w₁} (C : I → Type u₁) [(i : I) → CategoryTheory.Category.{v₁, u₁} (C i)] {J : Type w₂} (g : J → I) {j : J} {X Y : C (g j)} (f : X ⟶ Y)
Goal: (CategoryTheory.Sigma.map C g).map (CategoryTheory.Sigma.SigmaHom.mk f) = CategoryTheory.Sigma.SigmaHom.mk f