l3lab/ntp-mathlib huggingface dataset:
theorem ι_image_preimage_eq (i j : D.J) (U : Opens (D.U i).carrier) :
    (Opens.map (𝖣.ι j).base).obj ((D.ι_openEmbedding i).isOpenMap.functor.obj U) =
      (D.f_open j i).openFunctor.obj
        ((Opens.map (𝖣.t j i).base).obj ((Opens.map (𝖣.f i j).base).obj U)) := by
  ext1
  dsimp only [Opens.map_coe, IsOpenMap.functor_obj_coe]
  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`
  erw [coe_comp, coe_comp, coe_comp]
  rw [Set.image_comp, Set.preimage_comp]
  erw [Set.preimage_image_eq]
  · 

Proof state:
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))

Next tactic:
refine' Eq.trans (D.toTopGlueData.preimage_image_eq_image' _ _ _) _
theorem ι_image_preimage_eq (i j : D.J) (U : Opens (D.U i).carrier) :
    (Opens.map (𝖣.ι j).base).obj ((D.ι_openEmbedding i).isOpenMap.functor.obj U) =
      (D.f_open j i).openFunctor.obj
        ((Opens.map (𝖣.t j i).base).obj ((Opens.map (𝖣.f i j).base).obj U)) := by
  ext1
  dsimp only [Opens.map_coe, IsOpenMap.functor_obj_coe]
  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`
  erw [coe_comp, coe_comp, coe_comp]
  rw [Set.image_comp, Set.preimage_comp]
  erw [Set.preimage_image_eq]
  · refine' Eq.trans (D.toTopGlueData.preimage_image_eq_image' _ _ _) _
    

Proof state:
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))

Next tactic:
dsimp
theorem ι_image_preimage_eq (i j : D.J) (U : Opens (D.U i).carrier) :
    (Opens.map (𝖣.ι j).base).obj ((D.ι_openEmbedding i).isOpenMap.functor.obj U) =
      (D.f_open j i).openFunctor.obj
        ((Opens.map (𝖣.t j i).base).obj ((Opens.map (𝖣.f i j).base).obj U)) := by
  ext1
  dsimp only [Opens.map_coe, IsOpenMap.functor_obj_coe]
  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`
  erw [coe_comp, coe_comp, coe_comp]
  rw [Set.image_comp, Set.preimage_comp]
  erw [Set.preimage_image_eq]
  · refine' Eq.trans (D.toTopGlueData.preimage_image_eq_image' _ _ _) _
    dsimp
    

Proof state:
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))

Next tactic:
rw [coe_comp, Set.image_comp]
theorem ι_image_preimage_eq (i j : D.J) (U : Opens (D.U i).carrier) :
    (Opens.map (𝖣.ι j).base).obj ((D.ι_openEmbedding i).isOpenMap.functor.obj U) =
      (D.f_open j i).openFunctor.obj
        ((Opens.map (𝖣.t j i).base).obj ((Opens.map (𝖣.f i j).base).obj U)) := by
  ext1
  dsimp only [Opens.map_coe, IsOpenMap.functor_obj_coe]
  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`
  erw [coe_comp, coe_comp, coe_comp]
  rw [Set.image_comp, Set.preimage_comp]
  erw [Set.preimage_image_eq]
  · refine' Eq.trans (D.toTopGlueData.preimage_image_eq_image' _ _ _) _
    dsimp
    rw [coe_comp, Set.image_comp]
    

Proof state:
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))

Next tactic:
refine congr_arg (_ '' ·) ?_
theorem ι_image_preimage_eq (i j : D.J) (U : Opens (D.U i).carrier) :
    (Opens.map (𝖣.ι j).base).obj ((D.ι_openEmbedding i).isOpenMap.functor.obj U) =
      (D.f_open j i).openFunctor.obj
        ((Opens.map (𝖣.t j i).base).obj ((Opens.map (𝖣.f i j).base).obj U)) := by
  ext1
  dsimp only [Opens.map_coe, IsOpenMap.functor_obj_coe]
  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`
  erw [coe_comp, coe_comp, coe_comp]
  rw [Set.image_comp, Set.preimage_comp]
  erw [Set.preimage_image_eq]
  · refine' Eq.trans (D.toTopGlueData.preimage_image_eq_image' _ _ _) _
    dsimp
    rw [coe_comp, Set.image_comp]
    refine congr_arg (_ '' ·) ?_
    

Proof state:
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)

Next tactic:
rw [Set.eq_preimage_iff_image_eq, ← Set.image_comp]
theorem ι_image_preimage_eq (i j : D.J) (U : Opens (D.U i).carrier) :
    (Opens.map (𝖣.ι j).base).obj ((D.ι_openEmbedding i).isOpenMap.functor.obj U) =
      (D.f_open j i).openFunctor.obj
        ((Opens.map (𝖣.t j i).base).obj ((Opens.map (𝖣.f i j).base).obj U)) := by
  ext1
  dsimp only [Opens.map_coe, IsOpenMap.functor_obj_coe]
  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`
  erw [coe_comp, coe_comp, coe_comp]
  rw [Set.image_comp, Set.preimage_comp]
  erw [Set.preimage_image_eq]
  · refine' Eq.trans (D.toTopGlueData.preimage_image_eq_image' _ _ _) _
    dsimp
    rw [coe_comp, Set.image_comp]
    refine congr_arg (_ '' ·) ?_
    rw [Set.eq_preimage_iff_image_eq, ← Set.image_comp]
    

Proof state:
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

Next tactic:
swap
theorem ι_image_preimage_eq (i j : D.J) (U : Opens (D.U i).carrier) :
    (Opens.map (𝖣.ι j).base).obj ((D.ι_openEmbedding i).isOpenMap.functor.obj U) =
      (D.f_open j i).openFunctor.obj
        ((Opens.map (𝖣.t j i).base).obj ((Opens.map (𝖣.f i j).base).obj U)) := by
  ext1
  dsimp only [Opens.map_coe, IsOpenMap.functor_obj_coe]
  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`
  erw [coe_comp, coe_comp, coe_comp]
  rw [Set.image_comp, Set.preimage_comp]
  erw [Set.preimage_image_eq]
  · refine' Eq.trans (D.toTopGlueData.preimage_image_eq_image' _ _ _) _
    dsimp
    rw [coe_comp, Set.image_comp]
    refine congr_arg (_ '' ·) ?_
    rw [Set.eq_preimage_iff_image_eq, ← Set.image_comp]
    swap
    · 

Proof state:
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

Next tactic:
apply CategoryTheory.ConcreteCategory.bijective_of_isIso
theorem ι_image_preimage_eq (i j : D.J) (U : Opens (D.U i).carrier) :
    (Opens.map (𝖣.ι j).base).obj ((D.ι_openEmbedding i).isOpenMap.functor.obj U) =
      (D.f_open j i).openFunctor.obj
        ((Opens.map (𝖣.t j i).base).obj ((Opens.map (𝖣.f i j).base).obj U)) := by
  ext1
  dsimp only [Opens.map_coe, IsOpenMap.functor_obj_coe]
  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`
  erw [coe_comp, coe_comp, coe_comp]
  rw [Set.image_comp, Set.preimage_comp]
  erw [Set.preimage_image_eq]
  · refine' Eq.trans (D.toTopGlueData.preimage_image_eq_image' _ _ _) _
    dsimp
    rw [coe_comp, Set.image_comp]
    refine congr_arg (_ '' ·) ?_
    rw [Set.eq_preimage_iff_image_eq, ← Set.image_comp]
    swap
    · apply CategoryTheory.ConcreteCategory.bijective_of_isIso
    

Proof state:
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

Next tactic:
change (D.t i j ≫ D.t j i).base '' _ = _
theorem ι_image_preimage_eq (i j : D.J) (U : Opens (D.U i).carrier) :
    (Opens.map (𝖣.ι j).base).obj ((D.ι_openEmbedding i).isOpenMap.functor.obj U) =
      (D.f_open j i).openFunctor.obj
        ((Opens.map (𝖣.t j i).base).obj ((Opens.map (𝖣.f i j).base).obj U)) := by
  ext1
  dsimp only [Opens.map_coe, IsOpenMap.functor_obj_coe]
  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`
  erw [coe_comp, coe_comp, coe_comp]
  rw [Set.image_comp, Set.preimage_comp]
  erw [Set.preimage_image_eq]
  · refine' Eq.trans (D.toTopGlueData.preimage_image_eq_image' _ _ _) _
    dsimp
    rw [coe_comp, Set.image_comp]
    refine congr_arg (_ '' ·) ?_
    rw [Set.eq_preimage_iff_image_eq, ← Set.image_comp]
    swap
    · apply CategoryTheory.ConcreteCategory.bijective_of_isIso
    change (D.t i j ≫ D.t j i).base '' _ = _
    

Proof state:
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

Next tactic:
rw [𝖣.t_inv]
theorem ι_image_preimage_eq (i j : D.J) (U : Opens (D.U i).carrier) :
    (Opens.map (𝖣.ι j).base).obj ((D.ι_openEmbedding i).isOpenMap.functor.obj U) =
      (D.f_open j i).openFunctor.obj
        ((Opens.map (𝖣.t j i).base).obj ((Opens.map (𝖣.f i j).base).obj U)) := by
  ext1
  dsimp only [Opens.map_coe, IsOpenMap.functor_obj_coe]
  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`
  erw [coe_comp, coe_comp, coe_comp]
  rw [Set.image_comp, Set.preimage_comp]
  erw [Set.preimage_image_eq]
  · refine' Eq.trans (D.toTopGlueData.preimage_image_eq_image' _ _ _) _
    dsimp
    rw [coe_comp, Set.image_comp]
    refine congr_arg (_ '' ·) ?_
    rw [Set.eq_preimage_iff_image_eq, ← Set.image_comp]
    swap
    · apply CategoryTheory.ConcreteCategory.bijective_of_isIso
    change (D.t i j ≫ D.t j i).base '' _ = _
    rw [𝖣.t_inv]
    

Proof state:
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

Next tactic:
simp
theorem ι_image_preimage_eq (i j : D.J) (U : Opens (D.U i).carrier) :
    (Opens.map (𝖣.ι j).base).obj ((D.ι_openEmbedding i).isOpenMap.functor.obj U) =
      (D.f_open j i).openFunctor.obj
        ((Opens.map (𝖣.t j i).base).obj ((Opens.map (𝖣.f i j).base).obj U)) := by
  ext1
  dsimp only [Opens.map_coe, IsOpenMap.functor_obj_coe]
  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`
  erw [coe_comp, coe_comp, coe_comp]
  rw [Set.image_comp, Set.preimage_comp]
  erw [Set.preimage_image_eq]
  · refine' Eq.trans (D.toTopGlueData.preimage_image_eq_image' _ _ _) _
    dsimp
    rw [coe_comp, Set.image_comp]
    refine congr_arg (_ '' ·) ?_
    rw [Set.eq_preimage_iff_image_eq, ← Set.image_comp]
    swap
    · apply CategoryTheory.ConcreteCategory.bijective_of_isIso
    change (D.t i j ≫ D.t j i).base '' _ = _
    rw [𝖣.t_inv]
    simp
  · 

Proof state:
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)

Next tactic:
rw [← coe_comp, ← TopCat.mono_iff_injective]
theorem ι_image_preimage_eq (i j : D.J) (U : Opens (D.U i).carrier) :
    (Opens.map (𝖣.ι j).base).obj ((D.ι_openEmbedding i).isOpenMap.functor.obj U) =
      (D.f_open j i).openFunctor.obj
        ((Opens.map (𝖣.t j i).base).obj ((Opens.map (𝖣.f i j).base).obj U)) := by
  ext1
  dsimp only [Opens.map_coe, IsOpenMap.functor_obj_coe]
  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`
  erw [coe_comp, coe_comp, coe_comp]
  rw [Set.image_comp, Set.preimage_comp]
  erw [Set.preimage_image_eq]
  · refine' Eq.trans (D.toTopGlueData.preimage_image_eq_image' _ _ _) _
    dsimp
    rw [coe_comp, Set.image_comp]
    refine congr_arg (_ '' ·) ?_
    rw [Set.eq_preimage_iff_image_eq, ← Set.image_comp]
    swap
    · apply CategoryTheory.ConcreteCategory.bijective_of_isIso
    change (D.t i j ≫ D.t j i).base '' _ = _
    rw [𝖣.t_inv]
    simp
  · rw [← coe_comp, ← TopCat.mono_iff_injective]
    

Proof state:
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)

Next tactic:
infer_instance
theorem opensImagePreimageMap_app' (i j k : D.J) (U : Opens (D.U i).carrier) :
    ∃ eq,
      D.opensImagePreimageMap i j U ≫ (D.f j k).c.app _ =
        ((π₁ j, i, k) ≫ D.t j i ≫ D.f i j).c.app (op U) ≫
          (π₂⁻¹ j, i, k) (unop _) ≫ (D.V (j, k)).presheaf.map (eqToHom eq) := by
  

Proof state:
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 :
    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)))),
    opensImagePreimageMap D i j U ≫
        (f D.toGlueData j k).c.app
          (op
            ((Opens.map (ι D.toGlueData j).base).obj
              ((IsOpenMap.functor (_ : IsOpenMap ⇑(ι D.toGlueData i).base)).obj U))) =
      (pullback.fst ≫ t D.toGlueData j i ≫ f D.toGlueData i j).c.app (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)

Next tactic:
constructor
theorem opensImagePreimageMap_app' (i j k : D.J) (U : Opens (D.U i).carrier) :
    ∃ eq,
      D.opensImagePreimageMap i j U ≫ (D.f j k).c.app _ =
        ((π₁ j, i, k) ≫ D.t j i ≫ D.f i j).c.app (op U) ≫
          (π₂⁻¹ j, i, k) (unop _) ≫ (D.V (j, k)).presheaf.map (eqToHom eq) := by
  constructor
  

Proof state:
case h
C : Type u
inst✝¹ : Category.{v, u} C
D : GlueData C
inst✝ : HasLimits C
i j k : D.J
U : Opens ↑↑(CategoryTheory.GlueData.U D.toGlueData i)
⊢ opensImagePreimageMap D i j U ≫
      (f D.toGlueData j k).c.app
        (op
          ((Opens.map (ι D.toGlueData j).base).obj
            ((IsOpenMap.functor (_ : IsOpenMap ⇑(ι D.toGlueData i).base)).obj U))) =
    (pullback.fst ≫ t D.toGlueData j i ≫ f D.toGlueData i j).c.app (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)))

Next tactic:
delta opensImagePreimageMap
theorem opensImagePreimageMap_app' (i j k : D.J) (U : Opens (D.U i).carrier) :
    ∃ eq,
      D.opensImagePreimageMap i j U ≫ (D.f j k).c.app _ =
        ((π₁ j, i, k) ≫ D.t j i ≫ D.f i j).c.app (op U) ≫
          (π₂⁻¹ j, i, k) (unop _) ≫ (D.V (j, k)).presheaf.map (eqToHom eq) := by
  constructor
  delta opensImagePreimageMap
  

Proof state:
case h
C : Type u
inst✝¹ : Category.{v, u} C
D : GlueData C
inst✝ : HasLimits C
i j k : D.J
U : Opens ↑↑(CategoryTheory.GlueData.U D.toGlueData i)
⊢ ((f D.toGlueData i j).c.app (op U) ≫
        (t D.toGlueData j i).c.app ((Opens.map (f D.toGlueData i j).base).op.obj (op U)) ≫
          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) ≫
      (f D.toGlueData j k).c.app
        (op
          ((Opens.map (ι D.toGlueData j).base).obj
            ((IsOpenMap.functor (_ : IsOpenMap ⇑(ι D.toGlueData i).base)).obj U))) =
    (pullback.fst ≫ t D.toGlueData j i ≫ f D.toGlueData i j).c.app (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)))

Next tactic:
simp_rw [Category.assoc]