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 |
|---|---|---|---|---|---|---|---|---|---|---|
LocalPredicate.and (P Q : LocalPredicate T) : LocalPredicate T | where
__ := P.1.and Q.1
locality f w := by
refine ⟨P.locality f ?_, Q.locality f ?_⟩ <;>
(intro x; have ⟨V, hV, i, h⟩ := w x; use V, hV, i)
exacts [h.1, h.2] | def | TopCat.LocalPredicate.and | Topology.Sheaves | Mathlib/Topology/Sheaves/LocalPredicate.lean | [] | [] | The conjunction of two prelocal predicates is prelocal. | https://github.com/leanprover-community/mathlib4 | b9f14353520df73472ae3825fb53f86559a01319 |
isSection {T} (p : T → X) : LocalPredicate fun _ : X ↦ T | where
pred f := p ∘ f = (↑)
res _ _ h := funext fun _ ↦ congr_fun h _
locality _ w := funext fun x ↦ have ⟨_, hV, _, h⟩ := w x; congr_fun h ⟨x, hV⟩ | def | TopCat.isSection | Topology.Sheaves | Mathlib/Topology/Sheaves/LocalPredicate.lean | [] | [] | The local predicate of being a partial section of a function. | https://github.com/leanprover-community/mathlib4 | b9f14353520df73472ae3825fb53f86559a01319 |
PrelocalPredicate.sheafify {T : X → Type*} (P : PrelocalPredicate T) : LocalPredicate T | where
pred {U} f := ∀ x : U, ∃ (V : Opens X) (_ : x.1 ∈ V) (i : V ⟶ U), P.pred fun x : V ↦ f (i x : U)
res {V U} i f w x := by
specialize w (i x)
rcases w with ⟨V', m', i', p⟩
exact ⟨V ⊓ V', ⟨x.2, m'⟩, V.infLELeft _, P.res (V.infLERight V') _ p⟩
locality {U} f w x := by
specialize w x
rcases w... | def | TopCat.PrelocalPredicate.sheafify | Topology.Sheaves | Mathlib/Topology/Sheaves/LocalPredicate.lean | [] | [] | Given a `P : PrelocalPredicate`, we can always construct a `LocalPredicate`
by asking that the condition from `P` holds locally near every point. | https://github.com/leanprover-community/mathlib4 | b9f14353520df73472ae3825fb53f86559a01319 |
sheafifyOf {T : X → Type*} {P : PrelocalPredicate T} {U : Opens X}
{f : ∀ x : U, T x} (h : P.pred f) : P.sheafify.pred f | fun x ↦
⟨U, x.2, 𝟙 _, by convert! h⟩ | theorem | TopCat.PrelocalPredicate.sheafifyOf | Topology.Sheaves | Mathlib/Topology/Sheaves/LocalPredicate.lean | [] | [] | https://github.com/leanprover-community/mathlib4 | b9f14353520df73472ae3825fb53f86559a01319 | |
sheafify_inductionOn {X : TopCat} {T : X → Type*} (P : PrelocalPredicate T)
(op : {x : X} → T x → T x)
(hop : ∀ {U : Opens X} {a : (x : U) → T x}, P.pred a →
∀ (p : U), ∃ (W : Opens X) (i : W ⟶ U), p.1 ∈ W ∧ P.pred fun x : W ↦ op (a (i x)))
{U : Opens X} {a : (x : U) → T x} (ha : P.sheafify.pred a) :
... | by
intro x
rcases ha x with ⟨Va, ma, ia, ha⟩
rcases hop ha ⟨x, ma⟩ with ⟨W, sa, hx, hw⟩
exact ⟨W, hx, sa ≫ ia, hw⟩ | theorem | TopCat.PrelocalPredicate.sheafify_inductionOn | Topology.Sheaves | Mathlib/Topology/Sheaves/LocalPredicate.lean | [] | [
"TopCat"
] | For a unary operation (e.g. `x ↦ -x`) defined at each stalk, if a prelocal predicate is closed
under the operation on each open set (possibly by refinement), then the sheafified predicate is
also closed under the operation. See `sheafify_inductionOn'` for the version without refinement. | https://github.com/leanprover-community/mathlib4 | b9f14353520df73472ae3825fb53f86559a01319 |
sheafify_inductionOn' {X : TopCat} {T : X → Type*} (P : PrelocalPredicate T)
(op : {x : X} → T x → T x)
(hop : ∀ {U : Opens X} {a : (x : U) → T x}, P.pred a → P.pred fun x : U ↦ op (a x))
{U : Opens X} {a : (x : U) → T x} (ha : P.sheafify.pred a) :
P.sheafify.pred (fun x : U ↦ op (a x)) | P.sheafify_inductionOn op (fun ha p ↦ ⟨_, 𝟙 _, p.2, hop ha⟩) ha | theorem | TopCat.PrelocalPredicate.sheafify_inductionOn' | Topology.Sheaves | Mathlib/Topology/Sheaves/LocalPredicate.lean | [] | [
"TopCat"
] | For a unary operation (e.g. `x ↦ -x`) defined at each stalk, if a prelocal predicate is closed
under the operation on each open set, then the sheafified predicate is also closed under the
operation. See `sheafify_inductionOn` for the version with refinement. | https://github.com/leanprover-community/mathlib4 | b9f14353520df73472ae3825fb53f86559a01319 |
sheafify_inductionOn₂ {X : TopCat} {T₁ T₂ T₃ : X → Type*}
(P₁ : PrelocalPredicate T₁) (P₂ : PrelocalPredicate T₂) (P₃ : PrelocalPredicate T₃)
(op : {x : X} → T₁ x → T₂ x → T₃ x)
(hop : ∀ {U V : Opens X} {a : (x : U) → T₁ x} {b : (x : V) → T₂ x}, P₁.pred a → P₂.pred b →
∀ (p : (U ⊓ V : Opens X)), ∃ (W ... | by
intro x
rcases ha x with ⟨Va, ma, ia, ha⟩
rcases hb x with ⟨Vb, mb, ib, hb⟩
rcases hop ha hb ⟨x, ma, mb⟩ with ⟨W, sa, sb, hx, hw⟩
exact ⟨W, hx, sa ≫ ia, hw⟩ | theorem | TopCat.PrelocalPredicate.sheafify_inductionOn₂ | Topology.Sheaves | Mathlib/Topology/Sheaves/LocalPredicate.lean | [] | [
"TopCat"
] | For a binary operation (e.g. `x ↦ y ↦ x + y`) defined at each stalk, if a prelocal predicate is
closed under the operation on each open set (possibly by refinement), then the sheafified predicate
is also closed under the operation. See `sheafify_inductionOn₂'` for the version without
refinement. | https://github.com/leanprover-community/mathlib4 | b9f14353520df73472ae3825fb53f86559a01319 |
sheafify_inductionOn₂' {X : TopCat} {T₁ T₂ T₃ : X → Type*}
(P₁ : PrelocalPredicate T₁) (P₂ : PrelocalPredicate T₂) (P₃ : PrelocalPredicate T₃)
(op : {x : X} → T₁ x → T₂ x → T₃ x)
(hop : ∀ {U V : Opens X} {a : (x : U) → T₁ x} {b : (x : V) → T₂ x}, P₁.pred a → P₂.pred b →
P₃.pred fun x : (U ⊓ V : Opens ... | P₁.sheafify_inductionOn₂ P₂ P₃ op
(fun ha hb p ↦ ⟨_, Opens.infLELeft _ _, Opens.infLERight _ _, p.2, hop ha hb⟩) ha hb | theorem | TopCat.PrelocalPredicate.sheafify_inductionOn₂' | Topology.Sheaves | Mathlib/Topology/Sheaves/LocalPredicate.lean | [] | [
"TopCat"
] | For a binary operation (e.g. `x ↦ y ↦ x + y`) defined at each stalk, if a prelocal predicate is
closed under the operation on each open set, then the sheafified predicate is also closed under the
operation. See `sheafify_inductionOn₂` for the version with refinement. | https://github.com/leanprover-community/mathlib4 | b9f14353520df73472ae3825fb53f86559a01319 |
subpresheafToTypes (P : PrelocalPredicate T) : Presheaf (Type _) X | where
obj U := { f : ∀ x : U.unop, T x // P.pred f }
map i := ↾fun f ↦ ⟨fun x ↦ f.1 (i.unop x), P.res i.unop f.1 f.2⟩ | def | TopCat.subpresheafToTypes | Topology.Sheaves | Mathlib/Topology/Sheaves/LocalPredicate.lean | [] | [] | The subpresheaf of dependent functions on `X` satisfying the "pre-local" predicate `P`. | https://github.com/leanprover-community/mathlib4 | b9f14353520df73472ae3825fb53f86559a01319 |
subtype : subpresheafToTypes P ⟶ presheafToTypes X T | where app _ := ↾fun f ↦ f.1 | def | TopCat.subpresheafToTypes.subtype | Topology.Sheaves | Mathlib/Topology/Sheaves/LocalPredicate.lean | [] | [] | The natural transformation including the subpresheaf of functions satisfying a local predicate
into the presheaf of all functions. | https://github.com/leanprover-community/mathlib4 | b9f14353520df73472ae3825fb53f86559a01319 |
isSheaf (P : LocalPredicate T) : (subpresheafToTypes P.toPrelocalPredicate).IsSheaf | Presheaf.isSheaf_of_isSheafUniqueGluing_types _ fun ι U sf sf_comp ↦ by
-- We show the sheaf condition in terms of unique gluing.
-- First we obtain a family of sections for the underlying sheaf of functions,
-- by forgetting that the predicate holds
let sf' (i : ι) : (presheafToTypes X T).obj (op (U i)... | theorem | TopCat.subpresheafToTypes.isSheaf | Topology.Sheaves | Mathlib/Topology/Sheaves/LocalPredicate.lean | [] | [] | The functions satisfying a local predicate satisfy the sheaf condition. | https://github.com/leanprover-community/mathlib4 | b9f14353520df73472ae3825fb53f86559a01319 |
subsheafToTypes (P : LocalPredicate T) : Sheaf (Type _) X | ⟨subpresheafToTypes P.toPrelocalPredicate, subpresheafToTypes.isSheaf P⟩ | def | TopCat.subsheafToTypes | Topology.Sheaves | Mathlib/Topology/Sheaves/LocalPredicate.lean | [] | [] | The subsheaf of the sheaf of all dependently typed functions satisfying the local predicate `P`. | https://github.com/leanprover-community/mathlib4 | b9f14353520df73472ae3825fb53f86559a01319 |
LocalPredicate.cocone (P : LocalPredicate T) (x : X) :
Cocone ((OpenNhds.inclusion x).op ⋙ subpresheafToTypes P.toPrelocalPredicate) | where
pt := T x
ι := { app U := ↾fun f ↦ f.1 ⟨x, (unop U).2⟩ } | def | TopCat.LocalPredicate.cocone | Topology.Sheaves | Mathlib/Topology/Sheaves/LocalPredicate.lean | [] | [] | Auxiliary definition for `stalkToFiber`. | https://github.com/leanprover-community/mathlib4 | b9f14353520df73472ae3825fb53f86559a01319 |
stalkToFiber (P : LocalPredicate T) (x : X) :
(subsheafToTypes P).presheaf.stalk x ⟶ T x | colimit.desc _ (P.cocone x) | def | TopCat.stalkToFiber | Topology.Sheaves | Mathlib/Topology/Sheaves/LocalPredicate.lean | [] | [] | There is a canonical map from the stalk to the original fiber, given by evaluating sections. | https://github.com/leanprover-community/mathlib4 | b9f14353520df73472ae3825fb53f86559a01319 |
stalkToFiber_ι (P : LocalPredicate T) (x : X) (U : (OpenNhds x)ᵒᵖ)
(fU : {f // P.pred f}) :
dsimp% (stalkToFiber P x)
(colimit.ι ((OpenNhds.inclusion x).op ⋙ subpresheafToTypes P.toPrelocalPredicate) U fU) =
(P.cocone x).ι.app U fU | colimit.ι_desc_apply _ _ _ | lemma | TopCat.stalkToFiber_ι | Topology.Sheaves | Mathlib/Topology/Sheaves/LocalPredicate.lean | [] | [] | https://github.com/leanprover-community/mathlib4 | b9f14353520df73472ae3825fb53f86559a01319 | |
stalkToFiber_germ (P : LocalPredicate T) (U : Opens X) (x : X) (hx : x ∈ U) (f) :
stalkToFiber P x ((subsheafToTypes P).presheaf.germ U x hx f) = f.1 ⟨x, hx⟩ | by
dsimp [stalkToFiber, Presheaf.germ]
exact colimit.ι_desc_apply _ _ _ | theorem | TopCat.stalkToFiber_germ | Topology.Sheaves | Mathlib/Topology/Sheaves/LocalPredicate.lean | [] | [] | https://github.com/leanprover-community/mathlib4 | b9f14353520df73472ae3825fb53f86559a01319 | |
stalkToFiber_surjective (P : LocalPredicate T) (x : X)
(w : ∀ t : T x, ∃ (U : OpenNhds x) (f : ∀ y : U.1, T y) (_ : P.pred f), f ⟨x, U.2⟩ = t) :
Function.Surjective (stalkToFiber P x) | fun t ↦ by
rcases w t with ⟨U, f, h, rfl⟩
fconstructor
· exact (subsheafToTypes P).presheaf.germ _ x U.2 ⟨f, h⟩
· exact stalkToFiber_germ P U.1 x U.2 ⟨f, h⟩ | theorem | TopCat.stalkToFiber_surjective | Topology.Sheaves | Mathlib/Topology/Sheaves/LocalPredicate.lean | [] | [] | The `stalkToFiber` map is surjective at `x` if
every point in the fiber `T x` has an allowed section passing through it. | https://github.com/leanprover-community/mathlib4 | b9f14353520df73472ae3825fb53f86559a01319 |
stalkToFiber_injective (P : LocalPredicate T) (x : X)
(w :
∀ (U V : OpenNhds x) (fU : ∀ y : U.1, T y) (_ : P.pred fU) (fV : ∀ y : V.1, T y)
(_ : P.pred fV) (_ : fU ⟨x, U.2⟩ = fV ⟨x, V.2⟩),
∃ (W : OpenNhds x) (iU : W ⟶ U) (iV : W ⟶ V), ∀ w : W.1,
fU (iU w : U.1) = fV (iV w : V.1)) :
... | fun tU tV h ↦ by
-- We promise to provide all the ingredients of the proof later:
let Q :
∃ (W : (OpenNhds x)ᵒᵖ) (s : ∀ w : (unop W).1, T w) (hW : P.pred s),
tU = (subsheafToTypes P).presheaf.germ _ x (unop W).2 ⟨s, hW⟩ ∧
tV = (subsheafToTypes P).presheaf.germ _ x (unop W).2 ⟨s, hW⟩ :=
?_
· ... | theorem | TopCat.stalkToFiber_injective | Topology.Sheaves | Mathlib/Topology/Sheaves/LocalPredicate.lean | [] | [
"symm"
] | The `stalkToFiber` map is injective at `x` if any two allowed sections which agree at `x`
agree on some neighborhood of `x`. | https://github.com/leanprover-community/mathlib4 | b9f14353520df73472ae3825fb53f86559a01319 |
subpresheafContinuousPrelocalIsoPresheafToTop {X : TopCat.{u}} (T : TopCat.{u}) :
subpresheafToTypes (continuousPrelocal X T) ≅ presheafToTop X T | NatIso.ofComponents fun X ↦
{ hom := ↾fun f ↦ ofHom ⟨f.1, f.2⟩
inv := ↾fun f ↦ ⟨f.1, f.1.2⟩ } | def | TopCat.subpresheafContinuousPrelocalIsoPresheafToTop | Topology.Sheaves | Mathlib/Topology/Sheaves/LocalPredicate.lean | [] | [] | Some repackaging:
the presheaf of functions satisfying `continuousPrelocal` is just the same thing as
the presheaf of continuous functions. | https://github.com/leanprover-community/mathlib4 | b9f14353520df73472ae3825fb53f86559a01319 |
sheafToTop (T : TopCat) : Sheaf (Type _) X | ⟨presheafToTop X T,
Presheaf.isSheaf_of_iso (subpresheafContinuousPrelocalIsoPresheafToTop T)
(subpresheafToTypes.isSheaf (continuousLocal X T))⟩ | def | TopCat.sheafToTop | Topology.Sheaves | Mathlib/Topology/Sheaves/LocalPredicate.lean | [] | [
"TopCat"
] | The sheaf of continuous functions on `X` with values in a space `T`. | https://github.com/leanprover-community/mathlib4 | b9f14353520df73472ae3825fb53f86559a01319 |
mayerVietorisSquare' (sq : Square (Opens T))
(h₄ : sq.X₄ = sq.X₂ ⊔ sq.X₃) (h₁ : sq.X₁ = sq.X₂ ⊓ sq.X₃) :
(Opens.grothendieckTopology T).MayerVietorisSquare | GrothendieckTopology.MayerVietorisSquare.mk_of_isPullback
(J := (Opens.grothendieckTopology T)) sq
(Square.IsPullback.mk _ (by
refine PullbackCone.IsLimit.mk _ ?_ ?_ ?_ ?_
· intro s
apply homOfLE
rw [h₁, le_inf_iff]
exact ⟨leOfHom s.fst, leOfHom s.snd⟩
all_goals intros;... | def | Opens.mayerVietorisSquare' | Topology.Sheaves | Mathlib/Topology/Sheaves/MayerVietoris.lean | [] | [
"Opens.grothendieckTopology"
] | A square consisting of opens `X₂ ⊓ X₃`, `X₂`, `X₃` and `X₂ ⊔ X₃` is
a Mayer-Vietoris square. | https://github.com/leanprover-community/mathlib4 | b9f14353520df73472ae3825fb53f86559a01319 |
mayerVietorisSquare (U V : Opens T) :
(Opens.grothendieckTopology T).MayerVietorisSquare | mayerVietorisSquare'
{ X₁ := U ⊓ V
X₂ := U
X₃ := V
X₄ := U ⊔ V
f₁₂ := homOfLE inf_le_left
f₁₃ := homOfLE inf_le_right
f₂₄ := homOfLE le_sup_left
f₃₄ := homOfLE le_sup_right
fac := Subsingleton.elim _ _ } rfl rfl | def | Opens.mayerVietorisSquare | Topology.Sheaves | Mathlib/Topology/Sheaves/MayerVietoris.lean | [] | [
"Opens.grothendieckTopology",
"le_sup_left",
"le_sup_right"
] | The Mayer-Vietoris square attached to two open subsets
of a topological space. | https://github.com/leanprover-community/mathlib4 | b9f14353520df73472ae3825fb53f86559a01319 |
overEquivalence : Over U ≌ Opens ↥U | where
functor.obj V := ⟨_, IsOpen.preimage (continuous_subtype_val) V.left.isOpen⟩
functor.map f := homOfLE (Set.preimage_mono (f := Subtype.val) (leOfHom f.left))
inverse.obj W :=
Over.mk (Y := ⟨_, (U.isOpenEmbedding'.isOpen_iff_image_isOpen).1 W.isOpen⟩)
(homOfLE (fun _ _ ↦ by aesop))
inverse.map f ... | def | TopologicalSpace.Opens.overEquivalence | Topology.Sheaves | Mathlib/Topology/Sheaves/Over.lean | [] | [
"IsOpen.preimage",
"Set.image_mono",
"Set.mem_image",
"Set.mem_preimage",
"Set.preimage_mono",
"SetLike.mem_coe",
"continuous_subtype_val"
] | If `X` is a topological space and `U : Opens X`,
then the category `Over U` is equivalent to `Opens ↥U`. | https://github.com/leanprover-community/mathlib4 | b9f14353520df73472ae3825fb53f86559a01319 |
pointGrothendieckTopology : Point.{u} (grothendieckTopology X) | where
fiber.obj U := ULift.{u} (PLift (x ∈ U))
fiber.map f := ↾fun h ↦ ⟨⟨leOfHom f h.down.down⟩⟩
isCofiltered :=
{ nonempty := ⟨⊤, ⟨⟨by simp⟩⟩⟩
cone_objs := by
rintro ⟨U, ⟨⟨hU⟩⟩⟩ ⟨V, ⟨⟨hV⟩⟩⟩
exact ⟨⟨U ⊓ V, ⟨⟨⟨hU, hV⟩⟩⟩⟩, ⟨homOfLE (by simp), rfl⟩,
⟨homOfLE (by simp), rfl⟩, ⟨⟩⟩
... | def | Opens.pointGrothendieckTopology | Topology.Sheaves | Mathlib/Topology/Sheaves/Points.lean | [] | [] | Given a topological space `X` and `x : X`, this is the point of the site
`(Opens X, Opens.grothendieckTopology X)` corresponding to `x`. | https://github.com/leanprover-community/mathlib4 | b9f14353520df73472ae3825fb53f86559a01319 |
pointsGrothendieckTopology : ObjectProperty (Point.{u} (grothendieckTopology X)) | ObjectProperty.ofObj pointGrothendieckTopology
deriving ObjectProperty.Small.{u} | def | Opens.pointsGrothendieckTopology | Topology.Sheaves | Mathlib/Topology/Sheaves/Points.lean | [] | [] | When `X` is a topological space, this is the obvious conservative family of
points on the site `(Opens X, Opens.grothendieckTopology X)`. | https://github.com/leanprover-community/mathlib4 | b9f14353520df73472ae3825fb53f86559a01319 |
isConservativeFamilyOfPoints_pointsGrothendieckTopology :
(pointsGrothendieckTopology X).IsConservativeFamilyOfPoints | .mk' (fun U S hS x hx ↦ by
obtain ⟨V, f, hf, ⟨⟨hV⟩⟩, _⟩ := hS ⟨_, ⟨x⟩⟩ ⟨⟨hx⟩⟩
exact ⟨V, f, hf, hV⟩) | lemma | Opens.isConservativeFamilyOfPoints_pointsGrothendieckTopology | Topology.Sheaves | Mathlib/Topology/Sheaves/Points.lean | [] | [] | https://github.com/leanprover-community/mathlib4 | b9f14353520df73472ae3825fb53f86559a01319 | |
pointGrothendieckTopologyHomEquiv {x y : X} :
(pointGrothendieckTopology x ⟶ pointGrothendieckTopology y) ≃ x ⤳ y | where
toFun f := specializes_iff_forall_open.2 (fun U h₁ h₂ ↦ (f.hom.app ⟨U, h₁⟩ ⟨⟨h₂⟩⟩).down.down)
invFun s := { hom.app U := ↾fun hU ↦
⟨⟨specializes_iff_forall_open.1 s _ U.2 hU.down.down⟩⟩ }
left_inv _ := by subsingleton
right_inv _ := rfl | def | Opens.pointGrothendieckTopologyHomEquiv | Topology.Sheaves | Mathlib/Topology/Sheaves/Points.lean | [] | [] | A point `x` of a topological space `X` specializes to `y` if and only iff
there is a (unique) morphism between the corresponding points of the site
`(Opens X, grothendieckTopology X)`. | https://github.com/leanprover-community/mathlib4 | b9f14353520df73472ae3825fb53f86559a01319 |
Presheaf (X : TopCat.{w}) : Type max u v w | (Opens X)ᵒᵖ ⥤ C | def | TopCat.Presheaf | Topology.Sheaves | Mathlib/Topology/Sheaves/Presheaf.lean | [] | [] | The category of `C`-valued presheaves on a (bundled) topological space `X`. | https://github.com/leanprover-community/mathlib4 | b9f14353520df73472ae3825fb53f86559a01319 |
comp_app {X : TopCat.{w}} {U : (Opens X)ᵒᵖ} {P Q R : Presheaf C X}
(f : P ⟶ Q) (g : Q ⟶ R) :
(f ≫ g).app U = f.app U ≫ g.app U | rfl | theorem | TopCat.Presheaf.comp_app | Topology.Sheaves | Mathlib/Topology/Sheaves/Presheaf.lean | [] | [] | https://github.com/leanprover-community/mathlib4 | b9f14353520df73472ae3825fb53f86559a01319 | |
ext {X : TopCat.{w}} {P Q : Presheaf C X} {f g : P ⟶ Q}
(w : ∀ U : Opens X, f.app (op U) = g.app (op U)) :
f = g | by
apply NatTrans.ext
ext U
induction U with | _ U => ?_
apply w | lemma | TopCat.Presheaf.ext | Topology.Sheaves | Mathlib/Topology/Sheaves/Presheaf.lean | [] | [] | https://github.com/leanprover-community/mathlib4 | b9f14353520df73472ae3825fb53f86559a01319 | |
"sheaf_restrict" : attr =>
`(attr|aesop safe 50 apply (rule_sets := [$(Lean.mkIdent `Restrict):ident])) | macro | sheaf_restrict | Topology.Sheaves | Mathlib/Topology/Sheaves/Presheaf.lean | [] | [] | attribute `sheaf_restrict` to mark lemmas related to restricting sheaves | https://github.com/leanprover-community/mathlib4 | b9f14353520df73472ae3825fb53f86559a01319 | |
(name := restrict_tac) "restrict_tac" c:Aesop.tactic_clause* : tactic =>
`(tactic| first | assumption |
aesop $c*
(config := { terminal := true
assumptionTransparency := .reducible
enableSimp := false })
(rule_sets := [-default, -builtin, $(Lean.mkIdent `Restrict):ident])) | macro | restrict_tac | Topology.Sheaves | Mathlib/Topology/Sheaves/Presheaf.lean | [] | [] | `restrict_tac` solves relations among subsets (copied from `aesop cat`) | https://github.com/leanprover-community/mathlib4 | b9f14353520df73472ae3825fb53f86559a01319 | |
(name := restrict_tac?) "restrict_tac?" c:Aesop.tactic_clause* : tactic =>
`(tactic|
aesop? $c*
(config := { terminal := true
assumptionTransparency := .reducible
enableSimp := false
maxRuleApplications := 300 })
(rule_sets := [-default, -builtin, $(Lean.mkIden... | macro | restrict_tac? | Topology.Sheaves | Mathlib/Topology/Sheaves/Presheaf.lean | [] | [] | `restrict_tac?` passes along `Try this` from `aesop` | https://github.com/leanprover-community/mathlib4 | b9f14353520df73472ae3825fb53f86559a01319 | |
restrict {F : X.Presheaf C}
{V : Opens X} (x : ToType (F.obj (op V))) {U : Opens X} (h : U ⟶ V) : ToType (F.obj (op U)) | F.map h.op x
/-- restriction of a section along an inclusion -/
scoped[AlgebraicGeometry] infixl:80 " |_ₕ " => TopCat.Presheaf.restrict
/-- restriction of a section along a subset relation -/
scoped[AlgebraicGeometry] notation:80 x " |_ₗ " U " ⟪" e "⟫ " =>
@TopCat.Presheaf.restrict _ _ _ _ _ _ _ _ _ x U (@homOfLE (O... | def | TopCat.Presheaf.restrict | Topology.Sheaves | Mathlib/Topology/Sheaves/Presheaf.lean | [] | [] | The restriction of a section along an inclusion of open sets.
For `x : F.obj (op V)`, we provide the notation `x |_ₕ i` (`h` stands for `hom`) for `i : U ⟶ V`,
and the notation `x |_ₗ U ⟪i⟫` (`l` stands for `le`) for `i : U ≤ V`. | https://github.com/leanprover-community/mathlib4 | b9f14353520df73472ae3825fb53f86559a01319 |
restrictOpen {F : X.Presheaf C}
{V : Opens X} (x : ToType (F.obj (op V))) (U : Opens X)
(e : U ≤ V := by restrict_tac) :
ToType (F.obj (op U)) | x |_ₗ U ⟪e⟫
/-- restriction of a section to open subset -/
scoped[AlgebraicGeometry] infixl:80 " |_ " => TopCat.Presheaf.restrictOpen | abbrev | TopCat.Presheaf.restrictOpen | Topology.Sheaves | Mathlib/Topology/Sheaves/Presheaf.lean | [] | [] | The restriction of a section along an inclusion of open sets.
For `x : F.obj (op V)`, we provide the notation `x |_ U`, where the proof `U ≤ V` is inferred by
the tactic `Top.presheaf.restrict_tac'` | https://github.com/leanprover-community/mathlib4 | b9f14353520df73472ae3825fb53f86559a01319 |
restrict_restrict
{F : X.Presheaf C} {U V W : Opens X} (e₁ : U ≤ V) (e₂ : V ≤ W) (x : ToType (F.obj (op W))) :
x |_ V |_ U = x |_ U | by
delta restrictOpen restrict
rw [← ConcreteCategory.comp_apply, ← Functor.map_comp]
rfl | theorem | TopCat.Presheaf.restrict_restrict | Topology.Sheaves | Mathlib/Topology/Sheaves/Presheaf.lean | [] | [] | https://github.com/leanprover-community/mathlib4 | b9f14353520df73472ae3825fb53f86559a01319 | |
map_restrict
{F G : X.Presheaf C} (e : F ⟶ G) {U V : Opens X} (h : U ≤ V) (x : ToType (F.obj (op V))) :
e.app _ (x |_ U) = e.app _ x |_ U | by
delta restrictOpen restrict
rw [← ConcreteCategory.comp_apply, NatTrans.naturality, ConcreteCategory.comp_apply] | theorem | TopCat.Presheaf.map_restrict | Topology.Sheaves | Mathlib/Topology/Sheaves/Presheaf.lean | [] | [] | https://github.com/leanprover-community/mathlib4 | b9f14353520df73472ae3825fb53f86559a01319 | |
restrict_self {F : X.Presheaf C} {U : Opens X} (x : ToType (F.obj (op U))) :
x |_ U = x | by
simp [restrictOpen, restrict] | lemma | TopCat.Presheaf.restrict_self | Topology.Sheaves | Mathlib/Topology/Sheaves/Presheaf.lean | [] | [] | https://github.com/leanprover-community/mathlib4 | b9f14353520df73472ae3825fb53f86559a01319 | |
pushforward {X Y : TopCat.{w}} (f : X ⟶ Y) : X.Presheaf C ⥤ Y.Presheaf C | (whiskeringLeft _ _ _).obj (Opens.map f).op
/-- push forward of a presheaf -/
scoped[AlgebraicGeometry] notation f:80 " _* " P:81 =>
Functor.obj (TopCat.Presheaf.pushforward _ f) P | def | TopCat.Presheaf.pushforward | Topology.Sheaves | Mathlib/Topology/Sheaves/Presheaf.lean | [] | [] | The pushforward functor. | https://github.com/leanprover-community/mathlib4 | b9f14353520df73472ae3825fb53f86559a01319 |
pushforward_map_app' {X Y : TopCat.{w}} (f : X ⟶ Y) {ℱ 𝒢 : X.Presheaf C} (α : ℱ ⟶ 𝒢)
{U : (Opens Y)ᵒᵖ} : ((pushforward C f).map α).app U = α.app (op <| (Opens.map f).obj U.unop) | rfl | theorem | TopCat.Presheaf.pushforward_map_app' | Topology.Sheaves | Mathlib/Topology/Sheaves/Presheaf.lean | [] | [] | https://github.com/leanprover-community/mathlib4 | b9f14353520df73472ae3825fb53f86559a01319 | |
id_pushforward (X : TopCat.{w}) : pushforward C (𝟙 X) = 𝟭 (X.Presheaf C) | rfl | lemma | TopCat.Presheaf.id_pushforward | Topology.Sheaves | Mathlib/Topology/Sheaves/Presheaf.lean | [] | [] | https://github.com/leanprover-community/mathlib4 | b9f14353520df73472ae3825fb53f86559a01319 | |
id {X : TopCat.{w}} (ℱ : X.Presheaf C) : 𝟙 X _* ℱ ≅ ℱ | Iso.refl _ | def | TopCat.Presheaf.Pushforward.id | Topology.Sheaves | Mathlib/Topology/Sheaves/Presheaf.lean | [] | [] | The natural isomorphism between the pushforward of a presheaf along the identity continuous map
and the original presheaf. | https://github.com/leanprover-community/mathlib4 | b9f14353520df73472ae3825fb53f86559a01319 |
id_hom_app {X : TopCat.{w}} (ℱ : X.Presheaf C) (U) : (id ℱ).hom.app U = 𝟙 _ | rfl | theorem | TopCat.Presheaf.Pushforward.id_hom_app | Topology.Sheaves | Mathlib/Topology/Sheaves/Presheaf.lean | [] | [] | https://github.com/leanprover-community/mathlib4 | b9f14353520df73472ae3825fb53f86559a01319 | |
id_inv_app {X : TopCat.{w}} (ℱ : X.Presheaf C) (U) :
(id ℱ).inv.app U = 𝟙 _ | rfl | theorem | TopCat.Presheaf.Pushforward.id_inv_app | Topology.Sheaves | Mathlib/Topology/Sheaves/Presheaf.lean | [] | [] | https://github.com/leanprover-community/mathlib4 | b9f14353520df73472ae3825fb53f86559a01319 | |
id_eq {X : TopCat.{w}} (ℱ : X.Presheaf C) : 𝟙 X _* ℱ = ℱ | rfl | theorem | TopCat.Presheaf.Pushforward.id_eq | Topology.Sheaves | Mathlib/Topology/Sheaves/Presheaf.lean | [] | [] | https://github.com/leanprover-community/mathlib4 | b9f14353520df73472ae3825fb53f86559a01319 | |
comp {X Y Z : TopCat.{w}} (f : X ⟶ Y) (g : Y ⟶ Z) (ℱ : X.Presheaf C) :
(f ≫ g) _* ℱ ≅ g _* (f _* ℱ) | Iso.refl _ | def | TopCat.Presheaf.Pushforward.comp | Topology.Sheaves | Mathlib/Topology/Sheaves/Presheaf.lean | [] | [] | The natural isomorphism between
the pushforward of a presheaf along the composition of two continuous maps and
the corresponding pushforward of a pushforward. | https://github.com/leanprover-community/mathlib4 | b9f14353520df73472ae3825fb53f86559a01319 |
comp_eq {X Y Z : TopCat.{w}} (f : X ⟶ Y) (g : Y ⟶ Z) (ℱ : X.Presheaf C) :
(f ≫ g) _* ℱ = g _* (f _* ℱ) | rfl | theorem | TopCat.Presheaf.Pushforward.comp_eq | Topology.Sheaves | Mathlib/Topology/Sheaves/Presheaf.lean | [] | [] | https://github.com/leanprover-community/mathlib4 | b9f14353520df73472ae3825fb53f86559a01319 | |
comp_hom_app {X Y Z : TopCat.{w}} (f : X ⟶ Y) (g : Y ⟶ Z) (ℱ : X.Presheaf C) (U) :
(comp f g ℱ).hom.app U = 𝟙 _ | rfl | theorem | TopCat.Presheaf.Pushforward.comp_hom_app | Topology.Sheaves | Mathlib/Topology/Sheaves/Presheaf.lean | [] | [] | https://github.com/leanprover-community/mathlib4 | b9f14353520df73472ae3825fb53f86559a01319 | |
comp_inv_app {X Y Z : TopCat.{w}} (f : X ⟶ Y) (g : Y ⟶ Z) (ℱ : X.Presheaf C) (U) :
(comp f g ℱ).inv.app U = 𝟙 _ | rfl | theorem | TopCat.Presheaf.Pushforward.comp_inv_app | Topology.Sheaves | Mathlib/Topology/Sheaves/Presheaf.lean | [] | [] | https://github.com/leanprover-community/mathlib4 | b9f14353520df73472ae3825fb53f86559a01319 | |
pushforwardEq {X Y : TopCat.{w}} {f g : X ⟶ Y} (h : f = g) (ℱ : X.Presheaf C) :
f _* ℱ ≅ g _* ℱ | isoWhiskerRight (NatIso.op (Opens.mapIso f g h).symm) ℱ | def | TopCat.Presheaf.pushforwardEq | Topology.Sheaves | Mathlib/Topology/Sheaves/Presheaf.lean | [] | [
"symm"
] | An equality of continuous maps induces a natural isomorphism between the pushforwards of a presheaf
along those maps. | https://github.com/leanprover-community/mathlib4 | b9f14353520df73472ae3825fb53f86559a01319 |
pushforward_eq' {X Y : TopCat.{w}} {f g : X ⟶ Y} (h : f = g) (ℱ : X.Presheaf C) :
f _* ℱ = g _* ℱ | by rw [h] | theorem | TopCat.Presheaf.pushforward_eq' | Topology.Sheaves | Mathlib/Topology/Sheaves/Presheaf.lean | [] | [] | https://github.com/leanprover-community/mathlib4 | b9f14353520df73472ae3825fb53f86559a01319 | |
pushforwardEq_hom_app {X Y : TopCat.{w}} {f g : X ⟶ Y}
(h : f = g) (ℱ : X.Presheaf C) (U) :
(pushforwardEq h ℱ).hom.app U = ℱ.map (eqToHom (by cat_disch)) | by
simp [pushforwardEq] | theorem | TopCat.Presheaf.pushforwardEq_hom_app | Topology.Sheaves | Mathlib/Topology/Sheaves/Presheaf.lean | [] | [] | https://github.com/leanprover-community/mathlib4 | b9f14353520df73472ae3825fb53f86559a01319 | |
presheafEquivOfIso {X Y : TopCat.{w}} (H : X ≅ Y) : X.Presheaf C ≌ Y.Presheaf C | Equivalence.congrLeft (Opens.mapMapIso H).symm.op | def | TopCat.Presheaf.presheafEquivOfIso | Topology.Sheaves | Mathlib/Topology/Sheaves/Presheaf.lean | [] | [] | A homeomorphism of spaces gives an equivalence of categories of presheaves. | https://github.com/leanprover-community/mathlib4 | b9f14353520df73472ae3825fb53f86559a01319 |
toPushforwardOfIso {X Y : TopCat.{w}} (H : X ≅ Y) {ℱ : X.Presheaf C} {𝒢 : Y.Presheaf C}
(α : H.hom _* ℱ ⟶ 𝒢) : ℱ ⟶ H.inv _* 𝒢 | (presheafEquivOfIso _ H).toAdjunction.homEquiv ℱ 𝒢 α | def | TopCat.Presheaf.toPushforwardOfIso | Topology.Sheaves | Mathlib/Topology/Sheaves/Presheaf.lean | [] | [] | If `H : X ≅ Y` is a homeomorphism,
then given an `H _* ℱ ⟶ 𝒢`, we may obtain an `ℱ ⟶ H ⁻¹ _* 𝒢`. | https://github.com/leanprover-community/mathlib4 | b9f14353520df73472ae3825fb53f86559a01319 |
toPushforwardOfIso_app {X Y : TopCat.{w}} (H₁ : X ≅ Y) {ℱ : X.Presheaf C} {𝒢 : Y.Presheaf C}
(H₂ : H₁.hom _* ℱ ⟶ 𝒢) (U : (Opens X)ᵒᵖ) :
(toPushforwardOfIso H₁ H₂).app U =
ℱ.map (eqToHom (by simp [Opens.map, Set.preimage_preimage])) ≫
H₂.app (op ((Opens.map H₁.inv).obj (unop U))) | by
simp [toPushforwardOfIso, Adjunction.homEquiv_unit] | theorem | TopCat.Presheaf.toPushforwardOfIso_app | Topology.Sheaves | Mathlib/Topology/Sheaves/Presheaf.lean | [] | [
"Set.preimage_preimage"
] | https://github.com/leanprover-community/mathlib4 | b9f14353520df73472ae3825fb53f86559a01319 | |
pushforwardToOfIso {X Y : TopCat.{w}} (H₁ : X ≅ Y) {ℱ : Y.Presheaf C} {𝒢 : X.Presheaf C}
(H₂ : ℱ ⟶ H₁.hom _* 𝒢) : H₁.inv _* ℱ ⟶ 𝒢 | ((presheafEquivOfIso _ H₁.symm).toAdjunction.homEquiv ℱ 𝒢).symm H₂ | def | TopCat.Presheaf.pushforwardToOfIso | Topology.Sheaves | Mathlib/Topology/Sheaves/Presheaf.lean | [] | [
"symm"
] | If `H : X ≅ Y` is a homeomorphism,
then given an `H _* ℱ ⟶ 𝒢`, we may obtain an `ℱ ⟶ H ⁻¹ _* 𝒢`. | https://github.com/leanprover-community/mathlib4 | b9f14353520df73472ae3825fb53f86559a01319 |
pushforwardToOfIso_app {X Y : TopCat.{w}} (H₁ : X ≅ Y) {ℱ : Y.Presheaf C} {𝒢 : X.Presheaf C}
(H₂ : ℱ ⟶ H₁.hom _* 𝒢) (U : (Opens X)ᵒᵖ) :
(pushforwardToOfIso H₁ H₂).app U =
H₂.app (op ((Opens.map H₁.inv).obj (unop U))) ≫
𝒢.map (eqToHom (by simp [Opens.map, Set.preimage_preimage])) | by
simp [pushforwardToOfIso, Equivalence.toAdjunction, Adjunction.homEquiv_counit] | theorem | TopCat.Presheaf.pushforwardToOfIso_app | Topology.Sheaves | Mathlib/Topology/Sheaves/Presheaf.lean | [] | [
"Set.preimage_preimage"
] | https://github.com/leanprover-community/mathlib4 | b9f14353520df73472ae3825fb53f86559a01319 | |
pullback {X Y : TopCat.{v}} (f : X ⟶ Y) : Y.Presheaf C ⥤ X.Presheaf C | (Opens.map f).op.lan | def | TopCat.Presheaf.pullback | Topology.Sheaves | Mathlib/Topology/Sheaves/Presheaf.lean | [] | [] | Pullback a presheaf on `Y` along a continuous map `f : X ⟶ Y`, obtaining a presheaf
on `X`. | https://github.com/leanprover-community/mathlib4 | b9f14353520df73472ae3825fb53f86559a01319 |
pullbackPushforwardAdjunction {X Y : TopCat.{v}} (f : X ⟶ Y) :
pullback C f ⊣ pushforward C f | Functor.lanAdjunction _ _
@[deprecated (since := "2026-03-03")]
alias pushforwardPullbackAdjunction := pullbackPushforwardAdjunction | def | TopCat.Presheaf.pullbackPushforwardAdjunction | Topology.Sheaves | Mathlib/Topology/Sheaves/Presheaf.lean | [] | [] | The pullback and pushforward along a continuous map are adjoint to each other. | https://github.com/leanprover-community/mathlib4 | b9f14353520df73472ae3825fb53f86559a01319 |
pullbackHomIsoPushforwardInv {X Y : TopCat.{v}} (H : X ≅ Y) :
pullback C H.hom ≅ pushforward C H.inv | Adjunction.leftAdjointUniq (pullbackPushforwardAdjunction C H.hom)
(presheafEquivOfIso C H.symm).toAdjunction | def | TopCat.Presheaf.pullbackHomIsoPushforwardInv | Topology.Sheaves | Mathlib/Topology/Sheaves/Presheaf.lean | [] | [] | Pulling back along a homeomorphism is the same as pushing forward along its inverse. | https://github.com/leanprover-community/mathlib4 | b9f14353520df73472ae3825fb53f86559a01319 |
pullbackInvIsoPushforwardHom {X Y : TopCat.{v}} (H : X ≅ Y) :
pullback C H.inv ≅ pushforward C H.hom | Adjunction.leftAdjointUniq (pullbackPushforwardAdjunction C H.inv)
(presheafEquivOfIso C H).toAdjunction | def | TopCat.Presheaf.pullbackInvIsoPushforwardHom | Topology.Sheaves | Mathlib/Topology/Sheaves/Presheaf.lean | [] | [] | Pulling back along the inverse of a homeomorphism is the same as pushing forward along it. | https://github.com/leanprover-community/mathlib4 | b9f14353520df73472ae3825fb53f86559a01319 |
pullbackObjObjOfImageOpen {X Y : TopCat.{v}} (f : X ⟶ Y) (ℱ : Y.Presheaf C) (U : Opens X)
(H : IsOpen (f '' U)) : ((pullback C f).obj ℱ).obj (op U) ≅ ℱ.obj (op ⟨_, H⟩) | by
let x : CostructuredArrow (Opens.map f).op (op U) := CostructuredArrow.mk
(@homOfLE _ _ _ ((Opens.map f).obj ⟨_, H⟩) (Set.image_preimage.le_u_l _)).op
have hx : IsTerminal x :=
{ lift := fun s ↦ by
fapply CostructuredArrow.homMk
· change op (unop _) ⟶ op (⟨_, H⟩ : Opens _)
refin... | def | TopCat.Presheaf.pullbackObjObjOfImageOpen | Topology.Sheaves | Mathlib/Topology/Sheaves/Presheaf.lean | [] | [
"IsOpen",
"Set.image_mono",
"trans"
] | If `f '' U` is open, then `f⁻¹ℱ U ≅ ℱ (f '' U)`. | https://github.com/leanprover-community/mathlib4 | b9f14353520df73472ae3825fb53f86559a01319 |
pullbackObjObjOfImageOpen_hom_naturality {X Y : TopCat.{v}} (f : X ⟶ Y) (ℱ : Y.Presheaf C)
{U V : Opens X} (HU : IsOpen (f '' U)) (HV : IsOpen (f '' V)) (le : U ≤ V) :
((pullback C f).obj ℱ).map (homOfLE le).op ≫ (pullbackObjObjOfImageOpen f ℱ U HU).hom =
(pullbackObjObjOfImageOpen f ℱ V HV).hom ≫ ℱ.map (Is... | by
dsimp [pullbackObjObjOfImageOpen]
refine ((Opens.map f).op.isPointwiseLeftKanExtensionLeftKanExtensionUnit ℱ (op V)).hom_ext
(fun j ↦ ?_)
have eq : ((LeftExtension.mk ((Opens.map f).op.leftKanExtension ℱ)
((Opens.map f).op.leftKanExtensionUnit ℱ)).coconeAt
(op V)).ι.app j ≫ ((pullback C f).obj ... | theorem | TopCat.Presheaf.pullbackObjObjOfImageOpen_hom_naturality | Topology.Sheaves | Mathlib/Topology/Sheaves/Presheaf.lean | [] | [
"IsOpen",
"IsOpenMap.functorMap"
] | If `U ⊆ V` and `f '' U`, `f '' V` are open, then the isomorphisms `f⁻¹ℱ U ≅ ℱ (f '' U)`,
`f⁻¹ℱ V ≅ ℱ (f '' V)` given by `pullbackObjObjOfImageOpen` are compatible with the restriction
maps. | https://github.com/leanprover-community/mathlib4 | b9f14353520df73472ae3825fb53f86559a01319 |
pullbackObjIso {X Y : TopCat.{v}} {f : X ⟶ Y} (hf : IsOpenMap f) (ℱ : Y.Presheaf C) :
(pullback C f).obj ℱ ≅ hf.functor.op ⋙ ℱ | NatIso.ofComponents
(fun U ↦ pullbackObjObjOfImageOpen f ℱ U.1 (hf (unop U).1 (unop U).2))
(fun {U V} i ↦ (pullbackObjObjOfImageOpen_hom_naturality f ℱ (hf (unop V).1 (unop V).2)
(hf (unop U).1 (unop U).2) (leOfHom i.unop))) | def | TopCat.IsOpenMap.pullbackObjIso | Topology.Sheaves | Mathlib/Topology/Sheaves/Presheaf.lean | [] | [
"IsOpenMap"
] | If `f : X ⟶ Y` is an open map and `ℱ` is a presheaf on `Y`, then the pullback of `ℱ` by `f` is
isomorphic to the composition of `ℱ` and of the functor `(Open X)ᵒᵖ ⥤ (Open Y)ᵒᵖ` induced by `f`. | https://github.com/leanprover-community/mathlib4 | b9f14353520df73472ae3825fb53f86559a01319 |
pullbackObjIso_hom_naturality {X Y : TopCat.{v}} {f : X ⟶ Y} (hf : IsOpenMap f)
{ℱ 𝒢 : Y.Presheaf C} (u : ℱ ⟶ 𝒢) :
(pullback C f).map u ≫ (hf.pullbackObjIso 𝒢).hom =
(hf.pullbackObjIso ℱ).hom ≫ Functor.whiskerLeft hf.functor.op u | by
ext U
dsimp [pullbackObjIso, pullbackObjObjOfImageOpen]
refine ((Opens.map f).op.isPointwiseLeftKanExtensionLeftKanExtensionUnit ℱ (op U)).hom_ext
(fun j ↦ ?_)
have eq : ((LeftExtension.mk ((Opens.map f).op.leftKanExtension ℱ)
((Opens.map f).op.leftKanExtensionUnit ℱ)).coconeAt (op U)).ι.app j
... | lemma | TopCat.IsOpenMap.pullbackObjIso_hom_naturality | Topology.Sheaves | Mathlib/Topology/Sheaves/Presheaf.lean | [] | [
"IsOpenMap"
] | If `f : X ⟶ Y` is an open map, this expresses the naturality of the isomorphism
`IsOpenMap.pullbackObjIso` between the pullback by `f` of a presheaf and the composition
of that presheaf and of the functor `(Open X)ᵒᵖ ⥤ (Open Y)ᵒᵖ` induced by `f`. | https://github.com/leanprover-community/mathlib4 | b9f14353520df73472ae3825fb53f86559a01319 |
pullbackIso {X Y : TopCat.{v}} {f : X ⟶ Y} (hf : IsOpenMap f) :
pullback C f ≅ (Functor.whiskeringLeft _ _ _).obj hf.functor.op | NatIso.ofComponents hf.pullbackObjIso hf.pullbackObjIso_hom_naturality | def | TopCat.IsOpenMap.pullbackIso | Topology.Sheaves | Mathlib/Topology/Sheaves/Presheaf.lean | [] | [
"IsOpenMap"
] | If `f : X ⟶ Y`, this is the isomorphism between the pullback functor by `f` and the
"naive" pullback given by composing presheaves with the functor `(Open X)ᵒᵖ ⥤ (Open Y)ᵒᵖ`
induced by `f`. | https://github.com/leanprover-community/mathlib4 | b9f14353520df73472ae3825fb53f86559a01319 |
presheafToTypes (T : X → Type*) : X.Presheaf (Type _) | where
obj U := ∀ x : U.unop, T x
map {_ V} i := ↾fun (g) (x : V.unop) => g (i.unop x) | def | TopCat.presheafToTypes | Topology.Sheaves | Mathlib/Topology/Sheaves/PresheafOfFunctions.lean | [] | [] | The presheaf of dependently typed functions on `X`, with fibres given by a type family `T`.
There is no requirement that the functions are continuous, here. | https://github.com/leanprover-community/mathlib4 | b9f14353520df73472ae3825fb53f86559a01319 |
presheafToTypes_obj {T : X → Type*} {U : (Opens X)ᵒᵖ} :
(presheafToTypes X T).obj U = ∀ x : U.unop, T x | rfl | theorem | TopCat.presheafToTypes_obj | Topology.Sheaves | Mathlib/Topology/Sheaves/PresheafOfFunctions.lean | [] | [] | https://github.com/leanprover-community/mathlib4 | b9f14353520df73472ae3825fb53f86559a01319 | |
presheafToTypes_map {T : X → Type*} {U V : (Opens X)ᵒᵖ} {i : U ⟶ V} {f} :
dsimp% (presheafToTypes X T).map i f = fun x => f (i.unop x) | rfl | theorem | TopCat.presheafToTypes_map | Topology.Sheaves | Mathlib/Topology/Sheaves/PresheafOfFunctions.lean | [] | [] | https://github.com/leanprover-community/mathlib4 | b9f14353520df73472ae3825fb53f86559a01319 | |
presheafToType (T : Type*) : X.Presheaf (Type _) | where
obj U := U.unop → T
map {_ _} i := ↾fun g ↦ g ∘ i.unop | def | TopCat.presheafToType | Topology.Sheaves | Mathlib/Topology/Sheaves/PresheafOfFunctions.lean | [] | [] | The presheaf of functions on `X` with values in a type `T`.
There is no requirement that the functions are continuous, here. | https://github.com/leanprover-community/mathlib4 | b9f14353520df73472ae3825fb53f86559a01319 |
presheafToType_obj {T : Type*} {U : (Opens X)ᵒᵖ} :
(presheafToType X T).obj U = (U.unop → T) | rfl | theorem | TopCat.presheafToType_obj | Topology.Sheaves | Mathlib/Topology/Sheaves/PresheafOfFunctions.lean | [] | [] | https://github.com/leanprover-community/mathlib4 | b9f14353520df73472ae3825fb53f86559a01319 | |
presheafToType_map {T : Type*} {U V : (Opens X)ᵒᵖ} {i : U ⟶ V} {f} :
dsimp% (presheafToType X T).map i f = f ∘ i.unop | rfl | theorem | TopCat.presheafToType_map | Topology.Sheaves | Mathlib/Topology/Sheaves/PresheafOfFunctions.lean | [] | [] | https://github.com/leanprover-community/mathlib4 | b9f14353520df73472ae3825fb53f86559a01319 | |
presheafToTop (T : TopCat) : X.Presheaf (Type _) | (Opens.toTopCat X).op ⋙ yoneda.obj T | def | TopCat.presheafToTop | Topology.Sheaves | Mathlib/Topology/Sheaves/PresheafOfFunctions.lean | [] | [
"TopCat"
] | The presheaf of continuous functions on `X` with values in fixed target topological space
`T`. | https://github.com/leanprover-community/mathlib4 | b9f14353520df73472ae3825fb53f86559a01319 |
presheafToTop_obj (T : TopCat) (U : (Opens X)ᵒᵖ) :
(presheafToTop X T).obj U = ((Opens.toTopCat X).obj (unop U) ⟶ T) | rfl | theorem | TopCat.presheafToTop_obj | Topology.Sheaves | Mathlib/Topology/Sheaves/PresheafOfFunctions.lean | [] | [
"TopCat"
] | https://github.com/leanprover-community/mathlib4 | b9f14353520df73472ae3825fb53f86559a01319 | |
isSheaf_of_isTerminal_of_indiscrete {X : TopCat.{w}} (hind : X.str = ⊤) (F : Presheaf C X)
(it : IsTerminal <| F.obj <| op ⊥) : F.IsSheaf | fun c U s hs => by
have : IndiscreteTopology X := ⟨hind⟩
obtain rfl | hne := eq_or_ne U ⊥
· intro _ _
rw [@existsUnique_iff_exists _ ⟨fun _ _ => _⟩]
· refine ⟨it.from _, fun U hU hs => IsTerminal.hom_ext ?_ _ _⟩
rwa [le_bot_iff.1 hU.le]
· apply it.hom_ext
· convert! Presieve.isSheafFor_top (F ... | theorem | TopCat.Presheaf.isSheaf_of_isTerminal_of_indiscrete | Topology.Sheaves | Mathlib/Topology/Sheaves/PUnit.lean | [] | [
"IndiscreteTopology",
"eq_or_ne",
"existsUnique_iff_exists",
"isEmpty_or_nonempty"
] | https://github.com/leanprover-community/mathlib4 | b9f14353520df73472ae3825fb53f86559a01319 | |
isSheaf_iff_isTerminal_of_indiscrete {X : TopCat.{w}} (hind : X.str = ⊤)
(F : Presheaf C X) : F.IsSheaf ↔ Nonempty (IsTerminal <| F.obj <| op ⊥) | ⟨fun h => ⟨Sheaf.isTerminalOfEmpty ⟨F, h⟩⟩, fun ⟨it⟩ =>
isSheaf_of_isTerminal_of_indiscrete hind F it⟩ | theorem | TopCat.Presheaf.isSheaf_iff_isTerminal_of_indiscrete | Topology.Sheaves | Mathlib/Topology/Sheaves/PUnit.lean | [] | [] | https://github.com/leanprover-community/mathlib4 | b9f14353520df73472ae3825fb53f86559a01319 | |
isSheaf_on_punit_of_isTerminal (F : Presheaf C (TopCat.of PUnit))
(it : IsTerminal <| F.obj <| op ⊥) : F.IsSheaf | isSheaf_of_isTerminal_of_indiscrete (@Subsingleton.elim (TopologicalSpace PUnit) _ _ _) F it | theorem | TopCat.Presheaf.isSheaf_on_punit_of_isTerminal | Topology.Sheaves | Mathlib/Topology/Sheaves/PUnit.lean | [] | [
"TopologicalSpace"
] | https://github.com/leanprover-community/mathlib4 | b9f14353520df73472ae3825fb53f86559a01319 | |
isSheaf_on_punit_iff_isTerminal (F : Presheaf C (TopCat.of PUnit)) :
F.IsSheaf ↔ Nonempty (IsTerminal <| F.obj <| op ⊥) | ⟨fun h => ⟨Sheaf.isTerminalOfEmpty ⟨F, h⟩⟩, fun ⟨it⟩ => isSheaf_on_punit_of_isTerminal F it⟩ | theorem | TopCat.Presheaf.isSheaf_on_punit_iff_isTerminal | Topology.Sheaves | Mathlib/Topology/Sheaves/PUnit.lean | [] | [] | https://github.com/leanprover-community/mathlib4 | b9f14353520df73472ae3825fb53f86559a01319 | |
IsSheaf (F : Presheaf.{w, v, u} C X) : Prop | Presheaf.IsSheaf (Opens.grothendieckTopology X) F | def | TopCat.Presheaf.IsSheaf | Topology.Sheaves | Mathlib/Topology/Sheaves/Sheaf.lean | [] | [
"Opens.grothendieckTopology"
] | The sheaf condition has several different equivalent formulations.
The official definition chosen here is in terms of Grothendieck topologies so that the results on
sites could be applied here easily, and this condition does not require additional constraints on
the value category.
The equivalent formulations of the sh... | https://github.com/leanprover-community/mathlib4 | b9f14353520df73472ae3825fb53f86559a01319 |
isSheaf_unit (F : Presheaf (CategoryTheory.Discrete Unit) X) : F.IsSheaf | fun x U S _ x _ => ⟨eqToHom (Subsingleton.elim _ _), by cat_disch, fun _ => by cat_disch⟩ | theorem | TopCat.Presheaf.isSheaf_unit | Topology.Sheaves | Mathlib/Topology/Sheaves/Sheaf.lean | [] | [
"CategoryTheory.Discrete"
] | The presheaf valued in `Unit` over any topological space is a sheaf. | https://github.com/leanprover-community/mathlib4 | b9f14353520df73472ae3825fb53f86559a01319 |
isSheaf_iso_iff {F G : Presheaf C X} (α : F ≅ G) : F.IsSheaf ↔ G.IsSheaf | Presheaf.isSheaf_of_iso_iff α | theorem | TopCat.Presheaf.isSheaf_iso_iff | Topology.Sheaves | Mathlib/Topology/Sheaves/Sheaf.lean | [] | [] | https://github.com/leanprover-community/mathlib4 | b9f14353520df73472ae3825fb53f86559a01319 | |
isSheaf_of_iso {F G : Presheaf C X} (α : F ≅ G) (h : F.IsSheaf) : G.IsSheaf | (isSheaf_iso_iff α).1 h | theorem | TopCat.Presheaf.isSheaf_of_iso | Topology.Sheaves | Mathlib/Topology/Sheaves/Sheaf.lean | [] | [] | Transfer the sheaf condition across an isomorphism of presheaves. | https://github.com/leanprover-community/mathlib4 | b9f14353520df73472ae3825fb53f86559a01319 |
Sheaf : Type max u v w | Sheaf (Opens.grothendieckTopology X) C
deriving Category | def | TopCat.Sheaf | Topology.Sheaves | Mathlib/Topology/Sheaves/Sheaf.lean | [] | [
"Opens.grothendieckTopology"
] | A `TopCat.Sheaf C X` is a presheaf of objects from `C` over a (bundled) topological space `X`,
satisfying the sheaf condition. | https://github.com/leanprover-community/mathlib4 | b9f14353520df73472ae3825fb53f86559a01319 |
Sheaf.presheaf (F : X.Sheaf C) : TopCat.Presheaf C X | F.1 | abbrev | TopCat.Sheaf.presheaf | Topology.Sheaves | Mathlib/Topology/Sheaves/Sheaf.lean | [] | [
"TopCat.Presheaf"
] | The underlying presheaf of a sheaf | https://github.com/leanprover-community/mathlib4 | b9f14353520df73472ae3825fb53f86559a01319 |
sheafInhabited : Inhabited (Sheaf (CategoryTheory.Discrete PUnit) X) | ⟨⟨Functor.star _, Presheaf.isSheaf_unit _⟩⟩ | instance | TopCat.sheafInhabited | Topology.Sheaves | Mathlib/Topology/Sheaves/Sheaf.lean | [] | [
"CategoryTheory.Discrete"
] | https://github.com/leanprover-community/mathlib4 | b9f14353520df73472ae3825fb53f86559a01319 | |
forget : TopCat.Sheaf C X ⥤ TopCat.Presheaf C X | sheafToPresheaf _ _ | def | TopCat.Sheaf.forget | Topology.Sheaves | Mathlib/Topology/Sheaves/Sheaf.lean | [] | [
"TopCat.Presheaf",
"TopCat.Sheaf"
] | The forgetful functor from sheaves to presheaves. | https://github.com/leanprover-community/mathlib4 | b9f14353520df73472ae3825fb53f86559a01319 |
forget_full : (forget C X).Full | where
map_surjective f := ⟨ObjectProperty.homMk f, rfl⟩ | instance | TopCat.Sheaf.forget_full | Topology.Sheaves | Mathlib/Topology/Sheaves/Sheaf.lean | [] | [] | https://github.com/leanprover-community/mathlib4 | b9f14353520df73472ae3825fb53f86559a01319 | |
forgetFaithful : (forget C X).Faithful | where
map_injective := Sheaf.hom_ext | instance | TopCat.Sheaf.forgetFaithful | Topology.Sheaves | Mathlib/Topology/Sheaves/Sheaf.lean | [] | [] | https://github.com/leanprover-community/mathlib4 | b9f14353520df73472ae3825fb53f86559a01319 | |
id_app (F : Sheaf C X) (t) : (𝟙 F : F ⟶ F).1.app t = 𝟙 _ | rfl | theorem | TopCat.Sheaf.id_app | Topology.Sheaves | Mathlib/Topology/Sheaves/Sheaf.lean | [] | [] | https://github.com/leanprover-community/mathlib4 | b9f14353520df73472ae3825fb53f86559a01319 | |
comp_app {F G H : Sheaf C X} (f : F ⟶ G) (g : G ⟶ H) (t) :
(f ≫ g).1.app t = f.1.app t ≫ g.1.app t | rfl | theorem | TopCat.Sheaf.comp_app | Topology.Sheaves | Mathlib/Topology/Sheaves/Sheaf.lean | [] | [] | https://github.com/leanprover-community/mathlib4 | b9f14353520df73472ae3825fb53f86559a01319 | |
Presheaf.IsSheaf.section_ext {X : TopCat.{u}}
{A : Type*} [Category.{u} A] {FC : A → A → Type*} {CC : A → Type u}
[∀ X Y : A, FunLike (FC X Y) (CC X) (CC Y)] [ConcreteCategory.{u} A FC]
[HasLimits A] [PreservesLimits (forget A)] [(forget A).ReflectsIsomorphisms]
{F : TopCat.Presheaf A X} (hF : TopCat.Pr... | by
have := (isSheaf_iff_isSheaf_of_type _ _).mp
((Presheaf.isSheaf_iff_isSheaf_forget (C := Opens X) (A' := A) _ F (forget _)).mp hF)
choose V hV hxV H using fun x : U.unop ↦ hst x.1 x.2
refine (this.isSheafFor (.ofArrows V fun x ↦ homOfLE (hV x)) ?_).isSeparatedFor.ext ?_
· exact fun x hx ↦ ⟨V ⟨x, hx⟩, hom... | lemma | TopCat.Presheaf.IsSheaf.section_ext | Topology.Sheaves | Mathlib/Topology/Sheaves/Sheaf.lean | [] | [
"FunLike",
"TopCat.Presheaf",
"TopCat.Presheaf.IsSheaf"
] | https://github.com/leanprover-community/mathlib4 | b9f14353520df73472ae3825fb53f86559a01319 | |
isGerm : PrelocalPredicate fun x => F.stalk x | where
pred {U} f := ∃ g : F.obj (op U), ∀ x : U, f x = F.germ U x.1 x.2 g
res := fun i _ ⟨g, p⟩ => ⟨F.map i.op g, fun x ↦ (p (i x)).trans (F.germ_res_apply i x x.2 g).symm⟩ | def | TopCat.Presheaf.Sheafify.isGerm | Topology.Sheaves | Mathlib/Topology/Sheaves/Sheafify.lean | [] | [
"trans"
] | The prelocal predicate on functions into the stalks, asserting that the function is equal to a germ. | https://github.com/leanprover-community/mathlib4 | b9f14353520df73472ae3825fb53f86559a01319 |
isLocallyGerm : LocalPredicate fun x => F.stalk x | (isGerm F).sheafify | def | TopCat.Presheaf.Sheafify.isLocallyGerm | Topology.Sheaves | Mathlib/Topology/Sheaves/Sheafify.lean | [] | [] | The local predicate on functions into the stalks,
asserting that the function is locally equal to a germ. | https://github.com/leanprover-community/mathlib4 | b9f14353520df73472ae3825fb53f86559a01319 |
sheafify : Sheaf (Type v) X | subsheafToTypes (Sheafify.isLocallyGerm F) | def | TopCat.Presheaf.sheafify | Topology.Sheaves | Mathlib/Topology/Sheaves/Sheafify.lean | [] | [] | The sheafification of a `Type`-valued presheaf, defined as the functions into the stalks which
are locally equal to germs. | https://github.com/leanprover-community/mathlib4 | b9f14353520df73472ae3825fb53f86559a01319 |
toSheafify : F ⟶ F.sheafify.1 | where
app U := ↾fun f ↦ ⟨fun x => F.germ _ x x.2 f, PrelocalPredicate.sheafifyOf
⟨f, fun x => rfl⟩⟩
naturality U U' f := by
ext x
apply Subtype.ext -- Porting note (https://github.com/leanprover-community/mathlib4/issues/11041): Added `apply`
ext ⟨u, m⟩
exact germ_res_apply F f.unop u m x | def | TopCat.Presheaf.toSheafify | Topology.Sheaves | Mathlib/Topology/Sheaves/Sheafify.lean | [] | [] | The morphism from a presheaf to its sheafification,
sending each section to its germs.
(This forms the unit of the adjunction.) | https://github.com/leanprover-community/mathlib4 | b9f14353520df73472ae3825fb53f86559a01319 |
stalkToFiber (x : X) : F.sheafify.presheaf.stalk x ⟶ F.stalk x | TopCat.stalkToFiber (Sheafify.isLocallyGerm F) x | def | TopCat.Presheaf.stalkToFiber | Topology.Sheaves | Mathlib/Topology/Sheaves/Sheafify.lean | [] | [
"TopCat.stalkToFiber"
] | The natural morphism from the stalk of the sheafification to the original stalk.
In `sheafifyStalkIso` we show this is an isomorphism. | https://github.com/leanprover-community/mathlib4 | b9f14353520df73472ae3825fb53f86559a01319 |
stalkToFiber_surjective (x : X) : Function.Surjective (F.stalkToFiber x) | by
apply TopCat.stalkToFiber_surjective
intro t
obtain ⟨U, m, s, rfl⟩ := F.exists_germ_eq t
use ⟨U, m⟩
fconstructor
· exact fun y => F.germ _ _ y.2 s
· exact ⟨PrelocalPredicate.sheafifyOf ⟨s, fun _ => rfl⟩, rfl⟩ | theorem | TopCat.Presheaf.stalkToFiber_surjective | Topology.Sheaves | Mathlib/Topology/Sheaves/Sheafify.lean | [] | [
"TopCat.stalkToFiber_surjective"
] | https://github.com/leanprover-community/mathlib4 | b9f14353520df73472ae3825fb53f86559a01319 | |
stalkToFiber_injective (x : X) : Function.Injective (F.stalkToFiber x) | by
apply TopCat.stalkToFiber_injective
intro U V fU hU fV hV e
rcases hU ⟨x, U.2⟩ with ⟨U', mU, iU, gU, wU⟩
rcases hV ⟨x, V.2⟩ with ⟨V', mV, iV, gV, wV⟩
have wUx := wU ⟨x, mU⟩
dsimp at wUx; rw [wUx] at e; clear wUx
have wVx := wV ⟨x, mV⟩
dsimp at wVx; rw [wVx] at e; clear wVx
rcases F.germ_eq x mU mV ... | theorem | TopCat.Presheaf.stalkToFiber_injective | Topology.Sheaves | Mathlib/Topology/Sheaves/Sheafify.lean | [] | [
"CategoryTheory.types_comp_apply",
"TopCat.stalkToFiber_injective",
"trans"
] | https://github.com/leanprover-community/mathlib4 | b9f14353520df73472ae3825fb53f86559a01319 | |
sheafifyStalkIso (x : X) : F.sheafify.presheaf.stalk x ≅ F.stalk x | (Equiv.ofBijective _ ⟨stalkToFiber_injective _ _, stalkToFiber_surjective _ _⟩).toIso | def | TopCat.Presheaf.sheafifyStalkIso | Topology.Sheaves | Mathlib/Topology/Sheaves/Sheafify.lean | [] | [
"Equiv.ofBijective"
] | The isomorphism between a stalk of the sheafification and the original stalk. | https://github.com/leanprover-community/mathlib4 | b9f14353520df73472ae3825fb53f86559a01319 |
stalkFunctor_map_unit_toSheafify_isIso : IsIso ((Presheaf.stalkFunctor C p₀).map
(CategoryTheory.toSheafify (Opens.grothendieckTopology X) 𝓕)) | by
classical
exact Adjunction.isIso_map_unit_of_isLeftAdjoint_comp (sheafificationAdjunction _ C)
(skyscraperSheafForgetAdjunction p₀) | theorem | TopCat.Presheaf.stalkFunctor_map_unit_toSheafify_isIso | Topology.Sheaves | Mathlib/Topology/Sheaves/Sheafify.lean | [] | [
"CategoryTheory.toSheafify",
"Opens.grothendieckTopology",
"skyscraperSheafForgetAdjunction"
] | Given a presheaf `𝓕`, the induced map on stalks of `CategoryTheory.toSheafify`, `𝓕ₓ ⟶ 𝓕⁺ₓ`,
is an isomorphism | 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.