Module: Mathlib.CategoryTheory.Join.Basic

Goal state before:
pp: C : Type u₁
inst✝¹ : Category.{v₁, u₁} C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
a b c d : C ⋆ D
f : a.Hom b
g : b.Hom c
h : c.Hom d
⊢ comp (comp f g) h = comp f (comp g h)

Tactic:
cases a <;>
    cases b <;>
    cases c <;>
    cases d <;>
    simp only [Hom, comp, Category.assoc]

Goal state after:
case left.left.right.left
C : Type u₁
inst✝¹ : Category.{v₁, u₁} C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
a✝³ a✝² : C
f : (left a✝³).Hom (left a✝²)
a✝¹ : D
g : (left a✝²).Hom (right a✝¹)
a✝ : C
h : (right a✝¹).Hom (left a✝)
⊢ (match left a✝³, right a✝¹, left a✝, PUnit.unit, h with
    | left _x, left _y, left _z, f, g => { down := f.down ≫ g.down }
    | left _x, left _y, right _z, x, x_1 => PUnit.unit
    | left _x, right _y, right _z, x, x_1 => PUnit.unit
    | right _x, right _y, right _z, f, g => { down := f.down ≫ g.down }) =
    {
      down :=
        f.down ≫
          (match left a✝², right a✝¹, left a✝, g, h with
            | left _x, left _y, left _z, f, g => { down := f.down ≫ g.down }
            | left _x, left _y, right _z, x, x_1 => PUnit.unit
            | left _x, right _y, right _z, x, x_1 => PUnit.unit
            | right _x, right _y, right _z, f, g => { down := f.down ≫ g.down }).down }

case left.right.left.left
C : Type u₁
inst✝¹ : Category.{v₁, u₁} C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
a✝³ : C
a✝² : D
f : (left a✝³).Hom (right a✝²)
a✝¹ : C
g : (right a✝²).Hom (left a✝¹)
a✝ : C
h : (left a✝¹).Hom (left a✝)
⊢ {
      down :=
        (match left a✝³, right a✝², left a✝¹, f, g with
            | left _x, left _y, left _z, f, g => { down := f.down ≫ g.down }
            | left _x, left _y, right _z, x, x_1 => PUnit.unit
            | left _x, right _y, right _z, x, x_1 => PUnit.unit
            | right _x, right _y, right _z, f, g => { down := f.down ≫ g.down }).down ≫
          h.down } =
    match left a✝³, right a✝², left a✝, f,
      match right a✝², left a✝¹, left a✝, g, h with
      | left _x, left _y, left _z, f, g => { down := f.down ≫ g.down }
      | left _x, left _y, right _z, x, x_1 => PUnit.unit
      | left _x, right _y, right _z, x, x_1 => PUnit.unit
      | right _x, right _y, right _z, f, g => { down := f.down ≫ g.down } with
    | left _x, left _y, left _z, f, g => { down := f.down ≫ g.down }
    | left _x, left _y, right _z, x, x_1 => PUnit.unit
    | left _x, right _y, right _z, x, x_1 => PUnit.unit
    | right _x, right _y, right _z, f, g => { down := f.down ≫ g.down }

case left.right.right.left
C : Type u₁
inst✝¹ : Category.{v₁, u₁} C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
a✝³ : C
a✝² : D
f : (left a✝³).Hom (right a✝²)
a✝¹ : D
g : (right a✝²).Hom (right a✝¹)
a✝ : C
h : (right a✝¹).Hom (left a✝)
⊢ (match left a✝³, right a✝¹, left a✝, PUnit.unit, h with
    | left _x, left _y, left _z, f, g => { down := f.down ≫ g.down }
    | left _x, left _y, right _z, x, x_1 => PUnit.unit
    | left _x, right _y, right _z, x, x_1 => PUnit.unit
    | right _x, right _y, right _z, f, g => { down := f.down ≫ g.down }) =
    match left a✝³, right a✝², left a✝, f,
      match right a✝², right a✝¹, left a✝, g, h with
      | left _x, left _y, left _z, f, g => { down := f.down ≫ g.down }
      | left _x, left _y, right _z, x, x_1 => PUnit.unit
      | left _x, right _y, right _z, x, x_1 => PUnit.unit
      | right _x, right _y, right _z, f, g => { down := f.down ≫ g.down } with
    | left _x, left _y, left _z, f, g => { down := f.down ≫ g.down }
    | left _x, left _y, right _z, x, x_1 => PUnit.unit
    | left _x, right _y, right _z, x, x_1 => PUnit.unit
    | right _x, right _y, right _z, f, g => { down := f.down ≫ g.down }

case right.left.left.left
C : Type u₁
inst✝¹ : Category.{v₁, u₁} C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
a✝³ : D
a✝² : C
f : (right a✝³).Hom (left a✝²)
a✝¹ : C
g : (left a✝²).Hom (left a✝¹)
a✝ : C
h : (left a✝¹).Hom (left a✝)
⊢ (match right a✝³, left a✝¹, left a✝,
      match right a✝³, left a✝², left a✝¹, f, g with
      | left _x, left _y, left _z, f, g => { down := f.down ≫ g.down }
      | left _x, left _y, right _z, x, x_1 => PUnit.unit
      | left _x, right _y, right _z, x, x_1 => PUnit.unit
      | right _x, right _y, right _z, f, g => { down := f.down ≫ g.down },
      h with
    | left _x, left _y, left _z, f, g => { down := f.down ≫ g.down }
    | left _x, left _y, right _z, x, x_1 => PUnit.unit
    | left _x, right _y, right _z, x, x_1 => PUnit.unit
    | right _x, right _y, right _z, f, g => { down := f.down ≫ g.down }) =
    match right a✝³, left a✝², left a✝, f, { down := g.down ≫ h.down } with
    | left _x, left _y, left _z, f, g => { down := f.down ≫ g.down }
    | left _x, left _y, right _z, x, x_1 => PUnit.unit
    | left _x, right _y, right _z, x, x_1 => PUnit.unit
    | right _x, right _y, right _z, f, g => { down := f.down ≫ g.down }

case right.left.left.right
C : Type u₁
inst✝¹ : Category.{v₁, u₁} C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
a✝³ : D
a✝² : C
f : (right a✝³).Hom (left a✝²)
a✝¹ : C
g : (left a✝²).Hom (left a✝¹)
a✝ : D
h : (left a✝¹).Hom (right a✝)
⊢ (match right a✝³, left a✝¹, right a✝,
      match right a✝³, left a✝², left a✝¹, f, g with
      | left _x, left _y, left _z, f, g => { down := f.down ≫ g.down }
      | left _x, left _y, right _z, x, x_1 => PUnit.unit
      | left _x, right _y, right _z, x, x_1 => PUnit.unit
      | right _x, right _y, right _z, f, g => { down := f.down ≫ g.down },
      h with
    | left _x, left _y, left _z, f, g => { down := f.down ≫ g.down }
    | left _x, left _y, right _z, x, x_1 => PUnit.unit
    | left _x, right _y, right _z, x, x_1 => PUnit.unit
    | right _x, right _y, right _z, f, g => { down := f.down ≫ g.down }) =
    match right a✝³, left a✝², right a✝, f, PUnit.unit with
    | left _x, left _y, left _z, f, g => { down := f.down ≫ g.down }
    | left _x, left _y, right _z, x, x_1 => PUnit.unit
    | left _x, right _y, right _z, x, x_1 => PUnit.unit
    | right _x, right _y, right _z, f, g => { down := f.down ≫ g.down }

case right.left.right.left
C : Type u₁
inst✝¹ : Category.{v₁, u₁} C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
a✝³ : D
a✝² : C
f : (right a✝³).Hom (left a✝²)
a✝¹ : D
g : (left a✝²).Hom (right a✝¹)
a✝ : C
h : (right a✝¹).Hom (left a✝)
⊢ (match right a✝³, right a✝¹, left a✝,
      match right a✝³, left a✝², right a✝¹, f, g with
      | left _x, left _y, left _z, f, g => { down := f.down ≫ g.down }
      | left _x, left _y, right _z, x, x_1 => PUnit.unit
      | left _x, right _y, right _z, x, x_1 => PUnit.unit
      | right _x, right _y, right _z, f, g => { down := f.down ≫ g.down },
      h with
    | left _x, left _y, left _z, f, g => { down := f.down ≫ g.down }
    | left _x, left _y, right _z, x, x_1 => PUnit.unit
    | left _x, right _y, right _z, x, x_1 => PUnit.unit
    | right _x, right _y, right _z, f, g => { down := f.down ≫ g.down }) =
    match right a✝³, left a✝², left a✝, f,
      match left a✝², right a✝¹, left a✝, g, h with
      | left _x, left _y, left _z, f, g => { down := f.down ≫ g.down }
      | left _x, left _y, right _z, x, x_1 => PUnit.unit
      | left _x, right _y, right _z, x, x_1 => PUnit.unit
      | right _x, right _y, right _z, f, g => { down := f.down ≫ g.down } with
    | left _x, left _y, left _z, f, g => { down := f.down ≫ g.down }
    | left _x, left _y, right _z, x, x_1 => PUnit.unit
    | left _x, right _y, right _z, x, x_1 => PUnit.unit
    | right _x, right _y, right _z, f, g => { down := f.down ≫ g.down }

case right.left.right.right
C : Type u₁
inst✝¹ : Category.{v₁, u₁} C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
a✝³ : D
a✝² : C
f : (right a✝³).Hom (left a✝²)
a✝¹ : D
g : (left a✝²).Hom (right a✝¹)
a✝ : D
h : (right a✝¹).Hom (right a✝)
⊢ {
      down :=
        (match right a✝³, left a✝², right a✝¹, f, g with
            | left _x, left _y, left _z, f, g => { down := f.down ≫ g.down }
            | left _x, left _y, right _z, x, x_1 => PUnit.unit
            | left _x, right _y, right _z, x, x_1 => PUnit.unit
            | right _x, right _y, right _z, f, g => { down := f.down ≫ g.down }).down ≫
          h.down } =
    match right a✝³, left a✝², right a✝, f, PUnit.unit with
    | left _x, left _y, left _z, f, g => { down := f.down ≫ g.down }
    | left _x, left _y, right _z, x, x_1 => PUnit.unit
    | left _x, right _y, right _z, x, x_1 => PUnit.unit
    | right _x, right _y, right _z, f, g => { down := f.down ≫ g.down }

case right.right.left.left
C : Type u₁
inst✝¹ : Category.{v₁, u₁} C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
a✝³ a✝² : D
f : (right a✝³).Hom (right a✝²)
a✝¹ : C
g : (right a✝²).Hom (left a✝¹)
a✝ : C
h : (left a✝¹).Hom (left a✝)
⊢ (match right a✝³, left a✝¹, left a✝,
      match right a✝³, right a✝², left a✝¹, f, g with
      | left _x, left _y, left _z, f, g => { down := f.down ≫ g.down }
      | left _x, left _y, right _z, x, x_1 => PUnit.unit
      | left _x, right _y, right _z, x, x_1 => PUnit.unit
      | right _x, right _y, right _z, f, g => { down := f.down ≫ g.down },
      h with
    | left _x, left _y, left _z, f, g => { down := f.down ≫ g.down }
    | left _x, left _y, right _z, x, x_1 => PUnit.unit
    | left _x, right _y, right _z, x, x_1 => PUnit.unit
    | right _x, right _y, right _z, f, g => { down := f.down ≫ g.down }) =
    match right a✝³, right a✝², left a✝, f,
      match right a✝², left a✝¹, left a✝, g, h with
      | left _x, left _y, left _z, f, g => { down := f.down ≫ g.down }
      | left _x, left _y, right _z, x, x_1 => PUnit.unit
      | left _x, right _y, right _z, x, x_1 => PUnit.unit
      | right _x, right _y, right _z, f, g => { down := f.down ≫ g.down } with
    | left _x, left _y, left _z, f, g => { down := f.down ≫ g.down }
    | left _x, left _y, right _z, x, x_1 => PUnit.unit
    | left _x, right _y, right _z, x, x_1 => PUnit.unit
    | right _x, right _y, right _z, f, g => { down := f.down ≫ g.down }

case right.right.left.right
C : Type u₁
inst✝¹ : Category.{v₁, u₁} C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
a✝³ a✝² : D
f : (right a✝³).Hom (right a✝²)
a✝¹ : C
g : (right a✝²).Hom (left a✝¹)
a✝ : D
h : (left a✝¹).Hom (right a✝)
⊢ (match right a✝³, left a✝¹, right a✝,
      match right a✝³, right a✝², left a✝¹, f, g with
      | left _x, left _y, left _z, f, g => { down := f.down ≫ g.down }
      | left _x, left _y, right _z, x, x_1 => PUnit.unit
      | left _x, right _y, right _z, x, x_1 => PUnit.unit
      | right _x, right _y, right _z, f, g => { down := f.down ≫ g.down },
      h with
    | left _x, left _y, left _z, f, g => { down := f.down ≫ g.down }
    | left _x, left _y, right _z, x, x_1 => PUnit.unit
    | left _x, right _y, right _z, x, x_1 => PUnit.unit
    | right _x, right _y, right _z, f, g => { down := f.down ≫ g.down }) =
    {
      down :=
        f.down ≫
          (match right a✝², left a✝¹, right a✝, g, h with
            | left _x, left _y, left _z, f, g => { down := f.down ≫ g.down }
            | left _x, left _y, right _z, x, x_1 => PUnit.unit
            | left _x, right _y, right _z, x, x_1 => PUnit.unit
            | right _x, right _y, right _z, f, g => { down := f.down ≫ g.down }).down }

case right.right.right.left
C : Type u₁
inst✝¹ : Category.{v₁, u₁} C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
a✝³ a✝² : D
f : (right a✝³).Hom (right a✝²)
a✝¹ : D
g : (right a✝²).Hom (right a✝¹)
a✝ : C
h : (right a✝¹).Hom (left a✝)
⊢ (match right a✝³, right a✝¹, left a✝, { down := f.down ≫ g.down }, h with
    | left _x, left _y, left _z, f, g => { down := f.down ≫ g.down }
    | left _x, left _y, right _z, x, x_1 => PUnit.unit
    | left _x, right _y, right _z, x, x_1 => PUnit.unit
    | right _x, right _y, right _z, f, g => { down := f.down ≫ g.down }) =
    match right a✝³, right a✝², left a✝, f,
      match right a✝², right a✝¹, left a✝, g, h with
      | left _x, left _y, left _z, f, g => { down := f.down ≫ g.down }
      | left _x, left _y, right _z, x, x_1 => PUnit.unit
      | left _x, right _y, right _z, x, x_1 => PUnit.unit
      | right _x, right _y, right _z, f, g => { down := f.down ≫ g.down } with
    | left _x, left _y, left _z, f, g => { down := f.down ≫ g.down }
    | left _x, left _y, right _z, x, x_1 => PUnit.unit
    | left _x, right _y, right _z, x, x_1 => PUnit.unit
    | right _x, right _y, right _z, f, g => { down := f.down ≫ g.down }