Theorem: CategoryTheory.Limits.combineCones_π_app_app
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) → LimitCone (F.flip.obj k)
k : K
j : J
⊢ { obj := fun k => (c k).cone.pt,
            map := fun {k₁ k₂} f =>
              (c k₂).isLimit.lift { pt := (c k₁).cone.pt, π := (c k₁).cone.π ≫ F.flip.map f } }.map
        (𝟙 k) ≫
      (c k).cone.π.app j =
    𝟙
        ({ obj := fun k => (c k).cone.pt,
              map := fun {k₁ k₂} f =>
                (c k₂).isLimit.lift { pt := (c k₁).cone.pt, π := (c k₁).cone.π ≫ F.flip.map f } }.obj
          k) ≫
      (c k).cone.π.app j
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) → LimitCone (F.flip.obj k)
k : K
j : J
⊢ (c k).isLimit.lift { pt := (c k).cone.pt, π := (c k).cone.π ≫ F.flip.map (𝟙 k) } ≫ (c k).cone.π.app j =
    𝟙 (c k).cone.pt ≫ (c k).cone.π.app j
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) → LimitCone (F.flip.obj k)
k : K
j : J
⊢ (c k).isLimit.lift { pt := (c k).cone.pt, π := (c k).cone.π ≫ F.flip.map (𝟙 k) } ≫ (c k).cone.π.app j =
    𝟙 (c k).cone.pt ≫ (c k).cone.π.app j
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) → LimitCone (F.flip.obj k)
k₁ k₂ k₃ : K
f₁ : k₁ ⟶ k₂
f₂ : k₂ ⟶ k₃
j : J
⊢ { obj := fun k => (c k).cone.pt,
            map := fun {k₁ k₂} f =>
              (c k₂).isLimit.lift { pt := (c k₁).cone.pt, π := (c k₁).cone.π ≫ F.flip.map f } }.map
        (f₁ ≫ f₂) ≫
      (c k₃).cone.π.app j =
    ({ obj := fun k => (c k).cone.pt,
              map := fun {k₁ k₂} f =>
                (c k₂).isLimit.lift { pt := (c k₁).cone.pt, π := (c k₁).cone.π ≫ F.flip.map f } }.map
          f₁ ≫
        { obj := fun k => (c k).cone.pt,
              map := fun {k₁ k₂} f =>
                (c k₂).isLimit.lift { pt := (c k₁).cone.pt, π := (c k₁).cone.π ≫ F.flip.map f } }.map
          f₂) ≫
      (c k₃).cone.π.app j
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) → LimitCone (F.flip.obj k)
j₁ j₂ : J
g : j₁ ⟶ j₂
⊢ ((const J).obj
            { obj := fun k => (c k).cone.pt,
              map := fun {k₁ k₂} f => (c k₂).isLimit.lift { pt := (c k₁).cone.pt, π := (c k₁).cone.π ≫ F.flip.map f },
              map_id := ⋯, map_comp := ⋯ }).map
        g ≫
      (fun j => { app := fun k => (c k).cone.π.app j, naturality := ⋯ }) j₂ =
    (fun j => { app := fun k => (c k).cone.π.app j, naturality := ⋯ }) j₁ ≫ F.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) → LimitCone (F.flip.obj k)
j₁ j₂ : J
g : j₁ ⟶ j₂
k : K
⊢ (((const J).obj
                { obj := fun k => (c k).cone.pt,
                  map := fun {k₁ k₂} f =>
                    (c k₂).isLimit.lift { pt := (c k₁).cone.pt, π := (c k₁).cone.π ≫ F.flip.map f },
                  map_id := ⋯, map_comp := ⋯ }).map
            g ≫
          (fun j => { app := fun k => (c k).cone.π.app j, naturality := ⋯ }) j₂).app
      k =
    ((fun j => { app := fun k => (c k).cone.π.app j, naturality := ⋯ }) j₁ ≫ F.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) → LimitCone (F.flip.obj k)
j₁ j₂ : J
g : j₁ ⟶ j₂
k : K
⊢ (((const J).obj
                { obj := fun k => (c k).cone.pt,
                  map := fun {k₁ k₂} f =>
                    (c k₂).isLimit.lift { pt := (c k₁).cone.pt, π := (c k₁).cone.π ≫ F.flip.map f },
                  map_id := ⋯, map_comp := ⋯ }).map
            g ≫
          (fun j => { app := fun k => (c k).cone.π.app j, naturality := ⋯ }) j₂).app
      k =
    ((fun j => { app := fun k => (c k).cone.π.app j, naturality := ⋯ }) j₁ ≫ F.map g).app k
state_after: no goals
tactic: exact (c k).cone.π.naturality g