ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
-- CategoryTheory.Triangulated.TStructure.IsGE.ge
class IsGE (X : C) (n : ℤ) : Prop where
  ge : t.GE n X
Arguments: {C : Type u_1} [CategoryTheory.Category.{u_2, u_1} C] [CategoryTheory.Preadditive C] [CategoryTheory.Limits.HasZeroObject C] [CategoryTheory.HasShift C ℤ] [∀ (n : ℤ), (CategoryTheory.shiftFunctor C n).Additive] [CategoryTheory.Pretriangulated C] {t : CategoryTheory.Triangulated.TStructure C} {X : C} {n : ℤ} [self : t.IsGE X n]
Goal: t.GE n X
-- CategoryTheory.Triangulated.TStructure.mem_of_isLE
lemma mem_of_isLE (X : C) (n : ℤ) [t.IsLE X n] : t.LE n X 
Arguments: {C : Type u_1} [CategoryTheory.Category.{u_2, u_1} C] [CategoryTheory.Preadditive C] [CategoryTheory.Limits.HasZeroObject C] [CategoryTheory.HasShift C ℤ] [∀ (n : ℤ), (CategoryTheory.shiftFunctor C n).Additive] [CategoryTheory.Pretriangulated C] (t : CategoryTheory.Triangulated.TStructure C) (X : C) (n : ℤ) [t.IsLE X n]
Goal: t.LE n X
-- CategoryTheory.Triangulated.TStructure.mem_of_isGE
lemma mem_of_isGE (X : C) (n : ℤ) [t.IsGE X n] : t.GE n X 
Arguments: {C : Type u_1} [CategoryTheory.Category.{u_2, u_1} C] [CategoryTheory.Preadditive C] [CategoryTheory.Limits.HasZeroObject C] [CategoryTheory.HasShift C ℤ] [∀ (n : ℤ), (CategoryTheory.shiftFunctor C n).Additive] [CategoryTheory.Pretriangulated C] (t : CategoryTheory.Triangulated.TStructure C) (X : C) (n : ℤ) [t.IsGE X n]
Goal: t.GE n X
-- CategoryTheory.Conv.one_eq
theorem one_eq : (1 : Conv M N) = M.counit ≫ N.one 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] [CategoryTheory.MonoidalCategory C] {M : Comon_ C} {N : Mon_ C}
Goal: 1 = CategoryTheory.CategoryStruct.comp M.counit N.one
-- CategoryTheory.Conv.mul_eq
theorem mul_eq (f g : Conv M N) : f * g = M.comul ≫ f ▷ M.X ≫ N.X ◁ g ≫ N.mul 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] [CategoryTheory.MonoidalCategory C] {M : Comon_ C} {N : Mon_ C} (f g : CategoryTheory.Conv M N)
Goal: f * g =
  CategoryTheory.CategoryStruct.comp M.comul
    (CategoryTheory.CategoryStruct.comp (CategoryTheory.MonoidalCategory.whiskerRight f M.X)
      (CategoryTheory.CategoryStruct.comp (CategoryTheory.MonoidalCategory.whiskerLeft N.X g) N.mul))
-- CategoryTheory.linearYoneda_obj_obj
@[simps]
def linearYoneda : C ⥤ Cᵒᵖ ⥤ ModuleCat R 
Arguments: (R : Type w) [Ring R] (C : Type u) [CategoryTheory.Category.{v, u} C] [CategoryTheory.Preadditive C] [CategoryTheory.Linear R C] (X : C) (Y : Cᵒᵖ)
Goal: ((CategoryTheory.linearYoneda R C).obj X).obj Y = ModuleCat.of R (Opposite.unop Y ⟶ X)
-- CategoryTheory.linearYoneda_map_app
@[simps]
def linearYoneda : C ⥤ Cᵒᵖ ⥤ ModuleCat R 
Arguments: (R : Type w) [Ring R] (C : Type u) [CategoryTheory.Category.{v, u} C] [CategoryTheory.Preadditive C] [CategoryTheory.Linear R C] {X₁ X₂ : C} (f : X₁ ⟶ X₂) (Y : Cᵒᵖ)
Goal: ((CategoryTheory.linearYoneda R C).map f).app Y =
  ModuleCat.ofHom (CategoryTheory.Linear.rightComp R (Opposite.unop Y) f)
-- CategoryTheory.linearYoneda_obj_map
@[simps]
def linearYoneda : C ⥤ Cᵒᵖ ⥤ ModuleCat R 
Arguments: (R : Type w) [Ring R] (C : Type u) [CategoryTheory.Category.{v, u} C] [CategoryTheory.Preadditive C] [CategoryTheory.Linear R C] (X : C)
Goal: ∀ {X_1 Y : Cᵒᵖ} (f : X_1 ⟶ Y),
  ((CategoryTheory.linearYoneda R C).obj X).map f = ModuleCat.ofHom (CategoryTheory.Linear.leftComp R X f.unop)
-- CategoryTheory.linearCoyoneda_obj_obj
@[simps]
def linearCoyoneda : Cᵒᵖ ⥤ C ⥤ ModuleCat R 
Arguments: (R : Type w) [Ring R] (C : Type u) [CategoryTheory.Category.{v, u} C] [CategoryTheory.Preadditive C] [CategoryTheory.Linear R C] (Y : Cᵒᵖ) (X : C)
Goal: ((CategoryTheory.linearCoyoneda R C).obj Y).obj X = ModuleCat.of R (Opposite.unop Y ⟶ X)
-- CategoryTheory.linearCoyoneda_obj_map
@[simps]
def linearCoyoneda : Cᵒᵖ ⥤ C ⥤ ModuleCat R 
Arguments: (R : Type w) [Ring R] (C : Type u) [CategoryTheory.Category.{v, u} C] [CategoryTheory.Preadditive C] [CategoryTheory.Linear R C] (Y : Cᵒᵖ)
Goal: ∀ {X Y_1 : C} (f : X ⟶ Y_1),
  ((CategoryTheory.linearCoyoneda R C).obj Y).map f =
    ModuleCat.ofHom (CategoryTheory.Linear.rightComp R (Opposite.unop Y) f)
-- CategoryTheory.linearCoyoneda_map_app
@[simps]
def linearCoyoneda : Cᵒᵖ ⥤ C ⥤ ModuleCat R 
Arguments: (R : Type w) [Ring R] (C : Type u) [CategoryTheory.Category.{v, u} C] [CategoryTheory.Preadditive C] [CategoryTheory.Linear R C] {Y₁ Y₂ : Cᵒᵖ} (f : Y₁ ⟶ Y₂) (X : C)
Goal: ((CategoryTheory.linearCoyoneda R C).map f).app X = ModuleCat.ofHom (CategoryTheory.Linear.leftComp R X f.unop)
-- CategoryTheory.whiskering_linearYoneda
@[simp]
theorem whiskering_linearYoneda :
    linearYoneda R C ⋙ (whiskeringRight _ _ _).obj (forget (ModuleCat.{v} R)) = yoneda 
Arguments: (R : Type w) [Ring R] (C : Type u) [CategoryTheory.Category.{v, u} C] [CategoryTheory.Preadditive C] [CategoryTheory.Linear R C]
Goal: (CategoryTheory.linearYoneda R C).comp
    ((CategoryTheory.whiskeringRight Cᵒᵖ (ModuleCat R) (Type v)).obj (CategoryTheory.forget (ModuleCat R))) =
  CategoryTheory.yoneda
-- CategoryTheory.whiskering_linearYoneda₂
@[simp]
theorem whiskering_linearYoneda₂ :
    linearYoneda R C ⋙ (whiskeringRight _ _ _).obj (forget₂ (ModuleCat.{v} R) AddCommGrp.{v}) =
      preadditiveYoneda 
Arguments: (R : Type w) [Ring R] (C : Type u) [CategoryTheory.Category.{v, u} C] [CategoryTheory.Preadditive C] [CategoryTheory.Linear R C]
Goal: (CategoryTheory.linearYoneda R C).comp
    ((CategoryTheory.whiskeringRight Cᵒᵖ (ModuleCat R) AddCommGrp).obj
      (CategoryTheory.forget₂ (ModuleCat R) AddCommGrp)) =
  CategoryTheory.preadditiveYoneda
-- CategoryTheory.whiskering_linearCoyoneda
@[simp]
theorem whiskering_linearCoyoneda :
    linearCoyoneda R C ⋙ (whiskeringRight _ _ _).obj (forget (ModuleCat.{v} R)) = coyoneda 
Arguments: (R : Type w) [Ring R] (C : Type u) [CategoryTheory.Category.{v, u} C] [CategoryTheory.Preadditive C] [CategoryTheory.Linear R C]
Goal: (CategoryTheory.linearCoyoneda R C).comp
    ((CategoryTheory.whiskeringRight C (ModuleCat R) (Type v)).obj (CategoryTheory.forget (ModuleCat R))) =
  CategoryTheory.coyoneda
-- CategoryTheory.whiskering_linearCoyoneda₂
@[simp]
theorem whiskering_linearCoyoneda₂ :
    linearCoyoneda R C ⋙
        (whiskeringRight _ _ _).obj (forget₂ (ModuleCat.{v} R) AddCommGrp.{v}) =
      preadditiveCoyoneda 
Arguments: (R : Type w) [Ring R] (C : Type u) [CategoryTheory.Category.{v, u} C] [CategoryTheory.Preadditive C] [CategoryTheory.Linear R C]
Goal: (CategoryTheory.linearCoyoneda R C).comp
    ((CategoryTheory.whiskeringRight C (ModuleCat R) AddCommGrp).obj
      (CategoryTheory.forget₂ (ModuleCat R) AddCommGrp)) =
  CategoryTheory.preadditiveCoyoneda
-- CategoryTheory.WithTerminal.down_id
@[simp] lemma down_id {X : C} : down (𝟙 (of X)) = 𝟙 X 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] {X : C}
Goal: CategoryTheory.WithTerminal.down (CategoryTheory.CategoryStruct.id (CategoryTheory.WithTerminal.of X)) =
  CategoryTheory.CategoryStruct.id X
-- CategoryTheory.WithTerminal.down_comp
@[simp] lemma down_comp {X Y Z : C} (f : of X ⟶ of Y) (g : of Y ⟶ of Z) :
    down (f ≫ g) = down f ≫ down g 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] {X Y Z : C} (f : CategoryTheory.WithTerminal.of X ⟶ CategoryTheory.WithTerminal.of Y) (g : CategoryTheory.WithTerminal.of Y ⟶ CategoryTheory.WithTerminal.of Z)
Goal: CategoryTheory.WithTerminal.down (CategoryTheory.CategoryStruct.comp f g) =
  CategoryTheory.CategoryStruct.comp (CategoryTheory.WithTerminal.down f) (CategoryTheory.WithTerminal.down g)
-- CategoryTheory.WithTerminal.false_of_from_star
@[aesop safe destruct (rule_sets := [CategoryTheory])]
lemma false_of_from_star {X : C} (f : star ⟶ of X) : False 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] {X : C} (f : CategoryTheory.WithTerminal.star ⟶ CategoryTheory.WithTerminal.of X)
Goal: False
-- CategoryTheory.WithTerminal.map_map
@[simps]
def map {D : Type*} [Category D] (F : C ⥤ D) : WithTerminal C ⥤ WithTerminal D 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] {D : Type u_1} [CategoryTheory.Category.{u_2, u_1} D] (F : CategoryTheory.Functor C D) {X Y : CategoryTheory.WithTerminal C} (f : X ⟶ Y)
Goal: (CategoryTheory.WithTerminal.map F).map f =
  match X, Y, f with
  | CategoryTheory.WithTerminal.of x, CategoryTheory.WithTerminal.of y, f => F.map (CategoryTheory.WithTerminal.down f)
  | CategoryTheory.WithTerminal.of a, CategoryTheory.WithTerminal.star, x => PUnit.unit
  | CategoryTheory.WithTerminal.star, CategoryTheory.WithTerminal.star, x => PUnit.unit
-- CategoryTheory.WithTerminal.map_obj
@[simps]
def map {D : Type*} [Category D] (F : C ⥤ D) : WithTerminal C ⥤ WithTerminal D 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] {D : Type u_1} [CategoryTheory.Category.{u_2, u_1} D] (F : CategoryTheory.Functor C D) (X : CategoryTheory.WithTerminal C)
Goal: (CategoryTheory.WithTerminal.map F).obj X =
  match X with
  | CategoryTheory.WithTerminal.of x => CategoryTheory.WithTerminal.of (F.obj x)
  | CategoryTheory.WithTerminal.star => CategoryTheory.WithTerminal.star
-- CategoryTheory.WithTerminal.mapId_hom_app
@[simps!]
def mapId (C : Type*) [Category C] : map (𝟭 C) ≅ 𝟭 (WithTerminal C) 
Arguments: (C : Type u_1) [CategoryTheory.Category.{u_2, u_1} C] (X : CategoryTheory.WithTerminal C)
Goal: (CategoryTheory.WithTerminal.mapId C).hom.app X =
  (match X with
    | CategoryTheory.WithTerminal.of x => CategoryTheory.Iso.refl (CategoryTheory.WithTerminal.of x)
    | CategoryTheory.WithTerminal.star => CategoryTheory.Iso.refl CategoryTheory.WithTerminal.star).hom
-- CategoryTheory.WithTerminal.mapId_inv_app
@[simps!]
def mapId (C : Type*) [Category C] : map (𝟭 C) ≅ 𝟭 (WithTerminal C) 
Arguments: (C : Type u_1) [CategoryTheory.Category.{u_2, u_1} C] (X : CategoryTheory.WithTerminal C)
Goal: (CategoryTheory.WithTerminal.mapId C).inv.app X =
  (match X with
    | CategoryTheory.WithTerminal.of x => CategoryTheory.Iso.refl (CategoryTheory.WithTerminal.of x)
    | CategoryTheory.WithTerminal.star => CategoryTheory.Iso.refl CategoryTheory.WithTerminal.star).inv
-- CategoryTheory.WithTerminal.mapComp_inv_app
@[simps!]
def mapComp {D E : Type*} [Category D] [Category E] (F : C ⥤ D) (G : D ⥤ E) :
    map (F ⋙ G) ≅ map F ⋙ map G 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] {D : Type u_1} {E : Type u_2} [CategoryTheory.Category.{u_3, u_1} D] [CategoryTheory.Category.{u_4, u_2} E] (F : CategoryTheory.Functor C D) (G : CategoryTheory.Functor D E) (X : CategoryTheory.WithTerminal C)
Goal: (CategoryTheory.WithTerminal.mapComp F G).inv.app X =
  (match X with
    | CategoryTheory.WithTerminal.of x => CategoryTheory.Iso.refl (CategoryTheory.WithTerminal.of (G.obj (F.obj x)))
    | CategoryTheory.WithTerminal.star => CategoryTheory.Iso.refl CategoryTheory.WithTerminal.star).inv
-- CategoryTheory.WithTerminal.mapComp_hom_app
@[simps!]
def mapComp {D E : Type*} [Category D] [Category E] (F : C ⥤ D) (G : D ⥤ E) :
    map (F ⋙ G) ≅ map F ⋙ map G 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] {D : Type u_1} {E : Type u_2} [CategoryTheory.Category.{u_3, u_1} D] [CategoryTheory.Category.{u_4, u_2} E] (F : CategoryTheory.Functor C D) (G : CategoryTheory.Functor D E) (X : CategoryTheory.WithTerminal C)
Goal: (CategoryTheory.WithTerminal.mapComp F G).hom.app X =
  (match X with
    | CategoryTheory.WithTerminal.of x => CategoryTheory.Iso.refl (CategoryTheory.WithTerminal.of (G.obj (F.obj x)))
    | CategoryTheory.WithTerminal.star => CategoryTheory.Iso.refl CategoryTheory.WithTerminal.star).hom
-- CategoryTheory.WithTerminal.map₂_app
@[simps]
def map₂ {D : Type*} [Category D] {F G : C ⥤ D} (η : F ⟶ G) : map F ⟶ map G 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] {D : Type u_1} [CategoryTheory.Category.{u_2, u_1} D] {F G : CategoryTheory.Functor C D} (η : F ⟶ G) (X : CategoryTheory.WithTerminal C)
Goal: (CategoryTheory.WithTerminal.map₂ η).app X =
  match X with
  | CategoryTheory.WithTerminal.of x => η.app x
  | CategoryTheory.WithTerminal.star => CategoryTheory.CategoryStruct.id CategoryTheory.WithTerminal.star
-- CategoryTheory.WithTerminal.prelaxfunctor_toPrelaxFunctorStruct_map₂
@[simps]
def prelaxfunctor : PrelaxFunctor Cat Cat 
Goal: ∀ {a b : CategoryTheory.Cat} {f g : a ⟶ b} (η : f ⟶ g),
  CategoryTheory.WithTerminal.prelaxfunctor.map₂ η = CategoryTheory.WithTerminal.map₂ η
-- CategoryTheory.WithTerminal.prelaxfunctor_toPrelaxFunctorStruct_toPrefunctor_map
@[simps]
def prelaxfunctor : PrelaxFunctor Cat Cat 
Goal: ∀ {X Y : CategoryTheory.Cat} (F : CategoryTheory.Functor ↑X ↑Y),
  CategoryTheory.WithTerminal.prelaxfunctor.map F = CategoryTheory.WithTerminal.map F
-- CategoryTheory.WithTerminal.prelaxfunctor_toPrelaxFunctorStruct_toPrefunctor_obj
@[simps]
def prelaxfunctor : PrelaxFunctor Cat Cat 
Arguments: (C : CategoryTheory.Cat)
Goal: CategoryTheory.WithTerminal.prelaxfunctor.obj C = CategoryTheory.Cat.of (CategoryTheory.WithTerminal ↑C)
-- CategoryTheory.WithTerminal.pseudofunctor_mapComp
@[simps]
def pseudofunctor : Pseudofunctor Cat Cat 
Goal: ∀ {a b c : CategoryTheory.Cat} (F : CategoryTheory.Functor ↑a ↑b) (G : CategoryTheory.Functor ↑b ↑c),
  CategoryTheory.WithTerminal.pseudofunctor.mapComp F G = CategoryTheory.WithTerminal.mapComp F G
-- CategoryTheory.WithTerminal.pseudofunctor_toPrelaxFunctor
@[simps]
def pseudofunctor : Pseudofunctor Cat Cat 
Goal: CategoryTheory.WithTerminal.pseudofunctor.toPrelaxFunctor = CategoryTheory.WithTerminal.prelaxfunctor
-- CategoryTheory.WithTerminal.pseudofunctor_mapId
@[simps]
def pseudofunctor : Pseudofunctor Cat Cat 
Arguments: (C : CategoryTheory.Cat)
Goal: CategoryTheory.WithTerminal.pseudofunctor.mapId C = CategoryTheory.WithTerminal.mapId ↑C
-- CategoryTheory.WithTerminal.lift_obj
@[simps]
def lift {D : Type*} [Category D] {Z : D} (F : C ⥤ D) (M : ∀ x : C, F.obj x ⟶ Z)
    (hM : ∀ (x y : C) (f : x ⟶ y), F.map f ≫ M y = M x) : WithTerminal C ⥤ D 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] {D : Type u_1} [CategoryTheory.Category.{u_2, u_1} D] {Z : D} (F : CategoryTheory.Functor C D) (M : (x : C) → F.obj x ⟶ Z) (hM : ∀ (x y : C) (f : x ⟶ y), CategoryTheory.CategoryStruct.comp (F.map f) (M y) = M x) (X : CategoryTheory.WithTerminal C)
Goal: (CategoryTheory.WithTerminal.lift F M hM).obj X =
  match X with
  | CategoryTheory.WithTerminal.of x => F.obj x
  | CategoryTheory.WithTerminal.star => Z
-- CategoryTheory.WithTerminal.lift_map
@[simps]
def lift {D : Type*} [Category D] {Z : D} (F : C ⥤ D) (M : ∀ x : C, F.obj x ⟶ Z)
    (hM : ∀ (x y : C) (f : x ⟶ y), F.map f ≫ M y = M x) : WithTerminal C ⥤ D 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] {D : Type u_1} [CategoryTheory.Category.{u_2, u_1} D] {Z : D} (F : CategoryTheory.Functor C D) (M : (x : C) → F.obj x ⟶ Z) (hM : ∀ (x y : C) (f : x ⟶ y), CategoryTheory.CategoryStruct.comp (F.map f) (M y) = M x) {X Y : CategoryTheory.WithTerminal C} (f : X ⟶ Y)
Goal: (CategoryTheory.WithTerminal.lift F M hM).map f =
  match X, Y, f with
  | CategoryTheory.WithTerminal.of x, CategoryTheory.WithTerminal.of y, f => F.map (CategoryTheory.WithTerminal.down f)
  | CategoryTheory.WithTerminal.of x, CategoryTheory.WithTerminal.star, x_1 => M x
  | CategoryTheory.WithTerminal.star, CategoryTheory.WithTerminal.star, x => CategoryTheory.CategoryStruct.id Z
-- CategoryTheory.WithTerminal.inclLift_inv_app
@[simps!]
def inclLift {D : Type*} [Category D] {Z : D} (F : C ⥤ D) (M : ∀ x : C, F.obj x ⟶ Z)
    (hM : ∀ (x y : C) (f : x ⟶ y), F.map f ≫ M y = M x) : incl ⋙ lift F M hM ≅ F 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] {D : Type u_1} [CategoryTheory.Category.{u_2, u_1} D] {Z : D} (F : CategoryTheory.Functor C D) (M : (x : C) → F.obj x ⟶ Z) (hM : ∀ (x y : C) (f : x ⟶ y), CategoryTheory.CategoryStruct.comp (F.map f) (M y) = M x) (X : C)
Goal: (CategoryTheory.WithTerminal.inclLift F M hM).inv.app X = CategoryTheory.CategoryStruct.id (F.obj X)
-- CategoryTheory.WithTerminal.inclLift_hom_app
@[simps!]
def inclLift {D : Type*} [Category D] {Z : D} (F : C ⥤ D) (M : ∀ x : C, F.obj x ⟶ Z)
    (hM : ∀ (x y : C) (f : x ⟶ y), F.map f ≫ M y = M x) : incl ⋙ lift F M hM ≅ F 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] {D : Type u_1} [CategoryTheory.Category.{u_2, u_1} D] {Z : D} (F : CategoryTheory.Functor C D) (M : (x : C) → F.obj x ⟶ Z) (hM : ∀ (x y : C) (f : x ⟶ y), CategoryTheory.CategoryStruct.comp (F.map f) (M y) = M x) (X : C)
Goal: (CategoryTheory.WithTerminal.inclLift F M hM).hom.app X =
  CategoryTheory.CategoryStruct.id
    (match CategoryTheory.WithTerminal.incl.obj X with
    | CategoryTheory.WithTerminal.of x => F.obj x
    | CategoryTheory.WithTerminal.star => Z)
-- CategoryTheory.WithTerminal.liftStar_hom
@[simps!]
def liftStar {D : Type*} [Category D] {Z : D} (F : C ⥤ D) (M : ∀ x : C, F.obj x ⟶ Z)
    (hM : ∀ (x y : C) (f : x ⟶ y), F.map f ≫ M y = M x) : (lift F M hM).obj star ≅ Z 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] {D : Type u_1} [CategoryTheory.Category.{u_2, u_1} D] {Z : D} (F : CategoryTheory.Functor C D) (M : (x : C) → F.obj x ⟶ Z) (hM : ∀ (x y : C) (f : x ⟶ y), CategoryTheory.CategoryStruct.comp (F.map f) (M y) = M x)
Goal: (CategoryTheory.WithTerminal.liftStar F M hM).hom = CategoryTheory.CategoryStruct.id Z
-- CategoryTheory.WithTerminal.liftStar_inv
@[simps!]
def liftStar {D : Type*} [Category D] {Z : D} (F : C ⥤ D) (M : ∀ x : C, F.obj x ⟶ Z)
    (hM : ∀ (x y : C) (f : x ⟶ y), F.map f ≫ M y = M x) : (lift F M hM).obj star ≅ Z 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] {D : Type u_1} [CategoryTheory.Category.{u_2, u_1} D] {Z : D} (F : CategoryTheory.Functor C D) (M : (x : C) → F.obj x ⟶ Z) (hM : ∀ (x y : C) (f : x ⟶ y), CategoryTheory.CategoryStruct.comp (F.map f) (M y) = M x)
Goal: (CategoryTheory.WithTerminal.liftStar F M hM).inv = CategoryTheory.CategoryStruct.id Z
-- CategoryTheory.WithTerminal.lift_map_liftStar
theorem lift_map_liftStar {D : Type*} [Category D] {Z : D} (F : C ⥤ D) (M : ∀ x : C, F.obj x ⟶ Z)
    (hM : ∀ (x y : C) (f : x ⟶ y), F.map f ≫ M y = M x) (x : C) :
    (lift F M hM).map (starTerminal.from (incl.obj x)) ≫ (liftStar F M hM).hom =
      (inclLift F M hM).hom.app x ≫ M x 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] {D : Type u_1} [CategoryTheory.Category.{u_2, u_1} D] {Z : D} (F : CategoryTheory.Functor C D) (M : (x : C) → F.obj x ⟶ Z) (hM : ∀ (x y : C) (f : x ⟶ y), CategoryTheory.CategoryStruct.comp (F.map f) (M y) = M x) (x : C)
Goal: CategoryTheory.CategoryStruct.comp
    ((CategoryTheory.WithTerminal.lift F M hM).map
      (CategoryTheory.WithTerminal.starTerminal.from (CategoryTheory.WithTerminal.incl.obj x)))
    (CategoryTheory.WithTerminal.liftStar F M hM).hom =
  CategoryTheory.CategoryStruct.comp ((CategoryTheory.WithTerminal.inclLift F M hM).hom.app x) (M x)
-- CategoryTheory.WithTerminal.liftToTerminal_map
@[simps!]
def liftToTerminal {D : Type*} [Category D] {Z : D} (F : C ⥤ D) (hZ : Limits.IsTerminal Z) :
    WithTerminal C ⥤ D 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] {D : Type u_1} [CategoryTheory.Category.{u_2, u_1} D] {Z : D} (F : CategoryTheory.Functor C D) (hZ : CategoryTheory.Limits.IsTerminal Z) {X Y : CategoryTheory.WithTerminal C} (f : X ⟶ Y)
Goal: (CategoryTheory.WithTerminal.liftToTerminal F hZ).map f =
  match X, Y, f with
  | CategoryTheory.WithTerminal.of x, CategoryTheory.WithTerminal.of y, f => F.map (CategoryTheory.WithTerminal.down f)
  | CategoryTheory.WithTerminal.of x, CategoryTheory.WithTerminal.star, x_1 => hZ.from (F.obj x)
  | CategoryTheory.WithTerminal.star, CategoryTheory.WithTerminal.star, x => CategoryTheory.CategoryStruct.id Z
-- CategoryTheory.WithTerminal.liftToTerminal_obj
@[simps!]
def liftToTerminal {D : Type*} [Category D] {Z : D} (F : C ⥤ D) (hZ : Limits.IsTerminal Z) :
    WithTerminal C ⥤ D 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] {D : Type u_1} [CategoryTheory.Category.{u_2, u_1} D] {Z : D} (F : CategoryTheory.Functor C D) (hZ : CategoryTheory.Limits.IsTerminal Z) (X : CategoryTheory.WithTerminal C)
Goal: (CategoryTheory.WithTerminal.liftToTerminal F hZ).obj X =
  match X with
  | CategoryTheory.WithTerminal.of x => F.obj x
  | CategoryTheory.WithTerminal.star => Z
-- CategoryTheory.WithTerminal.inclLiftToTerminal_hom_app
@[simps!]
def inclLiftToTerminal {D : Type*} [Category D] {Z : D} (F : C ⥤ D) (hZ : Limits.IsTerminal Z) :
    incl ⋙ liftToTerminal F hZ ≅ F 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] {D : Type u_1} [CategoryTheory.Category.{u_2, u_1} D] {Z : D} (F : CategoryTheory.Functor C D) (hZ : CategoryTheory.Limits.IsTerminal Z) (X : C)
Goal: (CategoryTheory.WithTerminal.inclLiftToTerminal F hZ).hom.app X =
  CategoryTheory.CategoryStruct.id
    (match CategoryTheory.WithTerminal.incl.obj X with
    | CategoryTheory.WithTerminal.of x => F.obj x
    | CategoryTheory.WithTerminal.star => Z)
-- CategoryTheory.WithTerminal.inclLiftToTerminal_inv_app
@[simps!]
def inclLiftToTerminal {D : Type*} [Category D] {Z : D} (F : C ⥤ D) (hZ : Limits.IsTerminal Z) :
    incl ⋙ liftToTerminal F hZ ≅ F 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] {D : Type u_1} [CategoryTheory.Category.{u_2, u_1} D] {Z : D} (F : CategoryTheory.Functor C D) (hZ : CategoryTheory.Limits.IsTerminal Z) (X : C)
Goal: (CategoryTheory.WithTerminal.inclLiftToTerminal F hZ).inv.app X = CategoryTheory.CategoryStruct.id (F.obj X)
-- CategoryTheory.WithTerminal.liftToTerminalUnique_hom_app
@[simps!]
def liftToTerminalUnique {D : Type*} [Category D] {Z : D} (F : C ⥤ D) (hZ : Limits.IsTerminal Z)
    (G : WithTerminal C ⥤ D) (h : incl ⋙ G ≅ F) (hG : G.obj star ≅ Z) : G ≅ liftToTerminal F hZ 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] {D : Type u_1} [CategoryTheory.Category.{u_2, u_1} D] {Z : D} (F : CategoryTheory.Functor C D) (hZ : CategoryTheory.Limits.IsTerminal Z) (G : CategoryTheory.Functor (CategoryTheory.WithTerminal C) D) (h : CategoryTheory.WithTerminal.incl.comp G ≅ F) (hG : G.obj CategoryTheory.WithTerminal.star ≅ Z) (X : CategoryTheory.WithTerminal C)
Goal: (CategoryTheory.WithTerminal.liftToTerminalUnique F hZ G h hG).hom.app X =
  (match X with
    | CategoryTheory.WithTerminal.of x => h.app x
    | CategoryTheory.WithTerminal.star => hG).hom
-- CategoryTheory.WithTerminal.liftToTerminalUnique_inv_app
@[simps!]
def liftToTerminalUnique {D : Type*} [Category D] {Z : D} (F : C ⥤ D) (hZ : Limits.IsTerminal Z)
    (G : WithTerminal C ⥤ D) (h : incl ⋙ G ≅ F) (hG : G.obj star ≅ Z) : G ≅ liftToTerminal F hZ 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] {D : Type u_1} [CategoryTheory.Category.{u_2, u_1} D] {Z : D} (F : CategoryTheory.Functor C D) (hZ : CategoryTheory.Limits.IsTerminal Z) (G : CategoryTheory.Functor (CategoryTheory.WithTerminal C) D) (h : CategoryTheory.WithTerminal.incl.comp G ≅ F) (hG : G.obj CategoryTheory.WithTerminal.star ≅ Z) (X : CategoryTheory.WithTerminal C)
Goal: (CategoryTheory.WithTerminal.liftToTerminalUnique F hZ G h hG).inv.app X =
  (match X with
    | CategoryTheory.WithTerminal.of x => h.app x
    | CategoryTheory.WithTerminal.star => hG).inv
-- CategoryTheory.WithInitial.down_id
@[simp] lemma down_id {X : C} : down (𝟙 (of X)) = 𝟙 X 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] {X : C}
Goal: CategoryTheory.WithInitial.down (CategoryTheory.CategoryStruct.id (CategoryTheory.WithInitial.of X)) =
  CategoryTheory.CategoryStruct.id X
-- CategoryTheory.WithInitial.down_comp
@[simp] lemma down_comp {X Y Z : C} (f : of X ⟶ of Y) (g : of Y ⟶ of Z) :
    down (f ≫ g) = down f ≫ down g 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] {X Y Z : C} (f : CategoryTheory.WithInitial.of X ⟶ CategoryTheory.WithInitial.of Y) (g : CategoryTheory.WithInitial.of Y ⟶ CategoryTheory.WithInitial.of Z)
Goal: CategoryTheory.WithInitial.down (CategoryTheory.CategoryStruct.comp f g) =
  CategoryTheory.CategoryStruct.comp (CategoryTheory.WithInitial.down f) (CategoryTheory.WithInitial.down g)
-- CategoryTheory.WithInitial.false_of_to_star
@[aesop safe destruct (rule_sets := [CategoryTheory])]
lemma false_of_to_star {X : C} (f : of X ⟶ star) : False 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] {X : C} (f : CategoryTheory.WithInitial.of X ⟶ CategoryTheory.WithInitial.star)
Goal: False