Theorem: TopCat.stalkToFiber_injective
File: Mathlib/Topology/Sheaves/LocalPredicate.lean

tactic: let Q :
  ∃ (W : (OpenNhds x)ᵒᵖ)(s : ∀ w : (unop W).1, T w)(hW : P.pred s),
    tU = (subsheafToTypes P).presheaf.germ ⟨x, (unop W).2⟩ ⟨s, hW⟩ ∧
      tV = (subsheafToTypes P).presheaf.germ ⟨x, (unop W).2⟩ ⟨s, hW⟩ :=
  ?_
state_before: X : TopCat
T : ↑X → Type v
P : LocalPredicate T
x : ↑X
w :
  ∀ (U V : OpenNhds x) (fU : (y : { x_1 // x_1 ∈ U.obj }) → T ↑y),
    PrelocalPredicate.pred P.toPrelocalPredicate fU →
      ∀ (fV : (y : { x_2 // x_2 ∈ V.obj }) → T ↑y),
        PrelocalPredicate.pred P.toPrelocalPredicate fV →
          fU { val := x, property := (_ : x ∈ U.obj) } = fV { val := x, property := (_ : x ∈ V.obj) } →
            ∃ W iU iV,
              ∀ (w : { x_4 // x_4 ∈ W.obj }),
                fU ((fun x_4 => { val := ↑x_4, property := (_ : ↑x_4 ∈ ↑U.obj) }) w) =
                  fV ((fun x_4 => { val := ↑x_4, property := (_ : ↑x_4 ∈ ↑V.obj) }) w)
tU tV : Presheaf.stalk (Sheaf.presheaf (subsheafToTypes P)) x
h : stalkToFiber P x tU = stalkToFiber P x tV
⊢ tU = tV

tactic: obtain ⟨U, ⟨fU, hU⟩, rfl⟩ := jointly_surjective'.{v, v} tU
state_before: case refine_1
X : TopCat
T : ↑X → Type v
P : LocalPredicate T
x : ↑X
w :
  ∀ (U V : OpenNhds x) (fU : (y : { x_1 // x_1 ∈ U.obj }) → T ↑y),
    PrelocalPredicate.pred P.toPrelocalPredicate fU →
      ∀ (fV : (y : { x_2 // x_2 ∈ V.obj }) → T ↑y),
        PrelocalPredicate.pred P.toPrelocalPredicate fV →
          fU { val := x, property := (_ : x ∈ U.obj) } = fV { val := x, property := (_ : x ∈ V.obj) } →
            ∃ W iU iV,
              ∀ (w : { x_4 // x_4 ∈ W.obj }),
                fU ((fun x_4 => { val := ↑x_4, property := (_ : ↑x_4 ∈ ↑U.obj) }) w) =
                  fV ((fun x_4 => { val := ↑x_4, property := (_ : ↑x_4 ∈ ↑V.obj) }) w)
tU tV : Presheaf.stalk (Sheaf.presheaf (subsheafToTypes P)) x
h : stalkToFiber P x tU = stalkToFiber P x tV
⊢ ∃ W s hW,
    tU =
        Presheaf.germ (Sheaf.presheaf (subsheafToTypes P)) { val := x, property := (_ : x ∈ W.unop.obj) }
          { val := s, property := hW } ∧
      tV =
        Presheaf.germ (Sheaf.presheaf (subsheafToTypes P)) { val := x, property := (_ : x ∈ W.unop.obj) }
          { val := s, property := hW }

tactic: obtain ⟨V, ⟨fV, hV⟩, rfl⟩ := jointly_surjective'.{v, v} tV
state_before: case refine_1.intro.intro.mk
X : TopCat
T : ↑X → Type v
P : LocalPredicate T
x : ↑X
w :
  ∀ (U V : OpenNhds x) (fU : (y : { x_1 // x_1 ∈ U.obj }) → T ↑y),
    PrelocalPredicate.pred P.toPrelocalPredicate fU →
      ∀ (fV : (y : { x_2 // x_2 ∈ V.obj }) → T ↑y),
        PrelocalPredicate.pred P.toPrelocalPredicate fV →
          fU { val := x, property := (_ : x ∈ U.obj) } = fV { val := x, property := (_ : x ∈ V.obj) } →
            ∃ W iU iV,
              ∀ (w : { x_4 // x_4 ∈ W.obj }),
                fU ((fun x_4 => { val := ↑x_4, property := (_ : ↑x_4 ∈ ↑U.obj) }) w) =
                  fV ((fun x_4 => { val := ↑x_4, property := (_ : ↑x_4 ∈ ↑V.obj) }) w)
tV : Presheaf.stalk (Sheaf.presheaf (subsheafToTypes P)) x
U : (OpenNhds x)ᵒᵖ
fU : (x_1 : { x_1 // x_1 ∈ ((Functor.op (OpenNhds.inclusion x)).obj U).unop }) → T ↑x_1
hU : PrelocalPredicate.pred P.toPrelocalPredicate fU
h :
  stalkToFiber P x
      (colimit.ι
        (((whiskeringLeft (OpenNhds x)ᵒᵖ (Opens ↑X)ᵒᵖ (Type v)).obj (Functor.op (OpenNhds.inclusion x))).obj
          (Sheaf.presheaf (subsheafToTypes P)))
        U { val := fU, property := hU }) =
    stalkToFiber P x tV
⊢ ∃ W s hW,
    colimit.ι
          (((whiskeringLeft (OpenNhds x)ᵒᵖ (Opens ↑X)ᵒᵖ (Type v)).obj (Functor.op (OpenNhds.inclusion x))).obj
            (Sheaf.presheaf (subsheafToTypes P)))
          U { val := fU, property := hU } =
        Presheaf.germ (Sheaf.presheaf (subsheafToTypes P)) { val := x, property := (_ : x ∈ W.unop.obj) }
          { val := s, property := hW } ∧
      tV =
        Presheaf.germ (Sheaf.presheaf (subsheafToTypes P)) { val := x, property := (_ : x ∈ W.unop.obj) }
          { val := s, property := hW }

tactic: choose W s hW e using Q
state_before: case refine_2
X : TopCat
T : ↑X → Type v
P : LocalPredicate T
x : ↑X
w :
  ∀ (U V : OpenNhds x) (fU : (y : { x_1 // x_1 ∈ U.obj }) → T ↑y),
    PrelocalPredicate.pred P.toPrelocalPredicate fU →
      ∀ (fV : (y : { x_2 // x_2 ∈ V.obj }) → T ↑y),
        PrelocalPredicate.pred P.toPrelocalPredicate fV →
          fU { val := x, property := (_ : x ∈ U.obj) } = fV { val := x, property := (_ : x ∈ V.obj) } →
            ∃ W iU iV,
              ∀ (w : { x_4 // x_4 ∈ W.obj }),
                fU ((fun x_4 => { val := ↑x_4, property := (_ : ↑x_4 ∈ ↑U.obj) }) w) =
                  fV ((fun x_4 => { val := ↑x_4, property := (_ : ↑x_4 ∈ ↑V.obj) }) w)
tU tV : Presheaf.stalk (Sheaf.presheaf (subsheafToTypes P)) x
h : stalkToFiber P x tU = stalkToFiber P x tV
Q : ∃ W s hW,
  tU =
      Presheaf.germ (Sheaf.presheaf (subsheafToTypes P)) { val := x, property := (_ : x ∈ W.unop.obj) }
        { val := s, property := hW } ∧
    tV =
      Presheaf.germ (Sheaf.presheaf (subsheafToTypes P)) { val := x, property := (_ : x ∈ W.unop.obj) }
        { val := s, property := hW } :=
  ?refine_1
⊢ tU = tV

tactic: exact e.1.trans e.2.symm
state_before: case refine_2
X : TopCat
T : ↑X → Type v
P : LocalPredicate T
x : ↑X
w :
  ∀ (U V : OpenNhds x) (fU : (y : { x_1 // x_1 ∈ U.obj }) → T ↑y),
    PrelocalPredicate.pred P.toPrelocalPredicate fU →
      ∀ (fV : (y : { x_2 // x_2 ∈ V.obj }) → T ↑y),
        PrelocalPredicate.pred P.toPrelocalPredicate fV →
          fU { val := x, property := (_ : x ∈ U.obj) } = fV { val := x, property := (_ : x ∈ V.obj) } →
            ∃ W iU iV,
              ∀ (w : { x_4 // x_4 ∈ W.obj }),
                fU ((fun x_4 => { val := ↑x_4, property := (_ : ↑x_4 ∈ ↑U.obj) }) w) =
                  fV ((fun x_4 => { val := ↑x_4, property := (_ : ↑x_4 ∈ ↑V.obj) }) w)
tU tV : Presheaf.stalk (Sheaf.presheaf (subsheafToTypes P)) x
h : stalkToFiber P x tU = stalkToFiber P x tV
W : (OpenNhds x)ᵒᵖ
s : (w : { x_1 // x_1 ∈ W.unop.obj }) → T ↑w
hW : PrelocalPredicate.pred P.toPrelocalPredicate s
e :
  tU =
      Presheaf.germ (Sheaf.presheaf (subsheafToTypes P)) { val := x, property := (_ : x ∈ W.unop.obj) }
        { val := s, property := hW } ∧
    tV =
      Presheaf.germ (Sheaf.presheaf (subsheafToTypes P)) { val := x, property := (_ : x ∈ W.unop.obj) }
        { val := s, property := hW }
⊢ tU = tV

tactic: dsimp
state_before: case refine_1.intro.intro.mk.intro.intro.mk
X : TopCat
T : ↑X → Type v
P : LocalPredicate T
x : ↑X
w :
  ∀ (U V : OpenNhds x) (fU : (y : { x_1 // x_1 ∈ U.obj }) → T ↑y),
    PrelocalPredicate.pred P.toPrelocalPredicate fU →
      ∀ (fV : (y : { x_2 // x_2 ∈ V.obj }) → T ↑y),
        PrelocalPredicate.pred P.toPrelocalPredicate fV →
          fU { val := x, property := (_ : x ∈ U.obj) } = fV { val := x, property := (_ : x ∈ V.obj) } →
            ∃ W iU iV,
              ∀ (w : { x_4 // x_4 ∈ W.obj }),
                fU ((fun x_4 => { val := ↑x_4, property := (_ : ↑x_4 ∈ ↑U.obj) }) w) =
                  fV ((fun x_4 => { val := ↑x_4, property := (_ : ↑x_4 ∈ ↑V.obj) }) w)
U : (OpenNhds x)ᵒᵖ
fU : (x_1 : { x_1 // x_1 ∈ ((Functor.op (OpenNhds.inclusion x)).obj U).unop }) → T ↑x_1
hU : PrelocalPredicate.pred P.toPrelocalPredicate fU
V : (OpenNhds x)ᵒᵖ
fV : (x_1 : { x_1 // x_1 ∈ ((Functor.op (OpenNhds.inclusion x)).obj V).unop }) → T ↑x_1
hV : PrelocalPredicate.pred P.toPrelocalPredicate fV
h :
  stalkToFiber P x
      (colimit.ι
        (((whiskeringLeft (OpenNhds x)ᵒᵖ (Opens ↑X)ᵒᵖ (Type v)).obj (Functor.op (OpenNhds.inclusion x))).obj
          (Sheaf.presheaf (subsheafToTypes P)))
        U { val := fU, property := hU }) =
    stalkToFiber P x
      (colimit.ι
        (((whiskeringLeft (OpenNhds x)ᵒᵖ (Opens ↑X)ᵒᵖ (Type v)).obj (Functor.op (OpenNhds.inclusion x))).obj
          (Sheaf.presheaf (subsheafToTypes P)))
        V { val := fV, property := hV })
⊢ ∃ W s hW,
    colimit.ι
          (((whiskeringLeft (OpenNhds x)ᵒᵖ (Opens ↑X)ᵒᵖ (Type v)).obj (Functor.op (OpenNhds.inclusion x))).obj
            (Sheaf.presheaf (subsheafToTypes P)))
          U { val := fU, property := hU } =
        Presheaf.germ (Sheaf.presheaf (subsheafToTypes P)) { val := x, property := (_ : x ∈ W.unop.obj) }
          { val := s, property := hW } ∧
      colimit.ι
          (((whiskeringLeft (OpenNhds x)ᵒᵖ (Opens ↑X)ᵒᵖ (Type v)).obj (Functor.op (OpenNhds.inclusion x))).obj
            (Sheaf.presheaf (subsheafToTypes P)))
          V { val := fV, property := hV } =
        Presheaf.germ (Sheaf.presheaf (subsheafToTypes P)) { val := x, property := (_ : x ∈ W.unop.obj) }
          { val := s, property := hW }

tactic: simp only [stalkToFiber, Types.Colimit.ι_desc_apply'] at h
state_before: case refine_1.intro.intro.mk.intro.intro.mk
X : TopCat
T : ↑X → Type v
P : LocalPredicate T
x : ↑X
w :
  ∀ (U V : OpenNhds x) (fU : (y : { x_1 // x_1 ∈ U.obj }) → T ↑y),
    PrelocalPredicate.pred P.toPrelocalPredicate fU →
      ∀ (fV : (y : { x_2 // x_2 ∈ V.obj }) → T ↑y),
        PrelocalPredicate.pred P.toPrelocalPredicate fV →
          fU { val := x, property := (_ : x ∈ U.obj) } = fV { val := x, property := (_ : x ∈ V.obj) } →
            ∃ W iU iV,
              ∀ (w : { x_4 // x_4 ∈ W.obj }),
                fU ((fun x_4 => { val := ↑x_4, property := (_ : ↑x_4 ∈ ↑U.obj) }) w) =
                  fV ((fun x_4 => { val := ↑x_4, property := (_ : ↑x_4 ∈ ↑V.obj) }) w)
U : (OpenNhds x)ᵒᵖ
fU : (x_1 : { x_1 // x_1 ∈ ((Functor.op (OpenNhds.inclusion x)).obj U).unop }) → T ↑x_1
hU : PrelocalPredicate.pred P.toPrelocalPredicate fU
V : (OpenNhds x)ᵒᵖ
fV : (x_1 : { x_1 // x_1 ∈ ((Functor.op (OpenNhds.inclusion x)).obj V).unop }) → T ↑x_1
hV : PrelocalPredicate.pred P.toPrelocalPredicate fV
h :
  stalkToFiber P x
      (colimit.ι
        (((whiskeringLeft (OpenNhds x)ᵒᵖ (Opens ↑X)ᵒᵖ (Type v)).obj (Functor.op (OpenNhds.inclusion x))).obj
          (Sheaf.presheaf (subsheafToTypes P)))
        U { val := fU, property := hU }) =
    stalkToFiber P x
      (colimit.ι
        (((whiskeringLeft (OpenNhds x)ᵒᵖ (Opens ↑X)ᵒᵖ (Type v)).obj (Functor.op (OpenNhds.inclusion x))).obj
          (Sheaf.presheaf (subsheafToTypes P)))
        V { val := fV, property := hV })
⊢ ∃ W s hW,
    colimit.ι (Functor.op (OpenNhds.inclusion x) ⋙ subpresheafToTypes P.toPrelocalPredicate) U
          { val := fU, property := hU } =
        Presheaf.germ (subpresheafToTypes P.toPrelocalPredicate) { val := x, property := (_ : x ∈ W.unop.obj) }
          { val := s, property := hW } ∧
      colimit.ι (Functor.op (OpenNhds.inclusion x) ⋙ subpresheafToTypes P.toPrelocalPredicate) V
          { val := fV, property := hV } =
        Presheaf.germ (subpresheafToTypes P.toPrelocalPredicate) { val := x, property := (_ : x ∈ W.unop.obj) }
          { val := s, property := hW }

tactic: specialize w (unop U) (unop V) fU hU fV hV h
state_before: case refine_1.intro.intro.mk.intro.intro.mk
X : TopCat
T : ↑X → Type v
P : LocalPredicate T
x : ↑X
w :
  ∀ (U V : OpenNhds x) (fU : (y : { x_1 // x_1 ∈ U.obj }) → T ↑y),
    PrelocalPredicate.pred P.toPrelocalPredicate fU →
      ∀ (fV : (y : { x_2 // x_2 ∈ V.obj }) → T ↑y),
        PrelocalPredicate.pred P.toPrelocalPredicate fV →
          fU { val := x, property := (_ : x ∈ U.obj) } = fV { val := x, property := (_ : x ∈ V.obj) } →
            ∃ W iU iV,
              ∀ (w : { x_4 // x_4 ∈ W.obj }),
                fU ((fun x_4 => { val := ↑x_4, property := (_ : ↑x_4 ∈ ↑U.obj) }) w) =
                  fV ((fun x_4 => { val := ↑x_4, property := (_ : ↑x_4 ∈ ↑V.obj) }) w)
U : (OpenNhds x)ᵒᵖ
fU : (x_1 : { x_1 // x_1 ∈ ((Functor.op (OpenNhds.inclusion x)).obj U).unop }) → T ↑x_1
hU : PrelocalPredicate.pred P.toPrelocalPredicate fU
V : (OpenNhds x)ᵒᵖ
fV : (x_1 : { x_1 // x_1 ∈ ((Functor.op (OpenNhds.inclusion x)).obj V).unop }) → T ↑x_1
hV : PrelocalPredicate.pred P.toPrelocalPredicate fV
h : fU { val := x, property := (_ : x ∈ U.unop.obj) } = fV { val := x, property := (_ : x ∈ V.unop.obj) }
⊢ ∃ W s hW,
    colimit.ι (Functor.op (OpenNhds.inclusion x) ⋙ subpresheafToTypes P.toPrelocalPredicate) U
          { val := fU, property := hU } =
        Presheaf.germ (subpresheafToTypes P.toPrelocalPredicate) { val := x, property := (_ : x ∈ W.unop.obj) }
          { val := s, property := hW } ∧
      colimit.ι (Functor.op (OpenNhds.inclusion x) ⋙ subpresheafToTypes P.toPrelocalPredicate) V
          { val := fV, property := hV } =
        Presheaf.germ (subpresheafToTypes P.toPrelocalPredicate) { val := x, property := (_ : x ∈ W.unop.obj) }
          { val := s, property := hW }

tactic: rcases w with ⟨W, iU, iV, w⟩
state_before: case refine_1.intro.intro.mk.intro.intro.mk
X : TopCat
T : ↑X → Type v
P : LocalPredicate T
x : ↑X
U : (OpenNhds x)ᵒᵖ
fU : (x_1 : { x_1 // x_1 ∈ ((Functor.op (OpenNhds.inclusion x)).obj U).unop }) → T ↑x_1
hU : PrelocalPredicate.pred P.toPrelocalPredicate fU
V : (OpenNhds x)ᵒᵖ
fV : (x_1 : { x_1 // x_1 ∈ ((Functor.op (OpenNhds.inclusion x)).obj V).unop }) → T ↑x_1
hV : PrelocalPredicate.pred P.toPrelocalPredicate fV
h : fU { val := x, property := (_ : x ∈ U.unop.obj) } = fV { val := x, property := (_ : x ∈ V.unop.obj) }
w :
  ∃ W iU iV,
    ∀ (w : { x_1 // x_1 ∈ W.obj }),
      fU ((fun x_1 => { val := ↑x_1, property := (_ : ↑x_1 ∈ ↑U.unop.obj) }) w) =
        fV ((fun x_1 => { val := ↑x_1, property := (_ : ↑x_1 ∈ ↑V.unop.obj) }) w)
⊢ ∃ W s hW,
    colimit.ι (Functor.op (OpenNhds.inclusion x) ⋙ subpresheafToTypes P.toPrelocalPredicate) U
          { val := fU, property := hU } =
        Presheaf.germ (subpresheafToTypes P.toPrelocalPredicate) { val := x, property := (_ : x ∈ W.unop.obj) }
          { val := s, property := hW } ∧
      colimit.ι (Functor.op (OpenNhds.inclusion x) ⋙ subpresheafToTypes P.toPrelocalPredicate) V
          { val := fV, property := hV } =
        Presheaf.germ (subpresheafToTypes P.toPrelocalPredicate) { val := x, property := (_ : x ∈ W.unop.obj) }
          { val := s, property := hW }

tactic: refine' ⟨op W, fun w => fU (iU w : (unop U).1), P.res _ _ hU, _⟩
state_before: case refine_1.intro.intro.mk.intro.intro.mk.intro.intro.intro
X : TopCat
T : ↑X → Type v
P : LocalPredicate T
x : ↑X
U : (OpenNhds x)ᵒᵖ
fU : (x_1 : { x_1 // x_1 ∈ ((Functor.op (OpenNhds.inclusion x)).obj U).unop }) → T ↑x_1
hU : PrelocalPredicate.pred P.toPrelocalPredicate fU
V : (OpenNhds x)ᵒᵖ
fV : (x_1 : { x_1 // x_1 ∈ ((Functor.op (OpenNhds.inclusion x)).obj V).unop }) → T ↑x_1
hV : PrelocalPredicate.pred P.toPrelocalPredicate fV
h : fU { val := x, property := (_ : x ∈ U.unop.obj) } = fV { val := x, property := (_ : x ∈ V.unop.obj) }
W : OpenNhds x
iU : W ⟶ U.unop
iV : W ⟶ V.unop
w :
  ∀ (w : { x_1 // x_1 ∈ W.obj }),
    fU ((fun x_1 => { val := ↑x_1, property := (_ : ↑x_1 ∈ ↑U.unop.obj) }) w) =
      fV ((fun x_1 => { val := ↑x_1, property := (_ : ↑x_1 ∈ ↑V.unop.obj) }) w)
⊢ ∃ W s hW,
    colimit.ι (Functor.op (OpenNhds.inclusion x) ⋙ subpresheafToTypes P.toPrelocalPredicate) U
          { val := fU, property := hU } =
        Presheaf.germ (subpresheafToTypes P.toPrelocalPredicate) { val := x, property := (_ : x ∈ W.unop.obj) }
          { val := s, property := hW } ∧
      colimit.ι (Functor.op (OpenNhds.inclusion x) ⋙ subpresheafToTypes P.toPrelocalPredicate) V
          { val := fV, property := hV } =
        Presheaf.germ (subpresheafToTypes P.toPrelocalPredicate) { val := x, property := (_ : x ∈ W.unop.obj) }
          { val := s, property := hW }

tactic: rcases W with ⟨W, m⟩
state_before: case refine_1.intro.intro.mk.intro.intro.mk.intro.intro.intro.refine'_1
X : TopCat
T : ↑X → Type v
P : LocalPredicate T
x : ↑X
U : (OpenNhds x)ᵒᵖ
fU : (x_1 : { x_1 // x_1 ∈ ((Functor.op (OpenNhds.inclusion x)).obj U).unop }) → T ↑x_1
hU : PrelocalPredicate.pred P.toPrelocalPredicate fU
V : (OpenNhds x)ᵒᵖ
fV : (x_1 : { x_1 // x_1 ∈ ((Functor.op (OpenNhds.inclusion x)).obj V).unop }) → T ↑x_1
hV : PrelocalPredicate.pred P.toPrelocalPredicate fV
h : fU { val := x, property := (_ : x ∈ U.unop.obj) } = fV { val := x, property := (_ : x ∈ V.unop.obj) }
W : OpenNhds x
iU : W ⟶ U.unop
iV : W ⟶ V.unop
w :
  ∀ (w : { x_1 // x_1 ∈ W.obj }),
    fU ((fun x_1 => { val := ↑x_1, property := (_ : ↑x_1 ∈ ↑U.unop.obj) }) w) =
      fV ((fun x_1 => { val := ↑x_1, property := (_ : ↑x_1 ∈ ↑V.unop.obj) }) w)
⊢ W.op.unop.obj ⟶ U.unop.obj

case refine_1.intro.intro.mk.intro.intro.mk.intro.intro.intro.refine'_2
X : TopCat
T : ↑X → Type v
P : LocalPredicate T
x : ↑X
U : (OpenNhds x)ᵒᵖ
fU : (x_1 : { x_1 // x_1 ∈ ((Functor.op (OpenNhds.inclusion x)).obj U).unop }) → T ↑x_1
hU : PrelocalPredicate.pred P.toPrelocalPredicate fU
V : (OpenNhds x)ᵒᵖ
fV : (x_1 : { x_1 // x_1 ∈ ((Functor.op (OpenNhds.inclusion x)).obj V).unop }) → T ↑x_1
hV : PrelocalPredicate.pred P.toPrelocalPredicate fV
h : fU { val := x, property := (_ : x ∈ U.unop.obj) } = fV { val := x, property := (_ : x ∈ V.unop.obj) }
W : OpenNhds x
iU : W ⟶ U.unop
iV : W ⟶ V.unop
w :
  ∀ (w : { x_1 // x_1 ∈ W.obj }),
    fU ((fun x_1 => { val := ↑x_1, property := (_ : ↑x_1 ∈ ↑U.unop.obj) }) w) =
      fV ((fun x_1 => { val := ↑x_1, property := (_ : ↑x_1 ∈ ↑V.unop.obj) }) w)
⊢ colimit.ι (Functor.op (OpenNhds.inclusion x) ⋙ subpresheafToTypes P.toPrelocalPredicate) U
        { val := fU, property := hU } =
      Presheaf.germ (subpresheafToTypes P.toPrelocalPredicate) { val := x, property := (_ : x ∈ W.op.unop.obj) }
        { val := fun w => fU ((fun x_1 => { val := ↑x_1, property := (_ : ↑x_1 ∈ ↑U.unop.obj) }) w),
          property :=
            (_ :
              PrelocalPredicate.pred P.toPrelocalPredicate fun x_1 =>
                fU ((fun x_2 => { val := ↑x_2, property := (_ : ↑x_2 ∈ ↑U.unop.obj) }) x_1)) } ∧
    colimit.ι (Functor.op (OpenNhds.inclusion x) ⋙ subpresheafToTypes P.toPrelocalPredicate) V
        { val := fV, property := hV } =
      Presheaf.germ (subpresheafToTypes P.toPrelocalPredicate) { val := x, property := (_ : x ∈ W.op.unop.obj) }
        { val := fun w => fU ((fun x_1 => { val := ↑x_1, property := (_ : ↑x_1 ∈ ↑U.unop.obj) }) w),
          property :=
            (_ :
              PrelocalPredicate.pred P.toPrelocalPredicate fun x_1 =>
                fU ((fun x_2 => { val := ↑x_2, property := (_ : ↑x_2 ∈ ↑U.unop.obj) }) x_1)) }

tactic: . exact iU
state_before: case refine_1.intro.intro.mk.intro.intro.mk.intro.intro.intro.refine'_1.mk
X : TopCat
T : ↑X → Type v
P : LocalPredicate T
x : ↑X
U : (OpenNhds x)ᵒᵖ
fU : (x_1 : { x_1 // x_1 ∈ ((Functor.op (OpenNhds.inclusion x)).obj U).unop }) → T ↑x_1
hU : PrelocalPredicate.pred P.toPrelocalPredicate fU
V : (OpenNhds x)ᵒᵖ
fV : (x_1 : { x_1 // x_1 ∈ ((Functor.op (OpenNhds.inclusion x)).obj V).unop }) → T ↑x_1
hV : PrelocalPredicate.pred P.toPrelocalPredicate fV
h : fU { val := x, property := (_ : x ∈ U.unop.obj) } = fV { val := x, property := (_ : x ∈ V.unop.obj) }
W : Opens ↑X
m : x ∈ W
iU : { obj := W, property := m } ⟶ U.unop
iV : { obj := W, property := m } ⟶ V.unop
w :
  ∀ (w : { x_1 // x_1 ∈ { obj := W, property := m }.obj }),
    fU ((fun x_1 => { val := ↑x_1, property := (_ : ↑x_1 ∈ ↑U.unop.obj) }) w) =
      fV ((fun x_1 => { val := ↑x_1, property := (_ : ↑x_1 ∈ ↑V.unop.obj) }) w)
⊢ { obj := W, property := m }.op.unop.obj ⟶ U.unop.obj

case refine_1.intro.intro.mk.intro.intro.mk.intro.intro.intro.refine'_2
X : TopCat
T : ↑X → Type v
P : LocalPredicate T
x : ↑X
U : (OpenNhds x)ᵒᵖ
fU : (x_1 : { x_1 // x_1 ∈ ((Functor.op (OpenNhds.inclusion x)).obj U).unop }) → T ↑x_1
hU : PrelocalPredicate.pred P.toPrelocalPredicate fU
V : (OpenNhds x)ᵒᵖ
fV : (x_1 : { x_1 // x_1 ∈ ((Functor.op (OpenNhds.inclusion x)).obj V).unop }) → T ↑x_1
hV : PrelocalPredicate.pred P.toPrelocalPredicate fV
h : fU { val := x, property := (_ : x ∈ U.unop.obj) } = fV { val := x, property := (_ : x ∈ V.unop.obj) }
W : OpenNhds x
iU : W ⟶ U.unop
iV : W ⟶ V.unop
w :
  ∀ (w : { x_1 // x_1 ∈ W.obj }),
    fU ((fun x_1 => { val := ↑x_1, property := (_ : ↑x_1 ∈ ↑U.unop.obj) }) w) =
      fV ((fun x_1 => { val := ↑x_1, property := (_ : ↑x_1 ∈ ↑V.unop.obj) }) w)
⊢ colimit.ι (Functor.op (OpenNhds.inclusion x) ⋙ subpresheafToTypes P.toPrelocalPredicate) U
        { val := fU, property := hU } =
      Presheaf.germ (subpresheafToTypes P.toPrelocalPredicate) { val := x, property := (_ : x ∈ W.op.unop.obj) }
        { val := fun w => fU ((fun x_1 => { val := ↑x_1, property := (_ : ↑x_1 ∈ ↑U.unop.obj) }) w),
          property :=
            (_ :
              PrelocalPredicate.pred P.toPrelocalPredicate fun x_1 =>
                fU ((fun x_2 => { val := ↑x_2, property := (_ : ↑x_2 ∈ ↑U.unop.obj) }) x_1)) } ∧
    colimit.ι (Functor.op (OpenNhds.inclusion x) ⋙ subpresheafToTypes P.toPrelocalPredicate) V
        { val := fV, property := hV } =
      Presheaf.germ (subpresheafToTypes P.toPrelocalPredicate) { val := x, property := (_ : x ∈ W.op.unop.obj) }
        { val := fun w => fU ((fun x_1 => { val := ↑x_1, property := (_ : ↑x_1 ∈ ↑U.unop.obj) }) w),
          property :=
            (_ :
              PrelocalPredicate.pred P.toPrelocalPredicate fun x_1 =>
                fU ((fun x_2 => { val := ↑x_2, property := (_ : ↑x_2 ∈ ↑U.unop.obj) }) x_1)) }

tactic: . exact ⟨colimit_sound iU.op (Subtype.eq rfl), colimit_sound iV.op (Subtype.eq (funext w).symm)⟩
state_before: case refine_1.intro.intro.mk.intro.intro.mk.intro.intro.intro.refine'_2
X : TopCat
T : ↑X → Type v
P : LocalPredicate T
x : ↑X
U : (OpenNhds x)ᵒᵖ
fU : (x_1 : { x_1 // x_1 ∈ ((Functor.op (OpenNhds.inclusion x)).obj U).unop }) → T ↑x_1
hU : PrelocalPredicate.pred P.toPrelocalPredicate fU
V : (OpenNhds x)ᵒᵖ
fV : (x_1 : { x_1 // x_1 ∈ ((Functor.op (OpenNhds.inclusion x)).obj V).unop }) → T ↑x_1
hV : PrelocalPredicate.pred P.toPrelocalPredicate fV
h : fU { val := x, property := (_ : x ∈ U.unop.obj) } = fV { val := x, property := (_ : x ∈ V.unop.obj) }
W : OpenNhds x
iU : W ⟶ U.unop
iV : W ⟶ V.unop
w :
  ∀ (w : { x_1 // x_1 ∈ W.obj }),
    fU ((fun x_1 => { val := ↑x_1, property := (_ : ↑x_1 ∈ ↑U.unop.obj) }) w) =
      fV ((fun x_1 => { val := ↑x_1, property := (_ : ↑x_1 ∈ ↑V.unop.obj) }) w)
⊢ colimit.ι (Functor.op (OpenNhds.inclusion x) ⋙ subpresheafToTypes P.toPrelocalPredicate) U
        { val := fU, property := hU } =
      Presheaf.germ (subpresheafToTypes P.toPrelocalPredicate) { val := x, property := (_ : x ∈ W.op.unop.obj) }
        { val := fun w => fU ((fun x_1 => { val := ↑x_1, property := (_ : ↑x_1 ∈ ↑U.unop.obj) }) w),
          property :=
            (_ :
              PrelocalPredicate.pred P.toPrelocalPredicate fun x_1 =>
                fU ((fun x_2 => { val := ↑x_2, property := (_ : ↑x_2 ∈ ↑U.unop.obj) }) x_1)) } ∧
    colimit.ι (Functor.op (OpenNhds.inclusion x) ⋙ subpresheafToTypes P.toPrelocalPredicate) V
        { val := fV, property := hV } =
      Presheaf.germ (subpresheafToTypes P.toPrelocalPredicate) { val := x, property := (_ : x ∈ W.op.unop.obj) }
        { val := fun w => fU ((fun x_1 => { val := ↑x_1, property := (_ : ↑x_1 ∈ ↑U.unop.obj) }) w),
          property :=
            (_ :
              PrelocalPredicate.pred P.toPrelocalPredicate fun x_1 =>
                fU ((fun x_2 => { val := ↑x_2, property := (_ : ↑x_2 ∈ ↑U.unop.obj) }) x_1)) }

tactic: exact iU
state_before: case refine_1.intro.intro.mk.intro.intro.mk.intro.intro.intro.refine'_1.mk
X : TopCat
T : ↑X → Type v
P : LocalPredicate T
x : ↑X
U : (OpenNhds x)ᵒᵖ
fU : (x_1 : { x_1 // x_1 ∈ ((Functor.op (OpenNhds.inclusion x)).obj U).unop }) → T ↑x_1
hU : PrelocalPredicate.pred P.toPrelocalPredicate fU
V : (OpenNhds x)ᵒᵖ
fV : (x_1 : { x_1 // x_1 ∈ ((Functor.op (OpenNhds.inclusion x)).obj V).unop }) → T ↑x_1
hV : PrelocalPredicate.pred P.toPrelocalPredicate fV
h : fU { val := x, property := (_ : x ∈ U.unop.obj) } = fV { val := x, property := (_ : x ∈ V.unop.obj) }
W : Opens ↑X
m : x ∈ W
iU : { obj := W, property := m } ⟶ U.unop
iV : { obj := W, property := m } ⟶ V.unop
w :
  ∀ (w : { x_1 // x_1 ∈ { obj := W, property := m }.obj }),
    fU ((fun x_1 => { val := ↑x_1, property := (_ : ↑x_1 ∈ ↑U.unop.obj) }) w) =
      fV ((fun x_1 => { val := ↑x_1, property := (_ : ↑x_1 ∈ ↑V.unop.obj) }) w)
⊢ { obj := W, property := m }.op.unop.obj ⟶ U.unop.obj

tactic: exact ⟨colimit_sound iU.op (Subtype.eq rfl), colimit_sound iV.op (Subtype.eq (funext w).symm)⟩
state_before: case refine_1.intro.intro.mk.intro.intro.mk.intro.intro.intro.refine'_2
X : TopCat
T : ↑X → Type v
P : LocalPredicate T
x : ↑X
U : (OpenNhds x)ᵒᵖ
fU : (x_1 : { x_1 // x_1 ∈ ((Functor.op (OpenNhds.inclusion x)).obj U).unop }) → T ↑x_1
hU : PrelocalPredicate.pred P.toPrelocalPredicate fU
V : (OpenNhds x)ᵒᵖ
fV : (x_1 : { x_1 // x_1 ∈ ((Functor.op (OpenNhds.inclusion x)).obj V).unop }) → T ↑x_1
hV : PrelocalPredicate.pred P.toPrelocalPredicate fV
h : fU { val := x, property := (_ : x ∈ U.unop.obj) } = fV { val := x, property := (_ : x ∈ V.unop.obj) }
W : OpenNhds x
iU : W ⟶ U.unop
iV : W ⟶ V.unop
w :
  ∀ (w : { x_1 // x_1 ∈ W.obj }),
    fU ((fun x_1 => { val := ↑x_1, property := (_ : ↑x_1 ∈ ↑U.unop.obj) }) w) =
      fV ((fun x_1 => { val := ↑x_1, property := (_ : ↑x_1 ∈ ↑V.unop.obj) }) w)
⊢ colimit.ι (Functor.op (OpenNhds.inclusion x) ⋙ subpresheafToTypes P.toPrelocalPredicate) U
        { val := fU, property := hU } =
      Presheaf.germ (subpresheafToTypes P.toPrelocalPredicate) { val := x, property := (_ : x ∈ W.op.unop.obj) }
        { val := fun w => fU ((fun x_1 => { val := ↑x_1, property := (_ : ↑x_1 ∈ ↑U.unop.obj) }) w),
          property :=
            (_ :
              PrelocalPredicate.pred P.toPrelocalPredicate fun x_1 =>
                fU ((fun x_2 => { val := ↑x_2, property := (_ : ↑x_2 ∈ ↑U.unop.obj) }) x_1)) } ∧
    colimit.ι (Functor.op (OpenNhds.inclusion x) ⋙ subpresheafToTypes P.toPrelocalPredicate) V
        { val := fV, property := hV } =
      Presheaf.germ (subpresheafToTypes P.toPrelocalPredicate) { val := x, property := (_ : x ∈ W.op.unop.obj) }
        { val := fun w => fU ((fun x_1 => { val := ↑x_1, property := (_ : ↑x_1 ∈ ↑U.unop.obj) }) w),
          property :=
            (_ :
              PrelocalPredicate.pred P.toPrelocalPredicate fun x_1 =>
                fU ((fun x_2 => { val := ↑x_2, property := (_ : ↑x_2 ∈ ↑U.unop.obj) }) x_1)) }