/-- 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
            rintro ⟨a, ha⟩
            

Proof state:
case mk
α : Type u_1
β : Type u_2
X Y : Pointed
f : X ⟶ Y
a✝ : ((pointedToPartialFun ⋙ partialFunToPointed).obj X).X
a : X.X
ha : a ≠ X.point
⊢ 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 := a, property := ha }) =
    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 := a, property := ha })

Next tactic:
change Option.elim' _ _ _ = f.toFun a