/-- The equivalence induced by `PartialFunToPointed` and `PointedToPartialFun`.
`Part.equivOption` made functorial. -/
@[simps!]
noncomputable def partialFunEquivPointed : PartialFun.{u} ≌ Pointed :=
  CategoryTheory.Equivalence.mk partialFunToPointed pointedToPartialFun
    (NatIso.ofComponents (fun X => PartialFun.Iso.mk
      { toFun := fun a => ⟨some a, some_ne_none a⟩
        invFun := fun a => Option.get _ (Option.ne_none_iff_isSome.1 a.2)
        left_inv := fun a => Option.get_some _ _
        right_inv := fun a => by simp only [some_get, Subtype.coe_eta] })
      fun f =>
        PFun.ext fun a b => by
          dsimp [PartialFun.Iso.mk, CategoryStruct.comp, pointedToPartialFun]
          rw [Part.bind_some]
          -- porting note: the proof below has changed a lot because
          -- `Part.mem_bind_iff` means that `b ∈ Part.bind f g` is equivalent
          -- to `∃ (a : α), a ∈ f ∧ b ∈ g a`, while in mathlib3 it was equivalent
          -- to `∃ (a : α) (H : a ∈ f), b ∈ g a`
          refine' (Part.mem_bind_iff.trans _).trans PFun.mem_toSubtype_iff.symm
          obtain ⟨b | b, hb⟩ := b
          · exact (hb rfl).elim
          · dsimp [Part.toOption]
            simp_rw [Part.mem_some_iff, Subtype.mk_eq_mk]
            constructor
            · rintro ⟨_, ⟨h₁, h₂⟩, h₃⟩
              rw [h₃, ← h₂, dif_pos h₁]
            · intro h
              split_ifs at h with ha
              rw [some_inj] at h
              refine' ⟨b, ⟨ha, h.symm⟩, rfl⟩)
    (NatIso.ofComponents (fun X => Pointed.Iso.mk
      { toFun := Option.elim' X.point Subtype.val
        invFun := fun a => by
          classical
          exact if h : a = X.point then none else some ⟨_, h⟩
        left_inv := fun a => Option.recOn a (dif_pos rfl) fun a => by
          dsimp
          rw [dif_neg a.2]
          rfl
        right_inv := fun a => by
          dsimp
          split_ifs with h
          · rw [h]
            rfl
          · rfl} rfl)
      fun {X Y} f =>
      Pointed.Hom.ext _ _ <|
        funext fun a =>
          Option.recOn a f.map_point.symm (by
            

Proof state:
α : Type u_1
β : Type u_2
X Y : Pointed
f : X ⟶ Y
a : ((pointedToPartialFun ⋙ partialFunToPointed).obj X).X
⊢ ∀ (val : pointedToPartialFun.obj X),
    Pointed.Hom.toFun
        ((pointedToPartialFun ⋙ partialFunToPointed).map f ≫
          ((fun X =>
                Pointed.Iso.mk
                  { toFun := Option.elim' X.point Subtype.val,
                    invFun := fun a => if h : a = X.point then none else some { val := a, property := h },
                    left_inv :=
                      (_ :
                        ∀ (a : ((pointedToPartialFun ⋙ partialFunToPointed).obj X).X),
                          (fun a => if h : a = X.point then none else some { val := a, property := h })
                              (Option.elim' X.point Subtype.val a) =
                            a),
                    right_inv :=
                      (_ :
                        ∀ (a : ((𝟭 Pointed).obj X).X),
                          Option.elim' X.point Subtype.val
                              ((fun a => if h : a = X.point then none else some { val := a, property := h }) a) =
                            a) }
                  (_ :
                    { toFun := Option.elim' X.point Subtype.val,
                          invFun := fun a => if h : a = X.point then none else some { val := a, property := h },
                          left_inv :=
                            (_ :
                              ∀ (a : ((pointedToPartialFun ⋙ partialFunToPointed).obj X).X),
                                (fun a => if h : a = X.point then none else some { val := a, property := h })
                                    (Option.elim' X.point Subtype.val a) =
                                  a),
                          right_inv :=
                            (_ :
                              ∀ (a : ((𝟭 Pointed).obj X).X),
                                Option.elim' X.point Subtype.val
                                    ((fun a => if h : a = X.point then none else some { val := a, property := h }) a) =
                                  a) }
                        ((pointedToPartialFun ⋙ partialFunToPointed).obj X).point =
                      { toFun := Option.elim' X.point Subtype.val,
                          invFun := fun a => if h : a = X.point then none else some { val := a, property := h },
                          left_inv :=
                            (_ :
                              ∀ (a : ((pointedToPartialFun ⋙ partialFunToPointed).obj X).X),
                                (fun a => if h : a = X.point then none else some { val := a, property := h })
                                    (Option.elim' X.point Subtype.val a) =
                                  a),
                          right_inv :=
                            (_ :
                              ∀ (a : ((𝟭 Pointed).obj X).X),
                                Option.elim' X.point Subtype.val
                                    ((fun a => if h : a = X.point then none else some { val := a, property := h }) a) =
                                  a) }
                        ((pointedToPartialFun ⋙ partialFunToPointed).obj X).point))
              Y).hom)
        (some val) =
      Pointed.Hom.toFun
        (((fun X =>
                Pointed.Iso.mk
                  { toFun := Option.elim' X.point Subtype.val,
                    invFun := fun a => if h : a = X.point then none else some { val := a, property := h },
                    left_inv :=
                      (_ :
                        ∀ (a : ((pointedToPartialFun ⋙ partialFunToPointed).obj X).X),
                          (fun a => if h : a = X.point then none else some { val := a, property := h })
                              (Option.elim' X.point Subtype.val a) =
                            a),
                    right_inv :=
                      (_ :
                        ∀ (a : ((𝟭 Pointed).obj X).X),
                          Option.elim' X.point Subtype.val
                              ((fun a => if h : a = X.point then none else some { val := a, property := h }) a) =
                            a) }
                  (_ :
                    { toFun := Option.elim' X.point Subtype.val,
                          invFun := fun a => if h : a = X.point then none else some { val := a, property := h },
                          left_inv :=
                            (_ :
                              ∀ (a : ((pointedToPartialFun ⋙ partialFunToPointed).obj X).X),
                                (fun a => if h : a = X.point then none else some { val := a, property := h })
                                    (Option.elim' X.point Subtype.val a) =
                                  a),
                          right_inv :=
                            (_ :
                              ∀ (a : ((𝟭 Pointed).obj X).X),
                                Option.elim' X.point Subtype.val
                                    ((fun a => if h : a = X.point then none else some { val := a, property := h }) a) =
                                  a) }
                        ((pointedToPartialFun ⋙ partialFunToPointed).obj X).point =
                      { toFun := Option.elim' X.point Subtype.val,
                          invFun := fun a => if h : a = X.point then none else some { val := a, property := h },
                          left_inv :=
                            (_ :
                              ∀ (a : ((pointedToPartialFun ⋙ partialFunToPointed).obj X).X),
                                (fun a => if h : a = X.point then none else some { val := a, property := h })
                                    (Option.elim' X.point Subtype.val a) =
                                  a),
                          right_inv :=
                            (_ :
                              ∀ (a : ((𝟭 Pointed).obj X).X),
                                Option.elim' X.point Subtype.val
                                    ((fun a => if h : a = X.point then none else some { val := a, property := h }) a) =
                                  a) }
                        ((pointedToPartialFun ⋙ partialFunToPointed).obj X).point))
              X).hom ≫
          (𝟭 Pointed).map f)
        (some val)

Next tactic:
rintro ⟨a, ha⟩