Theorem: TopCat.subpresheafToTypes.isSheaf
File: Mathlib/Topology/Sheaves/LocalPredicate.lean

tactic: let sf' : ∀ i : ι, (presheafToTypes X T).obj (op (U i)) := fun i => (sf i).val
state_before: X : TopCat
T : ↑X → Type v
P✝ : PrelocalPredicate T
P : LocalPredicate T
ι : Type v
U : ι → Opens ↑X
sf : (i : ι) → (forget (Type v)).obj ((subpresheafToTypes P.toPrelocalPredicate).obj { unop := U i })
sf_comp : (subpresheafToTypes P.toPrelocalPredicate).IsCompatible U sf
⊢ ∃! s, (subpresheafToTypes P.toPrelocalPredicate).IsGluing U sf s
state_after: X : TopCat
T : ↑X → Type v
P✝ : PrelocalPredicate T
P : LocalPredicate T
ι : Type v
U : ι → Opens ↑X
sf : (i : ι) → (forget (Type v)).obj ((subpresheafToTypes P.toPrelocalPredicate).obj { unop := U i })
sf_comp : (subpresheafToTypes P.toPrelocalPredicate).IsCompatible U sf
sf' : (i : ι) → (X.presheafToTypes T).obj { unop := U i } := fun i => ↑(sf i)
⊢ ∃! s, (subpresheafToTypes P.toPrelocalPredicate).IsGluing U sf s

tactic: have sf'_comp : (presheafToTypes X T).IsCompatible U sf' := fun i j =>
  congr_arg Subtype.val (sf_comp i j)
state_before: X : TopCat
T : ↑X → Type v
P✝ : PrelocalPredicate T
P : LocalPredicate T
ι : Type v
U : ι → Opens ↑X
sf : (i : ι) → (forget (Type v)).obj ((subpresheafToTypes P.toPrelocalPredicate).obj { unop := U i })
sf_comp : (subpresheafToTypes P.toPrelocalPredicate).IsCompatible U sf
sf' : (i : ι) → (X.presheafToTypes T).obj { unop := U i } := fun i => ↑(sf i)
⊢ ∃! s, (subpresheafToTypes P.toPrelocalPredicate).IsGluing U sf s
state_after: X : TopCat
T : ↑X → Type v
P✝ : PrelocalPredicate T
P : LocalPredicate T
ι : Type v
U : ι → Opens ↑X
sf : (i : ι) → (forget (Type v)).obj ((subpresheafToTypes P.toPrelocalPredicate).obj { unop := U i })
sf_comp : (subpresheafToTypes P.toPrelocalPredicate).IsCompatible U sf
sf' : (i : ι) → (X.presheafToTypes T).obj { unop := U i } := fun i => ↑(sf i)
sf'_comp : (X.presheafToTypes T).IsCompatible U sf'
⊢ ∃! s, (subpresheafToTypes P.toPrelocalPredicate).IsGluing U sf s

tactic: obtain ⟨gl, gl_spec, gl_uniq⟩ := (sheafToTypes X T).existsUnique_gluing U sf' sf'_comp
state_before: X : TopCat
T : ↑X → Type v
P✝ : PrelocalPredicate T
P : LocalPredicate T
ι : Type v
U : ι → Opens ↑X
sf : (i : ι) → (forget (Type v)).obj ((subpresheafToTypes P.toPrelocalPredicate).obj { unop := U i })
sf_comp : (subpresheafToTypes P.toPrelocalPredicate).IsCompatible U sf
sf' : (i : ι) → (X.presheafToTypes T).obj { unop := U i } := fun i => ↑(sf i)
sf'_comp : (X.presheafToTypes T).IsCompatible U sf'
⊢ ∃! s, (subpresheafToTypes P.toPrelocalPredicate).IsGluing U sf s
state_after: case intro.intro
X : TopCat
T : ↑X → Type v
P✝ : PrelocalPredicate T
P : LocalPredicate T
ι : Type v
U : ι → Opens ↑X
sf : (i : ι) → (forget (Type v)).obj ((subpresheafToTypes P.toPrelocalPredicate).obj { unop := U i })
sf_comp : (subpresheafToTypes P.toPrelocalPredicate).IsCompatible U sf
sf' : (i : ι) → (X.presheafToTypes T).obj { unop := U i } := fun i => ↑(sf i)
sf'_comp : (X.presheafToTypes T).IsCompatible U sf'
gl : (forget (Type v)).obj ((X.sheafToTypes T).val.obj { unop := iSup U })
gl_spec : IsGluing (X.sheafToTypes T).val U sf' gl
gl_uniq :
  ∀ (y : (forget (Type v)).obj ((X.sheafToTypes T).val.obj { unop := iSup U })),
    (fun s => IsGluing (X.sheafToTypes T).val U sf' s) y → y = gl
⊢ ∃! s, (subpresheafToTypes P.toPrelocalPredicate).IsGluing U sf s

tactic: refine ⟨⟨gl, ?_⟩, ?_, ?_⟩
state_before: case intro.intro
X : TopCat
T : ↑X → Type v
P✝ : PrelocalPredicate T
P : LocalPredicate T
ι : Type v
U : ι → Opens ↑X
sf : (i : ι) → (forget (Type v)).obj ((subpresheafToTypes P.toPrelocalPredicate).obj { unop := U i })
sf_comp : (subpresheafToTypes P.toPrelocalPredicate).IsCompatible U sf
sf' : (i : ι) → (X.presheafToTypes T).obj { unop := U i } := fun i => ↑(sf i)
sf'_comp : (X.presheafToTypes T).IsCompatible U sf'
gl : (forget (Type v)).obj ((X.sheafToTypes T).val.obj { unop := iSup U })
gl_spec : IsGluing (X.sheafToTypes T).val U sf' gl
gl_uniq :
  ∀ (y : (forget (Type v)).obj ((X.sheafToTypes T).val.obj { unop := iSup U })),
    (fun s => IsGluing (X.sheafToTypes T).val U sf' s) y → y = gl
⊢ ∃! s, (subpresheafToTypes P.toPrelocalPredicate).IsGluing U sf s
state_after: case intro.intro.refine_1
X : TopCat
T : ↑X → Type v
P✝ : PrelocalPredicate T
P : LocalPredicate T
ι : Type v
U : ι → Opens ↑X
sf : (i : ι) → (forget (Type v)).obj ((subpresheafToTypes P.toPrelocalPredicate).obj { unop := U i })
sf_comp : (subpresheafToTypes P.toPrelocalPredicate).IsCompatible U sf
sf' : (i : ι) → (X.presheafToTypes T).obj { unop := U i } := fun i => ↑(sf i)
sf'_comp : (X.presheafToTypes T).IsCompatible U sf'
gl : (forget (Type v)).obj ((X.sheafToTypes T).val.obj { unop := iSup U })
gl_spec : IsGluing (X.sheafToTypes T).val U sf' gl
gl_uniq :
  ∀ (y : (forget (Type v)).obj ((X.sheafToTypes T).val.obj { unop := iSup U })),
    (fun s => IsGluing (X.sheafToTypes T).val U sf' s) y → y = gl
⊢ P.pred gl

case intro.intro.refine_2
X : TopCat
T : ↑X → Type v
P✝ : PrelocalPredicate T
P : LocalPredicate T
ι : Type v
U : ι → Opens ↑X
sf : (i : ι) → (forget (Type v)).obj ((subpresheafToTypes P.toPrelocalPredicate).obj { unop := U i })
sf_comp : (subpresheafToTypes P.toPrelocalPredicate).IsCompatible U sf
sf' : (i : ι) → (X.presheafToTypes T).obj { unop := U i } := fun i => ↑(sf i)
sf'_comp : (X.presheafToTypes T).IsCompatible U sf'
gl : (forget (Type v)).obj ((X.sheafToTypes T).val.obj { unop := iSup U })
gl_spec : IsGluing (X.sheafToTypes T).val U sf' gl
gl_uniq :
  ∀ (y : (forget (Type v)).obj ((X.sheafToTypes T).val.obj { unop := iSup U })),
    (fun s => IsGluing (X.sheafToTypes T).val U sf' s) y → y = gl
⊢ (fun s => (subpresheafToTypes P.toPrelocalPredicate).IsGluing U sf s) ⟨gl, ?intro.intro.refine_1⟩

case intro.intro.refine_3
X : TopCat
T : ↑X → Type v
P✝ : PrelocalPredicate T
P : LocalPredicate T
ι : Type v
U : ι → Opens ↑X
sf : (i : ι) → (forget (Type v)).obj ((subpresheafToTypes P.toPrelocalPredicate).obj { unop := U i })
sf_comp : (subpresheafToTypes P.toPrelocalPredicate).IsCompatible U sf
sf' : (i : ι) → (X.presheafToTypes T).obj { unop := U i } := fun i => ↑(sf i)
sf'_comp : (X.presheafToTypes T).IsCompatible U sf'
gl : (forget (Type v)).obj ((X.sheafToTypes T).val.obj { unop := iSup U })
gl_spec : IsGluing (X.sheafToTypes T).val U sf' gl
gl_uniq :
  ∀ (y : (forget (Type v)).obj ((X.sheafToTypes T).val.obj { unop := iSup U })),
    (fun s => IsGluing (X.sheafToTypes T).val U sf' s) y → y = gl
⊢ ∀ (y : (forget (Type v)).obj ((subpresheafToTypes P.toPrelocalPredicate).obj { unop := iSup U })),
    (fun s => (subpresheafToTypes P.toPrelocalPredicate).IsGluing U sf s) y → y = ⟨gl, ?intro.intro.refine_1⟩

tactic: apply P.locality
state_before: case intro.intro.refine_1
X : TopCat
T : ↑X → Type v
P✝ : PrelocalPredicate T
P : LocalPredicate T
ι : Type v
U : ι → Opens ↑X
sf : (i : ι) → (forget (Type v)).obj ((subpresheafToTypes P.toPrelocalPredicate).obj { unop := U i })
sf_comp : (subpresheafToTypes P.toPrelocalPredicate).IsCompatible U sf
sf' : (i : ι) → (X.presheafToTypes T).obj { unop := U i } := fun i => ↑(sf i)
sf'_comp : (X.presheafToTypes T).IsCompatible U sf'
gl : (forget (Type v)).obj ((X.sheafToTypes T).val.obj { unop := iSup U })
gl_spec : IsGluing (X.sheafToTypes T).val U sf' gl
gl_uniq :
  ∀ (y : (forget (Type v)).obj ((X.sheafToTypes T).val.obj { unop := iSup U })),
    (fun s => IsGluing (X.sheafToTypes T).val U sf' s) y → y = gl
⊢ P.pred gl
state_after: case intro.intro.refine_1.x
X : TopCat
T : ↑X → Type v
P✝ : PrelocalPredicate T
P : LocalPredicate T
ι : Type v
U : ι → Opens ↑X
sf : (i : ι) → (forget (Type v)).obj ((subpresheafToTypes P.toPrelocalPredicate).obj { unop := U i })
sf_comp : (subpresheafToTypes P.toPrelocalPredicate).IsCompatible U sf
sf' : (i : ι) → (X.presheafToTypes T).obj { unop := U i } := fun i => ↑(sf i)
sf'_comp : (X.presheafToTypes T).IsCompatible U sf'
gl : (forget (Type v)).obj ((X.sheafToTypes T).val.obj { unop := iSup U })
gl_spec : IsGluing (X.sheafToTypes T).val U sf' gl
gl_uniq :
  ∀ (y : (forget (Type v)).obj ((X.sheafToTypes T).val.obj { unop := iSup U })),
    (fun s => IsGluing (X.sheafToTypes T).val U sf' s) y → y = gl
⊢ ∀ (x : ↥{ unop := iSup U }.unop), ∃ V, ∃ (_ : ↑x ∈ V), ∃ i, P.pred fun x => gl ((fun x => ⟨↑x, ⋯⟩) x)

tactic: rintro ⟨x, mem⟩
state_before: case intro.intro.refine_1.x
X : TopCat
T : ↑X → Type v
P✝ : PrelocalPredicate T
P : LocalPredicate T
ι : Type v
U : ι → Opens ↑X
sf : (i : ι) → (forget (Type v)).obj ((subpresheafToTypes P.toPrelocalPredicate).obj { unop := U i })
sf_comp : (subpresheafToTypes P.toPrelocalPredicate).IsCompatible U sf
sf' : (i : ι) → (X.presheafToTypes T).obj { unop := U i } := fun i => ↑(sf i)
sf'_comp : (X.presheafToTypes T).IsCompatible U sf'
gl : (forget (Type v)).obj ((X.sheafToTypes T).val.obj { unop := iSup U })
gl_spec : IsGluing (X.sheafToTypes T).val U sf' gl
gl_uniq :
  ∀ (y : (forget (Type v)).obj ((X.sheafToTypes T).val.obj { unop := iSup U })),
    (fun s => IsGluing (X.sheafToTypes T).val U sf' s) y → y = gl
⊢ ∀ (x : ↥{ unop := iSup U }.unop), ∃ V, ∃ (_ : ↑x ∈ V), ∃ i, P.pred fun x => gl ((fun x => ⟨↑x, ⋯⟩) x)
state_after: case intro.intro.refine_1.x.mk
X : TopCat
T : ↑X → Type v
P✝ : PrelocalPredicate T
P : LocalPredicate T
ι : Type v
U : ι → Opens ↑X
sf : (i : ι) → (forget (Type v)).obj ((subpresheafToTypes P.toPrelocalPredicate).obj { unop := U i })
sf_comp : (subpresheafToTypes P.toPrelocalPredicate).IsCompatible U sf
sf' : (i : ι) → (X.presheafToTypes T).obj { unop := U i } := fun i => ↑(sf i)
sf'_comp : (X.presheafToTypes T).IsCompatible U sf'
gl : (forget (Type v)).obj ((X.sheafToTypes T).val.obj { unop := iSup U })
gl_spec : IsGluing (X.sheafToTypes T).val U sf' gl
gl_uniq :
  ∀ (y : (forget (Type v)).obj ((X.sheafToTypes T).val.obj { unop := iSup U })),
    (fun s => IsGluing (X.sheafToTypes T).val U sf' s) y → y = gl
x : ↑X
mem : x ∈ { unop := iSup U }.unop
⊢ ∃ V, ∃ (_ : ↑⟨x, mem⟩ ∈ V), ∃ i, P.pred fun x => gl ((fun x => ⟨↑x, ⋯⟩) x)

tactic: choose i hi using Opens.mem_iSup.mp mem
state_before: case intro.intro.refine_1.x.mk
X : TopCat
T : ↑X → Type v
P✝ : PrelocalPredicate T
P : LocalPredicate T
ι : Type v
U : ι → Opens ↑X
sf : (i : ι) → (forget (Type v)).obj ((subpresheafToTypes P.toPrelocalPredicate).obj { unop := U i })
sf_comp : (subpresheafToTypes P.toPrelocalPredicate).IsCompatible U sf
sf' : (i : ι) → (X.presheafToTypes T).obj { unop := U i } := fun i => ↑(sf i)
sf'_comp : (X.presheafToTypes T).IsCompatible U sf'
gl : (forget (Type v)).obj ((X.sheafToTypes T).val.obj { unop := iSup U })
gl_spec : IsGluing (X.sheafToTypes T).val U sf' gl
gl_uniq :
  ∀ (y : (forget (Type v)).obj ((X.sheafToTypes T).val.obj { unop := iSup U })),
    (fun s => IsGluing (X.sheafToTypes T).val U sf' s) y → y = gl
x : ↑X
mem : x ∈ { unop := iSup U }.unop
⊢ ∃ V, ∃ (_ : ↑⟨x, mem⟩ ∈ V), ∃ i, P.pred fun x => gl ((fun x => ⟨↑x, ⋯⟩) x)
state_after: case intro.intro.refine_1.x.mk
X : TopCat
T : ↑X → Type v
P✝ : PrelocalPredicate T
P : LocalPredicate T
ι : Type v
U : ι → Opens ↑X
sf : (i : ι) → (forget (Type v)).obj ((subpresheafToTypes P.toPrelocalPredicate).obj { unop := U i })
sf_comp : (subpresheafToTypes P.toPrelocalPredicate).IsCompatible U sf
sf' : (i : ι) → (X.presheafToTypes T).obj { unop := U i } := fun i => ↑(sf i)
sf'_comp : (X.presheafToTypes T).IsCompatible U sf'
gl : (forget (Type v)).obj ((X.sheafToTypes T).val.obj { unop := iSup U })
gl_spec : IsGluing (X.sheafToTypes T).val U sf' gl
gl_uniq :
  ∀ (y : (forget (Type v)).obj ((X.sheafToTypes T).val.obj { unop := iSup U })),
    (fun s => IsGluing (X.sheafToTypes T).val U sf' s) y → y = gl
x : ↑X
mem : x ∈ { unop := iSup U }.unop
i : ι
hi : x ∈ U i
⊢ ∃ V, ∃ (_ : ↑⟨x, mem⟩ ∈ V), ∃ i, P.pred fun x => gl ((fun x => ⟨↑x, ⋯⟩) x)

tactic: use U i, hi, Opens.leSupr U i
state_before: case intro.intro.refine_1.x.mk
X : TopCat
T : ↑X → Type v
P✝ : PrelocalPredicate T
P : LocalPredicate T
ι : Type v
U : ι → Opens ↑X
sf : (i : ι) → (forget (Type v)).obj ((subpresheafToTypes P.toPrelocalPredicate).obj { unop := U i })
sf_comp : (subpresheafToTypes P.toPrelocalPredicate).IsCompatible U sf
sf' : (i : ι) → (X.presheafToTypes T).obj { unop := U i } := fun i => ↑(sf i)
sf'_comp : (X.presheafToTypes T).IsCompatible U sf'
gl : (forget (Type v)).obj ((X.sheafToTypes T).val.obj { unop := iSup U })
gl_spec : IsGluing (X.sheafToTypes T).val U sf' gl
gl_uniq :
  ∀ (y : (forget (Type v)).obj ((X.sheafToTypes T).val.obj { unop := iSup U })),
    (fun s => IsGluing (X.sheafToTypes T).val U sf' s) y → y = gl
x : ↑X
mem : x ∈ { unop := iSup U }.unop
i : ι
hi : x ∈ U i
⊢ ∃ V, ∃ (_ : ↑⟨x, mem⟩ ∈ V), ∃ i, P.pred fun x => gl ((fun x => ⟨↑x, ⋯⟩) x)
state_after: case h
X : TopCat
T : ↑X → Type v
P✝ : PrelocalPredicate T
P : LocalPredicate T
ι : Type v
U : ι → Opens ↑X
sf : (i : ι) → (forget (Type v)).obj ((subpresheafToTypes P.toPrelocalPredicate).obj { unop := U i })
sf_comp : (subpresheafToTypes P.toPrelocalPredicate).IsCompatible U sf
sf' : (i : ι) → (X.presheafToTypes T).obj { unop := U i } := fun i => ↑(sf i)
sf'_comp : (X.presheafToTypes T).IsCompatible U sf'
gl : (forget (Type v)).obj ((X.sheafToTypes T).val.obj { unop := iSup U })
gl_spec : IsGluing (X.sheafToTypes T).val U sf' gl
gl_uniq :
  ∀ (y : (forget (Type v)).obj ((X.sheafToTypes T).val.obj { unop := iSup U })),
    (fun s => IsGluing (X.sheafToTypes T).val U sf' s) y → y = gl
x : ↑X
mem : x ∈ { unop := iSup U }.unop
i : ι
hi : x ∈ U i
⊢ P.pred fun x => gl ((fun x => ⟨↑x, ⋯⟩) x)

tactic: convert (sf i).property using 1
state_before: case h
X : TopCat
T : ↑X → Type v
P✝ : PrelocalPredicate T
P : LocalPredicate T
ι : Type v
U : ι → Opens ↑X
sf : (i : ι) → (forget (Type v)).obj ((subpresheafToTypes P.toPrelocalPredicate).obj { unop := U i })
sf_comp : (subpresheafToTypes P.toPrelocalPredicate).IsCompatible U sf
sf' : (i : ι) → (X.presheafToTypes T).obj { unop := U i } := fun i => ↑(sf i)
sf'_comp : (X.presheafToTypes T).IsCompatible U sf'
gl : (forget (Type v)).obj ((X.sheafToTypes T).val.obj { unop := iSup U })
gl_spec : IsGluing (X.sheafToTypes T).val U sf' gl
gl_uniq :
  ∀ (y : (forget (Type v)).obj ((X.sheafToTypes T).val.obj { unop := iSup U })),
    (fun s => IsGluing (X.sheafToTypes T).val U sf' s) y → y = gl
x : ↑X
mem : x ∈ { unop := iSup U }.unop
i : ι
hi : x ∈ U i
⊢ P.pred fun x => gl ((fun x => ⟨↑x, ⋯⟩) x)
state_after: case h.e'_5
X : TopCat
T : ↑X → Type v
P✝ : PrelocalPredicate T
P : LocalPredicate T
ι : Type v
U : ι → Opens ↑X
sf : (i : ι) → (forget (Type v)).obj ((subpresheafToTypes P.toPrelocalPredicate).obj { unop := U i })
sf_comp : (subpresheafToTypes P.toPrelocalPredicate).IsCompatible U sf
sf' : (i : ι) → (X.presheafToTypes T).obj { unop := U i } := fun i => ↑(sf i)
sf'_comp : (X.presheafToTypes T).IsCompatible U sf'
gl : (forget (Type v)).obj ((X.sheafToTypes T).val.obj { unop := iSup U })
gl_spec : IsGluing (X.sheafToTypes T).val U sf' gl
gl_uniq :
  ∀ (y : (forget (Type v)).obj ((X.sheafToTypes T).val.obj { unop := iSup U })),
    (fun s => IsGluing (X.sheafToTypes T).val U sf' s) y → y = gl
x : ↑X
mem : x ∈ { unop := iSup U }.unop
i : ι
hi : x ∈ U i
⊢ (fun x => gl ((fun x => ⟨↑x, ⋯⟩) x)) = ↑(sf i)

tactic: exact gl_spec i
state_before: case h.e'_5
X : TopCat
T : ↑X → Type v
P✝ : PrelocalPredicate T
P : LocalPredicate T
ι : Type v
U : ι → Opens ↑X
sf : (i : ι) → (forget (Type v)).obj ((subpresheafToTypes P.toPrelocalPredicate).obj { unop := U i })
sf_comp : (subpresheafToTypes P.toPrelocalPredicate).IsCompatible U sf
sf' : (i : ι) → (X.presheafToTypes T).obj { unop := U i } := fun i => ↑(sf i)
sf'_comp : (X.presheafToTypes T).IsCompatible U sf'
gl : (forget (Type v)).obj ((X.sheafToTypes T).val.obj { unop := iSup U })
gl_spec : IsGluing (X.sheafToTypes T).val U sf' gl
gl_uniq :
  ∀ (y : (forget (Type v)).obj ((X.sheafToTypes T).val.obj { unop := iSup U })),
    (fun s => IsGluing (X.sheafToTypes T).val U sf' s) y → y = gl
x : ↑X
mem : x ∈ { unop := iSup U }.unop
i : ι
hi : x ∈ U i
⊢ (fun x => gl ((fun x => ⟨↑x, ⋯⟩) x)) = ↑(sf i)
state_after: no goals

tactic: exact fun i => Subtype.ext (gl_spec i)
state_before: case intro.intro.refine_2
X : TopCat
T : ↑X → Type v
P✝ : PrelocalPredicate T
P : LocalPredicate T
ι : Type v
U : ι → Opens ↑X
sf : (i : ι) → (forget (Type v)).obj ((subpresheafToTypes P.toPrelocalPredicate).obj { unop := U i })
sf_comp : (subpresheafToTypes P.toPrelocalPredicate).IsCompatible U sf
sf' : (i : ι) → (X.presheafToTypes T).obj { unop := U i } := fun i => ↑(sf i)
sf'_comp : (X.presheafToTypes T).IsCompatible U sf'
gl : (forget (Type v)).obj ((X.sheafToTypes T).val.obj { unop := iSup U })
gl_spec : IsGluing (X.sheafToTypes T).val U sf' gl
gl_uniq :
  ∀ (y : (forget (Type v)).obj ((X.sheafToTypes T).val.obj { unop := iSup U })),
    (fun s => IsGluing (X.sheafToTypes T).val U sf' s) y → y = gl
⊢ (fun s => (subpresheafToTypes P.toPrelocalPredicate).IsGluing U sf s) ⟨gl, ⋯⟩
state_after: no goals

tactic: intro gl' hgl'
state_before: case intro.intro.refine_3
X : TopCat
T : ↑X → Type v
P✝ : PrelocalPredicate T
P : LocalPredicate T
ι : Type v
U : ι → Opens ↑X
sf : (i : ι) → (forget (Type v)).obj ((subpresheafToTypes P.toPrelocalPredicate).obj { unop := U i })
sf_comp : (subpresheafToTypes P.toPrelocalPredicate).IsCompatible U sf
sf' : (i : ι) → (X.presheafToTypes T).obj { unop := U i } := fun i => ↑(sf i)
sf'_comp : (X.presheafToTypes T).IsCompatible U sf'
gl : (forget (Type v)).obj ((X.sheafToTypes T).val.obj { unop := iSup U })
gl_spec : IsGluing (X.sheafToTypes T).val U sf' gl
gl_uniq :
  ∀ (y : (forget (Type v)).obj ((X.sheafToTypes T).val.obj { unop := iSup U })),
    (fun s => IsGluing (X.sheafToTypes T).val U sf' s) y → y = gl
⊢ ∀ (y : (forget (Type v)).obj ((subpresheafToTypes P.toPrelocalPredicate).obj { unop := iSup U })),
    (fun s => (subpresheafToTypes P.toPrelocalPredicate).IsGluing U sf s) y → y = ⟨gl, ⋯⟩
state_after: case intro.intro.refine_3
X : TopCat
T : ↑X → Type v
P✝ : PrelocalPredicate T
P : LocalPredicate T
ι : Type v
U : ι → Opens ↑X
sf : (i : ι) → (forget (Type v)).obj ((subpresheafToTypes P.toPrelocalPredicate).obj { unop := U i })
sf_comp : (subpresheafToTypes P.toPrelocalPredicate).IsCompatible U sf
sf' : (i : ι) → (X.presheafToTypes T).obj { unop := U i } := fun i => ↑(sf i)
sf'_comp : (X.presheafToTypes T).IsCompatible U sf'
gl : (forget (Type v)).obj ((X.sheafToTypes T).val.obj { unop := iSup U })
gl_spec : IsGluing (X.sheafToTypes T).val U sf' gl
gl_uniq :
  ∀ (y : (forget (Type v)).obj ((X.sheafToTypes T).val.obj { unop := iSup U })),
    (fun s => IsGluing (X.sheafToTypes T).val U sf' s) y → y = gl
gl' : (forget (Type v)).obj ((subpresheafToTypes P.toPrelocalPredicate).obj { unop := iSup U })
hgl' : (subpresheafToTypes P.toPrelocalPredicate).IsGluing U sf gl'
⊢ gl' = ⟨gl, ⋯⟩

tactic: refine Subtype.ext ?_
state_before: case intro.intro.refine_3
X : TopCat
T : ↑X → Type v
P✝ : PrelocalPredicate T
P : LocalPredicate T
ι : Type v
U : ι → Opens ↑X
sf : (i : ι) → (forget (Type v)).obj ((subpresheafToTypes P.toPrelocalPredicate).obj { unop := U i })
sf_comp : (subpresheafToTypes P.toPrelocalPredicate).IsCompatible U sf
sf' : (i : ι) → (X.presheafToTypes T).obj { unop := U i } := fun i => ↑(sf i)
sf'_comp : (X.presheafToTypes T).IsCompatible U sf'
gl : (forget (Type v)).obj ((X.sheafToTypes T).val.obj { unop := iSup U })
gl_spec : IsGluing (X.sheafToTypes T).val U sf' gl
gl_uniq :
  ∀ (y : (forget (Type v)).obj ((X.sheafToTypes T).val.obj { unop := iSup U })),
    (fun s => IsGluing (X.sheafToTypes T).val U sf' s) y → y = gl
gl' : (forget (Type v)).obj ((subpresheafToTypes P.toPrelocalPredicate).obj { unop := iSup U })
hgl' : (subpresheafToTypes P.toPrelocalPredicate).IsGluing U sf gl'
⊢ gl' = ⟨gl, ⋯⟩
state_after: case intro.intro.refine_3
X : TopCat
T : ↑X → Type v
P✝ : PrelocalPredicate T
P : LocalPredicate T
ι : Type v
U : ι → Opens ↑X
sf : (i : ι) → (forget (Type v)).obj ((subpresheafToTypes P.toPrelocalPredicate).obj { unop := U i })
sf_comp : (subpresheafToTypes P.toPrelocalPredicate).IsCompatible U sf
sf' : (i : ι) → (X.presheafToTypes T).obj { unop := U i } := fun i => ↑(sf i)
sf'_comp : (X.presheafToTypes T).IsCompatible U sf'
gl : (forget (Type v)).obj ((X.sheafToTypes T).val.obj { unop := iSup U })
gl_spec : IsGluing (X.sheafToTypes T).val U sf' gl
gl_uniq :
  ∀ (y : (forget (Type v)).obj ((X.sheafToTypes T).val.obj { unop := iSup U })),
    (fun s => IsGluing (X.sheafToTypes T).val U sf' s) y → y = gl
gl' : (forget (Type v)).obj ((subpresheafToTypes P.toPrelocalPredicate).obj { unop := iSup U })
hgl' : (subpresheafToTypes P.toPrelocalPredicate).IsGluing U sf gl'
⊢ ↑gl' = ↑⟨gl, ⋯⟩

tactic: exact gl_uniq gl'.1 fun i => congr_arg Subtype.val (hgl' i)
state_before: case intro.intro.refine_3
X : TopCat
T : ↑X → Type v
P✝ : PrelocalPredicate T
P : LocalPredicate T
ι : Type v
U : ι → Opens ↑X
sf : (i : ι) → (forget (Type v)).obj ((subpresheafToTypes P.toPrelocalPredicate).obj { unop := U i })
sf_comp : (subpresheafToTypes P.toPrelocalPredicate).IsCompatible U sf
sf' : (i : ι) → (X.presheafToTypes T).obj { unop := U i } := fun i => ↑(sf i)
sf'_comp : (X.presheafToTypes T).IsCompatible U sf'
gl : (forget (Type v)).obj ((X.sheafToTypes T).val.obj { unop := iSup U })
gl_spec : IsGluing (X.sheafToTypes T).val U sf' gl
gl_uniq :
  ∀ (y : (forget (Type v)).obj ((X.sheafToTypes T).val.obj { unop := iSup U })),
    (fun s => IsGluing (X.sheafToTypes T).val U sf' s) y → y = gl
gl' : (forget (Type v)).obj ((subpresheafToTypes P.toPrelocalPredicate).obj { unop := iSup U })
hgl' : (subpresheafToTypes P.toPrelocalPredicate).IsGluing U sf gl'
⊢ ↑gl' = ↑⟨gl, ⋯⟩
state_after: no goals