Theorem: CategoryTheory.Limits.combineCocones_pt_map
File: Mathlib/CategoryTheory/Limits/FunctorCategory.lean

Proof steps:
state_before: C : Type u
inst✝³ : Category.{v, u} C
D : Type u'
inst✝² : Category.{v', u'} D
J : Type u₁
inst✝¹ : Category.{v₁, u₁} J
K : Type u₂
inst✝ : Category.{v₂, u₂} K
F : J ⥤ K ⥤ C
c : (k : K) → ColimitCocone (F.flip.obj k)
k : K
j : J
⊢ (c k).cocone.ι.app j ≫
      { obj := fun k => (c k).cocone.pt,
            map := fun {k₁ k₂} f =>
              (c k₁).isColimit.desc { pt := (c k₂).cocone.pt, ι := F.flip.map f ≫ (c k₂).cocone.ι } }.map
        (𝟙 k) =
    (c k).cocone.ι.app j ≫
      𝟙
        ({ obj := fun k => (c k).cocone.pt,
              map := fun {k₁ k₂} f =>
                (c k₁).isColimit.desc { pt := (c k₂).cocone.pt, ι := F.flip.map f ≫ (c k₂).cocone.ι } }.obj
          k)
state_after: C : Type u
inst✝³ : Category.{v, u} C
D : Type u'
inst✝² : Category.{v', u'} D
J : Type u₁
inst✝¹ : Category.{v₁, u₁} J
K : Type u₂
inst✝ : Category.{v₂, u₂} K
F : J ⥤ K ⥤ C
c : (k : K) → ColimitCocone (F.flip.obj k)
k : K
j : J
⊢ (c k).cocone.ι.app j ≫ (c k).isColimit.desc { pt := (c k).cocone.pt, ι := F.flip.map (𝟙 k) ≫ (c k).cocone.ι } =
    (c k).cocone.ι.app j ≫ 𝟙 (c k).cocone.pt
tactic: dsimp
state_before: C : Type u
inst✝³ : Category.{v, u} C
D : Type u'
inst✝² : Category.{v', u'} D
J : Type u₁
inst✝¹ : Category.{v₁, u₁} J
K : Type u₂
inst✝ : Category.{v₂, u₂} K
F : J ⥤ K ⥤ C
c : (k : K) → ColimitCocone (F.flip.obj k)
k : K
j : J
⊢ (c k).cocone.ι.app j ≫ (c k).isColimit.desc { pt := (c k).cocone.pt, ι := F.flip.map (𝟙 k) ≫ (c k).cocone.ι } =
    (c k).cocone.ι.app j ≫ 𝟙 (c k).cocone.pt
state_after: no goals
tactic: simp
state_before: C : Type u
inst✝³ : Category.{v, u} C
D : Type u'
inst✝² : Category.{v', u'} D
J : Type u₁
inst✝¹ : Category.{v₁, u₁} J
K : Type u₂
inst✝ : Category.{v₂, u₂} K
F : J ⥤ K ⥤ C
c : (k : K) → ColimitCocone (F.flip.obj k)
k₁ k₂ k₃ : K
f₁ : k₁ ⟶ k₂
f₂ : k₂ ⟶ k₃
j : J
⊢ (c k₁).cocone.ι.app j ≫
      { obj := fun k => (c k).cocone.pt,
            map := fun {k₁ k₂} f =>
              (c k₁).isColimit.desc { pt := (c k₂).cocone.pt, ι := F.flip.map f ≫ (c k₂).cocone.ι } }.map
        (f₁ ≫ f₂) =
    (c k₁).cocone.ι.app j ≫
      { obj := fun k => (c k).cocone.pt,
              map := fun {k₁ k₂} f =>
                (c k₁).isColimit.desc { pt := (c k₂).cocone.pt, ι := F.flip.map f ≫ (c k₂).cocone.ι } }.map
          f₁ ≫
        { obj := fun k => (c k).cocone.pt,
              map := fun {k₁ k₂} f =>
                (c k₁).isColimit.desc { pt := (c k₂).cocone.pt, ι := F.flip.map f ≫ (c k₂).cocone.ι } }.map
          f₂
state_after: no goals
tactic: simp
state_before: C : Type u
inst✝³ : Category.{v, u} C
D : Type u'
inst✝² : Category.{v', u'} D
J : Type u₁
inst✝¹ : Category.{v₁, u₁} J
K : Type u₂
inst✝ : Category.{v₂, u₂} K
F : J ⥤ K ⥤ C
c : (k : K) → ColimitCocone (F.flip.obj k)
j₁ j₂ : J
g : j₁ ⟶ j₂
⊢ F.map g ≫ (fun j => { app := fun k => (c k).cocone.ι.app j, naturality := ⋯ }) j₂ =
    (fun j => { app := fun k => (c k).cocone.ι.app j, naturality := ⋯ }) j₁ ≫
      ((const J).obj
            { obj := fun k => (c k).cocone.pt,
              map := fun {k₁ k₂} f =>
                (c k₁).isColimit.desc { pt := (c k₂).cocone.pt, ι := F.flip.map f ≫ (c k₂).cocone.ι },
              map_id := ⋯, map_comp := ⋯ }).map
        g
state_after: case w.h
C : Type u
inst✝³ : Category.{v, u} C
D : Type u'
inst✝² : Category.{v', u'} D
J : Type u₁
inst✝¹ : Category.{v₁, u₁} J
K : Type u₂
inst✝ : Category.{v₂, u₂} K
F : J ⥤ K ⥤ C
c : (k : K) → ColimitCocone (F.flip.obj k)
j₁ j₂ : J
g : j₁ ⟶ j₂
k : K
⊢ (F.map g ≫ (fun j => { app := fun k => (c k).cocone.ι.app j, naturality := ⋯ }) j₂).app k =
    ((fun j => { app := fun k => (c k).cocone.ι.app j, naturality := ⋯ }) j₁ ≫
          ((const J).obj
                { obj := fun k => (c k).cocone.pt,
                  map := fun {k₁ k₂} f =>
                    (c k₁).isColimit.desc { pt := (c k₂).cocone.pt, ι := F.flip.map f ≫ (c k₂).cocone.ι },
                  map_id := ⋯, map_comp := ⋯ }).map
            g).app
      k
tactic: ext k
state_before: case w.h
C : Type u
inst✝³ : Category.{v, u} C
D : Type u'
inst✝² : Category.{v', u'} D
J : Type u₁
inst✝¹ : Category.{v₁, u₁} J
K : Type u₂
inst✝ : Category.{v₂, u₂} K
F : J ⥤ K ⥤ C
c : (k : K) → ColimitCocone (F.flip.obj k)
j₁ j₂ : J
g : j₁ ⟶ j₂
k : K
⊢ (F.map g ≫ (fun j => { app := fun k => (c k).cocone.ι.app j, naturality := ⋯ }) j₂).app k =
    ((fun j => { app := fun k => (c k).cocone.ι.app j, naturality := ⋯ }) j₁ ≫
          ((const J).obj
                { obj := fun k => (c k).cocone.pt,
                  map := fun {k₁ k₂} f =>
                    (c k₁).isColimit.desc { pt := (c k₂).cocone.pt, ι := F.flip.map f ≫ (c k₂).cocone.ι },
                  map_id := ⋯, map_comp := ⋯ }).map
            g).app
      k
state_after: no goals
tactic: exact (c k).cocone.ι.naturality g