l3lab/ntp-mathlib huggingface dataset:
/-- The equivalence of categories expressing associativity of sums of categories.
-/
def associativity : Sum (Sum C D) E ≌ Sum C (Sum D E) :=
  Equivalence.mk (associator C D E) (inverseAssociator C D E)
    (NatIso.ofComponents (fun X => eqToIso
      (by rcases X with ((_|_)|_) <;> rfl)) -- Porting notes: aesop_cat fails
      (by rintro ((_|_)|_) ((_|_)|_) f <;> first | 

Proof state:
case inr.inl.inr
C : Type u
inst✝² : Category.{v, u} C
D : Type u
inst✝¹ : Category.{v, u} D
E : Type u
inst✝ : Category.{v, u} E
val✝¹ : E
val✝ : D
f : inr val✝¹ ⟶ inl (inr val✝)
⊢ (𝟭 ((C ⊕ D) ⊕ E)).map f ≫
      ((fun X => eqToIso (_ : (𝟭 ((C ⊕ D) ⊕ E)).obj X = (associator C D E ⋙ inverseAssociator C D E).obj X))
          (inl (inr val✝))).hom =
    ((fun X => eqToIso (_ : (𝟭 ((C ⊕ D) ⊕ E)).obj X = (associator C D E ⋙ inverseAssociator C D E).obj X))
          (inr val✝¹)).hom ≫
      (associator C D E ⋙ inverseAssociator C D E).map f

Next tactic:
cases f
/-- The equivalence of categories expressing associativity of sums of categories.
-/
def associativity : Sum (Sum C D) E ≌ Sum C (Sum D E) :=
  Equivalence.mk (associator C D E) (inverseAssociator C D E)
    (NatIso.ofComponents (fun X => eqToIso
      (by rcases X with ((_|_)|_) <;> rfl)) -- Porting notes: aesop_cat fails
      (by rintro ((_|_)|_) ((_|_)|_) f <;> 

Proof state:
case inr.inr
C : Type u
inst✝² : Category.{v, u} C
D : Type u
inst✝¹ : Category.{v, u} D
E : Type u
inst✝ : Category.{v, u} E
val✝¹ val✝ : E
f : inr val✝¹ ⟶ inr val✝
⊢ (𝟭 ((C ⊕ D) ⊕ E)).map f ≫
      ((fun X => eqToIso (_ : (𝟭 ((C ⊕ D) ⊕ E)).obj X = (associator C D E ⋙ inverseAssociator C D E).obj X))
          (inr val✝)).hom =
    ((fun X => eqToIso (_ : (𝟭 ((C ⊕ D) ⊕ E)).obj X = (associator C D E ⋙ inverseAssociator C D E).obj X))
          (inr val✝¹)).hom ≫
      (associator C D E ⋙ inverseAssociator C D E).map f

Next tactic:
first | cases f | aesop_cat
/-- The equivalence of categories expressing associativity of sums of categories.
-/
def associativity : Sum (Sum C D) E ≌ Sum C (Sum D E) :=
  Equivalence.mk (associator C D E) (inverseAssociator C D E)
    (NatIso.ofComponents (fun X => eqToIso
      (by rcases X with ((_|_)|_) <;> rfl)) -- Porting notes: aesop_cat fails
      (by rintro ((_|_)|_) ((_|_)|_) f <;> first | 

Proof state:
case inr.inr
C : Type u
inst✝² : Category.{v, u} C
D : Type u
inst✝¹ : Category.{v, u} D
E : Type u
inst✝ : Category.{v, u} E
val✝¹ val✝ : E
f : inr val✝¹ ⟶ inr val✝
⊢ (𝟭 ((C ⊕ D) ⊕ E)).map f ≫
      ((fun X => eqToIso (_ : (𝟭 ((C ⊕ D) ⊕ E)).obj X = (associator C D E ⋙ inverseAssociator C D E).obj X))
          (inr val✝)).hom =
    ((fun X => eqToIso (_ : (𝟭 ((C ⊕ D) ⊕ E)).obj X = (associator C D E ⋙ inverseAssociator C D E).obj X))
          (inr val✝¹)).hom ≫
      (associator C D E ⋙ inverseAssociator C D E).map f

Next tactic:
cases f
/-- The equivalence of categories expressing associativity of sums of categories.
-/
def associativity : Sum (Sum C D) E ≌ Sum C (Sum D E) :=
  Equivalence.mk (associator C D E) (inverseAssociator C D E)
    (NatIso.ofComponents (fun X => eqToIso
      (by rcases X with ((_|_)|_) <;> rfl)) -- Porting notes: aesop_cat fails
      (by rintro ((_|_)|_) ((_|_)|_) f <;> first | cases f | 

Proof state:
case inr.inr
C : Type u
inst✝² : Category.{v, u} C
D : Type u
inst✝¹ : Category.{v, u} D
E : Type u
inst✝ : Category.{v, u} E
val✝¹ val✝ : E
f : inr val✝¹ ⟶ inr val✝
⊢ (𝟭 ((C ⊕ D) ⊕ E)).map f ≫
      ((fun X => eqToIso (_ : (𝟭 ((C ⊕ D) ⊕ E)).obj X = (associator C D E ⋙ inverseAssociator C D E).obj X))
          (inr val✝)).hom =
    ((fun X => eqToIso (_ : (𝟭 ((C ⊕ D) ⊕ E)).obj X = (associator C D E ⋙ inverseAssociator C D E).obj X))
          (inr val✝¹)).hom ≫
      (associator C D E ⋙ inverseAssociator C D E).map f

Next tactic:
aesop_cat
/-- The equivalence of categories expressing associativity of sums of categories.
-/
def associativity : Sum (Sum C D) E ≌ Sum C (Sum D E) :=
  Equivalence.mk (associator C D E) (inverseAssociator C D E)
    (NatIso.ofComponents (fun X => eqToIso
      (by rcases X with ((_|_)|_) <;> rfl)) -- Porting notes: aesop_cat fails
      (by rintro ((_|_)|_) ((_|_)|_) f <;> first | cases f | aesop_cat))
    (NatIso.ofComponents (fun X => eqToIso
      (by 

Proof state:
C : Type u
inst✝² : Category.{v, u} C
D : Type u
inst✝¹ : Category.{v, u} D
E : Type u
inst✝ : Category.{v, u} E
X : C ⊕ D ⊕ E
⊢ (inverseAssociator C D E ⋙ associator C D E).obj X = (𝟭 (C ⊕ D ⊕ E)).obj X

Next tactic:
rcases X with (_|(_|_))
/-- The equivalence of categories expressing associativity of sums of categories.
-/
def associativity : Sum (Sum C D) E ≌ Sum C (Sum D E) :=
  Equivalence.mk (associator C D E) (inverseAssociator C D E)
    (NatIso.ofComponents (fun X => eqToIso
      (by rcases X with ((_|_)|_) <;> rfl)) -- Porting notes: aesop_cat fails
      (by rintro ((_|_)|_) ((_|_)|_) f <;> first | cases f | aesop_cat))
    (NatIso.ofComponents (fun X => eqToIso
      (by rcases X with (_|(_|_)) <;> 

Proof state:
case inl
C : Type u
inst✝² : Category.{v, u} C
D : Type u
inst✝¹ : Category.{v, u} D
E : Type u
inst✝ : Category.{v, u} E
val✝ : C
⊢ (inverseAssociator C D E ⋙ associator C D E).obj (inl val✝) = (𝟭 (C ⊕ D ⊕ E)).obj (inl val✝)

Next tactic:
rfl
/-- The equivalence of categories expressing associativity of sums of categories.
-/
def associativity : Sum (Sum C D) E ≌ Sum C (Sum D E) :=
  Equivalence.mk (associator C D E) (inverseAssociator C D E)
    (NatIso.ofComponents (fun X => eqToIso
      (by rcases X with ((_|_)|_) <;> rfl)) -- Porting notes: aesop_cat fails
      (by rintro ((_|_)|_) ((_|_)|_) f <;> first | cases f | aesop_cat))
    (NatIso.ofComponents (fun X => eqToIso
      (by rcases X with (_|(_|_)) <;> 

Proof state:
case inr.inl
C : Type u
inst✝² : Category.{v, u} C
D : Type u
inst✝¹ : Category.{v, u} D
E : Type u
inst✝ : Category.{v, u} E
val✝ : D
⊢ (inverseAssociator C D E ⋙ associator C D E).obj (inr (inl val✝)) = (𝟭 (C ⊕ D ⊕ E)).obj (inr (inl val✝))

Next tactic:
rfl
/-- The equivalence of categories expressing associativity of sums of categories.
-/
def associativity : Sum (Sum C D) E ≌ Sum C (Sum D E) :=
  Equivalence.mk (associator C D E) (inverseAssociator C D E)
    (NatIso.ofComponents (fun X => eqToIso
      (by rcases X with ((_|_)|_) <;> rfl)) -- Porting notes: aesop_cat fails
      (by rintro ((_|_)|_) ((_|_)|_) f <;> first | cases f | aesop_cat))
    (NatIso.ofComponents (fun X => eqToIso
      (by rcases X with (_|(_|_)) <;> 

Proof state:
case inr.inr
C : Type u
inst✝² : Category.{v, u} C
D : Type u
inst✝¹ : Category.{v, u} D
E : Type u
inst✝ : Category.{v, u} E
val✝ : E
⊢ (inverseAssociator C D E ⋙ associator C D E).obj (inr (inr val✝)) = (𝟭 (C ⊕ D ⊕ E)).obj (inr (inr val✝))

Next tactic:
rfl
/-- The equivalence of categories expressing associativity of sums of categories.
-/
def associativity : Sum (Sum C D) E ≌ Sum C (Sum D E) :=
  Equivalence.mk (associator C D E) (inverseAssociator C D E)
    (NatIso.ofComponents (fun X => eqToIso
      (by rcases X with ((_|_)|_) <;> rfl)) -- Porting notes: aesop_cat fails
      (by rintro ((_|_)|_) ((_|_)|_) f <;> first | cases f | aesop_cat))
    (NatIso.ofComponents (fun X => eqToIso
      (by rcases X with (_|(_|_)) <;> rfl)) -- Porting notes: aesop_cat fails
      (by 

Proof state:
C : Type u
inst✝² : Category.{v, u} C
D : Type u
inst✝¹ : Category.{v, u} D
E : Type u
inst✝ : Category.{v, u} E
⊢ ∀ {X Y : C ⊕ D ⊕ E} (f : X ⟶ Y),
    (inverseAssociator C D E ⋙ associator C D E).map f ≫
        ((fun X => eqToIso (_ : (inverseAssociator C D E ⋙ associator C D E).obj X = (𝟭 (C ⊕ D ⊕ E)).obj X)) Y).hom =
      ((fun X => eqToIso (_ : (inverseAssociator C D E ⋙ associator C D E).obj X = (𝟭 (C ⊕ D ⊕ E)).obj X)) X).hom ≫
        (𝟭 (C ⊕ D ⊕ E)).map f

Next tactic:
rintro (_|(_|_)) (_|(_|_)) f
/-- The equivalence of categories expressing associativity of sums of categories.
-/
def associativity : Sum (Sum C D) E ≌ Sum C (Sum D E) :=
  Equivalence.mk (associator C D E) (inverseAssociator C D E)
    (NatIso.ofComponents (fun X => eqToIso
      (by rcases X with ((_|_)|_) <;> rfl)) -- Porting notes: aesop_cat fails
      (by rintro ((_|_)|_) ((_|_)|_) f <;> first | cases f | aesop_cat))
    (NatIso.ofComponents (fun X => eqToIso
      (by rcases X with (_|(_|_)) <;> rfl)) -- Porting notes: aesop_cat fails
      (by rintro (_|(_|_)) (_|(_|_)) f <;> 

Proof state:
case inl.inl
C : Type u
inst✝² : Category.{v, u} C
D : Type u
inst✝¹ : Category.{v, u} D
E : Type u
inst✝ : Category.{v, u} E
val✝¹ val✝ : C
f : inl val✝¹ ⟶ inl val✝
⊢ (inverseAssociator C D E ⋙ associator C D E).map f ≫
      ((fun X => eqToIso (_ : (inverseAssociator C D E ⋙ associator C D E).obj X = (𝟭 (C ⊕ D ⊕ E)).obj X))
          (inl val✝)).hom =
    ((fun X => eqToIso (_ : (inverseAssociator C D E ⋙ associator C D E).obj X = (𝟭 (C ⊕ D ⊕ E)).obj X))
          (inl val✝¹)).hom ≫
      (𝟭 (C ⊕ D ⊕ E)).map f

Next tactic:
first | cases f | aesop_cat
/-- The equivalence of categories expressing associativity of sums of categories.
-/
def associativity : Sum (Sum C D) E ≌ Sum C (Sum D E) :=
  Equivalence.mk (associator C D E) (inverseAssociator C D E)
    (NatIso.ofComponents (fun X => eqToIso
      (by rcases X with ((_|_)|_) <;> rfl)) -- Porting notes: aesop_cat fails
      (by rintro ((_|_)|_) ((_|_)|_) f <;> first | cases f | aesop_cat))
    (NatIso.ofComponents (fun X => eqToIso
      (by rcases X with (_|(_|_)) <;> rfl)) -- Porting notes: aesop_cat fails
      (by rintro (_|(_|_)) (_|(_|_)) f <;> first | 

Proof state:
case inl.inl
C : Type u
inst✝² : Category.{v, u} C
D : Type u
inst✝¹ : Category.{v, u} D
E : Type u
inst✝ : Category.{v, u} E
val✝¹ val✝ : C
f : inl val✝¹ ⟶ inl val✝
⊢ (inverseAssociator C D E ⋙ associator C D E).map f ≫
      ((fun X => eqToIso (_ : (inverseAssociator C D E ⋙ associator C D E).obj X = (𝟭 (C ⊕ D ⊕ E)).obj X))
          (inl val✝)).hom =
    ((fun X => eqToIso (_ : (inverseAssociator C D E ⋙ associator C D E).obj X = (𝟭 (C ⊕ D ⊕ E)).obj X))
          (inl val✝¹)).hom ≫
      (𝟭 (C ⊕ D ⊕ E)).map f

Next tactic:
cases f
/-- The equivalence of categories expressing associativity of sums of categories.
-/
def associativity : Sum (Sum C D) E ≌ Sum C (Sum D E) :=
  Equivalence.mk (associator C D E) (inverseAssociator C D E)
    (NatIso.ofComponents (fun X => eqToIso
      (by rcases X with ((_|_)|_) <;> rfl)) -- Porting notes: aesop_cat fails
      (by rintro ((_|_)|_) ((_|_)|_) f <;> first | cases f | aesop_cat))
    (NatIso.ofComponents (fun X => eqToIso
      (by rcases X with (_|(_|_)) <;> rfl)) -- Porting notes: aesop_cat fails
      (by rintro (_|(_|_)) (_|(_|_)) f <;> first | cases f | 

Proof state:
case inl.inl
C : Type u
inst✝² : Category.{v, u} C
D : Type u
inst✝¹ : Category.{v, u} D
E : Type u
inst✝ : Category.{v, u} E
val✝¹ val✝ : C
f : inl val✝¹ ⟶ inl val✝
⊢ (inverseAssociator C D E ⋙ associator C D E).map f ≫
      ((fun X => eqToIso (_ : (inverseAssociator C D E ⋙ associator C D E).obj X = (𝟭 (C ⊕ D ⊕ E)).obj X))
          (inl val✝)).hom =
    ((fun X => eqToIso (_ : (inverseAssociator C D E ⋙ associator C D E).obj X = (𝟭 (C ⊕ D ⊕ E)).obj X))
          (inl val✝¹)).hom ≫
      (𝟭 (C ⊕ D ⊕ E)).map f

Next tactic:
aesop_cat
/-- The equivalence of categories expressing associativity of sums of categories.
-/
def associativity : Sum (Sum C D) E ≌ Sum C (Sum D E) :=
  Equivalence.mk (associator C D E) (inverseAssociator C D E)
    (NatIso.ofComponents (fun X => eqToIso
      (by rcases X with ((_|_)|_) <;> rfl)) -- Porting notes: aesop_cat fails
      (by rintro ((_|_)|_) ((_|_)|_) f <;> first | cases f | aesop_cat))
    (NatIso.ofComponents (fun X => eqToIso
      (by rcases X with (_|(_|_)) <;> rfl)) -- Porting notes: aesop_cat fails
      (by rintro (_|(_|_)) (_|(_|_)) f <;> 

Proof state:
case inl.inr.inl
C : Type u
inst✝² : Category.{v, u} C
D : Type u
inst✝¹ : Category.{v, u} D
E : Type u
inst✝ : Category.{v, u} E
val✝¹ : C
val✝ : D
f : inl val✝¹ ⟶ inr (inl val✝)
⊢ (inverseAssociator C D E ⋙ associator C D E).map f ≫
      ((fun X => eqToIso (_ : (inverseAssociator C D E ⋙ associator C D E).obj X = (𝟭 (C ⊕ D ⊕ E)).obj X))
          (inr (inl val✝))).hom =
    ((fun X => eqToIso (_ : (inverseAssociator C D E ⋙ associator C D E).obj X = (𝟭 (C ⊕ D ⊕ E)).obj X))
          (inl val✝¹)).hom ≫
      (𝟭 (C ⊕ D ⊕ E)).map f

Next tactic:
first | cases f | aesop_cat
/-- The equivalence of categories expressing associativity of sums of categories.
-/
def associativity : Sum (Sum C D) E ≌ Sum C (Sum D E) :=
  Equivalence.mk (associator C D E) (inverseAssociator C D E)
    (NatIso.ofComponents (fun X => eqToIso
      (by rcases X with ((_|_)|_) <;> rfl)) -- Porting notes: aesop_cat fails
      (by rintro ((_|_)|_) ((_|_)|_) f <;> first | cases f | aesop_cat))
    (NatIso.ofComponents (fun X => eqToIso
      (by rcases X with (_|(_|_)) <;> rfl)) -- Porting notes: aesop_cat fails
      (by rintro (_|(_|_)) (_|(_|_)) f <;> first | 

Proof state:
case inl.inr.inl
C : Type u
inst✝² : Category.{v, u} C
D : Type u
inst✝¹ : Category.{v, u} D
E : Type u
inst✝ : Category.{v, u} E
val✝¹ : C
val✝ : D
f : inl val✝¹ ⟶ inr (inl val✝)
⊢ (inverseAssociator C D E ⋙ associator C D E).map f ≫
      ((fun X => eqToIso (_ : (inverseAssociator C D E ⋙ associator C D E).obj X = (𝟭 (C ⊕ D ⊕ E)).obj X))
          (inr (inl val✝))).hom =
    ((fun X => eqToIso (_ : (inverseAssociator C D E ⋙ associator C D E).obj X = (𝟭 (C ⊕ D ⊕ E)).obj X))
          (inl val✝¹)).hom ≫
      (𝟭 (C ⊕ D ⊕ E)).map f

Next tactic:
cases f
/-- The equivalence of categories expressing associativity of sums of categories.
-/
def associativity : Sum (Sum C D) E ≌ Sum C (Sum D E) :=
  Equivalence.mk (associator C D E) (inverseAssociator C D E)
    (NatIso.ofComponents (fun X => eqToIso
      (by rcases X with ((_|_)|_) <;> rfl)) -- Porting notes: aesop_cat fails
      (by rintro ((_|_)|_) ((_|_)|_) f <;> first | cases f | aesop_cat))
    (NatIso.ofComponents (fun X => eqToIso
      (by rcases X with (_|(_|_)) <;> rfl)) -- Porting notes: aesop_cat fails
      (by rintro (_|(_|_)) (_|(_|_)) f <;> 

Proof state:
case inl.inr.inr
C : Type u
inst✝² : Category.{v, u} C
D : Type u
inst✝¹ : Category.{v, u} D
E : Type u
inst✝ : Category.{v, u} E
val✝¹ : C
val✝ : E
f : inl val✝¹ ⟶ inr (inr val✝)
⊢ (inverseAssociator C D E ⋙ associator C D E).map f ≫
      ((fun X => eqToIso (_ : (inverseAssociator C D E ⋙ associator C D E).obj X = (𝟭 (C ⊕ D ⊕ E)).obj X))
          (inr (inr val✝))).hom =
    ((fun X => eqToIso (_ : (inverseAssociator C D E ⋙ associator C D E).obj X = (𝟭 (C ⊕ D ⊕ E)).obj X))
          (inl val✝¹)).hom ≫
      (𝟭 (C ⊕ D ⊕ E)).map f

Next tactic:
first | cases f | aesop_cat
/-- The equivalence of categories expressing associativity of sums of categories.
-/
def associativity : Sum (Sum C D) E ≌ Sum C (Sum D E) :=
  Equivalence.mk (associator C D E) (inverseAssociator C D E)
    (NatIso.ofComponents (fun X => eqToIso
      (by rcases X with ((_|_)|_) <;> rfl)) -- Porting notes: aesop_cat fails
      (by rintro ((_|_)|_) ((_|_)|_) f <;> first | cases f | aesop_cat))
    (NatIso.ofComponents (fun X => eqToIso
      (by rcases X with (_|(_|_)) <;> rfl)) -- Porting notes: aesop_cat fails
      (by rintro (_|(_|_)) (_|(_|_)) f <;> first | 

Proof state:
case inl.inr.inr
C : Type u
inst✝² : Category.{v, u} C
D : Type u
inst✝¹ : Category.{v, u} D
E : Type u
inst✝ : Category.{v, u} E
val✝¹ : C
val✝ : E
f : inl val✝¹ ⟶ inr (inr val✝)
⊢ (inverseAssociator C D E ⋙ associator C D E).map f ≫
      ((fun X => eqToIso (_ : (inverseAssociator C D E ⋙ associator C D E).obj X = (𝟭 (C ⊕ D ⊕ E)).obj X))
          (inr (inr val✝))).hom =
    ((fun X => eqToIso (_ : (inverseAssociator C D E ⋙ associator C D E).obj X = (𝟭 (C ⊕ D ⊕ E)).obj X))
          (inl val✝¹)).hom ≫
      (𝟭 (C ⊕ D ⊕ E)).map f

Next tactic:
cases f
/-- The equivalence of categories expressing associativity of sums of categories.
-/
def associativity : Sum (Sum C D) E ≌ Sum C (Sum D E) :=
  Equivalence.mk (associator C D E) (inverseAssociator C D E)
    (NatIso.ofComponents (fun X => eqToIso
      (by rcases X with ((_|_)|_) <;> rfl)) -- Porting notes: aesop_cat fails
      (by rintro ((_|_)|_) ((_|_)|_) f <;> first | cases f | aesop_cat))
    (NatIso.ofComponents (fun X => eqToIso
      (by rcases X with (_|(_|_)) <;> rfl)) -- Porting notes: aesop_cat fails
      (by rintro (_|(_|_)) (_|(_|_)) f <;> 

Proof state:
case inr.inl.inl
C : Type u
inst✝² : Category.{v, u} C
D : Type u
inst✝¹ : Category.{v, u} D
E : Type u
inst✝ : Category.{v, u} E
val✝¹ : D
val✝ : C
f : inr (inl val✝¹) ⟶ inl val✝
⊢ (inverseAssociator C D E ⋙ associator C D E).map f ≫
      ((fun X => eqToIso (_ : (inverseAssociator C D E ⋙ associator C D E).obj X = (𝟭 (C ⊕ D ⊕ E)).obj X))
          (inl val✝)).hom =
    ((fun X => eqToIso (_ : (inverseAssociator C D E ⋙ associator C D E).obj X = (𝟭 (C ⊕ D ⊕ E)).obj X))
          (inr (inl val✝¹))).hom ≫
      (𝟭 (C ⊕ D ⊕ E)).map f

Next tactic:
first | cases f | aesop_cat
/-- The equivalence of categories expressing associativity of sums of categories.
-/
def associativity : Sum (Sum C D) E ≌ Sum C (Sum D E) :=
  Equivalence.mk (associator C D E) (inverseAssociator C D E)
    (NatIso.ofComponents (fun X => eqToIso
      (by rcases X with ((_|_)|_) <;> rfl)) -- Porting notes: aesop_cat fails
      (by rintro ((_|_)|_) ((_|_)|_) f <;> first | cases f | aesop_cat))
    (NatIso.ofComponents (fun X => eqToIso
      (by rcases X with (_|(_|_)) <;> rfl)) -- Porting notes: aesop_cat fails
      (by rintro (_|(_|_)) (_|(_|_)) f <;> first | 

Proof state:
case inr.inl.inl
C : Type u
inst✝² : Category.{v, u} C
D : Type u
inst✝¹ : Category.{v, u} D
E : Type u
inst✝ : Category.{v, u} E
val✝¹ : D
val✝ : C
f : inr (inl val✝¹) ⟶ inl val✝
⊢ (inverseAssociator C D E ⋙ associator C D E).map f ≫
      ((fun X => eqToIso (_ : (inverseAssociator C D E ⋙ associator C D E).obj X = (𝟭 (C ⊕ D ⊕ E)).obj X))
          (inl val✝)).hom =
    ((fun X => eqToIso (_ : (inverseAssociator C D E ⋙ associator C D E).obj X = (𝟭 (C ⊕ D ⊕ E)).obj X))
          (inr (inl val✝¹))).hom ≫
      (𝟭 (C ⊕ D ⊕ E)).map f

Next tactic:
cases f
/-- The equivalence of categories expressing associativity of sums of categories.
-/
def associativity : Sum (Sum C D) E ≌ Sum C (Sum D E) :=
  Equivalence.mk (associator C D E) (inverseAssociator C D E)
    (NatIso.ofComponents (fun X => eqToIso
      (by rcases X with ((_|_)|_) <;> rfl)) -- Porting notes: aesop_cat fails
      (by rintro ((_|_)|_) ((_|_)|_) f <;> first | cases f | aesop_cat))
    (NatIso.ofComponents (fun X => eqToIso
      (by rcases X with (_|(_|_)) <;> rfl)) -- Porting notes: aesop_cat fails
      (by rintro (_|(_|_)) (_|(_|_)) f <;> 

Proof state:
case inr.inl.inr.inl
C : Type u
inst✝² : Category.{v, u} C
D : Type u
inst✝¹ : Category.{v, u} D
E : Type u
inst✝ : Category.{v, u} E
val✝¹ val✝ : D
f : inr (inl val✝¹) ⟶ inr (inl val✝)
⊢ (inverseAssociator C D E ⋙ associator C D E).map f ≫
      ((fun X => eqToIso (_ : (inverseAssociator C D E ⋙ associator C D E).obj X = (𝟭 (C ⊕ D ⊕ E)).obj X))
          (inr (inl val✝))).hom =
    ((fun X => eqToIso (_ : (inverseAssociator C D E ⋙ associator C D E).obj X = (𝟭 (C ⊕ D ⊕ E)).obj X))
          (inr (inl val✝¹))).hom ≫
      (𝟭 (C ⊕ D ⊕ E)).map f

Next tactic:
first | cases f | aesop_cat
/-- The equivalence of categories expressing associativity of sums of categories.
-/
def associativity : Sum (Sum C D) E ≌ Sum C (Sum D E) :=
  Equivalence.mk (associator C D E) (inverseAssociator C D E)
    (NatIso.ofComponents (fun X => eqToIso
      (by rcases X with ((_|_)|_) <;> rfl)) -- Porting notes: aesop_cat fails
      (by rintro ((_|_)|_) ((_|_)|_) f <;> first | cases f | aesop_cat))
    (NatIso.ofComponents (fun X => eqToIso
      (by rcases X with (_|(_|_)) <;> rfl)) -- Porting notes: aesop_cat fails
      (by rintro (_|(_|_)) (_|(_|_)) f <;> first | 

Proof state:
case inr.inl.inr.inl
C : Type u
inst✝² : Category.{v, u} C
D : Type u
inst✝¹ : Category.{v, u} D
E : Type u
inst✝ : Category.{v, u} E
val✝¹ val✝ : D
f : inr (inl val✝¹) ⟶ inr (inl val✝)
⊢ (inverseAssociator C D E ⋙ associator C D E).map f ≫
      ((fun X => eqToIso (_ : (inverseAssociator C D E ⋙ associator C D E).obj X = (𝟭 (C ⊕ D ⊕ E)).obj X))
          (inr (inl val✝))).hom =
    ((fun X => eqToIso (_ : (inverseAssociator C D E ⋙ associator C D E).obj X = (𝟭 (C ⊕ D ⊕ E)).obj X))
          (inr (inl val✝¹))).hom ≫
      (𝟭 (C ⊕ D ⊕ E)).map f

Next tactic:
cases f
/-- The equivalence of categories expressing associativity of sums of categories.
-/
def associativity : Sum (Sum C D) E ≌ Sum C (Sum D E) :=
  Equivalence.mk (associator C D E) (inverseAssociator C D E)
    (NatIso.ofComponents (fun X => eqToIso
      (by rcases X with ((_|_)|_) <;> rfl)) -- Porting notes: aesop_cat fails
      (by rintro ((_|_)|_) ((_|_)|_) f <;> first | cases f | aesop_cat))
    (NatIso.ofComponents (fun X => eqToIso
      (by rcases X with (_|(_|_)) <;> rfl)) -- Porting notes: aesop_cat fails
      (by rintro (_|(_|_)) (_|(_|_)) f <;> first | cases f | 

Proof state:
case inr.inl.inr.inl
C : Type u
inst✝² : Category.{v, u} C
D : Type u
inst✝¹ : Category.{v, u} D
E : Type u
inst✝ : Category.{v, u} E
val✝¹ val✝ : D
f : inr (inl val✝¹) ⟶ inr (inl val✝)
⊢ (inverseAssociator C D E ⋙ associator C D E).map f ≫
      ((fun X => eqToIso (_ : (inverseAssociator C D E ⋙ associator C D E).obj X = (𝟭 (C ⊕ D ⊕ E)).obj X))
          (inr (inl val✝))).hom =
    ((fun X => eqToIso (_ : (inverseAssociator C D E ⋙ associator C D E).obj X = (𝟭 (C ⊕ D ⊕ E)).obj X))
          (inr (inl val✝¹))).hom ≫
      (𝟭 (C ⊕ D ⊕ E)).map f

Next tactic:
aesop_cat
/-- The equivalence of categories expressing associativity of sums of categories.
-/
def associativity : Sum (Sum C D) E ≌ Sum C (Sum D E) :=
  Equivalence.mk (associator C D E) (inverseAssociator C D E)
    (NatIso.ofComponents (fun X => eqToIso
      (by rcases X with ((_|_)|_) <;> rfl)) -- Porting notes: aesop_cat fails
      (by rintro ((_|_)|_) ((_|_)|_) f <;> first | cases f | aesop_cat))
    (NatIso.ofComponents (fun X => eqToIso
      (by rcases X with (_|(_|_)) <;> rfl)) -- Porting notes: aesop_cat fails
      (by rintro (_|(_|_)) (_|(_|_)) f <;> 

Proof state:
case inr.inl.inr.inr
C : Type u
inst✝² : Category.{v, u} C
D : Type u
inst✝¹ : Category.{v, u} D
E : Type u
inst✝ : Category.{v, u} E
val✝¹ : D
val✝ : E
f : inr (inl val✝¹) ⟶ inr (inr val✝)
⊢ (inverseAssociator C D E ⋙ associator C D E).map f ≫
      ((fun X => eqToIso (_ : (inverseAssociator C D E ⋙ associator C D E).obj X = (𝟭 (C ⊕ D ⊕ E)).obj X))
          (inr (inr val✝))).hom =
    ((fun X => eqToIso (_ : (inverseAssociator C D E ⋙ associator C D E).obj X = (𝟭 (C ⊕ D ⊕ E)).obj X))
          (inr (inl val✝¹))).hom ≫
      (𝟭 (C ⊕ D ⊕ E)).map f

Next tactic:
first | cases f | aesop_cat
/-- The equivalence of categories expressing associativity of sums of categories.
-/
def associativity : Sum (Sum C D) E ≌ Sum C (Sum D E) :=
  Equivalence.mk (associator C D E) (inverseAssociator C D E)
    (NatIso.ofComponents (fun X => eqToIso
      (by rcases X with ((_|_)|_) <;> rfl)) -- Porting notes: aesop_cat fails
      (by rintro ((_|_)|_) ((_|_)|_) f <;> first | cases f | aesop_cat))
    (NatIso.ofComponents (fun X => eqToIso
      (by rcases X with (_|(_|_)) <;> rfl)) -- Porting notes: aesop_cat fails
      (by rintro (_|(_|_)) (_|(_|_)) f <;> first | 

Proof state:
case inr.inl.inr.inr
C : Type u
inst✝² : Category.{v, u} C
D : Type u
inst✝¹ : Category.{v, u} D
E : Type u
inst✝ : Category.{v, u} E
val✝¹ : D
val✝ : E
f : inr (inl val✝¹) ⟶ inr (inr val✝)
⊢ (inverseAssociator C D E ⋙ associator C D E).map f ≫
      ((fun X => eqToIso (_ : (inverseAssociator C D E ⋙ associator C D E).obj X = (𝟭 (C ⊕ D ⊕ E)).obj X))
          (inr (inr val✝))).hom =
    ((fun X => eqToIso (_ : (inverseAssociator C D E ⋙ associator C D E).obj X = (𝟭 (C ⊕ D ⊕ E)).obj X))
          (inr (inl val✝¹))).hom ≫
      (𝟭 (C ⊕ D ⊕ E)).map f

Next tactic:
cases f