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 <;> 

Proof state:
case star.of.star
C : Type u
inst✝ : Category.{v, u} C
d : WithTerminal 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} (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 <;> 

Proof state:
case star.star.of
C : Type u
inst✝ : Category.{v, u} C
d : WithTerminal 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} (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 <;> 

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

Next tactic:
cases d
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 <;> 

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} (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 

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} (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 <;> 

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} (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 

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} (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 <;> 

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} (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 

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} (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 <;> 

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} (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 

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
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 <;> 

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:
try aesop_cat
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 

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:
aesop_cat
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 <;> 

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

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

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

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

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:
try aesop_cat
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 

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:
aesop_cat
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 <;> 

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

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

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

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

Proof state:
case star.of.of.of
C : Type u
inst✝ : Category.{v, u} C
a✝² : C
f : star ⟶ 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} (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 

Proof state:
case star.of.of.of
C : Type u
inst✝ : Category.{v, u} C
a✝² : C
f : star ⟶ 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} (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 <;> 

Proof state:
case star.of.of.star
C : Type u
inst✝ : Category.{v, u} C
a✝¹ : C
f : star ⟶ 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} (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 

Proof state:
case star.of.of.star
C : Type u
inst✝ : Category.{v, u} C
a✝¹ : C
f : star ⟶ 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} (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 <;> 

Proof state:
case star.of.star.of
C : Type u
inst✝ : Category.{v, u} C
a✝¹ : C
f : star ⟶ 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} (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 

Proof state:
case star.of.star.of
C : Type u
inst✝ : Category.{v, u} C
a✝¹ : C
f : star ⟶ 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} (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 <;> 

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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:
exact (h : PEmpty).elim