[GOAL]
D : GlueData
U : Set ↑(GlueData.glued D.toGlueData)
⊢ IsOpen U ↔ ∀ (i : D.J), IsOpen (↑(GlueData.ι D.toGlueData i) ⁻¹' U)
[PROOFSTEP]
delta CategoryTheory.GlueData.ι
[GOAL]
D : GlueData
U : Set ↑(GlueData.glued D.toGlueData)
⊢ IsOpen U ↔ ∀ (i : D.J), IsOpen (↑(Multicoequalizer.π (GlueData.diagram D.toGlueData) i) ⁻¹' U)
[PROOFSTEP]
simp_rw [← Multicoequalizer.ι_sigmaπ 𝖣.diagram]
[GOAL]
D : GlueData
U : Set ↑(GlueData.glued D.toGlueData)
⊢ IsOpen U ↔
    ∀ (i : D.J),
      IsOpen
        (↑(Sigma.ι (GlueData.diagram D.toGlueData).right i ≫
              Multicoequalizer.sigmaπ (GlueData.diagram D.toGlueData)) ⁻¹'
          U)
[PROOFSTEP]
rw [← (homeoOfIso (Multicoequalizer.isoCoequalizer 𝖣.diagram).symm).isOpen_preimage]
[GOAL]
D : GlueData
U : Set ↑(GlueData.glued D.toGlueData)
⊢ IsOpen (↑(homeoOfIso (Multicoequalizer.isoCoequalizer (GlueData.diagram D.toGlueData)).symm) ⁻¹' U) ↔
    ∀ (i : D.J),
      IsOpen
        (↑(Sigma.ι (GlueData.diagram D.toGlueData).right i ≫
              Multicoequalizer.sigmaπ (GlueData.diagram D.toGlueData)) ⁻¹'
          U)
[PROOFSTEP]
rw [coequalizer_isOpen_iff]
[GOAL]
D : GlueData
U : Set ↑(GlueData.glued D.toGlueData)
⊢ IsOpen
      (↑(colimit.ι
            (parallelPair (MultispanIndex.fstSigmaMap (GlueData.diagram D.toGlueData))
              (MultispanIndex.sndSigmaMap (GlueData.diagram D.toGlueData)))
            WalkingParallelPair.one) ⁻¹'
        (↑(homeoOfIso (Multicoequalizer.isoCoequalizer (GlueData.diagram D.toGlueData)).symm) ⁻¹' U)) ↔
    ∀ (i : D.J),
      IsOpen
        (↑(Sigma.ι (GlueData.diagram D.toGlueData).right i ≫
              Multicoequalizer.sigmaπ (GlueData.diagram D.toGlueData)) ⁻¹'
          U)
[PROOFSTEP]
dsimp only [GlueData.diagram_l, GlueData.diagram_left, GlueData.diagram_r, GlueData.diagram_right, parallelPair_obj_one]
[GOAL]
D : GlueData
U : Set ↑(GlueData.glued D.toGlueData)
⊢ IsOpen
      (↑(colimit.ι
            (parallelPair (MultispanIndex.fstSigmaMap (GlueData.diagram D.toGlueData))
              (MultispanIndex.sndSigmaMap (GlueData.diagram D.toGlueData)))
            WalkingParallelPair.one) ⁻¹'
        (↑(homeoOfIso (Multicoequalizer.isoCoequalizer (GlueData.diagram D.toGlueData)).symm) ⁻¹' U)) ↔
    ∀ (i : D.J), IsOpen (↑(Sigma.ι D.U i ≫ Multicoequalizer.sigmaπ (GlueData.diagram D.toGlueData)) ⁻¹' U)
[PROOFSTEP]
rw [colimit_isOpen_iff.{_, u}]
  -- porting note: changed `.{u}` to `.{_,u}`.  fun fact: the proof
                                   -- breaks down if this `rw` is merged with the `rw` above.
[GOAL]
D : GlueData
U : Set ↑(GlueData.glued D.toGlueData)
⊢ (∀ (j : Discrete D.J),
      IsOpen
        (↑(colimit.ι (Discrete.functor D.U) j) ⁻¹'
          (↑(colimit.ι
                (parallelPair (MultispanIndex.fstSigmaMap (GlueData.diagram D.toGlueData))
                  (MultispanIndex.sndSigmaMap (GlueData.diagram D.toGlueData)))
                WalkingParallelPair.one) ⁻¹'
            (↑(homeoOfIso (Multicoequalizer.isoCoequalizer (GlueData.diagram D.toGlueData)).symm) ⁻¹' U)))) ↔
    ∀ (i : D.J), IsOpen (↑(Sigma.ι D.U i ≫ Multicoequalizer.sigmaπ (GlueData.diagram D.toGlueData)) ⁻¹' U)
[PROOFSTEP]
constructor
[GOAL]
case mp
D : GlueData
U : Set ↑(GlueData.glued D.toGlueData)
⊢ (∀ (j : Discrete D.J),
      IsOpen
        (↑(colimit.ι (Discrete.functor D.U) j) ⁻¹'
          (↑(colimit.ι
                (parallelPair (MultispanIndex.fstSigmaMap (GlueData.diagram D.toGlueData))
                  (MultispanIndex.sndSigmaMap (GlueData.diagram D.toGlueData)))
                WalkingParallelPair.one) ⁻¹'
            (↑(homeoOfIso (Multicoequalizer.isoCoequalizer (GlueData.diagram D.toGlueData)).symm) ⁻¹' U)))) →
    ∀ (i : D.J), IsOpen (↑(Sigma.ι D.U i ≫ Multicoequalizer.sigmaπ (GlueData.diagram D.toGlueData)) ⁻¹' U)
[PROOFSTEP]
intro h j
[GOAL]
case mp
D : GlueData
U : Set ↑(GlueData.glued D.toGlueData)
h :
  ∀ (j : Discrete D.J),
    IsOpen
      (↑(colimit.ι (Discrete.functor D.U) j) ⁻¹'
        (↑(colimit.ι
              (parallelPair (MultispanIndex.fstSigmaMap (GlueData.diagram D.toGlueData))
                (MultispanIndex.sndSigmaMap (GlueData.diagram D.toGlueData)))
              WalkingParallelPair.one) ⁻¹'
          (↑(homeoOfIso (Multicoequalizer.isoCoequalizer (GlueData.diagram D.toGlueData)).symm) ⁻¹' U)))
j : D.J
⊢ IsOpen (↑(Sigma.ι D.U j ≫ Multicoequalizer.sigmaπ (GlueData.diagram D.toGlueData)) ⁻¹' U)
[PROOFSTEP]
exact h ⟨j⟩
[GOAL]
case mpr
D : GlueData
U : Set ↑(GlueData.glued D.toGlueData)
⊢ (∀ (i : D.J), IsOpen (↑(Sigma.ι D.U i ≫ Multicoequalizer.sigmaπ (GlueData.diagram D.toGlueData)) ⁻¹' U)) →
    ∀ (j : Discrete D.J),
      IsOpen
        (↑(colimit.ι (Discrete.functor D.U) j) ⁻¹'
          (↑(colimit.ι
                (parallelPair (MultispanIndex.fstSigmaMap (GlueData.diagram D.toGlueData))
                  (MultispanIndex.sndSigmaMap (GlueData.diagram D.toGlueData)))
                WalkingParallelPair.one) ⁻¹'
            (↑(homeoOfIso (Multicoequalizer.isoCoequalizer (GlueData.diagram D.toGlueData)).symm) ⁻¹' U)))
[PROOFSTEP]
intro h j
[GOAL]
case mpr
D : GlueData
U : Set ↑(GlueData.glued D.toGlueData)
h : ∀ (i : D.J), IsOpen (↑(Sigma.ι D.U i ≫ Multicoequalizer.sigmaπ (GlueData.diagram D.toGlueData)) ⁻¹' U)
j : Discrete D.J
⊢ IsOpen
    (↑(colimit.ι (Discrete.functor D.U) j) ⁻¹'
      (↑(colimit.ι
            (parallelPair (MultispanIndex.fstSigmaMap (GlueData.diagram D.toGlueData))
              (MultispanIndex.sndSigmaMap (GlueData.diagram D.toGlueData)))
            WalkingParallelPair.one) ⁻¹'
        (↑(homeoOfIso (Multicoequalizer.isoCoequalizer (GlueData.diagram D.toGlueData)).symm) ⁻¹' U)))
[PROOFSTEP]
cases j
[GOAL]
case mpr.mk
D : GlueData
U : Set ↑(GlueData.glued D.toGlueData)
h : ∀ (i : D.J), IsOpen (↑(Sigma.ι D.U i ≫ Multicoequalizer.sigmaπ (GlueData.diagram D.toGlueData)) ⁻¹' U)
as✝ : D.J
⊢ IsOpen
    (↑(colimit.ι (Discrete.functor D.U) { as := as✝ }) ⁻¹'
      (↑(colimit.ι
            (parallelPair (MultispanIndex.fstSigmaMap (GlueData.diagram D.toGlueData))
              (MultispanIndex.sndSigmaMap (GlueData.diagram D.toGlueData)))
            WalkingParallelPair.one) ⁻¹'
        (↑(homeoOfIso (Multicoequalizer.isoCoequalizer (GlueData.diagram D.toGlueData)).symm) ⁻¹' U)))
[PROOFSTEP]
apply h
[GOAL]
D : GlueData
⊢ ∀ {x y : (i : D.J) × ↑(GlueData.U D.toGlueData i)}, Rel D x y → Rel D y x
[PROOFSTEP]
rintro a b (⟨⟨⟩⟩ | ⟨x, e₁, e₂⟩)
[GOAL]
case inl.refl
D : GlueData
a : (i : D.J) × ↑(GlueData.U D.toGlueData i)
⊢ Rel D a a
case inr.intro.intro
D : GlueData
a b : (i : D.J) × ↑(GlueData.U D.toGlueData i)
x : ↑(GlueData.V D.toGlueData (a.fst, b.fst))
e₁ : ↑(GlueData.f D.toGlueData a.fst b.fst) x = a.snd
e₂ : ↑(GlueData.f D.toGlueData b.fst a.fst) (↑(GlueData.t D.toGlueData a.fst b.fst) x) = b.snd
⊢ Rel D b a
[PROOFSTEP]
exacts [Or.inl rfl, Or.inr ⟨D.t _ _ x, by simp [e₁, e₂]⟩]
[GOAL]
D : GlueData
a b : (i : D.J) × ↑(GlueData.U D.toGlueData i)
x : ↑(GlueData.V D.toGlueData (a.fst, b.fst))
e₁ : ↑(GlueData.f D.toGlueData a.fst b.fst) x = a.snd
e₂ : ↑(GlueData.f D.toGlueData b.fst a.fst) (↑(GlueData.t D.toGlueData a.fst b.fst) x) = b.snd
⊢ ↑(GlueData.f D.toGlueData b.fst a.fst) (↑(GlueData.t D.toGlueData a.fst b.fst) x) = b.snd ∧
    ↑(GlueData.f D.toGlueData a.fst b.fst)
        (↑(GlueData.t D.toGlueData b.fst a.fst) (↑(GlueData.t D.toGlueData a.fst b.fst) x)) =
      a.snd
[PROOFSTEP]
simp [e₁, e₂]
[GOAL]
D : GlueData
⊢ ∀ {x y z : (i : D.J) × ↑(GlueData.U D.toGlueData i)}, Rel D x y → Rel D y z → Rel D x z
[PROOFSTEP]
rintro ⟨i, a⟩ ⟨j, b⟩ ⟨k, c⟩ (⟨⟨⟩⟩ | ⟨x, e₁, e₂⟩)
[GOAL]
case mk.mk.mk.inl.refl
D : GlueData
i : D.J
a : ↑(GlueData.U D.toGlueData i)
k : D.J
c : ↑(GlueData.U D.toGlueData k)
⊢ Rel D { fst := i, snd := a } { fst := k, snd := c } → Rel D { fst := i, snd := a } { fst := k, snd := c }
case mk.mk.mk.inr.intro.intro
D : GlueData
i : D.J
a : ↑(GlueData.U D.toGlueData i)
j : D.J
b : ↑(GlueData.U D.toGlueData j)
k : D.J
c : ↑(GlueData.U D.toGlueData k)
x : ↑(GlueData.V D.toGlueData ({ fst := i, snd := a }.fst, { fst := j, snd := b }.fst))
e₁ : ↑(GlueData.f D.toGlueData { fst := i, snd := a }.fst { fst := j, snd := b }.fst) x = { fst := i, snd := a }.snd
e₂ :
  ↑(GlueData.f D.toGlueData { fst := j, snd := b }.fst { fst := i, snd := a }.fst)
      (↑(GlueData.t D.toGlueData { fst := i, snd := a }.fst { fst := j, snd := b }.fst) x) =
    { fst := j, snd := b }.snd
⊢ Rel D { fst := j, snd := b } { fst := k, snd := c } → Rel D { fst := i, snd := a } { fst := k, snd := c }
[PROOFSTEP]
exact id
[GOAL]
case mk.mk.mk.inr.intro.intro
D : GlueData
i : D.J
a : ↑(GlueData.U D.toGlueData i)
j : D.J
b : ↑(GlueData.U D.toGlueData j)
k : D.J
c : ↑(GlueData.U D.toGlueData k)
x : ↑(GlueData.V D.toGlueData ({ fst := i, snd := a }.fst, { fst := j, snd := b }.fst))
e₁ : ↑(GlueData.f D.toGlueData { fst := i, snd := a }.fst { fst := j, snd := b }.fst) x = { fst := i, snd := a }.snd
e₂ :
  ↑(GlueData.f D.toGlueData { fst := j, snd := b }.fst { fst := i, snd := a }.fst)
      (↑(GlueData.t D.toGlueData { fst := i, snd := a }.fst { fst := j, snd := b }.fst) x) =
    { fst := j, snd := b }.snd
⊢ Rel D { fst := j, snd := b } { fst := k, snd := c } → Rel D { fst := i, snd := a } { fst := k, snd := c }
[PROOFSTEP]
rintro (⟨⟨⟩⟩ | ⟨y, e₃, e₄⟩)
[GOAL]
case mk.mk.mk.inr.intro.intro.inl.refl
D : GlueData
i : D.J
a : ↑(GlueData.U D.toGlueData i)
j : D.J
b : ↑(GlueData.U D.toGlueData j)
x : ↑(GlueData.V D.toGlueData ({ fst := i, snd := a }.fst, { fst := j, snd := b }.fst))
e₁ : ↑(GlueData.f D.toGlueData { fst := i, snd := a }.fst { fst := j, snd := b }.fst) x = { fst := i, snd := a }.snd
e₂ :
  ↑(GlueData.f D.toGlueData { fst := j, snd := b }.fst { fst := i, snd := a }.fst)
      (↑(GlueData.t D.toGlueData { fst := i, snd := a }.fst { fst := j, snd := b }.fst) x) =
    { fst := j, snd := b }.snd
⊢ Rel D { fst := i, snd := a } { fst := j, snd := b }
case mk.mk.mk.inr.intro.intro.inr.intro.intro
D : GlueData
i : D.J
a : ↑(GlueData.U D.toGlueData i)
j : D.J
b : ↑(GlueData.U D.toGlueData j)
k : D.J
c : ↑(GlueData.U D.toGlueData k)
x : ↑(GlueData.V D.toGlueData ({ fst := i, snd := a }.fst, { fst := j, snd := b }.fst))
e₁ : ↑(GlueData.f D.toGlueData { fst := i, snd := a }.fst { fst := j, snd := b }.fst) x = { fst := i, snd := a }.snd
e₂ :
  ↑(GlueData.f D.toGlueData { fst := j, snd := b }.fst { fst := i, snd := a }.fst)
      (↑(GlueData.t D.toGlueData { fst := i, snd := a }.fst { fst := j, snd := b }.fst) x) =
    { fst := j, snd := b }.snd
y : ↑(GlueData.V D.toGlueData ({ fst := j, snd := b }.fst, { fst := k, snd := c }.fst))
e₃ : ↑(GlueData.f D.toGlueData { fst := j, snd := b }.fst { fst := k, snd := c }.fst) y = { fst := j, snd := b }.snd
e₄ :
  ↑(GlueData.f D.toGlueData { fst := k, snd := c }.fst { fst := j, snd := b }.fst)
      (↑(GlueData.t D.toGlueData { fst := j, snd := b }.fst { fst := k, snd := c }.fst) y) =
    { fst := k, snd := c }.snd
⊢ Rel D { fst := i, snd := a } { fst := k, snd := c }
[PROOFSTEP]
exact Or.inr ⟨x, e₁, e₂⟩
[GOAL]
case mk.mk.mk.inr.intro.intro.inr.intro.intro
D : GlueData
i : D.J
a : ↑(GlueData.U D.toGlueData i)
j : D.J
b : ↑(GlueData.U D.toGlueData j)
k : D.J
c : ↑(GlueData.U D.toGlueData k)
x : ↑(GlueData.V D.toGlueData ({ fst := i, snd := a }.fst, { fst := j, snd := b }.fst))
e₁ : ↑(GlueData.f D.toGlueData { fst := i, snd := a }.fst { fst := j, snd := b }.fst) x = { fst := i, snd := a }.snd
e₂ :
  ↑(GlueData.f D.toGlueData { fst := j, snd := b }.fst { fst := i, snd := a }.fst)
      (↑(GlueData.t D.toGlueData { fst := i, snd := a }.fst { fst := j, snd := b }.fst) x) =
    { fst := j, snd := b }.snd
y : ↑(GlueData.V D.toGlueData ({ fst := j, snd := b }.fst, { fst := k, snd := c }.fst))
e₃ : ↑(GlueData.f D.toGlueData { fst := j, snd := b }.fst { fst := k, snd := c }.fst) y = { fst := j, snd := b }.snd
e₄ :
  ↑(GlueData.f D.toGlueData { fst := k, snd := c }.fst { fst := j, snd := b }.fst)
      (↑(GlueData.t D.toGlueData { fst := j, snd := b }.fst { fst := k, snd := c }.fst) y) =
    { fst := k, snd := c }.snd
⊢ Rel D { fst := i, snd := a } { fst := k, snd := c }
[PROOFSTEP]
let z := (pullbackIsoProdSubtype (D.f j i) (D.f j k)).inv ⟨⟨_, _⟩, e₂.trans e₃.symm⟩
[GOAL]
case mk.mk.mk.inr.intro.intro.inr.intro.intro
D : GlueData
i : D.J
a : ↑(GlueData.U D.toGlueData i)
j : D.J
b : ↑(GlueData.U D.toGlueData j)
k : D.J
c : ↑(GlueData.U D.toGlueData k)
x : ↑(GlueData.V D.toGlueData ({ fst := i, snd := a }.fst, { fst := j, snd := b }.fst))
e₁ : ↑(GlueData.f D.toGlueData { fst := i, snd := a }.fst { fst := j, snd := b }.fst) x = { fst := i, snd := a }.snd
e₂ :
  ↑(GlueData.f D.toGlueData { fst := j, snd := b }.fst { fst := i, snd := a }.fst)
      (↑(GlueData.t D.toGlueData { fst := i, snd := a }.fst { fst := j, snd := b }.fst) x) =
    { fst := j, snd := b }.snd
y : ↑(GlueData.V D.toGlueData ({ fst := j, snd := b }.fst, { fst := k, snd := c }.fst))
e₃ : ↑(GlueData.f D.toGlueData { fst := j, snd := b }.fst { fst := k, snd := c }.fst) y = { fst := j, snd := b }.snd
e₄ :
  ↑(GlueData.f D.toGlueData { fst := k, snd := c }.fst { fst := j, snd := b }.fst)
      (↑(GlueData.t D.toGlueData { fst := j, snd := b }.fst { fst := k, snd := c }.fst) y) =
    { fst := k, snd := c }.snd
z : (fun x => (forget TopCat).obj (pullback (GlueData.f D.toGlueData j i) (GlueData.f D.toGlueData j k)))
  { val := (↑(GlueData.t D.toGlueData { fst := i, snd := a }.fst { fst := j, snd := b }.fst) x, y),
    property :=
      (_ :
        ↑(GlueData.f D.toGlueData { fst := j, snd := b }.fst { fst := i, snd := a }.fst)
            (↑(GlueData.t D.toGlueData { fst := i, snd := a }.fst { fst := j, snd := b }.fst) x) =
          ↑(GlueData.f D.toGlueData j k)
            (↑(GlueData.t D.toGlueData { fst := i, snd := a }.fst { fst := j, snd := b }.fst) x, y).snd) } :=
  ↑(pullbackIsoProdSubtype (GlueData.f D.toGlueData j i) (GlueData.f D.toGlueData j k)).inv
    { val := (↑(GlueData.t D.toGlueData { fst := i, snd := a }.fst { fst := j, snd := b }.fst) x, y),
      property :=
        (_ :
          ↑(GlueData.f D.toGlueData { fst := j, snd := b }.fst { fst := i, snd := a }.fst)
              (↑(GlueData.t D.toGlueData { fst := i, snd := a }.fst { fst := j, snd := b }.fst) x) =
            ↑(GlueData.f D.toGlueData j k)
              (↑(GlueData.t D.toGlueData { fst := i, snd := a }.fst { fst := j, snd := b }.fst) x, y).snd) }
⊢ Rel D { fst := i, snd := a } { fst := k, snd := c }
[PROOFSTEP]
have eq₁ : (D.t j i) ((pullback.fst : _  /-(D.f j k)-/ ⟶ D.V (j, i)) z) = x := by simp
[GOAL]
D : GlueData
i : D.J
a : ↑(GlueData.U D.toGlueData i)
j : D.J
b : ↑(GlueData.U D.toGlueData j)
k : D.J
c : ↑(GlueData.U D.toGlueData k)
x : ↑(GlueData.V D.toGlueData ({ fst := i, snd := a }.fst, { fst := j, snd := b }.fst))
e₁ : ↑(GlueData.f D.toGlueData { fst := i, snd := a }.fst { fst := j, snd := b }.fst) x = { fst := i, snd := a }.snd
e₂ :
  ↑(GlueData.f D.toGlueData { fst := j, snd := b }.fst { fst := i, snd := a }.fst)
      (↑(GlueData.t D.toGlueData { fst := i, snd := a }.fst { fst := j, snd := b }.fst) x) =
    { fst := j, snd := b }.snd
y : ↑(GlueData.V D.toGlueData ({ fst := j, snd := b }.fst, { fst := k, snd := c }.fst))
e₃ : ↑(GlueData.f D.toGlueData { fst := j, snd := b }.fst { fst := k, snd := c }.fst) y = { fst := j, snd := b }.snd
e₄ :
  ↑(GlueData.f D.toGlueData { fst := k, snd := c }.fst { fst := j, snd := b }.fst)
      (↑(GlueData.t D.toGlueData { fst := j, snd := b }.fst { fst := k, snd := c }.fst) y) =
    { fst := k, snd := c }.snd
z : (fun x => (forget TopCat).obj (pullback (GlueData.f D.toGlueData j i) (GlueData.f D.toGlueData j k)))
  { val := (↑(GlueData.t D.toGlueData { fst := i, snd := a }.fst { fst := j, snd := b }.fst) x, y),
    property :=
      (_ :
        ↑(GlueData.f D.toGlueData { fst := j, snd := b }.fst { fst := i, snd := a }.fst)
            (↑(GlueData.t D.toGlueData { fst := i, snd := a }.fst { fst := j, snd := b }.fst) x) =
          ↑(GlueData.f D.toGlueData j k)
            (↑(GlueData.t D.toGlueData { fst := i, snd := a }.fst { fst := j, snd := b }.fst) x, y).snd) } :=
  ↑(pullbackIsoProdSubtype (GlueData.f D.toGlueData j i) (GlueData.f D.toGlueData j k)).inv
    { val := (↑(GlueData.t D.toGlueData { fst := i, snd := a }.fst { fst := j, snd := b }.fst) x, y),
      property :=
        (_ :
          ↑(GlueData.f D.toGlueData { fst := j, snd := b }.fst { fst := i, snd := a }.fst)
              (↑(GlueData.t D.toGlueData { fst := i, snd := a }.fst { fst := j, snd := b }.fst) x) =
            ↑(GlueData.f D.toGlueData j k)
              (↑(GlueData.t D.toGlueData { fst := i, snd := a }.fst { fst := j, snd := b }.fst) x, y).snd) }
⊢ ↑(GlueData.t D.toGlueData j i) (↑pullback.fst z) = x
[PROOFSTEP]
simp
[GOAL]
case mk.mk.mk.inr.intro.intro.inr.intro.intro
D : GlueData
i : D.J
a : ↑(GlueData.U D.toGlueData i)
j : D.J
b : ↑(GlueData.U D.toGlueData j)
k : D.J
c : ↑(GlueData.U D.toGlueData k)
x : ↑(GlueData.V D.toGlueData ({ fst := i, snd := a }.fst, { fst := j, snd := b }.fst))
e₁ : ↑(GlueData.f D.toGlueData { fst := i, snd := a }.fst { fst := j, snd := b }.fst) x = { fst := i, snd := a }.snd
e₂ :
  ↑(GlueData.f D.toGlueData { fst := j, snd := b }.fst { fst := i, snd := a }.fst)
      (↑(GlueData.t D.toGlueData { fst := i, snd := a }.fst { fst := j, snd := b }.fst) x) =
    { fst := j, snd := b }.snd
y : ↑(GlueData.V D.toGlueData ({ fst := j, snd := b }.fst, { fst := k, snd := c }.fst))
e₃ : ↑(GlueData.f D.toGlueData { fst := j, snd := b }.fst { fst := k, snd := c }.fst) y = { fst := j, snd := b }.snd
e₄ :
  ↑(GlueData.f D.toGlueData { fst := k, snd := c }.fst { fst := j, snd := b }.fst)
      (↑(GlueData.t D.toGlueData { fst := j, snd := b }.fst { fst := k, snd := c }.fst) y) =
    { fst := k, snd := c }.snd
z : (fun x => (forget TopCat).obj (pullback (GlueData.f D.toGlueData j i) (GlueData.f D.toGlueData j k)))
  { val := (↑(GlueData.t D.toGlueData { fst := i, snd := a }.fst { fst := j, snd := b }.fst) x, y),
    property :=
      (_ :
        ↑(GlueData.f D.toGlueData { fst := j, snd := b }.fst { fst := i, snd := a }.fst)
            (↑(GlueData.t D.toGlueData { fst := i, snd := a }.fst { fst := j, snd := b }.fst) x) =
          ↑(GlueData.f D.toGlueData j k)
            (↑(GlueData.t D.toGlueData { fst := i, snd := a }.fst { fst := j, snd := b }.fst) x, y).snd) } :=
  ↑(pullbackIsoProdSubtype (GlueData.f D.toGlueData j i) (GlueData.f D.toGlueData j k)).inv
    { val := (↑(GlueData.t D.toGlueData { fst := i, snd := a }.fst { fst := j, snd := b }.fst) x, y),
      property :=
        (_ :
          ↑(GlueData.f D.toGlueData { fst := j, snd := b }.fst { fst := i, snd := a }.fst)
              (↑(GlueData.t D.toGlueData { fst := i, snd := a }.fst { fst := j, snd := b }.fst) x) =
            ↑(GlueData.f D.toGlueData j k)
              (↑(GlueData.t D.toGlueData { fst := i, snd := a }.fst { fst := j, snd := b }.fst) x, y).snd) }
eq₁ : ↑(GlueData.t D.toGlueData j i) (↑pullback.fst z) = x
⊢ Rel D { fst := i, snd := a } { fst := k, snd := c }
[PROOFSTEP]
have eq₂ : (pullback.snd : _ ⟶ D.V _) z = y := pullbackIsoProdSubtype_inv_snd_apply _ _ _
[GOAL]
case mk.mk.mk.inr.intro.intro.inr.intro.intro
D : GlueData
i : D.J
a : ↑(GlueData.U D.toGlueData i)
j : D.J
b : ↑(GlueData.U D.toGlueData j)
k : D.J
c : ↑(GlueData.U D.toGlueData k)
x : ↑(GlueData.V D.toGlueData ({ fst := i, snd := a }.fst, { fst := j, snd := b }.fst))
e₁ : ↑(GlueData.f D.toGlueData { fst := i, snd := a }.fst { fst := j, snd := b }.fst) x = { fst := i, snd := a }.snd
e₂ :
  ↑(GlueData.f D.toGlueData { fst := j, snd := b }.fst { fst := i, snd := a }.fst)
      (↑(GlueData.t D.toGlueData { fst := i, snd := a }.fst { fst := j, snd := b }.fst) x) =
    { fst := j, snd := b }.snd
y : ↑(GlueData.V D.toGlueData ({ fst := j, snd := b }.fst, { fst := k, snd := c }.fst))
e₃ : ↑(GlueData.f D.toGlueData { fst := j, snd := b }.fst { fst := k, snd := c }.fst) y = { fst := j, snd := b }.snd
e₄ :
  ↑(GlueData.f D.toGlueData { fst := k, snd := c }.fst { fst := j, snd := b }.fst)
      (↑(GlueData.t D.toGlueData { fst := j, snd := b }.fst { fst := k, snd := c }.fst) y) =
    { fst := k, snd := c }.snd
z : (fun x => (forget TopCat).obj (pullback (GlueData.f D.toGlueData j i) (GlueData.f D.toGlueData j k)))
  { val := (↑(GlueData.t D.toGlueData { fst := i, snd := a }.fst { fst := j, snd := b }.fst) x, y),
    property :=
      (_ :
        ↑(GlueData.f D.toGlueData { fst := j, snd := b }.fst { fst := i, snd := a }.fst)
            (↑(GlueData.t D.toGlueData { fst := i, snd := a }.fst { fst := j, snd := b }.fst) x) =
          ↑(GlueData.f D.toGlueData j k)
            (↑(GlueData.t D.toGlueData { fst := i, snd := a }.fst { fst := j, snd := b }.fst) x, y).snd) } :=
  ↑(pullbackIsoProdSubtype (GlueData.f D.toGlueData j i) (GlueData.f D.toGlueData j k)).inv
    { val := (↑(GlueData.t D.toGlueData { fst := i, snd := a }.fst { fst := j, snd := b }.fst) x, y),
      property :=
        (_ :
          ↑(GlueData.f D.toGlueData { fst := j, snd := b }.fst { fst := i, snd := a }.fst)
              (↑(GlueData.t D.toGlueData { fst := i, snd := a }.fst { fst := j, snd := b }.fst) x) =
            ↑(GlueData.f D.toGlueData j k)
              (↑(GlueData.t D.toGlueData { fst := i, snd := a }.fst { fst := j, snd := b }.fst) x, y).snd) }
eq₁ : ↑(GlueData.t D.toGlueData j i) (↑pullback.fst z) = x
eq₂ : ↑pullback.snd z = y
⊢ Rel D { fst := i, snd := a } { fst := k, snd := c }
[PROOFSTEP]
clear_value z
[GOAL]
case mk.mk.mk.inr.intro.intro.inr.intro.intro
D : GlueData
i : D.J
a : ↑(GlueData.U D.toGlueData i)
j : D.J
b : ↑(GlueData.U D.toGlueData j)
k : D.J
c : ↑(GlueData.U D.toGlueData k)
x : ↑(GlueData.V D.toGlueData ({ fst := i, snd := a }.fst, { fst := j, snd := b }.fst))
e₁ : ↑(GlueData.f D.toGlueData { fst := i, snd := a }.fst { fst := j, snd := b }.fst) x = { fst := i, snd := a }.snd
e₂ :
  ↑(GlueData.f D.toGlueData { fst := j, snd := b }.fst { fst := i, snd := a }.fst)
      (↑(GlueData.t D.toGlueData { fst := i, snd := a }.fst { fst := j, snd := b }.fst) x) =
    { fst := j, snd := b }.snd
y : ↑(GlueData.V D.toGlueData ({ fst := j, snd := b }.fst, { fst := k, snd := c }.fst))
e₃ : ↑(GlueData.f D.toGlueData { fst := j, snd := b }.fst { fst := k, snd := c }.fst) y = { fst := j, snd := b }.snd
e₄ :
  ↑(GlueData.f D.toGlueData { fst := k, snd := c }.fst { fst := j, snd := b }.fst)
      (↑(GlueData.t D.toGlueData { fst := j, snd := b }.fst { fst := k, snd := c }.fst) y) =
    { fst := k, snd := c }.snd
z : (forget TopCat).obj (pullback (GlueData.f D.toGlueData j i) (GlueData.f D.toGlueData j k))
eq₁ : ↑(GlueData.t D.toGlueData j i) (↑pullback.fst z) = x
eq₂ : ↑pullback.snd z = y
⊢ Rel D { fst := i, snd := a } { fst := k, snd := c }
[PROOFSTEP]
right
[GOAL]
case mk.mk.mk.inr.intro.intro.inr.intro.intro.h
D : GlueData
i : D.J
a : ↑(GlueData.U D.toGlueData i)
j : D.J
b : ↑(GlueData.U D.toGlueData j)
k : D.J
c : ↑(GlueData.U D.toGlueData k)
x : ↑(GlueData.V D.toGlueData ({ fst := i, snd := a }.fst, { fst := j, snd := b }.fst))
e₁ : ↑(GlueData.f D.toGlueData { fst := i, snd := a }.fst { fst := j, snd := b }.fst) x = { fst := i, snd := a }.snd
e₂ :
  ↑(GlueData.f D.toGlueData { fst := j, snd := b }.fst { fst := i, snd := a }.fst)
      (↑(GlueData.t D.toGlueData { fst := i, snd := a }.fst { fst := j, snd := b }.fst) x) =
    { fst := j, snd := b }.snd
y : ↑(GlueData.V D.toGlueData ({ fst := j, snd := b }.fst, { fst := k, snd := c }.fst))
e₃ : ↑(GlueData.f D.toGlueData { fst := j, snd := b }.fst { fst := k, snd := c }.fst) y = { fst := j, snd := b }.snd
e₄ :
  ↑(GlueData.f D.toGlueData { fst := k, snd := c }.fst { fst := j, snd := b }.fst)
      (↑(GlueData.t D.toGlueData { fst := j, snd := b }.fst { fst := k, snd := c }.fst) y) =
    { fst := k, snd := c }.snd
z : (forget TopCat).obj (pullback (GlueData.f D.toGlueData j i) (GlueData.f D.toGlueData j k))
eq₁ : ↑(GlueData.t D.toGlueData j i) (↑pullback.fst z) = x
eq₂ : ↑pullback.snd z = y
⊢ ∃ x,
    ↑(GlueData.f D.toGlueData { fst := i, snd := a }.fst { fst := k, snd := c }.fst) x = { fst := i, snd := a }.snd ∧
      ↑(GlueData.f D.toGlueData { fst := k, snd := c }.fst { fst := i, snd := a }.fst)
          (↑(GlueData.t D.toGlueData { fst := i, snd := a }.fst { fst := k, snd := c }.fst) x) =
        { fst := k, snd := c }.snd
[PROOFSTEP]
use(pullback.fst : _ ⟶ D.V (i, k)) (D.t' _ _ _ z)
[GOAL]
case h
D : GlueData
i : D.J
a : ↑(GlueData.U D.toGlueData i)
j : D.J
b : ↑(GlueData.U D.toGlueData j)
k : D.J
c : ↑(GlueData.U D.toGlueData k)
x : ↑(GlueData.V D.toGlueData ({ fst := i, snd := a }.fst, { fst := j, snd := b }.fst))
e₁ : ↑(GlueData.f D.toGlueData { fst := i, snd := a }.fst { fst := j, snd := b }.fst) x = { fst := i, snd := a }.snd
e₂ :
  ↑(GlueData.f D.toGlueData { fst := j, snd := b }.fst { fst := i, snd := a }.fst)
      (↑(GlueData.t D.toGlueData { fst := i, snd := a }.fst { fst := j, snd := b }.fst) x) =
    { fst := j, snd := b }.snd
y : ↑(GlueData.V D.toGlueData ({ fst := j, snd := b }.fst, { fst := k, snd := c }.fst))
e₃ : ↑(GlueData.f D.toGlueData { fst := j, snd := b }.fst { fst := k, snd := c }.fst) y = { fst := j, snd := b }.snd
e₄ :
  ↑(GlueData.f D.toGlueData { fst := k, snd := c }.fst { fst := j, snd := b }.fst)
      (↑(GlueData.t D.toGlueData { fst := j, snd := b }.fst { fst := k, snd := c }.fst) y) =
    { fst := k, snd := c }.snd
z : (forget TopCat).obj (pullback (GlueData.f D.toGlueData j i) (GlueData.f D.toGlueData j k))
eq₁ : ↑(GlueData.t D.toGlueData j i) (↑pullback.fst z) = x
eq₂ : ↑pullback.snd z = y
⊢ ↑(GlueData.f D.toGlueData { fst := i, snd := a }.fst { fst := k, snd := c }.fst)
        (↑pullback.fst (↑(GlueData.t' D.toGlueData j i k) z)) =
      { fst := i, snd := a }.snd ∧
    ↑(GlueData.f D.toGlueData { fst := k, snd := c }.fst { fst := i, snd := a }.fst)
        (↑(GlueData.t D.toGlueData { fst := i, snd := a }.fst { fst := k, snd := c }.fst)
          (↑pullback.fst (↑(GlueData.t' D.toGlueData j i k) z))) =
      { fst := k, snd := c }.snd
[PROOFSTEP]
dsimp only at *
[GOAL]
case h
D : GlueData
i : D.J
a : ↑(GlueData.U D.toGlueData i)
j : D.J
b : ↑(GlueData.U D.toGlueData j)
k : D.J
c : ↑(GlueData.U D.toGlueData k)
x : ↑(GlueData.V D.toGlueData ({ fst := i, snd := a }.fst, { fst := j, snd := b }.fst))
e₁ : ↑(GlueData.f D.toGlueData i j) x = a
e₂ : ↑(GlueData.f D.toGlueData j i) (↑(GlueData.t D.toGlueData i j) x) = b
y : ↑(GlueData.V D.toGlueData ({ fst := j, snd := b }.fst, { fst := k, snd := c }.fst))
e₃ : ↑(GlueData.f D.toGlueData j k) y = b
e₄ : ↑(GlueData.f D.toGlueData k j) (↑(GlueData.t D.toGlueData j k) y) = c
z : (forget TopCat).obj (pullback (GlueData.f D.toGlueData j i) (GlueData.f D.toGlueData j k))
eq₁ : ↑(GlueData.t D.toGlueData j i) (↑pullback.fst z) = x
eq₂ : ↑pullback.snd z = y
⊢ ↑(GlueData.f D.toGlueData i k) (↑pullback.fst (↑(GlueData.t' D.toGlueData j i k) z)) = a ∧
    ↑(GlueData.f D.toGlueData k i)
        (↑(GlueData.t D.toGlueData i k) (↑pullback.fst (↑(GlueData.t' D.toGlueData j i k) z))) =
      c
[PROOFSTEP]
substs eq₁ eq₂ e₁ e₃ e₄
[GOAL]
case h
D : GlueData
i j k : D.J
z : (forget TopCat).obj (pullback (GlueData.f D.toGlueData j i) (GlueData.f D.toGlueData j k))
e₂ :
  ↑(GlueData.f D.toGlueData j i) (↑(GlueData.t D.toGlueData i j) (↑(GlueData.t D.toGlueData j i) (↑pullback.fst z))) =
    ↑(GlueData.f D.toGlueData j k) (↑pullback.snd z)
⊢ ↑(GlueData.f D.toGlueData i k) (↑pullback.fst (↑(GlueData.t' D.toGlueData j i k) z)) =
      ↑(GlueData.f D.toGlueData i j) (↑(GlueData.t D.toGlueData j i) (↑pullback.fst z)) ∧
    ↑(GlueData.f D.toGlueData k i)
        (↑(GlueData.t D.toGlueData i k) (↑pullback.fst (↑(GlueData.t' D.toGlueData j i k) z))) =
      ↑(GlueData.f D.toGlueData k j) (↑(GlueData.t D.toGlueData j k) (↑pullback.snd z))
[PROOFSTEP]
have h₁ : D.t' j i k ≫ pullback.fst ≫ D.f i k = pullback.fst ≫ D.t j i ≫ D.f i j := by rw [← 𝖣.t_fac_assoc]; congr 1;
  exact pullback.condition
[GOAL]
D : GlueData
i j k : D.J
z : (forget TopCat).obj (pullback (GlueData.f D.toGlueData j i) (GlueData.f D.toGlueData j k))
e₂ :
  ↑(GlueData.f D.toGlueData j i) (↑(GlueData.t D.toGlueData i j) (↑(GlueData.t D.toGlueData j i) (↑pullback.fst z))) =
    ↑(GlueData.f D.toGlueData j k) (↑pullback.snd z)
⊢ GlueData.t' D.toGlueData j i k ≫ pullback.fst ≫ GlueData.f D.toGlueData i k =
    pullback.fst ≫ GlueData.t D.toGlueData j i ≫ GlueData.f D.toGlueData i j
[PROOFSTEP]
rw [← 𝖣.t_fac_assoc]
[GOAL]
D : GlueData
i j k : D.J
z : (forget TopCat).obj (pullback (GlueData.f D.toGlueData j i) (GlueData.f D.toGlueData j k))
e₂ :
  ↑(GlueData.f D.toGlueData j i) (↑(GlueData.t D.toGlueData i j) (↑(GlueData.t D.toGlueData j i) (↑pullback.fst z))) =
    ↑(GlueData.f D.toGlueData j k) (↑pullback.snd z)
⊢ GlueData.t' D.toGlueData j i k ≫ pullback.fst ≫ GlueData.f D.toGlueData i k =
    GlueData.t' D.toGlueData j i k ≫ pullback.snd ≫ GlueData.f D.toGlueData i j
[PROOFSTEP]
congr 1
[GOAL]
case e_a
D : GlueData
i j k : D.J
z : (forget TopCat).obj (pullback (GlueData.f D.toGlueData j i) (GlueData.f D.toGlueData j k))
e₂ :
  ↑(GlueData.f D.toGlueData j i) (↑(GlueData.t D.toGlueData i j) (↑(GlueData.t D.toGlueData j i) (↑pullback.fst z))) =
    ↑(GlueData.f D.toGlueData j k) (↑pullback.snd z)
⊢ pullback.fst ≫ GlueData.f D.toGlueData i k = pullback.snd ≫ GlueData.f D.toGlueData i j
[PROOFSTEP]
exact pullback.condition
[GOAL]
case h
D : GlueData
i j k : D.J
z : (forget TopCat).obj (pullback (GlueData.f D.toGlueData j i) (GlueData.f D.toGlueData j k))
e₂ :
  ↑(GlueData.f D.toGlueData j i) (↑(GlueData.t D.toGlueData i j) (↑(GlueData.t D.toGlueData j i) (↑pullback.fst z))) =
    ↑(GlueData.f D.toGlueData j k) (↑pullback.snd z)
h₁ :
  GlueData.t' D.toGlueData j i k ≫ pullback.fst ≫ GlueData.f D.toGlueData i k =
    pullback.fst ≫ GlueData.t D.toGlueData j i ≫ GlueData.f D.toGlueData i j
⊢ ↑(GlueData.f D.toGlueData i k) (↑pullback.fst (↑(GlueData.t' D.toGlueData j i k) z)) =
      ↑(GlueData.f D.toGlueData i j) (↑(GlueData.t D.toGlueData j i) (↑pullback.fst z)) ∧
    ↑(GlueData.f D.toGlueData k i)
        (↑(GlueData.t D.toGlueData i k) (↑pullback.fst (↑(GlueData.t' D.toGlueData j i k) z))) =
      ↑(GlueData.f D.toGlueData k j) (↑(GlueData.t D.toGlueData j k) (↑pullback.snd z))
[PROOFSTEP]
have h₂ : D.t' j i k ≫ pullback.fst ≫ D.t i k ≫ D.f k i = pullback.snd ≫ D.t j k ≫ D.f k j :=
  by
  rw [← 𝖣.t_fac_assoc]
  apply @Epi.left_cancellation _ _ _ _ (D.t' k j i)
  rw [𝖣.cocycle_assoc, 𝖣.t_fac_assoc, 𝖣.t_inv_assoc]
  exact pullback.condition.symm
[GOAL]
D : GlueData
i j k : D.J
z : (forget TopCat).obj (pullback (GlueData.f D.toGlueData j i) (GlueData.f D.toGlueData j k))
e₂ :
  ↑(GlueData.f D.toGlueData j i) (↑(GlueData.t D.toGlueData i j) (↑(GlueData.t D.toGlueData j i) (↑pullback.fst z))) =
    ↑(GlueData.f D.toGlueData j k) (↑pullback.snd z)
h₁ :
  GlueData.t' D.toGlueData j i k ≫ pullback.fst ≫ GlueData.f D.toGlueData i k =
    pullback.fst ≫ GlueData.t D.toGlueData j i ≫ GlueData.f D.toGlueData i j
⊢ GlueData.t' D.toGlueData j i k ≫ pullback.fst ≫ GlueData.t D.toGlueData i k ≫ GlueData.f D.toGlueData k i =
    pullback.snd ≫ GlueData.t D.toGlueData j k ≫ GlueData.f D.toGlueData k j
[PROOFSTEP]
rw [← 𝖣.t_fac_assoc]
[GOAL]
D : GlueData
i j k : D.J
z : (forget TopCat).obj (pullback (GlueData.f D.toGlueData j i) (GlueData.f D.toGlueData j k))
e₂ :
  ↑(GlueData.f D.toGlueData j i) (↑(GlueData.t D.toGlueData i j) (↑(GlueData.t D.toGlueData j i) (↑pullback.fst z))) =
    ↑(GlueData.f D.toGlueData j k) (↑pullback.snd z)
h₁ :
  GlueData.t' D.toGlueData j i k ≫ pullback.fst ≫ GlueData.f D.toGlueData i k =
    pullback.fst ≫ GlueData.t D.toGlueData j i ≫ GlueData.f D.toGlueData i j
⊢ GlueData.t' D.toGlueData j i k ≫ GlueData.t' D.toGlueData i k j ≫ pullback.snd ≫ GlueData.f D.toGlueData k i =
    pullback.snd ≫ GlueData.t D.toGlueData j k ≫ GlueData.f D.toGlueData k j
[PROOFSTEP]
apply @Epi.left_cancellation _ _ _ _ (D.t' k j i)
[GOAL]
case a
D : GlueData
i j k : D.J
z : (forget TopCat).obj (pullback (GlueData.f D.toGlueData j i) (GlueData.f D.toGlueData j k))
e₂ :
  ↑(GlueData.f D.toGlueData j i) (↑(GlueData.t D.toGlueData i j) (↑(GlueData.t D.toGlueData j i) (↑pullback.fst z))) =
    ↑(GlueData.f D.toGlueData j k) (↑pullback.snd z)
h₁ :
  GlueData.t' D.toGlueData j i k ≫ pullback.fst ≫ GlueData.f D.toGlueData i k =
    pullback.fst ≫ GlueData.t D.toGlueData j i ≫ GlueData.f D.toGlueData i j
⊢ GlueData.t' D.toGlueData k j i ≫
      GlueData.t' D.toGlueData j i k ≫ GlueData.t' D.toGlueData i k j ≫ pullback.snd ≫ GlueData.f D.toGlueData k i =
    GlueData.t' D.toGlueData k j i ≫ pullback.snd ≫ GlueData.t D.toGlueData j k ≫ GlueData.f D.toGlueData k j
[PROOFSTEP]
rw [𝖣.cocycle_assoc, 𝖣.t_fac_assoc, 𝖣.t_inv_assoc]
[GOAL]
case a
D : GlueData
i j k : D.J
z : (forget TopCat).obj (pullback (GlueData.f D.toGlueData j i) (GlueData.f D.toGlueData j k))
e₂ :
  ↑(GlueData.f D.toGlueData j i) (↑(GlueData.t D.toGlueData i j) (↑(GlueData.t D.toGlueData j i) (↑pullback.fst z))) =
    ↑(GlueData.f D.toGlueData j k) (↑pullback.snd z)
h₁ :
  GlueData.t' D.toGlueData j i k ≫ pullback.fst ≫ GlueData.f D.toGlueData i k =
    pullback.fst ≫ GlueData.t D.toGlueData j i ≫ GlueData.f D.toGlueData i j
⊢ pullback.snd ≫ GlueData.f D.toGlueData k i = pullback.fst ≫ GlueData.f D.toGlueData k j
[PROOFSTEP]
exact pullback.condition.symm
[GOAL]
case h
D : GlueData
i j k : D.J
z : (forget TopCat).obj (pullback (GlueData.f D.toGlueData j i) (GlueData.f D.toGlueData j k))
e₂ :
  ↑(GlueData.f D.toGlueData j i) (↑(GlueData.t D.toGlueData i j) (↑(GlueData.t D.toGlueData j i) (↑pullback.fst z))) =
    ↑(GlueData.f D.toGlueData j k) (↑pullback.snd z)
h₁ :
  GlueData.t' D.toGlueData j i k ≫ pullback.fst ≫ GlueData.f D.toGlueData i k =
    pullback.fst ≫ GlueData.t D.toGlueData j i ≫ GlueData.f D.toGlueData i j
h₂ :
  GlueData.t' D.toGlueData j i k ≫ pullback.fst ≫ GlueData.t D.toGlueData i k ≫ GlueData.f D.toGlueData k i =
    pullback.snd ≫ GlueData.t D.toGlueData j k ≫ GlueData.f D.toGlueData k j
⊢ ↑(GlueData.f D.toGlueData i k) (↑pullback.fst (↑(GlueData.t' D.toGlueData j i k) z)) =
      ↑(GlueData.f D.toGlueData i j) (↑(GlueData.t D.toGlueData j i) (↑pullback.fst z)) ∧
    ↑(GlueData.f D.toGlueData k i)
        (↑(GlueData.t D.toGlueData i k) (↑pullback.fst (↑(GlueData.t' D.toGlueData j i k) z))) =
      ↑(GlueData.f D.toGlueData k j) (↑(GlueData.t D.toGlueData j k) (↑pullback.snd z))
[PROOFSTEP]
exact ⟨ContinuousMap.congr_fun h₁ z, ContinuousMap.congr_fun h₂ z⟩
[GOAL]
D : GlueData
x y : ↑(∐ D.U)
h : ↑(GlueData.π D.toGlueData) x = ↑(GlueData.π D.toGlueData) y
⊢ EqvGen
    (Types.CoequalizerRel ↑(MultispanIndex.fstSigmaMap (GlueData.diagram D.toGlueData))
      ↑(MultispanIndex.sndSigmaMap (GlueData.diagram D.toGlueData)))
    x y
[PROOFSTEP]
delta GlueData.π Multicoequalizer.sigmaπ at h 
[GOAL]
D : GlueData
x y : ↑(∐ D.U)
h :
  ↑(coequalizer.π (MultispanIndex.fstSigmaMap (GlueData.diagram D.toGlueData))
            (MultispanIndex.sndSigmaMap (GlueData.diagram D.toGlueData)) ≫
          (Multicoequalizer.isoCoequalizer (GlueData.diagram D.toGlueData)).inv)
      x =
    ↑(coequalizer.π (MultispanIndex.fstSigmaMap (GlueData.diagram D.toGlueData))
            (MultispanIndex.sndSigmaMap (GlueData.diagram D.toGlueData)) ≫
          (Multicoequalizer.isoCoequalizer (GlueData.diagram D.toGlueData)).inv)
      y
⊢ EqvGen
    (Types.CoequalizerRel ↑(MultispanIndex.fstSigmaMap (GlueData.diagram D.toGlueData))
      ↑(MultispanIndex.sndSigmaMap (GlueData.diagram D.toGlueData)))
    x y
[PROOFSTEP]
replace h := (TopCat.mono_iff_injective (Multicoequalizer.isoCoequalizer 𝖣.diagram).inv).mp inferInstance h
[GOAL]
D : GlueData
x y : ↑(∐ D.U)
h :
  (coequalizer.π (MultispanIndex.fstSigmaMap (GlueData.diagram D.toGlueData))
          (MultispanIndex.sndSigmaMap (GlueData.diagram D.toGlueData))).1
      x =
    (coequalizer.π (MultispanIndex.fstSigmaMap (GlueData.diagram D.toGlueData))
          (MultispanIndex.sndSigmaMap (GlueData.diagram D.toGlueData))).1
      y
⊢ EqvGen
    (Types.CoequalizerRel ↑(MultispanIndex.fstSigmaMap (GlueData.diagram D.toGlueData))
      ↑(MultispanIndex.sndSigmaMap (GlueData.diagram D.toGlueData)))
    x y
[PROOFSTEP]
let diagram := parallelPair 𝖣.diagram.fstSigmaMap 𝖣.diagram.sndSigmaMap ⋙ forget _
[GOAL]
D : GlueData
x y : ↑(∐ D.U)
h :
  (coequalizer.π (MultispanIndex.fstSigmaMap (GlueData.diagram D.toGlueData))
          (MultispanIndex.sndSigmaMap (GlueData.diagram D.toGlueData))).1
      x =
    (coequalizer.π (MultispanIndex.fstSigmaMap (GlueData.diagram D.toGlueData))
          (MultispanIndex.sndSigmaMap (GlueData.diagram D.toGlueData))).1
      y
diagram : WalkingParallelPair ⥤ Type u :=
  parallelPair (MultispanIndex.fstSigmaMap (GlueData.diagram D.toGlueData))
      (MultispanIndex.sndSigmaMap (GlueData.diagram D.toGlueData)) ⋙
    forget TopCat
⊢ EqvGen
    (Types.CoequalizerRel ↑(MultispanIndex.fstSigmaMap (GlueData.diagram D.toGlueData))
      ↑(MultispanIndex.sndSigmaMap (GlueData.diagram D.toGlueData)))
    x y
[PROOFSTEP]
have : colimit.ι diagram one x = colimit.ι diagram one y :=
  by
  dsimp only [coequalizer.π, ContinuousMap.toFun_eq_coe] at h 
  rw [← ι_preservesColimitsIso_hom, forget_map_eq_coe, types_comp_apply, h]
  simp
[GOAL]
D : GlueData
x y : ↑(∐ D.U)
h :
  (coequalizer.π (MultispanIndex.fstSigmaMap (GlueData.diagram D.toGlueData))
          (MultispanIndex.sndSigmaMap (GlueData.diagram D.toGlueData))).1
      x =
    (coequalizer.π (MultispanIndex.fstSigmaMap (GlueData.diagram D.toGlueData))
          (MultispanIndex.sndSigmaMap (GlueData.diagram D.toGlueData))).1
      y
diagram : WalkingParallelPair ⥤ Type u :=
  parallelPair (MultispanIndex.fstSigmaMap (GlueData.diagram D.toGlueData))
      (MultispanIndex.sndSigmaMap (GlueData.diagram D.toGlueData)) ⋙
    forget TopCat
⊢ colimit.ι diagram one x = colimit.ι diagram one y
[PROOFSTEP]
dsimp only [coequalizer.π, ContinuousMap.toFun_eq_coe] at h 
[GOAL]
D : GlueData
x y : ↑(∐ D.U)
h :
  ↑(colimit.ι
          (parallelPair (MultispanIndex.fstSigmaMap (GlueData.diagram D.toGlueData))
            (MultispanIndex.sndSigmaMap (GlueData.diagram D.toGlueData)))
          one)
      x =
    ↑(colimit.ι
          (parallelPair (MultispanIndex.fstSigmaMap (GlueData.diagram D.toGlueData))
            (MultispanIndex.sndSigmaMap (GlueData.diagram D.toGlueData)))
          one)
      y
diagram : WalkingParallelPair ⥤ Type u :=
  parallelPair (MultispanIndex.fstSigmaMap (GlueData.diagram D.toGlueData))
      (MultispanIndex.sndSigmaMap (GlueData.diagram D.toGlueData)) ⋙
    forget TopCat
⊢ colimit.ι diagram one x = colimit.ι diagram one y
[PROOFSTEP]
rw [← ι_preservesColimitsIso_hom, forget_map_eq_coe, types_comp_apply, h]
[GOAL]
D : GlueData
x y : ↑(∐ D.U)
h :
  ↑(colimit.ι
          (parallelPair (MultispanIndex.fstSigmaMap (GlueData.diagram D.toGlueData))
            (MultispanIndex.sndSigmaMap (GlueData.diagram D.toGlueData)))
          one)
      x =
    ↑(colimit.ι
          (parallelPair (MultispanIndex.fstSigmaMap (GlueData.diagram D.toGlueData))
            (MultispanIndex.sndSigmaMap (GlueData.diagram D.toGlueData)))
          one)
      y
diagram : WalkingParallelPair ⥤ Type u :=
  parallelPair (MultispanIndex.fstSigmaMap (GlueData.diagram D.toGlueData))
      (MultispanIndex.sndSigmaMap (GlueData.diagram D.toGlueData)) ⋙
    forget TopCat
⊢ (preservesColimitIso (forget TopCat)
          (parallelPair (MultispanIndex.fstSigmaMap (GlueData.diagram D.toGlueData))
            (MultispanIndex.sndSigmaMap (GlueData.diagram D.toGlueData)))).hom
      (↑(colimit.ι
            (parallelPair (MultispanIndex.fstSigmaMap (GlueData.diagram D.toGlueData))
              (MultispanIndex.sndSigmaMap (GlueData.diagram D.toGlueData)))
            one)
        y) =
    (↑(colimit.ι
            (parallelPair (MultispanIndex.fstSigmaMap (GlueData.diagram D.toGlueData))
              (MultispanIndex.sndSigmaMap (GlueData.diagram D.toGlueData)))
            one) ≫
        (preservesColimitIso (forget TopCat)
            (parallelPair (MultispanIndex.fstSigmaMap (GlueData.diagram D.toGlueData))
              (MultispanIndex.sndSigmaMap (GlueData.diagram D.toGlueData)))).hom)
      y
[PROOFSTEP]
simp
[GOAL]
D : GlueData
x y : ↑(∐ D.U)
h :
  (coequalizer.π (MultispanIndex.fstSigmaMap (GlueData.diagram D.toGlueData))
          (MultispanIndex.sndSigmaMap (GlueData.diagram D.toGlueData))).1
      x =
    (coequalizer.π (MultispanIndex.fstSigmaMap (GlueData.diagram D.toGlueData))
          (MultispanIndex.sndSigmaMap (GlueData.diagram D.toGlueData))).1
      y
diagram : WalkingParallelPair ⥤ Type u :=
  parallelPair (MultispanIndex.fstSigmaMap (GlueData.diagram D.toGlueData))
      (MultispanIndex.sndSigmaMap (GlueData.diagram D.toGlueData)) ⋙
    forget TopCat
this : colimit.ι diagram one x = colimit.ι diagram one y
⊢ EqvGen
    (Types.CoequalizerRel ↑(MultispanIndex.fstSigmaMap (GlueData.diagram D.toGlueData))
      ↑(MultispanIndex.sndSigmaMap (GlueData.diagram D.toGlueData)))
    x y
[PROOFSTEP]
have :
  (colimit.ι diagram _ ≫ colim.map _ ≫ (colimit.isoColimitCocone _).hom) _ =
    (colimit.ι diagram _ ≫ colim.map _ ≫ (colimit.isoColimitCocone _).hom) _ :=
  (congr_arg
      (colim.map (diagramIsoParallelPair diagram).hom ≫ (colimit.isoColimitCocone (Types.coequalizerColimit _ _)).hom)
      this :
    _)
    -- Porting note: was
      -- simp only [eqToHom_refl, types_comp_apply, colimit.ι_map_assoc,
      --   diagramIsoParallelPair_hom_app, colimit.isoColimitCocone_ι_hom, types_id_apply] at this
      -- See https://github.com/leanprover-community/mathlib4/issues/5026
[GOAL]
D : GlueData
x y : ↑(∐ D.U)
h :
  (coequalizer.π (MultispanIndex.fstSigmaMap (GlueData.diagram D.toGlueData))
          (MultispanIndex.sndSigmaMap (GlueData.diagram D.toGlueData))).1
      x =
    (coequalizer.π (MultispanIndex.fstSigmaMap (GlueData.diagram D.toGlueData))
          (MultispanIndex.sndSigmaMap (GlueData.diagram D.toGlueData))).1
      y
diagram : WalkingParallelPair ⥤ Type u :=
  parallelPair (MultispanIndex.fstSigmaMap (GlueData.diagram D.toGlueData))
      (MultispanIndex.sndSigmaMap (GlueData.diagram D.toGlueData)) ⋙
    forget TopCat
this✝ : colimit.ι diagram one x = colimit.ι diagram one y
this :
  (colimit.ι diagram one ≫
        colim.map (diagramIsoParallelPair diagram).hom ≫
          (colimit.isoColimitCocone
              (Types.coequalizerColimit (diagram.map WalkingParallelPairHom.left)
                (diagram.map WalkingParallelPairHom.right))).hom)
      x =
    (colimit.ι diagram one ≫
        colim.map (diagramIsoParallelPair diagram).hom ≫
          (colimit.isoColimitCocone
              (Types.coequalizerColimit (diagram.map WalkingParallelPairHom.left)
                (diagram.map WalkingParallelPairHom.right))).hom)
      y
⊢ EqvGen
    (Types.CoequalizerRel ↑(MultispanIndex.fstSigmaMap (GlueData.diagram D.toGlueData))
      ↑(MultispanIndex.sndSigmaMap (GlueData.diagram D.toGlueData)))
    x y
[PROOFSTEP]
rw [colimit.ι_map_assoc, diagramIsoParallelPair_hom_app, eqToHom_refl, colimit.isoColimitCocone_ι_hom, types_comp_apply,
  types_id_apply, types_comp_apply, types_id_apply] at this 
[GOAL]
D : GlueData
x y : ↑(∐ D.U)
h :
  (coequalizer.π (MultispanIndex.fstSigmaMap (GlueData.diagram D.toGlueData))
          (MultispanIndex.sndSigmaMap (GlueData.diagram D.toGlueData))).1
      x =
    (coequalizer.π (MultispanIndex.fstSigmaMap (GlueData.diagram D.toGlueData))
          (MultispanIndex.sndSigmaMap (GlueData.diagram D.toGlueData))).1
      y
diagram : WalkingParallelPair ⥤ Type u :=
  parallelPair (MultispanIndex.fstSigmaMap (GlueData.diagram D.toGlueData))
      (MultispanIndex.sndSigmaMap (GlueData.diagram D.toGlueData)) ⋙
    forget TopCat
this✝ : colimit.ι diagram one x = colimit.ι diagram one y
this :
  NatTrans.app
      (Types.coequalizerColimit (diagram.map WalkingParallelPairHom.left)
            (diagram.map WalkingParallelPairHom.right)).cocone.ι
      one x =
    NatTrans.app
      (Types.coequalizerColimit (diagram.map WalkingParallelPairHom.left)
            (diagram.map WalkingParallelPairHom.right)).cocone.ι
      one y
⊢ EqvGen
    (Types.CoequalizerRel ↑(MultispanIndex.fstSigmaMap (GlueData.diagram D.toGlueData))
      ↑(MultispanIndex.sndSigmaMap (GlueData.diagram D.toGlueData)))
    x y
[PROOFSTEP]
exact Quot.eq.1 this
[GOAL]
D : GlueData
i j : D.J
x : ↑(GlueData.U D.toGlueData i)
y : ↑(GlueData.U D.toGlueData j)
⊢ ↑(GlueData.ι D.toGlueData i) x = ↑(GlueData.ι D.toGlueData j) y ↔ Rel D { fst := i, snd := x } { fst := j, snd := y }
[PROOFSTEP]
constructor
[GOAL]
case mp
D : GlueData
i j : D.J
x : ↑(GlueData.U D.toGlueData i)
y : ↑(GlueData.U D.toGlueData j)
⊢ ↑(GlueData.ι D.toGlueData i) x = ↑(GlueData.ι D.toGlueData j) y → Rel D { fst := i, snd := x } { fst := j, snd := y }
[PROOFSTEP]
delta GlueData.ι
[GOAL]
case mp
D : GlueData
i j : D.J
x : ↑(GlueData.U D.toGlueData i)
y : ↑(GlueData.U D.toGlueData j)
⊢ ↑(Multicoequalizer.π (GlueData.diagram D.toGlueData) i) x =
      ↑(Multicoequalizer.π (GlueData.diagram D.toGlueData) j) y →
    Rel D { fst := i, snd := x } { fst := j, snd := y }
[PROOFSTEP]
simp_rw [← Multicoequalizer.ι_sigmaπ]
[GOAL]
case mp
D : GlueData
i j : D.J
x : ↑(GlueData.U D.toGlueData i)
y : ↑(GlueData.U D.toGlueData j)
⊢ ↑(Sigma.ι (GlueData.diagram D.toGlueData).right i ≫ Multicoequalizer.sigmaπ (GlueData.diagram D.toGlueData)) x =
      ↑(Sigma.ι (GlueData.diagram D.toGlueData).right j ≫ Multicoequalizer.sigmaπ (GlueData.diagram D.toGlueData)) y →
    Rel D { fst := i, snd := x } { fst := j, snd := y }
[PROOFSTEP]
intro h
[GOAL]
case mp
D : GlueData
i j : D.J
x : ↑(GlueData.U D.toGlueData i)
y : ↑(GlueData.U D.toGlueData j)
h :
  ↑(Sigma.ι (GlueData.diagram D.toGlueData).right i ≫ Multicoequalizer.sigmaπ (GlueData.diagram D.toGlueData)) x =
    ↑(Sigma.ι (GlueData.diagram D.toGlueData).right j ≫ Multicoequalizer.sigmaπ (GlueData.diagram D.toGlueData)) y
⊢ Rel D { fst := i, snd := x } { fst := j, snd := y }
[PROOFSTEP]
rw [← show _ = Sigma.mk i x from ConcreteCategory.congr_hom (sigmaIsoSigma.{_, u} D.U).inv_hom_id _]
[GOAL]
case mp
D : GlueData
i j : D.J
x : ↑(GlueData.U D.toGlueData i)
y : ↑(GlueData.U D.toGlueData j)
h :
  ↑(Sigma.ι (GlueData.diagram D.toGlueData).right i ≫ Multicoequalizer.sigmaπ (GlueData.diagram D.toGlueData)) x =
    ↑(Sigma.ι (GlueData.diagram D.toGlueData).right j ≫ Multicoequalizer.sigmaπ (GlueData.diagram D.toGlueData)) y
⊢ Rel D (↑((sigmaIsoSigma D.U).inv ≫ (sigmaIsoSigma D.U).hom) { fst := i, snd := x }) { fst := j, snd := y }
[PROOFSTEP]
rw [← show _ = Sigma.mk j y from ConcreteCategory.congr_hom (sigmaIsoSigma.{_, u} D.U).inv_hom_id _]
[GOAL]
case mp
D : GlueData
i j : D.J
x : ↑(GlueData.U D.toGlueData i)
y : ↑(GlueData.U D.toGlueData j)
h :
  ↑(Sigma.ι (GlueData.diagram D.toGlueData).right i ≫ Multicoequalizer.sigmaπ (GlueData.diagram D.toGlueData)) x =
    ↑(Sigma.ι (GlueData.diagram D.toGlueData).right j ≫ Multicoequalizer.sigmaπ (GlueData.diagram D.toGlueData)) y
⊢ Rel D (↑((sigmaIsoSigma D.U).inv ≫ (sigmaIsoSigma D.U).hom) { fst := i, snd := x })
    (↑((sigmaIsoSigma D.U).inv ≫ (sigmaIsoSigma D.U).hom) { fst := j, snd := y })
[PROOFSTEP]
change InvImage D.Rel (sigmaIsoSigma.{_, u} D.U).hom _ _
[GOAL]
case mp
D : GlueData
i j : D.J
x : ↑(GlueData.U D.toGlueData i)
y : ↑(GlueData.U D.toGlueData j)
h :
  ↑(Sigma.ι (GlueData.diagram D.toGlueData).right i ≫ Multicoequalizer.sigmaπ (GlueData.diagram D.toGlueData)) x =
    ↑(Sigma.ι (GlueData.diagram D.toGlueData).right j ≫ Multicoequalizer.sigmaπ (GlueData.diagram D.toGlueData)) y
⊢ InvImage (Rel D) (↑(sigmaIsoSigma D.U).hom) (↑(sigmaIsoSigma D.U).inv { fst := i, snd := x })
    (↑(sigmaIsoSigma D.U).inv { fst := j, snd := y })
[PROOFSTEP]
simp only [TopCat.sigmaIsoSigma_inv_apply]
[GOAL]
case mp
D : GlueData
i j : D.J
x : ↑(GlueData.U D.toGlueData i)
y : ↑(GlueData.U D.toGlueData j)
h :
  ↑(Sigma.ι (GlueData.diagram D.toGlueData).right i ≫ Multicoequalizer.sigmaπ (GlueData.diagram D.toGlueData)) x =
    ↑(Sigma.ι (GlueData.diagram D.toGlueData).right j ≫ Multicoequalizer.sigmaπ (GlueData.diagram D.toGlueData)) y
⊢ InvImage (Rel D) (↑(sigmaIsoSigma D.U).hom) (↑(sigmaIsoSigma D.U).inv { fst := i, snd := x })
    (↑(sigmaIsoSigma D.U).inv { fst := j, snd := y })
[PROOFSTEP]
rw [← (InvImage.equivalence _ _ D.rel_equiv).eqvGen_iff]
[GOAL]
case mp
D : GlueData
i j : D.J
x : ↑(GlueData.U D.toGlueData i)
y : ↑(GlueData.U D.toGlueData j)
h :
  ↑(Sigma.ι (GlueData.diagram D.toGlueData).right i ≫ Multicoequalizer.sigmaπ (GlueData.diagram D.toGlueData)) x =
    ↑(Sigma.ι (GlueData.diagram D.toGlueData).right j ≫ Multicoequalizer.sigmaπ (GlueData.diagram D.toGlueData)) y
⊢ EqvGen (InvImage (Rel D) ↑(sigmaIsoSigma D.U).hom) (↑(sigmaIsoSigma D.U).inv { fst := i, snd := x })
    (↑(sigmaIsoSigma D.U).inv { fst := j, snd := y })
[PROOFSTEP]
refine' EqvGen.mono _ (D.eqvGen_of_π_eq h : _)
[GOAL]
case mp
D : GlueData
i j : D.J
x : ↑(GlueData.U D.toGlueData i)
y : ↑(GlueData.U D.toGlueData j)
h :
  ↑(Sigma.ι (GlueData.diagram D.toGlueData).right i ≫ Multicoequalizer.sigmaπ (GlueData.diagram D.toGlueData)) x =
    ↑(Sigma.ι (GlueData.diagram D.toGlueData).right j ≫ Multicoequalizer.sigmaπ (GlueData.diagram D.toGlueData)) y
⊢ ∀ (a b : (forget TopCat).obj (∐ D.U)),
    Types.CoequalizerRel (↑(MultispanIndex.fstSigmaMap (GlueData.diagram D.toGlueData)))
        (↑(MultispanIndex.sndSigmaMap (GlueData.diagram D.toGlueData))) a b →
      InvImage (Rel D) (↑(sigmaIsoSigma D.U).hom) a b
[PROOFSTEP]
rintro _ _ ⟨x⟩
[GOAL]
case mp.Rel
D : GlueData
i j : D.J
x✝ : ↑(GlueData.U D.toGlueData i)
y : ↑(GlueData.U D.toGlueData j)
h :
  ↑(Sigma.ι (GlueData.diagram D.toGlueData).right i ≫ Multicoequalizer.sigmaπ (GlueData.diagram D.toGlueData)) x✝ =
    ↑(Sigma.ι (GlueData.diagram D.toGlueData).right j ≫ Multicoequalizer.sigmaπ (GlueData.diagram D.toGlueData)) y
x : ↑(∐ (GlueData.diagram D.toGlueData).left)
⊢ InvImage (Rel D) (↑(sigmaIsoSigma D.U).hom) (↑(MultispanIndex.fstSigmaMap (GlueData.diagram D.toGlueData)) x)
    (↑(MultispanIndex.sndSigmaMap (GlueData.diagram D.toGlueData)) x)
[PROOFSTEP]
rw [← show (sigmaIsoSigma.{u, u} _).inv _ = x from ConcreteCategory.congr_hom (sigmaIsoSigma.{u, u} _).hom_inv_id x]
[GOAL]
case mp.Rel
D : GlueData
i j : D.J
x✝ : ↑(GlueData.U D.toGlueData i)
y : ↑(GlueData.U D.toGlueData j)
h :
  ↑(Sigma.ι (GlueData.diagram D.toGlueData).right i ≫ Multicoequalizer.sigmaπ (GlueData.diagram D.toGlueData)) x✝ =
    ↑(Sigma.ι (GlueData.diagram D.toGlueData).right j ≫ Multicoequalizer.sigmaπ (GlueData.diagram D.toGlueData)) y
x : ↑(∐ (GlueData.diagram D.toGlueData).left)
⊢ InvImage (Rel D) (↑(sigmaIsoSigma D.U).hom)
    (↑(MultispanIndex.fstSigmaMap (GlueData.diagram D.toGlueData))
      (↑(sigmaIsoSigma (GlueData.diagram D.toGlueData).left).inv
        (↑(sigmaIsoSigma (GlueData.diagram D.toGlueData).left).hom x)))
    (↑(MultispanIndex.sndSigmaMap (GlueData.diagram D.toGlueData))
      (↑(sigmaIsoSigma (GlueData.diagram D.toGlueData).left).inv
        (↑(sigmaIsoSigma (GlueData.diagram D.toGlueData).left).hom x)))
[PROOFSTEP]
generalize (sigmaIsoSigma.{u, u} D.V).hom x = x'
[GOAL]
case mp.Rel
D : GlueData
i j : D.J
x✝ : ↑(GlueData.U D.toGlueData i)
y : ↑(GlueData.U D.toGlueData j)
h :
  ↑(Sigma.ι (GlueData.diagram D.toGlueData).right i ≫ Multicoequalizer.sigmaπ (GlueData.diagram D.toGlueData)) x✝ =
    ↑(Sigma.ι (GlueData.diagram D.toGlueData).right j ≫ Multicoequalizer.sigmaπ (GlueData.diagram D.toGlueData)) y
x : ↑(∐ (GlueData.diagram D.toGlueData).left)
x' : (forget TopCat).obj (of ((i : D.J × D.J) × ↑(GlueData.V D.toGlueData i)))
⊢ InvImage (Rel D) (↑(sigmaIsoSigma D.U).hom)
    (↑(MultispanIndex.fstSigmaMap (GlueData.diagram D.toGlueData))
      (↑(sigmaIsoSigma (GlueData.diagram D.toGlueData).left).inv x'))
    (↑(MultispanIndex.sndSigmaMap (GlueData.diagram D.toGlueData))
      (↑(sigmaIsoSigma (GlueData.diagram D.toGlueData).left).inv x'))
[PROOFSTEP]
obtain ⟨⟨i, j⟩, y⟩ := x'
[GOAL]
case mp.Rel.mk.mk
D : GlueData
i✝ j✝ : D.J
x✝ : ↑(GlueData.U D.toGlueData i✝)
y✝ : ↑(GlueData.U D.toGlueData j✝)
h :
  ↑(Sigma.ι (GlueData.diagram D.toGlueData).right i✝ ≫ Multicoequalizer.sigmaπ (GlueData.diagram D.toGlueData)) x✝ =
    ↑(Sigma.ι (GlueData.diagram D.toGlueData).right j✝ ≫ Multicoequalizer.sigmaπ (GlueData.diagram D.toGlueData)) y✝
x : ↑(∐ (GlueData.diagram D.toGlueData).left)
i j : D.J
y : ↑(GlueData.V D.toGlueData (i, j))
⊢ InvImage (Rel D) (↑(sigmaIsoSigma D.U).hom)
    (↑(MultispanIndex.fstSigmaMap (GlueData.diagram D.toGlueData))
      (↑(sigmaIsoSigma (GlueData.diagram D.toGlueData).left).inv { fst := (i, j), snd := y }))
    (↑(MultispanIndex.sndSigmaMap (GlueData.diagram D.toGlueData))
      (↑(sigmaIsoSigma (GlueData.diagram D.toGlueData).left).inv { fst := (i, j), snd := y }))
[PROOFSTEP]
unfold InvImage MultispanIndex.fstSigmaMap MultispanIndex.sndSigmaMap
[GOAL]
case mp.Rel.mk.mk
D : GlueData
i✝ j✝ : D.J
x✝ : ↑(GlueData.U D.toGlueData i✝)
y✝ : ↑(GlueData.U D.toGlueData j✝)
h :
  ↑(Sigma.ι (GlueData.diagram D.toGlueData).right i✝ ≫ Multicoequalizer.sigmaπ (GlueData.diagram D.toGlueData)) x✝ =
    ↑(Sigma.ι (GlueData.diagram D.toGlueData).right j✝ ≫ Multicoequalizer.sigmaπ (GlueData.diagram D.toGlueData)) y✝
x : ↑(∐ (GlueData.diagram D.toGlueData).left)
i j : D.J
y : ↑(GlueData.V D.toGlueData (i, j))
⊢ Rel D
    (↑(sigmaIsoSigma D.U).hom
      (↑(Sigma.desc fun b =>
            MultispanIndex.fst (GlueData.diagram D.toGlueData) b ≫
              Sigma.ι (GlueData.diagram D.toGlueData).right (MultispanIndex.fstFrom (GlueData.diagram D.toGlueData) b))
        (↑(sigmaIsoSigma (GlueData.diagram D.toGlueData).left).inv { fst := (i, j), snd := y })))
    (↑(sigmaIsoSigma D.U).hom
      (↑(Sigma.desc fun b =>
            MultispanIndex.snd (GlueData.diagram D.toGlueData) b ≫
              Sigma.ι (GlueData.diagram D.toGlueData).right (MultispanIndex.sndFrom (GlueData.diagram D.toGlueData) b))
        (↑(sigmaIsoSigma (GlueData.diagram D.toGlueData).left).inv { fst := (i, j), snd := y })))
[PROOFSTEP]
simp only [Opens.inclusion_apply, TopCat.comp_app, sigmaIsoSigma_inv_apply, Cofan.mk_ι_app]
[GOAL]
case mp.Rel.mk.mk
D : GlueData
i✝ j✝ : D.J
x✝ : ↑(GlueData.U D.toGlueData i✝)
y✝ : ↑(GlueData.U D.toGlueData j✝)
h :
  ↑(Sigma.ι (GlueData.diagram D.toGlueData).right i✝ ≫ Multicoequalizer.sigmaπ (GlueData.diagram D.toGlueData)) x✝ =
    ↑(Sigma.ι (GlueData.diagram D.toGlueData).right j✝ ≫ Multicoequalizer.sigmaπ (GlueData.diagram D.toGlueData)) y✝
x : ↑(∐ (GlueData.diagram D.toGlueData).left)
i j : D.J
y : ↑(GlueData.V D.toGlueData (i, j))
⊢ Rel D
    (↑(sigmaIsoSigma D.U).hom
      (↑(Sigma.desc fun b =>
            MultispanIndex.fst (GlueData.diagram D.toGlueData) b ≫
              Sigma.ι (GlueData.diagram D.toGlueData).right (MultispanIndex.fstFrom (GlueData.diagram D.toGlueData) b))
        (↑(Sigma.ι (GlueData.diagram D.toGlueData).left (i, j)) y)))
    (↑(sigmaIsoSigma D.U).hom
      (↑(Sigma.desc fun b =>
            MultispanIndex.snd (GlueData.diagram D.toGlueData) b ≫
              Sigma.ι (GlueData.diagram D.toGlueData).right (MultispanIndex.sndFrom (GlueData.diagram D.toGlueData) b))
        (↑(Sigma.ι (GlueData.diagram D.toGlueData).left (i, j)) y)))
[PROOFSTEP]
rw [← comp_apply, colimit.ι_desc, ← comp_apply, colimit.ι_desc]
[GOAL]
case mp.Rel.mk.mk
D : GlueData
i✝ j✝ : D.J
x✝ : ↑(GlueData.U D.toGlueData i✝)
y✝ : ↑(GlueData.U D.toGlueData j✝)
h :
  ↑(Sigma.ι (GlueData.diagram D.toGlueData).right i✝ ≫ Multicoequalizer.sigmaπ (GlueData.diagram D.toGlueData)) x✝ =
    ↑(Sigma.ι (GlueData.diagram D.toGlueData).right j✝ ≫ Multicoequalizer.sigmaπ (GlueData.diagram D.toGlueData)) y✝
x : ↑(∐ (GlueData.diagram D.toGlueData).left)
i j : D.J
y : ↑(GlueData.V D.toGlueData (i, j))
⊢ Rel D
    (↑(sigmaIsoSigma D.U).hom
      (↑(NatTrans.app
            (Cofan.mk (∐ (GlueData.diagram D.toGlueData).right) fun b =>
                MultispanIndex.fst (GlueData.diagram D.toGlueData) b ≫
                  Sigma.ι (GlueData.diagram D.toGlueData).right
                    (MultispanIndex.fstFrom (GlueData.diagram D.toGlueData) b)).ι
            { as := (i, j) })
        y))
    (↑(sigmaIsoSigma D.U).hom
      (↑(NatTrans.app
            (Cofan.mk (∐ (GlueData.diagram D.toGlueData).right) fun b =>
                MultispanIndex.snd (GlueData.diagram D.toGlueData) b ≫
                  Sigma.ι (GlueData.diagram D.toGlueData).right
                    (MultispanIndex.sndFrom (GlueData.diagram D.toGlueData) b)).ι
            { as := (i, j) })
        y))
[PROOFSTEP]
erw [sigmaIsoSigma_hom_ι_apply, sigmaIsoSigma_hom_ι_apply]
[GOAL]
case mp.Rel.mk.mk
D : GlueData
i✝ j✝ : D.J
x✝ : ↑(GlueData.U D.toGlueData i✝)
y✝ : ↑(GlueData.U D.toGlueData j✝)
h :
  ↑(Sigma.ι (GlueData.diagram D.toGlueData).right i✝ ≫ Multicoequalizer.sigmaπ (GlueData.diagram D.toGlueData)) x✝ =
    ↑(Sigma.ι (GlueData.diagram D.toGlueData).right j✝ ≫ Multicoequalizer.sigmaπ (GlueData.diagram D.toGlueData)) y✝
x : ↑(∐ (GlueData.diagram D.toGlueData).left)
i j : D.J
y : ↑(GlueData.V D.toGlueData (i, j))
⊢ Rel D
    { fst := MultispanIndex.fstFrom (GlueData.diagram D.toGlueData) { as := (i, j) }.as,
      snd := ↑(MultispanIndex.fst (GlueData.diagram D.toGlueData) { as := (i, j) }.as) y }
    { fst := MultispanIndex.sndFrom (GlueData.diagram D.toGlueData) { as := (i, j) }.as,
      snd := ↑(MultispanIndex.snd (GlueData.diagram D.toGlueData) { as := (i, j) }.as) y }
[PROOFSTEP]
exact Or.inr ⟨y, by dsimp [GlueData.diagram]; simp only [true_and]; rfl⟩
[GOAL]
D : GlueData
i✝ j✝ : D.J
x✝ : ↑(GlueData.U D.toGlueData i✝)
y✝ : ↑(GlueData.U D.toGlueData j✝)
h :
  ↑(Sigma.ι (GlueData.diagram D.toGlueData).right i✝ ≫ Multicoequalizer.sigmaπ (GlueData.diagram D.toGlueData)) x✝ =
    ↑(Sigma.ι (GlueData.diagram D.toGlueData).right j✝ ≫ Multicoequalizer.sigmaπ (GlueData.diagram D.toGlueData)) y✝
x : ↑(∐ (GlueData.diagram D.toGlueData).left)
i j : D.J
y : ↑(GlueData.V D.toGlueData (i, j))
⊢ ↑(GlueData.f D.toGlueData
            { fst := MultispanIndex.fstFrom (GlueData.diagram D.toGlueData) { as := (i, j) }.as,
                snd := ↑(MultispanIndex.fst (GlueData.diagram D.toGlueData) { as := (i, j) }.as) y }.fst
            { fst := MultispanIndex.sndFrom (GlueData.diagram D.toGlueData) { as := (i, j) }.as,
                snd := ↑(MultispanIndex.snd (GlueData.diagram D.toGlueData) { as := (i, j) }.as) y }.fst)
        y =
      { fst := MultispanIndex.fstFrom (GlueData.diagram D.toGlueData) { as := (i, j) }.as,
          snd := ↑(MultispanIndex.fst (GlueData.diagram D.toGlueData) { as := (i, j) }.as) y }.snd ∧
    ↑(GlueData.f D.toGlueData
            { fst := MultispanIndex.sndFrom (GlueData.diagram D.toGlueData) { as := (i, j) }.as,
                snd := ↑(MultispanIndex.snd (GlueData.diagram D.toGlueData) { as := (i, j) }.as) y }.fst
            { fst := MultispanIndex.fstFrom (GlueData.diagram D.toGlueData) { as := (i, j) }.as,
                snd := ↑(MultispanIndex.fst (GlueData.diagram D.toGlueData) { as := (i, j) }.as) y }.fst)
        (↑(GlueData.t D.toGlueData
              { fst := MultispanIndex.fstFrom (GlueData.diagram D.toGlueData) { as := (i, j) }.as,
                  snd := ↑(MultispanIndex.fst (GlueData.diagram D.toGlueData) { as := (i, j) }.as) y }.fst
              { fst := MultispanIndex.sndFrom (GlueData.diagram D.toGlueData) { as := (i, j) }.as,
                  snd := ↑(MultispanIndex.snd (GlueData.diagram D.toGlueData) { as := (i, j) }.as) y }.fst)
          y) =
      { fst := MultispanIndex.sndFrom (GlueData.diagram D.toGlueData) { as := (i, j) }.as,
          snd := ↑(MultispanIndex.snd (GlueData.diagram D.toGlueData) { as := (i, j) }.as) y }.snd
[PROOFSTEP]
dsimp [GlueData.diagram]
[GOAL]
D : GlueData
i✝ j✝ : D.J
x✝ : ↑(GlueData.U D.toGlueData i✝)
y✝ : ↑(GlueData.U D.toGlueData j✝)
h :
  ↑(Sigma.ι (GlueData.diagram D.toGlueData).right i✝ ≫ Multicoequalizer.sigmaπ (GlueData.diagram D.toGlueData)) x✝ =
    ↑(Sigma.ι (GlueData.diagram D.toGlueData).right j✝ ≫ Multicoequalizer.sigmaπ (GlueData.diagram D.toGlueData)) y✝
x : ↑(∐ (GlueData.diagram D.toGlueData).left)
i j : D.J
y : ↑(GlueData.V D.toGlueData (i, j))
⊢ ↑(GlueData.f D.toGlueData i j) y = ↑(GlueData.f D.toGlueData i j) y ∧
    ↑(GlueData.f D.toGlueData j i) (↑(GlueData.t D.toGlueData i j) y) =
      ↑(GlueData.t D.toGlueData i j ≫ GlueData.f D.toGlueData j i) y
[PROOFSTEP]
simp only [true_and]
[GOAL]
D : GlueData
i✝ j✝ : D.J
x✝ : ↑(GlueData.U D.toGlueData i✝)
y✝ : ↑(GlueData.U D.toGlueData j✝)
h :
  ↑(Sigma.ι (GlueData.diagram D.toGlueData).right i✝ ≫ Multicoequalizer.sigmaπ (GlueData.diagram D.toGlueData)) x✝ =
    ↑(Sigma.ι (GlueData.diagram D.toGlueData).right j✝ ≫ Multicoequalizer.sigmaπ (GlueData.diagram D.toGlueData)) y✝
x : ↑(∐ (GlueData.diagram D.toGlueData).left)
i j : D.J
y : ↑(GlueData.V D.toGlueData (i, j))
⊢ ↑(GlueData.f D.toGlueData j i) (↑(GlueData.t D.toGlueData i j) y) =
    ↑(GlueData.t D.toGlueData i j ≫ GlueData.f D.toGlueData j i) y
[PROOFSTEP]
rfl
[GOAL]
case mpr
D : GlueData
i j : D.J
x : ↑(GlueData.U D.toGlueData i)
y : ↑(GlueData.U D.toGlueData j)
⊢ Rel D { fst := i, snd := x } { fst := j, snd := y } → ↑(GlueData.ι D.toGlueData i) x = ↑(GlueData.ι D.toGlueData j) y
[PROOFSTEP]
rintro (⟨⟨⟩⟩ | ⟨z, e₁, e₂⟩)
[GOAL]
case mpr.inl.refl
D : GlueData
i : D.J
x : ↑(GlueData.U D.toGlueData i)
⊢ ↑(GlueData.ι D.toGlueData i) x = ↑(GlueData.ι D.toGlueData i) x
case mpr.inr.intro.intro
D : GlueData
i j : D.J
x : ↑(GlueData.U D.toGlueData i)
y : ↑(GlueData.U D.toGlueData j)
z : ↑(GlueData.V D.toGlueData ({ fst := i, snd := x }.fst, { fst := j, snd := y }.fst))
e₁ : ↑(GlueData.f D.toGlueData { fst := i, snd := x }.fst { fst := j, snd := y }.fst) z = { fst := i, snd := x }.snd
e₂ :
  ↑(GlueData.f D.toGlueData { fst := j, snd := y }.fst { fst := i, snd := x }.fst)
      (↑(GlueData.t D.toGlueData { fst := i, snd := x }.fst { fst := j, snd := y }.fst) z) =
    { fst := j, snd := y }.snd
⊢ ↑(GlueData.ι D.toGlueData i) x = ↑(GlueData.ι D.toGlueData j) y
[PROOFSTEP]
rfl
[GOAL]
case mpr.inr.intro.intro
D : GlueData
i j : D.J
x : ↑(GlueData.U D.toGlueData i)
y : ↑(GlueData.U D.toGlueData j)
z : ↑(GlueData.V D.toGlueData ({ fst := i, snd := x }.fst, { fst := j, snd := y }.fst))
e₁ : ↑(GlueData.f D.toGlueData { fst := i, snd := x }.fst { fst := j, snd := y }.fst) z = { fst := i, snd := x }.snd
e₂ :
  ↑(GlueData.f D.toGlueData { fst := j, snd := y }.fst { fst := i, snd := x }.fst)
      (↑(GlueData.t D.toGlueData { fst := i, snd := x }.fst { fst := j, snd := y }.fst) z) =
    { fst := j, snd := y }.snd
⊢ ↑(GlueData.ι D.toGlueData i) x = ↑(GlueData.ι D.toGlueData j) y
[PROOFSTEP]
dsimp only at *
  -- porting note: there were `subst e₁` and `subst e₂`, instead of the `rw`
[GOAL]
case mpr.inr.intro.intro
D : GlueData
i j : D.J
x : ↑(GlueData.U D.toGlueData i)
y : ↑(GlueData.U D.toGlueData j)
z : ↑(GlueData.V D.toGlueData ({ fst := i, snd := x }.fst, { fst := j, snd := y }.fst))
e₁ : ↑(GlueData.f D.toGlueData i j) z = x
e₂ : ↑(GlueData.f D.toGlueData j i) (↑(GlueData.t D.toGlueData i j) z) = y
⊢ ↑(GlueData.ι D.toGlueData i) x = ↑(GlueData.ι D.toGlueData j) y
[PROOFSTEP]
rw [← e₁, ← e₂] at *
[GOAL]
case mpr.inr.intro.intro
D : GlueData
i j : D.J
x : ↑(GlueData.U D.toGlueData i)
y : ↑(GlueData.U D.toGlueData j)
z : ↑(GlueData.V D.toGlueData ({ fst := i, snd := x }.fst, { fst := j, snd := y }.fst))
e₁ : ↑(GlueData.f D.toGlueData i j) z = ↑(GlueData.f D.toGlueData i j) z
e₂ :
  ↑(GlueData.f D.toGlueData j i) (↑(GlueData.t D.toGlueData i j) z) =
    ↑(GlueData.f D.toGlueData j i) (↑(GlueData.t D.toGlueData i j) z)
⊢ ↑(GlueData.ι D.toGlueData i) (↑(GlueData.f D.toGlueData i j) z) =
    ↑(GlueData.ι D.toGlueData j) (↑(GlueData.f D.toGlueData j i) (↑(GlueData.t D.toGlueData i j) z))
[PROOFSTEP]
simp
[GOAL]
D : GlueData
i : D.J
⊢ Function.Injective ↑(GlueData.ι D.toGlueData i)
[PROOFSTEP]
intro x y h
[GOAL]
D : GlueData
i : D.J
x y : (forget TopCat).obj (GlueData.U D.toGlueData i)
h : ↑(GlueData.ι D.toGlueData i) x = ↑(GlueData.ι D.toGlueData i) y
⊢ x = y
[PROOFSTEP]
rcases(D.ι_eq_iff_rel _ _ _ _).mp h with (⟨⟨⟩⟩ | ⟨_, e₁, e₂⟩)
[GOAL]
case inl.refl
D : GlueData
i : D.J
x : (forget TopCat).obj (GlueData.U D.toGlueData i)
h : ↑(GlueData.ι D.toGlueData i) x = ↑(GlueData.ι D.toGlueData i) x
⊢ x = x
[PROOFSTEP]
rfl
[GOAL]
case inr.intro.intro
D : GlueData
i : D.J
x y : (forget TopCat).obj (GlueData.U D.toGlueData i)
h : ↑(GlueData.ι D.toGlueData i) x = ↑(GlueData.ι D.toGlueData i) y
w✝ : ↑(GlueData.V D.toGlueData ({ fst := i, snd := x }.fst, { fst := i, snd := y }.fst))
e₁ : ↑(GlueData.f D.toGlueData { fst := i, snd := x }.fst { fst := i, snd := y }.fst) w✝ = { fst := i, snd := x }.snd
e₂ :
  ↑(GlueData.f D.toGlueData { fst := i, snd := y }.fst { fst := i, snd := x }.fst)
      (↑(GlueData.t D.toGlueData { fst := i, snd := x }.fst { fst := i, snd := y }.fst) w✝) =
    { fst := i, snd := y }.snd
⊢ x = y
[PROOFSTEP]
dsimp only at *
  -- porting note: there were `cases e₁` and `cases e₂`, instead of the `rw`
[GOAL]
case inr.intro.intro
D : GlueData
i : D.J
x y : (forget TopCat).obj (GlueData.U D.toGlueData i)
h : ↑(GlueData.ι D.toGlueData i) x = ↑(GlueData.ι D.toGlueData i) y
w✝ : ↑(GlueData.V D.toGlueData ({ fst := i, snd := x }.fst, { fst := i, snd := y }.fst))
e₁ : ↑(GlueData.f D.toGlueData i i) w✝ = x
e₂ : ↑(GlueData.f D.toGlueData i i) (↑(GlueData.t D.toGlueData i i) w✝) = y
⊢ x = y
[PROOFSTEP]
rw [← e₁, ← e₂]
[GOAL]
case inr.intro.intro
D : GlueData
i : D.J
x y : (forget TopCat).obj (GlueData.U D.toGlueData i)
h : ↑(GlueData.ι D.toGlueData i) x = ↑(GlueData.ι D.toGlueData i) y
w✝ : ↑(GlueData.V D.toGlueData ({ fst := i, snd := x }.fst, { fst := i, snd := y }.fst))
e₁ : ↑(GlueData.f D.toGlueData i i) w✝ = x
e₂ : ↑(GlueData.f D.toGlueData i i) (↑(GlueData.t D.toGlueData i i) w✝) = y
⊢ ↑(GlueData.f D.toGlueData i i) w✝ = ↑(GlueData.f D.toGlueData i i) (↑(GlueData.t D.toGlueData i i) w✝)
[PROOFSTEP]
simp
[GOAL]
D : GlueData
i j : D.J
⊢ Set.range ↑(GlueData.ι D.toGlueData i) ∩ Set.range ↑(GlueData.ι D.toGlueData j) =
    Set.range ↑(GlueData.f D.toGlueData i j ≫ GlueData.ι D.toGlueData i)
[PROOFSTEP]
ext x
[GOAL]
case h
D : GlueData
i j : D.J
x : (forget TopCat).obj (GlueData.glued D.toGlueData)
⊢ x ∈ Set.range ↑(GlueData.ι D.toGlueData i) ∩ Set.range ↑(GlueData.ι D.toGlueData j) ↔
    x ∈ Set.range ↑(GlueData.f D.toGlueData i j ≫ GlueData.ι D.toGlueData i)
[PROOFSTEP]
constructor
[GOAL]
case h.mp
D : GlueData
i j : D.J
x : (forget TopCat).obj (GlueData.glued D.toGlueData)
⊢ x ∈ Set.range ↑(GlueData.ι D.toGlueData i) ∩ Set.range ↑(GlueData.ι D.toGlueData j) →
    x ∈ Set.range ↑(GlueData.f D.toGlueData i j ≫ GlueData.ι D.toGlueData i)
[PROOFSTEP]
rintro ⟨⟨x₁, eq₁⟩, ⟨x₂, eq₂⟩⟩
[GOAL]
case h.mp.intro.intro.intro
D : GlueData
i j : D.J
x : (forget TopCat).obj (GlueData.glued D.toGlueData)
x₁ : (forget TopCat).obj (GlueData.U D.toGlueData i)
eq₁ : ↑(GlueData.ι D.toGlueData i) x₁ = x
x₂ : (forget TopCat).obj (GlueData.U D.toGlueData j)
eq₂ : ↑(GlueData.ι D.toGlueData j) x₂ = x
⊢ x ∈ Set.range ↑(GlueData.f D.toGlueData i j ≫ GlueData.ι D.toGlueData i)
[PROOFSTEP]
obtain ⟨⟨⟩⟩ | ⟨y, e₁, -⟩ := (D.ι_eq_iff_rel _ _ _ _).mp (eq₁.trans eq₂.symm)
[GOAL]
case h.mp.intro.intro.intro.inl.refl
D : GlueData
i : D.J
x : (forget TopCat).obj (GlueData.glued D.toGlueData)
x₁ : (forget TopCat).obj (GlueData.U D.toGlueData i)
eq₁ eq₂ : ↑(GlueData.ι D.toGlueData i) x₁ = x
⊢ x ∈ Set.range ↑(GlueData.f D.toGlueData i i ≫ GlueData.ι D.toGlueData i)
[PROOFSTEP]
exact
  ⟨inv (D.f i i) x₁, by
    -- Porting note: was `simp [eq₁]`
            -- See https://github.com/leanprover-community/mathlib4/issues/5026
    rw [TopCat.comp_app]
    erw [CategoryTheory.IsIso.inv_hom_id_apply]
    rw [eq₁]⟩
[GOAL]
D : GlueData
i : D.J
x : (forget TopCat).obj (GlueData.glued D.toGlueData)
x₁ : (forget TopCat).obj (GlueData.U D.toGlueData i)
eq₁ eq₂ : ↑(GlueData.ι D.toGlueData i) x₁ = x
⊢ ↑(GlueData.f D.toGlueData i i ≫ GlueData.ι D.toGlueData i) (↑(inv (GlueData.f D.toGlueData i i)) x₁) = x
[PROOFSTEP]
rw [TopCat.comp_app]
[GOAL]
D : GlueData
i : D.J
x : (forget TopCat).obj (GlueData.glued D.toGlueData)
x₁ : (forget TopCat).obj (GlueData.U D.toGlueData i)
eq₁ eq₂ : ↑(GlueData.ι D.toGlueData i) x₁ = x
⊢ ↑(GlueData.ι D.toGlueData i) (↑(GlueData.f D.toGlueData i i) (↑(inv (GlueData.f D.toGlueData i i)) x₁)) = x
[PROOFSTEP]
erw [CategoryTheory.IsIso.inv_hom_id_apply]
[GOAL]
D : GlueData
i : D.J
x : (forget TopCat).obj (GlueData.glued D.toGlueData)
x₁ : (forget TopCat).obj (GlueData.U D.toGlueData i)
eq₁ eq₂ : ↑(GlueData.ι D.toGlueData i) x₁ = x
⊢ ↑(GlueData.ι D.toGlueData i) x₁ = x
[PROOFSTEP]
rw [eq₁]
[GOAL]
case h.mp.intro.intro.intro.inr.intro.intro
D : GlueData
i j : D.J
x : (forget TopCat).obj (GlueData.glued D.toGlueData)
x₁ : (forget TopCat).obj (GlueData.U D.toGlueData i)
eq₁ : ↑(GlueData.ι D.toGlueData i) x₁ = x
x₂ : (forget TopCat).obj (GlueData.U D.toGlueData j)
eq₂ : ↑(GlueData.ι D.toGlueData j) x₂ = x
y : ↑(GlueData.V D.toGlueData ({ fst := i, snd := x₁ }.fst, { fst := j, snd := x₂ }.fst))
e₁ : ↑(GlueData.f D.toGlueData { fst := i, snd := x₁ }.fst { fst := j, snd := x₂ }.fst) y = { fst := i, snd := x₁ }.snd
⊢ x ∈ Set.range ↑(GlueData.f D.toGlueData i j ≫ GlueData.ι D.toGlueData i)
[PROOFSTEP]
dsimp only at *
[GOAL]
case h.mp.intro.intro.intro.inr.intro.intro
D : GlueData
i j : D.J
x : (forget TopCat).obj (GlueData.glued D.toGlueData)
x₁ : (forget TopCat).obj (GlueData.U D.toGlueData i)
eq₁ : ↑(GlueData.ι D.toGlueData i) x₁ = x
x₂ : (forget TopCat).obj (GlueData.U D.toGlueData j)
eq₂ : ↑(GlueData.ι D.toGlueData j) x₂ = x
y : ↑(GlueData.V D.toGlueData ({ fst := i, snd := x₁ }.fst, { fst := j, snd := x₂ }.fst))
e₁ : ↑(GlueData.f D.toGlueData i j) y = x₁
⊢ x ∈ Set.range ↑(GlueData.f D.toGlueData i j ≫ GlueData.ι D.toGlueData i)
[PROOFSTEP]
substs eq₁
[GOAL]
case h.mp.intro.intro.intro.inr.intro.intro
D : GlueData
i j : D.J
x₁ : (forget TopCat).obj (GlueData.U D.toGlueData i)
x₂ : (forget TopCat).obj (GlueData.U D.toGlueData j)
y : ↑(GlueData.V D.toGlueData ({ fst := i, snd := x₁ }.fst, { fst := j, snd := x₂ }.fst))
e₁ : ↑(GlueData.f D.toGlueData i j) y = x₁
eq₂ : ↑(GlueData.ι D.toGlueData j) x₂ = ↑(GlueData.ι D.toGlueData i) x₁
⊢ ↑(GlueData.ι D.toGlueData i) x₁ ∈ Set.range ↑(GlueData.f D.toGlueData i j ≫ GlueData.ι D.toGlueData i)
[PROOFSTEP]
exact ⟨y, by simp [e₁]⟩
[GOAL]
D : GlueData
i j : D.J
x₁ : (forget TopCat).obj (GlueData.U D.toGlueData i)
x₂ : (forget TopCat).obj (GlueData.U D.toGlueData j)
y : ↑(GlueData.V D.toGlueData ({ fst := i, snd := x₁ }.fst, { fst := j, snd := x₂ }.fst))
e₁ : ↑(GlueData.f D.toGlueData i j) y = x₁
eq₂ : ↑(GlueData.ι D.toGlueData j) x₂ = ↑(GlueData.ι D.toGlueData i) x₁
⊢ ↑(GlueData.f D.toGlueData i j ≫ GlueData.ι D.toGlueData i) y = ↑(GlueData.ι D.toGlueData i) x₁
[PROOFSTEP]
simp [e₁]
[GOAL]
case h.mpr
D : GlueData
i j : D.J
x : (forget TopCat).obj (GlueData.glued D.toGlueData)
⊢ x ∈ Set.range ↑(GlueData.f D.toGlueData i j ≫ GlueData.ι D.toGlueData i) →
    x ∈ Set.range ↑(GlueData.ι D.toGlueData i) ∩ Set.range ↑(GlueData.ι D.toGlueData j)
[PROOFSTEP]
rintro ⟨x, hx⟩
[GOAL]
case h.mpr.intro
D : GlueData
i j : D.J
x✝ : (forget TopCat).obj (GlueData.glued D.toGlueData)
x : (forget TopCat).obj (GlueData.V D.toGlueData (i, j))
hx : ↑(GlueData.f D.toGlueData i j ≫ GlueData.ι D.toGlueData i) x = x✝
⊢ x✝ ∈ Set.range ↑(GlueData.ι D.toGlueData i) ∩ Set.range ↑(GlueData.ι D.toGlueData j)
[PROOFSTEP]
exact ⟨⟨D.f i j x, hx⟩, ⟨D.f j i (D.t _ _ x), by simp [← hx]⟩⟩
[GOAL]
D : GlueData
i j : D.J
x✝ : (forget TopCat).obj (GlueData.glued D.toGlueData)
x : (forget TopCat).obj (GlueData.V D.toGlueData (i, j))
hx : ↑(GlueData.f D.toGlueData i j ≫ GlueData.ι D.toGlueData i) x = x✝
⊢ ↑(GlueData.ι D.toGlueData j) (↑(GlueData.f D.toGlueData j i) (↑(GlueData.t D.toGlueData i j) x)) = x✝
[PROOFSTEP]
simp [← hx]
[GOAL]
D : GlueData
i j : D.J
⊢ ↑(GlueData.ι D.toGlueData j) ⁻¹' Set.range ↑(GlueData.ι D.toGlueData i) = Set.range ↑(GlueData.f D.toGlueData j i)
[PROOFSTEP]
rw [← Set.preimage_image_eq (Set.range (D.f j i)) (D.ι_injective j), ← Set.image_univ, ← Set.image_univ, ←
  Set.image_comp, ← coe_comp, Set.image_univ, Set.image_univ, ← image_inter, Set.preimage_range_inter]
[GOAL]
D : GlueData
i j : D.J
U : Set ↑(GlueData.U D.toGlueData i)
⊢ ↑(GlueData.ι D.toGlueData j) ⁻¹' (↑(GlueData.ι D.toGlueData i) '' U) =
    ↑(GlueData.f D.toGlueData j i) '' (↑(GlueData.t D.toGlueData j i ≫ GlueData.f D.toGlueData i j) ⁻¹' U)
[PROOFSTEP]
have : D.f _ _ ⁻¹' (𝖣.ι j ⁻¹' (𝖣.ι i '' U)) = (D.t j i ≫ D.f _ _) ⁻¹' U :=
  by
  ext x
  conv_rhs => rw [← Set.preimage_image_eq U (D.ι_injective _)]
  generalize 𝖣.ι i '' U = U'
  simp
[GOAL]
D : GlueData
i j : D.J
U : Set ↑(GlueData.U D.toGlueData i)
⊢ ↑(GlueData.f D.toGlueData j i) ⁻¹' (↑(GlueData.ι D.toGlueData j) ⁻¹' (↑(GlueData.ι D.toGlueData i) '' U)) =
    ↑(GlueData.t D.toGlueData j i ≫ GlueData.f D.toGlueData i j) ⁻¹' U
[PROOFSTEP]
ext x
[GOAL]
case h
D : GlueData
i j : D.J
U : Set ↑(GlueData.U D.toGlueData i)
x : (forget TopCat).obj (GlueData.V D.toGlueData (j, i))
⊢ x ∈ ↑(GlueData.f D.toGlueData j i) ⁻¹' (↑(GlueData.ι D.toGlueData j) ⁻¹' (↑(GlueData.ι D.toGlueData i) '' U)) ↔
    x ∈ ↑(GlueData.t D.toGlueData j i ≫ GlueData.f D.toGlueData i j) ⁻¹' U
[PROOFSTEP]
conv_rhs => rw [← Set.preimage_image_eq U (D.ι_injective _)]
[GOAL]
D : GlueData
i j : D.J
U : Set ↑(GlueData.U D.toGlueData i)
x : (forget TopCat).obj (GlueData.V D.toGlueData (j, i))
| x ∈ ↑(GlueData.t D.toGlueData j i ≫ GlueData.f D.toGlueData i j) ⁻¹' U
[PROOFSTEP]
rw [← Set.preimage_image_eq U (D.ι_injective _)]
[GOAL]
D : GlueData
i j : D.J
U : Set ↑(GlueData.U D.toGlueData i)
x : (forget TopCat).obj (GlueData.V D.toGlueData (j, i))
| x ∈ ↑(GlueData.t D.toGlueData j i ≫ GlueData.f D.toGlueData i j) ⁻¹' U
[PROOFSTEP]
rw [← Set.preimage_image_eq U (D.ι_injective _)]
[GOAL]
D : GlueData
i j : D.J
U : Set ↑(GlueData.U D.toGlueData i)
x : (forget TopCat).obj (GlueData.V D.toGlueData (j, i))
| x ∈ ↑(GlueData.t D.toGlueData j i ≫ GlueData.f D.toGlueData i j) ⁻¹' U
[PROOFSTEP]
rw [← Set.preimage_image_eq U (D.ι_injective _)]
[GOAL]
case h
D : GlueData
i j : D.J
U : Set ↑(GlueData.U D.toGlueData i)
x : (forget TopCat).obj (GlueData.V D.toGlueData (j, i))
⊢ x ∈ ↑(GlueData.f D.toGlueData j i) ⁻¹' (↑(GlueData.ι D.toGlueData j) ⁻¹' (↑(GlueData.ι D.toGlueData i) '' U)) ↔
    x ∈
      ↑(GlueData.t D.toGlueData j i ≫ GlueData.f D.toGlueData i j) ⁻¹'
        (↑(GlueData.ι D.toGlueData i) ⁻¹' (↑(GlueData.ι D.toGlueData i) '' U))
[PROOFSTEP]
generalize 𝖣.ι i '' U = U'
[GOAL]
case h
D : GlueData
i j : D.J
U : Set ↑(GlueData.U D.toGlueData i)
x : (forget TopCat).obj (GlueData.V D.toGlueData (j, i))
U' : Set ((forget TopCat).obj (GlueData.glued D.toGlueData))
⊢ x ∈ ↑(GlueData.f D.toGlueData j i) ⁻¹' (↑(GlueData.ι D.toGlueData j) ⁻¹' U') ↔
    x ∈ ↑(GlueData.t D.toGlueData j i ≫ GlueData.f D.toGlueData i j) ⁻¹' (↑(GlueData.ι D.toGlueData i) ⁻¹' U')
[PROOFSTEP]
simp
[GOAL]
D : GlueData
i j : D.J
U : Set ↑(GlueData.U D.toGlueData i)
this :
  ↑(GlueData.f D.toGlueData j i) ⁻¹' (↑(GlueData.ι D.toGlueData j) ⁻¹' (↑(GlueData.ι D.toGlueData i) '' U)) =
    ↑(GlueData.t D.toGlueData j i ≫ GlueData.f D.toGlueData i j) ⁻¹' U
⊢ ↑(GlueData.ι D.toGlueData j) ⁻¹' (↑(GlueData.ι D.toGlueData i) '' U) =
    ↑(GlueData.f D.toGlueData j i) '' (↑(GlueData.t D.toGlueData j i ≫ GlueData.f D.toGlueData i j) ⁻¹' U)
[PROOFSTEP]
rw [← this, Set.image_preimage_eq_inter_range]
[GOAL]
D : GlueData
i j : D.J
U : Set ↑(GlueData.U D.toGlueData i)
this :
  ↑(GlueData.f D.toGlueData j i) ⁻¹' (↑(GlueData.ι D.toGlueData j) ⁻¹' (↑(GlueData.ι D.toGlueData i) '' U)) =
    ↑(GlueData.t D.toGlueData j i ≫ GlueData.f D.toGlueData i j) ⁻¹' U
⊢ ↑(GlueData.ι D.toGlueData j) ⁻¹' (↑(GlueData.ι D.toGlueData i) '' U) =
    ↑(GlueData.ι D.toGlueData j) ⁻¹' (↑(GlueData.ι D.toGlueData i) '' U) ∩ Set.range ↑(GlueData.f D.toGlueData j i)
[PROOFSTEP]
symm
[GOAL]
D : GlueData
i j : D.J
U : Set ↑(GlueData.U D.toGlueData i)
this :
  ↑(GlueData.f D.toGlueData j i) ⁻¹' (↑(GlueData.ι D.toGlueData j) ⁻¹' (↑(GlueData.ι D.toGlueData i) '' U)) =
    ↑(GlueData.t D.toGlueData j i ≫ GlueData.f D.toGlueData i j) ⁻¹' U
⊢ ↑(GlueData.ι D.toGlueData j) ⁻¹' (↑(GlueData.ι D.toGlueData i) '' U) ∩ Set.range ↑(GlueData.f D.toGlueData j i) =
    ↑(GlueData.ι D.toGlueData j) ⁻¹' (↑(GlueData.ι D.toGlueData i) '' U)
[PROOFSTEP]
apply Set.inter_eq_self_of_subset_left
[GOAL]
case a
D : GlueData
i j : D.J
U : Set ↑(GlueData.U D.toGlueData i)
this :
  ↑(GlueData.f D.toGlueData j i) ⁻¹' (↑(GlueData.ι D.toGlueData j) ⁻¹' (↑(GlueData.ι D.toGlueData i) '' U)) =
    ↑(GlueData.t D.toGlueData j i ≫ GlueData.f D.toGlueData i j) ⁻¹' U
⊢ ↑(GlueData.ι D.toGlueData j) ⁻¹' (↑(GlueData.ι D.toGlueData i) '' U) ⊆ Set.range ↑(GlueData.f D.toGlueData j i)
[PROOFSTEP]
rw [← D.preimage_range i j]
[GOAL]
case a
D : GlueData
i j : D.J
U : Set ↑(GlueData.U D.toGlueData i)
this :
  ↑(GlueData.f D.toGlueData j i) ⁻¹' (↑(GlueData.ι D.toGlueData j) ⁻¹' (↑(GlueData.ι D.toGlueData i) '' U)) =
    ↑(GlueData.t D.toGlueData j i ≫ GlueData.f D.toGlueData i j) ⁻¹' U
⊢ ↑(GlueData.ι D.toGlueData j) ⁻¹' (↑(GlueData.ι D.toGlueData i) '' U) ⊆
    ↑(GlueData.ι D.toGlueData j) ⁻¹' Set.range ↑(GlueData.ι D.toGlueData i)
[PROOFSTEP]
exact Set.preimage_mono (Set.image_subset_range _ _)
[GOAL]
D : GlueData
i j : D.J
U : Set ↑(GlueData.U D.toGlueData i)
⊢ ↑(GlueData.ι D.toGlueData j) ⁻¹' (↑(GlueData.ι D.toGlueData i) '' U) =
    ↑(GlueData.t D.toGlueData i j ≫ GlueData.f D.toGlueData j i) '' (↑(GlueData.f D.toGlueData i j) ⁻¹' U)
[PROOFSTEP]
convert D.preimage_image_eq_image i j U using 1
[GOAL]
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)
[PROOFSTEP]
rw [coe_comp, coe_comp]
  -- porting note: `show` was not needed, since `rw [← Set.image_image]` worked.
[GOAL]
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)
[PROOFSTEP]
show (fun x => ((forget TopCat).map _ ((forget TopCat).map _ x))) '' _ = _
[GOAL]
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)
[PROOFSTEP]
rw [← Set.image_image]
  -- porting note: `congr 1` was here, instead of `congr_arg`, however, it did nothing.
[GOAL]
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)
[PROOFSTEP]
refine congr_arg ?_ ?_
[GOAL]
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
[PROOFSTEP]
rw [← Set.eq_preimage_iff_image_eq, Set.preimage_preimage]
[GOAL]
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
[PROOFSTEP]
change _ = (D.t i j ≫ D.t j i ≫ _) ⁻¹' _
[GOAL]
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
[PROOFSTEP]
rw [𝖣.t_inv_assoc]
[GOAL]
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
[PROOFSTEP]
rw [← isIso_iff_bijective]
[GOAL]
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
[PROOFSTEP]
apply (forget TopCat).map_isIso
[GOAL]
D : GlueData
i : D.J
U : Opens ↑(GlueData.U D.toGlueData i)
⊢ IsOpen (↑(GlueData.ι D.toGlueData i) '' ↑U)
[PROOFSTEP]
rw [isOpen_iff]
[GOAL]
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))
[PROOFSTEP]
intro j
[GOAL]
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))
[PROOFSTEP]
rw [preimage_image_eq_image]
[GOAL]
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))
[PROOFSTEP]
apply (D.f_open _ _).isOpenMap
[GOAL]
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)
[PROOFSTEP]
apply (D.t j i ≫ D.f i j).continuous_toFun.isOpen_preimage
[GOAL]
case a.a
D : GlueData
i : D.J
U : Opens ↑(GlueData.U D.toGlueData i)
j : D.J
⊢ IsOpen ↑U
[PROOFSTEP]
exact U.isOpen
[GOAL]
D : GlueData
h : MkCore
i j : h.J
x : { x // x ∈ V h j i }
⊢ ↑(t h i j) (↑(t h j i) x) = x
[PROOFSTEP]
have := h.cocycle j i j x ?_
[GOAL]
case refine_2
D : GlueData
h : MkCore
i j : h.J
x : { x // 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 : { x // x ∈ V h j i } ⊢ ↑x ∈ V h j j
[PROOFSTEP]
rw [h.t_id] at this 
[GOAL]
case refine_2
D : GlueData
h : MkCore
i j : h.J
x : { x // 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 : { x // x ∈ V h j i }
⊢ ↑x ∈ V h j j
case refine_1 D : GlueData h : MkCore i j : h.J x : { x // x ∈ V h j i } ⊢ ↑x ∈ V h j j
[PROOFSTEP]
convert Subtype.eq this
[GOAL]
case refine_1
D : GlueData
h : MkCore
i j : h.J
x : { x // x ∈ V h j i }
⊢ ↑x ∈ V h j j
case refine_1
D : GlueData
h : MkCore
i j : h.J
x : { x // x ∈ V h j i }
⊢ ↑x ∈ V h j j
case refine_1 D : GlueData h : MkCore i j : h.J x : { x // x ∈ V h j i } ⊢ ↑x ∈ V h j j
[PROOFSTEP]
rw [h.V_id]
[GOAL]
case refine_1
D : GlueData
h : MkCore
i j : h.J
x : { x // x ∈ V h j i }
⊢ ↑x ∈ ⊤
[PROOFSTEP]
trivial
[GOAL]
D : GlueData
h : MkCore
i j : h.J
⊢ IsIso (MkCore.t h i j)
[PROOFSTEP]
use h.t j i
[GOAL]
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))
[PROOFSTEP]
constructor
[GOAL]
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))
[PROOFSTEP]
ext1
[GOAL]
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))
[PROOFSTEP]
ext1
[GOAL]
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✝
[PROOFSTEP]
exacts [h.t_inv _ _ _, h.t_inv _ _ _]
[GOAL]
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))
[PROOFSTEP]
refine' (pullbackIsoProdSubtype _ _).hom ≫ ⟨_, _⟩ ≫ (pullbackIsoProdSubtype _ _).inv
[GOAL]
case refine'_1
D : GlueData
h : MkCore
i j k : h.J
⊢ ↑(of { p // ↑(Opens.inclusion (V h i j)) p.fst = ↑(Opens.inclusion (V h i k)) p.snd }) →
    ↑(of { p // ↑(Opens.inclusion (V h j k)) p.fst = ↑(Opens.inclusion (V h j i)) p.snd })
[PROOFSTEP]
intro x
[GOAL]
case refine'_1
D : GlueData
h : MkCore
i j k : h.J
x : ↑(of { p // ↑(Opens.inclusion (V h i j)) p.fst = ↑(Opens.inclusion (V h i k)) p.snd })
⊢ ↑(of { p // ↑(Opens.inclusion (V h j k)) p.fst = ↑(Opens.inclusion (V h j i)) p.snd })
[PROOFSTEP]
refine' ⟨⟨⟨(h.t i j x.1.1).1, _⟩, h.t i j x.1.1⟩, rfl⟩
[GOAL]
case refine'_1
D : GlueData
h : MkCore
i j k : h.J
x : ↑(of { p // ↑(Opens.inclusion (V h i j)) p.fst = ↑(Opens.inclusion (V h i k)) p.snd })
⊢ ↑(↑(t h i j) (↑x).fst) ∈ V h j k
[PROOFSTEP]
rcases x with ⟨⟨⟨x, hx⟩, ⟨x', hx'⟩⟩, rfl : x = x'⟩
[GOAL]
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) }).fst) ∈
    V h j k
[PROOFSTEP]
exact h.t_inter _ ⟨x, hx⟩ hx'
[GOAL]
case refine'_2
D : GlueData
h : MkCore
i j k : h.J
⊢ Continuous fun x =>
    {
      val :=
        ({ val := ↑(↑(t h i j) (↑x).fst), property := (_ : ↑(↑(t h i j) (↑x).fst) ∈ V h j k) }, ↑(t h i j) (↑x).fst),
      property :=
        (_ :
          ↑(Opens.inclusion (V h j k))
              ({ val := ↑(↑(t h i j) (↑x).fst), property := (_ : ↑(↑(t h i j) (↑x).fst) ∈ V h j k) },
                  ↑(t h i j) (↑x).fst).fst =
            ↑(Opens.inclusion (V h j k))
              ({ val := ↑(↑(t h i j) (↑x).fst), property := (_ : ↑(↑(t h i j) (↑x).fst) ∈ V h j k) },
                  ↑(t h i j) (↑x).fst).fst) }
[PROOFSTEP]
have : Continuous (h.t i j) := map_continuous (self := ContinuousMap.toContinuousMapClass) _
[GOAL]
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).fst), property := (_ : ↑(↑(t h i j) (↑x).fst) ∈ V h j k) }, ↑(t h i j) (↑x).fst),
      property :=
        (_ :
          ↑(Opens.inclusion (V h j k))
              ({ val := ↑(↑(t h i j) (↑x).fst), property := (_ : ↑(↑(t h i j) (↑x).fst) ∈ V h j k) },
                  ↑(t h i j) (↑x).fst).fst =
            ↑(Opens.inclusion (V h j k))
              ({ val := ↑(↑(t h i j) (↑x).fst), property := (_ : ↑(↑(t h i j) (↑x).fst) ∈ V h j k) },
                  ↑(t h i j) (↑x).fst).fst) }
[PROOFSTEP]
exact ((Continuous.subtype_mk (by continuity) _).prod_mk (by continuity)).subtype_mk _
[GOAL]
D : GlueData
h : MkCore
i j k : h.J
this : Continuous ↑(t h i j)
⊢ Continuous fun x => ↑(↑(t h i j) (↑x).fst)
[PROOFSTEP]
continuity
[GOAL]
D : GlueData
h : MkCore
i j k : h.J
this : Continuous ↑(t h i j)
⊢ Continuous fun x => ↑(t h i j) (↑x).fst
[PROOFSTEP]
continuity
[GOAL]
D : GlueData
h : MkCore
i : h.J
⊢ IsIso ((fun i j => Opens.inclusion (MkCore.V h i j)) i i)
[PROOFSTEP]
dsimp only
[GOAL]
D : GlueData
h : MkCore
i : h.J
⊢ IsIso (Opens.inclusion (MkCore.V h i i))
[PROOFSTEP]
exact (h.V_id i).symm ▸ IsIso.of_iso (Opens.inclusionTopIso (h.U i))
[GOAL]
D : GlueData
h : MkCore
i : h.J
⊢ MkCore.t h i i = 𝟙 ((fun i => (Opens.toTopCat (MkCore.U h i.fst)).obj (MkCore.V h i.fst i.snd)) (i, i))
[PROOFSTEP]
ext
[GOAL]
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.fst)).obj (MkCore.V h i.fst i.snd)) (i, i))) x✝
[PROOFSTEP]
rw [h.t_id]
[GOAL]
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))
⊢ id x✝ = ↑(𝟙 ((fun i => (Opens.toTopCat (MkCore.U h i.fst)).obj (MkCore.V h i.fst i.snd)) (i, i))) x✝
[PROOFSTEP]
rfl
[GOAL]
D : GlueData
h : MkCore
i j k : h.J
⊢ MkCore.t' h i j k ≫ pullback.snd = pullback.fst ≫ MkCore.t h i j
[PROOFSTEP]
delta MkCore.t'
[GOAL]
D : GlueData
h : MkCore
i j k : h.J
⊢ ((pullbackIsoProdSubtype (Opens.inclusion (MkCore.V h i j)) (Opens.inclusion (MkCore.V h i k))).hom ≫
        (ContinuousMap.mk fun x =>
            {
              val :=
                ({ val := ↑(↑(MkCore.t h i j) (↑x).fst),
                    property := (_ : ↑(↑(MkCore.t h i j) (↑x).fst) ∈ MkCore.V h j k) },
                  ↑(MkCore.t h i j) (↑x).fst),
              property :=
                (_ :
                  ↑(Opens.inclusion (MkCore.V h j k))
                      ({ val := ↑(↑(MkCore.t h i j) (↑x).fst),
                            property := (_ : ↑(↑(MkCore.t h i j) (↑x).fst) ∈ MkCore.V h j k) },
                          ↑(MkCore.t h i j) (↑x).fst).fst =
                    ↑(Opens.inclusion (MkCore.V h j k))
                      ({ val := ↑(↑(MkCore.t h i j) (↑x).fst),
                            property := (_ : ↑(↑(MkCore.t h i j) (↑x).fst) ∈ MkCore.V h j k) },
                          ↑(MkCore.t h i j) (↑x).fst).fst) }) ≫
          (pullbackIsoProdSubtype (Opens.inclusion (MkCore.V h j k)) (Opens.inclusion (MkCore.V h j i))).inv) ≫
      pullback.snd =
    pullback.fst ≫ MkCore.t h i j
[PROOFSTEP]
rw [Category.assoc, Category.assoc, pullbackIsoProdSubtype_inv_snd, ← Iso.eq_inv_comp,
  pullbackIsoProdSubtype_inv_fst_assoc]
[GOAL]
D : GlueData
h : MkCore
i j k : h.J
⊢ (ContinuousMap.mk fun x =>
        {
          val :=
            ({ val := ↑(↑(MkCore.t h i j) (↑x).fst), property := (_ : ↑(↑(MkCore.t h i j) (↑x).fst) ∈ MkCore.V h j k) },
              ↑(MkCore.t h i j) (↑x).fst),
          property :=
            (_ :
              ↑(Opens.inclusion (MkCore.V h j k))
                  ({ val := ↑(↑(MkCore.t h i j) (↑x).fst),
                        property := (_ : ↑(↑(MkCore.t h i j) (↑x).fst) ∈ MkCore.V h j k) },
                      ↑(MkCore.t h i j) (↑x).fst).fst =
                ↑(Opens.inclusion (MkCore.V h j k))
                  ({ val := ↑(↑(MkCore.t h i j) (↑x).fst),
                        property := (_ : ↑(↑(MkCore.t h i j) (↑x).fst) ∈ MkCore.V h j k) },
                      ↑(MkCore.t h i j) (↑x).fst).fst) }) ≫
      pullbackSnd (Opens.inclusion (MkCore.V h j k)) (Opens.inclusion (MkCore.V h j i)) =
    pullbackFst (Opens.inclusion (MkCore.V h i j)) (Opens.inclusion (MkCore.V h i k)) ≫ MkCore.t h i j
[PROOFSTEP]
ext ⟨⟨⟨x, hx⟩, ⟨x', hx'⟩⟩, rfl : x = x'⟩
[GOAL]
case w.mk.mk.mk.mk
D : GlueData
h : MkCore
i j k : h.J
x : ↑(MkCore.U h i)
hx : x ∈ MkCore.V h i j
hx' : x ∈ MkCore.V h i k
⊢ ↑((ContinuousMap.mk fun x =>
            {
              val :=
                ({ val := ↑(↑(MkCore.t h i j) (↑x).fst),
                    property := (_ : ↑(↑(MkCore.t h i j) (↑x).fst) ∈ MkCore.V h j k) },
                  ↑(MkCore.t h i j) (↑x).fst),
              property :=
                (_ :
                  ↑(Opens.inclusion (MkCore.V h j k))
                      ({ val := ↑(↑(MkCore.t h i j) (↑x).fst),
                            property := (_ : ↑(↑(MkCore.t h i j) (↑x).fst) ∈ MkCore.V h j k) },
                          ↑(MkCore.t h i j) (↑x).fst).fst =
                    ↑(Opens.inclusion (MkCore.V h j k))
                      ({ val := ↑(↑(MkCore.t h i j) (↑x).fst),
                            property := (_ : ↑(↑(MkCore.t h i j) (↑x).fst) ∈ MkCore.V h j k) },
                          ↑(MkCore.t h i j) (↑x).fst).fst) }) ≫
          pullbackSnd (Opens.inclusion (MkCore.V h j k)) (Opens.inclusion (MkCore.V h j i)))
      { val := ({ val := x, property := hx }, { val := x, property := hx' }), property := (_ : x = x) } =
    ↑(pullbackFst (Opens.inclusion (MkCore.V h i j)) (Opens.inclusion (MkCore.V h i k)) ≫ MkCore.t h i j)
      { val := ({ val := x, property := hx }, { val := x, property := hx' }), property := (_ : x = x) }
[PROOFSTEP]
rfl
[GOAL]
D : GlueData
h : MkCore
i j k : h.J
⊢ MkCore.t' h i j k ≫ MkCore.t' h j k i ≫ MkCore.t' h k i j =
    𝟙 (pullback ((fun i j => Opens.inclusion (MkCore.V h i j)) i j) ((fun i j => Opens.inclusion (MkCore.V h i j)) i k))
[PROOFSTEP]
delta MkCore.t'
[GOAL]
D : GlueData
h : MkCore
i j k : h.J
⊢ ((pullbackIsoProdSubtype (Opens.inclusion (MkCore.V h i j)) (Opens.inclusion (MkCore.V h i k))).hom ≫
        (ContinuousMap.mk fun x =>
            {
              val :=
                ({ val := ↑(↑(MkCore.t h i j) (↑x).fst),
                    property := (_ : ↑(↑(MkCore.t h i j) (↑x).fst) ∈ MkCore.V h j k) },
                  ↑(MkCore.t h i j) (↑x).fst),
              property :=
                (_ :
                  ↑(Opens.inclusion (MkCore.V h j k))
                      ({ val := ↑(↑(MkCore.t h i j) (↑x).fst),
                            property := (_ : ↑(↑(MkCore.t h i j) (↑x).fst) ∈ MkCore.V h j k) },
                          ↑(MkCore.t h i j) (↑x).fst).fst =
                    ↑(Opens.inclusion (MkCore.V h j k))
                      ({ val := ↑(↑(MkCore.t h i j) (↑x).fst),
                            property := (_ : ↑(↑(MkCore.t h i j) (↑x).fst) ∈ MkCore.V h j k) },
                          ↑(MkCore.t h i j) (↑x).fst).fst) }) ≫
          (pullbackIsoProdSubtype (Opens.inclusion (MkCore.V h j k)) (Opens.inclusion (MkCore.V h j i))).inv) ≫
      ((pullbackIsoProdSubtype (Opens.inclusion (MkCore.V h j k)) (Opens.inclusion (MkCore.V h j i))).hom ≫
          (ContinuousMap.mk fun x =>
              {
                val :=
                  ({ val := ↑(↑(MkCore.t h j k) (↑x).fst),
                      property := (_ : ↑(↑(MkCore.t h j k) (↑x).fst) ∈ MkCore.V h k i) },
                    ↑(MkCore.t h j k) (↑x).fst),
                property :=
                  (_ :
                    ↑(Opens.inclusion (MkCore.V h k i))
                        ({ val := ↑(↑(MkCore.t h j k) (↑x).fst),
                              property := (_ : ↑(↑(MkCore.t h j k) (↑x).fst) ∈ MkCore.V h k i) },
                            ↑(MkCore.t h j k) (↑x).fst).fst =
                      ↑(Opens.inclusion (MkCore.V h k i))
                        ({ val := ↑(↑(MkCore.t h j k) (↑x).fst),
                              property := (_ : ↑(↑(MkCore.t h j k) (↑x).fst) ∈ MkCore.V h k i) },
                            ↑(MkCore.t h j k) (↑x).fst).fst) }) ≫
            (pullbackIsoProdSubtype (Opens.inclusion (MkCore.V h k i)) (Opens.inclusion (MkCore.V h k j))).inv) ≫
        (pullbackIsoProdSubtype (Opens.inclusion (MkCore.V h k i)) (Opens.inclusion (MkCore.V h k j))).hom ≫
          (ContinuousMap.mk fun x =>
              {
                val :=
                  ({ val := ↑(↑(MkCore.t h k i) (↑x).fst),
                      property := (_ : ↑(↑(MkCore.t h k i) (↑x).fst) ∈ MkCore.V h i j) },
                    ↑(MkCore.t h k i) (↑x).fst),
                property :=
                  (_ :
                    ↑(Opens.inclusion (MkCore.V h i j))
                        ({ val := ↑(↑(MkCore.t h k i) (↑x).fst),
                              property := (_ : ↑(↑(MkCore.t h k i) (↑x).fst) ∈ MkCore.V h i j) },
                            ↑(MkCore.t h k i) (↑x).fst).fst =
                      ↑(Opens.inclusion (MkCore.V h i j))
                        ({ val := ↑(↑(MkCore.t h k i) (↑x).fst),
                              property := (_ : ↑(↑(MkCore.t h k i) (↑x).fst) ∈ MkCore.V h i j) },
                            ↑(MkCore.t h k i) (↑x).fst).fst) }) ≫
            (pullbackIsoProdSubtype (Opens.inclusion (MkCore.V h i j)) (Opens.inclusion (MkCore.V h i k))).inv =
    𝟙 (pullback ((fun i j => Opens.inclusion (MkCore.V h i j)) i j) ((fun i j => Opens.inclusion (MkCore.V h i j)) i k))
[PROOFSTEP]
simp_rw [← Category.assoc]
[GOAL]
D : GlueData
h : MkCore
i j k : h.J
⊢ ((((((((pullbackIsoProdSubtype (Opens.inclusion (MkCore.V h i j)) (Opens.inclusion (MkCore.V h i k))).hom ≫
                    ContinuousMap.mk fun x =>
                      {
                        val :=
                          ({ val := ↑(↑(MkCore.t h i j) (↑x).fst),
                              property := (_ : ↑(↑(MkCore.t h i j) (↑x).fst) ∈ MkCore.V h j k) },
                            ↑(MkCore.t h i j) (↑x).fst),
                        property :=
                          (_ :
                            ↑(Opens.inclusion (MkCore.V h j k))
                                ({ val := ↑(↑(MkCore.t h i j) (↑x).fst),
                                      property := (_ : ↑(↑(MkCore.t h i j) (↑x).fst) ∈ MkCore.V h j k) },
                                    ↑(MkCore.t h i j) (↑x).fst).fst =
                              ↑(Opens.inclusion (MkCore.V h j k))
                                ({ val := ↑(↑(MkCore.t h i j) (↑x).fst),
                                      property := (_ : ↑(↑(MkCore.t h i j) (↑x).fst) ∈ MkCore.V h j k) },
                                    ↑(MkCore.t h i j) (↑x).fst).fst) }) ≫
                  (pullbackIsoProdSubtype (Opens.inclusion (MkCore.V h j k)) (Opens.inclusion (MkCore.V h j i))).inv) ≫
                (pullbackIsoProdSubtype (Opens.inclusion (MkCore.V h j k)) (Opens.inclusion (MkCore.V h j i))).hom) ≫
              ContinuousMap.mk fun x =>
                {
                  val :=
                    ({ val := ↑(↑(MkCore.t h j k) (↑x).fst),
                        property := (_ : ↑(↑(MkCore.t h j k) (↑x).fst) ∈ MkCore.V h k i) },
                      ↑(MkCore.t h j k) (↑x).fst),
                  property :=
                    (_ :
                      ↑(Opens.inclusion (MkCore.V h k i))
                          ({ val := ↑(↑(MkCore.t h j k) (↑x).fst),
                                property := (_ : ↑(↑(MkCore.t h j k) (↑x).fst) ∈ MkCore.V h k i) },
                              ↑(MkCore.t h j k) (↑x).fst).fst =
                        ↑(Opens.inclusion (MkCore.V h k i))
                          ({ val := ↑(↑(MkCore.t h j k) (↑x).fst),
                                property := (_ : ↑(↑(MkCore.t h j k) (↑x).fst) ∈ MkCore.V h k i) },
                              ↑(MkCore.t h j k) (↑x).fst).fst) }) ≫
            (pullbackIsoProdSubtype (Opens.inclusion (MkCore.V h k i)) (Opens.inclusion (MkCore.V h k j))).inv) ≫
          (pullbackIsoProdSubtype (Opens.inclusion (MkCore.V h k i)) (Opens.inclusion (MkCore.V h k j))).hom) ≫
        ContinuousMap.mk fun x =>
          {
            val :=
              ({ val := ↑(↑(MkCore.t h k i) (↑x).fst),
                  property := (_ : ↑(↑(MkCore.t h k i) (↑x).fst) ∈ MkCore.V h i j) },
                ↑(MkCore.t h k i) (↑x).fst),
            property :=
              (_ :
                ↑(Opens.inclusion (MkCore.V h i j))
                    ({ val := ↑(↑(MkCore.t h k i) (↑x).fst),
                          property := (_ : ↑(↑(MkCore.t h k i) (↑x).fst) ∈ MkCore.V h i j) },
                        ↑(MkCore.t h k i) (↑x).fst).fst =
                  ↑(Opens.inclusion (MkCore.V h i j))
                    ({ val := ↑(↑(MkCore.t h k i) (↑x).fst),
                          property := (_ : ↑(↑(MkCore.t h k i) (↑x).fst) ∈ MkCore.V h i j) },
                        ↑(MkCore.t h k i) (↑x).fst).fst) }) ≫
      (pullbackIsoProdSubtype (Opens.inclusion (MkCore.V h i j)) (Opens.inclusion (MkCore.V h i k))).inv =
    𝟙 (pullback (Opens.inclusion (MkCore.V h i j)) (Opens.inclusion (MkCore.V h i k)))
[PROOFSTEP]
rw [Iso.comp_inv_eq]
[GOAL]
D : GlueData
h : MkCore
i j k : h.J
⊢ ((((((((pullbackIsoProdSubtype (Opens.inclusion (MkCore.V h i j)) (Opens.inclusion (MkCore.V h i k))).hom ≫
                  ContinuousMap.mk fun x =>
                    {
                      val :=
                        ({ val := ↑(↑(MkCore.t h i j) (↑x).fst),
                            property := (_ : ↑(↑(MkCore.t h i j) (↑x).fst) ∈ MkCore.V h j k) },
                          ↑(MkCore.t h i j) (↑x).fst),
                      property :=
                        (_ :
                          ↑(Opens.inclusion (MkCore.V h j k))
                              ({ val := ↑(↑(MkCore.t h i j) (↑x).fst),
                                    property := (_ : ↑(↑(MkCore.t h i j) (↑x).fst) ∈ MkCore.V h j k) },
                                  ↑(MkCore.t h i j) (↑x).fst).fst =
                            ↑(Opens.inclusion (MkCore.V h j k))
                              ({ val := ↑(↑(MkCore.t h i j) (↑x).fst),
                                    property := (_ : ↑(↑(MkCore.t h i j) (↑x).fst) ∈ MkCore.V h j k) },
                                  ↑(MkCore.t h i j) (↑x).fst).fst) }) ≫
                (pullbackIsoProdSubtype (Opens.inclusion (MkCore.V h j k)) (Opens.inclusion (MkCore.V h j i))).inv) ≫
              (pullbackIsoProdSubtype (Opens.inclusion (MkCore.V h j k)) (Opens.inclusion (MkCore.V h j i))).hom) ≫
            ContinuousMap.mk fun x =>
              {
                val :=
                  ({ val := ↑(↑(MkCore.t h j k) (↑x).fst),
                      property := (_ : ↑(↑(MkCore.t h j k) (↑x).fst) ∈ MkCore.V h k i) },
                    ↑(MkCore.t h j k) (↑x).fst),
                property :=
                  (_ :
                    ↑(Opens.inclusion (MkCore.V h k i))
                        ({ val := ↑(↑(MkCore.t h j k) (↑x).fst),
                              property := (_ : ↑(↑(MkCore.t h j k) (↑x).fst) ∈ MkCore.V h k i) },
                            ↑(MkCore.t h j k) (↑x).fst).fst =
                      ↑(Opens.inclusion (MkCore.V h k i))
                        ({ val := ↑(↑(MkCore.t h j k) (↑x).fst),
                              property := (_ : ↑(↑(MkCore.t h j k) (↑x).fst) ∈ MkCore.V h k i) },
                            ↑(MkCore.t h j k) (↑x).fst).fst) }) ≫
          (pullbackIsoProdSubtype (Opens.inclusion (MkCore.V h k i)) (Opens.inclusion (MkCore.V h k j))).inv) ≫
        (pullbackIsoProdSubtype (Opens.inclusion (MkCore.V h k i)) (Opens.inclusion (MkCore.V h k j))).hom) ≫
      ContinuousMap.mk fun x =>
        {
          val :=
            ({ val := ↑(↑(MkCore.t h k i) (↑x).fst), property := (_ : ↑(↑(MkCore.t h k i) (↑x).fst) ∈ MkCore.V h i j) },
              ↑(MkCore.t h k i) (↑x).fst),
          property :=
            (_ :
              ↑(Opens.inclusion (MkCore.V h i j))
                  ({ val := ↑(↑(MkCore.t h k i) (↑x).fst),
                        property := (_ : ↑(↑(MkCore.t h k i) (↑x).fst) ∈ MkCore.V h i j) },
                      ↑(MkCore.t h k i) (↑x).fst).fst =
                ↑(Opens.inclusion (MkCore.V h i j))
                  ({ val := ↑(↑(MkCore.t h k i) (↑x).fst),
                        property := (_ : ↑(↑(MkCore.t h k i) (↑x).fst) ∈ MkCore.V h i j) },
                      ↑(MkCore.t h k i) (↑x).fst).fst) }) =
    𝟙 (pullback (Opens.inclusion (MkCore.V h i j)) (Opens.inclusion (MkCore.V h i k))) ≫
      (pullbackIsoProdSubtype (Opens.inclusion (MkCore.V h i j)) (Opens.inclusion (MkCore.V h i k))).hom
[PROOFSTEP]
simp only [Iso.inv_hom_id_assoc, Category.assoc, Category.id_comp]
[GOAL]
D : GlueData
h : MkCore
i j k : h.J
⊢ ((pullbackIsoProdSubtype (Opens.inclusion (MkCore.V h i j)) (Opens.inclusion (MkCore.V h i k))).hom ≫
      (ContinuousMap.mk fun x =>
          {
            val :=
              ({ val := ↑(↑(MkCore.t h i j) (↑x).fst),
                  property := (_ : ↑(↑(MkCore.t h i j) (↑x).fst) ∈ MkCore.V h j k) },
                ↑(MkCore.t h i j) (↑x).fst),
            property :=
              (_ :
                ↑(Opens.inclusion (MkCore.V h j k))
                    ({ val := ↑(↑(MkCore.t h i j) (↑x).fst),
                          property := (_ : ↑(↑(MkCore.t h i j) (↑x).fst) ∈ MkCore.V h j k) },
                        ↑(MkCore.t h i j) (↑x).fst).fst =
                  ↑(Opens.inclusion (MkCore.V h j k))
                    ({ val := ↑(↑(MkCore.t h i j) (↑x).fst),
                          property := (_ : ↑(↑(MkCore.t h i j) (↑x).fst) ∈ MkCore.V h j k) },
                        ↑(MkCore.t h i j) (↑x).fst).fst) }) ≫
        (ContinuousMap.mk fun x =>
            {
              val :=
                ({ val := ↑(↑(MkCore.t h j k) (↑x).fst),
                    property := (_ : ↑(↑(MkCore.t h j k) (↑x).fst) ∈ MkCore.V h k i) },
                  ↑(MkCore.t h j k) (↑x).fst),
              property :=
                (_ :
                  ↑(Opens.inclusion (MkCore.V h k i))
                      ({ val := ↑(↑(MkCore.t h j k) (↑x).fst),
                            property := (_ : ↑(↑(MkCore.t h j k) (↑x).fst) ∈ MkCore.V h k i) },
                          ↑(MkCore.t h j k) (↑x).fst).fst =
                    ↑(Opens.inclusion (MkCore.V h k i))
                      ({ val := ↑(↑(MkCore.t h j k) (↑x).fst),
                            property := (_ : ↑(↑(MkCore.t h j k) (↑x).fst) ∈ MkCore.V h k i) },
                          ↑(MkCore.t h j k) (↑x).fst).fst) }) ≫
          ContinuousMap.mk fun x =>
            {
              val :=
                ({ val := ↑(↑(MkCore.t h k i) (↑x).fst),
                    property := (_ : ↑(↑(MkCore.t h k i) (↑x).fst) ∈ MkCore.V h i j) },
                  ↑(MkCore.t h k i) (↑x).fst),
              property :=
                (_ :
                  ↑(Opens.inclusion (MkCore.V h i j))
                      ({ val := ↑(↑(MkCore.t h k i) (↑x).fst),
                            property := (_ : ↑(↑(MkCore.t h k i) (↑x).fst) ∈ MkCore.V h i j) },
                          ↑(MkCore.t h k i) (↑x).fst).fst =
                    ↑(Opens.inclusion (MkCore.V h i j))
                      ({ val := ↑(↑(MkCore.t h k i) (↑x).fst),
                            property := (_ : ↑(↑(MkCore.t h k i) (↑x).fst) ∈ MkCore.V h i j) },
                          ↑(MkCore.t h k i) (↑x).fst).fst) }) =
    (pullbackIsoProdSubtype (Opens.inclusion (MkCore.V h i j)) (Opens.inclusion (MkCore.V h i k))).hom
[PROOFSTEP]
rw [← Iso.eq_inv_comp, Iso.inv_hom_id]
[GOAL]
D : GlueData
h : MkCore
i j k : h.J
⊢ ((ContinuousMap.mk fun x =>
        {
          val :=
            ({ val := ↑(↑(MkCore.t h i j) (↑x).fst), property := (_ : ↑(↑(MkCore.t h i j) (↑x).fst) ∈ MkCore.V h j k) },
              ↑(MkCore.t h i j) (↑x).fst),
          property :=
            (_ :
              ↑(Opens.inclusion (MkCore.V h j k))
                  ({ val := ↑(↑(MkCore.t h i j) (↑x).fst),
                        property := (_ : ↑(↑(MkCore.t h i j) (↑x).fst) ∈ MkCore.V h j k) },
                      ↑(MkCore.t h i j) (↑x).fst).fst =
                ↑(Opens.inclusion (MkCore.V h j k))
                  ({ val := ↑(↑(MkCore.t h i j) (↑x).fst),
                        property := (_ : ↑(↑(MkCore.t h i j) (↑x).fst) ∈ MkCore.V h j k) },
                      ↑(MkCore.t h i j) (↑x).fst).fst) }) ≫
      (ContinuousMap.mk fun x =>
          {
            val :=
              ({ val := ↑(↑(MkCore.t h j k) (↑x).fst),
                  property := (_ : ↑(↑(MkCore.t h j k) (↑x).fst) ∈ MkCore.V h k i) },
                ↑(MkCore.t h j k) (↑x).fst),
            property :=
              (_ :
                ↑(Opens.inclusion (MkCore.V h k i))
                    ({ val := ↑(↑(MkCore.t h j k) (↑x).fst),
                          property := (_ : ↑(↑(MkCore.t h j k) (↑x).fst) ∈ MkCore.V h k i) },
                        ↑(MkCore.t h j k) (↑x).fst).fst =
                  ↑(Opens.inclusion (MkCore.V h k i))
                    ({ val := ↑(↑(MkCore.t h j k) (↑x).fst),
                          property := (_ : ↑(↑(MkCore.t h j k) (↑x).fst) ∈ MkCore.V h k i) },
                        ↑(MkCore.t h j k) (↑x).fst).fst) }) ≫
        ContinuousMap.mk fun x =>
          {
            val :=
              ({ val := ↑(↑(MkCore.t h k i) (↑x).fst),
                  property := (_ : ↑(↑(MkCore.t h k i) (↑x).fst) ∈ MkCore.V h i j) },
                ↑(MkCore.t h k i) (↑x).fst),
            property :=
              (_ :
                ↑(Opens.inclusion (MkCore.V h i j))
                    ({ val := ↑(↑(MkCore.t h k i) (↑x).fst),
                          property := (_ : ↑(↑(MkCore.t h k i) (↑x).fst) ∈ MkCore.V h i j) },
                        ↑(MkCore.t h k i) (↑x).fst).fst =
                  ↑(Opens.inclusion (MkCore.V h i j))
                    ({ val := ↑(↑(MkCore.t h k i) (↑x).fst),
                          property := (_ : ↑(↑(MkCore.t h k i) (↑x).fst) ∈ MkCore.V h i j) },
                        ↑(MkCore.t h k i) (↑x).fst).fst) }) =
    𝟙 (of { p // ↑(Opens.inclusion (MkCore.V h i j)) p.fst = ↑(Opens.inclusion (MkCore.V h i k)) p.snd })
[PROOFSTEP]
ext1 ⟨⟨⟨x, hx⟩, ⟨x', hx'⟩⟩, rfl : x = x'⟩
[GOAL]
case w.mk.mk.mk.mk
D : GlueData
h : MkCore
i j k : h.J
x : ↑(MkCore.U h i)
hx : x ∈ MkCore.V h i j
hx' : x ∈ MkCore.V h i k
⊢ ↑((ContinuousMap.mk fun x =>
            {
              val :=
                ({ val := ↑(↑(MkCore.t h i j) (↑x).fst),
                    property := (_ : ↑(↑(MkCore.t h i j) (↑x).fst) ∈ MkCore.V h j k) },
                  ↑(MkCore.t h i j) (↑x).fst),
              property :=
                (_ :
                  ↑(Opens.inclusion (MkCore.V h j k))
                      ({ val := ↑(↑(MkCore.t h i j) (↑x).fst),
                            property := (_ : ↑(↑(MkCore.t h i j) (↑x).fst) ∈ MkCore.V h j k) },
                          ↑(MkCore.t h i j) (↑x).fst).fst =
                    ↑(Opens.inclusion (MkCore.V h j k))
                      ({ val := ↑(↑(MkCore.t h i j) (↑x).fst),
                            property := (_ : ↑(↑(MkCore.t h i j) (↑x).fst) ∈ MkCore.V h j k) },
                          ↑(MkCore.t h i j) (↑x).fst).fst) }) ≫
          (ContinuousMap.mk fun x =>
              {
                val :=
                  ({ val := ↑(↑(MkCore.t h j k) (↑x).fst),
                      property := (_ : ↑(↑(MkCore.t h j k) (↑x).fst) ∈ MkCore.V h k i) },
                    ↑(MkCore.t h j k) (↑x).fst),
                property :=
                  (_ :
                    ↑(Opens.inclusion (MkCore.V h k i))
                        ({ val := ↑(↑(MkCore.t h j k) (↑x).fst),
                              property := (_ : ↑(↑(MkCore.t h j k) (↑x).fst) ∈ MkCore.V h k i) },
                            ↑(MkCore.t h j k) (↑x).fst).fst =
                      ↑(Opens.inclusion (MkCore.V h k i))
                        ({ val := ↑(↑(MkCore.t h j k) (↑x).fst),
                              property := (_ : ↑(↑(MkCore.t h j k) (↑x).fst) ∈ MkCore.V h k i) },
                            ↑(MkCore.t h j k) (↑x).fst).fst) }) ≫
            ContinuousMap.mk fun x =>
              {
                val :=
                  ({ val := ↑(↑(MkCore.t h k i) (↑x).fst),
                      property := (_ : ↑(↑(MkCore.t h k i) (↑x).fst) ∈ MkCore.V h i j) },
                    ↑(MkCore.t h k i) (↑x).fst),
                property :=
                  (_ :
                    ↑(Opens.inclusion (MkCore.V h i j))
                        ({ val := ↑(↑(MkCore.t h k i) (↑x).fst),
                              property := (_ : ↑(↑(MkCore.t h k i) (↑x).fst) ∈ MkCore.V h i j) },
                            ↑(MkCore.t h k i) (↑x).fst).fst =
                      ↑(Opens.inclusion (MkCore.V h i j))
                        ({ val := ↑(↑(MkCore.t h k i) (↑x).fst),
                              property := (_ : ↑(↑(MkCore.t h k i) (↑x).fst) ∈ MkCore.V h i j) },
                            ↑(MkCore.t h k i) (↑x).fst).fst) })
      { val := ({ val := x, property := hx }, { val := x, property := hx' }), property := (_ : x = x) } =
    ↑(𝟙 (of { p // ↑(Opens.inclusion (MkCore.V h i j)) p.fst = ↑(Opens.inclusion (MkCore.V h i k)) p.snd }))
      { val := ({ val := x, property := hx }, { val := x, property := hx' }), property := (_ : x = x) }
[PROOFSTEP]
rw [comp_app, ContinuousMap.coe_mk, comp_app, id_app, ContinuousMap.coe_mk, Subtype.mk_eq_mk, Prod.mk.inj_iff,
  Subtype.mk_eq_mk, Subtype.ext_iff, and_self_iff]
[GOAL]
case w.mk.mk.mk.mk
D : GlueData
h : MkCore
i j k : h.J
x : ↑(MkCore.U h i)
hx : x ∈ MkCore.V h i j
hx' : x ∈ MkCore.V h i k
⊢ ↑(↑(MkCore.t h k i)
        (↑(↑(ContinuousMap.mk fun x =>
                  {
                    val :=
                      ({ val := ↑(↑(MkCore.t h j k) (↑x).fst),
                          property := (_ : ↑(↑(MkCore.t h j k) (↑x).fst) ∈ MkCore.V h k i) },
                        ↑(MkCore.t h j k) (↑x).fst),
                    property :=
                      (_ :
                        ↑(Opens.inclusion (MkCore.V h k i))
                            ({ val := ↑(↑(MkCore.t h j k) (↑x).fst),
                                  property := (_ : ↑(↑(MkCore.t h j k) (↑x).fst) ∈ MkCore.V h k i) },
                                ↑(MkCore.t h j k) (↑x).fst).fst =
                          ↑(Opens.inclusion (MkCore.V h k i))
                            ({ val := ↑(↑(MkCore.t h j k) (↑x).fst),
                                  property := (_ : ↑(↑(MkCore.t h j k) (↑x).fst) ∈ MkCore.V h k i) },
                                ↑(MkCore.t h j k) (↑x).fst).fst) })
              {
                val :=
                  ({
                      val :=
                        ↑(↑(MkCore.t h i j)
                            (↑{ val := ({ val := x, property := hx }, { val := x, property := hx' }),
                                  property := (_ : x = x) }).fst),
                      property :=
                        (_ :
                          ↑(↑(MkCore.t h i j)
                                (↑{ val := ({ val := x, property := hx }, { val := x, property := hx' }),
                                      property := (_ : x = x) }).fst) ∈
                            MkCore.V h j k) },
                    ↑(MkCore.t h i j)
                      (↑{ val := ({ val := x, property := hx }, { val := x, property := hx' }),
                            property := (_ : x = x) }).fst),
                property :=
                  (_ :
                    ↑(Opens.inclusion (MkCore.V h j k))
                        ({
                              val :=
                                ↑(↑(MkCore.t h i j)
                                    (↑{ val := ({ val := x, property := hx }, { val := x, property := hx' }),
                                          property := (_ : x = x) }).fst),
                              property :=
                                (_ :
                                  ↑(↑(MkCore.t h i j)
                                        (↑{ val := ({ val := x, property := hx }, { val := x, property := hx' }),
                                              property := (_ : x = x) }).fst) ∈
                                    MkCore.V h j k) },
                            ↑(MkCore.t h i j)
                              (↑{ val := ({ val := x, property := hx }, { val := x, property := hx' }),
                                    property := (_ : x = x) }).fst).fst =
                      ↑(Opens.inclusion (MkCore.V h j k))
                        ({
                              val :=
                                ↑(↑(MkCore.t h i j)
                                    (↑{ val := ({ val := x, property := hx }, { val := x, property := hx' }),
                                          property := (_ : x = x) }).fst),
                              property :=
                                (_ :
                                  ↑(↑(MkCore.t h i j)
                                        (↑{ val := ({ val := x, property := hx }, { val := x, property := hx' }),
                                              property := (_ : x = x) }).fst) ∈
                                    MkCore.V h j k) },
                            ↑(MkCore.t h i j)
                              (↑{ val := ({ val := x, property := hx }, { val := x, property := hx' }),
                                    property := (_ : x = x) }).fst).fst) })).fst) =
    x
[PROOFSTEP]
convert congr_arg Subtype.val (h.t_inv k i ⟨x, hx'⟩) using 3
[GOAL]
case h.e'_2.h.e'_3.h.e'_6
D : GlueData
h : MkCore
i j k : h.J
x : ↑(MkCore.U h i)
hx : x ∈ MkCore.V h i j
hx' : x ∈ MkCore.V h i k
⊢ (↑(↑(ContinuousMap.mk fun x =>
              {
                val :=
                  ({ val := ↑(↑(MkCore.t h j k) (↑x).fst),
                      property := (_ : ↑(↑(MkCore.t h j k) (↑x).fst) ∈ MkCore.V h k i) },
                    ↑(MkCore.t h j k) (↑x).fst),
                property :=
                  (_ :
                    ↑(Opens.inclusion (MkCore.V h k i))
                        ({ val := ↑(↑(MkCore.t h j k) (↑x).fst),
                              property := (_ : ↑(↑(MkCore.t h j k) (↑x).fst) ∈ MkCore.V h k i) },
                            ↑(MkCore.t h j k) (↑x).fst).fst =
                      ↑(Opens.inclusion (MkCore.V h k i))
                        ({ val := ↑(↑(MkCore.t h j k) (↑x).fst),
                              property := (_ : ↑(↑(MkCore.t h j k) (↑x).fst) ∈ MkCore.V h k i) },
                            ↑(MkCore.t h j k) (↑x).fst).fst) })
          {
            val :=
              ({
                  val :=
                    ↑(↑(MkCore.t h i j)
                        (↑{ val := ({ val := x, property := hx }, { val := x, property := hx' }),
                              property := (_ : x = x) }).fst),
                  property :=
                    (_ :
                      ↑(↑(MkCore.t h i j)
                            (↑{ val := ({ val := x, property := hx }, { val := x, property := hx' }),
                                  property := (_ : x = x) }).fst) ∈
                        MkCore.V h j k) },
                ↑(MkCore.t h i j)
                  (↑{ val := ({ val := x, property := hx }, { val := x, property := hx' }),
                        property := (_ : x = x) }).fst),
            property :=
              (_ :
                ↑(Opens.inclusion (MkCore.V h j k))
                    ({
                          val :=
                            ↑(↑(MkCore.t h i j)
                                (↑{ val := ({ val := x, property := hx }, { val := x, property := hx' }),
                                      property := (_ : x = x) }).fst),
                          property :=
                            (_ :
                              ↑(↑(MkCore.t h i j)
                                    (↑{ val := ({ val := x, property := hx }, { val := x, property := hx' }),
                                          property := (_ : x = x) }).fst) ∈
                                MkCore.V h j k) },
                        ↑(MkCore.t h i j)
                          (↑{ val := ({ val := x, property := hx }, { val := x, property := hx' }),
                                property := (_ : x = x) }).fst).fst =
                  ↑(Opens.inclusion (MkCore.V h j k))
                    ({
                          val :=
                            ↑(↑(MkCore.t h i j)
                                (↑{ val := ({ val := x, property := hx }, { val := x, property := hx' }),
                                      property := (_ : x = x) }).fst),
                          property :=
                            (_ :
                              ↑(↑(MkCore.t h i j)
                                    (↑{ val := ({ val := x, property := hx }, { val := x, property := hx' }),
                                          property := (_ : x = x) }).fst) ∈
                                MkCore.V h j k) },
                        ↑(MkCore.t h i j)
                          (↑{ val := ({ val := x, property := hx }, { val := x, property := hx' }),
                                property := (_ : x = x) }).fst).fst) })).fst =
    ↑(MkCore.t h i k) { val := x, property := hx' }
[PROOFSTEP]
refine Subtype.ext ?_
[GOAL]
case h.e'_2.h.e'_3.h.e'_6
D : GlueData
h : MkCore
i j k : h.J
x : ↑(MkCore.U h i)
hx : x ∈ MkCore.V h i j
hx' : x ∈ MkCore.V h i k
⊢ ↑(↑(↑(ContinuousMap.mk fun x =>
                {
                  val :=
                    ({ val := ↑(↑(MkCore.t h j k) (↑x).fst),
                        property := (_ : ↑(↑(MkCore.t h j k) (↑x).fst) ∈ MkCore.V h k i) },
                      ↑(MkCore.t h j k) (↑x).fst),
                  property :=
                    (_ :
                      ↑(Opens.inclusion (MkCore.V h k i))
                          ({ val := ↑(↑(MkCore.t h j k) (↑x).fst),
                                property := (_ : ↑(↑(MkCore.t h j k) (↑x).fst) ∈ MkCore.V h k i) },
                              ↑(MkCore.t h j k) (↑x).fst).fst =
                        ↑(Opens.inclusion (MkCore.V h k i))
                          ({ val := ↑(↑(MkCore.t h j k) (↑x).fst),
                                property := (_ : ↑(↑(MkCore.t h j k) (↑x).fst) ∈ MkCore.V h k i) },
                              ↑(MkCore.t h j k) (↑x).fst).fst) })
            {
              val :=
                ({
                    val :=
                      ↑(↑(MkCore.t h i j)
                          (↑{ val := ({ val := x, property := hx }, { val := x, property := hx' }),
                                property := (_ : x = x) }).fst),
                    property :=
                      (_ :
                        ↑(↑(MkCore.t h i j)
                              (↑{ val := ({ val := x, property := hx }, { val := x, property := hx' }),
                                    property := (_ : x = x) }).fst) ∈
                          MkCore.V h j k) },
                  ↑(MkCore.t h i j)
                    (↑{ val := ({ val := x, property := hx }, { val := x, property := hx' }),
                          property := (_ : x = x) }).fst),
              property :=
                (_ :
                  ↑(Opens.inclusion (MkCore.V h j k))
                      ({
                            val :=
                              ↑(↑(MkCore.t h i j)
                                  (↑{ val := ({ val := x, property := hx }, { val := x, property := hx' }),
                                        property := (_ : x = x) }).fst),
                            property :=
                              (_ :
                                ↑(↑(MkCore.t h i j)
                                      (↑{ val := ({ val := x, property := hx }, { val := x, property := hx' }),
                                            property := (_ : x = x) }).fst) ∈
                                  MkCore.V h j k) },
                          ↑(MkCore.t h i j)
                            (↑{ val := ({ val := x, property := hx }, { val := x, property := hx' }),
                                  property := (_ : x = x) }).fst).fst =
                    ↑(Opens.inclusion (MkCore.V h j k))
                      ({
                            val :=
                              ↑(↑(MkCore.t h i j)
                                  (↑{ val := ({ val := x, property := hx }, { val := x, property := hx' }),
                                        property := (_ : x = x) }).fst),
                            property :=
                              (_ :
                                ↑(↑(MkCore.t h i j)
                                      (↑{ val := ({ val := x, property := hx }, { val := x, property := hx' }),
                                            property := (_ : x = x) }).fst) ∈
                                  MkCore.V h j k) },
                          ↑(MkCore.t h i j)
                            (↑{ val := ({ val := x, property := hx }, { val := x, property := hx' }),
                                  property := (_ : x = x) }).fst).fst) })).fst =
    ↑(↑(MkCore.t h i k) { val := x, property := hx' })
[PROOFSTEP]
exact h.cocycle i j k ⟨x, hx⟩ hx'
[GOAL]
D : GlueData
α : Type u
inst✝ : TopologicalSpace α
J : Type u
U : J → Opens α
i j : J
⊢ Continuous fun x =>
    { val := { val := ↑↑x, property := (_ : ↑x ∈ (fun i j => (Opens.map (Opens.inclusion (U i))).obj (U j)) i j) },
      property := (_ : ↑↑x ∈ U i) }
[PROOFSTEP]
refine Continuous.subtype_mk ?_ ?_
[GOAL]
D : GlueData
α : Type u
inst✝ : TopologicalSpace α
J : Type u
U : J → Opens α
i j : J
⊢ Continuous fun x =>
    { val := ↑↑x, property := (_ : ↑x ∈ (fun i j => (Opens.map (Opens.inclusion (U i))).obj (U j)) i j) }
[PROOFSTEP]
refine Continuous.subtype_mk ?_ ?_
[GOAL]
D : GlueData
α : Type u
inst✝ : TopologicalSpace α
J : Type u
U : J → Opens α
i j : J
⊢ Continuous fun x => ↑↑x
[PROOFSTEP]
continuity
[GOAL]
D : GlueData
α : Type u
inst✝ : TopologicalSpace α
J : Type u
U : J → Opens α
i : J
⊢ (fun i j => (Opens.map (Opens.inclusion (U i))).obj (U j)) i i = ⊤
[PROOFSTEP]
ext
  -- porting note: no longer needed `cases U i`!
[GOAL]
case h.h
D : GlueData
α : Type u
inst✝ : TopologicalSpace α
J : Type u
U : J → Opens α
i : J
x✝ : ↑((Opens.toTopCat (of α)).obj (U i))
⊢ x✝ ∈ ↑((fun i j => (Opens.map (Opens.inclusion (U i))).obj (U j)) i i) ↔ x✝ ∈ ↑⊤
[PROOFSTEP]
simp
[GOAL]
D : GlueData
α : Type u
inst✝ : TopologicalSpace α
J : Type u
U : J → Opens α
i : J
⊢ ↑((fun i j =>
          ContinuousMap.mk fun x =>
            {
              val :=
                { val := ↑↑x, property := (_ : ↑x ∈ (fun i j => (Opens.map (Opens.inclusion (U i))).obj (U j)) i j) },
              property := (_ : ↑↑x ∈ U i) })
        i i) =
    id
[PROOFSTEP]
ext
[GOAL]
case h
D : GlueData
α : Type u
inst✝ : TopologicalSpace α
J : Type u
U : J → Opens α
i : J
x✝ :
  (forget TopCat).obj
    ((Opens.toTopCat ((fun i => (Opens.toTopCat (of α)).obj (U i)) i)).obj
      ((fun i j => (Opens.map (Opens.inclusion (U i))).obj (U j)) i i))
⊢ ↑((fun i j =>
            ContinuousMap.mk fun x =>
              {
                val :=
                  { val := ↑↑x, property := (_ : ↑x ∈ (fun i j => (Opens.map (Opens.inclusion (U i))).obj (U j)) i j) },
                property := (_ : ↑↑x ∈ U i) })
          i i)
      x✝ =
    id x✝
[PROOFSTEP]
rfl
[GOAL]
D : GlueData
α : Type u
inst✝ : TopologicalSpace α
J : Type u
U : J → Opens α
⊢ ∀ (a : (GlueData.diagram (ofOpenSubsets U).toGlueData).L),
    MultispanIndex.fst (GlueData.diagram (ofOpenSubsets U).toGlueData) a ≫
        (fun x => Opens.inclusion (U x)) (MultispanIndex.fstFrom (GlueData.diagram (ofOpenSubsets U).toGlueData) a) =
      MultispanIndex.snd (GlueData.diagram (ofOpenSubsets U).toGlueData) a ≫
        (fun x => Opens.inclusion (U x)) (MultispanIndex.sndFrom (GlueData.diagram (ofOpenSubsets U).toGlueData) a)
[PROOFSTEP]
rintro ⟨i, j⟩
[GOAL]
case mk
D : GlueData
α : Type u
inst✝ : TopologicalSpace α
J : Type u
U : J → Opens α
i j : (ofOpenSubsets U).toGlueData.J
⊢ MultispanIndex.fst (GlueData.diagram (ofOpenSubsets U).toGlueData) (i, j) ≫
      (fun x => Opens.inclusion (U x)) (MultispanIndex.fstFrom (GlueData.diagram (ofOpenSubsets U).toGlueData) (i, j)) =
    MultispanIndex.snd (GlueData.diagram (ofOpenSubsets U).toGlueData) (i, j) ≫
      (fun x => Opens.inclusion (U x)) (MultispanIndex.sndFrom (GlueData.diagram (ofOpenSubsets U).toGlueData) (i, j))
[PROOFSTEP]
ext x
[GOAL]
case mk.w
D : GlueData
α : Type u
inst✝ : TopologicalSpace α
J : Type u
U : J → Opens α
i j : (ofOpenSubsets U).toGlueData.J
x : (forget TopCat).obj (MultispanIndex.left (GlueData.diagram (ofOpenSubsets U).toGlueData) (i, j))
⊢ ↑(MultispanIndex.fst (GlueData.diagram (ofOpenSubsets U).toGlueData) (i, j) ≫
          (fun x => Opens.inclusion (U x))
            (MultispanIndex.fstFrom (GlueData.diagram (ofOpenSubsets U).toGlueData) (i, j)))
      x =
    ↑(MultispanIndex.snd (GlueData.diagram (ofOpenSubsets U).toGlueData) (i, j) ≫
          (fun x => Opens.inclusion (U x))
            (MultispanIndex.sndFrom (GlueData.diagram (ofOpenSubsets U).toGlueData) (i, j)))
      x
[PROOFSTEP]
rfl
[GOAL]
D : GlueData
α : Type u
inst✝ : TopologicalSpace α
J : Type u
U : J → Opens α
⊢ Function.Injective ↑(fromOpenSubsetsGlue U)
[PROOFSTEP]
intro x y e
[GOAL]
D : GlueData
α : Type u
inst✝ : TopologicalSpace α
J : Type u
U : J → Opens α
x y : (forget TopCat).obj (GlueData.glued (ofOpenSubsets U).toGlueData)
e : ↑(fromOpenSubsetsGlue U) x = ↑(fromOpenSubsetsGlue U) y
⊢ x = y
[PROOFSTEP]
obtain ⟨i, ⟨x, hx⟩, rfl⟩ := (ofOpenSubsets U).ι_jointly_surjective x
[GOAL]
case intro.intro.mk
D : GlueData
α : Type u
inst✝ : TopologicalSpace α
J : Type u
U : J → Opens α
y : (forget TopCat).obj (GlueData.glued (ofOpenSubsets U).toGlueData)
i : (ofOpenSubsets U).toGlueData.J
x : ↑(of α)
hx : x ∈ U i
e :
  ↑(fromOpenSubsetsGlue U) (↑(GlueData.ι (ofOpenSubsets U).toGlueData i) { val := x, property := hx }) =
    ↑(fromOpenSubsetsGlue U) y
⊢ ↑(GlueData.ι (ofOpenSubsets U).toGlueData i) { val := x, property := hx } = y
[PROOFSTEP]
obtain ⟨j, ⟨y, hy⟩, rfl⟩ := (ofOpenSubsets U).ι_jointly_surjective y
[GOAL]
case intro.intro.mk.intro.intro.mk
D : GlueData
α : Type u
inst✝ : TopologicalSpace α
J : Type u
U : J → Opens α
i : (ofOpenSubsets U).toGlueData.J
x : ↑(of α)
hx : x ∈ U i
j : (ofOpenSubsets U).toGlueData.J
y : ↑(of α)
hy : y ∈ U j
e :
  ↑(fromOpenSubsetsGlue U) (↑(GlueData.ι (ofOpenSubsets U).toGlueData i) { val := x, property := hx }) =
    ↑(fromOpenSubsetsGlue U) (↑(GlueData.ι (ofOpenSubsets U).toGlueData j) { val := y, property := hy })
⊢ ↑(GlueData.ι (ofOpenSubsets U).toGlueData i) { val := x, property := hx } =
    ↑(GlueData.ι (ofOpenSubsets U).toGlueData j) { val := y, property := hy }
[PROOFSTEP]
erw [ι_fromOpenSubsetsGlue_apply, ι_fromOpenSubsetsGlue_apply] at e 
[GOAL]
case intro.intro.mk.intro.intro.mk
D : GlueData
α : Type u
inst✝ : TopologicalSpace α
J : Type u
U : J → Opens α
i : (ofOpenSubsets U).toGlueData.J
x : ↑(of α)
hx : x ∈ U i
j : (ofOpenSubsets U).toGlueData.J
y : ↑(of α)
hy : y ∈ U j
e : ↑(Opens.inclusion (U i)) { val := x, property := hx } = ↑(Opens.inclusion (U j)) { val := y, property := hy }
⊢ ↑(GlueData.ι (ofOpenSubsets U).toGlueData i) { val := x, property := hx } =
    ↑(GlueData.ι (ofOpenSubsets U).toGlueData j) { val := y, property := hy }
[PROOFSTEP]
change x = y at e 
[GOAL]
case intro.intro.mk.intro.intro.mk
D : GlueData
α : Type u
inst✝ : TopologicalSpace α
J : Type u
U : J → Opens α
i : (ofOpenSubsets U).toGlueData.J
x : ↑(of α)
hx : x ∈ U i
j : (ofOpenSubsets U).toGlueData.J
y : ↑(of α)
hy : y ∈ U j
e : x = y
⊢ ↑(GlueData.ι (ofOpenSubsets U).toGlueData i) { val := x, property := hx } =
    ↑(GlueData.ι (ofOpenSubsets U).toGlueData j) { val := y, property := hy }
[PROOFSTEP]
subst e
[GOAL]
case intro.intro.mk.intro.intro.mk
D : GlueData
α : Type u
inst✝ : TopologicalSpace α
J : Type u
U : J → Opens α
i : (ofOpenSubsets U).toGlueData.J
x : ↑(of α)
hx : x ∈ U i
j : (ofOpenSubsets U).toGlueData.J
hy : x ∈ U j
⊢ ↑(GlueData.ι (ofOpenSubsets U).toGlueData i) { val := x, property := hx } =
    ↑(GlueData.ι (ofOpenSubsets U).toGlueData j) { val := x, property := hy }
[PROOFSTEP]
rw [(ofOpenSubsets U).ι_eq_iff_rel]
[GOAL]
case intro.intro.mk.intro.intro.mk
D : GlueData
α : Type u
inst✝ : TopologicalSpace α
J : Type u
U : J → Opens α
i : (ofOpenSubsets U).toGlueData.J
x : ↑(of α)
hx : x ∈ U i
j : (ofOpenSubsets U).toGlueData.J
hy : x ∈ U j
⊢ Rel (ofOpenSubsets U) { fst := i, snd := { val := x, property := hx } }
    { fst := j, snd := { val := x, property := hy } }
[PROOFSTEP]
right
[GOAL]
case intro.intro.mk.intro.intro.mk.h
D : GlueData
α : Type u
inst✝ : TopologicalSpace α
J : Type u
U : J → Opens α
i : (ofOpenSubsets U).toGlueData.J
x : ↑(of α)
hx : x ∈ U i
j : (ofOpenSubsets U).toGlueData.J
hy : x ∈ U j
⊢ ∃ x_1,
    ↑(GlueData.f (ofOpenSubsets U).toGlueData { fst := i, snd := { val := x, property := hx } }.fst
              { fst := j, snd := { val := x, property := hy } }.fst)
          x_1 =
        { fst := i, snd := { val := x, property := hx } }.snd ∧
      ↑(GlueData.f (ofOpenSubsets U).toGlueData { fst := j, snd := { val := x, property := hy } }.fst
              { fst := i, snd := { val := x, property := hx } }.fst)
          (↑(GlueData.t (ofOpenSubsets U).toGlueData { fst := i, snd := { val := x, property := hx } }.fst
                { fst := j, snd := { val := x, property := hy } }.fst)
            x_1) =
        { fst := j, snd := { val := x, property := hy } }.snd
[PROOFSTEP]
exact ⟨⟨⟨x, hx⟩, hy⟩, rfl, rfl⟩
[GOAL]
D : GlueData
α : Type u
inst✝ : TopologicalSpace α
J : Type u
U : J → Opens α
⊢ IsOpenMap ↑(fromOpenSubsetsGlue U)
[PROOFSTEP]
intro s hs
[GOAL]
D : GlueData
α : Type u
inst✝ : TopologicalSpace α
J : Type u
U : J → Opens α
s : Set ((forget TopCat).obj (GlueData.glued (ofOpenSubsets U).toGlueData))
hs : IsOpen s
⊢ IsOpen (↑(fromOpenSubsetsGlue U) '' s)
[PROOFSTEP]
rw [(ofOpenSubsets U).isOpen_iff] at hs 
[GOAL]
D : GlueData
α : Type u
inst✝ : TopologicalSpace α
J : Type u
U : J → Opens α
s : Set ((forget TopCat).obj (GlueData.glued (ofOpenSubsets U).toGlueData))
hs : ∀ (i : (ofOpenSubsets U).toGlueData.J), IsOpen (↑(GlueData.ι (ofOpenSubsets U).toGlueData i) ⁻¹' s)
⊢ IsOpen (↑(fromOpenSubsetsGlue U) '' s)
[PROOFSTEP]
rw [isOpen_iff_forall_mem_open]
[GOAL]
D : GlueData
α : Type u
inst✝ : TopologicalSpace α
J : Type u
U : J → Opens α
s : Set ((forget TopCat).obj (GlueData.glued (ofOpenSubsets U).toGlueData))
hs : ∀ (i : (ofOpenSubsets U).toGlueData.J), IsOpen (↑(GlueData.ι (ofOpenSubsets U).toGlueData i) ⁻¹' s)
⊢ ∀ (x : (forget TopCat).obj (of α)),
    x ∈ ↑(fromOpenSubsetsGlue U) '' s → ∃ t, t ⊆ ↑(fromOpenSubsetsGlue U) '' s ∧ IsOpen t ∧ x ∈ t
[PROOFSTEP]
rintro _ ⟨x, hx, rfl⟩
[GOAL]
case intro.intro
D : GlueData
α : Type u
inst✝ : TopologicalSpace α
J : Type u
U : J → Opens α
s : Set ((forget TopCat).obj (GlueData.glued (ofOpenSubsets U).toGlueData))
hs : ∀ (i : (ofOpenSubsets U).toGlueData.J), IsOpen (↑(GlueData.ι (ofOpenSubsets U).toGlueData i) ⁻¹' s)
x : (forget TopCat).obj (GlueData.glued (ofOpenSubsets U).toGlueData)
hx : x ∈ s
⊢ ∃ t, t ⊆ ↑(fromOpenSubsetsGlue U) '' s ∧ IsOpen t ∧ ↑(fromOpenSubsetsGlue U) x ∈ t
[PROOFSTEP]
obtain ⟨i, ⟨x, hx'⟩, rfl⟩ := (ofOpenSubsets U).ι_jointly_surjective x
[GOAL]
case intro.intro.intro.intro.mk
D : GlueData
α : Type u
inst✝ : TopologicalSpace α
J : Type u
U : J → Opens α
s : Set ((forget TopCat).obj (GlueData.glued (ofOpenSubsets U).toGlueData))
hs : ∀ (i : (ofOpenSubsets U).toGlueData.J), IsOpen (↑(GlueData.ι (ofOpenSubsets U).toGlueData i) ⁻¹' s)
i : (ofOpenSubsets U).toGlueData.J
x : ↑(of α)
hx' : x ∈ U i
hx : ↑(GlueData.ι (ofOpenSubsets U).toGlueData i) { val := x, property := hx' } ∈ s
⊢ ∃ t,
    t ⊆ ↑(fromOpenSubsetsGlue U) '' s ∧
      IsOpen t ∧
        ↑(fromOpenSubsetsGlue U) (↑(GlueData.ι (ofOpenSubsets U).toGlueData i) { val := x, property := hx' }) ∈ t
[PROOFSTEP]
use fromOpenSubsetsGlue U '' s ∩ Set.range (@Opens.inclusion (TopCat.of α) (U i))
[GOAL]
case h
D : GlueData
α : Type u
inst✝ : TopologicalSpace α
J : Type u
U : J → Opens α
s : Set ((forget TopCat).obj (GlueData.glued (ofOpenSubsets U).toGlueData))
hs : ∀ (i : (ofOpenSubsets U).toGlueData.J), IsOpen (↑(GlueData.ι (ofOpenSubsets U).toGlueData i) ⁻¹' s)
i : (ofOpenSubsets U).toGlueData.J
x : ↑(of α)
hx' : x ∈ U i
hx : ↑(GlueData.ι (ofOpenSubsets U).toGlueData i) { val := x, property := hx' } ∈ s
⊢ ↑(fromOpenSubsetsGlue U) '' s ∩ Set.range ↑(Opens.inclusion (U i)) ⊆ ↑(fromOpenSubsetsGlue U) '' s ∧
    IsOpen (↑(fromOpenSubsetsGlue U) '' s ∩ Set.range ↑(Opens.inclusion (U i))) ∧
      ↑(fromOpenSubsetsGlue U) (↑(GlueData.ι (ofOpenSubsets U).toGlueData i) { val := x, property := hx' }) ∈
        ↑(fromOpenSubsetsGlue U) '' s ∩ Set.range ↑(Opens.inclusion (U i))
[PROOFSTEP]
use Set.inter_subset_left _ _
[GOAL]
case right
D : GlueData
α : Type u
inst✝ : TopologicalSpace α
J : Type u
U : J → Opens α
s : Set ((forget TopCat).obj (GlueData.glued (ofOpenSubsets U).toGlueData))
hs : ∀ (i : (ofOpenSubsets U).toGlueData.J), IsOpen (↑(GlueData.ι (ofOpenSubsets U).toGlueData i) ⁻¹' s)
i : (ofOpenSubsets U).toGlueData.J
x : ↑(of α)
hx' : x ∈ U i
hx : ↑(GlueData.ι (ofOpenSubsets U).toGlueData i) { val := x, property := hx' } ∈ s
⊢ IsOpen (↑(fromOpenSubsetsGlue U) '' s ∩ Set.range ↑(Opens.inclusion (U i))) ∧
    ↑(fromOpenSubsetsGlue U) (↑(GlueData.ι (ofOpenSubsets U).toGlueData i) { val := x, property := hx' }) ∈
      ↑(fromOpenSubsetsGlue U) '' s ∩ Set.range ↑(Opens.inclusion (U i))
[PROOFSTEP]
constructor
[GOAL]
case right.left
D : GlueData
α : Type u
inst✝ : TopologicalSpace α
J : Type u
U : J → Opens α
s : Set ((forget TopCat).obj (GlueData.glued (ofOpenSubsets U).toGlueData))
hs : ∀ (i : (ofOpenSubsets U).toGlueData.J), IsOpen (↑(GlueData.ι (ofOpenSubsets U).toGlueData i) ⁻¹' s)
i : (ofOpenSubsets U).toGlueData.J
x : ↑(of α)
hx' : x ∈ U i
hx : ↑(GlueData.ι (ofOpenSubsets U).toGlueData i) { val := x, property := hx' } ∈ s
⊢ IsOpen (↑(fromOpenSubsetsGlue U) '' s ∩ Set.range ↑(Opens.inclusion (U i)))
[PROOFSTEP]
erw [← Set.image_preimage_eq_inter_range]
[GOAL]
case right.left
D : GlueData
α : Type u
inst✝ : TopologicalSpace α
J : Type u
U : J → Opens α
s : Set ((forget TopCat).obj (GlueData.glued (ofOpenSubsets U).toGlueData))
hs : ∀ (i : (ofOpenSubsets U).toGlueData.J), IsOpen (↑(GlueData.ι (ofOpenSubsets U).toGlueData i) ⁻¹' s)
i : (ofOpenSubsets U).toGlueData.J
x : ↑(of α)
hx' : x ∈ U i
hx : ↑(GlueData.ι (ofOpenSubsets U).toGlueData i) { val := x, property := hx' } ∈ s
⊢ IsOpen (↑(Opens.inclusion (U i)) '' (↑(Opens.inclusion (U i)) ⁻¹' (↑(fromOpenSubsetsGlue U) '' s)))
[PROOFSTEP]
apply (Opens.openEmbedding (X := TopCat.of α) (U i)).isOpenMap
[GOAL]
case right.left.a
D : GlueData
α : Type u
inst✝ : TopologicalSpace α
J : Type u
U : J → Opens α
s : Set ((forget TopCat).obj (GlueData.glued (ofOpenSubsets U).toGlueData))
hs : ∀ (i : (ofOpenSubsets U).toGlueData.J), IsOpen (↑(GlueData.ι (ofOpenSubsets U).toGlueData i) ⁻¹' s)
i : (ofOpenSubsets U).toGlueData.J
x : ↑(of α)
hx' : x ∈ U i
hx : ↑(GlueData.ι (ofOpenSubsets U).toGlueData i) { val := x, property := hx' } ∈ s
⊢ IsOpen (↑(Opens.inclusion (U i)) ⁻¹' (↑(fromOpenSubsetsGlue U) '' s))
[PROOFSTEP]
convert hs i using 1
[GOAL]
case h.e'_3.h
D : GlueData
α : Type u
inst✝ : TopologicalSpace α
J : Type u
U : J → Opens α
s : Set ((forget TopCat).obj (GlueData.glued (ofOpenSubsets U).toGlueData))
hs : ∀ (i : (ofOpenSubsets U).toGlueData.J), IsOpen (↑(GlueData.ι (ofOpenSubsets U).toGlueData i) ⁻¹' s)
i : (ofOpenSubsets U).toGlueData.J
x : ↑(of α)
hx' : x ∈ U i
hx : ↑(GlueData.ι (ofOpenSubsets U).toGlueData i) { val := x, property := hx' } ∈ s
e_1✝ :
  (forget TopCat).obj ((Opens.toTopCat (of α)).obj (U i)) =
    (forget TopCat).obj (GlueData.U (ofOpenSubsets U).toGlueData i)
⊢ ↑(Opens.inclusion (U i)) ⁻¹' (↑(fromOpenSubsetsGlue U) '' s) = ↑(GlueData.ι (ofOpenSubsets U).toGlueData i) ⁻¹' s
[PROOFSTEP]
erw [← ι_fromOpenSubsetsGlue, coe_comp, Set.preimage_comp]
  --  porting note: `congr 1` did nothing, so I replaced it with `apply congr_arg`
[GOAL]
case h.e'_3.h
D : GlueData
α : Type u
inst✝ : TopologicalSpace α
J : Type u
U : J → Opens α
s : Set ((forget TopCat).obj (GlueData.glued (ofOpenSubsets U).toGlueData))
hs : ∀ (i : (ofOpenSubsets U).toGlueData.J), IsOpen (↑(GlueData.ι (ofOpenSubsets U).toGlueData i) ⁻¹' s)
i : (ofOpenSubsets U).toGlueData.J
x : ↑(of α)
hx' : x ∈ U i
hx : ↑(GlueData.ι (ofOpenSubsets U).toGlueData i) { val := x, property := hx' } ∈ s
e_1✝ :
  (forget TopCat).obj ((Opens.toTopCat (of α)).obj (U i)) =
    (forget TopCat).obj (GlueData.U (ofOpenSubsets U).toGlueData i)
⊢ ↑(GlueData.ι (ofOpenSubsets U).toGlueData i) ⁻¹' (↑(fromOpenSubsetsGlue U) ⁻¹' (↑(fromOpenSubsetsGlue U) '' s)) =
    ↑(GlueData.ι (ofOpenSubsets U).toGlueData i) ⁻¹' s
[PROOFSTEP]
apply congr_arg
[GOAL]
case h.e'_3.h.h
D : GlueData
α : Type u
inst✝ : TopologicalSpace α
J : Type u
U : J → Opens α
s : Set ((forget TopCat).obj (GlueData.glued (ofOpenSubsets U).toGlueData))
hs : ∀ (i : (ofOpenSubsets U).toGlueData.J), IsOpen (↑(GlueData.ι (ofOpenSubsets U).toGlueData i) ⁻¹' s)
i : (ofOpenSubsets U).toGlueData.J
x : ↑(of α)
hx' : x ∈ U i
hx : ↑(GlueData.ι (ofOpenSubsets U).toGlueData i) { val := x, property := hx' } ∈ s
e_1✝ :
  (forget TopCat).obj ((Opens.toTopCat (of α)).obj (U i)) =
    (forget TopCat).obj (GlueData.U (ofOpenSubsets U).toGlueData i)
⊢ ↑(fromOpenSubsetsGlue U) ⁻¹' (↑(fromOpenSubsetsGlue U) '' s) = s
[PROOFSTEP]
refine' Set.preimage_image_eq _ (fromOpenSubsetsGlue_injective U)
[GOAL]
case right.right
D : GlueData
α : Type u
inst✝ : TopologicalSpace α
J : Type u
U : J → Opens α
s : Set ((forget TopCat).obj (GlueData.glued (ofOpenSubsets U).toGlueData))
hs : ∀ (i : (ofOpenSubsets U).toGlueData.J), IsOpen (↑(GlueData.ι (ofOpenSubsets U).toGlueData i) ⁻¹' s)
i : (ofOpenSubsets U).toGlueData.J
x : ↑(of α)
hx' : x ∈ U i
hx : ↑(GlueData.ι (ofOpenSubsets U).toGlueData i) { val := x, property := hx' } ∈ s
⊢ ↑(fromOpenSubsetsGlue U) (↑(GlueData.ι (ofOpenSubsets U).toGlueData i) { val := x, property := hx' }) ∈
    ↑(fromOpenSubsetsGlue U) '' s ∩ Set.range ↑(Opens.inclusion (U i))
[PROOFSTEP]
refine'
  ⟨Set.mem_image_of_mem _ hx, _⟩
    -- porting note: another `rw ↦ erw`
        -- See above.
[GOAL]
case right.right
D : GlueData
α : Type u
inst✝ : TopologicalSpace α
J : Type u
U : J → Opens α
s : Set ((forget TopCat).obj (GlueData.glued (ofOpenSubsets U).toGlueData))
hs : ∀ (i : (ofOpenSubsets U).toGlueData.J), IsOpen (↑(GlueData.ι (ofOpenSubsets U).toGlueData i) ⁻¹' s)
i : (ofOpenSubsets U).toGlueData.J
x : ↑(of α)
hx' : x ∈ U i
hx : ↑(GlueData.ι (ofOpenSubsets U).toGlueData i) { val := x, property := hx' } ∈ s
⊢ ↑(fromOpenSubsetsGlue U) (↑(GlueData.ι (ofOpenSubsets U).toGlueData i) { val := x, property := hx' }) ∈
    Set.range ↑(Opens.inclusion (U i))
[PROOFSTEP]
erw [ι_fromOpenSubsetsGlue_apply]
[GOAL]
case right.right
D : GlueData
α : Type u
inst✝ : TopologicalSpace α
J : Type u
U : J → Opens α
s : Set ((forget TopCat).obj (GlueData.glued (ofOpenSubsets U).toGlueData))
hs : ∀ (i : (ofOpenSubsets U).toGlueData.J), IsOpen (↑(GlueData.ι (ofOpenSubsets U).toGlueData i) ⁻¹' s)
i : (ofOpenSubsets U).toGlueData.J
x : ↑(of α)
hx' : x ∈ U i
hx : ↑(GlueData.ι (ofOpenSubsets U).toGlueData i) { val := x, property := hx' } ∈ s
⊢ ↑(Opens.inclusion (U i)) { val := x, property := hx' } ∈ Set.range ↑(Opens.inclusion (U i))
[PROOFSTEP]
exact Set.mem_range_self _
[GOAL]
D : GlueData
α : Type u
inst✝ : TopologicalSpace α
J : Type u
U : J → Opens α
⊢ Set.range ↑(fromOpenSubsetsGlue U) = ⋃ (i : J), ↑(U i)
[PROOFSTEP]
ext
[GOAL]
case h
D : GlueData
α : Type u
inst✝ : TopologicalSpace α
J : Type u
U : J → Opens α
x✝ : (forget TopCat).obj (of α)
⊢ x✝ ∈ Set.range ↑(fromOpenSubsetsGlue U) ↔ x✝ ∈ ⋃ (i : J), ↑(U i)
[PROOFSTEP]
constructor
[GOAL]
case h.mp
D : GlueData
α : Type u
inst✝ : TopologicalSpace α
J : Type u
U : J → Opens α
x✝ : (forget TopCat).obj (of α)
⊢ x✝ ∈ Set.range ↑(fromOpenSubsetsGlue U) → x✝ ∈ ⋃ (i : J), ↑(U i)
[PROOFSTEP]
rintro ⟨x, rfl⟩
[GOAL]
case h.mp.intro
D : GlueData
α : Type u
inst✝ : TopologicalSpace α
J : Type u
U : J → Opens α
x : (forget TopCat).obj (GlueData.glued (ofOpenSubsets U).toGlueData)
⊢ ↑(fromOpenSubsetsGlue U) x ∈ ⋃ (i : J), ↑(U i)
[PROOFSTEP]
obtain ⟨i, ⟨x, hx'⟩, rfl⟩ := (ofOpenSubsets U).ι_jointly_surjective x
[GOAL]
case h.mp.intro.intro.intro.mk
D : GlueData
α : Type u
inst✝ : TopologicalSpace α
J : Type u
U : J → Opens α
i : (ofOpenSubsets U).toGlueData.J
x : ↑(of α)
hx' : x ∈ U i
⊢ ↑(fromOpenSubsetsGlue U) (↑(GlueData.ι (ofOpenSubsets U).toGlueData i) { val := x, property := hx' }) ∈
    ⋃ (i : J), ↑(U i)
[PROOFSTEP]
erw [ι_fromOpenSubsetsGlue_apply]
[GOAL]
case h.mp.intro.intro.intro.mk
D : GlueData
α : Type u
inst✝ : TopologicalSpace α
J : Type u
U : J → Opens α
i : (ofOpenSubsets U).toGlueData.J
x : ↑(of α)
hx' : x ∈ U i
⊢ ↑(Opens.inclusion (U i)) { val := x, property := hx' } ∈ ⋃ (i : J), ↑(U i)
[PROOFSTEP]
exact Set.subset_iUnion _ i hx'
[GOAL]
case h.mpr
D : GlueData
α : Type u
inst✝ : TopologicalSpace α
J : Type u
U : J → Opens α
x✝ : (forget TopCat).obj (of α)
⊢ x✝ ∈ ⋃ (i : J), ↑(U i) → x✝ ∈ Set.range ↑(fromOpenSubsetsGlue U)
[PROOFSTEP]
rintro ⟨_, ⟨i, rfl⟩, hx⟩
[GOAL]
case h.mpr.intro.intro.intro
D : GlueData
α : Type u
inst✝ : TopologicalSpace α
J : Type u
U : J → Opens α
x✝ : (forget TopCat).obj (of α)
i : J
hx : x✝ ∈ (fun i => ↑(U i)) i
⊢ x✝ ∈ Set.range ↑(fromOpenSubsetsGlue U)
[PROOFSTEP]
rename_i x
[GOAL]
case h.mpr.intro.intro.intro
D : GlueData
α : Type u
inst✝ : TopologicalSpace α
J : Type u
U : J → Opens α
x : (forget TopCat).obj (of α)
i : J
hx : x ∈ (fun i => ↑(U i)) i
⊢ x ∈ Set.range ↑(fromOpenSubsetsGlue U)
[PROOFSTEP]
refine' ⟨(ofOpenSubsets U).toGlueData.ι i ⟨x, hx⟩, ι_fromOpenSubsetsGlue_apply _ _ _⟩
