-- Lean 4 proof step from Mathlib.CategoryTheory.SmallObject.WellOrderInductionData (goal)
Goal:
J : Type u
inst : LinearOrder J
inst_1 : SuccOrder J
F : Functor.{u, v, u, v + 1} Jᵒᵖ (Type v)
d : F.WellOrderInductionData
inst_2 : OrderBot J
val₀ : F.obj (op ⊥)
inst_3 : WellFoundedLT J
j : J
hj : Order.IsSuccLimit j
e : (i : J) → i < j → d.Extension val₀ i
j_1 j' : { x : J // x ∈ Set.Iio j }ᵒᵖ
f : j_1 ⟶ j'
⊢ Eq (α :=
    (fun (X : Type v) ↦ X)
      (obj
        (Functor.op
            (Monotone.functor (f :=
              (⇑(OrderHom.Subtype.val fun (x : J) ↦ x ∈ Set.Iio j) : (a : { x : J // x ∈ Set.Iio j }) → J)) ⋯) ⋙
          F)
        j'))
    ((ConcreteCategory.hom (FC := TypeCat.Fun)
            (map
              (Functor.op
                  (Monotone.functor (f :=
                    (⇑(OrderHom.Subtype.val fun (x : J) ↦ x ∈ Set.Iio j) : (a : { x : J // x ∈ Set.Iio j }) → J)) ⋯) ⋙
                F)
              f) :
          (a : (fun (X : Type v) ↦ X) ((⋯.functor.op ⋙ F).obj j_1)) →
            (fun (X : Type v) ↦ X) ((⋯.functor.op ⋙ F).obj j'))
        ((fun (x : { x : J // x ∈ Set.Iio j }ᵒᵖ) ↦
            (match (motive :=
                (x : { x : J // x ∈ Set.Iio j }ᵒᵖ) →
                  obj
                    (Functor.op
                        (Monotone.functor (f :=
                          (⇑(OrderHom.Subtype.val fun (x : J) ↦ x ∈ Set.Iio j) : (a : { x : J // x ∈ Set.Iio j }) → J))
                          ⋯) ⋙
                      F)
                    x)
                x with
              | op ⟨i, hi⟩ => (e i hi).val :
              obj
                (Functor.op
                    (Monotone.functor (f :=
                      (⇑(OrderHom.Subtype.val fun (x : J) ↦ x ∈ Set.Iio j) : (a : { x : J // x ∈ Set.Iio j }) → J)) ⋯) ⋙
                  F)
                x))
          j_1) :
      (fun (X : Type v) ↦ X)
        (obj
          (Functor.op
              (Monotone.functor (f :=
                (⇑(OrderHom.Subtype.val fun (x : J) ↦ x ∈ Set.Iio j) : (a : { x : J // x ∈ Set.Iio j }) → J)) ⋯) ⋙
            F)
          j'))
    ((fun (x : { x : J // x ∈ Set.Iio j }ᵒᵖ) ↦
          (match (motive :=
              (x : { x : J // x ∈ Set.Iio j }ᵒᵖ) →
                obj
                  (Functor.op
                      (Monotone.functor (f :=
                        (⇑(OrderHom.Subtype.val fun (x : J) ↦ x ∈ Set.Iio j) : (a : { x : J // x ∈ Set.Iio j }) → J))
                        ⋯) ⋙
                    F)
                  x)
              x with
            | op ⟨i, hi⟩ => (e i hi).val :
            obj
              (Functor.op
                  (Monotone.functor (f :=
                    (⇑(OrderHom.Subtype.val fun (x : J) ↦ x ∈ Set.Iio j) : (a : { x : J // x ∈ Set.Iio j }) → J)) ⋯) ⋙
                F)
              x))
        j' :
      obj
        (Functor.op
            (Monotone.functor (f :=
              (⇑(OrderHom.Subtype.val fun (x : J) ↦ x ∈ Set.Iio j) : (a : { x : J // x ∈ Set.Iio j }) → J)) ⋯) ⋙
          F)
        j')
have dsimp : Eq (α := F.obj (op (↑(unop j') : J)))
  ((@ConcreteCategory.hom _ types TypeCat.Fun _ _ _ _ _
          (F.map
            (Quiver.Hom.op (map (Monotone.functor (f := Subtype.val (p := fun (x : J) ↦ x ∈ Set.Iio j)) sorry) f.unop))) :
        (a : F.obj (op (↑(unop j_1) : J))) → F.obj (op (↑(unop j') : J)))
      (val (e (↑j_1.1 : J) sorry)) :
    F.obj (op (↑(unop j') : J)))
  (val (e (↑j'.1 : J) sorry) : F.obj (op (↑j'.1 : J)))
Tactic: dsimp