File: Mathlib/Geometry/RingedSpace/LocallyRingedSpace.lean

full_name: AlgebraicGeometry.LocallyRingedSpace
code: /-- A `LocallyRingedSpace` is a topological space equipped with a sheaf of commutative rings
such that all the stalks are local rings.

A morphism of locally ringed spaces is a morphism of ringed spaces
such that the morphisms induced on stalks are local ring homomorphisms. -/
structure LocallyRingedSpace extends SheafedSpace CommRingCat.{u} where
  /-- Stalks of a locally ringed space are local rings. -/
  localRing : ∀ x, LocalRing (presheaf.stalk x)
goal: Type (u + 1)

full_name: AlgebraicGeometry.LocallyRingedSpace.localRing
code: /-- A `LocallyRingedSpace` is a topological space equipped with a sheaf of commutative rings
such that all the stalks are local rings.

A morphism of locally ringed spaces is a morphism of ringed spaces
such that the morphisms induced on stalks are local ring homomorphisms. -/
structure LocallyRingedSpace extends SheafedSpace CommRingCat.{u} where
  /-- Stalks of a locally ringed space are local rings. -/
  localRing : ∀ x, LocalRing (presheaf.stalk x)
goal: LocalRing ↑(self.presheaf.stalk x)

full_name: AlgebraicGeometry.LocallyRingedSpace.toRingedSpace
code: /-- An alias for `to_SheafedSpace`, where the result type is a `RingedSpace`.
This allows us to use dot-notation for the `RingedSpace` namespace.
 -/
def toRingedSpace : RingedSpace 
goal: AlgebraicGeometry.RingedSpace

full_name: AlgebraicGeometry.LocallyRingedSpace.toTopCat
code: /-- The underlying topological space of a locally ringed space. -/
def toTopCat : TopCat 
goal: TopCat

full_name: AlgebraicGeometry.LocallyRingedSpace.instCoeSortType
code: instance : CoeSort LocallyRingedSpace (Type u) 
goal: CoeSort AlgebraicGeometry.LocallyRingedSpace (Type u)

full_name: AlgebraicGeometry.LocallyRingedSpace.instLocalRingαCommRingStalkCommRingCatPresheaf
code: instance (x : X) : LocalRing (X.presheaf.stalk x) 
goal: LocalRing ↑(X.presheaf.stalk x)

full_name: AlgebraicGeometry.LocallyRingedSpace.𝒪
code: /-- The structure sheaf of a locally ringed space. -/
def 𝒪 : Sheaf CommRingCat X.toTopCat 
goal: TopCat.Sheaf CommRingCat X.toTopCat

full_name: AlgebraicGeometry.LocallyRingedSpace.Hom
code: /-- A morphism of locally ringed spaces is a morphism of ringed spaces
 such that the morphisms induced on stalks are local ring homomorphisms. -/
@[ext]
structure Hom (X Y : LocallyRingedSpace.{u}) : Type _ where
  /-- the underlying morphism between ringed spaces -/
  val : X.toSheafedSpace ⟶ Y.toSheafedSpace
  /-- the underlying morphism induces a local ring homomorphism on stalks -/
  prop : ∀ x, IsLocalRingHom (val.stalkMap x)
goal: Type u

full_name: AlgebraicGeometry.LocallyRingedSpace.Hom.prop
code: /-- A morphism of locally ringed spaces is a morphism of ringed spaces
 such that the morphisms induced on stalks are local ring homomorphisms. -/
@[ext]
structure Hom (X Y : LocallyRingedSpace.{u}) : Type _ where
  /-- the underlying morphism between ringed spaces -/
  val : X.toSheafedSpace ⟶ Y.toSheafedSpace
  /-- the underlying morphism induces a local ring homomorphism on stalks -/
  prop : ∀ x, IsLocalRingHom (val.stalkMap x)
goal: IsLocalRingHom (AlgebraicGeometry.PresheafedSpace.Hom.stalkMap self.val x)

full_name: AlgebraicGeometry.LocallyRingedSpace.Hom.val
code: /-- A morphism of locally ringed spaces is a morphism of ringed spaces
 such that the morphisms induced on stalks are local ring homomorphisms. -/
@[ext]
structure Hom (X Y : LocallyRingedSpace.{u}) : Type _ where
  /-- the underlying morphism between ringed spaces -/
  val : X.toSheafedSpace ⟶ Y.toSheafedSpace
  /-- the underlying morphism induces a local ring homomorphism on stalks -/
  prop : ∀ x, IsLocalRingHom (val.stalkMap x)
goal: X.toSheafedSpace ⟶ Y.toSheafedSpace

full_name: AlgebraicGeometry.LocallyRingedSpace.instQuiver
code: instance : Quiver LocallyRingedSpace 
goal: Quiver AlgebraicGeometry.LocallyRingedSpace

full_name: AlgebraicGeometry.LocallyRingedSpace.Hom.ext'
code: @[ext] lemma Hom.ext' (X Y : LocallyRingedSpace.{u}) {f g : X ⟶ Y} (h : f.val = g.val) : f = g 
goal: f = g

full_name: AlgebraicGeometry.LocallyRingedSpace.Hom.stalkMap
code: /-- A morphism of locally ringed spaces `f : X ⟶ Y` induces
a local ring homomorphism from `Y.stalk (f x)` to `X.stalk x` for any `x : X`.
-/
noncomputable def Hom.stalkMap {X Y : LocallyRingedSpace.{u}} (f : Hom X Y) (x : X) :
    Y.presheaf.stalk (f.1.1 x) ⟶ X.presheaf.stalk x 
goal: Y.presheaf.stalk (f.val.base x) ⟶ X.presheaf.stalk x

full_name: AlgebraicGeometry.LocallyRingedSpace.instIsLocalRingHomαCommRingStalkCommRingCatPresheafCoeHomTopCatCarrierTopologicalSpaceBaseValStalkMap
code: instance {X Y : LocallyRingedSpace.{u}} (f : X ⟶ Y) (x : X) : IsLocalRingHom (f.stalkMap x) 
goal: IsLocalRingHom (AlgebraicGeometry.LocallyRingedSpace.Hom.stalkMap f x)

full_name: AlgebraicGeometry.LocallyRingedSpace.instIsLocalRingHomαCommRingStalkCommRingCatPresheafCoeHomTopCatCarrierTopologicalSpaceBaseValStalkMap_1
code: instance {X Y : LocallyRingedSpace.{u}} (f : X ⟶ Y) (x : X) :
    IsLocalRingHom (f.val.stalkMap x) 
goal: IsLocalRingHom (AlgebraicGeometry.PresheafedSpace.Hom.stalkMap f.val x)

full_name: AlgebraicGeometry.LocallyRingedSpace.id_val
code: /-- The identity morphism on a locally ringed space. -/
@[simps]
def id (X : LocallyRingedSpace.{u}) : Hom X X 
goal: X.id.val = 𝟙 X.toSheafedSpace

full_name: AlgebraicGeometry.LocallyRingedSpace.id
code: /-- The identity morphism on a locally ringed space. -/
@[simps]
def id (X : LocallyRingedSpace.{u}) : Hom X X 
goal: X.Hom X

full_name: AlgebraicGeometry.LocallyRingedSpace.instInhabitedHom
code: instance (X : LocallyRingedSpace.{u}) : Inhabited (Hom X X) 
goal: Inhabited (X.Hom X)

full_name: AlgebraicGeometry.LocallyRingedSpace.comp
code: /-- Composition of morphisms of locally ringed spaces. -/
def comp {X Y Z : LocallyRingedSpace.{u}} (f : Hom X Y) (g : Hom Y Z) : Hom X Z 
goal: X.Hom Z

full_name: AlgebraicGeometry.LocallyRingedSpace.instCategory
code: /-- The category of locally ringed spaces. -/
instance : Category LocallyRingedSpace.{u} 
goal: CategoryTheory.Category.{u, u + 1} AlgebraicGeometry.LocallyRingedSpace

full_name: AlgebraicGeometry.LocallyRingedSpace.forgetToSheafedSpace
code: /-- The forgetful functor from `LocallyRingedSpace` to `SheafedSpace CommRing`. -/
@[simps]
def forgetToSheafedSpace : LocallyRingedSpace.{u} ⥤ SheafedSpace CommRingCat.{u} 
goal: AlgebraicGeometry.LocallyRingedSpace ⥤ AlgebraicGeometry.SheafedSpace CommRingCat

full_name: AlgebraicGeometry.LocallyRingedSpace.forgetToSheafedSpace_map
code: /-- The forgetful functor from `LocallyRingedSpace` to `SheafedSpace CommRing`. -/
@[simps]
def forgetToSheafedSpace : LocallyRingedSpace.{u} ⥤ SheafedSpace CommRingCat.{u} 
goal: AlgebraicGeometry.LocallyRingedSpace.forgetToSheafedSpace.map f = f.val

full_name: AlgebraicGeometry.LocallyRingedSpace.forgetToSheafedSpace_obj
code: /-- The forgetful functor from `LocallyRingedSpace` to `SheafedSpace CommRing`. -/
@[simps]
def forgetToSheafedSpace : LocallyRingedSpace.{u} ⥤ SheafedSpace CommRingCat.{u} 
goal: AlgebraicGeometry.LocallyRingedSpace.forgetToSheafedSpace.obj X = X.toSheafedSpace

full_name: AlgebraicGeometry.LocallyRingedSpace.instFaithfulSheafedSpaceCommRingCatForgetToSheafedSpace
code: instance : forgetToSheafedSpace.Faithful 
goal: AlgebraicGeometry.LocallyRingedSpace.forgetToSheafedSpace.Faithful

full_name: AlgebraicGeometry.LocallyRingedSpace.forgetToTop_obj
code: /-- The forgetful functor from `LocallyRingedSpace` to `Top`. -/
@[simps!]
def forgetToTop : LocallyRingedSpace.{u} ⥤ TopCat.{u} 
goal: AlgebraicGeometry.LocallyRingedSpace.forgetToTop.obj X =
  (AlgebraicGeometry.SheafedSpace.forget CommRingCat).obj X.toSheafedSpace

full_name: AlgebraicGeometry.LocallyRingedSpace.forgetToTop
code: /-- The forgetful functor from `LocallyRingedSpace` to `Top`. -/
@[simps!]
def forgetToTop : LocallyRingedSpace.{u} ⥤ TopCat.{u} 
goal: AlgebraicGeometry.LocallyRingedSpace ⥤ TopCat

full_name: AlgebraicGeometry.LocallyRingedSpace.forgetToTop_map
code: /-- The forgetful functor from `LocallyRingedSpace` to `Top`. -/
@[simps!]
def forgetToTop : LocallyRingedSpace.{u} ⥤ TopCat.{u} 
goal: ∀ {X Y : AlgebraicGeometry.LocallyRingedSpace} (f : X ⟶ Y),
  AlgebraicGeometry.LocallyRingedSpace.forgetToTop.map f = (AlgebraicGeometry.SheafedSpace.forget CommRingCat).map f.val

full_name: AlgebraicGeometry.LocallyRingedSpace.comp_val
code: @[simp]
theorem comp_val {X Y Z : LocallyRingedSpace.{u}} (f : X ⟶ Y) (g : Y ⟶ Z) :
    (f ≫ g).val = f.val ≫ g.val 
goal: (f ≫ g).val = f.val ≫ g.val

full_name: AlgebraicGeometry.LocallyRingedSpace.id_val'
code: @[simp] theorem id_val' (X : LocallyRingedSpace.{u}) : Hom.val (𝟙 X) = 𝟙 X.toSheafedSpace 
goal: (𝟙 X).val = 𝟙 X.toSheafedSpace

full_name: AlgebraicGeometry.LocallyRingedSpace.comp_val_c
code: @[simp]
theorem comp_val_c {X Y Z : LocallyRingedSpace.{u}} (f : X ⟶ Y) (g : Y ⟶ Z) :
    (f.1 ≫ g.1).c = g.val.c ≫ (Presheaf.pushforward _ g.val.base).map f.val.c 
goal: (f.val ≫ g.val).c = g.val.c ≫ (TopCat.Presheaf.pushforward CommRingCat g.val.base).map f.val.c

full_name: AlgebraicGeometry.LocallyRingedSpace.comp_val_c_app
code: theorem comp_val_c_app {X Y Z : LocallyRingedSpace.{u}} (f : X ⟶ Y) (g : Y ⟶ Z) (U : (Opens Z)ᵒᵖ) :
    (f ≫ g).val.c.app U = g.val.c.app U ≫ f.val.c.app (op <| (Opens.map g.val.base).obj U.unop) 
goal: (f ≫ g).val.c.app U =
  g.val.c.app U ≫ f.val.c.app (Opposite.op ((TopologicalSpace.Opens.map g.val.base).obj (Opposite.unop U)))

full_name: AlgebraicGeometry.LocallyRingedSpace.homOfSheafedSpaceHomOfIsIso_val
code: /-- Given two locally ringed spaces `X` and `Y`, an isomorphism between `X` and `Y` as _sheafed_
spaces can be lifted to a morphism `X ⟶ Y` as locally ringed spaces.

See also `iso_of_SheafedSpace_iso`.
-/
@[simps]
def homOfSheafedSpaceHomOfIsIso {X Y : LocallyRingedSpace.{u}}
    (f : X.toSheafedSpace ⟶ Y.toSheafedSpace) [IsIso f] : X ⟶ Y 
goal: (AlgebraicGeometry.LocallyRingedSpace.homOfSheafedSpaceHomOfIsIso f).val = f

full_name: AlgebraicGeometry.LocallyRingedSpace.homOfSheafedSpaceHomOfIsIso
code: /-- Given two locally ringed spaces `X` and `Y`, an isomorphism between `X` and `Y` as _sheafed_
spaces can be lifted to a morphism `X ⟶ Y` as locally ringed spaces.

See also `iso_of_SheafedSpace_iso`.
-/
@[simps]
def homOfSheafedSpaceHomOfIsIso {X Y : LocallyRingedSpace.{u}}
    (f : X.toSheafedSpace ⟶ Y.toSheafedSpace) [IsIso f] : X ⟶ Y 
goal: X ⟶ Y

full_name: AlgebraicGeometry.LocallyRingedSpace.isoOfSheafedSpaceIso
code: /-- Given two locally ringed spaces `X` and `Y`, an isomorphism between `X` and `Y` as _sheafed_
spaces can be lifted to an isomorphism `X ⟶ Y` as locally ringed spaces.

This is related to the property that the functor `forget_to_SheafedSpace` reflects isomorphisms.
In fact, it is slightly stronger as we do not require `f` to come from a morphism between
_locally_ ringed spaces.
-/
def isoOfSheafedSpaceIso {X Y : LocallyRingedSpace.{u}} (f : X.toSheafedSpace ≅ Y.toSheafedSpace) :
    X ≅ Y 
goal: X ≅ Y

full_name: AlgebraicGeometry.LocallyRingedSpace.instReflectsIsomorphismsSheafedSpaceCommRingCatForgetToSheafedSpace
code: instance : forgetToSheafedSpace.ReflectsIsomorphisms 
goal: AlgebraicGeometry.LocallyRingedSpace.forgetToSheafedSpace.ReflectsIsomorphisms

full_name: AlgebraicGeometry.LocallyRingedSpace.is_sheafedSpace_iso
code: instance is_sheafedSpace_iso {X Y : LocallyRingedSpace.{u}} (f : X ⟶ Y) [IsIso f] : IsIso f.1 
goal: CategoryTheory.IsIso f.val

full_name: AlgebraicGeometry.LocallyRingedSpace.restrict
code: /-- The restriction of a locally ringed space along an open embedding.
-/
@[simps!]
def restrict {U : TopCat} (X : LocallyRingedSpace.{u}) {f : U ⟶ X.toTopCat} (h : OpenEmbedding f) :
    LocallyRingedSpace 
goal: AlgebraicGeometry.LocallyRingedSpace

full_name: AlgebraicGeometry.LocallyRingedSpace.restrict_presheaf_map
code: /-- The restriction of a locally ringed space along an open embedding.
-/
@[simps!]
def restrict {U : TopCat} (X : LocallyRingedSpace.{u}) {f : U ⟶ X.toTopCat} (h : OpenEmbedding f) :
    LocallyRingedSpace 
goal: ∀ {X_1 Y : (TopologicalSpace.Opens ↑U)ᵒᵖ} (f_1 : X_1 ⟶ Y),
  (X.restrict h).presheaf.map f_1 = X.presheaf.map (⋯.functor.map f_1.unop).op

full_name: AlgebraicGeometry.LocallyRingedSpace.restrict_presheaf_obj
code: /-- The restriction of a locally ringed space along an open embedding.
-/
@[simps!]
def restrict {U : TopCat} (X : LocallyRingedSpace.{u}) {f : U ⟶ X.toTopCat} (h : OpenEmbedding f) :
    LocallyRingedSpace 
goal: ∀ (X_1 : (TopologicalSpace.Opens ↑U)ᵒᵖ),
  (X.restrict h).presheaf.obj X_1 = X.presheaf.obj (Opposite.op (⋯.functor.obj (Opposite.unop X_1)))

full_name: AlgebraicGeometry.LocallyRingedSpace.restrict_carrier
code: /-- The restriction of a locally ringed space along an open embedding.
-/
@[simps!]
def restrict {U : TopCat} (X : LocallyRingedSpace.{u}) {f : U ⟶ X.toTopCat} (h : OpenEmbedding f) :
    LocallyRingedSpace 
goal: ↑(X.restrict h).toPresheafedSpace = U

full_name: AlgebraicGeometry.LocallyRingedSpace.ofRestrict
code: /-- The canonical map from the restriction to the subspace. -/
def ofRestrict {U : TopCat} (X : LocallyRingedSpace.{u})
    {f : U ⟶ X.toTopCat} (h : OpenEmbedding f) : X.restrict h ⟶ X 
goal: X.restrict h ⟶ X

full_name: AlgebraicGeometry.LocallyRingedSpace.restrictTopIso
code: /-- The restriction of a locally ringed space `X` to the top subspace is isomorphic to `X` itself.
-/
def restrictTopIso (X : LocallyRingedSpace.{u}) :
    X.restrict (Opens.openEmbedding ⊤) ≅ X 
goal: X.restrict ⋯ ≅ X

full_name: AlgebraicGeometry.LocallyRingedSpace.Γ
code: /-- The global sections, notated Gamma.
-/
def Γ : LocallyRingedSpace.{u}ᵒᵖ ⥤ CommRingCat.{u} 
goal: AlgebraicGeometry.LocallyRingedSpaceᵒᵖ ⥤ CommRingCat

full_name: AlgebraicGeometry.LocallyRingedSpace.Γ_def
code: theorem Γ_def : Γ = forgetToSheafedSpace.op ⋙ SheafedSpace.Γ 
goal: AlgebraicGeometry.LocallyRingedSpace.Γ =
  AlgebraicGeometry.LocallyRingedSpace.forgetToSheafedSpace.op ⋙ AlgebraicGeometry.SheafedSpace.Γ

full_name: AlgebraicGeometry.LocallyRingedSpace.Γ_obj
code: @[simp]
theorem Γ_obj (X : LocallyRingedSpace.{u}ᵒᵖ) : Γ.obj X = X.unop.presheaf.obj (op ⊤) 
goal: AlgebraicGeometry.LocallyRingedSpace.Γ.obj X = (Opposite.unop X).presheaf.obj (Opposite.op ⊤)

full_name: AlgebraicGeometry.LocallyRingedSpace.Γ_obj_op
code: theorem Γ_obj_op (X : LocallyRingedSpace.{u}) : Γ.obj (op X) = X.presheaf.obj (op ⊤) 
goal: AlgebraicGeometry.LocallyRingedSpace.Γ.obj (Opposite.op X) = X.presheaf.obj (Opposite.op ⊤)

full_name: AlgebraicGeometry.LocallyRingedSpace.Γ_map
code: @[simp]
theorem Γ_map {X Y : LocallyRingedSpace.{u}ᵒᵖ} (f : X ⟶ Y) : Γ.map f = f.unop.1.c.app (op ⊤) 
goal: AlgebraicGeometry.LocallyRingedSpace.Γ.map f = f.unop.val.c.app (Opposite.op ⊤)

full_name: AlgebraicGeometry.LocallyRingedSpace.Γ_map_op
code: theorem Γ_map_op {X Y : LocallyRingedSpace.{u}} (f : X ⟶ Y) : Γ.map f.op = f.1.c.app (op ⊤) 
goal: AlgebraicGeometry.LocallyRingedSpace.Γ.map f.op = f.val.c.app (Opposite.op ⊤)

full_name: AlgebraicGeometry.LocallyRingedSpace.empty
code: /-- The empty locally ringed space. -/
def empty : LocallyRingedSpace.{u} 
goal: AlgebraicGeometry.LocallyRingedSpace

full_name: AlgebraicGeometry.LocallyRingedSpace.instEmptyCollection
code: instance : EmptyCollection LocallyRingedSpace.{u} 
goal: EmptyCollection AlgebraicGeometry.LocallyRingedSpace

full_name: AlgebraicGeometry.LocallyRingedSpace.emptyTo
code: /-- The canonical map from the empty locally ringed space. -/
def emptyTo (X : LocallyRingedSpace) : ∅ ⟶ X 
goal: ∅ ⟶ X

full_name: AlgebraicGeometry.LocallyRingedSpace.instUniqueHomEmptyCollection
code: noncomputable
instance {X : LocallyRingedSpace} : Unique (∅ ⟶ X) 
goal: Unique (∅ ⟶ X)

full_name: AlgebraicGeometry.LocallyRingedSpace.emptyIsInitial
code: /-- The empty space is initial in `LocallyRingedSpace`. -/
noncomputable
def emptyIsInitial : Limits.IsInitial (∅ : LocallyRingedSpace.{u}) 
goal: CategoryTheory.Limits.IsInitial ∅

full_name: AlgebraicGeometry.LocallyRingedSpace.preimage_basicOpen
code: theorem preimage_basicOpen {X Y : LocallyRingedSpace.{u}} (f : X ⟶ Y) {U : Opens Y}
    (s : Y.presheaf.obj (op U)) :
    (Opens.map f.1.base).obj (Y.toRingedSpace.basicOpen s) =
      @RingedSpace.basicOpen X.toRingedSpace ((Opens.map f.1.base).obj U) (f.1.c.app _ s) 
goal: (TopologicalSpace.Opens.map f.val.base).obj (Y.toRingedSpace.basicOpen s) =
  X.toRingedSpace.basicOpen ((f.val.c.app (Opposite.op U)) s)

full_name: AlgebraicGeometry.LocallyRingedSpace.basicOpen_zero
code: theorem basicOpen_zero (X : LocallyRingedSpace.{u}) (U : Opens X.carrier) :
    X.toRingedSpace.basicOpen (0 : X.presheaf.obj <| op U) = ⊥ 
goal: X.toRingedSpace.basicOpen 0 = ⊥

full_name: AlgebraicGeometry.LocallyRingedSpace.basicOpen_eq_bot_of_isNilpotent
code: @[simp]
lemma basicOpen_eq_bot_of_isNilpotent (X : LocallyRingedSpace.{u}) (U : Opens X.carrier)
    (f : (X.presheaf.obj <| op U)) (hf : IsNilpotent f) :
    X.toRingedSpace.basicOpen f = ⊥ 
goal: X.toRingedSpace.basicOpen f = ⊥

full_name: AlgebraicGeometry.LocallyRingedSpace.component_nontrivial
code: instance component_nontrivial (X : LocallyRingedSpace.{u}) (U : Opens X.carrier) [hU : Nonempty U] :
    Nontrivial (X.presheaf.obj <| op U) 
goal: Nontrivial ↑(X.presheaf.obj (Opposite.op U))

full_name: AlgebraicGeometry.LocallyRingedSpace.iso_hom_val_base_inv_val_base
code: @[simp]
lemma iso_hom_val_base_inv_val_base {X Y : LocallyRingedSpace.{u}} (e : X ≅ Y) :
    e.hom.val.base ≫ e.inv.val.base = 𝟙 _ 
goal: e.hom.val.base ≫ e.inv.val.base = 𝟙 ↑X.toPresheafedSpace

full_name: AlgebraicGeometry.LocallyRingedSpace.iso_hom_val_base_inv_val_base_apply
code: @[simp]
lemma iso_hom_val_base_inv_val_base_apply {X Y : LocallyRingedSpace.{u}} (e : X ≅ Y) (x : X) :
    (e.inv.val.base (e.hom.val.base x)) = x 
goal: e.inv.val.base (e.hom.val.base x) = x

full_name: AlgebraicGeometry.LocallyRingedSpace.iso_inv_val_base_hom_val_base
code: @[simp]
lemma iso_inv_val_base_hom_val_base {X Y : LocallyRingedSpace.{u}} (e : X ≅ Y) :
    e.inv.val.base ≫ e.hom.val.base = 𝟙 _ 
goal: e.inv.val.base ≫ e.hom.val.base = 𝟙 ↑Y.toPresheafedSpace

full_name: AlgebraicGeometry.LocallyRingedSpace.iso_inv_val_base_hom_val_base_apply
code: @[simp]
lemma iso_inv_val_base_hom_val_base_apply {X Y : LocallyRingedSpace.{u}} (e : X ≅ Y) (y : Y) :
    (e.hom.val.base (e.inv.val.base y)) = y 
goal: e.hom.val.base (e.inv.val.base y) = y

full_name: AlgebraicGeometry.LocallyRingedSpace.stalkMap_id
code: @[simp]
lemma stalkMap_id (X : LocallyRingedSpace.{u}) (x : X) :
    (𝟙 X : X ⟶ X).stalkMap x = 𝟙 (X.presheaf.stalk x) 
goal: AlgebraicGeometry.LocallyRingedSpace.Hom.stalkMap (𝟙 X) x = 𝟙 (X.presheaf.stalk x)

full_name: AlgebraicGeometry.LocallyRingedSpace.stalkMap_comp
code: lemma stalkMap_comp (x : X) :
    (f ≫ g : X ⟶ Z).stalkMap x = g.stalkMap (f.val.base x) ≫ f.stalkMap x 
goal: AlgebraicGeometry.LocallyRingedSpace.Hom.stalkMap (f ≫ g) x =
  AlgebraicGeometry.LocallyRingedSpace.Hom.stalkMap g (f.val.base x) ≫
    AlgebraicGeometry.LocallyRingedSpace.Hom.stalkMap f x

full_name: AlgebraicGeometry.LocallyRingedSpace.stalkSpecializes_stalkMap
code: @[reassoc]
lemma stalkSpecializes_stalkMap (x x' : X) (h : x ⤳ x') :
    Y.presheaf.stalkSpecializes (f.val.base.map_specializes h) ≫ f.stalkMap x =
      f.stalkMap x' ≫ X.presheaf.stalkSpecializes h 
goal: Y.presheaf.stalkSpecializes ⋯ ≫ AlgebraicGeometry.LocallyRingedSpace.Hom.stalkMap f x =
  AlgebraicGeometry.LocallyRingedSpace.Hom.stalkMap f x' ≫ X.presheaf.stalkSpecializes h

full_name: AlgebraicGeometry.LocallyRingedSpace.stalkSpecializes_stalkMap_apply
code: lemma stalkSpecializes_stalkMap_apply (x x' : X) (h : x ⤳ x') (y) :
    f.stalkMap x (Y.presheaf.stalkSpecializes (f.val.base.map_specializes h) y) =
      (X.presheaf.stalkSpecializes h (f.stalkMap x' y)) 
goal: (AlgebraicGeometry.LocallyRingedSpace.Hom.stalkMap f x) ((Y.presheaf.stalkSpecializes ⋯) y) =
  (X.presheaf.stalkSpecializes h) ((AlgebraicGeometry.LocallyRingedSpace.Hom.stalkMap f x') y)

full_name: AlgebraicGeometry.LocallyRingedSpace.stalkMap_congr
code: @[reassoc]
lemma stalkMap_congr (f g : X ⟶ Y) (hfg : f = g) (x x' : X) (hxx' : x = x') :
    f.stalkMap x ≫ X.presheaf.stalkSpecializes (specializes_of_eq hxx'.symm) =
      Y.presheaf.stalkSpecializes (specializes_of_eq <| hfg ▸ hxx' ▸ rfl) ≫ g.stalkMap x' 
goal: AlgebraicGeometry.LocallyRingedSpace.Hom.stalkMap f x ≫ X.presheaf.stalkSpecializes ⋯ =
  Y.presheaf.stalkSpecializes ⋯ ≫ AlgebraicGeometry.LocallyRingedSpace.Hom.stalkMap g x'

full_name: AlgebraicGeometry.LocallyRingedSpace.stalkMap_congr_hom
code: @[reassoc]
lemma stalkMap_congr_hom (f g : X ⟶ Y) (hfg : f = g) (x : X) :
    f.stalkMap x = Y.presheaf.stalkSpecializes (specializes_of_eq <| hfg ▸ rfl) ≫
      g.stalkMap x 
goal: AlgebraicGeometry.LocallyRingedSpace.Hom.stalkMap f x =
  Y.presheaf.stalkSpecializes ⋯ ≫ AlgebraicGeometry.LocallyRingedSpace.Hom.stalkMap g x

full_name: AlgebraicGeometry.LocallyRingedSpace.stalkMap_congr_point
code: @[reassoc]
lemma stalkMap_congr_point {X Y : LocallyRingedSpace.{u}} (f : X ⟶ Y) (x x' : X) (hxx' : x = x') :
    f.stalkMap x ≫ X.presheaf.stalkSpecializes (specializes_of_eq hxx'.symm) =
      Y.presheaf.stalkSpecializes (specializes_of_eq <| hxx' ▸ rfl) ≫ f.stalkMap x' 
goal: AlgebraicGeometry.LocallyRingedSpace.Hom.stalkMap f x ≫ X.presheaf.stalkSpecializes ⋯ =
  Y.presheaf.stalkSpecializes ⋯ ≫ AlgebraicGeometry.LocallyRingedSpace.Hom.stalkMap f x'

full_name: AlgebraicGeometry.LocallyRingedSpace.stalkMap_hom_inv
code: @[reassoc (attr := simp)]
lemma stalkMap_hom_inv (e : X ≅ Y) (y : Y) :
    e.hom.stalkMap (e.inv.val.base y) ≫ e.inv.stalkMap y =
      Y.presheaf.stalkSpecializes (specializes_of_eq <| by simp) 
goal: AlgebraicGeometry.LocallyRingedSpace.Hom.stalkMap e.hom (e.inv.val.base y) ≫
    AlgebraicGeometry.LocallyRingedSpace.Hom.stalkMap e.inv y =
  Y.presheaf.stalkSpecializes ⋯

full_name: AlgebraicGeometry.LocallyRingedSpace.stalkMap_hom_inv_apply
code: @[simp]
lemma stalkMap_hom_inv_apply (e : X ≅ Y) (y : Y) (z) :
    e.inv.stalkMap y (e.hom.stalkMap (e.inv.val.base y) z) =
      Y.presheaf.stalkSpecializes (specializes_of_eq <| by simp) z 
goal: (AlgebraicGeometry.LocallyRingedSpace.Hom.stalkMap e.inv y)
    ((AlgebraicGeometry.LocallyRingedSpace.Hom.stalkMap e.hom (e.inv.val.base y)) z) =
  (Y.presheaf.stalkSpecializes ⋯) z

full_name: AlgebraicGeometry.LocallyRingedSpace.stalkMap_inv_hom
code: @[reassoc (attr := simp)]
lemma stalkMap_inv_hom (e : X ≅ Y) (x : X) :
    e.inv.stalkMap (e.hom.val.base x) ≫ e.hom.stalkMap x =
      X.presheaf.stalkSpecializes (specializes_of_eq <| by simp) 
goal: AlgebraicGeometry.LocallyRingedSpace.Hom.stalkMap e.inv (e.hom.val.base x) ≫
    AlgebraicGeometry.LocallyRingedSpace.Hom.stalkMap e.hom x =
  X.presheaf.stalkSpecializes ⋯

full_name: AlgebraicGeometry.LocallyRingedSpace.stalkMap_inv_hom_apply
code: @[simp]
lemma stalkMap_inv_hom_apply (e : X ≅ Y) (x : X) (y) :
    e.hom.stalkMap x (e.inv.stalkMap (e.hom.val.base x) y) =
      X.presheaf.stalkSpecializes (specializes_of_eq <| by simp) y 
goal: (AlgebraicGeometry.LocallyRingedSpace.Hom.stalkMap e.hom x)
    ((AlgebraicGeometry.LocallyRingedSpace.Hom.stalkMap e.inv (e.hom.val.base x)) y) =
  (X.presheaf.stalkSpecializes ⋯) y

full_name: AlgebraicGeometry.LocallyRingedSpace.stalkMap_germ
code: @[reassoc]
lemma stalkMap_germ (U : Opens Y)
    (x : (Opens.map f.val.base).obj U) :
    Y.presheaf.germ ⟨f.val.base x.val, x.property⟩ ≫ f.stalkMap x.val =
      f.val.c.app (op U) ≫ X.presheaf.germ x 
goal: Y.presheaf.germ ⟨f.val.base ↑x, ⋯⟩ ≫ AlgebraicGeometry.LocallyRingedSpace.Hom.stalkMap f ↑x =
  f.val.c.app (Opposite.op U) ≫ X.presheaf.germ x

full_name: AlgebraicGeometry.LocallyRingedSpace.stalkMap_germ_apply
code: lemma stalkMap_germ_apply (U : Opens Y) (x : (Opens.map f.val.base).obj U) (y) :
    f.stalkMap x.val (Y.presheaf.germ ⟨f.val.base x.val, x.property⟩ y) =
      X.presheaf.germ x (f.val.c.app (op U) y) 
goal: (AlgebraicGeometry.LocallyRingedSpace.Hom.stalkMap f ↑x) ((Y.presheaf.germ ⟨f.val.base ↑x, ⋯⟩) y) =
  (X.presheaf.germ x) ((f.val.c.app (Opposite.op U)) y)

full_name: AlgebraicGeometry.LocallyRingedSpace.stalkMap_germ'
code: @[reassoc (attr := simp)]
lemma stalkMap_germ' (U : Opens Y) (x : X) (hx : f.val.base x ∈ U) :
    Y.presheaf.germ ⟨f.val.base x, hx⟩ ≫ f.stalkMap x =
      f.val.c.app (op U) ≫ X.presheaf.germ (U := (Opens.map f.val.base).obj U) ⟨x, hx⟩ 
goal: Y.presheaf.germ ⟨f.val.base x, hx⟩ ≫ AlgebraicGeometry.LocallyRingedSpace.Hom.stalkMap f x =
  f.val.c.app (Opposite.op U) ≫ X.presheaf.germ ⟨x, hx⟩

full_name: AlgebraicGeometry.LocallyRingedSpace.stalkMap_germ'_apply
code: @[simp]
lemma stalkMap_germ'_apply
    (U : Opens Y) (x : X) (hx : f.val.base x ∈ U) (y : Y.presheaf.obj (op U)) :
    f.stalkMap x (Y.presheaf.germ (U := U) ⟨f.val.base x, hx⟩ y) =
      X.presheaf.germ (U := (Opens.map f.val.base).obj U) ⟨x, hx⟩ (f.val.c.app (op U) y) 
goal: (AlgebraicGeometry.LocallyRingedSpace.Hom.stalkMap f x) ((Y.presheaf.germ ⟨f.val.base x, hx⟩) y) =
  (X.presheaf.germ ⟨x, hx⟩) ((f.val.c.app (Opposite.op U)) y)

full_name: AlgebraicGeometry.LocallyRingedSpace.restrictStalkIso
code: /-- For an open embedding `f : U ⟶ X` and a point `x : U`, we get an isomorphism between the stalk
of `X` at `f x` and the stalk of the restriction of `X` along `f` at t `x`. -/
noncomputable
def restrictStalkIso : (X.restrict h).presheaf.stalk x ≅ X.presheaf.stalk (f x) 
goal: (X.restrict h).presheaf.stalk x ≅ X.presheaf.stalk (f x)

full_name: AlgebraicGeometry.LocallyRingedSpace.restrictStalkIso_hom_eq_germ
code: @[reassoc (attr := simp)]
lemma restrictStalkIso_hom_eq_germ :
    (X.restrict h).presheaf.germ ⟨x, hx⟩ ≫ (X.restrictStalkIso h x).hom =
      X.presheaf.germ ⟨f x, show f x ∈ h.isOpenMap.functor.obj V from ⟨x, hx, rfl⟩⟩ 
goal: (X.restrict h).presheaf.germ ⟨x, hx⟩ ≫ (X.restrictStalkIso h x).hom = X.presheaf.germ ⟨f x, ⋯⟩

full_name: AlgebraicGeometry.LocallyRingedSpace.restrictStalkIso_hom_eq_germ_apply
code: lemma restrictStalkIso_hom_eq_germ_apply (y) :
    (X.restrictStalkIso h x).hom ((X.restrict h).presheaf.germ ⟨x, hx⟩ y) =
      X.presheaf.germ ⟨f x, show f x ∈ h.isOpenMap.functor.obj V from ⟨x, hx, rfl⟩⟩ y 
goal: (X.restrictStalkIso h x).hom (((X.restrict h).presheaf.germ ⟨x, hx⟩) y) = (X.presheaf.germ ⟨f x, ⋯⟩) y

full_name: AlgebraicGeometry.LocallyRingedSpace.restrictStalkIso_inv_eq_germ
code: @[reassoc (attr := simp)]
lemma restrictStalkIso_inv_eq_germ :
    X.presheaf.germ ⟨f x, show f x ∈ h.isOpenMap.functor.obj V from ⟨x, hx, rfl⟩⟩ ≫
      (X.restrictStalkIso h x).inv = (X.restrict h).presheaf.germ ⟨x, hx⟩ 
goal: X.presheaf.germ ⟨f x, ⋯⟩ ≫ (X.restrictStalkIso h x).inv = (X.restrict h).presheaf.germ ⟨x, hx⟩

full_name: AlgebraicGeometry.LocallyRingedSpace.restrictStalkIso_inv_eq_germ_apply
code: lemma restrictStalkIso_inv_eq_germ_apply (y) :
    (X.restrictStalkIso h x).inv
      (X.presheaf.germ ⟨f x, show f x ∈ h.isOpenMap.functor.obj V from ⟨x, hx, rfl⟩⟩ y) =
        (X.restrict h).presheaf.germ ⟨x, hx⟩ y 
goal: (X.restrictStalkIso h x).inv ((X.presheaf.germ ⟨f x, ⋯⟩) y) = ((X.restrict h).presheaf.germ ⟨x, hx⟩) y

full_name: AlgebraicGeometry.LocallyRingedSpace.restrictStalkIso_inv_eq_ofRestrict
code: lemma restrictStalkIso_inv_eq_ofRestrict :
    (X.restrictStalkIso h x).inv = (X.ofRestrict h).stalkMap x 
goal: (X.restrictStalkIso h x).inv = AlgebraicGeometry.LocallyRingedSpace.Hom.stalkMap (X.ofRestrict h) x

full_name: AlgebraicGeometry.LocallyRingedSpace.ofRestrict_stalkMap_isIso
code: instance ofRestrict_stalkMap_isIso : IsIso ((X.ofRestrict h).stalkMap x) 
goal: CategoryTheory.IsIso (AlgebraicGeometry.LocallyRingedSpace.Hom.stalkMap (X.ofRestrict h) x)