[GOAL]
C : Type u
inst✝² : Category.{v, u} C
inst✝¹ : ConcreteCategory C
X : TopCat
F : Presheaf (Type u) X
ι : Type x
U : ι → Opens ↑X
inst✝ : UnivLE.{x, u}
sf : piOpens F U
i : ι
⊢ ↑(piOpensIsoSectionsFamily F U) sf i = Pi.π (fun i => F.obj (op (U i))) i sf
[PROOFSTEP]
simp [piOpensIsoSectionsFamily]
[GOAL]
C : Type u
inst✝² : Category.{v, u} C
inst✝¹ : ConcreteCategory C
X : TopCat
F : Presheaf (Type u) X
ι : Type x
U : ι → Opens ↑X
inst✝ : UnivLE.{x, u}
sf : piOpens F U
⊢ IsCompatible F U (↑(piOpensIsoSectionsFamily F U) sf) ↔ leftRes F U sf = rightRes F U sf
[PROOFSTEP]
constructor
[GOAL]
case mp
C : Type u
inst✝² : Category.{v, u} C
inst✝¹ : ConcreteCategory C
X : TopCat
F : Presheaf (Type u) X
ι : Type x
U : ι → Opens ↑X
inst✝ : UnivLE.{x, u}
sf : piOpens F U
⊢ IsCompatible F U (↑(piOpensIsoSectionsFamily F U) sf) → leftRes F U sf = rightRes F U sf
[PROOFSTEP]
intro h
[GOAL]
case mpr
C : Type u
inst✝² : Category.{v, u} C
inst✝¹ : ConcreteCategory C
X : TopCat
F : Presheaf (Type u) X
ι : Type x
U : ι → Opens ↑X
inst✝ : UnivLE.{x, u}
sf : piOpens F U
⊢ leftRes F U sf = rightRes F U sf → IsCompatible F U (↑(piOpensIsoSectionsFamily F U) sf)
[PROOFSTEP]
intro h
[GOAL]
case mp
C : Type u
inst✝² : Category.{v, u} C
inst✝¹ : ConcreteCategory C
X : TopCat
F : Presheaf (Type u) X
ι : Type x
U : ι → Opens ↑X
inst✝ : UnivLE.{x, u}
sf : piOpens F U
h : IsCompatible F U (↑(piOpensIsoSectionsFamily F U) sf)
⊢ leftRes F U sf = rightRes F U sf
[PROOFSTEP]
refine Types.limit_ext _ _ _ fun ⟨i, j⟩ => ?_
[GOAL]
case mp
C : Type u
inst✝² : Category.{v, u} C
inst✝¹ : ConcreteCategory C
X : TopCat
F : Presheaf (Type u) X
ι : Type x
U : ι → Opens ↑X
inst✝ : UnivLE.{x, u}
sf : piOpens F U
h : IsCompatible F U (↑(piOpensIsoSectionsFamily F U) sf)
x✝ : Discrete (ι × ι)
i j : ι
⊢ limit.π (Discrete.functor fun p => F.obj (op (U p.fst ⊓ U p.snd))) { as := (i, j) } (leftRes F U sf) =
    limit.π (Discrete.functor fun p => F.obj (op (U p.fst ⊓ U p.snd))) { as := (i, j) } (rightRes F U sf)
[PROOFSTEP]
rw [leftRes, Types.Limit.lift_π_apply, Fan.mk_π_app, rightRes, Types.Limit.lift_π_apply, Fan.mk_π_app]
[GOAL]
case mp
C : Type u
inst✝² : Category.{v, u} C
inst✝¹ : ConcreteCategory C
X : TopCat
F : Presheaf (Type u) X
ι : Type x
U : ι → Opens ↑X
inst✝ : UnivLE.{x, u}
sf : piOpens F U
h : IsCompatible F U (↑(piOpensIsoSectionsFamily F U) sf)
x✝ : Discrete (ι × ι)
i j : ι
⊢ (Pi.π (fun i => F.obj (op (U i))) { as := (i, j) }.as.fst ≫
        F.map (infLELeft (U { as := (i, j) }.as.fst) (U { as := (i, j) }.as.snd)).op)
      sf =
    (Pi.π (fun i => F.obj (op (U i))) { as := (i, j) }.as.snd ≫
        F.map (infLERight (U { as := (i, j) }.as.fst) (U { as := (i, j) }.as.snd)).op)
      sf
[PROOFSTEP]
simpa using h i j
[GOAL]
case mpr
C : Type u
inst✝² : Category.{v, u} C
inst✝¹ : ConcreteCategory C
X : TopCat
F : Presheaf (Type u) X
ι : Type x
U : ι → Opens ↑X
inst✝ : UnivLE.{x, u}
sf : piOpens F U
h : leftRes F U sf = rightRes F U sf
⊢ IsCompatible F U (↑(piOpensIsoSectionsFamily F U) sf)
[PROOFSTEP]
intro i j
[GOAL]
case mpr
C : Type u
inst✝² : Category.{v, u} C
inst✝¹ : ConcreteCategory C
X : TopCat
F : Presheaf (Type u) X
ι : Type x
U : ι → Opens ↑X
inst✝ : UnivLE.{x, u}
sf : piOpens F U
h : leftRes F U sf = rightRes F U sf
i j : ι
⊢ ↑(F.map (infLELeft (U i) (U j)).op) (↑(piOpensIsoSectionsFamily F U) sf i) =
    ↑(F.map (infLERight (U i) (U j)).op) (↑(piOpensIsoSectionsFamily F U) sf j)
[PROOFSTEP]
convert congr_arg (Limits.Pi.π (fun p : ι × ι => F.obj (op (U p.1 ⊓ U p.2))) (i, j)) h
[GOAL]
case h.e'_2.h
C : Type u
inst✝² : Category.{v, u} C
inst✝¹ : ConcreteCategory C
X : TopCat
F : Presheaf (Type u) X
ι : Type x
U : ι → Opens ↑X
inst✝ : UnivLE.{x, u}
sf : piOpens F U
h : leftRes F U sf = rightRes F U sf
i j : ι
e_1✝ :
  (fun x => (forget (Type u)).obj (F.obj (op (U i ⊓ U j)))) (↑(piOpensIsoSectionsFamily F U) sf i) =
    F.obj (op (U (i, j).fst ⊓ U (i, j).snd))
⊢ ↑(F.map (infLELeft (U i) (U j)).op) (↑(piOpensIsoSectionsFamily F U) sf i) =
    Pi.π (fun p => F.obj (op (U p.fst ⊓ U p.snd))) (i, j) (leftRes F U sf)
[PROOFSTEP]
rw [leftRes, Types.pi_lift_π_apply, piOpensIsoSectionsFamily_apply]
[GOAL]
case h.e'_2.h
C : Type u
inst✝² : Category.{v, u} C
inst✝¹ : ConcreteCategory C
X : TopCat
F : Presheaf (Type u) X
ι : Type x
U : ι → Opens ↑X
inst✝ : UnivLE.{x, u}
sf : piOpens F U
h : leftRes F U sf = rightRes F U sf
i j : ι
e_1✝ :
  (fun x => (forget (Type u)).obj (F.obj (op (U i ⊓ U j)))) (↑(piOpensIsoSectionsFamily F U) sf i) =
    F.obj (op (U (i, j).fst ⊓ U (i, j).snd))
⊢ ↑(F.map (infLELeft (U i) (U j)).op) (Pi.π (fun i => F.obj (op (U i))) i sf) =
    (Pi.π (fun i => F.obj (op (U i))) (i, j).fst ≫ F.map (infLELeft (U (i, j).fst) (U (i, j).snd)).op) sf
[PROOFSTEP]
rfl
[GOAL]
case h.e'_3.h
C : Type u
inst✝² : Category.{v, u} C
inst✝¹ : ConcreteCategory C
X : TopCat
F : Presheaf (Type u) X
ι : Type x
U : ι → Opens ↑X
inst✝ : UnivLE.{x, u}
sf : piOpens F U
h : leftRes F U sf = rightRes F U sf
i j : ι
e_1✝ :
  (fun x => (forget (Type u)).obj (F.obj (op (U i ⊓ U j)))) (↑(piOpensIsoSectionsFamily F U) sf i) =
    F.obj (op (U (i, j).fst ⊓ U (i, j).snd))
⊢ ↑(F.map (infLERight (U i) (U j)).op) (↑(piOpensIsoSectionsFamily F U) sf j) =
    Pi.π (fun p => F.obj (op (U p.fst ⊓ U p.snd))) (i, j) (rightRes F U sf)
[PROOFSTEP]
rw [rightRes, Types.pi_lift_π_apply]
[GOAL]
case h.e'_3.h
C : Type u
inst✝² : Category.{v, u} C
inst✝¹ : ConcreteCategory C
X : TopCat
F : Presheaf (Type u) X
ι : Type x
U : ι → Opens ↑X
inst✝ : UnivLE.{x, u}
sf : piOpens F U
h : leftRes F U sf = rightRes F U sf
i j : ι
e_1✝ :
  (fun x => (forget (Type u)).obj (F.obj (op (U i ⊓ U j)))) (↑(piOpensIsoSectionsFamily F U) sf i) =
    F.obj (op (U (i, j).fst ⊓ U (i, j).snd))
⊢ ↑(F.map (infLERight (U i) (U j)).op) (↑(piOpensIsoSectionsFamily F U) sf j) =
    (Pi.π (fun i => F.obj (op (U i))) (i, j).snd ≫ F.map (infLERight (U (i, j).fst) (U (i, j).snd)).op) sf
[PROOFSTEP]
simp only [piOpensIsoSectionsFamily_apply]
[GOAL]
case h.e'_3.h
C : Type u
inst✝² : Category.{v, u} C
inst✝¹ : ConcreteCategory C
X : TopCat
F : Presheaf (Type u) X
ι : Type x
U : ι → Opens ↑X
inst✝ : UnivLE.{x, u}
sf : piOpens F U
h : leftRes F U sf = rightRes F U sf
i j : ι
e_1✝ :
  (fun x => (forget (Type u)).obj (F.obj (op (U i ⊓ U j)))) (↑(piOpensIsoSectionsFamily F U) sf i) =
    F.obj (op (U (i, j).fst ⊓ U (i, j).snd))
⊢ ↑(F.map (infLERight (U i) (U j)).op) (Pi.π (fun i => F.obj (op (U i))) j sf) =
    (Pi.π (fun i => F.obj (op (U i))) j ≫ F.map (infLERight (U i) (U j)).op) sf
[PROOFSTEP]
rfl
[GOAL]
C : Type u
inst✝² : Category.{v, u} C
inst✝¹ : ConcreteCategory C
X : TopCat
F : Presheaf (Type u) X
ι : Type x
U : ι → Opens ↑X
inst✝ : UnivLE.{x, u}
sf : piOpens F U
s : F.obj (op (iSup U))
⊢ IsGluing F U (↑(piOpensIsoSectionsFamily F U) sf) s ↔ res F U s = sf
[PROOFSTEP]
constructor
[GOAL]
case mp
C : Type u
inst✝² : Category.{v, u} C
inst✝¹ : ConcreteCategory C
X : TopCat
F : Presheaf (Type u) X
ι : Type x
U : ι → Opens ↑X
inst✝ : UnivLE.{x, u}
sf : piOpens F U
s : F.obj (op (iSup U))
⊢ IsGluing F U (↑(piOpensIsoSectionsFamily F U) sf) s → res F U s = sf
[PROOFSTEP]
intro h
[GOAL]
case mpr
C : Type u
inst✝² : Category.{v, u} C
inst✝¹ : ConcreteCategory C
X : TopCat
F : Presheaf (Type u) X
ι : Type x
U : ι → Opens ↑X
inst✝ : UnivLE.{x, u}
sf : piOpens F U
s : F.obj (op (iSup U))
⊢ res F U s = sf → IsGluing F U (↑(piOpensIsoSectionsFamily F U) sf) s
[PROOFSTEP]
intro h
[GOAL]
case mp
C : Type u
inst✝² : Category.{v, u} C
inst✝¹ : ConcreteCategory C
X : TopCat
F : Presheaf (Type u) X
ι : Type x
U : ι → Opens ↑X
inst✝ : UnivLE.{x, u}
sf : piOpens F U
s : F.obj (op (iSup U))
h : IsGluing F U (↑(piOpensIsoSectionsFamily F U) sf) s
⊢ res F U s = sf
[PROOFSTEP]
refine Types.limit_ext _ _ _ fun ⟨i⟩ => ?_
[GOAL]
case mp
C : Type u
inst✝² : Category.{v, u} C
inst✝¹ : ConcreteCategory C
X : TopCat
F : Presheaf (Type u) X
ι : Type x
U : ι → Opens ↑X
inst✝ : UnivLE.{x, u}
sf : piOpens F U
s : F.obj (op (iSup U))
h : IsGluing F U (↑(piOpensIsoSectionsFamily F U) sf) s
x✝ : Discrete ι
i : ι
⊢ limit.π (Discrete.functor fun i => F.obj (op (U i))) { as := i } (res F U s) =
    limit.π (Discrete.functor fun i => F.obj (op (U i))) { as := i } sf
[PROOFSTEP]
rw [res, Types.Limit.lift_π_apply, Fan.mk_π_app]
[GOAL]
case mp
C : Type u
inst✝² : Category.{v, u} C
inst✝¹ : ConcreteCategory C
X : TopCat
F : Presheaf (Type u) X
ι : Type x
U : ι → Opens ↑X
inst✝ : UnivLE.{x, u}
sf : piOpens F U
s : F.obj (op (iSup U))
h : IsGluing F U (↑(piOpensIsoSectionsFamily F U) sf) s
x✝ : Discrete ι
i : ι
⊢ F.map (leSupr U { as := i }.as).op s = limit.π (Discrete.functor fun i => F.obj (op (U i))) { as := i } sf
[PROOFSTEP]
simpa using h i
[GOAL]
case mpr
C : Type u
inst✝² : Category.{v, u} C
inst✝¹ : ConcreteCategory C
X : TopCat
F : Presheaf (Type u) X
ι : Type x
U : ι → Opens ↑X
inst✝ : UnivLE.{x, u}
sf : piOpens F U
s : F.obj (op (iSup U))
h : res F U s = sf
⊢ IsGluing F U (↑(piOpensIsoSectionsFamily F U) sf) s
[PROOFSTEP]
intro i
[GOAL]
case mpr
C : Type u
inst✝² : Category.{v, u} C
inst✝¹ : ConcreteCategory C
X : TopCat
F : Presheaf (Type u) X
ι : Type x
U : ι → Opens ↑X
inst✝ : UnivLE.{x, u}
sf : piOpens F U
s : F.obj (op (iSup U))
h : res F U s = sf
i : ι
⊢ ↑(F.map (leSupr U i).op) s = ↑(piOpensIsoSectionsFamily F U) sf i
[PROOFSTEP]
convert congr_arg (Limits.Pi.π (fun i : ι => F.obj (op (U i))) i) h
[GOAL]
case h.e'_2.h
C : Type u
inst✝² : Category.{v, u} C
inst✝¹ : ConcreteCategory C
X : TopCat
F : Presheaf (Type u) X
ι : Type x
U : ι → Opens ↑X
inst✝ : UnivLE.{x, u}
sf : piOpens F U
s : F.obj (op (iSup U))
h : res F U s = sf
i : ι
e_1✝ : (fun x => (forget (Type u)).obj (F.obj (op (U i)))) s = F.obj (op (U i))
⊢ ↑(F.map (leSupr U i).op) s = Pi.π (fun i => F.obj (op (U i))) i (res F U s)
case h.e'_3.h
C : Type u
inst✝² : Category.{v, u} C
inst✝¹ : ConcreteCategory C
X : TopCat
F : Presheaf (Type u) X
ι : Type x
U : ι → Opens ↑X
inst✝ : UnivLE.{x, u}
sf : piOpens F U
s : F.obj (op (iSup U))
h : res F U s = sf
i : ι
e_1✝ : (fun x => (forget (Type u)).obj (F.obj (op (U i)))) s = F.obj (op (U i))
⊢ ↑(piOpensIsoSectionsFamily F U) sf i = Pi.π (fun i => F.obj (op (U i))) i sf
[PROOFSTEP]
rw [res, Types.pi_lift_π_apply]
[GOAL]
case h.e'_2.h
C : Type u
inst✝² : Category.{v, u} C
inst✝¹ : ConcreteCategory C
X : TopCat
F : Presheaf (Type u) X
ι : Type x
U : ι → Opens ↑X
inst✝ : UnivLE.{x, u}
sf : piOpens F U
s : F.obj (op (iSup U))
h : res F U s = sf
i : ι
e_1✝ : (fun x => (forget (Type u)).obj (F.obj (op (U i)))) s = F.obj (op (U i))
⊢ ↑(F.map (leSupr U i).op) s = F.map (leSupr U i).op s
[PROOFSTEP]
rfl
[GOAL]
case h.e'_3.h
C : Type u
inst✝² : Category.{v, u} C
inst✝¹ : ConcreteCategory C
X : TopCat
F : Presheaf (Type u) X
ι : Type x
U : ι → Opens ↑X
inst✝ : UnivLE.{x, u}
sf : piOpens F U
s : F.obj (op (iSup U))
h : res F U s = sf
i : ι
e_1✝ : (fun x => (forget (Type u)).obj (F.obj (op (U i)))) s = F.obj (op (U i))
⊢ ↑(piOpensIsoSectionsFamily F U) sf i = Pi.π (fun i => F.obj (op (U i))) i sf
[PROOFSTEP]
simp
[GOAL]
C : Type u
inst✝² : Category.{v, u} C
inst✝¹ : ConcreteCategory C
X : TopCat
F : Presheaf (Type u) X
ι : Type x
U : ι → Opens ↑X
inst✝ : UnivLE.{x, u}
Fsh : IsSheafUniqueGluing F
⊢ IsSheaf F
[PROOFSTEP]
rw [isSheaf_iff_isSheafEqualizerProducts]
[GOAL]
C : Type u
inst✝² : Category.{v, u} C
inst✝¹ : ConcreteCategory C
X : TopCat
F : Presheaf (Type u) X
ι : Type x
U : ι → Opens ↑X
inst✝ : UnivLE.{x, u}
Fsh : IsSheafUniqueGluing F
⊢ IsSheafEqualizerProducts F
[PROOFSTEP]
intro ι U
[GOAL]
C : Type u
inst✝² : Category.{v, u} C
inst✝¹ : ConcreteCategory C
X : TopCat
F : Presheaf (Type u) X
ι✝ : Type x
U✝ : ι✝ → Opens ↑X
inst✝ : UnivLE.{x, u}
Fsh : IsSheafUniqueGluing F
ι : Type x
U : ι → Opens ↑X
⊢ Nonempty (IsLimit (fork F U))
[PROOFSTEP]
refine' ⟨Fork.IsLimit.mk' _ _⟩
[GOAL]
C : Type u
inst✝² : Category.{v, u} C
inst✝¹ : ConcreteCategory C
X : TopCat
F : Presheaf (Type u) X
ι✝ : Type x
U✝ : ι✝ → Opens ↑X
inst✝ : UnivLE.{x, u}
Fsh : IsSheafUniqueGluing F
ι : Type x
U : ι → Opens ↑X
⊢ (s : Fork (leftRes F U) (rightRes F U)) →
    { l //
      l ≫ Fork.ι (fork F U) = Fork.ι s ∧
        ∀
          {m :
            ((Functor.const WalkingParallelPair).obj s.pt).obj WalkingParallelPair.zero ⟶
              ((Functor.const WalkingParallelPair).obj (fork F U).pt).obj WalkingParallelPair.zero},
          m ≫ Fork.ι (fork F U) = Fork.ι s → m = l }
[PROOFSTEP]
intro s
[GOAL]
C : Type u
inst✝² : Category.{v, u} C
inst✝¹ : ConcreteCategory C
X : TopCat
F : Presheaf (Type u) X
ι✝ : Type x
U✝ : ι✝ → Opens ↑X
inst✝ : UnivLE.{x, u}
Fsh : IsSheafUniqueGluing F
ι : Type x
U : ι → Opens ↑X
s : Fork (leftRes F U) (rightRes F U)
⊢ { l //
    l ≫ Fork.ι (fork F U) = Fork.ι s ∧
      ∀
        {m :
          ((Functor.const WalkingParallelPair).obj s.pt).obj WalkingParallelPair.zero ⟶
            ((Functor.const WalkingParallelPair).obj (fork F U).pt).obj WalkingParallelPair.zero},
        m ≫ Fork.ι (fork F U) = Fork.ι s → m = l }
[PROOFSTEP]
have h_compatible : ∀ x : s.pt, F.IsCompatible U (piOpensIsoSectionsFamily F U (s.ι x)) :=
  by
  intro x
  rw [compatible_iff_leftRes_eq_rightRes]
  convert congr_fun s.condition x
[GOAL]
C : Type u
inst✝² : Category.{v, u} C
inst✝¹ : ConcreteCategory C
X : TopCat
F : Presheaf (Type u) X
ι✝ : Type x
U✝ : ι✝ → Opens ↑X
inst✝ : UnivLE.{x, u}
Fsh : IsSheafUniqueGluing F
ι : Type x
U : ι → Opens ↑X
s : Fork (leftRes F U) (rightRes F U)
⊢ ∀ (x : s.pt), IsCompatible F U (↑(piOpensIsoSectionsFamily F U) (Fork.ι s x))
[PROOFSTEP]
intro x
[GOAL]
C : Type u
inst✝² : Category.{v, u} C
inst✝¹ : ConcreteCategory C
X : TopCat
F : Presheaf (Type u) X
ι✝ : Type x
U✝ : ι✝ → Opens ↑X
inst✝ : UnivLE.{x, u}
Fsh : IsSheafUniqueGluing F
ι : Type x
U : ι → Opens ↑X
s : Fork (leftRes F U) (rightRes F U)
x : s.pt
⊢ IsCompatible F U (↑(piOpensIsoSectionsFamily F U) (Fork.ι s x))
[PROOFSTEP]
rw [compatible_iff_leftRes_eq_rightRes]
[GOAL]
C : Type u
inst✝² : Category.{v, u} C
inst✝¹ : ConcreteCategory C
X : TopCat
F : Presheaf (Type u) X
ι✝ : Type x
U✝ : ι✝ → Opens ↑X
inst✝ : UnivLE.{x, u}
Fsh : IsSheafUniqueGluing F
ι : Type x
U : ι → Opens ↑X
s : Fork (leftRes F U) (rightRes F U)
x : s.pt
⊢ leftRes F U (Fork.ι s x) = rightRes F U (Fork.ι s x)
[PROOFSTEP]
convert congr_fun s.condition x
[GOAL]
C : Type u
inst✝² : Category.{v, u} C
inst✝¹ : ConcreteCategory C
X : TopCat
F : Presheaf (Type u) X
ι✝ : Type x
U✝ : ι✝ → Opens ↑X
inst✝ : UnivLE.{x, u}
Fsh : IsSheafUniqueGluing F
ι : Type x
U : ι → Opens ↑X
s : Fork (leftRes F U) (rightRes F U)
h_compatible : ∀ (x : s.pt), IsCompatible F U (↑(piOpensIsoSectionsFamily F U) (Fork.ι s x))
⊢ { l //
    l ≫ Fork.ι (fork F U) = Fork.ι s ∧
      ∀
        {m :
          ((Functor.const WalkingParallelPair).obj s.pt).obj WalkingParallelPair.zero ⟶
            ((Functor.const WalkingParallelPair).obj (fork F U).pt).obj WalkingParallelPair.zero},
        m ≫ Fork.ι (fork F U) = Fork.ι s → m = l }
[PROOFSTEP]
choose m m_spec m_uniq using fun x : s.pt => Fsh U (piOpensIsoSectionsFamily F U (s.ι x)) (h_compatible x)
[GOAL]
C : Type u
inst✝² : Category.{v, u} C
inst✝¹ : ConcreteCategory C
X : TopCat
F : Presheaf (Type u) X
ι✝ : Type x
U✝ : ι✝ → Opens ↑X
inst✝ : UnivLE.{x, u}
Fsh : IsSheafUniqueGluing F
ι : Type x
U : ι → Opens ↑X
s : Fork (leftRes F U) (rightRes F U)
h_compatible : ∀ (x : s.pt), IsCompatible F U (↑(piOpensIsoSectionsFamily F U) (Fork.ι s x))
m : s.pt → (forget (Type u)).obj (F.obj (op (iSup U)))
m_spec : ∀ (x : s.pt), (fun s_1 => IsGluing F U (↑(piOpensIsoSectionsFamily F U) (Fork.ι s x)) s_1) (m x)
m_uniq :
  ∀ (x : s.pt) (y : (forget (Type u)).obj (F.obj (op (iSup U)))),
    (fun s_1 => IsGluing F U (↑(piOpensIsoSectionsFamily F U) (Fork.ι s x)) s_1) y → y = m x
⊢ { l //
    l ≫ Fork.ι (fork F U) = Fork.ι s ∧
      ∀
        {m :
          ((Functor.const WalkingParallelPair).obj s.pt).obj WalkingParallelPair.zero ⟶
            ((Functor.const WalkingParallelPair).obj (fork F U).pt).obj WalkingParallelPair.zero},
        m ≫ Fork.ι (fork F U) = Fork.ι s → m = l }
[PROOFSTEP]
refine' ⟨m, _, _⟩
[GOAL]
case refine'_1
C : Type u
inst✝² : Category.{v, u} C
inst✝¹ : ConcreteCategory C
X : TopCat
F : Presheaf (Type u) X
ι✝ : Type x
U✝ : ι✝ → Opens ↑X
inst✝ : UnivLE.{x, u}
Fsh : IsSheafUniqueGluing F
ι : Type x
U : ι → Opens ↑X
s : Fork (leftRes F U) (rightRes F U)
h_compatible : ∀ (x : s.pt), IsCompatible F U (↑(piOpensIsoSectionsFamily F U) (Fork.ι s x))
m : s.pt → (forget (Type u)).obj (F.obj (op (iSup U)))
m_spec : ∀ (x : s.pt), (fun s_1 => IsGluing F U (↑(piOpensIsoSectionsFamily F U) (Fork.ι s x)) s_1) (m x)
m_uniq :
  ∀ (x : s.pt) (y : (forget (Type u)).obj (F.obj (op (iSup U)))),
    (fun s_1 => IsGluing F U (↑(piOpensIsoSectionsFamily F U) (Fork.ι s x)) s_1) y → y = m x
⊢ m ≫ Fork.ι (fork F U) = Fork.ι s
[PROOFSTEP]
refine limit.hom_ext fun ⟨i⟩ => funext fun x => ?_
[GOAL]
case refine'_1
C : Type u
inst✝² : Category.{v, u} C
inst✝¹ : ConcreteCategory C
X : TopCat
F : Presheaf (Type u) X
ι✝ : Type x
U✝ : ι✝ → Opens ↑X
inst✝ : UnivLE.{x, u}
Fsh : IsSheafUniqueGluing F
ι : Type x
U : ι → Opens ↑X
s : Fork (leftRes F U) (rightRes F U)
h_compatible : ∀ (x : s.pt), IsCompatible F U (↑(piOpensIsoSectionsFamily F U) (Fork.ι s x))
m : s.pt → (forget (Type u)).obj (F.obj (op (iSup U)))
m_spec : ∀ (x : s.pt), (fun s_1 => IsGluing F U (↑(piOpensIsoSectionsFamily F U) (Fork.ι s x)) s_1) (m x)
m_uniq :
  ∀ (x : s.pt) (y : (forget (Type u)).obj (F.obj (op (iSup U)))),
    (fun s_1 => IsGluing F U (↑(piOpensIsoSectionsFamily F U) (Fork.ι s x)) s_1) y → y = m x
x✝ : Discrete ι
i : ι
x : ((Functor.const WalkingParallelPair).obj s.pt).obj WalkingParallelPair.zero
⊢ ((m ≫ Fork.ι (fork F U)) ≫ limit.π (Discrete.functor fun i => F.obj (op (U i))) { as := i }) x =
    (Fork.ι s ≫ limit.π (Discrete.functor fun i => F.obj (op (U i))) { as := i }) x
[PROOFSTEP]
simp [res]
[GOAL]
case refine'_1
C : Type u
inst✝² : Category.{v, u} C
inst✝¹ : ConcreteCategory C
X : TopCat
F : Presheaf (Type u) X
ι✝ : Type x
U✝ : ι✝ → Opens ↑X
inst✝ : UnivLE.{x, u}
Fsh : IsSheafUniqueGluing F
ι : Type x
U : ι → Opens ↑X
s : Fork (leftRes F U) (rightRes F U)
h_compatible : ∀ (x : s.pt), IsCompatible F U (↑(piOpensIsoSectionsFamily F U) (Fork.ι s x))
m : s.pt → (forget (Type u)).obj (F.obj (op (iSup U)))
m_spec : ∀ (x : s.pt), (fun s_1 => IsGluing F U (↑(piOpensIsoSectionsFamily F U) (Fork.ι s x)) s_1) (m x)
m_uniq :
  ∀ (x : s.pt) (y : (forget (Type u)).obj (F.obj (op (iSup U)))),
    (fun s_1 => IsGluing F U (↑(piOpensIsoSectionsFamily F U) (Fork.ι s x)) s_1) y → y = m x
x✝ : Discrete ι
i : ι
x : ((Functor.const WalkingParallelPair).obj s.pt).obj WalkingParallelPair.zero
⊢ F.map (leSupr U i).op (m x) = limit.π (Discrete.functor fun i => F.obj (op (U i))) { as := i } (Fork.ι s x)
[PROOFSTEP]
simpa using m_spec x i
[GOAL]
case refine'_2
C : Type u
inst✝² : Category.{v, u} C
inst✝¹ : ConcreteCategory C
X : TopCat
F : Presheaf (Type u) X
ι✝ : Type x
U✝ : ι✝ → Opens ↑X
inst✝ : UnivLE.{x, u}
Fsh : IsSheafUniqueGluing F
ι : Type x
U : ι → Opens ↑X
s : Fork (leftRes F U) (rightRes F U)
h_compatible : ∀ (x : s.pt), IsCompatible F U (↑(piOpensIsoSectionsFamily F U) (Fork.ι s x))
m : s.pt → (forget (Type u)).obj (F.obj (op (iSup U)))
m_spec : ∀ (x : s.pt), (fun s_1 => IsGluing F U (↑(piOpensIsoSectionsFamily F U) (Fork.ι s x)) s_1) (m x)
m_uniq :
  ∀ (x : s.pt) (y : (forget (Type u)).obj (F.obj (op (iSup U)))),
    (fun s_1 => IsGluing F U (↑(piOpensIsoSectionsFamily F U) (Fork.ι s x)) s_1) y → y = m x
⊢ ∀
    {m_1 :
      ((Functor.const WalkingParallelPair).obj s.pt).obj WalkingParallelPair.zero ⟶
        ((Functor.const WalkingParallelPair).obj (fork F U).pt).obj WalkingParallelPair.zero},
    m_1 ≫ Fork.ι (fork F U) = Fork.ι s → m_1 = m
[PROOFSTEP]
intro l hl
[GOAL]
case refine'_2
C : Type u
inst✝² : Category.{v, u} C
inst✝¹ : ConcreteCategory C
X : TopCat
F : Presheaf (Type u) X
ι✝ : Type x
U✝ : ι✝ → Opens ↑X
inst✝ : UnivLE.{x, u}
Fsh : IsSheafUniqueGluing F
ι : Type x
U : ι → Opens ↑X
s : Fork (leftRes F U) (rightRes F U)
h_compatible : ∀ (x : s.pt), IsCompatible F U (↑(piOpensIsoSectionsFamily F U) (Fork.ι s x))
m : s.pt → (forget (Type u)).obj (F.obj (op (iSup U)))
m_spec : ∀ (x : s.pt), (fun s_1 => IsGluing F U (↑(piOpensIsoSectionsFamily F U) (Fork.ι s x)) s_1) (m x)
m_uniq :
  ∀ (x : s.pt) (y : (forget (Type u)).obj (F.obj (op (iSup U)))),
    (fun s_1 => IsGluing F U (↑(piOpensIsoSectionsFamily F U) (Fork.ι s x)) s_1) y → y = m x
l :
  ((Functor.const WalkingParallelPair).obj s.pt).obj WalkingParallelPair.zero ⟶
    ((Functor.const WalkingParallelPair).obj (fork F U).pt).obj WalkingParallelPair.zero
hl : l ≫ Fork.ι (fork F U) = Fork.ι s
⊢ l = m
[PROOFSTEP]
ext x
[GOAL]
case refine'_2.h
C : Type u
inst✝² : Category.{v, u} C
inst✝¹ : ConcreteCategory C
X : TopCat
F : Presheaf (Type u) X
ι✝ : Type x
U✝ : ι✝ → Opens ↑X
inst✝ : UnivLE.{x, u}
Fsh : IsSheafUniqueGluing F
ι : Type x
U : ι → Opens ↑X
s : Fork (leftRes F U) (rightRes F U)
h_compatible : ∀ (x : s.pt), IsCompatible F U (↑(piOpensIsoSectionsFamily F U) (Fork.ι s x))
m : s.pt → (forget (Type u)).obj (F.obj (op (iSup U)))
m_spec : ∀ (x : s.pt), (fun s_1 => IsGluing F U (↑(piOpensIsoSectionsFamily F U) (Fork.ι s x)) s_1) (m x)
m_uniq :
  ∀ (x : s.pt) (y : (forget (Type u)).obj (F.obj (op (iSup U)))),
    (fun s_1 => IsGluing F U (↑(piOpensIsoSectionsFamily F U) (Fork.ι s x)) s_1) y → y = m x
l :
  ((Functor.const WalkingParallelPair).obj s.pt).obj WalkingParallelPair.zero ⟶
    ((Functor.const WalkingParallelPair).obj (fork F U).pt).obj WalkingParallelPair.zero
hl : l ≫ Fork.ι (fork F U) = Fork.ι s
x : ((Functor.const WalkingParallelPair).obj s.pt).obj WalkingParallelPair.zero
⊢ l x = m x
[PROOFSTEP]
apply m_uniq
[GOAL]
case refine'_2.h.a
C : Type u
inst✝² : Category.{v, u} C
inst✝¹ : ConcreteCategory C
X : TopCat
F : Presheaf (Type u) X
ι✝ : Type x
U✝ : ι✝ → Opens ↑X
inst✝ : UnivLE.{x, u}
Fsh : IsSheafUniqueGluing F
ι : Type x
U : ι → Opens ↑X
s : Fork (leftRes F U) (rightRes F U)
h_compatible : ∀ (x : s.pt), IsCompatible F U (↑(piOpensIsoSectionsFamily F U) (Fork.ι s x))
m : s.pt → (forget (Type u)).obj (F.obj (op (iSup U)))
m_spec : ∀ (x : s.pt), (fun s_1 => IsGluing F U (↑(piOpensIsoSectionsFamily F U) (Fork.ι s x)) s_1) (m x)
m_uniq :
  ∀ (x : s.pt) (y : (forget (Type u)).obj (F.obj (op (iSup U)))),
    (fun s_1 => IsGluing F U (↑(piOpensIsoSectionsFamily F U) (Fork.ι s x)) s_1) y → y = m x
l :
  ((Functor.const WalkingParallelPair).obj s.pt).obj WalkingParallelPair.zero ⟶
    ((Functor.const WalkingParallelPair).obj (fork F U).pt).obj WalkingParallelPair.zero
hl : l ≫ Fork.ι (fork F U) = Fork.ι s
x : ((Functor.const WalkingParallelPair).obj s.pt).obj WalkingParallelPair.zero
⊢ IsGluing F U (↑(piOpensIsoSectionsFamily F U) (Fork.ι s x)) (l x)
[PROOFSTEP]
rw [isGluing_iff_eq_res]
[GOAL]
case refine'_2.h.a
C : Type u
inst✝² : Category.{v, u} C
inst✝¹ : ConcreteCategory C
X : TopCat
F : Presheaf (Type u) X
ι✝ : Type x
U✝ : ι✝ → Opens ↑X
inst✝ : UnivLE.{x, u}
Fsh : IsSheafUniqueGluing F
ι : Type x
U : ι → Opens ↑X
s : Fork (leftRes F U) (rightRes F U)
h_compatible : ∀ (x : s.pt), IsCompatible F U (↑(piOpensIsoSectionsFamily F U) (Fork.ι s x))
m : s.pt → (forget (Type u)).obj (F.obj (op (iSup U)))
m_spec : ∀ (x : s.pt), (fun s_1 => IsGluing F U (↑(piOpensIsoSectionsFamily F U) (Fork.ι s x)) s_1) (m x)
m_uniq :
  ∀ (x : s.pt) (y : (forget (Type u)).obj (F.obj (op (iSup U)))),
    (fun s_1 => IsGluing F U (↑(piOpensIsoSectionsFamily F U) (Fork.ι s x)) s_1) y → y = m x
l :
  ((Functor.const WalkingParallelPair).obj s.pt).obj WalkingParallelPair.zero ⟶
    ((Functor.const WalkingParallelPair).obj (fork F U).pt).obj WalkingParallelPair.zero
hl : l ≫ Fork.ι (fork F U) = Fork.ι s
x : ((Functor.const WalkingParallelPair).obj s.pt).obj WalkingParallelPair.zero
⊢ res F U (l x) = Fork.ι s x
[PROOFSTEP]
exact congr_fun hl x
[GOAL]
C : Type u
inst✝² : Category.{v, u} C
inst✝¹ : ConcreteCategory C
X : TopCat
F : Presheaf (Type u) X
ι : Type x
U : ι → Opens ↑X
inst✝ : UnivLE.{x, u}
Fsh : IsSheaf F
⊢ IsSheafUniqueGluing F
[PROOFSTEP]
rw [isSheaf_iff_isSheafEqualizerProducts] at Fsh
[GOAL]
C : Type u
inst✝² : Category.{v, u} C
inst✝¹ : ConcreteCategory C
X : TopCat
F : Presheaf (Type u) X
ι : Type x
U : ι → Opens ↑X
inst✝ : UnivLE.{x, u}
Fsh✝ : IsSheaf F
Fsh : IsSheafEqualizerProducts F
⊢ IsSheafUniqueGluing F
[PROOFSTEP]
intro ι U sf hsf
[GOAL]
C : Type u
inst✝² : Category.{v, u} C
inst✝¹ : ConcreteCategory C
X : TopCat
F : Presheaf (Type u) X
ι✝ : Type x
U✝ : ι✝ → Opens ↑X
inst✝ : UnivLE.{x, u}
Fsh✝ : IsSheaf F
Fsh : IsSheafEqualizerProducts F
ι : Type x
U : ι → Opens ↑X
sf : (i : ι) → (forget (Type u)).obj (F.obj (op (U i)))
hsf : IsCompatible F U sf
⊢ ∃! s, IsGluing F U sf s
[PROOFSTEP]
let sf' := (piOpensIsoSectionsFamily F U).symm sf
[GOAL]
C : Type u
inst✝² : Category.{v, u} C
inst✝¹ : ConcreteCategory C
X : TopCat
F : Presheaf (Type u) X
ι✝ : Type x
U✝ : ι✝ → Opens ↑X
inst✝ : UnivLE.{x, u}
Fsh✝ : IsSheaf F
Fsh : IsSheafEqualizerProducts F
ι : Type x
U : ι → Opens ↑X
sf : (i : ι) → (forget (Type u)).obj (F.obj (op (U i)))
hsf : IsCompatible F U sf
sf' : (fun x => piOpens F U) sf := ↑(piOpensIsoSectionsFamily F U).symm sf
⊢ ∃! s, IsGluing F U sf s
[PROOFSTEP]
have hsf' : leftRes F U sf' = rightRes F U sf' := by
  rwa [← compatible_iff_leftRes_eq_rightRes F U sf', Equiv.apply_symm_apply]
[GOAL]
C : Type u
inst✝² : Category.{v, u} C
inst✝¹ : ConcreteCategory C
X : TopCat
F : Presheaf (Type u) X
ι✝ : Type x
U✝ : ι✝ → Opens ↑X
inst✝ : UnivLE.{x, u}
Fsh✝ : IsSheaf F
Fsh : IsSheafEqualizerProducts F
ι : Type x
U : ι → Opens ↑X
sf : (i : ι) → (forget (Type u)).obj (F.obj (op (U i)))
hsf : IsCompatible F U sf
sf' : (fun x => piOpens F U) sf := ↑(piOpensIsoSectionsFamily F U).symm sf
⊢ leftRes F U sf' = rightRes F U sf'
[PROOFSTEP]
rwa [← compatible_iff_leftRes_eq_rightRes F U sf', Equiv.apply_symm_apply]
[GOAL]
C : Type u
inst✝² : Category.{v, u} C
inst✝¹ : ConcreteCategory C
X : TopCat
F : Presheaf (Type u) X
ι✝ : Type x
U✝ : ι✝ → Opens ↑X
inst✝ : UnivLE.{x, u}
Fsh✝ : IsSheaf F
Fsh : IsSheafEqualizerProducts F
ι : Type x
U : ι → Opens ↑X
sf : (i : ι) → (forget (Type u)).obj (F.obj (op (U i)))
hsf : IsCompatible F U sf
sf' : (fun x => piOpens F U) sf := ↑(piOpensIsoSectionsFamily F U).symm sf
hsf' : leftRes F U sf' = rightRes F U sf'
⊢ ∃! s, IsGluing F U sf s
[PROOFSTEP]
choose s s_spec s_uniq using Types.unique_of_type_equalizer _ _ (Fsh U).some sf' hsf'
[GOAL]
C : Type u
inst✝² : Category.{v, u} C
inst✝¹ : ConcreteCategory C
X : TopCat
F : Presheaf (Type u) X
ι✝ : Type x
U✝ : ι✝ → Opens ↑X
inst✝ : UnivLE.{x, u}
Fsh✝ : IsSheaf F
Fsh : IsSheafEqualizerProducts F
ι : Type x
U : ι → Opens ↑X
sf : (i : ι) → (forget (Type u)).obj (F.obj (op (U i)))
hsf : IsCompatible F U sf
sf' : (fun x => piOpens F U) sf := ↑(piOpensIsoSectionsFamily F U).symm sf
hsf' : leftRes F U sf' = rightRes F U sf'
s : F.obj (op (iSup U))
s_spec : res F U s = sf'
s_uniq : ∀ (y : F.obj (op (iSup U))), (fun x => res F U x = sf') y → y = s
⊢ ∃! s, IsGluing F U sf s
[PROOFSTEP]
use s
[GOAL]
case h
C : Type u
inst✝² : Category.{v, u} C
inst✝¹ : ConcreteCategory C
X : TopCat
F : Presheaf (Type u) X
ι✝ : Type x
U✝ : ι✝ → Opens ↑X
inst✝ : UnivLE.{x, u}
Fsh✝ : IsSheaf F
Fsh : IsSheafEqualizerProducts F
ι : Type x
U : ι → Opens ↑X
sf : (i : ι) → (forget (Type u)).obj (F.obj (op (U i)))
hsf : IsCompatible F U sf
sf' : (fun x => piOpens F U) sf := ↑(piOpensIsoSectionsFamily F U).symm sf
hsf' : leftRes F U sf' = rightRes F U sf'
s : F.obj (op (iSup U))
s_spec : res F U s = sf'
s_uniq : ∀ (y : F.obj (op (iSup U))), (fun x => res F U x = sf') y → y = s
⊢ (fun s => IsGluing F U sf s) s ∧
    ∀ (y : (forget (Type u)).obj (F.obj (op (iSup U)))), (fun s => IsGluing F U sf s) y → y = s
[PROOFSTEP]
dsimp
[GOAL]
case h
C : Type u
inst✝² : Category.{v, u} C
inst✝¹ : ConcreteCategory C
X : TopCat
F : Presheaf (Type u) X
ι✝ : Type x
U✝ : ι✝ → Opens ↑X
inst✝ : UnivLE.{x, u}
Fsh✝ : IsSheaf F
Fsh : IsSheafEqualizerProducts F
ι : Type x
U : ι → Opens ↑X
sf : (i : ι) → (forget (Type u)).obj (F.obj (op (U i)))
hsf : IsCompatible F U sf
sf' : (fun x => piOpens F U) sf := ↑(piOpensIsoSectionsFamily F U).symm sf
hsf' : leftRes F U sf' = rightRes F U sf'
s : F.obj (op (iSup U))
s_spec : res F U s = sf'
s_uniq : ∀ (y : F.obj (op (iSup U))), (fun x => res F U x = sf') y → y = s
⊢ IsGluing F U sf s ∧ ∀ (y : (forget (Type u)).obj (F.obj (op (iSup U)))), IsGluing F U sf y → y = s
[PROOFSTEP]
constructor
[GOAL]
case h.left
C : Type u
inst✝² : Category.{v, u} C
inst✝¹ : ConcreteCategory C
X : TopCat
F : Presheaf (Type u) X
ι✝ : Type x
U✝ : ι✝ → Opens ↑X
inst✝ : UnivLE.{x, u}
Fsh✝ : IsSheaf F
Fsh : IsSheafEqualizerProducts F
ι : Type x
U : ι → Opens ↑X
sf : (i : ι) → (forget (Type u)).obj (F.obj (op (U i)))
hsf : IsCompatible F U sf
sf' : (fun x => piOpens F U) sf := ↑(piOpensIsoSectionsFamily F U).symm sf
hsf' : leftRes F U sf' = rightRes F U sf'
s : F.obj (op (iSup U))
s_spec : res F U s = sf'
s_uniq : ∀ (y : F.obj (op (iSup U))), (fun x => res F U x = sf') y → y = s
⊢ IsGluing F U sf s
[PROOFSTEP]
convert (isGluing_iff_eq_res F U sf' _).mpr s_spec
[GOAL]
case h.e'_8
C : Type u
inst✝² : Category.{v, u} C
inst✝¹ : ConcreteCategory C
X : TopCat
F : Presheaf (Type u) X
ι✝ : Type x
U✝ : ι✝ → Opens ↑X
inst✝ : UnivLE.{x, u}
Fsh✝ : IsSheaf F
Fsh : IsSheafEqualizerProducts F
ι : Type x
U : ι → Opens ↑X
sf : (i : ι) → (forget (Type u)).obj (F.obj (op (U i)))
hsf : IsCompatible F U sf
sf' : (fun x => piOpens F U) sf := ↑(piOpensIsoSectionsFamily F U).symm sf
hsf' : leftRes F U sf' = rightRes F U sf'
s : F.obj (op (iSup U))
s_spec : res F U s = sf'
s_uniq : ∀ (y : F.obj (op (iSup U))), (fun x => res F U x = sf') y → y = s
⊢ sf = ↑(piOpensIsoSectionsFamily F U) sf'
[PROOFSTEP]
simp only [Equiv.apply_symm_apply]
[GOAL]
case h.right
C : Type u
inst✝² : Category.{v, u} C
inst✝¹ : ConcreteCategory C
X : TopCat
F : Presheaf (Type u) X
ι✝ : Type x
U✝ : ι✝ → Opens ↑X
inst✝ : UnivLE.{x, u}
Fsh✝ : IsSheaf F
Fsh : IsSheafEqualizerProducts F
ι : Type x
U : ι → Opens ↑X
sf : (i : ι) → (forget (Type u)).obj (F.obj (op (U i)))
hsf : IsCompatible F U sf
sf' : (fun x => piOpens F U) sf := ↑(piOpensIsoSectionsFamily F U).symm sf
hsf' : leftRes F U sf' = rightRes F U sf'
s : F.obj (op (iSup U))
s_spec : res F U s = sf'
s_uniq : ∀ (y : F.obj (op (iSup U))), (fun x => res F U x = sf') y → y = s
⊢ ∀ (y : (forget (Type u)).obj (F.obj (op (iSup U)))), IsGluing F U sf y → y = s
[PROOFSTEP]
intro y hy
[GOAL]
case h.right
C : Type u
inst✝² : Category.{v, u} C
inst✝¹ : ConcreteCategory C
X : TopCat
F : Presheaf (Type u) X
ι✝ : Type x
U✝ : ι✝ → Opens ↑X
inst✝ : UnivLE.{x, u}
Fsh✝ : IsSheaf F
Fsh : IsSheafEqualizerProducts F
ι : Type x
U : ι → Opens ↑X
sf : (i : ι) → (forget (Type u)).obj (F.obj (op (U i)))
hsf : IsCompatible F U sf
sf' : (fun x => piOpens F U) sf := ↑(piOpensIsoSectionsFamily F U).symm sf
hsf' : leftRes F U sf' = rightRes F U sf'
s : F.obj (op (iSup U))
s_spec : res F U s = sf'
s_uniq : ∀ (y : F.obj (op (iSup U))), (fun x => res F U x = sf') y → y = s
y : (forget (Type u)).obj (F.obj (op (iSup U)))
hy : IsGluing F U sf y
⊢ y = s
[PROOFSTEP]
apply s_uniq
[GOAL]
case h.right.a
C : Type u
inst✝² : Category.{v, u} C
inst✝¹ : ConcreteCategory C
X : TopCat
F : Presheaf (Type u) X
ι✝ : Type x
U✝ : ι✝ → Opens ↑X
inst✝ : UnivLE.{x, u}
Fsh✝ : IsSheaf F
Fsh : IsSheafEqualizerProducts F
ι : Type x
U : ι → Opens ↑X
sf : (i : ι) → (forget (Type u)).obj (F.obj (op (U i)))
hsf : IsCompatible F U sf
sf' : (fun x => piOpens F U) sf := ↑(piOpensIsoSectionsFamily F U).symm sf
hsf' : leftRes F U sf' = rightRes F U sf'
s : F.obj (op (iSup U))
s_spec : res F U s = sf'
s_uniq : ∀ (y : F.obj (op (iSup U))), (fun x => res F U x = sf') y → y = s
y : (forget (Type u)).obj (F.obj (op (iSup U)))
hy : IsGluing F U sf y
⊢ res F U y = sf'
[PROOFSTEP]
rw [← isGluing_iff_eq_res F U]
[GOAL]
case h.right.a
C : Type u
inst✝² : Category.{v, u} C
inst✝¹ : ConcreteCategory C
X : TopCat
F : Presheaf (Type u) X
ι✝ : Type x
U✝ : ι✝ → Opens ↑X
inst✝ : UnivLE.{x, u}
Fsh✝ : IsSheaf F
Fsh : IsSheafEqualizerProducts F
ι : Type x
U : ι → Opens ↑X
sf : (i : ι) → (forget (Type u)).obj (F.obj (op (U i)))
hsf : IsCompatible F U sf
sf' : (fun x => piOpens F U) sf := ↑(piOpensIsoSectionsFamily F U).symm sf
hsf' : leftRes F U sf' = rightRes F U sf'
s : F.obj (op (iSup U))
s_spec : res F U s = sf'
s_uniq : ∀ (y : F.obj (op (iSup U))), (fun x => res F U x = sf') y → y = s
y : (forget (Type u)).obj (F.obj (op (iSup U)))
hy : IsGluing F U sf y
⊢ IsGluing F U (↑(piOpensIsoSectionsFamily F U) sf') y
[PROOFSTEP]
convert hy
[GOAL]
case h.e'_8
C : Type u
inst✝² : Category.{v, u} C
inst✝¹ : ConcreteCategory C
X : TopCat
F : Presheaf (Type u) X
ι✝ : Type x
U✝ : ι✝ → Opens ↑X
inst✝ : UnivLE.{x, u}
Fsh✝ : IsSheaf F
Fsh : IsSheafEqualizerProducts F
ι : Type x
U : ι → Opens ↑X
sf : (i : ι) → (forget (Type u)).obj (F.obj (op (U i)))
hsf : IsCompatible F U sf
sf' : (fun x => piOpens F U) sf := ↑(piOpensIsoSectionsFamily F U).symm sf
hsf' : leftRes F U sf' = rightRes F U sf'
s : F.obj (op (iSup U))
s_spec : res F U s = sf'
s_uniq : ∀ (y : F.obj (op (iSup U))), (fun x => res F U x = sf') y → y = s
y : (forget (Type u)).obj (F.obj (op (iSup U)))
hy : IsGluing F U sf y
⊢ ↑(piOpensIsoSectionsFamily F U) sf' = sf
[PROOFSTEP]
simp only [Equiv.apply_symm_apply]
[GOAL]
C : Type u
inst✝⁴ : Category.{v, u} C
inst✝³ : ConcreteCategory C
inst✝² : HasLimits C
inst✝¹ : ReflectsIsomorphisms ConcreteCategory.forget
inst✝ : PreservesLimits ConcreteCategory.forget
X : TopCat
F : Sheaf C X
ι : Type v
U : ι → Opens ↑X
V : Opens ↑X
iUV : (i : ι) → U i ⟶ V
hcover : V ≤ iSup U
sf : (i : ι) → (CategoryTheory.forget C).obj (F.val.obj (op (U i)))
h : IsCompatible F.val U sf
⊢ ∃! s, ∀ (i : ι), ↑(F.val.map (iUV i).op) s = sf i
[PROOFSTEP]
have V_eq_supr_U : V = iSup U := le_antisymm hcover (iSup_le fun i => (iUV i).le)
[GOAL]
C : Type u
inst✝⁴ : Category.{v, u} C
inst✝³ : ConcreteCategory C
inst✝² : HasLimits C
inst✝¹ : ReflectsIsomorphisms ConcreteCategory.forget
inst✝ : PreservesLimits ConcreteCategory.forget
X : TopCat
F : Sheaf C X
ι : Type v
U : ι → Opens ↑X
V : Opens ↑X
iUV : (i : ι) → U i ⟶ V
hcover : V ≤ iSup U
sf : (i : ι) → (CategoryTheory.forget C).obj (F.val.obj (op (U i)))
h : IsCompatible F.val U sf
V_eq_supr_U : V = iSup U
⊢ ∃! s, ∀ (i : ι), ↑(F.val.map (iUV i).op) s = sf i
[PROOFSTEP]
obtain ⟨gl, gl_spec, gl_uniq⟩ := F.existsUnique_gluing U sf h
[GOAL]
case intro.intro
C : Type u
inst✝⁴ : Category.{v, u} C
inst✝³ : ConcreteCategory C
inst✝² : HasLimits C
inst✝¹ : ReflectsIsomorphisms ConcreteCategory.forget
inst✝ : PreservesLimits ConcreteCategory.forget
X : TopCat
F : Sheaf C X
ι : Type v
U : ι → Opens ↑X
V : Opens ↑X
iUV : (i : ι) → U i ⟶ V
hcover : V ≤ iSup U
sf : (i : ι) → (CategoryTheory.forget C).obj (F.val.obj (op (U i)))
h : IsCompatible F.val U sf
V_eq_supr_U : V = iSup U
gl : (CategoryTheory.forget C).obj (F.val.obj (op (iSup U)))
gl_spec : IsGluing F.val U sf gl
gl_uniq : ∀ (y : (CategoryTheory.forget C).obj (F.val.obj (op (iSup U)))), (fun s => IsGluing F.val U sf s) y → y = gl
⊢ ∃! s, ∀ (i : ι), ↑(F.val.map (iUV i).op) s = sf i
[PROOFSTEP]
refine' ⟨F.1.map (eqToHom V_eq_supr_U).op gl, _, _⟩
[GOAL]
case intro.intro.refine'_1
C : Type u
inst✝⁴ : Category.{v, u} C
inst✝³ : ConcreteCategory C
inst✝² : HasLimits C
inst✝¹ : ReflectsIsomorphisms ConcreteCategory.forget
inst✝ : PreservesLimits ConcreteCategory.forget
X : TopCat
F : Sheaf C X
ι : Type v
U : ι → Opens ↑X
V : Opens ↑X
iUV : (i : ι) → U i ⟶ V
hcover : V ≤ iSup U
sf : (i : ι) → (CategoryTheory.forget C).obj (F.val.obj (op (U i)))
h : IsCompatible F.val U sf
V_eq_supr_U : V = iSup U
gl : (CategoryTheory.forget C).obj (F.val.obj (op (iSup U)))
gl_spec : IsGluing F.val U sf gl
gl_uniq : ∀ (y : (CategoryTheory.forget C).obj (F.val.obj (op (iSup U)))), (fun s => IsGluing F.val U sf s) y → y = gl
⊢ (fun s => ∀ (i : ι), ↑(F.val.map (iUV i).op) s = sf i) (↑(F.val.map (eqToHom V_eq_supr_U).op) gl)
[PROOFSTEP]
intro i
[GOAL]
case intro.intro.refine'_1
C : Type u
inst✝⁴ : Category.{v, u} C
inst✝³ : ConcreteCategory C
inst✝² : HasLimits C
inst✝¹ : ReflectsIsomorphisms ConcreteCategory.forget
inst✝ : PreservesLimits ConcreteCategory.forget
X : TopCat
F : Sheaf C X
ι : Type v
U : ι → Opens ↑X
V : Opens ↑X
iUV : (i : ι) → U i ⟶ V
hcover : V ≤ iSup U
sf : (i : ι) → (CategoryTheory.forget C).obj (F.val.obj (op (U i)))
h : IsCompatible F.val U sf
V_eq_supr_U : V = iSup U
gl : (CategoryTheory.forget C).obj (F.val.obj (op (iSup U)))
gl_spec : IsGluing F.val U sf gl
gl_uniq : ∀ (y : (CategoryTheory.forget C).obj (F.val.obj (op (iSup U)))), (fun s => IsGluing F.val U sf s) y → y = gl
i : ι
⊢ ↑(F.val.map (iUV i).op) (↑(F.val.map (eqToHom V_eq_supr_U).op) gl) = sf i
[PROOFSTEP]
rw [← comp_apply, ← F.1.map_comp]
[GOAL]
case intro.intro.refine'_1
C : Type u
inst✝⁴ : Category.{v, u} C
inst✝³ : ConcreteCategory C
inst✝² : HasLimits C
inst✝¹ : ReflectsIsomorphisms ConcreteCategory.forget
inst✝ : PreservesLimits ConcreteCategory.forget
X : TopCat
F : Sheaf C X
ι : Type v
U : ι → Opens ↑X
V : Opens ↑X
iUV : (i : ι) → U i ⟶ V
hcover : V ≤ iSup U
sf : (i : ι) → (CategoryTheory.forget C).obj (F.val.obj (op (U i)))
h : IsCompatible F.val U sf
V_eq_supr_U : V = iSup U
gl : (CategoryTheory.forget C).obj (F.val.obj (op (iSup U)))
gl_spec : IsGluing F.val U sf gl
gl_uniq : ∀ (y : (CategoryTheory.forget C).obj (F.val.obj (op (iSup U)))), (fun s => IsGluing F.val U sf s) y → y = gl
i : ι
⊢ ↑(F.val.map ((eqToHom V_eq_supr_U).op ≫ (iUV i).op)) gl = sf i
[PROOFSTEP]
exact gl_spec i
[GOAL]
case intro.intro.refine'_2
C : Type u
inst✝⁴ : Category.{v, u} C
inst✝³ : ConcreteCategory C
inst✝² : HasLimits C
inst✝¹ : ReflectsIsomorphisms ConcreteCategory.forget
inst✝ : PreservesLimits ConcreteCategory.forget
X : TopCat
F : Sheaf C X
ι : Type v
U : ι → Opens ↑X
V : Opens ↑X
iUV : (i : ι) → U i ⟶ V
hcover : V ≤ iSup U
sf : (i : ι) → (CategoryTheory.forget C).obj (F.val.obj (op (U i)))
h : IsCompatible F.val U sf
V_eq_supr_U : V = iSup U
gl : (CategoryTheory.forget C).obj (F.val.obj (op (iSup U)))
gl_spec : IsGluing F.val U sf gl
gl_uniq : ∀ (y : (CategoryTheory.forget C).obj (F.val.obj (op (iSup U)))), (fun s => IsGluing F.val U sf s) y → y = gl
⊢ ∀ (y : (CategoryTheory.forget C).obj (F.val.obj (op V))),
    (fun s => ∀ (i : ι), ↑(F.val.map (iUV i).op) s = sf i) y → y = ↑(F.val.map (eqToHom V_eq_supr_U).op) gl
[PROOFSTEP]
intro gl' gl'_spec
[GOAL]
case intro.intro.refine'_2
C : Type u
inst✝⁴ : Category.{v, u} C
inst✝³ : ConcreteCategory C
inst✝² : HasLimits C
inst✝¹ : ReflectsIsomorphisms ConcreteCategory.forget
inst✝ : PreservesLimits ConcreteCategory.forget
X : TopCat
F : Sheaf C X
ι : Type v
U : ι → Opens ↑X
V : Opens ↑X
iUV : (i : ι) → U i ⟶ V
hcover : V ≤ iSup U
sf : (i : ι) → (CategoryTheory.forget C).obj (F.val.obj (op (U i)))
h : IsCompatible F.val U sf
V_eq_supr_U : V = iSup U
gl : (CategoryTheory.forget C).obj (F.val.obj (op (iSup U)))
gl_spec : IsGluing F.val U sf gl
gl_uniq : ∀ (y : (CategoryTheory.forget C).obj (F.val.obj (op (iSup U)))), (fun s => IsGluing F.val U sf s) y → y = gl
gl' : (CategoryTheory.forget C).obj (F.val.obj (op V))
gl'_spec : ∀ (i : ι), ↑(F.val.map (iUV i).op) gl' = sf i
⊢ gl' = ↑(F.val.map (eqToHom V_eq_supr_U).op) gl
[PROOFSTEP]
convert congr_arg _ (gl_uniq (F.1.map (eqToHom V_eq_supr_U.symm).op gl') fun i => _)
[GOAL]
case h.e'_2
C : Type u
inst✝⁴ : Category.{v, u} C
inst✝³ : ConcreteCategory C
inst✝² : HasLimits C
inst✝¹ : ReflectsIsomorphisms ConcreteCategory.forget
inst✝ : PreservesLimits ConcreteCategory.forget
X : TopCat
F : Sheaf C X
ι : Type v
U : ι → Opens ↑X
V : Opens ↑X
iUV : (i : ι) → U i ⟶ V
hcover : V ≤ iSup U
sf : (i : ι) → (CategoryTheory.forget C).obj (F.val.obj (op (U i)))
h : IsCompatible F.val U sf
V_eq_supr_U : V = iSup U
gl : (CategoryTheory.forget C).obj (F.val.obj (op (iSup U)))
gl_spec : IsGluing F.val U sf gl
gl_uniq : ∀ (y : (CategoryTheory.forget C).obj (F.val.obj (op (iSup U)))), (fun s => IsGluing F.val U sf s) y → y = gl
gl' : (CategoryTheory.forget C).obj (F.val.obj (op V))
gl'_spec : ∀ (i : ι), ↑(F.val.map (iUV i).op) gl' = sf i
⊢ gl' = ↑(F.val.map (eqToHom V_eq_supr_U).op) (↑(F.val.map (eqToHom (_ : iSup U = V)).op) gl')
[PROOFSTEP]
rw [← comp_apply, ← F.1.map_comp]
[GOAL]
case intro.intro.refine'_2.convert_3
C : Type u
inst✝⁴ : Category.{v, u} C
inst✝³ : ConcreteCategory C
inst✝² : HasLimits C
inst✝¹ : ReflectsIsomorphisms ConcreteCategory.forget
inst✝ : PreservesLimits ConcreteCategory.forget
X : TopCat
F : Sheaf C X
ι : Type v
U : ι → Opens ↑X
V : Opens ↑X
iUV : (i : ι) → U i ⟶ V
hcover : V ≤ iSup U
sf : (i : ι) → (CategoryTheory.forget C).obj (F.val.obj (op (U i)))
h : IsCompatible F.val U sf
V_eq_supr_U : V = iSup U
gl : (CategoryTheory.forget C).obj (F.val.obj (op (iSup U)))
gl_spec : IsGluing F.val U sf gl
gl_uniq : ∀ (y : (CategoryTheory.forget C).obj (F.val.obj (op (iSup U)))), (fun s => IsGluing F.val U sf s) y → y = gl
gl' : (CategoryTheory.forget C).obj (F.val.obj (op V))
gl'_spec : ∀ (i : ι), ↑(F.val.map (iUV i).op) gl' = sf i
i : ι
⊢ ↑(F.val.map (leSupr U i).op) (↑(F.val.map (eqToHom (_ : iSup U = V)).op) gl') = sf i
[PROOFSTEP]
rw [← comp_apply, ← F.1.map_comp]
[GOAL]
case h.e'_2
C : Type u
inst✝⁴ : Category.{v, u} C
inst✝³ : ConcreteCategory C
inst✝² : HasLimits C
inst✝¹ : ReflectsIsomorphisms ConcreteCategory.forget
inst✝ : PreservesLimits ConcreteCategory.forget
X : TopCat
F : Sheaf C X
ι : Type v
U : ι → Opens ↑X
V : Opens ↑X
iUV : (i : ι) → U i ⟶ V
hcover : V ≤ iSup U
sf : (i : ι) → (CategoryTheory.forget C).obj (F.val.obj (op (U i)))
h : IsCompatible F.val U sf
V_eq_supr_U : V = iSup U
gl : (CategoryTheory.forget C).obj (F.val.obj (op (iSup U)))
gl_spec : IsGluing F.val U sf gl
gl_uniq : ∀ (y : (CategoryTheory.forget C).obj (F.val.obj (op (iSup U)))), (fun s => IsGluing F.val U sf s) y → y = gl
gl' : (CategoryTheory.forget C).obj (F.val.obj (op V))
gl'_spec : ∀ (i : ι), ↑(F.val.map (iUV i).op) gl' = sf i
⊢ gl' = ↑(F.val.map ((eqToHom (_ : iSup U = V)).op ≫ (eqToHom V_eq_supr_U).op)) gl'
[PROOFSTEP]
rw [eqToHom_op, eqToHom_op, eqToHom_trans, eqToHom_refl, F.1.map_id, id_apply]
[GOAL]
case intro.intro.refine'_2.convert_3
C : Type u
inst✝⁴ : Category.{v, u} C
inst✝³ : ConcreteCategory C
inst✝² : HasLimits C
inst✝¹ : ReflectsIsomorphisms ConcreteCategory.forget
inst✝ : PreservesLimits ConcreteCategory.forget
X : TopCat
F : Sheaf C X
ι : Type v
U : ι → Opens ↑X
V : Opens ↑X
iUV : (i : ι) → U i ⟶ V
hcover : V ≤ iSup U
sf : (i : ι) → (CategoryTheory.forget C).obj (F.val.obj (op (U i)))
h : IsCompatible F.val U sf
V_eq_supr_U : V = iSup U
gl : (CategoryTheory.forget C).obj (F.val.obj (op (iSup U)))
gl_spec : IsGluing F.val U sf gl
gl_uniq : ∀ (y : (CategoryTheory.forget C).obj (F.val.obj (op (iSup U)))), (fun s => IsGluing F.val U sf s) y → y = gl
gl' : (CategoryTheory.forget C).obj (F.val.obj (op V))
gl'_spec : ∀ (i : ι), ↑(F.val.map (iUV i).op) gl' = sf i
i : ι
⊢ ↑(F.val.map ((eqToHom (_ : iSup U = V)).op ≫ (leSupr U i).op)) gl' = sf i
[PROOFSTEP]
convert gl'_spec i
[GOAL]
C : Type u
inst✝⁴ : Category.{v, u} C
inst✝³ : ConcreteCategory C
inst✝² : HasLimits C
inst✝¹ : ReflectsIsomorphisms ConcreteCategory.forget
inst✝ : PreservesLimits ConcreteCategory.forget
X : TopCat
F : Sheaf C X
ι : Type v
U : ι → Opens ↑X
s t : (CategoryTheory.forget C).obj (F.val.obj (op (iSup U)))
h : ∀ (i : ι), ↑(F.val.map (leSupr U i).op) s = ↑(F.val.map (leSupr U i).op) t
⊢ s = t
[PROOFSTEP]
let sf : ∀ i : ι, F.1.obj (op (U i)) := fun i => F.1.map (Opens.leSupr U i).op s
[GOAL]
C : Type u
inst✝⁴ : Category.{v, u} C
inst✝³ : ConcreteCategory C
inst✝² : HasLimits C
inst✝¹ : ReflectsIsomorphisms ConcreteCategory.forget
inst✝ : PreservesLimits ConcreteCategory.forget
X : TopCat
F : Sheaf C X
ι : Type v
U : ι → Opens ↑X
s t : (CategoryTheory.forget C).obj (F.val.obj (op (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 (op (U i))) := fun i => ↑(F.val.map (leSupr U i).op) s
⊢ s = t
[PROOFSTEP]
have sf_compatible : IsCompatible _ U sf := by
  intro i j
  simp_rw [← comp_apply, ← F.1.map_comp]
  rfl
[GOAL]
C : Type u
inst✝⁴ : Category.{v, u} C
inst✝³ : ConcreteCategory C
inst✝² : HasLimits C
inst✝¹ : ReflectsIsomorphisms ConcreteCategory.forget
inst✝ : PreservesLimits ConcreteCategory.forget
X : TopCat
F : Sheaf C X
ι : Type v
U : ι → Opens ↑X
s t : (CategoryTheory.forget C).obj (F.val.obj (op (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 (op (U i))) := fun i => ↑(F.val.map (leSupr U i).op) s
⊢ IsCompatible F.val U sf
[PROOFSTEP]
intro i j
[GOAL]
C : Type u
inst✝⁴ : Category.{v, u} C
inst✝³ : ConcreteCategory C
inst✝² : HasLimits C
inst✝¹ : ReflectsIsomorphisms ConcreteCategory.forget
inst✝ : PreservesLimits ConcreteCategory.forget
X : TopCat
F : Sheaf C X
ι : Type v
U : ι → Opens ↑X
s t : (CategoryTheory.forget C).obj (F.val.obj (op (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 (op (U i))) := fun i => ↑(F.val.map (leSupr U i).op) s
i j : ι
⊢ ↑(F.val.map (infLELeft (U i) (U j)).op) (sf i) = ↑(F.val.map (infLERight (U i) (U j)).op) (sf j)
[PROOFSTEP]
simp_rw [← comp_apply, ← F.1.map_comp]
[GOAL]
C : Type u
inst✝⁴ : Category.{v, u} C
inst✝³ : ConcreteCategory C
inst✝² : HasLimits C
inst✝¹ : ReflectsIsomorphisms ConcreteCategory.forget
inst✝ : PreservesLimits ConcreteCategory.forget
X : TopCat
F : Sheaf C X
ι : Type v
U : ι → Opens ↑X
s t : (CategoryTheory.forget C).obj (F.val.obj (op (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 (op (U i))) := fun i => ↑(F.val.map (leSupr U i).op) s
i j : ι
⊢ ↑(F.val.map ((leSupr U i).op ≫ (infLELeft (U i) (U j)).op)) s =
    ↑(F.val.map ((leSupr U j).op ≫ (infLERight (U i) (U j)).op)) s
[PROOFSTEP]
rfl
[GOAL]
C : Type u
inst✝⁴ : Category.{v, u} C
inst✝³ : ConcreteCategory C
inst✝² : HasLimits C
inst✝¹ : ReflectsIsomorphisms ConcreteCategory.forget
inst✝ : PreservesLimits ConcreteCategory.forget
X : TopCat
F : Sheaf C X
ι : Type v
U : ι → Opens ↑X
s t : (CategoryTheory.forget C).obj (F.val.obj (op (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 (op (U i))) := fun i => ↑(F.val.map (leSupr U i).op) s
sf_compatible : IsCompatible F.val U sf
⊢ s = t
[PROOFSTEP]
obtain ⟨gl, -, gl_uniq⟩ := F.existsUnique_gluing U sf sf_compatible
[GOAL]
case intro.intro
C : Type u
inst✝⁴ : Category.{v, u} C
inst✝³ : ConcreteCategory C
inst✝² : HasLimits C
inst✝¹ : ReflectsIsomorphisms ConcreteCategory.forget
inst✝ : PreservesLimits ConcreteCategory.forget
X : TopCat
F : Sheaf C X
ι : Type v
U : ι → Opens ↑X
s t : (CategoryTheory.forget C).obj (F.val.obj (op (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 (op (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 (op (iSup U)))
gl_uniq : ∀ (y : (CategoryTheory.forget C).obj (F.val.obj (op (iSup U)))), (fun s => IsGluing F.val U sf s) y → y = gl
⊢ s = t
[PROOFSTEP]
trans gl
[GOAL]
C : Type u
inst✝⁴ : Category.{v, u} C
inst✝³ : ConcreteCategory C
inst✝² : HasLimits C
inst✝¹ : ReflectsIsomorphisms ConcreteCategory.forget
inst✝ : PreservesLimits ConcreteCategory.forget
X : TopCat
F : Sheaf C X
ι : Type v
U : ι → Opens ↑X
s t : (CategoryTheory.forget C).obj (F.val.obj (op (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 (op (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 (op (iSup U)))
gl_uniq : ∀ (y : (CategoryTheory.forget C).obj (F.val.obj (op (iSup U)))), (fun s => IsGluing F.val U sf s) y → y = gl
⊢ s = gl
[PROOFSTEP]
apply gl_uniq
[GOAL]
case a
C : Type u
inst✝⁴ : Category.{v, u} C
inst✝³ : ConcreteCategory C
inst✝² : HasLimits C
inst✝¹ : ReflectsIsomorphisms ConcreteCategory.forget
inst✝ : PreservesLimits ConcreteCategory.forget
X : TopCat
F : Sheaf C X
ι : Type v
U : ι → Opens ↑X
s t : (CategoryTheory.forget C).obj (F.val.obj (op (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 (op (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 (op (iSup U)))
gl_uniq : ∀ (y : (CategoryTheory.forget C).obj (F.val.obj (op (iSup U)))), (fun s => IsGluing F.val U sf s) y → y = gl
⊢ IsGluing F.val U sf s
[PROOFSTEP]
intro i
[GOAL]
case a
C : Type u
inst✝⁴ : Category.{v, u} C
inst✝³ : ConcreteCategory C
inst✝² : HasLimits C
inst✝¹ : ReflectsIsomorphisms ConcreteCategory.forget
inst✝ : PreservesLimits ConcreteCategory.forget
X : TopCat
F : Sheaf C X
ι : Type v
U : ι → Opens ↑X
s t : (CategoryTheory.forget C).obj (F.val.obj (op (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 (op (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 (op (iSup U)))
gl_uniq : ∀ (y : (CategoryTheory.forget C).obj (F.val.obj (op (iSup U)))), (fun s => IsGluing F.val U sf s) y → y = gl
i : ι
⊢ ↑(F.val.map (leSupr U i).op) s = sf i
[PROOFSTEP]
rfl
[GOAL]
C : Type u
inst✝⁴ : Category.{v, u} C
inst✝³ : ConcreteCategory C
inst✝² : HasLimits C
inst✝¹ : ReflectsIsomorphisms ConcreteCategory.forget
inst✝ : PreservesLimits ConcreteCategory.forget
X : TopCat
F : Sheaf C X
ι : Type v
U : ι → Opens ↑X
s t : (CategoryTheory.forget C).obj (F.val.obj (op (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 (op (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 (op (iSup U)))
gl_uniq : ∀ (y : (CategoryTheory.forget C).obj (F.val.obj (op (iSup U)))), (fun s => IsGluing F.val U sf s) y → y = gl
⊢ gl = t
[PROOFSTEP]
symm
[GOAL]
C : Type u
inst✝⁴ : Category.{v, u} C
inst✝³ : ConcreteCategory C
inst✝² : HasLimits C
inst✝¹ : ReflectsIsomorphisms ConcreteCategory.forget
inst✝ : PreservesLimits ConcreteCategory.forget
X : TopCat
F : Sheaf C X
ι : Type v
U : ι → Opens ↑X
s t : (CategoryTheory.forget C).obj (F.val.obj (op (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 (op (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 (op (iSup U)))
gl_uniq : ∀ (y : (CategoryTheory.forget C).obj (F.val.obj (op (iSup U)))), (fun s => IsGluing F.val U sf s) y → y = gl
⊢ t = gl
[PROOFSTEP]
apply gl_uniq
[GOAL]
case a
C : Type u
inst✝⁴ : Category.{v, u} C
inst✝³ : ConcreteCategory C
inst✝² : HasLimits C
inst✝¹ : ReflectsIsomorphisms ConcreteCategory.forget
inst✝ : PreservesLimits ConcreteCategory.forget
X : TopCat
F : Sheaf C X
ι : Type v
U : ι → Opens ↑X
s t : (CategoryTheory.forget C).obj (F.val.obj (op (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 (op (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 (op (iSup U)))
gl_uniq : ∀ (y : (CategoryTheory.forget C).obj (F.val.obj (op (iSup U)))), (fun s => IsGluing F.val U sf s) y → y = gl
⊢ IsGluing F.val U sf t
[PROOFSTEP]
intro i
[GOAL]
case a
C : Type u
inst✝⁴ : Category.{v, u} C
inst✝³ : ConcreteCategory C
inst✝² : HasLimits C
inst✝¹ : ReflectsIsomorphisms ConcreteCategory.forget
inst✝ : PreservesLimits ConcreteCategory.forget
X : TopCat
F : Sheaf C X
ι : Type v
U : ι → Opens ↑X
s t : (CategoryTheory.forget C).obj (F.val.obj (op (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 (op (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 (op (iSup U)))
gl_uniq : ∀ (y : (CategoryTheory.forget C).obj (F.val.obj (op (iSup U)))), (fun s => IsGluing F.val U sf s) y → y = gl
i : ι
⊢ ↑(F.val.map (leSupr U i).op) t = sf i
[PROOFSTEP]
rw [← h]
[GOAL]
C : Type u
inst✝⁴ : Category.{v, u} C
inst✝³ : ConcreteCategory C
inst✝² : HasLimits C
inst✝¹ : ReflectsIsomorphisms ConcreteCategory.forget
inst✝ : PreservesLimits ConcreteCategory.forget
X : TopCat
F : Sheaf C X
ι : Type v
U : ι → Opens ↑X
V : Opens ↑X
iUV : (i : ι) → U i ⟶ V
hcover : V ≤ iSup U
s t : (CategoryTheory.forget C).obj (F.val.obj (op V))
h : ∀ (i : ι), ↑(F.val.map (iUV i).op) s = ↑(F.val.map (iUV i).op) t
⊢ s = t
[PROOFSTEP]
have V_eq_supr_U : V = iSup U := le_antisymm hcover (iSup_le fun i => (iUV i).le)
[GOAL]
C : Type u
inst✝⁴ : Category.{v, u} C
inst✝³ : ConcreteCategory C
inst✝² : HasLimits C
inst✝¹ : ReflectsIsomorphisms ConcreteCategory.forget
inst✝ : PreservesLimits ConcreteCategory.forget
X : TopCat
F : Sheaf C X
ι : Type v
U : ι → Opens ↑X
V : Opens ↑X
iUV : (i : ι) → U i ⟶ V
hcover : V ≤ iSup U
s t : (CategoryTheory.forget C).obj (F.val.obj (op V))
h : ∀ (i : ι), ↑(F.val.map (iUV i).op) s = ↑(F.val.map (iUV i).op) t
V_eq_supr_U : V = iSup U
⊢ s = t
[PROOFSTEP]
suffices F.1.map (eqToHom V_eq_supr_U.symm).op s = F.1.map (eqToHom V_eq_supr_U.symm).op t by
  convert congr_arg (F.1.map (eqToHom V_eq_supr_U).op) this <;>
    rw [← comp_apply, ← F.1.map_comp, eqToHom_op, eqToHom_op, eqToHom_trans, eqToHom_refl, F.1.map_id, id_apply]
[GOAL]
C : Type u
inst✝⁴ : Category.{v, u} C
inst✝³ : ConcreteCategory C
inst✝² : HasLimits C
inst✝¹ : ReflectsIsomorphisms ConcreteCategory.forget
inst✝ : PreservesLimits ConcreteCategory.forget
X : TopCat
F : Sheaf C X
ι : Type v
U : ι → Opens ↑X
V : Opens ↑X
iUV : (i : ι) → U i ⟶ V
hcover : V ≤ iSup U
s t : (CategoryTheory.forget C).obj (F.val.obj (op V))
h : ∀ (i : ι), ↑(F.val.map (iUV i).op) s = ↑(F.val.map (iUV i).op) t
V_eq_supr_U : V = iSup U
this : ↑(F.val.map (eqToHom (_ : iSup U = V)).op) s = ↑(F.val.map (eqToHom (_ : iSup U = V)).op) t
⊢ s = t
[PROOFSTEP]
convert congr_arg (F.1.map (eqToHom V_eq_supr_U).op) this
[GOAL]
case h.e'_2
C : Type u
inst✝⁴ : Category.{v, u} C
inst✝³ : ConcreteCategory C
inst✝² : HasLimits C
inst✝¹ : ReflectsIsomorphisms ConcreteCategory.forget
inst✝ : PreservesLimits ConcreteCategory.forget
X : TopCat
F : Sheaf C X
ι : Type v
U : ι → Opens ↑X
V : Opens ↑X
iUV : (i : ι) → U i ⟶ V
hcover : V ≤ iSup U
s t : (CategoryTheory.forget C).obj (F.val.obj (op V))
h : ∀ (i : ι), ↑(F.val.map (iUV i).op) s = ↑(F.val.map (iUV i).op) t
V_eq_supr_U : V = iSup U
this : ↑(F.val.map (eqToHom (_ : iSup U = V)).op) s = ↑(F.val.map (eqToHom (_ : iSup U = V)).op) t
⊢ s = ↑(F.val.map (eqToHom V_eq_supr_U).op) (↑(F.val.map (eqToHom (_ : iSup U = V)).op) s)
[PROOFSTEP]
rw [← comp_apply, ← F.1.map_comp, eqToHom_op, eqToHom_op, eqToHom_trans, eqToHom_refl, F.1.map_id, id_apply]
[GOAL]
case h.e'_3
C : Type u
inst✝⁴ : Category.{v, u} C
inst✝³ : ConcreteCategory C
inst✝² : HasLimits C
inst✝¹ : ReflectsIsomorphisms ConcreteCategory.forget
inst✝ : PreservesLimits ConcreteCategory.forget
X : TopCat
F : Sheaf C X
ι : Type v
U : ι → Opens ↑X
V : Opens ↑X
iUV : (i : ι) → U i ⟶ V
hcover : V ≤ iSup U
s t : (CategoryTheory.forget C).obj (F.val.obj (op V))
h : ∀ (i : ι), ↑(F.val.map (iUV i).op) s = ↑(F.val.map (iUV i).op) t
V_eq_supr_U : V = iSup U
this : ↑(F.val.map (eqToHom (_ : iSup U = V)).op) s = ↑(F.val.map (eqToHom (_ : iSup U = V)).op) t
⊢ t = ↑(F.val.map (eqToHom V_eq_supr_U).op) (↑(F.val.map (eqToHom (_ : iSup U = V)).op) t)
[PROOFSTEP]
rw [← comp_apply, ← F.1.map_comp, eqToHom_op, eqToHom_op, eqToHom_trans, eqToHom_refl, F.1.map_id, id_apply]
[GOAL]
C : Type u
inst✝⁴ : Category.{v, u} C
inst✝³ : ConcreteCategory C
inst✝² : HasLimits C
inst✝¹ : ReflectsIsomorphisms ConcreteCategory.forget
inst✝ : PreservesLimits ConcreteCategory.forget
X : TopCat
F : Sheaf C X
ι : Type v
U : ι → Opens ↑X
V : Opens ↑X
iUV : (i : ι) → U i ⟶ V
hcover : V ≤ iSup U
s t : (CategoryTheory.forget C).obj (F.val.obj (op V))
h : ∀ (i : ι), ↑(F.val.map (iUV i).op) s = ↑(F.val.map (iUV i).op) t
V_eq_supr_U : V = iSup U
⊢ ↑(F.val.map (eqToHom (_ : iSup U = V)).op) s = ↑(F.val.map (eqToHom (_ : iSup U = V)).op) t
[PROOFSTEP]
apply eq_of_locally_eq
[GOAL]
case h
C : Type u
inst✝⁴ : Category.{v, u} C
inst✝³ : ConcreteCategory C
inst✝² : HasLimits C
inst✝¹ : ReflectsIsomorphisms ConcreteCategory.forget
inst✝ : PreservesLimits ConcreteCategory.forget
X : TopCat
F : Sheaf C X
ι : Type v
U : ι → Opens ↑X
V : Opens ↑X
iUV : (i : ι) → U i ⟶ V
hcover : V ≤ iSup U
s t : (CategoryTheory.forget C).obj (F.val.obj (op V))
h : ∀ (i : ι), ↑(F.val.map (iUV i).op) s = ↑(F.val.map (iUV i).op) t
V_eq_supr_U : V = iSup U
⊢ ∀ (i : ι),
    ↑(F.val.map (leSupr U i).op) (↑(F.val.map (eqToHom (_ : iSup U = V)).op) s) =
      ↑(F.val.map (leSupr U i).op) (↑(F.val.map (eqToHom (_ : iSup U = V)).op) t)
[PROOFSTEP]
intro i
[GOAL]
case h
C : Type u
inst✝⁴ : Category.{v, u} C
inst✝³ : ConcreteCategory C
inst✝² : HasLimits C
inst✝¹ : ReflectsIsomorphisms ConcreteCategory.forget
inst✝ : PreservesLimits ConcreteCategory.forget
X : TopCat
F : Sheaf C X
ι : Type v
U : ι → Opens ↑X
V : Opens ↑X
iUV : (i : ι) → U i ⟶ V
hcover : V ≤ iSup U
s t : (CategoryTheory.forget C).obj (F.val.obj (op V))
h : ∀ (i : ι), ↑(F.val.map (iUV i).op) s = ↑(F.val.map (iUV i).op) t
V_eq_supr_U : V = iSup U
i : ι
⊢ ↑(F.val.map (leSupr U i).op) (↑(F.val.map (eqToHom (_ : iSup U = V)).op) s) =
    ↑(F.val.map (leSupr U i).op) (↑(F.val.map (eqToHom (_ : iSup U = V)).op) t)
[PROOFSTEP]
rw [← comp_apply, ← comp_apply, ← F.1.map_comp]
[GOAL]
case h
C : Type u
inst✝⁴ : Category.{v, u} C
inst✝³ : ConcreteCategory C
inst✝² : HasLimits C
inst✝¹ : ReflectsIsomorphisms ConcreteCategory.forget
inst✝ : PreservesLimits ConcreteCategory.forget
X : TopCat
F : Sheaf C X
ι : Type v
U : ι → Opens ↑X
V : Opens ↑X
iUV : (i : ι) → U i ⟶ V
hcover : V ≤ iSup U
s t : (CategoryTheory.forget C).obj (F.val.obj (op V))
h : ∀ (i : ι), ↑(F.val.map (iUV i).op) s = ↑(F.val.map (iUV i).op) t
V_eq_supr_U : V = iSup U
i : ι
⊢ ↑(F.val.map ((eqToHom (_ : iSup U = V)).op ≫ (leSupr U i).op)) s =
    ↑(F.val.map ((eqToHom (_ : iSup U = V)).op ≫ (leSupr U i).op)) t
[PROOFSTEP]
convert h i
[GOAL]
C : Type u
inst✝⁴ : Category.{v, u} C
inst✝³ : ConcreteCategory C
inst✝² : HasLimits C
inst✝¹ : ReflectsIsomorphisms ConcreteCategory.forget
inst✝ : PreservesLimits ConcreteCategory.forget
X : TopCat
F : Sheaf C X
ι : Type v
U : ι → Opens ↑X
U₁ U₂ V : Opens ↑X
i₁ : U₁ ⟶ V
i₂ : U₂ ⟶ V
hcover : V ≤ U₁ ⊔ U₂
s t : (CategoryTheory.forget C).obj (F.val.obj (op V))
h₁ : ↑(F.val.map i₁.op) s = ↑(F.val.map i₁.op) t
h₂ : ↑(F.val.map i₂.op) s = ↑(F.val.map i₂.op) t
⊢ s = t
[PROOFSTEP]
classical
fapply F.eq_of_locally_eq' fun t : ULift Bool => if t.1 then U₁ else U₂
· exact fun i => if h : i.1 then eqToHom (if_pos h) ≫ i₁ else eqToHom (if_neg h) ≫ i₂
· refine' le_trans hcover _
  rw [sup_le_iff]
  constructor
  · convert le_iSup (fun t : ULift Bool => if t.1 then U₁ else U₂) (ULift.up True)
  · convert le_iSup (fun t : ULift Bool => if t.1 then U₁ else U₂) (ULift.up False)
· rintro ⟨_ | _⟩
  any_goals exact h₁
  any_goals exact h₂
[GOAL]
C : Type u
inst✝⁴ : Category.{v, u} C
inst✝³ : ConcreteCategory C
inst✝² : HasLimits C
inst✝¹ : ReflectsIsomorphisms ConcreteCategory.forget
inst✝ : PreservesLimits ConcreteCategory.forget
X : TopCat
F : Sheaf C X
ι : Type v
U : ι → Opens ↑X
U₁ U₂ V : Opens ↑X
i₁ : U₁ ⟶ V
i₂ : U₂ ⟶ V
hcover : V ≤ U₁ ⊔ U₂
s t : (CategoryTheory.forget C).obj (F.val.obj (op V))
h₁ : ↑(F.val.map i₁.op) s = ↑(F.val.map i₁.op) t
h₂ : ↑(F.val.map i₂.op) s = ↑(F.val.map i₂.op) t
⊢ s = t
[PROOFSTEP]
fapply F.eq_of_locally_eq' fun t : ULift Bool => if t.1 then U₁ else U₂
[GOAL]
case iUV
C : Type u
inst✝⁴ : Category.{v, u} C
inst✝³ : ConcreteCategory C
inst✝² : HasLimits C
inst✝¹ : ReflectsIsomorphisms ConcreteCategory.forget
inst✝ : PreservesLimits ConcreteCategory.forget
X : TopCat
F : Sheaf C X
ι : Type v
U : ι → Opens ↑X
U₁ U₂ V : Opens ↑X
i₁ : U₁ ⟶ V
i₂ : U₂ ⟶ V
hcover : V ≤ U₁ ⊔ U₂
s t : (CategoryTheory.forget C).obj (F.val.obj (op V))
h₁ : ↑(F.val.map i₁.op) s = ↑(F.val.map i₁.op) t
h₂ : ↑(F.val.map i₂.op) s = ↑(F.val.map i₂.op) t
⊢ (i : ULift Bool) → (if i.down = true then U₁ else U₂) ⟶ V
[PROOFSTEP]
exact fun i => if h : i.1 then eqToHom (if_pos h) ≫ i₁ else eqToHom (if_neg h) ≫ i₂
[GOAL]
case hcover
C : Type u
inst✝⁴ : Category.{v, u} C
inst✝³ : ConcreteCategory C
inst✝² : HasLimits C
inst✝¹ : ReflectsIsomorphisms ConcreteCategory.forget
inst✝ : PreservesLimits ConcreteCategory.forget
X : TopCat
F : Sheaf C X
ι : Type v
U : ι → Opens ↑X
U₁ U₂ V : Opens ↑X
i₁ : U₁ ⟶ V
i₂ : U₂ ⟶ V
hcover : V ≤ U₁ ⊔ U₂
s t : (CategoryTheory.forget C).obj (F.val.obj (op V))
h₁ : ↑(F.val.map i₁.op) s = ↑(F.val.map i₁.op) t
h₂ : ↑(F.val.map i₂.op) s = ↑(F.val.map i₂.op) t
⊢ V ≤ ⨆ (t : ULift Bool), if t.down = true then U₁ else U₂
[PROOFSTEP]
refine' le_trans hcover _
[GOAL]
case hcover
C : Type u
inst✝⁴ : Category.{v, u} C
inst✝³ : ConcreteCategory C
inst✝² : HasLimits C
inst✝¹ : ReflectsIsomorphisms ConcreteCategory.forget
inst✝ : PreservesLimits ConcreteCategory.forget
X : TopCat
F : Sheaf C X
ι : Type v
U : ι → Opens ↑X
U₁ U₂ V : Opens ↑X
i₁ : U₁ ⟶ V
i₂ : U₂ ⟶ V
hcover : V ≤ U₁ ⊔ U₂
s t : (CategoryTheory.forget C).obj (F.val.obj (op V))
h₁ : ↑(F.val.map i₁.op) s = ↑(F.val.map i₁.op) t
h₂ : ↑(F.val.map i₂.op) s = ↑(F.val.map i₂.op) t
⊢ U₁ ⊔ U₂ ≤ ⨆ (t : ULift Bool), if t.down = true then U₁ else U₂
[PROOFSTEP]
rw [sup_le_iff]
[GOAL]
case hcover
C : Type u
inst✝⁴ : Category.{v, u} C
inst✝³ : ConcreteCategory C
inst✝² : HasLimits C
inst✝¹ : ReflectsIsomorphisms ConcreteCategory.forget
inst✝ : PreservesLimits ConcreteCategory.forget
X : TopCat
F : Sheaf C X
ι : Type v
U : ι → Opens ↑X
U₁ U₂ V : Opens ↑X
i₁ : U₁ ⟶ V
i₂ : U₂ ⟶ V
hcover : V ≤ U₁ ⊔ U₂
s t : (CategoryTheory.forget C).obj (F.val.obj (op V))
h₁ : ↑(F.val.map i₁.op) s = ↑(F.val.map i₁.op) t
h₂ : ↑(F.val.map i₂.op) s = ↑(F.val.map i₂.op) t
⊢ (U₁ ≤ ⨆ (t : ULift Bool), if t.down = true then U₁ else U₂) ∧
    U₂ ≤ ⨆ (t : ULift Bool), if t.down = true then U₁ else U₂
[PROOFSTEP]
constructor
[GOAL]
case hcover.left
C : Type u
inst✝⁴ : Category.{v, u} C
inst✝³ : ConcreteCategory C
inst✝² : HasLimits C
inst✝¹ : ReflectsIsomorphisms ConcreteCategory.forget
inst✝ : PreservesLimits ConcreteCategory.forget
X : TopCat
F : Sheaf C X
ι : Type v
U : ι → Opens ↑X
U₁ U₂ V : Opens ↑X
i₁ : U₁ ⟶ V
i₂ : U₂ ⟶ V
hcover : V ≤ U₁ ⊔ U₂
s t : (CategoryTheory.forget C).obj (F.val.obj (op V))
h₁ : ↑(F.val.map i₁.op) s = ↑(F.val.map i₁.op) t
h₂ : ↑(F.val.map i₂.op) s = ↑(F.val.map i₂.op) t
⊢ U₁ ≤ ⨆ (t : ULift Bool), if t.down = true then U₁ else U₂
[PROOFSTEP]
convert le_iSup (fun t : ULift Bool => if t.1 then U₁ else U₂) (ULift.up True)
[GOAL]
case hcover.right
C : Type u
inst✝⁴ : Category.{v, u} C
inst✝³ : ConcreteCategory C
inst✝² : HasLimits C
inst✝¹ : ReflectsIsomorphisms ConcreteCategory.forget
inst✝ : PreservesLimits ConcreteCategory.forget
X : TopCat
F : Sheaf C X
ι : Type v
U : ι → Opens ↑X
U₁ U₂ V : Opens ↑X
i₁ : U₁ ⟶ V
i₂ : U₂ ⟶ V
hcover : V ≤ U₁ ⊔ U₂
s t : (CategoryTheory.forget C).obj (F.val.obj (op V))
h₁ : ↑(F.val.map i₁.op) s = ↑(F.val.map i₁.op) t
h₂ : ↑(F.val.map i₂.op) s = ↑(F.val.map i₂.op) t
⊢ U₂ ≤ ⨆ (t : ULift Bool), if t.down = true then U₁ else U₂
[PROOFSTEP]
convert le_iSup (fun t : ULift Bool => if t.1 then U₁ else U₂) (ULift.up False)
[GOAL]
case h
C : Type u
inst✝⁴ : Category.{v, u} C
inst✝³ : ConcreteCategory C
inst✝² : HasLimits C
inst✝¹ : ReflectsIsomorphisms ConcreteCategory.forget
inst✝ : PreservesLimits ConcreteCategory.forget
X : TopCat
F : Sheaf C X
ι : Type v
U : ι → Opens ↑X
U₁ U₂ V : Opens ↑X
i₁ : U₁ ⟶ V
i₂ : U₂ ⟶ V
hcover : V ≤ U₁ ⊔ U₂
s t : (CategoryTheory.forget C).obj (F.val.obj (op V))
h₁ : ↑(F.val.map i₁.op) s = ↑(F.val.map i₁.op) t
h₂ : ↑(F.val.map i₂.op) s = ↑(F.val.map i₂.op) t
⊢ ∀ (i : ULift Bool),
    ↑(F.val.map
            (if h : i.down = true then eqToHom (_ : (if i.down = true then U₁ else U₂) = U₁) ≫ i₁
              else eqToHom (_ : (if i.down = true then U₁ else U₂) = U₂) ≫ i₂).op)
        s =
      ↑(F.val.map
            (if h : i.down = true then eqToHom (_ : (if i.down = true then U₁ else U₂) = U₁) ≫ i₁
              else eqToHom (_ : (if i.down = true then U₁ else U₂) = U₂) ≫ i₂).op)
        t
[PROOFSTEP]
rintro ⟨_ | _⟩
[GOAL]
case h.up.false
C : Type u
inst✝⁴ : Category.{v, u} C
inst✝³ : ConcreteCategory C
inst✝² : HasLimits C
inst✝¹ : ReflectsIsomorphisms ConcreteCategory.forget
inst✝ : PreservesLimits ConcreteCategory.forget
X : TopCat
F : Sheaf C X
ι : Type v
U : ι → Opens ↑X
U₁ U₂ V : Opens ↑X
i₁ : U₁ ⟶ V
i₂ : U₂ ⟶ V
hcover : V ≤ U₁ ⊔ U₂
s t : (CategoryTheory.forget C).obj (F.val.obj (op V))
h₁ : ↑(F.val.map i₁.op) s = ↑(F.val.map i₁.op) t
h₂ : ↑(F.val.map i₂.op) s = ↑(F.val.map i₂.op) t
⊢ ↑(F.val.map
          (if h : { down := false }.down = true then
              eqToHom (_ : (if { down := false }.down = true then U₁ else U₂) = U₁) ≫ i₁
            else eqToHom (_ : (if { down := false }.down = true then U₁ else U₂) = U₂) ≫ i₂).op)
      s =
    ↑(F.val.map
          (if h : { down := false }.down = true then
              eqToHom (_ : (if { down := false }.down = true then U₁ else U₂) = U₁) ≫ i₁
            else eqToHom (_ : (if { down := false }.down = true then U₁ else U₂) = U₂) ≫ i₂).op)
      t
case h.up.true
C : Type u
inst✝⁴ : Category.{v, u} C
inst✝³ : ConcreteCategory C
inst✝² : HasLimits C
inst✝¹ : ReflectsIsomorphisms ConcreteCategory.forget
inst✝ : PreservesLimits ConcreteCategory.forget
X : TopCat
F : Sheaf C X
ι : Type v
U : ι → Opens ↑X
U₁ U₂ V : Opens ↑X
i₁ : U₁ ⟶ V
i₂ : U₂ ⟶ V
hcover : V ≤ U₁ ⊔ U₂
s t : (CategoryTheory.forget C).obj (F.val.obj (op V))
h₁ : ↑(F.val.map i₁.op) s = ↑(F.val.map i₁.op) t
h₂ : ↑(F.val.map i₂.op) s = ↑(F.val.map i₂.op) t
⊢ ↑(F.val.map
          (if h : { down := true }.down = true then
              eqToHom (_ : (if { down := true }.down = true then U₁ else U₂) = U₁) ≫ i₁
            else eqToHom (_ : (if { down := true }.down = true then U₁ else U₂) = U₂) ≫ i₂).op)
      s =
    ↑(F.val.map
          (if h : { down := true }.down = true then
              eqToHom (_ : (if { down := true }.down = true then U₁ else U₂) = U₁) ≫ i₁
            else eqToHom (_ : (if { down := true }.down = true then U₁ else U₂) = U₂) ≫ i₂).op)
      t
[PROOFSTEP]
any_goals exact h₁
[GOAL]
case h.up.false
C : Type u
inst✝⁴ : Category.{v, u} C
inst✝³ : ConcreteCategory C
inst✝² : HasLimits C
inst✝¹ : ReflectsIsomorphisms ConcreteCategory.forget
inst✝ : PreservesLimits ConcreteCategory.forget
X : TopCat
F : Sheaf C X
ι : Type v
U : ι → Opens ↑X
U₁ U₂ V : Opens ↑X
i₁ : U₁ ⟶ V
i₂ : U₂ ⟶ V
hcover : V ≤ U₁ ⊔ U₂
s t : (CategoryTheory.forget C).obj (F.val.obj (op V))
h₁ : ↑(F.val.map i₁.op) s = ↑(F.val.map i₁.op) t
h₂ : ↑(F.val.map i₂.op) s = ↑(F.val.map i₂.op) t
⊢ ↑(F.val.map
          (if h : { down := false }.down = true then
              eqToHom (_ : (if { down := false }.down = true then U₁ else U₂) = U₁) ≫ i₁
            else eqToHom (_ : (if { down := false }.down = true then U₁ else U₂) = U₂) ≫ i₂).op)
      s =
    ↑(F.val.map
          (if h : { down := false }.down = true then
              eqToHom (_ : (if { down := false }.down = true then U₁ else U₂) = U₁) ≫ i₁
            else eqToHom (_ : (if { down := false }.down = true then U₁ else U₂) = U₂) ≫ i₂).op)
      t
[PROOFSTEP]
exact h₁
[GOAL]
case h.up.true
C : Type u
inst✝⁴ : Category.{v, u} C
inst✝³ : ConcreteCategory C
inst✝² : HasLimits C
inst✝¹ : ReflectsIsomorphisms ConcreteCategory.forget
inst✝ : PreservesLimits ConcreteCategory.forget
X : TopCat
F : Sheaf C X
ι : Type v
U : ι → Opens ↑X
U₁ U₂ V : Opens ↑X
i₁ : U₁ ⟶ V
i₂ : U₂ ⟶ V
hcover : V ≤ U₁ ⊔ U₂
s t : (CategoryTheory.forget C).obj (F.val.obj (op V))
h₁ : ↑(F.val.map i₁.op) s = ↑(F.val.map i₁.op) t
h₂ : ↑(F.val.map i₂.op) s = ↑(F.val.map i₂.op) t
⊢ ↑(F.val.map
          (if h : { down := true }.down = true then
              eqToHom (_ : (if { down := true }.down = true then U₁ else U₂) = U₁) ≫ i₁
            else eqToHom (_ : (if { down := true }.down = true then U₁ else U₂) = U₂) ≫ i₂).op)
      s =
    ↑(F.val.map
          (if h : { down := true }.down = true then
              eqToHom (_ : (if { down := true }.down = true then U₁ else U₂) = U₁) ≫ i₁
            else eqToHom (_ : (if { down := true }.down = true then U₁ else U₂) = U₂) ≫ i₂).op)
      t
[PROOFSTEP]
exact h₁
[GOAL]
case h.up.false
C : Type u
inst✝⁴ : Category.{v, u} C
inst✝³ : ConcreteCategory C
inst✝² : HasLimits C
inst✝¹ : ReflectsIsomorphisms ConcreteCategory.forget
inst✝ : PreservesLimits ConcreteCategory.forget
X : TopCat
F : Sheaf C X
ι : Type v
U : ι → Opens ↑X
U₁ U₂ V : Opens ↑X
i₁ : U₁ ⟶ V
i₂ : U₂ ⟶ V
hcover : V ≤ U₁ ⊔ U₂
s t : (CategoryTheory.forget C).obj (F.val.obj (op V))
h₁ : ↑(F.val.map i₁.op) s = ↑(F.val.map i₁.op) t
h₂ : ↑(F.val.map i₂.op) s = ↑(F.val.map i₂.op) t
⊢ ↑(F.val.map
          (if h : { down := false }.down = true then
              eqToHom (_ : (if { down := false }.down = true then U₁ else U₂) = U₁) ≫ i₁
            else eqToHom (_ : (if { down := false }.down = true then U₁ else U₂) = U₂) ≫ i₂).op)
      s =
    ↑(F.val.map
          (if h : { down := false }.down = true then
              eqToHom (_ : (if { down := false }.down = true then U₁ else U₂) = U₁) ≫ i₁
            else eqToHom (_ : (if { down := false }.down = true then U₁ else U₂) = U₂) ≫ i₂).op)
      t
[PROOFSTEP]
any_goals exact h₂
[GOAL]
case h.up.false
C : Type u
inst✝⁴ : Category.{v, u} C
inst✝³ : ConcreteCategory C
inst✝² : HasLimits C
inst✝¹ : ReflectsIsomorphisms ConcreteCategory.forget
inst✝ : PreservesLimits ConcreteCategory.forget
X : TopCat
F : Sheaf C X
ι : Type v
U : ι → Opens ↑X
U₁ U₂ V : Opens ↑X
i₁ : U₁ ⟶ V
i₂ : U₂ ⟶ V
hcover : V ≤ U₁ ⊔ U₂
s t : (CategoryTheory.forget C).obj (F.val.obj (op V))
h₁ : ↑(F.val.map i₁.op) s = ↑(F.val.map i₁.op) t
h₂ : ↑(F.val.map i₂.op) s = ↑(F.val.map i₂.op) t
⊢ ↑(F.val.map
          (if h : { down := false }.down = true then
              eqToHom (_ : (if { down := false }.down = true then U₁ else U₂) = U₁) ≫ i₁
            else eqToHom (_ : (if { down := false }.down = true then U₁ else U₂) = U₂) ≫ i₂).op)
      s =
    ↑(F.val.map
          (if h : { down := false }.down = true then
              eqToHom (_ : (if { down := false }.down = true then U₁ else U₂) = U₁) ≫ i₁
            else eqToHom (_ : (if { down := false }.down = true then U₁ else U₂) = U₂) ≫ i₂).op)
      t
[PROOFSTEP]
exact h₂