ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
-- CategoryTheory.ofTypeMonad_obj
@[simps!]
def ofTypeMonad : Monad (Type u) 
Arguments: (m : Type u → Type u) [Monad m] [LawfulMonad m]
Goal: ∀ (a : Type u), (CategoryTheory.ofTypeMonad m).obj a = m a
-- CategoryTheory.ofTypeMonad_map
@[simps!]
def ofTypeMonad : Monad (Type u) 
Arguments: (m : Type u → Type u) [Monad m] [LawfulMonad m]
Goal: ∀ {X Y : Type u} (f : X ⟶ Y) (a : m X), (CategoryTheory.ofTypeMonad m).map f a = f <$> a
-- CategoryTheory.ofTypeMonad_μ_app
@[simps!]
def ofTypeMonad : Monad (Type u) 
Arguments: (m : Type u → Type u) [Monad m] [LawfulMonad m] {α : Type u} (a : m (m α))
Goal: (CategoryTheory.ofTypeMonad m).μ.app α a = joinM a
-- CategoryTheory.ofTypeMonad_η_app
@[simps!]
def ofTypeMonad : Monad (Type u) 
Arguments: (m : Type u → Type u) [Monad m] [LawfulMonad m] {α : Type u}
Goal: ∀ (a : α), (CategoryTheory.ofTypeMonad m).η.app α a = pure a
-- CategoryTheory.eq_functor_obj
@[simps]
def eq : KleisliCat m ≌ Kleisli (ofTypeMonad m) 
Arguments: (m : Type u → Type u) [Monad m] [LawfulMonad m] (X : CategoryTheory.KleisliCat m)
Goal: (CategoryTheory.eq m).functor.obj X = X
-- CategoryTheory.eq_inverse_obj
@[simps]
def eq : KleisliCat m ≌ Kleisli (ofTypeMonad m) 
Arguments: (m : Type u → Type u) [Monad m] [LawfulMonad m] (X : CategoryTheory.Kleisli (CategoryTheory.ofTypeMonad m))
Goal: (CategoryTheory.eq m).inverse.obj X = X
-- CategoryTheory.eq_unitIso
@[simps]
def eq : KleisliCat m ≌ Kleisli (ofTypeMonad m) 
Arguments: (m : Type u → Type u) [Monad m] [LawfulMonad m]
Goal: (CategoryTheory.eq m).unitIso = CategoryTheory.NatIso.ofComponents (fun X => CategoryTheory.Iso.refl X) ⋯
-- CategoryTheory.eq_counitIso
@[simps]
def eq : KleisliCat m ≌ Kleisli (ofTypeMonad m) 
Arguments: (m : Type u → Type u) [Monad m] [LawfulMonad m]
Goal: (CategoryTheory.eq m).counitIso = CategoryTheory.NatIso.ofComponents (fun X => CategoryTheory.Iso.refl X) ⋯
-- CategoryTheory.eq_inverse_map
@[simps]
def eq : KleisliCat m ≌ Kleisli (ofTypeMonad m) 
Arguments: (m : Type u → Type u) [Monad m] [LawfulMonad m]
Goal: ∀ {X Y : CategoryTheory.Kleisli (CategoryTheory.ofTypeMonad m)} (f : X ⟶ Y) (a : X),
  (CategoryTheory.eq m).inverse.map f a = f a
-- CategoryTheory.eq_functor_map
@[simps]
def eq : KleisliCat m ≌ Kleisli (ofTypeMonad m) 
Arguments: (m : Type u → Type u) [Monad m] [LawfulMonad m]
Goal: ∀ {X Y : CategoryTheory.KleisliCat m} (f : X ⟶ Y) (a : X), (CategoryTheory.eq m).functor.map f a = f a
-- CategoryTheory.Over.OverMorphism.ext
@[ext]
theorem OverMorphism.ext {X : T} {U V : Over X} {f g : U ⟶ V} (h : f.left = g.left) : f = g 
Arguments: {T : Type u₁} [CategoryTheory.Category.{v₁, u₁} T] {X : T} {U V : CategoryTheory.Over X} {f g : U ⟶ V} (h : f.left = g.left)
Goal: f = g
-- CategoryTheory.Over.over_right
theorem over_right (U : Over X) : U.right = ⟨⟨⟩⟩ 
Arguments: {T : Type u₁} [CategoryTheory.Category.{v₁, u₁} T] {X : T} (U : CategoryTheory.Over X)
Goal: U.right = { as := PUnit.unit }
-- CategoryTheory.Over.id_left
@[simp]
theorem id_left (U : Over X) : CommaMorphism.left (𝟙 U) = 𝟙 U.left 
Arguments: {T : Type u₁} [CategoryTheory.Category.{v₁, u₁} T] {X : T} (U : CategoryTheory.Over X)
Goal: (CategoryTheory.CategoryStruct.id U).left = CategoryTheory.CategoryStruct.id U.left
-- CategoryTheory.Over.comp_left
@[simp]
theorem comp_left (a b c : Over X) (f : a ⟶ b) (g : b ⟶ c) : (f ≫ g).left = f.left ≫ g.left 
Arguments: {T : Type u₁} [CategoryTheory.Category.{v₁, u₁} T] {X : T} (a b c : CategoryTheory.Over X) (f : a ⟶ b) (g : b ⟶ c)
Goal: (CategoryTheory.CategoryStruct.comp f g).left = CategoryTheory.CategoryStruct.comp f.left g.left
-- CategoryTheory.Over.w
@[reassoc (attr := simp)]
theorem w {A B : Over X} (f : A ⟶ B) : f.left ≫ B.hom = A.hom 
Arguments: {T : Type u₁} [CategoryTheory.Category.{v₁, u₁} T] {X : T} {A B : CategoryTheory.Over X} (f : A ⟶ B)
Goal: CategoryTheory.CategoryStruct.comp f.left B.hom = A.hom
-- CategoryTheory.Over.mk_left
@[simps! left hom]
def mk {X Y : T} (f : Y ⟶ X) : Over X 
Arguments: {T : Type u₁} [CategoryTheory.Category.{v₁, u₁} T] {X Y : T} (f : Y ⟶ X)
Goal: (CategoryTheory.Over.mk f).left = Y
-- CategoryTheory.Over.mk_hom
@[simps! left hom]
def mk {X Y : T} (f : Y ⟶ X) : Over X 
Arguments: {T : Type u₁} [CategoryTheory.Category.{v₁, u₁} T] {X Y : T} (f : Y ⟶ X)
Goal: (CategoryTheory.Over.mk f).hom = f
-- CategoryTheory.Over.coe_hom
@[simp]
theorem coe_hom {X Y : T} (f : Y ⟶ X) : (f : Over X).hom = f 
Arguments: {T : Type u₁} [CategoryTheory.Category.{v₁, u₁} T] {X Y : T} (f : Y ⟶ X)
Goal: (CategoryTheory.Over.mk f).hom = f
-- CategoryTheory.Over.homMk_right_down_down
@[simps!]
def homMk {U V : Over X} (f : U.left ⟶ V.left) (w : f ≫ V.hom = U.hom := by aesop_cat) : U ⟶ V 
Arguments: {T : Type u₁} [CategoryTheory.Category.{v₁, u₁} T] {X : T} {U V : CategoryTheory.Over X} (f : U.left ⟶ V.left) (w : CategoryTheory.CategoryStruct.comp f V.hom = U.hom := by aesop_cat)
Goal: ⋯ = ⋯
-- CategoryTheory.Over.homMk_left
@[simps!]
def homMk {U V : Over X} (f : U.left ⟶ V.left) (w : f ≫ V.hom = U.hom := by aesop_cat) : U ⟶ V 
Arguments: {T : Type u₁} [CategoryTheory.Category.{v₁, u₁} T] {X : T} {U V : CategoryTheory.Over X} (f : U.left ⟶ V.left) (w : CategoryTheory.CategoryStruct.comp f V.hom = U.hom := by aesop_cat)
Goal: (CategoryTheory.Over.homMk f w).left = f
-- CategoryTheory.Over.isoMk_inv_left
@[simps!]
def isoMk {f g : Over X} (hl : f.left ≅ g.left) (hw : hl.hom ≫ g.hom = f.hom := by aesop_cat) :
    f ≅ g 
Arguments: {T : Type u₁} [CategoryTheory.Category.{v₁, u₁} T] {X : T} {f g : CategoryTheory.Over X} (hl : f.left ≅ g.left) (hw : CategoryTheory.CategoryStruct.comp hl.hom g.hom = f.hom := by aesop_cat)
Goal: (CategoryTheory.Over.isoMk hl hw).inv.left = hl.inv
-- CategoryTheory.Over.isoMk_hom_left
@[simps!]
def isoMk {f g : Over X} (hl : f.left ≅ g.left) (hw : hl.hom ≫ g.hom = f.hom := by aesop_cat) :
    f ≅ g 
Arguments: {T : Type u₁} [CategoryTheory.Category.{v₁, u₁} T] {X : T} {f g : CategoryTheory.Over X} (hl : f.left ≅ g.left) (hw : CategoryTheory.CategoryStruct.comp hl.hom g.hom = f.hom := by aesop_cat)
Goal: (CategoryTheory.Over.isoMk hl hw).hom.left = hl.hom
-- CategoryTheory.Over.isoMk_inv_right_down_down
@[simps!]
def isoMk {f g : Over X} (hl : f.left ≅ g.left) (hw : hl.hom ≫ g.hom = f.hom := by aesop_cat) :
    f ≅ g 
Arguments: {T : Type u₁} [CategoryTheory.Category.{v₁, u₁} T] {X : T} {f g : CategoryTheory.Over X} (hl : f.left ≅ g.left) (hw : CategoryTheory.CategoryStruct.comp hl.hom g.hom = f.hom := by aesop_cat)
Goal: ⋯ = ⋯
-- CategoryTheory.Over.isoMk_hom_right_down_down
@[simps!]
def isoMk {f g : Over X} (hl : f.left ≅ g.left) (hw : hl.hom ≫ g.hom = f.hom := by aesop_cat) :
    f ≅ g 
Arguments: {T : Type u₁} [CategoryTheory.Category.{v₁, u₁} T] {X : T} {f g : CategoryTheory.Over X} (hl : f.left ≅ g.left) (hw : CategoryTheory.CategoryStruct.comp hl.hom g.hom = f.hom := by aesop_cat)
Goal: ⋯ = ⋯
-- CategoryTheory.Over.forget_obj
@[simp]
theorem forget_obj {U : Over X} : (forget X).obj U = U.left 
Arguments: {T : Type u₁} [CategoryTheory.Category.{v₁, u₁} T] {X : T} {U : CategoryTheory.Over X}
Goal: (CategoryTheory.Over.forget X).obj U = U.left
-- CategoryTheory.Over.forget_map
@[simp]
theorem forget_map {U V : Over X} {f : U ⟶ V} : (forget X).map f = f.left 
Arguments: {T : Type u₁} [CategoryTheory.Category.{v₁, u₁} T] {X : T} {U V : CategoryTheory.Over X} {f : U ⟶ V}
Goal: (CategoryTheory.Over.forget X).map f = f.left
-- CategoryTheory.Over.forgetCocone_ι_app
@[simps]
def forgetCocone (X : T) : Limits.Cocone (forget X) 
Arguments: {T : Type u₁} [CategoryTheory.Category.{v₁, u₁} T] (X : T) (self : CategoryTheory.Comma (CategoryTheory.Functor.id T) (CategoryTheory.Functor.fromPUnit X))
Goal: (CategoryTheory.Over.forgetCocone X).ι.app self = self.hom
-- CategoryTheory.Over.forgetCocone_pt
@[simps]
def forgetCocone (X : T) : Limits.Cocone (forget X) 
Arguments: {T : Type u₁} [CategoryTheory.Category.{v₁, u₁} T] (X : T)
Goal: (CategoryTheory.Over.forgetCocone X).pt = X
-- CategoryTheory.Over.map_obj_left
@[simp]
theorem map_obj_left : ((map f).obj U).left = U.left 
Arguments: {T : Type u₁} [CategoryTheory.Category.{v₁, u₁} T] {X Y : T} {f : X ⟶ Y} {U : CategoryTheory.Over X}
Goal: ((CategoryTheory.Over.map f).obj U).left = U.left
-- CategoryTheory.Over.map_obj_hom
@[simp]
theorem map_obj_hom : ((map f).obj U).hom = U.hom ≫ f 
Arguments: {T : Type u₁} [CategoryTheory.Category.{v₁, u₁} T] {X Y : T} {f : X ⟶ Y} {U : CategoryTheory.Over X}
Goal: ((CategoryTheory.Over.map f).obj U).hom = CategoryTheory.CategoryStruct.comp U.hom f
-- CategoryTheory.Over.map_map_left
@[simp]
theorem map_map_left : ((map f).map g).left = g.left 
Arguments: {T : Type u₁} [CategoryTheory.Category.{v₁, u₁} T] {X Y : T} {f : X ⟶ Y} {U V : CategoryTheory.Over X} {g : U ⟶ V}
Goal: ((CategoryTheory.Over.map f).map g).left = g.left
-- CategoryTheory.Over.mapId_eq
theorem mapId_eq (Y : T) : map (𝟙 Y) = 𝟭 _ 
Arguments: {T : Type u₁} [CategoryTheory.Category.{v₁, u₁} T] (Y : T)
Goal: CategoryTheory.Over.map (CategoryTheory.CategoryStruct.id Y) = CategoryTheory.Functor.id (CategoryTheory.Over Y)
-- CategoryTheory.Over.mapForget_eq
theorem mapForget_eq {X Y : T} (f : X ⟶ Y) :
    (map f) ⋙ (forget Y) = (forget X) 
Arguments: {T : Type u₁} [CategoryTheory.Category.{v₁, u₁} T] {X Y : T} (f : X ⟶ Y)
Goal: (CategoryTheory.Over.map f).comp (CategoryTheory.Over.forget Y) = CategoryTheory.Over.forget X
-- CategoryTheory.Over.eqToHom_left
@[simp]
theorem eqToHom_left {X : T} {U V : Over X} (e : U = V) :
    (eqToHom e).left = eqToHom (e ▸ rfl : U.left = V.left) 
Arguments: {T : Type u₁} [CategoryTheory.Category.{v₁, u₁} T] {X : T} {U V : CategoryTheory.Over X} (e : U = V)
Goal: (CategoryTheory.eqToHom e).left = CategoryTheory.eqToHom ⋯
-- CategoryTheory.Over.mapComp_eq
theorem mapComp_eq {X Y Z : T} (f : X ⟶ Y) (g : Y ⟶ Z) :
    map (f ≫ g) = (map f) ⋙ (map g) 
Arguments: {T : Type u₁} [CategoryTheory.Category.{v₁, u₁} T] {X Y Z : T} (f : X ⟶ Y) (g : Y ⟶ Z)
Goal: CategoryTheory.Over.map (CategoryTheory.CategoryStruct.comp f g) =
  (CategoryTheory.Over.map f).comp (CategoryTheory.Over.map g)
-- CategoryTheory.Over.mapFunctor_map
@[simps] def mapFunctor : T ⥤ Cat 
Arguments: (T : Type u₁) [CategoryTheory.Category.{v₁, u₁} T]
Goal: ∀ {X Y : T} (f : X ⟶ Y), (CategoryTheory.Over.mapFunctor T).map f = CategoryTheory.Over.map f
-- CategoryTheory.Over.mapFunctor_obj
@[simps] def mapFunctor : T ⥤ Cat 
Arguments: (T : Type u₁) [CategoryTheory.Category.{v₁, u₁} T] (X : T)
Goal: (CategoryTheory.Over.mapFunctor T).obj X = CategoryTheory.Cat.of (CategoryTheory.Over X)
-- CategoryTheory.Over.epi_of_epi_left
theorem epi_of_epi_left {f g : Over X} (k : f ⟶ g) [hk : Epi k.left] : Epi k 
Arguments: {T : Type u₁} [CategoryTheory.Category.{v₁, u₁} T] {X : T} {f g : CategoryTheory.Over X} (k : f ⟶ g) [hk : CategoryTheory.Epi k.left]
Goal: CategoryTheory.Epi k
-- CategoryTheory.Over.mono_of_mono_left
theorem mono_of_mono_left {f g : Over X} (k : f ⟶ g) [hk : Mono k.left] : Mono k 
Arguments: {T : Type u₁} [CategoryTheory.Category.{v₁, u₁} T] {X : T} {f g : CategoryTheory.Over X} (k : f ⟶ g) [hk : CategoryTheory.Mono k.left]
Goal: CategoryTheory.Mono k
-- CategoryTheory.Over.iteratedSliceForward_map
@[simps]
def iteratedSliceForward : Over f ⥤ Over f.left 
Arguments: {T : Type u₁} [CategoryTheory.Category.{v₁, u₁} T] {X : T} (f : CategoryTheory.Over X)
Goal: ∀ {X_1 Y : CategoryTheory.Over f} (κ : X_1 ⟶ Y), f.iteratedSliceForward.map κ = CategoryTheory.Over.homMk κ.left.left ⋯
-- CategoryTheory.Over.iteratedSliceForward_obj
@[simps]
def iteratedSliceForward : Over f ⥤ Over f.left 
Arguments: {T : Type u₁} [CategoryTheory.Category.{v₁, u₁} T] {X : T} (f : CategoryTheory.Over X) (α : CategoryTheory.Over f)
Goal: f.iteratedSliceForward.obj α = CategoryTheory.Over.mk α.hom.left
-- CategoryTheory.Over.iteratedSliceBackward_map
@[simps]
def iteratedSliceBackward : Over f.left ⥤ Over f 
Arguments: {T : Type u₁} [CategoryTheory.Category.{v₁, u₁} T] {X : T} (f : CategoryTheory.Over X)
Goal: ∀ {X_1 Y : CategoryTheory.Over f.left} (α : X_1 ⟶ Y),
  f.iteratedSliceBackward.map α = CategoryTheory.Over.homMk (CategoryTheory.Over.homMk α.left ⋯) ⋯
-- CategoryTheory.Over.iteratedSliceBackward_obj
@[simps]
def iteratedSliceBackward : Over f.left ⥤ Over f 
Arguments: {T : Type u₁} [CategoryTheory.Category.{v₁, u₁} T] {X : T} (f : CategoryTheory.Over X) (g : CategoryTheory.Over f.left)
Goal: f.iteratedSliceBackward.obj g = CategoryTheory.Over.mk (CategoryTheory.Over.homMk g.hom ⋯)
-- CategoryTheory.Over.iteratedSliceEquiv_functor
@[simps]
def iteratedSliceEquiv : Over f ≌ Over f.left 
Arguments: {T : Type u₁} [CategoryTheory.Category.{v₁, u₁} T] {X : T} (f : CategoryTheory.Over X)
Goal: f.iteratedSliceEquiv.functor = f.iteratedSliceForward
-- CategoryTheory.Over.iteratedSliceEquiv_unitIso
@[simps]
def iteratedSliceEquiv : Over f ≌ Over f.left 
Arguments: {T : Type u₁} [CategoryTheory.Category.{v₁, u₁} T] {X : T} (f : CategoryTheory.Over X)
Goal: f.iteratedSliceEquiv.unitIso =
  CategoryTheory.NatIso.ofComponents
    (fun g =>
      CategoryTheory.Over.isoMk
        (CategoryTheory.Over.isoMk
          (CategoryTheory.Iso.refl ((CategoryTheory.Functor.id (CategoryTheory.Over f)).obj g).left.left) ⋯)
        ⋯)
    ⋯
-- CategoryTheory.Over.iteratedSliceEquiv_counitIso
@[simps]
def iteratedSliceEquiv : Over f ≌ Over f.left 
Arguments: {T : Type u₁} [CategoryTheory.Category.{v₁, u₁} T] {X : T} (f : CategoryTheory.Over X)
Goal: f.iteratedSliceEquiv.counitIso =
  CategoryTheory.NatIso.ofComponents
    (fun g =>
      CategoryTheory.Over.isoMk
        (CategoryTheory.Iso.refl ((f.iteratedSliceBackward.comp f.iteratedSliceForward).obj g).left) ⋯)
    ⋯
-- CategoryTheory.Over.iteratedSliceEquiv_inverse
@[simps]
def iteratedSliceEquiv : Over f ≌ Over f.left 
Arguments: {T : Type u₁} [CategoryTheory.Category.{v₁, u₁} T] {X : T} (f : CategoryTheory.Over X)
Goal: f.iteratedSliceEquiv.inverse = f.iteratedSliceBackward
-- CategoryTheory.Over.iteratedSliceForward_forget
theorem iteratedSliceForward_forget :
    iteratedSliceForward f ⋙ forget f.left = forget f ⋙ forget X 
Arguments: {T : Type u₁} [CategoryTheory.Category.{v₁, u₁} T] {X : T} (f : CategoryTheory.Over X)
Goal: f.iteratedSliceForward.comp (CategoryTheory.Over.forget f.left) =
  (CategoryTheory.Over.forget f).comp (CategoryTheory.Over.forget X)
-- CategoryTheory.Over.iteratedSliceBackward_forget_forget
theorem iteratedSliceBackward_forget_forget :
    iteratedSliceBackward f ⋙ forget f ⋙ forget X = forget f.left 
Arguments: {T : Type u₁} [CategoryTheory.Category.{v₁, u₁} T] {X : T} (f : CategoryTheory.Over X)
Goal: f.iteratedSliceBackward.comp ((CategoryTheory.Over.forget f).comp (CategoryTheory.Over.forget X)) =
  CategoryTheory.Over.forget f.left
-- CategoryTheory.Over.post_map
@[simps]
def post (F : T ⥤ D) : Over X ⥤ Over (F.obj X) 
Arguments: {T : Type u₁} [CategoryTheory.Category.{v₁, u₁} T] {X : T} {D : Type u₂} [CategoryTheory.Category.{v₂, u₂} D] (F : CategoryTheory.Functor T D)
Goal: ∀ {X_1 Y : CategoryTheory.Over X} (f : X_1 ⟶ Y),
  (CategoryTheory.Over.post F).map f = CategoryTheory.Over.homMk (F.map f.left) ⋯
-- CategoryTheory.Over.post_obj
@[simps]
def post (F : T ⥤ D) : Over X ⥤ Over (F.obj X) 
Arguments: {T : Type u₁} [CategoryTheory.Category.{v₁, u₁} T] {X : T} {D : Type u₂} [CategoryTheory.Category.{v₂, u₂} D] (F : CategoryTheory.Functor T D) (Y : CategoryTheory.Over X)
Goal: (CategoryTheory.Over.post F).obj Y = CategoryTheory.Over.mk (F.map Y.hom)
-- CategoryTheory.CostructuredArrow.toOver_obj_right
@[simps!]
def toOver (F : D ⥤ T) (X : T) : CostructuredArrow F X ⥤ Over X 
Arguments: {T : Type u₁} [CategoryTheory.Category.{v₁, u₁} T] {D : Type u₂} [CategoryTheory.Category.{v₂, u₂} D] (F : CategoryTheory.Functor D T) (X : T)
Goal: ∀ (X_1 : CategoryTheory.Comma (F.comp (CategoryTheory.Functor.id T)) (CategoryTheory.Functor.fromPUnit X)),
  ((CategoryTheory.CostructuredArrow.toOver F X).obj X_1).right = X_1.right
-- CategoryTheory.CostructuredArrow.toOver_obj_hom
@[simps!]
def toOver (F : D ⥤ T) (X : T) : CostructuredArrow F X ⥤ Over X 
Arguments: {T : Type u₁} [CategoryTheory.Category.{v₁, u₁} T] {D : Type u₂} [CategoryTheory.Category.{v₂, u₂} D] (F : CategoryTheory.Functor D T) (X : T)
Goal: ∀ (X_1 : CategoryTheory.Comma (F.comp (CategoryTheory.Functor.id T)) (CategoryTheory.Functor.fromPUnit X)),
  ((CategoryTheory.CostructuredArrow.toOver F X).obj X_1).hom = X_1.hom
-- CategoryTheory.CostructuredArrow.toOver_map_right
@[simps!]
def toOver (F : D ⥤ T) (X : T) : CostructuredArrow F X ⥤ Over X 
Arguments: {T : Type u₁} [CategoryTheory.Category.{v₁, u₁} T] {D : Type u₂} [CategoryTheory.Category.{v₂, u₂} D] (F : CategoryTheory.Functor D T) (X : T)
Goal: ∀ {X_1 Y : CategoryTheory.Comma (F.comp (CategoryTheory.Functor.id T)) (CategoryTheory.Functor.fromPUnit X)}
  (f : X_1 ⟶ Y),
  ((CategoryTheory.CostructuredArrow.toOver F X).map f).right = CategoryTheory.CategoryStruct.id X_1.right
-- CategoryTheory.CostructuredArrow.toOver_map_left
@[simps!]
def toOver (F : D ⥤ T) (X : T) : CostructuredArrow F X ⥤ Over X 
Arguments: {T : Type u₁} [CategoryTheory.Category.{v₁, u₁} T] {D : Type u₂} [CategoryTheory.Category.{v₂, u₂} D] (F : CategoryTheory.Functor D T) (X : T)
Goal: ∀ {X_1 Y : CategoryTheory.Comma (F.comp (CategoryTheory.Functor.id T)) (CategoryTheory.Functor.fromPUnit X)}
  (f : X_1 ⟶ Y), ((CategoryTheory.CostructuredArrow.toOver F X).map f).left = F.map f.left
-- CategoryTheory.CostructuredArrow.toOver_obj_left
@[simps!]
def toOver (F : D ⥤ T) (X : T) : CostructuredArrow F X ⥤ Over X 
Arguments: {T : Type u₁} [CategoryTheory.Category.{v₁, u₁} T] {D : Type u₂} [CategoryTheory.Category.{v₂, u₂} D] (F : CategoryTheory.Functor D T) (X : T)
Goal: ∀ (X_1 : CategoryTheory.Comma (F.comp (CategoryTheory.Functor.id T)) (CategoryTheory.Functor.fromPUnit X)),
  ((CategoryTheory.CostructuredArrow.toOver F X).obj X_1).left = F.obj X_1.left
-- CategoryTheory.Under.UnderMorphism.ext
@[ext]
theorem UnderMorphism.ext {X : T} {U V : Under X} {f g : U ⟶ V} (h : f.right = g.right) :
    f = g 
Arguments: {T : Type u₁} [CategoryTheory.Category.{v₁, u₁} T] {X : T} {U V : CategoryTheory.Under X} {f g : U ⟶ V} (h : f.right = g.right)
Goal: f = g
-- CategoryTheory.Under.under_left
theorem under_left (U : Under X) : U.left = ⟨⟨⟩⟩ 
Arguments: {T : Type u₁} [CategoryTheory.Category.{v₁, u₁} T] {X : T} (U : CategoryTheory.Under X)
Goal: U.left = { as := PUnit.unit }
-- CategoryTheory.Under.id_right
@[simp]
theorem id_right (U : Under X) : CommaMorphism.right (𝟙 U) = 𝟙 U.right 
Arguments: {T : Type u₁} [CategoryTheory.Category.{v₁, u₁} T] {X : T} (U : CategoryTheory.Under X)
Goal: (CategoryTheory.CategoryStruct.id U).right = CategoryTheory.CategoryStruct.id U.right
-- CategoryTheory.Under.comp_right
@[simp]
theorem comp_right (a b c : Under X) (f : a ⟶ b) (g : b ⟶ c) : (f ≫ g).right = f.right ≫ g.right 
Arguments: {T : Type u₁} [CategoryTheory.Category.{v₁, u₁} T] {X : T} (a b c : CategoryTheory.Under X) (f : a ⟶ b) (g : b ⟶ c)
Goal: (CategoryTheory.CategoryStruct.comp f g).right = CategoryTheory.CategoryStruct.comp f.right g.right
-- CategoryTheory.Under.w
@[reassoc (attr := simp)]
theorem w {A B : Under X} (f : A ⟶ B) : A.hom ≫ f.right = B.hom 
Arguments: {T : Type u₁} [CategoryTheory.Category.{v₁, u₁} T] {X : T} {A B : CategoryTheory.Under X} (f : A ⟶ B)
Goal: CategoryTheory.CategoryStruct.comp A.hom f.right = B.hom
-- CategoryTheory.Under.mk_right
@[simps! right hom]
def mk {X Y : T} (f : X ⟶ Y) : Under X 
Arguments: {T : Type u₁} [CategoryTheory.Category.{v₁, u₁} T] {X Y : T} (f : X ⟶ Y)
Goal: (CategoryTheory.Under.mk f).right = Y
-- CategoryTheory.Under.mk_hom
@[simps! right hom]
def mk {X Y : T} (f : X ⟶ Y) : Under X 
Arguments: {T : Type u₁} [CategoryTheory.Category.{v₁, u₁} T] {X Y : T} (f : X ⟶ Y)
Goal: (CategoryTheory.Under.mk f).hom = f
-- CategoryTheory.Under.homMk_right
@[simps!]
def homMk {U V : Under X} (f : U.right ⟶ V.right) (w : U.hom ≫ f = V.hom := by aesop_cat) : U ⟶ V 
Arguments: {T : Type u₁} [CategoryTheory.Category.{v₁, u₁} T] {X : T} {U V : CategoryTheory.Under X} (f : U.right ⟶ V.right) (w : CategoryTheory.CategoryStruct.comp U.hom f = V.hom := by aesop_cat)
Goal: (CategoryTheory.Under.homMk f w).right = f
-- CategoryTheory.Under.homMk_left_down_down
@[simps!]
def homMk {U V : Under X} (f : U.right ⟶ V.right) (w : U.hom ≫ f = V.hom := by aesop_cat) : U ⟶ V 
Arguments: {T : Type u₁} [CategoryTheory.Category.{v₁, u₁} T] {X : T} {U V : CategoryTheory.Under X} (f : U.right ⟶ V.right) (w : CategoryTheory.CategoryStruct.comp U.hom f = V.hom := by aesop_cat)
Goal: ⋯ = ⋯
-- CategoryTheory.Under.isoMk_hom_right
@[simp]
theorem isoMk_hom_right {f g : Under X} (hr : f.right ≅ g.right) (hw : f.hom ≫ hr.hom = g.hom) :
    (isoMk hr hw).hom.right = hr.hom 
Arguments: {T : Type u₁} [CategoryTheory.Category.{v₁, u₁} T] {X : T} {f g : CategoryTheory.Under X} (hr : f.right ≅ g.right) (hw : CategoryTheory.CategoryStruct.comp f.hom hr.hom = g.hom)
Goal: (CategoryTheory.Under.isoMk hr hw).hom.right = hr.hom
-- CategoryTheory.Under.isoMk_inv_right
@[simp]
theorem isoMk_inv_right {f g : Under X} (hr : f.right ≅ g.right) (hw : f.hom ≫ hr.hom = g.hom) :
    (isoMk hr hw).inv.right = hr.inv 
Arguments: {T : Type u₁} [CategoryTheory.Category.{v₁, u₁} T] {X : T} {f g : CategoryTheory.Under X} (hr : f.right ≅ g.right) (hw : CategoryTheory.CategoryStruct.comp f.hom hr.hom = g.hom)
Goal: (CategoryTheory.Under.isoMk hr hw).inv.right = hr.inv
-- CategoryTheory.Under.forget_obj
@[simp]
theorem forget_obj {U : Under X} : (forget X).obj U = U.right 
Arguments: {T : Type u₁} [CategoryTheory.Category.{v₁, u₁} T] {X : T} {U : CategoryTheory.Under X}
Goal: (CategoryTheory.Under.forget X).obj U = U.right
-- CategoryTheory.Under.forget_map
@[simp]
theorem forget_map {U V : Under X} {f : U ⟶ V} : (forget X).map f = f.right 
Arguments: {T : Type u₁} [CategoryTheory.Category.{v₁, u₁} T] {X : T} {U V : CategoryTheory.Under X} {f : U ⟶ V}
Goal: (CategoryTheory.Under.forget X).map f = f.right
-- CategoryTheory.Under.forgetCone_pt
@[simps]
def forgetCone (X : T) : Limits.Cone (forget X) 
Arguments: {T : Type u₁} [CategoryTheory.Category.{v₁, u₁} T] (X : T)
Goal: (CategoryTheory.Under.forgetCone X).pt = X
-- CategoryTheory.Under.forgetCone_π_app
@[simps]
def forgetCone (X : T) : Limits.Cone (forget X) 
Arguments: {T : Type u₁} [CategoryTheory.Category.{v₁, u₁} T] (X : T) (self : CategoryTheory.Comma (CategoryTheory.Functor.fromPUnit X) (CategoryTheory.Functor.id T))
Goal: (CategoryTheory.Under.forgetCone X).π.app self = self.hom
-- CategoryTheory.Under.map_obj_right
@[simp]
theorem map_obj_right : ((map f).obj U).right = U.right 
Arguments: {T : Type u₁} [CategoryTheory.Category.{v₁, u₁} T] {X Y : T} {f : X ⟶ Y} {U : CategoryTheory.Under Y}
Goal: ((CategoryTheory.Under.map f).obj U).right = U.right
-- CategoryTheory.Under.map_obj_hom
@[simp]
theorem map_obj_hom : ((map f).obj U).hom = f ≫ U.hom 
Arguments: {T : Type u₁} [CategoryTheory.Category.{v₁, u₁} T] {X Y : T} {f : X ⟶ Y} {U : CategoryTheory.Under Y}
Goal: ((CategoryTheory.Under.map f).obj U).hom = CategoryTheory.CategoryStruct.comp f U.hom
-- CategoryTheory.Under.map_map_right
@[simp]
theorem map_map_right : ((map f).map g).right = g.right 
Arguments: {T : Type u₁} [CategoryTheory.Category.{v₁, u₁} T] {X Y : T} {f : X ⟶ Y} {U V : CategoryTheory.Under Y} {g : U ⟶ V}
Goal: ((CategoryTheory.Under.map f).map g).right = g.right
-- CategoryTheory.Under.mapId_eq
theorem mapId_eq (Y : T) : map (𝟙 Y) = 𝟭 _ 
Arguments: {T : Type u₁} [CategoryTheory.Category.{v₁, u₁} T] (Y : T)
Goal: CategoryTheory.Under.map (CategoryTheory.CategoryStruct.id Y) = CategoryTheory.Functor.id (CategoryTheory.Under Y)
-- CategoryTheory.Under.mapForget_eq
theorem mapForget_eq {X Y : T} (f : X ⟶ Y) :
    (map f) ⋙ (forget X) = (forget Y) 
Arguments: {T : Type u₁} [CategoryTheory.Category.{v₁, u₁} T] {X Y : T} (f : X ⟶ Y)
Goal: (CategoryTheory.Under.map f).comp (CategoryTheory.Under.forget X) = CategoryTheory.Under.forget Y
-- CategoryTheory.Under.eqToHom_right
@[simp]
theorem eqToHom_right {X : T} {U V : Under X} (e : U = V) :
    (eqToHom e).right = eqToHom (e ▸ rfl : U.right = V.right) 
Arguments: {T : Type u₁} [CategoryTheory.Category.{v₁, u₁} T] {X : T} {U V : CategoryTheory.Under X} (e : U = V)
Goal: (CategoryTheory.eqToHom e).right = CategoryTheory.eqToHom ⋯