Theorem: AlgebraicGeometry.PresheafedSpace.GlueData.ιInvApp_π
File: Mathlib/Geometry/RingedSpace/PresheafedSpace/Gluing.lean

tactic: fconstructor
state_before: C : Type u
inst✝¹ : Category.{v, u} C
D : GlueData C
inst✝ : HasLimits C
i : D.J
U : Opens ↑↑(D.U i)
⊢ ∃ (eq :
    { unop := U } =
      {
        unop :=
          (Opens.map (colimit.ι D.diagram.multispan { unop := WalkingMultispan.right i }.unop).base).obj
            (⋯.functor.obj U) }),
    D.ιInvApp U ≫ D.diagramOverOpenπ U i = (D.U i).presheaf.map (eqToHom eq)
state_after: case w
C : Type u
inst✝¹ : Category.{v, u} C
D : GlueData C
inst✝ : HasLimits C
i : D.J
U : Opens ↑↑(D.U i)
⊢ { unop := U } =
    {
      unop :=
        (Opens.map (colimit.ι D.diagram.multispan { unop := WalkingMultispan.right i }.unop).base).obj
          (⋯.functor.obj U) }

case h
C : Type u
inst✝¹ : Category.{v, u} C
D : GlueData C
inst✝ : HasLimits C
i : D.J
U : Opens ↑↑(D.U i)
⊢ D.ιInvApp U ≫ D.diagramOverOpenπ U i = (D.U i).presheaf.map (eqToHom ?w)

tactic: delta ιInvApp
state_before: case h
C : Type u
inst✝¹ : Category.{v, u} C
D : GlueData C
inst✝ : HasLimits C
i : D.J
U : Opens ↑↑(D.U i)
⊢ D.ιInvApp U ≫ D.diagramOverOpenπ U i = (D.U i).presheaf.map (eqToHom ⋯)
state_after: case h
C : Type u
inst✝¹ : Category.{v, u} C
D : GlueData C
inst✝ : HasLimits C
i : D.J
U : Opens ↑↑(D.U i)
⊢ limit.lift (D.diagramOverOpen U)
        { pt := (D.U i).presheaf.obj { unop := U }, π := { app := fun j => D.ιInvAppπApp U j.unop, naturality := ⋯ } } ≫
      D.diagramOverOpenπ U i =
    (D.U i).presheaf.map (eqToHom ⋯)

tactic: rw [limit.lift_π]
state_before: case h
C : Type u
inst✝¹ : Category.{v, u} C
D : GlueData C
inst✝ : HasLimits C
i : D.J
U : Opens ↑↑(D.U i)
⊢ limit.lift (D.diagramOverOpen U)
        { pt := (D.U i).presheaf.obj { unop := U }, π := { app := fun j => D.ιInvAppπApp U j.unop, naturality := ⋯ } } ≫
      D.diagramOverOpenπ U i =
    (D.U i).presheaf.map (eqToHom ⋯)
state_after: case h
C : Type u
inst✝¹ : Category.{v, u} C
D : GlueData C
inst✝ : HasLimits C
i : D.J
U : Opens ↑↑(D.U i)
⊢ { pt := (D.U i).presheaf.obj { unop := U }, π := { app := fun j => D.ιInvAppπApp U j.unop, naturality := ⋯ } }.π.app
      { unop := WalkingMultispan.right i } =
    (D.U i).presheaf.map (eqToHom ⋯)

tactic: change D.opensImagePreimageMap i i U = _
state_before: case h
C : Type u
inst✝¹ : Category.{v, u} C
D : GlueData C
inst✝ : HasLimits C
i : D.J
U : Opens ↑↑(D.U i)
⊢ { pt := (D.U i).presheaf.obj { unop := U }, π := { app := fun j => D.ιInvAppπApp U j.unop, naturality := ⋯ } }.π.app
      { unop := WalkingMultispan.right i } =
    (D.U i).presheaf.map (eqToHom ⋯)
state_after: case h
C : Type u
inst✝¹ : Category.{v, u} C
D : GlueData C
inst✝ : HasLimits C
i : D.J
U : Opens ↑↑(D.U i)
⊢ D.opensImagePreimageMap i i U = (D.U i).presheaf.map (eqToHom ⋯)

tactic: dsimp [opensImagePreimageMap]
state_before: case h
C : Type u
inst✝¹ : Category.{v, u} C
D : GlueData C
inst✝ : HasLimits C
i : D.J
U : Opens ↑↑(D.U i)
⊢ D.opensImagePreimageMap i i U = (D.U i).presheaf.map (eqToHom ⋯)
state_after: case h
C : Type u
inst✝¹ : Category.{v, u} C
D : GlueData C
inst✝ : HasLimits C
i : D.J
U : Opens ↑↑(D.U i)
⊢ (D.f i i).c.app { unop := U } ≫
      (D.t i i).c.app { unop := (Opens.map (D.f i i).base).obj U } ≫
        invApp (D.f i i) ((Opens.map (D.t i i).base).toPrefunctor.1 ((Opens.map (D.f i i).base).obj U)) ≫
          (D.U i).presheaf.map (eqToHom ⋯).op =
    (D.U i).presheaf.map (eqToHom ⋯)

tactic: rw [congr_app (D.t_id _), id_c_app, ← Functor.map_comp]
state_before: case h
C : Type u
inst✝¹ : Category.{v, u} C
D : GlueData C
inst✝ : HasLimits C
i : D.J
U : Opens ↑↑(D.U i)
⊢ (D.f i i).c.app { unop := U } ≫
      (D.t i i).c.app { unop := (Opens.map (D.f i i).base).obj U } ≫
        invApp (D.f i i) ((Opens.map (D.t i i).base).toPrefunctor.1 ((Opens.map (D.f i i).base).obj U)) ≫
          (D.U i).presheaf.map (eqToHom ⋯).op =
    (D.U i).presheaf.map (eqToHom ⋯)
state_after: case h
C : Type u
inst✝¹ : Category.{v, u} C
D : GlueData C
inst✝ : HasLimits C
i : D.J
U : Opens ↑↑(D.U i)
⊢ (D.f i i).c.app { unop := U } ≫
      (D.V (i, i)).presheaf.map (𝟙 { unop := (Opens.map (D.f i i).base).obj U } ≫ eqToHom ⋯) ≫
        invApp (D.f i i) ((Opens.map (D.t i i).base).toPrefunctor.1 ((Opens.map (D.f i i).base).obj U)) ≫
          (D.U i).presheaf.map (eqToHom ⋯).op =
    (D.U i).presheaf.map (eqToHom ⋯)

tactic: erw [IsOpenImmersion.inv_naturality_assoc, IsOpenImmersion.app_inv_app'_assoc]
state_before: case h
C : Type u
inst✝¹ : Category.{v, u} C
D : GlueData C
inst✝ : HasLimits C
i : D.J
U : Opens ↑↑(D.U i)
⊢ (D.f i i).c.app { unop := U } ≫
      (D.V (i, i)).presheaf.map (𝟙 { unop := (Opens.map (D.f i i).base).obj U } ≫ eqToHom ⋯) ≫
        invApp (D.f i i) ((Opens.map (D.t i i).base).toPrefunctor.1 ((Opens.map (D.f i i).base).obj U)) ≫
          (D.U i).presheaf.map (eqToHom ⋯).op =
    (D.U i).presheaf.map (eqToHom ⋯)
state_after: case h
C : Type u
inst✝¹ : Category.{v, u} C
D : GlueData C
inst✝ : HasLimits C
i : D.J
U : Opens ↑↑(D.U i)
⊢ (D.U i).presheaf.map (eqToHom ⋯).op ≫
      (D.U i).presheaf.map
          ((opensFunctor (D.f i i)).op.map (𝟙 { unop := (Opens.map (D.f i i).base).obj U } ≫ eqToHom ⋯)) ≫
        (D.U i).presheaf.map (eqToHom ⋯).op =
    (D.U i).presheaf.map (eqToHom ⋯)

case h.hU
C : Type u
inst✝¹ : Category.{v, u} C
D : GlueData C
inst✝ : HasLimits C
i : D.J
U : Opens ↑↑(D.U i)
⊢ ↑U ⊆ Set.range ⇑(D.f i i).base

tactic: congr
state_before: case w
C : Type u
inst✝¹ : Category.{v, u} C
D : GlueData C
inst✝ : HasLimits C
i : D.J
U : Opens ↑↑(D.U i)
⊢ { unop := U } =
    {
      unop :=
        (Opens.map (colimit.ι D.diagram.multispan { unop := WalkingMultispan.right i }.unop).base).obj
          (⋯.functor.obj U) }
state_after: case w.e_unop
C : Type u
inst✝¹ : Category.{v, u} C
D : GlueData C
inst✝ : HasLimits C
i : D.J
U : Opens ↑↑(D.U i)
⊢ U = (Opens.map (colimit.ι D.diagram.multispan { unop := WalkingMultispan.right i }.unop).base).obj (⋯.functor.obj U)

tactic: ext1
state_before: case w.e_unop
C : Type u
inst✝¹ : Category.{v, u} C
D : GlueData C
inst✝ : HasLimits C
i : D.J
U : Opens ↑↑(D.U i)
⊢ U = (Opens.map (colimit.ι D.diagram.multispan { unop := WalkingMultispan.right i }.unop).base).obj (⋯.functor.obj U)
state_after: case w.e_unop.h
C : Type u
inst✝¹ : Category.{v, u} C
D : GlueData C
inst✝ : HasLimits C
i : D.J
U : Opens ↑↑(D.U i)
⊢ ↑U =
    ↑((Opens.map (colimit.ι D.diagram.multispan { unop := WalkingMultispan.right i }.unop).base).obj (⋯.functor.obj U))

tactic: change _ = _ ⁻¹' (_ '' _)
state_before: case w.e_unop.h
C : Type u
inst✝¹ : Category.{v, u} C
D : GlueData C
inst✝ : HasLimits C
i : D.J
U : Opens ↑↑(D.U i)
⊢ ↑U =
    ↑((Opens.map (colimit.ι D.diagram.multispan { unop := WalkingMultispan.right i }.unop).base).obj (⋯.functor.obj U))
state_after: case w.e_unop.h
C : Type u
inst✝¹ : Category.{v, u} C
D : GlueData C
inst✝ : HasLimits C
i : D.J
U : Opens ↑↑(D.U i)
⊢ ↑U = ⇑(colimit.ι D.diagram.multispan { unop := WalkingMultispan.right i }.unop).base ⁻¹' (⇑(D.ι i).base '' ↑U)

tactic: ext1 x
state_before: case w.e_unop.h
C : Type u
inst✝¹ : Category.{v, u} C
D : GlueData C
inst✝ : HasLimits C
i : D.J
U : Opens ↑↑(D.U i)
⊢ ↑U = ⇑(colimit.ι D.diagram.multispan { unop := WalkingMultispan.right i }.unop).base ⁻¹' (⇑(D.ι i).base '' ↑U)
state_after: case w.e_unop.h.h
C : Type u
inst✝¹ : Category.{v, u} C
D : GlueData C
inst✝ : HasLimits C
i : D.J
U : Opens ↑↑(D.U i)
x : ↑↑(D.U i)
⊢ x ∈ ↑U ↔ x ∈ ⇑(colimit.ι D.diagram.multispan { unop := WalkingMultispan.right i }.unop).base ⁻¹' (⇑(D.ι i).base '' ↑U)

tactic: simp only [SetLike.mem_coe, diagram_l, diagram_r, unop_op, Set.mem_preimage, Set.mem_image]
state_before: case w.e_unop.h.h
C : Type u
inst✝¹ : Category.{v, u} C
D : GlueData C
inst✝ : HasLimits C
i : D.J
U : Opens ↑↑(D.U i)
x : ↑↑(D.U i)
⊢ x ∈ ↑U ↔ x ∈ ⇑(colimit.ι D.diagram.multispan { unop := WalkingMultispan.right i }.unop).base ⁻¹' (⇑(D.ι i).base '' ↑U)
state_after: case w.e_unop.h.h
C : Type u
inst✝¹ : Category.{v, u} C
D : GlueData C
inst✝ : HasLimits C
i : D.J
U : Opens ↑↑(D.U i)
x : ↑↑(D.U i)
⊢ x ∈ U ↔ ∃ x_1 ∈ U, (D.ι i).base x_1 = (colimit.ι D.diagram.multispan (WalkingMultispan.right i)).base x

tactic: refine ⟨fun h => ⟨_, h, rfl⟩, ?_⟩
state_before: case w.e_unop.h.h
C : Type u
inst✝¹ : Category.{v, u} C
D : GlueData C
inst✝ : HasLimits C
i : D.J
U : Opens ↑↑(D.U i)
x : ↑↑(D.U i)
⊢ x ∈ U ↔ ∃ x_1 ∈ U, (D.ι i).base x_1 = (colimit.ι D.diagram.multispan (WalkingMultispan.right i)).base x
state_after: case w.e_unop.h.h
C : Type u
inst✝¹ : Category.{v, u} C
D : GlueData C
inst✝ : HasLimits C
i : D.J
U : Opens ↑↑(D.U i)
x : ↑↑(D.U i)
⊢ (∃ x_1 ∈ U, (D.ι i).base x_1 = (colimit.ι D.diagram.multispan (WalkingMultispan.right i)).base x) → x ∈ U

tactic: rintro ⟨y, h1, h2⟩
state_before: case w.e_unop.h.h
C : Type u
inst✝¹ : Category.{v, u} C
D : GlueData C
inst✝ : HasLimits C
i : D.J
U : Opens ↑↑(D.U i)
x : ↑↑(D.U i)
⊢ (∃ x_1 ∈ U, (D.ι i).base x_1 = (colimit.ι D.diagram.multispan (WalkingMultispan.right i)).base x) → x ∈ U
state_after: case w.e_unop.h.h.intro.intro
C : Type u
inst✝¹ : Category.{v, u} C
D : GlueData C
inst✝ : HasLimits C
i : D.J
U : Opens ↑↑(D.U i)
x y : ↑↑(D.U i)
h1 : y ∈ U
h2 : (D.ι i).base y = (colimit.ι D.diagram.multispan (WalkingMultispan.right i)).base x
⊢ x ∈ U

tactic: convert h1 using 1
state_before: case w.e_unop.h.h.intro.intro
C : Type u
inst✝¹ : Category.{v, u} C
D : GlueData C
inst✝ : HasLimits C
i : D.J
U : Opens ↑↑(D.U i)
x y : ↑↑(D.U i)
h1 : y ∈ U
h2 : (D.ι i).base y = (colimit.ι D.diagram.multispan (WalkingMultispan.right i)).base x
⊢ x ∈ U
state_after: case h.e'_4
C : Type u
inst✝¹ : Category.{v, u} C
D : GlueData C
inst✝ : HasLimits C
i : D.J
U : Opens ↑↑(D.U i)
x y : ↑↑(D.U i)
h1 : y ∈ U
h2 : (D.ι i).base y = (colimit.ι D.diagram.multispan (WalkingMultispan.right i)).base x
⊢ x = y

tactic: delta ι Multicoequalizer.π at h2
state_before: case h.e'_4
C : Type u
inst✝¹ : Category.{v, u} C
D : GlueData C
inst✝ : HasLimits C
i : D.J
U : Opens ↑↑(D.U i)
x y : ↑↑(D.U i)
h1 : y ∈ U
h2 : (D.ι i).base y = (colimit.ι D.diagram.multispan (WalkingMultispan.right i)).base x
⊢ x = y
state_after: case h.e'_4
C : Type u
inst✝¹ : Category.{v, u} C
D : GlueData C
inst✝ : HasLimits C
i : D.J
U : Opens ↑↑(D.U i)
x y : ↑↑(D.U i)
h1 : y ∈ U
h2 :
  (colimit.ι D.diagram.multispan (WalkingMultispan.right i)).base y =
    (colimit.ι D.diagram.multispan (WalkingMultispan.right i)).base x
⊢ x = y

tactic: apply_fun (D.ι _).base
state_before: case h.e'_4
C : Type u
inst✝¹ : Category.{v, u} C
D : GlueData C
inst✝ : HasLimits C
i : D.J
U : Opens ↑↑(D.U i)
x y : ↑↑(D.U i)
h1 : y ∈ U
h2 :
  (colimit.ι D.diagram.multispan (WalkingMultispan.right i)).base y =
    (colimit.ι D.diagram.multispan (WalkingMultispan.right i)).base x
⊢ x = y
state_after: case h.e'_4
C : Type u
inst✝¹ : Category.{v, u} C
D : GlueData C
inst✝ : HasLimits C
i : D.J
U : Opens ↑↑(D.U i)
x y : ↑↑(D.U i)
h1 : y ∈ U
h2 :
  (colimit.ι D.diagram.multispan (WalkingMultispan.right i)).base y =
    (colimit.ι D.diagram.multispan (WalkingMultispan.right i)).base x
⊢ (D.ι i).base x = (D.ι i).base y

case h.e'_4.inj
C : Type u
inst✝¹ : Category.{v, u} C
D : GlueData C
inst✝ : HasLimits C
i : D.J
U : Opens ↑↑(D.U i)
x y : ↑↑(D.U i)
h1 : y ∈ U
h2 :
  (colimit.ι D.diagram.multispan (WalkingMultispan.right i)).base y =
    (colimit.ι D.diagram.multispan (WalkingMultispan.right i)).base x
⊢ Function.Injective ⇑(D.ι i).base

tactic: exact h2.symm
state_before: case h.e'_4
C : Type u
inst✝¹ : Category.{v, u} C
D : GlueData C
inst✝ : HasLimits C
i : D.J
U : Opens ↑↑(D.U i)
x y : ↑↑(D.U i)
h1 : y ∈ U
h2 :
  (colimit.ι D.diagram.multispan (WalkingMultispan.right i)).base y =
    (colimit.ι D.diagram.multispan (WalkingMultispan.right i)).base x
⊢ (D.ι i).base x = (D.ι i).base y
state_after: no goals

tactic: have := D.ι_gluedIso_inv (PresheafedSpace.forget _) i
state_before: case h.e'_4.inj
C : Type u
inst✝¹ : Category.{v, u} C
D : GlueData C
inst✝ : HasLimits C
i : D.J
U : Opens ↑↑(D.U i)
x y : ↑↑(D.U i)
h1 : y ∈ U
h2 :
  (colimit.ι D.diagram.multispan (WalkingMultispan.right i)).base y =
    (colimit.ι D.diagram.multispan (WalkingMultispan.right i)).base x
⊢ Function.Injective ⇑(D.ι i).base
state_after: case h.e'_4.inj
C : Type u
inst✝¹ : Category.{v, u} C
D : GlueData C
inst✝ : HasLimits C
i : D.J
U : Opens ↑↑(D.U i)
x y : ↑↑(D.U i)
h1 : y ∈ U
h2 :
  (colimit.ι D.diagram.multispan (WalkingMultispan.right i)).base y =
    (colimit.ι D.diagram.multispan (WalkingMultispan.right i)).base x
this : (D.mapGlueData (forget C)).ι i ≫ (D.gluedIso (forget C)).inv = (forget C).map (D.ι i)
⊢ Function.Injective ⇑(D.ι i).base

tactic: dsimp at this
state_before: case h.e'_4.inj
C : Type u
inst✝¹ : Category.{v, u} C
D : GlueData C
inst✝ : HasLimits C
i : D.J
U : Opens ↑↑(D.U i)
x y : ↑↑(D.U i)
h1 : y ∈ U
h2 :
  (colimit.ι D.diagram.multispan (WalkingMultispan.right i)).base y =
    (colimit.ι D.diagram.multispan (WalkingMultispan.right i)).base x
this : (D.mapGlueData (forget C)).ι i ≫ (D.gluedIso (forget C)).inv = (forget C).map (D.ι i)
⊢ Function.Injective ⇑(D.ι i).base
state_after: case h.e'_4.inj
C : Type u
inst✝¹ : Category.{v, u} C
D : GlueData C
inst✝ : HasLimits C
i : D.J
U : Opens ↑↑(D.U i)
x y : ↑↑(D.U i)
h1 : y ∈ U
h2 :
  (colimit.ι D.diagram.multispan (WalkingMultispan.right i)).base y =
    (colimit.ι D.diagram.multispan (WalkingMultispan.right i)).base x
this : (D.mapGlueData (forget C)).ι i ≫ (D.gluedIso (forget C)).inv = (D.ι i).base
⊢ Function.Injective ⇑(D.ι i).base

tactic: erw [← this, coe_comp]
state_before: case h.e'_4.inj
C : Type u
inst✝¹ : Category.{v, u} C
D : GlueData C
inst✝ : HasLimits C
i : D.J
U : Opens ↑↑(D.U i)
x y : ↑↑(D.U i)
h1 : y ∈ U
h2 :
  (colimit.ι D.diagram.multispan (WalkingMultispan.right i)).base y =
    (colimit.ι D.diagram.multispan (WalkingMultispan.right i)).base x
this : (D.mapGlueData (forget C)).ι i ≫ (D.gluedIso (forget C)).inv = (D.ι i).base
⊢ Function.Injective ⇑(D.ι i).base
state_after: case h.e'_4.inj
C : Type u
inst✝¹ : Category.{v, u} C
D : GlueData C
inst✝ : HasLimits C
i : D.J
U : Opens ↑↑(D.U i)
x y : ↑↑(D.U i)
h1 : y ∈ U
h2 :
  (colimit.ι D.diagram.multispan (WalkingMultispan.right i)).base y =
    (colimit.ι D.diagram.multispan (WalkingMultispan.right i)).base x
this : (D.mapGlueData (forget C)).ι i ≫ (D.gluedIso (forget C)).inv = (D.ι i).base
⊢ Function.Injective (⇑(D.gluedIso (forget C)).inv ∘ ⇑((D.mapGlueData (forget C)).ι i))

tactic: refine Function.Injective.comp ?_ (TopCat.GlueData.ι_injective D.toTopGlueData i)
state_before: case h.e'_4.inj
C : Type u
inst✝¹ : Category.{v, u} C
D : GlueData C
inst✝ : HasLimits C
i : D.J
U : Opens ↑↑(D.U i)
x y : ↑↑(D.U i)
h1 : y ∈ U
h2 :
  (colimit.ι D.diagram.multispan (WalkingMultispan.right i)).base y =
    (colimit.ι D.diagram.multispan (WalkingMultispan.right i)).base x
this : (D.mapGlueData (forget C)).ι i ≫ (D.gluedIso (forget C)).inv = (D.ι i).base
⊢ Function.Injective (⇑(D.gluedIso (forget C)).inv ∘ ⇑((D.mapGlueData (forget C)).ι i))
state_after: case h.e'_4.inj
C : Type u
inst✝¹ : Category.{v, u} C
D : GlueData C
inst✝ : HasLimits C
i : D.J
U : Opens ↑↑(D.U i)
x y : ↑↑(D.U i)
h1 : y ∈ U
h2 :
  (colimit.ι D.diagram.multispan (WalkingMultispan.right i)).base y =
    (colimit.ι D.diagram.multispan (WalkingMultispan.right i)).base x
this : (D.mapGlueData (forget C)).ι i ≫ (D.gluedIso (forget C)).inv = (D.ι i).base
⊢ Function.Injective ⇑(D.gluedIso (forget C)).inv

tactic: erw [← TopCat.mono_iff_injective]
state_before: case h.e'_4.inj
C : Type u
inst✝¹ : Category.{v, u} C
D : GlueData C
inst✝ : HasLimits C
i : D.J
U : Opens ↑↑(D.U i)
x y : ↑↑(D.U i)
h1 : y ∈ U
h2 :
  (colimit.ι D.diagram.multispan (WalkingMultispan.right i)).base y =
    (colimit.ι D.diagram.multispan (WalkingMultispan.right i)).base x
this : (D.mapGlueData (forget C)).ι i ≫ (D.gluedIso (forget C)).inv = (D.ι i).base
⊢ Function.Injective ⇑(D.gluedIso (forget C)).inv
state_after: case h.e'_4.inj
C : Type u
inst✝¹ : Category.{v, u} C
D : GlueData C
inst✝ : HasLimits C
i : D.J
U : Opens ↑↑(D.U i)
x y : ↑↑(D.U i)
h1 : y ∈ U
h2 :
  (colimit.ι D.diagram.multispan (WalkingMultispan.right i)).base y =
    (colimit.ι D.diagram.multispan (WalkingMultispan.right i)).base x
this : (D.mapGlueData (forget C)).ι i ≫ (D.gluedIso (forget C)).inv = (D.ι i).base
⊢ Mono (D.gluedIso (forget C)).inv

tactic: infer_instance
state_before: case h.e'_4.inj
C : Type u
inst✝¹ : Category.{v, u} C
D : GlueData C
inst✝ : HasLimits C
i : D.J
U : Opens ↑↑(D.U i)
x y : ↑↑(D.U i)
h1 : y ∈ U
h2 :
  (colimit.ι D.diagram.multispan (WalkingMultispan.right i)).base y =
    (colimit.ι D.diagram.multispan (WalkingMultispan.right i)).base x
this : (D.mapGlueData (forget C)).ι i ≫ (D.gluedIso (forget C)).inv = (D.ι i).base
⊢ Mono (D.gluedIso (forget C)).inv
state_after: no goals

tactic: simp only [eqToHom_op, eqToHom_trans, eqToHom_map (Functor.op _), ← Functor.map_comp]
state_before: case h
C : Type u
inst✝¹ : Category.{v, u} C
D : GlueData C
inst✝ : HasLimits C
i : D.J
U : Opens ↑↑(D.U i)
⊢ (D.U i).presheaf.map (eqToHom ⋯).op ≫
      (D.U i).presheaf.map
          ((opensFunctor (D.f i i)).op.map (𝟙 { unop := (Opens.map (D.f i i).base).obj U } ≫ eqToHom ⋯)) ≫
        (D.U i).presheaf.map (eqToHom ⋯).op =
    (D.U i).presheaf.map (eqToHom ⋯)
state_after: case h
C : Type u
inst✝¹ : Category.{v, u} C
D : GlueData C
inst✝ : HasLimits C
i : D.J
U : Opens ↑↑(D.U i)
⊢ (D.U i).presheaf.map
      (eqToHom ⋯ ≫
        (opensFunctor (D.f i i)).op.map (𝟙 { unop := (Opens.map (D.f i i).base).obj U } ≫ eqToHom ⋯) ≫ eqToHom ⋯) =
    (D.U i).presheaf.map (eqToHom ⋯)

tactic: rfl
state_before: case h
C : Type u
inst✝¹ : Category.{v, u} C
D : GlueData C
inst✝ : HasLimits C
i : D.J
U : Opens ↑↑(D.U i)
⊢ (D.U i).presheaf.map
      (eqToHom ⋯ ≫
        (opensFunctor (D.f i i)).op.map (𝟙 { unop := (Opens.map (D.f i i).base).obj U } ≫ eqToHom ⋯) ≫ eqToHom ⋯) =
    (D.U i).presheaf.map (eqToHom ⋯)
state_after: no goals

tactic: rw [Set.range_iff_surjective.mpr _]
state_before: case h.hU
C : Type u
inst✝¹ : Category.{v, u} C
D : GlueData C
inst✝ : HasLimits C
i : D.J
U : Opens ↑↑(D.U i)
⊢ ↑U ⊆ Set.range ⇑(D.f i i).base
state_after: case h.hU
C : Type u
inst✝¹ : Category.{v, u} C
D : GlueData C
inst✝ : HasLimits C
i : D.J
U : Opens ↑↑(D.U i)
⊢ ↑U ⊆ Set.univ

C : Type u
inst✝¹ : Category.{v, u} C
D : GlueData C
inst✝ : HasLimits C
i : D.J
U : Opens ↑↑(D.U i)
⊢ Function.Surjective ⇑(D.f i i).base

tactic: simp
state_before: case h.hU
C : Type u
inst✝¹ : Category.{v, u} C
D : GlueData C
inst✝ : HasLimits C
i : D.J
U : Opens ↑↑(D.U i)
⊢ ↑U ⊆ Set.univ
state_after: no goals

tactic: rw [← TopCat.epi_iff_surjective]
state_before: C : Type u
inst✝¹ : Category.{v, u} C
D : GlueData C
inst✝ : HasLimits C
i : D.J
U : Opens ↑↑(D.U i)
⊢ Function.Surjective ⇑(D.f i i).base
state_after: C : Type u
inst✝¹ : Category.{v, u} C
D : GlueData C
inst✝ : HasLimits C
i : D.J
U : Opens ↑↑(D.U i)
⊢ Epi (D.f i i).base

tactic: infer_instance
state_before: C : Type u
inst✝¹ : Category.{v, u} C
D : GlueData C
inst✝ : HasLimits C
i : D.J
U : Opens ↑↑(D.U i)
⊢ Epi (D.f i i).base
state_after: no goals