-- Module: Mathlib.CategoryTheory.Sites.Coherent.RegularSheaves
Goal:
C : Type u_1
inst : Category.{v_1, u_1} C
P : Functor.{v_1, u_4, u_1, u_4 + 1} Cᵒᵖ (Type u_4)
X B : C
π : X ⟶ B
inst_1 : EffectiveEpi π
c : PullbackCone π π
hc : IsLimit c
this : HasPullback π π
hP :
  ∀
    (b :
      (fun (X : Type u_4) ↦ X)
        (↑{x : P.obj (op X) |
              Eq (α := (fun (X : Type u_4) ↦ X) (P.obj (op (pullback π π))))
                ((ConcreteCategory.hom (FC := TypeCat.Fun) (P.map (Quiver.Hom.op (pullback.fst π π))) :
                      (a : (fun (X : Type u_4) ↦ X) (P.obj (op X))) →
                        (fun (X : Type u_4) ↦ X) (P.obj (op (pullback π π))))
                    x :
                  (fun (X : Type u_4) ↦ X) (P.obj (op (pullback π π))))
                ((ConcreteCategory.hom (FC := TypeCat.Fun) (P.map (Quiver.Hom.op (pullback.snd π π))) :
                      (a : (fun (X : Type u_4) ↦ X) (P.obj (op X))) →
                        (fun (X : Type u_4) ↦ X) (P.obj (op (pullback π π))))
                    x :
                  (fun (X : Type u_4) ↦ X) (P.obj (op (pullback π π))))} :
          Type u_4)),
    ∃! a : (fun (X : Type u_4) ↦ X) (P.obj (op B)),
      (ConcreteCategory.hom (FC := TypeCat.Fun) (mapToEqualizer P π (pullback.fst π π) (pullback.snd π π) ⋯) :
            (a : (fun (X : Type u_4) ↦ X) (P.obj (op B))) →
              (fun (X : Type u_4) ↦ X)
                (↑{x : P.obj (op X) |
                      (ConcreteCategory.hom (P.map (pullback.fst π π).op) :
                            (a : (fun (X : Type u_4) ↦ X) (P.obj (op X))) →
                              (fun (X : Type u_4) ↦ X) (P.obj (op (pullback π π))))
                          x =
                        (ConcreteCategory.hom (P.map (pullback.snd π π).op) :
                            (a : (fun (X : Type u_4) ↦ X) (P.obj (op X))) →
                              (fun (X : Type u_4) ↦ X) (P.obj (op (pullback π π))))
                          x} :
                  Type u_4))
          a =
        b
b : P.obj (op X)
hb :
  Eq (α := (fun (X : Type u_4) ↦ X) (P.obj (op c.pt)))
    ((ConcreteCategory.hom (FC := TypeCat.Fun) (P.map c.fst.op) :
          (a : (fun (X : Type u_4) ↦ X) (P.obj (op X))) → (fun (X : Type u_4) ↦ X) (P.obj (op c.pt)))
        b :
      (fun (X : Type u_4) ↦ X) (P.obj (op c.pt)))
    ((ConcreteCategory.hom (FC := TypeCat.Fun) (P.map c.snd.op) :
          (a : (fun (X : Type u_4) ↦ X) (P.obj (op X))) → (fun (X : Type u_4) ↦ X) (P.obj (op c.pt)))
        b :
      (fun (X : Type u_4) ↦ X) (P.obj (op c.pt)))
h₁ :
  Eq (α := (PullbackCone.mk (W := pullback π π) (pullback.fst π π) (pullback.snd π π) ⋯).pt ⟶ X)
    (Iso.hom (IsLimit.conePointUniqueUpToIso (pullbackIsPullback π π) hc) ≫ c.fst) (pullback.fst π π)
rw :
  Eq (α := (fun (X : Type u_4) ↦ X) (P.obj (op (pullback π π))))
    ((ConcreteCategory.hom (FC := TypeCat.Fun)
            (P.map (Quiver.Hom.op (Iso.hom (IsLimit.conePointUniqueUpToIso (pullbackIsPullback π π) hc)))) :
          (a : P.obj (op c.pt)) → P.obj (op (pullback π π)))
        ((ConcreteCategory.hom (FC := TypeCat.Fun) (P.map c.snd.op) :
              (a : (fun (X : Type u_4) ↦ X) (P.obj (op X))) → (fun (X : Type u_4) ↦ X) (P.obj (op c.pt)))
            b :
          (fun (X : Type u_4) ↦ X) (P.obj (op c.pt))) :
      P.obj (op (pullback π π)))
    ((ConcreteCategory.hom (FC := TypeCat.Fun) (P.map (Quiver.Hom.op (pullback.snd π π))) :
          (a : (fun (X : Type u_4) ↦ X) (P.obj (op X))) → (fun (X : Type u_4) ↦ X) (P.obj (op (pullback π π))))
        b :
      (fun (X : Type u_4) ↦ X) (P.obj (op (pullback π π))))
⊢ Eq (α := (fun (X : Type u_4) ↦ X) (P.obj (op (pullback π π))))
    ((ConcreteCategory.hom (FC := TypeCat.Fun) (P.map (Quiver.Hom.op (pullback.fst π π))) :
          (a : (fun (X : Type u_4) ↦ X) (P.obj (op X))) → (fun (X : Type u_4) ↦ X) (P.obj (op (pullback π π))))
        b :
      (fun (X : Type u_4) ↦ X) (P.obj (op (pullback π π))))
    ((ConcreteCategory.hom (FC := TypeCat.Fun) (P.map (Quiver.Hom.op (pullback.snd π π))) :
          (a : (fun (X : Type u_4) ↦ X) (P.obj (op X))) → (fun (X : Type u_4) ↦ X) (P.obj (op (pullback π π))))
        b :
      (fun (X : Type u_4) ↦ X) (P.obj (op (pullback π π))))

Tactic:
rw [← h₁, op_comp, Functor.map_comp, comp_apply, hb]

Premises used: CategoryTheory.op_comp, CategoryTheory.comp_apply, CategoryTheory.Functor.map_comp