theorem opensImagePreimageMap_app' (i j k : D.J) (U : Opens (D.U i).carrier) :
    ∃ eq,
      D.opensImagePreimageMap i j U ≫ (D.f j k).c.app _ =
        ((π₁ j, i, k) ≫ D.t j i ≫ D.f i j).c.app (op U) ≫
          (π₂⁻¹ j, i, k) (unop _) ≫ (D.V (j, k)).presheaf.map (eqToHom eq) := by
  constructor
  delta opensImagePreimageMap
  simp_rw [Category.assoc]
  rw [(D.f j k).c.naturality, f_invApp_f_app_assoc]
  erw [← (D.V (j, k)).presheaf.map_comp]
  simp_rw [← Category.assoc]
  erw [← comp_c_app, ← comp_c_app]
  

Proof state:
case h
C : Type u
inst✝¹ : Category.{v, u} C
D : GlueData C
inst✝ : HasLimits C
i j k : D.J
U : Opens ↑↑(CategoryTheory.GlueData.U D.toGlueData i)
⊢ ((pullback.fst ≫ t D.toGlueData j i ≫ f D.toGlueData i j).c.app (op U) ≫
        IsOpenImmersion.invApp (_ : IsOpenImmersion pullback.snd)
          {
            carrier :=
              ⇑pullback.fst.base ⁻¹'
                ↑(op
                      {
                        carrier :=
                          ⇑(t D.toGlueData j i).base ⁻¹' ↑((Opens.map (f D.toGlueData i j).base).op.obj (op U)).unop,
                        is_open' :=
                          (_ :
                            IsOpen
                              (⇑(t D.toGlueData j i).base ⁻¹'
                                ↑((Opens.map (f D.toGlueData i j).base).op.obj (op U)).unop)) }).unop,
            is_open' :=
              (_ :
                IsOpen
                  (⇑pullback.fst.base ⁻¹'
                    ↑(op
                          {
                            carrier :=
                              ⇑(t D.toGlueData j i).base ⁻¹'
                                ↑((Opens.map (f D.toGlueData i j).base).op.obj (op U)).unop,
                            is_open' :=
                              (_ :
                                IsOpen
                                  (⇑(t D.toGlueData j i).base ⁻¹'
                                    ↑((Opens.map (f D.toGlueData i j).base).op.obj (op U)).unop)) }).unop)) }) ≫
      (V D.toGlueData (j, k)).presheaf.map
        (eqToHom
            (_ :
              op
                  ((IsOpenImmersion.openFunctor (_ : IsOpenImmersion pullback.snd)).obj
                    {
                        unop :=
                          {
                            carrier :=
                              ⇑pullback.fst.base ⁻¹'
                                ↑(op
                                      {
                                        carrier :=
                                          ⇑(t D.toGlueData j i).base ⁻¹'
                                            ↑((Opens.map (f D.toGlueData i j).base).op.obj (op U)).unop,
                                        is_open' :=
                                          (_ :
                                            IsOpen
                                              (⇑(t D.toGlueData j i).base ⁻¹'
                                                ↑((Opens.map (f D.toGlueData i j).base).op.obj (op U)).unop)) }).unop,
                            is_open' :=
                              (_ :
                                IsOpen
                                  (⇑pullback.fst.base ⁻¹'
                                    ↑(op
                                          {
                                            carrier :=
                                              ⇑(t D.toGlueData j i).base ⁻¹'
                                                ↑((Opens.map (f D.toGlueData i j).base).op.obj (op U)).unop,
                                            is_open' :=
                                              (_ :
                                                IsOpen
                                                  (⇑(t D.toGlueData j i).base ⁻¹'
                                                    ↑((Opens.map (f D.toGlueData i j).base).op.obj
                                                          (op U)).unop)) }).unop)) } }.unop) =
                (Opens.map (f D.toGlueData j k).base).op.obj
                  (op
                    ((IsOpenImmersion.openFunctor (_ : IsOpenImmersion (f D.toGlueData j i))).obj
                      {
                        carrier :=
                          ⇑(t D.toGlueData j i).base ⁻¹' ↑((Opens.map (f D.toGlueData i j).base).op.obj (op U)).unop,
                        is_open' :=
                          (_ :
                            IsOpen
                              (⇑(t D.toGlueData j i).base ⁻¹'
                                ↑((Opens.map (f D.toGlueData i j).base).op.obj (op U)).unop)) }))) ≫
          (Opens.map (f D.toGlueData j k).base).op.map
            (eqToHom
                (_ :
                  (Opens.map (ι D.toGlueData j).base).obj
                      ((IsOpenMap.functor (_ : IsOpenMap ⇑(ι D.toGlueData i).base)).obj U) =
                    (IsOpenImmersion.openFunctor (_ : IsOpenImmersion (f D.toGlueData j i))).obj
                      ((Opens.map (t D.toGlueData j i).base).obj ((Opens.map (f D.toGlueData i j).base).obj U)))).op) =
    ((pullback.fst ≫ t D.toGlueData j i ≫ f D.toGlueData i j).c.app (op U) ≫
        IsOpenImmersion.invApp (_ : IsOpenImmersion pullback.snd)
          { carrier := ⇑(pullback.fst ≫ t D.toGlueData j i ≫ f D.toGlueData i j).base ⁻¹' ↑(op U).unop,
            is_open' :=
              (_ : IsOpen (⇑(pullback.fst ≫ t D.toGlueData j i ≫ f D.toGlueData i j).base ⁻¹' ↑(op U).unop)) }) ≫
      (V D.toGlueData (j, k)).presheaf.map (eqToHom ?w)
case w
C : Type u
inst✝¹ : Category.{v, u} C
D : GlueData C
inst✝ : HasLimits C
i j k : D.J
U : Opens ↑↑(CategoryTheory.GlueData.U D.toGlueData i)
⊢ op
      ((IsOpenImmersion.openFunctor (_ : IsOpenImmersion pullback.snd)).obj
        {
            unop :=
              { carrier := ⇑(pullback.fst ≫ t D.toGlueData j i ≫ f D.toGlueData i j).base ⁻¹' ↑(op U).unop,
                is_open' :=
                  (_ :
                    IsOpen
                      (⇑(pullback.fst ≫ t D.toGlueData j i ≫ f D.toGlueData i j).base ⁻¹' ↑(op U).unop)) } }.unop) =
    (Opens.map (f D.toGlueData j k).base).op.obj
      (op
        ((Opens.map (ι D.toGlueData j).base).obj ((IsOpenMap.functor (_ : IsOpenMap ⇑(ι D.toGlueData i).base)).obj U)))
case w
C : Type u
inst✝¹ : Category.{v, u} C
D : GlueData C
inst✝ : HasLimits C
i j k : D.J
U : Opens ↑↑(CategoryTheory.GlueData.U D.toGlueData i)
⊢ op
      ((IsOpenImmersion.openFunctor (_ : IsOpenImmersion pullback.snd)).obj
        {
            unop :=
              { carrier := ⇑(pullback.fst ≫ t D.toGlueData j i ≫ f D.toGlueData i j).base ⁻¹' ↑(op U).unop,
                is_open' :=
                  (_ :
                    IsOpen
                      (⇑(pullback.fst ≫ t D.toGlueData j i ≫ f D.toGlueData i j).base ⁻¹' ↑(op U).unop)) } }.unop) =
    (Opens.map (f D.toGlueData j k).base).op.obj
      (op
        ((Opens.map (ι D.toGlueData j).base).obj ((IsOpenMap.functor (_ : IsOpenMap ⇑(ι D.toGlueData i).base)).obj U)))
case w
C : Type u
inst✝¹ : Category.{v, u} C
D : GlueData C
inst✝ : HasLimits C
i j k : D.J
U : Opens ↑↑(CategoryTheory.GlueData.U D.toGlueData i)
⊢ op
      ((IsOpenImmersion.openFunctor (_ : IsOpenImmersion pullback.snd)).obj
        {
            unop :=
              { carrier := ⇑(pullback.fst ≫ t D.toGlueData j i ≫ f D.toGlueData i j).base ⁻¹' ↑(op U).unop,
                is_open' :=
                  (_ :
                    IsOpen
                      (⇑(pullback.fst ≫ t D.toGlueData j i ≫ f D.toGlueData i j).base ⁻¹' ↑(op U).unop)) } }.unop) =
    (Opens.map (f D.toGlueData j k).base).op.obj
      (op
        ((Opens.map (ι D.toGlueData j).base).obj ((IsOpenMap.functor (_ : IsOpenMap ⇑(ι D.toGlueData i).base)).obj U)))
case w
C : Type u
inst✝¹ : Category.{v, u} C
D : GlueData C
inst✝ : HasLimits C
i j k : D.J
U : Opens ↑↑(CategoryTheory.GlueData.U D.toGlueData i)
⊢ op
      ((IsOpenImmersion.openFunctor (_ : IsOpenImmersion pullback.snd)).obj
        {
            unop :=
              { carrier := ⇑(pullback.fst ≫ t D.toGlueData j i ≫ f D.toGlueData i j).base ⁻¹' ↑(op U).unop,
                is_open' :=
                  (_ :
                    IsOpen
                      (⇑(pullback.fst ≫ t D.toGlueData j i ≫ f D.toGlueData i j).base ⁻¹' ↑(op U).unop)) } }.unop) =
    (Opens.map (f D.toGlueData j k).base).op.obj
      (op
        ((Opens.map (ι D.toGlueData j).base).obj ((IsOpenMap.functor (_ : IsOpenMap ⇑(ι D.toGlueData i).base)).obj U)))
case w
C : Type u
inst✝¹ : Category.{v, u} C
D : GlueData C
inst✝ : HasLimits C
i j k : D.J
U : Opens ↑↑(CategoryTheory.GlueData.U D.toGlueData i)
⊢ op
      ((IsOpenImmersion.openFunctor (_ : IsOpenImmersion pullback.snd)).obj
        {
            unop :=
              { carrier := ⇑(pullback.fst ≫ t D.toGlueData j i ≫ f D.toGlueData i j).base ⁻¹' ↑(op U).unop,
                is_open' :=
                  (_ :
                    IsOpen
                      (⇑(pullback.fst ≫ t D.toGlueData j i ≫ f D.toGlueData i j).base ⁻¹' ↑(op U).unop)) } }.unop) =
    (Opens.map (f D.toGlueData j k).base).op.obj
      (op
        ((Opens.map (ι D.toGlueData j).base).obj ((IsOpenMap.functor (_ : IsOpenMap ⇑(ι D.toGlueData i).base)).obj U)))
case w
C : Type u
inst✝¹ : Category.{v, u} C
D : GlueData C
inst✝ : HasLimits C
i j k : D.J
U : Opens ↑↑(CategoryTheory.GlueData.U D.toGlueData i)
⊢ op
      ((IsOpenImmersion.openFunctor (_ : IsOpenImmersion pullback.snd)).obj
        {
            unop :=
              { carrier := ⇑(pullback.fst ≫ t D.toGlueData j i ≫ f D.toGlueData i j).base ⁻¹' ↑(op U).unop,
                is_open' :=
                  (_ :
                    IsOpen
                      (⇑(pullback.fst ≫ t D.toGlueData j i ≫ f D.toGlueData i j).base ⁻¹' ↑(op U).unop)) } }.unop) =
    (Opens.map (f D.toGlueData j k).base).op.obj
      (op
        ((Opens.map (ι D.toGlueData j).base).obj ((IsOpenMap.functor (_ : IsOpenMap ⇑(ι D.toGlueData i).base)).obj U)))

Next tactic:
simp_rw [Category.assoc]