-- Module: Mathlib.AlgebraicTopology.SimplicialSet.Path
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⦌ ⋯)))
hₐ₃ 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 (⟨j + (↑i : ℕ), ⋯⟩ : Fin m)) ⋯ 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⦌ ⋯)))

Tactic:
rw [← Functor.map_comp_apply, ← op_comp, ← tr_comp,
      mkOfSucc_subinterval_eq]

Premises used: CategoryTheory.op_comp, SimplexCategory.Truncated.Hom.tr_comp, SimplexCategory.mkOfSucc_subinterval_eq, CategoryTheory.Functor.map_comp_apply