Theorem: CategoryTheory.Limits.ι_colimitLimitToLimitColimit_π_apply
File: Mathlib/CategoryTheory/Limits/ColimitLimit.lean

tactic: dsimp [colimitLimitToLimitColimit]
state_before: J : Type u₁
K : Type u₂
inst✝⁶ : Category.{v₁, u₁} J
inst✝⁵ : Category.{v₂, u₂} K
C : Type u
inst✝⁴ : Category.{v, u} C
F✝ : J × K ⥤ C
inst✝³ : HasLimitsOfShape J C
inst✝² : HasColimitsOfShape K C
inst✝¹ : Small.{v, u₁} J
inst✝ : Small.{v, u₂} K
F : J × K ⥤ Type v
j : J
k : K
f : (curry.obj (Prod.swap K J ⋙ F) ⋙ lim).obj k
⊢ limit.π (curry.obj F ⋙ colim) j (colimitLimitToLimitColimit F (colimit.ι (curry.obj (Prod.swap K J ⋙ F) ⋙ lim) k f)) =
    colimit.ι ((curry.obj F).obj j) k (limit.π ((curry.obj (Prod.swap K J ⋙ F)).obj k) j f)
state_after: J : Type u₁
K : Type u₂
inst✝⁶ : Category.{v₁, u₁} J
inst✝⁵ : Category.{v₂, u₂} K
C : Type u
inst✝⁴ : Category.{v, u} C
F✝ : J × K ⥤ C
inst✝³ : HasLimitsOfShape J C
inst✝² : HasColimitsOfShape K C
inst✝¹ : Small.{v, u₁} J
inst✝ : Small.{v, u₂} K
F : J × K ⥤ Type v
j : J
k : K
f : (curry.obj (Prod.swap K J ⋙ F) ⋙ lim).obj k
⊢ limit.π (curry.obj F ⋙ colim) j
      (limit.lift (curry.obj F ⋙ colim)
        { pt := colimit (curry.obj (Prod.swap K J ⋙ F) ⋙ lim),
          π :=
            {
              app := fun j =>
                colimit.desc (curry.obj (Prod.swap K J ⋙ F) ⋙ lim)
                  { pt := colimit ((curry.obj F).obj j),
                    ι :=
                      {
                        app := fun k =>
                          limit.π ((curry.obj (Prod.swap K J ⋙ F)).obj k) j ≫ colimit.ι ((curry.obj F).obj j) k,
                        naturality := ⋯ } },
              naturality := ⋯ } }
        (colimit.ι (curry.obj (Prod.swap K J ⋙ F) ⋙ lim) k f)) =
    colimit.ι ((curry.obj F).obj j) k (limit.π ((curry.obj (Prod.swap K J ⋙ F)).obj k) j f)

tactic: rw [Types.Limit.lift_π_apply]
state_before: J : Type u₁
K : Type u₂
inst✝⁶ : Category.{v₁, u₁} J
inst✝⁵ : Category.{v₂, u₂} K
C : Type u
inst✝⁴ : Category.{v, u} C
F✝ : J × K ⥤ C
inst✝³ : HasLimitsOfShape J C
inst✝² : HasColimitsOfShape K C
inst✝¹ : Small.{v, u₁} J
inst✝ : Small.{v, u₂} K
F : J × K ⥤ Type v
j : J
k : K
f : (curry.obj (Prod.swap K J ⋙ F) ⋙ lim).obj k
⊢ limit.π (curry.obj F ⋙ colim) j
      (limit.lift (curry.obj F ⋙ colim)
        { pt := colimit (curry.obj (Prod.swap K J ⋙ F) ⋙ lim),
          π :=
            {
              app := fun j =>
                colimit.desc (curry.obj (Prod.swap K J ⋙ F) ⋙ lim)
                  { pt := colimit ((curry.obj F).obj j),
                    ι :=
                      {
                        app := fun k =>
                          limit.π ((curry.obj (Prod.swap K J ⋙ F)).obj k) j ≫ colimit.ι ((curry.obj F).obj j) k,
                        naturality := ⋯ } },
              naturality := ⋯ } }
        (colimit.ι (curry.obj (Prod.swap K J ⋙ F) ⋙ lim) k f)) =
    colimit.ι ((curry.obj F).obj j) k (limit.π ((curry.obj (Prod.swap K J ⋙ F)).obj k) j f)
state_after: J : Type u₁
K : Type u₂
inst✝⁶ : Category.{v₁, u₁} J
inst✝⁵ : Category.{v₂, u₂} K
C : Type u
inst✝⁴ : Category.{v, u} C
F✝ : J × K ⥤ C
inst✝³ : HasLimitsOfShape J C
inst✝² : HasColimitsOfShape K C
inst✝¹ : Small.{v, u₁} J
inst✝ : Small.{v, u₂} K
F : J × K ⥤ Type v
j : J
k : K
f : (curry.obj (Prod.swap K J ⋙ F) ⋙ lim).obj k
⊢ { pt := colimit (curry.obj (Prod.swap K J ⋙ F) ⋙ lim),
            π :=
              {
                app := fun j =>
                  colimit.desc (curry.obj (Prod.swap K J ⋙ F) ⋙ lim)
                    { pt := colimit ((curry.obj F).obj j),
                      ι :=
                        {
                          app := fun k =>
                            limit.π ((curry.obj (Prod.swap K J ⋙ F)).obj k) j ≫ colimit.ι ((curry.obj F).obj j) k,
                          naturality := ⋯ } },
                naturality := ⋯ } }.π.app
      j (colimit.ι (curry.obj (Prod.swap K J ⋙ F) ⋙ lim) k f) =
    colimit.ι ((curry.obj F).obj j) k (limit.π ((curry.obj (Prod.swap K J ⋙ F)).obj k) j f)

tactic: dsimp only
state_before: J : Type u₁
K : Type u₂
inst✝⁶ : Category.{v₁, u₁} J
inst✝⁵ : Category.{v₂, u₂} K
C : Type u
inst✝⁴ : Category.{v, u} C
F✝ : J × K ⥤ C
inst✝³ : HasLimitsOfShape J C
inst✝² : HasColimitsOfShape K C
inst✝¹ : Small.{v, u₁} J
inst✝ : Small.{v, u₂} K
F : J × K ⥤ Type v
j : J
k : K
f : (curry.obj (Prod.swap K J ⋙ F) ⋙ lim).obj k
⊢ { pt := colimit (curry.obj (Prod.swap K J ⋙ F) ⋙ lim),
            π :=
              {
                app := fun j =>
                  colimit.desc (curry.obj (Prod.swap K J ⋙ F) ⋙ lim)
                    { pt := colimit ((curry.obj F).obj j),
                      ι :=
                        {
                          app := fun k =>
                            limit.π ((curry.obj (Prod.swap K J ⋙ F)).obj k) j ≫ colimit.ι ((curry.obj F).obj j) k,
                          naturality := ⋯ } },
                naturality := ⋯ } }.π.app
      j (colimit.ι (curry.obj (Prod.swap K J ⋙ F) ⋙ lim) k f) =
    colimit.ι ((curry.obj F).obj j) k (limit.π ((curry.obj (Prod.swap K J ⋙ F)).obj k) j f)
state_after: J : Type u₁
K : Type u₂
inst✝⁶ : Category.{v₁, u₁} J
inst✝⁵ : Category.{v₂, u₂} K
C : Type u
inst✝⁴ : Category.{v, u} C
F✝ : J × K ⥤ C
inst✝³ : HasLimitsOfShape J C
inst✝² : HasColimitsOfShape K C
inst✝¹ : Small.{v, u₁} J
inst✝ : Small.{v, u₂} K
F : J × K ⥤ Type v
j : J
k : K
f : (curry.obj (Prod.swap K J ⋙ F) ⋙ lim).obj k
⊢ colimit.desc (curry.obj (Prod.swap K J ⋙ F) ⋙ lim)
      { pt := colimit ((curry.obj F).obj j),
        ι :=
          { app := fun k => limit.π ((curry.obj (Prod.swap K J ⋙ F)).obj k) j ≫ colimit.ι ((curry.obj F).obj j) k,
            naturality := ⋯ } }
      (colimit.ι (curry.obj (Prod.swap K J ⋙ F) ⋙ lim) k f) =
    colimit.ι ((curry.obj F).obj j) k (limit.π ((curry.obj (Prod.swap K J ⋙ F)).obj k) j f)

tactic: rw [Types.Colimit.ι_desc_apply]
state_before: J : Type u₁
K : Type u₂
inst✝⁶ : Category.{v₁, u₁} J
inst✝⁵ : Category.{v₂, u₂} K
C : Type u
inst✝⁴ : Category.{v, u} C
F✝ : J × K ⥤ C
inst✝³ : HasLimitsOfShape J C
inst✝² : HasColimitsOfShape K C
inst✝¹ : Small.{v, u₁} J
inst✝ : Small.{v, u₂} K
F : J × K ⥤ Type v
j : J
k : K
f : (curry.obj (Prod.swap K J ⋙ F) ⋙ lim).obj k
⊢ colimit.desc (curry.obj (Prod.swap K J ⋙ F) ⋙ lim)
      { pt := colimit ((curry.obj F).obj j),
        ι :=
          { app := fun k => limit.π ((curry.obj (Prod.swap K J ⋙ F)).obj k) j ≫ colimit.ι ((curry.obj F).obj j) k,
            naturality := ⋯ } }
      (colimit.ι (curry.obj (Prod.swap K J ⋙ F) ⋙ lim) k f) =
    colimit.ι ((curry.obj F).obj j) k (limit.π ((curry.obj (Prod.swap K J ⋙ F)).obj k) j f)
state_after: J : Type u₁
K : Type u₂
inst✝⁶ : Category.{v₁, u₁} J
inst✝⁵ : Category.{v₂, u₂} K
C : Type u
inst✝⁴ : Category.{v, u} C
F✝ : J × K ⥤ C
inst✝³ : HasLimitsOfShape J C
inst✝² : HasColimitsOfShape K C
inst✝¹ : Small.{v, u₁} J
inst✝ : Small.{v, u₂} K
F : J × K ⥤ Type v
j : J
k : K
f : (curry.obj (Prod.swap K J ⋙ F) ⋙ lim).obj k
⊢ { pt := colimit ((curry.obj F).obj j),
            ι :=
              { app := fun k => limit.π ((curry.obj (Prod.swap K J ⋙ F)).obj k) j ≫ colimit.ι ((curry.obj F).obj j) k,
                naturality := ⋯ } }.ι.app
      k f =
    colimit.ι ((curry.obj F).obj j) k (limit.π ((curry.obj (Prod.swap K J ⋙ F)).obj k) j f)

tactic: dsimp
state_before: J : Type u₁
K : Type u₂
inst✝⁶ : Category.{v₁, u₁} J
inst✝⁵ : Category.{v₂, u₂} K
C : Type u
inst✝⁴ : Category.{v, u} C
F✝ : J × K ⥤ C
inst✝³ : HasLimitsOfShape J C
inst✝² : HasColimitsOfShape K C
inst✝¹ : Small.{v, u₁} J
inst✝ : Small.{v, u₂} K
F : J × K ⥤ Type v
j : J
k : K
f : (curry.obj (Prod.swap K J ⋙ F) ⋙ lim).obj k
⊢ { pt := colimit ((curry.obj F).obj j),
            ι :=
              { app := fun k => limit.π ((curry.obj (Prod.swap K J ⋙ F)).obj k) j ≫ colimit.ι ((curry.obj F).obj j) k,
                naturality := ⋯ } }.ι.app
      k f =
    colimit.ι ((curry.obj F).obj j) k (limit.π ((curry.obj (Prod.swap K J ⋙ F)).obj k) j f)
state_after: no goals