File: Mathlib/Topology/Sheaves/SheafCondition/UniqueGluing.lean

full_name: TopCat.Presheaf.IsCompatible
code: /-- A family of sections `sf` is compatible, if the restrictions of `sf i` and `sf j` to `U i ⊓ U j`
agree, for all `i` and `j`
-/
def IsCompatible (sf : ∀ i : ι, F.obj (op (U i))) : Prop 
goal: Prop

full_name: TopCat.Presheaf.IsGluing
code: /-- A section `s` is a gluing for a family of sections `sf` if it restricts to `sf i` on `U i`,
for all `i`
-/
def IsGluing (sf : ∀ i : ι, F.obj (op (U i))) (s : F.obj (op (iSup U))) : Prop 
goal: Prop

full_name: TopCat.Presheaf.IsSheafUniqueGluing
code: /--
The sheaf condition in terms of unique gluings. A presheaf `F : Presheaf C X` satisfies this sheaf
condition if and only if, for every compatible family of sections `sf : Π i : ι, F.obj (op (U i))`,
there exists a unique gluing `s : F.obj (op (iSup U))`.

We prove this to be equivalent to the usual one below in
`TopCat.Presheaf.isSheaf_iff_isSheafUniqueGluing`
-/
def IsSheafUniqueGluing : Prop 
goal: Prop

full_name: TopCat.Presheaf.objPairwiseOfFamily
code: /-- Given sections over a family of open sets, extend it to include
  sections over pairwise intersections of the open sets. -/
def objPairwiseOfFamily (sf : ∀ i, F.obj (op (U i))) :
    ∀ i, ((Pairwise.diagram U).op ⋙ F).obj i
  
goal: ((CategoryTheory.Pairwise.diagram U).op ⋙ F).obj i

full_name: TopCat.Presheaf.IsCompatible.sectionPairwise
code: /-- Given a compatible family of sections over open sets, extend it to a
  section of the functor `(Pairwise.diagram U).op ⋙ F`. -/
def IsCompatible.sectionPairwise {sf} (h : IsCompatible F U sf) :
    ((Pairwise.diagram U).op ⋙ F).sections 
goal: ↑((CategoryTheory.Pairwise.diagram U).op ⋙ F).sections

full_name: TopCat.Presheaf.isGluing_iff_pairwise
code: theorem isGluing_iff_pairwise {sf s} : IsGluing F U sf s ↔
    ∀ i, (F.mapCone (Pairwise.cocone U).op).π.app i s = objPairwiseOfFamily sf i 
goal: F.IsGluing U sf s ↔
  ∀ (i : (CategoryTheory.Pairwise ι)ᵒᵖ),
    (CategoryTheory.Functor.mapCone F (CategoryTheory.Pairwise.cocone U).op).π.app i s =
      TopCat.Presheaf.objPairwiseOfFamily sf i

full_name: TopCat.Presheaf.isSheaf_iff_isSheafUniqueGluing_types
code: /-- For type-valued presheaves, the sheaf condition in terms of unique gluings is equivalent to the
usual sheaf condition.
-/
theorem isSheaf_iff_isSheafUniqueGluing_types : F.IsSheaf ↔ F.IsSheafUniqueGluing 
goal: F.IsSheaf ↔ F.IsSheafUniqueGluing

full_name: TopCat.Presheaf.isSheaf_of_isSheafUniqueGluing_types
code: /-- The usual sheaf condition can be obtained from the sheaf condition
in terms of unique gluings.
-/
theorem isSheaf_of_isSheafUniqueGluing_types (Fsh : F.IsSheafUniqueGluing) : F.IsSheaf 
goal: F.IsSheaf

full_name: TopCat.Presheaf.isSheaf_iff_isSheafUniqueGluing
code: /-- For presheaves valued in a concrete category, whose forgetful functor reflects isomorphisms and
preserves limits, the sheaf condition in terms of unique gluings is equivalent to the usual one.
-/
theorem isSheaf_iff_isSheafUniqueGluing : F.IsSheaf ↔ F.IsSheafUniqueGluing 
goal: F.IsSheaf ↔ F.IsSheafUniqueGluing

full_name: TopCat.Sheaf.existsUnique_gluing
code: /-- A more convenient way of obtaining a unique gluing of sections for a sheaf.
-/
theorem existsUnique_gluing (sf : ∀ i : ι, F.1.obj (op (U i))) (h : IsCompatible F.1 U sf) :
    ∃! s : F.1.obj (op (iSup U)), IsGluing F.1 U sf s 
goal: ∃! s, TopCat.Presheaf.IsGluing F.val U sf s

full_name: TopCat.Sheaf.existsUnique_gluing'
code: /-- In this version of the lemma, the inclusion homs `iUV` can be specified directly by the user,
which can be more convenient in practice.
-/
theorem existsUnique_gluing' (V : Opens X) (iUV : ∀ i : ι, U i ⟶ V) (hcover : V ≤ iSup U)
    (sf : ∀ i : ι, F.1.obj (op (U i))) (h : IsCompatible F.1 U sf) :
    ∃! s : F.1.obj (op V), ∀ i : ι, F.1.map (iUV i).op s = sf i 
goal: ∃! s, ∀ (i : ι), (F.val.map (iUV i).op) s = sf i

full_name: TopCat.Sheaf.eq_of_locally_eq
code: @[ext]
theorem eq_of_locally_eq (s t : F.1.obj (op (iSup U)))
    (h : ∀ i, F.1.map (Opens.leSupr U i).op s = F.1.map (Opens.leSupr U i).op t) : s = t 
goal: s = t

full_name: TopCat.Sheaf.eq_of_locally_eq'
code: /-- In this version of the lemma, the inclusion homs `iUV` can be specified directly by the user,
which can be more convenient in practice.
-/
theorem eq_of_locally_eq' (V : Opens X) (iUV : ∀ i : ι, U i ⟶ V) (hcover : V ≤ iSup U)
    (s t : F.1.obj (op V)) (h : ∀ i, F.1.map (iUV i).op s = F.1.map (iUV i).op t) : s = t 
goal: s = t

full_name: TopCat.Sheaf.eq_of_locally_eq₂
code: theorem eq_of_locally_eq₂ {U₁ U₂ V : Opens X} (i₁ : U₁ ⟶ V) (i₂ : U₂ ⟶ V) (hcover : V ≤ U₁ ⊔ U₂)
    (s t : F.1.obj (op V)) (h₁ : F.1.map i₁.op s = F.1.map i₁.op t)
    (h₂ : F.1.map i₂.op s = F.1.map i₂.op t) : s = t 
goal: s = t

full_name: TopCat.Sheaf.objSupIsoProdEqLocus_inv_eq_iff
code: theorem objSupIsoProdEqLocus_inv_eq_iff {X : TopCat.{u}} (F : X.Sheaf CommRingCat.{u})
    {U V W UW VW : Opens X} (e : W ≤ U ⊔ V) (x) (y : F.1.obj (op W))
    (h₁ : UW = U ⊓ W) (h₂ : VW = V ⊓ W) :
    F.1.map (homOfLE e).op ((F.objSupIsoProdEqLocus U V).inv x) = y ↔
    F.1.map (homOfLE (h₁ ▸ inf_le_left : UW ≤ U)).op x.1.1 =
      F.1.map (homOfLE <| h₁ ▸ inf_le_right).op y ∧
    F.1.map (homOfLE (h₂ ▸ inf_le_left : VW ≤ V)).op x.1.2 =
      F.1.map (homOfLE <| h₂ ▸ inf_le_right).op y 
goal: (F.val.map (CategoryTheory.homOfLE e).op) ((F.objSupIsoProdEqLocus U V).inv x) = y ↔
  (F.val.map (CategoryTheory.homOfLE ⋯).op) (↑x).1 = (F.val.map (CategoryTheory.homOfLE ⋯).op) y ∧
    (F.val.map (CategoryTheory.homOfLE ⋯).op) (↑x).2 = (F.val.map (CategoryTheory.homOfLE ⋯).op) y