Theorem: TopCat.Sheaf.eq_of_locally_eq
File: Mathlib/Topology/Sheaves/SheafCondition/UniqueGluing.lean

tactic: let sf : ∀ i : ι, F.1.obj (op (U i)) := fun i => F.1.map (Opens.leSupr U i).op s
state_before: C : Type u
inst✝⁴ : Category.{v, u} C
inst✝³ : ConcreteCategory C
inst✝² : HasLimits C
inst✝¹ : ConcreteCategory.forget.ReflectsIsomorphisms
inst✝ : PreservesLimits ConcreteCategory.forget
X : TopCat
F : Sheaf C X
ι : Type v
U : ι → Opens ↑X
s t : (CategoryTheory.forget C).obj (F.val.obj { unop := iSup U })
h : ∀ (i : ι), (F.val.map (leSupr U i).op) s = (F.val.map (leSupr U i).op) t
⊢ s = t
state_after: C : Type u
inst✝⁴ : Category.{v, u} C
inst✝³ : ConcreteCategory C
inst✝² : HasLimits C
inst✝¹ : ConcreteCategory.forget.ReflectsIsomorphisms
inst✝ : PreservesLimits ConcreteCategory.forget
X : TopCat
F : Sheaf C X
ι : Type v
U : ι → Opens ↑X
s t : (CategoryTheory.forget C).obj (F.val.obj { unop := iSup U })
h : ∀ (i : ι), (F.val.map (leSupr U i).op) s = (F.val.map (leSupr U i).op) t
sf : (i : ι) → (CategoryTheory.forget C).obj (F.val.obj { unop := U i }) := fun i => (F.val.map (leSupr U i).op) s
⊢ s = t

tactic: have sf_compatible : IsCompatible _ U sf := by
  intro i j
  simp_rw [sf, ← comp_apply, ← F.1.map_comp]
  rfl
state_before: C : Type u
inst✝⁴ : Category.{v, u} C
inst✝³ : ConcreteCategory C
inst✝² : HasLimits C
inst✝¹ : ConcreteCategory.forget.ReflectsIsomorphisms
inst✝ : PreservesLimits ConcreteCategory.forget
X : TopCat
F : Sheaf C X
ι : Type v
U : ι → Opens ↑X
s t : (CategoryTheory.forget C).obj (F.val.obj { unop := iSup U })
h : ∀ (i : ι), (F.val.map (leSupr U i).op) s = (F.val.map (leSupr U i).op) t
sf : (i : ι) → (CategoryTheory.forget C).obj (F.val.obj { unop := U i }) := fun i => (F.val.map (leSupr U i).op) s
⊢ s = t
state_after: C : Type u
inst✝⁴ : Category.{v, u} C
inst✝³ : ConcreteCategory C
inst✝² : HasLimits C
inst✝¹ : ConcreteCategory.forget.ReflectsIsomorphisms
inst✝ : PreservesLimits ConcreteCategory.forget
X : TopCat
F : Sheaf C X
ι : Type v
U : ι → Opens ↑X
s t : (CategoryTheory.forget C).obj (F.val.obj { unop := iSup U })
h : ∀ (i : ι), (F.val.map (leSupr U i).op) s = (F.val.map (leSupr U i).op) t
sf : (i : ι) → (CategoryTheory.forget C).obj (F.val.obj { unop := U i }) := fun i => (F.val.map (leSupr U i).op) s
sf_compatible : IsCompatible F.val U sf
⊢ s = t

tactic: obtain ⟨gl, -, gl_uniq⟩ := F.existsUnique_gluing U sf sf_compatible
state_before: C : Type u
inst✝⁴ : Category.{v, u} C
inst✝³ : ConcreteCategory C
inst✝² : HasLimits C
inst✝¹ : ConcreteCategory.forget.ReflectsIsomorphisms
inst✝ : PreservesLimits ConcreteCategory.forget
X : TopCat
F : Sheaf C X
ι : Type v
U : ι → Opens ↑X
s t : (CategoryTheory.forget C).obj (F.val.obj { unop := iSup U })
h : ∀ (i : ι), (F.val.map (leSupr U i).op) s = (F.val.map (leSupr U i).op) t
sf : (i : ι) → (CategoryTheory.forget C).obj (F.val.obj { unop := U i }) := fun i => (F.val.map (leSupr U i).op) s
sf_compatible : IsCompatible F.val U sf
⊢ s = t
state_after: case intro.intro
C : Type u
inst✝⁴ : Category.{v, u} C
inst✝³ : ConcreteCategory C
inst✝² : HasLimits C
inst✝¹ : ConcreteCategory.forget.ReflectsIsomorphisms
inst✝ : PreservesLimits ConcreteCategory.forget
X : TopCat
F : Sheaf C X
ι : Type v
U : ι → Opens ↑X
s t : (CategoryTheory.forget C).obj (F.val.obj { unop := iSup U })
h : ∀ (i : ι), (F.val.map (leSupr U i).op) s = (F.val.map (leSupr U i).op) t
sf : (i : ι) → (CategoryTheory.forget C).obj (F.val.obj { unop := U i }) := fun i => (F.val.map (leSupr U i).op) s
sf_compatible : IsCompatible F.val U sf
gl : (CategoryTheory.forget C).obj (F.val.obj { unop := iSup U })
gl_uniq :
  ∀ (y : (CategoryTheory.forget C).obj (F.val.obj { unop := iSup U })), (fun s => IsGluing F.val U sf s) y → y = gl
⊢ s = t

tactic: trans gl
state_before: case intro.intro
C : Type u
inst✝⁴ : Category.{v, u} C
inst✝³ : ConcreteCategory C
inst✝² : HasLimits C
inst✝¹ : ConcreteCategory.forget.ReflectsIsomorphisms
inst✝ : PreservesLimits ConcreteCategory.forget
X : TopCat
F : Sheaf C X
ι : Type v
U : ι → Opens ↑X
s t : (CategoryTheory.forget C).obj (F.val.obj { unop := iSup U })
h : ∀ (i : ι), (F.val.map (leSupr U i).op) s = (F.val.map (leSupr U i).op) t
sf : (i : ι) → (CategoryTheory.forget C).obj (F.val.obj { unop := U i }) := fun i => (F.val.map (leSupr U i).op) s
sf_compatible : IsCompatible F.val U sf
gl : (CategoryTheory.forget C).obj (F.val.obj { unop := iSup U })
gl_uniq :
  ∀ (y : (CategoryTheory.forget C).obj (F.val.obj { unop := iSup U })), (fun s => IsGluing F.val U sf s) y → y = gl
⊢ s = t
state_after: C : Type u
inst✝⁴ : Category.{v, u} C
inst✝³ : ConcreteCategory C
inst✝² : HasLimits C
inst✝¹ : ConcreteCategory.forget.ReflectsIsomorphisms
inst✝ : PreservesLimits ConcreteCategory.forget
X : TopCat
F : Sheaf C X
ι : Type v
U : ι → Opens ↑X
s t : (CategoryTheory.forget C).obj (F.val.obj { unop := iSup U })
h : ∀ (i : ι), (F.val.map (leSupr U i).op) s = (F.val.map (leSupr U i).op) t
sf : (i : ι) → (CategoryTheory.forget C).obj (F.val.obj { unop := U i }) := fun i => (F.val.map (leSupr U i).op) s
sf_compatible : IsCompatible F.val U sf
gl : (CategoryTheory.forget C).obj (F.val.obj { unop := iSup U })
gl_uniq :
  ∀ (y : (CategoryTheory.forget C).obj (F.val.obj { unop := iSup U })), (fun s => IsGluing F.val U sf s) y → y = gl
⊢ s = gl

C : Type u
inst✝⁴ : Category.{v, u} C
inst✝³ : ConcreteCategory C
inst✝² : HasLimits C
inst✝¹ : ConcreteCategory.forget.ReflectsIsomorphisms
inst✝ : PreservesLimits ConcreteCategory.forget
X : TopCat
F : Sheaf C X
ι : Type v
U : ι → Opens ↑X
s t : (CategoryTheory.forget C).obj (F.val.obj { unop := iSup U })
h : ∀ (i : ι), (F.val.map (leSupr U i).op) s = (F.val.map (leSupr U i).op) t
sf : (i : ι) → (CategoryTheory.forget C).obj (F.val.obj { unop := U i }) := fun i => (F.val.map (leSupr U i).op) s
sf_compatible : IsCompatible F.val U sf
gl : (CategoryTheory.forget C).obj (F.val.obj { unop := iSup U })
gl_uniq :
  ∀ (y : (CategoryTheory.forget C).obj (F.val.obj { unop := iSup U })), (fun s => IsGluing F.val U sf s) y → y = gl
⊢ gl = t

tactic: intro i j
state_before: C : Type u
inst✝⁴ : Category.{v, u} C
inst✝³ : ConcreteCategory C
inst✝² : HasLimits C
inst✝¹ : ConcreteCategory.forget.ReflectsIsomorphisms
inst✝ : PreservesLimits ConcreteCategory.forget
X : TopCat
F : Sheaf C X
ι : Type v
U : ι → Opens ↑X
s t : (CategoryTheory.forget C).obj (F.val.obj { unop := iSup U })
h : ∀ (i : ι), (F.val.map (leSupr U i).op) s = (F.val.map (leSupr U i).op) t
sf : (i : ι) → (CategoryTheory.forget C).obj (F.val.obj { unop := U i }) := fun i => (F.val.map (leSupr U i).op) s
⊢ IsCompatible F.val U sf
state_after: C : Type u
inst✝⁴ : Category.{v, u} C
inst✝³ : ConcreteCategory C
inst✝² : HasLimits C
inst✝¹ : ConcreteCategory.forget.ReflectsIsomorphisms
inst✝ : PreservesLimits ConcreteCategory.forget
X : TopCat
F : Sheaf C X
ι : Type v
U : ι → Opens ↑X
s t : (CategoryTheory.forget C).obj (F.val.obj { unop := iSup U })
h : ∀ (i : ι), (F.val.map (leSupr U i).op) s = (F.val.map (leSupr U i).op) t
sf : (i : ι) → (CategoryTheory.forget C).obj (F.val.obj { unop := U i }) := fun i => (F.val.map (leSupr U i).op) s
i j : ι
⊢ (F.val.map ((U i).infLELeft (U j)).op) (sf i) = (F.val.map ((U i).infLERight (U j)).op) (sf j)

tactic: simp_rw [sf, ← comp_apply, ← F.1.map_comp]
state_before: C : Type u
inst✝⁴ : Category.{v, u} C
inst✝³ : ConcreteCategory C
inst✝² : HasLimits C
inst✝¹ : ConcreteCategory.forget.ReflectsIsomorphisms
inst✝ : PreservesLimits ConcreteCategory.forget
X : TopCat
F : Sheaf C X
ι : Type v
U : ι → Opens ↑X
s t : (CategoryTheory.forget C).obj (F.val.obj { unop := iSup U })
h : ∀ (i : ι), (F.val.map (leSupr U i).op) s = (F.val.map (leSupr U i).op) t
sf : (i : ι) → (CategoryTheory.forget C).obj (F.val.obj { unop := U i }) := fun i => (F.val.map (leSupr U i).op) s
i j : ι
⊢ (F.val.map ((U i).infLELeft (U j)).op) (sf i) = (F.val.map ((U i).infLERight (U j)).op) (sf j)
state_after: C : Type u
inst✝⁴ : Category.{v, u} C
inst✝³ : ConcreteCategory C
inst✝² : HasLimits C
inst✝¹ : ConcreteCategory.forget.ReflectsIsomorphisms
inst✝ : PreservesLimits ConcreteCategory.forget
X : TopCat
F : Sheaf C X
ι : Type v
U : ι → Opens ↑X
s t : (CategoryTheory.forget C).obj (F.val.obj { unop := iSup U })
h : ∀ (i : ι), (F.val.map (leSupr U i).op) s = (F.val.map (leSupr U i).op) t
sf : (i : ι) → (CategoryTheory.forget C).obj (F.val.obj { unop := U i }) := fun i => (F.val.map (leSupr U i).op) s
i j : ι
⊢ (F.val.map ((leSupr U i).op ≫ ((U i).infLELeft (U j)).op)) s =
    (F.val.map ((leSupr U j).op ≫ ((U i).infLERight (U j)).op)) s

tactic: rfl
state_before: C : Type u
inst✝⁴ : Category.{v, u} C
inst✝³ : ConcreteCategory C
inst✝² : HasLimits C
inst✝¹ : ConcreteCategory.forget.ReflectsIsomorphisms
inst✝ : PreservesLimits ConcreteCategory.forget
X : TopCat
F : Sheaf C X
ι : Type v
U : ι → Opens ↑X
s t : (CategoryTheory.forget C).obj (F.val.obj { unop := iSup U })
h : ∀ (i : ι), (F.val.map (leSupr U i).op) s = (F.val.map (leSupr U i).op) t
sf : (i : ι) → (CategoryTheory.forget C).obj (F.val.obj { unop := U i }) := fun i => (F.val.map (leSupr U i).op) s
i j : ι
⊢ (F.val.map ((leSupr U i).op ≫ ((U i).infLELeft (U j)).op)) s =
    (F.val.map ((leSupr U j).op ≫ ((U i).infLERight (U j)).op)) s
state_after: no goals

tactic: apply gl_uniq
state_before: C : Type u
inst✝⁴ : Category.{v, u} C
inst✝³ : ConcreteCategory C
inst✝² : HasLimits C
inst✝¹ : ConcreteCategory.forget.ReflectsIsomorphisms
inst✝ : PreservesLimits ConcreteCategory.forget
X : TopCat
F : Sheaf C X
ι : Type v
U : ι → Opens ↑X
s t : (CategoryTheory.forget C).obj (F.val.obj { unop := iSup U })
h : ∀ (i : ι), (F.val.map (leSupr U i).op) s = (F.val.map (leSupr U i).op) t
sf : (i : ι) → (CategoryTheory.forget C).obj (F.val.obj { unop := U i }) := fun i => (F.val.map (leSupr U i).op) s
sf_compatible : IsCompatible F.val U sf
gl : (CategoryTheory.forget C).obj (F.val.obj { unop := iSup U })
gl_uniq :
  ∀ (y : (CategoryTheory.forget C).obj (F.val.obj { unop := iSup U })), (fun s => IsGluing F.val U sf s) y → y = gl
⊢ s = gl
state_after: case a
C : Type u
inst✝⁴ : Category.{v, u} C
inst✝³ : ConcreteCategory C
inst✝² : HasLimits C
inst✝¹ : ConcreteCategory.forget.ReflectsIsomorphisms
inst✝ : PreservesLimits ConcreteCategory.forget
X : TopCat
F : Sheaf C X
ι : Type v
U : ι → Opens ↑X
s t : (CategoryTheory.forget C).obj (F.val.obj { unop := iSup U })
h : ∀ (i : ι), (F.val.map (leSupr U i).op) s = (F.val.map (leSupr U i).op) t
sf : (i : ι) → (CategoryTheory.forget C).obj (F.val.obj { unop := U i }) := fun i => (F.val.map (leSupr U i).op) s
sf_compatible : IsCompatible F.val U sf
gl : (CategoryTheory.forget C).obj (F.val.obj { unop := iSup U })
gl_uniq :
  ∀ (y : (CategoryTheory.forget C).obj (F.val.obj { unop := iSup U })), (fun s => IsGluing F.val U sf s) y → y = gl
⊢ IsGluing F.val U sf s

tactic: intro i
state_before: case a
C : Type u
inst✝⁴ : Category.{v, u} C
inst✝³ : ConcreteCategory C
inst✝² : HasLimits C
inst✝¹ : ConcreteCategory.forget.ReflectsIsomorphisms
inst✝ : PreservesLimits ConcreteCategory.forget
X : TopCat
F : Sheaf C X
ι : Type v
U : ι → Opens ↑X
s t : (CategoryTheory.forget C).obj (F.val.obj { unop := iSup U })
h : ∀ (i : ι), (F.val.map (leSupr U i).op) s = (F.val.map (leSupr U i).op) t
sf : (i : ι) → (CategoryTheory.forget C).obj (F.val.obj { unop := U i }) := fun i => (F.val.map (leSupr U i).op) s
sf_compatible : IsCompatible F.val U sf
gl : (CategoryTheory.forget C).obj (F.val.obj { unop := iSup U })
gl_uniq :
  ∀ (y : (CategoryTheory.forget C).obj (F.val.obj { unop := iSup U })), (fun s => IsGluing F.val U sf s) y → y = gl
⊢ IsGluing F.val U sf s
state_after: case a
C : Type u
inst✝⁴ : Category.{v, u} C
inst✝³ : ConcreteCategory C
inst✝² : HasLimits C
inst✝¹ : ConcreteCategory.forget.ReflectsIsomorphisms
inst✝ : PreservesLimits ConcreteCategory.forget
X : TopCat
F : Sheaf C X
ι : Type v
U : ι → Opens ↑X
s t : (CategoryTheory.forget C).obj (F.val.obj { unop := iSup U })
h : ∀ (i : ι), (F.val.map (leSupr U i).op) s = (F.val.map (leSupr U i).op) t
sf : (i : ι) → (CategoryTheory.forget C).obj (F.val.obj { unop := U i }) := fun i => (F.val.map (leSupr U i).op) s
sf_compatible : IsCompatible F.val U sf
gl : (CategoryTheory.forget C).obj (F.val.obj { unop := iSup U })
gl_uniq :
  ∀ (y : (CategoryTheory.forget C).obj (F.val.obj { unop := iSup U })), (fun s => IsGluing F.val U sf s) y → y = gl
i : ι
⊢ (F.val.map (leSupr U i).op) s = sf i

tactic: rfl
state_before: case a
C : Type u
inst✝⁴ : Category.{v, u} C
inst✝³ : ConcreteCategory C
inst✝² : HasLimits C
inst✝¹ : ConcreteCategory.forget.ReflectsIsomorphisms
inst✝ : PreservesLimits ConcreteCategory.forget
X : TopCat
F : Sheaf C X
ι : Type v
U : ι → Opens ↑X
s t : (CategoryTheory.forget C).obj (F.val.obj { unop := iSup U })
h : ∀ (i : ι), (F.val.map (leSupr U i).op) s = (F.val.map (leSupr U i).op) t
sf : (i : ι) → (CategoryTheory.forget C).obj (F.val.obj { unop := U i }) := fun i => (F.val.map (leSupr U i).op) s
sf_compatible : IsCompatible F.val U sf
gl : (CategoryTheory.forget C).obj (F.val.obj { unop := iSup U })
gl_uniq :
  ∀ (y : (CategoryTheory.forget C).obj (F.val.obj { unop := iSup U })), (fun s => IsGluing F.val U sf s) y → y = gl
i : ι
⊢ (F.val.map (leSupr U i).op) s = sf i
state_after: no goals

tactic: symm
state_before: C : Type u
inst✝⁴ : Category.{v, u} C
inst✝³ : ConcreteCategory C
inst✝² : HasLimits C
inst✝¹ : ConcreteCategory.forget.ReflectsIsomorphisms
inst✝ : PreservesLimits ConcreteCategory.forget
X : TopCat
F : Sheaf C X
ι : Type v
U : ι → Opens ↑X
s t : (CategoryTheory.forget C).obj (F.val.obj { unop := iSup U })
h : ∀ (i : ι), (F.val.map (leSupr U i).op) s = (F.val.map (leSupr U i).op) t
sf : (i : ι) → (CategoryTheory.forget C).obj (F.val.obj { unop := U i }) := fun i => (F.val.map (leSupr U i).op) s
sf_compatible : IsCompatible F.val U sf
gl : (CategoryTheory.forget C).obj (F.val.obj { unop := iSup U })
gl_uniq :
  ∀ (y : (CategoryTheory.forget C).obj (F.val.obj { unop := iSup U })), (fun s => IsGluing F.val U sf s) y → y = gl
⊢ gl = t
state_after: C : Type u
inst✝⁴ : Category.{v, u} C
inst✝³ : ConcreteCategory C
inst✝² : HasLimits C
inst✝¹ : ConcreteCategory.forget.ReflectsIsomorphisms
inst✝ : PreservesLimits ConcreteCategory.forget
X : TopCat
F : Sheaf C X
ι : Type v
U : ι → Opens ↑X
s t : (CategoryTheory.forget C).obj (F.val.obj { unop := iSup U })
h : ∀ (i : ι), (F.val.map (leSupr U i).op) s = (F.val.map (leSupr U i).op) t
sf : (i : ι) → (CategoryTheory.forget C).obj (F.val.obj { unop := U i }) := fun i => (F.val.map (leSupr U i).op) s
sf_compatible : IsCompatible F.val U sf
gl : (CategoryTheory.forget C).obj (F.val.obj { unop := iSup U })
gl_uniq :
  ∀ (y : (CategoryTheory.forget C).obj (F.val.obj { unop := iSup U })), (fun s => IsGluing F.val U sf s) y → y = gl
⊢ t = gl

tactic: apply gl_uniq
state_before: C : Type u
inst✝⁴ : Category.{v, u} C
inst✝³ : ConcreteCategory C
inst✝² : HasLimits C
inst✝¹ : ConcreteCategory.forget.ReflectsIsomorphisms
inst✝ : PreservesLimits ConcreteCategory.forget
X : TopCat
F : Sheaf C X
ι : Type v
U : ι → Opens ↑X
s t : (CategoryTheory.forget C).obj (F.val.obj { unop := iSup U })
h : ∀ (i : ι), (F.val.map (leSupr U i).op) s = (F.val.map (leSupr U i).op) t
sf : (i : ι) → (CategoryTheory.forget C).obj (F.val.obj { unop := U i }) := fun i => (F.val.map (leSupr U i).op) s
sf_compatible : IsCompatible F.val U sf
gl : (CategoryTheory.forget C).obj (F.val.obj { unop := iSup U })
gl_uniq :
  ∀ (y : (CategoryTheory.forget C).obj (F.val.obj { unop := iSup U })), (fun s => IsGluing F.val U sf s) y → y = gl
⊢ t = gl
state_after: case a
C : Type u
inst✝⁴ : Category.{v, u} C
inst✝³ : ConcreteCategory C
inst✝² : HasLimits C
inst✝¹ : ConcreteCategory.forget.ReflectsIsomorphisms
inst✝ : PreservesLimits ConcreteCategory.forget
X : TopCat
F : Sheaf C X
ι : Type v
U : ι → Opens ↑X
s t : (CategoryTheory.forget C).obj (F.val.obj { unop := iSup U })
h : ∀ (i : ι), (F.val.map (leSupr U i).op) s = (F.val.map (leSupr U i).op) t
sf : (i : ι) → (CategoryTheory.forget C).obj (F.val.obj { unop := U i }) := fun i => (F.val.map (leSupr U i).op) s
sf_compatible : IsCompatible F.val U sf
gl : (CategoryTheory.forget C).obj (F.val.obj { unop := iSup U })
gl_uniq :
  ∀ (y : (CategoryTheory.forget C).obj (F.val.obj { unop := iSup U })), (fun s => IsGluing F.val U sf s) y → y = gl
⊢ IsGluing F.val U sf t

tactic: intro i
state_before: case a
C : Type u
inst✝⁴ : Category.{v, u} C
inst✝³ : ConcreteCategory C
inst✝² : HasLimits C
inst✝¹ : ConcreteCategory.forget.ReflectsIsomorphisms
inst✝ : PreservesLimits ConcreteCategory.forget
X : TopCat
F : Sheaf C X
ι : Type v
U : ι → Opens ↑X
s t : (CategoryTheory.forget C).obj (F.val.obj { unop := iSup U })
h : ∀ (i : ι), (F.val.map (leSupr U i).op) s = (F.val.map (leSupr U i).op) t
sf : (i : ι) → (CategoryTheory.forget C).obj (F.val.obj { unop := U i }) := fun i => (F.val.map (leSupr U i).op) s
sf_compatible : IsCompatible F.val U sf
gl : (CategoryTheory.forget C).obj (F.val.obj { unop := iSup U })
gl_uniq :
  ∀ (y : (CategoryTheory.forget C).obj (F.val.obj { unop := iSup U })), (fun s => IsGluing F.val U sf s) y → y = gl
⊢ IsGluing F.val U sf t
state_after: case a
C : Type u
inst✝⁴ : Category.{v, u} C
inst✝³ : ConcreteCategory C
inst✝² : HasLimits C
inst✝¹ : ConcreteCategory.forget.ReflectsIsomorphisms
inst✝ : PreservesLimits ConcreteCategory.forget
X : TopCat
F : Sheaf C X
ι : Type v
U : ι → Opens ↑X
s t : (CategoryTheory.forget C).obj (F.val.obj { unop := iSup U })
h : ∀ (i : ι), (F.val.map (leSupr U i).op) s = (F.val.map (leSupr U i).op) t
sf : (i : ι) → (CategoryTheory.forget C).obj (F.val.obj { unop := U i }) := fun i => (F.val.map (leSupr U i).op) s
sf_compatible : IsCompatible F.val U sf
gl : (CategoryTheory.forget C).obj (F.val.obj { unop := iSup U })
gl_uniq :
  ∀ (y : (CategoryTheory.forget C).obj (F.val.obj { unop := iSup U })), (fun s => IsGluing F.val U sf s) y → y = gl
i : ι
⊢ (F.val.map (leSupr U i).op) t = sf i

tactic: rw [← h]
state_before: case a
C : Type u
inst✝⁴ : Category.{v, u} C
inst✝³ : ConcreteCategory C
inst✝² : HasLimits C
inst✝¹ : ConcreteCategory.forget.ReflectsIsomorphisms
inst✝ : PreservesLimits ConcreteCategory.forget
X : TopCat
F : Sheaf C X
ι : Type v
U : ι → Opens ↑X
s t : (CategoryTheory.forget C).obj (F.val.obj { unop := iSup U })
h : ∀ (i : ι), (F.val.map (leSupr U i).op) s = (F.val.map (leSupr U i).op) t
sf : (i : ι) → (CategoryTheory.forget C).obj (F.val.obj { unop := U i }) := fun i => (F.val.map (leSupr U i).op) s
sf_compatible : IsCompatible F.val U sf
gl : (CategoryTheory.forget C).obj (F.val.obj { unop := iSup U })
gl_uniq :
  ∀ (y : (CategoryTheory.forget C).obj (F.val.obj { unop := iSup U })), (fun s => IsGluing F.val U sf s) y → y = gl
i : ι
⊢ (F.val.map (leSupr U i).op) t = sf i
state_after: no goals