Theorem: AlgebraicGeometry.LocallyRingedSpace.HasCoequalizer.imageBasicOpen_image_preimage
File: Mathlib/Geometry/RingedSpace/LocallyRingedSpace/HasColimits.lean

tactic: fapply Types.coequalizer_preimage_image_eq_of_preimage_eq
  (f.1.base : X.carrier.1 ⟶ Y.carrier.1) (g.1.base : X.carrier.1 ⟶ Y.carrier.1)
state_before: X Y : LocallyRingedSpace
f g : X ⟶ Y
U : Opens ↑↑(coequalizer f.val g.val).toPresheafedSpace
s : ↑((coequalizer f.val g.val).presheaf.obj { unop := U })
⊢ ⇑(coequalizer.π f.val g.val).base ⁻¹' (⇑(coequalizer.π f.val g.val).base '' (imageBasicOpen f g U s).carrier) =
    (imageBasicOpen f g U s).carrier
state_after: case e
X Y : LocallyRingedSpace
f g : X ⟶ Y
U : Opens ↑↑(coequalizer f.val g.val).toPresheafedSpace
s : ↑((coequalizer f.val g.val).presheaf.obj { unop := U })
⊢ ⇑f.val.base ≫ ⇑(coequalizer.π f.val g.val).base = ⇑g.val.base ≫ ⇑(coequalizer.π f.val g.val).base

case h
X Y : LocallyRingedSpace
f g : X ⟶ Y
U : Opens ↑↑(coequalizer f.val g.val).toPresheafedSpace
s : ↑((coequalizer f.val g.val).presheaf.obj { unop := U })
⊢ IsColimit (Cofork.ofπ ⇑(coequalizer.π f.val g.val).base ?e)

case H
X Y : LocallyRingedSpace
f g : X ⟶ Y
U : Opens ↑↑(coequalizer f.val g.val).toPresheafedSpace
s : ↑((coequalizer f.val g.val).presheaf.obj { unop := U })
⊢ ⇑f.val.base ⁻¹' (imageBasicOpen f g U s).carrier = ⇑g.val.base ⁻¹' (imageBasicOpen f g U s).carrier

tactic: ext
state_before: case e
X Y : LocallyRingedSpace
f g : X ⟶ Y
U : Opens ↑↑(coequalizer f.val g.val).toPresheafedSpace
s : ↑((coequalizer f.val g.val).presheaf.obj { unop := U })
⊢ ⇑f.val.base ≫ ⇑(coequalizer.π f.val g.val).base = ⇑g.val.base ≫ ⇑(coequalizer.π f.val g.val).base
state_after: case e.h
X Y : LocallyRingedSpace
f g : X ⟶ Y
U : Opens ↑↑(coequalizer f.val g.val).toPresheafedSpace
s : ↑((coequalizer f.val g.val).presheaf.obj { unop := U })
a✝ : ↑↑X.toPresheafedSpace
⊢ (⇑f.val.base ≫ ⇑(coequalizer.π f.val g.val).base) a✝ = (⇑g.val.base ≫ ⇑(coequalizer.π f.val g.val).base) a✝

tactic: simp_rw [types_comp_apply, ← TopCat.comp_app, ← PresheafedSpace.comp_base]
state_before: case e.h
X Y : LocallyRingedSpace
f g : X ⟶ Y
U : Opens ↑↑(coequalizer f.val g.val).toPresheafedSpace
s : ↑((coequalizer f.val g.val).presheaf.obj { unop := U })
a✝ : ↑↑X.toPresheafedSpace
⊢ (⇑f.val.base ≫ ⇑(coequalizer.π f.val g.val).base) a✝ = (⇑g.val.base ≫ ⇑(coequalizer.π f.val g.val).base) a✝
state_after: case e.h
X Y : LocallyRingedSpace
f g : X ⟶ Y
U : Opens ↑↑(coequalizer f.val g.val).toPresheafedSpace
s : ↑((coequalizer f.val g.val).presheaf.obj { unop := U })
a✝ : ↑↑X.toPresheafedSpace
⊢ (f.val ≫ coequalizer.π f.val g.val).base a✝ = (g.val ≫ coequalizer.π f.val g.val).base a✝

tactic: congr 2
state_before: case e.h
X Y : LocallyRingedSpace
f g : X ⟶ Y
U : Opens ↑↑(coequalizer f.val g.val).toPresheafedSpace
s : ↑((coequalizer f.val g.val).presheaf.obj { unop := U })
a✝ : ↑↑X.toPresheafedSpace
⊢ (f.val ≫ coequalizer.π f.val g.val).base a✝ = (g.val ≫ coequalizer.π f.val g.val).base a✝
state_after: case e.h.e_a.e_self
X Y : LocallyRingedSpace
f g : X ⟶ Y
U : Opens ↑↑(coequalizer f.val g.val).toPresheafedSpace
s : ↑((coequalizer f.val g.val).presheaf.obj { unop := U })
a✝ : ↑↑X.toPresheafedSpace
⊢ f.val ≫ coequalizer.π f.val g.val = g.val ≫ coequalizer.π f.val g.val

tactic: exact coequalizer.condition f.1 g.1
state_before: case e.h.e_a.e_self
X Y : LocallyRingedSpace
f g : X ⟶ Y
U : Opens ↑↑(coequalizer f.val g.val).toPresheafedSpace
s : ↑((coequalizer f.val g.val).presheaf.obj { unop := U })
a✝ : ↑↑X.toPresheafedSpace
⊢ f.val ≫ coequalizer.π f.val g.val = g.val ≫ coequalizer.π f.val g.val
state_after: no goals

tactic: apply isColimitCoforkMapOfIsColimit (forget TopCat)
state_before: case h
X Y : LocallyRingedSpace
f g : X ⟶ Y
U : Opens ↑↑(coequalizer f.val g.val).toPresheafedSpace
s : ↑((coequalizer f.val g.val).presheaf.obj { unop := U })
⊢ IsColimit (Cofork.ofπ ⇑(coequalizer.π f.val g.val).base ⋯)
state_after: case h.l
X Y : LocallyRingedSpace
f g : X ⟶ Y
U : Opens ↑↑(coequalizer f.val g.val).toPresheafedSpace
s : ↑((coequalizer f.val g.val).presheaf.obj { unop := U })
⊢ IsColimit (Cofork.ofπ (coequalizer.π f.val g.val).base ?h.w)

case h.w
X Y : LocallyRingedSpace
f g : X ⟶ Y
U : Opens ↑↑(coequalizer f.val g.val).toPresheafedSpace
s : ↑((coequalizer f.val g.val).presheaf.obj { unop := U })
⊢ f.val.base ≫ (coequalizer.π f.val g.val).base = g.val.base ≫ (coequalizer.π f.val g.val).base

tactic: apply isColimitCoforkMapOfIsColimit (SheafedSpace.forget _)
state_before: case h.l
X Y : LocallyRingedSpace
f g : X ⟶ Y
U : Opens ↑↑(coequalizer f.val g.val).toPresheafedSpace
s : ↑((coequalizer f.val g.val).presheaf.obj { unop := U })
⊢ IsColimit (Cofork.ofπ (coequalizer.π f.val g.val).base ?h.w)

case h.w
X Y : LocallyRingedSpace
f g : X ⟶ Y
U : Opens ↑↑(coequalizer f.val g.val).toPresheafedSpace
s : ↑((coequalizer f.val g.val).presheaf.obj { unop := U })
⊢ f.val.base ≫ (coequalizer.π f.val g.val).base = g.val.base ≫ (coequalizer.π f.val g.val).base
state_after: case h.l.l
X Y : LocallyRingedSpace
f g : X ⟶ Y
U : Opens ↑↑(coequalizer f.val g.val).toPresheafedSpace
s : ↑((coequalizer f.val g.val).presheaf.obj { unop := U })
⊢ IsColimit (Cofork.ofπ (coequalizer.π f.val g.val) ?h.l.w)

case h.l.w
X Y : LocallyRingedSpace
f g : X ⟶ Y
U : Opens ↑↑(coequalizer f.val g.val).toPresheafedSpace
s : ↑((coequalizer f.val g.val).presheaf.obj { unop := U })
⊢ f.val ≫ coequalizer.π f.val g.val = g.val ≫ coequalizer.π f.val g.val

tactic: exact coequalizerIsCoequalizer f.1 g.1
state_before: case h.l.l
X Y : LocallyRingedSpace
f g : X ⟶ Y
U : Opens ↑↑(coequalizer f.val g.val).toPresheafedSpace
s : ↑((coequalizer f.val g.val).presheaf.obj { unop := U })
⊢ IsColimit (Cofork.ofπ (coequalizer.π f.val g.val) ?h.l.w)

case h.l.w
X Y : LocallyRingedSpace
f g : X ⟶ Y
U : Opens ↑↑(coequalizer f.val g.val).toPresheafedSpace
s : ↑((coequalizer f.val g.val).presheaf.obj { unop := U })
⊢ f.val ≫ coequalizer.π f.val g.val = g.val ≫ coequalizer.π f.val g.val
state_after: no goals

tactic: suffices
  (TopologicalSpace.Opens.map f.1.base).obj (imageBasicOpen f g U s) =
    (TopologicalSpace.Opens.map g.1.base).obj (imageBasicOpen f g U s)
  by injection this
state_before: case H
X Y : LocallyRingedSpace
f g : X ⟶ Y
U : Opens ↑↑(coequalizer f.val g.val).toPresheafedSpace
s : ↑((coequalizer f.val g.val).presheaf.obj { unop := U })
⊢ ⇑f.val.base ⁻¹' (imageBasicOpen f g U s).carrier = ⇑g.val.base ⁻¹' (imageBasicOpen f g U s).carrier
state_after: case H
X Y : LocallyRingedSpace
f g : X ⟶ Y
U : Opens ↑↑(coequalizer f.val g.val).toPresheafedSpace
s : ↑((coequalizer f.val g.val).presheaf.obj { unop := U })
⊢ (Opens.map f.val.base).obj (imageBasicOpen f g U s) = (Opens.map g.val.base).obj (imageBasicOpen f g U s)

tactic: delta imageBasicOpen
state_before: case H
X Y : LocallyRingedSpace
f g : X ⟶ Y
U : Opens ↑↑(coequalizer f.val g.val).toPresheafedSpace
s : ↑((coequalizer f.val g.val).presheaf.obj { unop := U })
⊢ (Opens.map f.val.base).obj (imageBasicOpen f g U s) = (Opens.map g.val.base).obj (imageBasicOpen f g U s)
state_after: case H
X Y : LocallyRingedSpace
f g : X ⟶ Y
U : Opens ↑↑(coequalizer f.val g.val).toPresheafedSpace
s : ↑((coequalizer f.val g.val).presheaf.obj { unop := U })
⊢ (Opens.map f.val.base).obj
      (Y.toRingedSpace.basicOpen
        (let_fun this := ((coequalizer.π f.val g.val).c.app { unop := U }) s;
        this)) =
    (Opens.map g.val.base).obj
      (Y.toRingedSpace.basicOpen
        (let_fun this := ((coequalizer.π f.val g.val).c.app { unop := U }) s;
        this))

tactic: rw [preimage_basicOpen f, preimage_basicOpen g]
state_before: case H
X Y : LocallyRingedSpace
f g : X ⟶ Y
U : Opens ↑↑(coequalizer f.val g.val).toPresheafedSpace
s : ↑((coequalizer f.val g.val).presheaf.obj { unop := U })
⊢ (Opens.map f.val.base).obj
      (Y.toRingedSpace.basicOpen
        (let_fun this := ((coequalizer.π f.val g.val).c.app { unop := U }) s;
        this)) =
    (Opens.map g.val.base).obj
      (Y.toRingedSpace.basicOpen
        (let_fun this := ((coequalizer.π f.val g.val).c.app { unop := U }) s;
        this))
state_after: case H
X Y : LocallyRingedSpace
f g : X ⟶ Y
U : Opens ↑↑(coequalizer f.val g.val).toPresheafedSpace
s : ↑((coequalizer f.val g.val).presheaf.obj { unop := U })
⊢ X.toRingedSpace.basicOpen
      ((f.val.c.app
          { unop := { unop := (Opens.map (coequalizer.π f.val g.val).base).toPrefunctor.1 { unop := U }.unop }.unop })
        (let_fun this := ((coequalizer.π f.val g.val).c.app { unop := U }) s;
        this)) =
    X.toRingedSpace.basicOpen
      ((g.val.c.app
          { unop := { unop := (Opens.map (coequalizer.π f.val g.val).base).toPrefunctor.1 { unop := U }.unop }.unop })
        (let_fun this := ((coequalizer.π f.val g.val).c.app { unop := U }) s;
        this))

tactic: dsimp only [Functor.op, unop_op]
state_before: case H
X Y : LocallyRingedSpace
f g : X ⟶ Y
U : Opens ↑↑(coequalizer f.val g.val).toPresheafedSpace
s : ↑((coequalizer f.val g.val).presheaf.obj { unop := U })
⊢ X.toRingedSpace.basicOpen
      ((f.val.c.app
          { unop := { unop := (Opens.map (coequalizer.π f.val g.val).base).toPrefunctor.1 { unop := U }.unop }.unop })
        (let_fun this := ((coequalizer.π f.val g.val).c.app { unop := U }) s;
        this)) =
    X.toRingedSpace.basicOpen
      ((g.val.c.app
          { unop := { unop := (Opens.map (coequalizer.π f.val g.val).base).toPrefunctor.1 { unop := U }.unop }.unop })
        (let_fun this := ((coequalizer.π f.val g.val).c.app { unop := U }) s;
        this))
state_after: case H
X Y : LocallyRingedSpace
f g : X ⟶ Y
U : Opens ↑↑(coequalizer f.val g.val).toPresheafedSpace
s : ↑((coequalizer f.val g.val).presheaf.obj { unop := U })
⊢ X.toRingedSpace.basicOpen
      ((f.val.c.app { unop := (Opens.map (coequalizer.π f.val g.val).base).toPrefunctor.1 U })
        (((coequalizer.π f.val g.val).c.app { unop := U }) s)) =
    X.toRingedSpace.basicOpen
      ((g.val.c.app { unop := (Opens.map (coequalizer.π f.val g.val).base).toPrefunctor.1 U })
        (((coequalizer.π f.val g.val).c.app { unop := U }) s))

tactic: erw [← comp_apply, ← SheafedSpace.comp_c_app', ← comp_apply, ← SheafedSpace.comp_c_app',
  SheafedSpace.congr_app (coequalizer.condition f.1 g.1), comp_apply,
  X.toRingedSpace.basicOpen_res]
state_before: case H
X Y : LocallyRingedSpace
f g : X ⟶ Y
U : Opens ↑↑(coequalizer f.val g.val).toPresheafedSpace
s : ↑((coequalizer f.val g.val).presheaf.obj { unop := U })
⊢ X.toRingedSpace.basicOpen
      ((f.val.c.app { unop := (Opens.map (coequalizer.π f.val g.val).base).toPrefunctor.1 U })
        (((coequalizer.π f.val g.val).c.app { unop := U }) s)) =
    X.toRingedSpace.basicOpen
      ((g.val.c.app { unop := (Opens.map (coequalizer.π f.val g.val).base).toPrefunctor.1 U })
        (((coequalizer.π f.val g.val).c.app { unop := U }) s))
state_after: case H
X Y : LocallyRingedSpace
f g : X ⟶ Y
U : Opens ↑↑(coequalizer f.val g.val).toPresheafedSpace
s : ↑((coequalizer f.val g.val).presheaf.obj { unop := U })
⊢ ((Opens.map (f.val ≫ coequalizer.π f.val g.val).base).op.obj { unop := U }).unop ⊓
      X.toRingedSpace.basicOpen (((g.val ≫ coequalizer.π f.val g.val).c.app { unop := U }) s) =
    X.toRingedSpace.basicOpen (((g.val ≫ coequalizer.π f.val g.val).c.app { unop := U }) s)

tactic: apply inf_eq_right.mpr
state_before: case H
X Y : LocallyRingedSpace
f g : X ⟶ Y
U : Opens ↑↑(coequalizer f.val g.val).toPresheafedSpace
s : ↑((coequalizer f.val g.val).presheaf.obj { unop := U })
⊢ ((Opens.map (f.val ≫ coequalizer.π f.val g.val).base).op.obj { unop := U }).unop ⊓
      X.toRingedSpace.basicOpen (((g.val ≫ coequalizer.π f.val g.val).c.app { unop := U }) s) =
    X.toRingedSpace.basicOpen (((g.val ≫ coequalizer.π f.val g.val).c.app { unop := U }) s)
state_after: case H
X Y : LocallyRingedSpace
f g : X ⟶ Y
U : Opens ↑↑(coequalizer f.val g.val).toPresheafedSpace
s : ↑((coequalizer f.val g.val).presheaf.obj { unop := U })
⊢ X.toRingedSpace.basicOpen (((g.val ≫ coequalizer.π f.val g.val).c.app { unop := U }) s) ≤
    ((Opens.map (f.val ≫ coequalizer.π f.val g.val).base).op.obj { unop := U }).unop

tactic: refine (RingedSpace.basicOpen_le _ _).trans ?_
state_before: case H
X Y : LocallyRingedSpace
f g : X ⟶ Y
U : Opens ↑↑(coequalizer f.val g.val).toPresheafedSpace
s : ↑((coequalizer f.val g.val).presheaf.obj { unop := U })
⊢ X.toRingedSpace.basicOpen (((g.val ≫ coequalizer.π f.val g.val).c.app { unop := U }) s) ≤
    ((Opens.map (f.val ≫ coequalizer.π f.val g.val).base).op.obj { unop := U }).unop
state_after: case H
X Y : LocallyRingedSpace
f g : X ⟶ Y
U : Opens ↑↑(coequalizer f.val g.val).toPresheafedSpace
s : ↑((coequalizer f.val g.val).presheaf.obj { unop := U })
⊢ ((Opens.map (g.val ≫ coequalizer.π f.val g.val).base).op.obj { unop := U }).unop ≤
    ((Opens.map (f.val ≫ coequalizer.π f.val g.val).base).op.obj { unop := U }).unop

tactic: rw [coequalizer.condition f.1 g.1]
state_before: case H
X Y : LocallyRingedSpace
f g : X ⟶ Y
U : Opens ↑↑(coequalizer f.val g.val).toPresheafedSpace
s : ↑((coequalizer f.val g.val).presheaf.obj { unop := U })
⊢ ((Opens.map (g.val ≫ coequalizer.π f.val g.val).base).op.obj { unop := U }).unop ≤
    ((Opens.map (f.val ≫ coequalizer.π f.val g.val).base).op.obj { unop := U }).unop
state_after: no goals

tactic: injection this
state_before: X Y : LocallyRingedSpace
f g : X ⟶ Y
U : Opens ↑↑(coequalizer f.val g.val).toPresheafedSpace
s : ↑((coequalizer f.val g.val).presheaf.obj { unop := U })
this : (Opens.map f.val.base).obj (imageBasicOpen f g U s) = (Opens.map g.val.base).obj (imageBasicOpen f g U s)
⊢ ⇑f.val.base ⁻¹' (imageBasicOpen f g U s).carrier = ⇑g.val.base ⁻¹' (imageBasicOpen f g U s).carrier
state_after: no goals