Theorem: CategoryTheory.evaluationUncurried_map
File: Mathlib/CategoryTheory/Products/Basic.lean

Proof steps:
state_before: C : Type u₁
inst✝¹ : Category.{v₁, u₁} C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
X Y Z : C × (C ⥤ D)
f : X ⟶ Y
g : Y ⟶ Z
⊢ { obj := fun p => p.2.obj p.1, map := fun {x y} f => x.2.map f.1 ≫ f.2.app y.1 }.map (f ≫ g) =
    { obj := fun p => p.2.obj p.1, map := fun {x y} f => x.2.map f.1 ≫ f.2.app y.1 }.map f ≫
      { obj := fun p => p.2.obj p.1, map := fun {x y} f => x.2.map f.1 ≫ f.2.app y.1 }.map g
state_after: case mk
C : Type u₁
inst✝¹ : Category.{v₁, u₁} C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
X Y Z : C × (C ⥤ D)
f : X ⟶ Y
fst✝ : Y.1 ⟶ Z.1
snd✝ : Y.2 ⟶ Z.2
⊢ { obj := fun p => p.2.obj p.1, map := fun {x y} f => x.2.map f.1 ≫ f.2.app y.1 }.map (f ≫ (fst✝, snd✝)) =
    { obj := fun p => p.2.obj p.1, map := fun {x y} f => x.2.map f.1 ≫ f.2.app y.1 }.map f ≫
      { obj := fun p => p.2.obj p.1, map := fun {x y} f => x.2.map f.1 ≫ f.2.app y.1 }.map (fst✝, snd✝)
tactic: cases g
state_before: case mk
C : Type u₁
inst✝¹ : Category.{v₁, u₁} C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
X Y Z : C × (C ⥤ D)
f : X ⟶ Y
fst✝ : Y.1 ⟶ Z.1
snd✝ : Y.2 ⟶ Z.2
⊢ { obj := fun p => p.2.obj p.1, map := fun {x y} f => x.2.map f.1 ≫ f.2.app y.1 }.map (f ≫ (fst✝, snd✝)) =
    { obj := fun p => p.2.obj p.1, map := fun {x y} f => x.2.map f.1 ≫ f.2.app y.1 }.map f ≫
      { obj := fun p => p.2.obj p.1, map := fun {x y} f => x.2.map f.1 ≫ f.2.app y.1 }.map (fst✝, snd✝)
state_after: case mk.mk
C : Type u₁
inst✝¹ : Category.{v₁, u₁} C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
X Y Z : C × (C ⥤ D)
fst✝¹ : Y.1 ⟶ Z.1
snd✝¹ : Y.2 ⟶ Z.2
fst✝ : X.1 ⟶ Y.1
snd✝ : X.2 ⟶ Y.2
⊢ { obj := fun p => p.2.obj p.1, map := fun {x y} f => x.2.map f.1 ≫ f.2.app y.1 }.map ((fst✝, snd✝) ≫ (fst✝¹, snd✝¹)) =
    { obj := fun p => p.2.obj p.1, map := fun {x y} f => x.2.map f.1 ≫ f.2.app y.1 }.map (fst✝, snd✝) ≫
      { obj := fun p => p.2.obj p.1, map := fun {x y} f => x.2.map f.1 ≫ f.2.app y.1 }.map (fst✝¹, snd✝¹)
tactic: cases f
state_before: case mk.mk
C : Type u₁
inst✝¹ : Category.{v₁, u₁} C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
X Y Z : C × (C ⥤ D)
fst✝¹ : Y.1 ⟶ Z.1
snd✝¹ : Y.2 ⟶ Z.2
fst✝ : X.1 ⟶ Y.1
snd✝ : X.2 ⟶ Y.2
⊢ { obj := fun p => p.2.obj p.1, map := fun {x y} f => x.2.map f.1 ≫ f.2.app y.1 }.map ((fst✝, snd✝) ≫ (fst✝¹, snd✝¹)) =
    { obj := fun p => p.2.obj p.1, map := fun {x y} f => x.2.map f.1 ≫ f.2.app y.1 }.map (fst✝, snd✝) ≫
      { obj := fun p => p.2.obj p.1, map := fun {x y} f => x.2.map f.1 ≫ f.2.app y.1 }.map (fst✝¹, snd✝¹)
state_after: case mk.mk.mk
C : Type u₁
inst✝¹ : Category.{v₁, u₁} C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
X Y : C × (C ⥤ D)
fst✝² : X.1 ⟶ Y.1
snd✝² : X.2 ⟶ Y.2
fst✝¹ : C
snd✝¹ : C ⥤ D
fst✝ : Y.1 ⟶ (fst✝¹, snd✝¹).1
snd✝ : Y.2 ⟶ (fst✝¹, snd✝¹).2
⊢ { obj := fun p => p.2.obj p.1, map := fun {x y} f => x.2.map f.1 ≫ f.2.app y.1 }.map ((fst✝², snd✝²) ≫ (fst✝, snd✝)) =
    { obj := fun p => p.2.obj p.1, map := fun {x y} f => x.2.map f.1 ≫ f.2.app y.1 }.map (fst✝², snd✝²) ≫
      { obj := fun p => p.2.obj p.1, map := fun {x y} f => x.2.map f.1 ≫ f.2.app y.1 }.map (fst✝, snd✝)
tactic: cases Z
state_before: case mk.mk.mk
C : Type u₁
inst✝¹ : Category.{v₁, u₁} C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
X Y : C × (C ⥤ D)
fst✝² : X.1 ⟶ Y.1
snd✝² : X.2 ⟶ Y.2
fst✝¹ : C
snd✝¹ : C ⥤ D
fst✝ : Y.1 ⟶ (fst✝¹, snd✝¹).1
snd✝ : Y.2 ⟶ (fst✝¹, snd✝¹).2
⊢ { obj := fun p => p.2.obj p.1, map := fun {x y} f => x.2.map f.1 ≫ f.2.app y.1 }.map ((fst✝², snd✝²) ≫ (fst✝, snd✝)) =
    { obj := fun p => p.2.obj p.1, map := fun {x y} f => x.2.map f.1 ≫ f.2.app y.1 }.map (fst✝², snd✝²) ≫
      { obj := fun p => p.2.obj p.1, map := fun {x y} f => x.2.map f.1 ≫ f.2.app y.1 }.map (fst✝, snd✝)
state_after: case mk.mk.mk.mk
C : Type u₁
inst✝¹ : Category.{v₁, u₁} C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
X : C × (C ⥤ D)
fst✝³ : C
snd✝³ : C ⥤ D
fst✝² : C
snd✝² : C ⥤ D
fst✝¹ : X.1 ⟶ (fst✝², snd✝²).1
snd✝¹ : X.2 ⟶ (fst✝², snd✝²).2
fst✝ : (fst✝², snd✝²).1 ⟶ (fst✝³, snd✝³).1
snd✝ : (fst✝², snd✝²).2 ⟶ (fst✝³, snd✝³).2
⊢ { obj := fun p => p.2.obj p.1, map := fun {x y} f => x.2.map f.1 ≫ f.2.app y.1 }.map ((fst✝¹, snd✝¹) ≫ (fst✝, snd✝)) =
    { obj := fun p => p.2.obj p.1, map := fun {x y} f => x.2.map f.1 ≫ f.2.app y.1 }.map (fst✝¹, snd✝¹) ≫
      { obj := fun p => p.2.obj p.1, map := fun {x y} f => x.2.map f.1 ≫ f.2.app y.1 }.map (fst✝, snd✝)
tactic: cases Y
state_before: case mk.mk.mk.mk
C : Type u₁
inst✝¹ : Category.{v₁, u₁} C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
X : C × (C ⥤ D)
fst✝³ : C
snd✝³ : C ⥤ D
fst✝² : C
snd✝² : C ⥤ D
fst✝¹ : X.1 ⟶ (fst✝², snd✝²).1
snd✝¹ : X.2 ⟶ (fst✝², snd✝²).2
fst✝ : (fst✝², snd✝²).1 ⟶ (fst✝³, snd✝³).1
snd✝ : (fst✝², snd✝²).2 ⟶ (fst✝³, snd✝³).2
⊢ { obj := fun p => p.2.obj p.1, map := fun {x y} f => x.2.map f.1 ≫ f.2.app y.1 }.map ((fst✝¹, snd✝¹) ≫ (fst✝, snd✝)) =
    { obj := fun p => p.2.obj p.1, map := fun {x y} f => x.2.map f.1 ≫ f.2.app y.1 }.map (fst✝¹, snd✝¹) ≫
      { obj := fun p => p.2.obj p.1, map := fun {x y} f => x.2.map f.1 ≫ f.2.app y.1 }.map (fst✝, snd✝)
state_after: case mk.mk.mk.mk.mk
C : Type u₁
inst✝¹ : Category.{v₁, u₁} C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
fst✝⁴ : C
snd✝⁴ : C ⥤ D
fst✝³ : C
snd✝³ : C ⥤ D
fst✝² : (fst✝³, snd✝³).1 ⟶ (fst✝⁴, snd✝⁴).1
snd✝² : (fst✝³, snd✝³).2 ⟶ (fst✝⁴, snd✝⁴).2
fst✝¹ : C
snd✝¹ : C ⥤ D
fst✝ : (fst✝¹, snd✝¹).1 ⟶ (fst✝³, snd✝³).1
snd✝ : (fst✝¹, snd✝¹).2 ⟶ (fst✝³, snd✝³).2
⊢ { obj := fun p => p.2.obj p.1, map := fun {x y} f => x.2.map f.1 ≫ f.2.app y.1 }.map ((fst✝, snd✝) ≫ (fst✝², snd✝²)) =
    { obj := fun p => p.2.obj p.1, map := fun {x y} f => x.2.map f.1 ≫ f.2.app y.1 }.map (fst✝, snd✝) ≫
      { obj := fun p => p.2.obj p.1, map := fun {x y} f => x.2.map f.1 ≫ f.2.app y.1 }.map (fst✝², snd✝²)
tactic: cases X
state_before: case mk.mk.mk.mk.mk
C : Type u₁
inst✝¹ : Category.{v₁, u₁} C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
fst✝⁴ : C
snd✝⁴ : C ⥤ D
fst✝³ : C
snd✝³ : C ⥤ D
fst✝² : (fst✝³, snd✝³).1 ⟶ (fst✝⁴, snd✝⁴).1
snd✝² : (fst✝³, snd✝³).2 ⟶ (fst✝⁴, snd✝⁴).2
fst✝¹ : C
snd✝¹ : C ⥤ D
fst✝ : (fst✝¹, snd✝¹).1 ⟶ (fst✝³, snd✝³).1
snd✝ : (fst✝¹, snd✝¹).2 ⟶ (fst✝³, snd✝³).2
⊢ { obj := fun p => p.2.obj p.1, map := fun {x y} f => x.2.map f.1 ≫ f.2.app y.1 }.map ((fst✝, snd✝) ≫ (fst✝², snd✝²)) =
    { obj := fun p => p.2.obj p.1, map := fun {x y} f => x.2.map f.1 ≫ f.2.app y.1 }.map (fst✝, snd✝) ≫
      { obj := fun p => p.2.obj p.1, map := fun {x y} f => x.2.map f.1 ≫ f.2.app y.1 }.map (fst✝², snd✝²)
state_after: case mk.mk.mk.mk.mk
C : Type u₁
inst✝¹ : Category.{v₁, u₁} C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
fst✝⁴ : C
snd✝⁴ : C ⥤ D
fst✝³ : C
snd✝³ : C ⥤ D
fst✝² : (fst✝³, snd✝³).1 ⟶ (fst✝⁴, snd✝⁴).1
snd✝² : (fst✝³, snd✝³).2 ⟶ (fst✝⁴, snd✝⁴).2
fst✝¹ : C
snd✝¹ : C ⥤ D
fst✝ : (fst✝¹, snd✝¹).1 ⟶ (fst✝³, snd✝³).1
snd✝ : (fst✝¹, snd✝¹).2 ⟶ (fst✝³, snd✝³).2
⊢ snd✝¹.map fst✝ ≫ snd✝¹.map fst✝² ≫ snd✝.app fst✝⁴ ≫ snd✝².app fst✝⁴ =
    snd✝¹.map fst✝ ≫ snd✝.app fst✝³ ≫ snd✝³.map fst✝² ≫ snd✝².app fst✝⁴
tactic: simp only [prod_comp, NatTrans.comp_app, Functor.map_comp, Category.assoc]
state_before: case mk.mk.mk.mk.mk
C : Type u₁
inst✝¹ : Category.{v₁, u₁} C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
fst✝⁴ : C
snd✝⁴ : C ⥤ D
fst✝³ : C
snd✝³ : C ⥤ D
fst✝² : (fst✝³, snd✝³).1 ⟶ (fst✝⁴, snd✝⁴).1
snd✝² : (fst✝³, snd✝³).2 ⟶ (fst✝⁴, snd✝⁴).2
fst✝¹ : C
snd✝¹ : C ⥤ D
fst✝ : (fst✝¹, snd✝¹).1 ⟶ (fst✝³, snd✝³).1
snd✝ : (fst✝¹, snd✝¹).2 ⟶ (fst✝³, snd✝³).2
⊢ snd✝¹.map fst✝ ≫ snd✝¹.map fst✝² ≫ snd✝.app fst✝⁴ ≫ snd✝².app fst✝⁴ =
    snd✝¹.map fst✝ ≫ snd✝.app fst✝³ ≫ snd✝³.map fst✝² ≫ snd✝².app fst✝⁴
state_after: no goals
tactic: rw [← NatTrans.comp_app, NatTrans.naturality, NatTrans.comp_app, Category.assoc,
      NatTrans.naturality]