Documentation

Mathlib.Geometry.RingedSpace.LocallyRingedSpace

The category of locally ringed spaces #

We define (bundled) locally ringed spaces (as SheafedSpace CommRing along with the fact that the stalks are local rings), and morphisms between these (morphisms in SheafedSpace with IsLocalHom on the stalk maps).

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.

Instances For

    An alias for toSheafedSpace, where the result type is a RingedSpace. This allows us to use dot-notation for the RingedSpace namespace.

    Equations
    • X.toRingedSpace = X.toSheafedSpace
    Instances For

      The underlying topological space of a locally ringed space.

      Equations
      • X.toTopCat = X.toPresheafedSpace
      Instances For

        The structure sheaf of a locally ringed space.

        Equations
        • X.𝒪 = X.sheaf
        Instances For
          structure AlgebraicGeometry.LocallyRingedSpace.Hom (X Y : AlgebraicGeometry.LocallyRingedSpace) extends X.Hom Y.toPresheafedSpace :

          A morphism of locally ringed spaces is a morphism of ringed spaces such that the morphisms induced on stalks are local ring homomorphisms.

          Instances For
            theorem AlgebraicGeometry.LocallyRingedSpace.Hom.ext {X Y : AlgebraicGeometry.LocallyRingedSpace} {x y : X.Hom Y} (base : x.base = y.base) (c : HEq x.c y.c) :
            x = y
            @[reducible, inline]
            abbrev AlgebraicGeometry.LocallyRingedSpace.Hom.toShHom {X Y : AlgebraicGeometry.LocallyRingedSpace} (f : X.Hom Y) :
            X.toSheafedSpace Y.toSheafedSpace

            A morphism of locally ringed spaces as a morphism of sheafed spaces.

            Equations
            • f.toShHom = f.toHom
            Instances For
              @[simp]
              theorem AlgebraicGeometry.LocallyRingedSpace.Hom.toShHom_mk {X Y : AlgebraicGeometry.LocallyRingedSpace} (f : X.Hom Y.toPresheafedSpace) (hf : ∀ (x : X.toPresheafedSpace), IsLocalHom (f.stalkMap x).hom) :
              { toHom := f, prop := hf }.toShHom = f
              def AlgebraicGeometry.LocallyRingedSpace.Hom.Simps.toShHom {X Y : AlgebraicGeometry.LocallyRingedSpace} (f : X.Hom Y) :
              X.toSheafedSpace Y.toSheafedSpace

              See Note [custom simps projection]

              Equations
              Instances For
                noncomputable def AlgebraicGeometry.LocallyRingedSpace.Hom.stalkMap {X Y : AlgebraicGeometry.LocallyRingedSpace} (f : X.Hom Y) (x : X.toTopCat) :
                Y.presheaf.stalk (f.base x) X.presheaf.stalk x

                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.

                Equations
                Instances For

                  The identity morphism on a locally ringed space.

                  Equations
                  Instances For
                    Equations
                    • X.instInhabitedHom = { default := X.id }
                    def AlgebraicGeometry.LocallyRingedSpace.comp {X Y Z : AlgebraicGeometry.LocallyRingedSpace} (f : X.Hom Y) (g : Y.Hom Z) :
                    X.Hom Z

                    Composition of morphisms of locally ringed spaces.

                    Equations
                    Instances For

                      The category of locally ringed spaces.

                      Equations
                      • One or more equations did not get rendered due to their size.

                      The forgetful functor from LocallyRingedSpace to SheafedSpace CommRing.

                      Equations
                      • One or more equations did not get rendered due to their size.
                      Instances For

                        The canonical map X ⟶ Spec Γ(X, ⊤). This is the unit of the Γ-Spec adjunction.

                        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 isoOfSheafedSpaceIso.

                        Equations
                        Instances For

                          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 forgetToSheafedSpace reflects isomorphisms. In fact, it is slightly stronger as we do not require f to come from a morphism between locally ringed spaces.

                          Equations
                          • One or more equations did not get rendered due to their size.
                          Instances For

                            The restriction of a locally ringed space along an open embedding.

                            Equations
                            • X.restrict h = { toSheafedSpace := X.restrict h, isLocalRing := }
                            Instances For
                              @[simp]
                              theorem AlgebraicGeometry.LocallyRingedSpace.restrict_presheaf_map {U : TopCat} (X : AlgebraicGeometry.LocallyRingedSpace) {f : U X.toTopCat} (h : Topology.IsOpenEmbedding f) {X✝ Y✝ : (TopologicalSpace.Opens U)ᵒᵖ} (f✝ : X✝ Y✝) :
                              (X.restrict h).presheaf.map f✝ = X.presheaf.map (.functor.map f✝.unop).op
                              @[simp]
                              theorem AlgebraicGeometry.LocallyRingedSpace.restrict_presheaf_obj {U : TopCat} (X : AlgebraicGeometry.LocallyRingedSpace) {f : U X.toTopCat} (h : Topology.IsOpenEmbedding f) (X✝ : (TopologicalSpace.Opens U)ᵒᵖ) :
                              (X.restrict h).presheaf.obj X✝ = X.presheaf.obj (Opposite.op (.functor.obj (Opposite.unop X✝)))
                              @[simp]
                              theorem AlgebraicGeometry.LocallyRingedSpace.restrict_carrier {U : TopCat} (X : AlgebraicGeometry.LocallyRingedSpace) {f : U X.toTopCat} (h : Topology.IsOpenEmbedding f) :
                              (X.restrict h).toPresheafedSpace = U

                              The canonical map from the restriction to the subspace.

                              Equations
                              • X.ofRestrict h = { toHom := X.ofRestrict h, prop := }
                              Instances For

                                The restriction of a locally ringed space X to the top subspace is isomorphic to X itself.

                                Equations
                                Instances For

                                  The empty locally ringed space.

                                  Equations
                                  • One or more equations did not get rendered due to their size.
                                  Instances For

                                    The canonical map from the empty locally ringed space.

                                    Equations
                                    • One or more equations did not get rendered due to their size.
                                    Instances For
                                      Equations
                                      • AlgebraicGeometry.LocallyRingedSpace.instUniqueHomEmptyCollection = { default := X.emptyTo, uniq := }
                                      @[simp]
                                      theorem AlgebraicGeometry.LocallyRingedSpace.basicOpen_eq_bot_of_isNilpotent (X : AlgebraicGeometry.LocallyRingedSpace) (U : TopologicalSpace.Opens X.toPresheafedSpace) (f : (X.presheaf.obj (Opposite.op U))) (hf : IsNilpotent f) :
                                      X.toRingedSpace.basicOpen f =
                                      @[simp]
                                      theorem AlgebraicGeometry.LocallyRingedSpace.iso_hom_base_inv_base_apply {X Y : AlgebraicGeometry.LocallyRingedSpace} (e : X Y) (x : X.toTopCat) :
                                      e.inv.base (e.hom.base x) = x
                                      @[simp]
                                      theorem AlgebraicGeometry.LocallyRingedSpace.iso_inv_base_hom_base_apply {X Y : AlgebraicGeometry.LocallyRingedSpace} (e : X Y) (y : Y.toTopCat) :
                                      e.hom.base (e.inv.base y) = y
                                      theorem AlgebraicGeometry.LocallyRingedSpace.stalkSpecializes_stalkMap_apply {X Y : AlgebraicGeometry.LocallyRingedSpace} (f : X Y) (x x' : X.toTopCat) (h : x x') (y : (Y.presheaf.stalk (f.base x'))) :
                                      (AlgebraicGeometry.LocallyRingedSpace.Hom.stalkMap f x).hom ((Y.presheaf.stalkSpecializes ).hom y) = (X.presheaf.stalkSpecializes h).hom ((AlgebraicGeometry.LocallyRingedSpace.Hom.stalkMap f x').hom y)
                                      @[simp]
                                      theorem AlgebraicGeometry.LocallyRingedSpace.stalkMap_hom_inv_apply {X Y : AlgebraicGeometry.LocallyRingedSpace} (e : X Y) (y : Y.toTopCat) (z : (Y.presheaf.stalk (e.hom.base (e.inv.base y)))) :
                                      (AlgebraicGeometry.LocallyRingedSpace.Hom.stalkMap e.inv y).hom ((AlgebraicGeometry.LocallyRingedSpace.Hom.stalkMap e.hom (e.inv.base y)).hom z) = (Y.presheaf.stalkSpecializes ).hom z
                                      @[simp]
                                      theorem AlgebraicGeometry.LocallyRingedSpace.stalkMap_inv_hom_apply {X Y : AlgebraicGeometry.LocallyRingedSpace} (e : X Y) (x : X.toTopCat) (y : (X.presheaf.stalk (e.inv.base (e.hom.base x)))) :
                                      (AlgebraicGeometry.LocallyRingedSpace.Hom.stalkMap e.hom x).hom ((AlgebraicGeometry.LocallyRingedSpace.Hom.stalkMap e.inv (e.hom.base x)).hom y) = (X.presheaf.stalkSpecializes ).hom y
                                      @[simp]
                                      theorem AlgebraicGeometry.LocallyRingedSpace.stalkMap_germ {X Y : AlgebraicGeometry.LocallyRingedSpace} (f : X Y) (U : TopologicalSpace.Opens Y.toTopCat) (x : X.toTopCat) (hx : f.base x U) :
                                      @[simp]
                                      theorem AlgebraicGeometry.LocallyRingedSpace.stalkMap_germ_apply {X Y : AlgebraicGeometry.LocallyRingedSpace} (f : X Y) (U : TopologicalSpace.Opens Y.toTopCat) (x : X.toTopCat) (hx : f.base x U) (y : (Y.presheaf.obj (Opposite.op U))) :
                                      (AlgebraicGeometry.LocallyRingedSpace.Hom.stalkMap f x).hom ((Y.presheaf.germ U (f.base x) hx).hom y) = (X.presheaf.germ ((TopologicalSpace.Opens.map f.base).obj U) x hx).hom ((f.c.app (Opposite.op U)).hom y)
                                      theorem AlgebraicGeometry.LocallyRingedSpace.preimage_basicOpen {X Y : AlgebraicGeometry.LocallyRingedSpace} (f : X Y) {U : TopologicalSpace.Opens Y.toTopCat} (s : (Y.presheaf.obj (Opposite.op U))) :
                                      (TopologicalSpace.Opens.map f.base).obj (Y.toRingedSpace.basicOpen s) = X.toRingedSpace.basicOpen ((f.c.app (Opposite.op U)).hom s)
                                      noncomputable def AlgebraicGeometry.LocallyRingedSpace.restrictStalkIso {U : TopCat} (X : AlgebraicGeometry.LocallyRingedSpace) {f : U X.toTopCat} (h : Topology.IsOpenEmbedding f) (x : U) :
                                      (X.restrict h).presheaf.stalk x X.presheaf.stalk (f x)

                                      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.

                                      Equations
                                      • X.restrictStalkIso h x = X.restrictStalkIso h x
                                      Instances For
                                        @[simp]
                                        theorem AlgebraicGeometry.LocallyRingedSpace.restrictStalkIso_hom_eq_germ {U : TopCat} (X : AlgebraicGeometry.LocallyRingedSpace) {f : U X.toTopCat} (h : Topology.IsOpenEmbedding f) (V : TopologicalSpace.Opens U) (x : U) (hx : x V) :
                                        CategoryTheory.CategoryStruct.comp ((X.restrict h).presheaf.germ V x hx) (X.restrictStalkIso h x).hom = X.presheaf.germ (.functor.obj V) (f x)
                                        @[simp]
                                        theorem AlgebraicGeometry.LocallyRingedSpace.restrictStalkIso_hom_eq_germ_assoc {U : TopCat} (X : AlgebraicGeometry.LocallyRingedSpace) {f : U X.toTopCat} (h : Topology.IsOpenEmbedding f) (V : TopologicalSpace.Opens U) (x : U) (hx : x V) {Z : CommRingCat} (h✝ : X.presheaf.stalk (f x) Z) :
                                        CategoryTheory.CategoryStruct.comp ((X.restrict h).presheaf.germ V x hx) (CategoryTheory.CategoryStruct.comp (X.restrictStalkIso h x).hom h✝) = CategoryTheory.CategoryStruct.comp (X.presheaf.germ (.functor.obj V) (f x) ) h✝
                                        theorem AlgebraicGeometry.LocallyRingedSpace.restrictStalkIso_hom_eq_germ_apply {U : TopCat} (X : AlgebraicGeometry.LocallyRingedSpace) {f : U X.toTopCat} (h : Topology.IsOpenEmbedding f) (V : TopologicalSpace.Opens U) (x : U) (hx : x V) (y : ((X.restrict h).presheaf.obj (Opposite.op V))) :
                                        (X.restrictStalkIso h x).hom.hom (((X.restrict h).presheaf.germ V x hx).hom y) = (X.presheaf.germ (.functor.obj V) (f x) ).hom y
                                        @[simp]
                                        theorem AlgebraicGeometry.LocallyRingedSpace.restrictStalkIso_inv_eq_germ {U : TopCat} (X : AlgebraicGeometry.LocallyRingedSpace) {f : U X.toTopCat} (h : Topology.IsOpenEmbedding f) (V : TopologicalSpace.Opens U) (x : U) (hx : x V) :
                                        CategoryTheory.CategoryStruct.comp (X.presheaf.germ (.functor.obj V) (f x) ) (X.restrictStalkIso h x).inv = (X.restrict h).presheaf.germ V x hx
                                        @[simp]
                                        theorem AlgebraicGeometry.LocallyRingedSpace.restrictStalkIso_inv_eq_germ_assoc {U : TopCat} (X : AlgebraicGeometry.LocallyRingedSpace) {f : U X.toTopCat} (h : Topology.IsOpenEmbedding f) (V : TopologicalSpace.Opens U) (x : U) (hx : x V) {Z : CommRingCat} (h✝ : (X.restrict h).presheaf.stalk x Z) :
                                        CategoryTheory.CategoryStruct.comp (X.presheaf.germ (.functor.obj V) (f x) ) (CategoryTheory.CategoryStruct.comp (X.restrictStalkIso h x).inv h✝) = CategoryTheory.CategoryStruct.comp ((X.restrict h).presheaf.germ V x hx) h✝
                                        theorem AlgebraicGeometry.LocallyRingedSpace.restrictStalkIso_inv_eq_germ_apply {U : TopCat} (X : AlgebraicGeometry.LocallyRingedSpace) {f : U X.toTopCat} (h : Topology.IsOpenEmbedding f) (V : TopologicalSpace.Opens U) (x : U) (hx : x V) (y : (X.presheaf.obj (Opposite.op (.functor.obj V)))) :
                                        (X.restrictStalkIso h x).inv.hom ((X.presheaf.germ (.functor.obj V) (f x) ).hom y) = ((X.restrict h).presheaf.germ V x hx).hom y