-- Lean 4 proof step from Mathlib.AlgebraicTopology.SimplicialSet.Path (goal)
Goal:
n : ℕ
X : Truncated (n + 1)
m : ℕ
hₘ : m ≤ n + 1
j l : ℕ
h : j + l ≤ m
Δ : X.obj (op (ObjectProperty.FullSubcategory.mk (P := fun (a : SimplexCategory) ↦ a.len ≤ n + 1) ⦋m⦌ hₘ))
i : Fin l
hₐ :
  Eq (α := X.obj (op (ObjectProperty.FullSubcategory.mk (P := fun (a : SimplexCategory) ↦ a.len ≤ n + 1) ⦋1⦌ ⋯)))
    ((ConcreteCategory.hom (FC := TypeCat.Fun)
            (X.map ((tr (subinterval j l h) ⋯ hₘ).op ≫ Quiver.Hom.op (tr (mkOfSucc i) ⋯ ⋯))) :
          (a : X.obj (op { obj := ⦋m⦌, property := hₘ })) → X.obj (op { obj := ⦋1⦌, property := ⋯ }))
        Δ :
      X.obj (op (ObjectProperty.FullSubcategory.mk (P := fun (a : SimplexCategory) ↦ a.len ≤ n + 1) ⦋1⦌ ⋯)))
    (Path.arrow
        { vertex := fun (i : Fin (l + 1)) ↦ (X.spine m hₘ Δ).vertex ⟨j + (↑i : ℕ), ⋯⟩,
          arrow := fun (i : Fin l) ↦
            (ConcreteCategory.hom (FC := TypeCat.Fun)
                  (X.map (Quiver.Hom.op (tr (mkOfSucc (⟨j + (↑i : ℕ), ⋯⟩ : Fin m)) ⋯ hₘ))) :
                (a : X.obj (op { obj := ⦋m⦌, property := hₘ })) → X.obj (op { obj := ⦋1⦌, property := ⋯ }))
              Δ,
          arrow_src := ⋯, arrow_tgt := ⋯ }
        i :
      X.obj (op (ObjectProperty.FullSubcategory.mk (P := fun (a : SimplexCategory) ↦ a.len ≤ n + 1) ⦋1⦌ ⋯)))
hₐ₁ :
  Eq (α := X.obj (op (ObjectProperty.FullSubcategory.mk (P := fun (a : SimplexCategory) ↦ a.len ≤ n + 1) ⦋1⦌ ⋯)))
    ((ConcreteCategory.hom (FC := TypeCat.Fun)
            (X.map (Quiver.Hom.op (tr (mkOfSucc i) ⋯ ⋯ ≫ tr (subinterval j l h) ⋯ hₘ))) :
          (a : X.obj (op { obj := ⦋m⦌, property := hₘ })) → X.obj (op { obj := ⦋1⦌, property := ⋯ }))
        Δ :
      X.obj (op (ObjectProperty.FullSubcategory.mk (P := fun (a : SimplexCategory) ↦ a.len ≤ n + 1) ⦋1⦌ ⋯)))
    (Path.arrow
        { vertex := fun (i : Fin (l + 1)) ↦ (X.spine m hₘ Δ).vertex ⟨j + (↑i : ℕ), ⋯⟩,
          arrow := fun (i : Fin l) ↦
            (ConcreteCategory.hom (FC := TypeCat.Fun)
                  (X.map (Quiver.Hom.op (tr (mkOfSucc (⟨j + (↑i : ℕ), ⋯⟩ : Fin m)) ⋯ hₘ))) :
                (a : X.obj (op { obj := ⦋m⦌, property := hₘ })) → X.obj (op { obj := ⦋1⦌, property := ⋯ }))
              Δ,
          arrow_src := ⋯, arrow_tgt := ⋯ }
        i :
      X.obj (op (ObjectProperty.FullSubcategory.mk (P := fun (a : SimplexCategory) ↦ a.len ≤ n + 1) ⦋1⦌ ⋯)))
hₐ₂ :
  Eq (α := X.obj (op (ObjectProperty.FullSubcategory.mk (P := fun (a : SimplexCategory) ↦ a.len ≤ n + 1) ⦋1⦌ ⋯)))
    ((ConcreteCategory.hom (FC := TypeCat.Fun) (X.map (Quiver.Hom.op (tr (mkOfSucc i ≫ subinterval j l h) ⋯ hₘ))) :
          (a : X.obj (op { obj := ⦋m⦌, property := hₘ })) → X.obj (op { obj := ⦋1⦌, property := ⋯ }))
        Δ :
      X.obj (op (ObjectProperty.FullSubcategory.mk (P := fun (a : SimplexCategory) ↦ a.len ≤ n + 1) ⦋1⦌ ⋯)))
    (Path.arrow
        { vertex := fun (i : Fin (l + 1)) ↦ (X.spine m hₘ Δ).vertex ⟨j + (↑i : ℕ), ⋯⟩,
          arrow := fun (i : Fin l) ↦
            (ConcreteCategory.hom (FC := TypeCat.Fun)
                  (X.map (Quiver.Hom.op (tr (mkOfSucc (⟨j + (↑i : ℕ), ⋯⟩ : Fin m)) ⋯ hₘ))) :
                (a : X.obj (op { obj := ⦋m⦌, property := hₘ })) → X.obj (op { obj := ⦋1⦌, property := ⋯ }))
              Δ,
          arrow_src := ⋯, arrow_tgt := ⋯ }
        i :
      X.obj (op (ObjectProperty.FullSubcategory.mk (P := fun (a : SimplexCategory) ↦ a.len ≤ n + 1) ⦋1⦌ ⋯)))
⊢ Eq (α := X.obj (op (ObjectProperty.FullSubcategory.mk (P := fun (a : SimplexCategory) ↦ a.len ≤ n + 1) ⦋1⦌ ⋯)))
    ((ConcreteCategory.hom (FC := TypeCat.Fun) (X.map (Quiver.Hom.op (tr (mkOfSucc i) ⋯ ⋯))) :
          (a : X.obj (op { obj := ⦋l⦌, property := ⋯ })) → X.obj (op { obj := ⦋1⦌, property := ⋯ }))
        ((ConcreteCategory.hom (FC := TypeCat.Fun) (X.map (tr (subinterval j l h) ⋯ hₘ).op) :
              (a : X.obj (op { obj := ⦋m⦌, property := hₘ })) → X.obj (op { obj := ⦋l⦌, property := ⋯ }))
            Δ :
          X.obj (op (ObjectProperty.FullSubcategory.mk (P := fun (a : SimplexCategory) ↦ a.len ≤ n + 1) ⦋l⦌ ⋯))) :
      X.obj (op (ObjectProperty.FullSubcategory.mk (P := fun (a : SimplexCategory) ↦ a.len ≤ n + 1) ⦋1⦌ ⋯)))
    (Path.arrow
        { vertex := fun (i : Fin (l + 1)) ↦ (X.spine m hₘ Δ).vertex ⟨j + (↑i : ℕ), ⋯⟩,
          arrow := fun (i : Fin l) ↦
            (ConcreteCategory.hom (FC := TypeCat.Fun)
                  (X.map (Quiver.Hom.op (tr (mkOfSucc (⟨j + (↑i : ℕ), ⋯⟩ : Fin m)) ⋯ hₘ))) :
                (a : X.obj (op { obj := ⦋m⦌, property := hₘ })) → X.obj (op { obj := ⦋1⦌, property := ⋯ }))
              Δ,
          arrow_src := ⋯, arrow_tgt := ⋯ }
        i :
      X.obj (op (ObjectProperty.FullSubcategory.mk (P := fun (a : SimplexCategory) ↦ a.len ≤ n + 1) ⦋1⦌ ⋯)))
have hₐ₃ : Eq (α := X.obj (op (ObjectProperty.FullSubcategory.mk (P := fun (a : SimplexCategory) ↦ a.len ≤ n + 1) ⦋1⦌ sorry)))
  ((ConcreteCategory.hom (FC := TypeCat.Fun) (X.map (Quiver.Hom.op (tr (mkOfSucc (⟨j + (↑i : ℕ), sorry⟩ : Fin m)) sorry hₘ))) :
        (a : X.obj (op { obj := ⦋m⦌, property := hₘ })) → X.obj (op { obj := ⦋1⦌, property := sorry }))
      Δ :
    X.obj (op (ObjectProperty.FullSubcategory.mk (P := fun (a : SimplexCategory) ↦ a.len ≤ n + 1) ⦋1⦌ sorry)))
  (Path.arrow
      { vertex := fun (i : Fin (l + 1)) ↦ (X.spine m hₘ Δ).vertex ⟨j + (↑i : ℕ), sorry⟩,
        arrow := fun (i : Fin l) ↦
          (ConcreteCategory.hom (FC := TypeCat.Fun)
                (X.map (Quiver.Hom.op (tr (mkOfSucc (⟨j + (↑i : ℕ), sorry⟩ : Fin m)) sorry hₘ))) :
              (a : X.obj (op { obj := ⦋m⦌, property := hₘ })) → X.obj (op { obj := ⦋1⦌, property := sorry }))
            Δ,
        arrow_src := sorry, arrow_tgt := sorry }
      i :
    X.obj (op (ObjectProperty.FullSubcategory.mk (P := fun (a : SimplexCategory) ↦ a.len ≤ n + 1) ⦋1⦌ sorry)))
Tactic: rw [← Functor.map_comp_apply, ← op_comp, ← tr_comp,
      mkOfSucc_subinterval_eq]