[GOAL]
C : Type u
inst✝¹ : Category.{v, u} C
D : GlueData C
inst✝ : HasLimits C
i : D.J
⊢ OpenEmbedding ↑(ι D.toGlueData i).base
[PROOFSTEP]
rw [← show _ = (𝖣.ι i).base from 𝖣.ι_gluedIso_inv (PresheafedSpace.forget _) _]
  -- Porting note : added this erewrite
[GOAL]
C : Type u
inst✝¹ : Category.{v, u} C
D : GlueData C
inst✝ : HasLimits C
i : D.J
⊢ OpenEmbedding ↑(ι (mapGlueData D.toGlueData (forget C)) i ≫ (gluedIso D.toGlueData (forget C)).inv)
[PROOFSTEP]
erw [coe_comp]
[GOAL]
C : Type u
inst✝¹ : Category.{v, u} C
D : GlueData C
inst✝ : HasLimits C
i : D.J
⊢ OpenEmbedding (↑(gluedIso D.toGlueData (forget C)).inv ∘ ↑(ι (mapGlueData D.toGlueData (forget C)) i))
[PROOFSTEP]
refine
  OpenEmbedding.comp (TopCat.homeoOfIso (𝖣.gluedIso (PresheafedSpace.forget _)).symm).openEmbedding
    (D.toTopGlueData.ι_openEmbedding i)
[GOAL]
C : Type u
inst✝ : Category.{v, u} C
D : GlueData C
i j k : D.J
S : Set ↑↑(V D.toGlueData (i, j))
⊢ ↑pullback.snd.base '' (↑pullback.fst.base ⁻¹' S) = ↑(f D.toGlueData i k).base ⁻¹' (↑(f D.toGlueData i j).base '' S)
[PROOFSTEP]
have eq₁ : _ = (π₁ i, j, k).base := PreservesPullback.iso_hom_fst (forget C) _ _
[GOAL]
C : Type u
inst✝ : Category.{v, u} C
D : GlueData C
i j k : D.J
S : Set ↑↑(V D.toGlueData (i, j))
eq₁ :
  (PreservesPullback.iso (forget C) (f D.toGlueData i j) (f D.toGlueData i k)).hom ≫ pullback.fst = pullback.fst.base
⊢ ↑pullback.snd.base '' (↑pullback.fst.base ⁻¹' S) = ↑(f D.toGlueData i k).base ⁻¹' (↑(f D.toGlueData i j).base '' S)
[PROOFSTEP]
have eq₂ : _ = (π₂ i, j, k).base := PreservesPullback.iso_hom_snd (forget C) _ _
[GOAL]
C : Type u
inst✝ : Category.{v, u} C
D : GlueData C
i j k : D.J
S : Set ↑↑(V D.toGlueData (i, j))
eq₁ :
  (PreservesPullback.iso (forget C) (f D.toGlueData i j) (f D.toGlueData i k)).hom ≫ pullback.fst = pullback.fst.base
eq₂ :
  (PreservesPullback.iso (forget C) (f D.toGlueData i j) (f D.toGlueData i k)).hom ≫ pullback.snd = pullback.snd.base
⊢ ↑pullback.snd.base '' (↑pullback.fst.base ⁻¹' S) = ↑(f D.toGlueData i k).base ⁻¹' (↑(f D.toGlueData i j).base '' S)
[PROOFSTEP]
rw [← eq₁, ← eq₂]
  -- Porting note : `rw` to `erw` on `coe_comp`
[GOAL]
C : Type u
inst✝ : Category.{v, u} C
D : GlueData C
i j k : D.J
S : Set ↑↑(V D.toGlueData (i, j))
eq₁ :
  (PreservesPullback.iso (forget C) (f D.toGlueData i j) (f D.toGlueData i k)).hom ≫ pullback.fst = pullback.fst.base
eq₂ :
  (PreservesPullback.iso (forget C) (f D.toGlueData i j) (f D.toGlueData i k)).hom ≫ pullback.snd = pullback.snd.base
⊢ ↑((PreservesPullback.iso (forget C) (f D.toGlueData i j) (f D.toGlueData i k)).hom ≫ pullback.snd) ''
      (↑((PreservesPullback.iso (forget C) (f D.toGlueData i j) (f D.toGlueData i k)).hom ≫ pullback.fst) ⁻¹' S) =
    ↑(f D.toGlueData i k).base ⁻¹' (↑(f D.toGlueData i j).base '' S)
[PROOFSTEP]
erw [coe_comp]
[GOAL]
C : Type u
inst✝ : Category.{v, u} C
D : GlueData C
i j k : D.J
S : Set ↑↑(V D.toGlueData (i, j))
eq₁ :
  (PreservesPullback.iso (forget C) (f D.toGlueData i j) (f D.toGlueData i k)).hom ≫ pullback.fst = pullback.fst.base
eq₂ :
  (PreservesPullback.iso (forget C) (f D.toGlueData i j) (f D.toGlueData i k)).hom ≫ pullback.snd = pullback.snd.base
⊢ ↑pullback.snd ∘ ↑(PreservesPullback.iso (forget C) (f D.toGlueData i j) (f D.toGlueData i k)).hom ''
      (↑((PreservesPullback.iso (forget C) (f D.toGlueData i j) (f D.toGlueData i k)).hom ≫ pullback.fst) ⁻¹' S) =
    ↑(f D.toGlueData i k).base ⁻¹' (↑(f D.toGlueData i j).base '' S)
[PROOFSTEP]
rw [Set.image_comp]
  -- Porting note : `rw` to `erw` on `coe_comp`
[GOAL]
C : Type u
inst✝ : Category.{v, u} C
D : GlueData C
i j k : D.J
S : Set ↑↑(V D.toGlueData (i, j))
eq₁ :
  (PreservesPullback.iso (forget C) (f D.toGlueData i j) (f D.toGlueData i k)).hom ≫ pullback.fst = pullback.fst.base
eq₂ :
  (PreservesPullback.iso (forget C) (f D.toGlueData i j) (f D.toGlueData i k)).hom ≫ pullback.snd = pullback.snd.base
⊢ ↑pullback.snd ''
      (↑(PreservesPullback.iso (forget C) (f D.toGlueData i j) (f D.toGlueData i k)).hom ''
        (↑((PreservesPullback.iso (forget C) (f D.toGlueData i j) (f D.toGlueData i k)).hom ≫ pullback.fst) ⁻¹' S)) =
    ↑(f D.toGlueData i k).base ⁻¹' (↑(f D.toGlueData i j).base '' S)
[PROOFSTEP]
erw [coe_comp]
[GOAL]
C : Type u
inst✝ : Category.{v, u} C
D : GlueData C
i j k : D.J
S : Set ↑↑(V D.toGlueData (i, j))
eq₁ :
  (PreservesPullback.iso (forget C) (f D.toGlueData i j) (f D.toGlueData i k)).hom ≫ pullback.fst = pullback.fst.base
eq₂ :
  (PreservesPullback.iso (forget C) (f D.toGlueData i j) (f D.toGlueData i k)).hom ≫ pullback.snd = pullback.snd.base
⊢ ↑pullback.snd ''
      (↑(PreservesPullback.iso (forget C) (f D.toGlueData i j) (f D.toGlueData i k)).hom ''
        (↑pullback.fst ∘ ↑(PreservesPullback.iso (forget C) (f D.toGlueData i j) (f D.toGlueData i k)).hom ⁻¹' S)) =
    ↑(f D.toGlueData i k).base ⁻¹' (↑(f D.toGlueData i j).base '' S)
[PROOFSTEP]
rw [Set.preimage_comp, Set.image_preimage_eq, TopCat.pullback_snd_image_fst_preimage]
[GOAL]
C : Type u
inst✝ : Category.{v, u} C
D : GlueData C
i j k : D.J
S : Set ↑↑(V D.toGlueData (i, j))
eq₁ :
  (PreservesPullback.iso (forget C) (f D.toGlueData i j) (f D.toGlueData i k)).hom ≫ pullback.fst = pullback.fst.base
eq₂ :
  (PreservesPullback.iso (forget C) (f D.toGlueData i j) (f D.toGlueData i k)).hom ≫ pullback.snd = pullback.snd.base
⊢ ↑((forget C).map (f D.toGlueData i k)) ⁻¹' (↑((forget C).map (f D.toGlueData i j)) '' S) =
    ↑(f D.toGlueData i k).base ⁻¹' (↑(f D.toGlueData i j).base '' S)
case h
C : Type u
inst✝ : Category.{v, u} C
D : GlueData C
i j k : D.J
S : Set ↑↑(V D.toGlueData (i, j))
eq₁ :
  (PreservesPullback.iso (forget C) (f D.toGlueData i j) (f D.toGlueData i k)).hom ≫ pullback.fst = pullback.fst.base
eq₂ :
  (PreservesPullback.iso (forget C) (f D.toGlueData i j) (f D.toGlueData i k)).hom ≫ pullback.snd = pullback.snd.base
⊢ Function.Surjective ↑(PreservesPullback.iso (forget C) (f D.toGlueData i j) (f D.toGlueData i k)).hom
[PROOFSTEP]
rfl
[GOAL]
case h
C : Type u
inst✝ : Category.{v, u} C
D : GlueData C
i j k : D.J
S : Set ↑↑(V D.toGlueData (i, j))
eq₁ :
  (PreservesPullback.iso (forget C) (f D.toGlueData i j) (f D.toGlueData i k)).hom ≫ pullback.fst = pullback.fst.base
eq₂ :
  (PreservesPullback.iso (forget C) (f D.toGlueData i j) (f D.toGlueData i k)).hom ≫ pullback.snd = pullback.snd.base
⊢ Function.Surjective ↑(PreservesPullback.iso (forget C) (f D.toGlueData i j) (f D.toGlueData i k)).hom
[PROOFSTEP]
rw [← TopCat.epi_iff_surjective]
[GOAL]
case h
C : Type u
inst✝ : Category.{v, u} C
D : GlueData C
i j k : D.J
S : Set ↑↑(V D.toGlueData (i, j))
eq₁ :
  (PreservesPullback.iso (forget C) (f D.toGlueData i j) (f D.toGlueData i k)).hom ≫ pullback.fst = pullback.fst.base
eq₂ :
  (PreservesPullback.iso (forget C) (f D.toGlueData i j) (f D.toGlueData i k)).hom ≫ pullback.snd = pullback.snd.base
⊢ Epi (PreservesPullback.iso (forget C) (f D.toGlueData i j) (f D.toGlueData i k)).hom
[PROOFSTEP]
infer_instance
[GOAL]
C : Type u
inst✝ : Category.{v, u} C
D : GlueData C
i j k : D.J
U : Opens ↑↑(V D.toGlueData (i, j))
⊢ op
      ((IsOpenImmersion.openFunctor (_ : IsOpenImmersion pullback.snd)).obj
        {
            unop :=
              { carrier := ↑pullback.fst.base ⁻¹' ↑(op U).unop,
                is_open' := (_ : IsOpen (↑pullback.fst.base ⁻¹' ↑(op U).unop)) } }.unop) =
    (Opens.map (f D.toGlueData i k).base).op.obj
      (op ((IsOpenImmersion.openFunctor (_ : IsOpenImmersion (f D.toGlueData i j))).obj U))
[PROOFSTEP]
delta IsOpenImmersion.openFunctor
[GOAL]
C : Type u
inst✝ : Category.{v, u} C
D : GlueData C
i j k : D.J
U : Opens ↑↑(V D.toGlueData (i, j))
⊢ op
      ((IsOpenMap.functor (_ : IsOpenMap ↑pullback.snd.base)).obj
        {
            unop :=
              { carrier := ↑pullback.fst.base ⁻¹' ↑(op U).unop,
                is_open' := (_ : IsOpen (↑pullback.fst.base ⁻¹' ↑(op U).unop)) } }.unop) =
    (Opens.map (f D.toGlueData i k).base).op.obj
      (op ((IsOpenMap.functor (_ : IsOpenMap ↑(f D.toGlueData i j).base)).obj U))
[PROOFSTEP]
dsimp only [Functor.op, IsOpenMap.functor, Opens.map, unop_op]
[GOAL]
C : Type u
inst✝ : Category.{v, u} C
D : GlueData C
i j k : D.J
U : Opens ↑↑(V D.toGlueData (i, j))
⊢ op
      {
        carrier :=
          ↑pullback.snd.base ''
            ↑{ carrier := ↑pullback.fst.base ⁻¹' ↑U, is_open' := (_ : IsOpen (↑pullback.fst.base ⁻¹' ↑U)) },
        is_open' :=
          (_ :
            IsOpen
              (↑pullback.snd.base ''
                ↑{ carrier := ↑pullback.fst.base ⁻¹' ↑U, is_open' := (_ : IsOpen (↑pullback.fst.base ⁻¹' ↑U)) })) } =
    op
      {
        carrier :=
          ↑(f D.toGlueData i k).base ⁻¹'
            ↑{ carrier := ↑(f D.toGlueData i j).base '' ↑U,
                is_open' := (_ : IsOpen (↑(f D.toGlueData i j).base '' ↑U)) },
        is_open' :=
          (_ :
            IsOpen
              (↑(f D.toGlueData i k).base ⁻¹'
                ↑{ carrier := ↑(f D.toGlueData i j).base '' ↑U,
                    is_open' := (_ : IsOpen (↑(f D.toGlueData i j).base '' ↑U)) })) }
[PROOFSTEP]
congr
[GOAL]
case e_x.e_carrier
C : Type u
inst✝ : Category.{v, u} C
D : GlueData C
i j k : D.J
U : Opens ↑↑(V D.toGlueData (i, j))
⊢ ↑pullback.snd.base ''
      ↑{ carrier := ↑pullback.fst.base ⁻¹' ↑U, is_open' := (_ : IsOpen (↑pullback.fst.base ⁻¹' ↑U)) } =
    ↑(f D.toGlueData i k).base ⁻¹'
      ↑{ carrier := ↑(f D.toGlueData i j).base '' ↑U, is_open' := (_ : IsOpen (↑(f D.toGlueData i j).base '' ↑U)) }
[PROOFSTEP]
apply pullback_base
[GOAL]
C : Type u
inst✝ : Category.{v, u} C
D : GlueData C
i j k : D.J
U : Opens ↑↑(V D.toGlueData (i, j))
⊢ IsOpenImmersion.invApp (_ : IsOpenImmersion (f D.toGlueData i j)) U ≫
      NatTrans.app (f D.toGlueData i k).c
        (op ((IsOpenImmersion.openFunctor (_ : IsOpenImmersion (f D.toGlueData i j))).obj U)) =
    NatTrans.app pullback.fst.c (op U) ≫
      IsOpenImmersion.invApp (_ : IsOpenImmersion pullback.snd)
          {
              unop :=
                { carrier := ↑pullback.fst.base ⁻¹' ↑(op U).unop,
                  is_open' := (_ : IsOpen (↑pullback.fst.base ⁻¹' ↑(op U).unop)) } }.unop ≫
        (V D.toGlueData (i, k)).presheaf.map
          (eqToHom
            (_ :
              op
                  ((IsOpenImmersion.openFunctor (_ : IsOpenImmersion pullback.snd)).obj
                    {
                        unop :=
                          { carrier := ↑pullback.fst.base ⁻¹' ↑(op U).unop,
                            is_open' := (_ : IsOpen (↑pullback.fst.base ⁻¹' ↑(op U).unop)) } }.unop) =
                (Opens.map (f D.toGlueData i k).base).op.obj
                  (op ((IsOpenImmersion.openFunctor (_ : IsOpenImmersion (f D.toGlueData i j))).obj U))))
[PROOFSTEP]
have := PresheafedSpace.congr_app (@pullback.condition _ _ _ _ _ (D.f i j) (D.f i k) _)
[GOAL]
C : Type u
inst✝ : Category.{v, u} C
D : GlueData C
i j k : D.J
U : Opens ↑↑(V D.toGlueData (i, j))
this :
  ∀ (U : (Opens ↑↑(CategoryTheory.GlueData.U D.toGlueData i))ᵒᵖ),
    NatTrans.app (pullback.fst ≫ f D.toGlueData i j).c U =
      NatTrans.app (pullback.snd ≫ f D.toGlueData i k).c U ≫
        (pullback (f D.toGlueData i j) (f D.toGlueData i k)).presheaf.map
          (eqToHom
            (_ :
              (Opens.map (pullback.snd ≫ f D.toGlueData i k).base).op.obj U =
                (Opens.map (pullback.fst ≫ f D.toGlueData i j).base).op.obj U))
⊢ IsOpenImmersion.invApp (_ : IsOpenImmersion (f D.toGlueData i j)) U ≫
      NatTrans.app (f D.toGlueData i k).c
        (op ((IsOpenImmersion.openFunctor (_ : IsOpenImmersion (f D.toGlueData i j))).obj U)) =
    NatTrans.app pullback.fst.c (op U) ≫
      IsOpenImmersion.invApp (_ : IsOpenImmersion pullback.snd)
          {
              unop :=
                { carrier := ↑pullback.fst.base ⁻¹' ↑(op U).unop,
                  is_open' := (_ : IsOpen (↑pullback.fst.base ⁻¹' ↑(op U).unop)) } }.unop ≫
        (V D.toGlueData (i, k)).presheaf.map
          (eqToHom
            (_ :
              op
                  ((IsOpenImmersion.openFunctor (_ : IsOpenImmersion pullback.snd)).obj
                    {
                        unop :=
                          { carrier := ↑pullback.fst.base ⁻¹' ↑(op U).unop,
                            is_open' := (_ : IsOpen (↑pullback.fst.base ⁻¹' ↑(op U).unop)) } }.unop) =
                (Opens.map (f D.toGlueData i k).base).op.obj
                  (op ((IsOpenImmersion.openFunctor (_ : IsOpenImmersion (f D.toGlueData i j))).obj U))))
[PROOFSTEP]
dsimp only [comp_c_app] at this
[GOAL]
C : Type u
inst✝ : Category.{v, u} C
D : GlueData C
i j k : D.J
U : Opens ↑↑(V D.toGlueData (i, j))
this :
  ∀ (U : (Opens ↑↑(CategoryTheory.GlueData.U D.toGlueData i))ᵒᵖ),
    NatTrans.app (f D.toGlueData i j).c U ≫
        NatTrans.app pullback.fst.c (op ((Opens.map (f D.toGlueData i j).base).obj U.unop)) =
      (NatTrans.app (f D.toGlueData i k).c U ≫
          NatTrans.app pullback.snd.c (op ((Opens.map (f D.toGlueData i k).base).obj U.unop))) ≫
        (pullback (f D.toGlueData i j) (f D.toGlueData i k)).presheaf.map
          (eqToHom
            (_ :
              (Opens.map (pullback.snd ≫ f D.toGlueData i k).base).op.obj U =
                (Opens.map (pullback.fst ≫ f D.toGlueData i j).base).op.obj U))
⊢ IsOpenImmersion.invApp (_ : IsOpenImmersion (f D.toGlueData i j)) U ≫
      NatTrans.app (f D.toGlueData i k).c
        (op ((IsOpenImmersion.openFunctor (_ : IsOpenImmersion (f D.toGlueData i j))).obj U)) =
    NatTrans.app pullback.fst.c (op U) ≫
      IsOpenImmersion.invApp (_ : IsOpenImmersion pullback.snd)
          {
              unop :=
                { carrier := ↑pullback.fst.base ⁻¹' ↑(op U).unop,
                  is_open' := (_ : IsOpen (↑pullback.fst.base ⁻¹' ↑(op U).unop)) } }.unop ≫
        (V D.toGlueData (i, k)).presheaf.map
          (eqToHom
            (_ :
              op
                  ((IsOpenImmersion.openFunctor (_ : IsOpenImmersion pullback.snd)).obj
                    {
                        unop :=
                          { carrier := ↑pullback.fst.base ⁻¹' ↑(op U).unop,
                            is_open' := (_ : IsOpen (↑pullback.fst.base ⁻¹' ↑(op U).unop)) } }.unop) =
                (Opens.map (f D.toGlueData i k).base).op.obj
                  (op ((IsOpenImmersion.openFunctor (_ : IsOpenImmersion (f D.toGlueData i j))).obj U))))
[PROOFSTEP]
rw [← cancel_epi (inv ((D.f_open i j).invApp U)), IsIso.inv_hom_id_assoc, IsOpenImmersion.inv_invApp]
[GOAL]
C : Type u
inst✝ : Category.{v, u} C
D : GlueData C
i j k : D.J
U : Opens ↑↑(V D.toGlueData (i, j))
this :
  ∀ (U : (Opens ↑↑(CategoryTheory.GlueData.U D.toGlueData i))ᵒᵖ),
    NatTrans.app (f D.toGlueData i j).c U ≫
        NatTrans.app pullback.fst.c (op ((Opens.map (f D.toGlueData i j).base).obj U.unop)) =
      (NatTrans.app (f D.toGlueData i k).c U ≫
          NatTrans.app pullback.snd.c (op ((Opens.map (f D.toGlueData i k).base).obj U.unop))) ≫
        (pullback (f D.toGlueData i j) (f D.toGlueData i k)).presheaf.map
          (eqToHom
            (_ :
              (Opens.map (pullback.snd ≫ f D.toGlueData i k).base).op.obj U =
                (Opens.map (pullback.fst ≫ f D.toGlueData i j).base).op.obj U))
⊢ NatTrans.app (f D.toGlueData i k).c
      (op ((IsOpenImmersion.openFunctor (_ : IsOpenImmersion (f D.toGlueData i j))).obj U)) =
    (NatTrans.app (f D.toGlueData i j).c
          (op ((IsOpenImmersion.openFunctor (_ : IsOpenImmersion (f D.toGlueData i j))).obj U)) ≫
        (V D.toGlueData (i, j)).presheaf.map
          (eqToHom
            (_ :
              op
                  ((Opens.map (f D.toGlueData i j).base).obj
                    (op ((IsOpenImmersion.openFunctor (_ : IsOpenImmersion (f D.toGlueData i j))).obj U)).unop) =
                op U))) ≫
      NatTrans.app pullback.fst.c (op U) ≫
        IsOpenImmersion.invApp (_ : IsOpenImmersion pullback.snd)
            {
                unop :=
                  { carrier := ↑pullback.fst.base ⁻¹' ↑(op U).unop,
                    is_open' := (_ : IsOpen (↑pullback.fst.base ⁻¹' ↑(op U).unop)) } }.unop ≫
          (V D.toGlueData (i, k)).presheaf.map
            (eqToHom
              (_ :
                op
                    ((IsOpenImmersion.openFunctor (_ : IsOpenImmersion pullback.snd)).obj
                      {
                          unop :=
                            { carrier := ↑pullback.fst.base ⁻¹' ↑(op U).unop,
                              is_open' := (_ : IsOpen (↑pullback.fst.base ⁻¹' ↑(op U).unop)) } }.unop) =
                  (Opens.map (f D.toGlueData i k).base).op.obj
                    (op ((IsOpenImmersion.openFunctor (_ : IsOpenImmersion (f D.toGlueData i j))).obj U))))
[PROOFSTEP]
simp_rw [Category.assoc]
[GOAL]
C : Type u
inst✝ : Category.{v, u} C
D : GlueData C
i j k : D.J
U : Opens ↑↑(V D.toGlueData (i, j))
this :
  ∀ (U : (Opens ↑↑(CategoryTheory.GlueData.U D.toGlueData i))ᵒᵖ),
    NatTrans.app (f D.toGlueData i j).c U ≫
        NatTrans.app pullback.fst.c (op ((Opens.map (f D.toGlueData i j).base).obj U.unop)) =
      (NatTrans.app (f D.toGlueData i k).c U ≫
          NatTrans.app pullback.snd.c (op ((Opens.map (f D.toGlueData i k).base).obj U.unop))) ≫
        (pullback (f D.toGlueData i j) (f D.toGlueData i k)).presheaf.map
          (eqToHom
            (_ :
              (Opens.map (pullback.snd ≫ f D.toGlueData i k).base).op.obj U =
                (Opens.map (pullback.fst ≫ f D.toGlueData i j).base).op.obj U))
⊢ NatTrans.app (f D.toGlueData i k).c
      (op ((IsOpenImmersion.openFunctor (_ : IsOpenImmersion (f D.toGlueData i j))).obj U)) =
    NatTrans.app (f D.toGlueData i j).c
        (op ((IsOpenImmersion.openFunctor (_ : IsOpenImmersion (f D.toGlueData i j))).obj U)) ≫
      (V D.toGlueData (i, j)).presheaf.map
          (eqToHom
            (_ :
              op
                  ((Opens.map (f D.toGlueData i j).base).obj
                    (op ((IsOpenImmersion.openFunctor (_ : IsOpenImmersion (f D.toGlueData i j))).obj U)).unop) =
                op U)) ≫
        NatTrans.app pullback.fst.c (op U) ≫
          IsOpenImmersion.invApp (_ : IsOpenImmersion pullback.snd)
              { carrier := ↑pullback.fst.base ⁻¹' ↑(op U).unop,
                is_open' := (_ : IsOpen (↑pullback.fst.base ⁻¹' ↑(op U).unop)) } ≫
            (V D.toGlueData (i, k)).presheaf.map
              (eqToHom
                (_ :
                  op
                      ((IsOpenImmersion.openFunctor (_ : IsOpenImmersion pullback.snd)).obj
                        {
                            unop :=
                              { carrier := ↑pullback.fst.base ⁻¹' ↑(op U).unop,
                                is_open' := (_ : IsOpen (↑pullback.fst.base ⁻¹' ↑(op U).unop)) } }.unop) =
                    (Opens.map (f D.toGlueData i k).base).op.obj
                      (op ((IsOpenImmersion.openFunctor (_ : IsOpenImmersion (f D.toGlueData i j))).obj U))))
[PROOFSTEP]
erw [(π₁ i, j, k).c.naturality_assoc, reassoc_of% this, ← Functor.map_comp_assoc, IsOpenImmersion.inv_naturality_assoc,
  IsOpenImmersion.app_invApp_assoc, ← (D.V (i, k)).presheaf.map_comp, ← (D.V (i, k)).presheaf.map_comp]
  -- Porting note : need to provide an explicit argument, otherwise Lean does not know which
    -- category we are talking about
[GOAL]
C : Type u
inst✝ : Category.{v, u} C
D : GlueData C
i j k : D.J
U : Opens ↑↑(V D.toGlueData (i, j))
this :
  ∀ (U : (Opens ↑↑(CategoryTheory.GlueData.U D.toGlueData i))ᵒᵖ),
    NatTrans.app (f D.toGlueData i j).c U ≫
        NatTrans.app pullback.fst.c (op ((Opens.map (f D.toGlueData i j).base).obj U.unop)) =
      (NatTrans.app (f D.toGlueData i k).c U ≫
          NatTrans.app pullback.snd.c (op ((Opens.map (f D.toGlueData i k).base).obj U.unop))) ≫
        (pullback (f D.toGlueData i j) (f D.toGlueData i k)).presheaf.map
          (eqToHom
            (_ :
              (Opens.map (pullback.snd ≫ f D.toGlueData i k).base).op.obj U =
                (Opens.map (pullback.fst ≫ f D.toGlueData i j).base).op.obj U))
⊢ NatTrans.app (f D.toGlueData i k).c
      (op ((IsOpenImmersion.openFunctor (_ : IsOpenImmersion (f D.toGlueData i j))).obj U)) =
    NatTrans.app (f D.toGlueData i k).c
        (op ((IsOpenImmersion.openFunctor (_ : IsOpenImmersion (f D.toGlueData i j))).obj U)) ≫
      (V D.toGlueData (i, k)).presheaf.map
        ((homOfLE
              (_ :
                ↑pullback.snd.base ''
                    (↑pullback.snd.base ⁻¹'
                      ((Opens.map (f D.toGlueData i k).base).obj
                          (op
                              ((IsOpenImmersion.openFunctor (_ : IsOpenImmersion (f D.toGlueData i j))).obj
                                U)).unop).carrier) ⊆
                  ((Opens.map (f D.toGlueData i k).base).obj
                      (op
                          ((IsOpenImmersion.openFunctor (_ : IsOpenImmersion (f D.toGlueData i j))).obj
                            U)).unop).carrier)).op ≫
          (IsOpenImmersion.openFunctor (_ : IsOpenImmersion pullback.snd)).op.map
              (eqToHom
                  (_ :
                    (Opens.map (pullback.snd ≫ f D.toGlueData i k).base).op.obj
                        (op ((IsOpenImmersion.openFunctor (_ : IsOpenImmersion (f D.toGlueData i j))).obj U)) =
                      (Opens.map (pullback.fst ≫ f D.toGlueData i j).base).op.obj
                        (op ((IsOpenImmersion.openFunctor (_ : IsOpenImmersion (f D.toGlueData i j))).obj U))) ≫
                (Opens.map pullback.fst.base).op.map
                  (eqToHom
                    (_ :
                      op
                          ((Opens.map (f D.toGlueData i j).base).obj
                            (op
                                ((IsOpenImmersion.openFunctor (_ : IsOpenImmersion (f D.toGlueData i j))).obj
                                  U)).unop) =
                        op U))) ≫
            eqToHom
              (_ :
                op
                    ((IsOpenImmersion.openFunctor (_ : IsOpenImmersion pullback.snd)).obj
                      {
                          unop :=
                            { carrier := ↑pullback.fst.base ⁻¹' ↑(op U).unop,
                              is_open' := (_ : IsOpen (↑pullback.fst.base ⁻¹' ↑(op U).unop)) } }.unop) =
                  (Opens.map (f D.toGlueData i k).base).op.obj
                    (op ((IsOpenImmersion.openFunctor (_ : IsOpenImmersion (f D.toGlueData i j))).obj U))))
[PROOFSTEP]
convert (Category.comp_id ((f D.toGlueData i k).c.app _)).symm
[GOAL]
case h.e'_3.h.h.e'_7
C : Type u
inst✝ : Category.{v, u} C
D : GlueData C
i j k : D.J
U : Opens ↑↑(V D.toGlueData (i, j))
this :
  ∀ (U : (Opens ↑↑(CategoryTheory.GlueData.U D.toGlueData i))ᵒᵖ),
    NatTrans.app (f D.toGlueData i j).c U ≫
        NatTrans.app pullback.fst.c (op ((Opens.map (f D.toGlueData i j).base).obj U.unop)) =
      (NatTrans.app (f D.toGlueData i k).c U ≫
          NatTrans.app pullback.snd.c (op ((Opens.map (f D.toGlueData i k).base).obj U.unop))) ≫
        (pullback (f D.toGlueData i j) (f D.toGlueData i k)).presheaf.map
          (eqToHom
            (_ :
              (Opens.map (pullback.snd ≫ f D.toGlueData i k).base).op.obj U =
                (Opens.map (pullback.fst ≫ f D.toGlueData i j).base).op.obj U))
⊢ (V D.toGlueData (i, k)).presheaf.map
      ((homOfLE
            (_ :
              ↑pullback.snd.base ''
                  (↑pullback.snd.base ⁻¹'
                    ((Opens.map (f D.toGlueData i k).base).obj
                        (op
                            ((IsOpenImmersion.openFunctor (_ : IsOpenImmersion (f D.toGlueData i j))).obj
                              U)).unop).carrier) ⊆
                ((Opens.map (f D.toGlueData i k).base).obj
                    (op
                        ((IsOpenImmersion.openFunctor (_ : IsOpenImmersion (f D.toGlueData i j))).obj
                          U)).unop).carrier)).op ≫
        (IsOpenImmersion.openFunctor (_ : IsOpenImmersion pullback.snd)).op.map
            (eqToHom
                (_ :
                  (Opens.map (pullback.snd ≫ f D.toGlueData i k).base).op.obj
                      (op ((IsOpenImmersion.openFunctor (_ : IsOpenImmersion (f D.toGlueData i j))).obj U)) =
                    (Opens.map (pullback.fst ≫ f D.toGlueData i j).base).op.obj
                      (op ((IsOpenImmersion.openFunctor (_ : IsOpenImmersion (f D.toGlueData i j))).obj U))) ≫
              (Opens.map pullback.fst.base).op.map
                (eqToHom
                  (_ :
                    op
                        ((Opens.map (f D.toGlueData i j).base).obj
                          (op ((IsOpenImmersion.openFunctor (_ : IsOpenImmersion (f D.toGlueData i j))).obj U)).unop) =
                      op U))) ≫
          eqToHom
            (_ :
              op
                  ((IsOpenImmersion.openFunctor (_ : IsOpenImmersion pullback.snd)).obj
                    {
                        unop :=
                          { carrier := ↑pullback.fst.base ⁻¹' ↑(op U).unop,
                            is_open' := (_ : IsOpen (↑pullback.fst.base ⁻¹' ↑(op U).unop)) } }.unop) =
                (Opens.map (f D.toGlueData i k).base).op.obj
                  (op ((IsOpenImmersion.openFunctor (_ : IsOpenImmersion (f D.toGlueData i j))).obj U)))) =
    𝟙
      (((f D.toGlueData i k).base _* (V D.toGlueData (i, k)).presheaf).obj
        (op ((IsOpenImmersion.openFunctor (_ : IsOpenImmersion (f D.toGlueData i j))).obj U)))
[PROOFSTEP]
erw [(D.V (i, k)).presheaf.map_id]
[GOAL]
case h.e'_3.h.h.e'_7
C : Type u
inst✝ : Category.{v, u} C
D : GlueData C
i j k : D.J
U : Opens ↑↑(V D.toGlueData (i, j))
this :
  ∀ (U : (Opens ↑↑(CategoryTheory.GlueData.U D.toGlueData i))ᵒᵖ),
    NatTrans.app (f D.toGlueData i j).c U ≫
        NatTrans.app pullback.fst.c (op ((Opens.map (f D.toGlueData i j).base).obj U.unop)) =
      (NatTrans.app (f D.toGlueData i k).c U ≫
          NatTrans.app pullback.snd.c (op ((Opens.map (f D.toGlueData i k).base).obj U.unop))) ≫
        (pullback (f D.toGlueData i j) (f D.toGlueData i k)).presheaf.map
          (eqToHom
            (_ :
              (Opens.map (pullback.snd ≫ f D.toGlueData i k).base).op.obj U =
                (Opens.map (pullback.fst ≫ f D.toGlueData i j).base).op.obj U))
⊢ 𝟙
      ((V D.toGlueData (i, k)).presheaf.obj
        (op
          ((Opens.map (f D.toGlueData i k).base).obj
            (op ((IsOpenImmersion.openFunctor (_ : IsOpenImmersion (f D.toGlueData i j))).obj U)).unop))) =
    𝟙
      (((f D.toGlueData i k).base _* (V D.toGlueData (i, k)).presheaf).obj
        (op ((IsOpenImmersion.openFunctor (_ : IsOpenImmersion (f D.toGlueData i j))).obj U)))
[PROOFSTEP]
rfl
[GOAL]
C : Type u
inst✝ : Category.{v, u} C
D : GlueData C
i j k : D.J
U : Opens ↑↑(pullback (f D.toGlueData i j) (f D.toGlueData i k))
⊢ ∃ eq,
    IsOpenImmersion.invApp (_ : IsOpenImmersion pullback.snd) U ≫
        NatTrans.app (t D.toGlueData k i).c
            (op ((IsOpenImmersion.openFunctor (_ : IsOpenImmersion pullback.snd)).obj U)) ≫
          (V D.toGlueData (k, i)).presheaf.map (eqToHom eq) =
      NatTrans.app (t' D.toGlueData k i j).c (op U) ≫
        IsOpenImmersion.invApp (_ : IsOpenImmersion pullback.fst)
          {
              unop :=
                { carrier := ↑(t' D.toGlueData k i j).base ⁻¹' ↑(op U).unop,
                  is_open' := (_ : IsOpen (↑(t' D.toGlueData k i j).base ⁻¹' ↑(op U).unop)) } }.unop
[PROOFSTEP]
fconstructor
  -- Porting note: I don't know what the magic was in Lean3 proof, it just skipped the proof of `eq`
[GOAL]
case w
C : Type u
inst✝ : Category.{v, u} C
D : GlueData C
i j k : D.J
U : Opens ↑↑(pullback (f D.toGlueData i j) (f D.toGlueData i k))
⊢ (Opens.map (t D.toGlueData k i).base).op.obj
      (op ((IsOpenImmersion.openFunctor (_ : IsOpenImmersion pullback.snd)).obj U)) =
    op
      ((IsOpenImmersion.openFunctor (_ : IsOpenImmersion pullback.fst)).obj
        {
            unop :=
              { carrier := ↑(t' D.toGlueData k i j).base ⁻¹' ↑(op U).unop,
                is_open' := (_ : IsOpen (↑(t' D.toGlueData k i j).base ⁻¹' ↑(op U).unop)) } }.unop)
[PROOFSTEP]
delta IsOpenImmersion.openFunctor
[GOAL]
case w
C : Type u
inst✝ : Category.{v, u} C
D : GlueData C
i j k : D.J
U : Opens ↑↑(pullback (f D.toGlueData i j) (f D.toGlueData i k))
⊢ (Opens.map (t D.toGlueData k i).base).op.obj (op ((IsOpenMap.functor (_ : IsOpenMap ↑pullback.snd.base)).obj U)) =
    op
      ((IsOpenMap.functor (_ : IsOpenMap ↑pullback.fst.base)).obj
        {
            unop :=
              { carrier := ↑(t' D.toGlueData k i j).base ⁻¹' ↑(op U).unop,
                is_open' := (_ : IsOpen (↑(t' D.toGlueData k i j).base ⁻¹' ↑(op U).unop)) } }.unop)
[PROOFSTEP]
dsimp only [Functor.op, Opens.map, IsOpenMap.functor, unop_op, Opens.coe_mk]
[GOAL]
case w
C : Type u
inst✝ : Category.{v, u} C
D : GlueData C
i j k : D.J
U : Opens ↑↑(pullback (f D.toGlueData i j) (f D.toGlueData i k))
⊢ op
      { carrier := ↑(t D.toGlueData k i).base ⁻¹' (↑pullback.snd.base '' ↑U),
        is_open' :=
          (_ :
            IsOpen
              (↑(t D.toGlueData k i).base ⁻¹'
                ↑{ carrier := ↑pullback.snd.base '' ↑U, is_open' := (_ : IsOpen (↑pullback.snd.base '' ↑U)) })) } =
    op
      { carrier := ↑pullback.fst.base '' (↑(t' D.toGlueData k i j).base ⁻¹' ↑U),
        is_open' :=
          (_ :
            IsOpen
              (↑pullback.fst.base ''
                ↑{ carrier := ↑(t' D.toGlueData k i j).base ⁻¹' ↑U,
                    is_open' := (_ : IsOpen (↑(t' D.toGlueData k i j).base ⁻¹' ↑U)) })) }
[PROOFSTEP]
congr
[GOAL]
case w.e_x.e_carrier
C : Type u
inst✝ : Category.{v, u} C
D : GlueData C
i j k : D.J
U : Opens ↑↑(pullback (f D.toGlueData i j) (f D.toGlueData i k))
⊢ ↑(t D.toGlueData k i).base ⁻¹' (↑pullback.snd.base '' ↑U) =
    ↑pullback.fst.base '' (↑(t' D.toGlueData k i j).base ⁻¹' ↑U)
[PROOFSTEP]
have := (𝖣.t_fac k i j).symm
[GOAL]
case w.e_x.e_carrier
C : Type u
inst✝ : Category.{v, u} C
D : GlueData C
i j k : D.J
U : Opens ↑↑(pullback (f D.toGlueData i j) (f D.toGlueData i k))
this : pullback.fst ≫ t D.toGlueData k i = t' D.toGlueData k i j ≫ pullback.snd
⊢ ↑(t D.toGlueData k i).base ⁻¹' (↑pullback.snd.base '' ↑U) =
    ↑pullback.fst.base '' (↑(t' D.toGlueData k i j).base ⁻¹' ↑U)
[PROOFSTEP]
rw [← IsIso.inv_comp_eq] at this
[GOAL]
case w.e_x.e_carrier
C : Type u
inst✝ : Category.{v, u} C
D : GlueData C
i j k : D.J
U : Opens ↑↑(pullback (f D.toGlueData i j) (f D.toGlueData i k))
this : inv (t' D.toGlueData k i j) ≫ pullback.fst ≫ t D.toGlueData k i = pullback.snd
⊢ ↑(t D.toGlueData k i).base ⁻¹' (↑pullback.snd.base '' ↑U) =
    ↑pullback.fst.base '' (↑(t' D.toGlueData k i j).base ⁻¹' ↑U)
[PROOFSTEP]
replace this := (congr_arg ((PresheafedSpace.Hom.base ·)) this).symm
[GOAL]
case w.e_x.e_carrier
C : Type u
inst✝ : Category.{v, u} C
D : GlueData C
i j k : D.J
U : Opens ↑↑(pullback (f D.toGlueData i j) (f D.toGlueData i k))
this : pullback.snd.base = (inv (t' D.toGlueData k i j) ≫ pullback.fst ≫ t D.toGlueData k i).base
⊢ ↑(t D.toGlueData k i).base ⁻¹' (↑pullback.snd.base '' ↑U) =
    ↑pullback.fst.base '' (↑(t' D.toGlueData k i j).base ⁻¹' ↑U)
[PROOFSTEP]
replace this := congr_arg (ContinuousMap.toFun ·) this
[GOAL]
case w.e_x.e_carrier
C : Type u
inst✝ : Category.{v, u} C
D : GlueData C
i j k : D.J
U : Opens ↑↑(pullback (f D.toGlueData i j) (f D.toGlueData i k))
this :
  (fun x => x.toFun) pullback.snd.base =
    (fun x => x.toFun) (inv (t' D.toGlueData k i j) ≫ pullback.fst ≫ t D.toGlueData k i).base
⊢ ↑(t D.toGlueData k i).base ⁻¹' (↑pullback.snd.base '' ↑U) =
    ↑pullback.fst.base '' (↑(t' D.toGlueData k i j).base ⁻¹' ↑U)
[PROOFSTEP]
dsimp at this
[GOAL]
case w.e_x.e_carrier
C : Type u
inst✝ : Category.{v, u} C
D : GlueData C
i j k : D.J
U : Opens ↑↑(pullback (f D.toGlueData i j) (f D.toGlueData i k))
this : ↑pullback.snd.base = ↑((inv (t' D.toGlueData k i j)).base ≫ pullback.fst.base ≫ (t D.toGlueData k i).base)
⊢ ↑(t D.toGlueData k i).base ⁻¹' (↑pullback.snd.base '' ↑U) =
    ↑pullback.fst.base '' (↑(t' D.toGlueData k i j).base ⁻¹' ↑U)
[PROOFSTEP]
rw [coe_comp, coe_comp] at this
[GOAL]
case w.e_x.e_carrier
C : Type u
inst✝ : Category.{v, u} C
D : GlueData C
i j k : D.J
U : Opens ↑↑(pullback (f D.toGlueData i j) (f D.toGlueData i k))
this : ↑pullback.snd.base = (↑(t D.toGlueData k i).base ∘ ↑pullback.fst.base) ∘ ↑(inv (t' D.toGlueData k i j)).base
⊢ ↑(t D.toGlueData k i).base ⁻¹' (↑pullback.snd.base '' ↑U) =
    ↑pullback.fst.base '' (↑(t' D.toGlueData k i j).base ⁻¹' ↑U)
[PROOFSTEP]
rw [this, Set.image_comp, Set.image_comp, Set.preimage_image_eq]
[GOAL]
case w.e_x.e_carrier
C : Type u
inst✝ : Category.{v, u} C
D : GlueData C
i j k : D.J
U : Opens ↑↑(pullback (f D.toGlueData i j) (f D.toGlueData i k))
this : ↑pullback.snd.base = (↑(t D.toGlueData k i).base ∘ ↑pullback.fst.base) ∘ ↑(inv (t' D.toGlueData k i j)).base
⊢ ↑pullback.fst.base '' (↑(inv (t' D.toGlueData k i j)).base '' ↑U) =
    ↑pullback.fst.base '' (↑(t' D.toGlueData k i j).base ⁻¹' ↑U)
case w.e_x.e_carrier.h
C : Type u
inst✝ : Category.{v, u} C
D : GlueData C
i j k : D.J
U : Opens ↑↑(pullback (f D.toGlueData i j) (f D.toGlueData i k))
this : ↑pullback.snd.base = (↑(t D.toGlueData k i).base ∘ ↑pullback.fst.base) ∘ ↑(inv (t' D.toGlueData k i j)).base
⊢ Function.Injective ↑(t D.toGlueData k i).base
[PROOFSTEP]
swap
[GOAL]
case w.e_x.e_carrier.h
C : Type u
inst✝ : Category.{v, u} C
D : GlueData C
i j k : D.J
U : Opens ↑↑(pullback (f D.toGlueData i j) (f D.toGlueData i k))
this : ↑pullback.snd.base = (↑(t D.toGlueData k i).base ∘ ↑pullback.fst.base) ∘ ↑(inv (t' D.toGlueData k i j)).base
⊢ Function.Injective ↑(t D.toGlueData k i).base
[PROOFSTEP]
refine Function.HasLeftInverse.injective ⟨(D.t i k).base, fun x => ?_⟩
[GOAL]
case w.e_x.e_carrier.h
C : Type u
inst✝ : Category.{v, u} C
D : GlueData C
i j k : D.J
U : Opens ↑↑(pullback (f D.toGlueData i j) (f D.toGlueData i k))
this : ↑pullback.snd.base = (↑(t D.toGlueData k i).base ∘ ↑pullback.fst.base) ∘ ↑(inv (t' D.toGlueData k i j)).base
x : ↑↑(V D.toGlueData (k, i))
⊢ ↑(t D.toGlueData i k).base (↑(t D.toGlueData k i).base x) = x
[PROOFSTEP]
rw [← comp_apply, ← comp_base, D.t_inv, id_base, id_apply]
[GOAL]
case w.e_x.e_carrier
C : Type u
inst✝ : Category.{v, u} C
D : GlueData C
i j k : D.J
U : Opens ↑↑(pullback (f D.toGlueData i j) (f D.toGlueData i k))
this : ↑pullback.snd.base = (↑(t D.toGlueData k i).base ∘ ↑pullback.fst.base) ∘ ↑(inv (t' D.toGlueData k i j)).base
⊢ ↑pullback.fst.base '' (↑(inv (t' D.toGlueData k i j)).base '' ↑U) =
    ↑pullback.fst.base '' (↑(t' D.toGlueData k i j).base ⁻¹' ↑U)
[PROOFSTEP]
refine congr_arg (_ '' ·) ?_
[GOAL]
case w.e_x.e_carrier
C : Type u
inst✝ : Category.{v, u} C
D : GlueData C
i j k : D.J
U : Opens ↑↑(pullback (f D.toGlueData i j) (f D.toGlueData i k))
this : ↑pullback.snd.base = (↑(t D.toGlueData k i).base ∘ ↑pullback.fst.base) ∘ ↑(inv (t' D.toGlueData k i j)).base
⊢ ↑(inv (t' D.toGlueData k i j)).base '' ↑U = ↑(t' D.toGlueData k i j).base ⁻¹' ↑U
[PROOFSTEP]
refine congr_fun ?_ _
[GOAL]
case w.e_x.e_carrier
C : Type u
inst✝ : Category.{v, u} C
D : GlueData C
i j k : D.J
U : Opens ↑↑(pullback (f D.toGlueData i j) (f D.toGlueData i k))
this : ↑pullback.snd.base = (↑(t D.toGlueData k i).base ∘ ↑pullback.fst.base) ∘ ↑(inv (t' D.toGlueData k i j)).base
⊢ Set.image ↑(inv (t' D.toGlueData k i j)).base = Set.preimage ↑(t' D.toGlueData k i j).base
[PROOFSTEP]
refine Set.image_eq_preimage_of_inverse ?_ ?_
[GOAL]
case w.e_x.e_carrier.refine_1
C : Type u
inst✝ : Category.{v, u} C
D : GlueData C
i j k : D.J
U : Opens ↑↑(pullback (f D.toGlueData i j) (f D.toGlueData i k))
this : ↑pullback.snd.base = (↑(t D.toGlueData k i).base ∘ ↑pullback.fst.base) ∘ ↑(inv (t' D.toGlueData k i j)).base
⊢ Function.LeftInverse ↑(t' D.toGlueData k i j).base ↑(inv (t' D.toGlueData k i j)).base
[PROOFSTEP]
intro x
[GOAL]
case w.e_x.e_carrier.refine_1
C : Type u
inst✝ : Category.{v, u} C
D : GlueData C
i j k : D.J
U : Opens ↑↑(pullback (f D.toGlueData i j) (f D.toGlueData i k))
this : ↑pullback.snd.base = (↑(t D.toGlueData k i).base ∘ ↑pullback.fst.base) ∘ ↑(inv (t' D.toGlueData k i j)).base
x : (CategoryTheory.forget TopCat).obj ↑(pullback (f D.toGlueData i j) (f D.toGlueData i k))
⊢ ↑(t' D.toGlueData k i j).base (↑(inv (t' D.toGlueData k i j)).base x) = x
[PROOFSTEP]
rw [← comp_apply, ← comp_base, IsIso.inv_hom_id, id_base, id_apply]
[GOAL]
case w.e_x.e_carrier.refine_2
C : Type u
inst✝ : Category.{v, u} C
D : GlueData C
i j k : D.J
U : Opens ↑↑(pullback (f D.toGlueData i j) (f D.toGlueData i k))
this : ↑pullback.snd.base = (↑(t D.toGlueData k i).base ∘ ↑pullback.fst.base) ∘ ↑(inv (t' D.toGlueData k i j)).base
⊢ Function.RightInverse ↑(t' D.toGlueData k i j).base ↑(inv (t' D.toGlueData k i j)).base
[PROOFSTEP]
intro x
[GOAL]
case w.e_x.e_carrier.refine_2
C : Type u
inst✝ : Category.{v, u} C
D : GlueData C
i j k : D.J
U : Opens ↑↑(pullback (f D.toGlueData i j) (f D.toGlueData i k))
this : ↑pullback.snd.base = (↑(t D.toGlueData k i).base ∘ ↑pullback.fst.base) ∘ ↑(inv (t' D.toGlueData k i j)).base
x : (CategoryTheory.forget TopCat).obj ↑(pullback (f D.toGlueData k i) (f D.toGlueData k j))
⊢ ↑(inv (t' D.toGlueData k i j)).base (↑(t' D.toGlueData k i j).base x) = x
[PROOFSTEP]
rw [← comp_apply, ← comp_base, IsIso.hom_inv_id, id_base, id_apply]
[GOAL]
case h
C : Type u
inst✝ : Category.{v, u} C
D : GlueData C
i j k : D.J
U : Opens ↑↑(pullback (f D.toGlueData i j) (f D.toGlueData i k))
⊢ IsOpenImmersion.invApp (_ : IsOpenImmersion pullback.snd) U ≫
      NatTrans.app (t D.toGlueData k i).c
          (op ((IsOpenImmersion.openFunctor (_ : IsOpenImmersion pullback.snd)).obj U)) ≫
        (V D.toGlueData (k, i)).presheaf.map
          (eqToHom
            (_ :
              (Opens.map (t D.toGlueData k i).base).op.obj
                  (op ((IsOpenImmersion.openFunctor (_ : IsOpenImmersion pullback.snd)).obj U)) =
                op
                  ((IsOpenImmersion.openFunctor (_ : IsOpenImmersion pullback.fst)).obj
                    {
                        unop :=
                          { carrier := ↑(t' D.toGlueData k i j).base ⁻¹' ↑(op U).unop,
                            is_open' := (_ : IsOpen (↑(t' D.toGlueData k i j).base ⁻¹' ↑(op U).unop)) } }.unop))) =
    NatTrans.app (t' D.toGlueData k i j).c (op U) ≫
      IsOpenImmersion.invApp (_ : IsOpenImmersion pullback.fst)
        {
            unop :=
              { carrier := ↑(t' D.toGlueData k i j).base ⁻¹' ↑(op U).unop,
                is_open' := (_ : IsOpen (↑(t' D.toGlueData k i j).base ⁻¹' ↑(op U).unop)) } }.unop
[PROOFSTEP]
rw [← IsIso.eq_inv_comp, IsOpenImmersion.inv_invApp, Category.assoc, (D.t' k i j).c.naturality_assoc]
[GOAL]
case h
C : Type u
inst✝ : Category.{v, u} C
D : GlueData C
i j k : D.J
U : Opens ↑↑(pullback (f D.toGlueData i j) (f D.toGlueData i k))
⊢ NatTrans.app (t D.toGlueData k i).c (op ((IsOpenImmersion.openFunctor (_ : IsOpenImmersion pullback.snd)).obj U)) ≫
      (V D.toGlueData (k, i)).presheaf.map
        (eqToHom
          (_ :
            (Opens.map (t D.toGlueData k i).base).op.obj
                (op ((IsOpenImmersion.openFunctor (_ : IsOpenImmersion pullback.snd)).obj U)) =
              op
                ((IsOpenImmersion.openFunctor (_ : IsOpenImmersion pullback.fst)).obj
                  {
                      unop :=
                        { carrier := ↑(t' D.toGlueData k i j).base ⁻¹' ↑(op U).unop,
                          is_open' := (_ : IsOpen (↑(t' D.toGlueData k i j).base ⁻¹' ↑(op U).unop)) } }.unop))) =
    NatTrans.app pullback.snd.c (op ((IsOpenImmersion.openFunctor (_ : IsOpenImmersion pullback.snd)).obj U)) ≫
      NatTrans.app (t' D.toGlueData k i j).c
          ((Opens.map pullback.snd.base).op.obj
            (op ((IsOpenImmersion.openFunctor (_ : IsOpenImmersion pullback.snd)).obj U))) ≫
        ((t' D.toGlueData k i j).base _* (pullback (f D.toGlueData k i) (f D.toGlueData k j)).presheaf).map
            (eqToHom
              (_ :
                op
                    ((Opens.map pullback.snd.base).obj
                      (op ((IsOpenImmersion.openFunctor (_ : IsOpenImmersion pullback.snd)).obj U)).unop) =
                  op U)) ≫
          IsOpenImmersion.invApp (_ : IsOpenImmersion pullback.fst)
            {
                unop :=
                  { carrier := ↑(t' D.toGlueData k i j).base ⁻¹' ↑(op U).unop,
                    is_open' := (_ : IsOpen (↑(t' D.toGlueData k i j).base ⁻¹' ↑(op U).unop)) } }.unop
[PROOFSTEP]
simp_rw [← Category.assoc]
[GOAL]
case h
C : Type u
inst✝ : Category.{v, u} C
D : GlueData C
i j k : D.J
U : Opens ↑↑(pullback (f D.toGlueData i j) (f D.toGlueData i k))
⊢ NatTrans.app (t D.toGlueData k i).c (op ((IsOpenImmersion.openFunctor (_ : IsOpenImmersion pullback.snd)).obj U)) ≫
      (V D.toGlueData (k, i)).presheaf.map
        (eqToHom
          (_ :
            (Opens.map (t D.toGlueData k i).base).op.obj
                (op ((IsOpenImmersion.openFunctor (_ : IsOpenImmersion pullback.snd)).obj U)) =
              op
                ((IsOpenImmersion.openFunctor (_ : IsOpenImmersion pullback.fst)).obj
                  {
                      unop :=
                        { carrier := ↑(t' D.toGlueData k i j).base ⁻¹' ↑(op U).unop,
                          is_open' := (_ : IsOpen (↑(t' D.toGlueData k i j).base ⁻¹' ↑(op U).unop)) } }.unop))) =
    ((NatTrans.app pullback.snd.c (op ((IsOpenImmersion.openFunctor (_ : IsOpenImmersion pullback.snd)).obj U)) ≫
          NatTrans.app (t' D.toGlueData k i j).c
            ((Opens.map pullback.snd.base).op.obj
              (op ((IsOpenImmersion.openFunctor (_ : IsOpenImmersion pullback.snd)).obj U)))) ≫
        ((t' D.toGlueData k i j).base _* (pullback (f D.toGlueData k i) (f D.toGlueData k j)).presheaf).map
          (eqToHom
            (_ :
              op
                  ((Opens.map pullback.snd.base).obj
                    (op ((IsOpenImmersion.openFunctor (_ : IsOpenImmersion pullback.snd)).obj U)).unop) =
                op U))) ≫
      IsOpenImmersion.invApp (_ : IsOpenImmersion pullback.fst)
        { carrier := ↑(t' D.toGlueData k i j).base ⁻¹' ↑(op U).unop,
          is_open' := (_ : IsOpen (↑(t' D.toGlueData k i j).base ⁻¹' ↑(op U).unop)) }
[PROOFSTEP]
erw [← comp_c_app]
[GOAL]
case h
C : Type u
inst✝ : Category.{v, u} C
D : GlueData C
i j k : D.J
U : Opens ↑↑(pullback (f D.toGlueData i j) (f D.toGlueData i k))
⊢ NatTrans.app (t D.toGlueData k i).c (op ((IsOpenImmersion.openFunctor (_ : IsOpenImmersion pullback.snd)).obj U)) ≫
      (V D.toGlueData (k, i)).presheaf.map
        (eqToHom
          (_ :
            (Opens.map (t D.toGlueData k i).base).op.obj
                (op ((IsOpenImmersion.openFunctor (_ : IsOpenImmersion pullback.snd)).obj U)) =
              op
                ((IsOpenImmersion.openFunctor (_ : IsOpenImmersion pullback.fst)).obj
                  {
                      unop :=
                        { carrier := ↑(t' D.toGlueData k i j).base ⁻¹' ↑(op U).unop,
                          is_open' := (_ : IsOpen (↑(t' D.toGlueData k i j).base ⁻¹' ↑(op U).unop)) } }.unop))) =
    (NatTrans.app (t' D.toGlueData k i j ≫ pullback.snd).c
          (op ((IsOpenImmersion.openFunctor (_ : IsOpenImmersion pullback.snd)).obj U)) ≫
        ((t' D.toGlueData k i j).base _* (pullback (f D.toGlueData k i) (f D.toGlueData k j)).presheaf).map
          (eqToHom
            (_ :
              op
                  ((Opens.map pullback.snd.base).obj
                    (op ((IsOpenImmersion.openFunctor (_ : IsOpenImmersion pullback.snd)).obj U)).unop) =
                op U))) ≫
      IsOpenImmersion.invApp (_ : IsOpenImmersion pullback.fst)
        { carrier := ↑(t' D.toGlueData k i j).base ⁻¹' ↑(op U).unop,
          is_open' := (_ : IsOpen (↑(t' D.toGlueData k i j).base ⁻¹' ↑(op U).unop)) }
[PROOFSTEP]
rw [congr_app (D.t_fac k i j), comp_c_app]
[GOAL]
case h
C : Type u
inst✝ : Category.{v, u} C
D : GlueData C
i j k : D.J
U : Opens ↑↑(pullback (f D.toGlueData i j) (f D.toGlueData i k))
⊢ NatTrans.app (t D.toGlueData k i).c (op ((IsOpenImmersion.openFunctor (_ : IsOpenImmersion pullback.snd)).obj U)) ≫
      (V D.toGlueData (k, i)).presheaf.map
        (eqToHom
          (_ :
            (Opens.map (t D.toGlueData k i).base).op.obj
                (op ((IsOpenImmersion.openFunctor (_ : IsOpenImmersion pullback.snd)).obj U)) =
              op
                ((IsOpenImmersion.openFunctor (_ : IsOpenImmersion pullback.fst)).obj
                  {
                      unop :=
                        { carrier := ↑(t' D.toGlueData k i j).base ⁻¹' ↑(op U).unop,
                          is_open' := (_ : IsOpen (↑(t' D.toGlueData k i j).base ⁻¹' ↑(op U).unop)) } }.unop))) =
    (((NatTrans.app (t D.toGlueData k i).c
              (op ((IsOpenImmersion.openFunctor (_ : IsOpenImmersion pullback.snd)).obj U)) ≫
            NatTrans.app pullback.fst.c
              (op
                ((Opens.map (t D.toGlueData k i).base).obj
                  (op ((IsOpenImmersion.openFunctor (_ : IsOpenImmersion pullback.snd)).obj U)).unop))) ≫
          (pullback (f D.toGlueData k i) (f D.toGlueData k j)).presheaf.map
            (eqToHom
              (_ :
                (Opens.map (pullback.fst ≫ t D.toGlueData k i).base).op.obj
                    (op ((IsOpenImmersion.openFunctor (_ : IsOpenImmersion pullback.snd)).obj U)) =
                  (Opens.map (t' D.toGlueData k i j ≫ pullback.snd).base).op.obj
                    (op ((IsOpenImmersion.openFunctor (_ : IsOpenImmersion pullback.snd)).obj U))))) ≫
        ((t' D.toGlueData k i j).base _* (pullback (f D.toGlueData k i) (f D.toGlueData k j)).presheaf).map
          (eqToHom
            (_ :
              op
                  ((Opens.map pullback.snd.base).obj
                    (op ((IsOpenImmersion.openFunctor (_ : IsOpenImmersion pullback.snd)).obj U)).unop) =
                op U))) ≫
      IsOpenImmersion.invApp (_ : IsOpenImmersion pullback.fst)
        { carrier := ↑(t' D.toGlueData k i j).base ⁻¹' ↑(op U).unop,
          is_open' := (_ : IsOpen (↑(t' D.toGlueData k i j).base ⁻¹' ↑(op U).unop)) }
[PROOFSTEP]
simp_rw [Category.assoc]
[GOAL]
case h
C : Type u
inst✝ : Category.{v, u} C
D : GlueData C
i j k : D.J
U : Opens ↑↑(pullback (f D.toGlueData i j) (f D.toGlueData i k))
⊢ NatTrans.app (t D.toGlueData k i).c (op ((IsOpenImmersion.openFunctor (_ : IsOpenImmersion pullback.snd)).obj U)) ≫
      (V D.toGlueData (k, i)).presheaf.map
        (eqToHom
          (_ :
            (Opens.map (t D.toGlueData k i).base).op.obj
                (op ((IsOpenImmersion.openFunctor (_ : IsOpenImmersion pullback.snd)).obj U)) =
              op
                ((IsOpenImmersion.openFunctor (_ : IsOpenImmersion pullback.fst)).obj
                  {
                      unop :=
                        { carrier := ↑(t' D.toGlueData k i j).base ⁻¹' ↑(op U).unop,
                          is_open' := (_ : IsOpen (↑(t' D.toGlueData k i j).base ⁻¹' ↑(op U).unop)) } }.unop))) =
    NatTrans.app (t D.toGlueData k i).c (op ((IsOpenImmersion.openFunctor (_ : IsOpenImmersion pullback.snd)).obj U)) ≫
      NatTrans.app pullback.fst.c
          (op
            ((Opens.map (t D.toGlueData k i).base).obj
              (op ((IsOpenImmersion.openFunctor (_ : IsOpenImmersion pullback.snd)).obj U)).unop)) ≫
        (pullback (f D.toGlueData k i) (f D.toGlueData k j)).presheaf.map
            (eqToHom
              (_ :
                (Opens.map (pullback.fst ≫ t D.toGlueData k i).base).op.obj
                    (op ((IsOpenImmersion.openFunctor (_ : IsOpenImmersion pullback.snd)).obj U)) =
                  (Opens.map (t' D.toGlueData k i j ≫ pullback.snd).base).op.obj
                    (op ((IsOpenImmersion.openFunctor (_ : IsOpenImmersion pullback.snd)).obj U)))) ≫
          ((t' D.toGlueData k i j).base _* (pullback (f D.toGlueData k i) (f D.toGlueData k j)).presheaf).map
              (eqToHom
                (_ :
                  op
                      ((Opens.map pullback.snd.base).obj
                        (op ((IsOpenImmersion.openFunctor (_ : IsOpenImmersion pullback.snd)).obj U)).unop) =
                    op U)) ≫
            IsOpenImmersion.invApp (_ : IsOpenImmersion pullback.fst)
              { carrier := ↑(t' D.toGlueData k i j).base ⁻¹' ↑(op U).unop,
                is_open' := (_ : IsOpen (↑(t' D.toGlueData k i j).base ⁻¹' ↑(op U).unop)) }
[PROOFSTEP]
erw [IsOpenImmersion.inv_naturality, IsOpenImmersion.inv_naturality_assoc, IsOpenImmersion.app_inv_app'_assoc]
[GOAL]
case h
C : Type u
inst✝ : Category.{v, u} C
D : GlueData C
i j k : D.J
U : Opens ↑↑(pullback (f D.toGlueData i j) (f D.toGlueData i k))
⊢ NatTrans.app (t D.toGlueData k i).c (op ((IsOpenImmersion.openFunctor (_ : IsOpenImmersion pullback.snd)).obj U)) ≫
      (V D.toGlueData (k, i)).presheaf.map
        (eqToHom
          (_ :
            (Opens.map (t D.toGlueData k i).base).op.obj
                (op ((IsOpenImmersion.openFunctor (_ : IsOpenImmersion pullback.snd)).obj U)) =
              op
                ((IsOpenImmersion.openFunctor (_ : IsOpenImmersion pullback.fst)).obj
                  {
                      unop :=
                        { carrier := ↑(t' D.toGlueData k i j).base ⁻¹' ↑(op U).unop,
                          is_open' := (_ : IsOpen (↑(t' D.toGlueData k i j).base ⁻¹' ↑(op U).unop)) } }.unop))) =
    NatTrans.app (t D.toGlueData k i).c (op ((IsOpenImmersion.openFunctor (_ : IsOpenImmersion pullback.snd)).obj U)) ≫
      (V D.toGlueData (k, i)).presheaf.map
          (eqToHom
              (_ :
                (IsOpenImmersion.openFunctor (_ : IsOpenImmersion pullback.fst)).obj
                    ((Opens.map pullback.fst.base).obj
                      ((Opens.map (t D.toGlueData k i).base).obj
                        (op ((IsOpenImmersion.openFunctor (_ : IsOpenImmersion pullback.snd)).obj U)).unop)) =
                  (Opens.map (t D.toGlueData k i).base).obj
                    (op ((IsOpenImmersion.openFunctor (_ : IsOpenImmersion pullback.snd)).obj U)).unop)).op ≫
        (V D.toGlueData (k, i)).presheaf.map
            ((IsOpenImmersion.openFunctor (_ : IsOpenImmersion pullback.fst)).op.map
              (eqToHom
                (_ :
                  (Opens.map (pullback.fst ≫ t D.toGlueData k i).base).op.obj
                      (op ((IsOpenImmersion.openFunctor (_ : IsOpenImmersion pullback.snd)).obj U)) =
                    (Opens.map (t' D.toGlueData k i j ≫ pullback.snd).base).op.obj
                      (op ((IsOpenImmersion.openFunctor (_ : IsOpenImmersion pullback.snd)).obj U))))) ≫
          (V D.toGlueData (k, i)).presheaf.map
            ((IsOpenImmersion.openFunctor (_ : IsOpenImmersion pullback.fst)).op.map
              ((Opens.map (t' D.toGlueData k i j).base).op.map
                (eqToHom
                  (_ :
                    op
                        ((Opens.map pullback.snd.base).obj
                          (op ((IsOpenImmersion.openFunctor (_ : IsOpenImmersion pullback.snd)).obj U)).unop) =
                      op U))))
case h.hU
C : Type u
inst✝ : Category.{v, u} C
D : GlueData C
i j k : D.J
U : Opens ↑↑(pullback (f D.toGlueData i j) (f D.toGlueData i k))
⊢ ↑((Opens.map (t D.toGlueData k i).base).obj
        (op ((IsOpenImmersion.openFunctor (_ : IsOpenImmersion pullback.snd)).obj U)).unop) ⊆
    Set.range ↑pullback.fst.base
[PROOFSTEP]
simp_rw [← (𝖣.V (k, i)).presheaf.map_comp, eqToHom_map (Functor.op _), eqToHom_op, eqToHom_trans]
[GOAL]
case h.hU
C : Type u
inst✝ : Category.{v, u} C
D : GlueData C
i j k : D.J
U : Opens ↑↑(pullback (f D.toGlueData i j) (f D.toGlueData i k))
⊢ ↑((Opens.map (t D.toGlueData k i).base).obj
        (op ((IsOpenImmersion.openFunctor (_ : IsOpenImmersion pullback.snd)).obj U)).unop) ⊆
    Set.range ↑pullback.fst.base
[PROOFSTEP]
rintro x ⟨y, -, eq⟩
[GOAL]
case h.hU.intro.intro
C : Type u
inst✝ : Category.{v, u} C
D : GlueData C
i j k : D.J
U : Opens ↑↑(pullback (f D.toGlueData i j) (f D.toGlueData i k))
x : ↑↑(V D.toGlueData (k, i))
y : (CategoryTheory.forget TopCat).obj ↑(pullback (f D.toGlueData i j) (f D.toGlueData i k))
eq : ↑pullback.snd.base y = ↑(t D.toGlueData k i).base x
⊢ x ∈ Set.range ↑pullback.fst.base
[PROOFSTEP]
replace eq := ConcreteCategory.congr_arg (𝖣.t i k).base eq
[GOAL]
case h.hU.intro.intro
C : Type u
inst✝ : Category.{v, u} C
D : GlueData C
i j k : D.J
U : Opens ↑↑(pullback (f D.toGlueData i j) (f D.toGlueData i k))
x : ↑↑(V D.toGlueData (k, i))
y : (CategoryTheory.forget TopCat).obj ↑(pullback (f D.toGlueData i j) (f D.toGlueData i k))
eq : ↑(t D.toGlueData i k).base (↑pullback.snd.base y) = ↑(t D.toGlueData i k).base (↑(t D.toGlueData k i).base x)
⊢ x ∈ Set.range ↑pullback.fst.base
[PROOFSTEP]
change ((π₂ i, j, k) ≫ D.t i k).base y = (D.t k i ≫ D.t i k).base x at eq
[GOAL]
case h.hU.intro.intro
C : Type u
inst✝ : Category.{v, u} C
D : GlueData C
i j k : D.J
U : Opens ↑↑(pullback (f D.toGlueData i j) (f D.toGlueData i k))
x : ↑↑(V D.toGlueData (k, i))
y : (CategoryTheory.forget TopCat).obj ↑(pullback (f D.toGlueData i j) (f D.toGlueData i k))
eq : ↑(pullback.snd ≫ t D.toGlueData i k).base y = ↑(t D.toGlueData k i ≫ t D.toGlueData i k).base x
⊢ x ∈ Set.range ↑pullback.fst.base
[PROOFSTEP]
rw [𝖣.t_inv, id_base, TopCat.id_app] at eq
[GOAL]
case h.hU.intro.intro
C : Type u
inst✝ : Category.{v, u} C
D : GlueData C
i j k : D.J
U : Opens ↑↑(pullback (f D.toGlueData i j) (f D.toGlueData i k))
x : ↑↑(V D.toGlueData (k, i))
y : (CategoryTheory.forget TopCat).obj ↑(pullback (f D.toGlueData i j) (f D.toGlueData i k))
eq : ↑(pullback.snd ≫ t D.toGlueData i k).base y = x
⊢ x ∈ Set.range ↑pullback.fst.base
[PROOFSTEP]
subst eq
[GOAL]
case h.hU.intro.intro
C : Type u
inst✝ : Category.{v, u} C
D : GlueData C
i j k : D.J
U : Opens ↑↑(pullback (f D.toGlueData i j) (f D.toGlueData i k))
y : (CategoryTheory.forget TopCat).obj ↑(pullback (f D.toGlueData i j) (f D.toGlueData i k))
⊢ ↑(pullback.snd ≫ t D.toGlueData i k).base y ∈ Set.range ↑pullback.fst.base
[PROOFSTEP]
use(inv (D.t' k i j)).base y
[GOAL]
case h
C : Type u
inst✝ : Category.{v, u} C
D : GlueData C
i j k : D.J
U : Opens ↑↑(pullback (f D.toGlueData i j) (f D.toGlueData i k))
y : (CategoryTheory.forget TopCat).obj ↑(pullback (f D.toGlueData i j) (f D.toGlueData i k))
⊢ ↑pullback.fst.base (↑(inv (t' D.toGlueData k i j)).base y) = ↑(pullback.snd ≫ t D.toGlueData i k).base y
[PROOFSTEP]
change (inv (D.t' k i j) ≫ π₁ k, i, j).base y = _
[GOAL]
case h
C : Type u
inst✝ : Category.{v, u} C
D : GlueData C
i j k : D.J
U : Opens ↑↑(pullback (f D.toGlueData i j) (f D.toGlueData i k))
y : (CategoryTheory.forget TopCat).obj ↑(pullback (f D.toGlueData i j) (f D.toGlueData i k))
⊢ ↑(inv (t' D.toGlueData k i j) ≫ pullback.fst).base y = ↑(pullback.snd ≫ t D.toGlueData i k).base y
[PROOFSTEP]
congr 2
[GOAL]
case h.e_a.e_self
C : Type u
inst✝ : Category.{v, u} C
D : GlueData C
i j k : D.J
U : Opens ↑↑(pullback (f D.toGlueData i j) (f D.toGlueData i k))
y : (CategoryTheory.forget TopCat).obj ↑(pullback (f D.toGlueData i j) (f D.toGlueData i k))
⊢ inv (t' D.toGlueData k i j) ≫ pullback.fst = pullback.snd ≫ t D.toGlueData i k
[PROOFSTEP]
rw [IsIso.inv_comp_eq, 𝖣.t_fac_assoc, 𝖣.t_inv, Category.comp_id]
[GOAL]
C : Type u
inst✝ : Category.{v, u} C
D : GlueData C
i j k : D.J
U : Opens ↑↑(pullback (f D.toGlueData i j) (f D.toGlueData i k))
⊢ IsOpenImmersion.invApp (_ : IsOpenImmersion pullback.snd) U ≫
      NatTrans.app (t D.toGlueData k i).c
        (op ((IsOpenImmersion.openFunctor (_ : IsOpenImmersion pullback.snd)).obj U)) =
    NatTrans.app (t' D.toGlueData k i j).c (op U) ≫
      IsOpenImmersion.invApp (_ : IsOpenImmersion pullback.fst)
          {
              unop :=
                { carrier := ↑(t' D.toGlueData k i j).base ⁻¹' ↑(op U).unop,
                  is_open' := (_ : IsOpen (↑(t' D.toGlueData k i j).base ⁻¹' ↑(op U).unop)) } }.unop ≫
        (V D.toGlueData (k, i)).presheaf.map
          (eqToHom
            (_ :
              op
                  ((IsOpenImmersion.openFunctor (_ : IsOpenImmersion pullback.fst)).obj
                    {
                        unop :=
                          { carrier := ↑(t' D.toGlueData k i j).base ⁻¹' ↑(op U).unop,
                            is_open' := (_ : IsOpen (↑(t' D.toGlueData k i j).base ⁻¹' ↑(op U).unop)) } }.unop) =
                (Opens.map (t D.toGlueData k i).base).op.obj
                  (op ((IsOpenImmersion.openFunctor (_ : IsOpenImmersion pullback.snd)).obj U))))
[PROOFSTEP]
have e := (D.snd_invApp_t_app' i j k U).choose_spec
[GOAL]
C : Type u
inst✝ : Category.{v, u} C
D : GlueData C
i j k : D.J
U : Opens ↑↑(pullback (f D.toGlueData i j) (f D.toGlueData i k))
e :
  IsOpenImmersion.invApp (_ : IsOpenImmersion pullback.snd) U ≫
      NatTrans.app (t D.toGlueData k i).c
          (op ((IsOpenImmersion.openFunctor (_ : IsOpenImmersion pullback.snd)).obj U)) ≫
        (V D.toGlueData (k, i)).presheaf.map
          (eqToHom
            (_ :
              (Opens.map (t D.toGlueData k i).base).op.obj
                  (op ((IsOpenImmersion.openFunctor (_ : IsOpenImmersion pullback.snd)).obj U)) =
                op
                  ((IsOpenImmersion.openFunctor (_ : IsOpenImmersion pullback.fst)).obj
                    {
                        unop :=
                          { carrier := ↑(t' D.toGlueData k i j).base ⁻¹' ↑(op U).unop,
                            is_open' := (_ : IsOpen (↑(t' D.toGlueData k i j).base ⁻¹' ↑(op U).unop)) } }.unop))) =
    NatTrans.app (t' D.toGlueData k i j).c (op U) ≫
      IsOpenImmersion.invApp (_ : IsOpenImmersion pullback.fst)
        {
            unop :=
              { carrier := ↑(t' D.toGlueData k i j).base ⁻¹' ↑(op U).unop,
                is_open' := (_ : IsOpen (↑(t' D.toGlueData k i j).base ⁻¹' ↑(op U).unop)) } }.unop
⊢ IsOpenImmersion.invApp (_ : IsOpenImmersion pullback.snd) U ≫
      NatTrans.app (t D.toGlueData k i).c
        (op ((IsOpenImmersion.openFunctor (_ : IsOpenImmersion pullback.snd)).obj U)) =
    NatTrans.app (t' D.toGlueData k i j).c (op U) ≫
      IsOpenImmersion.invApp (_ : IsOpenImmersion pullback.fst)
          {
              unop :=
                { carrier := ↑(t' D.toGlueData k i j).base ⁻¹' ↑(op U).unop,
                  is_open' := (_ : IsOpen (↑(t' D.toGlueData k i j).base ⁻¹' ↑(op U).unop)) } }.unop ≫
        (V D.toGlueData (k, i)).presheaf.map
          (eqToHom
            (_ :
              op
                  ((IsOpenImmersion.openFunctor (_ : IsOpenImmersion pullback.fst)).obj
                    {
                        unop :=
                          { carrier := ↑(t' D.toGlueData k i j).base ⁻¹' ↑(op U).unop,
                            is_open' := (_ : IsOpen (↑(t' D.toGlueData k i j).base ⁻¹' ↑(op U).unop)) } }.unop) =
                (Opens.map (t D.toGlueData k i).base).op.obj
                  (op ((IsOpenImmersion.openFunctor (_ : IsOpenImmersion pullback.snd)).obj U))))
[PROOFSTEP]
replace e := reassoc_of% e
[GOAL]
C : Type u
inst✝ : Category.{v, u} C
D : GlueData C
i j k : D.J
U : Opens ↑↑(pullback (f D.toGlueData i j) (f D.toGlueData i k))
e :
  ∀ {Z : C}
    (h :
      (V D.toGlueData (k, i)).presheaf.obj
          (op
            ((IsOpenImmersion.openFunctor (_ : IsOpenImmersion pullback.fst)).obj
              {
                  unop :=
                    { carrier := ↑(t' D.toGlueData k i j).base ⁻¹' ↑(op U).unop,
                      is_open' := (_ : IsOpen (↑(t' D.toGlueData k i j).base ⁻¹' ↑(op U).unop)) } }.unop)) ⟶
        Z),
    IsOpenImmersion.invApp (_ : IsOpenImmersion pullback.snd) U ≫
        NatTrans.app (t D.toGlueData k i).c
            (op ((IsOpenImmersion.openFunctor (_ : IsOpenImmersion pullback.snd)).obj U)) ≫
          (V D.toGlueData (k, i)).presheaf.map
              (eqToHom
                (_ :
                  (Opens.map (t D.toGlueData k i).base).op.obj
                      (op ((IsOpenImmersion.openFunctor (_ : IsOpenImmersion pullback.snd)).obj U)) =
                    op
                      ((IsOpenImmersion.openFunctor (_ : IsOpenImmersion pullback.fst)).obj
                        {
                            unop :=
                              { carrier := ↑(t' D.toGlueData k i j).base ⁻¹' ↑(op U).unop,
                                is_open' := (_ : IsOpen (↑(t' D.toGlueData k i j).base ⁻¹' ↑(op U).unop)) } }.unop))) ≫
            h =
      NatTrans.app (t' D.toGlueData k i j).c (op U) ≫
        IsOpenImmersion.invApp (_ : IsOpenImmersion pullback.fst)
            { carrier := ↑(t' D.toGlueData k i j).base ⁻¹' ↑(op U).unop,
              is_open' := (_ : IsOpen (↑(t' D.toGlueData k i j).base ⁻¹' ↑(op U).unop)) } ≫
          h
⊢ IsOpenImmersion.invApp (_ : IsOpenImmersion pullback.snd) U ≫
      NatTrans.app (t D.toGlueData k i).c
        (op ((IsOpenImmersion.openFunctor (_ : IsOpenImmersion pullback.snd)).obj U)) =
    NatTrans.app (t' D.toGlueData k i j).c (op U) ≫
      IsOpenImmersion.invApp (_ : IsOpenImmersion pullback.fst)
          {
              unop :=
                { carrier := ↑(t' D.toGlueData k i j).base ⁻¹' ↑(op U).unop,
                  is_open' := (_ : IsOpen (↑(t' D.toGlueData k i j).base ⁻¹' ↑(op U).unop)) } }.unop ≫
        (V D.toGlueData (k, i)).presheaf.map
          (eqToHom
            (_ :
              op
                  ((IsOpenImmersion.openFunctor (_ : IsOpenImmersion pullback.fst)).obj
                    {
                        unop :=
                          { carrier := ↑(t' D.toGlueData k i j).base ⁻¹' ↑(op U).unop,
                            is_open' := (_ : IsOpen (↑(t' D.toGlueData k i j).base ⁻¹' ↑(op U).unop)) } }.unop) =
                (Opens.map (t D.toGlueData k i).base).op.obj
                  (op ((IsOpenImmersion.openFunctor (_ : IsOpenImmersion pullback.snd)).obj U))))
[PROOFSTEP]
rw [← e]
[GOAL]
C : Type u
inst✝ : Category.{v, u} C
D : GlueData C
i j k : D.J
U : Opens ↑↑(pullback (f D.toGlueData i j) (f D.toGlueData i k))
e :
  ∀ {Z : C}
    (h :
      (V D.toGlueData (k, i)).presheaf.obj
          (op
            ((IsOpenImmersion.openFunctor (_ : IsOpenImmersion pullback.fst)).obj
              {
                  unop :=
                    { carrier := ↑(t' D.toGlueData k i j).base ⁻¹' ↑(op U).unop,
                      is_open' := (_ : IsOpen (↑(t' D.toGlueData k i j).base ⁻¹' ↑(op U).unop)) } }.unop)) ⟶
        Z),
    IsOpenImmersion.invApp (_ : IsOpenImmersion pullback.snd) U ≫
        NatTrans.app (t D.toGlueData k i).c
            (op ((IsOpenImmersion.openFunctor (_ : IsOpenImmersion pullback.snd)).obj U)) ≫
          (V D.toGlueData (k, i)).presheaf.map
              (eqToHom
                (_ :
                  (Opens.map (t D.toGlueData k i).base).op.obj
                      (op ((IsOpenImmersion.openFunctor (_ : IsOpenImmersion pullback.snd)).obj U)) =
                    op
                      ((IsOpenImmersion.openFunctor (_ : IsOpenImmersion pullback.fst)).obj
                        {
                            unop :=
                              { carrier := ↑(t' D.toGlueData k i j).base ⁻¹' ↑(op U).unop,
                                is_open' := (_ : IsOpen (↑(t' D.toGlueData k i j).base ⁻¹' ↑(op U).unop)) } }.unop))) ≫
            h =
      NatTrans.app (t' D.toGlueData k i j).c (op U) ≫
        IsOpenImmersion.invApp (_ : IsOpenImmersion pullback.fst)
            { carrier := ↑(t' D.toGlueData k i j).base ⁻¹' ↑(op U).unop,
              is_open' := (_ : IsOpen (↑(t' D.toGlueData k i j).base ⁻¹' ↑(op U).unop)) } ≫
          h
⊢ IsOpenImmersion.invApp (_ : IsOpenImmersion pullback.snd) U ≫
      NatTrans.app (t D.toGlueData k i).c
        (op ((IsOpenImmersion.openFunctor (_ : IsOpenImmersion pullback.snd)).obj U)) =
    IsOpenImmersion.invApp (_ : IsOpenImmersion pullback.snd) U ≫
      NatTrans.app (t D.toGlueData k i).c
          (op ((IsOpenImmersion.openFunctor (_ : IsOpenImmersion pullback.snd)).obj U)) ≫
        (V D.toGlueData (k, i)).presheaf.map
            (eqToHom
              (_ :
                (Opens.map (t D.toGlueData k i).base).op.obj
                    (op ((IsOpenImmersion.openFunctor (_ : IsOpenImmersion pullback.snd)).obj U)) =
                  op
                    ((IsOpenImmersion.openFunctor (_ : IsOpenImmersion pullback.fst)).obj
                      {
                          unop :=
                            { carrier := ↑(t' D.toGlueData k i j).base ⁻¹' ↑(op U).unop,
                              is_open' := (_ : IsOpen (↑(t' D.toGlueData k i j).base ⁻¹' ↑(op U).unop)) } }.unop))) ≫
          (V D.toGlueData (k, i)).presheaf.map
            (eqToHom
              (_ :
                op
                    ((IsOpenImmersion.openFunctor (_ : IsOpenImmersion pullback.fst)).obj
                      {
                          unop :=
                            { carrier := ↑(t' D.toGlueData k i j).base ⁻¹' ↑(op U).unop,
                              is_open' := (_ : IsOpen (↑(t' D.toGlueData k i j).base ⁻¹' ↑(op U).unop)) } }.unop) =
                  (Opens.map (t D.toGlueData k i).base).op.obj
                    (op ((IsOpenImmersion.openFunctor (_ : IsOpenImmersion pullback.snd)).obj U))))
[PROOFSTEP]
simp [eqToHom_map]
[GOAL]
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)
⊢ (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))
[PROOFSTEP]
ext1
[GOAL]
case h
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)
⊢ ↑((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)))
[PROOFSTEP]
dsimp only [Opens.map_coe, IsOpenMap.functor_obj_coe]
[GOAL]
case h
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)
⊢ ↑(ι D.toGlueData j).base ⁻¹' (↑(ι D.toGlueData i).base '' ↑U) =
    ↑(f D.toGlueData j i).base '' (↑(t D.toGlueData j i).base ⁻¹' (↑(f D.toGlueData i j).base ⁻¹' ↑U))
[PROOFSTEP]
rw [← show _ = (𝖣.ι i).base from 𝖣.ι_gluedIso_inv (PresheafedSpace.forget _) i, ←
  show _ = (𝖣.ι j).base from 𝖣.ι_gluedIso_inv (PresheafedSpace.forget _) j]
  -- Porting note : change `rw` to `erw` on `coe_comp`
[GOAL]
case h
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)
⊢ ↑(ι (mapGlueData D.toGlueData (forget C)) j ≫ (gluedIso D.toGlueData (forget C)).inv) ⁻¹'
      (↑(ι (mapGlueData D.toGlueData (forget C)) i ≫ (gluedIso D.toGlueData (forget C)).inv) '' ↑U) =
    ↑(f D.toGlueData j i).base '' (↑(t D.toGlueData j i).base ⁻¹' (↑(f D.toGlueData i j).base ⁻¹' ↑U))
[PROOFSTEP]
erw [coe_comp, coe_comp, coe_comp]
[GOAL]
case h
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)
⊢ (↑(preservesColimitIso (forget C) (MultispanIndex.multispan (diagram D.toGlueData))).inv ∘
          ↑(HasColimit.isoOfNatIso (diagramIso D.toGlueData (forget C))).inv) ∘
        ↑(ι (mapGlueData D.toGlueData (forget C)) j) ⁻¹'
      (↑(gluedIso D.toGlueData (forget C)).inv ∘ ↑(ι (mapGlueData D.toGlueData (forget C)) i) '' ↑U) =
    ↑(f D.toGlueData j i).base '' (↑(t D.toGlueData j i).base ⁻¹' (↑(f D.toGlueData i j).base ⁻¹' ↑U))
[PROOFSTEP]
rw [Set.image_comp, Set.preimage_comp]
[GOAL]
case h
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)
⊢ ↑(ι (mapGlueData D.toGlueData (forget C)) j) ⁻¹'
      (↑(preservesColimitIso (forget C) (MultispanIndex.multispan (diagram D.toGlueData))).inv ∘
          ↑(HasColimit.isoOfNatIso (diagramIso D.toGlueData (forget C))).inv ⁻¹'
        (↑(gluedIso D.toGlueData (forget C)).inv '' (↑(ι (mapGlueData D.toGlueData (forget C)) i) '' ↑U))) =
    ↑(f D.toGlueData j i).base '' (↑(t D.toGlueData j i).base ⁻¹' (↑(f D.toGlueData i j).base ⁻¹' ↑U))
[PROOFSTEP]
erw [Set.preimage_image_eq]
[GOAL]
case h
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)
⊢ ↑(ι (mapGlueData D.toGlueData (forget C)) j) ⁻¹' (↑(ι (mapGlueData D.toGlueData (forget C)) i) '' ↑U) =
    ↑(f D.toGlueData j i).base '' (↑(t D.toGlueData j i).base ⁻¹' (↑(f D.toGlueData i j).base ⁻¹' ↑U))
[PROOFSTEP]
refine' Eq.trans (D.toTopGlueData.preimage_image_eq_image' _ _ _) _
[GOAL]
case h
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)
⊢ ↑(t (toTopGlueData D).toGlueData i j ≫ f (toTopGlueData D).toGlueData j i) ''
      (↑(f (toTopGlueData D).toGlueData i j) ⁻¹' ↑U) =
    ↑(f D.toGlueData j i).base '' (↑(t D.toGlueData j i).base ⁻¹' (↑(f D.toGlueData i j).base ⁻¹' ↑U))
[PROOFSTEP]
dsimp
[GOAL]
case h
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)
⊢ ↑((t D.toGlueData i j).base ≫ (f D.toGlueData j i).base) '' (↑(f D.toGlueData i j).base ⁻¹' ↑U) =
    ↑(f D.toGlueData j i).base '' (↑(t D.toGlueData j i).base ⁻¹' (↑(f D.toGlueData i j).base ⁻¹' ↑U))
[PROOFSTEP]
rw [coe_comp, Set.image_comp]
[GOAL]
case h
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)
⊢ ↑(f D.toGlueData j i).base '' (↑(t D.toGlueData i j).base '' (↑(f D.toGlueData i j).base ⁻¹' ↑U)) =
    ↑(f D.toGlueData j i).base '' (↑(t D.toGlueData j i).base ⁻¹' (↑(f D.toGlueData i j).base ⁻¹' ↑U))
[PROOFSTEP]
refine congr_arg (_ '' ·) ?_
[GOAL]
case h
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)
⊢ ↑(t D.toGlueData i j).base '' (↑(f D.toGlueData i j).base ⁻¹' ↑U) =
    ↑(t D.toGlueData j i).base ⁻¹' (↑(f D.toGlueData i j).base ⁻¹' ↑U)
[PROOFSTEP]
rw [Set.eq_preimage_iff_image_eq, ← Set.image_comp]
[GOAL]
case h
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)
⊢ ↑(t D.toGlueData j i).base ∘ ↑(t D.toGlueData i j).base '' (↑(f D.toGlueData i j).base ⁻¹' ↑U) =
    ↑(f D.toGlueData i j).base ⁻¹' ↑U
case h.hf
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)
⊢ Function.Bijective ↑(t D.toGlueData j i).base
[PROOFSTEP]
swap
[GOAL]
case h.hf
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)
⊢ Function.Bijective ↑(t D.toGlueData j i).base
[PROOFSTEP]
apply CategoryTheory.ConcreteCategory.bijective_of_isIso
[GOAL]
case h
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)
⊢ ↑(t D.toGlueData j i).base ∘ ↑(t D.toGlueData i j).base '' (↑(f D.toGlueData i j).base ⁻¹' ↑U) =
    ↑(f D.toGlueData i j).base ⁻¹' ↑U
[PROOFSTEP]
change (D.t i j ≫ D.t j i).base '' _ = _
[GOAL]
case h
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)
⊢ ↑(t D.toGlueData i j ≫ t D.toGlueData j i).base '' (↑(f D.toGlueData i j).base ⁻¹' ↑U) =
    ↑(f D.toGlueData i j).base ⁻¹' ↑U
[PROOFSTEP]
rw [𝖣.t_inv]
[GOAL]
case h
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)
⊢ ↑(𝟙 (V D.toGlueData (i, j))).base '' (↑(f D.toGlueData i j).base ⁻¹' ↑U) = ↑(f D.toGlueData i j).base ⁻¹' ↑U
[PROOFSTEP]
simp
[GOAL]
case h.h
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)
⊢ Function.Injective
    (↑(preservesColimitIso (forget C) (MultispanIndex.multispan (diagram D.toGlueData))).inv ∘
      ↑(HasColimit.isoOfNatIso (diagramIso D.toGlueData (forget C))).inv)
[PROOFSTEP]
rw [← coe_comp, ← TopCat.mono_iff_injective]
[GOAL]
case h.h
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)
⊢ Mono
    ((HasColimit.isoOfNatIso (diagramIso D.toGlueData (forget C))).inv ≫
      (preservesColimitIso (forget C) (MultispanIndex.multispan (diagram D.toGlueData))).inv)
[PROOFSTEP]
infer_instance
[GOAL]
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)
⊢ ∃ eq,
    opensImagePreimageMap D i j U ≫
        NatTrans.app (f D.toGlueData j k).c
          (op
            ((Opens.map (ι D.toGlueData j).base).obj
              ((IsOpenMap.functor (_ : IsOpenMap ↑(ι D.toGlueData i).base)).obj U))) =
      NatTrans.app (pullback.fst ≫ t D.toGlueData j i ≫ f D.toGlueData i j).c (op U) ≫
        IsOpenImmersion.invApp (_ : IsOpenImmersion pullback.snd)
            {
                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 ≫
          (V D.toGlueData (j, k)).presheaf.map (eqToHom eq)
[PROOFSTEP]
constructor
[GOAL]
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)
⊢ opensImagePreimageMap D i j U ≫
      NatTrans.app (f D.toGlueData j k).c
        (op
          ((Opens.map (ι D.toGlueData j).base).obj
            ((IsOpenMap.functor (_ : IsOpenMap ↑(ι D.toGlueData i).base)).obj U))) =
    NatTrans.app (pullback.fst ≫ t D.toGlueData j i ≫ f D.toGlueData i j).c (op U) ≫
      IsOpenImmersion.invApp (_ : IsOpenImmersion pullback.snd)
          {
              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 ≫
        (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)))
[PROOFSTEP]
delta opensImagePreimageMap
[GOAL]
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)
⊢ (NatTrans.app (f D.toGlueData i j).c (op U) ≫
        NatTrans.app (t D.toGlueData j i).c ((Opens.map (f D.toGlueData i j).base).op.obj (op U)) ≫
          IsOpenImmersion.invApp (_ : IsOpenImmersion (f D.toGlueData j i))
              {
                  unop :=
                    {
                      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 ≫
            (CategoryTheory.GlueData.U D.toGlueData j).presheaf.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) ≫
      NatTrans.app (f D.toGlueData j k).c
        (op
          ((Opens.map (ι D.toGlueData j).base).obj
            ((IsOpenMap.functor (_ : IsOpenMap ↑(ι D.toGlueData i).base)).obj U))) =
    NatTrans.app (pullback.fst ≫ t D.toGlueData j i ≫ f D.toGlueData i j).c (op U) ≫
      IsOpenImmersion.invApp (_ : IsOpenImmersion pullback.snd)
          {
              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 ≫
        (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)))
[PROOFSTEP]
simp_rw [Category.assoc]
[GOAL]
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)
⊢ NatTrans.app (f D.toGlueData i j).c (op U) ≫
      NatTrans.app (t D.toGlueData j i).c ((Opens.map (f D.toGlueData i j).base).op.obj (op U)) ≫
        IsOpenImmersion.invApp (_ : IsOpenImmersion (f D.toGlueData j i))
            { 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)) } ≫
          (CategoryTheory.GlueData.U D.toGlueData j).presheaf.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 ≫
            NatTrans.app (f D.toGlueData j k).c
              (op
                ((Opens.map (ι D.toGlueData j).base).obj
                  ((IsOpenMap.functor (_ : IsOpenMap ↑(ι D.toGlueData i).base)).obj U))) =
    NatTrans.app (pullback.fst ≫ t D.toGlueData j i ≫ f D.toGlueData i j).c (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)))
[PROOFSTEP]
rw [(D.f j k).c.naturality, f_invApp_f_app_assoc]
[GOAL]
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)
⊢ NatTrans.app (f D.toGlueData i j).c (op U) ≫
      NatTrans.app (t D.toGlueData j i).c ((Opens.map (f D.toGlueData i j).base).op.obj (op U)) ≫
        NatTrans.app pullback.fst.c
            (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)) })))) ≫
              ((f D.toGlueData j k).base _* (V D.toGlueData (j, k)).presheaf).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 =
    NatTrans.app (pullback.fst ≫ t D.toGlueData j i ≫ f D.toGlueData i j).c (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)))
[PROOFSTEP]
erw [← (D.V (j, k)).presheaf.map_comp]
[GOAL]
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)
⊢ NatTrans.app (f D.toGlueData i j).c (op U) ≫
      NatTrans.app (t D.toGlueData j i).c ((Opens.map (f D.toGlueData i j).base).op.obj (op U)) ≫
        NatTrans.app pullback.fst.c
            (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) =
    NatTrans.app (pullback.fst ≫ t D.toGlueData j i ≫ f D.toGlueData i j).c (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)))
[PROOFSTEP]
simp_rw [← Category.assoc]
[GOAL]
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)
⊢ (((NatTrans.app (f D.toGlueData i j).c (op U) ≫
            NatTrans.app (t D.toGlueData j i).c ((Opens.map (f D.toGlueData i j).base).op.obj (op U))) ≫
          NatTrans.app pullback.fst.c
            (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) =
    (NatTrans.app (pullback.fst ≫ t D.toGlueData j i ≫ f D.toGlueData i j).c (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)))
[PROOFSTEP]
erw [← comp_c_app, ← comp_c_app]
[GOAL]
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)
⊢ (NatTrans.app (pullback.fst ≫ t D.toGlueData j i ≫ f D.toGlueData i j).c (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) =
    (NatTrans.app (pullback.fst ≫ t D.toGlueData j i ≫ f D.toGlueData i j).c (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)))
[PROOFSTEP]
simp_rw [Category.assoc]
[GOAL]
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)
⊢ NatTrans.app (pullback.fst ≫ t D.toGlueData j i ≫ f D.toGlueData i j).c (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) =
    NatTrans.app (pullback.fst ≫ t D.toGlueData j i ≫ f D.toGlueData i j).c (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)))
[PROOFSTEP]
dsimp only [Functor.op, unop_op, Quiver.Hom.unop_op]
[GOAL]
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)
⊢ NatTrans.app (pullback.fst ≫ t D.toGlueData j i ≫ f D.toGlueData i j).c (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) =
    NatTrans.app (pullback.fst ≫ t D.toGlueData j i ≫ f D.toGlueData i j).c (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)))
[PROOFSTEP]
rw [eqToHom_map (Opens.map _), eqToHom_op, eqToHom_trans]
[GOAL]
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)
⊢ NatTrans.app (pullback.fst ≫ t D.toGlueData j i ≫ f D.toGlueData i j).c (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
                    ((Opens.map (ι D.toGlueData j).base).obj
                      ((IsOpenMap.functor (_ : IsOpenMap ↑(ι D.toGlueData i).base)).obj U))))) =
    NatTrans.app (pullback.fst ≫ t D.toGlueData j i ≫ f D.toGlueData i j).c (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)))
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)))
[PROOFSTEP]
congr
[GOAL]
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)
X' : C
f' :
  ((f D.toGlueData j k).base _* (V D.toGlueData (j, k)).presheaf).obj
      (op
        ((Opens.map (ι D.toGlueData j).base).obj
          ((IsOpenMap.functor (_ : IsOpenMap ↑(ι D.toGlueData i).base)).obj U))) ⟶
    X'
⊢ opensImagePreimageMap D i j U ≫
      NatTrans.app (f D.toGlueData j k).c
          (op
            ((Opens.map (ι D.toGlueData j).base).obj
              ((IsOpenMap.functor (_ : IsOpenMap ↑(ι D.toGlueData i).base)).obj U))) ≫
        f' =
    NatTrans.app (pullback.fst ≫ t D.toGlueData j i ≫ f D.toGlueData i j).c (op U) ≫
      IsOpenImmersion.invApp (_ : IsOpenImmersion pullback.snd)
          {
              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 ≫
        (V D.toGlueData (j, k)).presheaf.map
            (eqToHom
              (_ :
                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))))) ≫
          f'
[PROOFSTEP]
simpa only [Category.assoc] using congr_arg (· ≫ f') (opensImagePreimageMap_app D i j k U)
[GOAL]
C : Type u
inst✝¹ : Category.{v, u} C
D : GlueData C
inst✝ : HasLimits C
i : D.J
U : Opens ↑↑(CategoryTheory.GlueData.U D.toGlueData i)
j : WalkingMultispan (diagram D.toGlueData).fstFrom (diagram D.toGlueData).sndFrom
⊢ (CategoryTheory.GlueData.U D.toGlueData i).presheaf.obj (op U) ⟶ (diagramOverOpen D U).obj (op j)
[PROOFSTEP]
rcases j with (⟨j, k⟩ | j)
[GOAL]
case left.mk
C : Type u
inst✝¹ : Category.{v, u} C
D : GlueData C
inst✝ : HasLimits C
i : D.J
U : Opens ↑↑(CategoryTheory.GlueData.U D.toGlueData i)
j k : D.J
⊢ (CategoryTheory.GlueData.U D.toGlueData i).presheaf.obj (op U) ⟶
    (diagramOverOpen D U).obj (op (WalkingMultispan.left (j, k)))
[PROOFSTEP]
refine' D.opensImagePreimageMap i j U ≫ (D.f j k).c.app _ ≫ (D.V (j, k)).presheaf.map (eqToHom _)
[GOAL]
case left.mk
C : Type u
inst✝¹ : Category.{v, u} C
D : GlueData C
inst✝ : HasLimits C
i : D.J
U : Opens ↑↑(CategoryTheory.GlueData.U D.toGlueData i)
j k : D.J
⊢ (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))) =
    op
      ((Opens.map
            (colimit.ι (MultispanIndex.multispan (diagram D.toGlueData))
                (op (WalkingMultispan.left (j, k))).unop).base).obj
        ((IsOpenMap.functor (_ : IsOpenMap ↑(ι D.toGlueData i).base)).obj U))
[PROOFSTEP]
rw [Functor.op_obj]
[GOAL]
case left.mk
C : Type u
inst✝¹ : Category.{v, u} C
D : GlueData C
inst✝ : HasLimits C
i : D.J
U : Opens ↑↑(CategoryTheory.GlueData.U D.toGlueData i)
j k : D.J
⊢ op
      ((Opens.map (f D.toGlueData j k).base).obj
        (op
            ((Opens.map (ι D.toGlueData j).base).obj
              ((IsOpenMap.functor (_ : IsOpenMap ↑(ι D.toGlueData i).base)).obj U))).unop) =
    op
      ((Opens.map
            (colimit.ι (MultispanIndex.multispan (diagram D.toGlueData))
                (op (WalkingMultispan.left (j, k))).unop).base).obj
        ((IsOpenMap.functor (_ : IsOpenMap ↑(ι D.toGlueData i).base)).obj U))
[PROOFSTEP]
congr 1
[GOAL]
case left.mk.e_x
C : Type u
inst✝¹ : Category.{v, u} C
D : GlueData C
inst✝ : HasLimits C
i : D.J
U : Opens ↑↑(CategoryTheory.GlueData.U D.toGlueData i)
j k : D.J
⊢ (Opens.map (f D.toGlueData j k).base).obj
      (op
          ((Opens.map (ι D.toGlueData j).base).obj
            ((IsOpenMap.functor (_ : IsOpenMap ↑(ι D.toGlueData i).base)).obj U))).unop =
    (Opens.map
          (colimit.ι (MultispanIndex.multispan (diagram D.toGlueData))
              (op (WalkingMultispan.left (j, k))).unop).base).obj
      ((IsOpenMap.functor (_ : IsOpenMap ↑(ι D.toGlueData i).base)).obj U)
[PROOFSTEP]
ext1
[GOAL]
case left.mk.e_x.h
C : Type u
inst✝¹ : Category.{v, u} C
D : GlueData C
inst✝ : HasLimits C
i : D.J
U : Opens ↑↑(CategoryTheory.GlueData.U D.toGlueData i)
j k : D.J
⊢ ↑((Opens.map (f D.toGlueData j k).base).obj
        (op
            ((Opens.map (ι D.toGlueData j).base).obj
              ((IsOpenMap.functor (_ : IsOpenMap ↑(ι D.toGlueData i).base)).obj U))).unop) =
    ↑((Opens.map
            (colimit.ι (MultispanIndex.multispan (diagram D.toGlueData))
                (op (WalkingMultispan.left (j, k))).unop).base).obj
        ((IsOpenMap.functor (_ : IsOpenMap ↑(ι D.toGlueData i).base)).obj U))
[PROOFSTEP]
dsimp only [Functor.op_obj, Opens.map_coe, unop_op, IsOpenMap.functor_obj_coe]
[GOAL]
case left.mk.e_x.h
C : Type u
inst✝¹ : Category.{v, u} C
D : GlueData C
inst✝ : HasLimits C
i : D.J
U : Opens ↑↑(CategoryTheory.GlueData.U D.toGlueData i)
j k : D.J
⊢ ↑(f D.toGlueData j k).base ⁻¹' (↑(ι D.toGlueData j).base ⁻¹' (↑(ι D.toGlueData i).base '' ↑U)) =
    ↑(colimit.ι (MultispanIndex.multispan (diagram D.toGlueData)) (WalkingMultispan.left (j, k))).base ⁻¹'
      (↑(ι D.toGlueData i).base '' ↑U)
[PROOFSTEP]
rw [Set.preimage_preimage]
[GOAL]
case left.mk.e_x.h
C : Type u
inst✝¹ : Category.{v, u} C
D : GlueData C
inst✝ : HasLimits C
i : D.J
U : Opens ↑↑(CategoryTheory.GlueData.U D.toGlueData i)
j k : D.J
⊢ (fun x => ↑(ι D.toGlueData j).base (↑(f D.toGlueData j k).base x)) ⁻¹' (↑(ι D.toGlueData i).base '' ↑U) =
    ↑(colimit.ι (MultispanIndex.multispan (diagram D.toGlueData)) (WalkingMultispan.left (j, k))).base ⁻¹'
      (↑(ι D.toGlueData i).base '' ↑U)
[PROOFSTEP]
change
  (D.f j k ≫ 𝖣.ι j).base ⁻¹' _ =
    _
      -- Porting note : used to be `congr 3`
[GOAL]
case left.mk.e_x.h
C : Type u
inst✝¹ : Category.{v, u} C
D : GlueData C
inst✝ : HasLimits C
i : D.J
U : Opens ↑↑(CategoryTheory.GlueData.U D.toGlueData i)
j k : D.J
⊢ ↑(f D.toGlueData j k ≫ ι D.toGlueData j).base ⁻¹' (↑(ι D.toGlueData i).base '' ↑U) =
    ↑(colimit.ι (MultispanIndex.multispan (diagram D.toGlueData)) (WalkingMultispan.left (j, k))).base ⁻¹'
      (↑(ι D.toGlueData i).base '' ↑U)
[PROOFSTEP]
refine congr_arg (· ⁻¹' _) ?_
[GOAL]
case left.mk.e_x.h
C : Type u
inst✝¹ : Category.{v, u} C
D : GlueData C
inst✝ : HasLimits C
i : D.J
U : Opens ↑↑(CategoryTheory.GlueData.U D.toGlueData i)
j k : D.J
⊢ ↑(f D.toGlueData j k ≫ ι D.toGlueData j).base =
    ↑(colimit.ι (MultispanIndex.multispan (diagram D.toGlueData)) (WalkingMultispan.left (j, k))).base
[PROOFSTEP]
convert congr_arg (ContinuousMap.toFun (α := D.V ⟨j, k⟩) (β := D.glued) ·) ?_
[GOAL]
case left.mk.e_x.h.convert_3
C : Type u
inst✝¹ : Category.{v, u} C
D : GlueData C
inst✝ : HasLimits C
i : D.J
U : Opens ↑↑(CategoryTheory.GlueData.U D.toGlueData i)
j k : D.J
⊢ (f D.toGlueData j k ≫ ι D.toGlueData j).base =
    (colimit.ι (MultispanIndex.multispan (diagram D.toGlueData)) (WalkingMultispan.left (j, k))).base
[PROOFSTEP]
refine congr_arg (PresheafedSpace.Hom.base (C := C) ·) ?_
[GOAL]
case left.mk.e_x.h.convert_3
C : Type u
inst✝¹ : Category.{v, u} C
D : GlueData C
inst✝ : HasLimits C
i : D.J
U : Opens ↑↑(CategoryTheory.GlueData.U D.toGlueData i)
j k : D.J
⊢ f D.toGlueData j k ≫ ι D.toGlueData j =
    colimit.ι (MultispanIndex.multispan (diagram D.toGlueData)) (WalkingMultispan.left (j, k))
[PROOFSTEP]
exact colimit.w 𝖣.diagram.multispan (WalkingMultispan.Hom.fst (j, k))
[GOAL]
case right
C : Type u
inst✝¹ : Category.{v, u} C
D : GlueData C
inst✝ : HasLimits C
i : D.J
U : Opens ↑↑(CategoryTheory.GlueData.U D.toGlueData i)
j : (diagram D.toGlueData).R
⊢ (CategoryTheory.GlueData.U D.toGlueData i).presheaf.obj (op U) ⟶
    (diagramOverOpen D U).obj (op (WalkingMultispan.right j))
[PROOFSTEP]
exact D.opensImagePreimageMap i j U
[GOAL]
C : Type u
inst✝¹ : Category.{v, u} C
D : GlueData C
inst✝ : HasLimits C
i : D.J
U : Opens ↑↑(CategoryTheory.GlueData.U D.toGlueData i)
X Y : (WalkingMultispan (diagram D.toGlueData).fstFrom (diagram D.toGlueData).sndFrom)ᵒᵖ
f' : X ⟶ Y
⊢ ((Functor.const (WalkingMultispan (diagram D.toGlueData).fstFrom (diagram D.toGlueData).sndFrom)ᵒᵖ).obj
            ((CategoryTheory.GlueData.U D.toGlueData i).presheaf.obj (op U))).map
        f' ≫
      (fun j => ιInvAppπApp D U j.unop) Y =
    (fun j => ιInvAppπApp D U j.unop) X ≫ (diagramOverOpen D U).map f'
[PROOFSTEP]
induction X using Opposite.rec' with
| h X => ?_
[GOAL]
C : Type u
inst✝¹ : Category.{v, u} C
D : GlueData C
inst✝ : HasLimits C
i : D.J
U : Opens ↑↑(CategoryTheory.GlueData.U D.toGlueData i)
X Y : (WalkingMultispan (diagram D.toGlueData).fstFrom (diagram D.toGlueData).sndFrom)ᵒᵖ
f' : X ⟶ Y
⊢ ((Functor.const (WalkingMultispan (diagram D.toGlueData).fstFrom (diagram D.toGlueData).sndFrom)ᵒᵖ).obj
            ((CategoryTheory.GlueData.U D.toGlueData i).presheaf.obj (op U))).map
        f' ≫
      (fun j => ιInvAppπApp D U j.unop) Y =
    (fun j => ιInvAppπApp D U j.unop) X ≫ (diagramOverOpen D U).map f'
[PROOFSTEP]
induction X using Opposite.rec' with
| h X => ?_
[GOAL]
case h
C : Type u
inst✝¹ : Category.{v, u} C
D : GlueData C
inst✝ : HasLimits C
i : D.J
U : Opens ↑↑(CategoryTheory.GlueData.U D.toGlueData i)
Y : (WalkingMultispan (diagram D.toGlueData).fstFrom (diagram D.toGlueData).sndFrom)ᵒᵖ
X : WalkingMultispan (diagram D.toGlueData).fstFrom (diagram D.toGlueData).sndFrom
f' : op X ⟶ Y
⊢ ((Functor.const (WalkingMultispan (diagram D.toGlueData).fstFrom (diagram D.toGlueData).sndFrom)ᵒᵖ).obj
            ((CategoryTheory.GlueData.U D.toGlueData i).presheaf.obj (op U))).map
        f' ≫
      (fun j => ιInvAppπApp D U j.unop) Y =
    (fun j => ιInvAppπApp D U j.unop) (op X) ≫ (diagramOverOpen D U).map f'
[PROOFSTEP]
induction Y using Opposite.rec' with
| h Y => ?_
[GOAL]
case h
C : Type u
inst✝¹ : Category.{v, u} C
D : GlueData C
inst✝ : HasLimits C
i : D.J
U : Opens ↑↑(CategoryTheory.GlueData.U D.toGlueData i)
Y : (WalkingMultispan (diagram D.toGlueData).fstFrom (diagram D.toGlueData).sndFrom)ᵒᵖ
X : WalkingMultispan (diagram D.toGlueData).fstFrom (diagram D.toGlueData).sndFrom
f' : op X ⟶ Y
⊢ ((Functor.const (WalkingMultispan (diagram D.toGlueData).fstFrom (diagram D.toGlueData).sndFrom)ᵒᵖ).obj
            ((CategoryTheory.GlueData.U D.toGlueData i).presheaf.obj (op U))).map
        f' ≫
      (fun j => ιInvAppπApp D U j.unop) Y =
    (fun j => ιInvAppπApp D U j.unop) (op X) ≫ (diagramOverOpen D U).map f'
[PROOFSTEP]
induction Y using Opposite.rec' with
| h Y => ?_
[GOAL]
case h.h
C : Type u
inst✝¹ : Category.{v, u} C
D : GlueData C
inst✝ : HasLimits C
i : D.J
U : Opens ↑↑(CategoryTheory.GlueData.U D.toGlueData i)
X Y : WalkingMultispan (diagram D.toGlueData).fstFrom (diagram D.toGlueData).sndFrom
f' : op X ⟶ op Y
⊢ ((Functor.const (WalkingMultispan (diagram D.toGlueData).fstFrom (diagram D.toGlueData).sndFrom)ᵒᵖ).obj
            ((CategoryTheory.GlueData.U D.toGlueData i).presheaf.obj (op U))).map
        f' ≫
      (fun j => ιInvAppπApp D U j.unop) (op Y) =
    (fun j => ιInvAppπApp D U j.unop) (op X) ≫ (diagramOverOpen D U).map f'
[PROOFSTEP]
let f : Y ⟶ X := f'.unop
[GOAL]
case h.h
C : Type u
inst✝¹ : Category.{v, u} C
D : GlueData C
inst✝ : HasLimits C
i : D.J
U : Opens ↑↑(CategoryTheory.GlueData.U D.toGlueData i)
X Y : WalkingMultispan (diagram D.toGlueData).fstFrom (diagram D.toGlueData).sndFrom
f' : op X ⟶ op Y
f : Y ⟶ X := f'.unop
⊢ ((Functor.const (WalkingMultispan (diagram D.toGlueData).fstFrom (diagram D.toGlueData).sndFrom)ᵒᵖ).obj
            ((CategoryTheory.GlueData.U D.toGlueData i).presheaf.obj (op U))).map
        f' ≫
      (fun j => ιInvAppπApp D U j.unop) (op Y) =
    (fun j => ιInvAppπApp D U j.unop) (op X) ≫ (diagramOverOpen D U).map f'
[PROOFSTEP]
have : f' = f.op := rfl
[GOAL]
case h.h
C : Type u
inst✝¹ : Category.{v, u} C
D : GlueData C
inst✝ : HasLimits C
i : D.J
U : Opens ↑↑(CategoryTheory.GlueData.U D.toGlueData i)
X Y : WalkingMultispan (diagram D.toGlueData).fstFrom (diagram D.toGlueData).sndFrom
f' : op X ⟶ op Y
f : Y ⟶ X := f'.unop
this : f' = f.op
⊢ ((Functor.const (WalkingMultispan (diagram D.toGlueData).fstFrom (diagram D.toGlueData).sndFrom)ᵒᵖ).obj
            ((CategoryTheory.GlueData.U D.toGlueData i).presheaf.obj (op U))).map
        f' ≫
      (fun j => ιInvAppπApp D U j.unop) (op Y) =
    (fun j => ιInvAppπApp D U j.unop) (op X) ≫ (diagramOverOpen D U).map f'
[PROOFSTEP]
clear_value f
[GOAL]
case h.h
C : Type u
inst✝¹ : Category.{v, u} C
D : GlueData C
inst✝ : HasLimits C
i : D.J
U : Opens ↑↑(CategoryTheory.GlueData.U D.toGlueData i)
X Y : WalkingMultispan (diagram D.toGlueData).fstFrom (diagram D.toGlueData).sndFrom
f' : op X ⟶ op Y
f : Y ⟶ X
this : f' = f.op
⊢ ((Functor.const (WalkingMultispan (diagram D.toGlueData).fstFrom (diagram D.toGlueData).sndFrom)ᵒᵖ).obj
            ((CategoryTheory.GlueData.U D.toGlueData i).presheaf.obj (op U))).map
        f' ≫
      (fun j => ιInvAppπApp D U j.unop) (op Y) =
    (fun j => ιInvAppπApp D U j.unop) (op X) ≫ (diagramOverOpen D U).map f'
[PROOFSTEP]
subst this
[GOAL]
case h.h
C : Type u
inst✝¹ : Category.{v, u} C
D : GlueData C
inst✝ : HasLimits C
i : D.J
U : Opens ↑↑(CategoryTheory.GlueData.U D.toGlueData i)
X Y : WalkingMultispan (diagram D.toGlueData).fstFrom (diagram D.toGlueData).sndFrom
f : Y ⟶ X
⊢ ((Functor.const (WalkingMultispan (diagram D.toGlueData).fstFrom (diagram D.toGlueData).sndFrom)ᵒᵖ).obj
            ((CategoryTheory.GlueData.U D.toGlueData i).presheaf.obj (op U))).map
        f.op ≫
      (fun j => ιInvAppπApp D U j.unop) (op Y) =
    (fun j => ιInvAppπApp D U j.unop) (op X) ≫ (diagramOverOpen D U).map f.op
[PROOFSTEP]
rcases f with (_ | ⟨j, k⟩ | ⟨j, k⟩)
[GOAL]
case h.h.id
C : Type u
inst✝¹ : Category.{v, u} C
D : GlueData C
inst✝ : HasLimits C
i : D.J
U : Opens ↑↑(CategoryTheory.GlueData.U D.toGlueData i)
X : WalkingMultispan (diagram D.toGlueData).fstFrom (diagram D.toGlueData).sndFrom
⊢ ((Functor.const (WalkingMultispan (diagram D.toGlueData).fstFrom (diagram D.toGlueData).sndFrom)ᵒᵖ).obj
            ((CategoryTheory.GlueData.U D.toGlueData i).presheaf.obj (op U))).map
        (WalkingMultispan.Hom.id X).op ≫
      (fun j => ιInvAppπApp D U j.unop) (op X) =
    (fun j => ιInvAppπApp D U j.unop) (op X) ≫ (diagramOverOpen D U).map (WalkingMultispan.Hom.id X).op
[PROOFSTEP]
erw [Category.id_comp, CategoryTheory.Functor.map_id]
[GOAL]
case h.h.id
C : Type u
inst✝¹ : Category.{v, u} C
D : GlueData C
inst✝ : HasLimits C
i : D.J
U : Opens ↑↑(CategoryTheory.GlueData.U D.toGlueData i)
X : WalkingMultispan (diagram D.toGlueData).fstFrom (diagram D.toGlueData).sndFrom
⊢ (fun j => ιInvAppπApp D U j.unop) (op X) =
    (fun j => ιInvAppπApp D U j.unop) (op X) ≫ 𝟙 ((diagramOverOpen D U).obj (op X))
[PROOFSTEP]
rw [Category.comp_id]
[GOAL]
case h.h.fst.mk
C : Type u
inst✝¹ : Category.{v, u} C
D : GlueData C
inst✝ : HasLimits C
i : D.J
U : Opens ↑↑(CategoryTheory.GlueData.U D.toGlueData i)
j k : D.J
⊢ ((Functor.const (WalkingMultispan (diagram D.toGlueData).fstFrom (diagram D.toGlueData).sndFrom)ᵒᵖ).obj
            ((CategoryTheory.GlueData.U D.toGlueData i).presheaf.obj (op U))).map
        (WalkingMultispan.Hom.fst (j, k)).op ≫
      (fun j => ιInvAppπApp D U j.unop) (op (WalkingMultispan.left (j, k))) =
    (fun j => ιInvAppπApp D U j.unop)
        (op (WalkingMultispan.right (MultispanIndex.fstFrom (diagram D.toGlueData) (j, k)))) ≫
      (diagramOverOpen D U).map (WalkingMultispan.Hom.fst (j, k)).op
[PROOFSTEP]
erw [Category.id_comp]
[GOAL]
case h.h.fst.mk
C : Type u
inst✝¹ : Category.{v, u} C
D : GlueData C
inst✝ : HasLimits C
i : D.J
U : Opens ↑↑(CategoryTheory.GlueData.U D.toGlueData i)
j k : D.J
⊢ (fun j => ιInvAppπApp D U j.unop) (op (WalkingMultispan.left (j, k))) =
    (fun j => ιInvAppπApp D U j.unop)
        (op (WalkingMultispan.right (MultispanIndex.fstFrom (diagram D.toGlueData) (j, k)))) ≫
      (diagramOverOpen D U).map (WalkingMultispan.Hom.fst (j, k)).op
[PROOFSTEP]
congr 1
[GOAL]
case h.h.snd.mk
C : Type u
inst✝¹ : Category.{v, u} C
D : GlueData C
inst✝ : HasLimits C
i : D.J
U : Opens ↑↑(CategoryTheory.GlueData.U D.toGlueData i)
j k : D.J
⊢ ((Functor.const (WalkingMultispan (diagram D.toGlueData).fstFrom (diagram D.toGlueData).sndFrom)ᵒᵖ).obj
            ((CategoryTheory.GlueData.U D.toGlueData i).presheaf.obj (op U))).map
        (WalkingMultispan.Hom.snd (j, k)).op ≫
      (fun j => ιInvAppπApp D U j.unop) (op (WalkingMultispan.left (j, k))) =
    (fun j => ιInvAppπApp D U j.unop)
        (op (WalkingMultispan.right (MultispanIndex.sndFrom (diagram D.toGlueData) (j, k)))) ≫
      (diagramOverOpen D U).map (WalkingMultispan.Hom.snd (j, k)).op
[PROOFSTEP]
erw [Category.id_comp]
  -- It remains to show that the blue is equal to red + green in the original diagram.
              -- The proof strategy is illustrated in ![this diagram](https://i.imgur.com/mBzV1Rx.png)
              -- where we prove red = pink = light-blue = green = blue.
[GOAL]
case h.h.snd.mk
C : Type u
inst✝¹ : Category.{v, u} C
D : GlueData C
inst✝ : HasLimits C
i : D.J
U : Opens ↑↑(CategoryTheory.GlueData.U D.toGlueData i)
j k : D.J
⊢ (fun j => ιInvAppπApp D U j.unop) (op (WalkingMultispan.left (j, k))) =
    (fun j => ιInvAppπApp D U j.unop)
        (op (WalkingMultispan.right (MultispanIndex.sndFrom (diagram D.toGlueData) (j, k)))) ≫
      (diagramOverOpen D U).map (WalkingMultispan.Hom.snd (j, k)).op
[PROOFSTEP]
change
  D.opensImagePreimageMap i j U ≫ (D.f j k).c.app _ ≫ (D.V (j, k)).presheaf.map (eqToHom _) =
    D.opensImagePreimageMap _ _ _ ≫ ((D.f k j).c.app _ ≫ (D.t j k).c.app _) ≫ (D.V (j, k)).presheaf.map (eqToHom _)
[GOAL]
case h.h.snd.mk
C : Type u
inst✝¹ : Category.{v, u} C
D : GlueData C
inst✝ : HasLimits C
i : D.J
U : Opens ↑↑(CategoryTheory.GlueData.U D.toGlueData i)
j k : D.J
⊢ opensImagePreimageMap D i j U ≫
      NatTrans.app (f D.toGlueData j k).c
          (op
            ((Opens.map (ι D.toGlueData j).base).obj
              ((IsOpenMap.functor (_ : IsOpenMap ↑(ι D.toGlueData i).base)).obj U))) ≫
        (V D.toGlueData (j, k)).presheaf.map
          (eqToHom
            (_ :
              (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))) =
                op
                  ((Opens.map
                        (colimit.ι (MultispanIndex.multispan (diagram D.toGlueData))
                            (op (WalkingMultispan.left (j, k))).unop).base).obj
                    ((IsOpenMap.functor (_ : IsOpenMap ↑(ι D.toGlueData i).base)).obj U)))) =
    opensImagePreimageMap D i k U ≫
      (NatTrans.app (f D.toGlueData k j).c
            (op
              ((Opens.map (ι D.toGlueData k).base).obj
                ((IsOpenMap.functor (_ : IsOpenMap ↑(ι D.toGlueData i).base)).obj U))) ≫
          NatTrans.app (t D.toGlueData j k).c
            ((Opens.map (f D.toGlueData k j).base).op.obj
              (op
                ((Opens.map (ι D.toGlueData k).base).obj
                  ((IsOpenMap.functor (_ : IsOpenMap ↑(ι D.toGlueData i).base)).obj U))))) ≫
        (V D.toGlueData (j, k)).presheaf.map
          (eqToHom
            (_ :
              (Opens.map
                        ((MultispanIndex.multispan (diagram D.toGlueData)).map
                            (WalkingMultispan.Hom.snd (j, k)).op.unop).base).op.obj
                  (op
                    ((Opens.map
                          (colimit.ι (MultispanIndex.multispan (diagram D.toGlueData))
                              (op
                                  (WalkingMultispan.right
                                    (MultispanIndex.sndFrom (diagram D.toGlueData) (j, k)))).unop).base).obj
                      ((IsOpenMap.functor (_ : IsOpenMap ↑(ι D.toGlueData i).base)).obj U))) =
                op
                  ((Opens.map
                        (colimit.ι (MultispanIndex.multispan (diagram D.toGlueData))
                            (op (WalkingMultispan.left (j, k))).unop).base).obj
                    ((IsOpenMap.functor (_ : IsOpenMap ↑(ι D.toGlueData i).base)).obj U))))
[PROOFSTEP]
erw [opensImagePreimageMap_app_assoc]
[GOAL]
case h.h.snd.mk
C : Type u
inst✝¹ : Category.{v, u} C
D : GlueData C
inst✝ : HasLimits C
i : D.J
U : Opens ↑↑(CategoryTheory.GlueData.U D.toGlueData i)
j k : D.J
⊢ NatTrans.app (pullback.fst ≫ t D.toGlueData j i ≫ f D.toGlueData i j).c (op U) ≫
      IsOpenImmersion.invApp (_ : IsOpenImmersion pullback.snd)
          {
              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 ≫
        (V D.toGlueData (j, k)).presheaf.map
            (eqToHom
              (_ :
                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))))) ≫
          (V D.toGlueData (j, k)).presheaf.map
            (eqToHom
              (_ :
                (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))) =
                  op
                    ((Opens.map
                          (colimit.ι (MultispanIndex.multispan (diagram D.toGlueData))
                              (op (WalkingMultispan.left (j, k))).unop).base).obj
                      ((IsOpenMap.functor (_ : IsOpenMap ↑(ι D.toGlueData i).base)).obj U)))) =
    opensImagePreimageMap D i k U ≫
      (NatTrans.app (f D.toGlueData k j).c
            (op
              ((Opens.map (ι D.toGlueData k).base).obj
                ((IsOpenMap.functor (_ : IsOpenMap ↑(ι D.toGlueData i).base)).obj U))) ≫
          NatTrans.app (t D.toGlueData j k).c
            ((Opens.map (f D.toGlueData k j).base).op.obj
              (op
                ((Opens.map (ι D.toGlueData k).base).obj
                  ((IsOpenMap.functor (_ : IsOpenMap ↑(ι D.toGlueData i).base)).obj U))))) ≫
        (V D.toGlueData (j, k)).presheaf.map
          (eqToHom
            (_ :
              (Opens.map
                        ((MultispanIndex.multispan (diagram D.toGlueData)).map
                            (WalkingMultispan.Hom.snd (j, k)).op.unop).base).op.obj
                  (op
                    ((Opens.map
                          (colimit.ι (MultispanIndex.multispan (diagram D.toGlueData))
                              (op
                                  (WalkingMultispan.right
                                    (MultispanIndex.sndFrom (diagram D.toGlueData) (j, k)))).unop).base).obj
                      ((IsOpenMap.functor (_ : IsOpenMap ↑(ι D.toGlueData i).base)).obj U))) =
                op
                  ((Opens.map
                        (colimit.ι (MultispanIndex.multispan (diagram D.toGlueData))
                            (op (WalkingMultispan.left (j, k))).unop).base).obj
                    ((IsOpenMap.functor (_ : IsOpenMap ↑(ι D.toGlueData i).base)).obj U))))
[PROOFSTEP]
simp_rw [Category.assoc]
[GOAL]
case h.h.snd.mk
C : Type u
inst✝¹ : Category.{v, u} C
D : GlueData C
inst✝ : HasLimits C
i : D.J
U : Opens ↑↑(CategoryTheory.GlueData.U D.toGlueData i)
j k : D.J
⊢ NatTrans.app (pullback.fst ≫ t D.toGlueData j i ≫ f D.toGlueData i j).c (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
              (_ :
                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))))) ≫
          (V D.toGlueData (j, k)).presheaf.map
            (eqToHom
              (_ :
                (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))) =
                  op
                    ((Opens.map
                          (colimit.ι (MultispanIndex.multispan (diagram D.toGlueData))
                              (op (WalkingMultispan.left (j, k))).unop).base).obj
                      ((IsOpenMap.functor (_ : IsOpenMap ↑(ι D.toGlueData i).base)).obj U)))) =
    opensImagePreimageMap D i k U ≫
      NatTrans.app (f D.toGlueData k j).c
          (op
            ((Opens.map (ι D.toGlueData k).base).obj
              ((IsOpenMap.functor (_ : IsOpenMap ↑(ι D.toGlueData i).base)).obj U))) ≫
        NatTrans.app (t D.toGlueData j k).c
            ((Opens.map (f D.toGlueData k j).base).op.obj
              (op
                ((Opens.map (ι D.toGlueData k).base).obj
                  ((IsOpenMap.functor (_ : IsOpenMap ↑(ι D.toGlueData i).base)).obj U)))) ≫
          (V D.toGlueData (j, k)).presheaf.map
            (eqToHom
              (_ :
                (Opens.map
                          ((MultispanIndex.multispan (diagram D.toGlueData)).map
                              (WalkingMultispan.Hom.snd (j, k)).op.unop).base).op.obj
                    (op
                      ((Opens.map
                            (colimit.ι (MultispanIndex.multispan (diagram D.toGlueData))
                                (op
                                    (WalkingMultispan.right
                                      (MultispanIndex.sndFrom (diagram D.toGlueData) (j, k)))).unop).base).obj
                        ((IsOpenMap.functor (_ : IsOpenMap ↑(ι D.toGlueData i).base)).obj U))) =
                  op
                    ((Opens.map
                          (colimit.ι (MultispanIndex.multispan (diagram D.toGlueData))
                              (op (WalkingMultispan.left (j, k))).unop).base).obj
                      ((IsOpenMap.functor (_ : IsOpenMap ↑(ι D.toGlueData i).base)).obj U))))
[PROOFSTEP]
erw [opensImagePreimageMap_app_assoc, (D.t j k).c.naturality_assoc]
[GOAL]
case h.h.snd.mk
C : Type u
inst✝¹ : Category.{v, u} C
D : GlueData C
inst✝ : HasLimits C
i : D.J
U : Opens ↑↑(CategoryTheory.GlueData.U D.toGlueData i)
j k : D.J
⊢ NatTrans.app (pullback.fst ≫ t D.toGlueData j i ≫ f D.toGlueData i j).c (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
              (_ :
                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))))) ≫
          (V D.toGlueData (j, k)).presheaf.map
            (eqToHom
              (_ :
                (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))) =
                  op
                    ((Opens.map
                          (colimit.ι (MultispanIndex.multispan (diagram D.toGlueData))
                              (op (WalkingMultispan.left (j, k))).unop).base).obj
                      ((IsOpenMap.functor (_ : IsOpenMap ↑(ι D.toGlueData i).base)).obj U)))) =
    NatTrans.app (pullback.fst ≫ t D.toGlueData k i ≫ f D.toGlueData i k).c (op U) ≫
      IsOpenImmersion.invApp (_ : IsOpenImmersion pullback.snd)
          {
              unop :=
                { carrier := ↑(pullback.fst ≫ t D.toGlueData k i ≫ f D.toGlueData i k).base ⁻¹' ↑(op U).unop,
                  is_open' :=
                    (_ :
                      IsOpen
                        (↑(pullback.fst ≫ t D.toGlueData k i ≫ f D.toGlueData i k).base ⁻¹' ↑(op U).unop)) } }.unop ≫
        NatTrans.app (t D.toGlueData j k).c
            (op
              ((IsOpenImmersion.openFunctor (_ : IsOpenImmersion pullback.snd)).obj
                {
                    unop :=
                      { carrier := ↑(pullback.fst ≫ t D.toGlueData k i ≫ f D.toGlueData i k).base ⁻¹' ↑(op U).unop,
                        is_open' :=
                          (_ :
                            IsOpen
                              (↑(pullback.fst ≫ t D.toGlueData k i ≫ f D.toGlueData i k).base ⁻¹'
                                ↑(op U).unop)) } }.unop)) ≫
          ((t D.toGlueData j k).base _* (V D.toGlueData (j, k)).presheaf).map
              (eqToHom
                (_ :
                  op
                      ((IsOpenImmersion.openFunctor (_ : IsOpenImmersion pullback.snd)).obj
                        {
                            unop :=
                              {
                                carrier :=
                                  ↑(pullback.fst ≫ t D.toGlueData k i ≫ f D.toGlueData i k).base ⁻¹' ↑(op U).unop,
                                is_open' :=
                                  (_ :
                                    IsOpen
                                      (↑(pullback.fst ≫ t D.toGlueData k i ≫ f D.toGlueData i k).base ⁻¹'
                                        ↑(op U).unop)) } }.unop) =
                    (Opens.map (f D.toGlueData k j).base).op.obj
                      (op
                        ((Opens.map (ι D.toGlueData k).base).obj
                          ((IsOpenMap.functor (_ : IsOpenMap ↑(ι D.toGlueData i).base)).obj U))))) ≫
            (V D.toGlueData (j, k)).presheaf.map
              (eqToHom
                (_ :
                  (Opens.map
                            ((MultispanIndex.multispan (diagram D.toGlueData)).map
                                (WalkingMultispan.Hom.snd (j, k)).op.unop).base).op.obj
                      (op
                        ((Opens.map
                              (colimit.ι (MultispanIndex.multispan (diagram D.toGlueData))
                                  (op
                                      (WalkingMultispan.right
                                        (MultispanIndex.sndFrom (diagram D.toGlueData) (j, k)))).unop).base).obj
                          ((IsOpenMap.functor (_ : IsOpenMap ↑(ι D.toGlueData i).base)).obj U))) =
                    op
                      ((Opens.map
                            (colimit.ι (MultispanIndex.multispan (diagram D.toGlueData))
                                (op (WalkingMultispan.left (j, k))).unop).base).obj
                        ((IsOpenMap.functor (_ : IsOpenMap ↑(ι D.toGlueData i).base)).obj U))))
[PROOFSTEP]
rw [snd_invApp_t_app_assoc]
[GOAL]
case h.h.snd.mk
C : Type u
inst✝¹ : Category.{v, u} C
D : GlueData C
inst✝ : HasLimits C
i : D.J
U : Opens ↑↑(CategoryTheory.GlueData.U D.toGlueData i)
j k : D.J
⊢ NatTrans.app (pullback.fst ≫ t D.toGlueData j i ≫ f D.toGlueData i j).c (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
              (_ :
                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))))) ≫
          (V D.toGlueData (j, k)).presheaf.map
            (eqToHom
              (_ :
                (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))) =
                  op
                    ((Opens.map
                          (colimit.ι (MultispanIndex.multispan (diagram D.toGlueData))
                              (op (WalkingMultispan.left (j, k))).unop).base).obj
                      ((IsOpenMap.functor (_ : IsOpenMap ↑(ι D.toGlueData i).base)).obj U)))) =
    NatTrans.app (pullback.fst ≫ t D.toGlueData k i ≫ f D.toGlueData i k).c (op U) ≫
      NatTrans.app (t' D.toGlueData j k i).c
          (op
            {
                unop :=
                  { carrier := ↑(pullback.fst ≫ t D.toGlueData k i ≫ f D.toGlueData i k).base ⁻¹' ↑(op U).unop,
                    is_open' :=
                      (_ :
                        IsOpen
                          (↑(pullback.fst ≫ t D.toGlueData k i ≫ f D.toGlueData i k).base ⁻¹' ↑(op U).unop)) } }.unop) ≫
        IsOpenImmersion.invApp (_ : IsOpenImmersion pullback.fst)
            {
              carrier :=
                ↑(t' D.toGlueData j k i).base ⁻¹'
                  ↑(op
                        {
                            unop :=
                              {
                                carrier :=
                                  ↑(pullback.fst ≫ t D.toGlueData k i ≫ f D.toGlueData i k).base ⁻¹' ↑(op U).unop,
                                is_open' :=
                                  (_ :
                                    IsOpen
                                      (↑(pullback.fst ≫ t D.toGlueData k i ≫ f D.toGlueData i k).base ⁻¹'
                                        ↑(op U).unop)) } }.unop).unop,
              is_open' :=
                (_ :
                  IsOpen
                    (↑(t' D.toGlueData j k i).base ⁻¹'
                      ↑(op
                            {
                                unop :=
                                  {
                                    carrier :=
                                      ↑(pullback.fst ≫ t D.toGlueData k i ≫ f D.toGlueData i k).base ⁻¹' ↑(op U).unop,
                                    is_open' :=
                                      (_ :
                                        IsOpen
                                          (↑(pullback.fst ≫ t D.toGlueData k i ≫ f D.toGlueData i k).base ⁻¹'
                                            ↑(op U).unop)) } }.unop).unop)) } ≫
          (V D.toGlueData (j, k)).presheaf.map
              (eqToHom
                (_ :
                  op
                      ((IsOpenImmersion.openFunctor (_ : IsOpenImmersion pullback.fst)).obj
                        {
                            unop :=
                              {
                                carrier :=
                                  ↑(t' D.toGlueData j k i).base ⁻¹'
                                    ↑(op
                                          {
                                              unop :=
                                                {
                                                  carrier :=
                                                    ↑(pullback.fst ≫ t D.toGlueData k i ≫ f D.toGlueData i k).base ⁻¹'
                                                      ↑(op U).unop,
                                                  is_open' :=
                                                    (_ :
                                                      IsOpen
                                                        (↑(pullback.fst ≫
                                                                t D.toGlueData k i ≫ f D.toGlueData i k).base ⁻¹'
                                                          ↑(op U).unop)) } }.unop).unop,
                                is_open' :=
                                  (_ :
                                    IsOpen
                                      (↑(t' D.toGlueData j k i).base ⁻¹'
                                        ↑(op
                                              {
                                                  unop :=
                                                    {
                                                      carrier :=
                                                        ↑(pullback.fst ≫
                                                                t D.toGlueData k i ≫ f D.toGlueData i k).base ⁻¹'
                                                          ↑(op U).unop,
                                                      is_open' :=
                                                        (_ :
                                                          IsOpen
                                                            (↑(pullback.fst ≫
                                                                    t D.toGlueData k i ≫ f D.toGlueData i k).base ⁻¹'
                                                              ↑(op U).unop)) } }.unop).unop)) } }.unop) =
                    (Opens.map (t D.toGlueData j k).base).op.obj
                      (op
                        ((IsOpenImmersion.openFunctor (_ : IsOpenImmersion pullback.snd)).obj
                          {
                              unop :=
                                {
                                  carrier :=
                                    ↑(pullback.fst ≫ t D.toGlueData k i ≫ f D.toGlueData i k).base ⁻¹' ↑(op U).unop,
                                  is_open' :=
                                    (_ :
                                      IsOpen
                                        (↑(pullback.fst ≫ t D.toGlueData k i ≫ f D.toGlueData i k).base ⁻¹'
                                          ↑(op U).unop)) } }.unop)))) ≫
            ((t D.toGlueData j k).base _* (V D.toGlueData (j, k)).presheaf).map
                (eqToHom
                  (_ :
                    op
                        ((IsOpenImmersion.openFunctor (_ : IsOpenImmersion pullback.snd)).obj
                          {
                              unop :=
                                {
                                  carrier :=
                                    ↑(pullback.fst ≫ t D.toGlueData k i ≫ f D.toGlueData i k).base ⁻¹' ↑(op U).unop,
                                  is_open' :=
                                    (_ :
                                      IsOpen
                                        (↑(pullback.fst ≫ t D.toGlueData k i ≫ f D.toGlueData i k).base ⁻¹'
                                          ↑(op U).unop)) } }.unop) =
                      (Opens.map (f D.toGlueData k j).base).op.obj
                        (op
                          ((Opens.map (ι D.toGlueData k).base).obj
                            ((IsOpenMap.functor (_ : IsOpenMap ↑(ι D.toGlueData i).base)).obj U))))) ≫
              (V D.toGlueData (j, k)).presheaf.map
                (eqToHom
                  (_ :
                    (Opens.map
                              ((MultispanIndex.multispan (diagram D.toGlueData)).map
                                  (WalkingMultispan.Hom.snd (j, k)).op.unop).base).op.obj
                        (op
                          ((Opens.map
                                (colimit.ι (MultispanIndex.multispan (diagram D.toGlueData))
                                    (op
                                        (WalkingMultispan.right
                                          (MultispanIndex.sndFrom (diagram D.toGlueData) (j, k)))).unop).base).obj
                            ((IsOpenMap.functor (_ : IsOpenMap ↑(ι D.toGlueData i).base)).obj U))) =
                      op
                        ((Opens.map
                              (colimit.ι (MultispanIndex.multispan (diagram D.toGlueData))
                                  (op (WalkingMultispan.left (j, k))).unop).base).obj
                          ((IsOpenMap.functor (_ : IsOpenMap ↑(ι D.toGlueData i).base)).obj U))))
[PROOFSTEP]
erw [← PresheafedSpace.comp_c_app_assoc]
  -- light-blue = green is relatively easy since the part that differs does not involve
              -- partial inverses.
[GOAL]
case h.h.snd.mk
C : Type u
inst✝¹ : Category.{v, u} C
D : GlueData C
inst✝ : HasLimits C
i : D.J
U : Opens ↑↑(CategoryTheory.GlueData.U D.toGlueData i)
j k : D.J
⊢ NatTrans.app (pullback.fst ≫ t D.toGlueData j i ≫ f D.toGlueData i j).c (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
              (_ :
                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))))) ≫
          (V D.toGlueData (j, k)).presheaf.map
            (eqToHom
              (_ :
                (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))) =
                  op
                    ((Opens.map
                          (colimit.ι (MultispanIndex.multispan (diagram D.toGlueData))
                              (op (WalkingMultispan.left (j, k))).unop).base).obj
                      ((IsOpenMap.functor (_ : IsOpenMap ↑(ι D.toGlueData i).base)).obj U)))) =
    NatTrans.app (t' D.toGlueData j k i ≫ pullback.fst ≫ t D.toGlueData k i ≫ f D.toGlueData i k).c (op U) ≫
      IsOpenImmersion.invApp (_ : IsOpenImmersion pullback.fst)
          {
            carrier :=
              ↑(t' D.toGlueData j k i).base ⁻¹'
                ↑(op
                      {
                          unop :=
                            {
                              carrier :=
                                ↑(pullback.fst ≫ t D.toGlueData k i ≫ f D.toGlueData i k).base ⁻¹' ↑(op U).unop,
                              is_open' :=
                                (_ :
                                  IsOpen
                                    (↑(pullback.fst ≫ t D.toGlueData k i ≫ f D.toGlueData i k).base ⁻¹'
                                      ↑(op U).unop)) } }.unop).unop,
            is_open' :=
              (_ :
                IsOpen
                  (↑(t' D.toGlueData j k i).base ⁻¹'
                    ↑(op
                          {
                              unop :=
                                {
                                  carrier :=
                                    ↑(pullback.fst ≫ t D.toGlueData k i ≫ f D.toGlueData i k).base ⁻¹' ↑(op U).unop,
                                  is_open' :=
                                    (_ :
                                      IsOpen
                                        (↑(pullback.fst ≫ t D.toGlueData k i ≫ f D.toGlueData i k).base ⁻¹'
                                          ↑(op U).unop)) } }.unop).unop)) } ≫
        (V D.toGlueData (j, k)).presheaf.map
            (eqToHom
              (_ :
                op
                    ((IsOpenImmersion.openFunctor (_ : IsOpenImmersion pullback.fst)).obj
                      {
                          unop :=
                            {
                              carrier :=
                                ↑(t' D.toGlueData j k i).base ⁻¹'
                                  ↑(op
                                        {
                                            unop :=
                                              {
                                                carrier :=
                                                  ↑(pullback.fst ≫ t D.toGlueData k i ≫ f D.toGlueData i k).base ⁻¹'
                                                    ↑(op U).unop,
                                                is_open' :=
                                                  (_ :
                                                    IsOpen
                                                      (↑(pullback.fst ≫
                                                              t D.toGlueData k i ≫ f D.toGlueData i k).base ⁻¹'
                                                        ↑(op U).unop)) } }.unop).unop,
                              is_open' :=
                                (_ :
                                  IsOpen
                                    (↑(t' D.toGlueData j k i).base ⁻¹'
                                      ↑(op
                                            {
                                                unop :=
                                                  {
                                                    carrier :=
                                                      ↑(pullback.fst ≫ t D.toGlueData k i ≫ f D.toGlueData i k).base ⁻¹'
                                                        ↑(op U).unop,
                                                    is_open' :=
                                                      (_ :
                                                        IsOpen
                                                          (↑(pullback.fst ≫
                                                                  t D.toGlueData k i ≫ f D.toGlueData i k).base ⁻¹'
                                                            ↑(op U).unop)) } }.unop).unop)) } }.unop) =
                  (Opens.map (t D.toGlueData j k).base).op.obj
                    (op
                      ((IsOpenImmersion.openFunctor (_ : IsOpenImmersion pullback.snd)).obj
                        {
                            unop :=
                              {
                                carrier :=
                                  ↑(pullback.fst ≫ t D.toGlueData k i ≫ f D.toGlueData i k).base ⁻¹' ↑(op U).unop,
                                is_open' :=
                                  (_ :
                                    IsOpen
                                      (↑(pullback.fst ≫ t D.toGlueData k i ≫ f D.toGlueData i k).base ⁻¹'
                                        ↑(op U).unop)) } }.unop)))) ≫
          ((t D.toGlueData j k).base _* (V D.toGlueData (j, k)).presheaf).map
              (eqToHom
                (_ :
                  op
                      ((IsOpenImmersion.openFunctor (_ : IsOpenImmersion pullback.snd)).obj
                        {
                            unop :=
                              {
                                carrier :=
                                  ↑(pullback.fst ≫ t D.toGlueData k i ≫ f D.toGlueData i k).base ⁻¹' ↑(op U).unop,
                                is_open' :=
                                  (_ :
                                    IsOpen
                                      (↑(pullback.fst ≫ t D.toGlueData k i ≫ f D.toGlueData i k).base ⁻¹'
                                        ↑(op U).unop)) } }.unop) =
                    (Opens.map (f D.toGlueData k j).base).op.obj
                      (op
                        ((Opens.map (ι D.toGlueData k).base).obj
                          ((IsOpenMap.functor (_ : IsOpenMap ↑(ι D.toGlueData i).base)).obj U))))) ≫
            (V D.toGlueData (j, k)).presheaf.map
              (eqToHom
                (_ :
                  (Opens.map
                            ((MultispanIndex.multispan (diagram D.toGlueData)).map
                                (WalkingMultispan.Hom.snd (j, k)).op.unop).base).op.obj
                      (op
                        ((Opens.map
                              (colimit.ι (MultispanIndex.multispan (diagram D.toGlueData))
                                  (op
                                      (WalkingMultispan.right
                                        (MultispanIndex.sndFrom (diagram D.toGlueData) (j, k)))).unop).base).obj
                          ((IsOpenMap.functor (_ : IsOpenMap ↑(ι D.toGlueData i).base)).obj U))) =
                    op
                      ((Opens.map
                            (colimit.ι (MultispanIndex.multispan (diagram D.toGlueData))
                                (op (WalkingMultispan.left (j, k))).unop).base).obj
                        ((IsOpenMap.functor (_ : IsOpenMap ↑(ι D.toGlueData i).base)).obj U))))
[PROOFSTEP]
have : D.t' j k i ≫ (π₁ k, i, j) ≫ D.t k i ≫ 𝖣.f i k = (pullbackSymmetry _ _).hom ≫ (π₁ j, i, k) ≫ D.t j i ≫ D.f i j :=
  by
  rw [← 𝖣.t_fac_assoc, 𝖣.t'_comp_eq_pullbackSymmetry_assoc, pullbackSymmetry_hom_comp_snd_assoc, pullback.condition,
    𝖣.t_fac_assoc]
[GOAL]
C : Type u
inst✝¹ : Category.{v, u} C
D : GlueData C
inst✝ : HasLimits C
i : D.J
U : Opens ↑↑(CategoryTheory.GlueData.U D.toGlueData i)
j k : D.J
⊢ t' D.toGlueData j k i ≫ pullback.fst ≫ t D.toGlueData k i ≫ f D.toGlueData i k =
    (pullbackSymmetry (f D.toGlueData j k) (f D.toGlueData j i)).hom ≫
      pullback.fst ≫ t D.toGlueData j i ≫ f D.toGlueData i j
[PROOFSTEP]
rw [← 𝖣.t_fac_assoc, 𝖣.t'_comp_eq_pullbackSymmetry_assoc, pullbackSymmetry_hom_comp_snd_assoc, pullback.condition,
  𝖣.t_fac_assoc]
[GOAL]
case h.h.snd.mk
C : Type u
inst✝¹ : Category.{v, u} C
D : GlueData C
inst✝ : HasLimits C
i : D.J
U : Opens ↑↑(CategoryTheory.GlueData.U D.toGlueData i)
j k : D.J
this :
  t' D.toGlueData j k i ≫ pullback.fst ≫ t D.toGlueData k i ≫ f D.toGlueData i k =
    (pullbackSymmetry (f D.toGlueData j k) (f D.toGlueData j i)).hom ≫
      pullback.fst ≫ t D.toGlueData j i ≫ f D.toGlueData i j
⊢ NatTrans.app (pullback.fst ≫ t D.toGlueData j i ≫ f D.toGlueData i j).c (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
              (_ :
                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))))) ≫
          (V D.toGlueData (j, k)).presheaf.map
            (eqToHom
              (_ :
                (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))) =
                  op
                    ((Opens.map
                          (colimit.ι (MultispanIndex.multispan (diagram D.toGlueData))
                              (op (WalkingMultispan.left (j, k))).unop).base).obj
                      ((IsOpenMap.functor (_ : IsOpenMap ↑(ι D.toGlueData i).base)).obj U)))) =
    NatTrans.app (t' D.toGlueData j k i ≫ pullback.fst ≫ t D.toGlueData k i ≫ f D.toGlueData i k).c (op U) ≫
      IsOpenImmersion.invApp (_ : IsOpenImmersion pullback.fst)
          {
            carrier :=
              ↑(t' D.toGlueData j k i).base ⁻¹'
                ↑(op
                      {
                          unop :=
                            {
                              carrier :=
                                ↑(pullback.fst ≫ t D.toGlueData k i ≫ f D.toGlueData i k).base ⁻¹' ↑(op U).unop,
                              is_open' :=
                                (_ :
                                  IsOpen
                                    (↑(pullback.fst ≫ t D.toGlueData k i ≫ f D.toGlueData i k).base ⁻¹'
                                      ↑(op U).unop)) } }.unop).unop,
            is_open' :=
              (_ :
                IsOpen
                  (↑(t' D.toGlueData j k i).base ⁻¹'
                    ↑(op
                          {
                              unop :=
                                {
                                  carrier :=
                                    ↑(pullback.fst ≫ t D.toGlueData k i ≫ f D.toGlueData i k).base ⁻¹' ↑(op U).unop,
                                  is_open' :=
                                    (_ :
                                      IsOpen
                                        (↑(pullback.fst ≫ t D.toGlueData k i ≫ f D.toGlueData i k).base ⁻¹'
                                          ↑(op U).unop)) } }.unop).unop)) } ≫
        (V D.toGlueData (j, k)).presheaf.map
            (eqToHom
              (_ :
                op
                    ((IsOpenImmersion.openFunctor (_ : IsOpenImmersion pullback.fst)).obj
                      {
                          unop :=
                            {
                              carrier :=
                                ↑(t' D.toGlueData j k i).base ⁻¹'
                                  ↑(op
                                        {
                                            unop :=
                                              {
                                                carrier :=
                                                  ↑(pullback.fst ≫ t D.toGlueData k i ≫ f D.toGlueData i k).base ⁻¹'
                                                    ↑(op U).unop,
                                                is_open' :=
                                                  (_ :
                                                    IsOpen
                                                      (↑(pullback.fst ≫
                                                              t D.toGlueData k i ≫ f D.toGlueData i k).base ⁻¹'
                                                        ↑(op U).unop)) } }.unop).unop,
                              is_open' :=
                                (_ :
                                  IsOpen
                                    (↑(t' D.toGlueData j k i).base ⁻¹'
                                      ↑(op
                                            {
                                                unop :=
                                                  {
                                                    carrier :=
                                                      ↑(pullback.fst ≫ t D.toGlueData k i ≫ f D.toGlueData i k).base ⁻¹'
                                                        ↑(op U).unop,
                                                    is_open' :=
                                                      (_ :
                                                        IsOpen
                                                          (↑(pullback.fst ≫
                                                                  t D.toGlueData k i ≫ f D.toGlueData i k).base ⁻¹'
                                                            ↑(op U).unop)) } }.unop).unop)) } }.unop) =
                  (Opens.map (t D.toGlueData j k).base).op.obj
                    (op
                      ((IsOpenImmersion.openFunctor (_ : IsOpenImmersion pullback.snd)).obj
                        {
                            unop :=
                              {
                                carrier :=
                                  ↑(pullback.fst ≫ t D.toGlueData k i ≫ f D.toGlueData i k).base ⁻¹' ↑(op U).unop,
                                is_open' :=
                                  (_ :
                                    IsOpen
                                      (↑(pullback.fst ≫ t D.toGlueData k i ≫ f D.toGlueData i k).base ⁻¹'
                                        ↑(op U).unop)) } }.unop)))) ≫
          ((t D.toGlueData j k).base _* (V D.toGlueData (j, k)).presheaf).map
              (eqToHom
                (_ :
                  op
                      ((IsOpenImmersion.openFunctor (_ : IsOpenImmersion pullback.snd)).obj
                        {
                            unop :=
                              {
                                carrier :=
                                  ↑(pullback.fst ≫ t D.toGlueData k i ≫ f D.toGlueData i k).base ⁻¹' ↑(op U).unop,
                                is_open' :=
                                  (_ :
                                    IsOpen
                                      (↑(pullback.fst ≫ t D.toGlueData k i ≫ f D.toGlueData i k).base ⁻¹'
                                        ↑(op U).unop)) } }.unop) =
                    (Opens.map (f D.toGlueData k j).base).op.obj
                      (op
                        ((Opens.map (ι D.toGlueData k).base).obj
                          ((IsOpenMap.functor (_ : IsOpenMap ↑(ι D.toGlueData i).base)).obj U))))) ≫
            (V D.toGlueData (j, k)).presheaf.map
              (eqToHom
                (_ :
                  (Opens.map
                            ((MultispanIndex.multispan (diagram D.toGlueData)).map
                                (WalkingMultispan.Hom.snd (j, k)).op.unop).base).op.obj
                      (op
                        ((Opens.map
                              (colimit.ι (MultispanIndex.multispan (diagram D.toGlueData))
                                  (op
                                      (WalkingMultispan.right
                                        (MultispanIndex.sndFrom (diagram D.toGlueData) (j, k)))).unop).base).obj
                          ((IsOpenMap.functor (_ : IsOpenMap ↑(ι D.toGlueData i).base)).obj U))) =
                    op
                      ((Opens.map
                            (colimit.ι (MultispanIndex.multispan (diagram D.toGlueData))
                                (op (WalkingMultispan.left (j, k))).unop).base).obj
                        ((IsOpenMap.functor (_ : IsOpenMap ↑(ι D.toGlueData i).base)).obj U))))
[PROOFSTEP]
rw [congr_app this]
[GOAL]
case h.h.snd.mk
C : Type u
inst✝¹ : Category.{v, u} C
D : GlueData C
inst✝ : HasLimits C
i : D.J
U : Opens ↑↑(CategoryTheory.GlueData.U D.toGlueData i)
j k : D.J
this :
  t' D.toGlueData j k i ≫ pullback.fst ≫ t D.toGlueData k i ≫ f D.toGlueData i k =
    (pullbackSymmetry (f D.toGlueData j k) (f D.toGlueData j i)).hom ≫
      pullback.fst ≫ t D.toGlueData j i ≫ f D.toGlueData i j
⊢ NatTrans.app (pullback.fst ≫ t D.toGlueData j i ≫ f D.toGlueData i j).c (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
              (_ :
                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))))) ≫
          (V D.toGlueData (j, k)).presheaf.map
            (eqToHom
              (_ :
                (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))) =
                  op
                    ((Opens.map
                          (colimit.ι (MultispanIndex.multispan (diagram D.toGlueData))
                              (op (WalkingMultispan.left (j, k))).unop).base).obj
                      ((IsOpenMap.functor (_ : IsOpenMap ↑(ι D.toGlueData i).base)).obj U)))) =
    (NatTrans.app
          ((pullbackSymmetry (f D.toGlueData j k) (f D.toGlueData j i)).hom ≫
              pullback.fst ≫ t D.toGlueData j i ≫ f D.toGlueData i j).c
          (op U) ≫
        (pullback (f D.toGlueData j k) (f D.toGlueData j i)).presheaf.map
          (eqToHom
            (_ :
              (Opens.map
                        ((pullbackSymmetry (f D.toGlueData j k) (f D.toGlueData j i)).hom ≫
                            pullback.fst ≫ t D.toGlueData j i ≫ f D.toGlueData i j).base).op.obj
                  (op U) =
                (Opens.map (t' D.toGlueData j k i ≫ pullback.fst ≫ t D.toGlueData k i ≫ f D.toGlueData i k).base).op.obj
                  (op U)))) ≫
      IsOpenImmersion.invApp (_ : IsOpenImmersion pullback.fst)
          {
            carrier :=
              ↑(t' D.toGlueData j k i).base ⁻¹'
                ↑(op
                      {
                          unop :=
                            {
                              carrier :=
                                ↑(pullback.fst ≫ t D.toGlueData k i ≫ f D.toGlueData i k).base ⁻¹' ↑(op U).unop,
                              is_open' :=
                                (_ :
                                  IsOpen
                                    (↑(pullback.fst ≫ t D.toGlueData k i ≫ f D.toGlueData i k).base ⁻¹'
                                      ↑(op U).unop)) } }.unop).unop,
            is_open' :=
              (_ :
                IsOpen
                  (↑(t' D.toGlueData j k i).base ⁻¹'
                    ↑(op
                          {
                              unop :=
                                {
                                  carrier :=
                                    ↑(pullback.fst ≫ t D.toGlueData k i ≫ f D.toGlueData i k).base ⁻¹' ↑(op U).unop,
                                  is_open' :=
                                    (_ :
                                      IsOpen
                                        (↑(pullback.fst ≫ t D.toGlueData k i ≫ f D.toGlueData i k).base ⁻¹'
                                          ↑(op U).unop)) } }.unop).unop)) } ≫
        (V D.toGlueData (j, k)).presheaf.map
            (eqToHom
              (_ :
                op
                    ((IsOpenImmersion.openFunctor (_ : IsOpenImmersion pullback.fst)).obj
                      {
                          unop :=
                            {
                              carrier :=
                                ↑(t' D.toGlueData j k i).base ⁻¹'
                                  ↑(op
                                        {
                                            unop :=
                                              {
                                                carrier :=
                                                  ↑(pullback.fst ≫ t D.toGlueData k i ≫ f D.toGlueData i k).base ⁻¹'
                                                    ↑(op U).unop,
                                                is_open' :=
                                                  (_ :
                                                    IsOpen
                                                      (↑(pullback.fst ≫
                                                              t D.toGlueData k i ≫ f D.toGlueData i k).base ⁻¹'
                                                        ↑(op U).unop)) } }.unop).unop,
                              is_open' :=
                                (_ :
                                  IsOpen
                                    (↑(t' D.toGlueData j k i).base ⁻¹'
                                      ↑(op
                                            {
                                                unop :=
                                                  {
                                                    carrier :=
                                                      ↑(pullback.fst ≫ t D.toGlueData k i ≫ f D.toGlueData i k).base ⁻¹'
                                                        ↑(op U).unop,
                                                    is_open' :=
                                                      (_ :
                                                        IsOpen
                                                          (↑(pullback.fst ≫
                                                                  t D.toGlueData k i ≫ f D.toGlueData i k).base ⁻¹'
                                                            ↑(op U).unop)) } }.unop).unop)) } }.unop) =
                  (Opens.map (t D.toGlueData j k).base).op.obj
                    (op
                      ((IsOpenImmersion.openFunctor (_ : IsOpenImmersion pullback.snd)).obj
                        {
                            unop :=
                              {
                                carrier :=
                                  ↑(pullback.fst ≫ t D.toGlueData k i ≫ f D.toGlueData i k).base ⁻¹' ↑(op U).unop,
                                is_open' :=
                                  (_ :
                                    IsOpen
                                      (↑(pullback.fst ≫ t D.toGlueData k i ≫ f D.toGlueData i k).base ⁻¹'
                                        ↑(op U).unop)) } }.unop)))) ≫
          ((t D.toGlueData j k).base _* (V D.toGlueData (j, k)).presheaf).map
              (eqToHom
                (_ :
                  op
                      ((IsOpenImmersion.openFunctor (_ : IsOpenImmersion pullback.snd)).obj
                        {
                            unop :=
                              {
                                carrier :=
                                  ↑(pullback.fst ≫ t D.toGlueData k i ≫ f D.toGlueData i k).base ⁻¹' ↑(op U).unop,
                                is_open' :=
                                  (_ :
                                    IsOpen
                                      (↑(pullback.fst ≫ t D.toGlueData k i ≫ f D.toGlueData i k).base ⁻¹'
                                        ↑(op U).unop)) } }.unop) =
                    (Opens.map (f D.toGlueData k j).base).op.obj
                      (op
                        ((Opens.map (ι D.toGlueData k).base).obj
                          ((IsOpenMap.functor (_ : IsOpenMap ↑(ι D.toGlueData i).base)).obj U))))) ≫
            (V D.toGlueData (j, k)).presheaf.map
              (eqToHom
                (_ :
                  (Opens.map
                            ((MultispanIndex.multispan (diagram D.toGlueData)).map
                                (WalkingMultispan.Hom.snd (j, k)).op.unop).base).op.obj
                      (op
                        ((Opens.map
                              (colimit.ι (MultispanIndex.multispan (diagram D.toGlueData))
                                  (op
                                      (WalkingMultispan.right
                                        (MultispanIndex.sndFrom (diagram D.toGlueData) (j, k)))).unop).base).obj
                          ((IsOpenMap.functor (_ : IsOpenMap ↑(ι D.toGlueData i).base)).obj U))) =
                    op
                      ((Opens.map
                            (colimit.ι (MultispanIndex.multispan (diagram D.toGlueData))
                                (op (WalkingMultispan.left (j, k))).unop).base).obj
                        ((IsOpenMap.functor (_ : IsOpenMap ↑(ι D.toGlueData i).base)).obj U))))
[PROOFSTEP]
erw [PresheafedSpace.comp_c_app_assoc (pullbackSymmetry _ _).hom]
[GOAL]
case h.h.snd.mk
C : Type u
inst✝¹ : Category.{v, u} C
D : GlueData C
inst✝ : HasLimits C
i : D.J
U : Opens ↑↑(CategoryTheory.GlueData.U D.toGlueData i)
j k : D.J
this :
  t' D.toGlueData j k i ≫ pullback.fst ≫ t D.toGlueData k i ≫ f D.toGlueData i k =
    (pullbackSymmetry (f D.toGlueData j k) (f D.toGlueData j i)).hom ≫
      pullback.fst ≫ t D.toGlueData j i ≫ f D.toGlueData i j
⊢ NatTrans.app (pullback.fst ≫ t D.toGlueData j i ≫ f D.toGlueData i j).c (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
              (_ :
                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))))) ≫
          (V D.toGlueData (j, k)).presheaf.map
            (eqToHom
              (_ :
                (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))) =
                  op
                    ((Opens.map
                          (colimit.ι (MultispanIndex.multispan (diagram D.toGlueData))
                              (op (WalkingMultispan.left (j, k))).unop).base).obj
                      ((IsOpenMap.functor (_ : IsOpenMap ↑(ι D.toGlueData i).base)).obj U)))) =
    (NatTrans.app (pullback.fst ≫ t D.toGlueData j i ≫ f D.toGlueData i j).c (op U) ≫
        NatTrans.app (pullbackSymmetry (f D.toGlueData j k) (f D.toGlueData j i)).hom.c
            (op ((Opens.map (pullback.fst ≫ t D.toGlueData j i ≫ f D.toGlueData i j).base).obj (op U).unop)) ≫
          (pullback (f D.toGlueData j k) (f D.toGlueData j i)).presheaf.map
            (eqToHom
              (_ :
                (Opens.map
                          ((pullbackSymmetry (f D.toGlueData j k) (f D.toGlueData j i)).hom ≫
                              pullback.fst ≫ t D.toGlueData j i ≫ f D.toGlueData i j).base).op.obj
                    (op U) =
                  (Opens.map
                          (t' D.toGlueData j k i ≫ pullback.fst ≫ t D.toGlueData k i ≫ f D.toGlueData i k).base).op.obj
                    (op U)))) ≫
      IsOpenImmersion.invApp (_ : IsOpenImmersion pullback.fst)
          {
            carrier :=
              ↑(t' D.toGlueData j k i).base ⁻¹'
                ↑(op
                      {
                          unop :=
                            {
                              carrier :=
                                ↑(pullback.fst ≫ t D.toGlueData k i ≫ f D.toGlueData i k).base ⁻¹' ↑(op U).unop,
                              is_open' :=
                                (_ :
                                  IsOpen
                                    (↑(pullback.fst ≫ t D.toGlueData k i ≫ f D.toGlueData i k).base ⁻¹'
                                      ↑(op U).unop)) } }.unop).unop,
            is_open' :=
              (_ :
                IsOpen
                  (↑(t' D.toGlueData j k i).base ⁻¹'
                    ↑(op
                          {
                              unop :=
                                {
                                  carrier :=
                                    ↑(pullback.fst ≫ t D.toGlueData k i ≫ f D.toGlueData i k).base ⁻¹' ↑(op U).unop,
                                  is_open' :=
                                    (_ :
                                      IsOpen
                                        (↑(pullback.fst ≫ t D.toGlueData k i ≫ f D.toGlueData i k).base ⁻¹'
                                          ↑(op U).unop)) } }.unop).unop)) } ≫
        (V D.toGlueData (j, k)).presheaf.map
            (eqToHom
              (_ :
                op
                    ((IsOpenImmersion.openFunctor (_ : IsOpenImmersion pullback.fst)).obj
                      {
                          unop :=
                            {
                              carrier :=
                                ↑(t' D.toGlueData j k i).base ⁻¹'
                                  ↑(op
                                        {
                                            unop :=
                                              {
                                                carrier :=
                                                  ↑(pullback.fst ≫ t D.toGlueData k i ≫ f D.toGlueData i k).base ⁻¹'
                                                    ↑(op U).unop,
                                                is_open' :=
                                                  (_ :
                                                    IsOpen
                                                      (↑(pullback.fst ≫
                                                              t D.toGlueData k i ≫ f D.toGlueData i k).base ⁻¹'
                                                        ↑(op U).unop)) } }.unop).unop,
                              is_open' :=
                                (_ :
                                  IsOpen
                                    (↑(t' D.toGlueData j k i).base ⁻¹'
                                      ↑(op
                                            {
                                                unop :=
                                                  {
                                                    carrier :=
                                                      ↑(pullback.fst ≫ t D.toGlueData k i ≫ f D.toGlueData i k).base ⁻¹'
                                                        ↑(op U).unop,
                                                    is_open' :=
                                                      (_ :
                                                        IsOpen
                                                          (↑(pullback.fst ≫
                                                                  t D.toGlueData k i ≫ f D.toGlueData i k).base ⁻¹'
                                                            ↑(op U).unop)) } }.unop).unop)) } }.unop) =
                  (Opens.map (t D.toGlueData j k).base).op.obj
                    (op
                      ((IsOpenImmersion.openFunctor (_ : IsOpenImmersion pullback.snd)).obj
                        {
                            unop :=
                              {
                                carrier :=
                                  ↑(pullback.fst ≫ t D.toGlueData k i ≫ f D.toGlueData i k).base ⁻¹' ↑(op U).unop,
                                is_open' :=
                                  (_ :
                                    IsOpen
                                      (↑(pullback.fst ≫ t D.toGlueData k i ≫ f D.toGlueData i k).base ⁻¹'
                                        ↑(op U).unop)) } }.unop)))) ≫
          ((t D.toGlueData j k).base _* (V D.toGlueData (j, k)).presheaf).map
              (eqToHom
                (_ :
                  op
                      ((IsOpenImmersion.openFunctor (_ : IsOpenImmersion pullback.snd)).obj
                        {
                            unop :=
                              {
                                carrier :=
                                  ↑(pullback.fst ≫ t D.toGlueData k i ≫ f D.toGlueData i k).base ⁻¹' ↑(op U).unop,
                                is_open' :=
                                  (_ :
                                    IsOpen
                                      (↑(pullback.fst ≫ t D.toGlueData k i ≫ f D.toGlueData i k).base ⁻¹'
                                        ↑(op U).unop)) } }.unop) =
                    (Opens.map (f D.toGlueData k j).base).op.obj
                      (op
                        ((Opens.map (ι D.toGlueData k).base).obj
                          ((IsOpenMap.functor (_ : IsOpenMap ↑(ι D.toGlueData i).base)).obj U))))) ≫
            (V D.toGlueData (j, k)).presheaf.map
              (eqToHom
                (_ :
                  (Opens.map
                            ((MultispanIndex.multispan (diagram D.toGlueData)).map
                                (WalkingMultispan.Hom.snd (j, k)).op.unop).base).op.obj
                      (op
                        ((Opens.map
                              (colimit.ι (MultispanIndex.multispan (diagram D.toGlueData))
                                  (op
                                      (WalkingMultispan.right
                                        (MultispanIndex.sndFrom (diagram D.toGlueData) (j, k)))).unop).base).obj
                          ((IsOpenMap.functor (_ : IsOpenMap ↑(ι D.toGlueData i).base)).obj U))) =
                    op
                      ((Opens.map
                            (colimit.ι (MultispanIndex.multispan (diagram D.toGlueData))
                                (op (WalkingMultispan.left (j, k))).unop).base).obj
                        ((IsOpenMap.functor (_ : IsOpenMap ↑(ι D.toGlueData i).base)).obj U))))
[PROOFSTEP]
simp_rw [Category.assoc]
[GOAL]
case h.h.snd.mk
C : Type u
inst✝¹ : Category.{v, u} C
D : GlueData C
inst✝ : HasLimits C
i : D.J
U : Opens ↑↑(CategoryTheory.GlueData.U D.toGlueData i)
j k : D.J
this :
  t' D.toGlueData j k i ≫ pullback.fst ≫ t D.toGlueData k i ≫ f D.toGlueData i k =
    (pullbackSymmetry (f D.toGlueData j k) (f D.toGlueData j i)).hom ≫
      pullback.fst ≫ t D.toGlueData j i ≫ f D.toGlueData i j
⊢ NatTrans.app (pullback.fst ≫ t D.toGlueData j i ≫ f D.toGlueData i j).c (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
              (_ :
                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))))) ≫
          (V D.toGlueData (j, k)).presheaf.map
            (eqToHom
              (_ :
                (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))) =
                  op
                    ((Opens.map
                          (colimit.ι (MultispanIndex.multispan (diagram D.toGlueData))
                              (op (WalkingMultispan.left (j, k))).unop).base).obj
                      ((IsOpenMap.functor (_ : IsOpenMap ↑(ι D.toGlueData i).base)).obj U)))) =
    NatTrans.app (pullback.fst ≫ t D.toGlueData j i ≫ f D.toGlueData i j).c (op U) ≫
      NatTrans.app (pullbackSymmetry (f D.toGlueData j k) (f D.toGlueData j i)).hom.c
          (op ((Opens.map (pullback.fst ≫ t D.toGlueData j i ≫ f D.toGlueData i j).base).obj (op U).unop)) ≫
        (pullback (f D.toGlueData j k) (f D.toGlueData j i)).presheaf.map
            (eqToHom
              (_ :
                (Opens.map
                          ((pullbackSymmetry (f D.toGlueData j k) (f D.toGlueData j i)).hom ≫
                              pullback.fst ≫ t D.toGlueData j i ≫ f D.toGlueData i j).base).op.obj
                    (op U) =
                  (Opens.map
                          (t' D.toGlueData j k i ≫ pullback.fst ≫ t D.toGlueData k i ≫ f D.toGlueData i k).base).op.obj
                    (op U))) ≫
          IsOpenImmersion.invApp (_ : IsOpenImmersion pullback.fst)
              {
                carrier :=
                  ↑(t' D.toGlueData j k i).base ⁻¹'
                    ↑(op
                          { carrier := ↑(pullback.fst ≫ t D.toGlueData k i ≫ f D.toGlueData i k).base ⁻¹' ↑(op U).unop,
                            is_open' :=
                              (_ :
                                IsOpen
                                  (↑(pullback.fst ≫ t D.toGlueData k i ≫ f D.toGlueData i k).base ⁻¹'
                                    ↑(op U).unop)) }).unop,
                is_open' :=
                  (_ :
                    IsOpen
                      (↑(t' D.toGlueData j k i).base ⁻¹'
                        ↑(op
                              {
                                carrier :=
                                  ↑(pullback.fst ≫ t D.toGlueData k i ≫ f D.toGlueData i k).base ⁻¹' ↑(op U).unop,
                                is_open' :=
                                  (_ :
                                    IsOpen
                                      (↑(pullback.fst ≫ t D.toGlueData k i ≫ f D.toGlueData i k).base ⁻¹'
                                        ↑(op U).unop)) }).unop)) } ≫
            (V D.toGlueData (j, k)).presheaf.map
                (eqToHom
                  (_ :
                    op
                        ((IsOpenImmersion.openFunctor (_ : IsOpenImmersion pullback.fst)).obj
                          {
                              unop :=
                                {
                                  carrier :=
                                    ↑(t' D.toGlueData j k i).base ⁻¹'
                                      ↑(op
                                            {
                                                unop :=
                                                  {
                                                    carrier :=
                                                      ↑(pullback.fst ≫ t D.toGlueData k i ≫ f D.toGlueData i k).base ⁻¹'
                                                        ↑(op U).unop,
                                                    is_open' :=
                                                      (_ :
                                                        IsOpen
                                                          (↑(pullback.fst ≫
                                                                  t D.toGlueData k i ≫ f D.toGlueData i k).base ⁻¹'
                                                            ↑(op U).unop)) } }.unop).unop,
                                  is_open' :=
                                    (_ :
                                      IsOpen
                                        (↑(t' D.toGlueData j k i).base ⁻¹'
                                          ↑(op
                                                {
                                                    unop :=
                                                      {
                                                        carrier :=
                                                          ↑(pullback.fst ≫
                                                                  t D.toGlueData k i ≫ f D.toGlueData i k).base ⁻¹'
                                                            ↑(op U).unop,
                                                        is_open' :=
                                                          (_ :
                                                            IsOpen
                                                              (↑(pullback.fst ≫
                                                                      t D.toGlueData k i ≫ f D.toGlueData i k).base ⁻¹'
                                                                ↑(op U).unop)) } }.unop).unop)) } }.unop) =
                      (Opens.map (t D.toGlueData j k).base).op.obj
                        (op
                          ((IsOpenImmersion.openFunctor (_ : IsOpenImmersion pullback.snd)).obj
                            {
                                unop :=
                                  {
                                    carrier :=
                                      ↑(pullback.fst ≫ t D.toGlueData k i ≫ f D.toGlueData i k).base ⁻¹' ↑(op U).unop,
                                    is_open' :=
                                      (_ :
                                        IsOpen
                                          (↑(pullback.fst ≫ t D.toGlueData k i ≫ f D.toGlueData i k).base ⁻¹'
                                            ↑(op U).unop)) } }.unop)))) ≫
              ((t D.toGlueData j k).base _* (V D.toGlueData (j, k)).presheaf).map
                  (eqToHom
                    (_ :
                      op
                          ((IsOpenImmersion.openFunctor (_ : IsOpenImmersion pullback.snd)).obj
                            {
                                unop :=
                                  {
                                    carrier :=
                                      ↑(pullback.fst ≫ t D.toGlueData k i ≫ f D.toGlueData i k).base ⁻¹' ↑(op U).unop,
                                    is_open' :=
                                      (_ :
                                        IsOpen
                                          (↑(pullback.fst ≫ t D.toGlueData k i ≫ f D.toGlueData i k).base ⁻¹'
                                            ↑(op U).unop)) } }.unop) =
                        (Opens.map (f D.toGlueData k j).base).op.obj
                          (op
                            ((Opens.map (ι D.toGlueData k).base).obj
                              ((IsOpenMap.functor (_ : IsOpenMap ↑(ι D.toGlueData i).base)).obj U))))) ≫
                (V D.toGlueData (j, k)).presheaf.map
                  (eqToHom
                    (_ :
                      (Opens.map
                                ((MultispanIndex.multispan (diagram D.toGlueData)).map
                                    (WalkingMultispan.Hom.snd (j, k)).op.unop).base).op.obj
                          (op
                            ((Opens.map
                                  (colimit.ι (MultispanIndex.multispan (diagram D.toGlueData))
                                      (op
                                          (WalkingMultispan.right
                                            (MultispanIndex.sndFrom (diagram D.toGlueData) (j, k)))).unop).base).obj
                              ((IsOpenMap.functor (_ : IsOpenMap ↑(ι D.toGlueData i).base)).obj U))) =
                        op
                          ((Opens.map
                                (colimit.ι (MultispanIndex.multispan (diagram D.toGlueData))
                                    (op (WalkingMultispan.left (j, k))).unop).base).obj
                            ((IsOpenMap.functor (_ : IsOpenMap ↑(ι D.toGlueData i).base)).obj U))))
[PROOFSTEP]
congr 1
[GOAL]
case h.h.snd.mk.e_a
C : Type u
inst✝¹ : Category.{v, u} C
D : GlueData C
inst✝ : HasLimits C
i : D.J
U : Opens ↑↑(CategoryTheory.GlueData.U D.toGlueData i)
j k : D.J
this :
  t' D.toGlueData j k i ≫ pullback.fst ≫ t D.toGlueData k i ≫ f D.toGlueData i k =
    (pullbackSymmetry (f D.toGlueData j k) (f D.toGlueData j i)).hom ≫
      pullback.fst ≫ t D.toGlueData j i ≫ f D.toGlueData i j
⊢ 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
            (_ :
              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))))) ≫
        (V D.toGlueData (j, k)).presheaf.map
          (eqToHom
            (_ :
              (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))) =
                op
                  ((Opens.map
                        (colimit.ι (MultispanIndex.multispan (diagram D.toGlueData))
                            (op (WalkingMultispan.left (j, k))).unop).base).obj
                    ((IsOpenMap.functor (_ : IsOpenMap ↑(ι D.toGlueData i).base)).obj U)))) =
    NatTrans.app (pullbackSymmetry (f D.toGlueData j k) (f D.toGlueData j i)).hom.c
        (op ((Opens.map (pullback.fst ≫ t D.toGlueData j i ≫ f D.toGlueData i j).base).obj (op U).unop)) ≫
      (pullback (f D.toGlueData j k) (f D.toGlueData j i)).presheaf.map
          (eqToHom
            (_ :
              (Opens.map
                        ((pullbackSymmetry (f D.toGlueData j k) (f D.toGlueData j i)).hom ≫
                            pullback.fst ≫ t D.toGlueData j i ≫ f D.toGlueData i j).base).op.obj
                  (op U) =
                (Opens.map (t' D.toGlueData j k i ≫ pullback.fst ≫ t D.toGlueData k i ≫ f D.toGlueData i k).base).op.obj
                  (op U))) ≫
        IsOpenImmersion.invApp (_ : IsOpenImmersion pullback.fst)
            {
              carrier :=
                ↑(t' D.toGlueData j k i).base ⁻¹'
                  ↑(op
                        { carrier := ↑(pullback.fst ≫ t D.toGlueData k i ≫ f D.toGlueData i k).base ⁻¹' ↑(op U).unop,
                          is_open' :=
                            (_ :
                              IsOpen
                                (↑(pullback.fst ≫ t D.toGlueData k i ≫ f D.toGlueData i k).base ⁻¹'
                                  ↑(op U).unop)) }).unop,
              is_open' :=
                (_ :
                  IsOpen
                    (↑(t' D.toGlueData j k i).base ⁻¹'
                      ↑(op
                            {
                              carrier :=
                                ↑(pullback.fst ≫ t D.toGlueData k i ≫ f D.toGlueData i k).base ⁻¹' ↑(op U).unop,
                              is_open' :=
                                (_ :
                                  IsOpen
                                    (↑(pullback.fst ≫ t D.toGlueData k i ≫ f D.toGlueData i k).base ⁻¹'
                                      ↑(op U).unop)) }).unop)) } ≫
          (V D.toGlueData (j, k)).presheaf.map
              (eqToHom
                (_ :
                  op
                      ((IsOpenImmersion.openFunctor (_ : IsOpenImmersion pullback.fst)).obj
                        {
                            unop :=
                              {
                                carrier :=
                                  ↑(t' D.toGlueData j k i).base ⁻¹'
                                    ↑(op
                                          {
                                              unop :=
                                                {
                                                  carrier :=
                                                    ↑(pullback.fst ≫ t D.toGlueData k i ≫ f D.toGlueData i k).base ⁻¹'
                                                      ↑(op U).unop,
                                                  is_open' :=
                                                    (_ :
                                                      IsOpen
                                                        (↑(pullback.fst ≫
                                                                t D.toGlueData k i ≫ f D.toGlueData i k).base ⁻¹'
                                                          ↑(op U).unop)) } }.unop).unop,
                                is_open' :=
                                  (_ :
                                    IsOpen
                                      (↑(t' D.toGlueData j k i).base ⁻¹'
                                        ↑(op
                                              {
                                                  unop :=
                                                    {
                                                      carrier :=
                                                        ↑(pullback.fst ≫
                                                                t D.toGlueData k i ≫ f D.toGlueData i k).base ⁻¹'
                                                          ↑(op U).unop,
                                                      is_open' :=
                                                        (_ :
                                                          IsOpen
                                                            (↑(pullback.fst ≫
                                                                    t D.toGlueData k i ≫ f D.toGlueData i k).base ⁻¹'
                                                              ↑(op U).unop)) } }.unop).unop)) } }.unop) =
                    (Opens.map (t D.toGlueData j k).base).op.obj
                      (op
                        ((IsOpenImmersion.openFunctor (_ : IsOpenImmersion pullback.snd)).obj
                          {
                              unop :=
                                {
                                  carrier :=
                                    ↑(pullback.fst ≫ t D.toGlueData k i ≫ f D.toGlueData i k).base ⁻¹' ↑(op U).unop,
                                  is_open' :=
                                    (_ :
                                      IsOpen
                                        (↑(pullback.fst ≫ t D.toGlueData k i ≫ f D.toGlueData i k).base ⁻¹'
                                          ↑(op U).unop)) } }.unop)))) ≫
            ((t D.toGlueData j k).base _* (V D.toGlueData (j, k)).presheaf).map
                (eqToHom
                  (_ :
                    op
                        ((IsOpenImmersion.openFunctor (_ : IsOpenImmersion pullback.snd)).obj
                          {
                              unop :=
                                {
                                  carrier :=
                                    ↑(pullback.fst ≫ t D.toGlueData k i ≫ f D.toGlueData i k).base ⁻¹' ↑(op U).unop,
                                  is_open' :=
                                    (_ :
                                      IsOpen
                                        (↑(pullback.fst ≫ t D.toGlueData k i ≫ f D.toGlueData i k).base ⁻¹'
                                          ↑(op U).unop)) } }.unop) =
                      (Opens.map (f D.toGlueData k j).base).op.obj
                        (op
                          ((Opens.map (ι D.toGlueData k).base).obj
                            ((IsOpenMap.functor (_ : IsOpenMap ↑(ι D.toGlueData i).base)).obj U))))) ≫
              (V D.toGlueData (j, k)).presheaf.map
                (eqToHom
                  (_ :
                    (Opens.map
                              ((MultispanIndex.multispan (diagram D.toGlueData)).map
                                  (WalkingMultispan.Hom.snd (j, k)).op.unop).base).op.obj
                        (op
                          ((Opens.map
                                (colimit.ι (MultispanIndex.multispan (diagram D.toGlueData))
                                    (op
                                        (WalkingMultispan.right
                                          (MultispanIndex.sndFrom (diagram D.toGlueData) (j, k)))).unop).base).obj
                            ((IsOpenMap.functor (_ : IsOpenMap ↑(ι D.toGlueData i).base)).obj U))) =
                      op
                        ((Opens.map
                              (colimit.ι (MultispanIndex.multispan (diagram D.toGlueData))
                                  (op (WalkingMultispan.left (j, k))).unop).base).obj
                          ((IsOpenMap.functor (_ : IsOpenMap ↑(ι D.toGlueData i).base)).obj U))))
[PROOFSTEP]
rw [← IsIso.eq_inv_comp]
[GOAL]
case h.h.snd.mk.e_a
C : Type u
inst✝¹ : Category.{v, u} C
D : GlueData C
inst✝ : HasLimits C
i : D.J
U : Opens ↑↑(CategoryTheory.GlueData.U D.toGlueData i)
j k : D.J
this :
  t' D.toGlueData j k i ≫ pullback.fst ≫ t D.toGlueData k i ≫ f D.toGlueData i k =
    (pullbackSymmetry (f D.toGlueData j k) (f D.toGlueData j i)).hom ≫
      pullback.fst ≫ t D.toGlueData j i ≫ f D.toGlueData i j
⊢ (V D.toGlueData (j, k)).presheaf.map
        (eqToHom
          (_ :
            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))))) ≫
      (V D.toGlueData (j, k)).presheaf.map
        (eqToHom
          (_ :
            (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))) =
              op
                ((Opens.map
                      (colimit.ι (MultispanIndex.multispan (diagram D.toGlueData))
                          (op (WalkingMultispan.left (j, k))).unop).base).obj
                  ((IsOpenMap.functor (_ : IsOpenMap ↑(ι D.toGlueData i).base)).obj U)))) =
    inv
        (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)) }) ≫
      NatTrans.app (pullbackSymmetry (f D.toGlueData j k) (f D.toGlueData j i)).hom.c
          (op ((Opens.map (pullback.fst ≫ t D.toGlueData j i ≫ f D.toGlueData i j).base).obj (op U).unop)) ≫
        (pullback (f D.toGlueData j k) (f D.toGlueData j i)).presheaf.map
            (eqToHom
              (_ :
                (Opens.map
                          ((pullbackSymmetry (f D.toGlueData j k) (f D.toGlueData j i)).hom ≫
                              pullback.fst ≫ t D.toGlueData j i ≫ f D.toGlueData i j).base).op.obj
                    (op U) =
                  (Opens.map
                          (t' D.toGlueData j k i ≫ pullback.fst ≫ t D.toGlueData k i ≫ f D.toGlueData i k).base).op.obj
                    (op U))) ≫
          IsOpenImmersion.invApp (_ : IsOpenImmersion pullback.fst)
              {
                carrier :=
                  ↑(t' D.toGlueData j k i).base ⁻¹'
                    ↑(op
                          { carrier := ↑(pullback.fst ≫ t D.toGlueData k i ≫ f D.toGlueData i k).base ⁻¹' ↑(op U).unop,
                            is_open' :=
                              (_ :
                                IsOpen
                                  (↑(pullback.fst ≫ t D.toGlueData k i ≫ f D.toGlueData i k).base ⁻¹'
                                    ↑(op U).unop)) }).unop,
                is_open' :=
                  (_ :
                    IsOpen
                      (↑(t' D.toGlueData j k i).base ⁻¹'
                        ↑(op
                              {
                                carrier :=
                                  ↑(pullback.fst ≫ t D.toGlueData k i ≫ f D.toGlueData i k).base ⁻¹' ↑(op U).unop,
                                is_open' :=
                                  (_ :
                                    IsOpen
                                      (↑(pullback.fst ≫ t D.toGlueData k i ≫ f D.toGlueData i k).base ⁻¹'
                                        ↑(op U).unop)) }).unop)) } ≫
            (V D.toGlueData (j, k)).presheaf.map
                (eqToHom
                  (_ :
                    op
                        ((IsOpenImmersion.openFunctor (_ : IsOpenImmersion pullback.fst)).obj
                          {
                              unop :=
                                {
                                  carrier :=
                                    ↑(t' D.toGlueData j k i).base ⁻¹'
                                      ↑(op
                                            {
                                                unop :=
                                                  {
                                                    carrier :=
                                                      ↑(pullback.fst ≫ t D.toGlueData k i ≫ f D.toGlueData i k).base ⁻¹'
                                                        ↑(op U).unop,
                                                    is_open' :=
                                                      (_ :
                                                        IsOpen
                                                          (↑(pullback.fst ≫
                                                                  t D.toGlueData k i ≫ f D.toGlueData i k).base ⁻¹'
                                                            ↑(op U).unop)) } }.unop).unop,
                                  is_open' :=
                                    (_ :
                                      IsOpen
                                        (↑(t' D.toGlueData j k i).base ⁻¹'
                                          ↑(op
                                                {
                                                    unop :=
                                                      {
                                                        carrier :=
                                                          ↑(pullback.fst ≫
                                                                  t D.toGlueData k i ≫ f D.toGlueData i k).base ⁻¹'
                                                            ↑(op U).unop,
                                                        is_open' :=
                                                          (_ :
                                                            IsOpen
                                                              (↑(pullback.fst ≫
                                                                      t D.toGlueData k i ≫ f D.toGlueData i k).base ⁻¹'
                                                                ↑(op U).unop)) } }.unop).unop)) } }.unop) =
                      (Opens.map (t D.toGlueData j k).base).op.obj
                        (op
                          ((IsOpenImmersion.openFunctor (_ : IsOpenImmersion pullback.snd)).obj
                            {
                                unop :=
                                  {
                                    carrier :=
                                      ↑(pullback.fst ≫ t D.toGlueData k i ≫ f D.toGlueData i k).base ⁻¹' ↑(op U).unop,
                                    is_open' :=
                                      (_ :
                                        IsOpen
                                          (↑(pullback.fst ≫ t D.toGlueData k i ≫ f D.toGlueData i k).base ⁻¹'
                                            ↑(op U).unop)) } }.unop)))) ≫
              ((t D.toGlueData j k).base _* (V D.toGlueData (j, k)).presheaf).map
                  (eqToHom
                    (_ :
                      op
                          ((IsOpenImmersion.openFunctor (_ : IsOpenImmersion pullback.snd)).obj
                            {
                                unop :=
                                  {
                                    carrier :=
                                      ↑(pullback.fst ≫ t D.toGlueData k i ≫ f D.toGlueData i k).base ⁻¹' ↑(op U).unop,
                                    is_open' :=
                                      (_ :
                                        IsOpen
                                          (↑(pullback.fst ≫ t D.toGlueData k i ≫ f D.toGlueData i k).base ⁻¹'
                                            ↑(op U).unop)) } }.unop) =
                        (Opens.map (f D.toGlueData k j).base).op.obj
                          (op
                            ((Opens.map (ι D.toGlueData k).base).obj
                              ((IsOpenMap.functor (_ : IsOpenMap ↑(ι D.toGlueData i).base)).obj U))))) ≫
                (V D.toGlueData (j, k)).presheaf.map
                  (eqToHom
                    (_ :
                      (Opens.map
                                ((MultispanIndex.multispan (diagram D.toGlueData)).map
                                    (WalkingMultispan.Hom.snd (j, k)).op.unop).base).op.obj
                          (op
                            ((Opens.map
                                  (colimit.ι (MultispanIndex.multispan (diagram D.toGlueData))
                                      (op
                                          (WalkingMultispan.right
                                            (MultispanIndex.sndFrom (diagram D.toGlueData) (j, k)))).unop).base).obj
                              ((IsOpenMap.functor (_ : IsOpenMap ↑(ι D.toGlueData i).base)).obj U))) =
                        op
                          ((Opens.map
                                (colimit.ι (MultispanIndex.multispan (diagram D.toGlueData))
                                    (op (WalkingMultispan.left (j, k))).unop).base).obj
                            ((IsOpenMap.functor (_ : IsOpenMap ↑(ι D.toGlueData i).base)).obj U))))
[PROOFSTEP]
erw [IsOpenImmersion.inv_invApp]
[GOAL]
case h.h.snd.mk.e_a
C : Type u
inst✝¹ : Category.{v, u} C
D : GlueData C
inst✝ : HasLimits C
i : D.J
U : Opens ↑↑(CategoryTheory.GlueData.U D.toGlueData i)
j k : D.J
this :
  t' D.toGlueData j k i ≫ pullback.fst ≫ t D.toGlueData k i ≫ f D.toGlueData i k =
    (pullbackSymmetry (f D.toGlueData j k) (f D.toGlueData j i)).hom ≫
      pullback.fst ≫ t D.toGlueData j i ≫ f D.toGlueData i j
⊢ (V D.toGlueData (j, k)).presheaf.map
        (eqToHom
          (_ :
            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))))) ≫
      (V D.toGlueData (j, k)).presheaf.map
        (eqToHom
          (_ :
            (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))) =
              op
                ((Opens.map
                      (colimit.ι (MultispanIndex.multispan (diagram D.toGlueData))
                          (op (WalkingMultispan.left (j, k))).unop).base).obj
                  ((IsOpenMap.functor (_ : IsOpenMap ↑(ι D.toGlueData i).base)).obj U)))) =
    (NatTrans.app pullback.snd.c
          (op
            ((IsOpenImmersion.openFunctor (_ : IsOpenImmersion pullback.snd)).obj
              { 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)) })) ≫
        (pullback (f D.toGlueData j i) (f D.toGlueData j k)).presheaf.map
          (eqToHom
            (_ :
              op
                  ((Opens.map pullback.snd.base).obj
                    (op
                        ((IsOpenImmersion.openFunctor (_ : IsOpenImmersion pullback.snd)).obj
                          { 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) =
                op
                  { 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)) }))) ≫
      NatTrans.app (pullbackSymmetry (f D.toGlueData j k) (f D.toGlueData j i)).hom.c
          (op ((Opens.map (pullback.fst ≫ t D.toGlueData j i ≫ f D.toGlueData i j).base).obj (op U).unop)) ≫
        (pullback (f D.toGlueData j k) (f D.toGlueData j i)).presheaf.map
            (eqToHom
              (_ :
                (Opens.map
                          ((pullbackSymmetry (f D.toGlueData j k) (f D.toGlueData j i)).hom ≫
                              pullback.fst ≫ t D.toGlueData j i ≫ f D.toGlueData i j).base).op.obj
                    (op U) =
                  (Opens.map
                          (t' D.toGlueData j k i ≫ pullback.fst ≫ t D.toGlueData k i ≫ f D.toGlueData i k).base).op.obj
                    (op U))) ≫
          IsOpenImmersion.invApp (_ : IsOpenImmersion pullback.fst)
              {
                carrier :=
                  ↑(t' D.toGlueData j k i).base ⁻¹'
                    ↑(op
                          { carrier := ↑(pullback.fst ≫ t D.toGlueData k i ≫ f D.toGlueData i k).base ⁻¹' ↑(op U).unop,
                            is_open' :=
                              (_ :
                                IsOpen
                                  (↑(pullback.fst ≫ t D.toGlueData k i ≫ f D.toGlueData i k).base ⁻¹'
                                    ↑(op U).unop)) }).unop,
                is_open' :=
                  (_ :
                    IsOpen
                      (↑(t' D.toGlueData j k i).base ⁻¹'
                        ↑(op
                              {
                                carrier :=
                                  ↑(pullback.fst ≫ t D.toGlueData k i ≫ f D.toGlueData i k).base ⁻¹' ↑(op U).unop,
                                is_open' :=
                                  (_ :
                                    IsOpen
                                      (↑(pullback.fst ≫ t D.toGlueData k i ≫ f D.toGlueData i k).base ⁻¹'
                                        ↑(op U).unop)) }).unop)) } ≫
            (V D.toGlueData (j, k)).presheaf.map
                (eqToHom
                  (_ :
                    op
                        ((IsOpenImmersion.openFunctor (_ : IsOpenImmersion pullback.fst)).obj
                          {
                              unop :=
                                {
                                  carrier :=
                                    ↑(t' D.toGlueData j k i).base ⁻¹'
                                      ↑(op
                                            {
                                                unop :=
                                                  {
                                                    carrier :=
                                                      ↑(pullback.fst ≫ t D.toGlueData k i ≫ f D.toGlueData i k).base ⁻¹'
                                                        ↑(op U).unop,
                                                    is_open' :=
                                                      (_ :
                                                        IsOpen
                                                          (↑(pullback.fst ≫
                                                                  t D.toGlueData k i ≫ f D.toGlueData i k).base ⁻¹'
                                                            ↑(op U).unop)) } }.unop).unop,
                                  is_open' :=
                                    (_ :
                                      IsOpen
                                        (↑(t' D.toGlueData j k i).base ⁻¹'
                                          ↑(op
                                                {
                                                    unop :=
                                                      {
                                                        carrier :=
                                                          ↑(pullback.fst ≫
                                                                  t D.toGlueData k i ≫ f D.toGlueData i k).base ⁻¹'
                                                            ↑(op U).unop,
                                                        is_open' :=
                                                          (_ :
                                                            IsOpen
                                                              (↑(pullback.fst ≫
                                                                      t D.toGlueData k i ≫ f D.toGlueData i k).base ⁻¹'
                                                                ↑(op U).unop)) } }.unop).unop)) } }.unop) =
                      (Opens.map (t D.toGlueData j k).base).op.obj
                        (op
                          ((IsOpenImmersion.openFunctor (_ : IsOpenImmersion pullback.snd)).obj
                            {
                                unop :=
                                  {
                                    carrier :=
                                      ↑(pullback.fst ≫ t D.toGlueData k i ≫ f D.toGlueData i k).base ⁻¹' ↑(op U).unop,
                                    is_open' :=
                                      (_ :
                                        IsOpen
                                          (↑(pullback.fst ≫ t D.toGlueData k i ≫ f D.toGlueData i k).base ⁻¹'
                                            ↑(op U).unop)) } }.unop)))) ≫
              ((t D.toGlueData j k).base _* (V D.toGlueData (j, k)).presheaf).map
                  (eqToHom
                    (_ :
                      op
                          ((IsOpenImmersion.openFunctor (_ : IsOpenImmersion pullback.snd)).obj
                            {
                                unop :=
                                  {
                                    carrier :=
                                      ↑(pullback.fst ≫ t D.toGlueData k i ≫ f D.toGlueData i k).base ⁻¹' ↑(op U).unop,
                                    is_open' :=
                                      (_ :
                                        IsOpen
                                          (↑(pullback.fst ≫ t D.toGlueData k i ≫ f D.toGlueData i k).base ⁻¹'
                                            ↑(op U).unop)) } }.unop) =
                        (Opens.map (f D.toGlueData k j).base).op.obj
                          (op
                            ((Opens.map (ι D.toGlueData k).base).obj
                              ((IsOpenMap.functor (_ : IsOpenMap ↑(ι D.toGlueData i).base)).obj U))))) ≫
                (V D.toGlueData (j, k)).presheaf.map
                  (eqToHom
                    (_ :
                      (Opens.map
                                ((MultispanIndex.multispan (diagram D.toGlueData)).map
                                    (WalkingMultispan.Hom.snd (j, k)).op.unop).base).op.obj
                          (op
                            ((Opens.map
                                  (colimit.ι (MultispanIndex.multispan (diagram D.toGlueData))
                                      (op
                                          (WalkingMultispan.right
                                            (MultispanIndex.sndFrom (diagram D.toGlueData) (j, k)))).unop).base).obj
                              ((IsOpenMap.functor (_ : IsOpenMap ↑(ι D.toGlueData i).base)).obj U))) =
                        op
                          ((Opens.map
                                (colimit.ι (MultispanIndex.multispan (diagram D.toGlueData))
                                    (op (WalkingMultispan.left (j, k))).unop).base).obj
                            ((IsOpenMap.functor (_ : IsOpenMap ↑(ι D.toGlueData i).base)).obj U))))
[PROOFSTEP]
simp_rw [Category.assoc]
[GOAL]
case h.h.snd.mk.e_a
C : Type u
inst✝¹ : Category.{v, u} C
D : GlueData C
inst✝ : HasLimits C
i : D.J
U : Opens ↑↑(CategoryTheory.GlueData.U D.toGlueData i)
j k : D.J
this :
  t' D.toGlueData j k i ≫ pullback.fst ≫ t D.toGlueData k i ≫ f D.toGlueData i k =
    (pullbackSymmetry (f D.toGlueData j k) (f D.toGlueData j i)).hom ≫
      pullback.fst ≫ t D.toGlueData j i ≫ f D.toGlueData i j
⊢ (V D.toGlueData (j, k)).presheaf.map
        (eqToHom
          (_ :
            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))))) ≫
      (V D.toGlueData (j, k)).presheaf.map
        (eqToHom
          (_ :
            (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))) =
              op
                ((Opens.map
                      (colimit.ι (MultispanIndex.multispan (diagram D.toGlueData))
                          (op (WalkingMultispan.left (j, k))).unop).base).obj
                  ((IsOpenMap.functor (_ : IsOpenMap ↑(ι D.toGlueData i).base)).obj U)))) =
    NatTrans.app pullback.snd.c
        (op
          ((IsOpenImmersion.openFunctor (_ : IsOpenImmersion pullback.snd)).obj
            { 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)) })) ≫
      (pullback (f D.toGlueData j i) (f D.toGlueData j k)).presheaf.map
          (eqToHom
            (_ :
              op
                  ((Opens.map pullback.snd.base).obj
                    (op
                        ((IsOpenImmersion.openFunctor (_ : IsOpenImmersion pullback.snd)).obj
                          { 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) =
                op
                  { 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)) })) ≫
        NatTrans.app (pullbackSymmetry (f D.toGlueData j k) (f D.toGlueData j i)).hom.c
            (op ((Opens.map (pullback.fst ≫ t D.toGlueData j i ≫ f D.toGlueData i j).base).obj (op U).unop)) ≫
          (pullback (f D.toGlueData j k) (f D.toGlueData j i)).presheaf.map
              (eqToHom
                (_ :
                  (Opens.map
                            ((pullbackSymmetry (f D.toGlueData j k) (f D.toGlueData j i)).hom ≫
                                pullback.fst ≫ t D.toGlueData j i ≫ f D.toGlueData i j).base).op.obj
                      (op U) =
                    (Opens.map
                            (t' D.toGlueData j k i ≫
                                pullback.fst ≫ t D.toGlueData k i ≫ f D.toGlueData i k).base).op.obj
                      (op U))) ≫
            IsOpenImmersion.invApp (_ : IsOpenImmersion pullback.fst)
                {
                  carrier :=
                    ↑(t' D.toGlueData j k i).base ⁻¹'
                      ↑(op
                            {
                              carrier :=
                                ↑(pullback.fst ≫ t D.toGlueData k i ≫ f D.toGlueData i k).base ⁻¹' ↑(op U).unop,
                              is_open' :=
                                (_ :
                                  IsOpen
                                    (↑(pullback.fst ≫ t D.toGlueData k i ≫ f D.toGlueData i k).base ⁻¹'
                                      ↑(op U).unop)) }).unop,
                  is_open' :=
                    (_ :
                      IsOpen
                        (↑(t' D.toGlueData j k i).base ⁻¹'
                          ↑(op
                                {
                                  carrier :=
                                    ↑(pullback.fst ≫ t D.toGlueData k i ≫ f D.toGlueData i k).base ⁻¹' ↑(op U).unop,
                                  is_open' :=
                                    (_ :
                                      IsOpen
                                        (↑(pullback.fst ≫ t D.toGlueData k i ≫ f D.toGlueData i k).base ⁻¹'
                                          ↑(op U).unop)) }).unop)) } ≫
              (V D.toGlueData (j, k)).presheaf.map
                  (eqToHom
                    (_ :
                      op
                          ((IsOpenImmersion.openFunctor (_ : IsOpenImmersion pullback.fst)).obj
                            {
                                unop :=
                                  {
                                    carrier :=
                                      ↑(t' D.toGlueData j k i).base ⁻¹'
                                        ↑(op
                                              {
                                                  unop :=
                                                    {
                                                      carrier :=
                                                        ↑(pullback.fst ≫
                                                                t D.toGlueData k i ≫ f D.toGlueData i k).base ⁻¹'
                                                          ↑(op U).unop,
                                                      is_open' :=
                                                        (_ :
                                                          IsOpen
                                                            (↑(pullback.fst ≫
                                                                    t D.toGlueData k i ≫ f D.toGlueData i k).base ⁻¹'
                                                              ↑(op U).unop)) } }.unop).unop,
                                    is_open' :=
                                      (_ :
                                        IsOpen
                                          (↑(t' D.toGlueData j k i).base ⁻¹'
                                            ↑(op
                                                  {
                                                      unop :=
                                                        {
                                                          carrier :=
                                                            ↑(pullback.fst ≫
                                                                    t D.toGlueData k i ≫ f D.toGlueData i k).base ⁻¹'
                                                              ↑(op U).unop,
                                                          is_open' :=
                                                            (_ :
                                                              IsOpen
                                                                (↑(pullback.fst ≫
                                                                        t D.toGlueData k i ≫
                                                                          f D.toGlueData i k).base ⁻¹'
                                                                  ↑(op U).unop)) } }.unop).unop)) } }.unop) =
                        (Opens.map (t D.toGlueData j k).base).op.obj
                          (op
                            ((IsOpenImmersion.openFunctor (_ : IsOpenImmersion pullback.snd)).obj
                              {
                                  unop :=
                                    {
                                      carrier :=
                                        ↑(pullback.fst ≫ t D.toGlueData k i ≫ f D.toGlueData i k).base ⁻¹' ↑(op U).unop,
                                      is_open' :=
                                        (_ :
                                          IsOpen
                                            (↑(pullback.fst ≫ t D.toGlueData k i ≫ f D.toGlueData i k).base ⁻¹'
                                              ↑(op U).unop)) } }.unop)))) ≫
                ((t D.toGlueData j k).base _* (V D.toGlueData (j, k)).presheaf).map
                    (eqToHom
                      (_ :
                        op
                            ((IsOpenImmersion.openFunctor (_ : IsOpenImmersion pullback.snd)).obj
                              {
                                  unop :=
                                    {
                                      carrier :=
                                        ↑(pullback.fst ≫ t D.toGlueData k i ≫ f D.toGlueData i k).base ⁻¹' ↑(op U).unop,
                                      is_open' :=
                                        (_ :
                                          IsOpen
                                            (↑(pullback.fst ≫ t D.toGlueData k i ≫ f D.toGlueData i k).base ⁻¹'
                                              ↑(op U).unop)) } }.unop) =
                          (Opens.map (f D.toGlueData k j).base).op.obj
                            (op
                              ((Opens.map (ι D.toGlueData k).base).obj
                                ((IsOpenMap.functor (_ : IsOpenMap ↑(ι D.toGlueData i).base)).obj U))))) ≫
                  (V D.toGlueData (j, k)).presheaf.map
                    (eqToHom
                      (_ :
                        (Opens.map
                                  ((MultispanIndex.multispan (diagram D.toGlueData)).map
                                      (WalkingMultispan.Hom.snd (j, k)).op.unop).base).op.obj
                            (op
                              ((Opens.map
                                    (colimit.ι (MultispanIndex.multispan (diagram D.toGlueData))
                                        (op
                                            (WalkingMultispan.right
                                              (MultispanIndex.sndFrom (diagram D.toGlueData) (j, k)))).unop).base).obj
                                ((IsOpenMap.functor (_ : IsOpenMap ↑(ι D.toGlueData i).base)).obj U))) =
                          op
                            ((Opens.map
                                  (colimit.ι (MultispanIndex.multispan (diagram D.toGlueData))
                                      (op (WalkingMultispan.left (j, k))).unop).base).obj
                              ((IsOpenMap.functor (_ : IsOpenMap ↑(ι D.toGlueData i).base)).obj U))))
[PROOFSTEP]
erw [NatTrans.naturality_assoc, ← PresheafedSpace.comp_c_app_assoc, congr_app (pullbackSymmetry_hom_comp_snd _ _)]
[GOAL]
case h.h.snd.mk.e_a
C : Type u
inst✝¹ : Category.{v, u} C
D : GlueData C
inst✝ : HasLimits C
i : D.J
U : Opens ↑↑(CategoryTheory.GlueData.U D.toGlueData i)
j k : D.J
this :
  t' D.toGlueData j k i ≫ pullback.fst ≫ t D.toGlueData k i ≫ f D.toGlueData i k =
    (pullbackSymmetry (f D.toGlueData j k) (f D.toGlueData j i)).hom ≫
      pullback.fst ≫ t D.toGlueData j i ≫ f D.toGlueData i j
⊢ (V D.toGlueData (j, k)).presheaf.map
        (eqToHom
          (_ :
            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))))) ≫
      (V D.toGlueData (j, k)).presheaf.map
        (eqToHom
          (_ :
            (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))) =
              op
                ((Opens.map
                      (colimit.ι (MultispanIndex.multispan (diagram D.toGlueData))
                          (op (WalkingMultispan.left (j, k))).unop).base).obj
                  ((IsOpenMap.functor (_ : IsOpenMap ↑(ι D.toGlueData i).base)).obj U)))) =
    (NatTrans.app pullback.fst.c
          (op
            ((IsOpenImmersion.openFunctor (_ : IsOpenImmersion pullback.snd)).obj
              { 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)) })) ≫
        (pullback (f D.toGlueData j k) (f D.toGlueData j i)).presheaf.map
          (eqToHom
            (_ :
              (Opens.map pullback.fst.base).op.obj
                  (op
                    ((IsOpenImmersion.openFunctor (_ : IsOpenImmersion pullback.snd)).obj
                      { 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)) })) =
                (Opens.map
                        ((pullbackSymmetry (f D.toGlueData j k) (f D.toGlueData j i)).hom ≫ pullback.snd).base).op.obj
                  (op
                    ((IsOpenImmersion.openFunctor (_ : IsOpenImmersion pullback.snd)).obj
                      { 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)) }))))) ≫
      ((pullbackSymmetry (f D.toGlueData j k) (f D.toGlueData j i)).hom.base _*
              (pullback (f D.toGlueData j k) (f D.toGlueData j i)).presheaf).map
          (eqToHom
            (_ :
              op
                  ((Opens.map pullback.snd.base).obj
                    (op
                        ((IsOpenImmersion.openFunctor (_ : IsOpenImmersion pullback.snd)).obj
                          { 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) =
                op
                  { 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)) })) ≫
        (pullback (f D.toGlueData j k) (f D.toGlueData j i)).presheaf.map
            (eqToHom
              (_ :
                (Opens.map
                          ((pullbackSymmetry (f D.toGlueData j k) (f D.toGlueData j i)).hom ≫
                              pullback.fst ≫ t D.toGlueData j i ≫ f D.toGlueData i j).base).op.obj
                    (op U) =
                  (Opens.map
                          (t' D.toGlueData j k i ≫ pullback.fst ≫ t D.toGlueData k i ≫ f D.toGlueData i k).base).op.obj
                    (op U))) ≫
          IsOpenImmersion.invApp (_ : IsOpenImmersion pullback.fst)
              {
                carrier :=
                  ↑(t' D.toGlueData j k i).base ⁻¹'
                    ↑(op
                          { carrier := ↑(pullback.fst ≫ t D.toGlueData k i ≫ f D.toGlueData i k).base ⁻¹' ↑(op U).unop,
                            is_open' :=
                              (_ :
                                IsOpen
                                  (↑(pullback.fst ≫ t D.toGlueData k i ≫ f D.toGlueData i k).base ⁻¹'
                                    ↑(op U).unop)) }).unop,
                is_open' :=
                  (_ :
                    IsOpen
                      (↑(t' D.toGlueData j k i).base ⁻¹'
                        ↑(op
                              {
                                carrier :=
                                  ↑(pullback.fst ≫ t D.toGlueData k i ≫ f D.toGlueData i k).base ⁻¹' ↑(op U).unop,
                                is_open' :=
                                  (_ :
                                    IsOpen
                                      (↑(pullback.fst ≫ t D.toGlueData k i ≫ f D.toGlueData i k).base ⁻¹'
                                        ↑(op U).unop)) }).unop)) } ≫
            (V D.toGlueData (j, k)).presheaf.map
                (eqToHom
                  (_ :
                    op
                        ((IsOpenImmersion.openFunctor (_ : IsOpenImmersion pullback.fst)).obj
                          {
                              unop :=
                                {
                                  carrier :=
                                    ↑(t' D.toGlueData j k i).base ⁻¹'
                                      ↑(op
                                            {
                                                unop :=
                                                  {
                                                    carrier :=
                                                      ↑(pullback.fst ≫ t D.toGlueData k i ≫ f D.toGlueData i k).base ⁻¹'
                                                        ↑(op U).unop,
                                                    is_open' :=
                                                      (_ :
                                                        IsOpen
                                                          (↑(pullback.fst ≫
                                                                  t D.toGlueData k i ≫ f D.toGlueData i k).base ⁻¹'
                                                            ↑(op U).unop)) } }.unop).unop,
                                  is_open' :=
                                    (_ :
                                      IsOpen
                                        (↑(t' D.toGlueData j k i).base ⁻¹'
                                          ↑(op
                                                {
                                                    unop :=
                                                      {
                                                        carrier :=
                                                          ↑(pullback.fst ≫
                                                                  t D.toGlueData k i ≫ f D.toGlueData i k).base ⁻¹'
                                                            ↑(op U).unop,
                                                        is_open' :=
                                                          (_ :
                                                            IsOpen
                                                              (↑(pullback.fst ≫
                                                                      t D.toGlueData k i ≫ f D.toGlueData i k).base ⁻¹'
                                                                ↑(op U).unop)) } }.unop).unop)) } }.unop) =
                      (Opens.map (t D.toGlueData j k).base).op.obj
                        (op
                          ((IsOpenImmersion.openFunctor (_ : IsOpenImmersion pullback.snd)).obj
                            {
                                unop :=
                                  {
                                    carrier :=
                                      ↑(pullback.fst ≫ t D.toGlueData k i ≫ f D.toGlueData i k).base ⁻¹' ↑(op U).unop,
                                    is_open' :=
                                      (_ :
                                        IsOpen
                                          (↑(pullback.fst ≫ t D.toGlueData k i ≫ f D.toGlueData i k).base ⁻¹'
                                            ↑(op U).unop)) } }.unop)))) ≫
              ((t D.toGlueData j k).base _* (V D.toGlueData (j, k)).presheaf).map
                  (eqToHom
                    (_ :
                      op
                          ((IsOpenImmersion.openFunctor (_ : IsOpenImmersion pullback.snd)).obj
                            {
                                unop :=
                                  {
                                    carrier :=
                                      ↑(pullback.fst ≫ t D.toGlueData k i ≫ f D.toGlueData i k).base ⁻¹' ↑(op U).unop,
                                    is_open' :=
                                      (_ :
                                        IsOpen
                                          (↑(pullback.fst ≫ t D.toGlueData k i ≫ f D.toGlueData i k).base ⁻¹'
                                            ↑(op U).unop)) } }.unop) =
                        (Opens.map (f D.toGlueData k j).base).op.obj
                          (op
                            ((Opens.map (ι D.toGlueData k).base).obj
                              ((IsOpenMap.functor (_ : IsOpenMap ↑(ι D.toGlueData i).base)).obj U))))) ≫
                (V D.toGlueData (j, k)).presheaf.map
                  (eqToHom
                    (_ :
                      (Opens.map
                                ((MultispanIndex.multispan (diagram D.toGlueData)).map
                                    (WalkingMultispan.Hom.snd (j, k)).op.unop).base).op.obj
                          (op
                            ((Opens.map
                                  (colimit.ι (MultispanIndex.multispan (diagram D.toGlueData))
                                      (op
                                          (WalkingMultispan.right
                                            (MultispanIndex.sndFrom (diagram D.toGlueData) (j, k)))).unop).base).obj
                              ((IsOpenMap.functor (_ : IsOpenMap ↑(ι D.toGlueData i).base)).obj U))) =
                        op
                          ((Opens.map
                                (colimit.ι (MultispanIndex.multispan (diagram D.toGlueData))
                                    (op (WalkingMultispan.left (j, k))).unop).base).obj
                            ((IsOpenMap.functor (_ : IsOpenMap ↑(ι D.toGlueData i).base)).obj U))))
[PROOFSTEP]
simp_rw [Category.assoc]
[GOAL]
case h.h.snd.mk.e_a
C : Type u
inst✝¹ : Category.{v, u} C
D : GlueData C
inst✝ : HasLimits C
i : D.J
U : Opens ↑↑(CategoryTheory.GlueData.U D.toGlueData i)
j k : D.J
this :
  t' D.toGlueData j k i ≫ pullback.fst ≫ t D.toGlueData k i ≫ f D.toGlueData i k =
    (pullbackSymmetry (f D.toGlueData j k) (f D.toGlueData j i)).hom ≫
      pullback.fst ≫ t D.toGlueData j i ≫ f D.toGlueData i j
⊢ (V D.toGlueData (j, k)).presheaf.map
        (eqToHom
          (_ :
            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))))) ≫
      (V D.toGlueData (j, k)).presheaf.map
        (eqToHom
          (_ :
            (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))) =
              op
                ((Opens.map
                      (colimit.ι (MultispanIndex.multispan (diagram D.toGlueData))
                          (op (WalkingMultispan.left (j, k))).unop).base).obj
                  ((IsOpenMap.functor (_ : IsOpenMap ↑(ι D.toGlueData i).base)).obj U)))) =
    NatTrans.app pullback.fst.c
        (op
          ((IsOpenImmersion.openFunctor (_ : IsOpenImmersion pullback.snd)).obj
            { 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)) })) ≫
      (pullback (f D.toGlueData j k) (f D.toGlueData j i)).presheaf.map
          (eqToHom
            (_ :
              (Opens.map pullback.fst.base).op.obj
                  (op
                    ((IsOpenImmersion.openFunctor (_ : IsOpenImmersion pullback.snd)).obj
                      { 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)) })) =
                (Opens.map
                        ((pullbackSymmetry (f D.toGlueData j k) (f D.toGlueData j i)).hom ≫ pullback.snd).base).op.obj
                  (op
                    ((IsOpenImmersion.openFunctor (_ : IsOpenImmersion pullback.snd)).obj
                      { 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)) })))) ≫
        ((pullbackSymmetry (f D.toGlueData j k) (f D.toGlueData j i)).hom.base _*
                (pullback (f D.toGlueData j k) (f D.toGlueData j i)).presheaf).map
            (eqToHom
              (_ :
                op
                    ((Opens.map pullback.snd.base).obj
                      (op
                          ((IsOpenImmersion.openFunctor (_ : IsOpenImmersion pullback.snd)).obj
                            {
                              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) =
                  op
                    { 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)) })) ≫
          (pullback (f D.toGlueData j k) (f D.toGlueData j i)).presheaf.map
              (eqToHom
                (_ :
                  (Opens.map
                            ((pullbackSymmetry (f D.toGlueData j k) (f D.toGlueData j i)).hom ≫
                                pullback.fst ≫ t D.toGlueData j i ≫ f D.toGlueData i j).base).op.obj
                      (op U) =
                    (Opens.map
                            (t' D.toGlueData j k i ≫
                                pullback.fst ≫ t D.toGlueData k i ≫ f D.toGlueData i k).base).op.obj
                      (op U))) ≫
            IsOpenImmersion.invApp (_ : IsOpenImmersion pullback.fst)
                {
                  carrier :=
                    ↑(t' D.toGlueData j k i).base ⁻¹'
                      ↑(op
                            {
                              carrier :=
                                ↑(pullback.fst ≫ t D.toGlueData k i ≫ f D.toGlueData i k).base ⁻¹' ↑(op U).unop,
                              is_open' :=
                                (_ :
                                  IsOpen
                                    (↑(pullback.fst ≫ t D.toGlueData k i ≫ f D.toGlueData i k).base ⁻¹'
                                      ↑(op U).unop)) }).unop,
                  is_open' :=
                    (_ :
                      IsOpen
                        (↑(t' D.toGlueData j k i).base ⁻¹'
                          ↑(op
                                {
                                  carrier :=
                                    ↑(pullback.fst ≫ t D.toGlueData k i ≫ f D.toGlueData i k).base ⁻¹' ↑(op U).unop,
                                  is_open' :=
                                    (_ :
                                      IsOpen
                                        (↑(pullback.fst ≫ t D.toGlueData k i ≫ f D.toGlueData i k).base ⁻¹'
                                          ↑(op U).unop)) }).unop)) } ≫
              (V D.toGlueData (j, k)).presheaf.map
                  (eqToHom
                    (_ :
                      op
                          ((IsOpenImmersion.openFunctor (_ : IsOpenImmersion pullback.fst)).obj
                            {
                                unop :=
                                  {
                                    carrier :=
                                      ↑(t' D.toGlueData j k i).base ⁻¹'
                                        ↑(op
                                              {
                                                  unop :=
                                                    {
                                                      carrier :=
                                                        ↑(pullback.fst ≫
                                                                t D.toGlueData k i ≫ f D.toGlueData i k).base ⁻¹'
                                                          ↑(op U).unop,
                                                      is_open' :=
                                                        (_ :
                                                          IsOpen
                                                            (↑(pullback.fst ≫
                                                                    t D.toGlueData k i ≫ f D.toGlueData i k).base ⁻¹'
                                                              ↑(op U).unop)) } }.unop).unop,
                                    is_open' :=
                                      (_ :
                                        IsOpen
                                          (↑(t' D.toGlueData j k i).base ⁻¹'
                                            ↑(op
                                                  {
                                                      unop :=
                                                        {
                                                          carrier :=
                                                            ↑(pullback.fst ≫
                                                                    t D.toGlueData k i ≫ f D.toGlueData i k).base ⁻¹'
                                                              ↑(op U).unop,
                                                          is_open' :=
                                                            (_ :
                                                              IsOpen
                                                                (↑(pullback.fst ≫
                                                                        t D.toGlueData k i ≫
                                                                          f D.toGlueData i k).base ⁻¹'
                                                                  ↑(op U).unop)) } }.unop).unop)) } }.unop) =
                        (Opens.map (t D.toGlueData j k).base).op.obj
                          (op
                            ((IsOpenImmersion.openFunctor (_ : IsOpenImmersion pullback.snd)).obj
                              {
                                  unop :=
                                    {
                                      carrier :=
                                        ↑(pullback.fst ≫ t D.toGlueData k i ≫ f D.toGlueData i k).base ⁻¹' ↑(op U).unop,
                                      is_open' :=
                                        (_ :
                                          IsOpen
                                            (↑(pullback.fst ≫ t D.toGlueData k i ≫ f D.toGlueData i k).base ⁻¹'
                                              ↑(op U).unop)) } }.unop)))) ≫
                ((t D.toGlueData j k).base _* (V D.toGlueData (j, k)).presheaf).map
                    (eqToHom
                      (_ :
                        op
                            ((IsOpenImmersion.openFunctor (_ : IsOpenImmersion pullback.snd)).obj
                              {
                                  unop :=
                                    {
                                      carrier :=
                                        ↑(pullback.fst ≫ t D.toGlueData k i ≫ f D.toGlueData i k).base ⁻¹' ↑(op U).unop,
                                      is_open' :=
                                        (_ :
                                          IsOpen
                                            (↑(pullback.fst ≫ t D.toGlueData k i ≫ f D.toGlueData i k).base ⁻¹'
                                              ↑(op U).unop)) } }.unop) =
                          (Opens.map (f D.toGlueData k j).base).op.obj
                            (op
                              ((Opens.map (ι D.toGlueData k).base).obj
                                ((IsOpenMap.functor (_ : IsOpenMap ↑(ι D.toGlueData i).base)).obj U))))) ≫
                  (V D.toGlueData (j, k)).presheaf.map
                    (eqToHom
                      (_ :
                        (Opens.map
                                  ((MultispanIndex.multispan (diagram D.toGlueData)).map
                                      (WalkingMultispan.Hom.snd (j, k)).op.unop).base).op.obj
                            (op
                              ((Opens.map
                                    (colimit.ι (MultispanIndex.multispan (diagram D.toGlueData))
                                        (op
                                            (WalkingMultispan.right
                                              (MultispanIndex.sndFrom (diagram D.toGlueData) (j, k)))).unop).base).obj
                                ((IsOpenMap.functor (_ : IsOpenMap ↑(ι D.toGlueData i).base)).obj U))) =
                          op
                            ((Opens.map
                                  (colimit.ι (MultispanIndex.multispan (diagram D.toGlueData))
                                      (op (WalkingMultispan.left (j, k))).unop).base).obj
                              ((IsOpenMap.functor (_ : IsOpenMap ↑(ι D.toGlueData i).base)).obj U))))
[PROOFSTEP]
erw [IsOpenImmersion.inv_naturality_assoc, IsOpenImmersion.inv_naturality_assoc, IsOpenImmersion.inv_naturality_assoc,
  IsOpenImmersion.app_invApp_assoc]
[GOAL]
case h.h.snd.mk.e_a
C : Type u
inst✝¹ : Category.{v, u} C
D : GlueData C
inst✝ : HasLimits C
i : D.J
U : Opens ↑↑(CategoryTheory.GlueData.U D.toGlueData i)
j k : D.J
this :
  t' D.toGlueData j k i ≫ pullback.fst ≫ t D.toGlueData k i ≫ f D.toGlueData i k =
    (pullbackSymmetry (f D.toGlueData j k) (f D.toGlueData j i)).hom ≫
      pullback.fst ≫ t D.toGlueData j i ≫ f D.toGlueData i j
⊢ (V D.toGlueData (j, k)).presheaf.map
        (eqToHom
          (_ :
            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))))) ≫
      (V D.toGlueData (j, k)).presheaf.map
        (eqToHom
          (_ :
            (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))) =
              op
                ((Opens.map
                      (colimit.ι (MultispanIndex.multispan (diagram D.toGlueData))
                          (op (WalkingMultispan.left (j, k))).unop).base).obj
                  ((IsOpenMap.functor (_ : IsOpenMap ↑(ι D.toGlueData i).base)).obj U)))) =
    (V D.toGlueData (j, k)).presheaf.map
        (homOfLE
            (_ :
              ↑pullback.fst.base ''
                  (↑pullback.fst.base ⁻¹'
                    ((IsOpenImmersion.openFunctor (_ : IsOpenImmersion pullback.snd)).obj
                        { 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)) }).carrier) ⊆
                ((IsOpenImmersion.openFunctor (_ : IsOpenImmersion pullback.snd)).obj
                    { 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)) }).carrier)).op ≫
      (V D.toGlueData (j, k)).presheaf.map
          ((IsOpenImmersion.openFunctor (_ : IsOpenImmersion pullback.fst)).op.map
            (eqToHom
              (_ :
                (Opens.map pullback.fst.base).op.obj
                    (op
                      ((IsOpenImmersion.openFunctor (_ : IsOpenImmersion pullback.snd)).obj
                        { 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)) })) =
                  (Opens.map
                          ((pullbackSymmetry (f D.toGlueData j k) (f D.toGlueData j i)).hom ≫ pullback.snd).base).op.obj
                    (op
                      ((IsOpenImmersion.openFunctor (_ : IsOpenImmersion pullback.snd)).obj
                        { 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
            ((IsOpenImmersion.openFunctor (_ : IsOpenImmersion pullback.fst)).op.map
              ((Opens.map (pullbackSymmetry (f D.toGlueData j k) (f D.toGlueData j i)).hom.base).op.map
                (eqToHom
                  (_ :
                    op
                        ((Opens.map pullback.snd.base).obj
                          (op
                              ((IsOpenImmersion.openFunctor (_ : IsOpenImmersion pullback.snd)).obj
                                {
                                  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) =
                      op
                        { 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
              ((IsOpenImmersion.openFunctor (_ : IsOpenImmersion pullback.fst)).op.map
                (eqToHom
                  (_ :
                    (Opens.map
                              ((pullbackSymmetry (f D.toGlueData j k) (f D.toGlueData j i)).hom ≫
                                  pullback.fst ≫ t D.toGlueData j i ≫ f D.toGlueData i j).base).op.obj
                        (op U) =
                      (Opens.map
                              (t' D.toGlueData j k i ≫
                                  pullback.fst ≫ t D.toGlueData k i ≫ f D.toGlueData i k).base).op.obj
                        (op U)))) ≫
            (V D.toGlueData (j, k)).presheaf.map
                (eqToHom
                  (_ :
                    op
                        ((IsOpenImmersion.openFunctor (_ : IsOpenImmersion pullback.fst)).obj
                          {
                              unop :=
                                {
                                  carrier :=
                                    ↑(t' D.toGlueData j k i).base ⁻¹'
                                      ↑(op
                                            {
                                                unop :=
                                                  {
                                                    carrier :=
                                                      ↑(pullback.fst ≫ t D.toGlueData k i ≫ f D.toGlueData i k).base ⁻¹'
                                                        ↑(op U).unop,
                                                    is_open' :=
                                                      (_ :
                                                        IsOpen
                                                          (↑(pullback.fst ≫
                                                                  t D.toGlueData k i ≫ f D.toGlueData i k).base ⁻¹'
                                                            ↑(op U).unop)) } }.unop).unop,
                                  is_open' :=
                                    (_ :
                                      IsOpen
                                        (↑(t' D.toGlueData j k i).base ⁻¹'
                                          ↑(op
                                                {
                                                    unop :=
                                                      {
                                                        carrier :=
                                                          ↑(pullback.fst ≫
                                                                  t D.toGlueData k i ≫ f D.toGlueData i k).base ⁻¹'
                                                            ↑(op U).unop,
                                                        is_open' :=
                                                          (_ :
                                                            IsOpen
                                                              (↑(pullback.fst ≫
                                                                      t D.toGlueData k i ≫ f D.toGlueData i k).base ⁻¹'
                                                                ↑(op U).unop)) } }.unop).unop)) } }.unop) =
                      (Opens.map (t D.toGlueData j k).base).op.obj
                        (op
                          ((IsOpenImmersion.openFunctor (_ : IsOpenImmersion pullback.snd)).obj
                            {
                                unop :=
                                  {
                                    carrier :=
                                      ↑(pullback.fst ≫ t D.toGlueData k i ≫ f D.toGlueData i k).base ⁻¹' ↑(op U).unop,
                                    is_open' :=
                                      (_ :
                                        IsOpen
                                          (↑(pullback.fst ≫ t D.toGlueData k i ≫ f D.toGlueData i k).base ⁻¹'
                                            ↑(op U).unop)) } }.unop)))) ≫
              ((t D.toGlueData j k).base _* (V D.toGlueData (j, k)).presheaf).map
                  (eqToHom
                    (_ :
                      op
                          ((IsOpenImmersion.openFunctor (_ : IsOpenImmersion pullback.snd)).obj
                            {
                                unop :=
                                  {
                                    carrier :=
                                      ↑(pullback.fst ≫ t D.toGlueData k i ≫ f D.toGlueData i k).base ⁻¹' ↑(op U).unop,
                                    is_open' :=
                                      (_ :
                                        IsOpen
                                          (↑(pullback.fst ≫ t D.toGlueData k i ≫ f D.toGlueData i k).base ⁻¹'
                                            ↑(op U).unop)) } }.unop) =
                        (Opens.map (f D.toGlueData k j).base).op.obj
                          (op
                            ((Opens.map (ι D.toGlueData k).base).obj
                              ((IsOpenMap.functor (_ : IsOpenMap ↑(ι D.toGlueData i).base)).obj U))))) ≫
                (V D.toGlueData (j, k)).presheaf.map
                  (eqToHom
                    (_ :
                      (Opens.map
                                ((MultispanIndex.multispan (diagram D.toGlueData)).map
                                    (WalkingMultispan.Hom.snd (j, k)).op.unop).base).op.obj
                          (op
                            ((Opens.map
                                  (colimit.ι (MultispanIndex.multispan (diagram D.toGlueData))
                                      (op
                                          (WalkingMultispan.right
                                            (MultispanIndex.sndFrom (diagram D.toGlueData) (j, k)))).unop).base).obj
                              ((IsOpenMap.functor (_ : IsOpenMap ↑(ι D.toGlueData i).base)).obj U))) =
                        op
                          ((Opens.map
                                (colimit.ι (MultispanIndex.multispan (diagram D.toGlueData))
                                    (op (WalkingMultispan.left (j, k))).unop).base).obj
                            ((IsOpenMap.functor (_ : IsOpenMap ↑(ι D.toGlueData i).base)).obj U))))
[PROOFSTEP]
repeat'
  erw [← (D.V (j, k)).presheaf.map_comp]
    -- Porting note : was just `congr`
[GOAL]
case h.h.snd.mk.e_a
C : Type u
inst✝¹ : Category.{v, u} C
D : GlueData C
inst✝ : HasLimits C
i : D.J
U : Opens ↑↑(CategoryTheory.GlueData.U D.toGlueData i)
j k : D.J
this :
  t' D.toGlueData j k i ≫ pullback.fst ≫ t D.toGlueData k i ≫ f D.toGlueData i k =
    (pullbackSymmetry (f D.toGlueData j k) (f D.toGlueData j i)).hom ≫
      pullback.fst ≫ t D.toGlueData j i ≫ f D.toGlueData i j
⊢ (V D.toGlueData (j, k)).presheaf.map
        (eqToHom
          (_ :
            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))))) ≫
      (V D.toGlueData (j, k)).presheaf.map
        (eqToHom
          (_ :
            (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))) =
              op
                ((Opens.map
                      (colimit.ι (MultispanIndex.multispan (diagram D.toGlueData))
                          (op (WalkingMultispan.left (j, k))).unop).base).obj
                  ((IsOpenMap.functor (_ : IsOpenMap ↑(ι D.toGlueData i).base)).obj U)))) =
    (V D.toGlueData (j, k)).presheaf.map
        (homOfLE
            (_ :
              ↑pullback.fst.base ''
                  (↑pullback.fst.base ⁻¹'
                    ((IsOpenImmersion.openFunctor (_ : IsOpenImmersion pullback.snd)).obj
                        { 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)) }).carrier) ⊆
                ((IsOpenImmersion.openFunctor (_ : IsOpenImmersion pullback.snd)).obj
                    { 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)) }).carrier)).op ≫
      (V D.toGlueData (j, k)).presheaf.map
          ((IsOpenImmersion.openFunctor (_ : IsOpenImmersion pullback.fst)).op.map
            (eqToHom
              (_ :
                (Opens.map pullback.fst.base).op.obj
                    (op
                      ((IsOpenImmersion.openFunctor (_ : IsOpenImmersion pullback.snd)).obj
                        { 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)) })) =
                  (Opens.map
                          ((pullbackSymmetry (f D.toGlueData j k) (f D.toGlueData j i)).hom ≫ pullback.snd).base).op.obj
                    (op
                      ((IsOpenImmersion.openFunctor (_ : IsOpenImmersion pullback.snd)).obj
                        { 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
            ((IsOpenImmersion.openFunctor (_ : IsOpenImmersion pullback.fst)).op.map
              ((Opens.map (pullbackSymmetry (f D.toGlueData j k) (f D.toGlueData j i)).hom.base).op.map
                (eqToHom
                  (_ :
                    op
                        ((Opens.map pullback.snd.base).obj
                          (op
                              ((IsOpenImmersion.openFunctor (_ : IsOpenImmersion pullback.snd)).obj
                                {
                                  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) =
                      op
                        { 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
              ((IsOpenImmersion.openFunctor (_ : IsOpenImmersion pullback.fst)).op.map
                (eqToHom
                  (_ :
                    (Opens.map
                              ((pullbackSymmetry (f D.toGlueData j k) (f D.toGlueData j i)).hom ≫
                                  pullback.fst ≫ t D.toGlueData j i ≫ f D.toGlueData i j).base).op.obj
                        (op U) =
                      (Opens.map
                              (t' D.toGlueData j k i ≫
                                  pullback.fst ≫ t D.toGlueData k i ≫ f D.toGlueData i k).base).op.obj
                        (op U)))) ≫
            (V D.toGlueData (j, k)).presheaf.map
                (eqToHom
                  (_ :
                    op
                        ((IsOpenImmersion.openFunctor (_ : IsOpenImmersion pullback.fst)).obj
                          {
                              unop :=
                                {
                                  carrier :=
                                    ↑(t' D.toGlueData j k i).base ⁻¹'
                                      ↑(op
                                            {
                                                unop :=
                                                  {
                                                    carrier :=
                                                      ↑(pullback.fst ≫ t D.toGlueData k i ≫ f D.toGlueData i k).base ⁻¹'
                                                        ↑(op U).unop,
                                                    is_open' :=
                                                      (_ :
                                                        IsOpen
                                                          (↑(pullback.fst ≫
                                                                  t D.toGlueData k i ≫ f D.toGlueData i k).base ⁻¹'
                                                            ↑(op U).unop)) } }.unop).unop,
                                  is_open' :=
                                    (_ :
                                      IsOpen
                                        (↑(t' D.toGlueData j k i).base ⁻¹'
                                          ↑(op
                                                {
                                                    unop :=
                                                      {
                                                        carrier :=
                                                          ↑(pullback.fst ≫
                                                                  t D.toGlueData k i ≫ f D.toGlueData i k).base ⁻¹'
                                                            ↑(op U).unop,
                                                        is_open' :=
                                                          (_ :
                                                            IsOpen
                                                              (↑(pullback.fst ≫
                                                                      t D.toGlueData k i ≫ f D.toGlueData i k).base ⁻¹'
                                                                ↑(op U).unop)) } }.unop).unop)) } }.unop) =
                      (Opens.map (t D.toGlueData j k).base).op.obj
                        (op
                          ((IsOpenImmersion.openFunctor (_ : IsOpenImmersion pullback.snd)).obj
                            {
                                unop :=
                                  {
                                    carrier :=
                                      ↑(pullback.fst ≫ t D.toGlueData k i ≫ f D.toGlueData i k).base ⁻¹' ↑(op U).unop,
                                    is_open' :=
                                      (_ :
                                        IsOpen
                                          (↑(pullback.fst ≫ t D.toGlueData k i ≫ f D.toGlueData i k).base ⁻¹'
                                            ↑(op U).unop)) } }.unop)))) ≫
              ((t D.toGlueData j k).base _* (V D.toGlueData (j, k)).presheaf).map
                  (eqToHom
                    (_ :
                      op
                          ((IsOpenImmersion.openFunctor (_ : IsOpenImmersion pullback.snd)).obj
                            {
                                unop :=
                                  {
                                    carrier :=
                                      ↑(pullback.fst ≫ t D.toGlueData k i ≫ f D.toGlueData i k).base ⁻¹' ↑(op U).unop,
                                    is_open' :=
                                      (_ :
                                        IsOpen
                                          (↑(pullback.fst ≫ t D.toGlueData k i ≫ f D.toGlueData i k).base ⁻¹'
                                            ↑(op U).unop)) } }.unop) =
                        (Opens.map (f D.toGlueData k j).base).op.obj
                          (op
                            ((Opens.map (ι D.toGlueData k).base).obj
                              ((IsOpenMap.functor (_ : IsOpenMap ↑(ι D.toGlueData i).base)).obj U))))) ≫
                (V D.toGlueData (j, k)).presheaf.map
                  (eqToHom
                    (_ :
                      (Opens.map
                                ((MultispanIndex.multispan (diagram D.toGlueData)).map
                                    (WalkingMultispan.Hom.snd (j, k)).op.unop).base).op.obj
                          (op
                            ((Opens.map
                                  (colimit.ι (MultispanIndex.multispan (diagram D.toGlueData))
                                      (op
                                          (WalkingMultispan.right
                                            (MultispanIndex.sndFrom (diagram D.toGlueData) (j, k)))).unop).base).obj
                              ((IsOpenMap.functor (_ : IsOpenMap ↑(ι D.toGlueData i).base)).obj U))) =
                        op
                          ((Opens.map
                                (colimit.ι (MultispanIndex.multispan (diagram D.toGlueData))
                                    (op (WalkingMultispan.left (j, k))).unop).base).obj
                            ((IsOpenMap.functor (_ : IsOpenMap ↑(ι D.toGlueData i).base)).obj U))))
[PROOFSTEP]
erw [← (D.V (j, k)).presheaf.map_comp]
  -- Porting note : was just `congr`
[GOAL]
case h.h.snd.mk.e_a
C : Type u
inst✝¹ : Category.{v, u} C
D : GlueData C
inst✝ : HasLimits C
i : D.J
U : Opens ↑↑(CategoryTheory.GlueData.U D.toGlueData i)
j k : D.J
this :
  t' D.toGlueData j k i ≫ pullback.fst ≫ t D.toGlueData k i ≫ f D.toGlueData i k =
    (pullbackSymmetry (f D.toGlueData j k) (f D.toGlueData j i)).hom ≫
      pullback.fst ≫ t D.toGlueData j i ≫ f D.toGlueData i j
⊢ (V D.toGlueData (j, k)).presheaf.map
      (eqToHom
          (_ :
            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)))) ≫
        eqToHom
          (_ :
            (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))) =
              op
                ((Opens.map
                      (colimit.ι (MultispanIndex.multispan (diagram D.toGlueData))
                          (op (WalkingMultispan.left (j, k))).unop).base).obj
                  ((IsOpenMap.functor (_ : IsOpenMap ↑(ι D.toGlueData i).base)).obj U)))) =
    (V D.toGlueData (j, k)).presheaf.map
        (homOfLE
            (_ :
              ↑pullback.fst.base ''
                  (↑pullback.fst.base ⁻¹'
                    ((IsOpenImmersion.openFunctor (_ : IsOpenImmersion pullback.snd)).obj
                        { 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)) }).carrier) ⊆
                ((IsOpenImmersion.openFunctor (_ : IsOpenImmersion pullback.snd)).obj
                    { 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)) }).carrier)).op ≫
      (V D.toGlueData (j, k)).presheaf.map
          ((IsOpenImmersion.openFunctor (_ : IsOpenImmersion pullback.fst)).op.map
            (eqToHom
              (_ :
                (Opens.map pullback.fst.base).op.obj
                    (op
                      ((IsOpenImmersion.openFunctor (_ : IsOpenImmersion pullback.snd)).obj
                        { 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)) })) =
                  (Opens.map
                          ((pullbackSymmetry (f D.toGlueData j k) (f D.toGlueData j i)).hom ≫ pullback.snd).base).op.obj
                    (op
                      ((IsOpenImmersion.openFunctor (_ : IsOpenImmersion pullback.snd)).obj
                        { 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
            ((IsOpenImmersion.openFunctor (_ : IsOpenImmersion pullback.fst)).op.map
              ((Opens.map (pullbackSymmetry (f D.toGlueData j k) (f D.toGlueData j i)).hom.base).op.map
                (eqToHom
                  (_ :
                    op
                        ((Opens.map pullback.snd.base).obj
                          (op
                              ((IsOpenImmersion.openFunctor (_ : IsOpenImmersion pullback.snd)).obj
                                {
                                  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) =
                      op
                        { 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
              ((IsOpenImmersion.openFunctor (_ : IsOpenImmersion pullback.fst)).op.map
                (eqToHom
                  (_ :
                    (Opens.map
                              ((pullbackSymmetry (f D.toGlueData j k) (f D.toGlueData j i)).hom ≫
                                  pullback.fst ≫ t D.toGlueData j i ≫ f D.toGlueData i j).base).op.obj
                        (op U) =
                      (Opens.map
                              (t' D.toGlueData j k i ≫
                                  pullback.fst ≫ t D.toGlueData k i ≫ f D.toGlueData i k).base).op.obj
                        (op U)))) ≫
            (V D.toGlueData (j, k)).presheaf.map
                (eqToHom
                  (_ :
                    op
                        ((IsOpenImmersion.openFunctor (_ : IsOpenImmersion pullback.fst)).obj
                          {
                              unop :=
                                {
                                  carrier :=
                                    ↑(t' D.toGlueData j k i).base ⁻¹'
                                      ↑(op
                                            {
                                                unop :=
                                                  {
                                                    carrier :=
                                                      ↑(pullback.fst ≫ t D.toGlueData k i ≫ f D.toGlueData i k).base ⁻¹'
                                                        ↑(op U).unop,
                                                    is_open' :=
                                                      (_ :
                                                        IsOpen
                                                          (↑(pullback.fst ≫
                                                                  t D.toGlueData k i ≫ f D.toGlueData i k).base ⁻¹'
                                                            ↑(op U).unop)) } }.unop).unop,
                                  is_open' :=
                                    (_ :
                                      IsOpen
                                        (↑(t' D.toGlueData j k i).base ⁻¹'
                                          ↑(op
                                                {
                                                    unop :=
                                                      {
                                                        carrier :=
                                                          ↑(pullback.fst ≫
                                                                  t D.toGlueData k i ≫ f D.toGlueData i k).base ⁻¹'
                                                            ↑(op U).unop,
                                                        is_open' :=
                                                          (_ :
                                                            IsOpen
                                                              (↑(pullback.fst ≫
                                                                      t D.toGlueData k i ≫ f D.toGlueData i k).base ⁻¹'
                                                                ↑(op U).unop)) } }.unop).unop)) } }.unop) =
                      (Opens.map (t D.toGlueData j k).base).op.obj
                        (op
                          ((IsOpenImmersion.openFunctor (_ : IsOpenImmersion pullback.snd)).obj
                            {
                                unop :=
                                  {
                                    carrier :=
                                      ↑(pullback.fst ≫ t D.toGlueData k i ≫ f D.toGlueData i k).base ⁻¹' ↑(op U).unop,
                                    is_open' :=
                                      (_ :
                                        IsOpen
                                          (↑(pullback.fst ≫ t D.toGlueData k i ≫ f D.toGlueData i k).base ⁻¹'
                                            ↑(op U).unop)) } }.unop)))) ≫
              ((t D.toGlueData j k).base _* (V D.toGlueData (j, k)).presheaf).map
                  (eqToHom
                    (_ :
                      op
                          ((IsOpenImmersion.openFunctor (_ : IsOpenImmersion pullback.snd)).obj
                            {
                                unop :=
                                  {
                                    carrier :=
                                      ↑(pullback.fst ≫ t D.toGlueData k i ≫ f D.toGlueData i k).base ⁻¹' ↑(op U).unop,
                                    is_open' :=
                                      (_ :
                                        IsOpen
                                          (↑(pullback.fst ≫ t D.toGlueData k i ≫ f D.toGlueData i k).base ⁻¹'
                                            ↑(op U).unop)) } }.unop) =
                        (Opens.map (f D.toGlueData k j).base).op.obj
                          (op
                            ((Opens.map (ι D.toGlueData k).base).obj
                              ((IsOpenMap.functor (_ : IsOpenMap ↑(ι D.toGlueData i).base)).obj U))))) ≫
                (V D.toGlueData (j, k)).presheaf.map
                  (eqToHom
                    (_ :
                      (Opens.map
                                ((MultispanIndex.multispan (diagram D.toGlueData)).map
                                    (WalkingMultispan.Hom.snd (j, k)).op.unop).base).op.obj
                          (op
                            ((Opens.map
                                  (colimit.ι (MultispanIndex.multispan (diagram D.toGlueData))
                                      (op
                                          (WalkingMultispan.right
                                            (MultispanIndex.sndFrom (diagram D.toGlueData) (j, k)))).unop).base).obj
                              ((IsOpenMap.functor (_ : IsOpenMap ↑(ι D.toGlueData i).base)).obj U))) =
                        op
                          ((Opens.map
                                (colimit.ι (MultispanIndex.multispan (diagram D.toGlueData))
                                    (op (WalkingMultispan.left (j, k))).unop).base).obj
                            ((IsOpenMap.functor (_ : IsOpenMap ↑(ι D.toGlueData i).base)).obj U))))
[PROOFSTEP]
erw [← (D.V (j, k)).presheaf.map_comp]
  -- Porting note : was just `congr`
[GOAL]
case h.h.snd.mk.e_a
C : Type u
inst✝¹ : Category.{v, u} C
D : GlueData C
inst✝ : HasLimits C
i : D.J
U : Opens ↑↑(CategoryTheory.GlueData.U D.toGlueData i)
j k : D.J
this :
  t' D.toGlueData j k i ≫ pullback.fst ≫ t D.toGlueData k i ≫ f D.toGlueData i k =
    (pullbackSymmetry (f D.toGlueData j k) (f D.toGlueData j i)).hom ≫
      pullback.fst ≫ t D.toGlueData j i ≫ f D.toGlueData i j
⊢ (V D.toGlueData (j, k)).presheaf.map
      (eqToHom
          (_ :
            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)))) ≫
        eqToHom
          (_ :
            (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))) =
              op
                ((Opens.map
                      (colimit.ι (MultispanIndex.multispan (diagram D.toGlueData))
                          (op (WalkingMultispan.left (j, k))).unop).base).obj
                  ((IsOpenMap.functor (_ : IsOpenMap ↑(ι D.toGlueData i).base)).obj U)))) =
    (V D.toGlueData (j, k)).presheaf.map
        (homOfLE
            (_ :
              ↑pullback.fst.base ''
                  (↑pullback.fst.base ⁻¹'
                    ((IsOpenImmersion.openFunctor (_ : IsOpenImmersion pullback.snd)).obj
                        { 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)) }).carrier) ⊆
                ((IsOpenImmersion.openFunctor (_ : IsOpenImmersion pullback.snd)).obj
                    { 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)) }).carrier)).op ≫
      (V D.toGlueData (j, k)).presheaf.map
          ((IsOpenImmersion.openFunctor (_ : IsOpenImmersion pullback.fst)).op.map
            (eqToHom
              (_ :
                (Opens.map pullback.fst.base).op.obj
                    (op
                      ((IsOpenImmersion.openFunctor (_ : IsOpenImmersion pullback.snd)).obj
                        { 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)) })) =
                  (Opens.map
                          ((pullbackSymmetry (f D.toGlueData j k) (f D.toGlueData j i)).hom ≫ pullback.snd).base).op.obj
                    (op
                      ((IsOpenImmersion.openFunctor (_ : IsOpenImmersion pullback.snd)).obj
                        { 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
            ((IsOpenImmersion.openFunctor (_ : IsOpenImmersion pullback.fst)).op.map
              ((Opens.map (pullbackSymmetry (f D.toGlueData j k) (f D.toGlueData j i)).hom.base).op.map
                (eqToHom
                  (_ :
                    op
                        ((Opens.map pullback.snd.base).obj
                          (op
                              ((IsOpenImmersion.openFunctor (_ : IsOpenImmersion pullback.snd)).obj
                                {
                                  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) =
                      op
                        { 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
              ((IsOpenImmersion.openFunctor (_ : IsOpenImmersion pullback.fst)).op.map
                (eqToHom
                  (_ :
                    (Opens.map
                              ((pullbackSymmetry (f D.toGlueData j k) (f D.toGlueData j i)).hom ≫
                                  pullback.fst ≫ t D.toGlueData j i ≫ f D.toGlueData i j).base).op.obj
                        (op U) =
                      (Opens.map
                              (t' D.toGlueData j k i ≫
                                  pullback.fst ≫ t D.toGlueData k i ≫ f D.toGlueData i k).base).op.obj
                        (op U)))) ≫
            (V D.toGlueData (j, k)).presheaf.map
                (eqToHom
                  (_ :
                    op
                        ((IsOpenImmersion.openFunctor (_ : IsOpenImmersion pullback.fst)).obj
                          {
                              unop :=
                                {
                                  carrier :=
                                    ↑(t' D.toGlueData j k i).base ⁻¹'
                                      ↑(op
                                            {
                                                unop :=
                                                  {
                                                    carrier :=
                                                      ↑(pullback.fst ≫ t D.toGlueData k i ≫ f D.toGlueData i k).base ⁻¹'
                                                        ↑(op U).unop,
                                                    is_open' :=
                                                      (_ :
                                                        IsOpen
                                                          (↑(pullback.fst ≫
                                                                  t D.toGlueData k i ≫ f D.toGlueData i k).base ⁻¹'
                                                            ↑(op U).unop)) } }.unop).unop,
                                  is_open' :=
                                    (_ :
                                      IsOpen
                                        (↑(t' D.toGlueData j k i).base ⁻¹'
                                          ↑(op
                                                {
                                                    unop :=
                                                      {
                                                        carrier :=
                                                          ↑(pullback.fst ≫
                                                                  t D.toGlueData k i ≫ f D.toGlueData i k).base ⁻¹'
                                                            ↑(op U).unop,
                                                        is_open' :=
                                                          (_ :
                                                            IsOpen
                                                              (↑(pullback.fst ≫
                                                                      t D.toGlueData k i ≫ f D.toGlueData i k).base ⁻¹'
                                                                ↑(op U).unop)) } }.unop).unop)) } }.unop) =
                      (Opens.map (t D.toGlueData j k).base).op.obj
                        (op
                          ((IsOpenImmersion.openFunctor (_ : IsOpenImmersion pullback.snd)).obj
                            {
                                unop :=
                                  {
                                    carrier :=
                                      ↑(pullback.fst ≫ t D.toGlueData k i ≫ f D.toGlueData i k).base ⁻¹' ↑(op U).unop,
                                    is_open' :=
                                      (_ :
                                        IsOpen
                                          (↑(pullback.fst ≫ t D.toGlueData k i ≫ f D.toGlueData i k).base ⁻¹'
                                            ↑(op U).unop)) } }.unop)))) ≫
              (V D.toGlueData (j, k)).presheaf.map
                ((Opens.map (t D.toGlueData j k).base).op.map
                    (eqToHom
                      (_ :
                        op
                            ((IsOpenImmersion.openFunctor (_ : IsOpenImmersion pullback.snd)).obj
                              {
                                  unop :=
                                    {
                                      carrier :=
                                        ↑(pullback.fst ≫ t D.toGlueData k i ≫ f D.toGlueData i k).base ⁻¹' ↑(op U).unop,
                                      is_open' :=
                                        (_ :
                                          IsOpen
                                            (↑(pullback.fst ≫ t D.toGlueData k i ≫ f D.toGlueData i k).base ⁻¹'
                                              ↑(op U).unop)) } }.unop) =
                          (Opens.map (f D.toGlueData k j).base).op.obj
                            (op
                              ((Opens.map (ι D.toGlueData k).base).obj
                                ((IsOpenMap.functor (_ : IsOpenMap ↑(ι D.toGlueData i).base)).obj U))))) ≫
                  eqToHom
                    (_ :
                      (Opens.map
                                ((MultispanIndex.multispan (diagram D.toGlueData)).map
                                    (WalkingMultispan.Hom.snd (j, k)).op.unop).base).op.obj
                          (op
                            ((Opens.map
                                  (colimit.ι (MultispanIndex.multispan (diagram D.toGlueData))
                                      (op
                                          (WalkingMultispan.right
                                            (MultispanIndex.sndFrom (diagram D.toGlueData) (j, k)))).unop).base).obj
                              ((IsOpenMap.functor (_ : IsOpenMap ↑(ι D.toGlueData i).base)).obj U))) =
                        op
                          ((Opens.map
                                (colimit.ι (MultispanIndex.multispan (diagram D.toGlueData))
                                    (op (WalkingMultispan.left (j, k))).unop).base).obj
                            ((IsOpenMap.functor (_ : IsOpenMap ↑(ι D.toGlueData i).base)).obj U))))
[PROOFSTEP]
erw [← (D.V (j, k)).presheaf.map_comp]
  -- Porting note : was just `congr`
[GOAL]
case h.h.snd.mk.e_a
C : Type u
inst✝¹ : Category.{v, u} C
D : GlueData C
inst✝ : HasLimits C
i : D.J
U : Opens ↑↑(CategoryTheory.GlueData.U D.toGlueData i)
j k : D.J
this :
  t' D.toGlueData j k i ≫ pullback.fst ≫ t D.toGlueData k i ≫ f D.toGlueData i k =
    (pullbackSymmetry (f D.toGlueData j k) (f D.toGlueData j i)).hom ≫
      pullback.fst ≫ t D.toGlueData j i ≫ f D.toGlueData i j
⊢ (V D.toGlueData (j, k)).presheaf.map
      (eqToHom
          (_ :
            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)))) ≫
        eqToHom
          (_ :
            (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))) =
              op
                ((Opens.map
                      (colimit.ι (MultispanIndex.multispan (diagram D.toGlueData))
                          (op (WalkingMultispan.left (j, k))).unop).base).obj
                  ((IsOpenMap.functor (_ : IsOpenMap ↑(ι D.toGlueData i).base)).obj U)))) =
    (V D.toGlueData (j, k)).presheaf.map
        (homOfLE
            (_ :
              ↑pullback.fst.base ''
                  (↑pullback.fst.base ⁻¹'
                    ((IsOpenImmersion.openFunctor (_ : IsOpenImmersion pullback.snd)).obj
                        { 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)) }).carrier) ⊆
                ((IsOpenImmersion.openFunctor (_ : IsOpenImmersion pullback.snd)).obj
                    { 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)) }).carrier)).op ≫
      (V D.toGlueData (j, k)).presheaf.map
          ((IsOpenImmersion.openFunctor (_ : IsOpenImmersion pullback.fst)).op.map
            (eqToHom
              (_ :
                (Opens.map pullback.fst.base).op.obj
                    (op
                      ((IsOpenImmersion.openFunctor (_ : IsOpenImmersion pullback.snd)).obj
                        { 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)) })) =
                  (Opens.map
                          ((pullbackSymmetry (f D.toGlueData j k) (f D.toGlueData j i)).hom ≫ pullback.snd).base).op.obj
                    (op
                      ((IsOpenImmersion.openFunctor (_ : IsOpenImmersion pullback.snd)).obj
                        { 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
            ((IsOpenImmersion.openFunctor (_ : IsOpenImmersion pullback.fst)).op.map
              ((Opens.map (pullbackSymmetry (f D.toGlueData j k) (f D.toGlueData j i)).hom.base).op.map
                (eqToHom
                  (_ :
                    op
                        ((Opens.map pullback.snd.base).obj
                          (op
                              ((IsOpenImmersion.openFunctor (_ : IsOpenImmersion pullback.snd)).obj
                                {
                                  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) =
                      op
                        { 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
              ((IsOpenImmersion.openFunctor (_ : IsOpenImmersion pullback.fst)).op.map
                (eqToHom
                  (_ :
                    (Opens.map
                              ((pullbackSymmetry (f D.toGlueData j k) (f D.toGlueData j i)).hom ≫
                                  pullback.fst ≫ t D.toGlueData j i ≫ f D.toGlueData i j).base).op.obj
                        (op U) =
                      (Opens.map
                              (t' D.toGlueData j k i ≫
                                  pullback.fst ≫ t D.toGlueData k i ≫ f D.toGlueData i k).base).op.obj
                        (op U)))) ≫
            (V D.toGlueData (j, k)).presheaf.map
              (eqToHom
                  (_ :
                    op
                        ((IsOpenImmersion.openFunctor (_ : IsOpenImmersion pullback.fst)).obj
                          {
                              unop :=
                                {
                                  carrier :=
                                    ↑(t' D.toGlueData j k i).base ⁻¹'
                                      ↑(op
                                            {
                                                unop :=
                                                  {
                                                    carrier :=
                                                      ↑(pullback.fst ≫ t D.toGlueData k i ≫ f D.toGlueData i k).base ⁻¹'
                                                        ↑(op U).unop,
                                                    is_open' :=
                                                      (_ :
                                                        IsOpen
                                                          (↑(pullback.fst ≫
                                                                  t D.toGlueData k i ≫ f D.toGlueData i k).base ⁻¹'
                                                            ↑(op U).unop)) } }.unop).unop,
                                  is_open' :=
                                    (_ :
                                      IsOpen
                                        (↑(t' D.toGlueData j k i).base ⁻¹'
                                          ↑(op
                                                {
                                                    unop :=
                                                      {
                                                        carrier :=
                                                          ↑(pullback.fst ≫
                                                                  t D.toGlueData k i ≫ f D.toGlueData i k).base ⁻¹'
                                                            ↑(op U).unop,
                                                        is_open' :=
                                                          (_ :
                                                            IsOpen
                                                              (↑(pullback.fst ≫
                                                                      t D.toGlueData k i ≫ f D.toGlueData i k).base ⁻¹'
                                                                ↑(op U).unop)) } }.unop).unop)) } }.unop) =
                      (Opens.map (t D.toGlueData j k).base).op.obj
                        (op
                          ((IsOpenImmersion.openFunctor (_ : IsOpenImmersion pullback.snd)).obj
                            {
                                unop :=
                                  {
                                    carrier :=
                                      ↑(pullback.fst ≫ t D.toGlueData k i ≫ f D.toGlueData i k).base ⁻¹' ↑(op U).unop,
                                    is_open' :=
                                      (_ :
                                        IsOpen
                                          (↑(pullback.fst ≫ t D.toGlueData k i ≫ f D.toGlueData i k).base ⁻¹'
                                            ↑(op U).unop)) } }.unop))) ≫
                (Opens.map (t D.toGlueData j k).base).op.map
                    (eqToHom
                      (_ :
                        op
                            ((IsOpenImmersion.openFunctor (_ : IsOpenImmersion pullback.snd)).obj
                              {
                                  unop :=
                                    {
                                      carrier :=
                                        ↑(pullback.fst ≫ t D.toGlueData k i ≫ f D.toGlueData i k).base ⁻¹' ↑(op U).unop,
                                      is_open' :=
                                        (_ :
                                          IsOpen
                                            (↑(pullback.fst ≫ t D.toGlueData k i ≫ f D.toGlueData i k).base ⁻¹'
                                              ↑(op U).unop)) } }.unop) =
                          (Opens.map (f D.toGlueData k j).base).op.obj
                            (op
                              ((Opens.map (ι D.toGlueData k).base).obj
                                ((IsOpenMap.functor (_ : IsOpenMap ↑(ι D.toGlueData i).base)).obj U))))) ≫
                  eqToHom
                    (_ :
                      (Opens.map
                                ((MultispanIndex.multispan (diagram D.toGlueData)).map
                                    (WalkingMultispan.Hom.snd (j, k)).op.unop).base).op.obj
                          (op
                            ((Opens.map
                                  (colimit.ι (MultispanIndex.multispan (diagram D.toGlueData))
                                      (op
                                          (WalkingMultispan.right
                                            (MultispanIndex.sndFrom (diagram D.toGlueData) (j, k)))).unop).base).obj
                              ((IsOpenMap.functor (_ : IsOpenMap ↑(ι D.toGlueData i).base)).obj U))) =
                        op
                          ((Opens.map
                                (colimit.ι (MultispanIndex.multispan (diagram D.toGlueData))
                                    (op (WalkingMultispan.left (j, k))).unop).base).obj
                            ((IsOpenMap.functor (_ : IsOpenMap ↑(ι D.toGlueData i).base)).obj U))))
[PROOFSTEP]
erw [← (D.V (j, k)).presheaf.map_comp]
  -- Porting note : was just `congr`
[GOAL]
case h.h.snd.mk.e_a
C : Type u
inst✝¹ : Category.{v, u} C
D : GlueData C
inst✝ : HasLimits C
i : D.J
U : Opens ↑↑(CategoryTheory.GlueData.U D.toGlueData i)
j k : D.J
this :
  t' D.toGlueData j k i ≫ pullback.fst ≫ t D.toGlueData k i ≫ f D.toGlueData i k =
    (pullbackSymmetry (f D.toGlueData j k) (f D.toGlueData j i)).hom ≫
      pullback.fst ≫ t D.toGlueData j i ≫ f D.toGlueData i j
⊢ (V D.toGlueData (j, k)).presheaf.map
      (eqToHom
          (_ :
            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)))) ≫
        eqToHom
          (_ :
            (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))) =
              op
                ((Opens.map
                      (colimit.ι (MultispanIndex.multispan (diagram D.toGlueData))
                          (op (WalkingMultispan.left (j, k))).unop).base).obj
                  ((IsOpenMap.functor (_ : IsOpenMap ↑(ι D.toGlueData i).base)).obj U)))) =
    (V D.toGlueData (j, k)).presheaf.map
        (homOfLE
            (_ :
              ↑pullback.fst.base ''
                  (↑pullback.fst.base ⁻¹'
                    ((IsOpenImmersion.openFunctor (_ : IsOpenImmersion pullback.snd)).obj
                        { 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)) }).carrier) ⊆
                ((IsOpenImmersion.openFunctor (_ : IsOpenImmersion pullback.snd)).obj
                    { 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)) }).carrier)).op ≫
      (V D.toGlueData (j, k)).presheaf.map
          ((IsOpenImmersion.openFunctor (_ : IsOpenImmersion pullback.fst)).op.map
            (eqToHom
              (_ :
                (Opens.map pullback.fst.base).op.obj
                    (op
                      ((IsOpenImmersion.openFunctor (_ : IsOpenImmersion pullback.snd)).obj
                        { 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)) })) =
                  (Opens.map
                          ((pullbackSymmetry (f D.toGlueData j k) (f D.toGlueData j i)).hom ≫ pullback.snd).base).op.obj
                    (op
                      ((IsOpenImmersion.openFunctor (_ : IsOpenImmersion pullback.snd)).obj
                        { 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
            ((IsOpenImmersion.openFunctor (_ : IsOpenImmersion pullback.fst)).op.map
              ((Opens.map (pullbackSymmetry (f D.toGlueData j k) (f D.toGlueData j i)).hom.base).op.map
                (eqToHom
                  (_ :
                    op
                        ((Opens.map pullback.snd.base).obj
                          (op
                              ((IsOpenImmersion.openFunctor (_ : IsOpenImmersion pullback.snd)).obj
                                {
                                  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) =
                      op
                        { 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
            ((IsOpenImmersion.openFunctor (_ : IsOpenImmersion pullback.fst)).op.map
                (eqToHom
                  (_ :
                    (Opens.map
                              ((pullbackSymmetry (f D.toGlueData j k) (f D.toGlueData j i)).hom ≫
                                  pullback.fst ≫ t D.toGlueData j i ≫ f D.toGlueData i j).base).op.obj
                        (op U) =
                      (Opens.map
                              (t' D.toGlueData j k i ≫
                                  pullback.fst ≫ t D.toGlueData k i ≫ f D.toGlueData i k).base).op.obj
                        (op U))) ≫
              eqToHom
                  (_ :
                    op
                        ((IsOpenImmersion.openFunctor (_ : IsOpenImmersion pullback.fst)).obj
                          {
                              unop :=
                                {
                                  carrier :=
                                    ↑(t' D.toGlueData j k i).base ⁻¹'
                                      ↑(op
                                            {
                                                unop :=
                                                  {
                                                    carrier :=
                                                      ↑(pullback.fst ≫ t D.toGlueData k i ≫ f D.toGlueData i k).base ⁻¹'
                                                        ↑(op U).unop,
                                                    is_open' :=
                                                      (_ :
                                                        IsOpen
                                                          (↑(pullback.fst ≫
                                                                  t D.toGlueData k i ≫ f D.toGlueData i k).base ⁻¹'
                                                            ↑(op U).unop)) } }.unop).unop,
                                  is_open' :=
                                    (_ :
                                      IsOpen
                                        (↑(t' D.toGlueData j k i).base ⁻¹'
                                          ↑(op
                                                {
                                                    unop :=
                                                      {
                                                        carrier :=
                                                          ↑(pullback.fst ≫
                                                                  t D.toGlueData k i ≫ f D.toGlueData i k).base ⁻¹'
                                                            ↑(op U).unop,
                                                        is_open' :=
                                                          (_ :
                                                            IsOpen
                                                              (↑(pullback.fst ≫
                                                                      t D.toGlueData k i ≫ f D.toGlueData i k).base ⁻¹'
                                                                ↑(op U).unop)) } }.unop).unop)) } }.unop) =
                      (Opens.map (t D.toGlueData j k).base).op.obj
                        (op
                          ((IsOpenImmersion.openFunctor (_ : IsOpenImmersion pullback.snd)).obj
                            {
                                unop :=
                                  {
                                    carrier :=
                                      ↑(pullback.fst ≫ t D.toGlueData k i ≫ f D.toGlueData i k).base ⁻¹' ↑(op U).unop,
                                    is_open' :=
                                      (_ :
                                        IsOpen
                                          (↑(pullback.fst ≫ t D.toGlueData k i ≫ f D.toGlueData i k).base ⁻¹'
                                            ↑(op U).unop)) } }.unop))) ≫
                (Opens.map (t D.toGlueData j k).base).op.map
                    (eqToHom
                      (_ :
                        op
                            ((IsOpenImmersion.openFunctor (_ : IsOpenImmersion pullback.snd)).obj
                              {
                                  unop :=
                                    {
                                      carrier :=
                                        ↑(pullback.fst ≫ t D.toGlueData k i ≫ f D.toGlueData i k).base ⁻¹' ↑(op U).unop,
                                      is_open' :=
                                        (_ :
                                          IsOpen
                                            (↑(pullback.fst ≫ t D.toGlueData k i ≫ f D.toGlueData i k).base ⁻¹'
                                              ↑(op U).unop)) } }.unop) =
                          (Opens.map (f D.toGlueData k j).base).op.obj
                            (op
                              ((Opens.map (ι D.toGlueData k).base).obj
                                ((IsOpenMap.functor (_ : IsOpenMap ↑(ι D.toGlueData i).base)).obj U))))) ≫
                  eqToHom
                    (_ :
                      (Opens.map
                                ((MultispanIndex.multispan (diagram D.toGlueData)).map
                                    (WalkingMultispan.Hom.snd (j, k)).op.unop).base).op.obj
                          (op
                            ((Opens.map
                                  (colimit.ι (MultispanIndex.multispan (diagram D.toGlueData))
                                      (op
                                          (WalkingMultispan.right
                                            (MultispanIndex.sndFrom (diagram D.toGlueData) (j, k)))).unop).base).obj
                              ((IsOpenMap.functor (_ : IsOpenMap ↑(ι D.toGlueData i).base)).obj U))) =
                        op
                          ((Opens.map
                                (colimit.ι (MultispanIndex.multispan (diagram D.toGlueData))
                                    (op (WalkingMultispan.left (j, k))).unop).base).obj
                            ((IsOpenMap.functor (_ : IsOpenMap ↑(ι D.toGlueData i).base)).obj U))))
[PROOFSTEP]
erw [← (D.V (j, k)).presheaf.map_comp]
  -- Porting note : was just `congr`
[GOAL]
case h.h.snd.mk.e_a
C : Type u
inst✝¹ : Category.{v, u} C
D : GlueData C
inst✝ : HasLimits C
i : D.J
U : Opens ↑↑(CategoryTheory.GlueData.U D.toGlueData i)
j k : D.J
this :
  t' D.toGlueData j k i ≫ pullback.fst ≫ t D.toGlueData k i ≫ f D.toGlueData i k =
    (pullbackSymmetry (f D.toGlueData j k) (f D.toGlueData j i)).hom ≫
      pullback.fst ≫ t D.toGlueData j i ≫ f D.toGlueData i j
⊢ (V D.toGlueData (j, k)).presheaf.map
      (eqToHom
          (_ :
            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)))) ≫
        eqToHom
          (_ :
            (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))) =
              op
                ((Opens.map
                      (colimit.ι (MultispanIndex.multispan (diagram D.toGlueData))
                          (op (WalkingMultispan.left (j, k))).unop).base).obj
                  ((IsOpenMap.functor (_ : IsOpenMap ↑(ι D.toGlueData i).base)).obj U)))) =
    (V D.toGlueData (j, k)).presheaf.map
        (homOfLE
            (_ :
              ↑pullback.fst.base ''
                  (↑pullback.fst.base ⁻¹'
                    ((IsOpenImmersion.openFunctor (_ : IsOpenImmersion pullback.snd)).obj
                        { 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)) }).carrier) ⊆
                ((IsOpenImmersion.openFunctor (_ : IsOpenImmersion pullback.snd)).obj
                    { 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)) }).carrier)).op ≫
      (V D.toGlueData (j, k)).presheaf.map
          ((IsOpenImmersion.openFunctor (_ : IsOpenImmersion pullback.fst)).op.map
            (eqToHom
              (_ :
                (Opens.map pullback.fst.base).op.obj
                    (op
                      ((IsOpenImmersion.openFunctor (_ : IsOpenImmersion pullback.snd)).obj
                        { 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)) })) =
                  (Opens.map
                          ((pullbackSymmetry (f D.toGlueData j k) (f D.toGlueData j i)).hom ≫ pullback.snd).base).op.obj
                    (op
                      ((IsOpenImmersion.openFunctor (_ : IsOpenImmersion pullback.snd)).obj
                        { 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
          ((IsOpenImmersion.openFunctor (_ : IsOpenImmersion pullback.fst)).op.map
              ((Opens.map (pullbackSymmetry (f D.toGlueData j k) (f D.toGlueData j i)).hom.base).op.map
                (eqToHom
                  (_ :
                    op
                        ((Opens.map pullback.snd.base).obj
                          (op
                              ((IsOpenImmersion.openFunctor (_ : IsOpenImmersion pullback.snd)).obj
                                {
                                  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) =
                      op
                        { 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)) }))) ≫
            (IsOpenImmersion.openFunctor (_ : IsOpenImmersion pullback.fst)).op.map
                (eqToHom
                  (_ :
                    (Opens.map
                              ((pullbackSymmetry (f D.toGlueData j k) (f D.toGlueData j i)).hom ≫
                                  pullback.fst ≫ t D.toGlueData j i ≫ f D.toGlueData i j).base).op.obj
                        (op U) =
                      (Opens.map
                              (t' D.toGlueData j k i ≫
                                  pullback.fst ≫ t D.toGlueData k i ≫ f D.toGlueData i k).base).op.obj
                        (op U))) ≫
              eqToHom
                  (_ :
                    op
                        ((IsOpenImmersion.openFunctor (_ : IsOpenImmersion pullback.fst)).obj
                          {
                              unop :=
                                {
                                  carrier :=
                                    ↑(t' D.toGlueData j k i).base ⁻¹'
                                      ↑(op
                                            {
                                                unop :=
                                                  {
                                                    carrier :=
                                                      ↑(pullback.fst ≫ t D.toGlueData k i ≫ f D.toGlueData i k).base ⁻¹'
                                                        ↑(op U).unop,
                                                    is_open' :=
                                                      (_ :
                                                        IsOpen
                                                          (↑(pullback.fst ≫
                                                                  t D.toGlueData k i ≫ f D.toGlueData i k).base ⁻¹'
                                                            ↑(op U).unop)) } }.unop).unop,
                                  is_open' :=
                                    (_ :
                                      IsOpen
                                        (↑(t' D.toGlueData j k i).base ⁻¹'
                                          ↑(op
                                                {
                                                    unop :=
                                                      {
                                                        carrier :=
                                                          ↑(pullback.fst ≫
                                                                  t D.toGlueData k i ≫ f D.toGlueData i k).base ⁻¹'
                                                            ↑(op U).unop,
                                                        is_open' :=
                                                          (_ :
                                                            IsOpen
                                                              (↑(pullback.fst ≫
                                                                      t D.toGlueData k i ≫ f D.toGlueData i k).base ⁻¹'
                                                                ↑(op U).unop)) } }.unop).unop)) } }.unop) =
                      (Opens.map (t D.toGlueData j k).base).op.obj
                        (op
                          ((IsOpenImmersion.openFunctor (_ : IsOpenImmersion pullback.snd)).obj
                            {
                                unop :=
                                  {
                                    carrier :=
                                      ↑(pullback.fst ≫ t D.toGlueData k i ≫ f D.toGlueData i k).base ⁻¹' ↑(op U).unop,
                                    is_open' :=
                                      (_ :
                                        IsOpen
                                          (↑(pullback.fst ≫ t D.toGlueData k i ≫ f D.toGlueData i k).base ⁻¹'
                                            ↑(op U).unop)) } }.unop))) ≫
                (Opens.map (t D.toGlueData j k).base).op.map
                    (eqToHom
                      (_ :
                        op
                            ((IsOpenImmersion.openFunctor (_ : IsOpenImmersion pullback.snd)).obj
                              {
                                  unop :=
                                    {
                                      carrier :=
                                        ↑(pullback.fst ≫ t D.toGlueData k i ≫ f D.toGlueData i k).base ⁻¹' ↑(op U).unop,
                                      is_open' :=
                                        (_ :
                                          IsOpen
                                            (↑(pullback.fst ≫ t D.toGlueData k i ≫ f D.toGlueData i k).base ⁻¹'
                                              ↑(op U).unop)) } }.unop) =
                          (Opens.map (f D.toGlueData k j).base).op.obj
                            (op
                              ((Opens.map (ι D.toGlueData k).base).obj
                                ((IsOpenMap.functor (_ : IsOpenMap ↑(ι D.toGlueData i).base)).obj U))))) ≫
                  eqToHom
                    (_ :
                      (Opens.map
                                ((MultispanIndex.multispan (diagram D.toGlueData)).map
                                    (WalkingMultispan.Hom.snd (j, k)).op.unop).base).op.obj
                          (op
                            ((Opens.map
                                  (colimit.ι (MultispanIndex.multispan (diagram D.toGlueData))
                                      (op
                                          (WalkingMultispan.right
                                            (MultispanIndex.sndFrom (diagram D.toGlueData) (j, k)))).unop).base).obj
                              ((IsOpenMap.functor (_ : IsOpenMap ↑(ι D.toGlueData i).base)).obj U))) =
                        op
                          ((Opens.map
                                (colimit.ι (MultispanIndex.multispan (diagram D.toGlueData))
                                    (op (WalkingMultispan.left (j, k))).unop).base).obj
                            ((IsOpenMap.functor (_ : IsOpenMap ↑(ι D.toGlueData i).base)).obj U))))
[PROOFSTEP]
erw [← (D.V (j, k)).presheaf.map_comp]
  -- Porting note : was just `congr`
[GOAL]
case h.h.snd.mk.e_a
C : Type u
inst✝¹ : Category.{v, u} C
D : GlueData C
inst✝ : HasLimits C
i : D.J
U : Opens ↑↑(CategoryTheory.GlueData.U D.toGlueData i)
j k : D.J
this :
  t' D.toGlueData j k i ≫ pullback.fst ≫ t D.toGlueData k i ≫ f D.toGlueData i k =
    (pullbackSymmetry (f D.toGlueData j k) (f D.toGlueData j i)).hom ≫
      pullback.fst ≫ t D.toGlueData j i ≫ f D.toGlueData i j
⊢ (V D.toGlueData (j, k)).presheaf.map
      (eqToHom
          (_ :
            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)))) ≫
        eqToHom
          (_ :
            (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))) =
              op
                ((Opens.map
                      (colimit.ι (MultispanIndex.multispan (diagram D.toGlueData))
                          (op (WalkingMultispan.left (j, k))).unop).base).obj
                  ((IsOpenMap.functor (_ : IsOpenMap ↑(ι D.toGlueData i).base)).obj U)))) =
    (V D.toGlueData (j, k)).presheaf.map
        (homOfLE
            (_ :
              ↑pullback.fst.base ''
                  (↑pullback.fst.base ⁻¹'
                    ((IsOpenImmersion.openFunctor (_ : IsOpenImmersion pullback.snd)).obj
                        { 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)) }).carrier) ⊆
                ((IsOpenImmersion.openFunctor (_ : IsOpenImmersion pullback.snd)).obj
                    { 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)) }).carrier)).op ≫
      (V D.toGlueData (j, k)).presheaf.map
        ((IsOpenImmersion.openFunctor (_ : IsOpenImmersion pullback.fst)).op.map
            (eqToHom
              (_ :
                (Opens.map pullback.fst.base).op.obj
                    (op
                      ((IsOpenImmersion.openFunctor (_ : IsOpenImmersion pullback.snd)).obj
                        { 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)) })) =
                  (Opens.map
                          ((pullbackSymmetry (f D.toGlueData j k) (f D.toGlueData j i)).hom ≫ pullback.snd).base).op.obj
                    (op
                      ((IsOpenImmersion.openFunctor (_ : IsOpenImmersion pullback.snd)).obj
                        { 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)) })))) ≫
          (IsOpenImmersion.openFunctor (_ : IsOpenImmersion pullback.fst)).op.map
              ((Opens.map (pullbackSymmetry (f D.toGlueData j k) (f D.toGlueData j i)).hom.base).op.map
                (eqToHom
                  (_ :
                    op
                        ((Opens.map pullback.snd.base).obj
                          (op
                              ((IsOpenImmersion.openFunctor (_ : IsOpenImmersion pullback.snd)).obj
                                {
                                  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) =
                      op
                        { 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)) }))) ≫
            (IsOpenImmersion.openFunctor (_ : IsOpenImmersion pullback.fst)).op.map
                (eqToHom
                  (_ :
                    (Opens.map
                              ((pullbackSymmetry (f D.toGlueData j k) (f D.toGlueData j i)).hom ≫
                                  pullback.fst ≫ t D.toGlueData j i ≫ f D.toGlueData i j).base).op.obj
                        (op U) =
                      (Opens.map
                              (t' D.toGlueData j k i ≫
                                  pullback.fst ≫ t D.toGlueData k i ≫ f D.toGlueData i k).base).op.obj
                        (op U))) ≫
              eqToHom
                  (_ :
                    op
                        ((IsOpenImmersion.openFunctor (_ : IsOpenImmersion pullback.fst)).obj
                          {
                              unop :=
                                {
                                  carrier :=
                                    ↑(t' D.toGlueData j k i).base ⁻¹'
                                      ↑(op
                                            {
                                                unop :=
                                                  {
                                                    carrier :=
                                                      ↑(pullback.fst ≫ t D.toGlueData k i ≫ f D.toGlueData i k).base ⁻¹'
                                                        ↑(op U).unop,
                                                    is_open' :=
                                                      (_ :
                                                        IsOpen
                                                          (↑(pullback.fst ≫
                                                                  t D.toGlueData k i ≫ f D.toGlueData i k).base ⁻¹'
                                                            ↑(op U).unop)) } }.unop).unop,
                                  is_open' :=
                                    (_ :
                                      IsOpen
                                        (↑(t' D.toGlueData j k i).base ⁻¹'
                                          ↑(op
                                                {
                                                    unop :=
                                                      {
                                                        carrier :=
                                                          ↑(pullback.fst ≫
                                                                  t D.toGlueData k i ≫ f D.toGlueData i k).base ⁻¹'
                                                            ↑(op U).unop,
                                                        is_open' :=
                                                          (_ :
                                                            IsOpen
                                                              (↑(pullback.fst ≫
                                                                      t D.toGlueData k i ≫ f D.toGlueData i k).base ⁻¹'
                                                                ↑(op U).unop)) } }.unop).unop)) } }.unop) =
                      (Opens.map (t D.toGlueData j k).base).op.obj
                        (op
                          ((IsOpenImmersion.openFunctor (_ : IsOpenImmersion pullback.snd)).obj
                            {
                                unop :=
                                  {
                                    carrier :=
                                      ↑(pullback.fst ≫ t D.toGlueData k i ≫ f D.toGlueData i k).base ⁻¹' ↑(op U).unop,
                                    is_open' :=
                                      (_ :
                                        IsOpen
                                          (↑(pullback.fst ≫ t D.toGlueData k i ≫ f D.toGlueData i k).base ⁻¹'
                                            ↑(op U).unop)) } }.unop))) ≫
                (Opens.map (t D.toGlueData j k).base).op.map
                    (eqToHom
                      (_ :
                        op
                            ((IsOpenImmersion.openFunctor (_ : IsOpenImmersion pullback.snd)).obj
                              {
                                  unop :=
                                    {
                                      carrier :=
                                        ↑(pullback.fst ≫ t D.toGlueData k i ≫ f D.toGlueData i k).base ⁻¹' ↑(op U).unop,
                                      is_open' :=
                                        (_ :
                                          IsOpen
                                            (↑(pullback.fst ≫ t D.toGlueData k i ≫ f D.toGlueData i k).base ⁻¹'
                                              ↑(op U).unop)) } }.unop) =
                          (Opens.map (f D.toGlueData k j).base).op.obj
                            (op
                              ((Opens.map (ι D.toGlueData k).base).obj
                                ((IsOpenMap.functor (_ : IsOpenMap ↑(ι D.toGlueData i).base)).obj U))))) ≫
                  eqToHom
                    (_ :
                      (Opens.map
                                ((MultispanIndex.multispan (diagram D.toGlueData)).map
                                    (WalkingMultispan.Hom.snd (j, k)).op.unop).base).op.obj
                          (op
                            ((Opens.map
                                  (colimit.ι (MultispanIndex.multispan (diagram D.toGlueData))
                                      (op
                                          (WalkingMultispan.right
                                            (MultispanIndex.sndFrom (diagram D.toGlueData) (j, k)))).unop).base).obj
                              ((IsOpenMap.functor (_ : IsOpenMap ↑(ι D.toGlueData i).base)).obj U))) =
                        op
                          ((Opens.map
                                (colimit.ι (MultispanIndex.multispan (diagram D.toGlueData))
                                    (op (WalkingMultispan.left (j, k))).unop).base).obj
                            ((IsOpenMap.functor (_ : IsOpenMap ↑(ι D.toGlueData i).base)).obj U))))
[PROOFSTEP]
erw [← (D.V (j, k)).presheaf.map_comp]
  -- Porting note : was just `congr`
[GOAL]
case h.h.snd.mk.e_a
C : Type u
inst✝¹ : Category.{v, u} C
D : GlueData C
inst✝ : HasLimits C
i : D.J
U : Opens ↑↑(CategoryTheory.GlueData.U D.toGlueData i)
j k : D.J
this :
  t' D.toGlueData j k i ≫ pullback.fst ≫ t D.toGlueData k i ≫ f D.toGlueData i k =
    (pullbackSymmetry (f D.toGlueData j k) (f D.toGlueData j i)).hom ≫
      pullback.fst ≫ t D.toGlueData j i ≫ f D.toGlueData i j
⊢ (V D.toGlueData (j, k)).presheaf.map
      (eqToHom
          (_ :
            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)))) ≫
        eqToHom
          (_ :
            (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))) =
              op
                ((Opens.map
                      (colimit.ι (MultispanIndex.multispan (diagram D.toGlueData))
                          (op (WalkingMultispan.left (j, k))).unop).base).obj
                  ((IsOpenMap.functor (_ : IsOpenMap ↑(ι D.toGlueData i).base)).obj U)))) =
    (V D.toGlueData (j, k)).presheaf.map
      ((homOfLE
            (_ :
              ↑pullback.fst.base ''
                  (↑pullback.fst.base ⁻¹'
                    ((IsOpenImmersion.openFunctor (_ : IsOpenImmersion pullback.snd)).obj
                        { 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)) }).carrier) ⊆
                ((IsOpenImmersion.openFunctor (_ : IsOpenImmersion pullback.snd)).obj
                    { 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)) }).carrier)).op ≫
        (IsOpenImmersion.openFunctor (_ : IsOpenImmersion pullback.fst)).op.map
            (eqToHom
              (_ :
                (Opens.map pullback.fst.base).op.obj
                    (op
                      ((IsOpenImmersion.openFunctor (_ : IsOpenImmersion pullback.snd)).obj
                        { 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)) })) =
                  (Opens.map
                          ((pullbackSymmetry (f D.toGlueData j k) (f D.toGlueData j i)).hom ≫ pullback.snd).base).op.obj
                    (op
                      ((IsOpenImmersion.openFunctor (_ : IsOpenImmersion pullback.snd)).obj
                        { 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)) })))) ≫
          (IsOpenImmersion.openFunctor (_ : IsOpenImmersion pullback.fst)).op.map
              ((Opens.map (pullbackSymmetry (f D.toGlueData j k) (f D.toGlueData j i)).hom.base).op.map
                (eqToHom
                  (_ :
                    op
                        ((Opens.map pullback.snd.base).obj
                          (op
                              ((IsOpenImmersion.openFunctor (_ : IsOpenImmersion pullback.snd)).obj
                                {
                                  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) =
                      op
                        { 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)) }))) ≫
            (IsOpenImmersion.openFunctor (_ : IsOpenImmersion pullback.fst)).op.map
                (eqToHom
                  (_ :
                    (Opens.map
                              ((pullbackSymmetry (f D.toGlueData j k) (f D.toGlueData j i)).hom ≫
                                  pullback.fst ≫ t D.toGlueData j i ≫ f D.toGlueData i j).base).op.obj
                        (op U) =
                      (Opens.map
                              (t' D.toGlueData j k i ≫
                                  pullback.fst ≫ t D.toGlueData k i ≫ f D.toGlueData i k).base).op.obj
                        (op U))) ≫
              eqToHom
                  (_ :
                    op
                        ((IsOpenImmersion.openFunctor (_ : IsOpenImmersion pullback.fst)).obj
                          {
                              unop :=
                                {
                                  carrier :=
                                    ↑(t' D.toGlueData j k i).base ⁻¹'
                                      ↑(op
                                            {
                                                unop :=
                                                  {
                                                    carrier :=
                                                      ↑(pullback.fst ≫ t D.toGlueData k i ≫ f D.toGlueData i k).base ⁻¹'
                                                        ↑(op U).unop,
                                                    is_open' :=
                                                      (_ :
                                                        IsOpen
                                                          (↑(pullback.fst ≫
                                                                  t D.toGlueData k i ≫ f D.toGlueData i k).base ⁻¹'
                                                            ↑(op U).unop)) } }.unop).unop,
                                  is_open' :=
                                    (_ :
                                      IsOpen
                                        (↑(t' D.toGlueData j k i).base ⁻¹'
                                          ↑(op
                                                {
                                                    unop :=
                                                      {
                                                        carrier :=
                                                          ↑(pullback.fst ≫
                                                                  t D.toGlueData k i ≫ f D.toGlueData i k).base ⁻¹'
                                                            ↑(op U).unop,
                                                        is_open' :=
                                                          (_ :
                                                            IsOpen
                                                              (↑(pullback.fst ≫
                                                                      t D.toGlueData k i ≫ f D.toGlueData i k).base ⁻¹'
                                                                ↑(op U).unop)) } }.unop).unop)) } }.unop) =
                      (Opens.map (t D.toGlueData j k).base).op.obj
                        (op
                          ((IsOpenImmersion.openFunctor (_ : IsOpenImmersion pullback.snd)).obj
                            {
                                unop :=
                                  {
                                    carrier :=
                                      ↑(pullback.fst ≫ t D.toGlueData k i ≫ f D.toGlueData i k).base ⁻¹' ↑(op U).unop,
                                    is_open' :=
                                      (_ :
                                        IsOpen
                                          (↑(pullback.fst ≫ t D.toGlueData k i ≫ f D.toGlueData i k).base ⁻¹'
                                            ↑(op U).unop)) } }.unop))) ≫
                (Opens.map (t D.toGlueData j k).base).op.map
                    (eqToHom
                      (_ :
                        op
                            ((IsOpenImmersion.openFunctor (_ : IsOpenImmersion pullback.snd)).obj
                              {
                                  unop :=
                                    {
                                      carrier :=
                                        ↑(pullback.fst ≫ t D.toGlueData k i ≫ f D.toGlueData i k).base ⁻¹' ↑(op U).unop,
                                      is_open' :=
                                        (_ :
                                          IsOpen
                                            (↑(pullback.fst ≫ t D.toGlueData k i ≫ f D.toGlueData i k).base ⁻¹'
                                              ↑(op U).unop)) } }.unop) =
                          (Opens.map (f D.toGlueData k j).base).op.obj
                            (op
                              ((Opens.map (ι D.toGlueData k).base).obj
                                ((IsOpenMap.functor (_ : IsOpenMap ↑(ι D.toGlueData i).base)).obj U))))) ≫
                  eqToHom
                    (_ :
                      (Opens.map
                                ((MultispanIndex.multispan (diagram D.toGlueData)).map
                                    (WalkingMultispan.Hom.snd (j, k)).op.unop).base).op.obj
                          (op
                            ((Opens.map
                                  (colimit.ι (MultispanIndex.multispan (diagram D.toGlueData))
                                      (op
                                          (WalkingMultispan.right
                                            (MultispanIndex.sndFrom (diagram D.toGlueData) (j, k)))).unop).base).obj
                              ((IsOpenMap.functor (_ : IsOpenMap ↑(ι D.toGlueData i).base)).obj U))) =
                        op
                          ((Opens.map
                                (colimit.ι (MultispanIndex.multispan (diagram D.toGlueData))
                                    (op (WalkingMultispan.left (j, k))).unop).base).obj
                            ((IsOpenMap.functor (_ : IsOpenMap ↑(ι D.toGlueData i).base)).obj U))))
[PROOFSTEP]
erw [← (D.V (j, k)).presheaf.map_comp]
  -- Porting note : was just `congr`
[GOAL]
case h.h.snd.mk.e_a
C : Type u
inst✝¹ : Category.{v, u} C
D : GlueData C
inst✝ : HasLimits C
i : D.J
U : Opens ↑↑(CategoryTheory.GlueData.U D.toGlueData i)
j k : D.J
this :
  t' D.toGlueData j k i ≫ pullback.fst ≫ t D.toGlueData k i ≫ f D.toGlueData i k =
    (pullbackSymmetry (f D.toGlueData j k) (f D.toGlueData j i)).hom ≫
      pullback.fst ≫ t D.toGlueData j i ≫ f D.toGlueData i j
⊢ (V D.toGlueData (j, k)).presheaf.map
      (eqToHom
          (_ :
            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)))) ≫
        eqToHom
          (_ :
            (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))) =
              op
                ((Opens.map
                      (colimit.ι (MultispanIndex.multispan (diagram D.toGlueData))
                          (op (WalkingMultispan.left (j, k))).unop).base).obj
                  ((IsOpenMap.functor (_ : IsOpenMap ↑(ι D.toGlueData i).base)).obj U)))) =
    (V D.toGlueData (j, k)).presheaf.map
      ((homOfLE
            (_ :
              ↑pullback.fst.base ''
                  (↑pullback.fst.base ⁻¹'
                    ((IsOpenImmersion.openFunctor (_ : IsOpenImmersion pullback.snd)).obj
                        { 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)) }).carrier) ⊆
                ((IsOpenImmersion.openFunctor (_ : IsOpenImmersion pullback.snd)).obj
                    { 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)) }).carrier)).op ≫
        (IsOpenImmersion.openFunctor (_ : IsOpenImmersion pullback.fst)).op.map
            (eqToHom
              (_ :
                (Opens.map pullback.fst.base).op.obj
                    (op
                      ((IsOpenImmersion.openFunctor (_ : IsOpenImmersion pullback.snd)).obj
                        { 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)) })) =
                  (Opens.map
                          ((pullbackSymmetry (f D.toGlueData j k) (f D.toGlueData j i)).hom ≫ pullback.snd).base).op.obj
                    (op
                      ((IsOpenImmersion.openFunctor (_ : IsOpenImmersion pullback.snd)).obj
                        { 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)) })))) ≫
          (IsOpenImmersion.openFunctor (_ : IsOpenImmersion pullback.fst)).op.map
              ((Opens.map (pullbackSymmetry (f D.toGlueData j k) (f D.toGlueData j i)).hom.base).op.map
                (eqToHom
                  (_ :
                    op
                        ((Opens.map pullback.snd.base).obj
                          (op
                              ((IsOpenImmersion.openFunctor (_ : IsOpenImmersion pullback.snd)).obj
                                {
                                  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) =
                      op
                        { 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)) }))) ≫
            (IsOpenImmersion.openFunctor (_ : IsOpenImmersion pullback.fst)).op.map
                (eqToHom
                  (_ :
                    (Opens.map
                              ((pullbackSymmetry (f D.toGlueData j k) (f D.toGlueData j i)).hom ≫
                                  pullback.fst ≫ t D.toGlueData j i ≫ f D.toGlueData i j).base).op.obj
                        (op U) =
                      (Opens.map
                              (t' D.toGlueData j k i ≫
                                  pullback.fst ≫ t D.toGlueData k i ≫ f D.toGlueData i k).base).op.obj
                        (op U))) ≫
              eqToHom
                  (_ :
                    op
                        ((IsOpenImmersion.openFunctor (_ : IsOpenImmersion pullback.fst)).obj
                          {
                              unop :=
                                {
                                  carrier :=
                                    ↑(t' D.toGlueData j k i).base ⁻¹'
                                      ↑(op
                                            {
                                                unop :=
                                                  {
                                                    carrier :=
                                                      ↑(pullback.fst ≫ t D.toGlueData k i ≫ f D.toGlueData i k).base ⁻¹'
                                                        ↑(op U).unop,
                                                    is_open' :=
                                                      (_ :
                                                        IsOpen
                                                          (↑(pullback.fst ≫
                                                                  t D.toGlueData k i ≫ f D.toGlueData i k).base ⁻¹'
                                                            ↑(op U).unop)) } }.unop).unop,
                                  is_open' :=
                                    (_ :
                                      IsOpen
                                        (↑(t' D.toGlueData j k i).base ⁻¹'
                                          ↑(op
                                                {
                                                    unop :=
                                                      {
                                                        carrier :=
                                                          ↑(pullback.fst ≫
                                                                  t D.toGlueData k i ≫ f D.toGlueData i k).base ⁻¹'
                                                            ↑(op U).unop,
                                                        is_open' :=
                                                          (_ :
                                                            IsOpen
                                                              (↑(pullback.fst ≫
                                                                      t D.toGlueData k i ≫ f D.toGlueData i k).base ⁻¹'
                                                                ↑(op U).unop)) } }.unop).unop)) } }.unop) =
                      (Opens.map (t D.toGlueData j k).base).op.obj
                        (op
                          ((IsOpenImmersion.openFunctor (_ : IsOpenImmersion pullback.snd)).obj
                            {
                                unop :=
                                  {
                                    carrier :=
                                      ↑(pullback.fst ≫ t D.toGlueData k i ≫ f D.toGlueData i k).base ⁻¹' ↑(op U).unop,
                                    is_open' :=
                                      (_ :
                                        IsOpen
                                          (↑(pullback.fst ≫ t D.toGlueData k i ≫ f D.toGlueData i k).base ⁻¹'
                                            ↑(op U).unop)) } }.unop))) ≫
                (Opens.map (t D.toGlueData j k).base).op.map
                    (eqToHom
                      (_ :
                        op
                            ((IsOpenImmersion.openFunctor (_ : IsOpenImmersion pullback.snd)).obj
                              {
                                  unop :=
                                    {
                                      carrier :=
                                        ↑(pullback.fst ≫ t D.toGlueData k i ≫ f D.toGlueData i k).base ⁻¹' ↑(op U).unop,
                                      is_open' :=
                                        (_ :
                                          IsOpen
                                            (↑(pullback.fst ≫ t D.toGlueData k i ≫ f D.toGlueData i k).base ⁻¹'
                                              ↑(op U).unop)) } }.unop) =
                          (Opens.map (f D.toGlueData k j).base).op.obj
                            (op
                              ((Opens.map (ι D.toGlueData k).base).obj
                                ((IsOpenMap.functor (_ : IsOpenMap ↑(ι D.toGlueData i).base)).obj U))))) ≫
                  eqToHom
                    (_ :
                      (Opens.map
                                ((MultispanIndex.multispan (diagram D.toGlueData)).map
                                    (WalkingMultispan.Hom.snd (j, k)).op.unop).base).op.obj
                          (op
                            ((Opens.map
                                  (colimit.ι (MultispanIndex.multispan (diagram D.toGlueData))
                                      (op
                                          (WalkingMultispan.right
                                            (MultispanIndex.sndFrom (diagram D.toGlueData) (j, k)))).unop).base).obj
                              ((IsOpenMap.functor (_ : IsOpenMap ↑(ι D.toGlueData i).base)).obj U))) =
                        op
                          ((Opens.map
                                (colimit.ι (MultispanIndex.multispan (diagram D.toGlueData))
                                    (op (WalkingMultispan.left (j, k))).unop).base).obj
                            ((IsOpenMap.functor (_ : IsOpenMap ↑(ι D.toGlueData i).base)).obj U))))
[PROOFSTEP]
exact congr_arg ((D.V (j, k)).presheaf.map ·) rfl
[GOAL]
C : Type u
inst✝¹ : Category.{v, u} C
D : GlueData C
inst✝ : HasLimits C
i : D.J
U : Opens ↑↑(CategoryTheory.GlueData.U D.toGlueData i)
⊢ ∃ eq, ιInvApp D U ≫ diagramOverOpenπ D U i = (CategoryTheory.GlueData.U D.toGlueData i).presheaf.map (eqToHom eq)
[PROOFSTEP]
fconstructor
  -- Porting note: I don't know what the magic was in Lean3 proof, it just skipped the proof of `eq`
[GOAL]
case w
C : Type u
inst✝¹ : Category.{v, u} C
D : GlueData C
inst✝ : HasLimits C
i : D.J
U : Opens ↑↑(CategoryTheory.GlueData.U D.toGlueData i)
⊢ op U =
    op
      ((Opens.map
            (colimit.ι (MultispanIndex.multispan (diagram D.toGlueData)) (op (WalkingMultispan.right i)).unop).base).obj
        ((IsOpenMap.functor (_ : IsOpenMap ↑(ι D.toGlueData i).base)).obj U))
[PROOFSTEP]
congr
[GOAL]
case w.e_x
C : Type u
inst✝¹ : Category.{v, u} C
D : GlueData C
inst✝ : HasLimits C
i : D.J
U : Opens ↑↑(CategoryTheory.GlueData.U D.toGlueData i)
⊢ U =
    (Opens.map
          (colimit.ι (MultispanIndex.multispan (diagram D.toGlueData)) (op (WalkingMultispan.right i)).unop).base).obj
      ((IsOpenMap.functor (_ : IsOpenMap ↑(ι D.toGlueData i).base)).obj U)
[PROOFSTEP]
ext1
[GOAL]
case w.e_x.h
C : Type u
inst✝¹ : Category.{v, u} C
D : GlueData C
inst✝ : HasLimits C
i : D.J
U : Opens ↑↑(CategoryTheory.GlueData.U D.toGlueData i)
⊢ ↑U =
    ↑((Opens.map
            (colimit.ι (MultispanIndex.multispan (diagram D.toGlueData)) (op (WalkingMultispan.right i)).unop).base).obj
        ((IsOpenMap.functor (_ : IsOpenMap ↑(ι D.toGlueData i).base)).obj U))
[PROOFSTEP]
change _ = _ ⁻¹' (_ '' _)
[GOAL]
case w.e_x.h
C : Type u
inst✝¹ : Category.{v, u} C
D : GlueData C
inst✝ : HasLimits C
i : D.J
U : Opens ↑↑(CategoryTheory.GlueData.U D.toGlueData i)
⊢ ↑U =
    (fun x =>
        ↑(colimit.ι (MultispanIndex.multispan (diagram D.toGlueData)) (op (WalkingMultispan.right i)).unop).base x) ⁻¹'
      ((fun a => ↑(ι D.toGlueData i).base a) '' ↑U)
[PROOFSTEP]
ext1 x
[GOAL]
case w.e_x.h.h
C : Type u
inst✝¹ : Category.{v, u} C
D : GlueData C
inst✝ : HasLimits C
i : D.J
U : Opens ↑↑(CategoryTheory.GlueData.U D.toGlueData i)
x : ↑↑(CategoryTheory.GlueData.U D.toGlueData i)
⊢ x ∈ ↑U ↔
    x ∈
      (fun x =>
          ↑(colimit.ι (MultispanIndex.multispan (diagram D.toGlueData)) (op (WalkingMultispan.right i)).unop).base
            x) ⁻¹'
        ((fun a => ↑(ι D.toGlueData i).base a) '' ↑U)
[PROOFSTEP]
simp only [SetLike.mem_coe, diagram_l, diagram_r, unop_op, Set.mem_preimage, Set.mem_image]
[GOAL]
case w.e_x.h.h
C : Type u
inst✝¹ : Category.{v, u} C
D : GlueData C
inst✝ : HasLimits C
i : D.J
U : Opens ↑↑(CategoryTheory.GlueData.U D.toGlueData i)
x : ↑↑(CategoryTheory.GlueData.U D.toGlueData i)
⊢ x ∈ U ↔
    ∃ x_1,
      x_1 ∈ U ∧
        ↑(ι D.toGlueData i).base x_1 =
          ↑(colimit.ι (MultispanIndex.multispan (diagram D.toGlueData)) (WalkingMultispan.right i)).base x
[PROOFSTEP]
refine ⟨fun h => ⟨_, h, rfl⟩, ?_⟩
[GOAL]
case w.e_x.h.h
C : Type u
inst✝¹ : Category.{v, u} C
D : GlueData C
inst✝ : HasLimits C
i : D.J
U : Opens ↑↑(CategoryTheory.GlueData.U D.toGlueData i)
x : ↑↑(CategoryTheory.GlueData.U D.toGlueData i)
⊢ (∃ x_1,
      x_1 ∈ U ∧
        ↑(ι D.toGlueData i).base x_1 =
          ↑(colimit.ι (MultispanIndex.multispan (diagram D.toGlueData)) (WalkingMultispan.right i)).base x) →
    x ∈ U
[PROOFSTEP]
rintro ⟨y, h1, h2⟩
[GOAL]
case w.e_x.h.h.intro.intro
C : Type u
inst✝¹ : Category.{v, u} C
D : GlueData C
inst✝ : HasLimits C
i : D.J
U : Opens ↑↑(CategoryTheory.GlueData.U D.toGlueData i)
x : ↑↑(CategoryTheory.GlueData.U D.toGlueData i)
y : (CategoryTheory.forget TopCat).obj ↑(CategoryTheory.GlueData.U D.toGlueData i)
h1 : y ∈ U
h2 :
  ↑(ι D.toGlueData i).base y =
    ↑(colimit.ι (MultispanIndex.multispan (diagram D.toGlueData)) (WalkingMultispan.right i)).base x
⊢ x ∈ U
[PROOFSTEP]
convert h1 using 1
[GOAL]
case h.e'_4.h
C : Type u
inst✝¹ : Category.{v, u} C
D : GlueData C
inst✝ : HasLimits C
i : D.J
U : Opens ↑↑(CategoryTheory.GlueData.U D.toGlueData i)
x : ↑↑(CategoryTheory.GlueData.U D.toGlueData i)
y : (CategoryTheory.forget TopCat).obj ↑(CategoryTheory.GlueData.U D.toGlueData i)
h1 : y ∈ U
h2 :
  ↑(ι D.toGlueData i).base y =
    ↑(colimit.ι (MultispanIndex.multispan (diagram D.toGlueData)) (WalkingMultispan.right i)).base x
e_1✝ :
  ↑↑(CategoryTheory.GlueData.U D.toGlueData i) =
    (CategoryTheory.forget TopCat).obj ↑(CategoryTheory.GlueData.U D.toGlueData i)
⊢ x = y
[PROOFSTEP]
delta ι Multicoequalizer.π at h2
[GOAL]
case h.e'_4.h
C : Type u
inst✝¹ : Category.{v, u} C
D : GlueData C
inst✝ : HasLimits C
i : D.J
U : Opens ↑↑(CategoryTheory.GlueData.U D.toGlueData i)
x : ↑↑(CategoryTheory.GlueData.U D.toGlueData i)
y : (CategoryTheory.forget TopCat).obj ↑(CategoryTheory.GlueData.U D.toGlueData i)
h1 : y ∈ U
h2 :
  ↑(colimit.ι (MultispanIndex.multispan (diagram D.toGlueData)) (WalkingMultispan.right i)).base y =
    ↑(colimit.ι (MultispanIndex.multispan (diagram D.toGlueData)) (WalkingMultispan.right i)).base x
e_1✝ :
  ↑↑(CategoryTheory.GlueData.U D.toGlueData i) =
    (CategoryTheory.forget TopCat).obj ↑(CategoryTheory.GlueData.U D.toGlueData i)
⊢ x = y
[PROOFSTEP]
apply_fun (D.ι _).base
[GOAL]
case h.e'_4.h
C : Type u
inst✝¹ : Category.{v, u} C
D : GlueData C
inst✝ : HasLimits C
i : D.J
U : Opens ↑↑(CategoryTheory.GlueData.U D.toGlueData i)
x : ↑↑(CategoryTheory.GlueData.U D.toGlueData i)
y : (CategoryTheory.forget TopCat).obj ↑(CategoryTheory.GlueData.U D.toGlueData i)
h1 : y ∈ U
h2 :
  ↑(colimit.ι (MultispanIndex.multispan (diagram D.toGlueData)) (WalkingMultispan.right i)).base y =
    ↑(colimit.ι (MultispanIndex.multispan (diagram D.toGlueData)) (WalkingMultispan.right i)).base x
e_1✝ :
  ↑↑(CategoryTheory.GlueData.U D.toGlueData i) =
    (CategoryTheory.forget TopCat).obj ↑(CategoryTheory.GlueData.U D.toGlueData i)
⊢ ↑(ι D.toGlueData i).base x = ↑(ι D.toGlueData i).base y
[PROOFSTEP]
exact h2.symm
[GOAL]
case h.e'_4.h.inj
C : Type u
inst✝¹ : Category.{v, u} C
D : GlueData C
inst✝ : HasLimits C
i : D.J
U : Opens ↑↑(CategoryTheory.GlueData.U D.toGlueData i)
x : ↑↑(CategoryTheory.GlueData.U D.toGlueData i)
y : (CategoryTheory.forget TopCat).obj ↑(CategoryTheory.GlueData.U D.toGlueData i)
h1 : y ∈ U
h2 :
  ↑(colimit.ι (MultispanIndex.multispan (diagram D.toGlueData)) (WalkingMultispan.right i)).base y =
    ↑(colimit.ι (MultispanIndex.multispan (diagram D.toGlueData)) (WalkingMultispan.right i)).base x
e_1✝ :
  ↑↑(CategoryTheory.GlueData.U D.toGlueData i) =
    (CategoryTheory.forget TopCat).obj ↑(CategoryTheory.GlueData.U D.toGlueData i)
⊢ Function.Injective ↑(ι D.toGlueData i).base
[PROOFSTEP]
have := D.ι_gluedIso_inv (PresheafedSpace.forget _) i
[GOAL]
case h.e'_4.h.inj
C : Type u
inst✝¹ : Category.{v, u} C
D : GlueData C
inst✝ : HasLimits C
i : D.J
U : Opens ↑↑(CategoryTheory.GlueData.U D.toGlueData i)
x : ↑↑(CategoryTheory.GlueData.U D.toGlueData i)
y : (CategoryTheory.forget TopCat).obj ↑(CategoryTheory.GlueData.U D.toGlueData i)
h1 : y ∈ U
h2 :
  ↑(colimit.ι (MultispanIndex.multispan (diagram D.toGlueData)) (WalkingMultispan.right i)).base y =
    ↑(colimit.ι (MultispanIndex.multispan (diagram D.toGlueData)) (WalkingMultispan.right i)).base x
e_1✝ :
  ↑↑(CategoryTheory.GlueData.U D.toGlueData i) =
    (CategoryTheory.forget TopCat).obj ↑(CategoryTheory.GlueData.U D.toGlueData i)
this :
  ι (mapGlueData D.toGlueData (forget C)) i ≫ (gluedIso D.toGlueData (forget C)).inv = (forget C).map (ι D.toGlueData i)
⊢ Function.Injective ↑(ι D.toGlueData i).base
[PROOFSTEP]
dsimp at this
[GOAL]
case h.e'_4.h.inj
C : Type u
inst✝¹ : Category.{v, u} C
D : GlueData C
inst✝ : HasLimits C
i : D.J
U : Opens ↑↑(CategoryTheory.GlueData.U D.toGlueData i)
x : ↑↑(CategoryTheory.GlueData.U D.toGlueData i)
y : (CategoryTheory.forget TopCat).obj ↑(CategoryTheory.GlueData.U D.toGlueData i)
h1 : y ∈ U
h2 :
  ↑(colimit.ι (MultispanIndex.multispan (diagram D.toGlueData)) (WalkingMultispan.right i)).base y =
    ↑(colimit.ι (MultispanIndex.multispan (diagram D.toGlueData)) (WalkingMultispan.right i)).base x
e_1✝ :
  ↑↑(CategoryTheory.GlueData.U D.toGlueData i) =
    (CategoryTheory.forget TopCat).obj ↑(CategoryTheory.GlueData.U D.toGlueData i)
this : ι (mapGlueData D.toGlueData (forget C)) i ≫ (gluedIso D.toGlueData (forget C)).inv = (ι D.toGlueData i).base
⊢ Function.Injective ↑(ι D.toGlueData i).base
[PROOFSTEP]
rw [← this, coe_comp]
[GOAL]
case h.e'_4.h.inj
C : Type u
inst✝¹ : Category.{v, u} C
D : GlueData C
inst✝ : HasLimits C
i : D.J
U : Opens ↑↑(CategoryTheory.GlueData.U D.toGlueData i)
x : ↑↑(CategoryTheory.GlueData.U D.toGlueData i)
y : (CategoryTheory.forget TopCat).obj ↑(CategoryTheory.GlueData.U D.toGlueData i)
h1 : y ∈ U
h2 :
  ↑(colimit.ι (MultispanIndex.multispan (diagram D.toGlueData)) (WalkingMultispan.right i)).base y =
    ↑(colimit.ι (MultispanIndex.multispan (diagram D.toGlueData)) (WalkingMultispan.right i)).base x
e_1✝ :
  ↑↑(CategoryTheory.GlueData.U D.toGlueData i) =
    (CategoryTheory.forget TopCat).obj ↑(CategoryTheory.GlueData.U D.toGlueData i)
this : ι (mapGlueData D.toGlueData (forget C)) i ≫ (gluedIso D.toGlueData (forget C)).inv = (ι D.toGlueData i).base
⊢ Function.Injective (↑(gluedIso D.toGlueData (forget C)).inv ∘ ↑(ι (mapGlueData D.toGlueData (forget C)) i))
[PROOFSTEP]
refine Function.Injective.comp ?_ (TopCat.GlueData.ι_injective D.toTopGlueData i)
[GOAL]
case h.e'_4.h.inj
C : Type u
inst✝¹ : Category.{v, u} C
D : GlueData C
inst✝ : HasLimits C
i : D.J
U : Opens ↑↑(CategoryTheory.GlueData.U D.toGlueData i)
x : ↑↑(CategoryTheory.GlueData.U D.toGlueData i)
y : (CategoryTheory.forget TopCat).obj ↑(CategoryTheory.GlueData.U D.toGlueData i)
h1 : y ∈ U
h2 :
  ↑(colimit.ι (MultispanIndex.multispan (diagram D.toGlueData)) (WalkingMultispan.right i)).base y =
    ↑(colimit.ι (MultispanIndex.multispan (diagram D.toGlueData)) (WalkingMultispan.right i)).base x
e_1✝ :
  ↑↑(CategoryTheory.GlueData.U D.toGlueData i) =
    (CategoryTheory.forget TopCat).obj ↑(CategoryTheory.GlueData.U D.toGlueData i)
this : ι (mapGlueData D.toGlueData (forget C)) i ≫ (gluedIso D.toGlueData (forget C)).inv = (ι D.toGlueData i).base
⊢ Function.Injective ↑(gluedIso D.toGlueData (forget C)).inv
[PROOFSTEP]
rw [← TopCat.mono_iff_injective]
[GOAL]
case h.e'_4.h.inj
C : Type u
inst✝¹ : Category.{v, u} C
D : GlueData C
inst✝ : HasLimits C
i : D.J
U : Opens ↑↑(CategoryTheory.GlueData.U D.toGlueData i)
x : ↑↑(CategoryTheory.GlueData.U D.toGlueData i)
y : (CategoryTheory.forget TopCat).obj ↑(CategoryTheory.GlueData.U D.toGlueData i)
h1 : y ∈ U
h2 :
  ↑(colimit.ι (MultispanIndex.multispan (diagram D.toGlueData)) (WalkingMultispan.right i)).base y =
    ↑(colimit.ι (MultispanIndex.multispan (diagram D.toGlueData)) (WalkingMultispan.right i)).base x
e_1✝ :
  ↑↑(CategoryTheory.GlueData.U D.toGlueData i) =
    (CategoryTheory.forget TopCat).obj ↑(CategoryTheory.GlueData.U D.toGlueData i)
this : ι (mapGlueData D.toGlueData (forget C)) i ≫ (gluedIso D.toGlueData (forget C)).inv = (ι D.toGlueData i).base
⊢ Mono (gluedIso D.toGlueData (forget C)).inv
[PROOFSTEP]
infer_instance
[GOAL]
case h
C : Type u
inst✝¹ : Category.{v, u} C
D : GlueData C
inst✝ : HasLimits C
i : D.J
U : Opens ↑↑(CategoryTheory.GlueData.U D.toGlueData i)
⊢ ιInvApp D U ≫ diagramOverOpenπ D U i =
    (CategoryTheory.GlueData.U D.toGlueData i).presheaf.map
      (eqToHom
        (_ :
          op U =
            op
              ((Opens.map
                    (colimit.ι (MultispanIndex.multispan (diagram D.toGlueData))
                        (op (WalkingMultispan.right i)).unop).base).obj
                ((IsOpenMap.functor (_ : IsOpenMap ↑(ι D.toGlueData i).base)).obj U))))
[PROOFSTEP]
delta ιInvApp
[GOAL]
case h
C : Type u
inst✝¹ : Category.{v, u} C
D : GlueData C
inst✝ : HasLimits C
i : D.J
U : Opens ↑↑(CategoryTheory.GlueData.U D.toGlueData i)
⊢ limit.lift (diagramOverOpen D U)
        { pt := (CategoryTheory.GlueData.U D.toGlueData i).presheaf.obj (op U),
          π := NatTrans.mk fun j => ιInvAppπApp D U j.unop } ≫
      diagramOverOpenπ D U i =
    (CategoryTheory.GlueData.U D.toGlueData i).presheaf.map
      (eqToHom
        (_ :
          op U =
            op
              ((Opens.map
                    (colimit.ι (MultispanIndex.multispan (diagram D.toGlueData))
                        (op (WalkingMultispan.right i)).unop).base).obj
                ((IsOpenMap.functor (_ : IsOpenMap ↑(ι D.toGlueData i).base)).obj U))))
[PROOFSTEP]
rw [limit.lift_π]
[GOAL]
case h
C : Type u
inst✝¹ : Category.{v, u} C
D : GlueData C
inst✝ : HasLimits C
i : D.J
U : Opens ↑↑(CategoryTheory.GlueData.U D.toGlueData i)
⊢ NatTrans.app
      { pt := (CategoryTheory.GlueData.U D.toGlueData i).presheaf.obj (op U),
          π := NatTrans.mk fun j => ιInvAppπApp D U j.unop }.π
      (op (WalkingMultispan.right i)) =
    (CategoryTheory.GlueData.U D.toGlueData i).presheaf.map
      (eqToHom
        (_ :
          op U =
            op
              ((Opens.map
                    (colimit.ι (MultispanIndex.multispan (diagram D.toGlueData))
                        (op (WalkingMultispan.right i)).unop).base).obj
                ((IsOpenMap.functor (_ : IsOpenMap ↑(ι D.toGlueData i).base)).obj U))))
[PROOFSTEP]
change D.opensImagePreimageMap i i U = _
[GOAL]
case h
C : Type u
inst✝¹ : Category.{v, u} C
D : GlueData C
inst✝ : HasLimits C
i : D.J
U : Opens ↑↑(CategoryTheory.GlueData.U D.toGlueData i)
⊢ opensImagePreimageMap D i i U =
    (CategoryTheory.GlueData.U D.toGlueData i).presheaf.map
      (eqToHom
        (_ :
          op U =
            op
              ((Opens.map
                    (colimit.ι (MultispanIndex.multispan (diagram D.toGlueData))
                        (op (WalkingMultispan.right i)).unop).base).obj
                ((IsOpenMap.functor (_ : IsOpenMap ↑(ι D.toGlueData i).base)).obj U))))
[PROOFSTEP]
dsimp [opensImagePreimageMap]
[GOAL]
case h
C : Type u
inst✝¹ : Category.{v, u} C
D : GlueData C
inst✝ : HasLimits C
i : D.J
U : Opens ↑↑(CategoryTheory.GlueData.U D.toGlueData i)
⊢ NatTrans.app (f D.toGlueData i i).c (op U) ≫
      NatTrans.app (t D.toGlueData i i).c (op ((Opens.map (f D.toGlueData i i).base).obj U)) ≫
        IsOpenImmersion.invApp (_ : IsOpenImmersion (f D.toGlueData i i))
            { carrier := ↑(t D.toGlueData i i).base ⁻¹' ↑((Opens.map (f D.toGlueData i i).base).obj U),
              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 =
    (CategoryTheory.GlueData.U D.toGlueData i).presheaf.map
      (eqToHom
        (_ :
          op U =
            op
              ((Opens.map
                    (colimit.ι (MultispanIndex.multispan (diagram D.toGlueData)) (WalkingMultispan.right i)).base).obj
                ((IsOpenMap.functor (_ : IsOpenMap ↑(ι D.toGlueData i).base)).obj U))))
[PROOFSTEP]
rw [congr_app (D.t_id _), id_c_app, ← Functor.map_comp]
[GOAL]
case h
C : Type u
inst✝¹ : Category.{v, u} C
D : GlueData C
inst✝ : HasLimits C
i : D.J
U : Opens ↑↑(CategoryTheory.GlueData.U D.toGlueData i)
⊢ NatTrans.app (f D.toGlueData i i).c (op U) ≫
      (V D.toGlueData (i, i)).presheaf.map
          (𝟙 (op ((Opens.map (f D.toGlueData i i).base).obj U)) ≫
            eqToHom
              (_ :
                (Opens.map (𝟙 (V D.toGlueData (i, i))).base).op.obj (op ((Opens.map (f D.toGlueData i i).base).obj U)) =
                  (Opens.map (t D.toGlueData i i).base).op.obj (op ((Opens.map (f D.toGlueData i i).base).obj U)))) ≫
        IsOpenImmersion.invApp (_ : IsOpenImmersion (f D.toGlueData i i))
            { carrier := ↑(t D.toGlueData i i).base ⁻¹' ↑((Opens.map (f D.toGlueData i i).base).obj U),
              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 =
    (CategoryTheory.GlueData.U D.toGlueData i).presheaf.map
      (eqToHom
        (_ :
          op U =
            op
              ((Opens.map
                    (colimit.ι (MultispanIndex.multispan (diagram D.toGlueData)) (WalkingMultispan.right i)).base).obj
                ((IsOpenMap.functor (_ : IsOpenMap ↑(ι D.toGlueData i).base)).obj U))))
[PROOFSTEP]
erw [IsOpenImmersion.inv_naturality_assoc, IsOpenImmersion.app_inv_app'_assoc]
[GOAL]
case h
C : Type u
inst✝¹ : Category.{v, u} C
D : GlueData C
inst✝ : HasLimits C
i : D.J
U : Opens ↑↑(CategoryTheory.GlueData.U D.toGlueData i)
⊢ (CategoryTheory.GlueData.U D.toGlueData i).presheaf.map
        (eqToHom
            (_ :
              (IsOpenImmersion.openFunctor (_ : IsOpenImmersion (f D.toGlueData i i))).obj
                  ((Opens.map (f D.toGlueData i i).base).obj U) =
                U)).op ≫
      (CategoryTheory.GlueData.U D.toGlueData i).presheaf.map
          ((IsOpenImmersion.openFunctor (_ : IsOpenImmersion (f D.toGlueData i i))).op.map
            (𝟙 (op ((Opens.map (f D.toGlueData i i).base).obj U)) ≫
              eqToHom
                (_ :
                  (Opens.map (𝟙 (V D.toGlueData (i, i))).base).op.obj
                      (op ((Opens.map (f D.toGlueData i i).base).obj U)) =
                    (Opens.map (t D.toGlueData i i).base).op.obj (op ((Opens.map (f D.toGlueData i i).base).obj 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 =
    (CategoryTheory.GlueData.U D.toGlueData i).presheaf.map
      (eqToHom
        (_ :
          op U =
            op
              ((Opens.map
                    (colimit.ι (MultispanIndex.multispan (diagram D.toGlueData)) (WalkingMultispan.right i)).base).obj
                ((IsOpenMap.functor (_ : IsOpenMap ↑(ι D.toGlueData i).base)).obj U))))
[PROOFSTEP]
simp only [eqToHom_op, eqToHom_trans, eqToHom_map (Functor.op _), ← Functor.map_comp]
[GOAL]
case h
C : Type u
inst✝¹ : Category.{v, u} C
D : GlueData C
inst✝ : HasLimits C
i : D.J
U : Opens ↑↑(CategoryTheory.GlueData.U D.toGlueData i)
⊢ (CategoryTheory.GlueData.U D.toGlueData i).presheaf.map
      (eqToHom
          (_ :
            op U =
              op
                ((IsOpenImmersion.openFunctor (_ : IsOpenImmersion (f D.toGlueData i i))).obj
                  ((Opens.map (f D.toGlueData i i).base).obj U))) ≫
        (IsOpenImmersion.openFunctor (_ : IsOpenImmersion (f D.toGlueData i i))).op.map
            (𝟙 (op ((Opens.map (f D.toGlueData i i).base).obj U)) ≫
              eqToHom
                (_ :
                  (Opens.map (𝟙 (V D.toGlueData (i, i))).base).op.obj
                      (op ((Opens.map (f D.toGlueData i i).base).obj U)) =
                    (Opens.map (t D.toGlueData i i).base).op.obj (op ((Opens.map (f D.toGlueData i i).base).obj U)))) ≫
          eqToHom
            (_ :
              op
                  ((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
                  ((Opens.map (ι D.toGlueData i).base).obj
                    ((IsOpenMap.functor (_ : IsOpenMap ↑(ι D.toGlueData i).base)).obj U)))) =
    (CategoryTheory.GlueData.U D.toGlueData i).presheaf.map
      (eqToHom
        (_ :
          op U =
            op
              ((Opens.map
                    (colimit.ι (MultispanIndex.multispan (diagram D.toGlueData)) (WalkingMultispan.right i)).base).obj
                ((IsOpenMap.functor (_ : IsOpenMap ↑(ι D.toGlueData i).base)).obj U))))
[PROOFSTEP]
rfl
[GOAL]
case h.hU
C : Type u
inst✝¹ : Category.{v, u} C
D : GlueData C
inst✝ : HasLimits C
i : D.J
U : Opens ↑↑(CategoryTheory.GlueData.U D.toGlueData i)
⊢ ↑U ⊆ Set.range ↑(f D.toGlueData i i).base
[PROOFSTEP]
rw [Set.range_iff_surjective.mpr _]
[GOAL]
case h.hU
C : Type u
inst✝¹ : Category.{v, u} C
D : GlueData C
inst✝ : HasLimits C
i : D.J
U : Opens ↑↑(CategoryTheory.GlueData.U D.toGlueData i)
⊢ ↑U ⊆ Set.univ
[PROOFSTEP]
simp
[GOAL]
C : Type u
inst✝¹ : Category.{v, u} C
D : GlueData C
inst✝ : HasLimits C
i : D.J
U : Opens ↑↑(CategoryTheory.GlueData.U D.toGlueData i)
⊢ Function.Surjective ↑(f D.toGlueData i i).base
[PROOFSTEP]
rw [← TopCat.epi_iff_surjective]
[GOAL]
C : Type u
inst✝¹ : Category.{v, u} C
D : GlueData C
inst✝ : HasLimits C
i : D.J
U : Opens ↑↑(CategoryTheory.GlueData.U D.toGlueData i)
⊢ Epi (f D.toGlueData i i).base
[PROOFSTEP]
infer_instance
[GOAL]
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 ≫ ιInvApp D U ≫ diagramOverOpenπ D U j = diagramOverOpenπ D U j
[PROOFSTEP]
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)]
[GOAL]
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)
⊢ Mono
    ((componentwiseDiagram (MultispanIndex.multispan (diagram D.toGlueData))
            ((IsOpenMap.functor (_ : IsOpenMap ↑(ι D.toGlueData i).base)).obj U)).map
        (WalkingMultispan.Hom.snd (i, j)).op ≫
      𝟙
        ((componentwiseDiagram (MultispanIndex.multispan (diagram D.toGlueData))
              ((IsOpenMap.functor (_ : IsOpenMap ↑(ι D.toGlueData i).base)).obj U)).obj
          (op (WalkingMultispan.left (i, j)))))
[PROOFSTEP]
rw [Category.comp_id]
[GOAL]
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)
⊢ Mono
    ((componentwiseDiagram (MultispanIndex.multispan (diagram D.toGlueData))
          ((IsOpenMap.functor (_ : IsOpenMap ↑(ι D.toGlueData i).base)).obj U)).map
      (WalkingMultispan.Hom.snd (i, j)).op)
[PROOFSTEP]
apply (config := { allowSynthFailures := true }) mono_comp
[GOAL]
case inst
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)
⊢ Mono
    (NatTrans.app ((MultispanIndex.multispan (diagram D.toGlueData)).map (WalkingMultispan.Hom.snd (i, j)).op.unop).c
      (op
        ((Opens.map
              (colimit.ι (MultispanIndex.multispan (diagram D.toGlueData))
                  (op (WalkingMultispan.right (MultispanIndex.sndFrom (diagram D.toGlueData) (i, j)))).unop).base).obj
          ((IsOpenMap.functor (_ : IsOpenMap ↑(ι D.toGlueData i).base)).obj U))))
[PROOFSTEP]
change Mono ((_ ≫ D.f j i).c.app _)
[GOAL]
case inst
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)
⊢ Mono
    (NatTrans.app (t D.toGlueData i j ≫ f D.toGlueData j i).c
      (op
        ((Opens.map
              (colimit.ι (MultispanIndex.multispan (diagram D.toGlueData))
                  (op (WalkingMultispan.right (MultispanIndex.sndFrom (diagram D.toGlueData) (i, j)))).unop).base).obj
          ((IsOpenMap.functor (_ : IsOpenMap ↑(ι D.toGlueData i).base)).obj U))))
[PROOFSTEP]
rw [comp_c_app]
[GOAL]
case inst
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)
⊢ Mono
    (NatTrans.app (f D.toGlueData j i).c
        (op
          ((Opens.map
                (colimit.ι (MultispanIndex.multispan (diagram D.toGlueData))
                    (op (WalkingMultispan.right (MultispanIndex.sndFrom (diagram D.toGlueData) (i, j)))).unop).base).obj
            ((IsOpenMap.functor (_ : IsOpenMap ↑(ι D.toGlueData i).base)).obj U))) ≫
      NatTrans.app (t D.toGlueData i j).c
        (op
          ((Opens.map (f D.toGlueData j i).base).obj
            (op
                ((Opens.map
                      (colimit.ι (MultispanIndex.multispan (diagram D.toGlueData))
                          (op
                              (WalkingMultispan.right
                                (MultispanIndex.sndFrom (diagram D.toGlueData) (i, j)))).unop).base).obj
                  ((IsOpenMap.functor (_ : IsOpenMap ↑(ι D.toGlueData i).base)).obj U))).unop)))
[PROOFSTEP]
apply (config := { allowSynthFailures := true }) mono_comp
[GOAL]
case inst
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)
⊢ Mono
    (NatTrans.app (f D.toGlueData j i).c
      (op
        ((Opens.map
              (colimit.ι (MultispanIndex.multispan (diagram D.toGlueData))
                  (op (WalkingMultispan.right (MultispanIndex.sndFrom (diagram D.toGlueData) (i, j)))).unop).base).obj
          ((IsOpenMap.functor (_ : IsOpenMap ↑(ι D.toGlueData i).base)).obj U))))
case inst
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)
⊢ Mono
    (NatTrans.app (t D.toGlueData i j).c
      (op
        ((Opens.map (f D.toGlueData j i).base).obj
          (op
              ((Opens.map
                    (colimit.ι (MultispanIndex.multispan (diagram D.toGlueData))
                        (op
                            (WalkingMultispan.right
                              (MultispanIndex.sndFrom (diagram D.toGlueData) (i, j)))).unop).base).obj
                ((IsOpenMap.functor (_ : IsOpenMap ↑(ι D.toGlueData i).base)).obj U))).unop)))
[PROOFSTEP]
erw [D.ι_image_preimage_eq i j U]
[GOAL]
case inst
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)
⊢ Mono
    (NatTrans.app (f D.toGlueData j i).c
      (op
        ((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)))))
[PROOFSTEP]
infer_instance
[GOAL]
case inst
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)
⊢ Mono
    (NatTrans.app (t D.toGlueData i j).c
      (op
        ((Opens.map (f D.toGlueData j i).base).obj
          (op
              ((Opens.map
                    (colimit.ι (MultispanIndex.multispan (diagram D.toGlueData))
                        (op
                            (WalkingMultispan.right
                              (MultispanIndex.sndFrom (diagram D.toGlueData) (i, j)))).unop).base).obj
                ((IsOpenMap.functor (_ : IsOpenMap ↑(ι D.toGlueData i).base)).obj U))).unop)))
[PROOFSTEP]
have : IsIso (D.t i j).c := by apply c_isIso_of_iso
[GOAL]
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)
⊢ IsIso (t D.toGlueData i j).c
[PROOFSTEP]
apply c_isIso_of_iso
[GOAL]
case inst
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)
this : IsIso (t D.toGlueData i j).c
⊢ Mono
    (NatTrans.app (t D.toGlueData i j).c
      (op
        ((Opens.map (f D.toGlueData j i).base).obj
          (op
              ((Opens.map
                    (colimit.ι (MultispanIndex.multispan (diagram D.toGlueData))
                        (op
                            (WalkingMultispan.right
                              (MultispanIndex.sndFrom (diagram D.toGlueData) (i, j)))).unop).base).obj
                ((IsOpenMap.functor (_ : IsOpenMap ↑(ι D.toGlueData i).base)).obj U))).unop)))
[PROOFSTEP]
infer_instance
[GOAL]
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 ≫ ιInvApp D U ≫ diagramOverOpenπ D U j) ≫
      (componentwiseDiagram (MultispanIndex.multispan (diagram D.toGlueData))
              ((IsOpenMap.functor (_ : IsOpenMap ↑(ι D.toGlueData i).base)).obj U)).map
          (WalkingMultispan.Hom.snd (i, j)).op ≫
        𝟙
          ((componentwiseDiagram (MultispanIndex.multispan (diagram D.toGlueData))
                ((IsOpenMap.functor (_ : IsOpenMap ↑(ι D.toGlueData i).base)).obj U)).obj
            (op (WalkingMultispan.left (i, j)))) =
    diagramOverOpenπ D U j ≫
      (componentwiseDiagram (MultispanIndex.multispan (diagram D.toGlueData))
              ((IsOpenMap.functor (_ : IsOpenMap ↑(ι D.toGlueData i).base)).obj U)).map
          (WalkingMultispan.Hom.snd (i, j)).op ≫
        𝟙
          ((componentwiseDiagram (MultispanIndex.multispan (diagram D.toGlueData))
                ((IsOpenMap.functor (_ : IsOpenMap ↑(ι D.toGlueData i).base)).obj U)).obj
            (op (WalkingMultispan.left (i, j))))
[PROOFSTEP]
simp_rw [Category.assoc]
[GOAL]
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 ≫
        ιInvApp D U ≫
          diagramOverOpenπ D U j ≫
            (componentwiseDiagram (MultispanIndex.multispan (diagram D.toGlueData))
                    ((IsOpenMap.functor (_ : IsOpenMap ↑(ι D.toGlueData i).base)).obj U)).map
                (WalkingMultispan.Hom.snd (i, j)).op ≫
              𝟙
                ((componentwiseDiagram (MultispanIndex.multispan (diagram D.toGlueData))
                      ((IsOpenMap.functor (_ : IsOpenMap ↑(ι D.toGlueData i).base)).obj U)).obj
                  (op (WalkingMultispan.left (i, j)))) =
    diagramOverOpenπ D U j ≫
      (componentwiseDiagram (MultispanIndex.multispan (diagram D.toGlueData))
              ((IsOpenMap.functor (_ : IsOpenMap ↑(ι D.toGlueData i).base)).obj U)).map
          (WalkingMultispan.Hom.snd (i, j)).op ≫
        𝟙
          ((componentwiseDiagram (MultispanIndex.multispan (diagram D.toGlueData))
                ((IsOpenMap.functor (_ : IsOpenMap ↑(ι D.toGlueData i).base)).obj U)).obj
            (op (WalkingMultispan.left (i, j))))
[PROOFSTEP]
rw [limit.w_assoc]
[GOAL]
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 ≫
        ιInvApp D U ≫
          limit.π (diagramOverOpen D U) (op (WalkingMultispan.left (i, j))) ≫
            𝟙
              ((componentwiseDiagram (MultispanIndex.multispan (diagram D.toGlueData))
                    ((IsOpenMap.functor (_ : IsOpenMap ↑(ι D.toGlueData i).base)).obj U)).obj
                (op (WalkingMultispan.left (i, j)))) =
    limit.π (diagramOverOpen D U) (op (WalkingMultispan.left (i, j))) ≫
      𝟙
        ((componentwiseDiagram (MultispanIndex.multispan (diagram D.toGlueData))
              ((IsOpenMap.functor (_ : IsOpenMap ↑(ι D.toGlueData i).base)).obj U)).obj
          (op (WalkingMultispan.left (i, j))))
[PROOFSTEP]
erw [limit.lift_π_assoc]
[GOAL]
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 ≫
        NatTrans.app
            { pt := (CategoryTheory.GlueData.U D.toGlueData i).presheaf.obj (op U),
                π := NatTrans.mk fun j => ιInvAppπApp D U j.unop }.π
            (op (WalkingMultispan.left (i, j))) ≫
          𝟙
            ((componentwiseDiagram (MultispanIndex.multispan (diagram D.toGlueData))
                  ((IsOpenMap.functor (_ : IsOpenMap ↑(ι D.toGlueData i).base)).obj U)).obj
              (op (WalkingMultispan.left (i, j)))) =
    limit.π (diagramOverOpen D U) (op (WalkingMultispan.left (i, j))) ≫
      𝟙
        ((componentwiseDiagram (MultispanIndex.multispan (diagram D.toGlueData))
              ((IsOpenMap.functor (_ : IsOpenMap ↑(ι D.toGlueData i).base)).obj U)).obj
          (op (WalkingMultispan.left (i, j))))
[PROOFSTEP]
rw [Category.comp_id, Category.comp_id]
[GOAL]
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 ≫
        NatTrans.app
          { pt := (CategoryTheory.GlueData.U D.toGlueData i).presheaf.obj (op U),
              π := NatTrans.mk fun j => ιInvAppπApp D U j.unop }.π
          (op (WalkingMultispan.left (i, j))) =
    limit.π (diagramOverOpen D U) (op (WalkingMultispan.left (i, j)))
[PROOFSTEP]
change _ ≫ _ ≫ (_ ≫ _) ≫ _ = _
[GOAL]
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 ≫
        (NatTrans.app (f D.toGlueData i i).c (op U) ≫
            NatTrans.app (t D.toGlueData i i).c ((Opens.map (f D.toGlueData i i).base).op.obj (op U)) ≫
              IsOpenImmersion.invApp (_ : IsOpenImmersion (f D.toGlueData i i))
                  {
                      unop :=
                        {
                          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)) } }.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) ≫
          NatTrans.app (f D.toGlueData i j).c
              (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)))
[PROOFSTEP]
rw [congr_app (D.t_id _), id_c_app]
[GOAL]
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 ≫
        (NatTrans.app (f D.toGlueData i i).c (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))
                  {
                      unop :=
                        {
                          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)) } }.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) ≫
          NatTrans.app (f D.toGlueData i j).c
              (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)))
[PROOFSTEP]
simp_rw [Category.assoc]
[GOAL]
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 ≫
        NatTrans.app (f D.toGlueData i i).c (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 ≫
                  NatTrans.app (f D.toGlueData i j).c
                      (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)))
[PROOFSTEP]
rw [← Functor.map_comp_assoc]
  -- Porting note : change `rw` to `erw`
[GOAL]
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 ≫
        NatTrans.app (f D.toGlueData i i).c (op U) ≫
          (V D.toGlueData (i, i)).presheaf.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)))) ≫
            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 ≫
                NatTrans.app (f D.toGlueData i j).c
                    (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)))
[PROOFSTEP]
erw [IsOpenImmersion.inv_naturality_assoc]
[GOAL]
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 ≫
        NatTrans.app (f D.toGlueData i i).c (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 ≫
                NatTrans.app (f D.toGlueData i j).c
                    (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)))
[PROOFSTEP]
erw [IsOpenImmersion.app_invApp_assoc]
[GOAL]
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 ≫
        (CategoryTheory.GlueData.U D.toGlueData i).presheaf.map
            (homOfLE (_ : ↑(f D.toGlueData i i).base '' (↑(f D.toGlueData i i).base ⁻¹' U.carrier) ⊆ U.carrier)).op ≫
          (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 ≫
              NatTrans.app (f D.toGlueData i j).c
                  (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)))
[PROOFSTEP]
iterate 3 rw [← Functor.map_comp_assoc]
[GOAL]
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 ≫
        (CategoryTheory.GlueData.U D.toGlueData i).presheaf.map
            (homOfLE (_ : ↑(f D.toGlueData i i).base '' (↑(f D.toGlueData i i).base ⁻¹' U.carrier) ⊆ U.carrier)).op ≫
          (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 ≫
              NatTrans.app (f D.toGlueData i j).c
                  (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)))
[PROOFSTEP]
rw [← Functor.map_comp_assoc]
[GOAL]
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 ≫
      (CategoryTheory.GlueData.U D.toGlueData i).presheaf.map
          ((eqToIso
                (_ :
                  op U =
                    op
                      ((Opens.map
                            (colimit.ι (MultispanIndex.multispan (diagram D.toGlueData))
                                (op (WalkingMultispan.right i)).unop).base).obj
                        ((IsOpenMap.functor (_ : IsOpenMap ↑(ι D.toGlueData i).base)).obj U)))).inv ≫
            (homOfLE (_ : ↑(f D.toGlueData i i).base '' (↑(f D.toGlueData i i).base ⁻¹' U.carrier) ⊆ U.carrier)).op) ≫
        (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 ≫
            NatTrans.app (f D.toGlueData i j).c
                (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)))
[PROOFSTEP]
rw [← Functor.map_comp_assoc]
[GOAL]
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 ≫
      (CategoryTheory.GlueData.U D.toGlueData i).presheaf.map
          (((eqToIso
                  (_ :
                    op U =
                      op
                        ((Opens.map
                              (colimit.ι (MultispanIndex.multispan (diagram D.toGlueData))
                                  (op (WalkingMultispan.right i)).unop).base).obj
                          ((IsOpenMap.functor (_ : IsOpenMap ↑(ι D.toGlueData i).base)).obj U)))).inv ≫
              (homOfLE (_ : ↑(f D.toGlueData i i).base '' (↑(f D.toGlueData i i).base ⁻¹' U.carrier) ⊆ U.carrier)).op) ≫
            (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 ≫
          NatTrans.app (f D.toGlueData i j).c
              (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)))
[PROOFSTEP]
rw [← Functor.map_comp_assoc]
[GOAL]
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 ≫
      (CategoryTheory.GlueData.U D.toGlueData i).presheaf.map
          ((((eqToIso
                    (_ :
                      op U =
                        op
                          ((Opens.map
                                (colimit.ι (MultispanIndex.multispan (diagram D.toGlueData))
                                    (op (WalkingMultispan.right i)).unop).base).obj
                            ((IsOpenMap.functor (_ : IsOpenMap ↑(ι D.toGlueData i).base)).obj U)))).inv ≫
                (homOfLE
                    (_ : ↑(f D.toGlueData i i).base '' (↑(f D.toGlueData i i).base ⁻¹' U.carrier) ⊆ U.carrier)).op) ≫
              (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))))) ≫
            (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) ≫
        NatTrans.app (f D.toGlueData i j).c
            (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)))
[PROOFSTEP]
rw [NatTrans.naturality_assoc]
[GOAL]
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 ≫
      NatTrans.app (f D.toGlueData i j).c
          (op
            ((Opens.map
                  (colimit.ι (MultispanIndex.multispan (diagram D.toGlueData))
                      (op (WalkingMultispan.right i)).unop).base).obj
              ((IsOpenMap.functor (_ : IsOpenMap ↑(ι D.toGlueData i).base)).obj U))) ≫
        ((f D.toGlueData i j).base _* (V D.toGlueData (i, j)).presheaf).map
            ((((eqToIso
                      (_ :
                        op U =
                          op
                            ((Opens.map
                                  (colimit.ι (MultispanIndex.multispan (diagram D.toGlueData))
                                      (op (WalkingMultispan.right i)).unop).base).obj
                              ((IsOpenMap.functor (_ : IsOpenMap ↑(ι D.toGlueData i).base)).obj U)))).inv ≫
                  (homOfLE
                      (_ : ↑(f D.toGlueData i i).base '' (↑(f D.toGlueData i i).base ⁻¹' U.carrier) ⊆ U.carrier)).op) ≫
                (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))))) ≫
              (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) ≫
          (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)))
[PROOFSTEP]
erw [← (D.V (i, j)).presheaf.map_comp]
[GOAL]
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 ≫
      NatTrans.app (f D.toGlueData i j).c
          (op
            ((Opens.map
                  (colimit.ι (MultispanIndex.multispan (diagram D.toGlueData))
                      (op (WalkingMultispan.right i)).unop).base).obj
              ((IsOpenMap.functor (_ : IsOpenMap ↑(ι D.toGlueData i).base)).obj U))) ≫
        (V D.toGlueData (i, j)).presheaf.map
          ((Opens.map (f D.toGlueData i j).base).op.map
              ((((eqToIso
                        (_ :
                          op U =
                            op
                              ((Opens.map
                                    (colimit.ι (MultispanIndex.multispan (diagram D.toGlueData))
                                        (op (WalkingMultispan.right i)).unop).base).obj
                                ((IsOpenMap.functor (_ : IsOpenMap ↑(ι D.toGlueData i).base)).obj U)))).inv ≫
                    (homOfLE
                        (_ :
                          ↑(f D.toGlueData i i).base '' (↑(f D.toGlueData i i).base ⁻¹' U.carrier) ⊆ U.carrier)).op) ≫
                  (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))))) ≫
                (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) ≫
            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)))
[PROOFSTEP]
convert limit.w (componentwiseDiagram 𝖣.diagram.multispan _) (Quiver.Hom.op (WalkingMultispan.Hom.fst (i, j)))
[GOAL]
C : Type u
inst✝¹ : Category.{v, u} C
D : GlueData C
inst✝ : HasLimits C
i : D.J
U : Opens ↑↑(CategoryTheory.GlueData.U D.toGlueData i)
⊢ diagramOverOpenπ D U i ≫ ιInvAppπEqMap D U ≫ ιInvApp D U = 𝟙 (limit (diagramOverOpen D U))
[PROOFSTEP]
ext j
[GOAL]
case w
C : Type u
inst✝¹ : Category.{v, u} C
D : GlueData C
inst✝ : HasLimits C
i : D.J
U : Opens ↑↑(CategoryTheory.GlueData.U D.toGlueData i)
j : (WalkingMultispan (diagram D.toGlueData).fstFrom (diagram D.toGlueData).sndFrom)ᵒᵖ
⊢ (diagramOverOpenπ D U i ≫ ιInvAppπEqMap D U ≫ ιInvApp D U) ≫ limit.π (diagramOverOpen D U) j =
    𝟙 (limit (diagramOverOpen D U)) ≫ limit.π (diagramOverOpen D U) j
[PROOFSTEP]
induction j using Opposite.rec' with
| h j => ?_
[GOAL]
case w
C : Type u
inst✝¹ : Category.{v, u} C
D : GlueData C
inst✝ : HasLimits C
i : D.J
U : Opens ↑↑(CategoryTheory.GlueData.U D.toGlueData i)
j : (WalkingMultispan (diagram D.toGlueData).fstFrom (diagram D.toGlueData).sndFrom)ᵒᵖ
⊢ (diagramOverOpenπ D U i ≫ ιInvAppπEqMap D U ≫ ιInvApp D U) ≫ limit.π (diagramOverOpen D U) j =
    𝟙 (limit (diagramOverOpen D U)) ≫ limit.π (diagramOverOpen D U) j
[PROOFSTEP]
induction j using Opposite.rec' with
| h j => ?_
[GOAL]
case w.h
C : Type u
inst✝¹ : Category.{v, u} C
D : GlueData C
inst✝ : HasLimits C
i : D.J
U : Opens ↑↑(CategoryTheory.GlueData.U D.toGlueData i)
j : WalkingMultispan (diagram D.toGlueData).fstFrom (diagram D.toGlueData).sndFrom
⊢ (diagramOverOpenπ D U i ≫ ιInvAppπEqMap D U ≫ ιInvApp D U) ≫ limit.π (diagramOverOpen D U) (op j) =
    𝟙 (limit (diagramOverOpen D U)) ≫ limit.π (diagramOverOpen D U) (op j)
[PROOFSTEP]
rcases j with (⟨j, k⟩ | ⟨j⟩)
[GOAL]
case w.h.left.mk
C : Type u
inst✝¹ : Category.{v, u} C
D : GlueData C
inst✝ : HasLimits C
i : D.J
U : Opens ↑↑(CategoryTheory.GlueData.U D.toGlueData i)
j k : D.J
⊢ (diagramOverOpenπ D U i ≫ ιInvAppπEqMap D U ≫ ιInvApp D U) ≫
      limit.π (diagramOverOpen D U) (op (WalkingMultispan.left (j, k))) =
    𝟙 (limit (diagramOverOpen D U)) ≫ limit.π (diagramOverOpen D U) (op (WalkingMultispan.left (j, k)))
[PROOFSTEP]
rw [← limit.w (componentwiseDiagram 𝖣.diagram.multispan _) (Quiver.Hom.op (WalkingMultispan.Hom.fst (j, k))), ←
  Category.assoc, Category.id_comp]
[GOAL]
case w.h.left.mk
C : Type u
inst✝¹ : Category.{v, u} C
D : GlueData C
inst✝ : HasLimits C
i : D.J
U : Opens ↑↑(CategoryTheory.GlueData.U D.toGlueData i)
j k : D.J
⊢ ((diagramOverOpenπ D U i ≫ ιInvAppπEqMap D U ≫ ιInvApp D U) ≫
        limit.π
          (componentwiseDiagram (MultispanIndex.multispan (diagram D.toGlueData))
            ((IsOpenMap.functor (_ : IsOpenMap ↑(ι D.toGlueData i).base)).obj U))
          (op (WalkingMultispan.right (MultispanIndex.fstFrom (diagram D.toGlueData) (j, k))))) ≫
      (componentwiseDiagram (MultispanIndex.multispan (diagram D.toGlueData))
            ((IsOpenMap.functor (_ : IsOpenMap ↑(ι D.toGlueData i).base)).obj U)).map
        (WalkingMultispan.Hom.fst (j, k)).op =
    limit.π
        (componentwiseDiagram (MultispanIndex.multispan (diagram D.toGlueData))
          ((IsOpenMap.functor (_ : IsOpenMap ↑(ι D.toGlueData i).base)).obj U))
        (op (WalkingMultispan.right (MultispanIndex.fstFrom (diagram D.toGlueData) (j, k)))) ≫
      (componentwiseDiagram (MultispanIndex.multispan (diagram D.toGlueData))
            ((IsOpenMap.functor (_ : IsOpenMap ↑(ι D.toGlueData i).base)).obj U)).map
        (WalkingMultispan.Hom.fst (j, k)).op
[PROOFSTEP]
congr 1
[GOAL]
case w.h.left.mk.e_a
C : Type u
inst✝¹ : Category.{v, u} C
D : GlueData C
inst✝ : HasLimits C
i : D.J
U : Opens ↑↑(CategoryTheory.GlueData.U D.toGlueData i)
j k : D.J
⊢ (diagramOverOpenπ D U i ≫ ιInvAppπEqMap D U ≫ ιInvApp D U) ≫
      limit.π
        (componentwiseDiagram (MultispanIndex.multispan (diagram D.toGlueData))
          ((IsOpenMap.functor (_ : IsOpenMap ↑(ι D.toGlueData i).base)).obj U))
        (op (WalkingMultispan.right (MultispanIndex.fstFrom (diagram D.toGlueData) (j, k)))) =
    limit.π
      (componentwiseDiagram (MultispanIndex.multispan (diagram D.toGlueData))
        ((IsOpenMap.functor (_ : IsOpenMap ↑(ι D.toGlueData i).base)).obj U))
      (op (WalkingMultispan.right (MultispanIndex.fstFrom (diagram D.toGlueData) (j, k))))
[PROOFSTEP]
simp_rw [Category.assoc]
[GOAL]
case w.h.left.mk.e_a
C : Type u
inst✝¹ : Category.{v, u} C
D : GlueData C
inst✝ : HasLimits C
i : D.J
U : Opens ↑↑(CategoryTheory.GlueData.U D.toGlueData i)
j k : D.J
⊢ diagramOverOpenπ D U i ≫
      ιInvAppπEqMap D U ≫
        ιInvApp D U ≫
          limit.π
            (componentwiseDiagram (MultispanIndex.multispan (diagram D.toGlueData))
              ((IsOpenMap.functor (_ : IsOpenMap ↑(ι D.toGlueData i).base)).obj U))
            (op (WalkingMultispan.right (MultispanIndex.fstFrom (diagram D.toGlueData) (j, k)))) =
    limit.π
      (componentwiseDiagram (MultispanIndex.multispan (diagram D.toGlueData))
        ((IsOpenMap.functor (_ : IsOpenMap ↑(ι D.toGlueData i).base)).obj U))
      (op (WalkingMultispan.right (MultispanIndex.fstFrom (diagram D.toGlueData) (j, k))))
[PROOFSTEP]
apply π_ιInvApp_π
[GOAL]
case w.h.right
C : Type u
inst✝¹ : Category.{v, u} C
D : GlueData C
inst✝ : HasLimits C
i : D.J
U : Opens ↑↑(CategoryTheory.GlueData.U D.toGlueData i)
j : (diagram D.toGlueData).R
⊢ (diagramOverOpenπ D U i ≫ ιInvAppπEqMap D U ≫ ιInvApp D U) ≫
      limit.π (diagramOverOpen D U) (op (WalkingMultispan.right j)) =
    𝟙 (limit (diagramOverOpen D U)) ≫ limit.π (diagramOverOpen D U) (op (WalkingMultispan.right j))
[PROOFSTEP]
simp_rw [Category.assoc]
[GOAL]
case w.h.right
C : Type u
inst✝¹ : Category.{v, u} C
D : GlueData C
inst✝ : HasLimits C
i : D.J
U : Opens ↑↑(CategoryTheory.GlueData.U D.toGlueData i)
j : (diagram D.toGlueData).R
⊢ diagramOverOpenπ D U i ≫
      ιInvAppπEqMap D U ≫ ιInvApp D U ≫ limit.π (diagramOverOpen D U) (op (WalkingMultispan.right j)) =
    𝟙 (limit (diagramOverOpen D U)) ≫ limit.π (diagramOverOpen D U) (op (WalkingMultispan.right j))
[PROOFSTEP]
rw [Category.id_comp]
[GOAL]
case w.h.right
C : Type u
inst✝¹ : Category.{v, u} C
D : GlueData C
inst✝ : HasLimits C
i : D.J
U : Opens ↑↑(CategoryTheory.GlueData.U D.toGlueData i)
j : (diagram D.toGlueData).R
⊢ diagramOverOpenπ D U i ≫
      ιInvAppπEqMap D U ≫ ιInvApp D U ≫ limit.π (diagramOverOpen D U) (op (WalkingMultispan.right j)) =
    limit.π (diagramOverOpen D U) (op (WalkingMultispan.right j))
[PROOFSTEP]
apply π_ιInvApp_π
[GOAL]
C : Type u
inst✝¹ : Category.{v, u} C
D : GlueData C
inst✝ : HasLimits C
i : D.J
U : Opens ↑↑(CategoryTheory.GlueData.U D.toGlueData i)
⊢ IsIso (diagramOverOpenπ D U i)
[PROOFSTEP]
use D.ιInvAppπEqMap U ≫ D.ιInvApp U
[GOAL]
case h
C : Type u
inst✝¹ : Category.{v, u} C
D : GlueData C
inst✝ : HasLimits C
i : D.J
U : Opens ↑↑(CategoryTheory.GlueData.U D.toGlueData i)
⊢ diagramOverOpenπ D U i ≫ ιInvAppπEqMap D U ≫ ιInvApp D U = 𝟙 (limit (diagramOverOpen D U)) ∧
    (ιInvAppπEqMap D U ≫ ιInvApp D U) ≫ diagramOverOpenπ D U i =
      𝟙 ((diagramOverOpen D U).obj (op (WalkingMultispan.right i)))
[PROOFSTEP]
constructor
[GOAL]
case h.left
C : Type u
inst✝¹ : Category.{v, u} C
D : GlueData C
inst✝ : HasLimits C
i : D.J
U : Opens ↑↑(CategoryTheory.GlueData.U D.toGlueData i)
⊢ diagramOverOpenπ D U i ≫ ιInvAppπEqMap D U ≫ ιInvApp D U = 𝟙 (limit (diagramOverOpen D U))
[PROOFSTEP]
apply π_ιInvApp_eq_id
[GOAL]
case h.right
C : Type u
inst✝¹ : Category.{v, u} C
D : GlueData C
inst✝ : HasLimits C
i : D.J
U : Opens ↑↑(CategoryTheory.GlueData.U D.toGlueData i)
⊢ (ιInvAppπEqMap D U ≫ ιInvApp D U) ≫ diagramOverOpenπ D U i =
    𝟙 ((diagramOverOpen D U).obj (op (WalkingMultispan.right i)))
[PROOFSTEP]
rw [Category.assoc, (D.ιInvApp_π _).choose_spec]
[GOAL]
case h.right
C : Type u
inst✝¹ : Category.{v, u} C
D : GlueData C
inst✝ : HasLimits C
i : D.J
U : Opens ↑↑(CategoryTheory.GlueData.U D.toGlueData i)
⊢ ιInvAppπEqMap D U ≫
      (CategoryTheory.GlueData.U D.toGlueData i).presheaf.map
        (eqToHom
          (_ :
            op U =
              op
                ((Opens.map
                      (colimit.ι (MultispanIndex.multispan (diagram D.toGlueData))
                          (op (WalkingMultispan.right i)).unop).base).obj
                  ((IsOpenMap.functor (_ : IsOpenMap ↑(ι D.toGlueData i).base)).obj U)))) =
    𝟙 ((diagramOverOpen D U).obj (op (WalkingMultispan.right i)))
[PROOFSTEP]
exact Iso.inv_hom_id ((D.U i).presheaf.mapIso (eqToIso _))
[GOAL]
C : Type u
inst✝¹ : Category.{v, u} C
D : GlueData C
inst✝ : HasLimits C
i : D.J
U : Opens ↑↑(CategoryTheory.GlueData.U D.toGlueData i)
⊢ IsIso (NatTrans.app (ι D.toGlueData i).c (op ((IsOpenMap.functor (_ : IsOpenMap ↑(ι D.toGlueData i).base)).obj U)))
[PROOFSTEP]
erw [← colimitPresheafObjIsoComponentwiseLimit_hom_π]
[GOAL]
C : Type u
inst✝¹ : Category.{v, u} C
D : GlueData C
inst✝ : HasLimits C
i : D.J
U : Opens ↑↑(CategoryTheory.GlueData.U D.toGlueData i)
⊢ IsIso
    ((colimitPresheafObjIsoComponentwiseLimit (MultispanIndex.multispan (diagram D.toGlueData))
          ((IsOpenMap.functor (_ : IsOpenMap ↑(ι D.toGlueData i).base)).obj U)).hom ≫
      limit.π
        (componentwiseDiagram (MultispanIndex.multispan (diagram D.toGlueData))
          ((IsOpenMap.functor (_ : IsOpenMap ↑(ι D.toGlueData i).base)).obj U))
        (op (WalkingMultispan.right i)))
[PROOFSTEP]
infer_instance
[GOAL]
C : Type u
inst✝¹ : Category.{v, u} C
D : GlueData C
inst✝ : HasLimits C
i j : D.J
s : PullbackCone (ι D.toGlueData i) (ι D.toGlueData j)
⊢ { l //
    l ≫ PullbackCone.fst (vPullbackCone D.toGlueData i j) = PullbackCone.fst s ∧
      l ≫ PullbackCone.snd (vPullbackCone D.toGlueData i j) = PullbackCone.snd s ∧
        ∀ {m : s.pt ⟶ (vPullbackCone D.toGlueData i j).pt},
          m ≫ PullbackCone.fst (vPullbackCone D.toGlueData i j) = PullbackCone.fst s →
            m ≫ PullbackCone.snd (vPullbackCone D.toGlueData i j) = PullbackCone.snd s → m = l }
[PROOFSTEP]
refine' ⟨_, _, _, _⟩
[GOAL]
case refine'_1
C : Type u
inst✝¹ : Category.{v, u} C
D : GlueData C
inst✝ : HasLimits C
i j : D.J
s : PullbackCone (ι D.toGlueData i) (ι D.toGlueData j)
⊢ s.pt ⟶ (vPullbackCone D.toGlueData i j).pt
[PROOFSTEP]
refine' PresheafedSpace.IsOpenImmersion.lift (D.f i j) s.fst _
[GOAL]
case refine'_1
C : Type u
inst✝¹ : Category.{v, u} C
D : GlueData C
inst✝ : HasLimits C
i j : D.J
s : PullbackCone (ι D.toGlueData i) (ι D.toGlueData j)
⊢ Set.range ↑(PullbackCone.fst s).base ⊆ Set.range ↑(f D.toGlueData i j).base
[PROOFSTEP]
erw [← D.toTopGlueData.preimage_range j i]
[GOAL]
case refine'_1
C : Type u
inst✝¹ : Category.{v, u} C
D : GlueData C
inst✝ : HasLimits C
i j : D.J
s : PullbackCone (ι D.toGlueData i) (ι D.toGlueData j)
⊢ Set.range ↑(PullbackCone.fst s).base ⊆
    ↑(ι (toTopGlueData D).toGlueData i) ⁻¹' Set.range ↑(ι (toTopGlueData D).toGlueData j)
[PROOFSTEP]
have : s.fst.base ≫ D.toTopGlueData.ι i = s.snd.base ≫ D.toTopGlueData.ι j :=
  by
  rw [← 𝖣.ι_gluedIso_hom (PresheafedSpace.forget _) _, ← 𝖣.ι_gluedIso_hom (PresheafedSpace.forget _) _]
  have := congr_arg PresheafedSpace.Hom.base s.condition
  rw [comp_base, comp_base] at this
  replace this := reassoc_of% this
  exact this _
[GOAL]
C : Type u
inst✝¹ : Category.{v, u} C
D : GlueData C
inst✝ : HasLimits C
i j : D.J
s : PullbackCone (ι D.toGlueData i) (ι D.toGlueData j)
⊢ (PullbackCone.fst s).base ≫ ι (toTopGlueData D).toGlueData i =
    (PullbackCone.snd s).base ≫ ι (toTopGlueData D).toGlueData j
[PROOFSTEP]
rw [← 𝖣.ι_gluedIso_hom (PresheafedSpace.forget _) _, ← 𝖣.ι_gluedIso_hom (PresheafedSpace.forget _) _]
[GOAL]
C : Type u
inst✝¹ : Category.{v, u} C
D : GlueData C
inst✝ : HasLimits C
i j : D.J
s : PullbackCone (ι D.toGlueData i) (ι D.toGlueData j)
⊢ (PullbackCone.fst s).base ≫ (forget C).map (ι D.toGlueData i) ≫ (gluedIso D.toGlueData (forget C)).hom =
    (PullbackCone.snd s).base ≫ (forget C).map (ι D.toGlueData j) ≫ (gluedIso D.toGlueData (forget C)).hom
[PROOFSTEP]
have := congr_arg PresheafedSpace.Hom.base s.condition
[GOAL]
C : Type u
inst✝¹ : Category.{v, u} C
D : GlueData C
inst✝ : HasLimits C
i j : D.J
s : PullbackCone (ι D.toGlueData i) (ι D.toGlueData j)
this : (PullbackCone.fst s ≫ ι D.toGlueData i).base = (PullbackCone.snd s ≫ ι D.toGlueData j).base
⊢ (PullbackCone.fst s).base ≫ (forget C).map (ι D.toGlueData i) ≫ (gluedIso D.toGlueData (forget C)).hom =
    (PullbackCone.snd s).base ≫ (forget C).map (ι D.toGlueData j) ≫ (gluedIso D.toGlueData (forget C)).hom
[PROOFSTEP]
rw [comp_base, comp_base] at this
[GOAL]
C : Type u
inst✝¹ : Category.{v, u} C
D : GlueData C
inst✝ : HasLimits C
i j : D.J
s : PullbackCone (ι D.toGlueData i) (ι D.toGlueData j)
this : (PullbackCone.fst s).base ≫ (ι D.toGlueData i).base = (PullbackCone.snd s).base ≫ (ι D.toGlueData j).base
⊢ (PullbackCone.fst s).base ≫ (forget C).map (ι D.toGlueData i) ≫ (gluedIso D.toGlueData (forget C)).hom =
    (PullbackCone.snd s).base ≫ (forget C).map (ι D.toGlueData j) ≫ (gluedIso D.toGlueData (forget C)).hom
[PROOFSTEP]
replace this := reassoc_of% this
[GOAL]
C : Type u
inst✝¹ : Category.{v, u} C
D : GlueData C
inst✝ : HasLimits C
i j : D.J
s : PullbackCone (ι D.toGlueData i) (ι D.toGlueData j)
this :
  ∀ {Z : TopCat} (h : ↑(glued D.toGlueData) ⟶ Z),
    (PullbackCone.fst s).base ≫ (ι D.toGlueData i).base ≫ h = (PullbackCone.snd s).base ≫ (ι D.toGlueData j).base ≫ h
⊢ (PullbackCone.fst s).base ≫ (forget C).map (ι D.toGlueData i) ≫ (gluedIso D.toGlueData (forget C)).hom =
    (PullbackCone.snd s).base ≫ (forget C).map (ι D.toGlueData j) ≫ (gluedIso D.toGlueData (forget C)).hom
[PROOFSTEP]
exact this _
[GOAL]
case refine'_1
C : Type u
inst✝¹ : Category.{v, u} C
D : GlueData C
inst✝ : HasLimits C
i j : D.J
s : PullbackCone (ι D.toGlueData i) (ι D.toGlueData j)
this :
  (PullbackCone.fst s).base ≫ ι (toTopGlueData D).toGlueData i =
    (PullbackCone.snd s).base ≫ ι (toTopGlueData D).toGlueData j
⊢ Set.range ↑(PullbackCone.fst s).base ⊆
    ↑(ι (toTopGlueData D).toGlueData i) ⁻¹' Set.range ↑(ι (toTopGlueData D).toGlueData j)
[PROOFSTEP]
rw [← Set.image_subset_iff, ← Set.image_univ, ← Set.image_comp, Set.image_univ]
  -- Porting note : change `rw` to `erw`
[GOAL]
case refine'_1
C : Type u
inst✝¹ : Category.{v, u} C
D : GlueData C
inst✝ : HasLimits C
i j : D.J
s : PullbackCone (ι D.toGlueData i) (ι D.toGlueData j)
this :
  (PullbackCone.fst s).base ≫ ι (toTopGlueData D).toGlueData i =
    (PullbackCone.snd s).base ≫ ι (toTopGlueData D).toGlueData j
⊢ Set.range (↑(ι (toTopGlueData D).toGlueData i) ∘ ↑(PullbackCone.fst s).base) ⊆
    Set.range ↑(ι (toTopGlueData D).toGlueData j)
[PROOFSTEP]
erw [← coe_comp]
[GOAL]
case refine'_1
C : Type u
inst✝¹ : Category.{v, u} C
D : GlueData C
inst✝ : HasLimits C
i j : D.J
s : PullbackCone (ι D.toGlueData i) (ι D.toGlueData j)
this :
  (PullbackCone.fst s).base ≫ ι (toTopGlueData D).toGlueData i =
    (PullbackCone.snd s).base ≫ ι (toTopGlueData D).toGlueData j
⊢ Set.range ↑((PullbackCone.fst s).base ≫ ι (toTopGlueData D).toGlueData i) ⊆
    Set.range ↑(ι (toTopGlueData D).toGlueData j)
[PROOFSTEP]
rw [this, coe_comp, ← Set.image_univ, Set.image_comp]
[GOAL]
case refine'_1
C : Type u
inst✝¹ : Category.{v, u} C
D : GlueData C
inst✝ : HasLimits C
i j : D.J
s : PullbackCone (ι D.toGlueData i) (ι D.toGlueData j)
this :
  (PullbackCone.fst s).base ≫ ι (toTopGlueData D).toGlueData i =
    (PullbackCone.snd s).base ≫ ι (toTopGlueData D).toGlueData j
⊢ ↑(ι (toTopGlueData D).toGlueData j) '' (↑(PullbackCone.snd s).base '' Set.univ) ⊆
    Set.range ↑(ι (toTopGlueData D).toGlueData j)
[PROOFSTEP]
exact Set.image_subset_range _ _
[GOAL]
case refine'_2
C : Type u
inst✝¹ : Category.{v, u} C
D : GlueData C
inst✝ : HasLimits C
i j : D.J
s : PullbackCone (ι D.toGlueData i) (ι D.toGlueData j)
⊢ IsOpenImmersion.lift (f D.toGlueData i j) (PullbackCone.fst s)
        (_ : Set.range ↑(PullbackCone.fst s).base ⊆ Set.range ↑(f D.toGlueData i j).base) ≫
      PullbackCone.fst (vPullbackCone D.toGlueData i j) =
    PullbackCone.fst s
[PROOFSTEP]
apply IsOpenImmersion.lift_fac
[GOAL]
case refine'_3
C : Type u
inst✝¹ : Category.{v, u} C
D : GlueData C
inst✝ : HasLimits C
i j : D.J
s : PullbackCone (ι D.toGlueData i) (ι D.toGlueData j)
⊢ IsOpenImmersion.lift (f D.toGlueData i j) (PullbackCone.fst s)
        (_ : Set.range ↑(PullbackCone.fst s).base ⊆ Set.range ↑(f D.toGlueData i j).base) ≫
      PullbackCone.snd (vPullbackCone D.toGlueData i j) =
    PullbackCone.snd s
[PROOFSTEP]
rw [← cancel_mono (𝖣.ι j), Category.assoc, ← (𝖣.vPullbackCone i j).condition]
[GOAL]
case refine'_3
C : Type u
inst✝¹ : Category.{v, u} C
D : GlueData C
inst✝ : HasLimits C
i j : D.J
s : PullbackCone (ι D.toGlueData i) (ι D.toGlueData j)
⊢ IsOpenImmersion.lift (f D.toGlueData i j) (PullbackCone.fst s)
        (_ : Set.range ↑(PullbackCone.fst s).base ⊆ Set.range ↑(f D.toGlueData i j).base) ≫
      PullbackCone.fst (vPullbackCone D.toGlueData i j) ≫ ι D.toGlueData i =
    PullbackCone.snd s ≫ ι D.toGlueData j
[PROOFSTEP]
conv_rhs => rw [← s.condition]
[GOAL]
C : Type u
inst✝¹ : Category.{v, u} C
D : GlueData C
inst✝ : HasLimits C
i j : D.J
s : PullbackCone (ι D.toGlueData i) (ι D.toGlueData j)
| PullbackCone.snd s ≫ ι D.toGlueData j
[PROOFSTEP]
rw [← s.condition]
[GOAL]
C : Type u
inst✝¹ : Category.{v, u} C
D : GlueData C
inst✝ : HasLimits C
i j : D.J
s : PullbackCone (ι D.toGlueData i) (ι D.toGlueData j)
| PullbackCone.snd s ≫ ι D.toGlueData j
[PROOFSTEP]
rw [← s.condition]
[GOAL]
C : Type u
inst✝¹ : Category.{v, u} C
D : GlueData C
inst✝ : HasLimits C
i j : D.J
s : PullbackCone (ι D.toGlueData i) (ι D.toGlueData j)
| PullbackCone.snd s ≫ ι D.toGlueData j
[PROOFSTEP]
rw [← s.condition]
[GOAL]
case refine'_3
C : Type u
inst✝¹ : Category.{v, u} C
D : GlueData C
inst✝ : HasLimits C
i j : D.J
s : PullbackCone (ι D.toGlueData i) (ι D.toGlueData j)
⊢ IsOpenImmersion.lift (f D.toGlueData i j) (PullbackCone.fst s)
        (_ : Set.range ↑(PullbackCone.fst s).base ⊆ Set.range ↑(f D.toGlueData i j).base) ≫
      PullbackCone.fst (vPullbackCone D.toGlueData i j) ≫ ι D.toGlueData i =
    PullbackCone.fst s ≫ ι D.toGlueData i
[PROOFSTEP]
erw [IsOpenImmersion.lift_fac_assoc]
[GOAL]
case refine'_4
C : Type u
inst✝¹ : Category.{v, u} C
D : GlueData C
inst✝ : HasLimits C
i j : D.J
s : PullbackCone (ι D.toGlueData i) (ι D.toGlueData j)
⊢ ∀ {m : s.pt ⟶ (vPullbackCone D.toGlueData i j).pt},
    m ≫ PullbackCone.fst (vPullbackCone D.toGlueData i j) = PullbackCone.fst s →
      m ≫ PullbackCone.snd (vPullbackCone D.toGlueData i j) = PullbackCone.snd s →
        m =
          IsOpenImmersion.lift (f D.toGlueData i j) (PullbackCone.fst s)
            (_ : Set.range ↑(PullbackCone.fst s).base ⊆ Set.range ↑(f D.toGlueData i j).base)
[PROOFSTEP]
intro m e₁ _
[GOAL]
case refine'_4
C : Type u
inst✝¹ : Category.{v, u} C
D : GlueData C
inst✝ : HasLimits C
i j : D.J
s : PullbackCone (ι D.toGlueData i) (ι D.toGlueData j)
m : s.pt ⟶ (vPullbackCone D.toGlueData i j).pt
e₁ : m ≫ PullbackCone.fst (vPullbackCone D.toGlueData i j) = PullbackCone.fst s
a✝ : m ≫ PullbackCone.snd (vPullbackCone D.toGlueData i j) = PullbackCone.snd s
⊢ m =
    IsOpenImmersion.lift (f D.toGlueData i j) (PullbackCone.fst s)
      (_ : Set.range ↑(PullbackCone.fst s).base ⊆ Set.range ↑(f D.toGlueData i j).base)
[PROOFSTEP]
rw [← cancel_mono (D.f i j)]
[GOAL]
case refine'_4
C : Type u
inst✝¹ : Category.{v, u} C
D : GlueData C
inst✝ : HasLimits C
i j : D.J
s : PullbackCone (ι D.toGlueData i) (ι D.toGlueData j)
m : s.pt ⟶ (vPullbackCone D.toGlueData i j).pt
e₁ : m ≫ PullbackCone.fst (vPullbackCone D.toGlueData i j) = PullbackCone.fst s
a✝ : m ≫ PullbackCone.snd (vPullbackCone D.toGlueData i j) = PullbackCone.snd s
⊢ m ≫ f D.toGlueData i j =
    IsOpenImmersion.lift (f D.toGlueData i j) (PullbackCone.fst s)
        (_ : Set.range ↑(PullbackCone.fst s).base ⊆ Set.range ↑(f D.toGlueData i j).base) ≫
      f D.toGlueData i j
[PROOFSTEP]
erw [e₁]
[GOAL]
case refine'_4
C : Type u
inst✝¹ : Category.{v, u} C
D : GlueData C
inst✝ : HasLimits C
i j : D.J
s : PullbackCone (ι D.toGlueData i) (ι D.toGlueData j)
m : s.pt ⟶ (vPullbackCone D.toGlueData i j).pt
e₁ : m ≫ PullbackCone.fst (vPullbackCone D.toGlueData i j) = PullbackCone.fst s
a✝ : m ≫ PullbackCone.snd (vPullbackCone D.toGlueData i j) = PullbackCone.snd s
⊢ PullbackCone.fst s =
    IsOpenImmersion.lift (f D.toGlueData i j) (PullbackCone.fst s)
        (_ : Set.range ↑(PullbackCone.fst s).base ⊆ Set.range ↑(f D.toGlueData i j).base) ≫
      f D.toGlueData i j
[PROOFSTEP]
rw [IsOpenImmersion.lift_fac]
[GOAL]
C : Type u
inst✝² : Category.{v, u} C
inst✝¹ : HasProducts C
D : GlueData C
inst✝ : HasLimits C
i : D.J
⊢ IsOpenImmersion (ι D.toGlueData i)
[PROOFSTEP]
rw [← D.ι_isoPresheafedSpace_inv]
  -- Porting note : was `inferInstance`
[GOAL]
C : Type u
inst✝² : Category.{v, u} C
inst✝¹ : HasProducts C
D : GlueData C
inst✝ : HasLimits C
i : D.J
⊢ IsOpenImmersion (ι (toPresheafedSpaceGlueData D).toGlueData i ≫ (isoPresheafedSpace D).inv)
[PROOFSTEP]
refine PresheafedSpace.IsOpenImmersion.comp (hf := ?_) (hg := inferInstance)
[GOAL]
C : Type u
inst✝² : Category.{v, u} C
inst✝¹ : HasProducts C
D : GlueData C
inst✝ : HasLimits C
i : D.J
⊢ PresheafedSpace.IsOpenImmersion (ι (toPresheafedSpaceGlueData D).toGlueData i)
[PROOFSTEP]
apply PresheafedSpace.GlueData.ιIsOpenImmersion
[GOAL]
C : Type u
inst✝ : Category.{v, u} C
D : GlueData
i : D.J
⊢ IsOpenImmersion (ι D.toGlueData i)
[PROOFSTEP]
delta IsOpenImmersion
[GOAL]
C : Type u
inst✝ : Category.{v, u} C
D : GlueData
i : D.J
⊢ SheafedSpace.IsOpenImmersion (ι D.toGlueData i).val
[PROOFSTEP]
rw [← D.ι_isoSheafedSpace_inv]
[GOAL]
C : Type u
inst✝ : Category.{v, u} C
D : GlueData
i : D.J
⊢ SheafedSpace.IsOpenImmersion (ι (toSheafedSpaceGlueData D).toGlueData i ≫ (isoSheafedSpace D).inv)
[PROOFSTEP]
apply (config := { allowSynthFailures := true }) PresheafedSpace.IsOpenImmersion.comp
[GOAL]
case hf
C : Type u
inst✝ : Category.{v, u} C
D : GlueData
i : D.J
⊢ PresheafedSpace.IsOpenImmersion (ι (toSheafedSpaceGlueData D).toGlueData i)
[PROOFSTEP]
exact (D.toSheafedSpaceGlueData).ιIsOpenImmersion i