-- Module: Mathlib.CategoryTheory.SmallObject.WellOrderInductionData
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 ⊥)
j : J
e : d.Extension val₀ j
i : J
hij : i ≤ j
k : J
hk : Order.IsSuccLimit k
hki : k ≤ i
rw :
  d.lift k hk
      (Subtype.mk (p :=
        fun
          (x :
            (j : { x : J // x ∈ Set.Iio k }ᵒᵖ) →
              obj
                (Functor.op
                    (Monotone.functor (f :=
                      (⇑(OrderHom.Subtype.val fun (x : J) ↦ x ∈ Set.Iio k) : (a : { x : J // x ∈ Set.Iio k }) → J)) ⋯) ⋙
                  F)
                j) ↦
        Membership.mem (γ :=
          Set
            ((j : { x : J // x ∈ Set.Iio k }ᵒᵖ) →
              obj
                (Functor.op
                    (Monotone.functor (f :=
                      (⇑(OrderHom.Subtype.val fun (x : J) ↦ x ∈ Set.Iio k) : (a : { x : J // x ∈ Set.Iio k }) → J)) ⋯) ⋙
                  F)
                j))
          (sections
            (Functor.op
                (Monotone.functor (f :=
                  (⇑(OrderHom.Subtype.val fun (x : J) ↦ x ∈ Set.Iio k) : (a : { x : J // x ∈ Set.Iio k }) → J)) ⋯) ⋙
              F))
          x)
        (fun (x : { x : J // x ∈ Set.Iio k }ᵒᵖ) ↦
          match (motive :=
            (x : { x : J // x ∈ Set.Iio k }ᵒᵖ) →
              obj
                (Functor.op
                    (Monotone.functor (f :=
                      (⇑(OrderHom.Subtype.val fun (x : J) ↦ x ∈ Set.Iio k) : (a : { x : J // x ∈ Set.Iio k }) → J)) ⋯) ⋙
                  F)
                x)
            x with
          | op ⟨k_1, hk⟩ =>
            (ConcreteCategory.hom (FC := TypeCat.Fun) (F.map (homOfLE ⋯).op) :
                (a : (fun (X : Type v) ↦ X) (F.obj (op j))) → (fun (X : Type v) ↦ X) (F.obj (op k_1)))
              e.val)
        ⋯) =
    d.lift k hk
      (Subtype.mk (p :=
        fun
          (x :
            (j : { x : J // x ∈ Set.Iio k }ᵒᵖ) →
              obj
                (Functor.op
                    (Monotone.functor (f :=
                      (⇑(OrderHom.Subtype.val fun (x : J) ↦ x ∈ Set.Iio k) : (a : { x : J // x ∈ Set.Iio k }) → J)) ⋯) ⋙
                  F)
                j) ↦
        Membership.mem (γ :=
          Set
            ((j : { x : J // x ∈ Set.Iio k }ᵒᵖ) →
              obj
                (Functor.op
                    (Monotone.functor (f :=
                      (⇑(OrderHom.Subtype.val fun (x : J) ↦ x ∈ Set.Iio k) : (a : { x : J // x ∈ Set.Iio k }) → J)) ⋯) ⋙
                  F)
                j))
          (sections
            (Functor.op
                (Monotone.functor (f :=
                  (⇑(OrderHom.Subtype.val fun (x : J) ↦ x ∈ Set.Iio k) : (a : { x : J // x ∈ Set.Iio k }) → J)) ⋯) ⋙
              F))
          x)
        (fun (x : { x : J // x ∈ Set.Iio k }ᵒᵖ) ↦
          match (motive :=
            (x : { x : J // x ∈ Set.Iio k }ᵒᵖ) →
              obj
                (Functor.op
                    (Monotone.functor (f :=
                      (⇑(OrderHom.Subtype.val fun (x : J) ↦ x ∈ Set.Iio k) : (a : { x : J // x ∈ Set.Iio k }) → J)) ⋯) ⋙
                  F)
                x)
            x with
          | op ⟨k_1, hk⟩ =>
            (ConcreteCategory.hom (FC := TypeCat.Fun) (F.map (homOfLE ⋯).op) :
                (a : (fun (X : Type v) ↦ X) (F.obj (op i))) → (fun (X : Type v) ↦ X) (F.obj (op k_1)))
              ((ConcreteCategory.hom (FC := TypeCat.Fun) (F.map (homOfLE hij).op) :
                    (a : (fun (X : Type v) ↦ X) (F.obj (op j))) → (fun (X : Type v) ↦ X) (F.obj (op i)))
                  e.val :
                (fun (X : Type v) ↦ X) (F.obj (op i))))
        ⋯)
⊢ (ConcreteCategory.hom (FC := TypeCat.Fun) (F.map (homOfLE hki).op) :
        (a : (fun (X : Type v) ↦ X) (F.obj (op i))) → (fun (X : Type v) ↦ X) (F.obj (op k)))
      ((ConcreteCategory.hom (FC := TypeCat.Fun) (F.map (homOfLE hij).op) :
            (a : (fun (X : Type v) ↦ X) (F.obj (op j))) → (fun (X : Type v) ↦ X) (F.obj (op i)))
          e.val :
        (fun (X : Type v) ↦ X) (F.obj (op i))) =
    d.lift k hk
      (Subtype.mk (p :=
        fun
          (x :
            (j : { x : J // x ∈ Set.Iio k }ᵒᵖ) →
              obj
                (Functor.op
                    (Monotone.functor (f :=
                      (⇑(OrderHom.Subtype.val fun (x : J) ↦ x ∈ Set.Iio k) : (a : { x : J // x ∈ Set.Iio k }) → J)) ⋯) ⋙
                  F)
                j) ↦
        Membership.mem (γ :=
          Set
            ((j : { x : J // x ∈ Set.Iio k }ᵒᵖ) →
              obj
                (Functor.op
                    (Monotone.functor (f :=
                      (⇑(OrderHom.Subtype.val fun (x : J) ↦ x ∈ Set.Iio k) : (a : { x : J // x ∈ Set.Iio k }) → J)) ⋯) ⋙
                  F)
                j))
          (sections
            (Functor.op
                (Monotone.functor (f :=
                  (⇑(OrderHom.Subtype.val fun (x : J) ↦ x ∈ Set.Iio k) : (a : { x : J // x ∈ Set.Iio k }) → J)) ⋯) ⋙
              F))
          x)
        (fun (x : { x : J // x ∈ Set.Iio k }ᵒᵖ) ↦
          match (motive :=
            (x : { x : J // x ∈ Set.Iio k }ᵒᵖ) →
              obj
                (Functor.op
                    (Monotone.functor (f :=
                      (⇑(OrderHom.Subtype.val fun (x : J) ↦ x ∈ Set.Iio k) : (a : { x : J // x ∈ Set.Iio k }) → J)) ⋯) ⋙
                  F)
                x)
            x with
          | op ⟨k_1, hk⟩ =>
            (ConcreteCategory.hom (FC := TypeCat.Fun) (F.map (homOfLE ⋯).op) :
                (a : (fun (X : Type v) ↦ X) (F.obj (op i))) → (fun (X : Type v) ↦ X) (F.obj (op k_1)))
              ((ConcreteCategory.hom (FC := TypeCat.Fun) (F.map (homOfLE hij).op) :
                    (a : (fun (X : Type v) ↦ X) (F.obj (op j))) → (fun (X : Type v) ↦ X) (F.obj (op i)))
                  e.val :
                (fun (X : Type v) ↦ X) (F.obj (op i))))
        ⋯)

Tactic:
rw [← comp_apply, ← map_comp, ← op_comp, homOfLE_comp,
      e.map_limit k hk (hki.trans hij)]

Premises used: CategoryTheory.op_comp, CategoryTheory.comp_apply, CategoryTheory.homOfLE_comp, CategoryTheory.Functor.map_comp, LE.le.trans, CategoryTheory.Functor.WellOrderInductionData.Extension.map_limit