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]
  

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)
⊢ (f D.toGlueData i j).c.app (op U) ≫
      (t D.toGlueData j i).c.app ((Opens.map (f D.toGlueData i j).base).op.obj (op U)) ≫
        pullback.fst.c.app
            (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)) }) ≫
          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)))

Next tactic:
simp_rw [← Category.assoc]