theorem extendAlongYoneda_map {X Y : Cᵒᵖ ⥤ Type u₁} (f : X ⟶ Y) :
    (extendAlongYoneda A).map f =
      colimit.pre ((CategoryOfElements.π Y).leftOp ⋙ A) (CategoryOfElements.map f).op := by
  ext J
  erw [colimit.ι_pre ((CategoryOfElements.π Y).leftOp ⋙ A) (CategoryOfElements.map f).op]
  dsimp only [extendAlongYoneda, restrictYonedaHomEquiv, IsColimit.homIso', IsColimit.homIso,
    uliftTrivial]
  -- porting note: in mathlib3 the rest of the proof was `simp, refl`; this is squeezed
  -- and appropriately reordered, presumably because of a non-confluence issue.
  

Proof state:
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 : (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 (Opposite.op { fst := c, snd := p }),
                  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 (Opposite.op { fst := c, snd := p })) x) =
                          x),
                  right_inv :=
                    (_ :
                      ∀ (x : P ⟶ (restrictedYoneda A).obj E),
                        (fun k => NatTrans.mk fun c p => ↑k (Opposite.op { fst := c, snd := p }))
                            ((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) ((CategoryOfElements.map f).op.obj J)

Next 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_ι]