/-- `ι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]
  rw [← Functor.map_comp_assoc]
  -- Porting note : change `rw` to `erw`
  erw [IsOpenImmersion.inv_naturality_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) ≫
          IsOpenImmersion.invApp (_ : IsOpenImmersion (f D.toGlueData i i))
              ((Opens.map (f D.toGlueData i i).base).op.obj (op U)).unop ≫
            (CategoryTheory.GlueData.U D.toGlueData i).presheaf.map
                ((IsOpenImmersion.openFunctor (_ : IsOpenImmersion (f D.toGlueData i i))).op.map
                  (𝟙 ((Opens.map (f D.toGlueData i i).base).op.obj (op U)) ≫
                    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))))) ≫
              (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:
erw [IsOpenImmersion.app_invApp_assoc]