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 ℰ
A : C ⥤ ℰ
inst✝ : HasColimits ℰ
X Y : Cᵒᵖ ⥤ Type u₁
f : X ⟶ Y
⊢ (extendAlongYoneda A).map f =
    colimit.pre ((CategoryOfElements.π Y).leftOp ⋙ A) (Functor.op (CategoryOfElements.map f))

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 ℰ
A : C ⥤ ℰ
inst✝ : HasColimits ℰ
X Y : Cᵒᵖ ⥤ Type u₁
f : X ⟶ Y
J : (Functor.Elements X)ᵒᵖ
⊢ colimit.ι ((CategoryOfElements.π X).leftOp ⋙ A) J ≫ (extendAlongYoneda A).map f =
    colimit.ι ((CategoryOfElements.π X).leftOp ⋙ A) J ≫
      colimit.pre ((CategoryOfElements.π Y).leftOp ⋙ A) (Functor.op (CategoryOfElements.map f))

tactic: dsimp only [extendAlongYoneda, restrictYonedaHomEquiv, IsColimit.homIso', IsColimit.homIso,
  uliftTrivial]
state_before: case w
C : Type u₁
inst✝² : SmallCategory C
ℰ : Type u₂
inst✝¹ : Category ℰ
A : C ⥤ ℰ
inst✝ : HasColimits ℰ
X Y : Cᵒᵖ ⥤ Type u₁
f : X ⟶ Y
J : (Functor.Elements X)ᵒᵖ
⊢ colimit.ι ((CategoryOfElements.π X).leftOp ⋙ A) J ≫ (extendAlongYoneda A).map f =
    colimit.ι ((CategoryOfElements.π Y).leftOp ⋙ A) ((Functor.op (CategoryOfElements.map f)).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.def, 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 ℰ
A : C ⥤ ℰ
inst✝ : HasColimits ℰ
X Y : Cᵒᵖ ⥤ Type u₁
f : X ⟶ Y
J : (Functor.Elements X)ᵒᵖ
⊢ colimit.ι ((CategoryOfElements.π X).leftOp ⋙ A) J ≫
      (Adjunction.leftAdjointOfEquiv
            (fun P E =>
              ((Iso.mk (fun a => a.down) fun a => { down := a }).symm ≪≫
                    (Iso.mk (fun f => (Cocone.extend (colimit.cocone ((CategoryOfElements.π P).leftOp ⋙ A)) f.down).ι)
                        fun ι =>
                        {
                          down :=
                            IsColimit.desc (colimit.isColimit ((CategoryOfElements.π P).leftOp ⋙ A))
                              { pt := E, ι := ι } }) ≪≫
                      Iso.mk
                        (fun ι =>
                          { val := fun j => ι.app j,
                            property :=
                              (_ :
                                ∀ {j j' : (Functor.Elements P)ᵒᵖ} (f : j ⟶ j'),
                                  ((CategoryOfElements.π P).leftOp ⋙ A).map f ≫ (fun j => ι.app j) j' =
                                    (fun j => ι.app j) j) })
                        fun p => NatTrans.mk fun j => ↑p j).trans
                { toFun := fun k => NatTrans.mk fun c p => ↑k { fst := c, snd := p }.op,
                  invFun := fun τ =>
                    { val := fun p => τ.app p.unop.fst p.unop.snd,
                      property :=
                        (_ :
                          ∀ (p p' : (Functor.Elements P)ᵒᵖ) (f : p ⟶ p'),
                            ((CategoryOfElements.π P).leftOp ⋙ A).map f ≫ (fun p => τ.app p.unop.fst p.unop.snd) p' =
                              (fun p => τ.app p.unop.fst p.unop.snd) p) },
                  left_inv :=
                    (_ :
                      ∀
                        (x :
                          { p //
                            ∀ {j j' : (Functor.Elements P)ᵒᵖ} (f : j ⟶ j'),
                              ((CategoryOfElements.π P).leftOp ⋙ A).map f ≫ p j' = p j }),
                        (fun τ =>
                              { val := fun p => τ.app p.unop.fst p.unop.snd,
                                property :=
                                  (_ :
                                    ∀ (p p' : (Functor.Elements P)ᵒᵖ) (f : p ⟶ p'),
                                      ((CategoryOfElements.π P).leftOp ⋙ A).map f ≫
                                          (fun p => τ.app p.unop.fst p.unop.snd) p' =
                                        (fun p => τ.app p.unop.fst p.unop.snd) p) })
                            ((fun k => NatTrans.mk fun c p => ↑k { fst := c, snd := p }.op) x) =
                          x),
                  right_inv :=
                    (_ :
                      ∀ (x : P ⟶ (restrictedYoneda A).obj E),
                        (fun k => NatTrans.mk fun c p => ↑k { fst := c, snd := p }.op)
                            ((fun τ =>
                                { val := fun p => τ.app p.unop.fst p.unop.snd,
                                  property :=
                                    (_ :
                                      ∀ (p p' : (Functor.Elements P)ᵒᵖ) (f : p ⟶ p'),
                                        ((CategoryOfElements.π P).leftOp ⋙ A).map f ≫
                                            (fun p => τ.app p.unop.fst p.unop.snd) p' =
                                          (fun p => τ.app p.unop.fst p.unop.snd) p) })
                              x) =
                          x) })
            (_ :
              ∀ (P : Cᵒᵖ ⥤ Type u₁) (E E' : ℰ) (g : E ⟶ E')
                (k : (colimit.cocone ((CategoryOfElements.π P).leftOp ⋙ A)).pt ⟶ E),
                ↑(restrictYonedaHomEquiv A P E' (colimit.isColimit ((CategoryOfElements.π P).leftOp ⋙ A))) (k ≫ g) =
                  ↑(restrictYonedaHomEquiv A P E (colimit.isColimit ((CategoryOfElements.π P).leftOp ⋙ A))) k ≫
                    (restrictedYoneda A).map g)).map
        f =
    colimit.ι ((CategoryOfElements.π Y).leftOp ⋙ A) ((Functor.op (CategoryOfElements.map f)).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 ℰ
A : C ⥤ ℰ
inst✝ : HasColimits ℰ
X Y : Cᵒᵖ ⥤ Type u₁
f : X ⟶ Y
J : (Functor.Elements X)ᵒᵖ
⊢ (((fun k => NatTrans.mk fun c p => ↑k { fst := c, snd := p }.op) ∘
            ((fun ι =>
                  { val := fun j => ι.app j,
                    property :=
                      (_ :
                        ∀ {j j' : (Functor.Elements Y)ᵒᵖ} (f : j ⟶ j'),
                          ((CategoryOfElements.π Y).leftOp ⋙ A).map f ≫ (fun j => ι.app j) j' =
                            (fun j => ι.app j) j) }) ∘
                fun f =>
                (colimit.cocone ((CategoryOfElements.π Y).leftOp ⋙ A)).ι ≫
                  (Functor.const (Functor.Elements Y)ᵒᵖ).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) ((Functor.op (CategoryOfElements.map f)).obj J)

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