Theorem: CategoryTheory.ColimitAdj.extendAlongYoneda_map
File: Mathlib/CategoryTheory/Limits/Presheaf.lean

tactic: ext J
state_before: C : Type u₁
inst✝² : SmallCategory C
ℰ : Type u₂
inst✝¹ : Category.{u₁, u₂} ℰ
A : C ⥤ ℰ
inst✝ : HasColimits ℰ
X Y : Cᵒᵖ ⥤ Type u₁
f : X ⟶ Y
⊢ (extendAlongYoneda A).map f = colimit.pre ((CategoryOfElements.π Y).leftOp ⋙ A) (CategoryOfElements.map f).op
state_after: case w
C : Type u₁
inst✝² : SmallCategory C
ℰ : Type u₂
inst✝¹ : Category.{u₁, u₂} ℰ
A : C ⥤ ℰ
inst✝ : HasColimits ℰ
X Y : Cᵒᵖ ⥤ Type u₁
f : X ⟶ Y
J : X.Elementsᵒᵖ
⊢ colimit.ι ((CategoryOfElements.π X).leftOp ⋙ A) J ≫ (extendAlongYoneda A).map f =
    colimit.ι ((CategoryOfElements.π X).leftOp ⋙ A) J ≫
      colimit.pre ((CategoryOfElements.π Y).leftOp ⋙ A) (CategoryOfElements.map f).op

tactic: erw [colimit.ι_pre ((CategoryOfElements.π Y).leftOp ⋙ A) (CategoryOfElements.map f).op]
state_before: case w
C : Type u₁
inst✝² : SmallCategory C
ℰ : Type u₂
inst✝¹ : Category.{u₁, u₂} ℰ
A : C ⥤ ℰ
inst✝ : HasColimits ℰ
X Y : Cᵒᵖ ⥤ Type u₁
f : X ⟶ Y
J : X.Elementsᵒᵖ
⊢ colimit.ι ((CategoryOfElements.π X).leftOp ⋙ A) J ≫ (extendAlongYoneda A).map f =
    colimit.ι ((CategoryOfElements.π X).leftOp ⋙ A) J ≫
      colimit.pre ((CategoryOfElements.π Y).leftOp ⋙ A) (CategoryOfElements.map f).op
state_after: case w
C : Type u₁
inst✝² : SmallCategory C
ℰ : Type u₂
inst✝¹ : Category.{u₁, u₂} ℰ
A : C ⥤ ℰ
inst✝ : HasColimits ℰ
X Y : Cᵒᵖ ⥤ Type u₁
f : X ⟶ Y
J : X.Elementsᵒᵖ
⊢ colimit.ι ((CategoryOfElements.π X).leftOp ⋙ A) J ≫ (extendAlongYoneda A).map f =
    colimit.ι ((CategoryOfElements.π Y).leftOp ⋙ A) ((CategoryOfElements.map f).op.obj J)

tactic: dsimp only [extendAlongYoneda, restrictYonedaHomEquiv, IsColimit.homIso', IsColimit.homIso,
  uliftTrivial]
state_before: case w
C : Type u₁
inst✝² : SmallCategory C
ℰ : Type u₂
inst✝¹ : Category.{u₁, u₂} ℰ
A : C ⥤ ℰ
inst✝ : HasColimits ℰ
X Y : Cᵒᵖ ⥤ Type u₁
f : X ⟶ Y
J : X.Elementsᵒᵖ
⊢ colimit.ι ((CategoryOfElements.π X).leftOp ⋙ A) J ≫ (extendAlongYoneda A).map f =
    colimit.ι ((CategoryOfElements.π Y).leftOp ⋙ A) ((CategoryOfElements.map f).op.obj J)
state_after: case w
C : Type u₁
inst✝² : SmallCategory C
ℰ : Type u₂
inst✝¹ : Category.{u₁, u₂} ℰ
A : C ⥤ ℰ
inst✝ : HasColimits ℰ
X Y : Cᵒᵖ ⥤ Type u₁
f : X ⟶ Y
J : X.Elementsᵒᵖ
⊢ colimit.ι ((CategoryOfElements.π X).leftOp ⋙ A) J ≫
      (Adjunction.leftAdjointOfEquiv
            (fun P E =>
              ({ hom := fun a => a.down, inv := fun a => { down := a }, hom_inv_id := ⋯, inv_hom_id := ⋯ }.symm ≪≫
                      { hom := fun f => ((colimit.cocone ((CategoryOfElements.π P).leftOp ⋙ A)).extend f.down).ι,
                          inv := fun ι =>
                            {
                              down :=
                                (colimit.isColimit ((CategoryOfElements.π P).leftOp ⋙ A)).desc { pt := E, ι := ι } },
                          hom_inv_id := ⋯, inv_hom_id := ⋯ } ≪≫
                        { hom := fun ι => ⟨fun j => ι.app j, ⋯⟩,
                          inv := fun p => { app := fun j => ↑p j, naturality := ⋯ }, hom_inv_id := ⋯,
                          inv_hom_id := ⋯ }).toEquiv.trans
                { toFun := fun k => { app := fun c p => ↑k { unop := ⟨c, p⟩ }, naturality := ⋯ },
                  invFun := fun τ => ⟨fun p => τ.app p.unop.fst p.unop.snd, ⋯⟩, left_inv := ⋯, right_inv := ⋯ })
            ⋯).map
        f =
    colimit.ι ((CategoryOfElements.π Y).leftOp ⋙ A) ((CategoryOfElements.map f).op.obj J)

tactic: simp only [Adjunction.leftAdjointOfEquiv_map, Iso.symm_mk, Iso.toEquiv_comp, Equiv.coe_trans,
  Equiv.coe_fn_mk, Iso.toEquiv_fun, Equiv.symm_trans_apply, Equiv.coe_fn_symm_mk,
  Iso.toEquiv_symm_fun, id, colimit.isColimit_desc, colimit.ι_desc, FunctorToTypes.comp,
  Cocone.extend_ι, Cocone.extensions_app, Functor.map_id, Category.comp_id, colimit.cocone_ι]
state_before: case w
C : Type u₁
inst✝² : SmallCategory C
ℰ : Type u₂
inst✝¹ : Category.{u₁, u₂} ℰ
A : C ⥤ ℰ
inst✝ : HasColimits ℰ
X Y : Cᵒᵖ ⥤ Type u₁
f : X ⟶ Y
J : X.Elementsᵒᵖ
⊢ colimit.ι ((CategoryOfElements.π X).leftOp ⋙ A) J ≫
      (Adjunction.leftAdjointOfEquiv
            (fun P E =>
              ({ hom := fun a => a.down, inv := fun a => { down := a }, hom_inv_id := ⋯, inv_hom_id := ⋯ }.symm ≪≫
                      { hom := fun f => ((colimit.cocone ((CategoryOfElements.π P).leftOp ⋙ A)).extend f.down).ι,
                          inv := fun ι =>
                            {
                              down :=
                                (colimit.isColimit ((CategoryOfElements.π P).leftOp ⋙ A)).desc { pt := E, ι := ι } },
                          hom_inv_id := ⋯, inv_hom_id := ⋯ } ≪≫
                        { hom := fun ι => ⟨fun j => ι.app j, ⋯⟩,
                          inv := fun p => { app := fun j => ↑p j, naturality := ⋯ }, hom_inv_id := ⋯,
                          inv_hom_id := ⋯ }).toEquiv.trans
                { toFun := fun k => { app := fun c p => ↑k { unop := ⟨c, p⟩ }, naturality := ⋯ },
                  invFun := fun τ => ⟨fun p => τ.app p.unop.fst p.unop.snd, ⋯⟩, left_inv := ⋯, right_inv := ⋯ })
            ⋯).map
        f =
    colimit.ι ((CategoryOfElements.π Y).leftOp ⋙ A) ((CategoryOfElements.map f).op.obj J)
state_after: case w
C : Type u₁
inst✝² : SmallCategory C
ℰ : Type u₂
inst✝¹ : Category.{u₁, u₂} ℰ
A : C ⥤ ℰ
inst✝ : HasColimits ℰ
X Y : Cᵒᵖ ⥤ Type u₁
f : X ⟶ Y
J : X.Elementsᵒᵖ
⊢ (((fun k => { app := fun c p => ↑k { unop := ⟨c, p⟩ }, naturality := ⋯ }) ∘
            ((fun ι => ⟨fun j => ι.app j, ⋯⟩) ∘ fun f =>
                (colimit.cocone ((CategoryOfElements.π Y).leftOp ⋙ A)).ι ≫ (Functor.const Y.Elementsᵒᵖ).map f.down) ∘
              fun a => { down := a })
          (𝟙 (colimit.cocone ((CategoryOfElements.π Y).leftOp ⋙ A)).pt)).app
      J.unop.fst (f.app J.unop.fst J.unop.snd) =
    colimit.ι ((CategoryOfElements.π Y).leftOp ⋙ A) ((CategoryOfElements.map f).op.obj J)

tactic: simp only [Functor.comp_obj, Functor.leftOp_obj, CategoryOfElements.π_obj, colimit.cocone_x,
  Functor.comp_map, Functor.leftOp_map, CategoryOfElements.π_map, Opposite.unop_op,
  Adjunction.leftAdjointOfEquiv_obj, Function.comp_apply, Functor.map_id, comp_id,
  colimit.cocone_ι, Functor.op_obj]
state_before: case w
C : Type u₁
inst✝² : SmallCategory C
ℰ : Type u₂
inst✝¹ : Category.{u₁, u₂} ℰ
A : C ⥤ ℰ
inst✝ : HasColimits ℰ
X Y : Cᵒᵖ ⥤ Type u₁
f : X ⟶ Y
J : X.Elementsᵒᵖ
⊢ (((fun k => { app := fun c p => ↑k { unop := ⟨c, p⟩ }, naturality := ⋯ }) ∘
            ((fun ι => ⟨fun j => ι.app j, ⋯⟩) ∘ fun f =>
                (colimit.cocone ((CategoryOfElements.π Y).leftOp ⋙ A)).ι ≫ (Functor.const Y.Elementsᵒᵖ).map f.down) ∘
              fun a => { down := a })
          (𝟙 (colimit.cocone ((CategoryOfElements.π Y).leftOp ⋙ A)).pt)).app
      J.unop.fst (f.app J.unop.fst J.unop.snd) =
    colimit.ι ((CategoryOfElements.π Y).leftOp ⋙ A) ((CategoryOfElements.map f).op.obj J)
state_after: case w
C : Type u₁
inst✝² : SmallCategory C
ℰ : Type u₂
inst✝¹ : Category.{u₁, u₂} ℰ
A : C ⥤ ℰ
inst✝ : HasColimits ℰ
X Y : Cᵒᵖ ⥤ Type u₁
f : X ⟶ Y
J : X.Elementsᵒᵖ
⊢ colimit.ι ((CategoryOfElements.π Y).leftOp ⋙ A) { unop := ⟨J.unop.fst, f.app J.unop.fst J.unop.snd⟩ } =
    colimit.ι ((CategoryOfElements.π Y).leftOp ⋙ A) { unop := (CategoryOfElements.map f).obj J.unop }

tactic: rfl
state_before: case w
C : Type u₁
inst✝² : SmallCategory C
ℰ : Type u₂
inst✝¹ : Category.{u₁, u₂} ℰ
A : C ⥤ ℰ
inst✝ : HasColimits ℰ
X Y : Cᵒᵖ ⥤ Type u₁
f : X ⟶ Y
J : X.Elementsᵒᵖ
⊢ colimit.ι ((CategoryOfElements.π Y).leftOp ⋙ A) { unop := ⟨J.unop.fst, f.app J.unop.fst J.unop.snd⟩ } =
    colimit.ι ((CategoryOfElements.π Y).leftOp ⋙ A) { unop := (CategoryOfElements.map f).obj J.unop }
state_after: no goals