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]
  simp_rw [Category.assoc]
  dsimp only [Functor.op, unop_op, Quiver.Hom.unop_op]
  

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 ⁻¹'
                ↑{ carrier := ⇑(t D.toGlueData j i).base ⁻¹' ↑((Opens.map (f D.toGlueData i j).base).obj U),
                    is_open' :=
                      (_ :
                        IsOpen
                          (⇑(t D.toGlueData j i).base ⁻¹'
                            ↑((Opens.map (f D.toGlueData i j).base).op.obj (op U)).unop)) },
            is_open' :=
              (_ :
                IsOpen
                  (⇑pullback.fst.base ⁻¹'
                    ↑{ carrier := ⇑(t D.toGlueData j i).base ⁻¹' ↑((Opens.map (f D.toGlueData i j).base).obj U),
                        is_open' :=
                          (_ :
                            IsOpen
                              (⇑(t D.toGlueData j i).base ⁻¹'
                                ↑((Opens.map (f D.toGlueData i j).base).op.obj (op U)).unop)) })) } ≫
        (V D.toGlueData (j, k)).presheaf.map
          (eqToHom
              (_ :
                op
                    ((IsOpenImmersion.openFunctor (_ : IsOpenImmersion pullback.snd)).obj
                      {
                        carrier :=
                          ⇑pullback.fst.base ⁻¹'
                            ↑{ carrier := ⇑(t D.toGlueData j i).base ⁻¹' ↑((Opens.map (f D.toGlueData i j).base).obj U),
                                is_open' :=
                                  (_ :
                                    IsOpen
                                      (⇑(t D.toGlueData j i).base ⁻¹'
                                        ↑((Opens.map (f D.toGlueData i j).base).op.obj (op U)).unop)) },
                        is_open' :=
                          (_ :
                            IsOpen
                              (⇑pullback.fst.base ⁻¹'
                                ↑{
                                    carrier :=
                                      ⇑(t D.toGlueData j i).base ⁻¹' ↑((Opens.map (f D.toGlueData i j).base).obj U),
                                    is_open' :=
                                      (_ :
                                        IsOpen
                                          (⇑(t D.toGlueData j i).base ⁻¹'
                                            ↑((Opens.map (f D.toGlueData i j).base).op.obj (op U)).unop)) })) }) =
                  op
                    ((Opens.map (f D.toGlueData j k).base).obj
                      ((IsOpenImmersion.openFunctor (_ : IsOpenImmersion (f D.toGlueData j i))).obj
                        { carrier := ⇑(t D.toGlueData j i).base ⁻¹' ↑((Opens.map (f D.toGlueData i j).base).obj U),
                          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).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 ⁻¹' ↑U,
            is_open' := (_ : IsOpen (⇑(pullback.fst ≫ t D.toGlueData j i ≫ f D.toGlueData i j).base ⁻¹' ↑U)) } ≫
        (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:
rw [eqToHom_map (Opens.map _), eqToHom_op, eqToHom_trans]