[GOAL]
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),
    {
            obj := fun X =>
              match X with
              | inl (inl X) => inl X
              | inl (inr X) => inr (inl X)
              | inr X => inr (inr X),
            map := fun {X Y} f =>
              match X, Y, f with
              | inl (inl val), inl (inl val_1), f => f
              | inl (inr val), inl (inr val_1), f => f
              | inr val, inr val_1, f => f }.map
        (𝟙 X) =
      𝟙
        ({
              obj := fun X =>
                match X with
                | inl (inl X) => inl X
                | inl (inr X) => inr (inl X)
                | inr X => inr (inr X),
              map := fun {X Y} f =>
                match X, Y, f with
                | inl (inl val), inl (inl val_1), f => f
                | inl (inr val), inl (inr val_1), f => f
                | inr val, inr val_1, f => f }.obj
          X)
[PROOFSTEP]
rintro ((_ | _) | _)
[GOAL]
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✝ : C
⊢ {
          obj := fun X =>
            match X with
            | inl (inl X) => inl X
            | inl (inr X) => inr (inl X)
            | inr X => inr (inr X),
          map := fun {X Y} f =>
            match X, Y, f with
            | inl (inl val), inl (inl val_1), f => f
            | inl (inr val), inl (inr val_1), f => f
            | inr val, inr val_1, f => f }.map
      (𝟙 (inl (inl val✝))) =
    𝟙
      ({
            obj := fun X =>
              match X with
              | inl (inl X) => inl X
              | inl (inr X) => inr (inl X)
              | inr X => inr (inr X),
            map := fun {X Y} f =>
              match X, Y, f with
              | inl (inl val), inl (inl val_1), f => f
              | inl (inr val), inl (inr val_1), f => f
              | inr val, inr val_1, f => f }.obj
        (inl (inl val✝)))
[PROOFSTEP]
rfl
[GOAL]
case 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✝ : D
⊢ {
          obj := fun X =>
            match X with
            | inl (inl X) => inl X
            | inl (inr X) => inr (inl X)
            | inr X => inr (inr X),
          map := fun {X Y} f =>
            match X, Y, f with
            | inl (inl val), inl (inl val_1), f => f
            | inl (inr val), inl (inr val_1), f => f
            | inr val, inr val_1, f => f }.map
      (𝟙 (inl (inr val✝))) =
    𝟙
      ({
            obj := fun X =>
              match X with
              | inl (inl X) => inl X
              | inl (inr X) => inr (inl X)
              | inr X => inr (inr X),
            map := fun {X Y} f =>
              match X, Y, f with
              | inl (inl val), inl (inl val_1), f => f
              | inl (inr val), inl (inr val_1), f => f
              | inr val, inr val_1, f => f }.obj
        (inl (inr val✝)))
[PROOFSTEP]
rfl
[GOAL]
case 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
⊢ {
          obj := fun X =>
            match X with
            | inl (inl X) => inl X
            | inl (inr X) => inr (inl X)
            | inr X => inr (inr X),
          map := fun {X Y} f =>
            match X, Y, f with
            | inl (inl val), inl (inl val_1), f => f
            | inl (inr val), inl (inr val_1), f => f
            | inr val, inr val_1, f => f }.map
      (𝟙 (inr val✝)) =
    𝟙
      ({
            obj := fun X =>
              match X with
              | inl (inl X) => inl X
              | inl (inr X) => inr (inl X)
              | inr X => inr (inr X),
            map := fun {X Y} f =>
              match X, Y, f with
              | inl (inl val), inl (inl val_1), f => f
              | inl (inr val), inl (inr val_1), f => f
              | inr val, inr val_1, f => f }.obj
        (inr val✝))
[PROOFSTEP]
rfl
[GOAL]
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 Z : (C ⊕ D) ⊕ E} (f : X ⟶ Y) (g : Y ⟶ Z),
    {
            obj := fun X =>
              match X with
              | inl (inl X) => inl X
              | inl (inr X) => inr (inl X)
              | inr X => inr (inr X),
            map := fun {X Y} f =>
              match X, Y, f with
              | inl (inl val), inl (inl val_1), f => f
              | inl (inr val), inl (inr val_1), f => f
              | inr val, inr val_1, f => f }.map
        (f ≫ g) =
      {
              obj := fun X =>
                match X with
                | inl (inl X) => inl X
                | inl (inr X) => inr (inl X)
                | inr X => inr (inr X),
              map := fun {X Y} f =>
                match X, Y, f with
                | inl (inl val), inl (inl val_1), f => f
                | inl (inr val), inl (inr val_1), f => f
                | inr val, inr val_1, f => f }.map
          f ≫
        {
              obj := fun X =>
                match X with
                | inl (inl X) => inl X
                | inl (inr X) => inr (inl X)
                | inr X => inr (inr X),
              map := fun {X Y} f =>
                match X, Y, f with
                | inl (inl val), inl (inl val_1), f => f
                | inl (inr val), inl (inr val_1), f => f
                | inr val, inr val_1, f => f }.map
          g
[PROOFSTEP]
rintro ((_ | _) | _) ((_ | _) | _) ((_ | _) | _) f g
[GOAL]
case inl.inl.inl.inl.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✝¹ val✝ : C
f : inl (inl val✝²) ⟶ inl (inl val✝¹)
g : inl (inl val✝¹) ⟶ inl (inl val✝)
⊢ {
          obj := fun X =>
            match X with
            | inl (inl X) => inl X
            | inl (inr X) => inr (inl X)
            | inr X => inr (inr X),
          map := fun {X Y} f =>
            match X, Y, f with
            | inl (inl val), inl (inl val_1), f => f
            | inl (inr val), inl (inr val_1), f => f
            | inr val, inr val_1, f => f }.map
      (f ≫ g) =
    {
            obj := fun X =>
              match X with
              | inl (inl X) => inl X
              | inl (inr X) => inr (inl X)
              | inr X => inr (inr X),
            map := fun {X Y} f =>
              match X, Y, f with
              | inl (inl val), inl (inl val_1), f => f
              | inl (inr val), inl (inr val_1), f => f
              | inr val, inr val_1, f => f }.map
        f ≫
      {
            obj := fun X =>
              match X with
              | inl (inl X) => inl X
              | inl (inr X) => inr (inl X)
              | inr X => inr (inr X),
            map := fun {X Y} f =>
              match X, Y, f with
              | inl (inl val), inl (inl val_1), f => f
              | inl (inr val), inl (inr val_1), f => f
              | inr val, inr val_1, f => f }.map
        g
[PROOFSTEP]
first
| cases f
| cases g
| aesop_cat
[GOAL]
case inl.inl.inl.inl.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✝¹ val✝ : C
f : inl (inl val✝²) ⟶ inl (inl val✝¹)
g : inl (inl val✝¹) ⟶ inl (inl val✝)
⊢ {
          obj := fun X =>
            match X with
            | inl (inl X) => inl X
            | inl (inr X) => inr (inl X)
            | inr X => inr (inr X),
          map := fun {X Y} f =>
            match X, Y, f with
            | inl (inl val), inl (inl val_1), f => f
            | inl (inr val), inl (inr val_1), f => f
            | inr val, inr val_1, f => f }.map
      (f ≫ g) =
    {
            obj := fun X =>
              match X with
              | inl (inl X) => inl X
              | inl (inr X) => inr (inl X)
              | inr X => inr (inr X),
            map := fun {X Y} f =>
              match X, Y, f with
              | inl (inl val), inl (inl val_1), f => f
              | inl (inr val), inl (inr val_1), f => f
              | inr val, inr val_1, f => f }.map
        f ≫
      {
            obj := fun X =>
              match X with
              | inl (inl X) => inl X
              | inl (inr X) => inr (inl X)
              | inr X => inr (inr X),
            map := fun {X Y} f =>
              match X, Y, f with
              | inl (inl val), inl (inl val_1), f => f
              | inl (inr val), inl (inr val_1), f => f
              | inr val, inr val_1, f => f }.map
        g
[PROOFSTEP]
cases f
[GOAL]
case inl.inl.inl.inl.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✝¹ val✝ : C
f : inl (inl val✝²) ⟶ inl (inl val✝¹)
g : inl (inl val✝¹) ⟶ inl (inl val✝)
⊢ {
          obj := fun X =>
            match X with
            | inl (inl X) => inl X
            | inl (inr X) => inr (inl X)
            | inr X => inr (inr X),
          map := fun {X Y} f =>
            match X, Y, f with
            | inl (inl val), inl (inl val_1), f => f
            | inl (inr val), inl (inr val_1), f => f
            | inr val, inr val_1, f => f }.map
      (f ≫ g) =
    {
            obj := fun X =>
              match X with
              | inl (inl X) => inl X
              | inl (inr X) => inr (inl X)
              | inr X => inr (inr X),
            map := fun {X Y} f =>
              match X, Y, f with
              | inl (inl val), inl (inl val_1), f => f
              | inl (inr val), inl (inr val_1), f => f
              | inr val, inr val_1, f => f }.map
        f ≫
      {
            obj := fun X =>
              match X with
              | inl (inl X) => inl X
              | inl (inr X) => inr (inl X)
              | inr X => inr (inr X),
            map := fun {X Y} f =>
              match X, Y, f with
              | inl (inl val), inl (inl val_1), f => f
              | inl (inr val), inl (inr val_1), f => f
              | inr val, inr val_1, f => f }.map
        g
[PROOFSTEP]
cases g
[GOAL]
case inl.inl.inl.inl.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✝¹ val✝ : C
f : inl (inl val✝²) ⟶ inl (inl val✝¹)
g : inl (inl val✝¹) ⟶ inl (inl val✝)
⊢ {
          obj := fun X =>
            match X with
            | inl (inl X) => inl X
            | inl (inr X) => inr (inl X)
            | inr X => inr (inr X),
          map := fun {X Y} f =>
            match X, Y, f with
            | inl (inl val), inl (inl val_1), f => f
            | inl (inr val), inl (inr val_1), f => f
            | inr val, inr val_1, f => f }.map
      (f ≫ g) =
    {
            obj := fun X =>
              match X with
              | inl (inl X) => inl X
              | inl (inr X) => inr (inl X)
              | inr X => inr (inr X),
            map := fun {X Y} f =>
              match X, Y, f with
              | inl (inl val), inl (inl val_1), f => f
              | inl (inr val), inl (inr val_1), f => f
              | inr val, inr val_1, f => f }.map
        f ≫
      {
            obj := fun X =>
              match X with
              | inl (inl X) => inl X
              | inl (inr X) => inr (inl X)
              | inr X => inr (inr X),
            map := fun {X Y} f =>
              match X, Y, f with
              | inl (inl val), inl (inl val_1), f => f
              | inl (inr val), inl (inr val_1), f => f
              | inr val, inr val_1, f => f }.map
        g
[PROOFSTEP]
aesop_cat
[GOAL]
case inl.inl.inl.inl.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✝² val✝¹ : C
val✝ : D
f : inl (inl val✝²) ⟶ inl (inl val✝¹)
g : inl (inl val✝¹) ⟶ inl (inr val✝)
⊢ {
          obj := fun X =>
            match X with
            | inl (inl X) => inl X
            | inl (inr X) => inr (inl X)
            | inr X => inr (inr X),
          map := fun {X Y} f =>
            match X, Y, f with
            | inl (inl val), inl (inl val_1), f => f
            | inl (inr val), inl (inr val_1), f => f
            | inr val, inr val_1, f => f }.map
      (f ≫ g) =
    {
            obj := fun X =>
              match X with
              | inl (inl X) => inl X
              | inl (inr X) => inr (inl X)
              | inr X => inr (inr X),
            map := fun {X Y} f =>
              match X, Y, f with
              | inl (inl val), inl (inl val_1), f => f
              | inl (inr val), inl (inr val_1), f => f
              | inr val, inr val_1, f => f }.map
        f ≫
      {
            obj := fun X =>
              match X with
              | inl (inl X) => inl X
              | inl (inr X) => inr (inl X)
              | inr X => inr (inr X),
            map := fun {X Y} f =>
              match X, Y, f with
              | inl (inl val), inl (inl val_1), f => f
              | inl (inr val), inl (inr val_1), f => f
              | inr val, inr val_1, f => f }.map
        g
[PROOFSTEP]
first
| cases f
| cases g
| aesop_cat
[GOAL]
case inl.inl.inl.inl.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✝² val✝¹ : C
val✝ : D
f : inl (inl val✝²) ⟶ inl (inl val✝¹)
g : inl (inl val✝¹) ⟶ inl (inr val✝)
⊢ {
          obj := fun X =>
            match X with
            | inl (inl X) => inl X
            | inl (inr X) => inr (inl X)
            | inr X => inr (inr X),
          map := fun {X Y} f =>
            match X, Y, f with
            | inl (inl val), inl (inl val_1), f => f
            | inl (inr val), inl (inr val_1), f => f
            | inr val, inr val_1, f => f }.map
      (f ≫ g) =
    {
            obj := fun X =>
              match X with
              | inl (inl X) => inl X
              | inl (inr X) => inr (inl X)
              | inr X => inr (inr X),
            map := fun {X Y} f =>
              match X, Y, f with
              | inl (inl val), inl (inl val_1), f => f
              | inl (inr val), inl (inr val_1), f => f
              | inr val, inr val_1, f => f }.map
        f ≫
      {
            obj := fun X =>
              match X with
              | inl (inl X) => inl X
              | inl (inr X) => inr (inl X)
              | inr X => inr (inr X),
            map := fun {X Y} f =>
              match X, Y, f with
              | inl (inl val), inl (inl val_1), f => f
              | inl (inr val), inl (inr val_1), f => f
              | inr val, inr val_1, f => f }.map
        g
[PROOFSTEP]
cases f
[GOAL]
case inl.inl.inl.inl.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✝² val✝¹ : C
val✝ : D
f : inl (inl val✝²) ⟶ inl (inl val✝¹)
g : inl (inl val✝¹) ⟶ inl (inr val✝)
⊢ {
          obj := fun X =>
            match X with
            | inl (inl X) => inl X
            | inl (inr X) => inr (inl X)
            | inr X => inr (inr X),
          map := fun {X Y} f =>
            match X, Y, f with
            | inl (inl val), inl (inl val_1), f => f
            | inl (inr val), inl (inr val_1), f => f
            | inr val, inr val_1, f => f }.map
      (f ≫ g) =
    {
            obj := fun X =>
              match X with
              | inl (inl X) => inl X
              | inl (inr X) => inr (inl X)
              | inr X => inr (inr X),
            map := fun {X Y} f =>
              match X, Y, f with
              | inl (inl val), inl (inl val_1), f => f
              | inl (inr val), inl (inr val_1), f => f
              | inr val, inr val_1, f => f }.map
        f ≫
      {
            obj := fun X =>
              match X with
              | inl (inl X) => inl X
              | inl (inr X) => inr (inl X)
              | inr X => inr (inr X),
            map := fun {X Y} f =>
              match X, Y, f with
              | inl (inl val), inl (inl val_1), f => f
              | inl (inr val), inl (inr val_1), f => f
              | inr val, inr val_1, f => f }.map
        g
[PROOFSTEP]
cases g
[GOAL]
case inl.inl.inl.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✝² val✝¹ : C
val✝ : E
f : inl (inl val✝²) ⟶ inl (inl val✝¹)
g : inl (inl val✝¹) ⟶ inr val✝
⊢ {
          obj := fun X =>
            match X with
            | inl (inl X) => inl X
            | inl (inr X) => inr (inl X)
            | inr X => inr (inr X),
          map := fun {X Y} f =>
            match X, Y, f with
            | inl (inl val), inl (inl val_1), f => f
            | inl (inr val), inl (inr val_1), f => f
            | inr val, inr val_1, f => f }.map
      (f ≫ g) =
    {
            obj := fun X =>
              match X with
              | inl (inl X) => inl X
              | inl (inr X) => inr (inl X)
              | inr X => inr (inr X),
            map := fun {X Y} f =>
              match X, Y, f with
              | inl (inl val), inl (inl val_1), f => f
              | inl (inr val), inl (inr val_1), f => f
              | inr val, inr val_1, f => f }.map
        f ≫
      {
            obj := fun X =>
              match X with
              | inl (inl X) => inl X
              | inl (inr X) => inr (inl X)
              | inr X => inr (inr X),
            map := fun {X Y} f =>
              match X, Y, f with
              | inl (inl val), inl (inl val_1), f => f
              | inl (inr val), inl (inr val_1), f => f
              | inr val, inr val_1, f => f }.map
        g
[PROOFSTEP]
first
| cases f
| cases g
| aesop_cat
[GOAL]
case inl.inl.inl.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✝² val✝¹ : C
val✝ : E
f : inl (inl val✝²) ⟶ inl (inl val✝¹)
g : inl (inl val✝¹) ⟶ inr val✝
⊢ {
          obj := fun X =>
            match X with
            | inl (inl X) => inl X
            | inl (inr X) => inr (inl X)
            | inr X => inr (inr X),
          map := fun {X Y} f =>
            match X, Y, f with
            | inl (inl val), inl (inl val_1), f => f
            | inl (inr val), inl (inr val_1), f => f
            | inr val, inr val_1, f => f }.map
      (f ≫ g) =
    {
            obj := fun X =>
              match X with
              | inl (inl X) => inl X
              | inl (inr X) => inr (inl X)
              | inr X => inr (inr X),
            map := fun {X Y} f =>
              match X, Y, f with
              | inl (inl val), inl (inl val_1), f => f
              | inl (inr val), inl (inr val_1), f => f
              | inr val, inr val_1, f => f }.map
        f ≫
      {
            obj := fun X =>
              match X with
              | inl (inl X) => inl X
              | inl (inr X) => inr (inl X)
              | inr X => inr (inr X),
            map := fun {X Y} f =>
              match X, Y, f with
              | inl (inl val), inl (inl val_1), f => f
              | inl (inr val), inl (inr val_1), f => f
              | inr val, inr val_1, f => f }.map
        g
[PROOFSTEP]
cases f
[GOAL]
case inl.inl.inl.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✝² val✝¹ : C
val✝ : E
f : inl (inl val✝²) ⟶ inl (inl val✝¹)
g : inl (inl val✝¹) ⟶ inr val✝
⊢ {
          obj := fun X =>
            match X with
            | inl (inl X) => inl X
            | inl (inr X) => inr (inl X)
            | inr X => inr (inr X),
          map := fun {X Y} f =>
            match X, Y, f with
            | inl (inl val), inl (inl val_1), f => f
            | inl (inr val), inl (inr val_1), f => f
            | inr val, inr val_1, f => f }.map
      (f ≫ g) =
    {
            obj := fun X =>
              match X with
              | inl (inl X) => inl X
              | inl (inr X) => inr (inl X)
              | inr X => inr (inr X),
            map := fun {X Y} f =>
              match X, Y, f with
              | inl (inl val), inl (inl val_1), f => f
              | inl (inr val), inl (inr val_1), f => f
              | inr val, inr val_1, f => f }.map
        f ≫
      {
            obj := fun X =>
              match X with
              | inl (inl X) => inl X
              | inl (inr X) => inr (inl X)
              | inr X => inr (inr X),
            map := fun {X Y} f =>
              match X, Y, f with
              | inl (inl val), inl (inl val_1), f => f
              | inl (inr val), inl (inr val_1), f => f
              | inr val, inr val_1, f => f }.map
        g
[PROOFSTEP]
cases g
[GOAL]
case inl.inl.inl.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✝² : C
val✝¹ : D
val✝ : C
f : inl (inl val✝²) ⟶ inl (inr val✝¹)
g : inl (inr val✝¹) ⟶ inl (inl val✝)
⊢ {
          obj := fun X =>
            match X with
            | inl (inl X) => inl X
            | inl (inr X) => inr (inl X)
            | inr X => inr (inr X),
          map := fun {X Y} f =>
            match X, Y, f with
            | inl (inl val), inl (inl val_1), f => f
            | inl (inr val), inl (inr val_1), f => f
            | inr val, inr val_1, f => f }.map
      (f ≫ g) =
    {
            obj := fun X =>
              match X with
              | inl (inl X) => inl X
              | inl (inr X) => inr (inl X)
              | inr X => inr (inr X),
            map := fun {X Y} f =>
              match X, Y, f with
              | inl (inl val), inl (inl val_1), f => f
              | inl (inr val), inl (inr val_1), f => f
              | inr val, inr val_1, f => f }.map
        f ≫
      {
            obj := fun X =>
              match X with
              | inl (inl X) => inl X
              | inl (inr X) => inr (inl X)
              | inr X => inr (inr X),
            map := fun {X Y} f =>
              match X, Y, f with
              | inl (inl val), inl (inl val_1), f => f
              | inl (inr val), inl (inr val_1), f => f
              | inr val, inr val_1, f => f }.map
        g
[PROOFSTEP]
first
| cases f
| cases g
| aesop_cat
[GOAL]
case inl.inl.inl.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✝² : C
val✝¹ : D
val✝ : C
f : inl (inl val✝²) ⟶ inl (inr val✝¹)
g : inl (inr val✝¹) ⟶ inl (inl val✝)
⊢ {
          obj := fun X =>
            match X with
            | inl (inl X) => inl X
            | inl (inr X) => inr (inl X)
            | inr X => inr (inr X),
          map := fun {X Y} f =>
            match X, Y, f with
            | inl (inl val), inl (inl val_1), f => f
            | inl (inr val), inl (inr val_1), f => f
            | inr val, inr val_1, f => f }.map
      (f ≫ g) =
    {
            obj := fun X =>
              match X with
              | inl (inl X) => inl X
              | inl (inr X) => inr (inl X)
              | inr X => inr (inr X),
            map := fun {X Y} f =>
              match X, Y, f with
              | inl (inl val), inl (inl val_1), f => f
              | inl (inr val), inl (inr val_1), f => f
              | inr val, inr val_1, f => f }.map
        f ≫
      {
            obj := fun X =>
              match X with
              | inl (inl X) => inl X
              | inl (inr X) => inr (inl X)
              | inr X => inr (inr X),
            map := fun {X Y} f =>
              match X, Y, f with
              | inl (inl val), inl (inl val_1), f => f
              | inl (inr val), inl (inr val_1), f => f
              | inr val, inr val_1, f => f }.map
        g
[PROOFSTEP]
cases f
[GOAL]
case inl.inl.inl.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✝² : C
val✝¹ val✝ : D
f : inl (inl val✝²) ⟶ inl (inr val✝¹)
g : inl (inr val✝¹) ⟶ inl (inr val✝)
⊢ {
          obj := fun X =>
            match X with
            | inl (inl X) => inl X
            | inl (inr X) => inr (inl X)
            | inr X => inr (inr X),
          map := fun {X Y} f =>
            match X, Y, f with
            | inl (inl val), inl (inl val_1), f => f
            | inl (inr val), inl (inr val_1), f => f
            | inr val, inr val_1, f => f }.map
      (f ≫ g) =
    {
            obj := fun X =>
              match X with
              | inl (inl X) => inl X
              | inl (inr X) => inr (inl X)
              | inr X => inr (inr X),
            map := fun {X Y} f =>
              match X, Y, f with
              | inl (inl val), inl (inl val_1), f => f
              | inl (inr val), inl (inr val_1), f => f
              | inr val, inr val_1, f => f }.map
        f ≫
      {
            obj := fun X =>
              match X with
              | inl (inl X) => inl X
              | inl (inr X) => inr (inl X)
              | inr X => inr (inr X),
            map := fun {X Y} f =>
              match X, Y, f with
              | inl (inl val), inl (inl val_1), f => f
              | inl (inr val), inl (inr val_1), f => f
              | inr val, inr val_1, f => f }.map
        g
[PROOFSTEP]
first
| cases f
| cases g
| aesop_cat
[GOAL]
case inl.inl.inl.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✝² : C
val✝¹ val✝ : D
f : inl (inl val✝²) ⟶ inl (inr val✝¹)
g : inl (inr val✝¹) ⟶ inl (inr val✝)
⊢ {
          obj := fun X =>
            match X with
            | inl (inl X) => inl X
            | inl (inr X) => inr (inl X)
            | inr X => inr (inr X),
          map := fun {X Y} f =>
            match X, Y, f with
            | inl (inl val), inl (inl val_1), f => f
            | inl (inr val), inl (inr val_1), f => f
            | inr val, inr val_1, f => f }.map
      (f ≫ g) =
    {
            obj := fun X =>
              match X with
              | inl (inl X) => inl X
              | inl (inr X) => inr (inl X)
              | inr X => inr (inr X),
            map := fun {X Y} f =>
              match X, Y, f with
              | inl (inl val), inl (inl val_1), f => f
              | inl (inr val), inl (inr val_1), f => f
              | inr val, inr val_1, f => f }.map
        f ≫
      {
            obj := fun X =>
              match X with
              | inl (inl X) => inl X
              | inl (inr X) => inr (inl X)
              | inr X => inr (inr X),
            map := fun {X Y} f =>
              match X, Y, f with
              | inl (inl val), inl (inl val_1), f => f
              | inl (inr val), inl (inr val_1), f => f
              | inr val, inr val_1, f => f }.map
        g
[PROOFSTEP]
cases f
[GOAL]
case inl.inl.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✝¹ : D
val✝ : E
f : inl (inl val✝²) ⟶ inl (inr val✝¹)
g : inl (inr val✝¹) ⟶ inr val✝
⊢ {
          obj := fun X =>
            match X with
            | inl (inl X) => inl X
            | inl (inr X) => inr (inl X)
            | inr X => inr (inr X),
          map := fun {X Y} f =>
            match X, Y, f with
            | inl (inl val), inl (inl val_1), f => f
            | inl (inr val), inl (inr val_1), f => f
            | inr val, inr val_1, f => f }.map
      (f ≫ g) =
    {
            obj := fun X =>
              match X with
              | inl (inl X) => inl X
              | inl (inr X) => inr (inl X)
              | inr X => inr (inr X),
            map := fun {X Y} f =>
              match X, Y, f with
              | inl (inl val), inl (inl val_1), f => f
              | inl (inr val), inl (inr val_1), f => f
              | inr val, inr val_1, f => f }.map
        f ≫
      {
            obj := fun X =>
              match X with
              | inl (inl X) => inl X
              | inl (inr X) => inr (inl X)
              | inr X => inr (inr X),
            map := fun {X Y} f =>
              match X, Y, f with
              | inl (inl val), inl (inl val_1), f => f
              | inl (inr val), inl (inr val_1), f => f
              | inr val, inr val_1, f => f }.map
        g
[PROOFSTEP]
first
| cases f
| cases g
| aesop_cat
[GOAL]
case inl.inl.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✝¹ : D
val✝ : E
f : inl (inl val✝²) ⟶ inl (inr val✝¹)
g : inl (inr val✝¹) ⟶ inr val✝
⊢ {
          obj := fun X =>
            match X with
            | inl (inl X) => inl X
            | inl (inr X) => inr (inl X)
            | inr X => inr (inr X),
          map := fun {X Y} f =>
            match X, Y, f with
            | inl (inl val), inl (inl val_1), f => f
            | inl (inr val), inl (inr val_1), f => f
            | inr val, inr val_1, f => f }.map
      (f ≫ g) =
    {
            obj := fun X =>
              match X with
              | inl (inl X) => inl X
              | inl (inr X) => inr (inl X)
              | inr X => inr (inr X),
            map := fun {X Y} f =>
              match X, Y, f with
              | inl (inl val), inl (inl val_1), f => f
              | inl (inr val), inl (inr val_1), f => f
              | inr val, inr val_1, f => f }.map
        f ≫
      {
            obj := fun X =>
              match X with
              | inl (inl X) => inl X
              | inl (inr X) => inr (inl X)
              | inr X => inr (inr X),
            map := fun {X Y} f =>
              match X, Y, f with
              | inl (inl val), inl (inl val_1), f => f
              | inl (inr val), inl (inr val_1), f => f
              | inr val, inr val_1, f => f }.map
        g
[PROOFSTEP]
cases f
[GOAL]
case inl.inl.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✝² : C
val✝¹ : E
val✝ : C
f : inl (inl val✝²) ⟶ inr val✝¹
g : inr val✝¹ ⟶ inl (inl val✝)
⊢ {
          obj := fun X =>
            match X with
            | inl (inl X) => inl X
            | inl (inr X) => inr (inl X)
            | inr X => inr (inr X),
          map := fun {X Y} f =>
            match X, Y, f with
            | inl (inl val), inl (inl val_1), f => f
            | inl (inr val), inl (inr val_1), f => f
            | inr val, inr val_1, f => f }.map
      (f ≫ g) =
    {
            obj := fun X =>
              match X with
              | inl (inl X) => inl X
              | inl (inr X) => inr (inl X)
              | inr X => inr (inr X),
            map := fun {X Y} f =>
              match X, Y, f with
              | inl (inl val), inl (inl val_1), f => f
              | inl (inr val), inl (inr val_1), f => f
              | inr val, inr val_1, f => f }.map
        f ≫
      {
            obj := fun X =>
              match X with
              | inl (inl X) => inl X
              | inl (inr X) => inr (inl X)
              | inr X => inr (inr X),
            map := fun {X Y} f =>
              match X, Y, f with
              | inl (inl val), inl (inl val_1), f => f
              | inl (inr val), inl (inr val_1), f => f
              | inr val, inr val_1, f => f }.map
        g
[PROOFSTEP]
first
| cases f
| cases g
| aesop_cat
[GOAL]
case inl.inl.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✝² : C
val✝¹ : E
val✝ : C
f : inl (inl val✝²) ⟶ inr val✝¹
g : inr val✝¹ ⟶ inl (inl val✝)
⊢ {
          obj := fun X =>
            match X with
            | inl (inl X) => inl X
            | inl (inr X) => inr (inl X)
            | inr X => inr (inr X),
          map := fun {X Y} f =>
            match X, Y, f with
            | inl (inl val), inl (inl val_1), f => f
            | inl (inr val), inl (inr val_1), f => f
            | inr val, inr val_1, f => f }.map
      (f ≫ g) =
    {
            obj := fun X =>
              match X with
              | inl (inl X) => inl X
              | inl (inr X) => inr (inl X)
              | inr X => inr (inr X),
            map := fun {X Y} f =>
              match X, Y, f with
              | inl (inl val), inl (inl val_1), f => f
              | inl (inr val), inl (inr val_1), f => f
              | inr val, inr val_1, f => f }.map
        f ≫
      {
            obj := fun X =>
              match X with
              | inl (inl X) => inl X
              | inl (inr X) => inr (inl X)
              | inr X => inr (inr X),
            map := fun {X Y} f =>
              match X, Y, f with
              | inl (inl val), inl (inl val_1), f => f
              | inl (inr val), inl (inr val_1), f => f
              | inr val, inr val_1, f => f }.map
        g
[PROOFSTEP]
cases f
[GOAL]
case inl.inl.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✝² : C
val✝¹ : E
val✝ : D
f : inl (inl val✝²) ⟶ inr val✝¹
g : inr val✝¹ ⟶ inl (inr val✝)
⊢ {
          obj := fun X =>
            match X with
            | inl (inl X) => inl X
            | inl (inr X) => inr (inl X)
            | inr X => inr (inr X),
          map := fun {X Y} f =>
            match X, Y, f with
            | inl (inl val), inl (inl val_1), f => f
            | inl (inr val), inl (inr val_1), f => f
            | inr val, inr val_1, f => f }.map
      (f ≫ g) =
    {
            obj := fun X =>
              match X with
              | inl (inl X) => inl X
              | inl (inr X) => inr (inl X)
              | inr X => inr (inr X),
            map := fun {X Y} f =>
              match X, Y, f with
              | inl (inl val), inl (inl val_1), f => f
              | inl (inr val), inl (inr val_1), f => f
              | inr val, inr val_1, f => f }.map
        f ≫
      {
            obj := fun X =>
              match X with
              | inl (inl X) => inl X
              | inl (inr X) => inr (inl X)
              | inr X => inr (inr X),
            map := fun {X Y} f =>
              match X, Y, f with
              | inl (inl val), inl (inl val_1), f => f
              | inl (inr val), inl (inr val_1), f => f
              | inr val, inr val_1, f => f }.map
        g
[PROOFSTEP]
first
| cases f
| cases g
| aesop_cat
[GOAL]
case inl.inl.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✝² : C
val✝¹ : E
val✝ : D
f : inl (inl val✝²) ⟶ inr val✝¹
g : inr val✝¹ ⟶ inl (inr val✝)
⊢ {
          obj := fun X =>
            match X with
            | inl (inl X) => inl X
            | inl (inr X) => inr (inl X)
            | inr X => inr (inr X),
          map := fun {X Y} f =>
            match X, Y, f with
            | inl (inl val), inl (inl val_1), f => f
            | inl (inr val), inl (inr val_1), f => f
            | inr val, inr val_1, f => f }.map
      (f ≫ g) =
    {
            obj := fun X =>
              match X with
              | inl (inl X) => inl X
              | inl (inr X) => inr (inl X)
              | inr X => inr (inr X),
            map := fun {X Y} f =>
              match X, Y, f with
              | inl (inl val), inl (inl val_1), f => f
              | inl (inr val), inl (inr val_1), f => f
              | inr val, inr val_1, f => f }.map
        f ≫
      {
            obj := fun X =>
              match X with
              | inl (inl X) => inl X
              | inl (inr X) => inr (inl X)
              | inr X => inr (inr X),
            map := fun {X Y} f =>
              match X, Y, f with
              | inl (inl val), inl (inl val_1), f => f
              | inl (inr val), inl (inr val_1), f => f
              | inr val, inr val_1, f => f }.map
        g
[PROOFSTEP]
cases f
[GOAL]
case inl.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✝¹ val✝ : E
f : inl (inl val✝²) ⟶ inr val✝¹
g : inr val✝¹ ⟶ inr val✝
⊢ {
          obj := fun X =>
            match X with
            | inl (inl X) => inl X
            | inl (inr X) => inr (inl X)
            | inr X => inr (inr X),
          map := fun {X Y} f =>
            match X, Y, f with
            | inl (inl val), inl (inl val_1), f => f
            | inl (inr val), inl (inr val_1), f => f
            | inr val, inr val_1, f => f }.map
      (f ≫ g) =
    {
            obj := fun X =>
              match X with
              | inl (inl X) => inl X
              | inl (inr X) => inr (inl X)
              | inr X => inr (inr X),
            map := fun {X Y} f =>
              match X, Y, f with
              | inl (inl val), inl (inl val_1), f => f
              | inl (inr val), inl (inr val_1), f => f
              | inr val, inr val_1, f => f }.map
        f ≫
      {
            obj := fun X =>
              match X with
              | inl (inl X) => inl X
              | inl (inr X) => inr (inl X)
              | inr X => inr (inr X),
            map := fun {X Y} f =>
              match X, Y, f with
              | inl (inl val), inl (inl val_1), f => f
              | inl (inr val), inl (inr val_1), f => f
              | inr val, inr val_1, f => f }.map
        g
[PROOFSTEP]
first
| cases f
| cases g
| aesop_cat
[GOAL]
case inl.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✝¹ val✝ : E
f : inl (inl val✝²) ⟶ inr val✝¹
g : inr val✝¹ ⟶ inr val✝
⊢ {
          obj := fun X =>
            match X with
            | inl (inl X) => inl X
            | inl (inr X) => inr (inl X)
            | inr X => inr (inr X),
          map := fun {X Y} f =>
            match X, Y, f with
            | inl (inl val), inl (inl val_1), f => f
            | inl (inr val), inl (inr val_1), f => f
            | inr val, inr val_1, f => f }.map
      (f ≫ g) =
    {
            obj := fun X =>
              match X with
              | inl (inl X) => inl X
              | inl (inr X) => inr (inl X)
              | inr X => inr (inr X),
            map := fun {X Y} f =>
              match X, Y, f with
              | inl (inl val), inl (inl val_1), f => f
              | inl (inr val), inl (inr val_1), f => f
              | inr val, inr val_1, f => f }.map
        f ≫
      {
            obj := fun X =>
              match X with
              | inl (inl X) => inl X
              | inl (inr X) => inr (inl X)
              | inr X => inr (inr X),
            map := fun {X Y} f =>
              match X, Y, f with
              | inl (inl val), inl (inl val_1), f => f
              | inl (inr val), inl (inr val_1), f => f
              | inr val, inr val_1, f => f }.map
        g
[PROOFSTEP]
cases f
[GOAL]
case inl.inr.inl.inl.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✝¹ val✝ : C
f : inl (inr val✝²) ⟶ inl (inl val✝¹)
g : inl (inl val✝¹) ⟶ inl (inl val✝)
⊢ {
          obj := fun X =>
            match X with
            | inl (inl X) => inl X
            | inl (inr X) => inr (inl X)
            | inr X => inr (inr X),
          map := fun {X Y} f =>
            match X, Y, f with
            | inl (inl val), inl (inl val_1), f => f
            | inl (inr val), inl (inr val_1), f => f
            | inr val, inr val_1, f => f }.map
      (f ≫ g) =
    {
            obj := fun X =>
              match X with
              | inl (inl X) => inl X
              | inl (inr X) => inr (inl X)
              | inr X => inr (inr X),
            map := fun {X Y} f =>
              match X, Y, f with
              | inl (inl val), inl (inl val_1), f => f
              | inl (inr val), inl (inr val_1), f => f
              | inr val, inr val_1, f => f }.map
        f ≫
      {
            obj := fun X =>
              match X with
              | inl (inl X) => inl X
              | inl (inr X) => inr (inl X)
              | inr X => inr (inr X),
            map := fun {X Y} f =>
              match X, Y, f with
              | inl (inl val), inl (inl val_1), f => f
              | inl (inr val), inl (inr val_1), f => f
              | inr val, inr val_1, f => f }.map
        g
[PROOFSTEP]
first
| cases f
| cases g
| aesop_cat
[GOAL]
case inl.inr.inl.inl.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✝¹ val✝ : C
f : inl (inr val✝²) ⟶ inl (inl val✝¹)
g : inl (inl val✝¹) ⟶ inl (inl val✝)
⊢ {
          obj := fun X =>
            match X with
            | inl (inl X) => inl X
            | inl (inr X) => inr (inl X)
            | inr X => inr (inr X),
          map := fun {X Y} f =>
            match X, Y, f with
            | inl (inl val), inl (inl val_1), f => f
            | inl (inr val), inl (inr val_1), f => f
            | inr val, inr val_1, f => f }.map
      (f ≫ g) =
    {
            obj := fun X =>
              match X with
              | inl (inl X) => inl X
              | inl (inr X) => inr (inl X)
              | inr X => inr (inr X),
            map := fun {X Y} f =>
              match X, Y, f with
              | inl (inl val), inl (inl val_1), f => f
              | inl (inr val), inl (inr val_1), f => f
              | inr val, inr val_1, f => f }.map
        f ≫
      {
            obj := fun X =>
              match X with
              | inl (inl X) => inl X
              | inl (inr X) => inr (inl X)
              | inr X => inr (inr X),
            map := fun {X Y} f =>
              match X, Y, f with
              | inl (inl val), inl (inl val_1), f => f
              | inl (inr val), inl (inr val_1), f => f
              | inr val, inr val_1, f => f }.map
        g
[PROOFSTEP]
cases f
[GOAL]
case inl.inr.inl.inl.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✝² : D
val✝¹ : C
val✝ : D
f : inl (inr val✝²) ⟶ inl (inl val✝¹)
g : inl (inl val✝¹) ⟶ inl (inr val✝)
⊢ {
          obj := fun X =>
            match X with
            | inl (inl X) => inl X
            | inl (inr X) => inr (inl X)
            | inr X => inr (inr X),
          map := fun {X Y} f =>
            match X, Y, f with
            | inl (inl val), inl (inl val_1), f => f
            | inl (inr val), inl (inr val_1), f => f
            | inr val, inr val_1, f => f }.map
      (f ≫ g) =
    {
            obj := fun X =>
              match X with
              | inl (inl X) => inl X
              | inl (inr X) => inr (inl X)
              | inr X => inr (inr X),
            map := fun {X Y} f =>
              match X, Y, f with
              | inl (inl val), inl (inl val_1), f => f
              | inl (inr val), inl (inr val_1), f => f
              | inr val, inr val_1, f => f }.map
        f ≫
      {
            obj := fun X =>
              match X with
              | inl (inl X) => inl X
              | inl (inr X) => inr (inl X)
              | inr X => inr (inr X),
            map := fun {X Y} f =>
              match X, Y, f with
              | inl (inl val), inl (inl val_1), f => f
              | inl (inr val), inl (inr val_1), f => f
              | inr val, inr val_1, f => f }.map
        g
[PROOFSTEP]
first
| cases f
| cases g
| aesop_cat
[GOAL]
case inl.inr.inl.inl.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✝² : D
val✝¹ : C
val✝ : D
f : inl (inr val✝²) ⟶ inl (inl val✝¹)
g : inl (inl val✝¹) ⟶ inl (inr val✝)
⊢ {
          obj := fun X =>
            match X with
            | inl (inl X) => inl X
            | inl (inr X) => inr (inl X)
            | inr X => inr (inr X),
          map := fun {X Y} f =>
            match X, Y, f with
            | inl (inl val), inl (inl val_1), f => f
            | inl (inr val), inl (inr val_1), f => f
            | inr val, inr val_1, f => f }.map
      (f ≫ g) =
    {
            obj := fun X =>
              match X with
              | inl (inl X) => inl X
              | inl (inr X) => inr (inl X)
              | inr X => inr (inr X),
            map := fun {X Y} f =>
              match X, Y, f with
              | inl (inl val), inl (inl val_1), f => f
              | inl (inr val), inl (inr val_1), f => f
              | inr val, inr val_1, f => f }.map
        f ≫
      {
            obj := fun X =>
              match X with
              | inl (inl X) => inl X
              | inl (inr X) => inr (inl X)
              | inr X => inr (inr X),
            map := fun {X Y} f =>
              match X, Y, f with
              | inl (inl val), inl (inl val_1), f => f
              | inl (inr val), inl (inr val_1), f => f
              | inr val, inr val_1, f => f }.map
        g
[PROOFSTEP]
cases f
[GOAL]
case inl.inr.inl.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✝² : D
val✝¹ : C
val✝ : E
f : inl (inr val✝²) ⟶ inl (inl val✝¹)
g : inl (inl val✝¹) ⟶ inr val✝
⊢ {
          obj := fun X =>
            match X with
            | inl (inl X) => inl X
            | inl (inr X) => inr (inl X)
            | inr X => inr (inr X),
          map := fun {X Y} f =>
            match X, Y, f with
            | inl (inl val), inl (inl val_1), f => f
            | inl (inr val), inl (inr val_1), f => f
            | inr val, inr val_1, f => f }.map
      (f ≫ g) =
    {
            obj := fun X =>
              match X with
              | inl (inl X) => inl X
              | inl (inr X) => inr (inl X)
              | inr X => inr (inr X),
            map := fun {X Y} f =>
              match X, Y, f with
              | inl (inl val), inl (inl val_1), f => f
              | inl (inr val), inl (inr val_1), f => f
              | inr val, inr val_1, f => f }.map
        f ≫
      {
            obj := fun X =>
              match X with
              | inl (inl X) => inl X
              | inl (inr X) => inr (inl X)
              | inr X => inr (inr X),
            map := fun {X Y} f =>
              match X, Y, f with
              | inl (inl val), inl (inl val_1), f => f
              | inl (inr val), inl (inr val_1), f => f
              | inr val, inr val_1, f => f }.map
        g
[PROOFSTEP]
first
| cases f
| cases g
| aesop_cat
[GOAL]
case inl.inr.inl.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✝² : D
val✝¹ : C
val✝ : E
f : inl (inr val✝²) ⟶ inl (inl val✝¹)
g : inl (inl val✝¹) ⟶ inr val✝
⊢ {
          obj := fun X =>
            match X with
            | inl (inl X) => inl X
            | inl (inr X) => inr (inl X)
            | inr X => inr (inr X),
          map := fun {X Y} f =>
            match X, Y, f with
            | inl (inl val), inl (inl val_1), f => f
            | inl (inr val), inl (inr val_1), f => f
            | inr val, inr val_1, f => f }.map
      (f ≫ g) =
    {
            obj := fun X =>
              match X with
              | inl (inl X) => inl X
              | inl (inr X) => inr (inl X)
              | inr X => inr (inr X),
            map := fun {X Y} f =>
              match X, Y, f with
              | inl (inl val), inl (inl val_1), f => f
              | inl (inr val), inl (inr val_1), f => f
              | inr val, inr val_1, f => f }.map
        f ≫
      {
            obj := fun X =>
              match X with
              | inl (inl X) => inl X
              | inl (inr X) => inr (inl X)
              | inr X => inr (inr X),
            map := fun {X Y} f =>
              match X, Y, f with
              | inl (inl val), inl (inl val_1), f => f
              | inl (inr val), inl (inr val_1), f => f
              | inr val, inr val_1, f => f }.map
        g
[PROOFSTEP]
cases f
[GOAL]
case inl.inr.inl.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✝² val✝¹ : D
val✝ : C
f : inl (inr val✝²) ⟶ inl (inr val✝¹)
g : inl (inr val✝¹) ⟶ inl (inl val✝)
⊢ {
          obj := fun X =>
            match X with
            | inl (inl X) => inl X
            | inl (inr X) => inr (inl X)
            | inr X => inr (inr X),
          map := fun {X Y} f =>
            match X, Y, f with
            | inl (inl val), inl (inl val_1), f => f
            | inl (inr val), inl (inr val_1), f => f
            | inr val, inr val_1, f => f }.map
      (f ≫ g) =
    {
            obj := fun X =>
              match X with
              | inl (inl X) => inl X
              | inl (inr X) => inr (inl X)
              | inr X => inr (inr X),
            map := fun {X Y} f =>
              match X, Y, f with
              | inl (inl val), inl (inl val_1), f => f
              | inl (inr val), inl (inr val_1), f => f
              | inr val, inr val_1, f => f }.map
        f ≫
      {
            obj := fun X =>
              match X with
              | inl (inl X) => inl X
              | inl (inr X) => inr (inl X)
              | inr X => inr (inr X),
            map := fun {X Y} f =>
              match X, Y, f with
              | inl (inl val), inl (inl val_1), f => f
              | inl (inr val), inl (inr val_1), f => f
              | inr val, inr val_1, f => f }.map
        g
[PROOFSTEP]
first
| cases f
| cases g
| aesop_cat
[GOAL]
case inl.inr.inl.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✝² val✝¹ : D
val✝ : C
f : inl (inr val✝²) ⟶ inl (inr val✝¹)
g : inl (inr val✝¹) ⟶ inl (inl val✝)
⊢ {
          obj := fun X =>
            match X with
            | inl (inl X) => inl X
            | inl (inr X) => inr (inl X)
            | inr X => inr (inr X),
          map := fun {X Y} f =>
            match X, Y, f with
            | inl (inl val), inl (inl val_1), f => f
            | inl (inr val), inl (inr val_1), f => f
            | inr val, inr val_1, f => f }.map
      (f ≫ g) =
    {
            obj := fun X =>
              match X with
              | inl (inl X) => inl X
              | inl (inr X) => inr (inl X)
              | inr X => inr (inr X),
            map := fun {X Y} f =>
              match X, Y, f with
              | inl (inl val), inl (inl val_1), f => f
              | inl (inr val), inl (inr val_1), f => f
              | inr val, inr val_1, f => f }.map
        f ≫
      {
            obj := fun X =>
              match X with
              | inl (inl X) => inl X
              | inl (inr X) => inr (inl X)
              | inr X => inr (inr X),
            map := fun {X Y} f =>
              match X, Y, f with
              | inl (inl val), inl (inl val_1), f => f
              | inl (inr val), inl (inr val_1), f => f
              | inr val, inr val_1, f => f }.map
        g
[PROOFSTEP]
cases f
[GOAL]
case inl.inr.inl.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✝² val✝¹ : D
val✝ : C
f : inl (inr val✝²) ⟶ inl (inr val✝¹)
g : inl (inr val✝¹) ⟶ inl (inl val✝)
⊢ {
          obj := fun X =>
            match X with
            | inl (inl X) => inl X
            | inl (inr X) => inr (inl X)
            | inr X => inr (inr X),
          map := fun {X Y} f =>
            match X, Y, f with
            | inl (inl val), inl (inl val_1), f => f
            | inl (inr val), inl (inr val_1), f => f
            | inr val, inr val_1, f => f }.map
      (f ≫ g) =
    {
            obj := fun X =>
              match X with
              | inl (inl X) => inl X
              | inl (inr X) => inr (inl X)
              | inr X => inr (inr X),
            map := fun {X Y} f =>
              match X, Y, f with
              | inl (inl val), inl (inl val_1), f => f
              | inl (inr val), inl (inr val_1), f => f
              | inr val, inr val_1, f => f }.map
        f ≫
      {
            obj := fun X =>
              match X with
              | inl (inl X) => inl X
              | inl (inr X) => inr (inl X)
              | inr X => inr (inr X),
            map := fun {X Y} f =>
              match X, Y, f with
              | inl (inl val), inl (inl val_1), f => f
              | inl (inr val), inl (inr val_1), f => f
              | inr val, inr val_1, f => f }.map
        g
[PROOFSTEP]
cases g
[GOAL]
case inl.inr.inl.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✝² val✝¹ val✝ : D
f : inl (inr val✝²) ⟶ inl (inr val✝¹)
g : inl (inr val✝¹) ⟶ inl (inr val✝)
⊢ {
          obj := fun X =>
            match X with
            | inl (inl X) => inl X
            | inl (inr X) => inr (inl X)
            | inr X => inr (inr X),
          map := fun {X Y} f =>
            match X, Y, f with
            | inl (inl val), inl (inl val_1), f => f
            | inl (inr val), inl (inr val_1), f => f
            | inr val, inr val_1, f => f }.map
      (f ≫ g) =
    {
            obj := fun X =>
              match X with
              | inl (inl X) => inl X
              | inl (inr X) => inr (inl X)
              | inr X => inr (inr X),
            map := fun {X Y} f =>
              match X, Y, f with
              | inl (inl val), inl (inl val_1), f => f
              | inl (inr val), inl (inr val_1), f => f
              | inr val, inr val_1, f => f }.map
        f ≫
      {
            obj := fun X =>
              match X with
              | inl (inl X) => inl X
              | inl (inr X) => inr (inl X)
              | inr X => inr (inr X),
            map := fun {X Y} f =>
              match X, Y, f with
              | inl (inl val), inl (inl val_1), f => f
              | inl (inr val), inl (inr val_1), f => f
              | inr val, inr val_1, f => f }.map
        g
[PROOFSTEP]
first
| cases f
| cases g
| aesop_cat
[GOAL]
case inl.inr.inl.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✝² val✝¹ val✝ : D
f : inl (inr val✝²) ⟶ inl (inr val✝¹)
g : inl (inr val✝¹) ⟶ inl (inr val✝)
⊢ {
          obj := fun X =>
            match X with
            | inl (inl X) => inl X
            | inl (inr X) => inr (inl X)
            | inr X => inr (inr X),
          map := fun {X Y} f =>
            match X, Y, f with
            | inl (inl val), inl (inl val_1), f => f
            | inl (inr val), inl (inr val_1), f => f
            | inr val, inr val_1, f => f }.map
      (f ≫ g) =
    {
            obj := fun X =>
              match X with
              | inl (inl X) => inl X
              | inl (inr X) => inr (inl X)
              | inr X => inr (inr X),
            map := fun {X Y} f =>
              match X, Y, f with
              | inl (inl val), inl (inl val_1), f => f
              | inl (inr val), inl (inr val_1), f => f
              | inr val, inr val_1, f => f }.map
        f ≫
      {
            obj := fun X =>
              match X with
              | inl (inl X) => inl X
              | inl (inr X) => inr (inl X)
              | inr X => inr (inr X),
            map := fun {X Y} f =>
              match X, Y, f with
              | inl (inl val), inl (inl val_1), f => f
              | inl (inr val), inl (inr val_1), f => f
              | inr val, inr val_1, f => f }.map
        g
[PROOFSTEP]
cases f
[GOAL]
case inl.inr.inl.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✝² val✝¹ val✝ : D
f : inl (inr val✝²) ⟶ inl (inr val✝¹)
g : inl (inr val✝¹) ⟶ inl (inr val✝)
⊢ {
          obj := fun X =>
            match X with
            | inl (inl X) => inl X
            | inl (inr X) => inr (inl X)
            | inr X => inr (inr X),
          map := fun {X Y} f =>
            match X, Y, f with
            | inl (inl val), inl (inl val_1), f => f
            | inl (inr val), inl (inr val_1), f => f
            | inr val, inr val_1, f => f }.map
      (f ≫ g) =
    {
            obj := fun X =>
              match X with
              | inl (inl X) => inl X
              | inl (inr X) => inr (inl X)
              | inr X => inr (inr X),
            map := fun {X Y} f =>
              match X, Y, f with
              | inl (inl val), inl (inl val_1), f => f
              | inl (inr val), inl (inr val_1), f => f
              | inr val, inr val_1, f => f }.map
        f ≫
      {
            obj := fun X =>
              match X with
              | inl (inl X) => inl X
              | inl (inr X) => inr (inl X)
              | inr X => inr (inr X),
            map := fun {X Y} f =>
              match X, Y, f with
              | inl (inl val), inl (inl val_1), f => f
              | inl (inr val), inl (inr val_1), f => f
              | inr val, inr val_1, f => f }.map
        g
[PROOFSTEP]
cases g
[GOAL]
case inl.inr.inl.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✝² val✝¹ val✝ : D
f : inl (inr val✝²) ⟶ inl (inr val✝¹)
g : inl (inr val✝¹) ⟶ inl (inr val✝)
⊢ {
          obj := fun X =>
            match X with
            | inl (inl X) => inl X
            | inl (inr X) => inr (inl X)
            | inr X => inr (inr X),
          map := fun {X Y} f =>
            match X, Y, f with
            | inl (inl val), inl (inl val_1), f => f
            | inl (inr val), inl (inr val_1), f => f
            | inr val, inr val_1, f => f }.map
      (f ≫ g) =
    {
            obj := fun X =>
              match X with
              | inl (inl X) => inl X
              | inl (inr X) => inr (inl X)
              | inr X => inr (inr X),
            map := fun {X Y} f =>
              match X, Y, f with
              | inl (inl val), inl (inl val_1), f => f
              | inl (inr val), inl (inr val_1), f => f
              | inr val, inr val_1, f => f }.map
        f ≫
      {
            obj := fun X =>
              match X with
              | inl (inl X) => inl X
              | inl (inr X) => inr (inl X)
              | inr X => inr (inr X),
            map := fun {X Y} f =>
              match X, Y, f with
              | inl (inl val), inl (inl val_1), f => f
              | inl (inr val), inl (inr val_1), f => f
              | inr val, inr val_1, f => f }.map
        g
[PROOFSTEP]
aesop_cat
[GOAL]
case inl.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✝² val✝¹ : D
val✝ : E
f : inl (inr val✝²) ⟶ inl (inr val✝¹)
g : inl (inr val✝¹) ⟶ inr val✝
⊢ {
          obj := fun X =>
            match X with
            | inl (inl X) => inl X
            | inl (inr X) => inr (inl X)
            | inr X => inr (inr X),
          map := fun {X Y} f =>
            match X, Y, f with
            | inl (inl val), inl (inl val_1), f => f
            | inl (inr val), inl (inr val_1), f => f
            | inr val, inr val_1, f => f }.map
      (f ≫ g) =
    {
            obj := fun X =>
              match X with
              | inl (inl X) => inl X
              | inl (inr X) => inr (inl X)
              | inr X => inr (inr X),
            map := fun {X Y} f =>
              match X, Y, f with
              | inl (inl val), inl (inl val_1), f => f
              | inl (inr val), inl (inr val_1), f => f
              | inr val, inr val_1, f => f }.map
        f ≫
      {
            obj := fun X =>
              match X with
              | inl (inl X) => inl X
              | inl (inr X) => inr (inl X)
              | inr X => inr (inr X),
            map := fun {X Y} f =>
              match X, Y, f with
              | inl (inl val), inl (inl val_1), f => f
              | inl (inr val), inl (inr val_1), f => f
              | inr val, inr val_1, f => f }.map
        g
[PROOFSTEP]
first
| cases f
| cases g
| aesop_cat
[GOAL]
case inl.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✝² val✝¹ : D
val✝ : E
f : inl (inr val✝²) ⟶ inl (inr val✝¹)
g : inl (inr val✝¹) ⟶ inr val✝
⊢ {
          obj := fun X =>
            match X with
            | inl (inl X) => inl X
            | inl (inr X) => inr (inl X)
            | inr X => inr (inr X),
          map := fun {X Y} f =>
            match X, Y, f with
            | inl (inl val), inl (inl val_1), f => f
            | inl (inr val), inl (inr val_1), f => f
            | inr val, inr val_1, f => f }.map
      (f ≫ g) =
    {
            obj := fun X =>
              match X with
              | inl (inl X) => inl X
              | inl (inr X) => inr (inl X)
              | inr X => inr (inr X),
            map := fun {X Y} f =>
              match X, Y, f with
              | inl (inl val), inl (inl val_1), f => f
              | inl (inr val), inl (inr val_1), f => f
              | inr val, inr val_1, f => f }.map
        f ≫
      {
            obj := fun X =>
              match X with
              | inl (inl X) => inl X
              | inl (inr X) => inr (inl X)
              | inr X => inr (inr X),
            map := fun {X Y} f =>
              match X, Y, f with
              | inl (inl val), inl (inl val_1), f => f
              | inl (inr val), inl (inr val_1), f => f
              | inr val, inr val_1, f => f }.map
        g
[PROOFSTEP]
cases f
[GOAL]
case inl.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✝² val✝¹ : D
val✝ : E
f : inl (inr val✝²) ⟶ inl (inr val✝¹)
g : inl (inr val✝¹) ⟶ inr val✝
⊢ {
          obj := fun X =>
            match X with
            | inl (inl X) => inl X
            | inl (inr X) => inr (inl X)
            | inr X => inr (inr X),
          map := fun {X Y} f =>
            match X, Y, f with
            | inl (inl val), inl (inl val_1), f => f
            | inl (inr val), inl (inr val_1), f => f
            | inr val, inr val_1, f => f }.map
      (f ≫ g) =
    {
            obj := fun X =>
              match X with
              | inl (inl X) => inl X
              | inl (inr X) => inr (inl X)
              | inr X => inr (inr X),
            map := fun {X Y} f =>
              match X, Y, f with
              | inl (inl val), inl (inl val_1), f => f
              | inl (inr val), inl (inr val_1), f => f
              | inr val, inr val_1, f => f }.map
        f ≫
      {
            obj := fun X =>
              match X with
              | inl (inl X) => inl X
              | inl (inr X) => inr (inl X)
              | inr X => inr (inr X),
            map := fun {X Y} f =>
              match X, Y, f with
              | inl (inl val), inl (inl val_1), f => f
              | inl (inr val), inl (inr val_1), f => f
              | inr val, inr val_1, f => f }.map
        g
[PROOFSTEP]
cases g
[GOAL]
case inl.inr.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✝¹ : E
val✝ : C
f : inl (inr val✝²) ⟶ inr val✝¹
g : inr val✝¹ ⟶ inl (inl val✝)
⊢ {
          obj := fun X =>
            match X with
            | inl (inl X) => inl X
            | inl (inr X) => inr (inl X)
            | inr X => inr (inr X),
          map := fun {X Y} f =>
            match X, Y, f with
            | inl (inl val), inl (inl val_1), f => f
            | inl (inr val), inl (inr val_1), f => f
            | inr val, inr val_1, f => f }.map
      (f ≫ g) =
    {
            obj := fun X =>
              match X with
              | inl (inl X) => inl X
              | inl (inr X) => inr (inl X)
              | inr X => inr (inr X),
            map := fun {X Y} f =>
              match X, Y, f with
              | inl (inl val), inl (inl val_1), f => f
              | inl (inr val), inl (inr val_1), f => f
              | inr val, inr val_1, f => f }.map
        f ≫
      {
            obj := fun X =>
              match X with
              | inl (inl X) => inl X
              | inl (inr X) => inr (inl X)
              | inr X => inr (inr X),
            map := fun {X Y} f =>
              match X, Y, f with
              | inl (inl val), inl (inl val_1), f => f
              | inl (inr val), inl (inr val_1), f => f
              | inr val, inr val_1, f => f }.map
        g
[PROOFSTEP]
first
| cases f
| cases g
| aesop_cat
[GOAL]
case inl.inr.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✝¹ : E
val✝ : C
f : inl (inr val✝²) ⟶ inr val✝¹
g : inr val✝¹ ⟶ inl (inl val✝)
⊢ {
          obj := fun X =>
            match X with
            | inl (inl X) => inl X
            | inl (inr X) => inr (inl X)
            | inr X => inr (inr X),
          map := fun {X Y} f =>
            match X, Y, f with
            | inl (inl val), inl (inl val_1), f => f
            | inl (inr val), inl (inr val_1), f => f
            | inr val, inr val_1, f => f }.map
      (f ≫ g) =
    {
            obj := fun X =>
              match X with
              | inl (inl X) => inl X
              | inl (inr X) => inr (inl X)
              | inr X => inr (inr X),
            map := fun {X Y} f =>
              match X, Y, f with
              | inl (inl val), inl (inl val_1), f => f
              | inl (inr val), inl (inr val_1), f => f
              | inr val, inr val_1, f => f }.map
        f ≫
      {
            obj := fun X =>
              match X with
              | inl (inl X) => inl X
              | inl (inr X) => inr (inl X)
              | inr X => inr (inr X),
            map := fun {X Y} f =>
              match X, Y, f with
              | inl (inl val), inl (inl val_1), f => f
              | inl (inr val), inl (inr val_1), f => f
              | inr val, inr val_1, f => f }.map
        g
[PROOFSTEP]
cases f
[GOAL]
case inl.inr.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✝² : D
val✝¹ : E
val✝ : D
f : inl (inr val✝²) ⟶ inr val✝¹
g : inr val✝¹ ⟶ inl (inr val✝)
⊢ {
          obj := fun X =>
            match X with
            | inl (inl X) => inl X
            | inl (inr X) => inr (inl X)
            | inr X => inr (inr X),
          map := fun {X Y} f =>
            match X, Y, f with
            | inl (inl val), inl (inl val_1), f => f
            | inl (inr val), inl (inr val_1), f => f
            | inr val, inr val_1, f => f }.map
      (f ≫ g) =
    {
            obj := fun X =>
              match X with
              | inl (inl X) => inl X
              | inl (inr X) => inr (inl X)
              | inr X => inr (inr X),
            map := fun {X Y} f =>
              match X, Y, f with
              | inl (inl val), inl (inl val_1), f => f
              | inl (inr val), inl (inr val_1), f => f
              | inr val, inr val_1, f => f }.map
        f ≫
      {
            obj := fun X =>
              match X with
              | inl (inl X) => inl X
              | inl (inr X) => inr (inl X)
              | inr X => inr (inr X),
            map := fun {X Y} f =>
              match X, Y, f with
              | inl (inl val), inl (inl val_1), f => f
              | inl (inr val), inl (inr val_1), f => f
              | inr val, inr val_1, f => f }.map
        g
[PROOFSTEP]
first
| cases f
| cases g
| aesop_cat
[GOAL]
case inl.inr.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✝² : D
val✝¹ : E
val✝ : D
f : inl (inr val✝²) ⟶ inr val✝¹
g : inr val✝¹ ⟶ inl (inr val✝)
⊢ {
          obj := fun X =>
            match X with
            | inl (inl X) => inl X
            | inl (inr X) => inr (inl X)
            | inr X => inr (inr X),
          map := fun {X Y} f =>
            match X, Y, f with
            | inl (inl val), inl (inl val_1), f => f
            | inl (inr val), inl (inr val_1), f => f
            | inr val, inr val_1, f => f }.map
      (f ≫ g) =
    {
            obj := fun X =>
              match X with
              | inl (inl X) => inl X
              | inl (inr X) => inr (inl X)
              | inr X => inr (inr X),
            map := fun {X Y} f =>
              match X, Y, f with
              | inl (inl val), inl (inl val_1), f => f
              | inl (inr val), inl (inr val_1), f => f
              | inr val, inr val_1, f => f }.map
        f ≫
      {
            obj := fun X =>
              match X with
              | inl (inl X) => inl X
              | inl (inr X) => inr (inl X)
              | inr X => inr (inr X),
            map := fun {X Y} f =>
              match X, Y, f with
              | inl (inl val), inl (inl val_1), f => f
              | inl (inr val), inl (inr val_1), f => f
              | inr val, inr val_1, f => f }.map
        g
[PROOFSTEP]
cases f
[GOAL]
case inl.inr.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✝¹ val✝ : E
f : inl (inr val✝²) ⟶ inr val✝¹
g : inr val✝¹ ⟶ inr val✝
⊢ {
          obj := fun X =>
            match X with
            | inl (inl X) => inl X
            | inl (inr X) => inr (inl X)
            | inr X => inr (inr X),
          map := fun {X Y} f =>
            match X, Y, f with
            | inl (inl val), inl (inl val_1), f => f
            | inl (inr val), inl (inr val_1), f => f
            | inr val, inr val_1, f => f }.map
      (f ≫ g) =
    {
            obj := fun X =>
              match X with
              | inl (inl X) => inl X
              | inl (inr X) => inr (inl X)
              | inr X => inr (inr X),
            map := fun {X Y} f =>
              match X, Y, f with
              | inl (inl val), inl (inl val_1), f => f
              | inl (inr val), inl (inr val_1), f => f
              | inr val, inr val_1, f => f }.map
        f ≫
      {
            obj := fun X =>
              match X with
              | inl (inl X) => inl X
              | inl (inr X) => inr (inl X)
              | inr X => inr (inr X),
            map := fun {X Y} f =>
              match X, Y, f with
              | inl (inl val), inl (inl val_1), f => f
              | inl (inr val), inl (inr val_1), f => f
              | inr val, inr val_1, f => f }.map
        g
[PROOFSTEP]
first
| cases f
| cases g
| aesop_cat
[GOAL]
case inl.inr.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✝¹ val✝ : E
f : inl (inr val✝²) ⟶ inr val✝¹
g : inr val✝¹ ⟶ inr val✝
⊢ {
          obj := fun X =>
            match X with
            | inl (inl X) => inl X
            | inl (inr X) => inr (inl X)
            | inr X => inr (inr X),
          map := fun {X Y} f =>
            match X, Y, f with
            | inl (inl val), inl (inl val_1), f => f
            | inl (inr val), inl (inr val_1), f => f
            | inr val, inr val_1, f => f }.map
      (f ≫ g) =
    {
            obj := fun X =>
              match X with
              | inl (inl X) => inl X
              | inl (inr X) => inr (inl X)
              | inr X => inr (inr X),
            map := fun {X Y} f =>
              match X, Y, f with
              | inl (inl val), inl (inl val_1), f => f
              | inl (inr val), inl (inr val_1), f => f
              | inr val, inr val_1, f => f }.map
        f ≫
      {
            obj := fun X =>
              match X with
              | inl (inl X) => inl X
              | inl (inr X) => inr (inl X)
              | inr X => inr (inr X),
            map := fun {X Y} f =>
              match X, Y, f with
              | inl (inl val), inl (inl val_1), f => f
              | inl (inr val), inl (inr val_1), f => f
              | inr val, inr val_1, f => f }.map
        g
[PROOFSTEP]
cases f
[GOAL]
case inr.inl.inl.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✝² : E
val✝¹ val✝ : C
f : inr val✝² ⟶ inl (inl val✝¹)
g : inl (inl val✝¹) ⟶ inl (inl val✝)
⊢ {
          obj := fun X =>
            match X with
            | inl (inl X) => inl X
            | inl (inr X) => inr (inl X)
            | inr X => inr (inr X),
          map := fun {X Y} f =>
            match X, Y, f with
            | inl (inl val), inl (inl val_1), f => f
            | inl (inr val), inl (inr val_1), f => f
            | inr val, inr val_1, f => f }.map
      (f ≫ g) =
    {
            obj := fun X =>
              match X with
              | inl (inl X) => inl X
              | inl (inr X) => inr (inl X)
              | inr X => inr (inr X),
            map := fun {X Y} f =>
              match X, Y, f with
              | inl (inl val), inl (inl val_1), f => f
              | inl (inr val), inl (inr val_1), f => f
              | inr val, inr val_1, f => f }.map
        f ≫
      {
            obj := fun X =>
              match X with
              | inl (inl X) => inl X
              | inl (inr X) => inr (inl X)
              | inr X => inr (inr X),
            map := fun {X Y} f =>
              match X, Y, f with
              | inl (inl val), inl (inl val_1), f => f
              | inl (inr val), inl (inr val_1), f => f
              | inr val, inr val_1, f => f }.map
        g
[PROOFSTEP]
first
| cases f
| cases g
| aesop_cat
[GOAL]
case inr.inl.inl.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✝² : E
val✝¹ val✝ : C
f : inr val✝² ⟶ inl (inl val✝¹)
g : inl (inl val✝¹) ⟶ inl (inl val✝)
⊢ {
          obj := fun X =>
            match X with
            | inl (inl X) => inl X
            | inl (inr X) => inr (inl X)
            | inr X => inr (inr X),
          map := fun {X Y} f =>
            match X, Y, f with
            | inl (inl val), inl (inl val_1), f => f
            | inl (inr val), inl (inr val_1), f => f
            | inr val, inr val_1, f => f }.map
      (f ≫ g) =
    {
            obj := fun X =>
              match X with
              | inl (inl X) => inl X
              | inl (inr X) => inr (inl X)
              | inr X => inr (inr X),
            map := fun {X Y} f =>
              match X, Y, f with
              | inl (inl val), inl (inl val_1), f => f
              | inl (inr val), inl (inr val_1), f => f
              | inr val, inr val_1, f => f }.map
        f ≫
      {
            obj := fun X =>
              match X with
              | inl (inl X) => inl X
              | inl (inr X) => inr (inl X)
              | inr X => inr (inr X),
            map := fun {X Y} f =>
              match X, Y, f with
              | inl (inl val), inl (inl val_1), f => f
              | inl (inr val), inl (inr val_1), f => f
              | inr val, inr val_1, f => f }.map
        g
[PROOFSTEP]
cases f
[GOAL]
case inr.inl.inl.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✝¹ : C
val✝ : D
f : inr val✝² ⟶ inl (inl val✝¹)
g : inl (inl val✝¹) ⟶ inl (inr val✝)
⊢ {
          obj := fun X =>
            match X with
            | inl (inl X) => inl X
            | inl (inr X) => inr (inl X)
            | inr X => inr (inr X),
          map := fun {X Y} f =>
            match X, Y, f with
            | inl (inl val), inl (inl val_1), f => f
            | inl (inr val), inl (inr val_1), f => f
            | inr val, inr val_1, f => f }.map
      (f ≫ g) =
    {
            obj := fun X =>
              match X with
              | inl (inl X) => inl X
              | inl (inr X) => inr (inl X)
              | inr X => inr (inr X),
            map := fun {X Y} f =>
              match X, Y, f with
              | inl (inl val), inl (inl val_1), f => f
              | inl (inr val), inl (inr val_1), f => f
              | inr val, inr val_1, f => f }.map
        f ≫
      {
            obj := fun X =>
              match X with
              | inl (inl X) => inl X
              | inl (inr X) => inr (inl X)
              | inr X => inr (inr X),
            map := fun {X Y} f =>
              match X, Y, f with
              | inl (inl val), inl (inl val_1), f => f
              | inl (inr val), inl (inr val_1), f => f
              | inr val, inr val_1, f => f }.map
        g
[PROOFSTEP]
first
| cases f
| cases g
| aesop_cat
[GOAL]
case inr.inl.inl.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✝¹ : C
val✝ : D
f : inr val✝² ⟶ inl (inl val✝¹)
g : inl (inl val✝¹) ⟶ inl (inr val✝)
⊢ {
          obj := fun X =>
            match X with
            | inl (inl X) => inl X
            | inl (inr X) => inr (inl X)
            | inr X => inr (inr X),
          map := fun {X Y} f =>
            match X, Y, f with
            | inl (inl val), inl (inl val_1), f => f
            | inl (inr val), inl (inr val_1), f => f
            | inr val, inr val_1, f => f }.map
      (f ≫ g) =
    {
            obj := fun X =>
              match X with
              | inl (inl X) => inl X
              | inl (inr X) => inr (inl X)
              | inr X => inr (inr X),
            map := fun {X Y} f =>
              match X, Y, f with
              | inl (inl val), inl (inl val_1), f => f
              | inl (inr val), inl (inr val_1), f => f
              | inr val, inr val_1, f => f }.map
        f ≫
      {
            obj := fun X =>
              match X with
              | inl (inl X) => inl X
              | inl (inr X) => inr (inl X)
              | inr X => inr (inr X),
            map := fun {X Y} f =>
              match X, Y, f with
              | inl (inl val), inl (inl val_1), f => f
              | inl (inr val), inl (inr val_1), f => f
              | inr val, inr val_1, f => f }.map
        g
[PROOFSTEP]
cases f
[GOAL]
case inr.inl.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✝¹ : C
val✝ : E
f : inr val✝² ⟶ inl (inl val✝¹)
g : inl (inl val✝¹) ⟶ inr val✝
⊢ {
          obj := fun X =>
            match X with
            | inl (inl X) => inl X
            | inl (inr X) => inr (inl X)
            | inr X => inr (inr X),
          map := fun {X Y} f =>
            match X, Y, f with
            | inl (inl val), inl (inl val_1), f => f
            | inl (inr val), inl (inr val_1), f => f
            | inr val, inr val_1, f => f }.map
      (f ≫ g) =
    {
            obj := fun X =>
              match X with
              | inl (inl X) => inl X
              | inl (inr X) => inr (inl X)
              | inr X => inr (inr X),
            map := fun {X Y} f =>
              match X, Y, f with
              | inl (inl val), inl (inl val_1), f => f
              | inl (inr val), inl (inr val_1), f => f
              | inr val, inr val_1, f => f }.map
        f ≫
      {
            obj := fun X =>
              match X with
              | inl (inl X) => inl X
              | inl (inr X) => inr (inl X)
              | inr X => inr (inr X),
            map := fun {X Y} f =>
              match X, Y, f with
              | inl (inl val), inl (inl val_1), f => f
              | inl (inr val), inl (inr val_1), f => f
              | inr val, inr val_1, f => f }.map
        g
[PROOFSTEP]
first
| cases f
| cases g
| aesop_cat
[GOAL]
case inr.inl.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✝¹ : C
val✝ : E
f : inr val✝² ⟶ inl (inl val✝¹)
g : inl (inl val✝¹) ⟶ inr val✝
⊢ {
          obj := fun X =>
            match X with
            | inl (inl X) => inl X
            | inl (inr X) => inr (inl X)
            | inr X => inr (inr X),
          map := fun {X Y} f =>
            match X, Y, f with
            | inl (inl val), inl (inl val_1), f => f
            | inl (inr val), inl (inr val_1), f => f
            | inr val, inr val_1, f => f }.map
      (f ≫ g) =
    {
            obj := fun X =>
              match X with
              | inl (inl X) => inl X
              | inl (inr X) => inr (inl X)
              | inr X => inr (inr X),
            map := fun {X Y} f =>
              match X, Y, f with
              | inl (inl val), inl (inl val_1), f => f
              | inl (inr val), inl (inr val_1), f => f
              | inr val, inr val_1, f => f }.map
        f ≫
      {
            obj := fun X =>
              match X with
              | inl (inl X) => inl X
              | inl (inr X) => inr (inl X)
              | inr X => inr (inr X),
            map := fun {X Y} f =>
              match X, Y, f with
              | inl (inl val), inl (inl val_1), f => f
              | inl (inr val), inl (inr val_1), f => f
              | inr val, inr val_1, f => f }.map
        g
[PROOFSTEP]
cases f
[GOAL]
case inr.inl.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✝² : E
val✝¹ : D
val✝ : C
f : inr val✝² ⟶ inl (inr val✝¹)
g : inl (inr val✝¹) ⟶ inl (inl val✝)
⊢ {
          obj := fun X =>
            match X with
            | inl (inl X) => inl X
            | inl (inr X) => inr (inl X)
            | inr X => inr (inr X),
          map := fun {X Y} f =>
            match X, Y, f with
            | inl (inl val), inl (inl val_1), f => f
            | inl (inr val), inl (inr val_1), f => f
            | inr val, inr val_1, f => f }.map
      (f ≫ g) =
    {
            obj := fun X =>
              match X with
              | inl (inl X) => inl X
              | inl (inr X) => inr (inl X)
              | inr X => inr (inr X),
            map := fun {X Y} f =>
              match X, Y, f with
              | inl (inl val), inl (inl val_1), f => f
              | inl (inr val), inl (inr val_1), f => f
              | inr val, inr val_1, f => f }.map
        f ≫
      {
            obj := fun X =>
              match X with
              | inl (inl X) => inl X
              | inl (inr X) => inr (inl X)
              | inr X => inr (inr X),
            map := fun {X Y} f =>
              match X, Y, f with
              | inl (inl val), inl (inl val_1), f => f
              | inl (inr val), inl (inr val_1), f => f
              | inr val, inr val_1, f => f }.map
        g
[PROOFSTEP]
first
| cases f
| cases g
| aesop_cat
[GOAL]
case inr.inl.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✝² : E
val✝¹ : D
val✝ : C
f : inr val✝² ⟶ inl (inr val✝¹)
g : inl (inr val✝¹) ⟶ inl (inl val✝)
⊢ {
          obj := fun X =>
            match X with
            | inl (inl X) => inl X
            | inl (inr X) => inr (inl X)
            | inr X => inr (inr X),
          map := fun {X Y} f =>
            match X, Y, f with
            | inl (inl val), inl (inl val_1), f => f
            | inl (inr val), inl (inr val_1), f => f
            | inr val, inr val_1, f => f }.map
      (f ≫ g) =
    {
            obj := fun X =>
              match X with
              | inl (inl X) => inl X
              | inl (inr X) => inr (inl X)
              | inr X => inr (inr X),
            map := fun {X Y} f =>
              match X, Y, f with
              | inl (inl val), inl (inl val_1), f => f
              | inl (inr val), inl (inr val_1), f => f
              | inr val, inr val_1, f => f }.map
        f ≫
      {
            obj := fun X =>
              match X with
              | inl (inl X) => inl X
              | inl (inr X) => inr (inl X)
              | inr X => inr (inr X),
            map := fun {X Y} f =>
              match X, Y, f with
              | inl (inl val), inl (inl val_1), f => f
              | inl (inr val), inl (inr val_1), f => f
              | inr val, inr val_1, f => f }.map
        g
[PROOFSTEP]
cases f
[GOAL]
case inr.inl.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✝¹ val✝ : D
f : inr val✝² ⟶ inl (inr val✝¹)
g : inl (inr val✝¹) ⟶ inl (inr val✝)
⊢ {
          obj := fun X =>
            match X with
            | inl (inl X) => inl X
            | inl (inr X) => inr (inl X)
            | inr X => inr (inr X),
          map := fun {X Y} f =>
            match X, Y, f with
            | inl (inl val), inl (inl val_1), f => f
            | inl (inr val), inl (inr val_1), f => f
            | inr val, inr val_1, f => f }.map
      (f ≫ g) =
    {
            obj := fun X =>
              match X with
              | inl (inl X) => inl X
              | inl (inr X) => inr (inl X)
              | inr X => inr (inr X),
            map := fun {X Y} f =>
              match X, Y, f with
              | inl (inl val), inl (inl val_1), f => f
              | inl (inr val), inl (inr val_1), f => f
              | inr val, inr val_1, f => f }.map
        f ≫
      {
            obj := fun X =>
              match X with
              | inl (inl X) => inl X
              | inl (inr X) => inr (inl X)
              | inr X => inr (inr X),
            map := fun {X Y} f =>
              match X, Y, f with
              | inl (inl val), inl (inl val_1), f => f
              | inl (inr val), inl (inr val_1), f => f
              | inr val, inr val_1, f => f }.map
        g
[PROOFSTEP]
first
| cases f
| cases g
| aesop_cat
[GOAL]
case inr.inl.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✝¹ val✝ : D
f : inr val✝² ⟶ inl (inr val✝¹)
g : inl (inr val✝¹) ⟶ inl (inr val✝)
⊢ {
          obj := fun X =>
            match X with
            | inl (inl X) => inl X
            | inl (inr X) => inr (inl X)
            | inr X => inr (inr X),
          map := fun {X Y} f =>
            match X, Y, f with
            | inl (inl val), inl (inl val_1), f => f
            | inl (inr val), inl (inr val_1), f => f
            | inr val, inr val_1, f => f }.map
      (f ≫ g) =
    {
            obj := fun X =>
              match X with
              | inl (inl X) => inl X
              | inl (inr X) => inr (inl X)
              | inr X => inr (inr X),
            map := fun {X Y} f =>
              match X, Y, f with
              | inl (inl val), inl (inl val_1), f => f
              | inl (inr val), inl (inr val_1), f => f
              | inr val, inr val_1, f => f }.map
        f ≫
      {
            obj := fun X =>
              match X with
              | inl (inl X) => inl X
              | inl (inr X) => inr (inl X)
              | inr X => inr (inr X),
            map := fun {X Y} f =>
              match X, Y, f with
              | inl (inl val), inl (inl val_1), f => f
              | inl (inr val), inl (inr val_1), f => f
              | inr val, inr val_1, f => f }.map
        g
[PROOFSTEP]
cases f
[GOAL]
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✝² : E
val✝¹ : D
val✝ : E
f : inr val✝² ⟶ inl (inr val✝¹)
g : inl (inr val✝¹) ⟶ inr val✝
⊢ {
          obj := fun X =>
            match X with
            | inl (inl X) => inl X
            | inl (inr X) => inr (inl X)
            | inr X => inr (inr X),
          map := fun {X Y} f =>
            match X, Y, f with
            | inl (inl val), inl (inl val_1), f => f
            | inl (inr val), inl (inr val_1), f => f
            | inr val, inr val_1, f => f }.map
      (f ≫ g) =
    {
            obj := fun X =>
              match X with
              | inl (inl X) => inl X
              | inl (inr X) => inr (inl X)
              | inr X => inr (inr X),
            map := fun {X Y} f =>
              match X, Y, f with
              | inl (inl val), inl (inl val_1), f => f
              | inl (inr val), inl (inr val_1), f => f
              | inr val, inr val_1, f => f }.map
        f ≫
      {
            obj := fun X =>
              match X with
              | inl (inl X) => inl X
              | inl (inr X) => inr (inl X)
              | inr X => inr (inr X),
            map := fun {X Y} f =>
              match X, Y, f with
              | inl (inl val), inl (inl val_1), f => f
              | inl (inr val), inl (inr val_1), f => f
              | inr val, inr val_1, f => f }.map
        g
[PROOFSTEP]
first
| cases f
| cases g
| aesop_cat
[GOAL]
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✝² : E
val✝¹ : D
val✝ : E
f : inr val✝² ⟶ inl (inr val✝¹)
g : inl (inr val✝¹) ⟶ inr val✝
⊢ {
          obj := fun X =>
            match X with
            | inl (inl X) => inl X
            | inl (inr X) => inr (inl X)
            | inr X => inr (inr X),
          map := fun {X Y} f =>
            match X, Y, f with
            | inl (inl val), inl (inl val_1), f => f
            | inl (inr val), inl (inr val_1), f => f
            | inr val, inr val_1, f => f }.map
      (f ≫ g) =
    {
            obj := fun X =>
              match X with
              | inl (inl X) => inl X
              | inl (inr X) => inr (inl X)
              | inr X => inr (inr X),
            map := fun {X Y} f =>
              match X, Y, f with
              | inl (inl val), inl (inl val_1), f => f
              | inl (inr val), inl (inr val_1), f => f
              | inr val, inr val_1, f => f }.map
        f ≫
      {
            obj := fun X =>
              match X with
              | inl (inl X) => inl X
              | inl (inr X) => inr (inl X)
              | inr X => inr (inr X),
            map := fun {X Y} f =>
              match X, Y, f with
              | inl (inl val), inl (inl val_1), f => f
              | inl (inr val), inl (inr val_1), f => f
              | inr val, inr val_1, f => f }.map
        g
[PROOFSTEP]
cases f
[GOAL]
case inr.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✝² val✝¹ : E
val✝ : C
f : inr val✝² ⟶ inr val✝¹
g : inr val✝¹ ⟶ inl (inl val✝)
⊢ {
          obj := fun X =>
            match X with
            | inl (inl X) => inl X
            | inl (inr X) => inr (inl X)
            | inr X => inr (inr X),
          map := fun {X Y} f =>
            match X, Y, f with
            | inl (inl val), inl (inl val_1), f => f
            | inl (inr val), inl (inr val_1), f => f
            | inr val, inr val_1, f => f }.map
      (f ≫ g) =
    {
            obj := fun X =>
              match X with
              | inl (inl X) => inl X
              | inl (inr X) => inr (inl X)
              | inr X => inr (inr X),
            map := fun {X Y} f =>
              match X, Y, f with
              | inl (inl val), inl (inl val_1), f => f
              | inl (inr val), inl (inr val_1), f => f
              | inr val, inr val_1, f => f }.map
        f ≫
      {
            obj := fun X =>
              match X with
              | inl (inl X) => inl X
              | inl (inr X) => inr (inl X)
              | inr X => inr (inr X),
            map := fun {X Y} f =>
              match X, Y, f with
              | inl (inl val), inl (inl val_1), f => f
              | inl (inr val), inl (inr val_1), f => f
              | inr val, inr val_1, f => f }.map
        g
[PROOFSTEP]
first
| cases f
| cases g
| aesop_cat
[GOAL]
case inr.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✝² val✝¹ : E
val✝ : C
f : inr val✝² ⟶ inr val✝¹
g : inr val✝¹ ⟶ inl (inl val✝)
⊢ {
          obj := fun X =>
            match X with
            | inl (inl X) => inl X
            | inl (inr X) => inr (inl X)
            | inr X => inr (inr X),
          map := fun {X Y} f =>
            match X, Y, f with
            | inl (inl val), inl (inl val_1), f => f
            | inl (inr val), inl (inr val_1), f => f
            | inr val, inr val_1, f => f }.map
      (f ≫ g) =
    {
            obj := fun X =>
              match X with
              | inl (inl X) => inl X
              | inl (inr X) => inr (inl X)
              | inr X => inr (inr X),
            map := fun {X Y} f =>
              match X, Y, f with
              | inl (inl val), inl (inl val_1), f => f
              | inl (inr val), inl (inr val_1), f => f
              | inr val, inr val_1, f => f }.map
        f ≫
      {
            obj := fun X =>
              match X with
              | inl (inl X) => inl X
              | inl (inr X) => inr (inl X)
              | inr X => inr (inr X),
            map := fun {X Y} f =>
              match X, Y, f with
              | inl (inl val), inl (inl val_1), f => f
              | inl (inr val), inl (inr val_1), f => f
              | inr val, inr val_1, f => f }.map
        g
[PROOFSTEP]
cases f
[GOAL]
case inr.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✝² val✝¹ : E
val✝ : C
f : inr val✝² ⟶ inr val✝¹
g : inr val✝¹ ⟶ inl (inl val✝)
⊢ {
          obj := fun X =>
            match X with
            | inl (inl X) => inl X
            | inl (inr X) => inr (inl X)
            | inr X => inr (inr X),
          map := fun {X Y} f =>
            match X, Y, f with
            | inl (inl val), inl (inl val_1), f => f
            | inl (inr val), inl (inr val_1), f => f
            | inr val, inr val_1, f => f }.map
      (f ≫ g) =
    {
            obj := fun X =>
              match X with
              | inl (inl X) => inl X
              | inl (inr X) => inr (inl X)
              | inr X => inr (inr X),
            map := fun {X Y} f =>
              match X, Y, f with
              | inl (inl val), inl (inl val_1), f => f
              | inl (inr val), inl (inr val_1), f => f
              | inr val, inr val_1, f => f }.map
        f ≫
      {
            obj := fun X =>
              match X with
              | inl (inl X) => inl X
              | inl (inr X) => inr (inl X)
              | inr X => inr (inr X),
            map := fun {X Y} f =>
              match X, Y, f with
              | inl (inl val), inl (inl val_1), f => f
              | inl (inr val), inl (inr val_1), f => f
              | inr val, inr val_1, f => f }.map
        g
[PROOFSTEP]
cases g
[GOAL]
case inr.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✝² val✝¹ : E
val✝ : D
f : inr val✝² ⟶ inr val✝¹
g : inr val✝¹ ⟶ inl (inr val✝)
⊢ {
          obj := fun X =>
            match X with
            | inl (inl X) => inl X
            | inl (inr X) => inr (inl X)
            | inr X => inr (inr X),
          map := fun {X Y} f =>
            match X, Y, f with
            | inl (inl val), inl (inl val_1), f => f
            | inl (inr val), inl (inr val_1), f => f
            | inr val, inr val_1, f => f }.map
      (f ≫ g) =
    {
            obj := fun X =>
              match X with
              | inl (inl X) => inl X
              | inl (inr X) => inr (inl X)
              | inr X => inr (inr X),
            map := fun {X Y} f =>
              match X, Y, f with
              | inl (inl val), inl (inl val_1), f => f
              | inl (inr val), inl (inr val_1), f => f
              | inr val, inr val_1, f => f }.map
        f ≫
      {
            obj := fun X =>
              match X with
              | inl (inl X) => inl X
              | inl (inr X) => inr (inl X)
              | inr X => inr (inr X),
            map := fun {X Y} f =>
              match X, Y, f with
              | inl (inl val), inl (inl val_1), f => f
              | inl (inr val), inl (inr val_1), f => f
              | inr val, inr val_1, f => f }.map
        g
[PROOFSTEP]
first
| cases f
| cases g
| aesop_cat
[GOAL]
case inr.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✝² val✝¹ : E
val✝ : D
f : inr val✝² ⟶ inr val✝¹
g : inr val✝¹ ⟶ inl (inr val✝)
⊢ {
          obj := fun X =>
            match X with
            | inl (inl X) => inl X
            | inl (inr X) => inr (inl X)
            | inr X => inr (inr X),
          map := fun {X Y} f =>
            match X, Y, f with
            | inl (inl val), inl (inl val_1), f => f
            | inl (inr val), inl (inr val_1), f => f
            | inr val, inr val_1, f => f }.map
      (f ≫ g) =
    {
            obj := fun X =>
              match X with
              | inl (inl X) => inl X
              | inl (inr X) => inr (inl X)
              | inr X => inr (inr X),
            map := fun {X Y} f =>
              match X, Y, f with
              | inl (inl val), inl (inl val_1), f => f
              | inl (inr val), inl (inr val_1), f => f
              | inr val, inr val_1, f => f }.map
        f ≫
      {
            obj := fun X =>
              match X with
              | inl (inl X) => inl X
              | inl (inr X) => inr (inl X)
              | inr X => inr (inr X),
            map := fun {X Y} f =>
              match X, Y, f with
              | inl (inl val), inl (inl val_1), f => f
              | inl (inr val), inl (inr val_1), f => f
              | inr val, inr val_1, f => f }.map
        g
[PROOFSTEP]
cases f
[GOAL]
case inr.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✝² val✝¹ : E
val✝ : D
f : inr val✝² ⟶ inr val✝¹
g : inr val✝¹ ⟶ inl (inr val✝)
⊢ {
          obj := fun X =>
            match X with
            | inl (inl X) => inl X
            | inl (inr X) => inr (inl X)
            | inr X => inr (inr X),
          map := fun {X Y} f =>
            match X, Y, f with
            | inl (inl val), inl (inl val_1), f => f
            | inl (inr val), inl (inr val_1), f => f
            | inr val, inr val_1, f => f }.map
      (f ≫ g) =
    {
            obj := fun X =>
              match X with
              | inl (inl X) => inl X
              | inl (inr X) => inr (inl X)
              | inr X => inr (inr X),
            map := fun {X Y} f =>
              match X, Y, f with
              | inl (inl val), inl (inl val_1), f => f
              | inl (inr val), inl (inr val_1), f => f
              | inr val, inr val_1, f => f }.map
        f ≫
      {
            obj := fun X =>
              match X with
              | inl (inl X) => inl X
              | inl (inr X) => inr (inl X)
              | inr X => inr (inr X),
            map := fun {X Y} f =>
              match X, Y, f with
              | inl (inl val), inl (inl val_1), f => f
              | inl (inr val), inl (inr val_1), f => f
              | inr val, inr val_1, f => f }.map
        g
[PROOFSTEP]
cases g
[GOAL]
case inr.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✝¹ val✝ : E
f : inr val✝² ⟶ inr val✝¹
g : inr val✝¹ ⟶ inr val✝
⊢ {
          obj := fun X =>
            match X with
            | inl (inl X) => inl X
            | inl (inr X) => inr (inl X)
            | inr X => inr (inr X),
          map := fun {X Y} f =>
            match X, Y, f with
            | inl (inl val), inl (inl val_1), f => f
            | inl (inr val), inl (inr val_1), f => f
            | inr val, inr val_1, f => f }.map
      (f ≫ g) =
    {
            obj := fun X =>
              match X with
              | inl (inl X) => inl X
              | inl (inr X) => inr (inl X)
              | inr X => inr (inr X),
            map := fun {X Y} f =>
              match X, Y, f with
              | inl (inl val), inl (inl val_1), f => f
              | inl (inr val), inl (inr val_1), f => f
              | inr val, inr val_1, f => f }.map
        f ≫
      {
            obj := fun X =>
              match X with
              | inl (inl X) => inl X
              | inl (inr X) => inr (inl X)
              | inr X => inr (inr X),
            map := fun {X Y} f =>
              match X, Y, f with
              | inl (inl val), inl (inl val_1), f => f
              | inl (inr val), inl (inr val_1), f => f
              | inr val, inr val_1, f => f }.map
        g
[PROOFSTEP]
first
| cases f
| cases g
| aesop_cat
[GOAL]
case inr.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✝¹ val✝ : E
f : inr val✝² ⟶ inr val✝¹
g : inr val✝¹ ⟶ inr val✝
⊢ {
          obj := fun X =>
            match X with
            | inl (inl X) => inl X
            | inl (inr X) => inr (inl X)
            | inr X => inr (inr X),
          map := fun {X Y} f =>
            match X, Y, f with
            | inl (inl val), inl (inl val_1), f => f
            | inl (inr val), inl (inr val_1), f => f
            | inr val, inr val_1, f => f }.map
      (f ≫ g) =
    {
            obj := fun X =>
              match X with
              | inl (inl X) => inl X
              | inl (inr X) => inr (inl X)
              | inr X => inr (inr X),
            map := fun {X Y} f =>
              match X, Y, f with
              | inl (inl val), inl (inl val_1), f => f
              | inl (inr val), inl (inr val_1), f => f
              | inr val, inr val_1, f => f }.map
        f ≫
      {
            obj := fun X =>
              match X with
              | inl (inl X) => inl X
              | inl (inr X) => inr (inl X)
              | inr X => inr (inr X),
            map := fun {X Y} f =>
              match X, Y, f with
              | inl (inl val), inl (inl val_1), f => f
              | inl (inr val), inl (inr val_1), f => f
              | inr val, inr val_1, f => f }.map
        g
[PROOFSTEP]
cases f
[GOAL]
case inr.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✝¹ val✝ : E
f : inr val✝² ⟶ inr val✝¹
g : inr val✝¹ ⟶ inr val✝
⊢ {
          obj := fun X =>
            match X with
            | inl (inl X) => inl X
            | inl (inr X) => inr (inl X)
            | inr X => inr (inr X),
          map := fun {X Y} f =>
            match X, Y, f with
            | inl (inl val), inl (inl val_1), f => f
            | inl (inr val), inl (inr val_1), f => f
            | inr val, inr val_1, f => f }.map
      (f ≫ g) =
    {
            obj := fun X =>
              match X with
              | inl (inl X) => inl X
              | inl (inr X) => inr (inl X)
              | inr X => inr (inr X),
            map := fun {X Y} f =>
              match X, Y, f with
              | inl (inl val), inl (inl val_1), f => f
              | inl (inr val), inl (inr val_1), f => f
              | inr val, inr val_1, f => f }.map
        f ≫
      {
            obj := fun X =>
              match X with
              | inl (inl X) => inl X
              | inl (inr X) => inr (inl X)
              | inr X => inr (inr X),
            map := fun {X Y} f =>
              match X, Y, f with
              | inl (inl val), inl (inl val_1), f => f
              | inl (inr val), inl (inr val_1), f => f
              | inr val, inr val_1, f => f }.map
        g
[PROOFSTEP]
cases g
[GOAL]
case inr.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✝¹ val✝ : E
f : inr val✝² ⟶ inr val✝¹
g : inr val✝¹ ⟶ inr val✝
⊢ {
          obj := fun X =>
            match X with
            | inl (inl X) => inl X
            | inl (inr X) => inr (inl X)
            | inr X => inr (inr X),
          map := fun {X Y} f =>
            match X, Y, f with
            | inl (inl val), inl (inl val_1), f => f
            | inl (inr val), inl (inr val_1), f => f
            | inr val, inr val_1, f => f }.map
      (f ≫ g) =
    {
            obj := fun X =>
              match X with
              | inl (inl X) => inl X
              | inl (inr X) => inr (inl X)
              | inr X => inr (inr X),
            map := fun {X Y} f =>
              match X, Y, f with
              | inl (inl val), inl (inl val_1), f => f
              | inl (inr val), inl (inr val_1), f => f
              | inr val, inr val_1, f => f }.map
        f ≫
      {
            obj := fun X =>
              match X with
              | inl (inl X) => inl X
              | inl (inr X) => inr (inl X)
              | inr X => inr (inr X),
            map := fun {X Y} f =>
              match X, Y, f with
              | inl (inl val), inl (inl val_1), f => f
              | inl (inr val), inl (inr val_1), f => f
              | inr val, inr val_1, f => f }.map
        g
[PROOFSTEP]
aesop_cat
[GOAL]
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),
    {
            obj := fun X =>
              match X with
              | inl X => inl (inl X)
              | inr (inl X) => inl (inr X)
              | inr (inr X) => inr X,
            map := fun {X Y} f =>
              match X, Y, f with
              | inl val, inl val_1, f => f
              | inr (inl val), inr (inl val_1), f => f
              | inr (inr val), inr (inr val_1), f => f }.map
        (𝟙 X) =
      𝟙
        ({
              obj := fun X =>
                match X with
                | inl X => inl (inl X)
                | inr (inl X) => inl (inr X)
                | inr (inr X) => inr X,
              map := fun {X Y} f =>
                match X, Y, f with
                | inl val, inl val_1, f => f
                | inr (inl val), inr (inl val_1), f => f
                | inr (inr val), inr (inr val_1), f => f }.obj
          X)
[PROOFSTEP]
rintro (_ | (_ | _))
[GOAL]
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
⊢ {
          obj := fun X =>
            match X with
            | inl X => inl (inl X)
            | inr (inl X) => inl (inr X)
            | inr (inr X) => inr X,
          map := fun {X Y} f =>
            match X, Y, f with
            | inl val, inl val_1, f => f
            | inr (inl val), inr (inl val_1), f => f
            | inr (inr val), inr (inr val_1), f => f }.map
      (𝟙 (inl val✝)) =
    𝟙
      ({
            obj := fun X =>
              match X with
              | inl X => inl (inl X)
              | inr (inl X) => inl (inr X)
              | inr (inr X) => inr X,
            map := fun {X Y} f =>
              match X, Y, f with
              | inl val, inl val_1, f => f
              | inr (inl val), inr (inl val_1), f => f
              | inr (inr val), inr (inr val_1), f => f }.obj
        (inl val✝))
[PROOFSTEP]
rfl
[GOAL]
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
⊢ {
          obj := fun X =>
            match X with
            | inl X => inl (inl X)
            | inr (inl X) => inl (inr X)
            | inr (inr X) => inr X,
          map := fun {X Y} f =>
            match X, Y, f with
            | inl val, inl val_1, f => f
            | inr (inl val), inr (inl val_1), f => f
            | inr (inr val), inr (inr val_1), f => f }.map
      (𝟙 (inr (inl val✝))) =
    𝟙
      ({
            obj := fun X =>
              match X with
              | inl X => inl (inl X)
              | inr (inl X) => inl (inr X)
              | inr (inr X) => inr X,
            map := fun {X Y} f =>
              match X, Y, f with
              | inl val, inl val_1, f => f
              | inr (inl val), inr (inl val_1), f => f
              | inr (inr val), inr (inr val_1), f => f }.obj
        (inr (inl val✝)))
[PROOFSTEP]
rfl
[GOAL]
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
⊢ {
          obj := fun X =>
            match X with
            | inl X => inl (inl X)
            | inr (inl X) => inl (inr X)
            | inr (inr X) => inr X,
          map := fun {X Y} f =>
            match X, Y, f with
            | inl val, inl val_1, f => f
            | inr (inl val), inr (inl val_1), f => f
            | inr (inr val), inr (inr val_1), f => f }.map
      (𝟙 (inr (inr val✝))) =
    𝟙
      ({
            obj := fun X =>
              match X with
              | inl X => inl (inl X)
              | inr (inl X) => inl (inr X)
              | inr (inr X) => inr X,
            map := fun {X Y} f =>
              match X, Y, f with
              | inl val, inl val_1, f => f
              | inr (inl val), inr (inl val_1), f => f
              | inr (inr val), inr (inr val_1), f => f }.obj
        (inr (inr val✝)))
[PROOFSTEP]
rfl
[GOAL]
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 Z : C ⊕ D ⊕ E} (f : X ⟶ Y) (g : Y ⟶ Z),
    {
            obj := fun X =>
              match X with
              | inl X => inl (inl X)
              | inr (inl X) => inl (inr X)
              | inr (inr X) => inr X,
            map := fun {X Y} f =>
              match X, Y, f with
              | inl val, inl val_1, f => f
              | inr (inl val), inr (inl val_1), f => f
              | inr (inr val), inr (inr val_1), f => f }.map
        (f ≫ g) =
      {
              obj := fun X =>
                match X with
                | inl X => inl (inl X)
                | inr (inl X) => inl (inr X)
                | inr (inr X) => inr X,
              map := fun {X Y} f =>
                match X, Y, f with
                | inl val, inl val_1, f => f
                | inr (inl val), inr (inl val_1), f => f
                | inr (inr val), inr (inr val_1), f => f }.map
          f ≫
        {
              obj := fun X =>
                match X with
                | inl X => inl (inl X)
                | inr (inl X) => inl (inr X)
                | inr (inr X) => inr X,
              map := fun {X Y} f =>
                match X, Y, f with
                | inl val, inl val_1, f => f
                | inr (inl val), inr (inl val_1), f => f
                | inr (inr val), inr (inr val_1), f => f }.map
          g
[PROOFSTEP]
rintro (_ | (_ | _)) (_ | (_ | _)) (_ | (_ | _)) f g
[GOAL]
case inl.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✝¹ val✝ : C
f : inl val✝² ⟶ inl val✝¹
g : inl val✝¹ ⟶ inl val✝
⊢ {
          obj := fun X =>
            match X with
            | inl X => inl (inl X)
            | inr (inl X) => inl (inr X)
            | inr (inr X) => inr X,
          map := fun {X Y} f =>
            match X, Y, f with
            | inl val, inl val_1, f => f
            | inr (inl val), inr (inl val_1), f => f
            | inr (inr val), inr (inr val_1), f => f }.map
      (f ≫ g) =
    {
            obj := fun X =>
              match X with
              | inl X => inl (inl X)
              | inr (inl X) => inl (inr X)
              | inr (inr X) => inr X,
            map := fun {X Y} f =>
              match X, Y, f with
              | inl val, inl val_1, f => f
              | inr (inl val), inr (inl val_1), f => f
              | inr (inr val), inr (inr val_1), f => f }.map
        f ≫
      {
            obj := fun X =>
              match X with
              | inl X => inl (inl X)
              | inr (inl X) => inl (inr X)
              | inr (inr X) => inr X,
            map := fun {X Y} f =>
              match X, Y, f with
              | inl val, inl val_1, f => f
              | inr (inl val), inr (inl val_1), f => f
              | inr (inr val), inr (inr val_1), f => f }.map
        g
[PROOFSTEP]
first
| cases f
| cases g
| aesop_cat
[GOAL]
case inl.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✝¹ val✝ : C
f : inl val✝² ⟶ inl val✝¹
g : inl val✝¹ ⟶ inl val✝
⊢ {
          obj := fun X =>
            match X with
            | inl X => inl (inl X)
            | inr (inl X) => inl (inr X)
            | inr (inr X) => inr X,
          map := fun {X Y} f =>
            match X, Y, f with
            | inl val, inl val_1, f => f
            | inr (inl val), inr (inl val_1), f => f
            | inr (inr val), inr (inr val_1), f => f }.map
      (f ≫ g) =
    {
            obj := fun X =>
              match X with
              | inl X => inl (inl X)
              | inr (inl X) => inl (inr X)
              | inr (inr X) => inr X,
            map := fun {X Y} f =>
              match X, Y, f with
              | inl val, inl val_1, f => f
              | inr (inl val), inr (inl val_1), f => f
              | inr (inr val), inr (inr val_1), f => f }.map
        f ≫
      {
            obj := fun X =>
              match X with
              | inl X => inl (inl X)
              | inr (inl X) => inl (inr X)
              | inr (inr X) => inr X,
            map := fun {X Y} f =>
              match X, Y, f with
              | inl val, inl val_1, f => f
              | inr (inl val), inr (inl val_1), f => f
              | inr (inr val), inr (inr val_1), f => f }.map
        g
[PROOFSTEP]
cases f
[GOAL]
case inl.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✝¹ val✝ : C
f : inl val✝² ⟶ inl val✝¹
g : inl val✝¹ ⟶ inl val✝
⊢ {
          obj := fun X =>
            match X with
            | inl X => inl (inl X)
            | inr (inl X) => inl (inr X)
            | inr (inr X) => inr X,
          map := fun {X Y} f =>
            match X, Y, f with
            | inl val, inl val_1, f => f
            | inr (inl val), inr (inl val_1), f => f
            | inr (inr val), inr (inr val_1), f => f }.map
      (f ≫ g) =
    {
            obj := fun X =>
              match X with
              | inl X => inl (inl X)
              | inr (inl X) => inl (inr X)
              | inr (inr X) => inr X,
            map := fun {X Y} f =>
              match X, Y, f with
              | inl val, inl val_1, f => f
              | inr (inl val), inr (inl val_1), f => f
              | inr (inr val), inr (inr val_1), f => f }.map
        f ≫
      {
            obj := fun X =>
              match X with
              | inl X => inl (inl X)
              | inr (inl X) => inl (inr X)
              | inr (inr X) => inr X,
            map := fun {X Y} f =>
              match X, Y, f with
              | inl val, inl val_1, f => f
              | inr (inl val), inr (inl val_1), f => f
              | inr (inr val), inr (inr val_1), f => f }.map
        g
[PROOFSTEP]
cases g
[GOAL]
case inl.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✝¹ val✝ : C
f : inl val✝² ⟶ inl val✝¹
g : inl val✝¹ ⟶ inl val✝
⊢ {
          obj := fun X =>
            match X with
            | inl X => inl (inl X)
            | inr (inl X) => inl (inr X)
            | inr (inr X) => inr X,
          map := fun {X Y} f =>
            match X, Y, f with
            | inl val, inl val_1, f => f
            | inr (inl val), inr (inl val_1), f => f
            | inr (inr val), inr (inr val_1), f => f }.map
      (f ≫ g) =
    {
            obj := fun X =>
              match X with
              | inl X => inl (inl X)
              | inr (inl X) => inl (inr X)
              | inr (inr X) => inr X,
            map := fun {X Y} f =>
              match X, Y, f with
              | inl val, inl val_1, f => f
              | inr (inl val), inr (inl val_1), f => f
              | inr (inr val), inr (inr val_1), f => f }.map
        f ≫
      {
            obj := fun X =>
              match X with
              | inl X => inl (inl X)
              | inr (inl X) => inl (inr X)
              | inr (inr X) => inr X,
            map := fun {X Y} f =>
              match X, Y, f with
              | inl val, inl val_1, f => f
              | inr (inl val), inr (inl val_1), f => f
              | inr (inr val), inr (inr val_1), f => f }.map
        g
[PROOFSTEP]
aesop_cat
[GOAL]
case inl.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✝¹ : C
val✝ : D
f : inl val✝² ⟶ inl val✝¹
g : inl val✝¹ ⟶ inr (inl val✝)
⊢ {
          obj := fun X =>
            match X with
            | inl X => inl (inl X)
            | inr (inl X) => inl (inr X)
            | inr (inr X) => inr X,
          map := fun {X Y} f =>
            match X, Y, f with
            | inl val, inl val_1, f => f
            | inr (inl val), inr (inl val_1), f => f
            | inr (inr val), inr (inr val_1), f => f }.map
      (f ≫ g) =
    {
            obj := fun X =>
              match X with
              | inl X => inl (inl X)
              | inr (inl X) => inl (inr X)
              | inr (inr X) => inr X,
            map := fun {X Y} f =>
              match X, Y, f with
              | inl val, inl val_1, f => f
              | inr (inl val), inr (inl val_1), f => f
              | inr (inr val), inr (inr val_1), f => f }.map
        f ≫
      {
            obj := fun X =>
              match X with
              | inl X => inl (inl X)
              | inr (inl X) => inl (inr X)
              | inr (inr X) => inr X,
            map := fun {X Y} f =>
              match X, Y, f with
              | inl val, inl val_1, f => f
              | inr (inl val), inr (inl val_1), f => f
              | inr (inr val), inr (inr val_1), f => f }.map
        g
[PROOFSTEP]
first
| cases f
| cases g
| aesop_cat
[GOAL]
case inl.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✝¹ : C
val✝ : D
f : inl val✝² ⟶ inl val✝¹
g : inl val✝¹ ⟶ inr (inl val✝)
⊢ {
          obj := fun X =>
            match X with
            | inl X => inl (inl X)
            | inr (inl X) => inl (inr X)
            | inr (inr X) => inr X,
          map := fun {X Y} f =>
            match X, Y, f with
            | inl val, inl val_1, f => f
            | inr (inl val), inr (inl val_1), f => f
            | inr (inr val), inr (inr val_1), f => f }.map
      (f ≫ g) =
    {
            obj := fun X =>
              match X with
              | inl X => inl (inl X)
              | inr (inl X) => inl (inr X)
              | inr (inr X) => inr X,
            map := fun {X Y} f =>
              match X, Y, f with
              | inl val, inl val_1, f => f
              | inr (inl val), inr (inl val_1), f => f
              | inr (inr val), inr (inr val_1), f => f }.map
        f ≫
      {
            obj := fun X =>
              match X with
              | inl X => inl (inl X)
              | inr (inl X) => inl (inr X)
              | inr (inr X) => inr X,
            map := fun {X Y} f =>
              match X, Y, f with
              | inl val, inl val_1, f => f
              | inr (inl val), inr (inl val_1), f => f
              | inr (inr val), inr (inr val_1), f => f }.map
        g
[PROOFSTEP]
cases f
[GOAL]
case inl.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✝¹ : C
val✝ : D
f : inl val✝² ⟶ inl val✝¹
g : inl val✝¹ ⟶ inr (inl val✝)
⊢ {
          obj := fun X =>
            match X with
            | inl X => inl (inl X)
            | inr (inl X) => inl (inr X)
            | inr (inr X) => inr X,
          map := fun {X Y} f =>
            match X, Y, f with
            | inl val, inl val_1, f => f
            | inr (inl val), inr (inl val_1), f => f
            | inr (inr val), inr (inr val_1), f => f }.map
      (f ≫ g) =
    {
            obj := fun X =>
              match X with
              | inl X => inl (inl X)
              | inr (inl X) => inl (inr X)
              | inr (inr X) => inr X,
            map := fun {X Y} f =>
              match X, Y, f with
              | inl val, inl val_1, f => f
              | inr (inl val), inr (inl val_1), f => f
              | inr (inr val), inr (inr val_1), f => f }.map
        f ≫
      {
            obj := fun X =>
              match X with
              | inl X => inl (inl X)
              | inr (inl X) => inl (inr X)
              | inr (inr X) => inr X,
            map := fun {X Y} f =>
              match X, Y, f with
              | inl val, inl val_1, f => f
              | inr (inl val), inr (inl val_1), f => f
              | inr (inr val), inr (inr val_1), f => f }.map
        g
[PROOFSTEP]
cases g
[GOAL]
case inl.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✝² val✝¹ : C
val✝ : E
f : inl val✝² ⟶ inl val✝¹
g : inl val✝¹ ⟶ inr (inr val✝)
⊢ {
          obj := fun X =>
            match X with
            | inl X => inl (inl X)
            | inr (inl X) => inl (inr X)
            | inr (inr X) => inr X,
          map := fun {X Y} f =>
            match X, Y, f with
            | inl val, inl val_1, f => f
            | inr (inl val), inr (inl val_1), f => f
            | inr (inr val), inr (inr val_1), f => f }.map
      (f ≫ g) =
    {
            obj := fun X =>
              match X with
              | inl X => inl (inl X)
              | inr (inl X) => inl (inr X)
              | inr (inr X) => inr X,
            map := fun {X Y} f =>
              match X, Y, f with
              | inl val, inl val_1, f => f
              | inr (inl val), inr (inl val_1), f => f
              | inr (inr val), inr (inr val_1), f => f }.map
        f ≫
      {
            obj := fun X =>
              match X with
              | inl X => inl (inl X)
              | inr (inl X) => inl (inr X)
              | inr (inr X) => inr X,
            map := fun {X Y} f =>
              match X, Y, f with
              | inl val, inl val_1, f => f
              | inr (inl val), inr (inl val_1), f => f
              | inr (inr val), inr (inr val_1), f => f }.map
        g
[PROOFSTEP]
first
| cases f
| cases g
| aesop_cat
[GOAL]
case inl.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✝² val✝¹ : C
val✝ : E
f : inl val✝² ⟶ inl val✝¹
g : inl val✝¹ ⟶ inr (inr val✝)
⊢ {
          obj := fun X =>
            match X with
            | inl X => inl (inl X)
            | inr (inl X) => inl (inr X)
            | inr (inr X) => inr X,
          map := fun {X Y} f =>
            match X, Y, f with
            | inl val, inl val_1, f => f
            | inr (inl val), inr (inl val_1), f => f
            | inr (inr val), inr (inr val_1), f => f }.map
      (f ≫ g) =
    {
            obj := fun X =>
              match X with
              | inl X => inl (inl X)
              | inr (inl X) => inl (inr X)
              | inr (inr X) => inr X,
            map := fun {X Y} f =>
              match X, Y, f with
              | inl val, inl val_1, f => f
              | inr (inl val), inr (inl val_1), f => f
              | inr (inr val), inr (inr val_1), f => f }.map
        f ≫
      {
            obj := fun X =>
              match X with
              | inl X => inl (inl X)
              | inr (inl X) => inl (inr X)
              | inr (inr X) => inr X,
            map := fun {X Y} f =>
              match X, Y, f with
              | inl val, inl val_1, f => f
              | inr (inl val), inr (inl val_1), f => f
              | inr (inr val), inr (inr val_1), f => f }.map
        g
[PROOFSTEP]
cases f
[GOAL]
case inl.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✝² val✝¹ : C
val✝ : E
f : inl val✝² ⟶ inl val✝¹
g : inl val✝¹ ⟶ inr (inr val✝)
⊢ {
          obj := fun X =>
            match X with
            | inl X => inl (inl X)
            | inr (inl X) => inl (inr X)
            | inr (inr X) => inr X,
          map := fun {X Y} f =>
            match X, Y, f with
            | inl val, inl val_1, f => f
            | inr (inl val), inr (inl val_1), f => f
            | inr (inr val), inr (inr val_1), f => f }.map
      (f ≫ g) =
    {
            obj := fun X =>
              match X with
              | inl X => inl (inl X)
              | inr (inl X) => inl (inr X)
              | inr (inr X) => inr X,
            map := fun {X Y} f =>
              match X, Y, f with
              | inl val, inl val_1, f => f
              | inr (inl val), inr (inl val_1), f => f
              | inr (inr val), inr (inr val_1), f => f }.map
        f ≫
      {
            obj := fun X =>
              match X with
              | inl X => inl (inl X)
              | inr (inl X) => inl (inr X)
              | inr (inr X) => inr X,
            map := fun {X Y} f =>
              match X, Y, f with
              | inl val, inl val_1, f => f
              | inr (inl val), inr (inl val_1), f => f
              | inr (inr val), inr (inr val_1), f => f }.map
        g
[PROOFSTEP]
cases g
[GOAL]
case inl.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✝² : C
val✝¹ : D
val✝ : C
f : inl val✝² ⟶ inr (inl val✝¹)
g : inr (inl val✝¹) ⟶ inl val✝
⊢ {
          obj := fun X =>
            match X with
            | inl X => inl (inl X)
            | inr (inl X) => inl (inr X)
            | inr (inr X) => inr X,
          map := fun {X Y} f =>
            match X, Y, f with
            | inl val, inl val_1, f => f
            | inr (inl val), inr (inl val_1), f => f
            | inr (inr val), inr (inr val_1), f => f }.map
      (f ≫ g) =
    {
            obj := fun X =>
              match X with
              | inl X => inl (inl X)
              | inr (inl X) => inl (inr X)
              | inr (inr X) => inr X,
            map := fun {X Y} f =>
              match X, Y, f with
              | inl val, inl val_1, f => f
              | inr (inl val), inr (inl val_1), f => f
              | inr (inr val), inr (inr val_1), f => f }.map
        f ≫
      {
            obj := fun X =>
              match X with
              | inl X => inl (inl X)
              | inr (inl X) => inl (inr X)
              | inr (inr X) => inr X,
            map := fun {X Y} f =>
              match X, Y, f with
              | inl val, inl val_1, f => f
              | inr (inl val), inr (inl val_1), f => f
              | inr (inr val), inr (inr val_1), f => f }.map
        g
[PROOFSTEP]
first
| cases f
| cases g
| aesop_cat
[GOAL]
case inl.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✝² : C
val✝¹ : D
val✝ : C
f : inl val✝² ⟶ inr (inl val✝¹)
g : inr (inl val✝¹) ⟶ inl val✝
⊢ {
          obj := fun X =>
            match X with
            | inl X => inl (inl X)
            | inr (inl X) => inl (inr X)
            | inr (inr X) => inr X,
          map := fun {X Y} f =>
            match X, Y, f with
            | inl val, inl val_1, f => f
            | inr (inl val), inr (inl val_1), f => f
            | inr (inr val), inr (inr val_1), f => f }.map
      (f ≫ g) =
    {
            obj := fun X =>
              match X with
              | inl X => inl (inl X)
              | inr (inl X) => inl (inr X)
              | inr (inr X) => inr X,
            map := fun {X Y} f =>
              match X, Y, f with
              | inl val, inl val_1, f => f
              | inr (inl val), inr (inl val_1), f => f
              | inr (inr val), inr (inr val_1), f => f }.map
        f ≫
      {
            obj := fun X =>
              match X with
              | inl X => inl (inl X)
              | inr (inl X) => inl (inr X)
              | inr (inr X) => inr X,
            map := fun {X Y} f =>
              match X, Y, f with
              | inl val, inl val_1, f => f
              | inr (inl val), inr (inl val_1), f => f
              | inr (inr val), inr (inr val_1), f => f }.map
        g
[PROOFSTEP]
cases f
[GOAL]
case inl.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✝² : C
val✝¹ val✝ : D
f : inl val✝² ⟶ inr (inl val✝¹)
g : inr (inl val✝¹) ⟶ inr (inl val✝)
⊢ {
          obj := fun X =>
            match X with
            | inl X => inl (inl X)
            | inr (inl X) => inl (inr X)
            | inr (inr X) => inr X,
          map := fun {X Y} f =>
            match X, Y, f with
            | inl val, inl val_1, f => f
            | inr (inl val), inr (inl val_1), f => f
            | inr (inr val), inr (inr val_1), f => f }.map
      (f ≫ g) =
    {
            obj := fun X =>
              match X with
              | inl X => inl (inl X)
              | inr (inl X) => inl (inr X)
              | inr (inr X) => inr X,
            map := fun {X Y} f =>
              match X, Y, f with
              | inl val, inl val_1, f => f
              | inr (inl val), inr (inl val_1), f => f
              | inr (inr val), inr (inr val_1), f => f }.map
        f ≫
      {
            obj := fun X =>
              match X with
              | inl X => inl (inl X)
              | inr (inl X) => inl (inr X)
              | inr (inr X) => inr X,
            map := fun {X Y} f =>
              match X, Y, f with
              | inl val, inl val_1, f => f
              | inr (inl val), inr (inl val_1), f => f
              | inr (inr val), inr (inr val_1), f => f }.map
        g
[PROOFSTEP]
first
| cases f
| cases g
| aesop_cat
[GOAL]
case inl.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✝² : C
val✝¹ val✝ : D
f : inl val✝² ⟶ inr (inl val✝¹)
g : inr (inl val✝¹) ⟶ inr (inl val✝)
⊢ {
          obj := fun X =>
            match X with
            | inl X => inl (inl X)
            | inr (inl X) => inl (inr X)
            | inr (inr X) => inr X,
          map := fun {X Y} f =>
            match X, Y, f with
            | inl val, inl val_1, f => f
            | inr (inl val), inr (inl val_1), f => f
            | inr (inr val), inr (inr val_1), f => f }.map
      (f ≫ g) =
    {
            obj := fun X =>
              match X with
              | inl X => inl (inl X)
              | inr (inl X) => inl (inr X)
              | inr (inr X) => inr X,
            map := fun {X Y} f =>
              match X, Y, f with
              | inl val, inl val_1, f => f
              | inr (inl val), inr (inl val_1), f => f
              | inr (inr val), inr (inr val_1), f => f }.map
        f ≫
      {
            obj := fun X =>
              match X with
              | inl X => inl (inl X)
              | inr (inl X) => inl (inr X)
              | inr (inr X) => inr X,
            map := fun {X Y} f =>
              match X, Y, f with
              | inl val, inl val_1, f => f
              | inr (inl val), inr (inl val_1), f => f
              | inr (inr val), inr (inr val_1), f => f }.map
        g
[PROOFSTEP]
cases f
[GOAL]
case inl.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✝² : C
val✝¹ : D
val✝ : E
f : inl val✝² ⟶ inr (inl val✝¹)
g : inr (inl val✝¹) ⟶ inr (inr val✝)
⊢ {
          obj := fun X =>
            match X with
            | inl X => inl (inl X)
            | inr (inl X) => inl (inr X)
            | inr (inr X) => inr X,
          map := fun {X Y} f =>
            match X, Y, f with
            | inl val, inl val_1, f => f
            | inr (inl val), inr (inl val_1), f => f
            | inr (inr val), inr (inr val_1), f => f }.map
      (f ≫ g) =
    {
            obj := fun X =>
              match X with
              | inl X => inl (inl X)
              | inr (inl X) => inl (inr X)
              | inr (inr X) => inr X,
            map := fun {X Y} f =>
              match X, Y, f with
              | inl val, inl val_1, f => f
              | inr (inl val), inr (inl val_1), f => f
              | inr (inr val), inr (inr val_1), f => f }.map
        f ≫
      {
            obj := fun X =>
              match X with
              | inl X => inl (inl X)
              | inr (inl X) => inl (inr X)
              | inr (inr X) => inr X,
            map := fun {X Y} f =>
              match X, Y, f with
              | inl val, inl val_1, f => f
              | inr (inl val), inr (inl val_1), f => f
              | inr (inr val), inr (inr val_1), f => f }.map
        g
[PROOFSTEP]
first
| cases f
| cases g
| aesop_cat
[GOAL]
case inl.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✝² : C
val✝¹ : D
val✝ : E
f : inl val✝² ⟶ inr (inl val✝¹)
g : inr (inl val✝¹) ⟶ inr (inr val✝)
⊢ {
          obj := fun X =>
            match X with
            | inl X => inl (inl X)
            | inr (inl X) => inl (inr X)
            | inr (inr X) => inr X,
          map := fun {X Y} f =>
            match X, Y, f with
            | inl val, inl val_1, f => f
            | inr (inl val), inr (inl val_1), f => f
            | inr (inr val), inr (inr val_1), f => f }.map
      (f ≫ g) =
    {
            obj := fun X =>
              match X with
              | inl X => inl (inl X)
              | inr (inl X) => inl (inr X)
              | inr (inr X) => inr X,
            map := fun {X Y} f =>
              match X, Y, f with
              | inl val, inl val_1, f => f
              | inr (inl val), inr (inl val_1), f => f
              | inr (inr val), inr (inr val_1), f => f }.map
        f ≫
      {
            obj := fun X =>
              match X with
              | inl X => inl (inl X)
              | inr (inl X) => inl (inr X)
              | inr (inr X) => inr X,
            map := fun {X Y} f =>
              match X, Y, f with
              | inl val, inl val_1, f => f
              | inr (inl val), inr (inl val_1), f => f
              | inr (inr val), inr (inr val_1), f => f }.map
        g
[PROOFSTEP]
cases f
[GOAL]
case inl.inr.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✝¹ : E
val✝ : C
f : inl val✝² ⟶ inr (inr val✝¹)
g : inr (inr val✝¹) ⟶ inl val✝
⊢ {
          obj := fun X =>
            match X with
            | inl X => inl (inl X)
            | inr (inl X) => inl (inr X)
            | inr (inr X) => inr X,
          map := fun {X Y} f =>
            match X, Y, f with
            | inl val, inl val_1, f => f
            | inr (inl val), inr (inl val_1), f => f
            | inr (inr val), inr (inr val_1), f => f }.map
      (f ≫ g) =
    {
            obj := fun X =>
              match X with
              | inl X => inl (inl X)
              | inr (inl X) => inl (inr X)
              | inr (inr X) => inr X,
            map := fun {X Y} f =>
              match X, Y, f with
              | inl val, inl val_1, f => f
              | inr (inl val), inr (inl val_1), f => f
              | inr (inr val), inr (inr val_1), f => f }.map
        f ≫
      {
            obj := fun X =>
              match X with
              | inl X => inl (inl X)
              | inr (inl X) => inl (inr X)
              | inr (inr X) => inr X,
            map := fun {X Y} f =>
              match X, Y, f with
              | inl val, inl val_1, f => f
              | inr (inl val), inr (inl val_1), f => f
              | inr (inr val), inr (inr val_1), f => f }.map
        g
[PROOFSTEP]
first
| cases f
| cases g
| aesop_cat
[GOAL]
case inl.inr.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✝¹ : E
val✝ : C
f : inl val✝² ⟶ inr (inr val✝¹)
g : inr (inr val✝¹) ⟶ inl val✝
⊢ {
          obj := fun X =>
            match X with
            | inl X => inl (inl X)
            | inr (inl X) => inl (inr X)
            | inr (inr X) => inr X,
          map := fun {X Y} f =>
            match X, Y, f with
            | inl val, inl val_1, f => f
            | inr (inl val), inr (inl val_1), f => f
            | inr (inr val), inr (inr val_1), f => f }.map
      (f ≫ g) =
    {
            obj := fun X =>
              match X with
              | inl X => inl (inl X)
              | inr (inl X) => inl (inr X)
              | inr (inr X) => inr X,
            map := fun {X Y} f =>
              match X, Y, f with
              | inl val, inl val_1, f => f
              | inr (inl val), inr (inl val_1), f => f
              | inr (inr val), inr (inr val_1), f => f }.map
        f ≫
      {
            obj := fun X =>
              match X with
              | inl X => inl (inl X)
              | inr (inl X) => inl (inr X)
              | inr (inr X) => inr X,
            map := fun {X Y} f =>
              match X, Y, f with
              | inl val, inl val_1, f => f
              | inr (inl val), inr (inl val_1), f => f
              | inr (inr val), inr (inr val_1), f => f }.map
        g
[PROOFSTEP]
cases f
[GOAL]
case inl.inr.inr.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✝¹ : E
val✝ : D
f : inl val✝² ⟶ inr (inr val✝¹)
g : inr (inr val✝¹) ⟶ inr (inl val✝)
⊢ {
          obj := fun X =>
            match X with
            | inl X => inl (inl X)
            | inr (inl X) => inl (inr X)
            | inr (inr X) => inr X,
          map := fun {X Y} f =>
            match X, Y, f with
            | inl val, inl val_1, f => f
            | inr (inl val), inr (inl val_1), f => f
            | inr (inr val), inr (inr val_1), f => f }.map
      (f ≫ g) =
    {
            obj := fun X =>
              match X with
              | inl X => inl (inl X)
              | inr (inl X) => inl (inr X)
              | inr (inr X) => inr X,
            map := fun {X Y} f =>
              match X, Y, f with
              | inl val, inl val_1, f => f
              | inr (inl val), inr (inl val_1), f => f
              | inr (inr val), inr (inr val_1), f => f }.map
        f ≫
      {
            obj := fun X =>
              match X with
              | inl X => inl (inl X)
              | inr (inl X) => inl (inr X)
              | inr (inr X) => inr X,
            map := fun {X Y} f =>
              match X, Y, f with
              | inl val, inl val_1, f => f
              | inr (inl val), inr (inl val_1), f => f
              | inr (inr val), inr (inr val_1), f => f }.map
        g
[PROOFSTEP]
first
| cases f
| cases g
| aesop_cat
[GOAL]
case inl.inr.inr.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✝¹ : E
val✝ : D
f : inl val✝² ⟶ inr (inr val✝¹)
g : inr (inr val✝¹) ⟶ inr (inl val✝)
⊢ {
          obj := fun X =>
            match X with
            | inl X => inl (inl X)
            | inr (inl X) => inl (inr X)
            | inr (inr X) => inr X,
          map := fun {X Y} f =>
            match X, Y, f with
            | inl val, inl val_1, f => f
            | inr (inl val), inr (inl val_1), f => f
            | inr (inr val), inr (inr val_1), f => f }.map
      (f ≫ g) =
    {
            obj := fun X =>
              match X with
              | inl X => inl (inl X)
              | inr (inl X) => inl (inr X)
              | inr (inr X) => inr X,
            map := fun {X Y} f =>
              match X, Y, f with
              | inl val, inl val_1, f => f
              | inr (inl val), inr (inl val_1), f => f
              | inr (inr val), inr (inr val_1), f => f }.map
        f ≫
      {
            obj := fun X =>
              match X with
              | inl X => inl (inl X)
              | inr (inl X) => inl (inr X)
              | inr (inr X) => inr X,
            map := fun {X Y} f =>
              match X, Y, f with
              | inl val, inl val_1, f => f
              | inr (inl val), inr (inl val_1), f => f
              | inr (inr val), inr (inr val_1), f => f }.map
        g
[PROOFSTEP]
cases f
[GOAL]
case inl.inr.inr.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✝¹ val✝ : E
f : inl val✝² ⟶ inr (inr val✝¹)
g : inr (inr val✝¹) ⟶ inr (inr val✝)
⊢ {
          obj := fun X =>
            match X with
            | inl X => inl (inl X)
            | inr (inl X) => inl (inr X)
            | inr (inr X) => inr X,
          map := fun {X Y} f =>
            match X, Y, f with
            | inl val, inl val_1, f => f
            | inr (inl val), inr (inl val_1), f => f
            | inr (inr val), inr (inr val_1), f => f }.map
      (f ≫ g) =
    {
            obj := fun X =>
              match X with
              | inl X => inl (inl X)
              | inr (inl X) => inl (inr X)
              | inr (inr X) => inr X,
            map := fun {X Y} f =>
              match X, Y, f with
              | inl val, inl val_1, f => f
              | inr (inl val), inr (inl val_1), f => f
              | inr (inr val), inr (inr val_1), f => f }.map
        f ≫
      {
            obj := fun X =>
              match X with
              | inl X => inl (inl X)
              | inr (inl X) => inl (inr X)
              | inr (inr X) => inr X,
            map := fun {X Y} f =>
              match X, Y, f with
              | inl val, inl val_1, f => f
              | inr (inl val), inr (inl val_1), f => f
              | inr (inr val), inr (inr val_1), f => f }.map
        g
[PROOFSTEP]
first
| cases f
| cases g
| aesop_cat
[GOAL]
case inl.inr.inr.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✝¹ val✝ : E
f : inl val✝² ⟶ inr (inr val✝¹)
g : inr (inr val✝¹) ⟶ inr (inr val✝)
⊢ {
          obj := fun X =>
            match X with
            | inl X => inl (inl X)
            | inr (inl X) => inl (inr X)
            | inr (inr X) => inr X,
          map := fun {X Y} f =>
            match X, Y, f with
            | inl val, inl val_1, f => f
            | inr (inl val), inr (inl val_1), f => f
            | inr (inr val), inr (inr val_1), f => f }.map
      (f ≫ g) =
    {
            obj := fun X =>
              match X with
              | inl X => inl (inl X)
              | inr (inl X) => inl (inr X)
              | inr (inr X) => inr X,
            map := fun {X Y} f =>
              match X, Y, f with
              | inl val, inl val_1, f => f
              | inr (inl val), inr (inl val_1), f => f
              | inr (inr val), inr (inr val_1), f => f }.map
        f ≫
      {
            obj := fun X =>
              match X with
              | inl X => inl (inl X)
              | inr (inl X) => inl (inr X)
              | inr (inr X) => inr X,
            map := fun {X Y} f =>
              match X, Y, f with
              | inl val, inl val_1, f => f
              | inr (inl val), inr (inl val_1), f => f
              | inr (inr val), inr (inr val_1), f => f }.map
        g
[PROOFSTEP]
cases f
[GOAL]
case inr.inl.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✝¹ val✝ : C
f : inr (inl val✝²) ⟶ inl val✝¹
g : inl val✝¹ ⟶ inl val✝
⊢ {
          obj := fun X =>
            match X with
            | inl X => inl (inl X)
            | inr (inl X) => inl (inr X)
            | inr (inr X) => inr X,
          map := fun {X Y} f =>
            match X, Y, f with
            | inl val, inl val_1, f => f
            | inr (inl val), inr (inl val_1), f => f
            | inr (inr val), inr (inr val_1), f => f }.map
      (f ≫ g) =
    {
            obj := fun X =>
              match X with
              | inl X => inl (inl X)
              | inr (inl X) => inl (inr X)
              | inr (inr X) => inr X,
            map := fun {X Y} f =>
              match X, Y, f with
              | inl val, inl val_1, f => f
              | inr (inl val), inr (inl val_1), f => f
              | inr (inr val), inr (inr val_1), f => f }.map
        f ≫
      {
            obj := fun X =>
              match X with
              | inl X => inl (inl X)
              | inr (inl X) => inl (inr X)
              | inr (inr X) => inr X,
            map := fun {X Y} f =>
              match X, Y, f with
              | inl val, inl val_1, f => f
              | inr (inl val), inr (inl val_1), f => f
              | inr (inr val), inr (inr val_1), f => f }.map
        g
[PROOFSTEP]
first
| cases f
| cases g
| aesop_cat
[GOAL]
case inr.inl.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✝¹ val✝ : C
f : inr (inl val✝²) ⟶ inl val✝¹
g : inl val✝¹ ⟶ inl val✝
⊢ {
          obj := fun X =>
            match X with
            | inl X => inl (inl X)
            | inr (inl X) => inl (inr X)
            | inr (inr X) => inr X,
          map := fun {X Y} f =>
            match X, Y, f with
            | inl val, inl val_1, f => f
            | inr (inl val), inr (inl val_1), f => f
            | inr (inr val), inr (inr val_1), f => f }.map
      (f ≫ g) =
    {
            obj := fun X =>
              match X with
              | inl X => inl (inl X)
              | inr (inl X) => inl (inr X)
              | inr (inr X) => inr X,
            map := fun {X Y} f =>
              match X, Y, f with
              | inl val, inl val_1, f => f
              | inr (inl val), inr (inl val_1), f => f
              | inr (inr val), inr (inr val_1), f => f }.map
        f ≫
      {
            obj := fun X =>
              match X with
              | inl X => inl (inl X)
              | inr (inl X) => inl (inr X)
              | inr (inr X) => inr X,
            map := fun {X Y} f =>
              match X, Y, f with
              | inl val, inl val_1, f => f
              | inr (inl val), inr (inl val_1), f => f
              | inr (inr val), inr (inr val_1), f => f }.map
        g
[PROOFSTEP]
cases f
[GOAL]
case inr.inl.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✝² : D
val✝¹ : C
val✝ : D
f : inr (inl val✝²) ⟶ inl val✝¹
g : inl val✝¹ ⟶ inr (inl val✝)
⊢ {
          obj := fun X =>
            match X with
            | inl X => inl (inl X)
            | inr (inl X) => inl (inr X)
            | inr (inr X) => inr X,
          map := fun {X Y} f =>
            match X, Y, f with
            | inl val, inl val_1, f => f
            | inr (inl val), inr (inl val_1), f => f
            | inr (inr val), inr (inr val_1), f => f }.map
      (f ≫ g) =
    {
            obj := fun X =>
              match X with
              | inl X => inl (inl X)
              | inr (inl X) => inl (inr X)
              | inr (inr X) => inr X,
            map := fun {X Y} f =>
              match X, Y, f with
              | inl val, inl val_1, f => f
              | inr (inl val), inr (inl val_1), f => f
              | inr (inr val), inr (inr val_1), f => f }.map
        f ≫
      {
            obj := fun X =>
              match X with
              | inl X => inl (inl X)
              | inr (inl X) => inl (inr X)
              | inr (inr X) => inr X,
            map := fun {X Y} f =>
              match X, Y, f with
              | inl val, inl val_1, f => f
              | inr (inl val), inr (inl val_1), f => f
              | inr (inr val), inr (inr val_1), f => f }.map
        g
[PROOFSTEP]
first
| cases f
| cases g
| aesop_cat
[GOAL]
case inr.inl.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✝² : D
val✝¹ : C
val✝ : D
f : inr (inl val✝²) ⟶ inl val✝¹
g : inl val✝¹ ⟶ inr (inl val✝)
⊢ {
          obj := fun X =>
            match X with
            | inl X => inl (inl X)
            | inr (inl X) => inl (inr X)
            | inr (inr X) => inr X,
          map := fun {X Y} f =>
            match X, Y, f with
            | inl val, inl val_1, f => f
            | inr (inl val), inr (inl val_1), f => f
            | inr (inr val), inr (inr val_1), f => f }.map
      (f ≫ g) =
    {
            obj := fun X =>
              match X with
              | inl X => inl (inl X)
              | inr (inl X) => inl (inr X)
              | inr (inr X) => inr X,
            map := fun {X Y} f =>
              match X, Y, f with
              | inl val, inl val_1, f => f
              | inr (inl val), inr (inl val_1), f => f
              | inr (inr val), inr (inr val_1), f => f }.map
        f ≫
      {
            obj := fun X =>
              match X with
              | inl X => inl (inl X)
              | inr (inl X) => inl (inr X)
              | inr (inr X) => inr X,
            map := fun {X Y} f =>
              match X, Y, f with
              | inl val, inl val_1, f => f
              | inr (inl val), inr (inl val_1), f => f
              | inr (inr val), inr (inr val_1), f => f }.map
        g
[PROOFSTEP]
cases f
[GOAL]
case inr.inl.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✝¹ : C
val✝ : E
f : inr (inl val✝²) ⟶ inl val✝¹
g : inl val✝¹ ⟶ inr (inr val✝)
⊢ {
          obj := fun X =>
            match X with
            | inl X => inl (inl X)
            | inr (inl X) => inl (inr X)
            | inr (inr X) => inr X,
          map := fun {X Y} f =>
            match X, Y, f with
            | inl val, inl val_1, f => f
            | inr (inl val), inr (inl val_1), f => f
            | inr (inr val), inr (inr val_1), f => f }.map
      (f ≫ g) =
    {
            obj := fun X =>
              match X with
              | inl X => inl (inl X)
              | inr (inl X) => inl (inr X)
              | inr (inr X) => inr X,
            map := fun {X Y} f =>
              match X, Y, f with
              | inl val, inl val_1, f => f
              | inr (inl val), inr (inl val_1), f => f
              | inr (inr val), inr (inr val_1), f => f }.map
        f ≫
      {
            obj := fun X =>
              match X with
              | inl X => inl (inl X)
              | inr (inl X) => inl (inr X)
              | inr (inr X) => inr X,
            map := fun {X Y} f =>
              match X, Y, f with
              | inl val, inl val_1, f => f
              | inr (inl val), inr (inl val_1), f => f
              | inr (inr val), inr (inr val_1), f => f }.map
        g
[PROOFSTEP]
first
| cases f
| cases g
| aesop_cat
[GOAL]
case inr.inl.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✝¹ : C
val✝ : E
f : inr (inl val✝²) ⟶ inl val✝¹
g : inl val✝¹ ⟶ inr (inr val✝)
⊢ {
          obj := fun X =>
            match X with
            | inl X => inl (inl X)
            | inr (inl X) => inl (inr X)
            | inr (inr X) => inr X,
          map := fun {X Y} f =>
            match X, Y, f with
            | inl val, inl val_1, f => f
            | inr (inl val), inr (inl val_1), f => f
            | inr (inr val), inr (inr val_1), f => f }.map
      (f ≫ g) =
    {
            obj := fun X =>
              match X with
              | inl X => inl (inl X)
              | inr (inl X) => inl (inr X)
              | inr (inr X) => inr X,
            map := fun {X Y} f =>
              match X, Y, f with
              | inl val, inl val_1, f => f
              | inr (inl val), inr (inl val_1), f => f
              | inr (inr val), inr (inr val_1), f => f }.map
        f ≫
      {
            obj := fun X =>
              match X with
              | inl X => inl (inl X)
              | inr (inl X) => inl (inr X)
              | inr (inr X) => inr X,
            map := fun {X Y} f =>
              match X, Y, f with
              | inl val, inl val_1, f => f
              | inr (inl val), inr (inl val_1), f => f
              | inr (inr val), inr (inr val_1), f => f }.map
        g
[PROOFSTEP]
cases f
[GOAL]
case inr.inl.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✝² val✝¹ : D
val✝ : C
f : inr (inl val✝²) ⟶ inr (inl val✝¹)
g : inr (inl val✝¹) ⟶ inl val✝
⊢ {
          obj := fun X =>
            match X with
            | inl X => inl (inl X)
            | inr (inl X) => inl (inr X)
            | inr (inr X) => inr X,
          map := fun {X Y} f =>
            match X, Y, f with
            | inl val, inl val_1, f => f
            | inr (inl val), inr (inl val_1), f => f
            | inr (inr val), inr (inr val_1), f => f }.map
      (f ≫ g) =
    {
            obj := fun X =>
              match X with
              | inl X => inl (inl X)
              | inr (inl X) => inl (inr X)
              | inr (inr X) => inr X,
            map := fun {X Y} f =>
              match X, Y, f with
              | inl val, inl val_1, f => f
              | inr (inl val), inr (inl val_1), f => f
              | inr (inr val), inr (inr val_1), f => f }.map
        f ≫
      {
            obj := fun X =>
              match X with
              | inl X => inl (inl X)
              | inr (inl X) => inl (inr X)
              | inr (inr X) => inr X,
            map := fun {X Y} f =>
              match X, Y, f with
              | inl val, inl val_1, f => f
              | inr (inl val), inr (inl val_1), f => f
              | inr (inr val), inr (inr val_1), f => f }.map
        g
[PROOFSTEP]
first
| cases f
| cases g
| aesop_cat
[GOAL]
case inr.inl.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✝² val✝¹ : D
val✝ : C
f : inr (inl val✝²) ⟶ inr (inl val✝¹)
g : inr (inl val✝¹) ⟶ inl val✝
⊢ {
          obj := fun X =>
            match X with
            | inl X => inl (inl X)
            | inr (inl X) => inl (inr X)
            | inr (inr X) => inr X,
          map := fun {X Y} f =>
            match X, Y, f with
            | inl val, inl val_1, f => f
            | inr (inl val), inr (inl val_1), f => f
            | inr (inr val), inr (inr val_1), f => f }.map
      (f ≫ g) =
    {
            obj := fun X =>
              match X with
              | inl X => inl (inl X)
              | inr (inl X) => inl (inr X)
              | inr (inr X) => inr X,
            map := fun {X Y} f =>
              match X, Y, f with
              | inl val, inl val_1, f => f
              | inr (inl val), inr (inl val_1), f => f
              | inr (inr val), inr (inr val_1), f => f }.map
        f ≫
      {
            obj := fun X =>
              match X with
              | inl X => inl (inl X)
              | inr (inl X) => inl (inr X)
              | inr (inr X) => inr X,
            map := fun {X Y} f =>
              match X, Y, f with
              | inl val, inl val_1, f => f
              | inr (inl val), inr (inl val_1), f => f
              | inr (inr val), inr (inr val_1), f => f }.map
        g
[PROOFSTEP]
cases f
[GOAL]
case inr.inl.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✝² val✝¹ : D
val✝ : C
f : inr (inl val✝²) ⟶ inr (inl val✝¹)
g : inr (inl val✝¹) ⟶ inl val✝
⊢ {
          obj := fun X =>
            match X with
            | inl X => inl (inl X)
            | inr (inl X) => inl (inr X)
            | inr (inr X) => inr X,
          map := fun {X Y} f =>
            match X, Y, f with
            | inl val, inl val_1, f => f
            | inr (inl val), inr (inl val_1), f => f
            | inr (inr val), inr (inr val_1), f => f }.map
      (f ≫ g) =
    {
            obj := fun X =>
              match X with
              | inl X => inl (inl X)
              | inr (inl X) => inl (inr X)
              | inr (inr X) => inr X,
            map := fun {X Y} f =>
              match X, Y, f with
              | inl val, inl val_1, f => f
              | inr (inl val), inr (inl val_1), f => f
              | inr (inr val), inr (inr val_1), f => f }.map
        f ≫
      {
            obj := fun X =>
              match X with
              | inl X => inl (inl X)
              | inr (inl X) => inl (inr X)
              | inr (inr X) => inr X,
            map := fun {X Y} f =>
              match X, Y, f with
              | inl val, inl val_1, f => f
              | inr (inl val), inr (inl val_1), f => f
              | inr (inr val), inr (inr val_1), f => f }.map
        g
[PROOFSTEP]
cases g
[GOAL]
case inr.inl.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✝¹ val✝ : D
f : inr (inl val✝²) ⟶ inr (inl val✝¹)
g : inr (inl val✝¹) ⟶ inr (inl val✝)
⊢ {
          obj := fun X =>
            match X with
            | inl X => inl (inl X)
            | inr (inl X) => inl (inr X)
            | inr (inr X) => inr X,
          map := fun {X Y} f =>
            match X, Y, f with
            | inl val, inl val_1, f => f
            | inr (inl val), inr (inl val_1), f => f
            | inr (inr val), inr (inr val_1), f => f }.map
      (f ≫ g) =
    {
            obj := fun X =>
              match X with
              | inl X => inl (inl X)
              | inr (inl X) => inl (inr X)
              | inr (inr X) => inr X,
            map := fun {X Y} f =>
              match X, Y, f with
              | inl val, inl val_1, f => f
              | inr (inl val), inr (inl val_1), f => f
              | inr (inr val), inr (inr val_1), f => f }.map
        f ≫
      {
            obj := fun X =>
              match X with
              | inl X => inl (inl X)
              | inr (inl X) => inl (inr X)
              | inr (inr X) => inr X,
            map := fun {X Y} f =>
              match X, Y, f with
              | inl val, inl val_1, f => f
              | inr (inl val), inr (inl val_1), f => f
              | inr (inr val), inr (inr val_1), f => f }.map
        g
[PROOFSTEP]
first
| cases f
| cases g
| aesop_cat
[GOAL]
case inr.inl.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✝¹ val✝ : D
f : inr (inl val✝²) ⟶ inr (inl val✝¹)
g : inr (inl val✝¹) ⟶ inr (inl val✝)
⊢ {
          obj := fun X =>
            match X with
            | inl X => inl (inl X)
            | inr (inl X) => inl (inr X)
            | inr (inr X) => inr X,
          map := fun {X Y} f =>
            match X, Y, f with
            | inl val, inl val_1, f => f
            | inr (inl val), inr (inl val_1), f => f
            | inr (inr val), inr (inr val_1), f => f }.map
      (f ≫ g) =
    {
            obj := fun X =>
              match X with
              | inl X => inl (inl X)
              | inr (inl X) => inl (inr X)
              | inr (inr X) => inr X,
            map := fun {X Y} f =>
              match X, Y, f with
              | inl val, inl val_1, f => f
              | inr (inl val), inr (inl val_1), f => f
              | inr (inr val), inr (inr val_1), f => f }.map
        f ≫
      {
            obj := fun X =>
              match X with
              | inl X => inl (inl X)
              | inr (inl X) => inl (inr X)
              | inr (inr X) => inr X,
            map := fun {X Y} f =>
              match X, Y, f with
              | inl val, inl val_1, f => f
              | inr (inl val), inr (inl val_1), f => f
              | inr (inr val), inr (inr val_1), f => f }.map
        g
[PROOFSTEP]
cases f
[GOAL]
case inr.inl.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✝¹ val✝ : D
f : inr (inl val✝²) ⟶ inr (inl val✝¹)
g : inr (inl val✝¹) ⟶ inr (inl val✝)
⊢ {
          obj := fun X =>
            match X with
            | inl X => inl (inl X)
            | inr (inl X) => inl (inr X)
            | inr (inr X) => inr X,
          map := fun {X Y} f =>
            match X, Y, f with
            | inl val, inl val_1, f => f
            | inr (inl val), inr (inl val_1), f => f
            | inr (inr val), inr (inr val_1), f => f }.map
      (f ≫ g) =
    {
            obj := fun X =>
              match X with
              | inl X => inl (inl X)
              | inr (inl X) => inl (inr X)
              | inr (inr X) => inr X,
            map := fun {X Y} f =>
              match X, Y, f with
              | inl val, inl val_1, f => f
              | inr (inl val), inr (inl val_1), f => f
              | inr (inr val), inr (inr val_1), f => f }.map
        f ≫
      {
            obj := fun X =>
              match X with
              | inl X => inl (inl X)
              | inr (inl X) => inl (inr X)
              | inr (inr X) => inr X,
            map := fun {X Y} f =>
              match X, Y, f with
              | inl val, inl val_1, f => f
              | inr (inl val), inr (inl val_1), f => f
              | inr (inr val), inr (inr val_1), f => f }.map
        g
[PROOFSTEP]
cases g
[GOAL]
case inr.inl.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✝¹ val✝ : D
f : inr (inl val✝²) ⟶ inr (inl val✝¹)
g : inr (inl val✝¹) ⟶ inr (inl val✝)
⊢ {
          obj := fun X =>
            match X with
            | inl X => inl (inl X)
            | inr (inl X) => inl (inr X)
            | inr (inr X) => inr X,
          map := fun {X Y} f =>
            match X, Y, f with
            | inl val, inl val_1, f => f
            | inr (inl val), inr (inl val_1), f => f
            | inr (inr val), inr (inr val_1), f => f }.map
      (f ≫ g) =
    {
            obj := fun X =>
              match X with
              | inl X => inl (inl X)
              | inr (inl X) => inl (inr X)
              | inr (inr X) => inr X,
            map := fun {X Y} f =>
              match X, Y, f with
              | inl val, inl val_1, f => f
              | inr (inl val), inr (inl val_1), f => f
              | inr (inr val), inr (inr val_1), f => f }.map
        f ≫
      {
            obj := fun X =>
              match X with
              | inl X => inl (inl X)
              | inr (inl X) => inl (inr X)
              | inr (inr X) => inr X,
            map := fun {X Y} f =>
              match X, Y, f with
              | inl val, inl val_1, f => f
              | inr (inl val), inr (inl val_1), f => f
              | inr (inr val), inr (inr val_1), f => f }.map
        g
[PROOFSTEP]
aesop_cat
[GOAL]
case inr.inl.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✝² val✝¹ : D
val✝ : E
f : inr (inl val✝²) ⟶ inr (inl val✝¹)
g : inr (inl val✝¹) ⟶ inr (inr val✝)
⊢ {
          obj := fun X =>
            match X with
            | inl X => inl (inl X)
            | inr (inl X) => inl (inr X)
            | inr (inr X) => inr X,
          map := fun {X Y} f =>
            match X, Y, f with
            | inl val, inl val_1, f => f
            | inr (inl val), inr (inl val_1), f => f
            | inr (inr val), inr (inr val_1), f => f }.map
      (f ≫ g) =
    {
            obj := fun X =>
              match X with
              | inl X => inl (inl X)
              | inr (inl X) => inl (inr X)
              | inr (inr X) => inr X,
            map := fun {X Y} f =>
              match X, Y, f with
              | inl val, inl val_1, f => f
              | inr (inl val), inr (inl val_1), f => f
              | inr (inr val), inr (inr val_1), f => f }.map
        f ≫
      {
            obj := fun X =>
              match X with
              | inl X => inl (inl X)
              | inr (inl X) => inl (inr X)
              | inr (inr X) => inr X,
            map := fun {X Y} f =>
              match X, Y, f with
              | inl val, inl val_1, f => f
              | inr (inl val), inr (inl val_1), f => f
              | inr (inr val), inr (inr val_1), f => f }.map
        g
[PROOFSTEP]
first
| cases f
| cases g
| aesop_cat
[GOAL]
case inr.inl.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✝² val✝¹ : D
val✝ : E
f : inr (inl val✝²) ⟶ inr (inl val✝¹)
g : inr (inl val✝¹) ⟶ inr (inr val✝)
⊢ {
          obj := fun X =>
            match X with
            | inl X => inl (inl X)
            | inr (inl X) => inl (inr X)
            | inr (inr X) => inr X,
          map := fun {X Y} f =>
            match X, Y, f with
            | inl val, inl val_1, f => f
            | inr (inl val), inr (inl val_1), f => f
            | inr (inr val), inr (inr val_1), f => f }.map
      (f ≫ g) =
    {
            obj := fun X =>
              match X with
              | inl X => inl (inl X)
              | inr (inl X) => inl (inr X)
              | inr (inr X) => inr X,
            map := fun {X Y} f =>
              match X, Y, f with
              | inl val, inl val_1, f => f
              | inr (inl val), inr (inl val_1), f => f
              | inr (inr val), inr (inr val_1), f => f }.map
        f ≫
      {
            obj := fun X =>
              match X with
              | inl X => inl (inl X)
              | inr (inl X) => inl (inr X)
              | inr (inr X) => inr X,
            map := fun {X Y} f =>
              match X, Y, f with
              | inl val, inl val_1, f => f
              | inr (inl val), inr (inl val_1), f => f
              | inr (inr val), inr (inr val_1), f => f }.map
        g
[PROOFSTEP]
cases f
[GOAL]
case inr.inl.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✝² val✝¹ : D
val✝ : E
f : inr (inl val✝²) ⟶ inr (inl val✝¹)
g : inr (inl val✝¹) ⟶ inr (inr val✝)
⊢ {
          obj := fun X =>
            match X with
            | inl X => inl (inl X)
            | inr (inl X) => inl (inr X)
            | inr (inr X) => inr X,
          map := fun {X Y} f =>
            match X, Y, f with
            | inl val, inl val_1, f => f
            | inr (inl val), inr (inl val_1), f => f
            | inr (inr val), inr (inr val_1), f => f }.map
      (f ≫ g) =
    {
            obj := fun X =>
              match X with
              | inl X => inl (inl X)
              | inr (inl X) => inl (inr X)
              | inr (inr X) => inr X,
            map := fun {X Y} f =>
              match X, Y, f with
              | inl val, inl val_1, f => f
              | inr (inl val), inr (inl val_1), f => f
              | inr (inr val), inr (inr val_1), f => f }.map
        f ≫
      {
            obj := fun X =>
              match X with
              | inl X => inl (inl X)
              | inr (inl X) => inl (inr X)
              | inr (inr X) => inr X,
            map := fun {X Y} f =>
              match X, Y, f with
              | inl val, inl val_1, f => f
              | inr (inl val), inr (inl val_1), f => f
              | inr (inr val), inr (inr val_1), f => f }.map
        g
[PROOFSTEP]
cases g
[GOAL]
case inr.inl.inr.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
val✝¹ : E
val✝ : C
f : inr (inl val✝²) ⟶ inr (inr val✝¹)
g : inr (inr val✝¹) ⟶ inl val✝
⊢ {
          obj := fun X =>
            match X with
            | inl X => inl (inl X)
            | inr (inl X) => inl (inr X)
            | inr (inr X) => inr X,
          map := fun {X Y} f =>
            match X, Y, f with
            | inl val, inl val_1, f => f
            | inr (inl val), inr (inl val_1), f => f
            | inr (inr val), inr (inr val_1), f => f }.map
      (f ≫ g) =
    {
            obj := fun X =>
              match X with
              | inl X => inl (inl X)
              | inr (inl X) => inl (inr X)
              | inr (inr X) => inr X,
            map := fun {X Y} f =>
              match X, Y, f with
              | inl val, inl val_1, f => f
              | inr (inl val), inr (inl val_1), f => f
              | inr (inr val), inr (inr val_1), f => f }.map
        f ≫
      {
            obj := fun X =>
              match X with
              | inl X => inl (inl X)
              | inr (inl X) => inl (inr X)
              | inr (inr X) => inr X,
            map := fun {X Y} f =>
              match X, Y, f with
              | inl val, inl val_1, f => f
              | inr (inl val), inr (inl val_1), f => f
              | inr (inr val), inr (inr val_1), f => f }.map
        g
[PROOFSTEP]
first
| cases f
| cases g
| aesop_cat
[GOAL]
case inr.inl.inr.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
val✝¹ : E
val✝ : C
f : inr (inl val✝²) ⟶ inr (inr val✝¹)
g : inr (inr val✝¹) ⟶ inl val✝
⊢ {
          obj := fun X =>
            match X with
            | inl X => inl (inl X)
            | inr (inl X) => inl (inr X)
            | inr (inr X) => inr X,
          map := fun {X Y} f =>
            match X, Y, f with
            | inl val, inl val_1, f => f
            | inr (inl val), inr (inl val_1), f => f
            | inr (inr val), inr (inr val_1), f => f }.map
      (f ≫ g) =
    {
            obj := fun X =>
              match X with
              | inl X => inl (inl X)
              | inr (inl X) => inl (inr X)
              | inr (inr X) => inr X,
            map := fun {X Y} f =>
              match X, Y, f with
              | inl val, inl val_1, f => f
              | inr (inl val), inr (inl val_1), f => f
              | inr (inr val), inr (inr val_1), f => f }.map
        f ≫
      {
            obj := fun X =>
              match X with
              | inl X => inl (inl X)
              | inr (inl X) => inl (inr X)
              | inr (inr X) => inr X,
            map := fun {X Y} f =>
              match X, Y, f with
              | inl val, inl val_1, f => f
              | inr (inl val), inr (inl val_1), f => f
              | inr (inr val), inr (inr val_1), f => f }.map
        g
[PROOFSTEP]
cases f
[GOAL]
case inr.inl.inr.inr.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
val✝¹ : E
val✝ : D
f : inr (inl val✝²) ⟶ inr (inr val✝¹)
g : inr (inr val✝¹) ⟶ inr (inl val✝)
⊢ {
          obj := fun X =>
            match X with
            | inl X => inl (inl X)
            | inr (inl X) => inl (inr X)
            | inr (inr X) => inr X,
          map := fun {X Y} f =>
            match X, Y, f with
            | inl val, inl val_1, f => f
            | inr (inl val), inr (inl val_1), f => f
            | inr (inr val), inr (inr val_1), f => f }.map
      (f ≫ g) =
    {
            obj := fun X =>
              match X with
              | inl X => inl (inl X)
              | inr (inl X) => inl (inr X)
              | inr (inr X) => inr X,
            map := fun {X Y} f =>
              match X, Y, f with
              | inl val, inl val_1, f => f
              | inr (inl val), inr (inl val_1), f => f
              | inr (inr val), inr (inr val_1), f => f }.map
        f ≫
      {
            obj := fun X =>
              match X with
              | inl X => inl (inl X)
              | inr (inl X) => inl (inr X)
              | inr (inr X) => inr X,
            map := fun {X Y} f =>
              match X, Y, f with
              | inl val, inl val_1, f => f
              | inr (inl val), inr (inl val_1), f => f
              | inr (inr val), inr (inr val_1), f => f }.map
        g
[PROOFSTEP]
first
| cases f
| cases g
| aesop_cat
[GOAL]
case inr.inl.inr.inr.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
val✝¹ : E
val✝ : D
f : inr (inl val✝²) ⟶ inr (inr val✝¹)
g : inr (inr val✝¹) ⟶ inr (inl val✝)
⊢ {
          obj := fun X =>
            match X with
            | inl X => inl (inl X)
            | inr (inl X) => inl (inr X)
            | inr (inr X) => inr X,
          map := fun {X Y} f =>
            match X, Y, f with
            | inl val, inl val_1, f => f
            | inr (inl val), inr (inl val_1), f => f
            | inr (inr val), inr (inr val_1), f => f }.map
      (f ≫ g) =
    {
            obj := fun X =>
              match X with
              | inl X => inl (inl X)
              | inr (inl X) => inl (inr X)
              | inr (inr X) => inr X,
            map := fun {X Y} f =>
              match X, Y, f with
              | inl val, inl val_1, f => f
              | inr (inl val), inr (inl val_1), f => f
              | inr (inr val), inr (inr val_1), f => f }.map
        f ≫
      {
            obj := fun X =>
              match X with
              | inl X => inl (inl X)
              | inr (inl X) => inl (inr X)
              | inr (inr X) => inr X,
            map := fun {X Y} f =>
              match X, Y, f with
              | inl val, inl val_1, f => f
              | inr (inl val), inr (inl val_1), f => f
              | inr (inr val), inr (inr val_1), f => f }.map
        g
[PROOFSTEP]
cases f
[GOAL]
case inr.inl.inr.inr.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✝¹ val✝ : E
f : inr (inl val✝²) ⟶ inr (inr val✝¹)
g : inr (inr val✝¹) ⟶ inr (inr val✝)
⊢ {
          obj := fun X =>
            match X with
            | inl X => inl (inl X)
            | inr (inl X) => inl (inr X)
            | inr (inr X) => inr X,
          map := fun {X Y} f =>
            match X, Y, f with
            | inl val, inl val_1, f => f
            | inr (inl val), inr (inl val_1), f => f
            | inr (inr val), inr (inr val_1), f => f }.map
      (f ≫ g) =
    {
            obj := fun X =>
              match X with
              | inl X => inl (inl X)
              | inr (inl X) => inl (inr X)
              | inr (inr X) => inr X,
            map := fun {X Y} f =>
              match X, Y, f with
              | inl val, inl val_1, f => f
              | inr (inl val), inr (inl val_1), f => f
              | inr (inr val), inr (inr val_1), f => f }.map
        f ≫
      {
            obj := fun X =>
              match X with
              | inl X => inl (inl X)
              | inr (inl X) => inl (inr X)
              | inr (inr X) => inr X,
            map := fun {X Y} f =>
              match X, Y, f with
              | inl val, inl val_1, f => f
              | inr (inl val), inr (inl val_1), f => f
              | inr (inr val), inr (inr val_1), f => f }.map
        g
[PROOFSTEP]
first
| cases f
| cases g
| aesop_cat
[GOAL]
case inr.inl.inr.inr.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✝¹ val✝ : E
f : inr (inl val✝²) ⟶ inr (inr val✝¹)
g : inr (inr val✝¹) ⟶ inr (inr val✝)
⊢ {
          obj := fun X =>
            match X with
            | inl X => inl (inl X)
            | inr (inl X) => inl (inr X)
            | inr (inr X) => inr X,
          map := fun {X Y} f =>
            match X, Y, f with
            | inl val, inl val_1, f => f
            | inr (inl val), inr (inl val_1), f => f
            | inr (inr val), inr (inr val_1), f => f }.map
      (f ≫ g) =
    {
            obj := fun X =>
              match X with
              | inl X => inl (inl X)
              | inr (inl X) => inl (inr X)
              | inr (inr X) => inr X,
            map := fun {X Y} f =>
              match X, Y, f with
              | inl val, inl val_1, f => f
              | inr (inl val), inr (inl val_1), f => f
              | inr (inr val), inr (inr val_1), f => f }.map
        f ≫
      {
            obj := fun X =>
              match X with
              | inl X => inl (inl X)
              | inr (inl X) => inl (inr X)
              | inr (inr X) => inr X,
            map := fun {X Y} f =>
              match X, Y, f with
              | inl val, inl val_1, f => f
              | inr (inl val), inr (inl val_1), f => f
              | inr (inr val), inr (inr val_1), f => f }.map
        g
[PROOFSTEP]
cases f
[GOAL]
case inr.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✝² : E
val✝¹ val✝ : C
f : inr (inr val✝²) ⟶ inl val✝¹
g : inl val✝¹ ⟶ inl val✝
⊢ {
          obj := fun X =>
            match X with
            | inl X => inl (inl X)
            | inr (inl X) => inl (inr X)
            | inr (inr X) => inr X,
          map := fun {X Y} f =>
            match X, Y, f with
            | inl val, inl val_1, f => f
            | inr (inl val), inr (inl val_1), f => f
            | inr (inr val), inr (inr val_1), f => f }.map
      (f ≫ g) =
    {
            obj := fun X =>
              match X with
              | inl X => inl (inl X)
              | inr (inl X) => inl (inr X)
              | inr (inr X) => inr X,
            map := fun {X Y} f =>
              match X, Y, f with
              | inl val, inl val_1, f => f
              | inr (inl val), inr (inl val_1), f => f
              | inr (inr val), inr (inr val_1), f => f }.map
        f ≫
      {
            obj := fun X =>
              match X with
              | inl X => inl (inl X)
              | inr (inl X) => inl (inr X)
              | inr (inr X) => inr X,
            map := fun {X Y} f =>
              match X, Y, f with
              | inl val, inl val_1, f => f
              | inr (inl val), inr (inl val_1), f => f
              | inr (inr val), inr (inr val_1), f => f }.map
        g
[PROOFSTEP]
first
| cases f
| cases g
| aesop_cat
[GOAL]
case inr.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✝² : E
val✝¹ val✝ : C
f : inr (inr val✝²) ⟶ inl val✝¹
g : inl val✝¹ ⟶ inl val✝
⊢ {
          obj := fun X =>
            match X with
            | inl X => inl (inl X)
            | inr (inl X) => inl (inr X)
            | inr (inr X) => inr X,
          map := fun {X Y} f =>
            match X, Y, f with
            | inl val, inl val_1, f => f
            | inr (inl val), inr (inl val_1), f => f
            | inr (inr val), inr (inr val_1), f => f }.map
      (f ≫ g) =
    {
            obj := fun X =>
              match X with
              | inl X => inl (inl X)
              | inr (inl X) => inl (inr X)
              | inr (inr X) => inr X,
            map := fun {X Y} f =>
              match X, Y, f with
              | inl val, inl val_1, f => f
              | inr (inl val), inr (inl val_1), f => f
              | inr (inr val), inr (inr val_1), f => f }.map
        f ≫
      {
            obj := fun X =>
              match X with
              | inl X => inl (inl X)
              | inr (inl X) => inl (inr X)
              | inr (inr X) => inr X,
            map := fun {X Y} f =>
              match X, Y, f with
              | inl val, inl val_1, f => f
              | inr (inl val), inr (inl val_1), f => f
              | inr (inr val), inr (inr val_1), f => f }.map
        g
[PROOFSTEP]
cases f
[GOAL]
case inr.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✝² : E
val✝¹ : C
val✝ : D
f : inr (inr val✝²) ⟶ inl val✝¹
g : inl val✝¹ ⟶ inr (inl val✝)
⊢ {
          obj := fun X =>
            match X with
            | inl X => inl (inl X)
            | inr (inl X) => inl (inr X)
            | inr (inr X) => inr X,
          map := fun {X Y} f =>
            match X, Y, f with
            | inl val, inl val_1, f => f
            | inr (inl val), inr (inl val_1), f => f
            | inr (inr val), inr (inr val_1), f => f }.map
      (f ≫ g) =
    {
            obj := fun X =>
              match X with
              | inl X => inl (inl X)
              | inr (inl X) => inl (inr X)
              | inr (inr X) => inr X,
            map := fun {X Y} f =>
              match X, Y, f with
              | inl val, inl val_1, f => f
              | inr (inl val), inr (inl val_1), f => f
              | inr (inr val), inr (inr val_1), f => f }.map
        f ≫
      {
            obj := fun X =>
              match X with
              | inl X => inl (inl X)
              | inr (inl X) => inl (inr X)
              | inr (inr X) => inr X,
            map := fun {X Y} f =>
              match X, Y, f with
              | inl val, inl val_1, f => f
              | inr (inl val), inr (inl val_1), f => f
              | inr (inr val), inr (inr val_1), f => f }.map
        g
[PROOFSTEP]
first
| cases f
| cases g
| aesop_cat
[GOAL]
case inr.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✝² : E
val✝¹ : C
val✝ : D
f : inr (inr val✝²) ⟶ inl val✝¹
g : inl val✝¹ ⟶ inr (inl val✝)
⊢ {
          obj := fun X =>
            match X with
            | inl X => inl (inl X)
            | inr (inl X) => inl (inr X)
            | inr (inr X) => inr X,
          map := fun {X Y} f =>
            match X, Y, f with
            | inl val, inl val_1, f => f
            | inr (inl val), inr (inl val_1), f => f
            | inr (inr val), inr (inr val_1), f => f }.map
      (f ≫ g) =
    {
            obj := fun X =>
              match X with
              | inl X => inl (inl X)
              | inr (inl X) => inl (inr X)
              | inr (inr X) => inr X,
            map := fun {X Y} f =>
              match X, Y, f with
              | inl val, inl val_1, f => f
              | inr (inl val), inr (inl val_1), f => f
              | inr (inr val), inr (inr val_1), f => f }.map
        f ≫
      {
            obj := fun X =>
              match X with
              | inl X => inl (inl X)
              | inr (inl X) => inl (inr X)
              | inr (inr X) => inr X,
            map := fun {X Y} f =>
              match X, Y, f with
              | inl val, inl val_1, f => f
              | inr (inl val), inr (inl val_1), f => f
              | inr (inr val), inr (inr val_1), f => f }.map
        g
[PROOFSTEP]
cases f
[GOAL]
case inr.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✝² : E
val✝¹ : C
val✝ : E
f : inr (inr val✝²) ⟶ inl val✝¹
g : inl val✝¹ ⟶ inr (inr val✝)
⊢ {
          obj := fun X =>
            match X with
            | inl X => inl (inl X)
            | inr (inl X) => inl (inr X)
            | inr (inr X) => inr X,
          map := fun {X Y} f =>
            match X, Y, f with
            | inl val, inl val_1, f => f
            | inr (inl val), inr (inl val_1), f => f
            | inr (inr val), inr (inr val_1), f => f }.map
      (f ≫ g) =
    {
            obj := fun X =>
              match X with
              | inl X => inl (inl X)
              | inr (inl X) => inl (inr X)
              | inr (inr X) => inr X,
            map := fun {X Y} f =>
              match X, Y, f with
              | inl val, inl val_1, f => f
              | inr (inl val), inr (inl val_1), f => f
              | inr (inr val), inr (inr val_1), f => f }.map
        f ≫
      {
            obj := fun X =>
              match X with
              | inl X => inl (inl X)
              | inr (inl X) => inl (inr X)
              | inr (inr X) => inr X,
            map := fun {X Y} f =>
              match X, Y, f with
              | inl val, inl val_1, f => f
              | inr (inl val), inr (inl val_1), f => f
              | inr (inr val), inr (inr val_1), f => f }.map
        g
[PROOFSTEP]
first
| cases f
| cases g
| aesop_cat
[GOAL]
case inr.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✝² : E
val✝¹ : C
val✝ : E
f : inr (inr val✝²) ⟶ inl val✝¹
g : inl val✝¹ ⟶ inr (inr val✝)
⊢ {
          obj := fun X =>
            match X with
            | inl X => inl (inl X)
            | inr (inl X) => inl (inr X)
            | inr (inr X) => inr X,
          map := fun {X Y} f =>
            match X, Y, f with
            | inl val, inl val_1, f => f
            | inr (inl val), inr (inl val_1), f => f
            | inr (inr val), inr (inr val_1), f => f }.map
      (f ≫ g) =
    {
            obj := fun X =>
              match X with
              | inl X => inl (inl X)
              | inr (inl X) => inl (inr X)
              | inr (inr X) => inr X,
            map := fun {X Y} f =>
              match X, Y, f with
              | inl val, inl val_1, f => f
              | inr (inl val), inr (inl val_1), f => f
              | inr (inr val), inr (inr val_1), f => f }.map
        f ≫
      {
            obj := fun X =>
              match X with
              | inl X => inl (inl X)
              | inr (inl X) => inl (inr X)
              | inr (inr X) => inr X,
            map := fun {X Y} f =>
              match X, Y, f with
              | inl val, inl val_1, f => f
              | inr (inl val), inr (inl val_1), f => f
              | inr (inr val), inr (inr val_1), f => f }.map
        g
[PROOFSTEP]
cases f
[GOAL]
case inr.inr.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✝² : E
val✝¹ : D
val✝ : C
f : inr (inr val✝²) ⟶ inr (inl val✝¹)
g : inr (inl val✝¹) ⟶ inl val✝
⊢ {
          obj := fun X =>
            match X with
            | inl X => inl (inl X)
            | inr (inl X) => inl (inr X)
            | inr (inr X) => inr X,
          map := fun {X Y} f =>
            match X, Y, f with
            | inl val, inl val_1, f => f
            | inr (inl val), inr (inl val_1), f => f
            | inr (inr val), inr (inr val_1), f => f }.map
      (f ≫ g) =
    {
            obj := fun X =>
              match X with
              | inl X => inl (inl X)
              | inr (inl X) => inl (inr X)
              | inr (inr X) => inr X,
            map := fun {X Y} f =>
              match X, Y, f with
              | inl val, inl val_1, f => f
              | inr (inl val), inr (inl val_1), f => f
              | inr (inr val), inr (inr val_1), f => f }.map
        f ≫
      {
            obj := fun X =>
              match X with
              | inl X => inl (inl X)
              | inr (inl X) => inl (inr X)
              | inr (inr X) => inr X,
            map := fun {X Y} f =>
              match X, Y, f with
              | inl val, inl val_1, f => f
              | inr (inl val), inr (inl val_1), f => f
              | inr (inr val), inr (inr val_1), f => f }.map
        g
[PROOFSTEP]
first
| cases f
| cases g
| aesop_cat
[GOAL]
case inr.inr.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✝² : E
val✝¹ : D
val✝ : C
f : inr (inr val✝²) ⟶ inr (inl val✝¹)
g : inr (inl val✝¹) ⟶ inl val✝
⊢ {
          obj := fun X =>
            match X with
            | inl X => inl (inl X)
            | inr (inl X) => inl (inr X)
            | inr (inr X) => inr X,
          map := fun {X Y} f =>
            match X, Y, f with
            | inl val, inl val_1, f => f
            | inr (inl val), inr (inl val_1), f => f
            | inr (inr val), inr (inr val_1), f => f }.map
      (f ≫ g) =
    {
            obj := fun X =>
              match X with
              | inl X => inl (inl X)
              | inr (inl X) => inl (inr X)
              | inr (inr X) => inr X,
            map := fun {X Y} f =>
              match X, Y, f with
              | inl val, inl val_1, f => f
              | inr (inl val), inr (inl val_1), f => f
              | inr (inr val), inr (inr val_1), f => f }.map
        f ≫
      {
            obj := fun X =>
              match X with
              | inl X => inl (inl X)
              | inr (inl X) => inl (inr X)
              | inr (inr X) => inr X,
            map := fun {X Y} f =>
              match X, Y, f with
              | inl val, inl val_1, f => f
              | inr (inl val), inr (inl val_1), f => f
              | inr (inr val), inr (inr val_1), f => f }.map
        g
[PROOFSTEP]
cases f
[GOAL]
case inr.inr.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✝² : E
val✝¹ val✝ : D
f : inr (inr val✝²) ⟶ inr (inl val✝¹)
g : inr (inl val✝¹) ⟶ inr (inl val✝)
⊢ {
          obj := fun X =>
            match X with
            | inl X => inl (inl X)
            | inr (inl X) => inl (inr X)
            | inr (inr X) => inr X,
          map := fun {X Y} f =>
            match X, Y, f with
            | inl val, inl val_1, f => f
            | inr (inl val), inr (inl val_1), f => f
            | inr (inr val), inr (inr val_1), f => f }.map
      (f ≫ g) =
    {
            obj := fun X =>
              match X with
              | inl X => inl (inl X)
              | inr (inl X) => inl (inr X)
              | inr (inr X) => inr X,
            map := fun {X Y} f =>
              match X, Y, f with
              | inl val, inl val_1, f => f
              | inr (inl val), inr (inl val_1), f => f
              | inr (inr val), inr (inr val_1), f => f }.map
        f ≫
      {
            obj := fun X =>
              match X with
              | inl X => inl (inl X)
              | inr (inl X) => inl (inr X)
              | inr (inr X) => inr X,
            map := fun {X Y} f =>
              match X, Y, f with
              | inl val, inl val_1, f => f
              | inr (inl val), inr (inl val_1), f => f
              | inr (inr val), inr (inr val_1), f => f }.map
        g
[PROOFSTEP]
first
| cases f
| cases g
| aesop_cat
[GOAL]
case inr.inr.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✝² : E
val✝¹ val✝ : D
f : inr (inr val✝²) ⟶ inr (inl val✝¹)
g : inr (inl val✝¹) ⟶ inr (inl val✝)
⊢ {
          obj := fun X =>
            match X with
            | inl X => inl (inl X)
            | inr (inl X) => inl (inr X)
            | inr (inr X) => inr X,
          map := fun {X Y} f =>
            match X, Y, f with
            | inl val, inl val_1, f => f
            | inr (inl val), inr (inl val_1), f => f
            | inr (inr val), inr (inr val_1), f => f }.map
      (f ≫ g) =
    {
            obj := fun X =>
              match X with
              | inl X => inl (inl X)
              | inr (inl X) => inl (inr X)
              | inr (inr X) => inr X,
            map := fun {X Y} f =>
              match X, Y, f with
              | inl val, inl val_1, f => f
              | inr (inl val), inr (inl val_1), f => f
              | inr (inr val), inr (inr val_1), f => f }.map
        f ≫
      {
            obj := fun X =>
              match X with
              | inl X => inl (inl X)
              | inr (inl X) => inl (inr X)
              | inr (inr X) => inr X,
            map := fun {X Y} f =>
              match X, Y, f with
              | inl val, inl val_1, f => f
              | inr (inl val), inr (inl val_1), f => f
              | inr (inr val), inr (inr val_1), f => f }.map
        g
[PROOFSTEP]
cases f
[GOAL]
case inr.inr.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✝² : E
val✝¹ : D
val✝ : E
f : inr (inr val✝²) ⟶ inr (inl val✝¹)
g : inr (inl val✝¹) ⟶ inr (inr val✝)
⊢ {
          obj := fun X =>
            match X with
            | inl X => inl (inl X)
            | inr (inl X) => inl (inr X)
            | inr (inr X) => inr X,
          map := fun {X Y} f =>
            match X, Y, f with
            | inl val, inl val_1, f => f
            | inr (inl val), inr (inl val_1), f => f
            | inr (inr val), inr (inr val_1), f => f }.map
      (f ≫ g) =
    {
            obj := fun X =>
              match X with
              | inl X => inl (inl X)
              | inr (inl X) => inl (inr X)
              | inr (inr X) => inr X,
            map := fun {X Y} f =>
              match X, Y, f with
              | inl val, inl val_1, f => f
              | inr (inl val), inr (inl val_1), f => f
              | inr (inr val), inr (inr val_1), f => f }.map
        f ≫
      {
            obj := fun X =>
              match X with
              | inl X => inl (inl X)
              | inr (inl X) => inl (inr X)
              | inr (inr X) => inr X,
            map := fun {X Y} f =>
              match X, Y, f with
              | inl val, inl val_1, f => f
              | inr (inl val), inr (inl val_1), f => f
              | inr (inr val), inr (inr val_1), f => f }.map
        g
[PROOFSTEP]
first
| cases f
| cases g
| aesop_cat
[GOAL]
case inr.inr.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✝² : E
val✝¹ : D
val✝ : E
f : inr (inr val✝²) ⟶ inr (inl val✝¹)
g : inr (inl val✝¹) ⟶ inr (inr val✝)
⊢ {
          obj := fun X =>
            match X with
            | inl X => inl (inl X)
            | inr (inl X) => inl (inr X)
            | inr (inr X) => inr X,
          map := fun {X Y} f =>
            match X, Y, f with
            | inl val, inl val_1, f => f
            | inr (inl val), inr (inl val_1), f => f
            | inr (inr val), inr (inr val_1), f => f }.map
      (f ≫ g) =
    {
            obj := fun X =>
              match X with
              | inl X => inl (inl X)
              | inr (inl X) => inl (inr X)
              | inr (inr X) => inr X,
            map := fun {X Y} f =>
              match X, Y, f with
              | inl val, inl val_1, f => f
              | inr (inl val), inr (inl val_1), f => f
              | inr (inr val), inr (inr val_1), f => f }.map
        f ≫
      {
            obj := fun X =>
              match X with
              | inl X => inl (inl X)
              | inr (inl X) => inl (inr X)
              | inr (inr X) => inr X,
            map := fun {X Y} f =>
              match X, Y, f with
              | inl val, inl val_1, f => f
              | inr (inl val), inr (inl val_1), f => f
              | inr (inr val), inr (inr val_1), f => f }.map
        g
[PROOFSTEP]
cases f
[GOAL]
case inr.inr.inr.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✝¹ : E
val✝ : C
f : inr (inr val✝²) ⟶ inr (inr val✝¹)
g : inr (inr val✝¹) ⟶ inl val✝
⊢ {
          obj := fun X =>
            match X with
            | inl X => inl (inl X)
            | inr (inl X) => inl (inr X)
            | inr (inr X) => inr X,
          map := fun {X Y} f =>
            match X, Y, f with
            | inl val, inl val_1, f => f
            | inr (inl val), inr (inl val_1), f => f
            | inr (inr val), inr (inr val_1), f => f }.map
      (f ≫ g) =
    {
            obj := fun X =>
              match X with
              | inl X => inl (inl X)
              | inr (inl X) => inl (inr X)
              | inr (inr X) => inr X,
            map := fun {X Y} f =>
              match X, Y, f with
              | inl val, inl val_1, f => f
              | inr (inl val), inr (inl val_1), f => f
              | inr (inr val), inr (inr val_1), f => f }.map
        f ≫
      {
            obj := fun X =>
              match X with
              | inl X => inl (inl X)
              | inr (inl X) => inl (inr X)
              | inr (inr X) => inr X,
            map := fun {X Y} f =>
              match X, Y, f with
              | inl val, inl val_1, f => f
              | inr (inl val), inr (inl val_1), f => f
              | inr (inr val), inr (inr val_1), f => f }.map
        g
[PROOFSTEP]
first
| cases f
| cases g
| aesop_cat
[GOAL]
case inr.inr.inr.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✝¹ : E
val✝ : C
f : inr (inr val✝²) ⟶ inr (inr val✝¹)
g : inr (inr val✝¹) ⟶ inl val✝
⊢ {
          obj := fun X =>
            match X with
            | inl X => inl (inl X)
            | inr (inl X) => inl (inr X)
            | inr (inr X) => inr X,
          map := fun {X Y} f =>
            match X, Y, f with
            | inl val, inl val_1, f => f
            | inr (inl val), inr (inl val_1), f => f
            | inr (inr val), inr (inr val_1), f => f }.map
      (f ≫ g) =
    {
            obj := fun X =>
              match X with
              | inl X => inl (inl X)
              | inr (inl X) => inl (inr X)
              | inr (inr X) => inr X,
            map := fun {X Y} f =>
              match X, Y, f with
              | inl val, inl val_1, f => f
              | inr (inl val), inr (inl val_1), f => f
              | inr (inr val), inr (inr val_1), f => f }.map
        f ≫
      {
            obj := fun X =>
              match X with
              | inl X => inl (inl X)
              | inr (inl X) => inl (inr X)
              | inr (inr X) => inr X,
            map := fun {X Y} f =>
              match X, Y, f with
              | inl val, inl val_1, f => f
              | inr (inl val), inr (inl val_1), f => f
              | inr (inr val), inr (inr val_1), f => f }.map
        g
[PROOFSTEP]
cases f
[GOAL]
case inr.inr.inr.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✝¹ : E
val✝ : C
f : inr (inr val✝²) ⟶ inr (inr val✝¹)
g : inr (inr val✝¹) ⟶ inl val✝
⊢ {
          obj := fun X =>
            match X with
            | inl X => inl (inl X)
            | inr (inl X) => inl (inr X)
            | inr (inr X) => inr X,
          map := fun {X Y} f =>
            match X, Y, f with
            | inl val, inl val_1, f => f
            | inr (inl val), inr (inl val_1), f => f
            | inr (inr val), inr (inr val_1), f => f }.map
      (f ≫ g) =
    {
            obj := fun X =>
              match X with
              | inl X => inl (inl X)
              | inr (inl X) => inl (inr X)
              | inr (inr X) => inr X,
            map := fun {X Y} f =>
              match X, Y, f with
              | inl val, inl val_1, f => f
              | inr (inl val), inr (inl val_1), f => f
              | inr (inr val), inr (inr val_1), f => f }.map
        f ≫
      {
            obj := fun X =>
              match X with
              | inl X => inl (inl X)
              | inr (inl X) => inl (inr X)
              | inr (inr X) => inr X,
            map := fun {X Y} f =>
              match X, Y, f with
              | inl val, inl val_1, f => f
              | inr (inl val), inr (inl val_1), f => f
              | inr (inr val), inr (inr val_1), f => f }.map
        g
[PROOFSTEP]
cases g
[GOAL]
case inr.inr.inr.inr.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✝¹ : E
val✝ : D
f : inr (inr val✝²) ⟶ inr (inr val✝¹)
g : inr (inr val✝¹) ⟶ inr (inl val✝)
⊢ {
          obj := fun X =>
            match X with
            | inl X => inl (inl X)
            | inr (inl X) => inl (inr X)
            | inr (inr X) => inr X,
          map := fun {X Y} f =>
            match X, Y, f with
            | inl val, inl val_1, f => f
            | inr (inl val), inr (inl val_1), f => f
            | inr (inr val), inr (inr val_1), f => f }.map
      (f ≫ g) =
    {
            obj := fun X =>
              match X with
              | inl X => inl (inl X)
              | inr (inl X) => inl (inr X)
              | inr (inr X) => inr X,
            map := fun {X Y} f =>
              match X, Y, f with
              | inl val, inl val_1, f => f
              | inr (inl val), inr (inl val_1), f => f
              | inr (inr val), inr (inr val_1), f => f }.map
        f ≫
      {
            obj := fun X =>
              match X with
              | inl X => inl (inl X)
              | inr (inl X) => inl (inr X)
              | inr (inr X) => inr X,
            map := fun {X Y} f =>
              match X, Y, f with
              | inl val, inl val_1, f => f
              | inr (inl val), inr (inl val_1), f => f
              | inr (inr val), inr (inr val_1), f => f }.map
        g
[PROOFSTEP]
first
| cases f
| cases g
| aesop_cat
[GOAL]
case inr.inr.inr.inr.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✝¹ : E
val✝ : D
f : inr (inr val✝²) ⟶ inr (inr val✝¹)
g : inr (inr val✝¹) ⟶ inr (inl val✝)
⊢ {
          obj := fun X =>
            match X with
            | inl X => inl (inl X)
            | inr (inl X) => inl (inr X)
            | inr (inr X) => inr X,
          map := fun {X Y} f =>
            match X, Y, f with
            | inl val, inl val_1, f => f
            | inr (inl val), inr (inl val_1), f => f
            | inr (inr val), inr (inr val_1), f => f }.map
      (f ≫ g) =
    {
            obj := fun X =>
              match X with
              | inl X => inl (inl X)
              | inr (inl X) => inl (inr X)
              | inr (inr X) => inr X,
            map := fun {X Y} f =>
              match X, Y, f with
              | inl val, inl val_1, f => f
              | inr (inl val), inr (inl val_1), f => f
              | inr (inr val), inr (inr val_1), f => f }.map
        f ≫
      {
            obj := fun X =>
              match X with
              | inl X => inl (inl X)
              | inr (inl X) => inl (inr X)
              | inr (inr X) => inr X,
            map := fun {X Y} f =>
              match X, Y, f with
              | inl val, inl val_1, f => f
              | inr (inl val), inr (inl val_1), f => f
              | inr (inr val), inr (inr val_1), f => f }.map
        g
[PROOFSTEP]
cases f
[GOAL]
case inr.inr.inr.inr.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✝¹ : E
val✝ : D
f : inr (inr val✝²) ⟶ inr (inr val✝¹)
g : inr (inr val✝¹) ⟶ inr (inl val✝)
⊢ {
          obj := fun X =>
            match X with
            | inl X => inl (inl X)
            | inr (inl X) => inl (inr X)
            | inr (inr X) => inr X,
          map := fun {X Y} f =>
            match X, Y, f with
            | inl val, inl val_1, f => f
            | inr (inl val), inr (inl val_1), f => f
            | inr (inr val), inr (inr val_1), f => f }.map
      (f ≫ g) =
    {
            obj := fun X =>
              match X with
              | inl X => inl (inl X)
              | inr (inl X) => inl (inr X)
              | inr (inr X) => inr X,
            map := fun {X Y} f =>
              match X, Y, f with
              | inl val, inl val_1, f => f
              | inr (inl val), inr (inl val_1), f => f
              | inr (inr val), inr (inr val_1), f => f }.map
        f ≫
      {
            obj := fun X =>
              match X with
              | inl X => inl (inl X)
              | inr (inl X) => inl (inr X)
              | inr (inr X) => inr X,
            map := fun {X Y} f =>
              match X, Y, f with
              | inl val, inl val_1, f => f
              | inr (inl val), inr (inl val_1), f => f
              | inr (inr val), inr (inr val_1), f => f }.map
        g
[PROOFSTEP]
cases g
[GOAL]
case inr.inr.inr.inr.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✝¹ val✝ : E
f : inr (inr val✝²) ⟶ inr (inr val✝¹)
g : inr (inr val✝¹) ⟶ inr (inr val✝)
⊢ {
          obj := fun X =>
            match X with
            | inl X => inl (inl X)
            | inr (inl X) => inl (inr X)
            | inr (inr X) => inr X,
          map := fun {X Y} f =>
            match X, Y, f with
            | inl val, inl val_1, f => f
            | inr (inl val), inr (inl val_1), f => f
            | inr (inr val), inr (inr val_1), f => f }.map
      (f ≫ g) =
    {
            obj := fun X =>
              match X with
              | inl X => inl (inl X)
              | inr (inl X) => inl (inr X)
              | inr (inr X) => inr X,
            map := fun {X Y} f =>
              match X, Y, f with
              | inl val, inl val_1, f => f
              | inr (inl val), inr (inl val_1), f => f
              | inr (inr val), inr (inr val_1), f => f }.map
        f ≫
      {
            obj := fun X =>
              match X with
              | inl X => inl (inl X)
              | inr (inl X) => inl (inr X)
              | inr (inr X) => inr X,
            map := fun {X Y} f =>
              match X, Y, f with
              | inl val, inl val_1, f => f
              | inr (inl val), inr (inl val_1), f => f
              | inr (inr val), inr (inr val_1), f => f }.map
        g
[PROOFSTEP]
first
| cases f
| cases g
| aesop_cat
[GOAL]
case inr.inr.inr.inr.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✝¹ val✝ : E
f : inr (inr val✝²) ⟶ inr (inr val✝¹)
g : inr (inr val✝¹) ⟶ inr (inr val✝)
⊢ {
          obj := fun X =>
            match X with
            | inl X => inl (inl X)
            | inr (inl X) => inl (inr X)
            | inr (inr X) => inr X,
          map := fun {X Y} f =>
            match X, Y, f with
            | inl val, inl val_1, f => f
            | inr (inl val), inr (inl val_1), f => f
            | inr (inr val), inr (inr val_1), f => f }.map
      (f ≫ g) =
    {
            obj := fun X =>
              match X with
              | inl X => inl (inl X)
              | inr (inl X) => inl (inr X)
              | inr (inr X) => inr X,
            map := fun {X Y} f =>
              match X, Y, f with
              | inl val, inl val_1, f => f
              | inr (inl val), inr (inl val_1), f => f
              | inr (inr val), inr (inr val_1), f => f }.map
        f ≫
      {
            obj := fun X =>
              match X with
              | inl X => inl (inl X)
              | inr (inl X) => inl (inr X)
              | inr (inr X) => inr X,
            map := fun {X Y} f =>
              match X, Y, f with
              | inl val, inl val_1, f => f
              | inr (inl val), inr (inl val_1), f => f
              | inr (inr val), inr (inr val_1), f => f }.map
        g
[PROOFSTEP]
cases f
[GOAL]
case inr.inr.inr.inr.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✝¹ val✝ : E
f : inr (inr val✝²) ⟶ inr (inr val✝¹)
g : inr (inr val✝¹) ⟶ inr (inr val✝)
⊢ {
          obj := fun X =>
            match X with
            | inl X => inl (inl X)
            | inr (inl X) => inl (inr X)
            | inr (inr X) => inr X,
          map := fun {X Y} f =>
            match X, Y, f with
            | inl val, inl val_1, f => f
            | inr (inl val), inr (inl val_1), f => f
            | inr (inr val), inr (inr val_1), f => f }.map
      (f ≫ g) =
    {
            obj := fun X =>
              match X with
              | inl X => inl (inl X)
              | inr (inl X) => inl (inr X)
              | inr (inr X) => inr X,
            map := fun {X Y} f =>
              match X, Y, f with
              | inl val, inl val_1, f => f
              | inr (inl val), inr (inl val_1), f => f
              | inr (inr val), inr (inr val_1), f => f }.map
        f ≫
      {
            obj := fun X =>
              match X with
              | inl X => inl (inl X)
              | inr (inl X) => inl (inr X)
              | inr (inr X) => inr X,
            map := fun {X Y} f =>
              match X, Y, f with
              | inl val, inl val_1, f => f
              | inr (inl val), inr (inl val_1), f => f
              | inr (inr val), inr (inr val_1), f => f }.map
        g
[PROOFSTEP]
cases g
[GOAL]
case inr.inr.inr.inr.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✝¹ val✝ : E
f : inr (inr val✝²) ⟶ inr (inr val✝¹)
g : inr (inr val✝¹) ⟶ inr (inr val✝)
⊢ {
          obj := fun X =>
            match X with
            | inl X => inl (inl X)
            | inr (inl X) => inl (inr X)
            | inr (inr X) => inr X,
          map := fun {X Y} f =>
            match X, Y, f with
            | inl val, inl val_1, f => f
            | inr (inl val), inr (inl val_1), f => f
            | inr (inr val), inr (inr val_1), f => f }.map
      (f ≫ g) =
    {
            obj := fun X =>
              match X with
              | inl X => inl (inl X)
              | inr (inl X) => inl (inr X)
              | inr (inr X) => inr X,
            map := fun {X Y} f =>
              match X, Y, f with
              | inl val, inl val_1, f => f
              | inr (inl val), inr (inl val_1), f => f
              | inr (inr val), inr (inr val_1), f => f }.map
        f ≫
      {
            obj := fun X =>
              match X with
              | inl X => inl (inl X)
              | inr (inl X) => inl (inr X)
              | inr (inr X) => inr X,
            map := fun {X Y} f =>
              match X, Y, f with
              | inl val, inl val_1, f => f
              | inr (inl val), inr (inl val_1), f => f
              | inr (inr val), inr (inr val_1), f => f }.map
        g
[PROOFSTEP]
aesop_cat
[GOAL]
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
⊢ (𝟭 ((C ⊕ D) ⊕ E)).obj X = (associator C D E ⋙ inverseAssociator C D E).obj X
[PROOFSTEP]
rcases X with ((_ | _) | _)
[GOAL]
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✝ : C
⊢ (𝟭 ((C ⊕ D) ⊕ E)).obj (inl (inl val✝)) = (associator C D E ⋙ inverseAssociator C D E).obj (inl (inl val✝))
[PROOFSTEP]
rfl
[GOAL]
case 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✝ : D
⊢ (𝟭 ((C ⊕ D) ⊕ E)).obj (inl (inr val✝)) = (associator C D E ⋙ inverseAssociator C D E).obj (inl (inr val✝))
[PROOFSTEP]
rfl
[GOAL]
case 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
⊢ (𝟭 ((C ⊕ D) ⊕ E)).obj (inr val✝) = (associator C D E ⋙ inverseAssociator C D E).obj (inr val✝)
[PROOFSTEP]
rfl
[GOAL]
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),
    (𝟭 ((C ⊕ D) ⊕ E)).map f ≫
        ((fun X => eqToIso (_ : (𝟭 ((C ⊕ D) ⊕ E)).obj X = (associator C D E ⋙ inverseAssociator C D E).obj X)) Y).hom =
      ((fun X => eqToIso (_ : (𝟭 ((C ⊕ D) ⊕ E)).obj X = (associator C D E ⋙ inverseAssociator C D E).obj X)) X).hom ≫
        (associator C D E ⋙ inverseAssociator C D E).map f
[PROOFSTEP]
rintro ((_ | _) | _) ((_ | _) | _) f
[GOAL]
case inl.inl.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 (inl val✝¹) ⟶ inl (inl 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 (inl val✝))).hom =
    ((fun X => eqToIso (_ : (𝟭 ((C ⊕ D) ⊕ E)).obj X = (associator C D E ⋙ inverseAssociator C D E).obj X))
          (inl (inl val✝¹))).hom ≫
      (associator C D E ⋙ inverseAssociator C D E).map f
[PROOFSTEP]
first
| cases f
| aesop_cat
[GOAL]
case inl.inl.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 (inl val✝¹) ⟶ inl (inl 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 (inl val✝))).hom =
    ((fun X => eqToIso (_ : (𝟭 ((C ⊕ D) ⊕ E)).obj X = (associator C D E ⋙ inverseAssociator C D E).obj X))
          (inl (inl val✝¹))).hom ≫
      (associator C D E ⋙ inverseAssociator C D E).map f
[PROOFSTEP]
cases f
[GOAL]
case inl.inl.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 (inl val✝¹) ⟶ inl (inl 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 (inl val✝))).hom =
    ((fun X => eqToIso (_ : (𝟭 ((C ⊕ D) ⊕ E)).obj X = (associator C D E ⋙ inverseAssociator C D E).obj X))
          (inl (inl val✝¹))).hom ≫
      (associator C D E ⋙ inverseAssociator C D E).map f
[PROOFSTEP]
aesop_cat
[GOAL]
case inl.inl.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✝¹ : C
val✝ : D
f : inl (inl 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))
          (inl (inl val✝¹))).hom ≫
      (associator C D E ⋙ inverseAssociator C D E).map f
[PROOFSTEP]
first
| cases f
| aesop_cat
[GOAL]
case inl.inl.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✝¹ : C
val✝ : D
f : inl (inl 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))
          (inl (inl val✝¹))).hom ≫
      (associator C D E ⋙ inverseAssociator C D E).map f
[PROOFSTEP]
cases f
[GOAL]
case inl.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✝¹ : C
val✝ : E
f : inl (inl 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))
          (inl (inl val✝¹))).hom ≫
      (associator C D E ⋙ inverseAssociator C D E).map f
[PROOFSTEP]
first
| cases f
| aesop_cat
[GOAL]
case inl.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✝¹ : C
val✝ : E
f : inl (inl 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))
          (inl (inl val✝¹))).hom ≫
      (associator C D E ⋙ inverseAssociator C D E).map f
[PROOFSTEP]
cases f
[GOAL]
case inl.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 : inl (inr val✝¹) ⟶ inl (inl 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 (inl val✝))).hom =
    ((fun X => eqToIso (_ : (𝟭 ((C ⊕ D) ⊕ E)).obj X = (associator C D E ⋙ inverseAssociator C D E).obj X))
          (inl (inr val✝¹))).hom ≫
      (associator C D E ⋙ inverseAssociator C D E).map f
[PROOFSTEP]
first
| cases f
| aesop_cat
[GOAL]
case inl.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 : inl (inr val✝¹) ⟶ inl (inl 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 (inl val✝))).hom =
    ((fun X => eqToIso (_ : (𝟭 ((C ⊕ D) ⊕ E)).obj X = (associator C D E ⋙ inverseAssociator C D E).obj X))
          (inl (inr val✝¹))).hom ≫
      (associator C D E ⋙ inverseAssociator C D E).map f
[PROOFSTEP]
cases f
[GOAL]
case inl.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✝¹ val✝ : D
f : inl (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))
          (inl (inr val✝¹))).hom ≫
      (associator C D E ⋙ inverseAssociator C D E).map f
[PROOFSTEP]
first
| cases f
| aesop_cat
[GOAL]
case inl.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✝¹ val✝ : D
f : inl (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))
          (inl (inr val✝¹))).hom ≫
      (associator C D E ⋙ inverseAssociator C D E).map f
[PROOFSTEP]
cases f
[GOAL]
case inl.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✝¹ val✝ : D
f : inl (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))
          (inl (inr val✝¹))).hom ≫
      (associator C D E ⋙ inverseAssociator C D E).map f
[PROOFSTEP]
aesop_cat
[GOAL]
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✝¹ : D
val✝ : E
f : inl (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))
          (inl (inr val✝¹))).hom ≫
      (associator C D E ⋙ inverseAssociator C D E).map f
[PROOFSTEP]
first
| cases f
| aesop_cat
[GOAL]
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✝¹ : D
val✝ : E
f : inl (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))
          (inl (inr val✝¹))).hom ≫
      (associator C D E ⋙ inverseAssociator C D E).map f
[PROOFSTEP]
cases f
[GOAL]
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✝¹ : E
val✝ : C
f : inr val✝¹ ⟶ inl (inl 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 (inl 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
[PROOFSTEP]
first
| cases f
| aesop_cat
[GOAL]
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✝¹ : E
val✝ : C
f : inr val✝¹ ⟶ inl (inl 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 (inl 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
[PROOFSTEP]
cases f
[GOAL]
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
[PROOFSTEP]
first
| cases f
| aesop_cat
[GOAL]
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
[PROOFSTEP]
cases f
[GOAL]
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
[PROOFSTEP]
first
| cases f
| aesop_cat
[GOAL]
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
[PROOFSTEP]
cases f
[GOAL]
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
[PROOFSTEP]
aesop_cat
[GOAL]
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
[PROOFSTEP]
rcases X with (_ | (_ | _))
[GOAL]
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✝)
[PROOFSTEP]
rfl
[GOAL]
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✝))
[PROOFSTEP]
rfl
[GOAL]
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✝))
[PROOFSTEP]
rfl
[GOAL]
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
[PROOFSTEP]
rintro (_ | (_ | _)) (_ | (_ | _)) f
[GOAL]
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
[PROOFSTEP]
first
| cases f
| aesop_cat
[GOAL]
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
[PROOFSTEP]
cases f
[GOAL]
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
[PROOFSTEP]
aesop_cat
[GOAL]
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
[PROOFSTEP]
first
| cases f
| aesop_cat
[GOAL]
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
[PROOFSTEP]
cases f
[GOAL]
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
[PROOFSTEP]
first
| cases f
| aesop_cat
[GOAL]
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
[PROOFSTEP]
cases f
[GOAL]
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
[PROOFSTEP]
first
| cases f
| aesop_cat
[GOAL]
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
[PROOFSTEP]
cases f
[GOAL]
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
[PROOFSTEP]
first
| cases f
| aesop_cat
[GOAL]
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
[PROOFSTEP]
cases f
[GOAL]
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
[PROOFSTEP]
aesop_cat
[GOAL]
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
[PROOFSTEP]
first
| cases f
| aesop_cat
[GOAL]
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
[PROOFSTEP]
cases f
[GOAL]
case inr.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✝¹ : E
val✝ : C
f : inr (inr 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 (inr val✝¹))).hom ≫
      (𝟭 (C ⊕ D ⊕ E)).map f
[PROOFSTEP]
first
| cases f
| aesop_cat
[GOAL]
case inr.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✝¹ : E
val✝ : C
f : inr (inr 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 (inr val✝¹))).hom ≫
      (𝟭 (C ⊕ D ⊕ E)).map f
[PROOFSTEP]
cases f
[GOAL]
case inr.inr.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✝¹ : E
val✝ : D
f : inr (inr 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 (inr val✝¹))).hom ≫
      (𝟭 (C ⊕ D ⊕ E)).map f
[PROOFSTEP]
first
| cases f
| aesop_cat
[GOAL]
case inr.inr.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✝¹ : E
val✝ : D
f : inr (inr 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 (inr val✝¹))).hom ≫
      (𝟭 (C ⊕ D ⊕ E)).map f
[PROOFSTEP]
cases f
[GOAL]
case inr.inr.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 (inr 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 (inr val✝¹))).hom ≫
      (𝟭 (C ⊕ D ⊕ E)).map f
[PROOFSTEP]
first
| cases f
| aesop_cat
[GOAL]
case inr.inr.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 (inr 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 (inr val✝¹))).hom ≫
      (𝟭 (C ⊕ D ⊕ E)).map f
[PROOFSTEP]
cases f
[GOAL]
case inr.inr.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 (inr 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 (inr val✝¹))).hom ≫
      (𝟭 (C ⊕ D ⊕ E)).map f
[PROOFSTEP]
aesop_cat
[GOAL]
C : Type u
inst✝² : Category.{v, u} C
D : Type u
inst✝¹ : Category.{v, u} D
E : Type u
inst✝ : Category.{v, u} E
⊢ IsEquivalence (associativity C D E).functor
[PROOFSTEP]
infer_instance
[GOAL]
C : Type u
inst✝² : Category.{v, u} C
D : Type u
inst✝¹ : Category.{v, u} D
E : Type u
inst✝ : Category.{v, u} E
⊢ IsEquivalence (associativity C D E).inverse
[PROOFSTEP]
infer_instance