l3lab/ntp-mathlib huggingface dataset:
instance : Category.{v} (WithTerminal C) where
  Hom X Y := Hom X Y
  id X := id _
  comp := comp
  assoc {a b c d} f g h := by
    -- Porting note: it would be nice to automate this away as well.
    -- I tried splitting this into separate `Quiver` and `Category` instances,
    -- so the `false_of_from_star` destruct rule below can be used here.
    -- That works, but causes mysterious failures of `aesop_cat` in `map`.
    cases a <;> cases b <;> cases c <;> cases d <;> try aesop_cat
    · exact (h : PEmpty).elim
    · 

Proof state:
case of.star.of.of
C : Type u
inst✝ : Category.{v, u} C
a✝² : C
f : of a✝² ⟶ star
a✝¹ : C
g : star ⟶ of a✝¹
a✝ : C
h : of a✝¹ ⟶ of a✝
⊢ (f ≫ g) ≫ h = f ≫ g ≫ h

Next tactic:
exact (g : PEmpty).elim
instance : Category.{v} (WithTerminal C) where
  Hom X Y := Hom X Y
  id X := id _
  comp := comp
  assoc {a b c d} f g h := by
    -- Porting note: it would be nice to automate this away as well.
    -- I tried splitting this into separate `Quiver` and `Category` instances,
    -- so the `false_of_from_star` destruct rule below can be used here.
    -- That works, but causes mysterious failures of `aesop_cat` in `map`.
    cases a <;> cases b <;> cases c <;> cases d <;> try aesop_cat
    · exact (h : PEmpty).elim
    · exact (g : PEmpty).elim
    · 

Proof state:
case of.star.star.of
C : Type u
inst✝ : Category.{v, u} C
a✝¹ : C
f : of a✝¹ ⟶ star
g : star ⟶ star
a✝ : C
h : star ⟶ of a✝
⊢ (f ≫ g) ≫ h = f ≫ g ≫ h

Next tactic:
exact (h : PEmpty).elim
instance {X : WithTerminal C} : Unique (X ⟶ star) where
  default :=
    match X with
    | of _ => PUnit.unit
    | star => PUnit.unit
  uniq := by 

Proof state:
C : Type u
inst✝ : Category.{v, u} C
X : WithTerminal C
⊢ ∀ (a : X ⟶ star), a = default

Next tactic:
aesop_cat
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 := by
  

Proof state:
C : Type u
inst✝¹ : Category.{v, u} C
D : Type u_1
inst✝ : Category.{u_2, u_1} 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 (Limits.IsTerminal.from starTerminal (incl.obj x)) ≫ (liftStar F M hM).hom =
    (inclLift F M hM).hom.app x ≫ M x

Next tactic:
erw [Category.id_comp, Category.comp_id]
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 := by
  erw [Category.id_comp, Category.comp_id]
  

Proof state:
C : Type u
inst✝¹ : Category.{v, u} C
D : Type u_1
inst✝ : Category.{u_2, u_1} 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 (Limits.IsTerminal.from starTerminal (incl.obj x)) = M x

Next tactic:
rfl
/-- The uniqueness of `lift`. -/
@[simp]
def liftUnique {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)
    (G : WithTerminal C ⥤ D) (h : incl ⋙ G ≅ F)
    (hG : G.obj star ≅ Z)
    (hh : ∀ x : C, G.map (starTerminal.from (incl.obj x)) ≫ hG.hom = h.hom.app x ≫ M x) :
    G ≅ lift F M hM :=
  NatIso.ofComponents
    (fun X =>
      match X with
      | of x => h.app x
      | star => hG)
    (by
      

Proof state:
C : Type u
inst✝¹ : Category.{v, u} C
D : Type u_1
inst✝ : Category.{?u.143935, u_1} 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
G : WithTerminal C ⥤ D
h : incl ⋙ G ≅ F
hG : G.obj star ≅ Z
hh : ∀ (x : C), G.map (Limits.IsTerminal.from starTerminal (incl.obj x)) ≫ hG.hom = h.hom.app x ≫ M x
⊢ ∀ {X Y : WithTerminal C} (f : X ⟶ Y),
    G.map f ≫
        ((fun X =>
              match X with
              | of x => h.app x
              | star => hG)
            Y).hom =
      ((fun X =>
              match X with
              | of x => h.app x
              | star => hG)
            X).hom ≫
        (lift F M hM).map f

Next tactic:
rintro (X | X) (Y | Y) f
/-- The uniqueness of `lift`. -/
@[simp]
def liftUnique {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)
    (G : WithTerminal C ⥤ D) (h : incl ⋙ G ≅ F)
    (hG : G.obj star ≅ Z)
    (hh : ∀ x : C, G.map (starTerminal.from (incl.obj x)) ≫ hG.hom = h.hom.app x ≫ M x) :
    G ≅ lift F M hM :=
  NatIso.ofComponents
    (fun X =>
      match X with
      | of x => h.app x
      | star => hG)
    (by
      rintro (X | X) (Y | Y) f
      · 

Proof state:
case of.of
C : Type u
inst✝¹ : Category.{v, u} C
D : Type u_1
inst✝ : Category.{?u.143935, u_1} 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
G : WithTerminal C ⥤ D
h : incl ⋙ G ≅ F
hG : G.obj star ≅ Z
hh : ∀ (x : C), G.map (Limits.IsTerminal.from starTerminal (incl.obj x)) ≫ hG.hom = h.hom.app x ≫ M x
X Y : C
f : of X ⟶ of Y
⊢ G.map f ≫
      ((fun X =>
            match X with
            | of x => h.app x
            | star => hG)
          (of Y)).hom =
    ((fun X =>
            match X with
            | of x => h.app x
            | star => hG)
          (of X)).hom ≫
      (lift F M hM).map f

Next tactic:
apply h.hom.naturality
/-- The uniqueness of `lift`. -/
@[simp]
def liftUnique {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)
    (G : WithTerminal C ⥤ D) (h : incl ⋙ G ≅ F)
    (hG : G.obj star ≅ Z)
    (hh : ∀ x : C, G.map (starTerminal.from (incl.obj x)) ≫ hG.hom = h.hom.app x ≫ M x) :
    G ≅ lift F M hM :=
  NatIso.ofComponents
    (fun X =>
      match X with
      | of x => h.app x
      | star => hG)
    (by
      rintro (X | X) (Y | Y) f
      · apply h.hom.naturality
      · 

Proof state:
case of.star
C : Type u
inst✝¹ : Category.{v, u} C
D : Type u_1
inst✝ : Category.{?u.143935, u_1} 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
G : WithTerminal C ⥤ D
h : incl ⋙ G ≅ F
hG : G.obj star ≅ Z
hh : ∀ (x : C), G.map (Limits.IsTerminal.from starTerminal (incl.obj x)) ≫ hG.hom = h.hom.app x ≫ M x
X : C
f : of X ⟶ star
⊢ G.map f ≫
      ((fun X =>
            match X with
            | of x => h.app x
            | star => hG)
          star).hom =
    ((fun X =>
            match X with
            | of x => h.app x
            | star => hG)
          (of X)).hom ≫
      (lift F M hM).map f

Next tactic:
cases f
/-- The uniqueness of `lift`. -/
@[simp]
def liftUnique {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)
    (G : WithTerminal C ⥤ D) (h : incl ⋙ G ≅ F)
    (hG : G.obj star ≅ Z)
    (hh : ∀ x : C, G.map (starTerminal.from (incl.obj x)) ≫ hG.hom = h.hom.app x ≫ M x) :
    G ≅ lift F M hM :=
  NatIso.ofComponents
    (fun X =>
      match X with
      | of x => h.app x
      | star => hG)
    (by
      rintro (X | X) (Y | Y) f
      · apply h.hom.naturality
      · cases f
        

Proof state:
case of.star.unit
C : Type u
inst✝¹ : Category.{v, u} C
D : Type u_1
inst✝ : Category.{?u.143935, u_1} 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
G : WithTerminal C ⥤ D
h : incl ⋙ G ≅ F
hG : G.obj star ≅ Z
hh : ∀ (x : C), G.map (Limits.IsTerminal.from starTerminal (incl.obj x)) ≫ hG.hom = h.hom.app x ≫ M x
X : C
⊢ G.map PUnit.unit ≫
      ((fun X =>
            match X with
            | of x => h.app x
            | star => hG)
          star).hom =
    ((fun X =>
            match X with
            | of x => h.app x
            | star => hG)
          (of X)).hom ≫
      (lift F M hM).map PUnit.unit

Next tactic:
exact hh _
/-- The uniqueness of `lift`. -/
@[simp]
def liftUnique {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)
    (G : WithTerminal C ⥤ D) (h : incl ⋙ G ≅ F)
    (hG : G.obj star ≅ Z)
    (hh : ∀ x : C, G.map (starTerminal.from (incl.obj x)) ≫ hG.hom = h.hom.app x ≫ M x) :
    G ≅ lift F M hM :=
  NatIso.ofComponents
    (fun X =>
      match X with
      | of x => h.app x
      | star => hG)
    (by
      rintro (X | X) (Y | Y) f
      · apply h.hom.naturality
      · cases f
        exact hh _
      · 

Proof state:
case star.of
C : Type u
inst✝¹ : Category.{v, u} C
D : Type u_1
inst✝ : Category.{?u.143935, u_1} 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
G : WithTerminal C ⥤ D
h : incl ⋙ G ≅ F
hG : G.obj star ≅ Z
hh : ∀ (x : C), G.map (Limits.IsTerminal.from starTerminal (incl.obj x)) ≫ hG.hom = h.hom.app x ≫ M x
Y : C
f : star ⟶ of Y
⊢ G.map f ≫
      ((fun X =>
            match X with
            | of x => h.app x
            | star => hG)
          (of Y)).hom =
    ((fun X =>
            match X with
            | of x => h.app x
            | star => hG)
          star).hom ≫
      (lift F M hM).map f

Next tactic:
cases f
/-- The uniqueness of `lift`. -/
@[simp]
def liftUnique {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)
    (G : WithTerminal C ⥤ D) (h : incl ⋙ G ≅ F)
    (hG : G.obj star ≅ Z)
    (hh : ∀ x : C, G.map (starTerminal.from (incl.obj x)) ≫ hG.hom = h.hom.app x ≫ M x) :
    G ≅ lift F M hM :=
  NatIso.ofComponents
    (fun X =>
      match X with
      | of x => h.app x
      | star => hG)
    (by
      rintro (X | X) (Y | Y) f
      · apply h.hom.naturality
      · cases f
        exact hh _
      · cases f
      · 

Proof state:
case star.star
C : Type u
inst✝¹ : Category.{v, u} C
D : Type u_1
inst✝ : Category.{?u.143935, u_1} 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
G : WithTerminal C ⥤ D
h : incl ⋙ G ≅ F
hG : G.obj star ≅ Z
hh : ∀ (x : C), G.map (Limits.IsTerminal.from starTerminal (incl.obj x)) ≫ hG.hom = h.hom.app x ≫ M x
f : star ⟶ star
⊢ G.map f ≫
      ((fun X =>
            match X with
            | of x => h.app x
            | star => hG)
          star).hom =
    ((fun X =>
            match X with
            | of x => h.app x
            | star => hG)
          star).hom ≫
      (lift F M hM).map f

Next tactic:
cases f
/-- The uniqueness of `lift`. -/
@[simp]
def liftUnique {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)
    (G : WithTerminal C ⥤ D) (h : incl ⋙ G ≅ F)
    (hG : G.obj star ≅ Z)
    (hh : ∀ x : C, G.map (starTerminal.from (incl.obj x)) ≫ hG.hom = h.hom.app x ≫ M x) :
    G ≅ lift F M hM :=
  NatIso.ofComponents
    (fun X =>
      match X with
      | of x => h.app x
      | star => hG)
    (by
      rintro (X | X) (Y | Y) f
      · apply h.hom.naturality
      · cases f
        exact hh _
      · cases f
      · cases f
        

Proof state:
case star.star.unit
C : Type u
inst✝¹ : Category.{v, u} C
D : Type u_1
inst✝ : Category.{?u.143935, u_1} 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
G : WithTerminal C ⥤ D
h : incl ⋙ G ≅ F
hG : G.obj star ≅ Z
hh : ∀ (x : C), G.map (Limits.IsTerminal.from starTerminal (incl.obj x)) ≫ hG.hom = h.hom.app x ≫ M x
⊢ G.map PUnit.unit ≫
      ((fun X =>
            match X with
            | of x => h.app x
            | star => hG)
          star).hom =
    ((fun X =>
            match X with
            | of x => h.app x
            | star => hG)
          star).hom ≫
      (lift F M hM).map PUnit.unit

Next tactic:
change G.map (𝟙 _) ≫ hG.hom = hG.hom ≫ 𝟙 _
/-- The uniqueness of `lift`. -/
@[simp]
def liftUnique {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)
    (G : WithTerminal C ⥤ D) (h : incl ⋙ G ≅ F)
    (hG : G.obj star ≅ Z)
    (hh : ∀ x : C, G.map (starTerminal.from (incl.obj x)) ≫ hG.hom = h.hom.app x ≫ M x) :
    G ≅ lift F M hM :=
  NatIso.ofComponents
    (fun X =>
      match X with
      | of x => h.app x
      | star => hG)
    (by
      rintro (X | X) (Y | Y) f
      · apply h.hom.naturality
      · cases f
        exact hh _
      · cases f
      · cases f
        change G.map (𝟙 _) ≫ hG.hom = hG.hom ≫ 𝟙 _
        

Proof state:
case star.star.unit
C : Type u
inst✝¹ : Category.{v, u} C
D : Type u_1
inst✝ : Category.{?u.143935, u_1} 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
G : WithTerminal C ⥤ D
h : incl ⋙ G ≅ F
hG : G.obj star ≅ Z
hh : ∀ (x : C), G.map (Limits.IsTerminal.from starTerminal (incl.obj x)) ≫ hG.hom = h.hom.app x ≫ M x
⊢ G.map (𝟙 star) ≫ hG.hom = hG.hom ≫ 𝟙 Z

Next tactic:
simp
instance : Category.{v} (WithInitial C) where
  Hom X Y := Hom X Y
  id X := id X
  comp f g := comp f g
  assoc {a b c d} f g h := by
    -- Porting note: it would be nice to automate this away as well.
    -- See the note on `Category (WithTerminal C)`
    

Proof state:
C : Type u
inst✝ : Category.{v, u} C
a b c d : WithInitial C
f : a ⟶ b
g : b ⟶ c
h : c ⟶ d
⊢ (f ≫ g) ≫ h = f ≫ g ≫ h

Next tactic:
cases a
instance : Category.{v} (WithInitial C) where
  Hom X Y := Hom X Y
  id X := id X
  comp f g := comp f g
  assoc {a b c d} f g h := by
    -- Porting note: it would be nice to automate this away as well.
    -- See the note on `Category (WithTerminal C)`
    cases a <;> 

Proof state:
case of
C : Type u
inst✝ : Category.{v, u} C
b c d : WithInitial C
g : b ⟶ c
h : c ⟶ d
a✝ : C
f : of a✝ ⟶ b
⊢ (f ≫ g) ≫ h = f ≫ g ≫ h

Next tactic:
cases b
instance : Category.{v} (WithInitial C) where
  Hom X Y := Hom X Y
  id X := id X
  comp f g := comp f g
  assoc {a b c d} f g h := by
    -- Porting note: it would be nice to automate this away as well.
    -- See the note on `Category (WithTerminal C)`
    cases a <;> 

Proof state:
case star
C : Type u
inst✝ : Category.{v, u} C
b c d : WithInitial C
g : b ⟶ c
h : c ⟶ d
f : star ⟶ b
⊢ (f ≫ g) ≫ h = f ≫ g ≫ h

Next tactic:
cases b
instance : Category.{v} (WithInitial C) where
  Hom X Y := Hom X Y
  id X := id X
  comp f g := comp f g
  assoc {a b c d} f g h := by
    -- Porting note: it would be nice to automate this away as well.
    -- See the note on `Category (WithTerminal C)`
    cases a <;> cases b <;> 

Proof state:
case of.of
C : Type u
inst✝ : Category.{v, u} C
c d : WithInitial C
h : c ⟶ d
a✝¹ a✝ : C
g : of a✝ ⟶ c
f : of a✝¹ ⟶ of a✝
⊢ (f ≫ g) ≫ h = f ≫ g ≫ h

Next tactic:
cases c
instance : Category.{v} (WithInitial C) where
  Hom X Y := Hom X Y
  id X := id X
  comp f g := comp f g
  assoc {a b c d} f g h := by
    -- Porting note: it would be nice to automate this away as well.
    -- See the note on `Category (WithTerminal C)`
    cases a <;> cases b <;> 

Proof state:
case of.star
C : Type u
inst✝ : Category.{v, u} C
c d : WithInitial C
h : c ⟶ d
a✝ : C
g : star ⟶ c
f : of a✝ ⟶ star
⊢ (f ≫ g) ≫ h = f ≫ g ≫ h

Next tactic:
cases c
instance : Category.{v} (WithInitial C) where
  Hom X Y := Hom X Y
  id X := id X
  comp f g := comp f g
  assoc {a b c d} f g h := by
    -- Porting note: it would be nice to automate this away as well.
    -- See the note on `Category (WithTerminal C)`
    cases a <;> cases b <;> 

Proof state:
case star.of
C : Type u
inst✝ : Category.{v, u} C
c d : WithInitial C
h : c ⟶ d
a✝ : C
g : of a✝ ⟶ c
f : star ⟶ of a✝
⊢ (f ≫ g) ≫ h = f ≫ g ≫ h

Next tactic:
cases c
instance : Category.{v} (WithInitial C) where
  Hom X Y := Hom X Y
  id X := id X
  comp f g := comp f g
  assoc {a b c d} f g h := by
    -- Porting note: it would be nice to automate this away as well.
    -- See the note on `Category (WithTerminal C)`
    cases a <;> cases b <;> 

Proof state:
case star.star
C : Type u
inst✝ : Category.{v, u} C
c d : WithInitial C
h : c ⟶ d
g : star ⟶ c
f : star ⟶ star
⊢ (f ≫ g) ≫ h = f ≫ g ≫ h

Next tactic:
cases c
instance : Category.{v} (WithInitial C) where
  Hom X Y := Hom X Y
  id X := id X
  comp f g := comp f g
  assoc {a b c d} f g h := by
    -- Porting note: it would be nice to automate this away as well.
    -- See the note on `Category (WithTerminal C)`
    cases a <;> cases b <;> cases c <;> 

Proof state:
case of.of.of
C : Type u
inst✝ : Category.{v, u} C
d : WithInitial C
a✝² a✝¹ : C
f : of a✝² ⟶ of a✝¹
a✝ : C
h : of a✝ ⟶ d
g : of a✝¹ ⟶ of a✝
⊢ (f ≫ g) ≫ h = f ≫ g ≫ h

Next tactic:
cases d
instance : Category.{v} (WithInitial C) where
  Hom X Y := Hom X Y
  id X := id X
  comp f g := comp f g
  assoc {a b c d} f g h := by
    -- Porting note: it would be nice to automate this away as well.
    -- See the note on `Category (WithTerminal C)`
    cases a <;> cases b <;> cases c <;> 

Proof state:
case of.of.star
C : Type u
inst✝ : Category.{v, u} C
d : WithInitial C
a✝¹ a✝ : C
f : of a✝¹ ⟶ of a✝
h : star ⟶ d
g : of a✝ ⟶ star
⊢ (f ≫ g) ≫ h = f ≫ g ≫ h

Next tactic:
cases d
instance : Category.{v} (WithInitial C) where
  Hom X Y := Hom X Y
  id X := id X
  comp f g := comp f g
  assoc {a b c d} f g h := by
    -- Porting note: it would be nice to automate this away as well.
    -- See the note on `Category (WithTerminal C)`
    cases a <;> cases b <;> cases c <;> 

Proof state:
case of.star.of
C : Type u
inst✝ : Category.{v, u} C
d : WithInitial C
a✝¹ : C
f : of a✝¹ ⟶ star
a✝ : C
h : of a✝ ⟶ d
g : star ⟶ of a✝
⊢ (f ≫ g) ≫ h = f ≫ g ≫ h

Next tactic:
cases d
instance : Category.{v} (WithInitial C) where
  Hom X Y := Hom X Y
  id X := id X
  comp f g := comp f g
  assoc {a b c d} f g h := by
    -- Porting note: it would be nice to automate this away as well.
    -- See the note on `Category (WithTerminal C)`
    cases a <;> cases b <;> cases c <;> 

Proof state:
case of.star.star
C : Type u
inst✝ : Category.{v, u} C
d : WithInitial C
a✝ : C
f : of a✝ ⟶ star
h : star ⟶ d
g : star ⟶ star
⊢ (f ≫ g) ≫ h = f ≫ g ≫ h

Next tactic:
cases d
instance : Category.{v} (WithInitial C) where
  Hom X Y := Hom X Y
  id X := id X
  comp f g := comp f g
  assoc {a b c d} f g h := by
    -- Porting note: it would be nice to automate this away as well.
    -- See the note on `Category (WithTerminal C)`
    cases a <;> cases b <;> cases c <;> 

Proof state:
case star.of.of
C : Type u
inst✝ : Category.{v, u} C
d : WithInitial C
a✝¹ : C
f : star ⟶ of a✝¹
a✝ : C
h : of a✝ ⟶ d
g : of a✝¹ ⟶ of a✝
⊢ (f ≫ g) ≫ h = f ≫ g ≫ h

Next tactic:
cases d
instance : Category.{v} (WithInitial C) where
  Hom X Y := Hom X Y
  id X := id X
  comp f g := comp f g
  assoc {a b c d} f g h := by
    -- Porting note: it would be nice to automate this away as well.
    -- See the note on `Category (WithTerminal C)`
    cases a <;> cases b <;> cases c <;> 

Proof state:
case star.of.star
C : Type u
inst✝ : Category.{v, u} C
d : WithInitial C
a✝ : C
f : star ⟶ of a✝
h : star ⟶ d
g : of a✝ ⟶ star
⊢ (f ≫ g) ≫ h = f ≫ g ≫ h

Next tactic:
cases d
instance : Category.{v} (WithInitial C) where
  Hom X Y := Hom X Y
  id X := id X
  comp f g := comp f g
  assoc {a b c d} f g h := by
    -- Porting note: it would be nice to automate this away as well.
    -- See the note on `Category (WithTerminal C)`
    cases a <;> cases b <;> cases c <;> 

Proof state:
case star.star.of
C : Type u
inst✝ : Category.{v, u} C
d : WithInitial C
f : star ⟶ star
a✝ : C
h : of a✝ ⟶ d
g : star ⟶ of a✝
⊢ (f ≫ g) ≫ h = f ≫ g ≫ h

Next tactic:
cases d
instance : Category.{v} (WithInitial C) where
  Hom X Y := Hom X Y
  id X := id X
  comp f g := comp f g
  assoc {a b c d} f g h := by
    -- Porting note: it would be nice to automate this away as well.
    -- See the note on `Category (WithTerminal C)`
    cases a <;> cases b <;> cases c <;> 

Proof state:
case star.star.star
C : Type u
inst✝ : Category.{v, u} C
d : WithInitial C
f : star ⟶ star
h : star ⟶ d
g : star ⟶ star
⊢ (f ≫ g) ≫ h = f ≫ g ≫ h

Next tactic:
cases d
instance : Category.{v} (WithInitial C) where
  Hom X Y := Hom X Y
  id X := id X
  comp f g := comp f g
  assoc {a b c d} f g h := by
    -- Porting note: it would be nice to automate this away as well.
    -- See the note on `Category (WithTerminal C)`
    cases a <;> cases b <;> cases c <;> cases d <;> 

Proof state:
case of.of.of.of
C : Type u
inst✝ : Category.{v, u} C
a✝³ a✝² : C
f : of a✝³ ⟶ of a✝²
a✝¹ : C
g : of a✝² ⟶ of a✝¹
a✝ : C
h : of a✝¹ ⟶ of a✝
⊢ (f ≫ g) ≫ h = f ≫ g ≫ h

Next tactic:
try aesop_cat
instance : Category.{v} (WithInitial C) where
  Hom X Y := Hom X Y
  id X := id X
  comp f g := comp f g
  assoc {a b c d} f g h := by
    -- Porting note: it would be nice to automate this away as well.
    -- See the note on `Category (WithTerminal C)`
    cases a <;> cases b <;> cases c <;> cases d <;> try 

Proof state:
case of.of.of.of
C : Type u
inst✝ : Category.{v, u} C
a✝³ a✝² : C
f : of a✝³ ⟶ of a✝²
a✝¹ : C
g : of a✝² ⟶ of a✝¹
a✝ : C
h : of a✝¹ ⟶ of a✝
⊢ (f ≫ g) ≫ h = f ≫ g ≫ h

Next tactic:
aesop_cat
instance : Category.{v} (WithInitial C) where
  Hom X Y := Hom X Y
  id X := id X
  comp f g := comp f g
  assoc {a b c d} f g h := by
    -- Porting note: it would be nice to automate this away as well.
    -- See the note on `Category (WithTerminal C)`
    cases a <;> cases b <;> cases c <;> cases d <;> 

Proof state:
case of.of.of.star
C : Type u
inst✝ : Category.{v, u} C
a✝² a✝¹ : C
f : of a✝² ⟶ of a✝¹
a✝ : C
g : of a✝¹ ⟶ of a✝
h : of a✝ ⟶ star
⊢ (f ≫ g) ≫ h = f ≫ g ≫ h

Next tactic:
try aesop_cat
instance : Category.{v} (WithInitial C) where
  Hom X Y := Hom X Y
  id X := id X
  comp f g := comp f g
  assoc {a b c d} f g h := by
    -- Porting note: it would be nice to automate this away as well.
    -- See the note on `Category (WithTerminal C)`
    cases a <;> cases b <;> cases c <;> cases d <;> try 

Proof state:
case of.of.of.star
C : Type u
inst✝ : Category.{v, u} C
a✝² a✝¹ : C
f : of a✝² ⟶ of a✝¹
a✝ : C
g : of a✝¹ ⟶ of a✝
h : of a✝ ⟶ star
⊢ (f ≫ g) ≫ h = f ≫ g ≫ h

Next tactic:
aesop_cat
instance : Category.{v} (WithInitial C) where
  Hom X Y := Hom X Y
  id X := id X
  comp f g := comp f g
  assoc {a b c d} f g h := by
    -- Porting note: it would be nice to automate this away as well.
    -- See the note on `Category (WithTerminal C)`
    cases a <;> cases b <;> cases c <;> cases d <;> 

Proof state:
case of.of.star.of
C : Type u
inst✝ : Category.{v, u} C
a✝² a✝¹ : C
f : of a✝² ⟶ of a✝¹
g : of a✝¹ ⟶ star
a✝ : C
h : star ⟶ of a✝
⊢ (f ≫ g) ≫ h = f ≫ g ≫ h

Next tactic:
try aesop_cat
instance : Category.{v} (WithInitial C) where
  Hom X Y := Hom X Y
  id X := id X
  comp f g := comp f g
  assoc {a b c d} f g h := by
    -- Porting note: it would be nice to automate this away as well.
    -- See the note on `Category (WithTerminal C)`
    cases a <;> cases b <;> cases c <;> cases d <;> try 

Proof state:
case of.of.star.of
C : Type u
inst✝ : Category.{v, u} C
a✝² a✝¹ : C
f : of a✝² ⟶ of a✝¹
g : of a✝¹ ⟶ star
a✝ : C
h : star ⟶ of a✝
⊢ (f ≫ g) ≫ h = f ≫ g ≫ h

Next tactic:
aesop_cat
instance : Category.{v} (WithInitial C) where
  Hom X Y := Hom X Y
  id X := id X
  comp f g := comp f g
  assoc {a b c d} f g h := by
    -- Porting note: it would be nice to automate this away as well.
    -- See the note on `Category (WithTerminal C)`
    cases a <;> cases b <;> cases c <;> cases d <;> 

Proof state:
case of.of.star.star
C : Type u
inst✝ : Category.{v, u} C
a✝¹ a✝ : C
f : of a✝¹ ⟶ of a✝
g : of a✝ ⟶ star
h : star ⟶ star
⊢ (f ≫ g) ≫ h = f ≫ g ≫ h

Next tactic:
try aesop_cat
instance : Category.{v} (WithInitial C) where
  Hom X Y := Hom X Y
  id X := id X
  comp f g := comp f g
  assoc {a b c d} f g h := by
    -- Porting note: it would be nice to automate this away as well.
    -- See the note on `Category (WithTerminal C)`
    cases a <;> cases b <;> cases c <;> cases d <;> try 

Proof state:
case of.of.star.star
C : Type u
inst✝ : Category.{v, u} C
a✝¹ a✝ : C
f : of a✝¹ ⟶ of a✝
g : of a✝ ⟶ star
h : star ⟶ star
⊢ (f ≫ g) ≫ h = f ≫ g ≫ h

Next tactic:
aesop_cat