Theorem: CategoryTheory.Limits.CoproductsFromFiniteFiltered.liftToFinsetColimitCocone_cocone_ι_app
File: Mathlib/CategoryTheory/Limits/Constructions/Filtered.lean

Proof steps:
state_before: C : Type u
inst✝² : Category.{v, u} C
α : Type w
inst✝¹ : HasFiniteCoproducts C
inst✝ : HasFilteredColimitsOfSize.{w, w, v, u} C
F : Discrete α ⥤ C
j : Discrete α
⊢ j ∈ {j}
state_after: no goals
tactic: simp
state_before: C : Type u
inst✝² : Category.{v, u} C
α : Type w
inst✝¹ : HasFiniteCoproducts C
inst✝ : HasFilteredColimitsOfSize.{w, w, v, u} C
F : Discrete α ⥤ C
s : Cocone F
m :
  { pt := colimit (liftToFinset F),
        ι := Discrete.natTrans fun j => Sigma.ι (fun x => F.obj ↑x) ⟨j, ⋯⟩ ≫ colimit.ι (liftToFinset F) {j} }.pt ⟶
    s.pt
h :
  ∀ (j : Discrete α),
    { pt := colimit (liftToFinset F),
                ι :=
                  Discrete.natTrans fun j => Sigma.ι (fun x => F.obj ↑x) ⟨j, ⋯⟩ ≫ colimit.ι (liftToFinset F) {j} }.ι.app
          j ≫
        m =
      s.ι.app j
⊢ m =
    (fun s =>
        colimit.desc (liftToFinset F)
          { pt := s.pt, ι := { app := fun t => Sigma.desc fun x => s.ι.app ↑x, naturality := ⋯ } })
      s
state_after: case w
C : Type u
inst✝² : Category.{v, u} C
α : Type w
inst✝¹ : HasFiniteCoproducts C
inst✝ : HasFilteredColimitsOfSize.{w, w, v, u} C
F : Discrete α ⥤ C
s : Cocone F
m :
  { pt := colimit (liftToFinset F),
        ι := Discrete.natTrans fun j => Sigma.ι (fun x => F.obj ↑x) ⟨j, ⋯⟩ ≫ colimit.ι (liftToFinset F) {j} }.pt ⟶
    s.pt
h :
  ∀ (j : Discrete α),
    { pt := colimit (liftToFinset F),
                ι :=
                  Discrete.natTrans fun j => Sigma.ι (fun x => F.obj ↑x) ⟨j, ⋯⟩ ≫ colimit.ι (liftToFinset F) {j} }.ι.app
          j ≫
        m =
      s.ι.app j
⊢ ∀ (j : Finset (Discrete α)),
    colimit.ι (liftToFinset F) j ≫ m =
      colimit.ι (liftToFinset F) j ≫
        (fun s =>
            colimit.desc (liftToFinset F)
              { pt := s.pt, ι := { app := fun t => Sigma.desc fun x => s.ι.app ↑x, naturality := ⋯ } })
          s
tactic: apply colimit.hom_ext
state_before: case w
C : Type u
inst✝² : Category.{v, u} C
α : Type w
inst✝¹ : HasFiniteCoproducts C
inst✝ : HasFilteredColimitsOfSize.{w, w, v, u} C
F : Discrete α ⥤ C
s : Cocone F
m :
  { pt := colimit (liftToFinset F),
        ι := Discrete.natTrans fun j => Sigma.ι (fun x => F.obj ↑x) ⟨j, ⋯⟩ ≫ colimit.ι (liftToFinset F) {j} }.pt ⟶
    s.pt
h :
  ∀ (j : Discrete α),
    { pt := colimit (liftToFinset F),
                ι :=
                  Discrete.natTrans fun j => Sigma.ι (fun x => F.obj ↑x) ⟨j, ⋯⟩ ≫ colimit.ι (liftToFinset F) {j} }.ι.app
          j ≫
        m =
      s.ι.app j
⊢ ∀ (j : Finset (Discrete α)),
    colimit.ι (liftToFinset F) j ≫ m =
      colimit.ι (liftToFinset F) j ≫
        (fun s =>
            colimit.desc (liftToFinset F)
              { pt := s.pt, ι := { app := fun t => Sigma.desc fun x => s.ι.app ↑x, naturality := ⋯ } })
          s
state_after: case w
C : Type u
inst✝² : Category.{v, u} C
α : Type w
inst✝¹ : HasFiniteCoproducts C
inst✝ : HasFilteredColimitsOfSize.{w, w, v, u} C
F : Discrete α ⥤ C
s : Cocone F
m :
  { pt := colimit (liftToFinset F),
        ι := Discrete.natTrans fun j => Sigma.ι (fun x => F.obj ↑x) ⟨j, ⋯⟩ ≫ colimit.ι (liftToFinset F) {j} }.pt ⟶
    s.pt
h :
  ∀ (j : Discrete α),
    { pt := colimit (liftToFinset F),
                ι :=
                  Discrete.natTrans fun j => Sigma.ι (fun x => F.obj ↑x) ⟨j, ⋯⟩ ≫ colimit.ι (liftToFinset F) {j} }.ι.app
          j ≫
        m =
      s.ι.app j
t : Finset (Discrete α)
⊢ colimit.ι (liftToFinset F) t ≫ m =
    colimit.ι (liftToFinset F) t ≫
      (fun s =>
          colimit.desc (liftToFinset F)
            { pt := s.pt, ι := { app := fun t => Sigma.desc fun x => s.ι.app ↑x, naturality := ⋯ } })
        s
tactic: rintro t
state_before: case w
C : Type u
inst✝² : Category.{v, u} C
α : Type w
inst✝¹ : HasFiniteCoproducts C
inst✝ : HasFilteredColimitsOfSize.{w, w, v, u} C
F : Discrete α ⥤ C
s : Cocone F
m :
  { pt := colimit (liftToFinset F),
        ι := Discrete.natTrans fun j => Sigma.ι (fun x => F.obj ↑x) ⟨j, ⋯⟩ ≫ colimit.ι (liftToFinset F) {j} }.pt ⟶
    s.pt
h :
  ∀ (j : Discrete α),
    { pt := colimit (liftToFinset F),
                ι :=
                  Discrete.natTrans fun j => Sigma.ι (fun x => F.obj ↑x) ⟨j, ⋯⟩ ≫ colimit.ι (liftToFinset F) {j} }.ι.app
          j ≫
        m =
      s.ι.app j
t : Finset (Discrete α)
⊢ colimit.ι (liftToFinset F) t ≫ m =
    colimit.ι (liftToFinset F) t ≫
      (fun s =>
          colimit.desc (liftToFinset F)
            { pt := s.pt, ι := { app := fun t => Sigma.desc fun x => s.ι.app ↑x, naturality := ⋯ } })
        s
state_after: case w
C : Type u
inst✝² : Category.{v, u} C
α : Type w
inst✝¹ : HasFiniteCoproducts C
inst✝ : HasFilteredColimitsOfSize.{w, w, v, u} C
F : Discrete α ⥤ C
s : Cocone F
m :
  { pt := colimit (liftToFinset F),
        ι := Discrete.natTrans fun j => Sigma.ι (fun x => F.obj ↑x) ⟨j, ⋯⟩ ≫ colimit.ι (liftToFinset F) {j} }.pt ⟶
    s.pt
h :
  ∀ (j : Discrete α),
    { pt := colimit (liftToFinset F),
                ι :=
                  Discrete.natTrans fun j => Sigma.ι (fun x => F.obj ↑x) ⟨j, ⋯⟩ ≫ colimit.ι (liftToFinset F) {j} }.ι.app
          j ≫
        m =
      s.ι.app j
t : Finset (Discrete α)
⊢ colimit.ι
        { obj := fun s => ∐ fun x => F.obj ↑x,
          map := fun {x Y} h => Sigma.desc fun y => Sigma.ι (fun x => F.obj ↑x) ⟨↑y, ⋯⟩, map_id := ⋯, map_comp := ⋯ }
        t ≫
      m =
    colimit.ι
        { obj := fun s => ∐ fun x => F.obj ↑x,
          map := fun {x Y} h => Sigma.desc fun y => Sigma.ι (fun x => F.obj ↑x) ⟨↑y, ⋯⟩, map_id := ⋯, map_comp := ⋯ }
        t ≫
      colimit.desc
        { obj := fun s => ∐ fun x => F.obj ↑x,
          map := fun {x Y} h => Sigma.desc fun y => Sigma.ι (fun x => F.obj ↑x) ⟨↑y, ⋯⟩, map_id := ⋯, map_comp := ⋯ }
        { pt := s.pt, ι := { app := fun t => Sigma.desc fun x => s.ι.app ↑x, naturality := ⋯ } }
tactic: dsimp [liftToFinset]
state_before: case w
C : Type u
inst✝² : Category.{v, u} C
α : Type w
inst✝¹ : HasFiniteCoproducts C
inst✝ : HasFilteredColimitsOfSize.{w, w, v, u} C
F : Discrete α ⥤ C
s : Cocone F
m :
  { pt := colimit (liftToFinset F),
        ι := Discrete.natTrans fun j => Sigma.ι (fun x => F.obj ↑x) ⟨j, ⋯⟩ ≫ colimit.ι (liftToFinset F) {j} }.pt ⟶
    s.pt
h :
  ∀ (j : Discrete α),
    { pt := colimit (liftToFinset F),
                ι :=
                  Discrete.natTrans fun j => Sigma.ι (fun x => F.obj ↑x) ⟨j, ⋯⟩ ≫ colimit.ι (liftToFinset F) {j} }.ι.app
          j ≫
        m =
      s.ι.app j
t : Finset (Discrete α)
⊢ colimit.ι
        { obj := fun s => ∐ fun x => F.obj ↑x,
          map := fun {x Y} h => Sigma.desc fun y => Sigma.ι (fun x => F.obj ↑x) ⟨↑y, ⋯⟩, map_id := ⋯, map_comp := ⋯ }
        t ≫
      m =
    colimit.ι
        { obj := fun s => ∐ fun x => F.obj ↑x,
          map := fun {x Y} h => Sigma.desc fun y => Sigma.ι (fun x => F.obj ↑x) ⟨↑y, ⋯⟩, map_id := ⋯, map_comp := ⋯ }
        t ≫
      colimit.desc
        { obj := fun s => ∐ fun x => F.obj ↑x,
          map := fun {x Y} h => Sigma.desc fun y => Sigma.ι (fun x => F.obj ↑x) ⟨↑y, ⋯⟩, map_id := ⋯, map_comp := ⋯ }
        { pt := s.pt, ι := { app := fun t => Sigma.desc fun x => s.ι.app ↑x, naturality := ⋯ } }
state_after: case w.w
C : Type u
inst✝² : Category.{v, u} C
α : Type w
inst✝¹ : HasFiniteCoproducts C
inst✝ : HasFilteredColimitsOfSize.{w, w, v, u} C
F : Discrete α ⥤ C
s : Cocone F
m :
  { pt := colimit (liftToFinset F),
        ι := Discrete.natTrans fun j => Sigma.ι (fun x => F.obj ↑x) ⟨j, ⋯⟩ ≫ colimit.ι (liftToFinset F) {j} }.pt ⟶
    s.pt
h :
  ∀ (j : Discrete α),
    { pt := colimit (liftToFinset F),
                ι :=
                  Discrete.natTrans fun j => Sigma.ι (fun x => F.obj ↑x) ⟨j, ⋯⟩ ≫ colimit.ι (liftToFinset F) {j} }.ι.app
          j ≫
        m =
      s.ι.app j
t : Finset (Discrete α)
⊢ ∀ (j : Discrete { x // x ∈ t }),
    colimit.ι (Discrete.functor fun x => F.obj ↑x) j ≫
        colimit.ι
            { obj := fun s => ∐ fun x => F.obj ↑x,
              map := fun {x Y} h => Sigma.desc fun y => Sigma.ι (fun x => F.obj ↑x) ⟨↑y, ⋯⟩, map_id := ⋯,
              map_comp := ⋯ }
            t ≫
          m =
      colimit.ι (Discrete.functor fun x => F.obj ↑x) j ≫
        colimit.ι
            { obj := fun s => ∐ fun x => F.obj ↑x,
              map := fun {x Y} h => Sigma.desc fun y => Sigma.ι (fun x => F.obj ↑x) ⟨↑y, ⋯⟩, map_id := ⋯,
              map_comp := ⋯ }
            t ≫
          colimit.desc
            { obj := fun s => ∐ fun x => F.obj ↑x,
              map := fun {x Y} h => Sigma.desc fun y => Sigma.ι (fun x => F.obj ↑x) ⟨↑y, ⋯⟩, map_id := ⋯,
              map_comp := ⋯ }
            { pt := s.pt, ι := { app := fun t => Sigma.desc fun x => s.ι.app ↑x, naturality := ⋯ } }
tactic: apply colimit.hom_ext
state_before: case w.w
C : Type u
inst✝² : Category.{v, u} C
α : Type w
inst✝¹ : HasFiniteCoproducts C
inst✝ : HasFilteredColimitsOfSize.{w, w, v, u} C
F : Discrete α ⥤ C
s : Cocone F
m :
  { pt := colimit (liftToFinset F),
        ι := Discrete.natTrans fun j => Sigma.ι (fun x => F.obj ↑x) ⟨j, ⋯⟩ ≫ colimit.ι (liftToFinset F) {j} }.pt ⟶
    s.pt
h :
  ∀ (j : Discrete α),
    { pt := colimit (liftToFinset F),
                ι :=
                  Discrete.natTrans fun j => Sigma.ι (fun x => F.obj ↑x) ⟨j, ⋯⟩ ≫ colimit.ι (liftToFinset F) {j} }.ι.app
          j ≫
        m =
      s.ι.app j
t : Finset (Discrete α)
⊢ ∀ (j : Discrete { x // x ∈ t }),
    colimit.ι (Discrete.functor fun x => F.obj ↑x) j ≫
        colimit.ι
            { obj := fun s => ∐ fun x => F.obj ↑x,
              map := fun {x Y} h => Sigma.desc fun y => Sigma.ι (fun x => F.obj ↑x) ⟨↑y, ⋯⟩, map_id := ⋯,
              map_comp := ⋯ }
            t ≫
          m =
      colimit.ι (Discrete.functor fun x => F.obj ↑x) j ≫
        colimit.ι
            { obj := fun s => ∐ fun x => F.obj ↑x,
              map := fun {x Y} h => Sigma.desc fun y => Sigma.ι (fun x => F.obj ↑x) ⟨↑y, ⋯⟩, map_id := ⋯,
              map_comp := ⋯ }
            t ≫
          colimit.desc
            { obj := fun s => ∐ fun x => F.obj ↑x,
              map := fun {x Y} h => Sigma.desc fun y => Sigma.ι (fun x => F.obj ↑x) ⟨↑y, ⋯⟩, map_id := ⋯,
              map_comp := ⋯ }
            { pt := s.pt, ι := { app := fun t => Sigma.desc fun x => s.ι.app ↑x, naturality := ⋯ } }
state_after: case w.w.mk.mk
C : Type u
inst✝² : Category.{v, u} C
α : Type w
inst✝¹ : HasFiniteCoproducts C
inst✝ : HasFilteredColimitsOfSize.{w, w, v, u} C
F : Discrete α ⥤ C
s : Cocone F
m :
  { pt := colimit (liftToFinset F),
        ι := Discrete.natTrans fun j => Sigma.ι (fun x => F.obj ↑x) ⟨j, ⋯⟩ ≫ colimit.ι (liftToFinset F) {j} }.pt ⟶
    s.pt
h :
  ∀ (j : Discrete α),
    { pt := colimit (liftToFinset F),
                ι :=
                  Discrete.natTrans fun j => Sigma.ι (fun x => F.obj ↑x) ⟨j, ⋯⟩ ≫ colimit.ι (liftToFinset F) {j} }.ι.app
          j ≫
        m =
      s.ι.app j
t : Finset (Discrete α)
j : Discrete α
hj : j ∈ t
⊢ colimit.ι (Discrete.functor fun x => F.obj ↑x) { as := ⟨j, hj⟩ } ≫
      colimit.ι
          { obj := fun s => ∐ fun x => F.obj ↑x,
            map := fun {x Y} h => Sigma.desc fun y => Sigma.ι (fun x => F.obj ↑x) ⟨↑y, ⋯⟩, map_id := ⋯, map_comp := ⋯ }
          t ≫
        m =
    colimit.ι (Discrete.functor fun x => F.obj ↑x) { as := ⟨j, hj⟩ } ≫
      colimit.ι
          { obj := fun s => ∐ fun x => F.obj ↑x,
            map := fun {x Y} h => Sigma.desc fun y => Sigma.ι (fun x => F.obj ↑x) ⟨↑y, ⋯⟩, map_id := ⋯, map_comp := ⋯ }
          t ≫
        colimit.desc
          { obj := fun s => ∐ fun x => F.obj ↑x,
            map := fun {x Y} h => Sigma.desc fun y => Sigma.ι (fun x => F.obj ↑x) ⟨↑y, ⋯⟩, map_id := ⋯, map_comp := ⋯ }
          { pt := s.pt, ι := { app := fun t => Sigma.desc fun x => s.ι.app ↑x, naturality := ⋯ } }
tactic: rintro ⟨⟨j, hj⟩⟩
state_before: case w.w.mk.mk
C : Type u
inst✝² : Category.{v, u} C
α : Type w
inst✝¹ : HasFiniteCoproducts C
inst✝ : HasFilteredColimitsOfSize.{w, w, v, u} C
F : Discrete α ⥤ C
s : Cocone F
m :
  { pt := colimit (liftToFinset F),
        ι := Discrete.natTrans fun j => Sigma.ι (fun x => F.obj ↑x) ⟨j, ⋯⟩ ≫ colimit.ι (liftToFinset F) {j} }.pt ⟶
    s.pt
h :
  ∀ (j : Discrete α),
    { pt := colimit (liftToFinset F),
                ι :=
                  Discrete.natTrans fun j => Sigma.ι (fun x => F.obj ↑x) ⟨j, ⋯⟩ ≫ colimit.ι (liftToFinset F) {j} }.ι.app
          j ≫
        m =
      s.ι.app j
t : Finset (Discrete α)
j : Discrete α
hj : j ∈ t
⊢ colimit.ι (Discrete.functor fun x => F.obj ↑x) { as := ⟨j, hj⟩ } ≫
      colimit.ι
          { obj := fun s => ∐ fun x => F.obj ↑x,
            map := fun {x Y} h => Sigma.desc fun y => Sigma.ι (fun x => F.obj ↑x) ⟨↑y, ⋯⟩, map_id := ⋯, map_comp := ⋯ }
          t ≫
        m =
    colimit.ι (Discrete.functor fun x => F.obj ↑x) { as := ⟨j, hj⟩ } ≫
      colimit.ι
          { obj := fun s => ∐ fun x => F.obj ↑x,
            map := fun {x Y} h => Sigma.desc fun y => Sigma.ι (fun x => F.obj ↑x) ⟨↑y, ⋯⟩, map_id := ⋯, map_comp := ⋯ }
          t ≫
        colimit.desc
          { obj := fun s => ∐ fun x => F.obj ↑x,
            map := fun {x Y} h => Sigma.desc fun y => Sigma.ι (fun x => F.obj ↑x) ⟨↑y, ⋯⟩, map_id := ⋯, map_comp := ⋯ }
          { pt := s.pt, ι := { app := fun t => Sigma.desc fun x => s.ι.app ↑x, naturality := ⋯ } }
state_after: case h.e'_2.h
C : Type u
inst✝² : Category.{v, u} C
α : Type w
inst✝¹ : HasFiniteCoproducts C
inst✝ : HasFilteredColimitsOfSize.{w, w, v, u} C
F : Discrete α ⥤ C
s : Cocone F
m :
  { pt := colimit (liftToFinset F),
        ι := Discrete.natTrans fun j => Sigma.ι (fun x => F.obj ↑x) ⟨j, ⋯⟩ ≫ colimit.ι (liftToFinset F) {j} }.pt ⟶
    s.pt
h :
  ∀ (j : Discrete α),
    { pt := colimit (liftToFinset F),
                ι :=
                  Discrete.natTrans fun j => Sigma.ι (fun x => F.obj ↑x) ⟨j, ⋯⟩ ≫ colimit.ι (liftToFinset F) {j} }.ι.app
          j ≫
        m =
      s.ι.app j
t : Finset (Discrete α)
j : Discrete α
hj : j ∈ t
e_1✝ : ((Discrete.functor fun x => F.obj ↑x).obj { as := ⟨j, hj⟩ } ⟶ s.pt) = (F.obj j ⟶ s.pt)
⊢ colimit.ι (Discrete.functor fun x => F.obj ↑x) { as := ⟨j, hj⟩ } ≫
      colimit.ι
          { obj := fun s => ∐ fun x => F.obj ↑x,
            map := fun {x Y} h => Sigma.desc fun y => Sigma.ι (fun x => F.obj ↑x) ⟨↑y, ⋯⟩, map_id := ⋯, map_comp := ⋯ }
          t ≫
        m =
    { pt := colimit (liftToFinset F),
              ι :=
                Discrete.natTrans fun j => Sigma.ι (fun x => F.obj ↑x) ⟨j, ⋯⟩ ≫ colimit.ι (liftToFinset F) {j} }.ι.app
        j ≫
      m

case h.e'_3.h
C : Type u
inst✝² : Category.{v, u} C
α : Type w
inst✝¹ : HasFiniteCoproducts C
inst✝ : HasFilteredColimitsOfSize.{w, w, v, u} C
F : Discrete α ⥤ C
s : Cocone F
m :
  { pt := colimit (liftToFinset F),
        ι := Discrete.natTrans fun j => Sigma.ι (fun x => F.obj ↑x) ⟨j, ⋯⟩ ≫ colimit.ι (liftToFinset F) {j} }.pt ⟶
    s.pt
h :
  ∀ (j : Discrete α),
    { pt := colimit (liftToFinset F),
                ι :=
                  Discrete.natTrans fun j => Sigma.ι (fun x => F.obj ↑x) ⟨j, ⋯⟩ ≫ colimit.ι (liftToFinset F) {j} }.ι.app
          j ≫
        m =
      s.ι.app j
t : Finset (Discrete α)
j : Discrete α
hj : j ∈ t
e_1✝ : ((Discrete.functor fun x => F.obj ↑x).obj { as := ⟨j, hj⟩ } ⟶ s.pt) = (F.obj j ⟶ s.pt)
⊢ colimit.ι (Discrete.functor fun x => F.obj ↑x) { as := ⟨j, hj⟩ } ≫
      colimit.ι
          { obj := fun s => ∐ fun x => F.obj ↑x,
            map := fun {x Y} h => Sigma.desc fun y => Sigma.ι (fun x => F.obj ↑x) ⟨↑y, ⋯⟩, map_id := ⋯, map_comp := ⋯ }
          t ≫
        colimit.desc
          { obj := fun s => ∐ fun x => F.obj ↑x,
            map := fun {x Y} h => Sigma.desc fun y => Sigma.ι (fun x => F.obj ↑x) ⟨↑y, ⋯⟩, map_id := ⋯, map_comp := ⋯ }
          { pt := s.pt, ι := { app := fun t => Sigma.desc fun x => s.ι.app ↑x, naturality := ⋯ } } =
    s.ι.app j
tactic: convert h j using 1