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.