Theorem: TopCat.Presheaf.app_surjective_of_injective_of_locally_surjective
File: Mathlib/Topology/Sheaves/Stalks.lean

tactic: intro t
state_before: C : Type u
inst✝⁶ : Category.{v, u} C
inst✝⁵ : HasColimits C
X Y Z : TopCat
inst✝⁴ : ConcreteCategory C
inst✝³ : PreservesFilteredColimits (forget C)
inst✝² : HasLimits C
inst✝¹ : PreservesLimits (forget C)
inst✝ : (forget C).ReflectsIsomorphisms
F G : Sheaf C X
f : F ⟶ G
U : Opens ↑X
hinj : ∀ (x : ↥U), Function.Injective ⇑((stalkFunctor C ↑x).map f.val)
hsurj :
  ∀ (t : (forget C).obj (G.val.obj { unop := U })) (x : ↥U),
    ∃ V, ∃ (_ : ↑x ∈ V), ∃ iVU s, (f.val.app { unop := V }) s = (G.val.map iVU.op) t
⊢ Function.Surjective ⇑(f.val.app { unop := U })
state_after: C : Type u
inst✝⁶ : Category.{v, u} C
inst✝⁵ : HasColimits C
X Y Z : TopCat
inst✝⁴ : ConcreteCategory C
inst✝³ : PreservesFilteredColimits (forget C)
inst✝² : HasLimits C
inst✝¹ : PreservesLimits (forget C)
inst✝ : (forget C).ReflectsIsomorphisms
F G : Sheaf C X
f : F ⟶ G
U : Opens ↑X
hinj : ∀ (x : ↥U), Function.Injective ⇑((stalkFunctor C ↑x).map f.val)
hsurj :
  ∀ (t : (forget C).obj (G.val.obj { unop := U })) (x : ↥U),
    ∃ V, ∃ (_ : ↑x ∈ V), ∃ iVU s, (f.val.app { unop := V }) s = (G.val.map iVU.op) t
t : (forget C).obj (G.val.obj { unop := U })
⊢ ∃ a, (f.val.app { unop := U }) a = t

tactic: choose V mV iVU sf heq using hsurj t
state_before: C : Type u
inst✝⁶ : Category.{v, u} C
inst✝⁵ : HasColimits C
X Y Z : TopCat
inst✝⁴ : ConcreteCategory C
inst✝³ : PreservesFilteredColimits (forget C)
inst✝² : HasLimits C
inst✝¹ : PreservesLimits (forget C)
inst✝ : (forget C).ReflectsIsomorphisms
F G : Sheaf C X
f : F ⟶ G
U : Opens ↑X
hinj : ∀ (x : ↥U), Function.Injective ⇑((stalkFunctor C ↑x).map f.val)
hsurj :
  ∀ (t : (forget C).obj (G.val.obj { unop := U })) (x : ↥U),
    ∃ V, ∃ (_ : ↑x ∈ V), ∃ iVU s, (f.val.app { unop := V }) s = (G.val.map iVU.op) t
t : (forget C).obj (G.val.obj { unop := U })
⊢ ∃ a, (f.val.app { unop := U }) a = t
state_after: C : Type u
inst✝⁶ : Category.{v, u} C
inst✝⁵ : HasColimits C
X Y Z : TopCat
inst✝⁴ : ConcreteCategory C
inst✝³ : PreservesFilteredColimits (forget C)
inst✝² : HasLimits C
inst✝¹ : PreservesLimits (forget C)
inst✝ : (forget C).ReflectsIsomorphisms
F G : Sheaf C X
f : F ⟶ G
U : Opens ↑X
hinj : ∀ (x : ↥U), Function.Injective ⇑((stalkFunctor C ↑x).map f.val)
hsurj :
  ∀ (t : (forget C).obj (G.val.obj { unop := U })) (x : ↥U),
    ∃ V, ∃ (_ : ↑x ∈ V), ∃ iVU s, (f.val.app { unop := V }) s = (G.val.map iVU.op) t
t : (forget C).obj (G.val.obj { unop := U })
V : ↥U → Opens ↑X
mV : ∀ (x : ↥U), ↑x ∈ V x
iVU : (x : ↥U) → V x ⟶ U
sf : (x : ↥U) → (forget C).obj (F.val.obj { unop := V x })
heq : ∀ (x : ↥U), (f.val.app { unop := V x }) (sf x) = (G.val.map (iVU x).op) t
⊢ ∃ a, (f.val.app { unop := U }) a = t

tactic: have V_cover : U ≤ iSup V := by
  intro x hxU
  simp only [Opens.coe_iSup, Set.mem_iUnion, SetLike.mem_coe]
  exact ⟨⟨x, hxU⟩, mV ⟨x, hxU⟩⟩
state_before: C : Type u
inst✝⁶ : Category.{v, u} C
inst✝⁵ : HasColimits C
X Y Z : TopCat
inst✝⁴ : ConcreteCategory C
inst✝³ : PreservesFilteredColimits (forget C)
inst✝² : HasLimits C
inst✝¹ : PreservesLimits (forget C)
inst✝ : (forget C).ReflectsIsomorphisms
F G : Sheaf C X
f : F ⟶ G
U : Opens ↑X
hinj : ∀ (x : ↥U), Function.Injective ⇑((stalkFunctor C ↑x).map f.val)
hsurj :
  ∀ (t : (forget C).obj (G.val.obj { unop := U })) (x : ↥U),
    ∃ V, ∃ (_ : ↑x ∈ V), ∃ iVU s, (f.val.app { unop := V }) s = (G.val.map iVU.op) t
t : (forget C).obj (G.val.obj { unop := U })
V : ↥U → Opens ↑X
mV : ∀ (x : ↥U), ↑x ∈ V x
iVU : (x : ↥U) → V x ⟶ U
sf : (x : ↥U) → (forget C).obj (F.val.obj { unop := V x })
heq : ∀ (x : ↥U), (f.val.app { unop := V x }) (sf x) = (G.val.map (iVU x).op) t
⊢ ∃ a, (f.val.app { unop := U }) a = t
state_after: C : Type u
inst✝⁶ : Category.{v, u} C
inst✝⁵ : HasColimits C
X Y Z : TopCat
inst✝⁴ : ConcreteCategory C
inst✝³ : PreservesFilteredColimits (forget C)
inst✝² : HasLimits C
inst✝¹ : PreservesLimits (forget C)
inst✝ : (forget C).ReflectsIsomorphisms
F G : Sheaf C X
f : F ⟶ G
U : Opens ↑X
hinj : ∀ (x : ↥U), Function.Injective ⇑((stalkFunctor C ↑x).map f.val)
hsurj :
  ∀ (t : (forget C).obj (G.val.obj { unop := U })) (x : ↥U),
    ∃ V, ∃ (_ : ↑x ∈ V), ∃ iVU s, (f.val.app { unop := V }) s = (G.val.map iVU.op) t
t : (forget C).obj (G.val.obj { unop := U })
V : ↥U → Opens ↑X
mV : ∀ (x : ↥U), ↑x ∈ V x
iVU : (x : ↥U) → V x ⟶ U
sf : (x : ↥U) → (forget C).obj (F.val.obj { unop := V x })
heq : ∀ (x : ↥U), (f.val.app { unop := V x }) (sf x) = (G.val.map (iVU x).op) t
V_cover : U ≤ iSup V
⊢ ∃ a, (f.val.app { unop := U }) a = t

tactic: intro x y
state_before: C : Type u
inst✝⁶ : Category.{v, u} C
inst✝⁵ : HasColimits C
X Y Z : TopCat
inst✝⁴ : ConcreteCategory C
inst✝³ : PreservesFilteredColimits (forget C)
inst✝² : HasLimits C
inst✝¹ : PreservesLimits (forget C)
inst✝ : (forget C).ReflectsIsomorphisms
F G : Sheaf C X
f : F ⟶ G
U : Opens ↑X
hinj : ∀ (x : ↥U), Function.Injective ⇑((stalkFunctor C ↑x).map f.val)
hsurj :
  ∀ (t : (forget C).obj (G.val.obj { unop := U })) (x : ↥U),
    ∃ V, ∃ (_ : ↑x ∈ V), ∃ iVU s, (f.val.app { unop := V }) s = (G.val.map iVU.op) t
t : (forget C).obj (G.val.obj { unop := U })
V : ↥U → Opens ↑X
mV : ∀ (x : ↥U), ↑x ∈ V x
iVU : (x : ↥U) → V x ⟶ U
sf : (x : ↥U) → (forget C).obj (F.val.obj { unop := V x })
heq : ∀ (x : ↥U), (f.val.app { unop := V x }) (sf x) = (G.val.map (iVU x).op) t
V_cover : U ≤ iSup V
⊢ IsCompatible F.val V sf
state_after: C : Type u
inst✝⁶ : Category.{v, u} C
inst✝⁵ : HasColimits C
X Y Z : TopCat
inst✝⁴ : ConcreteCategory C
inst✝³ : PreservesFilteredColimits (forget C)
inst✝² : HasLimits C
inst✝¹ : PreservesLimits (forget C)
inst✝ : (forget C).ReflectsIsomorphisms
F G : Sheaf C X
f : F ⟶ G
U : Opens ↑X
hinj : ∀ (x : ↥U), Function.Injective ⇑((stalkFunctor C ↑x).map f.val)
hsurj :
  ∀ (t : (forget C).obj (G.val.obj { unop := U })) (x : ↥U),
    ∃ V, ∃ (_ : ↑x ∈ V), ∃ iVU s, (f.val.app { unop := V }) s = (G.val.map iVU.op) t
t : (forget C).obj (G.val.obj { unop := U })
V : ↥U → Opens ↑X
mV : ∀ (x : ↥U), ↑x ∈ V x
iVU : (x : ↥U) → V x ⟶ U
sf : (x : ↥U) → (forget C).obj (F.val.obj { unop := V x })
heq : ∀ (x : ↥U), (f.val.app { unop := V x }) (sf x) = (G.val.map (iVU x).op) t
V_cover : U ≤ iSup V
x y : ↥U
⊢ (F.val.map ((V x).infLELeft (V y)).op) (sf x) = (F.val.map ((V x).infLERight (V y)).op) (sf y)

tactic: apply section_ext
state_before: C : Type u
inst✝⁶ : Category.{v, u} C
inst✝⁵ : HasColimits C
X Y Z : TopCat
inst✝⁴ : ConcreteCategory C
inst✝³ : PreservesFilteredColimits (forget C)
inst✝² : HasLimits C
inst✝¹ : PreservesLimits (forget C)
inst✝ : (forget C).ReflectsIsomorphisms
F G : Sheaf C X
f : F ⟶ G
U : Opens ↑X
hinj : ∀ (x : ↥U), Function.Injective ⇑((stalkFunctor C ↑x).map f.val)
hsurj :
  ∀ (t : (forget C).obj (G.val.obj { unop := U })) (x : ↥U),
    ∃ V, ∃ (_ : ↑x ∈ V), ∃ iVU s, (f.val.app { unop := V }) s = (G.val.map iVU.op) t
t : (forget C).obj (G.val.obj { unop := U })
V : ↥U → Opens ↑X
mV : ∀ (x : ↥U), ↑x ∈ V x
iVU : (x : ↥U) → V x ⟶ U
sf : (x : ↥U) → (forget C).obj (F.val.obj { unop := V x })
heq : ∀ (x : ↥U), (f.val.app { unop := V x }) (sf x) = (G.val.map (iVU x).op) t
V_cover : U ≤ iSup V
x y : ↥U
⊢ (F.val.map ((V x).infLELeft (V y)).op) (sf x) = (F.val.map ((V x).infLERight (V y)).op) (sf y)
state_after: case h
C : Type u
inst✝⁶ : Category.{v, u} C
inst✝⁵ : HasColimits C
X Y Z : TopCat
inst✝⁴ : ConcreteCategory C
inst✝³ : PreservesFilteredColimits (forget C)
inst✝² : HasLimits C
inst✝¹ : PreservesLimits (forget C)
inst✝ : (forget C).ReflectsIsomorphisms
F G : Sheaf C X
f : F ⟶ G
U : Opens ↑X
hinj : ∀ (x : ↥U), Function.Injective ⇑((stalkFunctor C ↑x).map f.val)
hsurj :
  ∀ (t : (forget C).obj (G.val.obj { unop := U })) (x : ↥U),
    ∃ V, ∃ (_ : ↑x ∈ V), ∃ iVU s, (f.val.app { unop := V }) s = (G.val.map iVU.op) t
t : (forget C).obj (G.val.obj { unop := U })
V : ↥U → Opens ↑X
mV : ∀ (x : ↥U), ↑x ∈ V x
iVU : (x : ↥U) → V x ⟶ U
sf : (x : ↥U) → (forget C).obj (F.val.obj { unop := V x })
heq : ∀ (x : ↥U), (f.val.app { unop := V x }) (sf x) = (G.val.map (iVU x).op) t
V_cover : U ≤ iSup V
x y : ↥U
⊢ ∀ (x_1 : ↥(V x ⊓ V y)),
    (F.presheaf.germ x_1) ((F.val.map ((V x).infLELeft (V y)).op) (sf x)) =
      (F.presheaf.germ x_1) ((F.val.map ((V x).infLERight (V y)).op) (sf y))

tactic: intro z
state_before: case h
C : Type u
inst✝⁶ : Category.{v, u} C
inst✝⁵ : HasColimits C
X Y Z : TopCat
inst✝⁴ : ConcreteCategory C
inst✝³ : PreservesFilteredColimits (forget C)
inst✝² : HasLimits C
inst✝¹ : PreservesLimits (forget C)
inst✝ : (forget C).ReflectsIsomorphisms
F G : Sheaf C X
f : F ⟶ G
U : Opens ↑X
hinj : ∀ (x : ↥U), Function.Injective ⇑((stalkFunctor C ↑x).map f.val)
hsurj :
  ∀ (t : (forget C).obj (G.val.obj { unop := U })) (x : ↥U),
    ∃ V, ∃ (_ : ↑x ∈ V), ∃ iVU s, (f.val.app { unop := V }) s = (G.val.map iVU.op) t
t : (forget C).obj (G.val.obj { unop := U })
V : ↥U → Opens ↑X
mV : ∀ (x : ↥U), ↑x ∈ V x
iVU : (x : ↥U) → V x ⟶ U
sf : (x : ↥U) → (forget C).obj (F.val.obj { unop := V x })
heq : ∀ (x : ↥U), (f.val.app { unop := V x }) (sf x) = (G.val.map (iVU x).op) t
V_cover : U ≤ iSup V
x y : ↥U
⊢ ∀ (x_1 : ↥(V x ⊓ V y)),
    (F.presheaf.germ x_1) ((F.val.map ((V x).infLELeft (V y)).op) (sf x)) =
      (F.presheaf.germ x_1) ((F.val.map ((V x).infLERight (V y)).op) (sf y))
state_after: case h
C : Type u
inst✝⁶ : Category.{v, u} C
inst✝⁵ : HasColimits C
X Y Z : TopCat
inst✝⁴ : ConcreteCategory C
inst✝³ : PreservesFilteredColimits (forget C)
inst✝² : HasLimits C
inst✝¹ : PreservesLimits (forget C)
inst✝ : (forget C).ReflectsIsomorphisms
F G : Sheaf C X
f : F ⟶ G
U : Opens ↑X
hinj : ∀ (x : ↥U), Function.Injective ⇑((stalkFunctor C ↑x).map f.val)
hsurj :
  ∀ (t : (forget C).obj (G.val.obj { unop := U })) (x : ↥U),
    ∃ V, ∃ (_ : ↑x ∈ V), ∃ iVU s, (f.val.app { unop := V }) s = (G.val.map iVU.op) t
t : (forget C).obj (G.val.obj { unop := U })
V : ↥U → Opens ↑X
mV : ∀ (x : ↥U), ↑x ∈ V x
iVU : (x : ↥U) → V x ⟶ U
sf : (x : ↥U) → (forget C).obj (F.val.obj { unop := V x })
heq : ∀ (x : ↥U), (f.val.app { unop := V x }) (sf x) = (G.val.map (iVU x).op) t
V_cover : U ≤ iSup V
x y : ↥U
z : ↥(V x ⊓ V y)
⊢ (F.presheaf.germ z) ((F.val.map ((V x).infLELeft (V y)).op) (sf x)) =
    (F.presheaf.germ z) ((F.val.map ((V x).infLERight (V y)).op) (sf y))

tactic: apply hinj ⟨z, (iVU x).le ((inf_le_left : V x ⊓ V y ≤ V x) z.2)⟩
state_before: case h
C : Type u
inst✝⁶ : Category.{v, u} C
inst✝⁵ : HasColimits C
X Y Z : TopCat
inst✝⁴ : ConcreteCategory C
inst✝³ : PreservesFilteredColimits (forget C)
inst✝² : HasLimits C
inst✝¹ : PreservesLimits (forget C)
inst✝ : (forget C).ReflectsIsomorphisms
F G : Sheaf C X
f : F ⟶ G
U : Opens ↑X
hinj : ∀ (x : ↥U), Function.Injective ⇑((stalkFunctor C ↑x).map f.val)
hsurj :
  ∀ (t : (forget C).obj (G.val.obj { unop := U })) (x : ↥U),
    ∃ V, ∃ (_ : ↑x ∈ V), ∃ iVU s, (f.val.app { unop := V }) s = (G.val.map iVU.op) t
t : (forget C).obj (G.val.obj { unop := U })
V : ↥U → Opens ↑X
mV : ∀ (x : ↥U), ↑x ∈ V x
iVU : (x : ↥U) → V x ⟶ U
sf : (x : ↥U) → (forget C).obj (F.val.obj { unop := V x })
heq : ∀ (x : ↥U), (f.val.app { unop := V x }) (sf x) = (G.val.map (iVU x).op) t
V_cover : U ≤ iSup V
x y : ↥U
z : ↥(V x ⊓ V y)
⊢ (F.presheaf.germ z) ((F.val.map ((V x).infLELeft (V y)).op) (sf x)) =
    (F.presheaf.germ z) ((F.val.map ((V x).infLERight (V y)).op) (sf y))
state_after: case h.a
C : Type u
inst✝⁶ : Category.{v, u} C
inst✝⁵ : HasColimits C
X Y Z : TopCat
inst✝⁴ : ConcreteCategory C
inst✝³ : PreservesFilteredColimits (forget C)
inst✝² : HasLimits C
inst✝¹ : PreservesLimits (forget C)
inst✝ : (forget C).ReflectsIsomorphisms
F G : Sheaf C X
f : F ⟶ G
U : Opens ↑X
hinj : ∀ (x : ↥U), Function.Injective ⇑((stalkFunctor C ↑x).map f.val)
hsurj :
  ∀ (t : (forget C).obj (G.val.obj { unop := U })) (x : ↥U),
    ∃ V, ∃ (_ : ↑x ∈ V), ∃ iVU s, (f.val.app { unop := V }) s = (G.val.map iVU.op) t
t : (forget C).obj (G.val.obj { unop := U })
V : ↥U → Opens ↑X
mV : ∀ (x : ↥U), ↑x ∈ V x
iVU : (x : ↥U) → V x ⟶ U
sf : (x : ↥U) → (forget C).obj (F.val.obj { unop := V x })
heq : ∀ (x : ↥U), (f.val.app { unop := V x }) (sf x) = (G.val.map (iVU x).op) t
V_cover : U ≤ iSup V
x y : ↥U
z : ↥(V x ⊓ V y)
⊢ ((stalkFunctor C ↑⟨↑z, ⋯⟩).map f.val) ((F.presheaf.germ z) ((F.val.map ((V x).infLELeft (V y)).op) (sf x))) =
    ((stalkFunctor C ↑⟨↑z, ⋯⟩).map f.val) ((F.presheaf.germ z) ((F.val.map ((V x).infLERight (V y)).op) (sf y)))

tactic: dsimp only
state_before: case h.a
C : Type u
inst✝⁶ : Category.{v, u} C
inst✝⁵ : HasColimits C
X Y Z : TopCat
inst✝⁴ : ConcreteCategory C
inst✝³ : PreservesFilteredColimits (forget C)
inst✝² : HasLimits C
inst✝¹ : PreservesLimits (forget C)
inst✝ : (forget C).ReflectsIsomorphisms
F G : Sheaf C X
f : F ⟶ G
U : Opens ↑X
hinj : ∀ (x : ↥U), Function.Injective ⇑((stalkFunctor C ↑x).map f.val)
hsurj :
  ∀ (t : (forget C).obj (G.val.obj { unop := U })) (x : ↥U),
    ∃ V, ∃ (_ : ↑x ∈ V), ∃ iVU s, (f.val.app { unop := V }) s = (G.val.map iVU.op) t
t : (forget C).obj (G.val.obj { unop := U })
V : ↥U → Opens ↑X
mV : ∀ (x : ↥U), ↑x ∈ V x
iVU : (x : ↥U) → V x ⟶ U
sf : (x : ↥U) → (forget C).obj (F.val.obj { unop := V x })
heq : ∀ (x : ↥U), (f.val.app { unop := V x }) (sf x) = (G.val.map (iVU x).op) t
V_cover : U ≤ iSup V
x y : ↥U
z : ↥(V x ⊓ V y)
⊢ ((stalkFunctor C ↑⟨↑z, ⋯⟩).map f.val) ((F.presheaf.germ z) ((F.val.map ((V x).infLELeft (V y)).op) (sf x))) =
    ((stalkFunctor C ↑⟨↑z, ⋯⟩).map f.val) ((F.presheaf.germ z) ((F.val.map ((V x).infLERight (V y)).op) (sf y)))
state_after: case h.a
C : Type u
inst✝⁶ : Category.{v, u} C
inst✝⁵ : HasColimits C
X Y Z : TopCat
inst✝⁴ : ConcreteCategory C
inst✝³ : PreservesFilteredColimits (forget C)
inst✝² : HasLimits C
inst✝¹ : PreservesLimits (forget C)
inst✝ : (forget C).ReflectsIsomorphisms
F G : Sheaf C X
f : F ⟶ G
U : Opens ↑X
hinj : ∀ (x : ↥U), Function.Injective ⇑((stalkFunctor C ↑x).map f.val)
hsurj :
  ∀ (t : (forget C).obj (G.val.obj { unop := U })) (x : ↥U),
    ∃ V, ∃ (_ : ↑x ∈ V), ∃ iVU s, (f.val.app { unop := V }) s = (G.val.map iVU.op) t
t : (forget C).obj (G.val.obj { unop := U })
V : ↥U → Opens ↑X
mV : ∀ (x : ↥U), ↑x ∈ V x
iVU : (x : ↥U) → V x ⟶ U
sf : (x : ↥U) → (forget C).obj (F.val.obj { unop := V x })
heq : ∀ (x : ↥U), (f.val.app { unop := V x }) (sf x) = (G.val.map (iVU x).op) t
V_cover : U ≤ iSup V
x y : ↥U
z : ↥(V x ⊓ V y)
⊢ ((stalkFunctor C ↑z).map f.val) ((F.presheaf.germ z) ((F.val.map ((V x).infLELeft (V y)).op) (sf x))) =
    ((stalkFunctor C ↑z).map f.val) ((F.presheaf.germ z) ((F.val.map ((V x).infLERight (V y)).op) (sf y)))

tactic: erw [stalkFunctor_map_germ_apply, stalkFunctor_map_germ_apply]
state_before: case h.a
C : Type u
inst✝⁶ : Category.{v, u} C
inst✝⁵ : HasColimits C
X Y Z : TopCat
inst✝⁴ : ConcreteCategory C
inst✝³ : PreservesFilteredColimits (forget C)
inst✝² : HasLimits C
inst✝¹ : PreservesLimits (forget C)
inst✝ : (forget C).ReflectsIsomorphisms
F G : Sheaf C X
f : F ⟶ G
U : Opens ↑X
hinj : ∀ (x : ↥U), Function.Injective ⇑((stalkFunctor C ↑x).map f.val)
hsurj :
  ∀ (t : (forget C).obj (G.val.obj { unop := U })) (x : ↥U),
    ∃ V, ∃ (_ : ↑x ∈ V), ∃ iVU s, (f.val.app { unop := V }) s = (G.val.map iVU.op) t
t : (forget C).obj (G.val.obj { unop := U })
V : ↥U → Opens ↑X
mV : ∀ (x : ↥U), ↑x ∈ V x
iVU : (x : ↥U) → V x ⟶ U
sf : (x : ↥U) → (forget C).obj (F.val.obj { unop := V x })
heq : ∀ (x : ↥U), (f.val.app { unop := V x }) (sf x) = (G.val.map (iVU x).op) t
V_cover : U ≤ iSup V
x y : ↥U
z : ↥(V x ⊓ V y)
⊢ ((stalkFunctor C ↑z).map f.val) ((F.presheaf.germ z) ((F.val.map ((V x).infLELeft (V y)).op) (sf x))) =
    ((stalkFunctor C ↑z).map f.val) ((F.presheaf.germ z) ((F.val.map ((V x).infLERight (V y)).op) (sf y)))
state_after: case h.a
C : Type u
inst✝⁶ : Category.{v, u} C
inst✝⁵ : HasColimits C
X Y Z : TopCat
inst✝⁴ : ConcreteCategory C
inst✝³ : PreservesFilteredColimits (forget C)
inst✝² : HasLimits C
inst✝¹ : PreservesLimits (forget C)
inst✝ : (forget C).ReflectsIsomorphisms
F G : Sheaf C X
f : F ⟶ G
U : Opens ↑X
hinj : ∀ (x : ↥U), Function.Injective ⇑((stalkFunctor C ↑x).map f.val)
hsurj :
  ∀ (t : (forget C).obj (G.val.obj { unop := U })) (x : ↥U),
    ∃ V, ∃ (_ : ↑x ∈ V), ∃ iVU s, (f.val.app { unop := V }) s = (G.val.map iVU.op) t
t : (forget C).obj (G.val.obj { unop := U })
V : ↥U → Opens ↑X
mV : ∀ (x : ↥U), ↑x ∈ V x
iVU : (x : ↥U) → V x ⟶ U
sf : (x : ↥U) → (forget C).obj (F.val.obj { unop := V x })
heq : ∀ (x : ↥U), (f.val.app { unop := V x }) (sf x) = (G.val.map (iVU x).op) t
V_cover : U ≤ iSup V
x y : ↥U
z : ↥(V x ⊓ V y)
⊢ (germ G.val z) ((f.val.app { unop := V x ⊓ V y }) ((F.val.map ((V x).infLELeft (V y)).op) (sf x))) =
    (germ G.val z) ((f.val.app { unop := V x ⊓ V y }) ((F.val.map ((V x).infLERight (V y)).op) (sf y)))

tactic: simp_rw [← comp_apply, f.1.naturality, comp_apply, heq, ← comp_apply, ← G.1.map_comp]
state_before: case h.a
C : Type u
inst✝⁶ : Category.{v, u} C
inst✝⁵ : HasColimits C
X Y Z : TopCat
inst✝⁴ : ConcreteCategory C
inst✝³ : PreservesFilteredColimits (forget C)
inst✝² : HasLimits C
inst✝¹ : PreservesLimits (forget C)
inst✝ : (forget C).ReflectsIsomorphisms
F G : Sheaf C X
f : F ⟶ G
U : Opens ↑X
hinj : ∀ (x : ↥U), Function.Injective ⇑((stalkFunctor C ↑x).map f.val)
hsurj :
  ∀ (t : (forget C).obj (G.val.obj { unop := U })) (x : ↥U),
    ∃ V, ∃ (_ : ↑x ∈ V), ∃ iVU s, (f.val.app { unop := V }) s = (G.val.map iVU.op) t
t : (forget C).obj (G.val.obj { unop := U })
V : ↥U → Opens ↑X
mV : ∀ (x : ↥U), ↑x ∈ V x
iVU : (x : ↥U) → V x ⟶ U
sf : (x : ↥U) → (forget C).obj (F.val.obj { unop := V x })
heq : ∀ (x : ↥U), (f.val.app { unop := V x }) (sf x) = (G.val.map (iVU x).op) t
V_cover : U ≤ iSup V
x y : ↥U
z : ↥(V x ⊓ V y)
⊢ (germ G.val z) ((f.val.app { unop := V x ⊓ V y }) ((F.val.map ((V x).infLELeft (V y)).op) (sf x))) =
    (germ G.val z) ((f.val.app { unop := V x ⊓ V y }) ((F.val.map ((V x).infLERight (V y)).op) (sf y)))
state_after: case h.a
C : Type u
inst✝⁶ : Category.{v, u} C
inst✝⁵ : HasColimits C
X Y Z : TopCat
inst✝⁴ : ConcreteCategory C
inst✝³ : PreservesFilteredColimits (forget C)
inst✝² : HasLimits C
inst✝¹ : PreservesLimits (forget C)
inst✝ : (forget C).ReflectsIsomorphisms
F G : Sheaf C X
f : F ⟶ G
U : Opens ↑X
hinj : ∀ (x : ↥U), Function.Injective ⇑((stalkFunctor C ↑x).map f.val)
hsurj :
  ∀ (t : (forget C).obj (G.val.obj { unop := U })) (x : ↥U),
    ∃ V, ∃ (_ : ↑x ∈ V), ∃ iVU s, (f.val.app { unop := V }) s = (G.val.map iVU.op) t
t : (forget C).obj (G.val.obj { unop := U })
V : ↥U → Opens ↑X
mV : ∀ (x : ↥U), ↑x ∈ V x
iVU : (x : ↥U) → V x ⟶ U
sf : (x : ↥U) → (forget C).obj (F.val.obj { unop := V x })
heq : ∀ (x : ↥U), (f.val.app { unop := V x }) (sf x) = (G.val.map (iVU x).op) t
V_cover : U ≤ iSup V
x y : ↥U
z : ↥(V x ⊓ V y)
⊢ (G.val.map ((iVU x).op ≫ ((V x).infLELeft (V y)).op) ≫ germ G.val z) t =
    (G.val.map ((iVU y).op ≫ ((V x).infLERight (V y)).op) ≫ germ G.val z) t

tactic: rfl
state_before: case h.a
C : Type u
inst✝⁶ : Category.{v, u} C
inst✝⁵ : HasColimits C
X Y Z : TopCat
inst✝⁴ : ConcreteCategory C
inst✝³ : PreservesFilteredColimits (forget C)
inst✝² : HasLimits C
inst✝¹ : PreservesLimits (forget C)
inst✝ : (forget C).ReflectsIsomorphisms
F G : Sheaf C X
f : F ⟶ G
U : Opens ↑X
hinj : ∀ (x : ↥U), Function.Injective ⇑((stalkFunctor C ↑x).map f.val)
hsurj :
  ∀ (t : (forget C).obj (G.val.obj { unop := U })) (x : ↥U),
    ∃ V, ∃ (_ : ↑x ∈ V), ∃ iVU s, (f.val.app { unop := V }) s = (G.val.map iVU.op) t
t : (forget C).obj (G.val.obj { unop := U })
V : ↥U → Opens ↑X
mV : ∀ (x : ↥U), ↑x ∈ V x
iVU : (x : ↥U) → V x ⟶ U
sf : (x : ↥U) → (forget C).obj (F.val.obj { unop := V x })
heq : ∀ (x : ↥U), (f.val.app { unop := V x }) (sf x) = (G.val.map (iVU x).op) t
V_cover : U ≤ iSup V
x y : ↥U
z : ↥(V x ⊓ V y)
⊢ (G.val.map ((iVU x).op ≫ ((V x).infLELeft (V y)).op) ≫ germ G.val z) t =
    (G.val.map ((iVU y).op ≫ ((V x).infLERight (V y)).op) ≫ germ G.val z) t
state_after: no goals

tactic: intro x hxU
state_before: C : Type u
inst✝⁶ : Category.{v, u} C
inst✝⁵ : HasColimits C
X Y Z : TopCat
inst✝⁴ : ConcreteCategory C
inst✝³ : PreservesFilteredColimits (forget C)
inst✝² : HasLimits C
inst✝¹ : PreservesLimits (forget C)
inst✝ : (forget C).ReflectsIsomorphisms
F G : Sheaf C X
f : F ⟶ G
U : Opens ↑X
hinj : ∀ (x : ↥U), Function.Injective ⇑((stalkFunctor C ↑x).map f.val)
hsurj :
  ∀ (t : (forget C).obj (G.val.obj { unop := U })) (x : ↥U),
    ∃ V, ∃ (_ : ↑x ∈ V), ∃ iVU s, (f.val.app { unop := V }) s = (G.val.map iVU.op) t
t : (forget C).obj (G.val.obj { unop := U })
V : ↥U → Opens ↑X
mV : ∀ (x : ↥U), ↑x ∈ V x
iVU : (x : ↥U) → V x ⟶ U
sf : (x : ↥U) → (forget C).obj (F.val.obj { unop := V x })
heq : ∀ (x : ↥U), (f.val.app { unop := V x }) (sf x) = (G.val.map (iVU x).op) t
⊢ U ≤ iSup V
state_after: C : Type u
inst✝⁶ : Category.{v, u} C
inst✝⁵ : HasColimits C
X Y Z : TopCat
inst✝⁴ : ConcreteCategory C
inst✝³ : PreservesFilteredColimits (forget C)
inst✝² : HasLimits C
inst✝¹ : PreservesLimits (forget C)
inst✝ : (forget C).ReflectsIsomorphisms
F G : Sheaf C X
f : F ⟶ G
U : Opens ↑X
hinj : ∀ (x : ↥U), Function.Injective ⇑((stalkFunctor C ↑x).map f.val)
hsurj :
  ∀ (t : (forget C).obj (G.val.obj { unop := U })) (x : ↥U),
    ∃ V, ∃ (_ : ↑x ∈ V), ∃ iVU s, (f.val.app { unop := V }) s = (G.val.map iVU.op) t
t : (forget C).obj (G.val.obj { unop := U })
V : ↥U → Opens ↑X
mV : ∀ (x : ↥U), ↑x ∈ V x
iVU : (x : ↥U) → V x ⟶ U
sf : (x : ↥U) → (forget C).obj (F.val.obj { unop := V x })
heq : ∀ (x : ↥U), (f.val.app { unop := V x }) (sf x) = (G.val.map (iVU x).op) t
x : ↑X
hxU : x ∈ ↑U
⊢ x ∈ ↑(iSup V)

tactic: simp only [Opens.coe_iSup, Set.mem_iUnion, SetLike.mem_coe]
state_before: C : Type u
inst✝⁶ : Category.{v, u} C
inst✝⁵ : HasColimits C
X Y Z : TopCat
inst✝⁴ : ConcreteCategory C
inst✝³ : PreservesFilteredColimits (forget C)
inst✝² : HasLimits C
inst✝¹ : PreservesLimits (forget C)
inst✝ : (forget C).ReflectsIsomorphisms
F G : Sheaf C X
f : F ⟶ G
U : Opens ↑X
hinj : ∀ (x : ↥U), Function.Injective ⇑((stalkFunctor C ↑x).map f.val)
hsurj :
  ∀ (t : (forget C).obj (G.val.obj { unop := U })) (x : ↥U),
    ∃ V, ∃ (_ : ↑x ∈ V), ∃ iVU s, (f.val.app { unop := V }) s = (G.val.map iVU.op) t
t : (forget C).obj (G.val.obj { unop := U })
V : ↥U → Opens ↑X
mV : ∀ (x : ↥U), ↑x ∈ V x
iVU : (x : ↥U) → V x ⟶ U
sf : (x : ↥U) → (forget C).obj (F.val.obj { unop := V x })
heq : ∀ (x : ↥U), (f.val.app { unop := V x }) (sf x) = (G.val.map (iVU x).op) t
x : ↑X
hxU : x ∈ ↑U
⊢ x ∈ ↑(iSup V)
state_after: C : Type u
inst✝⁶ : Category.{v, u} C
inst✝⁵ : HasColimits C
X Y Z : TopCat
inst✝⁴ : ConcreteCategory C
inst✝³ : PreservesFilteredColimits (forget C)
inst✝² : HasLimits C
inst✝¹ : PreservesLimits (forget C)
inst✝ : (forget C).ReflectsIsomorphisms
F G : Sheaf C X
f : F ⟶ G
U : Opens ↑X
hinj : ∀ (x : ↥U), Function.Injective ⇑((stalkFunctor C ↑x).map f.val)
hsurj :
  ∀ (t : (forget C).obj (G.val.obj { unop := U })) (x : ↥U),
    ∃ V, ∃ (_ : ↑x ∈ V), ∃ iVU s, (f.val.app { unop := V }) s = (G.val.map iVU.op) t
t : (forget C).obj (G.val.obj { unop := U })
V : ↥U → Opens ↑X
mV : ∀ (x : ↥U), ↑x ∈ V x
iVU : (x : ↥U) → V x ⟶ U
sf : (x : ↥U) → (forget C).obj (F.val.obj { unop := V x })
heq : ∀ (x : ↥U), (f.val.app { unop := V x }) (sf x) = (G.val.map (iVU x).op) t
x : ↑X
hxU : x ∈ ↑U
⊢ ∃ i, x ∈ V i

tactic: exact ⟨⟨x, hxU⟩, mV ⟨x, hxU⟩⟩
state_before: C : Type u
inst✝⁶ : Category.{v, u} C
inst✝⁵ : HasColimits C
X Y Z : TopCat
inst✝⁴ : ConcreteCategory C
inst✝³ : PreservesFilteredColimits (forget C)
inst✝² : HasLimits C
inst✝¹ : PreservesLimits (forget C)
inst✝ : (forget C).ReflectsIsomorphisms
F G : Sheaf C X
f : F ⟶ G
U : Opens ↑X
hinj : ∀ (x : ↥U), Function.Injective ⇑((stalkFunctor C ↑x).map f.val)
hsurj :
  ∀ (t : (forget C).obj (G.val.obj { unop := U })) (x : ↥U),
    ∃ V, ∃ (_ : ↑x ∈ V), ∃ iVU s, (f.val.app { unop := V }) s = (G.val.map iVU.op) t
t : (forget C).obj (G.val.obj { unop := U })
V : ↥U → Opens ↑X
mV : ∀ (x : ↥U), ↑x ∈ V x
iVU : (x : ↥U) → V x ⟶ U
sf : (x : ↥U) → (forget C).obj (F.val.obj { unop := V x })
heq : ∀ (x : ↥U), (f.val.app { unop := V x }) (sf x) = (G.val.map (iVU x).op) t
x : ↑X
hxU : x ∈ ↑U
⊢ ∃ i, x ∈ V i
state_after: no goals

tactic: obtain ⟨s, s_spec, -⟩ := F.existsUnique_gluing' V U iVU V_cover sf this
state_before: C : Type u
inst✝⁶ : Category.{v, u} C
inst✝⁵ : HasColimits C
X Y Z : TopCat
inst✝⁴ : ConcreteCategory C
inst✝³ : PreservesFilteredColimits (forget C)
inst✝² : HasLimits C
inst✝¹ : PreservesLimits (forget C)
inst✝ : (forget C).ReflectsIsomorphisms
F G : Sheaf C X
f : F ⟶ G
U : Opens ↑X
hinj : ∀ (x : ↥U), Function.Injective ⇑((stalkFunctor C ↑x).map f.val)
hsurj :
  ∀ (t : (forget C).obj (G.val.obj { unop := U })) (x : ↥U),
    ∃ V, ∃ (_ : ↑x ∈ V), ∃ iVU s, (f.val.app { unop := V }) s = (G.val.map iVU.op) t
t : (forget C).obj (G.val.obj { unop := U })
V : ↥U → Opens ↑X
mV : ∀ (x : ↥U), ↑x ∈ V x
iVU : (x : ↥U) → V x ⟶ U
sf : (x : ↥U) → (forget C).obj (F.val.obj { unop := V x })
heq : ∀ (x : ↥U), (f.val.app { unop := V x }) (sf x) = (G.val.map (iVU x).op) t
V_cover : U ≤ iSup V
this : IsCompatible F.val V sf
⊢ ∃ a, (f.val.app { unop := U }) a = t
state_after: case intro.intro
C : Type u
inst✝⁶ : Category.{v, u} C
inst✝⁵ : HasColimits C
X Y Z : TopCat
inst✝⁴ : ConcreteCategory C
inst✝³ : PreservesFilteredColimits (forget C)
inst✝² : HasLimits C
inst✝¹ : PreservesLimits (forget C)
inst✝ : (forget C).ReflectsIsomorphisms
F G : Sheaf C X
f : F ⟶ G
U : Opens ↑X
hinj : ∀ (x : ↥U), Function.Injective ⇑((stalkFunctor C ↑x).map f.val)
hsurj :
  ∀ (t : (forget C).obj (G.val.obj { unop := U })) (x : ↥U),
    ∃ V, ∃ (_ : ↑x ∈ V), ∃ iVU s, (f.val.app { unop := V }) s = (G.val.map iVU.op) t
t : (forget C).obj (G.val.obj { unop := U })
V : ↥U → Opens ↑X
mV : ∀ (x : ↥U), ↑x ∈ V x
iVU : (x : ↥U) → V x ⟶ U
sf : (x : ↥U) → (forget C).obj (F.val.obj { unop := V x })
heq : ∀ (x : ↥U), (f.val.app { unop := V x }) (sf x) = (G.val.map (iVU x).op) t
V_cover : U ≤ iSup V
this : IsCompatible F.val V sf
s : (forget C).obj (F.val.obj { unop := U })
s_spec : ∀ (i : ↥U), (F.val.map (iVU i).op) s = sf i
⊢ ∃ a, (f.val.app { unop := U }) a = t

tactic: use s
state_before: case intro.intro
C : Type u
inst✝⁶ : Category.{v, u} C
inst✝⁵ : HasColimits C
X Y Z : TopCat
inst✝⁴ : ConcreteCategory C
inst✝³ : PreservesFilteredColimits (forget C)
inst✝² : HasLimits C
inst✝¹ : PreservesLimits (forget C)
inst✝ : (forget C).ReflectsIsomorphisms
F G : Sheaf C X
f : F ⟶ G
U : Opens ↑X
hinj : ∀ (x : ↥U), Function.Injective ⇑((stalkFunctor C ↑x).map f.val)
hsurj :
  ∀ (t : (forget C).obj (G.val.obj { unop := U })) (x : ↥U),
    ∃ V, ∃ (_ : ↑x ∈ V), ∃ iVU s, (f.val.app { unop := V }) s = (G.val.map iVU.op) t
t : (forget C).obj (G.val.obj { unop := U })
V : ↥U → Opens ↑X
mV : ∀ (x : ↥U), ↑x ∈ V x
iVU : (x : ↥U) → V x ⟶ U
sf : (x : ↥U) → (forget C).obj (F.val.obj { unop := V x })
heq : ∀ (x : ↥U), (f.val.app { unop := V x }) (sf x) = (G.val.map (iVU x).op) t
V_cover : U ≤ iSup V
this : IsCompatible F.val V sf
s : (forget C).obj (F.val.obj { unop := U })
s_spec : ∀ (i : ↥U), (F.val.map (iVU i).op) s = sf i
⊢ ∃ a, (f.val.app { unop := U }) a = t
state_after: case h
C : Type u
inst✝⁶ : Category.{v, u} C
inst✝⁵ : HasColimits C
X Y Z : TopCat
inst✝⁴ : ConcreteCategory C
inst✝³ : PreservesFilteredColimits (forget C)
inst✝² : HasLimits C
inst✝¹ : PreservesLimits (forget C)
inst✝ : (forget C).ReflectsIsomorphisms
F G : Sheaf C X
f : F ⟶ G
U : Opens ↑X
hinj : ∀ (x : ↥U), Function.Injective ⇑((stalkFunctor C ↑x).map f.val)
hsurj :
  ∀ (t : (forget C).obj (G.val.obj { unop := U })) (x : ↥U),
    ∃ V, ∃ (_ : ↑x ∈ V), ∃ iVU s, (f.val.app { unop := V }) s = (G.val.map iVU.op) t
t : (forget C).obj (G.val.obj { unop := U })
V : ↥U → Opens ↑X
mV : ∀ (x : ↥U), ↑x ∈ V x
iVU : (x : ↥U) → V x ⟶ U
sf : (x : ↥U) → (forget C).obj (F.val.obj { unop := V x })
heq : ∀ (x : ↥U), (f.val.app { unop := V x }) (sf x) = (G.val.map (iVU x).op) t
V_cover : U ≤ iSup V
this : IsCompatible F.val V sf
s : (forget C).obj (F.val.obj { unop := U })
s_spec : ∀ (i : ↥U), (F.val.map (iVU i).op) s = sf i
⊢ (f.val.app { unop := U }) s = t

tactic: apply G.eq_of_locally_eq' V U iVU V_cover
state_before: case h
C : Type u
inst✝⁶ : Category.{v, u} C
inst✝⁵ : HasColimits C
X Y Z : TopCat
inst✝⁴ : ConcreteCategory C
inst✝³ : PreservesFilteredColimits (forget C)
inst✝² : HasLimits C
inst✝¹ : PreservesLimits (forget C)
inst✝ : (forget C).ReflectsIsomorphisms
F G : Sheaf C X
f : F ⟶ G
U : Opens ↑X
hinj : ∀ (x : ↥U), Function.Injective ⇑((stalkFunctor C ↑x).map f.val)
hsurj :
  ∀ (t : (forget C).obj (G.val.obj { unop := U })) (x : ↥U),
    ∃ V, ∃ (_ : ↑x ∈ V), ∃ iVU s, (f.val.app { unop := V }) s = (G.val.map iVU.op) t
t : (forget C).obj (G.val.obj { unop := U })
V : ↥U → Opens ↑X
mV : ∀ (x : ↥U), ↑x ∈ V x
iVU : (x : ↥U) → V x ⟶ U
sf : (x : ↥U) → (forget C).obj (F.val.obj { unop := V x })
heq : ∀ (x : ↥U), (f.val.app { unop := V x }) (sf x) = (G.val.map (iVU x).op) t
V_cover : U ≤ iSup V
this : IsCompatible F.val V sf
s : (forget C).obj (F.val.obj { unop := U })
s_spec : ∀ (i : ↥U), (F.val.map (iVU i).op) s = sf i
⊢ (f.val.app { unop := U }) s = t
state_after: case h.h
C : Type u
inst✝⁶ : Category.{v, u} C
inst✝⁵ : HasColimits C
X Y Z : TopCat
inst✝⁴ : ConcreteCategory C
inst✝³ : PreservesFilteredColimits (forget C)
inst✝² : HasLimits C
inst✝¹ : PreservesLimits (forget C)
inst✝ : (forget C).ReflectsIsomorphisms
F G : Sheaf C X
f : F ⟶ G
U : Opens ↑X
hinj : ∀ (x : ↥U), Function.Injective ⇑((stalkFunctor C ↑x).map f.val)
hsurj :
  ∀ (t : (forget C).obj (G.val.obj { unop := U })) (x : ↥U),
    ∃ V, ∃ (_ : ↑x ∈ V), ∃ iVU s, (f.val.app { unop := V }) s = (G.val.map iVU.op) t
t : (forget C).obj (G.val.obj { unop := U })
V : ↥U → Opens ↑X
mV : ∀ (x : ↥U), ↑x ∈ V x
iVU : (x : ↥U) → V x ⟶ U
sf : (x : ↥U) → (forget C).obj (F.val.obj { unop := V x })
heq : ∀ (x : ↥U), (f.val.app { unop := V x }) (sf x) = (G.val.map (iVU x).op) t
V_cover : U ≤ iSup V
this : IsCompatible F.val V sf
s : (forget C).obj (F.val.obj { unop := U })
s_spec : ∀ (i : ↥U), (F.val.map (iVU i).op) s = sf i
⊢ ∀ (i : ↥U), (G.val.map (iVU i).op) ((f.val.app { unop := U }) s) = (G.val.map (iVU i).op) t

tactic: intro x
state_before: case h.h
C : Type u
inst✝⁶ : Category.{v, u} C
inst✝⁵ : HasColimits C
X Y Z : TopCat
inst✝⁴ : ConcreteCategory C
inst✝³ : PreservesFilteredColimits (forget C)
inst✝² : HasLimits C
inst✝¹ : PreservesLimits (forget C)
inst✝ : (forget C).ReflectsIsomorphisms
F G : Sheaf C X
f : F ⟶ G
U : Opens ↑X
hinj : ∀ (x : ↥U), Function.Injective ⇑((stalkFunctor C ↑x).map f.val)
hsurj :
  ∀ (t : (forget C).obj (G.val.obj { unop := U })) (x : ↥U),
    ∃ V, ∃ (_ : ↑x ∈ V), ∃ iVU s, (f.val.app { unop := V }) s = (G.val.map iVU.op) t
t : (forget C).obj (G.val.obj { unop := U })
V : ↥U → Opens ↑X
mV : ∀ (x : ↥U), ↑x ∈ V x
iVU : (x : ↥U) → V x ⟶ U
sf : (x : ↥U) → (forget C).obj (F.val.obj { unop := V x })
heq : ∀ (x : ↥U), (f.val.app { unop := V x }) (sf x) = (G.val.map (iVU x).op) t
V_cover : U ≤ iSup V
this : IsCompatible F.val V sf
s : (forget C).obj (F.val.obj { unop := U })
s_spec : ∀ (i : ↥U), (F.val.map (iVU i).op) s = sf i
⊢ ∀ (i : ↥U), (G.val.map (iVU i).op) ((f.val.app { unop := U }) s) = (G.val.map (iVU i).op) t
state_after: case h.h
C : Type u
inst✝⁶ : Category.{v, u} C
inst✝⁵ : HasColimits C
X Y Z : TopCat
inst✝⁴ : ConcreteCategory C
inst✝³ : PreservesFilteredColimits (forget C)
inst✝² : HasLimits C
inst✝¹ : PreservesLimits (forget C)
inst✝ : (forget C).ReflectsIsomorphisms
F G : Sheaf C X
f : F ⟶ G
U : Opens ↑X
hinj : ∀ (x : ↥U), Function.Injective ⇑((stalkFunctor C ↑x).map f.val)
hsurj :
  ∀ (t : (forget C).obj (G.val.obj { unop := U })) (x : ↥U),
    ∃ V, ∃ (_ : ↑x ∈ V), ∃ iVU s, (f.val.app { unop := V }) s = (G.val.map iVU.op) t
t : (forget C).obj (G.val.obj { unop := U })
V : ↥U → Opens ↑X
mV : ∀ (x : ↥U), ↑x ∈ V x
iVU : (x : ↥U) → V x ⟶ U
sf : (x : ↥U) → (forget C).obj (F.val.obj { unop := V x })
heq : ∀ (x : ↥U), (f.val.app { unop := V x }) (sf x) = (G.val.map (iVU x).op) t
V_cover : U ≤ iSup V
this : IsCompatible F.val V sf
s : (forget C).obj (F.val.obj { unop := U })
s_spec : ∀ (i : ↥U), (F.val.map (iVU i).op) s = sf i
x : ↥U
⊢ (G.val.map (iVU x).op) ((f.val.app { unop := U }) s) = (G.val.map (iVU x).op) t

tactic: rw [← comp_apply, ← f.1.naturality, comp_apply, s_spec, heq]
state_before: case h.h
C : Type u
inst✝⁶ : Category.{v, u} C
inst✝⁵ : HasColimits C
X Y Z : TopCat
inst✝⁴ : ConcreteCategory C
inst✝³ : PreservesFilteredColimits (forget C)
inst✝² : HasLimits C
inst✝¹ : PreservesLimits (forget C)
inst✝ : (forget C).ReflectsIsomorphisms
F G : Sheaf C X
f : F ⟶ G
U : Opens ↑X
hinj : ∀ (x : ↥U), Function.Injective ⇑((stalkFunctor C ↑x).map f.val)
hsurj :
  ∀ (t : (forget C).obj (G.val.obj { unop := U })) (x : ↥U),
    ∃ V, ∃ (_ : ↑x ∈ V), ∃ iVU s, (f.val.app { unop := V }) s = (G.val.map iVU.op) t
t : (forget C).obj (G.val.obj { unop := U })
V : ↥U → Opens ↑X
mV : ∀ (x : ↥U), ↑x ∈ V x
iVU : (x : ↥U) → V x ⟶ U
sf : (x : ↥U) → (forget C).obj (F.val.obj { unop := V x })
heq : ∀ (x : ↥U), (f.val.app { unop := V x }) (sf x) = (G.val.map (iVU x).op) t
V_cover : U ≤ iSup V
this : IsCompatible F.val V sf
s : (forget C).obj (F.val.obj { unop := U })
s_spec : ∀ (i : ↥U), (F.val.map (iVU i).op) s = sf i
x : ↥U
⊢ (G.val.map (iVU x).op) ((f.val.app { unop := U }) s) = (G.val.map (iVU x).op) t
state_after: no goals