l3lab/ntp-mathlib huggingface dataset:
theorem preimage_image_eq_image' (i j : D.J) (U : Set (𝖣.U i)) :
    𝖣.ι j ⁻¹' (𝖣.ι i '' U) = (D.t i j ≫ D.f _ _) '' (D.f _ _ ⁻¹' U) := by
  convert D.preimage_image_eq_image i j U using 1
  

Proof state:
case h.e'_3
D : GlueData
i j : D.J
U : Set ↑(GlueData.U D.toGlueData i)
⊢ ⇑(GlueData.t D.toGlueData i j ≫ GlueData.f D.toGlueData j i) '' (⇑(GlueData.f D.toGlueData i j) ⁻¹' U) =
    ⇑(GlueData.f D.toGlueData j i) '' (⇑(GlueData.t D.toGlueData j i ≫ GlueData.f D.toGlueData i j) ⁻¹' U)

Next tactic:
rw [coe_comp, coe_comp]
theorem preimage_image_eq_image' (i j : D.J) (U : Set (𝖣.U i)) :
    𝖣.ι j ⁻¹' (𝖣.ι i '' U) = (D.t i j ≫ D.f _ _) '' (D.f _ _ ⁻¹' U) := by
  convert D.preimage_image_eq_image i j U using 1
  rw [coe_comp, coe_comp]
  -- porting note: `show` was not needed, since `rw [← Set.image_image]` worked.
  

Proof state:
case h.e'_3
D : GlueData
i j : D.J
U : Set ↑(GlueData.U D.toGlueData i)
⊢ ⇑(GlueData.f D.toGlueData j i) ∘ ⇑(GlueData.t D.toGlueData i j) '' (⇑(GlueData.f D.toGlueData i j) ⁻¹' U) =
    ⇑(GlueData.f D.toGlueData j i) '' (⇑(GlueData.f D.toGlueData i j) ∘ ⇑(GlueData.t D.toGlueData j i) ⁻¹' U)

Next tactic:
show (fun x => ((forget TopCat).map _ ((forget TopCat).map _ x))) '' _ = _
theorem preimage_image_eq_image' (i j : D.J) (U : Set (𝖣.U i)) :
    𝖣.ι j ⁻¹' (𝖣.ι i '' U) = (D.t i j ≫ D.f _ _) '' (D.f _ _ ⁻¹' U) := by
  convert D.preimage_image_eq_image i j U using 1
  rw [coe_comp, coe_comp]
  -- porting note: `show` was not needed, since `rw [← Set.image_image]` worked.
  show (fun x => ((forget TopCat).map _ ((forget TopCat).map _ x))) '' _ = _
  

Proof state:
case h.e'_3
D : GlueData
i j : D.J
U : Set ↑(GlueData.U D.toGlueData i)
⊢ (fun x => (forget TopCat).map (GlueData.f D.toGlueData j i) ((forget TopCat).map (GlueData.t D.toGlueData i j) x)) ''
      (⇑(GlueData.f D.toGlueData i j) ⁻¹' U) =
    ⇑(GlueData.f D.toGlueData j i) '' (⇑(GlueData.f D.toGlueData i j) ∘ ⇑(GlueData.t D.toGlueData j i) ⁻¹' U)

Next tactic:
rw [← Set.image_image]
theorem preimage_image_eq_image' (i j : D.J) (U : Set (𝖣.U i)) :
    𝖣.ι j ⁻¹' (𝖣.ι i '' U) = (D.t i j ≫ D.f _ _) '' (D.f _ _ ⁻¹' U) := by
  convert D.preimage_image_eq_image i j U using 1
  rw [coe_comp, coe_comp]
  -- porting note: `show` was not needed, since `rw [← Set.image_image]` worked.
  show (fun x => ((forget TopCat).map _ ((forget TopCat).map _ x))) '' _ = _
  rw [← Set.image_image]
  -- porting note: `congr 1` was here, instead of `congr_arg`, however, it did nothing.
  

Proof state:
case h.e'_3
D : GlueData
i j : D.J
U : Set ↑(GlueData.U D.toGlueData i)
⊢ (forget TopCat).map (GlueData.f D.toGlueData j i) ''
      ((fun x => (forget TopCat).map (GlueData.t D.toGlueData i j) x) '' (⇑(GlueData.f D.toGlueData i j) ⁻¹' U)) =
    ⇑(GlueData.f D.toGlueData j i) '' (⇑(GlueData.f D.toGlueData i j) ∘ ⇑(GlueData.t D.toGlueData j i) ⁻¹' U)

Next tactic:
refine congr_arg ?_ ?_
theorem preimage_image_eq_image' (i j : D.J) (U : Set (𝖣.U i)) :
    𝖣.ι j ⁻¹' (𝖣.ι i '' U) = (D.t i j ≫ D.f _ _) '' (D.f _ _ ⁻¹' U) := by
  convert D.preimage_image_eq_image i j U using 1
  rw [coe_comp, coe_comp]
  -- porting note: `show` was not needed, since `rw [← Set.image_image]` worked.
  show (fun x => ((forget TopCat).map _ ((forget TopCat).map _ x))) '' _ = _
  rw [← Set.image_image]
  -- porting note: `congr 1` was here, instead of `congr_arg`, however, it did nothing.
  refine congr_arg ?_ ?_
  

Proof state:
case h.e'_3
D : GlueData
i j : D.J
U : Set ↑(GlueData.U D.toGlueData i)
⊢ (fun x => (forget TopCat).map (GlueData.t D.toGlueData i j) x) '' (⇑(GlueData.f D.toGlueData i j) ⁻¹' U) =
    ⇑(GlueData.f D.toGlueData i j) ∘ ⇑(GlueData.t D.toGlueData j i) ⁻¹' U

Next tactic:
rw [← Set.eq_preimage_iff_image_eq, Set.preimage_preimage]
theorem preimage_image_eq_image' (i j : D.J) (U : Set (𝖣.U i)) :
    𝖣.ι j ⁻¹' (𝖣.ι i '' U) = (D.t i j ≫ D.f _ _) '' (D.f _ _ ⁻¹' U) := by
  convert D.preimage_image_eq_image i j U using 1
  rw [coe_comp, coe_comp]
  -- porting note: `show` was not needed, since `rw [← Set.image_image]` worked.
  show (fun x => ((forget TopCat).map _ ((forget TopCat).map _ x))) '' _ = _
  rw [← Set.image_image]
  -- porting note: `congr 1` was here, instead of `congr_arg`, however, it did nothing.
  refine congr_arg ?_ ?_
  rw [← Set.eq_preimage_iff_image_eq, Set.preimage_preimage]
  

Proof state:
case h.e'_3
D : GlueData
i j : D.J
U : Set ↑(GlueData.U D.toGlueData i)
⊢ ⇑(GlueData.f D.toGlueData i j) ⁻¹' U =
    (fun x =>
        (⇑(GlueData.f D.toGlueData i j) ∘ ⇑(GlueData.t D.toGlueData j i))
          ((forget TopCat).map (GlueData.t D.toGlueData i j) x)) ⁻¹'
      U
case h.e'_3.hf
D : GlueData
i j : D.J
U : Set ↑(GlueData.U D.toGlueData i)
⊢ Function.Bijective fun x => (forget TopCat).map (GlueData.t D.toGlueData i j) x

Next tactic:
change _ = (D.t i j ≫ D.t j i ≫ _) ⁻¹' _
theorem preimage_image_eq_image' (i j : D.J) (U : Set (𝖣.U i)) :
    𝖣.ι j ⁻¹' (𝖣.ι i '' U) = (D.t i j ≫ D.f _ _) '' (D.f _ _ ⁻¹' U) := by
  convert D.preimage_image_eq_image i j U using 1
  rw [coe_comp, coe_comp]
  -- porting note: `show` was not needed, since `rw [← Set.image_image]` worked.
  show (fun x => ((forget TopCat).map _ ((forget TopCat).map _ x))) '' _ = _
  rw [← Set.image_image]
  -- porting note: `congr 1` was here, instead of `congr_arg`, however, it did nothing.
  refine congr_arg ?_ ?_
  rw [← Set.eq_preimage_iff_image_eq, Set.preimage_preimage]
  change _ = (D.t i j ≫ D.t j i ≫ _) ⁻¹' _
  

Proof state:
case h.e'_3
D : GlueData
i j : D.J
U : Set ↑(GlueData.U D.toGlueData i)
⊢ ⇑(GlueData.f D.toGlueData i j) ⁻¹' U =
    ⇑(GlueData.t D.toGlueData i j ≫ GlueData.t D.toGlueData j i ≫ GlueData.f D.toGlueData i j) ⁻¹' U
case h.e'_3.hf
D : GlueData
i j : D.J
U : Set ↑(GlueData.U D.toGlueData i)
⊢ Function.Bijective fun x => (forget TopCat).map (GlueData.t D.toGlueData i j) x

Next tactic:
rw [𝖣.t_inv_assoc]
theorem preimage_image_eq_image' (i j : D.J) (U : Set (𝖣.U i)) :
    𝖣.ι j ⁻¹' (𝖣.ι i '' U) = (D.t i j ≫ D.f _ _) '' (D.f _ _ ⁻¹' U) := by
  convert D.preimage_image_eq_image i j U using 1
  rw [coe_comp, coe_comp]
  -- porting note: `show` was not needed, since `rw [← Set.image_image]` worked.
  show (fun x => ((forget TopCat).map _ ((forget TopCat).map _ x))) '' _ = _
  rw [← Set.image_image]
  -- porting note: `congr 1` was here, instead of `congr_arg`, however, it did nothing.
  refine congr_arg ?_ ?_
  rw [← Set.eq_preimage_iff_image_eq, Set.preimage_preimage]
  change _ = (D.t i j ≫ D.t j i ≫ _) ⁻¹' _
  rw [𝖣.t_inv_assoc]
  

Proof state:
case h.e'_3.hf
D : GlueData
i j : D.J
U : Set ↑(GlueData.U D.toGlueData i)
⊢ Function.Bijective fun x => (forget TopCat).map (GlueData.t D.toGlueData i j) x

Next tactic:
rw [← isIso_iff_bijective]
theorem preimage_image_eq_image' (i j : D.J) (U : Set (𝖣.U i)) :
    𝖣.ι j ⁻¹' (𝖣.ι i '' U) = (D.t i j ≫ D.f _ _) '' (D.f _ _ ⁻¹' U) := by
  convert D.preimage_image_eq_image i j U using 1
  rw [coe_comp, coe_comp]
  -- porting note: `show` was not needed, since `rw [← Set.image_image]` worked.
  show (fun x => ((forget TopCat).map _ ((forget TopCat).map _ x))) '' _ = _
  rw [← Set.image_image]
  -- porting note: `congr 1` was here, instead of `congr_arg`, however, it did nothing.
  refine congr_arg ?_ ?_
  rw [← Set.eq_preimage_iff_image_eq, Set.preimage_preimage]
  change _ = (D.t i j ≫ D.t j i ≫ _) ⁻¹' _
  rw [𝖣.t_inv_assoc]
  rw [← isIso_iff_bijective]
  

Proof state:
case h.e'_3.hf
D : GlueData
i j : D.J
U : Set ↑(GlueData.U D.toGlueData i)
⊢ IsIso fun x => (forget TopCat).map (GlueData.t D.toGlueData i j) x

Next tactic:
apply (forget TopCat).map_isIso
theorem open_image_open (i : D.J) (U : Opens (𝖣.U i)) : IsOpen (𝖣.ι i '' (U : Set (D.U i))) := by
  

Proof state:
D : GlueData
i : D.J
U : Opens ↑(GlueData.U D.toGlueData i)
⊢ IsOpen (⇑(GlueData.ι D.toGlueData i) '' ↑U)

Next tactic:
rw [isOpen_iff]
theorem open_image_open (i : D.J) (U : Opens (𝖣.U i)) : IsOpen (𝖣.ι i '' (U : Set (D.U i))) := by
  rw [isOpen_iff]
  

Proof state:
D : GlueData
i : D.J
U : Opens ↑(GlueData.U D.toGlueData i)
⊢ ∀ (i_1 : D.J), IsOpen (⇑(GlueData.ι D.toGlueData i_1) ⁻¹' (⇑(GlueData.ι D.toGlueData i) '' ↑U))

Next tactic:
intro j
theorem open_image_open (i : D.J) (U : Opens (𝖣.U i)) : IsOpen (𝖣.ι i '' (U : Set (D.U i))) := by
  rw [isOpen_iff]
  intro j
  

Proof state:
D : GlueData
i : D.J
U : Opens ↑(GlueData.U D.toGlueData i)
j : D.J
⊢ IsOpen (⇑(GlueData.ι D.toGlueData j) ⁻¹' (⇑(GlueData.ι D.toGlueData i) '' ↑U))

Next tactic:
rw [preimage_image_eq_image]
theorem open_image_open (i : D.J) (U : Opens (𝖣.U i)) : IsOpen (𝖣.ι i '' (U : Set (D.U i))) := by
  rw [isOpen_iff]
  intro j
  rw [preimage_image_eq_image]
  

Proof state:
D : GlueData
i : D.J
U : Opens ↑(GlueData.U D.toGlueData i)
j : D.J
⊢ IsOpen (⇑(GlueData.f D.toGlueData j i) '' (⇑(GlueData.t D.toGlueData j i ≫ GlueData.f D.toGlueData i j) ⁻¹' ↑U))

Next tactic:
apply (D.f_open _ _).isOpenMap
theorem open_image_open (i : D.J) (U : Opens (𝖣.U i)) : IsOpen (𝖣.ι i '' (U : Set (D.U i))) := by
  rw [isOpen_iff]
  intro j
  rw [preimage_image_eq_image]
  apply (D.f_open _ _).isOpenMap
  

Proof state:
case a
D : GlueData
i : D.J
U : Opens ↑(GlueData.U D.toGlueData i)
j : D.J
⊢ IsOpen (⇑(GlueData.t D.toGlueData j i ≫ GlueData.f D.toGlueData i j) ⁻¹' ↑U)

Next tactic:
apply (D.t j i ≫ D.f i j).continuous_toFun.isOpen_preimage
theorem open_image_open (i : D.J) (U : Opens (𝖣.U i)) : IsOpen (𝖣.ι i '' (U : Set (D.U i))) := by
  rw [isOpen_iff]
  intro j
  rw [preimage_image_eq_image]
  apply (D.f_open _ _).isOpenMap
  apply (D.t j i ≫ D.f i j).continuous_toFun.isOpen_preimage
  

Proof state:
case a.a
D : GlueData
i : D.J
U : Opens ↑(GlueData.U D.toGlueData i)
j : D.J
⊢ IsOpen ↑U

Next tactic:
exact U.isOpen
theorem MkCore.t_inv (h : MkCore) (i j : h.J) (x : h.V j i) : h.t i j ((h.t j i) x) = x := by
  

Proof state:
D : GlueData
h : MkCore
i j : h.J
x : ↥(V h j i)
⊢ (t h i j) ((t h j i) x) = x

Next tactic:
have := h.cocycle j i j x ?_
theorem MkCore.t_inv (h : MkCore) (i j : h.J) (x : h.V j i) : h.t i j ((h.t j i) x) = x := by
  have := h.cocycle j i j x ?_
  

Proof state:
case refine_2
D : GlueData
h : MkCore
i j : h.J
x : ↥(V h j i)
this :
  ↑((t h i j) { val := ↑((t h j i) x), property := (_ : ↑((t h j i) x) ∈ V h i j) }) =
    ↑((t h j j) { val := ↑x, property := ?refine_1 })
⊢ (t h i j) ((t h j i) x) = x
case refine_1 D : GlueData h : MkCore i j : h.J x : ↥(V h j i) ⊢ ↑x ∈ V h j j

Next tactic:
rw [h.t_id] at this
theorem MkCore.t_inv (h : MkCore) (i j : h.J) (x : h.V j i) : h.t i j ((h.t j i) x) = x := by
  have := h.cocycle j i j x ?_
  rw [h.t_id] at this
  

Proof state:
case refine_2
D : GlueData
h : MkCore
i j : h.J
x : ↥(V h j i)
this :
  ↑((t h i j) { val := ↑((t h j i) x), property := (_ : ↑((t h j i) x) ∈ V h i j) }) =
    ↑(id { val := ↑x, property := ?refine_1 })
⊢ (t h i j) ((t h j i) x) = x
case refine_1
D : GlueData
h : MkCore
i j : h.J
x : ↥(V h j i)
⊢ ↑x ∈ V h j j
case refine_1 D : GlueData h : MkCore i j : h.J x : ↥(V h j i) ⊢ ↑x ∈ V h j j

Next tactic:
convert Subtype.eq this
theorem MkCore.t_inv (h : MkCore) (i j : h.J) (x : h.V j i) : h.t i j ((h.t j i) x) = x := by
  have := h.cocycle j i j x ?_
  rw [h.t_id] at this
  convert Subtype.eq this
  

Proof state:
case refine_1
D : GlueData
h : MkCore
i j : h.J
x : ↥(V h j i)
⊢ ↑x ∈ V h j j
case refine_1 D : GlueData h : MkCore i j : h.J x : ↥(V h j i) ⊢ ↑x ∈ V h j j

Next tactic:
rw [h.V_id]
theorem MkCore.t_inv (h : MkCore) (i j : h.J) (x : h.V j i) : h.t i j ((h.t j i) x) = x := by
  have := h.cocycle j i j x ?_
  rw [h.t_id] at this
  convert Subtype.eq this
  rw [h.V_id]
  

Proof state:
case refine_1
D : GlueData
h : MkCore
i j : h.J
x : ↥(V h j i)
⊢ ↑x ∈ ⊤

Next tactic:
trivial
instance (h : MkCore.{u}) (i j : h.J) : IsIso (h.t i j) := by
  

Proof state:
D : GlueData
h : MkCore
i j : h.J
⊢ IsIso (MkCore.t h i j)

Next tactic:
use h.t j i
instance (h : MkCore.{u}) (i j : h.J) : IsIso (h.t i j) := by
  use h.t j i; 

Proof state:
case h
D : GlueData
h : MkCore
i j : h.J
⊢ MkCore.t h i j ≫ MkCore.t h j i = 𝟙 ((Opens.toTopCat (MkCore.U h i)).obj (MkCore.V h i j)) ∧
    MkCore.t h j i ≫ MkCore.t h i j = 𝟙 ((Opens.toTopCat (MkCore.U h j)).obj (MkCore.V h j i))

Next tactic:
constructor
instance (h : MkCore.{u}) (i j : h.J) : IsIso (h.t i j) := by
  use h.t j i; constructor <;> 

Proof state:
case h.left
D : GlueData
h : MkCore
i j : h.J
⊢ MkCore.t h i j ≫ MkCore.t h j i = 𝟙 ((Opens.toTopCat (MkCore.U h i)).obj (MkCore.V h i j))

Next tactic:
ext1
instance (h : MkCore.{u}) (i j : h.J) : IsIso (h.t i j) := by
  use h.t j i; constructor <;> 

Proof state:
case h.right
D : GlueData
h : MkCore
i j : h.J
⊢ MkCore.t h j i ≫ MkCore.t h i j = 𝟙 ((Opens.toTopCat (MkCore.U h j)).obj (MkCore.V h j i))

Next tactic:
ext1
instance (h : MkCore.{u}) (i j : h.J) : IsIso (h.t i j) := by
  use h.t j i; constructor <;> ext1; 

Proof state:
case h.left.w
D : GlueData
h : MkCore
i j : h.J
x✝ : (forget TopCat).obj ((Opens.toTopCat (MkCore.U h i)).obj (MkCore.V h i j))
⊢ (MkCore.t h i j ≫ MkCore.t h j i) x✝ = (𝟙 ((Opens.toTopCat (MkCore.U h i)).obj (MkCore.V h i j))) x✝
case h.right.w
D : GlueData
h : MkCore
i j : h.J
x✝ : (forget TopCat).obj ((Opens.toTopCat (MkCore.U h j)).obj (MkCore.V h j i))
⊢ (MkCore.t h j i ≫ MkCore.t h i j) x✝ = (𝟙 ((Opens.toTopCat (MkCore.U h j)).obj (MkCore.V h j i))) x✝

Next tactic:
exacts [h.t_inv _ _ _, h.t_inv _ _ _]
/-- (Implementation) the restricted transition map to be fed into `TopCat.GlueData`. -/
def MkCore.t' (h : MkCore.{u}) (i j k : h.J) :
    pullback (h.V i j).inclusion (h.V i k).inclusion ⟶
      pullback (h.V j k).inclusion (h.V j i).inclusion := by
  

Proof state:
D : GlueData
h : MkCore
i j k : h.J
⊢ pullback (Opens.inclusion (V h i j)) (Opens.inclusion (V h i k)) ⟶
    pullback (Opens.inclusion (V h j k)) (Opens.inclusion (V h j i))

Next tactic:
refine' (pullbackIsoProdSubtype _ _).hom ≫ ⟨_, _⟩ ≫ (pullbackIsoProdSubtype _ _).inv
/-- (Implementation) the restricted transition map to be fed into `TopCat.GlueData`. -/
def MkCore.t' (h : MkCore.{u}) (i j k : h.J) :
    pullback (h.V i j).inclusion (h.V i k).inclusion ⟶
      pullback (h.V j k).inclusion (h.V j i).inclusion := by
  refine' (pullbackIsoProdSubtype _ _).hom ≫ ⟨_, _⟩ ≫ (pullbackIsoProdSubtype _ _).inv
  · 

Proof state:
case refine'_1
D : GlueData
h : MkCore
i j k : h.J
⊢ ↑(of { p // (Opens.inclusion (V h i j)) p.1 = (Opens.inclusion (V h i k)) p.2 }) →
    ↑(of { p // (Opens.inclusion (V h j k)) p.1 = (Opens.inclusion (V h j i)) p.2 })

Next tactic:
intro x
/-- (Implementation) the restricted transition map to be fed into `TopCat.GlueData`. -/
def MkCore.t' (h : MkCore.{u}) (i j k : h.J) :
    pullback (h.V i j).inclusion (h.V i k).inclusion ⟶
      pullback (h.V j k).inclusion (h.V j i).inclusion := by
  refine' (pullbackIsoProdSubtype _ _).hom ≫ ⟨_, _⟩ ≫ (pullbackIsoProdSubtype _ _).inv
  · intro x
    

Proof state:
case refine'_1
D : GlueData
h : MkCore
i j k : h.J
x : ↑(of { p // (Opens.inclusion (V h i j)) p.1 = (Opens.inclusion (V h i k)) p.2 })
⊢ ↑(of { p // (Opens.inclusion (V h j k)) p.1 = (Opens.inclusion (V h j i)) p.2 })

Next tactic:
refine' ⟨⟨⟨(h.t i j x.1.1).1, _⟩, h.t i j x.1.1⟩, rfl⟩
/-- (Implementation) the restricted transition map to be fed into `TopCat.GlueData`. -/
def MkCore.t' (h : MkCore.{u}) (i j k : h.J) :
    pullback (h.V i j).inclusion (h.V i k).inclusion ⟶
      pullback (h.V j k).inclusion (h.V j i).inclusion := by
  refine' (pullbackIsoProdSubtype _ _).hom ≫ ⟨_, _⟩ ≫ (pullbackIsoProdSubtype _ _).inv
  · intro x
    refine' ⟨⟨⟨(h.t i j x.1.1).1, _⟩, h.t i j x.1.1⟩, rfl⟩
    

Proof state:
case refine'_1
D : GlueData
h : MkCore
i j k : h.J
x : ↑(of { p // (Opens.inclusion (V h i j)) p.1 = (Opens.inclusion (V h i k)) p.2 })
⊢ ↑((t h i j) (↑x).1) ∈ V h j k

Next tactic:
rcases x with ⟨⟨⟨x, hx⟩, ⟨x', hx'⟩⟩, rfl : x = x'⟩
/-- (Implementation) the restricted transition map to be fed into `TopCat.GlueData`. -/
def MkCore.t' (h : MkCore.{u}) (i j k : h.J) :
    pullback (h.V i j).inclusion (h.V i k).inclusion ⟶
      pullback (h.V j k).inclusion (h.V j i).inclusion := by
  refine' (pullbackIsoProdSubtype _ _).hom ≫ ⟨_, _⟩ ≫ (pullbackIsoProdSubtype _ _).inv
  · intro x
    refine' ⟨⟨⟨(h.t i j x.1.1).1, _⟩, h.t i j x.1.1⟩, rfl⟩
    rcases x with ⟨⟨⟨x, hx⟩, ⟨x', hx'⟩⟩, rfl : x = x'⟩
    

Proof state:
case refine'_1.mk.mk.mk.mk
D : GlueData
h : MkCore
i j k : h.J
x : ↑(U h i)
hx : x ∈ V h i j
hx' : x ∈ V h i k
⊢ ↑((t h i j) (↑{ val := ({ val := x, property := hx }, { val := x, property := hx' }), property := (_ : x = x) }).1) ∈
    V h j k

Next tactic:
exact h.t_inter _ ⟨x, hx⟩ hx'
/-- (Implementation) the restricted transition map to be fed into `TopCat.GlueData`. -/
def MkCore.t' (h : MkCore.{u}) (i j k : h.J) :
    pullback (h.V i j).inclusion (h.V i k).inclusion ⟶
      pullback (h.V j k).inclusion (h.V j i).inclusion := by
  refine' (pullbackIsoProdSubtype _ _).hom ≫ ⟨_, _⟩ ≫ (pullbackIsoProdSubtype _ _).inv
  · intro x
    refine' ⟨⟨⟨(h.t i j x.1.1).1, _⟩, h.t i j x.1.1⟩, rfl⟩
    rcases x with ⟨⟨⟨x, hx⟩, ⟨x', hx'⟩⟩, rfl : x = x'⟩
    exact h.t_inter _ ⟨x, hx⟩ hx'
  -- Porting note: was `continuity`, see https://github.com/leanprover-community/mathlib4/issues/5030
  

Proof state:
case refine'_2
D : GlueData
h : MkCore
i j k : h.J
⊢ Continuous fun x =>
    { val := ({ val := ↑((t h i j) (↑x).1), property := (_ : ↑((t h i j) (↑x).1) ∈ V h j k) }, (t h i j) (↑x).1),
      property :=
        (_ :
          (Opens.inclusion (V h j k))
              ({ val := ↑((t h i j) (↑x).1), property := (_ : ↑((t h i j) (↑x).1) ∈ V h j k) }, (t h i j) (↑x).1).1 =
            (Opens.inclusion (V h j k))
              ({ val := ↑((t h i j) (↑x).1), property := (_ : ↑((t h i j) (↑x).1) ∈ V h j k) }, (t h i j) (↑x).1).1) }

Next tactic:
have : Continuous (h.t i j) := map_continuous (self := ContinuousMap.toContinuousMapClass) _
/-- (Implementation) the restricted transition map to be fed into `TopCat.GlueData`. -/
def MkCore.t' (h : MkCore.{u}) (i j k : h.J) :
    pullback (h.V i j).inclusion (h.V i k).inclusion ⟶
      pullback (h.V j k).inclusion (h.V j i).inclusion := by
  refine' (pullbackIsoProdSubtype _ _).hom ≫ ⟨_, _⟩ ≫ (pullbackIsoProdSubtype _ _).inv
  · intro x
    refine' ⟨⟨⟨(h.t i j x.1.1).1, _⟩, h.t i j x.1.1⟩, rfl⟩
    rcases x with ⟨⟨⟨x, hx⟩, ⟨x', hx'⟩⟩, rfl : x = x'⟩
    exact h.t_inter _ ⟨x, hx⟩ hx'
  -- Porting note: was `continuity`, see https://github.com/leanprover-community/mathlib4/issues/5030
  have : Continuous (h.t i j) := map_continuous (self := ContinuousMap.toContinuousMapClass) _
  

Proof state:
case refine'_2
D : GlueData
h : MkCore
i j k : h.J
this : Continuous ⇑(t h i j)
⊢ Continuous fun x =>
    { val := ({ val := ↑((t h i j) (↑x).1), property := (_ : ↑((t h i j) (↑x).1) ∈ V h j k) }, (t h i j) (↑x).1),
      property :=
        (_ :
          (Opens.inclusion (V h j k))
              ({ val := ↑((t h i j) (↑x).1), property := (_ : ↑((t h i j) (↑x).1) ∈ V h j k) }, (t h i j) (↑x).1).1 =
            (Opens.inclusion (V h j k))
              ({ val := ↑((t h i j) (↑x).1), property := (_ : ↑((t h i j) (↑x).1) ∈ V h j k) }, (t h i j) (↑x).1).1) }

Next tactic:
exact ((Continuous.subtype_mk (by continuity) _).prod_mk (by continuity)).subtype_mk _
/-- (Implementation) the restricted transition map to be fed into `TopCat.GlueData`. -/
def MkCore.t' (h : MkCore.{u}) (i j k : h.J) :
    pullback (h.V i j).inclusion (h.V i k).inclusion ⟶
      pullback (h.V j k).inclusion (h.V j i).inclusion := by
  refine' (pullbackIsoProdSubtype _ _).hom ≫ ⟨_, _⟩ ≫ (pullbackIsoProdSubtype _ _).inv
  · intro x
    refine' ⟨⟨⟨(h.t i j x.1.1).1, _⟩, h.t i j x.1.1⟩, rfl⟩
    rcases x with ⟨⟨⟨x, hx⟩, ⟨x', hx'⟩⟩, rfl : x = x'⟩
    exact h.t_inter _ ⟨x, hx⟩ hx'
  -- Porting note: was `continuity`, see https://github.com/leanprover-community/mathlib4/issues/5030
  have : Continuous (h.t i j) := map_continuous (self := ContinuousMap.toContinuousMapClass) _
  exact ((Continuous.subtype_mk (by 

Proof state:
D : GlueData
h : MkCore
i j k : h.J
this : Continuous ⇑(t h i j)
⊢ Continuous fun x => ↑((t h i j) (↑x).1)

Next tactic:
continuity
/-- (Implementation) the restricted transition map to be fed into `TopCat.GlueData`. -/
def MkCore.t' (h : MkCore.{u}) (i j k : h.J) :
    pullback (h.V i j).inclusion (h.V i k).inclusion ⟶
      pullback (h.V j k).inclusion (h.V j i).inclusion := by
  refine' (pullbackIsoProdSubtype _ _).hom ≫ ⟨_, _⟩ ≫ (pullbackIsoProdSubtype _ _).inv
  · intro x
    refine' ⟨⟨⟨(h.t i j x.1.1).1, _⟩, h.t i j x.1.1⟩, rfl⟩
    rcases x with ⟨⟨⟨x, hx⟩, ⟨x', hx'⟩⟩, rfl : x = x'⟩
    exact h.t_inter _ ⟨x, hx⟩ hx'
  -- Porting note: was `continuity`, see https://github.com/leanprover-community/mathlib4/issues/5030
  have : Continuous (h.t i j) := map_continuous (self := ContinuousMap.toContinuousMapClass) _
  exact ((Continuous.subtype_mk (by continuity) _).prod_mk (by 

Proof state:
D : GlueData
h : MkCore
i j k : h.J
this : Continuous ⇑(t h i j)
⊢ Continuous fun x => (t h i j) (↑x).1

Next tactic:
continuity
/-- This is a constructor of `TopCat.GlueData` whose arguments are in terms of elements and
intersections rather than subobjects and pullbacks. Please refer to `TopCat.GlueData.MkCore` for
details. -/
def mk' (h : MkCore.{u}) : TopCat.GlueData where
  J := h.J
  U := h.U
  V i := (Opens.toTopCat _).obj (h.V i.1 i.2)
  f i j := (h.V i j).inclusion
  f_id i := by
    -- Porting note: added `dsimp only`
    

Proof state:
D : GlueData
h : MkCore
i : h.J
⊢ IsIso ((fun i j => Opens.inclusion (MkCore.V h i j)) i i)

Next tactic:
dsimp only
/-- This is a constructor of `TopCat.GlueData` whose arguments are in terms of elements and
intersections rather than subobjects and pullbacks. Please refer to `TopCat.GlueData.MkCore` for
details. -/
def mk' (h : MkCore.{u}) : TopCat.GlueData where
  J := h.J
  U := h.U
  V i := (Opens.toTopCat _).obj (h.V i.1 i.2)
  f i j := (h.V i j).inclusion
  f_id i := by
    -- Porting note: added `dsimp only`
    dsimp only
    

Proof state:
D : GlueData
h : MkCore
i : h.J
⊢ IsIso (Opens.inclusion (MkCore.V h i i))

Next tactic:
exact (h.V_id i).symm ▸ IsIso.of_iso (Opens.inclusionTopIso (h.U i))
/-- This is a constructor of `TopCat.GlueData` whose arguments are in terms of elements and
intersections rather than subobjects and pullbacks. Please refer to `TopCat.GlueData.MkCore` for
details. -/
def mk' (h : MkCore.{u}) : TopCat.GlueData where
  J := h.J
  U := h.U
  V i := (Opens.toTopCat _).obj (h.V i.1 i.2)
  f i j := (h.V i j).inclusion
  f_id i := by
    -- Porting note: added `dsimp only`
    dsimp only
    exact (h.V_id i).symm ▸ IsIso.of_iso (Opens.inclusionTopIso (h.U i))
  f_open := fun i j : h.J => (h.V i j).openEmbedding
  t := h.t
  t_id i := by 

Proof state:
D : GlueData
h : MkCore
i : h.J
⊢ MkCore.t h i i = 𝟙 ((fun i => (Opens.toTopCat (MkCore.U h i.1)).obj (MkCore.V h i.1 i.2)) (i, i))

Next tactic:
ext
/-- This is a constructor of `TopCat.GlueData` whose arguments are in terms of elements and
intersections rather than subobjects and pullbacks. Please refer to `TopCat.GlueData.MkCore` for
details. -/
def mk' (h : MkCore.{u}) : TopCat.GlueData where
  J := h.J
  U := h.U
  V i := (Opens.toTopCat _).obj (h.V i.1 i.2)
  f i j := (h.V i j).inclusion
  f_id i := by
    -- Porting note: added `dsimp only`
    dsimp only
    exact (h.V_id i).symm ▸ IsIso.of_iso (Opens.inclusionTopIso (h.U i))
  f_open := fun i j : h.J => (h.V i j).openEmbedding
  t := h.t
  t_id i := by ext; 

Proof state:
case w
D : GlueData
h : MkCore
i : h.J
x✝ : (forget TopCat).obj ((Opens.toTopCat (MkCore.U h i)).obj (MkCore.V h i i))
⊢ (MkCore.t h i i) x✝ = (𝟙 ((fun i => (Opens.toTopCat (MkCore.U h i.1)).obj (MkCore.V h i.1 i.2)) (i, i))) x✝

Next tactic:
rw [h.t_id]