statement stringlengths 1 2.93k | proof stringlengths 0 19.2k | type stringclasses 13
values | symbolic_name stringlengths 1 131 | library stringlengths 4 62 | filename stringlengths 20 95 | imports listlengths 0 10 | deps listlengths 0 64 | docstring stringlengths 0 4.95k | source_url stringclasses 1
value | commit stringclasses 1
value |
|---|---|---|---|---|---|---|---|---|---|---|
isEmbedding_singleton : IsEmbedding ({·} : α → NonemptyCompacts α) | isEmbedding_coe.of_comp_iff.mp vietoris.isEmbedding_singleton | theorem | TopologicalSpace.NonemptyCompacts.isEmbedding_singleton | Topology.Sets | Mathlib/Topology/Sets/VietorisTopology.lean | [] | [] | https://github.com/leanprover-community/mathlib4 | b9f14353520df73472ae3825fb53f86559a01319 | |
continuous_singleton : Continuous ({·} : α → NonemptyCompacts α) | isEmbedding_singleton.continuous | theorem | TopologicalSpace.NonemptyCompacts.continuous_singleton | Topology.Sets | Mathlib/Topology/Sets/VietorisTopology.lean | [] | [
"Continuous"
] | https://github.com/leanprover-community/mathlib4 | b9f14353520df73472ae3825fb53f86559a01319 | |
isClosedEmbedding_singleton [T2Space α] :
Topology.IsClosedEmbedding ({·} : α → NonemptyCompacts α) | isClosedEmbedding_toCompacts.of_comp_iff.mp Compacts.isClosedEmbedding_singleton | theorem | TopologicalSpace.NonemptyCompacts.isClosedEmbedding_singleton | Topology.Sets | Mathlib/Topology/Sets/VietorisTopology.lean | [] | [
"T2Space",
"Topology.IsClosedEmbedding"
] | https://github.com/leanprover-community/mathlib4 | b9f14353520df73472ae3825fb53f86559a01319 | |
continuous_prod :
Continuous fun p : NonemptyCompacts α × NonemptyCompacts β => p.1 ×ˢ p.2 | by
simp_rw [isEmbedding_toCompacts.continuous_iff, Function.comp_def, toCompacts_prod]
fun_prop | theorem | TopologicalSpace.NonemptyCompacts.continuous_prod | Topology.Sets | Mathlib/Topology/Sets/VietorisTopology.lean | [] | [
"Continuous"
] | https://github.com/leanprover-community/mathlib4 | b9f14353520df73472ae3825fb53f86559a01319 | |
_root_.Continuous.nonemptyCompacts_map (hf : Continuous f) :
Continuous (NonemptyCompacts.map f hf) | isEmbedding_toCompacts.continuous_iff.mpr <| hf.compacts_map.comp continuous_toCompacts | theorem | Continuous.nonemptyCompacts_map | Topology.Sets | Mathlib/Topology/Sets/VietorisTopology.lean | [] | [
"Continuous"
] | https://github.com/leanprover-community/mathlib4 | b9f14353520df73472ae3825fb53f86559a01319 | |
_root_.Topology.IsInducing.nonemptyCompacts_map (hf : IsInducing f) :
IsInducing (NonemptyCompacts.map f hf.continuous) | .of_comp hf.continuous.nonemptyCompacts_map continuous_toCompacts <|
hf.compacts_map.comp isEmbedding_toCompacts.isInducing | theorem | Topology.IsInducing.nonemptyCompacts_map | Topology.Sets | Mathlib/Topology/Sets/VietorisTopology.lean | [] | [] | https://github.com/leanprover-community/mathlib4 | b9f14353520df73472ae3825fb53f86559a01319 | |
_root_.Topology.IsEmbedding.nonemptyCompacts_map (hf : IsEmbedding f) :
IsEmbedding (NonemptyCompacts.map f hf.continuous) | where
__ := hf.isInducing.nonemptyCompacts_map
injective := map_injective hf.continuous hf.injective | theorem | Topology.IsEmbedding.nonemptyCompacts_map | Topology.Sets | Mathlib/Topology/Sets/VietorisTopology.lean | [] | [] | https://github.com/leanprover-community/mathlib4 | b9f14353520df73472ae3825fb53f86559a01319 | |
_root_.Topology.IsOpenEmbedding.nonemptyCompacts_map (hf : IsOpenEmbedding f) :
IsOpenEmbedding (NonemptyCompacts.map f hf.continuous) | .of_comp _ isOpenEmbedding_toCompacts <| hf.compacts_map.comp isOpenEmbedding_toCompacts | theorem | Topology.IsOpenEmbedding.nonemptyCompacts_map | Topology.Sets | Mathlib/Topology/Sets/VietorisTopology.lean | [] | [] | https://github.com/leanprover-community/mathlib4 | b9f14353520df73472ae3825fb53f86559a01319 | |
_root_.Topology.IsClosedEmbedding.nonemptyCompacts_map (hf : IsClosedEmbedding f) :
IsClosedEmbedding (NonemptyCompacts.map f hf.continuous) | isClosedEmbedding_toCompacts.of_comp_iff.mp <| hf.compacts_map.comp isClosedEmbedding_toCompacts | theorem | Topology.IsClosedEmbedding.nonemptyCompacts_map | Topology.Sets | Mathlib/Topology/Sets/VietorisTopology.lean | [] | [] | https://github.com/leanprover-community/mathlib4 | b9f14353520df73472ae3825fb53f86559a01319 | |
discreteTopology_iff : DiscreteTopology (NonemptyCompacts α) ↔ DiscreteTopology α | ⟨fun _ => isEmbedding_singleton.discreteTopology, fun _ => inferInstance⟩ | theorem | TopologicalSpace.NonemptyCompacts.discreteTopology_iff | Topology.Sets | Mathlib/Topology/Sets/VietorisTopology.lean | [] | [
"DiscreteTopology"
] | https://github.com/leanprover-community/mathlib4 | b9f14353520df73472ae3825fb53f86559a01319 | |
t2Space_iff : T2Space (NonemptyCompacts α) ↔ T2Space α | ⟨fun _ => isEmbedding_singleton.t2Space, fun _ => inferInstance⟩ | theorem | TopologicalSpace.NonemptyCompacts.t2Space_iff | Topology.Sets | Mathlib/Topology/Sets/VietorisTopology.lean | [] | [
"T2Space"
] | https://github.com/leanprover-community/mathlib4 | b9f14353520df73472ae3825fb53f86559a01319 | |
regularSpace_iff : RegularSpace (NonemptyCompacts α) ↔ RegularSpace α | ⟨fun _ => isEmbedding_singleton.regularSpace, fun _ => inferInstance⟩ | theorem | TopologicalSpace.NonemptyCompacts.regularSpace_iff | Topology.Sets | Mathlib/Topology/Sets/VietorisTopology.lean | [] | [
"RegularSpace"
] | https://github.com/leanprover-community/mathlib4 | b9f14353520df73472ae3825fb53f86559a01319 | |
t3Space_iff : T3Space (NonemptyCompacts α) ↔ T3Space α | ⟨fun _ => isEmbedding_singleton.t3Space, fun _ => inferInstance⟩ | theorem | TopologicalSpace.NonemptyCompacts.t3Space_iff | Topology.Sets | Mathlib/Topology/Sets/VietorisTopology.lean | [] | [
"T3Space"
] | https://github.com/leanprover-community/mathlib4 | b9f14353520df73472ae3825fb53f86559a01319 | |
isCompact_subsets_of_isCompact {K : Set α} (hK : IsCompact K) :
IsCompact {L : NonemptyCompacts α | ↑L ⊆ K} | isClosedEmbedding_toCompacts.isCompact_preimage (Compacts.isCompact_subsets_of_isCompact hK) | theorem | TopologicalSpace.NonemptyCompacts.isCompact_subsets_of_isCompact | Topology.Sets | Mathlib/Topology/Sets/VietorisTopology.lean | [] | [
"IsCompact",
"Set"
] | https://github.com/leanprover-community/mathlib4 | b9f14353520df73472ae3825fb53f86559a01319 | |
isCompact_biUnion_coe_of_isCompact {S : Set (NonemptyCompacts α)} (hs : IsCompact S) :
IsCompact (⋃ K ∈ S, (K : Set α)) | by
convert! Compacts.isCompact_biUnion_coe_of_isCompact (hs.image continuous_toCompacts)
simp_rw [biUnion_image, coe_toCompacts] | theorem | TopologicalSpace.NonemptyCompacts.isCompact_biUnion_coe_of_isCompact | Topology.Sets | Mathlib/Topology/Sets/VietorisTopology.lean | [] | [
"IsCompact",
"Set"
] | https://github.com/leanprover-community/mathlib4 | b9f14353520df73472ae3825fb53f86559a01319 | |
compactSpace_iff : CompactSpace (NonemptyCompacts α) ↔ CompactSpace α | by
refine ⟨fun h => ⟨?_⟩, fun _ => inferInstance⟩
convert! isCompact_biUnion_coe_of_isCompact (α := α) isCompact_univ
symm
simp_rw [biUnion_univ, eq_univ_iff_forall, mem_iUnion]
exact fun x => ⟨{x}, Set.mem_singleton x⟩ | theorem | TopologicalSpace.NonemptyCompacts.compactSpace_iff | Topology.Sets | Mathlib/Topology/Sets/VietorisTopology.lean | [] | [
"CompactSpace",
"Set.mem_singleton",
"isCompact_univ",
"symm"
] | https://github.com/leanprover-community/mathlib4 | b9f14353520df73472ae3825fb53f86559a01319 | |
noncompactSpace_iff : NoncompactSpace (NonemptyCompacts α) ↔ NoncompactSpace α | by
simp_rw [← not_compactSpace_iff, compactSpace_iff] | theorem | TopologicalSpace.NonemptyCompacts.noncompactSpace_iff | Topology.Sets | Mathlib/Topology/Sets/VietorisTopology.lean | [] | [
"NoncompactSpace",
"not_compactSpace_iff"
] | https://github.com/leanprover-community/mathlib4 | b9f14353520df73472ae3825fb53f86559a01319 | |
locallyCompactSpace_iff :
LocallyCompactSpace (NonemptyCompacts α) ↔ LocallyCompactSpace α | by
refine ⟨fun _ => ⟨fun x U hU => ?_⟩, fun _ => inferInstance⟩
rw [← mem_interior_iff_mem_nhds, ← singleton_subset_iff, ← coe_singleton] at hU
obtain ⟨K, hK, hxK, hKU⟩ := exists_compact_subset (isOpen_subsets_of_isOpen isOpen_interior) hU
refine ⟨⋃ L ∈ K, L, ?_, iUnion₂_subset <| by grind [interior_subset],
... | theorem | TopologicalSpace.NonemptyCompacts.locallyCompactSpace_iff | Topology.Sets | Mathlib/Topology/Sets/VietorisTopology.lean | [] | [
"LocallyCompactSpace",
"exists_compact_subset",
"interior_subset",
"isOpen_interior",
"mem_interior_iff_mem_nhds"
] | https://github.com/leanprover-community/mathlib4 | b9f14353520df73472ae3825fb53f86559a01319 | |
_root_.TopologicalSpace.Compacts.locallyCompactSpace_iff :
LocallyCompactSpace (Compacts α) ↔ LocallyCompactSpace α | ⟨fun _ => NonemptyCompacts.locallyCompactSpace_iff.mp
isOpenEmbedding_toCompacts.locallyCompactSpace, fun _ => inferInstance⟩ | theorem | TopologicalSpace.Compacts.locallyCompactSpace_iff | Topology.Sets | Mathlib/Topology/Sets/VietorisTopology.lean | [] | [
"LocallyCompactSpace"
] | https://github.com/leanprover-community/mathlib4 | b9f14353520df73472ae3825fb53f86559a01319 | |
isZero_iff_stalkFunctor_obj_isZero (F : Sheaf C X) :
IsZero F ↔ ∀ x : X, IsZero ((forget C X ⋙ stalkFunctor C x).obj F) | by
refine ⟨fun h _ => Functor.map_isZero _ h, ?_⟩
intro h
let f : F ⟶ 0 := (isZero_zero (Sheaf C X)).from_ F
have : IsIso f := by
rw [Presheaf.isIso_iff_stalkFunctor_map_iso]
exact fun x => isIso_of_source_target_iso_zero _ (h x).isoZero
((forget C X ⋙ stalkFunctor C x).map_isZero (isZero_zero _))... | lemma | TopCat.Sheaf.isZero_iff_stalkFunctor_obj_isZero | Topology.Sheaves | Mathlib/Topology/Sheaves/Abelian.lean | [] | [] | A sheaf is zero if and only if its stalks are all zero. | https://github.com/leanprover-community/mathlib4 | b9f14353520df73472ae3825fb53f86559a01319 |
exact_iff_stalkFunctor_map_exact (S : ShortComplex (Sheaf C X)) :
S.Exact ↔ ∀ x : X, (S.map (forget C X ⋙ stalkFunctor C x)).Exact | by
constructor
· intro h x
have := (forget C X ⋙ stalkFunctor C x).exact_tfae.out 2 1
exact this.mp inferInstance S h
intro h
simp_rw [ShortComplex.exact_iff_isZero_homology] at h
rw [ShortComplex.exact_iff_isZero_homology, isZero_iff_stalkFunctor_obj_isZero S.homology]
exact fun x => (h x).of_iso
... | theorem | TopCat.Sheaf.exact_iff_stalkFunctor_map_exact | Topology.Sheaves | Mathlib/Topology/Sheaves/Abelian.lean | [] | [
"symm"
] | Exactness can be checked on stalks for complexes of sheaves. | https://github.com/leanprover-community/mathlib4 | b9f14353520df73472ae3825fb53f86559a01319 |
Presheaf.sections_exact_of_exact
{S : ShortComplex (Presheaf AddCommGrpCat.{u} X)}
(hS : S.Exact) {s : S.X₂.obj (Opposite.op U)} (h : S.g.app (Opposite.op U) s = 0) :
∃ (t : S.X₁.obj (Opposite.op U)), S.f.app (Opposite.op U) t = s | by
dsimp [Presheaf] at S
let F := (evaluation (Opens X)ᵒᵖ AddCommGrpCat.{u}).obj (Opposite.op U)
exact (ShortComplex.ab_exact_iff (S.map F)).mp (((Functor.exact_tfae F).out 1 3 rfl rfl).mpr
⟨inferInstance, inferInstance⟩ S hS) _ h | theorem | TopCat.Presheaf.sections_exact_of_exact | Topology.Sheaves | Mathlib/Topology/Sheaves/AddCommGrpCat.lean | [] | [] | https://github.com/leanprover-community/mathlib4 | b9f14353520df73472ae3825fb53f86559a01319 | |
Sheaf.sections_exact_of_left_exact {S : ShortComplex (TopCat.Sheaf AddCommGrpCat X)}
(hS : S.Exact) (hf : Mono S.f) (s : S.X₂.obj.obj (Opposite.op U))
(h : S.g.hom.app (Opposite.op U) s = 0) :
∃ (t : S.X₁.obj.obj (Opposite.op U)), S.f.hom.app (Opposite.op U) t = s | Presheaf.sections_exact_of_exact
(((Functor.preservesFiniteLimits_tfae (Sheaf.forget ..)).out 1 3 rfl rfl).mpr
inferInstance S ⟨hS, hf⟩).left h | lemma | TopCat.Sheaf.sections_exact_of_left_exact | Topology.Sheaves | Mathlib/Topology/Sheaves/AddCommGrpCat.lean | [] | [
"AddCommGrpCat",
"TopCat.Sheaf"
] | https://github.com/leanprover-community/mathlib4 | b9f14353520df73472ae3825fb53f86559a01319 | |
Presheaf.restrict_sum {V : Opens X} {F : Presheaf AddCommGrpCat X} (h : V ≤ U)
(s t : F.obj (op U)) : (s + t) |_ V = s |_ V + t |_ V | by
delta Presheaf.restrictOpen Presheaf.restrict
cat_disch | lemma | TopCat.Presheaf.restrict_sum | Topology.Sheaves | Mathlib/Topology/Sheaves/AddCommGrpCat.lean | [] | [
"AddCommGrpCat"
] | https://github.com/leanprover-community/mathlib4 | b9f14353520df73472ae3825fb53f86559a01319 | |
principalOpen (x : X) : Opens X | .mk { y | x ≤ y } <| by
rw [IsUpperSet.isOpen_iff_isUpperSet]
intro y z h1 h2
exact le_trans h2 h1 | def | Alexandrov.principalOpen | Topology.Sheaves | Mathlib/Topology/Sheaves/Alexandrov.lean | [] | [
"le_trans"
] | Given `x : X`, this is the principal open subset of `X` generated by `x`. | https://github.com/leanprover-community/mathlib4 | b9f14353520df73472ae3825fb53f86559a01319 |
self_mem_principalOpen (x : X) : x ∈ principalOpen x | le_refl _ | lemma | Alexandrov.self_mem_principalOpen | Topology.Sheaves | Mathlib/Topology/Sheaves/Alexandrov.lean | [] | [
"le_refl"
] | https://github.com/leanprover-community/mathlib4 | b9f14353520df73472ae3825fb53f86559a01319 | |
principalOpen_le_iff {x : X} (U : Opens X) :
principalOpen x ≤ U ↔ x ∈ U | by
refine ⟨fun h => h <| self_mem_principalOpen _, fun hx y hy => ?_⟩
· have := U.isOpen
rw [IsUpperSet.isOpen_iff_isUpperSet] at this
exact this hy hx | lemma | Alexandrov.principalOpen_le_iff | Topology.Sheaves | Mathlib/Topology/Sheaves/Alexandrov.lean | [] | [] | https://github.com/leanprover-community/mathlib4 | b9f14353520df73472ae3825fb53f86559a01319 | |
principalOpen_le {x y : X} (h : x ≤ y) :
principalOpen y ≤ principalOpen x | fun _ hc => le_trans h hc | lemma | Alexandrov.principalOpen_le | Topology.Sheaves | Mathlib/Topology/Sheaves/Alexandrov.lean | [] | [
"le_trans"
] | https://github.com/leanprover-community/mathlib4 | b9f14353520df73472ae3825fb53f86559a01319 | |
principals : X ⥤ (Opens X)ᵒᵖ | where
obj x := .op <| principalOpen x
map {x y} f := .op <| principalOpen_le f.le |>.hom | def | Alexandrov.principals | Topology.Sheaves | Mathlib/Topology/Sheaves/Alexandrov.lean | [] | [] | The functor sending `x : X` to the principal open associated with `x`. | https://github.com/leanprover-community/mathlib4 | b9f14353520df73472ae3825fb53f86559a01319 |
exists_le_of_le_sup {ι : Type v} {x : X}
(Us : ι → Opens X) (h : principalOpen x ≤ iSup Us) :
∃ i : ι, principalOpen x ≤ Us i | by
grind [principalOpen_le_iff, Opens.mem_iSup] | lemma | Alexandrov.exists_le_of_le_sup | Topology.Sheaves | Mathlib/Topology/Sheaves/Alexandrov.lean | [] | [
"iSup"
] | https://github.com/leanprover-community/mathlib4 | b9f14353520df73472ae3825fb53f86559a01319 | |
principalsKanExtension : (Opens X)ᵒᵖ ⥤ C | (principals X).pointwiseRightKanExtension F | abbrev | Alexandrov.principalsKanExtension | Topology.Sheaves | Mathlib/Topology/Sheaves/Alexandrov.lean | [] | [] | The right Kan extension of `F` along `X ⥤ (Opens X)ᵒᵖ`. | https://github.com/leanprover-community/mathlib4 | b9f14353520df73472ae3825fb53f86559a01319 |
generator (U : Opens X) :
StructuredArrow (.op U) (principals X) ⥤ X | StructuredArrow.proj (.op U) (principals X) | abbrev | Alexandrov.generator | Topology.Sheaves | Mathlib/Topology/Sheaves/Alexandrov.lean | [] | [] | Given a structured arrow `f` with domain `U : Opens X` over `principals X`,
this functor sends `f` to its "generator", an element of `X`. | https://github.com/leanprover-community/mathlib4 | b9f14353520df73472ae3825fb53f86559a01319 |
projSup {ι : Type v} (Us : ι → Opens X) :
StructuredArrow (.op <| iSup Us) (principals X) ⥤
(OpensLeCover (X := .of X) Us)ᵒᵖ | where
obj f := .op <| .mk (principalOpen f.right) <| exists_le_of_le_sup Us f.hom.unop.le
map e := (ObjectProperty.homMk (homOfLE (principalOpen_le e.right.le))).op | def | Alexandrov.projSup | Topology.Sheaves | Mathlib/Topology/Sheaves/Alexandrov.lean | [] | [
"iSup"
] | Given a structured arrow `f` with domain `iSup Us` over `principals X`,
where `Us` is a family of `Opens X`, this functor sends `f` to the principal open
associated with it, considered as an object in the full subcategory of all `V : Opens X`
such that `V ≤ Us i` for some `i`.
This definition is primarily meant to be ... | https://github.com/leanprover-community/mathlib4 | b9f14353520df73472ae3825fb53f86559a01319 |
lowerCone
{α : Type v} (Us : α → Opens X)
(S : Cone ((ObjectProperty.ι _ : OpensLeCover (X := .of X) Us ⥤ _).op ⋙
principalsKanExtension F)) :
Cone (generator (iSup Us) ⋙ F) | where
pt := S.pt
π := {
app := fun f =>
S.π.app ((projSup Us).obj f) ≫ limit.π (generator (principalOpen f.right) ⋙ F)
⟨.mk .unit, f.right, 𝟙 _⟩
naturality := by
rintro x y e
simp only [Functor.const_obj_obj, Functor.comp_obj, Functor.const_obj_map,
Functor.op_obj, Functor... | def | Alexandrov.lowerCone | Topology.Sheaves | Mathlib/Topology/Sheaves/Alexandrov.lean | [] | [
"LE.le.hom",
"iSup",
"symm",
"trans"
] | This is an auxiliary definition which is only meant to be used in `isLimit` below. | https://github.com/leanprover-community/mathlib4 | b9f14353520df73472ae3825fb53f86559a01319 |
isLimit {X : TopCat.{v}} [Preorder X] [Topology.IsUpperSet X]
(F : X ⥤ C)
(α : Type v) (Us : α → Opens X) :
IsLimit (mapCone (principalsKanExtension F) (opensLeCoverCocone Us).op) | where
lift S := limit.lift _ (lowerCone Us S)
fac := by
rintro S ⟨V, i, hV⟩
dsimp [forget, opensLeCoverCocone]
ext ⟨_, x, f⟩
simp only [Category.assoc, limit.lift_π, lowerCone_pt, lowerCone_π_app, const_obj_obj,
projSup_obj, StructuredArrow.map_obj_right, comp_obj, op_obj, pointwiseRightKanExt... | def | Alexandrov.isLimit | Topology.Sheaves | Mathlib/Topology/Sheaves/Alexandrov.lean | [] | [
"Preorder",
"Topology.IsUpperSet",
"le_trans",
"symm",
"trans"
] | This is the main construction in this file showing that the right Kan extension
of `F : X ⥤ C` along `principals : X ⥤ (Opens X)ᵒᵖ` is a sheaf, by showing that a certain
cone is a limit cone.
See `isSheaf_principalsKanExtension` for the main application. | https://github.com/leanprover-community/mathlib4 | b9f14353520df73472ae3825fb53f86559a01319 |
isSheaf_principalsKanExtension
{X : TopCat.{v}} [Preorder X] [Topology.IsUpperSet X] (F : X ⥤ C) :
Presheaf.IsSheaf (principalsKanExtension F) | by
rw [isSheaf_iff_isSheafOpensLeCover]
intro ι Us
constructor
apply isLimit | theorem | Alexandrov.isSheaf_principalsKanExtension | Topology.Sheaves | Mathlib/Topology/Sheaves/Alexandrov.lean | [] | [
"Preorder",
"Topology.IsUpperSet"
] | https://github.com/leanprover-community/mathlib4 | b9f14353520df73472ae3825fb53f86559a01319 | |
Topology.IsUpperSet.isSheaf_of_isRightKanExtension
(P : (Opens X)ᵒᵖ ⥤ C)
(η : Alexandrov.principals X ⋙ P ⟶ F)
[P.IsRightKanExtension η] :
Presheaf.IsSheaf (Opens.grothendieckTopology X) P | by
let γ : principals X ⋙ principalsKanExtension F ⟶ F :=
(principals X).pointwiseRightKanExtensionCounit F
let _ : (principalsKanExtension F).IsRightKanExtension γ := inferInstance
have : P ≅ principalsKanExtension F :=
@rightKanExtensionUnique _ _ _ _ _ _ _ _ _ _ (by assumption) _ _ (by assumption)
ch... | theorem | Topology.IsUpperSet.isSheaf_of_isRightKanExtension | Topology.Sheaves | Mathlib/Topology/Sheaves/Alexandrov.lean | [] | [
"Alexandrov.principals",
"Opens.grothendieckTopology",
"Preorder",
"TopCat.Presheaf.IsSheaf",
"Topology.IsUpperSet"
] | The main theorem of this file.
If `X` is a topological space and preorder whose topology is the `UpperSet` topology associated
with the preorder, `F : X ⥤ C` is a functor into a complete category from the preorder category,
and `P : (Opens X)ᵒᵖ ⥤ C` denotes the right Kan extension of `F` along the
functor `X ⥤ (Open X)... | https://github.com/leanprover-community/mathlib4 | b9f14353520df73472ae3825fb53f86559a01319 |
restrictOpenCommRingCat_apply {X : TopCat.{w}}
{F : Presheaf CommRingCat X} {V : Opens ↑X} (f : CommRingCat.carrier (F.obj (op V)))
(U : Opens ↑X) (e : U ≤ V := by restrict_tac) :
f |_ U = F.map (homOfLE e).op f | rfl | lemma | TopCat.Presheaf.restrictOpenCommRingCat_apply | Topology.Sheaves | Mathlib/Topology/Sheaves/CommRingCat.lean | [] | [
"CommRingCat"
] | Unfold `restrictOpen` in the category of commutative rings (with the correct carrier type).
Although unification hints help with applying `TopCat.Presheaf.restrictOpenCommRingCat`,
so it can be safely de-specialized, this lemma needs to be kept to ensure rewrites go right. | https://github.com/leanprover-community/mathlib4 | b9f14353520df73472ae3825fb53f86559a01319 |
SubmonoidPresheaf (F : X.Presheaf CommRingCat) where
/-- The submonoid structure for each component -/
obj : ∀ U, Submonoid (F.obj U)
map : ∀ {U V : (Opens X)ᵒᵖ} (i : U ⟶ V), obj U ≤ (obj V).comap (F.map i).hom | structure | TopCat.Presheaf.SubmonoidPresheaf | Topology.Sheaves | Mathlib/Topology/Sheaves/CommRingCat.lean | [] | [
"CommRingCat",
"Submonoid",
"comap"
] | A subpresheaf with a submonoid structure on each of the components. | https://github.com/leanprover-community/mathlib4 | b9f14353520df73472ae3825fb53f86559a01319 | |
SubmonoidPresheaf.localizationPresheaf : X.Presheaf CommRingCat | where
obj U := CommRingCat.of <| Localization (G.obj U)
map {_ _} i := CommRingCat.ofHom <| IsLocalization.map _ (F.map i).hom (G.map i)
map_id U := by
simp_rw [F.map_id]
ext x
exact IsLocalization.map_id x
map_comp {U V W} i j := by
delta CommRingCat.ofHom CommRingCat.of Bundled.of
simp_rw ... | def | TopCat.Presheaf.SubmonoidPresheaf.localizationPresheaf | Topology.Sheaves | Mathlib/Topology/Sheaves/CommRingCat.lean | [] | [
"CommRingCat",
"CommRingCat.ofHom",
"IsLocalization.map",
"IsLocalization.map_comp_map",
"IsLocalization.map_id",
"Localization"
] | The localization of a presheaf of `CommRing`s with respect to a `SubmonoidPresheaf`. | https://github.com/leanprover-community/mathlib4 | b9f14353520df73472ae3825fb53f86559a01319 |
SubmonoidPresheaf.toLocalizationPresheaf : F ⟶ G.localizationPresheaf | where
app U := CommRingCat.ofHom <| algebraMap (F.obj U) (Localization <| G.obj U)
naturality {_ _} i := CommRingCat.hom_ext <| (IsLocalization.map_comp (G.map i)).symm | def | TopCat.Presheaf.SubmonoidPresheaf.toLocalizationPresheaf | Topology.Sheaves | Mathlib/Topology/Sheaves/CommRingCat.lean | [] | [
"CommRingCat.hom_ext",
"CommRingCat.ofHom",
"IsLocalization.map_comp",
"Localization",
"symm"
] | The map into the localization presheaf. | https://github.com/leanprover-community/mathlib4 | b9f14353520df73472ae3825fb53f86559a01319 |
epi_toLocalizationPresheaf : Epi G.toLocalizationPresheaf | @NatTrans.epi_of_epi_app _ _ _ _ _ _ G.toLocalizationPresheaf fun U => Localization.epi' (G.obj U) | instance | TopCat.Presheaf.epi_toLocalizationPresheaf | Topology.Sheaves | Mathlib/Topology/Sheaves/CommRingCat.lean | [] | [
"Localization.epi'"
] | https://github.com/leanprover-community/mathlib4 | b9f14353520df73472ae3825fb53f86559a01319 | |
submonoidPresheafOfStalk (S : ∀ x : X, Submonoid (F.stalk x)) :
F.SubmonoidPresheaf | where
obj U := ⨅ x : U.unop, Submonoid.comap (F.germ U.unop x.1 x.2).hom (S x)
map {U V} i := by
intro s hs
simp only [Submonoid.mem_comap, Submonoid.mem_iInf] at hs ⊢
intro x
change (F.map i.unop.op ≫ F.germ V.unop x.1 x.2) s ∈ _
rw [F.germ_res]
exact hs ⟨_, i.unop.le x.2⟩ | def | TopCat.Presheaf.submonoidPresheafOfStalk | Topology.Sheaves | Mathlib/Topology/Sheaves/CommRingCat.lean | [] | [
"Submonoid",
"Submonoid.comap",
"Submonoid.mem_comap",
"Submonoid.mem_iInf"
] | Given a submonoid at each of the stalks, we may define a submonoid presheaf consisting of
sections whose restriction onto each stalk falls in the given submonoid. | https://github.com/leanprover-community/mathlib4 | b9f14353520df73472ae3825fb53f86559a01319 |
totalQuotientPresheaf : X.Presheaf CommRingCat.{w} | (F.submonoidPresheafOfStalk fun x => (F.stalk x)⁰).localizationPresheaf | def | TopCat.Presheaf.totalQuotientPresheaf | Topology.Sheaves | Mathlib/Topology/Sheaves/CommRingCat.lean | [] | [] | The localization of a presheaf of `CommRing`s at locally non-zero-divisor sections. | https://github.com/leanprover-community/mathlib4 | b9f14353520df73472ae3825fb53f86559a01319 |
toTotalQuotientPresheaf : F ⟶ F.totalQuotientPresheaf | SubmonoidPresheaf.toLocalizationPresheaf _
deriving Epi | def | TopCat.Presheaf.toTotalQuotientPresheaf | Topology.Sheaves | Mathlib/Topology/Sheaves/CommRingCat.lean | [] | [] | The map into the presheaf of total quotient rings | https://github.com/leanprover-community/mathlib4 | b9f14353520df73472ae3825fb53f86559a01319 |
continuousFunctions (X : TopCat.{v}ᵒᵖ) (R : TopCommRingCat.{v}) : CommRingCat.{v} | CommRingCat.of (X.unop ⟶ (forget₂ TopCommRingCat TopCat).obj R) | def | TopCat.continuousFunctions | Topology.Sheaves | Mathlib/Topology/Sheaves/CommRingCat.lean | [] | [
"TopCat",
"TopCommRingCat"
] | The (bundled) commutative ring of continuous functions from a topological space
to a topological commutative ring, with pointwise multiplication. | https://github.com/leanprover-community/mathlib4 | b9f14353520df73472ae3825fb53f86559a01319 |
pullback {X Y : TopCatᵒᵖ} (f : X ⟶ Y) (R : TopCommRingCat) :
continuousFunctions X R ⟶ continuousFunctions Y R | CommRingCat.ofHom
{ toFun g := f.unop ≫ g
map_one' := rfl
map_zero' := rfl
map_add' := by cat_disch
map_mul' := by cat_disch } | def | TopCat.continuousFunctions.pullback | Topology.Sheaves | Mathlib/Topology/Sheaves/CommRingCat.lean | [] | [
"CommRingCat.ofHom",
"TopCommRingCat"
] | Pulling back functions into a topological ring along a continuous map is a ring homomorphism. | https://github.com/leanprover-community/mathlib4 | b9f14353520df73472ae3825fb53f86559a01319 |
map (X : TopCat.{u}ᵒᵖ) {R S : TopCommRingCat.{u}} (φ : R ⟶ S) :
continuousFunctions X R ⟶ continuousFunctions X S | CommRingCat.ofHom
{ toFun g := g ≫ (forget₂ TopCommRingCat TopCat).map φ
map_one' := by ext; exact φ.1.map_one
map_zero' := by ext; exact φ.1.map_zero
map_add' _ _ := by ext; exact φ.1.map_add _ _
map_mul' _ _ := by ext; exact φ.1.map_mul _ _ } | def | TopCat.continuousFunctions.map | Topology.Sheaves | Mathlib/Topology/Sheaves/CommRingCat.lean | [] | [
"CommRingCat.ofHom",
"TopCat",
"TopCommRingCat"
] | A homomorphism of topological rings can be postcomposed with functions from a source space `X`;
this is a ring homomorphism (with respect to the pointwise ring operations on functions). | https://github.com/leanprover-community/mathlib4 | b9f14353520df73472ae3825fb53f86559a01319 |
commRingYoneda : TopCommRingCat.{u} ⥤ TopCat.{u}ᵒᵖ ⥤ CommRingCat.{u} | where
obj R :=
{ obj := fun X => continuousFunctions X R
map := fun {_ _} f => continuousFunctions.pullback f R
map_id := fun X => by
ext
rfl
map_comp := fun {_ _ _} _ _ => rfl }
map {_ _} φ :=
{ app := fun X => continuousFunctions.map X φ
naturality := fun _ _ _ => r... | def | TopCat.commRingYoneda | Topology.Sheaves | Mathlib/Topology/Sheaves/CommRingCat.lean | [] | [] | An upgraded version of the Yoneda embedding, observing that the continuous maps
from `X : TopCat` to `R : TopCommRingCat` form a commutative ring, functorial in both `X` and
`R`. | https://github.com/leanprover-community/mathlib4 | b9f14353520df73472ae3825fb53f86559a01319 |
presheafToTopCommRing (T : TopCommRingCat.{v}) : X.Presheaf CommRingCat.{v} | (Opens.toTopCat X).op ⋙ commRingYoneda.obj T | def | TopCat.presheafToTopCommRing | Topology.Sheaves | Mathlib/Topology/Sheaves/CommRingCat.lean | [] | [] | The presheaf (of commutative rings), consisting of functions on an open set `U ⊆ X` with
values in some topological commutative ring `T`.
For example, we could construct the presheaf of continuous complex-valued functions of `X` as
```
presheafToTopCommRing X (TopCommRingCat.of ℂ)
```
(this requires `import Topology.I... | https://github.com/leanprover-community/mathlib4 | b9f14353520df73472ae3825fb53f86559a01319 |
algebra_section_stalk (F : X.Presheaf CommRingCat) {U : Opens X} (x : U) :
Algebra (F.obj <| op U) (F.stalk x) | (F.germ U x.1 x.2).hom.toAlgebra | instance | TopCat.Presheaf.algebra_section_stalk | Topology.Sheaves | Mathlib/Topology/Sheaves/CommRingCat.lean | [] | [
"Algebra",
"CommRingCat"
] | https://github.com/leanprover-community/mathlib4 | b9f14353520df73472ae3825fb53f86559a01319 | |
stalk_open_algebraMap {X : TopCat.{v}} (F : X.Presheaf CommRingCat) {U : Opens X} (x : U) :
algebraMap (F.obj <| op U) (F.stalk x) = (F.germ U x.1 x.2).hom | rfl | theorem | TopCat.Presheaf.stalk_open_algebraMap | Topology.Sheaves | Mathlib/Topology/Sheaves/CommRingCat.lean | [] | [
"CommRingCat"
] | https://github.com/leanprover-community/mathlib4 | b9f14353520df73472ae3825fb53f86559a01319 | |
objSupIsoProdEqLocus {X : TopCat.{w}} (F : X.Sheaf CommRingCat) (U V : Opens X) :
F.1.obj (op <| U ⊔ V) ≅ CommRingCat.of <|
-- Porting note: Lean 3 is able to figure out the ring homomorphism automatically
RingHom.eqLocus
(RingHom.comp (F.obj.map (homOfLE inf_le_left : U ⊓ V ⟶ U).op).hom
(Ring... | (F.isLimitPullbackCone U V).conePointUniqueUpToIso (CommRingCat.pullbackConeIsLimit _ _) | def | TopCat.Sheaf.objSupIsoProdEqLocus | Topology.Sheaves | Mathlib/Topology/Sheaves/CommRingCat.lean | [] | [
"CommRingCat",
"CommRingCat.pullbackConeIsLimit",
"RingHom.comp",
"RingHom.eqLocus",
"RingHom.fst",
"RingHom.snd"
] | `F(U ⊔ V)` is isomorphic to the `eq_locus` of the two maps `F(U) × F(V) ⟶ F(U ⊓ V)`. | https://github.com/leanprover-community/mathlib4 | b9f14353520df73472ae3825fb53f86559a01319 |
objSupIsoProdEqLocus_hom_fst {X : TopCat.{w}} (F : X.Sheaf CommRingCat) (U V : Opens X)
(x) :
((F.objSupIsoProdEqLocus U V).hom x).1.fst = F.1.map (homOfLE le_sup_left).op x | ConcreteCategory.congr_hom
((F.isLimitPullbackCone U V).conePointUniqueUpToIso_hom_comp
(CommRingCat.pullbackConeIsLimit _ _) WalkingCospan.left)
x | theorem | TopCat.Sheaf.objSupIsoProdEqLocus_hom_fst | Topology.Sheaves | Mathlib/Topology/Sheaves/CommRingCat.lean | [] | [
"CommRingCat",
"CommRingCat.pullbackConeIsLimit",
"le_sup_left"
] | https://github.com/leanprover-community/mathlib4 | b9f14353520df73472ae3825fb53f86559a01319 | |
objSupIsoProdEqLocus_hom_snd {X : TopCat.{w}} (F : X.Sheaf CommRingCat) (U V : Opens X)
(x) :
((F.objSupIsoProdEqLocus U V).hom x).1.snd = F.1.map (homOfLE le_sup_right).op x | ConcreteCategory.congr_hom
((F.isLimitPullbackCone U V).conePointUniqueUpToIso_hom_comp
(CommRingCat.pullbackConeIsLimit _ _) WalkingCospan.right)
x | theorem | TopCat.Sheaf.objSupIsoProdEqLocus_hom_snd | Topology.Sheaves | Mathlib/Topology/Sheaves/CommRingCat.lean | [] | [
"CommRingCat",
"CommRingCat.pullbackConeIsLimit",
"le_sup_right"
] | https://github.com/leanprover-community/mathlib4 | b9f14353520df73472ae3825fb53f86559a01319 | |
objSupIsoProdEqLocus_inv_fst {X : TopCat.{w}} (F : X.Sheaf CommRingCat) (U V : Opens X)
(x) :
F.1.map (homOfLE le_sup_left).op ((F.objSupIsoProdEqLocus U V).inv x) = x.1.1 | ConcreteCategory.congr_hom
((F.isLimitPullbackCone U V).conePointUniqueUpToIso_inv_comp
(CommRingCat.pullbackConeIsLimit _ _) WalkingCospan.left)
x | theorem | TopCat.Sheaf.objSupIsoProdEqLocus_inv_fst | Topology.Sheaves | Mathlib/Topology/Sheaves/CommRingCat.lean | [] | [
"CommRingCat",
"CommRingCat.pullbackConeIsLimit",
"le_sup_left"
] | https://github.com/leanprover-community/mathlib4 | b9f14353520df73472ae3825fb53f86559a01319 | |
objSupIsoProdEqLocus_inv_snd {X : TopCat.{w}} (F : X.Sheaf CommRingCat) (U V : Opens X)
(x) :
F.1.map (homOfLE le_sup_right).op ((F.objSupIsoProdEqLocus U V).inv x) = x.1.2 | ConcreteCategory.congr_hom
((F.isLimitPullbackCone U V).conePointUniqueUpToIso_inv_comp
(CommRingCat.pullbackConeIsLimit _ _) WalkingCospan.right)
x | theorem | TopCat.Sheaf.objSupIsoProdEqLocus_inv_snd | Topology.Sheaves | Mathlib/Topology/Sheaves/CommRingCat.lean | [] | [
"CommRingCat",
"CommRingCat.pullbackConeIsLimit",
"le_sup_right"
] | https://github.com/leanprover-community/mathlib4 | b9f14353520df73472ae3825fb53f86559a01319 | |
objSupIsoProdEqLocus_inv_eq_iff {X : TopCat.{u}} (F : X.Sheaf CommRingCat.{u})
{U V W UW VW : Opens X} (e : W ≤ U ⊔ V) (x) (y : F.1.obj (op W))
(h₁ : UW = U ⊓ W) (h₂ : VW = V ⊓ W) :
F.1.map (homOfLE e).op ((F.objSupIsoProdEqLocus U V).inv x) = y ↔
F.1.map (homOfLE (h₁ ▸ inf_le_left : UW ≤ U)).op x.1.1 =... | by
subst h₁ h₂
constructor
· rintro rfl
rw [← TopCat.Sheaf.objSupIsoProdEqLocus_inv_fst, ← TopCat.Sheaf.objSupIsoProdEqLocus_inv_snd]
simp only [← CommRingCat.comp_apply, ← Functor.map_comp, ← op_comp,
homOfLE_comp, and_self]
· rintro ⟨e₁, e₂⟩
refine F.eq_of_locally_eq₂
(homOfLE (inf_le_... | theorem | TopCat.Sheaf.objSupIsoProdEqLocus_inv_eq_iff | Topology.Sheaves | Mathlib/Topology/Sheaves/CommRingCat.lean | [] | [
"CommRingCat.comp_apply",
"TopCat.Sheaf.objSupIsoProdEqLocus_inv_fst",
"TopCat.Sheaf.objSupIsoProdEqLocus_inv_snd",
"inf_sup_right",
"le_rfl"
] | https://github.com/leanprover-community/mathlib4 | b9f14353520df73472ae3825fb53f86559a01319 | |
EtaleSpace (F : Presheaf C X) where
/-- The base point. -/
base : X
/-- A germ at `base` (formally, an element of the stalk of `F` at `base`). -/
germ : ToType (F.stalk base) | structure | TopCat.Presheaf.EtaleSpace | Topology.Sheaves | Mathlib/Topology/Sheaves/EtaleSpace.lean | [] | [] | Etale space of a presheaf. | https://github.com/leanprover-community/mathlib4 | b9f14353520df73472ae3825fb53f86559a01319 | |
eventually_nhds (g : EtaleSpace F) {U : Opens X} (h : g.base ∈ U)
(s : ToType (F.obj (op U))) (hs : F.germ U g.base h s = g.germ) :
∀ᶠ g' : EtaleSpace F in 𝓝 g, ∃ hgU : g'.base ∈ U, g'.germ = F.germ U g'.base hgU s | by
simp only [nhds_generateFrom, Filter.Eventually, mem_setOf_eq, iInf_and, iInf_exists]
refine mem_iInf_of_mem _ <| mem_iInf_of_mem ?_ <| mem_iInf_of_mem U <| mem_iInf_of_mem s <|
mem_iInf_of_mem rfl <| mem_principal_self _
simp [*] | theorem | TopCat.Presheaf.EtaleSpace.eventually_nhds | Topology.Sheaves | Mathlib/Topology/Sheaves/EtaleSpace.lean | [] | [
"Filter.Eventually"
] | If `s` is a section of a presheaf `F` over `U` with germ at `g.base` equal to `g.germ`,
then a neighborhood of `g` consists of germs of `s` at points `x ∈ U`. | https://github.com/leanprover-community/mathlib4 | b9f14353520df73472ae3825fb53f86559a01319 |
continuous_base : Continuous (base (F := F)) | by
rw [continuous_iff_continuousAt]
intro x
rw [ContinuousAt, (nhds_basis_opens _).tendsto_right_iff]
rintro U ⟨hxU, hUo⟩
lift U to Opens X using hUo
rcases F.exists_le_germ_eq x.germ hxU with ⟨V, hVU, hxV, f, hf⟩
refine x.eventually_nhds hxV f hf |>.mono ?_
aesop | theorem | TopCat.Presheaf.EtaleSpace.continuous_base | Topology.Sheaves | Mathlib/Topology/Sheaves/EtaleSpace.lean | [] | [
"Continuous",
"ContinuousAt",
"continuous_iff_continuousAt",
"nhds_basis_opens"
] | https://github.com/leanprover-community/mathlib4 | b9f14353520df73472ae3825fb53f86559a01319 | |
exists_section_of_tendsto {α : Type*} {l : Filter α} {g : α → F.EtaleSpace}
{g₀ : F.EtaleSpace} (h : Tendsto g l (𝓝 g₀)) :
∃ (U : Opens X), g₀.base ∈ U ∧ ∃ (f : ToType (F.obj (op U))),
∀ᶠ a in l, ∃ ha : (g a).base ∈ U, (g a).germ = F.germ U (g a).base ha f | by
rcases F.exists_germ_eq g₀.germ with ⟨U, hU, s, hs⟩
use U, hU, s
exact h.eventually <| g₀.eventually_nhds hU s hs | theorem | TopCat.Presheaf.EtaleSpace.exists_section_of_tendsto | Topology.Sheaves | Mathlib/Topology/Sheaves/EtaleSpace.lean | [] | [
"Filter"
] | https://github.com/leanprover-community/mathlib4 | b9f14353520df73472ae3825fb53f86559a01319 | |
homeomorph (U : Opens X)
(hF_bij : ∀ (x : X) (hx : x ∈ U), Bijective (F.germ U x hx))
(x : X) (hx : x ∈ U) :
(base (F := F) ⁻¹' U) ≃ₜ U × WithDiscreteTopology (ToType (F.stalk x)) | where
toFun s := (⟨s.1.base, s.2⟩,
.toTopology ⊥ <| F.germ U x hx <| surjInv (hF_bij s.1.base s.2).surjective s.1.germ)
invFun
| (⟨y, hy⟩, .toTopology _ g) => ⟨⟨y, F.germ U y hy <| surjInv (hF_bij x hx).surjective g⟩, hy⟩
left_inv := by
rintro ⟨⟨base, s⟩, hs⟩
simp only
congr 2
rw [leftInvers... | def | TopCat.Presheaf.EtaleSpace.homeomorph | Topology.Sheaves | Mathlib/Topology/Sheaves/EtaleSpace.lean | [] | [
"ContinuousAt",
"WithDiscreteTopology",
"continuousAt_prod_of_discrete_right",
"continuous_iff_continuousAt",
"continuous_subtype_val",
"nhds_discrete",
"nhds_subtype",
"nhds_subtype_eq_comap"
] | Let `F` be a `C`-valued presheaf on `X`.
Let `U` be an open set on `X` such that for each `x ∈ U`, the `germ` map is bijective, i.e.,
every germ can be extended to a unique section over `U`.
Then for each `x ∈ U`, the preimage of `U` under `EtaleSpace.base`
is homeomorphic to the product of `U` and the stalk of `F` at... | https://github.com/leanprover-community/mathlib4 | b9f14353520df73472ae3825fb53f86559a01319 |
isCoveringMap_base
(hF_bij : ∀ x, ∃ (U : Opens X), x ∈ U ∧ ∀ y (hyU : y ∈ U), Bijective (F.germ U y hyU)) :
IsCoveringMap (base (F := F)) | by
refine fun x ↦ .to_isEvenlyCovered_preimage (I := WithDiscreteTopology (ToType (F.stalk x))) ?_
use inferInstance
rcases hF_bij x with ⟨U, hxU, hU_bij⟩
use U, hxU, U.isOpen, U.isOpen.preimage (continuous_base F), homeomorph U hU_bij x hxU
simp | theorem | TopCat.Presheaf.EtaleSpace.isCoveringMap_base | Topology.Sheaves | Mathlib/Topology/Sheaves/EtaleSpace.lean | [] | [
"IsCoveringMap",
"WithDiscreteTopology"
] | Let `F` be a presheaf with the following property.
For each `x`, there exists an open neighborhood `U ∋ x` such that for each `y ∈ U`,
the map `Presheaf.germ F U y hyU` from sections of `F` over `U` to the stalk at `y`
is bijective.
Then the projection from the etale space of `F` to the base is a covering map. | https://github.com/leanprover-community/mathlib4 | b9f14353520df73472ae3825fb53f86559a01319 |
IsFlasque : Prop where
epi : ∀ {U V : (Opens X)ᵒᵖ} (i : U ⟶ V), Epi (F.map i) | class | TopCat.Presheaf.IsFlasque | Topology.Sheaves | Mathlib/Topology/Sheaves/Flasque.lean | [] | [] | A sheaf is flasque if all of the restriction morphisms are epimorphisms. | https://github.com/leanprover-community/mathlib4 | b9f14353520df73472ae3825fb53f86559a01319 | |
pushforward_isFlasque {Y : TopCat.{u}} [IsFlasque F] (f : X ⟶ Y) :
IsFlasque (f _* F) | where
epi {U V} i := by
simp only [pushforward_obj_obj, pushforward_obj_map]
infer_instance | instance | TopCat.Presheaf.IsFlasque.pushforward_isFlasque | Topology.Sheaves | Mathlib/Topology/Sheaves/Flasque.lean | [] | [] | https://github.com/leanprover-community/mathlib4 | b9f14353520df73472ae3825fb53f86559a01319 | |
IsFlasque {C : Type v} [Category.{w} C] (F : Sheaf C X) | Presheaf.IsFlasque F.obj | abbrev | TopCat.Sheaf.IsFlasque | Topology.Sheaves | Mathlib/Topology/Sheaves/Flasque.lean | [] | [] | A sheaf is flasque if it is flasque as a presheaf | https://github.com/leanprover-community/mathlib4 | b9f14353520df73472ae3825fb53f86559a01319 |
pushforward_isFlasque {C : Type v} [Category.{w} C] {Y : TopCat.{u}} (F : Sheaf C X)
[IsFlasque F] (f : X ⟶ Y) : IsFlasque ((pushforward C f).obj F) | Presheaf.IsFlasque.pushforward_isFlasque F.1 f | instance | TopCat.Sheaf.IsFlasque.pushforward_isFlasque | Topology.Sheaves | Mathlib/Topology/Sheaves/Flasque.lean | [] | [] | https://github.com/leanprover-community/mathlib4 | b9f14353520df73472ae3825fb53f86559a01319 | |
Under | StructuredArrow ⟨op U, s⟩ (Functor.whiskerRight g.hom
(CategoryTheory.forget AddCommGrpCat.{u})).mapElements | abbrev | TopCat.Sheaf.IsFlasque.Under | Topology.Sheaves | Mathlib/Topology/Sheaves/Flasque.lean | [] | [
"CategoryTheory.forget"
] | Given a morphism of sheaves `g: F ⟶ G` and a section `s` of `G(U)`, `Under g s` is comprised of
an open `V` and a section of `F(V)` that maps to `s |_ V` via `g`. | https://github.com/leanprover-community/mathlib4 | b9f14353520df73472ae3825fb53f86559a01319 |
structured_arrows_elements_sheaf_chains_bounded (c : Set (Under g s))
(h : IsChain (fun x y ↦ Nonempty (y ⟶ x)) c) : ∃ ub, ∀ a ∈ c, Nonempty (ub ⟶ a) | by
let f : c → (Opens X) := fun x => x.1.right.1.unop
obtain ⟨t, ht, _⟩ : ∃! s_1, IsGluing F.obj f (fun x => x.val.right.2) s_1 := by
refine Sheaf.existsUnique_gluing F _ _ (fun i j ↦ ?_)
obtain (rfl | h₁ | h₁) : i = j ∨ Nonempty (i.val ⟶ j.val) ∨ Nonempty (j.val ⟶ i.val) := by
grind [Subtype.ext_iff,... | lemma | TopCat.Sheaf.IsFlasque.structured_arrows_elements_sheaf_chains_bounded | Topology.Sheaves | Mathlib/Topology/Sheaves/Flasque.lean | [] | [
"AddCommGrpCat",
"CategoryTheory.forget",
"IsChain",
"Set",
"iSup",
"iSup_le",
"le_iSup",
"symm"
] | https://github.com/leanprover-community/mathlib4 | b9f14353520df73472ae3825fb53f86559a01319 | |
epi_of_shortExact {S : ShortComplex (Sheaf AddCommGrpCat X)} (hS : S.ShortExact)
[IsFlasque S.X₁] : Epi (S.g.1.app (op U)) | by
refine (AddCommGrpCat.epi_iff_surjective _).mpr (fun s ↦ ?_)
-- We want to find a preimage of `s` by `S.g`.
-- We apply Zorn's lemma to obtain a term `t` of `Under S.g s` that is maximal.
obtain ⟨t, ht⟩ := exists_maximal_of_chains_bounded
(structured_arrows_elements_sheaf_chains_bounded S.g s)
(fun ⟨... | theorem | TopCat.Sheaf.IsFlasque.epi_of_shortExact | Topology.Sheaves | Mathlib/Topology/Sheaves/Flasque.lean | [] | [
"AddCommGrpCat",
"CategoryTheory.comp_apply",
"CategoryTheory.forget",
"exists_maximal_of_chains_bounded",
"iSup",
"le_iSup",
"le_of_eq",
"symm"
] | Given a short exact sequence of sheaves, `0 ⟶ 𝓕 ⟶ 𝓖 ⟶ 𝓗 ⟶ 0`, if `𝓕` is flasque then
`𝓖(U) ⟶ 𝓗(U)` is surjective, for any open `U`. | https://github.com/leanprover-community/mathlib4 | b9f14353520df73472ae3825fb53f86559a01319 |
of_shortExact_of_isFlasque₁₂ {S : ShortComplex (Sheaf AddCommGrpCat X)}
(hS : S.ShortExact) [IsFlasque S.X₁] [IsFlasque S.X₂] : IsFlasque S.X₃ | where
epi {U V} i := by
have : Epi (S.g.1.app U ≫ S.X₃.obj.map i) := by
rw [← S.g.hom.naturality i]
exact CategoryTheory.epi_comp' inferInstance (epi_of_shortExact hS)
exact CategoryTheory.epi_of_epi (S.g.1.app U) (S.X₃.obj.map i) | theorem | TopCat.Sheaf.IsFlasque.of_shortExact_of_isFlasque₁₂ | Topology.Sheaves | Mathlib/Topology/Sheaves/Flasque.lean | [] | [
"AddCommGrpCat",
"CategoryTheory.epi_comp'",
"CategoryTheory.epi_of_epi"
] | Given a short exact sequence of sheaves, `0 ⟶ 𝓕 ⟶ 𝓖 ⟶ 𝓗 ⟶ 0`, if `𝓕` and `𝓖` are flasque,
then `𝓗` is flasque. | https://github.com/leanprover-community/mathlib4 | b9f14353520df73472ae3825fb53f86559a01319 |
isFlasque_skyscraperSheaf_of_epi_from {X : TopCat} (p₀ : ↑X)
[(U : Opens ↑X) → Decidable (p₀ ∈ U)] {C : Type*} [Category* C] (A : C) [HasTerminal C]
[Epi <| terminalIsTerminal.from A] :
(skyscraperSheaf p₀ A).IsFlasque | where
epi {U V} r := by
by_cases h1 : p₀ ∈ unop U
· by_cases h2 : p₀ ∈ unop V
· simp_all only [skyscraperSheaf_obj_obj, skyscraperSheaf_obj_map, ↓reduceDIte]
infer_instance
· simp
grind
· have h2 : p₀ ∉ unop V := fun hV => h1 (r.unop.le hV)
have := isIso_of_isTerminal (is... | theorem | TopCat.Sheaf.isFlasque_skyscraperSheaf_of_epi_from | Topology.Sheaves | Mathlib/Topology/Sheaves/Flasque.lean | [] | [
"TopCat",
"by_cases",
"isTerminalSkyscraperSheafObjObjOfNotMem",
"skyscraperSheaf"
] | If the unique map from `A` to the terminal object is an epimorphism, then the skyscraper sheaf
valued in `A` supported at an arbitrary point is a flasque sheaf. | https://github.com/leanprover-community/mathlib4 | b9f14353520df73472ae3825fb53f86559a01319 |
isFlasque_skyscraperSheaf_of_hasZeroObject {X : TopCat} (p₀ : ↑X)
[(U : Opens ↑X) → Decidable (p₀ ∈ U)] {C : Type*} [Category* C] (A : C) [HasZeroObject C] :
(skyscraperSheaf p₀ A).IsFlasque | isFlasque_skyscraperSheaf_of_epi_from p₀ A | theorem | TopCat.Sheaf.isFlasque_skyscraperSheaf_of_hasZeroObject | Topology.Sheaves | Mathlib/Topology/Sheaves/Flasque.lean | [] | [
"TopCat",
"skyscraperSheaf"
] | If the target category has a zero object, then any skyscraper sheaf valued in this category is a
flasque sheaf. | https://github.com/leanprover-community/mathlib4 | b9f14353520df73472ae3825fb53f86559a01319 |
isSheaf_iff_isSheaf_comp' {C : Type u₁} [Category.{v₁} C] {D : Type u₂} [Category.{v₂} D]
(G : C ⥤ D) [G.ReflectsIsomorphisms] [HasLimitsOfSize.{v, v} C] [PreservesLimitsOfSize.{v, v} G]
{X : TopCat.{v}} (F : Presheaf C X) : Presheaf.IsSheaf F ↔ Presheaf.IsSheaf (F ⋙ G) | Presheaf.isSheaf_iff_isSheaf_comp _ F G | theorem | TopCat.Presheaf.isSheaf_iff_isSheaf_comp' | Topology.Sheaves | Mathlib/Topology/Sheaves/Forget.lean | [] | [] | If `G : C ⥤ D` is a functor which reflects isomorphisms and preserves limits
(we assume all limits exist in `C`),
then checking the sheaf condition for a presheaf `F : Presheaf C X`
is equivalent to checking the sheaf condition for `F ⋙ G`.
The important special case is when
`C` is a concrete category with a forgetful... | https://github.com/leanprover-community/mathlib4 | b9f14353520df73472ae3825fb53f86559a01319 |
isSheaf_iff_isSheaf_comp {C : Type u₁} [Category.{v} C] {D : Type u₂} [Category.{v} D]
(G : C ⥤ D) [G.ReflectsIsomorphisms] [HasLimits C] [PreservesLimits G]
{X : TopCat.{v}} (F : Presheaf C X) : Presheaf.IsSheaf F ↔ Presheaf.IsSheaf (F ⋙ G) | isSheaf_iff_isSheaf_comp' G F | theorem | TopCat.Presheaf.isSheaf_iff_isSheaf_comp | Topology.Sheaves | Mathlib/Topology/Sheaves/Forget.lean | [] | [] | https://github.com/leanprover-community/mathlib4 | b9f14353520df73472ae3825fb53f86559a01319 | |
pushforward_sheaf_of_sheaf {F : X.Presheaf C} (h : F.IsSheaf) : (f _* F).IsSheaf | (Opens.map f).op_comp_isSheaf _ _ ⟨_, h⟩ | theorem | TopCat.Sheaf.pushforward_sheaf_of_sheaf | Topology.Sheaves | Mathlib/Topology/Sheaves/Functors.lean | [] | [] | The pushforward of a sheaf (by a continuous map) is a sheaf. | https://github.com/leanprover-community/mathlib4 | b9f14353520df73472ae3825fb53f86559a01319 |
pushforward (f : X ⟶ Y) : X.Sheaf C ⥤ Y.Sheaf C | (Opens.map f).sheafPushforwardContinuous _ _ _ | def | TopCat.Sheaf.pushforward | Topology.Sheaves | Mathlib/Topology/Sheaves/Functors.lean | [] | [] | The pushforward functor. | https://github.com/leanprover-community/mathlib4 | b9f14353520df73472ae3825fb53f86559a01319 |
pushforward_forget (f : X ⟶ Y) :
pushforward C f ⋙ forget C Y = forget C X ⋙ Presheaf.pushforward C f | rfl | lemma | TopCat.Sheaf.pushforward_forget | Topology.Sheaves | Mathlib/Topology/Sheaves/Functors.lean | [] | [] | https://github.com/leanprover-community/mathlib4 | b9f14353520df73472ae3825fb53f86559a01319 | |
pushforwardForgetIso (f : X ⟶ Y) :
pushforward C f ⋙ forget C Y ≅ forget C X ⋙ Presheaf.pushforward C f | Iso.refl _ | def | TopCat.Sheaf.pushforwardForgetIso | Topology.Sheaves | Mathlib/Topology/Sheaves/Functors.lean | [] | [] | Pushforward of sheaves is isomorphic (actually definitionally equal) to pushforward of presheaves. | https://github.com/leanprover-community/mathlib4 | b9f14353520df73472ae3825fb53f86559a01319 |
pushforward_obj_val (f : X ⟶ Y) (F : X.Sheaf C) :
((pushforward C f).obj F).1 = f _* F.1 | rfl | lemma | TopCat.Sheaf.pushforward_obj_val | Topology.Sheaves | Mathlib/Topology/Sheaves/Functors.lean | [] | [] | https://github.com/leanprover-community/mathlib4 | b9f14353520df73472ae3825fb53f86559a01319 | |
pushforward_map (f : X ⟶ Y) {F F' : X.Sheaf C} (α : F ⟶ F') :
((pushforward C f).map α).1 = (Presheaf.pushforward C f).map α.1 | rfl | lemma | TopCat.Sheaf.pushforward_map | Topology.Sheaves | Mathlib/Topology/Sheaves/Functors.lean | [] | [] | https://github.com/leanprover-community/mathlib4 | b9f14353520df73472ae3825fb53f86559a01319 | |
pullback (f : X ⟶ Y) : Y.Sheaf A ⥤ X.Sheaf A | (Opens.map f).sheafPullback _ _ _ | def | TopCat.Sheaf.pullback | Topology.Sheaves | Mathlib/Topology/Sheaves/Functors.lean | [] | [] | The pullback functor. | https://github.com/leanprover-community/mathlib4 | b9f14353520df73472ae3825fb53f86559a01319 |
pullbackIso (f : X ⟶ Y) :
pullback A f ≅ forget A Y ⋙ Presheaf.pullback A f ⋙ presheafToSheaf _ _ | Functor.sheafPullbackConstruction.sheafPullbackIso _ _ _ _ | def | TopCat.Sheaf.pullbackIso | Topology.Sheaves | Mathlib/Topology/Sheaves/Functors.lean | [] | [] | The pullback of a sheaf is isomorphic (actually definitionally equal) to the sheafification
of the pullback as a presheaf. | https://github.com/leanprover-community/mathlib4 | b9f14353520df73472ae3825fb53f86559a01319 |
pullbackPushforwardAdjunction (f : X ⟶ Y) :
pullback A f ⊣ pushforward A f | (Opens.map f).sheafAdjunctionContinuous _ _ _ | def | TopCat.Sheaf.pullbackPushforwardAdjunction | Topology.Sheaves | Mathlib/Topology/Sheaves/Functors.lean | [] | [] | The adjunction between pullback and pushforward for sheaves on topological spaces. | https://github.com/leanprover-community/mathlib4 | b9f14353520df73472ae3825fb53f86559a01319 |
sheafPullback : Y.Sheaf A ⥤ X.Sheaf A | haveI := Topology.IsOpenEmbedding.functor_isContinuous hf
hf.functor.sheafPushforwardContinuous _ _ _ | def | Topology.IsOpenEmbedding.sheafPullback | Topology.Sheaves | Mathlib/Topology/Sheaves/Functors.lean | [] | [
"Topology.IsOpenEmbedding.functor_isContinuous"
] | The "naive" sheaf pullback by an open embedding `f`: on the underlying presheaf, this is just
composition by the functor `IsOpenMap.functor f` (sending an open `U` to `f '' U`). | https://github.com/leanprover-community/mathlib4 | b9f14353520df73472ae3825fb53f86559a01319 |
sheafPullbackIso : Sheaf.pullback A f ≅ hf.sheafPullback A | by
refine Sheaf.pullbackIso A f ≪≫ NatIso.ofComponents (fun F ↦ ?_) (fun u ↦ ?_)
· exact (presheafToSheaf (Opens.grothendieckTopology ↑X) A).mapIso
(hf.isOpenMap.pullbackIso.app _) ≪≫
(fullyFaithfulSheafToPresheaf (Opens.grothendieckTopology X) A).preimageIso
(isoSheafify (Opens.grothendieckTopolo... | def | Topology.IsOpenEmbedding.sheafPullbackIso | Topology.Sheaves | Mathlib/Topology/Sheaves/Functors.lean | [] | [
"CategoryTheory.sheafifyLift_comp",
"Opens.grothendieckTopology",
"TopCat.Presheaf.isSheaf_of_isOpenEmbedding",
"symm"
] | The pullback of a sheaf by an open embedding `f` is isomorphic to its naive pullback
`IsOpenEmbedding.sheafPullback`, i.e. to the composition by the functor `IsOpenMap.functor f`.
Also, this is an isomorphism of functors. | https://github.com/leanprover-community/mathlib4 | b9f14353520df73472ae3825fb53f86559a01319 |
isSheaf_of_isLimit [HasLimitsOfShape J C] {X : TopCat.{v}} (F : J ⥤ Presheaf.{v} C X)
(H : ∀ j, (F.obj j).IsSheaf) {c : Cone F} (hc : IsLimit c) : c.pt.IsSheaf | by
let F' : J ⥤ Sheaf C X :=
{ obj := fun j => ⟨F.obj j, H j⟩
map := fun f => ⟨F.map f⟩ }
let e : F' ⋙ Sheaf.forget C X ≅ F := NatIso.ofComponents fun _ => Iso.refl _
exact Presheaf.isSheaf_of_iso
((isLimitOfPreserves (Sheaf.forget C X) (limit.isLimit F')).conePointsIsoOfNatIso hc e)
(limit F').... | theorem | TopCat.isSheaf_of_isLimit | Topology.Sheaves | Mathlib/Topology/Sheaves/Limits.lean | [] | [] | https://github.com/leanprover-community/mathlib4 | b9f14353520df73472ae3825fb53f86559a01319 | |
limit_isSheaf [HasLimitsOfShape J C] {X : TopCat.{v}} (F : J ⥤ Presheaf.{v} C X)
(H : ∀ j, (F.obj j).IsSheaf) : (limit F).IsSheaf | isSheaf_of_isLimit F H (limit.isLimit F) | theorem | TopCat.limit_isSheaf | Topology.Sheaves | Mathlib/Topology/Sheaves/Limits.lean | [] | [] | https://github.com/leanprover-community/mathlib4 | b9f14353520df73472ae3825fb53f86559a01319 | |
IsLocallySurjective (T : ℱ ⟶ 𝒢) | CategoryTheory.Presheaf.IsLocallySurjective (Opens.grothendieckTopology X) T | def | TopCat.Presheaf.IsLocallySurjective | Topology.Sheaves | Mathlib/Topology/Sheaves/LocallySurjective.lean | [] | [
"CategoryTheory.Presheaf.IsLocallySurjective",
"Opens.grothendieckTopology"
] | A map of presheaves `T : ℱ ⟶ 𝒢` is **locally surjective** if for any open set `U`,
section `t` over `U`, and `x ∈ U`, there exists an open set `x ∈ V ⊆ U` and a section `s` over `V`
such that `$T_*(s_V) = t|_V$`.
See `TopCat.Presheaf.isLocallySurjective_iff` below. | https://github.com/leanprover-community/mathlib4 | b9f14353520df73472ae3825fb53f86559a01319 |
isLocallySurjective_iff (T : ℱ ⟶ 𝒢) :
IsLocallySurjective T ↔
∀ (U t), ∀ x ∈ U, ∃ (V : _) (_ : V ≤ U), (∃ s, (T.app _) s = t |_ V) ∧ x ∈ V | by
refine ⟨fun h _ t x hx ↦ ?_, fun h => ⟨fun s x hx ↦ ?_⟩⟩
· obtain ⟨V, i, hi⟩ := h.imageSieve_mem t x hx
exact ⟨V, leOfHom i, hi⟩
· obtain ⟨V, Vle, hV⟩ := h _ s x hx
exact ⟨V, homOfLE Vle, hV⟩ | theorem | TopCat.Presheaf.isLocallySurjective_iff | Topology.Sheaves | Mathlib/Topology/Sheaves/LocallySurjective.lean | [] | [] | https://github.com/leanprover-community/mathlib4 | b9f14353520df73472ae3825fb53f86559a01319 | |
locally_surjective_iff_surjective_on_stalks (T : ℱ ⟶ 𝒢) :
IsLocallySurjective T ↔ ∀ x : X, Function.Surjective ((stalkFunctor C x).map T) | by
constructor <;> intro hT
· /- human proof:
Let g ∈ Γₛₜ 𝒢 x be a germ. Represent it on an open set U ⊆ X
as ⟨t, U⟩. By local surjectivity, pass to a smaller open set V
on which there exists s ∈ Γ_ ℱ V mapping to t |_ V.
Then the germ of s maps to g -/
-- Let g ∈ Γₛₜ 𝒢 x be a ... | theorem | TopCat.Presheaf.locally_surjective_iff_surjective_on_stalks | Topology.Sheaves | Mathlib/Topology/Sheaves/LocallySurjective.lean | [] | [
"symm"
] | An equivalent condition for a map of presheaves to be locally surjective
is for all the induced maps on stalks to be surjective. | https://github.com/leanprover-community/mathlib4 | b9f14353520df73472ae3825fb53f86559a01319 |
TopCat.Sheaf.isLocallySurjective_iff_epi {X : TopCat.{v}} {C : Type u} [Category.{v} C]
{FC : C → C → Type*} {CC : C → Type v} [∀ X Y, FunLike (FC X Y) (CC X) (CC Y)]
[ConcreteCategory C FC] [Balanced (CategoryTheory.Sheaf (Opens.grothendieckTopology X) C)]
[(Opens.grothendieckTopology X).HasSheafCompose (C... | CategoryTheory.Sheaf.isLocallySurjective_iff_epi' .. | theorem | TopCat.Sheaf.isLocallySurjective_iff_epi | Topology.Sheaves | Mathlib/Topology/Sheaves/LocallySurjective.lean | [] | [
"Balanced",
"CategoryTheory.Sheaf",
"CategoryTheory.Sheaf.isLocallySurjective_iff_epi'",
"CategoryTheory.forget",
"FunLike",
"Opens.grothendieckTopology",
"TopCat.Presheaf.IsLocallySurjective"
] | https://github.com/leanprover-community/mathlib4 | b9f14353520df73472ae3825fb53f86559a01319 | |
PrelocalPredicate where
/-- The underlying predicate of a prelocal predicate -/
pred : ∀ {U : Opens X}, (∀ x : U, T x) → Prop
/-- The underlying predicate should be invariant under restriction -/
res : ∀ {U V : Opens X} (i : U ⟶ V) (f : ∀ x : V, T x) (_ : pred f), pred fun x : U ↦ f (i x) | structure | TopCat.PrelocalPredicate | Topology.Sheaves | Mathlib/Topology/Sheaves/LocalPredicate.lean | [] | [] | Given a topological space `X : TopCat` and a type family `T : X → Type`,
a `P : PrelocalPredicate T` consists of:
* a family of predicates `P.pred`, one for each `U : Opens X`, of the form `(Π x : U, T x) → Prop`
* a proof that if `f : Π x : V, T x` satisfies the predicate on `V : Opens X`, then
the restriction of `f... | https://github.com/leanprover-community/mathlib4 | b9f14353520df73472ae3825fb53f86559a01319 | |
continuousPrelocal (T) [TopologicalSpace T] : PrelocalPredicate fun _ : X ↦ T | where
pred {_} f := Continuous f
res {_ _} i _ h := Continuous.comp h (Opens.isOpenEmbedding_of_le i.le).continuous | def | TopCat.continuousPrelocal | Topology.Sheaves | Mathlib/Topology/Sheaves/LocalPredicate.lean | [] | [
"Continuous",
"Continuous.comp",
"TopologicalSpace"
] | Continuity is a "prelocal" predicate on functions to a fixed topological space `T`. | https://github.com/leanprover-community/mathlib4 | b9f14353520df73472ae3825fb53f86559a01319 |
inhabitedPrelocalPredicate (T) [TopologicalSpace T] :
Inhabited (PrelocalPredicate fun _ : X ↦ T) | ⟨continuousPrelocal X T⟩ | instance | TopCat.inhabitedPrelocalPredicate | Topology.Sheaves | Mathlib/Topology/Sheaves/LocalPredicate.lean | [] | [
"TopologicalSpace"
] | Satisfying the inhabited linter. | https://github.com/leanprover-community/mathlib4 | b9f14353520df73472ae3825fb53f86559a01319 |
LocalPredicate extends PrelocalPredicate T where
/-- A local predicate must be local --- provided that it is locally satisfied, it is also globally
satisfied -/
locality :
∀ {U : Opens X} (f : ∀ x : U, T x)
(_ : ∀ x : U, ∃ (V : Opens X) (_ : x.1 ∈ V) (i : V ⟶ U),
pred fun x : V ↦ f (i x : U)), p... | structure | TopCat.LocalPredicate | Topology.Sheaves | Mathlib/Topology/Sheaves/LocalPredicate.lean | [] | [] | Given a topological space `X : TopCat` and a type family `T : X → Type`,
a `P : LocalPredicate T` consists of:
* a family of predicates `P.pred`, one for each `U : Opens X`, of the form `(Π x : U, T x) → Prop`
* a proof that if `f : Π x : V, T x` satisfies the predicate on `V : Opens X`, then
the restriction of `f` t... | https://github.com/leanprover-community/mathlib4 | b9f14353520df73472ae3825fb53f86559a01319 | |
continuousLocal (T) [TopologicalSpace T] : LocalPredicate fun _ : X ↦ T | { continuousPrelocal X T with
locality := fun {U} f w ↦ by
apply continuous_iff_continuousAt.2
intro x
specialize w x
rcases w with ⟨V, m, i, w⟩
dsimp at w
rw [continuous_iff_continuousAt] at w
specialize w ⟨x, m⟩
simpa using (Opens.isOpenEmbedding_of_le i.le).continu... | def | TopCat.continuousLocal | Topology.Sheaves | Mathlib/Topology/Sheaves/LocalPredicate.lean | [] | [
"TopologicalSpace",
"continuous_iff_continuousAt"
] | Continuity is a "local" predicate on functions to a fixed topological space `T`. | https://github.com/leanprover-community/mathlib4 | b9f14353520df73472ae3825fb53f86559a01319 |
inhabitedLocalPredicate (T) [TopologicalSpace T] :
Inhabited (LocalPredicate fun _ : X ↦ T) | ⟨continuousLocal X T⟩ | instance | TopCat.inhabitedLocalPredicate | Topology.Sheaves | Mathlib/Topology/Sheaves/LocalPredicate.lean | [] | [
"TopologicalSpace"
] | Satisfying the inhabited linter. | https://github.com/leanprover-community/mathlib4 | b9f14353520df73472ae3825fb53f86559a01319 |
PrelocalPredicate.and (P Q : PrelocalPredicate T) : PrelocalPredicate T | where
pred f := P.pred f ∧ Q.pred f
res i f h := ⟨P.res i f h.1, Q.res i f h.2⟩ | def | TopCat.PrelocalPredicate.and | Topology.Sheaves | Mathlib/Topology/Sheaves/LocalPredicate.lean | [] | [] | The conjunction of two prelocal predicates is prelocal. | https://github.com/leanprover-community/mathlib4 | b9f14353520df73472ae3825fb53f86559a01319 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.