/-- `ιInvApp` is the right inverse of `D.ι i` on `U`. -/
theorem π_ιInvApp_π (i j : D.J) (U : Opens (D.U i).carrier) :
    D.diagramOverOpenπ U i ≫ D.ιInvAppπEqMap U ≫ D.ιInvApp U ≫ D.diagramOverOpenπ U j =
      D.diagramOverOpenπ U j := by
  -- Porting note : originally, the proof of monotonicity was left a blank and proved in the end
  -- but Lean 4 doesn't like this any more, so the proof is restructured
  rw [← @cancel_mono (f := (componentwiseDiagram 𝖣.diagram.multispan _).map
    (Quiver.Hom.op (WalkingMultispan.Hom.snd (i, j))) ≫ 𝟙 _) _ _ (by
    rw [Category.comp_id]
    apply (config := { allowSynthFailures := true }) mono_comp
    change Mono ((_ ≫ D.f j i).c.app _)
    rw [comp_c_app]
    apply (config := { allowSynthFailures := true }) mono_comp
    erw [D.ι_image_preimage_eq i j U]
    · infer_instance
    · have : IsIso (D.t i j).c := by apply c_isIso_of_iso
      infer_instance)]
  simp_rw [Category.assoc]
  rw [limit.w_assoc]
  erw [limit.lift_π_assoc]
  rw [Category.comp_id, Category.comp_id]
  change _ ≫ _ ≫ (_ ≫ _) ≫ _ = _
  rw [congr_app (D.t_id _), id_c_app]
  simp_rw [Category.assoc]
  

Proof state:
C : Type u
inst✝¹ : Category.{v, u} C
D : GlueData C
inst✝ : HasLimits C
i j : D.J
U : Opens ↑↑(CategoryTheory.GlueData.U D.toGlueData i)
⊢ diagramOverOpenπ D U i ≫
      ιInvAppπEqMap D U ≫
        (f D.toGlueData i i).c.app (op U) ≫
          (V D.toGlueData (i, i)).presheaf.map (𝟙 ((Opens.map (f D.toGlueData i i).base).op.obj (op U))) ≫
            (V D.toGlueData (i, i)).presheaf.map
                (eqToHom
                  (_ :
                    (Opens.map (𝟙 (V D.toGlueData (i, i))).base).op.obj
                        ((Opens.map (f D.toGlueData i i).base).op.obj (op U)) =
                      (Opens.map (t D.toGlueData i i).base).op.obj
                        ((Opens.map (f D.toGlueData i i).base).op.obj (op U)))) ≫
              IsOpenImmersion.invApp (_ : IsOpenImmersion (f D.toGlueData i i))
                  {
                    carrier :=
                      ⇑(t D.toGlueData i i).base ⁻¹' ↑((Opens.map (f D.toGlueData i i).base).op.obj (op U)).unop,
                    is_open' :=
                      (_ :
                        IsOpen
                          (⇑(t D.toGlueData i i).base ⁻¹'
                            ↑((Opens.map (f D.toGlueData i i).base).op.obj (op U)).unop)) } ≫
                (CategoryTheory.GlueData.U D.toGlueData i).presheaf.map
                    (eqToHom
                        (_ :
                          (Opens.map (ι D.toGlueData i).base).obj
                              ((IsOpenMap.functor (_ : IsOpenMap ⇑(ι D.toGlueData i).base)).obj U) =
                            (IsOpenImmersion.openFunctor (_ : IsOpenImmersion (f D.toGlueData i i))).obj
                              ((Opens.map (t D.toGlueData i i).base).obj
                                ((Opens.map (f D.toGlueData i i).base).obj U)))).op ≫
                  (f D.toGlueData i j).c.app
                      (op
                        ((Opens.map (ι D.toGlueData i).base).obj
                          ((IsOpenMap.functor (_ : IsOpenMap ⇑(ι D.toGlueData i).base)).obj U))) ≫
                    (V D.toGlueData (i, j)).presheaf.map
                      (eqToHom
                        (_ :
                          (Opens.map (f D.toGlueData i j).base).op.obj
                              (op
                                ((Opens.map (ι D.toGlueData i).base).obj
                                  ((IsOpenMap.functor (_ : IsOpenMap ⇑(ι D.toGlueData i).base)).obj U))) =
                            op
                              ((Opens.map
                                    (colimit.ι (MultispanIndex.multispan (diagram D.toGlueData))
                                        (op (WalkingMultispan.left (i, j))).unop).base).obj
                                ((IsOpenMap.functor (_ : IsOpenMap ⇑(ι D.toGlueData i).base)).obj U)))) =
    limit.π (diagramOverOpen D U) (op (WalkingMultispan.left (i, j)))

Next tactic:
rw [← Functor.map_comp_assoc]