File: Mathlib/Topology/Sheaves/PresheafOfFunctions.lean

full_name: TopCat.presheafToTypes
code: /-- 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.
-/
def presheafToTypes (T : X → Type v) : X.Presheaf (Type v) 
goal: TopCat.Presheaf (Type v) X

full_name: TopCat.presheafToTypes_obj
code: @[simp]
theorem presheafToTypes_obj {T : X → Type v} {U : (Opens X)ᵒᵖ} :
    (presheafToTypes X T).obj U = ∀ x : U.unop, T x 
goal: (X.presheafToTypes T).obj U = ((x : ↥(Opposite.unop U)) → T ↑x)

full_name: TopCat.presheafToTypes_map
code: @[simp]
theorem presheafToTypes_map {T : X → Type v} {U V : (Opens X)ᵒᵖ} {i : U ⟶ V} {f} :
    (presheafToTypes X T).map i f = fun x => f (i.unop x) 
goal: (X.presheafToTypes T).map i f = fun x => f ((fun x => ⟨↑x, ⋯⟩) x)

full_name: TopCat.presheafToType
code: /-- The presheaf of functions on `X` with values in a type `T`.
There is no requirement that the functions are continuous, here.
-/
def presheafToType (T : Type v) : X.Presheaf (Type v) 
goal: TopCat.Presheaf (Type v) X

full_name: TopCat.presheafToType_obj
code: @[simp]
theorem presheafToType_obj {T : Type v} {U : (Opens X)ᵒᵖ} :
    (presheafToType X T).obj U = (U.unop → T) 
goal: (X.presheafToType T).obj U = (↥(Opposite.unop U) → T)

full_name: TopCat.presheafToType_map
code: @[simp]
theorem presheafToType_map {T : Type v} {U V : (Opens X)ᵒᵖ} {i : U ⟶ V} {f} :
    (presheafToType X T).map i f = f ∘ i.unop 
goal: (X.presheafToType T).map i f = f ∘ fun x => ⟨↑x, ⋯⟩

full_name: TopCat.presheafToTop
code: /-- The presheaf of continuous functions on `X` with values in fixed target topological space
`T`. -/
def presheafToTop (T : TopCat.{v}) : X.Presheaf (Type v) 
goal: TopCat.Presheaf (Type v) X

full_name: TopCat.presheafToTop_obj
code: @[simp]
theorem presheafToTop_obj (T : TopCat.{v}) (U : (Opens X)ᵒᵖ) :
    (presheafToTop X T).obj U = ((Opens.toTopCat X).obj (unop U) ⟶ T) 
goal: (X.presheafToTop T).obj U = ((TopologicalSpace.Opens.toTopCat X).obj (Opposite.unop U) ⟶ T)

full_name: TopCat.continuousFunctions
code: /-- The (bundled) commutative ring of continuous functions from a topological space
to a topological commutative ring, with pointwise multiplication. -/
def continuousFunctions (X : TopCat.{v}ᵒᵖ) (R : TopCommRingCat.{v}) : CommRingCat.{v} 
goal: CommRingCat

full_name: TopCat.continuousFunctions.pullback
code: /-- Pulling back functions into a topological ring along a continuous map is a ring homomorphism. -/
def pullback {X Y : TopCatᵒᵖ} (f : X ⟶ Y) (R : TopCommRingCat) :
    continuousFunctions X R ⟶ continuousFunctions Y R 
goal: TopCat.continuousFunctions X R ⟶ TopCat.continuousFunctions Y R

full_name: TopCat.continuousFunctions.map
code: /-- 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). -/
def map (X : TopCat.{u}ᵒᵖ) {R S : TopCommRingCat.{u}} (φ : R ⟶ S) :
    continuousFunctions X R ⟶ continuousFunctions X S 
goal: TopCat.continuousFunctions X R ⟶ TopCat.continuousFunctions X S

full_name: TopCat.commRingYoneda
code: /-- 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`. -/
def commRingYoneda : TopCommRingCat.{u} ⥤ TopCat.{u}ᵒᵖ ⥤ CommRingCat.{u} 
goal: TopCommRingCat ⥤ TopCatᵒᵖ ⥤ CommRingCat

full_name: TopCat.presheafToTopCommRing
code: /-- 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 (TopCommRing.of ℂ)
```
(this requires `import Topology.Instances.Complex`).
-/
def presheafToTopCommRing (T : TopCommRingCat.{v}) : X.Presheaf CommRingCat.{v} 
goal: TopCat.Presheaf CommRingCat X