fact
stringlengths 6
3.84k
| type
stringclasses 11
values | library
stringclasses 32
values | imports
listlengths 1
14
| filename
stringlengths 20
95
| symbolic_name
stringlengths 1
90
| docstring
stringlengths 7
20k
⌀ |
|---|---|---|---|---|---|---|
res : F.obj (op (iSup U)) ⟶ piOpens.{v'} F U :=
Pi.lift fun i : ι => F.map (TopologicalSpace.Opens.leSupr U i).op
@[simp, elementwise]
|
def
|
Topology
|
[
"Mathlib.CategoryTheory.Limits.Shapes.Equalizers",
"Mathlib.CategoryTheory.Limits.Shapes.Products",
"Mathlib.Topology.Sheaves.SheafCondition.PairwiseIntersections"
] |
Mathlib/Topology/Sheaves/SheafCondition/EqualizerProducts.lean
|
res
|
The morphism `F.obj U ⟶ Π F.obj (U i)` whose components
are given by the restriction maps from `U j` to `U i ⊓ U j`.
|
res_π (i : ι) : res F U ≫ limit.π _ ⟨i⟩ = F.map (Opens.leSupr U i).op := by
rw [res, limit.lift_π, Fan.mk_π_app]
|
theorem
|
Topology
|
[
"Mathlib.CategoryTheory.Limits.Shapes.Equalizers",
"Mathlib.CategoryTheory.Limits.Shapes.Products",
"Mathlib.Topology.Sheaves.SheafCondition.PairwiseIntersections"
] |
Mathlib/Topology/Sheaves/SheafCondition/EqualizerProducts.lean
|
res_π
| null |
@[ext] piOpens.hom_ext
{X : C} {f f' : X ⟶ piOpens F U} (w : ∀ j, f ≫ limit.π _ j = f' ≫ limit.π _ j) : f = f' :=
limit.hom_ext w
|
theorem
|
Topology
|
[
"Mathlib.CategoryTheory.Limits.Shapes.Equalizers",
"Mathlib.CategoryTheory.Limits.Shapes.Products",
"Mathlib.Topology.Sheaves.SheafCondition.PairwiseIntersections"
] |
Mathlib/Topology/Sheaves/SheafCondition/EqualizerProducts.lean
|
piOpens.hom_ext
|
Copy of `limit.hom_ext`, specialized to `piOpens` for use by the `ext` tactic.
|
@[ext] piInters.hom_ext
{X : C} {f f' : X ⟶ piInters F U} (w : ∀ j, f ≫ limit.π _ j = f' ≫ limit.π _ j) : f = f' :=
limit.hom_ext w
@[elementwise]
|
theorem
|
Topology
|
[
"Mathlib.CategoryTheory.Limits.Shapes.Equalizers",
"Mathlib.CategoryTheory.Limits.Shapes.Products",
"Mathlib.Topology.Sheaves.SheafCondition.PairwiseIntersections"
] |
Mathlib/Topology/Sheaves/SheafCondition/EqualizerProducts.lean
|
piInters.hom_ext
|
Copy of `limit.hom_ext`, specialized to `piInters` for use by the `ext` tactic.
|
w : res F U ≫ leftRes F U = res F U ≫ rightRes F U := by
dsimp [res, leftRes, rightRes]
ext
simp only [limit.lift_π, limit.lift_π_assoc, Fan.mk_π_app, Category.assoc]
rw [← F.map_comp]
rw [← F.map_comp]
congr 1
|
theorem
|
Topology
|
[
"Mathlib.CategoryTheory.Limits.Shapes.Equalizers",
"Mathlib.CategoryTheory.Limits.Shapes.Products",
"Mathlib.Topology.Sheaves.SheafCondition.PairwiseIntersections"
] |
Mathlib/Topology/Sheaves/SheafCondition/EqualizerProducts.lean
|
w
| null |
diagram : WalkingParallelPair ⥤ C :=
parallelPair (leftRes.{v'} F U) (rightRes F U)
|
abbrev
|
Topology
|
[
"Mathlib.CategoryTheory.Limits.Shapes.Equalizers",
"Mathlib.CategoryTheory.Limits.Shapes.Products",
"Mathlib.Topology.Sheaves.SheafCondition.PairwiseIntersections"
] |
Mathlib/Topology/Sheaves/SheafCondition/EqualizerProducts.lean
|
diagram
|
The equalizer diagram for the sheaf condition.
|
fork : Fork.{v} (leftRes F U) (rightRes F U) :=
Fork.ofι _ (w F U)
@[simp]
|
def
|
Topology
|
[
"Mathlib.CategoryTheory.Limits.Shapes.Equalizers",
"Mathlib.CategoryTheory.Limits.Shapes.Products",
"Mathlib.Topology.Sheaves.SheafCondition.PairwiseIntersections"
] |
Mathlib/Topology/Sheaves/SheafCondition/EqualizerProducts.lean
|
fork
|
The restriction map `F.obj U ⟶ Π F.obj (U i)` gives a cone over the equalizer diagram
for the sheaf condition. The sheaf condition asserts this cone is a limit cone.
|
fork_pt : (fork F U).pt = F.obj (op (iSup U)) :=
rfl
@[simp]
|
theorem
|
Topology
|
[
"Mathlib.CategoryTheory.Limits.Shapes.Equalizers",
"Mathlib.CategoryTheory.Limits.Shapes.Products",
"Mathlib.Topology.Sheaves.SheafCondition.PairwiseIntersections"
] |
Mathlib/Topology/Sheaves/SheafCondition/EqualizerProducts.lean
|
fork_pt
| null |
fork_ι : (fork F U).ι = res F U :=
rfl
@[simp]
|
theorem
|
Topology
|
[
"Mathlib.CategoryTheory.Limits.Shapes.Equalizers",
"Mathlib.CategoryTheory.Limits.Shapes.Products",
"Mathlib.Topology.Sheaves.SheafCondition.PairwiseIntersections"
] |
Mathlib/Topology/Sheaves/SheafCondition/EqualizerProducts.lean
|
fork_ι
| null |
fork_π_app_walkingParallelPair_zero : (fork F U).π.app WalkingParallelPair.zero = res F U :=
rfl
@[simp]
|
theorem
|
Topology
|
[
"Mathlib.CategoryTheory.Limits.Shapes.Equalizers",
"Mathlib.CategoryTheory.Limits.Shapes.Products",
"Mathlib.Topology.Sheaves.SheafCondition.PairwiseIntersections"
] |
Mathlib/Topology/Sheaves/SheafCondition/EqualizerProducts.lean
|
fork_π_app_walkingParallelPair_zero
| null |
fork_π_app_walkingParallelPair_one :
(fork F U).π.app WalkingParallelPair.one = res F U ≫ leftRes F U :=
rfl
variable {F} {G : Presheaf C X}
|
theorem
|
Topology
|
[
"Mathlib.CategoryTheory.Limits.Shapes.Equalizers",
"Mathlib.CategoryTheory.Limits.Shapes.Products",
"Mathlib.Topology.Sheaves.SheafCondition.PairwiseIntersections"
] |
Mathlib/Topology/Sheaves/SheafCondition/EqualizerProducts.lean
|
fork_π_app_walkingParallelPair_one
| null |
@[simp]
piOpens.isoOfIso (α : F ≅ G) : piOpens F U ≅ piOpens.{v'} G U :=
Pi.mapIso fun _ => α.app _
|
def
|
Topology
|
[
"Mathlib.CategoryTheory.Limits.Shapes.Equalizers",
"Mathlib.CategoryTheory.Limits.Shapes.Products",
"Mathlib.Topology.Sheaves.SheafCondition.PairwiseIntersections"
] |
Mathlib/Topology/Sheaves/SheafCondition/EqualizerProducts.lean
|
piOpens.isoOfIso
|
Isomorphic presheaves have isomorphic `piOpens` for any cover `U`.
|
@[simp]
piInters.isoOfIso (α : F ≅ G) : piInters F U ≅ piInters.{v'} G U :=
Pi.mapIso fun _ => α.app _
|
def
|
Topology
|
[
"Mathlib.CategoryTheory.Limits.Shapes.Equalizers",
"Mathlib.CategoryTheory.Limits.Shapes.Products",
"Mathlib.Topology.Sheaves.SheafCondition.PairwiseIntersections"
] |
Mathlib/Topology/Sheaves/SheafCondition/EqualizerProducts.lean
|
piInters.isoOfIso
|
Isomorphic presheaves have isomorphic `piInters` for any cover `U`.
|
diagram.isoOfIso (α : F ≅ G) : diagram F U ≅ diagram.{v'} G U :=
NatIso.ofComponents (by
rintro ⟨⟩
· exact piOpens.isoOfIso U α
· exact piInters.isoOfIso U α)
(by
rintro ⟨⟩ ⟨⟩ ⟨⟩
· simp
· dsimp
ext
simp only [leftRes, limit.lift_map, limit.lift_π, Cones.postcompose_obj_π,
NatTrans.comp_app, Fan.mk_π_app, Discrete.natIso_hom_app, Iso.app_hom, Category.assoc,
NatTrans.naturality, limMap_π_assoc]
· dsimp [diagram]
ext
simp only [rightRes, limit.lift_map, limit.lift_π, Cones.postcompose_obj_π,
NatTrans.comp_app, Fan.mk_π_app, Discrete.natIso_hom_app, Iso.app_hom, Category.assoc,
NatTrans.naturality, limMap_π_assoc]
· simp)
|
def
|
Topology
|
[
"Mathlib.CategoryTheory.Limits.Shapes.Equalizers",
"Mathlib.CategoryTheory.Limits.Shapes.Products",
"Mathlib.Topology.Sheaves.SheafCondition.PairwiseIntersections"
] |
Mathlib/Topology/Sheaves/SheafCondition/EqualizerProducts.lean
|
diagram.isoOfIso
|
Isomorphic presheaves have isomorphic sheaf condition diagrams.
|
fork.isoOfIso (α : F ≅ G) :
fork F U ≅ (Cones.postcompose (diagram.isoOfIso U α).inv).obj (fork G U) := by
fapply Fork.ext
· apply α.app
· dsimp
ext
dsimp only [Fork.ι]
simp only [res, diagram.isoOfIso, piOpens.isoOfIso, Cones.postcompose_obj_π,
NatTrans.comp_app, fork_π_app_walkingParallelPair_zero, NatIso.ofComponents_inv_app,
Functor.mapIso_inv, lim_map, limit.lift_map, Category.assoc, limit.lift_π, Fan.mk_π_app,
Discrete.natIso_inv_app, Iso.app_inv, NatTrans.naturality, Iso.hom_inv_id_app_assoc]
|
def
|
Topology
|
[
"Mathlib.CategoryTheory.Limits.Shapes.Equalizers",
"Mathlib.CategoryTheory.Limits.Shapes.Products",
"Mathlib.Topology.Sheaves.SheafCondition.PairwiseIntersections"
] |
Mathlib/Topology/Sheaves/SheafCondition/EqualizerProducts.lean
|
fork.isoOfIso
|
If `F G : Presheaf C X` are isomorphic presheaves,
then the `fork F U`, the canonical cone of the sheaf condition diagram for `F`,
is isomorphic to `fork F G` postcomposed with the corresponding isomorphism between
sheaf condition diagrams.
|
IsSheafEqualizerProducts (F : Presheaf.{v', v, u} C X) : Prop :=
∀ ⦃ι : Type v'⦄ (U : ι → Opens X), Nonempty (IsLimit (SheafConditionEqualizerProducts.fork F U))
/-!
The remainder of this file shows that the "equalizer products" sheaf condition is equivalent
to the "pairwise intersections" sheaf condition.
-/
|
def
|
Topology
|
[
"Mathlib.CategoryTheory.Limits.Shapes.Equalizers",
"Mathlib.CategoryTheory.Limits.Shapes.Products",
"Mathlib.Topology.Sheaves.SheafCondition.PairwiseIntersections"
] |
Mathlib/Topology/Sheaves/SheafCondition/EqualizerProducts.lean
|
IsSheafEqualizerProducts
|
The sheaf condition for a `F : Presheaf C X` requires that the morphism
`F.obj U ⟶ ∏ᶜ F.obj (U i)` (where `U` is some open set which is the union of the `U i`)
is the equalizer of the two morphisms
`∏ᶜ F.obj (U i) ⟶ ∏ᶜ F.obj (U i) ⊓ (U j)`.
|
@[simps]
coneEquivFunctorObj (c : Cone ((diagram U).op ⋙ F)) :
Cone (SheafConditionEqualizerProducts.diagram F U) where
pt := c.pt
π :=
{ app := fun Z =>
WalkingParallelPair.casesOn Z (Pi.lift fun i : ι => c.π.app (op (single i)))
(Pi.lift fun b : ι × ι => c.π.app (op (pair b.1 b.2)))
naturality := fun Y Z f => by
cases Y <;> cases Z <;> cases f
· dsimp
ext
simp
· dsimp
ext ij
rcases ij with ⟨i, j⟩
simpa [SheafConditionEqualizerProducts.leftRes]
using c.π.naturality (Quiver.Hom.op (Hom.left i j))
· dsimp
ext ij
rcases ij with ⟨i, j⟩
simpa [SheafConditionEqualizerProducts.rightRes]
using c.π.naturality (Quiver.Hom.op (Hom.right i j))
· dsimp
ext
simp }
|
def
|
Topology
|
[
"Mathlib.CategoryTheory.Limits.Shapes.Equalizers",
"Mathlib.CategoryTheory.Limits.Shapes.Products",
"Mathlib.Topology.Sheaves.SheafCondition.PairwiseIntersections"
] |
Mathlib/Topology/Sheaves/SheafCondition/EqualizerProducts.lean
|
coneEquivFunctorObj
|
Implementation of `SheafConditionPairwiseIntersections.coneEquiv`.
|
@[simps!]
coneEquivFunctor :
Limits.Cone ((diagram U).op ⋙ F) ⥤
Limits.Cone (SheafConditionEqualizerProducts.diagram F U) where
obj c := coneEquivFunctorObj F U c
map {c c'} f :=
{ hom := f.hom
w := fun j => by
cases j <;>
· dsimp
ext
simp }
|
def
|
Topology
|
[
"Mathlib.CategoryTheory.Limits.Shapes.Equalizers",
"Mathlib.CategoryTheory.Limits.Shapes.Products",
"Mathlib.Topology.Sheaves.SheafCondition.PairwiseIntersections"
] |
Mathlib/Topology/Sheaves/SheafCondition/EqualizerProducts.lean
|
coneEquivFunctor
|
Implementation of `SheafConditionPairwiseIntersections.coneEquiv`.
|
@[simps]
coneEquivInverseObj (c : Limits.Cone (SheafConditionEqualizerProducts.diagram F U)) :
Limits.Cone ((diagram U).op ⋙ F) where
pt := c.pt
π :=
{ app := by
intro x
induction x with | op x => ?_
rcases x with (⟨i⟩ | ⟨i, j⟩)
· exact c.π.app WalkingParallelPair.zero ≫ Pi.π _ i
· exact c.π.app WalkingParallelPair.one ≫ Pi.π _ (i, j)
naturality := by
intro x y f
induction x with | op x => ?_
induction y with | op y => ?_
have ef : f = f.unop.op := rfl
revert ef
generalize f.unop = f'
rintro rfl
rcases x with (⟨i⟩ | ⟨⟩) <;> rcases y with (⟨⟩ | ⟨j, j⟩) <;> rcases f' with ⟨⟩
· dsimp
rw [F.map_id]
simp
· dsimp
simp only [Category.id_comp, Category.assoc]
have h := c.π.naturality WalkingParallelPairHom.left
dsimp [SheafConditionEqualizerProducts.leftRes] at h
simp only [Category.id_comp] at h
have h' := h =≫ Pi.π _ (i, j)
rw [h']
simp only [Category.assoc, limit.lift_π, Fan.mk_π_app]
rfl
· dsimp
simp only [Category.id_comp, Category.assoc]
have h := c.π.naturality WalkingParallelPairHom.right
dsimp [SheafConditionEqualizerProducts.rightRes] at h
simp only [Category.id_comp] at h
have h' := h =≫ Pi.π _ (j, i)
rw [h']
simp
rfl
· dsimp
rw [F.map_id]
simp }
|
def
|
Topology
|
[
"Mathlib.CategoryTheory.Limits.Shapes.Equalizers",
"Mathlib.CategoryTheory.Limits.Shapes.Products",
"Mathlib.Topology.Sheaves.SheafCondition.PairwiseIntersections"
] |
Mathlib/Topology/Sheaves/SheafCondition/EqualizerProducts.lean
|
coneEquivInverseObj
|
Implementation of `SheafConditionPairwiseIntersections.coneEquiv`.
|
@[simps!]
coneEquivInverse :
Limits.Cone (SheafConditionEqualizerProducts.diagram F U) ⥤
Limits.Cone ((diagram U).op ⋙ F) where
obj c := coneEquivInverseObj F U c
map {c c'} f :=
{ hom := f.hom
w := by
intro x
induction x with | op x => ?_
rcases x with (⟨i⟩ | ⟨i, j⟩)
· dsimp
dsimp only [Fork.ι]
rw [← f.w WalkingParallelPair.zero, Category.assoc]
· dsimp
rw [← f.w WalkingParallelPair.one, Category.assoc] }
|
def
|
Topology
|
[
"Mathlib.CategoryTheory.Limits.Shapes.Equalizers",
"Mathlib.CategoryTheory.Limits.Shapes.Products",
"Mathlib.Topology.Sheaves.SheafCondition.PairwiseIntersections"
] |
Mathlib/Topology/Sheaves/SheafCondition/EqualizerProducts.lean
|
coneEquivInverse
|
Implementation of `SheafConditionPairwiseIntersections.coneEquiv`.
|
@[simps]
coneEquivUnitIsoApp (c : Cone ((diagram U).op ⋙ F)) :
(𝟭 (Cone ((diagram U).op ⋙ F))).obj c ≅
(coneEquivFunctor F U ⋙ coneEquivInverse F U).obj c where
hom :=
{ hom := 𝟙 _
w := fun j => by
induction j with | op j => ?_
rcases j with ⟨⟩ <;>
· dsimp [coneEquivInverse]
simp only [Limits.Fan.mk_π_app, Category.id_comp, Limits.limit.lift_π] }
inv :=
{ hom := 𝟙 _
w := fun j => by
induction j with | op j => ?_
rcases j with ⟨⟩ <;>
· dsimp [coneEquivInverse]
simp only [Limits.Fan.mk_π_app, Category.id_comp, Limits.limit.lift_π] }
|
def
|
Topology
|
[
"Mathlib.CategoryTheory.Limits.Shapes.Equalizers",
"Mathlib.CategoryTheory.Limits.Shapes.Products",
"Mathlib.Topology.Sheaves.SheafCondition.PairwiseIntersections"
] |
Mathlib/Topology/Sheaves/SheafCondition/EqualizerProducts.lean
|
coneEquivUnitIsoApp
|
Implementation of `SheafConditionPairwiseIntersections.coneEquiv`.
|
@[simps!]
coneEquivUnitIso :
𝟭 (Limits.Cone ((diagram U).op ⋙ F)) ≅ coneEquivFunctor F U ⋙ coneEquivInverse F U :=
NatIso.ofComponents (coneEquivUnitIsoApp F U)
|
def
|
Topology
|
[
"Mathlib.CategoryTheory.Limits.Shapes.Equalizers",
"Mathlib.CategoryTheory.Limits.Shapes.Products",
"Mathlib.Topology.Sheaves.SheafCondition.PairwiseIntersections"
] |
Mathlib/Topology/Sheaves/SheafCondition/EqualizerProducts.lean
|
coneEquivUnitIso
|
Implementation of `SheafConditionPairwiseIntersections.coneEquiv`.
|
@[simps!]
coneEquivCounitIso :
coneEquivInverse F U ⋙ coneEquivFunctor F U ≅
𝟭 (Limits.Cone (SheafConditionEqualizerProducts.diagram F U)) :=
NatIso.ofComponents
(fun c =>
{ hom :=
{ hom := 𝟙 _
w := by
rintro ⟨_ | _⟩
· dsimp
ext
simp
· dsimp
ext
simp }
inv :=
{ hom := 𝟙 _
w := by
rintro ⟨_ | _⟩
· dsimp
ext
simp
· dsimp
ext
simp } })
fun {c d} f => by
ext
dsimp
simp only [Category.comp_id, Category.id_comp]
|
def
|
Topology
|
[
"Mathlib.CategoryTheory.Limits.Shapes.Equalizers",
"Mathlib.CategoryTheory.Limits.Shapes.Products",
"Mathlib.Topology.Sheaves.SheafCondition.PairwiseIntersections"
] |
Mathlib/Topology/Sheaves/SheafCondition/EqualizerProducts.lean
|
coneEquivCounitIso
|
Implementation of `SheafConditionPairwiseIntersections.coneEquiv`.
|
@[simps]
coneEquiv :
Limits.Cone ((diagram U).op ⋙ F) ≌
Limits.Cone (SheafConditionEqualizerProducts.diagram F U) where
functor := coneEquivFunctor F U
inverse := coneEquivInverse F U
unitIso := coneEquivUnitIso F U
counitIso := coneEquivCounitIso F U
|
def
|
Topology
|
[
"Mathlib.CategoryTheory.Limits.Shapes.Equalizers",
"Mathlib.CategoryTheory.Limits.Shapes.Products",
"Mathlib.Topology.Sheaves.SheafCondition.PairwiseIntersections"
] |
Mathlib/Topology/Sheaves/SheafCondition/EqualizerProducts.lean
|
coneEquiv
|
Cones over `diagram U ⋙ F` are the same as a cones over the usual sheaf condition equalizer diagram.
|
isLimitMapConeOfIsLimitSheafConditionFork
(P : IsLimit (SheafConditionEqualizerProducts.fork F U)) : IsLimit (F.mapCone (cocone U).op) :=
IsLimit.ofIsoLimit ((IsLimit.ofConeEquiv (coneEquiv F U).symm).symm P)
{ hom :=
{ hom := 𝟙 _
w := by
intro x
induction x with | op x => ?_
rcases x with ⟨⟩
· simp
rfl
· dsimp [coneEquivInverse, SheafConditionEqualizerProducts.res,
SheafConditionEqualizerProducts.leftRes]
simp only [limit.lift_π, limit.lift_π_assoc, Category.id_comp, Fan.mk_π_app,
Category.assoc]
rw [← F.map_comp]
rfl }
inv :=
{ hom := 𝟙 _
w := by
intro x
induction x with | op x => ?_
rcases x with ⟨⟩
· simp
rfl
· dsimp [coneEquivInverse, SheafConditionEqualizerProducts.res,
SheafConditionEqualizerProducts.leftRes]
simp only [limit.lift_π, limit.lift_π_assoc, Category.id_comp, Fan.mk_π_app,
Category.assoc]
rw [← F.map_comp]
rfl } }
|
def
|
Topology
|
[
"Mathlib.CategoryTheory.Limits.Shapes.Equalizers",
"Mathlib.CategoryTheory.Limits.Shapes.Products",
"Mathlib.Topology.Sheaves.SheafCondition.PairwiseIntersections"
] |
Mathlib/Topology/Sheaves/SheafCondition/EqualizerProducts.lean
|
isLimitMapConeOfIsLimitSheafConditionFork
|
If `SheafConditionEqualizerProducts.fork` is an equalizer,
then `F.mapCone (cone U)` is a limit cone.
|
isLimitSheafConditionForkOfIsLimitMapCone (Q : IsLimit (F.mapCone (cocone U).op)) :
IsLimit (SheafConditionEqualizerProducts.fork F U) :=
IsLimit.ofIsoLimit ((IsLimit.ofConeEquiv (coneEquiv F U)).symm Q)
{ hom :=
{ hom := 𝟙 _
w := by
rintro ⟨⟩
· simp
rfl
· dsimp
ext
dsimp [coneEquivInverse, SheafConditionEqualizerProducts.res,
SheafConditionEqualizerProducts.leftRes]
simp only [limit.lift_π, limit.lift_π_assoc, Category.id_comp, Fan.mk_π_app,
Category.assoc]
rw [← F.map_comp]
rfl }
inv :=
{ hom := 𝟙 _
w := by
rintro ⟨⟩
· simp
rfl
· dsimp
ext
dsimp [coneEquivInverse, SheafConditionEqualizerProducts.res,
SheafConditionEqualizerProducts.leftRes]
simp only [limit.lift_π, limit.lift_π_assoc, Category.id_comp, Fan.mk_π_app,
Category.assoc]
rw [← F.map_comp]
rfl } }
|
def
|
Topology
|
[
"Mathlib.CategoryTheory.Limits.Shapes.Equalizers",
"Mathlib.CategoryTheory.Limits.Shapes.Products",
"Mathlib.Topology.Sheaves.SheafCondition.PairwiseIntersections"
] |
Mathlib/Topology/Sheaves/SheafCondition/EqualizerProducts.lean
|
isLimitSheafConditionForkOfIsLimitMapCone
|
If `F.mapCone (cone U)` is a limit cone,
then `SheafConditionEqualizerProducts.fork` is an equalizer.
|
isSheaf_iff_isSheafEqualizerProducts (F : Presheaf C X) :
F.IsSheaf ↔ F.IsSheafEqualizerProducts :=
(isSheaf_iff_isSheafPairwiseIntersections F).trans <|
Iff.intro (fun h _ U => ⟨isLimitSheafConditionForkOfIsLimitMapCone F U (h U).some⟩) fun h _ U =>
⟨isLimitMapConeOfIsLimitSheafConditionFork F U (h U).some⟩
|
theorem
|
Topology
|
[
"Mathlib.CategoryTheory.Limits.Shapes.Equalizers",
"Mathlib.CategoryTheory.Limits.Shapes.Products",
"Mathlib.Topology.Sheaves.SheafCondition.PairwiseIntersections"
] |
Mathlib/Topology/Sheaves/SheafCondition/EqualizerProducts.lean
|
isSheaf_iff_isSheafEqualizerProducts
|
The sheaf condition in terms of an equalizer diagram is equivalent
to the default sheaf condition.
|
OpensLeCover : Type w :=
ObjectProperty.FullSubcategory fun V : Opens X ↦ ∃ i, V ≤ U i
deriving Category
|
def
|
Topology
|
[
"Mathlib.Topology.Sheaves.SheafCondition.Sites"
] |
Mathlib/Topology/Sheaves/SheafCondition/OpensLeCover.lean
|
OpensLeCover
|
The category of open sets contained in some element of the cover.
|
index (V : OpensLeCover U) : ι :=
V.property.choose
|
def
|
Topology
|
[
"Mathlib.Topology.Sheaves.SheafCondition.Sites"
] |
Mathlib/Topology/Sheaves/SheafCondition/OpensLeCover.lean
|
index
|
An arbitrarily chosen index such that `V ≤ U i`.
|
homToIndex (V : OpensLeCover U) : V.obj ⟶ U (index V) :=
V.property.choose_spec.hom
|
def
|
Topology
|
[
"Mathlib.Topology.Sheaves.SheafCondition.Sites"
] |
Mathlib/Topology/Sheaves/SheafCondition/OpensLeCover.lean
|
homToIndex
|
The morphism from `V` to `U i` for some `i`.
|
opensLeCoverCocone : Cocone (ObjectProperty.ι _ : OpensLeCover U ⥤ Opens X) where
pt := iSup U
ι := { app := fun V : OpensLeCover U => V.homToIndex ≫ Opens.leSupr U _ }
|
def
|
Topology
|
[
"Mathlib.Topology.Sheaves.SheafCondition.Sites"
] |
Mathlib/Topology/Sheaves/SheafCondition/OpensLeCover.lean
|
opensLeCoverCocone
|
`iSup U` as a cocone over the opens sets contained in some element of the cover.
(In fact this is a colimit cocone.)
|
IsSheafOpensLeCover : Prop :=
∀ ⦃ι : Type w⦄ (U : ι → Opens X), Nonempty (IsLimit (F.mapCone (opensLeCoverCocone U).op))
|
def
|
Topology
|
[
"Mathlib.Topology.Sheaves.SheafCondition.Sites"
] |
Mathlib/Topology/Sheaves/SheafCondition/OpensLeCover.lean
|
IsSheafOpensLeCover
|
An equivalent formulation of the sheaf condition
(which we prove equivalent to the usual one below as
`isSheaf_iff_isSheafOpensLeCover`).
A presheaf is a sheaf if `F` sends the cone `(opensLeCoverCocone U).op` to a limit cone.
(Recall `opensLeCoverCocone U`, has cone point `iSup U`,
mapping down to any `V` which is contained in some `U i`.)
|
@[simps]
generateEquivalenceOpensLe_functor' :
(ObjectProperty.FullSubcategory
fun f : Over Y => (Sieve.generate (presieveOfCoveringAux U Y)).arrows f.hom) ⥤
OpensLeCover U :=
{ obj := fun f =>
⟨f.1.left,
let ⟨_, h, _, ⟨i, hY⟩, _⟩ := f.2
⟨i, hY ▸ h.le⟩⟩
map := fun {_ _} g => g.left }
|
def
|
Topology
|
[
"Mathlib.Topology.Sheaves.SheafCondition.Sites"
] |
Mathlib/Topology/Sheaves/SheafCondition/OpensLeCover.lean
|
generateEquivalenceOpensLe_functor'
|
Given a family of opens `U` and an open `Y` equal to the union of opens in `U`, we may
take the presieve on `Y` associated to `U` and the sieve generated by it, and form the
full subcategory (subposet) of opens contained in `Y` (`over Y`) consisting of arrows
in the sieve. This full subcategory is equivalent to `OpensLeCover U`, the (poset)
category of opens contained in some `U i`.
|
@[simps]
generateEquivalenceOpensLe_inverse' (hY : Y = iSup U) :
OpensLeCover U ⥤
(ObjectProperty.FullSubcategory fun f : Over Y =>
(Sieve.generate (presieveOfCoveringAux U Y)).arrows f.hom) where
obj := fun V => ⟨⟨V.obj, ⟨⟨⟩⟩, homOfLE <| hY ▸ (V.2.choose_spec.trans (le_iSup U (V.2.choose)))⟩,
⟨U V.2.choose, V.2.choose_spec.hom, homOfLE <| hY ▸ le_iSup U V.2.choose,
⟨V.2.choose, rfl⟩, rfl⟩⟩
map {_ _} g := Over.homMk g
map_id _ := by
refine Over.OverMorphism.ext ?_
simp only [Functor.id_obj, Sieve.generate_apply, Functor.const_obj_obj, Over.homMk_left,
eq_iff_true_of_subsingleton]
map_comp {_ _ _} f g := by
refine Over.OverMorphism.ext ?_
simp only [Functor.id_obj, Sieve.generate_apply, Functor.const_obj_obj, Over.homMk_left,
eq_iff_true_of_subsingleton]
|
def
|
Topology
|
[
"Mathlib.Topology.Sheaves.SheafCondition.Sites"
] |
Mathlib/Topology/Sheaves/SheafCondition/OpensLeCover.lean
|
generateEquivalenceOpensLe_inverse'
|
Given a family of opens `U` and an open `Y` equal to the union of opens in `U`, we may
take the presieve on `Y` associated to `U` and the sieve generated by it, and form the
full subcategory (subposet) of opens contained in `Y` (`over Y`) consisting of arrows
in the sieve. This full subcategory is equivalent to `OpensLeCover U`, the (poset)
category of opens contained in some `U i`.
|
@[simps]
generateEquivalenceOpensLe (hY : Y = iSup U) :
(ObjectProperty.FullSubcategory
fun f : Over Y => (Sieve.generate (presieveOfCoveringAux U Y)).arrows f.hom) ≌
OpensLeCover U where
functor := generateEquivalenceOpensLe_functor' _
inverse := generateEquivalenceOpensLe_inverse' _ hY
unitIso := eqToIso <| CategoryTheory.Functor.ext
(by rintro ⟨⟨_, _⟩, _⟩; dsimp; congr)
(by intros; refine Over.OverMorphism.ext ?_; simp)
counitIso := eqToIso <| CategoryTheory.Functor.hext
(by intro; refine ObjectProperty.FullSubcategory.ext ?_; rfl) (by intros; rfl)
|
def
|
Topology
|
[
"Mathlib.Topology.Sheaves.SheafCondition.Sites"
] |
Mathlib/Topology/Sheaves/SheafCondition/OpensLeCover.lean
|
generateEquivalenceOpensLe
|
Given a family of opens `U` and an open `Y` equal to the union of opens in `U`, we may
take the presieve on `Y` associated to `U` and the sieve generated by it, and form the
full subcategory (subposet) of opens contained in `Y` (`over Y`) consisting of arrows
in the sieve. This full subcategory is equivalent to `OpensLeCover U`, the (poset)
category of opens contained in some `U i`.
|
@[simps]
whiskerIsoMapGenerateCocone (hY : Y = iSup U) :
(F.mapCone (opensLeCoverCocone U).op).whisker (generateEquivalenceOpensLe U hY).op.functor ≅
F.mapCone (Sieve.generate (presieveOfCoveringAux U Y)).arrows.cocone.op where
hom :=
{ hom := F.map (eqToHom (congr_arg op hY.symm))
w := fun j => by
erw [← F.map_comp]
dsimp
congr 1 }
inv :=
{ hom := F.map (eqToHom (congr_arg op hY))
w := fun j => by
erw [← F.map_comp]
dsimp
congr 1 }
hom_inv_id := by
ext
simp [eqToHom_map]
inv_hom_id := by
ext
simp [eqToHom_map]
|
def
|
Topology
|
[
"Mathlib.Topology.Sheaves.SheafCondition.Sites"
] |
Mathlib/Topology/Sheaves/SheafCondition/OpensLeCover.lean
|
whiskerIsoMapGenerateCocone
|
Given a family of opens `opensLeCoverCocone U` is essentially the natural cocone
associated to the sieve generated by the presieve associated to `U` with indexing
category changed using the above equivalence.
|
isLimitOpensLeEquivGenerate₁ (hY : Y = iSup U) :
IsLimit (F.mapCone (opensLeCoverCocone U).op) ≃
IsLimit (F.mapCone (Sieve.generate (presieveOfCoveringAux U Y)).arrows.cocone.op) :=
(IsLimit.whiskerEquivalenceEquiv (generateEquivalenceOpensLe U hY).op).trans
(IsLimit.equivIsoLimit (whiskerIsoMapGenerateCocone F U hY))
|
def
|
Topology
|
[
"Mathlib.Topology.Sheaves.SheafCondition.Sites"
] |
Mathlib/Topology/Sheaves/SheafCondition/OpensLeCover.lean
|
isLimitOpensLeEquivGenerate₁
|
Given a presheaf `F` on the topological space `X` and a family of opens `U` of `X`,
the natural cone associated to `F` and `U` used in the definition of
`F.IsSheafOpensLeCover` is a limit cone iff the natural cone associated to `F`
and the sieve generated by the presieve associated to `U` is a limit cone.
|
isLimitOpensLeEquivGenerate₂ (R : Presieve Y)
(hR : Sieve.generate R ∈ Opens.grothendieckTopology X Y) :
IsLimit (F.mapCone (opensLeCoverCocone (coveringOfPresieve Y R)).op) ≃
IsLimit (F.mapCone (Sieve.generate R).arrows.cocone.op) := by
convert isLimitOpensLeEquivGenerate₁ F (coveringOfPresieve Y R)
(coveringOfPresieve.iSup_eq_of_mem_grothendieck Y R hR).symm using 1
rw [covering_presieve_eq_self R]
variable {F} in
|
def
|
Topology
|
[
"Mathlib.Topology.Sheaves.SheafCondition.Sites"
] |
Mathlib/Topology/Sheaves/SheafCondition/OpensLeCover.lean
|
isLimitOpensLeEquivGenerate₂
|
Given a presheaf `F` on the topological space `X` and a presieve `R` whose generated sieve
is covering for the associated Grothendieck topology (equivalently, the presieve is covering
for the associated pretopology), the natural cone associated to `F` and the family of opens
associated to `R` is a limit cone iff the natural cone associated to `F` and the generated
sieve is a limit cone.
Since only the existence of a 1-1 correspondence will be used, the exact definition does
not matter, so tactics are used liberally.
|
IsSheaf.isSheafOpensLeCover (h : F.IsSheaf) :
Nonempty (IsLimit (F.mapCone (opensLeCoverCocone U).op)) := by
rw [(isLimitOpensLeEquivGenerate₁ F U rfl).nonempty_congr]
apply (Presheaf.isSheaf_iff_isLimit _ _).mp h
apply presieveOfCovering.mem_grothendieckTopology
|
theorem
|
Topology
|
[
"Mathlib.Topology.Sheaves.SheafCondition.Sites"
] |
Mathlib/Topology/Sheaves/SheafCondition/OpensLeCover.lean
|
IsSheaf.isSheafOpensLeCover
| null |
isSheaf_iff_isSheafOpensLeCover : F.IsSheaf ↔ F.IsSheafOpensLeCover := by
refine ⟨fun h _ ↦ h.isSheafOpensLeCover,
fun h ↦ (Presheaf.isSheaf_iff_isLimit _ _).mpr fun Y S ↦ ?_⟩
rw [← Sieve.generate_sieve S]
intro hS
rw [← (isLimitOpensLeEquivGenerate₂ F S.1 hS).nonempty_congr]
apply h
|
theorem
|
Topology
|
[
"Mathlib.Topology.Sheaves.SheafCondition.Sites"
] |
Mathlib/Topology/Sheaves/SheafCondition/OpensLeCover.lean
|
isSheaf_iff_isSheafOpensLeCover
|
A presheaf `(opens X)ᵒᵖ ⥤ C` on a topological space `X` is a sheaf on the site `opens X` iff
it satisfies the `IsSheafOpensLeCover` sheaf condition. The latter is not the
official definition of sheaves on spaces, but has the advantage that it does not
require `has_products C`.
|
IsSheafPairwiseIntersections (F : Presheaf C X) : Prop :=
∀ ⦃ι : Type w⦄ (U : ι → Opens X), Nonempty (IsLimit (F.mapCone (Pairwise.cocone U).op))
|
def
|
Topology
|
[
"Mathlib.CategoryTheory.Category.Pairwise",
"Mathlib.CategoryTheory.Limits.Constructions.BinaryProducts",
"Mathlib.CategoryTheory.Limits.Final",
"Mathlib.CategoryTheory.Limits.Preserves.Basic",
"Mathlib.Topology.Sheaves.SheafCondition.OpensLeCover"
] |
Mathlib/Topology/Sheaves/SheafCondition/PairwiseIntersections.lean
|
IsSheafPairwiseIntersections
|
An alternative formulation of the sheaf condition
(which we prove equivalent to the usual one below as
`isSheaf_iff_isSheafPairwiseIntersections`).
A presheaf is a sheaf if `F` sends the cone `(Pairwise.cocone U).op` to a limit cone.
(Recall `Pairwise.cocone U` has cone point `iSup U`, mapping down to the `U i` and the `U i ⊓ U j`.)
|
IsSheafPreservesLimitPairwiseIntersections (F : Presheaf C X) : Prop :=
∀ ⦃ι : Type w⦄ (U : ι → Opens X), PreservesLimit (Pairwise.diagram U).op F
|
def
|
Topology
|
[
"Mathlib.CategoryTheory.Category.Pairwise",
"Mathlib.CategoryTheory.Limits.Constructions.BinaryProducts",
"Mathlib.CategoryTheory.Limits.Final",
"Mathlib.CategoryTheory.Limits.Preserves.Basic",
"Mathlib.Topology.Sheaves.SheafCondition.OpensLeCover"
] |
Mathlib/Topology/Sheaves/SheafCondition/PairwiseIntersections.lean
|
IsSheafPreservesLimitPairwiseIntersections
|
An alternative formulation of the sheaf condition
(which we prove equivalent to the usual one below as
`isSheaf_iff_isSheafPreservesLimitPairwiseIntersections`).
A presheaf is a sheaf if `F` preserves the limit of `Pairwise.diagram U`.
(Recall `Pairwise.diagram U` is the diagram consisting of the pairwise intersections
`U i ⊓ U j` mapping into the open sets `U i`. This diagram has limit `iSup U`.)
|
@[simp]
pairwiseToOpensLeCoverObj : Pairwise ι → OpensLeCover U
| single i => ⟨U i, ⟨i, le_rfl⟩⟩
| Pairwise.pair i j => ⟨U i ⊓ U j, ⟨i, inf_le_left⟩⟩
open CategoryTheory.Pairwise.Hom
|
def
|
Topology
|
[
"Mathlib.CategoryTheory.Category.Pairwise",
"Mathlib.CategoryTheory.Limits.Constructions.BinaryProducts",
"Mathlib.CategoryTheory.Limits.Final",
"Mathlib.CategoryTheory.Limits.Preserves.Basic",
"Mathlib.Topology.Sheaves.SheafCondition.OpensLeCover"
] |
Mathlib/Topology/Sheaves/SheafCondition/PairwiseIntersections.lean
|
pairwiseToOpensLeCoverObj
|
Implementation detail:
the object level of `pairwiseToOpensLeCover : Pairwise ι ⥤ OpensLeCover U`
|
pairwiseToOpensLeCoverMap :
∀ {V W : Pairwise ι}, (V ⟶ W) → (pairwiseToOpensLeCoverObj U V ⟶ pairwiseToOpensLeCoverObj U W)
| _, _, id_single _ => 𝟙 _
| _, _, id_pair _ _ => 𝟙 _
| _, _, left _ _ => homOfLE inf_le_left
| _, _, right _ _ => homOfLE inf_le_right
|
def
|
Topology
|
[
"Mathlib.CategoryTheory.Category.Pairwise",
"Mathlib.CategoryTheory.Limits.Constructions.BinaryProducts",
"Mathlib.CategoryTheory.Limits.Final",
"Mathlib.CategoryTheory.Limits.Preserves.Basic",
"Mathlib.Topology.Sheaves.SheafCondition.OpensLeCover"
] |
Mathlib/Topology/Sheaves/SheafCondition/PairwiseIntersections.lean
|
pairwiseToOpensLeCoverMap
|
Implementation detail:
the morphism level of `pairwiseToOpensLeCover : Pairwise ι ⥤ OpensLeCover U`
|
@[simps]
pairwiseToOpensLeCover : Pairwise ι ⥤ OpensLeCover U where
obj := pairwiseToOpensLeCoverObj U
map {_ _} i := pairwiseToOpensLeCoverMap U i
|
def
|
Topology
|
[
"Mathlib.CategoryTheory.Category.Pairwise",
"Mathlib.CategoryTheory.Limits.Constructions.BinaryProducts",
"Mathlib.CategoryTheory.Limits.Final",
"Mathlib.CategoryTheory.Limits.Preserves.Basic",
"Mathlib.Topology.Sheaves.SheafCondition.OpensLeCover"
] |
Mathlib/Topology/Sheaves/SheafCondition/PairwiseIntersections.lean
|
pairwiseToOpensLeCover
|
The category of single and double intersections of the `U i` maps into the category
of open sets below some `U i`.
|
pairwiseDiagramIso :
Pairwise.diagram U ≅ pairwiseToOpensLeCover U ⋙ ObjectProperty.ι _ where
hom := { app := by rintro (i | ⟨i, j⟩) <;> exact 𝟙 _ }
inv := { app := by rintro (i | ⟨i, j⟩) <;> exact 𝟙 _ }
|
def
|
Topology
|
[
"Mathlib.CategoryTheory.Category.Pairwise",
"Mathlib.CategoryTheory.Limits.Constructions.BinaryProducts",
"Mathlib.CategoryTheory.Limits.Final",
"Mathlib.CategoryTheory.Limits.Preserves.Basic",
"Mathlib.Topology.Sheaves.SheafCondition.OpensLeCover"
] |
Mathlib/Topology/Sheaves/SheafCondition/PairwiseIntersections.lean
|
pairwiseDiagramIso
|
The diagram consisting of the `U i` and `U i ⊓ U j` is cofinal in the diagram
of all opens contained in some `U i`.
-/
instance : Functor.Final (pairwiseToOpensLeCover U) :=
⟨fun V =>
isConnected_of_zigzag fun A B => by
rcases A with ⟨⟨⟨⟩⟩, ⟨i⟩ | ⟨i, j⟩, a⟩ <;> rcases B with ⟨⟨⟨⟩⟩, ⟨i'⟩ | ⟨i', j'⟩, b⟩
· refine
⟨[{ left := ⟨⟨⟩⟩
right := pair i i'
hom := (le_inf a.le b.le).hom }, _], ?_, rfl⟩
exact
List.IsChain.cons_cons
(Or.inr
⟨{ left := 𝟙 _
right := left i i' }⟩)
(List.IsChain.cons_cons
(Or.inl
⟨{ left := 𝟙 _
right := right i i' }⟩)
(List.IsChain.singleton _))
· refine
⟨[{ left := ⟨⟨⟩⟩
right := pair i' i
hom := (le_inf (b.le.trans inf_le_left) a.le).hom },
{ left := ⟨⟨⟩⟩
right := single i'
hom := (b.le.trans inf_le_left).hom }, _], ?_, rfl⟩
exact
List.IsChain.cons_cons
(Or.inr
⟨{ left := 𝟙 _
right := right i' i }⟩)
(List.IsChain.cons_cons
(Or.inl
⟨{ left := 𝟙 _
right := left i' i }⟩)
(List.IsChain.cons_cons
(Or.inr
⟨{ left := 𝟙 _
right := left i' j' }⟩)
(List.IsChain.singleton _)))
· refine
⟨[{ left := ⟨⟨⟩⟩
right := single i
hom := (a.le.trans inf_le_left).hom },
{ left := ⟨⟨⟩⟩
right := pair i i'
hom := (le_inf (a.le.trans inf_le_left) b.le).hom }, _], ?_, rfl⟩
exact
List.IsChain.cons_cons
(Or.inl
⟨{ left := 𝟙 _
right := left i j }⟩)
(List.IsChain.cons_cons
(Or.inr
⟨{ left := 𝟙 _
right := left i i' }⟩)
(List.IsChain.cons_cons
(Or.inl
⟨{ left := 𝟙 _
right := right i i' }⟩)
(List.IsChain.singleton _)))
· refine
⟨[{ left := ⟨⟨⟩⟩
right := single i
hom := (a.le.trans inf_le_left).hom },
{ left := ⟨⟨⟩⟩
right := pair i i'
hom := (le_inf (a.le.trans inf_le_left) (b.le.trans inf_le_left)).hom },
{ left := ⟨⟨⟩⟩
right := single i'
hom := (b.le.trans inf_le_left).hom }, _], ?_, rfl⟩
exact
List.IsChain.cons_cons
(Or.inl
⟨{ left := 𝟙 _
right := left i j }⟩)
(List.IsChain.cons_cons
(Or.inr
⟨{ left := 𝟙 _
right := left i i' }⟩)
(List.IsChain.cons_cons
(Or.inl
⟨{ left := 𝟙 _
right := right i i' }⟩)
(List.IsChain.cons_cons
(Or.inr
⟨{ left := 𝟙 _
right := left i' j' }⟩)
(List.IsChain.singleton _))))⟩
/-- The diagram in `Opens X` indexed by pairwise intersections from `U` is isomorphic
(in fact, equal) to the diagram factored through `OpensLeCover U`.
|
pairwiseCoconeIso :
(Pairwise.cocone U).op ≅
(Cones.postcomposeEquivalence (NatIso.op (pairwiseDiagramIso U :) :)).functor.obj
((opensLeCoverCocone U).op.whisker (pairwiseToOpensLeCover U).op) :=
Cones.ext (Iso.refl _) (by cat_disch)
|
def
|
Topology
|
[
"Mathlib.CategoryTheory.Category.Pairwise",
"Mathlib.CategoryTheory.Limits.Constructions.BinaryProducts",
"Mathlib.CategoryTheory.Limits.Final",
"Mathlib.CategoryTheory.Limits.Preserves.Basic",
"Mathlib.Topology.Sheaves.SheafCondition.OpensLeCover"
] |
Mathlib/Topology/Sheaves/SheafCondition/PairwiseIntersections.lean
|
pairwiseCoconeIso
|
The cocone `Pairwise.cocone U` with cocone point `iSup U` over `Pairwise.diagram U` is isomorphic
to the cocone `opensLeCoverCocone U` (with the same cocone point)
after appropriate whiskering and postcomposition.
|
isLimitOpensLeCoverEquivPairwise :
IsLimit (F.mapCone (opensLeCoverCocone U).op) ≃ IsLimit (F.mapCone (Pairwise.cocone U).op) :=
calc
IsLimit (F.mapCone (opensLeCoverCocone U).op) ≃
IsLimit ((F.mapCone (opensLeCoverCocone U).op).whisker (pairwiseToOpensLeCover U).op) :=
(Functor.Initial.isLimitWhiskerEquiv (pairwiseToOpensLeCover U).op _).symm
_ ≃ IsLimit (F.mapCone ((opensLeCoverCocone U).op.whisker (pairwiseToOpensLeCover U).op)) :=
(IsLimit.equivIsoLimit F.mapConeWhisker.symm)
_ ≃
IsLimit
((Cones.postcomposeEquivalence _).functor.obj
(F.mapCone ((opensLeCoverCocone U).op.whisker (pairwiseToOpensLeCover U).op))) :=
(IsLimit.postcomposeHomEquiv _ _).symm
_ ≃
IsLimit
(F.mapCone
((Cones.postcomposeEquivalence _).functor.obj
((opensLeCoverCocone U).op.whisker (pairwiseToOpensLeCover U).op))) :=
(IsLimit.equivIsoLimit (Functor.mapConePostcomposeEquivalenceFunctor _).symm)
_ ≃ IsLimit (F.mapCone (Pairwise.cocone U).op) :=
IsLimit.equivIsoLimit ((Cones.functoriality _ _).mapIso (pairwiseCoconeIso U :).symm)
|
def
|
Topology
|
[
"Mathlib.CategoryTheory.Category.Pairwise",
"Mathlib.CategoryTheory.Limits.Constructions.BinaryProducts",
"Mathlib.CategoryTheory.Limits.Final",
"Mathlib.CategoryTheory.Limits.Preserves.Basic",
"Mathlib.Topology.Sheaves.SheafCondition.OpensLeCover"
] |
Mathlib/Topology/Sheaves/SheafCondition/PairwiseIntersections.lean
|
isLimitOpensLeCoverEquivPairwise
|
The diagram over all `{ V : Opens X // ∃ i, V ≤ U i }` is a limit iff the diagram
over `U i` and `U i ⊓ U j` is a limit.
|
isSheafOpensLeCover_iff_isSheafPairwiseIntersections :
F.IsSheafOpensLeCover ↔ F.IsSheafPairwiseIntersections :=
forall₂_congr fun _ U ↦ (F.isLimitOpensLeCoverEquivPairwise U).nonempty_congr
variable {F} in
|
theorem
|
Topology
|
[
"Mathlib.CategoryTheory.Category.Pairwise",
"Mathlib.CategoryTheory.Limits.Constructions.BinaryProducts",
"Mathlib.CategoryTheory.Limits.Final",
"Mathlib.CategoryTheory.Limits.Preserves.Basic",
"Mathlib.Topology.Sheaves.SheafCondition.OpensLeCover"
] |
Mathlib/Topology/Sheaves/SheafCondition/PairwiseIntersections.lean
|
isSheafOpensLeCover_iff_isSheafPairwiseIntersections
|
The sheaf condition
in terms of a limit diagram over all `{ V : Opens X // ∃ i, V ≤ U i }`
is equivalent to the reformulation
in terms of a limit diagram over `U i` and `U i ⊓ U j`.
|
IsSheaf.isSheafPairwiseIntersections (h : F.IsSheaf) :
Nonempty (IsLimit (F.mapCone (Pairwise.cocone U).op)) :=
(h.isSheafOpensLeCover U).map (F.isLimitOpensLeCoverEquivPairwise _)
|
theorem
|
Topology
|
[
"Mathlib.CategoryTheory.Category.Pairwise",
"Mathlib.CategoryTheory.Limits.Constructions.BinaryProducts",
"Mathlib.CategoryTheory.Limits.Final",
"Mathlib.CategoryTheory.Limits.Preserves.Basic",
"Mathlib.Topology.Sheaves.SheafCondition.OpensLeCover"
] |
Mathlib/Topology/Sheaves/SheafCondition/PairwiseIntersections.lean
|
IsSheaf.isSheafPairwiseIntersections
| null |
isSheaf_iff_isSheafPairwiseIntersections : F.IsSheaf ↔ F.IsSheafPairwiseIntersections := by
rw [isSheaf_iff_isSheafOpensLeCover, isSheafOpensLeCover_iff_isSheafPairwiseIntersections]
variable {F} in
|
theorem
|
Topology
|
[
"Mathlib.CategoryTheory.Category.Pairwise",
"Mathlib.CategoryTheory.Limits.Constructions.BinaryProducts",
"Mathlib.CategoryTheory.Limits.Final",
"Mathlib.CategoryTheory.Limits.Preserves.Basic",
"Mathlib.Topology.Sheaves.SheafCondition.OpensLeCover"
] |
Mathlib/Topology/Sheaves/SheafCondition/PairwiseIntersections.lean
|
isSheaf_iff_isSheafPairwiseIntersections
|
The sheaf condition in terms of an equalizer diagram is equivalent
to the reformulation in terms of a limit diagram over `U i` and `U i ⊓ U j`.
|
IsSheaf.isSheafPreservesLimitPairwiseIntersections (h : F.IsSheaf) :
PreservesLimit (Pairwise.diagram U).op F :=
preservesLimit_of_preserves_limit_cone (Pairwise.coconeIsColimit U).op
(h.isSheafPairwiseIntersections U).some
|
theorem
|
Topology
|
[
"Mathlib.CategoryTheory.Category.Pairwise",
"Mathlib.CategoryTheory.Limits.Constructions.BinaryProducts",
"Mathlib.CategoryTheory.Limits.Final",
"Mathlib.CategoryTheory.Limits.Preserves.Basic",
"Mathlib.Topology.Sheaves.SheafCondition.OpensLeCover"
] |
Mathlib/Topology/Sheaves/SheafCondition/PairwiseIntersections.lean
|
IsSheaf.isSheafPreservesLimitPairwiseIntersections
| null |
isSheaf_iff_isSheafPreservesLimitPairwiseIntersections :
F.IsSheaf ↔ F.IsSheafPreservesLimitPairwiseIntersections := by
refine ⟨fun h U ↦ h.isSheafPreservesLimitPairwiseIntersections,
fun h ↦ F.isSheaf_iff_isSheafPairwiseIntersections.mpr fun ι U ↦ ?_⟩
haveI := h U
exact ⟨isLimitOfPreserves _ (Pairwise.coconeIsColimit U).op⟩
|
theorem
|
Topology
|
[
"Mathlib.CategoryTheory.Category.Pairwise",
"Mathlib.CategoryTheory.Limits.Constructions.BinaryProducts",
"Mathlib.CategoryTheory.Limits.Final",
"Mathlib.CategoryTheory.Limits.Preserves.Basic",
"Mathlib.Topology.Sheaves.SheafCondition.OpensLeCover"
] |
Mathlib/Topology/Sheaves/SheafCondition/PairwiseIntersections.lean
|
isSheaf_iff_isSheafPreservesLimitPairwiseIntersections
|
The sheaf condition in terms of an equalizer diagram is equivalent
to the reformulation in terms of the presheaf preserving the limit of the diagram
consisting of the `U i` and `U i ⊓ U j`.
|
interUnionPullbackCone :
PullbackCone (F.1.map (homOfLE inf_le_left : U ⊓ V ⟶ _).op)
(F.1.map (homOfLE inf_le_right).op) :=
PullbackCone.mk (F.1.map (homOfLE le_sup_left).op) (F.1.map (homOfLE le_sup_right).op) <| by
rw [← F.1.map_comp, ← F.1.map_comp]
congr 1
@[simp]
|
def
|
Topology
|
[
"Mathlib.CategoryTheory.Category.Pairwise",
"Mathlib.CategoryTheory.Limits.Constructions.BinaryProducts",
"Mathlib.CategoryTheory.Limits.Final",
"Mathlib.CategoryTheory.Limits.Preserves.Basic",
"Mathlib.Topology.Sheaves.SheafCondition.OpensLeCover"
] |
Mathlib/Topology/Sheaves/SheafCondition/PairwiseIntersections.lean
|
interUnionPullbackCone
|
For a sheaf `F`, `F(U ⊔ V)` is the pullback of `F(U) ⟶ F(U ⊓ V)` and `F(V) ⟶ F(U ⊓ V)`.
This is the pullback cone.
|
interUnionPullbackCone_pt : (interUnionPullbackCone F U V).pt = F.1.obj (op <| U ⊔ V) :=
rfl
@[simp]
|
theorem
|
Topology
|
[
"Mathlib.CategoryTheory.Category.Pairwise",
"Mathlib.CategoryTheory.Limits.Constructions.BinaryProducts",
"Mathlib.CategoryTheory.Limits.Final",
"Mathlib.CategoryTheory.Limits.Preserves.Basic",
"Mathlib.Topology.Sheaves.SheafCondition.OpensLeCover"
] |
Mathlib/Topology/Sheaves/SheafCondition/PairwiseIntersections.lean
|
interUnionPullbackCone_pt
| null |
interUnionPullbackCone_fst :
(interUnionPullbackCone F U V).fst = F.1.map (homOfLE le_sup_left).op :=
rfl
@[simp]
|
theorem
|
Topology
|
[
"Mathlib.CategoryTheory.Category.Pairwise",
"Mathlib.CategoryTheory.Limits.Constructions.BinaryProducts",
"Mathlib.CategoryTheory.Limits.Final",
"Mathlib.CategoryTheory.Limits.Preserves.Basic",
"Mathlib.Topology.Sheaves.SheafCondition.OpensLeCover"
] |
Mathlib/Topology/Sheaves/SheafCondition/PairwiseIntersections.lean
|
interUnionPullbackCone_fst
| null |
interUnionPullbackCone_snd :
(interUnionPullbackCone F U V).snd = F.1.map (homOfLE le_sup_right).op :=
rfl
variable
(s :
PullbackCone (F.1.map (homOfLE inf_le_left : U ⊓ V ⟶ _).op) (F.1.map (homOfLE inf_le_right).op))
|
theorem
|
Topology
|
[
"Mathlib.CategoryTheory.Category.Pairwise",
"Mathlib.CategoryTheory.Limits.Constructions.BinaryProducts",
"Mathlib.CategoryTheory.Limits.Final",
"Mathlib.CategoryTheory.Limits.Preserves.Basic",
"Mathlib.Topology.Sheaves.SheafCondition.OpensLeCover"
] |
Mathlib/Topology/Sheaves/SheafCondition/PairwiseIntersections.lean
|
interUnionPullbackCone_snd
| null |
interUnionPullbackConeLift : s.pt ⟶ F.1.obj (op (U ⊔ V)) := by
let ι : ULift.{w} WalkingPair → Opens X := fun j => WalkingPair.casesOn j.down U V
have hι : U ⊔ V = iSup ι := by
ext
rw [Opens.coe_iSup, Set.mem_iUnion]
constructor
· rintro (h | h)
exacts [⟨⟨WalkingPair.left⟩, h⟩, ⟨⟨WalkingPair.right⟩, h⟩]
· rintro ⟨⟨_ | _⟩, h⟩
exacts [Or.inl h, Or.inr h]
refine
(F.presheaf.isSheaf_iff_isSheafPairwiseIntersections.mp F.2 ι).some.lift
⟨s.pt,
{ app := ?_
naturality := ?_ }⟩ ≫
F.1.map (eqToHom hι).op
· rintro ((_ | _) | (_ | _))
exacts [s.fst, s.snd, s.fst ≫ F.1.map (homOfLE inf_le_left).op,
s.snd ≫ F.1.map (homOfLE inf_le_left).op]
rintro ⟨i⟩ ⟨j⟩ f
let g : j ⟶ i := f.unop
have : f = g.op := rfl
clear_value g
subst this
rcases i with (⟨⟨_ | _⟩⟩ | ⟨⟨_ | _⟩, ⟨_⟩⟩) <;>
rcases j with (⟨⟨_ | _⟩⟩ | ⟨⟨_ | _⟩, ⟨_⟩⟩) <;>
rcases g with ⟨⟩ <;>
dsimp [Pairwise.diagram] <;>
simp only [ι, Category.id_comp, s.condition, CategoryTheory.Functor.map_id, Category.comp_id]
rw [← cancel_mono (F.1.map (eqToHom <| inf_comm U V : U ⊓ V ⟶ _).op), Category.assoc,
Category.assoc, ← F.1.map_comp, ← F.1.map_comp]
exact s.condition.symm
|
def
|
Topology
|
[
"Mathlib.CategoryTheory.Category.Pairwise",
"Mathlib.CategoryTheory.Limits.Constructions.BinaryProducts",
"Mathlib.CategoryTheory.Limits.Final",
"Mathlib.CategoryTheory.Limits.Preserves.Basic",
"Mathlib.Topology.Sheaves.SheafCondition.OpensLeCover"
] |
Mathlib/Topology/Sheaves/SheafCondition/PairwiseIntersections.lean
|
interUnionPullbackConeLift
|
(Implementation).
Every cone over `F(U) ⟶ F(U ⊓ V)` and `F(V) ⟶ F(U ⊓ V)` factors through `F(U ⊔ V)`.
|
interUnionPullbackConeLift_left :
interUnionPullbackConeLift F U V s ≫ F.1.map (homOfLE le_sup_left).op = s.fst := by
erw [Category.assoc]
simp_rw [← F.1.map_comp]
exact
(F.presheaf.isSheaf_iff_isSheafPairwiseIntersections.mp F.2 _).some.fac _ <|
op <| Pairwise.single <| ULift.up WalkingPair.left
|
theorem
|
Topology
|
[
"Mathlib.CategoryTheory.Category.Pairwise",
"Mathlib.CategoryTheory.Limits.Constructions.BinaryProducts",
"Mathlib.CategoryTheory.Limits.Final",
"Mathlib.CategoryTheory.Limits.Preserves.Basic",
"Mathlib.Topology.Sheaves.SheafCondition.OpensLeCover"
] |
Mathlib/Topology/Sheaves/SheafCondition/PairwiseIntersections.lean
|
interUnionPullbackConeLift_left
| null |
interUnionPullbackConeLift_right :
interUnionPullbackConeLift F U V s ≫ F.1.map (homOfLE le_sup_right).op = s.snd := by
erw [Category.assoc]
simp_rw [← F.1.map_comp]
exact
(F.presheaf.isSheaf_iff_isSheafPairwiseIntersections.mp F.2 _).some.fac _ <|
op <| Pairwise.single <| ULift.up WalkingPair.right
|
theorem
|
Topology
|
[
"Mathlib.CategoryTheory.Category.Pairwise",
"Mathlib.CategoryTheory.Limits.Constructions.BinaryProducts",
"Mathlib.CategoryTheory.Limits.Final",
"Mathlib.CategoryTheory.Limits.Preserves.Basic",
"Mathlib.Topology.Sheaves.SheafCondition.OpensLeCover"
] |
Mathlib/Topology/Sheaves/SheafCondition/PairwiseIntersections.lean
|
interUnionPullbackConeLift_right
| null |
isLimitPullbackCone : IsLimit (interUnionPullbackCone F U V) := by
let ι : ULift.{w} WalkingPair → Opens X := fun ⟨j⟩ => WalkingPair.casesOn j U V
have hι : U ⊔ V = iSup ι := by
ext
rw [Opens.coe_iSup, Set.mem_iUnion]
constructor
· rintro (h | h)
exacts [⟨⟨WalkingPair.left⟩, h⟩, ⟨⟨WalkingPair.right⟩, h⟩]
· rintro ⟨⟨_ | _⟩, h⟩
exacts [Or.inl h, Or.inr h]
apply PullbackCone.isLimitAux'
intro s
use interUnionPullbackConeLift F U V s
refine ⟨?_, ?_, ?_⟩
· apply interUnionPullbackConeLift_left
· apply interUnionPullbackConeLift_right
· intro m h₁ h₂
rw [← cancel_mono (F.1.map (eqToHom hι.symm).op)]
apply (F.presheaf.isSheaf_iff_isSheafPairwiseIntersections.mp F.2 ι).some.hom_ext
rintro ((_ | _) | (_ | _)) <;>
rw [Category.assoc, Category.assoc]
· erw [← F.1.map_comp]
convert h₁
apply interUnionPullbackConeLift_left
· erw [← F.1.map_comp]
convert h₂
apply interUnionPullbackConeLift_right
all_goals
dsimp only [Functor.op, Pairwise.cocone_ι_app, Functor.mapCone_π_app, Cocone.op,
Pairwise.coconeιApp, unop_op, op_comp, NatTrans.op]
simp_rw [F.1.map_comp, ← Category.assoc]
congr 1
simp_rw [Category.assoc, ← F.1.map_comp]
· convert h₁
apply interUnionPullbackConeLift_left
· convert h₂
apply interUnionPullbackConeLift_right
|
def
|
Topology
|
[
"Mathlib.CategoryTheory.Category.Pairwise",
"Mathlib.CategoryTheory.Limits.Constructions.BinaryProducts",
"Mathlib.CategoryTheory.Limits.Final",
"Mathlib.CategoryTheory.Limits.Preserves.Basic",
"Mathlib.Topology.Sheaves.SheafCondition.OpensLeCover"
] |
Mathlib/Topology/Sheaves/SheafCondition/PairwiseIntersections.lean
|
isLimitPullbackCone
|
For a sheaf `F`, `F(U ⊔ V)` is the pullback of `F(U) ⟶ F(U ⊓ V)` and `F(V) ⟶ F(U ⊓ V)`.
|
isProductOfDisjoint (h : U ⊓ V = ⊥) :
IsLimit
(BinaryFan.mk (F.1.map (homOfLE le_sup_left : _ ⟶ U ⊔ V).op)
(F.1.map (homOfLE le_sup_right : _ ⟶ U ⊔ V).op)) :=
isProductOfIsTerminalIsPullback _ _ _ _ (F.isTerminalOfEqEmpty h) (isLimitPullbackCone F U V)
|
def
|
Topology
|
[
"Mathlib.CategoryTheory.Category.Pairwise",
"Mathlib.CategoryTheory.Limits.Constructions.BinaryProducts",
"Mathlib.CategoryTheory.Limits.Final",
"Mathlib.CategoryTheory.Limits.Preserves.Basic",
"Mathlib.Topology.Sheaves.SheafCondition.OpensLeCover"
] |
Mathlib/Topology/Sheaves/SheafCondition/PairwiseIntersections.lean
|
isProductOfDisjoint
|
If `U, V` are disjoint, then `F(U ⊔ V) = F(U) × F(V)`.
|
coveringOfPresieve (U : Opens X) (R : Presieve U) : (Σ V, { f : V ⟶ U // R f }) → Opens X :=
fun f => f.1
@[simp]
|
def
|
Topology
|
[
"Mathlib.CategoryTheory.Sites.Spaces",
"Mathlib.Topology.Sheaves.Sheaf",
"Mathlib.CategoryTheory.Sites.DenseSubsite.Basic"
] |
Mathlib/Topology/Sheaves/SheafCondition/Sites.lean
|
coveringOfPresieve
|
Given a presieve `R` on `U`, we obtain a covering family of open sets in `X`, by taking as index
type the type of dependent pairs `(V, f)`, where `f : V ⟶ U` is in `R`.
|
coveringOfPresieve_apply (U : Opens X) (R : Presieve U) (f : Σ V, { f : V ⟶ U // R f }) :
coveringOfPresieve U R f = f.1 := rfl
|
theorem
|
Topology
|
[
"Mathlib.CategoryTheory.Sites.Spaces",
"Mathlib.Topology.Sheaves.Sheaf",
"Mathlib.CategoryTheory.Sites.DenseSubsite.Basic"
] |
Mathlib/Topology/Sheaves/SheafCondition/Sites.lean
|
coveringOfPresieve_apply
| null |
iSup_eq_of_mem_grothendieck (hR : Sieve.generate R ∈ Opens.grothendieckTopology X U) :
iSup (coveringOfPresieve U R) = U := by
apply le_antisymm
· refine iSup_le ?_
intro f
exact f.2.1.le
intro x hxU
rw [Opens.coe_iSup, Set.mem_iUnion]
obtain ⟨V, iVU, ⟨W, iVW, iWU, hiWU, -⟩, hxV⟩ := hR x hxU
exact ⟨⟨W, ⟨iWU, hiWU⟩⟩, iVW.le hxV⟩
|
theorem
|
Topology
|
[
"Mathlib.CategoryTheory.Sites.Spaces",
"Mathlib.Topology.Sheaves.Sheaf",
"Mathlib.CategoryTheory.Sites.DenseSubsite.Basic"
] |
Mathlib/Topology/Sheaves/SheafCondition/Sites.lean
|
iSup_eq_of_mem_grothendieck
|
If `R` is a presieve in the Grothendieck topology on `Opens X`, the covering family associated
to `R` really is _covering_, i.e. the union of all open sets equals `U`.
|
presieveOfCoveringAux {ι : Type v} (U : ι → Opens X) (Y : Opens X) : Presieve Y :=
fun V _ => ∃ i, V = U i
|
def
|
Topology
|
[
"Mathlib.CategoryTheory.Sites.Spaces",
"Mathlib.Topology.Sheaves.Sheaf",
"Mathlib.CategoryTheory.Sites.DenseSubsite.Basic"
] |
Mathlib/Topology/Sheaves/SheafCondition/Sites.lean
|
presieveOfCoveringAux
|
Given a family of opens `U : ι → Opens X` and any open `Y : Opens X`, we obtain a presieve
on `Y` by declaring that a morphism `f : V ⟶ Y` is a member of the presieve if and only if
there exists an index `i : ι` such that `V = U i`.
|
presieveOfCovering {ι : Type v} (U : ι → Opens X) : Presieve (iSup U) :=
presieveOfCoveringAux U (iSup U)
|
def
|
Topology
|
[
"Mathlib.CategoryTheory.Sites.Spaces",
"Mathlib.Topology.Sheaves.Sheaf",
"Mathlib.CategoryTheory.Sites.DenseSubsite.Basic"
] |
Mathlib/Topology/Sheaves/SheafCondition/Sites.lean
|
presieveOfCovering
|
Take `Y` to be `iSup U` and obtain a presieve over `iSup U`.
|
@[simp]
covering_presieve_eq_self {Y : Opens X} (R : Presieve Y) :
presieveOfCoveringAux (coveringOfPresieve Y R) Y = R := by
funext Z
ext f
exact ⟨fun ⟨⟨_, f', h⟩, rfl⟩ => by rwa [Subsingleton.elim f f'], fun h => ⟨⟨Z, f, h⟩, rfl⟩⟩
|
theorem
|
Topology
|
[
"Mathlib.CategoryTheory.Sites.Spaces",
"Mathlib.Topology.Sheaves.Sheaf",
"Mathlib.CategoryTheory.Sites.DenseSubsite.Basic"
] |
Mathlib/Topology/Sheaves/SheafCondition/Sites.lean
|
covering_presieve_eq_self
|
Given a presieve `R` on `Y`, if we take its associated family of opens via `coveringOfPresieve`
(which may not cover `Y` if `R` is not covering), and take the presieve on `Y` associated to the
family of opens via `presieveOfCoveringAux`, then we get back the original presieve `R`.
|
mem_grothendieckTopology :
Sieve.generate (presieveOfCovering U) ∈ Opens.grothendieckTopology X (iSup U) := by
intro x hx
obtain ⟨i, hxi⟩ := Opens.mem_iSup.mp hx
exact ⟨U i, Opens.leSupr U i, ⟨U i, 𝟙 _, Opens.leSupr U i, ⟨i, rfl⟩, Category.id_comp _⟩, hxi⟩
|
theorem
|
Topology
|
[
"Mathlib.CategoryTheory.Sites.Spaces",
"Mathlib.Topology.Sheaves.Sheaf",
"Mathlib.CategoryTheory.Sites.DenseSubsite.Basic"
] |
Mathlib/Topology/Sheaves/SheafCondition/Sites.lean
|
mem_grothendieckTopology
|
The sieve generated by `presieveOfCovering U` is a member of the Grothendieck topology.
|
homOfIndex (i : ι) : Σ V, { f : V ⟶ iSup U // presieveOfCovering U f } :=
⟨U i, Opens.leSupr U i, i, rfl⟩
|
def
|
Topology
|
[
"Mathlib.CategoryTheory.Sites.Spaces",
"Mathlib.Topology.Sheaves.Sheaf",
"Mathlib.CategoryTheory.Sites.DenseSubsite.Basic"
] |
Mathlib/Topology/Sheaves/SheafCondition/Sites.lean
|
homOfIndex
|
An index `i : ι` can be turned into a dependent pair `(V, f)`, where `V` is an open set and
`f : V ⟶ iSup U` is a member of `presieveOfCovering U f`.
|
indexOfHom (f : Σ V, { f : V ⟶ iSup U // presieveOfCovering U f }) : ι :=
f.2.2.choose
|
def
|
Topology
|
[
"Mathlib.CategoryTheory.Sites.Spaces",
"Mathlib.Topology.Sheaves.Sheaf",
"Mathlib.CategoryTheory.Sites.DenseSubsite.Basic"
] |
Mathlib/Topology/Sheaves/SheafCondition/Sites.lean
|
indexOfHom
|
By using the axiom of choice, a dependent pair `(V, f)` where `f : V ⟶ iSup U` is a member of
`presieveOfCovering U f` can be turned into an index `i : ι`, such that `V = U i`.
|
indexOfHom_spec (f : Σ V, { f : V ⟶ iSup U // presieveOfCovering U f }) :
f.1 = U (indexOfHom U f) :=
f.2.2.choose_spec
|
theorem
|
Topology
|
[
"Mathlib.CategoryTheory.Sites.Spaces",
"Mathlib.Topology.Sheaves.Sheaf",
"Mathlib.CategoryTheory.Sites.DenseSubsite.Basic"
] |
Mathlib/Topology/Sheaves/SheafCondition/Sites.lean
|
indexOfHom_spec
| null |
coverDense_iff_isBasis [Category ι] (B : ι ⥤ Opens X) :
B.IsCoverDense (Opens.grothendieckTopology X) ↔ Opens.IsBasis (Set.range B.obj) := by
rw [Opens.isBasis_iff_nbhd]
constructor
· intro hd U x hx; rcases hd.1 U x hx with ⟨V, f, ⟨i, f₁, f₂, _⟩, hV⟩
exact ⟨B.obj i, ⟨i, rfl⟩, f₁.le hV, f₂.le⟩
intro hb; constructor; intro U x hx; rcases hb hx with ⟨_, ⟨i, rfl⟩, hx, hi⟩
exact ⟨B.obj i, ⟨⟨hi⟩⟩, ⟨⟨i, 𝟙 _, ⟨⟨hi⟩⟩, rfl⟩⟩, hx⟩
|
theorem
|
Topology
|
[
"Mathlib.CategoryTheory.Sites.Spaces",
"Mathlib.Topology.Sheaves.Sheaf",
"Mathlib.CategoryTheory.Sites.DenseSubsite.Basic"
] |
Mathlib/Topology/Sheaves/SheafCondition/Sites.lean
|
coverDense_iff_isBasis
| null |
coverDense_inducedFunctor {B : ι → Opens X} (h : Opens.IsBasis (Set.range B)) :
(inducedFunctor B).IsCoverDense (Opens.grothendieckTopology X) :=
(coverDense_iff_isBasis _).2 h
|
theorem
|
Topology
|
[
"Mathlib.CategoryTheory.Sites.Spaces",
"Mathlib.Topology.Sheaves.Sheaf",
"Mathlib.CategoryTheory.Sites.DenseSubsite.Basic"
] |
Mathlib/Topology/Sheaves/SheafCondition/Sites.lean
|
coverDense_inducedFunctor
| null |
Topology.IsOpenEmbedding.compatiblePreserving (hf : IsOpenEmbedding f) :
CompatiblePreserving (Opens.grothendieckTopology Y) hf.isOpenMap.functor := by
haveI : Mono f := (TopCat.mono_iff_injective f).mpr hf.injective
apply compatiblePreservingOfDownwardsClosed
intro U V i
refine ⟨(Opens.map f).obj V, eqToIso <| Opens.ext <| Set.image_preimage_eq_of_subset fun x h ↦ ?_⟩
obtain ⟨_, _, rfl⟩ := i.le h
exact ⟨_, rfl⟩
|
theorem
|
Topology
|
[
"Mathlib.CategoryTheory.Sites.Spaces",
"Mathlib.Topology.Sheaves.Sheaf",
"Mathlib.CategoryTheory.Sites.DenseSubsite.Basic"
] |
Mathlib/Topology/Sheaves/SheafCondition/Sites.lean
|
Topology.IsOpenEmbedding.compatiblePreserving
| null |
IsOpenMap.coverPreserving (hf : IsOpenMap f) :
CoverPreserving (Opens.grothendieckTopology X) (Opens.grothendieckTopology Y) hf.functor := by
constructor
rintro U S hU _ ⟨x, hx, rfl⟩
obtain ⟨V, i, hV, hxV⟩ := hU x hx
exact ⟨_, hf.functor.map i, ⟨_, i, 𝟙 _, hV, rfl⟩, Set.mem_image_of_mem f hxV⟩
|
theorem
|
Topology
|
[
"Mathlib.CategoryTheory.Sites.Spaces",
"Mathlib.Topology.Sheaves.Sheaf",
"Mathlib.CategoryTheory.Sites.DenseSubsite.Basic"
] |
Mathlib/Topology/Sheaves/SheafCondition/Sites.lean
|
IsOpenMap.coverPreserving
| null |
Topology.IsOpenEmbedding.functor_isContinuous (h : IsOpenEmbedding f) :
h.isOpenMap.functor.IsContinuous (Opens.grothendieckTopology X)
(Opens.grothendieckTopology Y) := by
apply Functor.isContinuous_of_coverPreserving
· exact h.compatiblePreserving
· exact h.isOpenMap.coverPreserving
|
lemma
|
Topology
|
[
"Mathlib.CategoryTheory.Sites.Spaces",
"Mathlib.Topology.Sheaves.Sheaf",
"Mathlib.CategoryTheory.Sites.DenseSubsite.Basic"
] |
Mathlib/Topology/Sheaves/SheafCondition/Sites.lean
|
Topology.IsOpenEmbedding.functor_isContinuous
| null |
TopCat.Presheaf.isSheaf_of_isOpenEmbedding (h : IsOpenEmbedding f) (hF : F.IsSheaf) :
IsSheaf (h.isOpenMap.functor.op ⋙ F) := by
have := h.functor_isContinuous
exact Functor.op_comp_isSheaf _ _ _ ⟨_, hF⟩
variable (f)
|
theorem
|
Topology
|
[
"Mathlib.CategoryTheory.Sites.Spaces",
"Mathlib.Topology.Sheaves.Sheaf",
"Mathlib.CategoryTheory.Sites.DenseSubsite.Basic"
] |
Mathlib/Topology/Sheaves/SheafCondition/Sites.lean
|
TopCat.Presheaf.isSheaf_of_isOpenEmbedding
| null |
compatiblePreserving_opens_map :
CompatiblePreserving (Opens.grothendieckTopology X) (Opens.map f) :=
compatiblePreservingOfFlat _ _
|
theorem
|
Topology
|
[
"Mathlib.CategoryTheory.Sites.Spaces",
"Mathlib.Topology.Sheaves.Sheaf",
"Mathlib.CategoryTheory.Sites.DenseSubsite.Basic"
] |
Mathlib/Topology/Sheaves/SheafCondition/Sites.lean
|
compatiblePreserving_opens_map
| null |
coverPreserving_opens_map : CoverPreserving (Opens.grothendieckTopology Y)
(Opens.grothendieckTopology X) (Opens.map f) := by
constructor
intro U S hS x hx
obtain ⟨V, i, hi, hxV⟩ := hS (f x) hx
exact ⟨_, (Opens.map f).map i, ⟨_, _, 𝟙 _, hi, Subsingleton.elim _ _⟩, hxV⟩
|
theorem
|
Topology
|
[
"Mathlib.CategoryTheory.Sites.Spaces",
"Mathlib.Topology.Sheaves.Sheaf",
"Mathlib.CategoryTheory.Sites.DenseSubsite.Basic"
] |
Mathlib/Topology/Sheaves/SheafCondition/Sites.lean
|
coverPreserving_opens_map
| null |
isTerminalOfEmpty (F : Sheaf C X) : Limits.IsTerminal (F.val.obj (op ⊥)) :=
F.isTerminalOfBotCover ⊥ (fun _ h => h.elim)
|
def
|
Topology
|
[
"Mathlib.CategoryTheory.Sites.Spaces",
"Mathlib.Topology.Sheaves.Sheaf",
"Mathlib.CategoryTheory.Sites.DenseSubsite.Basic"
] |
Mathlib/Topology/Sheaves/SheafCondition/Sites.lean
|
isTerminalOfEmpty
|
The empty component of a sheaf is terminal.
|
isTerminalOfEqEmpty (F : X.Sheaf C) {U : Opens X} (h : U = ⊥) :
Limits.IsTerminal (F.val.obj (op U)) := by
convert F.isTerminalOfEmpty
|
def
|
Topology
|
[
"Mathlib.CategoryTheory.Sites.Spaces",
"Mathlib.Topology.Sheaves.Sheaf",
"Mathlib.CategoryTheory.Sites.DenseSubsite.Basic"
] |
Mathlib/Topology/Sheaves/SheafCondition/Sites.lean
|
isTerminalOfEqEmpty
|
A variant of `isTerminalOfEmpty` that is easier to `apply`.
|
restrictHomEquivHom (h : Opens.IsBasis (Set.range B)) :
((inducedFunctor B).op ⋙ F ⟶ (inducedFunctor B).op ⋙ F'.1) ≃ (F ⟶ F'.1) :=
@Functor.IsCoverDense.restrictHomEquivHom _ _ _ _ _ _ _ _
(Opens.coverDense_inducedFunctor h) _ F F'
@[simp]
|
def
|
Topology
|
[
"Mathlib.CategoryTheory.Sites.Spaces",
"Mathlib.Topology.Sheaves.Sheaf",
"Mathlib.CategoryTheory.Sites.DenseSubsite.Basic"
] |
Mathlib/Topology/Sheaves/SheafCondition/Sites.lean
|
restrictHomEquivHom
|
If a family `B` of open sets forms a basis of the topology on `X`, and if `F'`
is a sheaf on `X`, then a homomorphism between a presheaf `F` on `X` and `F'`
is equivalent to a homomorphism between their restrictions to the indexing type
`ι` of `B`, with the induced category structure on `ι`.
|
extend_hom_app (h : Opens.IsBasis (Set.range B))
(α : (inducedFunctor B).op ⋙ F ⟶ (inducedFunctor B).op ⋙ F'.1) (i : ι) :
(restrictHomEquivHom F F' h α).app (op (B i)) = α.app (op i) := by
nth_rw 2 [← (restrictHomEquivHom F F' h).left_inv α]
rfl
|
theorem
|
Topology
|
[
"Mathlib.CategoryTheory.Sites.Spaces",
"Mathlib.Topology.Sheaves.Sheaf",
"Mathlib.CategoryTheory.Sites.DenseSubsite.Basic"
] |
Mathlib/Topology/Sheaves/SheafCondition/Sites.lean
|
extend_hom_app
| null |
hom_ext (h : Opens.IsBasis (Set.range B))
{α β : F ⟶ F'.1} (he : ∀ i, α.app (op (B i)) = β.app (op (B i))) : α = β := by
apply (restrictHomEquivHom F F' h).symm.injective
ext i
exact he i.unop
|
theorem
|
Topology
|
[
"Mathlib.CategoryTheory.Sites.Spaces",
"Mathlib.Topology.Sheaves.Sheaf",
"Mathlib.CategoryTheory.Sites.DenseSubsite.Basic"
] |
Mathlib/Topology/Sheaves/SheafCondition/Sites.lean
|
hom_ext
| null |
IsCompatible (sf : ∀ i : ι, ToType (F.obj (op (U i)))) : Prop :=
∀ i j : ι, F.map (infLELeft (U i) (U j)).op (sf i) = F.map (infLERight (U i) (U j)).op (sf j)
|
def
|
Topology
|
[
"Mathlib.Topology.Sheaves.Forget",
"Mathlib.Topology.Sheaves.SheafCondition.PairwiseIntersections",
"Mathlib.CategoryTheory.Limits.Types.Shapes"
] |
Mathlib/Topology/Sheaves/SheafCondition/UniqueGluing.lean
|
IsCompatible
|
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`
|
IsGluing (sf : ∀ i : ι, ToType (F.obj (op (U i)))) (s : ToType (F.obj (op (iSup U)))) : Prop :=
∀ i : ι, F.map (Opens.leSupr U i).op s = sf i
|
def
|
Topology
|
[
"Mathlib.Topology.Sheaves.Forget",
"Mathlib.Topology.Sheaves.SheafCondition.PairwiseIntersections",
"Mathlib.CategoryTheory.Limits.Types.Shapes"
] |
Mathlib/Topology/Sheaves/SheafCondition/UniqueGluing.lean
|
IsGluing
|
A section `s` is a gluing for a family of sections `sf` if it restricts to `sf i` on `U i`,
for all `i`
|
IsSheafUniqueGluing : Prop :=
∀ ⦃ι : Type x⦄ (U : ι → Opens X) (sf : ∀ i : ι, ToType (F.obj (op (U i)))),
IsCompatible F U sf → ∃! s : ToType (F.obj (op (iSup U))), IsGluing F U sf s
|
def
|
Topology
|
[
"Mathlib.Topology.Sheaves.Forget",
"Mathlib.Topology.Sheaves.SheafCondition.PairwiseIntersections",
"Mathlib.CategoryTheory.Limits.Types.Shapes"
] |
Mathlib/Topology/Sheaves/SheafCondition/UniqueGluing.lean
|
IsSheafUniqueGluing
|
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`
|
objPairwiseOfFamily (sf : ∀ i, F.obj (op (U i))) :
∀ i, ((Pairwise.diagram U).op ⋙ F).obj i
| ⟨Pairwise.single i⟩ => sf i
| ⟨Pairwise.pair i j⟩ => F.map (infLELeft (U i) (U j)).op (sf i)
attribute [local instance] Types.instFunLike Types.instConcreteCategory
|
def
|
Topology
|
[
"Mathlib.Topology.Sheaves.Forget",
"Mathlib.Topology.Sheaves.SheafCondition.PairwiseIntersections",
"Mathlib.CategoryTheory.Limits.Types.Shapes"
] |
Mathlib/Topology/Sheaves/SheafCondition/UniqueGluing.lean
|
objPairwiseOfFamily
|
Given sections over a family of open sets, extend it to include
sections over pairwise intersections of the open sets.
|
IsCompatible.sectionPairwise {sf} (h : IsCompatible F U sf) :
((Pairwise.diagram U).op ⋙ F).sections := by
refine ⟨objPairwiseOfFamily sf, ?_⟩
let G := (Pairwise.diagram U).op ⋙ F
rintro (i|⟨i,j⟩) (i'|⟨i',j'⟩) (_ | _ | _ | _)
· exact congr_fun (G.map_id <| op <| Pairwise.single i) _
· rfl
· exact (h i' i).symm
· exact congr_fun (G.map_id <| op <| Pairwise.pair i j) _
|
def
|
Topology
|
[
"Mathlib.Topology.Sheaves.Forget",
"Mathlib.Topology.Sheaves.SheafCondition.PairwiseIntersections",
"Mathlib.CategoryTheory.Limits.Types.Shapes"
] |
Mathlib/Topology/Sheaves/SheafCondition/UniqueGluing.lean
|
IsCompatible.sectionPairwise
|
Given a compatible family of sections over open sets, extend it to a
section of the functor `(Pairwise.diagram U).op ⋙ F`.
|
isGluing_iff_pairwise {sf s} : IsGluing F U sf s ↔
∀ i, (F.mapCone (Pairwise.cocone U).op).π.app i s = objPairwiseOfFamily sf i := by
refine ⟨fun h ↦ ?_, fun h i ↦ h (op <| Pairwise.single i)⟩
rintro (i|⟨i,j⟩)
· exact h i
· rw [← (F.mapCone (Pairwise.cocone U).op).w (op <| Pairwise.Hom.left i j)]
exact congr_arg _ (h i)
|
theorem
|
Topology
|
[
"Mathlib.Topology.Sheaves.Forget",
"Mathlib.Topology.Sheaves.SheafCondition.PairwiseIntersections",
"Mathlib.CategoryTheory.Limits.Types.Shapes"
] |
Mathlib/Topology/Sheaves/SheafCondition/UniqueGluing.lean
|
isGluing_iff_pairwise
| null |
IsSheaf.isSheafUniqueGluing_types (h : F.IsSheaf) (sf : ∀ i : ι, F.obj (op (U i)))
(cpt : IsCompatible F U sf) : ∃! s : F.obj (op (iSup U)), IsGluing F U sf s := by
simp_rw [isGluing_iff_pairwise]
exact (Types.isLimit_iff _).mp (h.isSheafPairwiseIntersections U) _ cpt.sectionPairwise.prop
variable (F)
|
theorem
|
Topology
|
[
"Mathlib.Topology.Sheaves.Forget",
"Mathlib.Topology.Sheaves.SheafCondition.PairwiseIntersections",
"Mathlib.CategoryTheory.Limits.Types.Shapes"
] |
Mathlib/Topology/Sheaves/SheafCondition/UniqueGluing.lean
|
IsSheaf.isSheafUniqueGluing_types
| null |
isSheaf_iff_isSheafUniqueGluing_types : F.IsSheaf ↔ F.IsSheafUniqueGluing := by
simp_rw [isSheaf_iff_isSheafPairwiseIntersections, IsSheafPairwiseIntersections,
Types.isLimit_iff, IsSheafUniqueGluing, isGluing_iff_pairwise]
refine forall₂_congr fun ι U ↦ ⟨fun h sf cpt ↦ ?_, fun h s hs ↦ ?_⟩
· exact h _ cpt.sectionPairwise.prop
· specialize h (fun i ↦ s <| op <| Pairwise.single i) fun i j ↦
(hs <| op <| Pairwise.Hom.left i j).trans (hs <| op <| Pairwise.Hom.right i j).symm
convert h; ext (i|⟨i,j⟩)
· rfl
· exact (hs <| op <| Pairwise.Hom.left i j).symm
|
theorem
|
Topology
|
[
"Mathlib.Topology.Sheaves.Forget",
"Mathlib.Topology.Sheaves.SheafCondition.PairwiseIntersections",
"Mathlib.CategoryTheory.Limits.Types.Shapes"
] |
Mathlib/Topology/Sheaves/SheafCondition/UniqueGluing.lean
|
isSheaf_iff_isSheafUniqueGluing_types
|
For type-valued presheaves, the sheaf condition in terms of unique gluings is equivalent to the
usual sheaf condition.
|
isSheaf_of_isSheafUniqueGluing_types (Fsh : F.IsSheafUniqueGluing) : F.IsSheaf :=
(isSheaf_iff_isSheafUniqueGluing_types F).mpr Fsh
|
theorem
|
Topology
|
[
"Mathlib.Topology.Sheaves.Forget",
"Mathlib.Topology.Sheaves.SheafCondition.PairwiseIntersections",
"Mathlib.CategoryTheory.Limits.Types.Shapes"
] |
Mathlib/Topology/Sheaves/SheafCondition/UniqueGluing.lean
|
isSheaf_of_isSheafUniqueGluing_types
|
The usual sheaf condition can be obtained from the sheaf condition
in terms of unique gluings.
|
IsSheaf.isSheafUniqueGluing (h : F.IsSheaf) {ι : Type*} (U : ι → Opens X)
(sf : ∀ i : ι, ToType (F.obj (op (U i))))
(cpt : IsCompatible F U sf) : ∃! s : ToType (F.obj (op (iSup U))), IsGluing F U sf s :=
((isSheaf_iff_isSheaf_comp' (forget C) F).mp h).isSheafUniqueGluing_types sf cpt
variable (F)
|
theorem
|
Topology
|
[
"Mathlib.Topology.Sheaves.Forget",
"Mathlib.Topology.Sheaves.SheafCondition.PairwiseIntersections",
"Mathlib.CategoryTheory.Limits.Types.Shapes"
] |
Mathlib/Topology/Sheaves/SheafCondition/UniqueGluing.lean
|
IsSheaf.isSheafUniqueGluing
| null |
isSheaf_iff_isSheafUniqueGluing : F.IsSheaf ↔ F.IsSheafUniqueGluing :=
Iff.trans (isSheaf_iff_isSheaf_comp' (forget C) F)
(isSheaf_iff_isSheafUniqueGluing_types (F ⋙ forget C))
|
theorem
|
Topology
|
[
"Mathlib.Topology.Sheaves.Forget",
"Mathlib.Topology.Sheaves.SheafCondition.PairwiseIntersections",
"Mathlib.CategoryTheory.Limits.Types.Shapes"
] |
Mathlib/Topology/Sheaves/SheafCondition/UniqueGluing.lean
|
isSheaf_iff_isSheafUniqueGluing
|
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.
|
existsUnique_gluing (sf : ∀ i : ι, ToType (F.1.obj (op (U i))))
(h : IsCompatible F.1 U sf) :
∃! s : ToType (F.1.obj (op (iSup U))), IsGluing F.1 U sf s :=
IsSheaf.isSheafUniqueGluing F.cond U sf h
|
theorem
|
Topology
|
[
"Mathlib.Topology.Sheaves.Forget",
"Mathlib.Topology.Sheaves.SheafCondition.PairwiseIntersections",
"Mathlib.CategoryTheory.Limits.Types.Shapes"
] |
Mathlib/Topology/Sheaves/SheafCondition/UniqueGluing.lean
|
existsUnique_gluing
|
A more convenient way of obtaining a unique gluing of sections for a sheaf.
|
existsUnique_gluing' (V : Opens X) (iUV : ∀ i : ι, U i ⟶ V) (hcover : V ≤ iSup U)
(sf : ∀ i : ι, ToType (F.1.obj (op (U i)))) (h : IsCompatible F.1 U sf) :
∃! s : ToType (F.1.obj (op V)), ∀ i : ι, F.1.map (iUV i).op s = sf i := by
have V_eq_supr_U : V = iSup U := le_antisymm hcover (iSup_le fun i => (iUV i).le)
obtain ⟨gl, gl_spec, gl_uniq⟩ := F.existsUnique_gluing U sf h
refine ⟨F.1.map (eqToHom V_eq_supr_U).op gl, ?_, ?_⟩
· intro i
rw [← ConcreteCategory.comp_apply, ← F.1.map_comp]
exact gl_spec i
· intro gl' gl'_spec
convert congr_arg _ (gl_uniq (F.1.map (eqToHom V_eq_supr_U.symm).op gl') fun i => _) <;>
rw [← ConcreteCategory.comp_apply, ← F.1.map_comp]
· rw [eqToHom_op, eqToHom_op, eqToHom_trans, eqToHom_refl, F.1.map_id,
ConcreteCategory.id_apply]
· exact gl'_spec i
@[ext]
|
theorem
|
Topology
|
[
"Mathlib.Topology.Sheaves.Forget",
"Mathlib.Topology.Sheaves.SheafCondition.PairwiseIntersections",
"Mathlib.CategoryTheory.Limits.Types.Shapes"
] |
Mathlib/Topology/Sheaves/SheafCondition/UniqueGluing.lean
|
existsUnique_gluing'
|
In this version of the lemma, the inclusion homs `iUV` can be specified directly by the user,
which can be more convenient in practice.
|
eq_of_locally_eq (s t : ToType (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 := by
let sf : ∀ i : ι, ToType (F.1.obj (op (U i))) := fun i => F.1.map (Opens.leSupr U i).op s
have sf_compatible : IsCompatible _ U sf := by
intro i j
simp_rw [sf, ← ConcreteCategory.comp_apply, ← F.1.map_comp]
rfl
obtain ⟨gl, -, gl_uniq⟩ := F.existsUnique_gluing U sf sf_compatible
trans gl
· apply gl_uniq
intro i
rfl
· symm
apply gl_uniq
intro i
rw [← h]
|
theorem
|
Topology
|
[
"Mathlib.Topology.Sheaves.Forget",
"Mathlib.Topology.Sheaves.SheafCondition.PairwiseIntersections",
"Mathlib.CategoryTheory.Limits.Types.Shapes"
] |
Mathlib/Topology/Sheaves/SheafCondition/UniqueGluing.lean
|
eq_of_locally_eq
| null |
eq_of_locally_eq' (V : Opens X) (iUV : ∀ i : ι, U i ⟶ V) (hcover : V ≤ iSup U)
(s t : ToType (F.1.obj (op V))) (h : ∀ i, F.1.map (iUV i).op s = F.1.map (iUV i).op t) :
s = t := by
have V_eq_supr_U : V = iSup U := le_antisymm hcover (iSup_le fun i => (iUV i).le)
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 [← ConcreteCategory.comp_apply, ← F.1.map_comp, eqToHom_op, eqToHom_op, eqToHom_trans,
eqToHom_refl, F.1.map_id, ConcreteCategory.id_apply]
apply eq_of_locally_eq
intro i
rw [← ConcreteCategory.comp_apply, ← ConcreteCategory.comp_apply, ← F.1.map_comp]
exact h i
|
theorem
|
Topology
|
[
"Mathlib.Topology.Sheaves.Forget",
"Mathlib.Topology.Sheaves.SheafCondition.PairwiseIntersections",
"Mathlib.CategoryTheory.Limits.Types.Shapes"
] |
Mathlib/Topology/Sheaves/SheafCondition/UniqueGluing.lean
|
eq_of_locally_eq'
|
In this version of the lemma, the inclusion homs `iUV` can be specified directly by the user,
which can be more convenient in practice.
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.