Subschemes of toric space - Schemes

Skip to content
Back to top
View this page
Edit this page

# Subschemes of toric space

AUTHORS:

- David Kohel (2005): initial version.

- William Stein (2005): initial version.

- Andrey Novoseltsev (2010-05-17): subschemes of toric varieties.

class sage.schemes.toric.toric_subscheme.AlgebraicScheme_subscheme_affine_toric(toric_variety, polynomials)

  Bases: `AlgebraicScheme_subscheme_toric`

  Construct an algebraic subscheme of an affine toric variety.

  Warning

  You should not create objects of this class directly. The preferred method to construct such subschemes is to use `subscheme()` method of `toric varieties`.

  INPUT:

  - `toric_variety` – ambient `affine toric variety`

  - `polynomials` – single polynomial, list, or ideal of defining polynomials in the coordinate ring of `toric_variety`

  OUTPUT:

  A `algebraic subscheme of an affine toric variety`.

  dimension()

    Return the dimension of `self`.

    OUTPUT: integer

    EXAMPLES:

    Sage

        sage: # needs sage.libs.singular
        sage: P1xP1.<s0,s1,t0,t1> = toric_varieties.P1xP1()
        sage: P1 = P1xP1.subscheme(s0 - s1)
        sage: P1.dimension()
        1

    Python

        >>> from sage.all import *
        >>> # needs sage.libs.singular
        >>> P1xP1 = toric_varieties.P1xP1(names=('s0', 's1', 't0', 't1',)); (s0, s1, t0, t1,) = P1xP1._first_ngens(4)
        >>> P1 = P1xP1.subscheme(s0 - s1)
        >>> P1.dimension()
        1

    A more complicated example where the ambient toric variety is not smooth:

    Sage

        sage: # needs sage.libs.singular
        sage: X.<x,y> = toric_varieties.A2_Z2()
        sage: X.is_smooth()
        False
        sage: Y = X.subscheme([x*y, x^2]); Y
        Closed subscheme of 2-d affine toric variety defined by:
          x*y,
          x^2
        sage: Y.dimension()
        1

    [Python]

        >>> from sage.all import *
        >>> # needs sage.libs.singular
        >>> X = toric_varieties.A2_Z2(names=('x', 'y',)); (x, y,) = X._first_ngens(2)
        >>> X.is_smooth()
        False
        >>> Y = X.subscheme([x*y, x**Integer(2)]); Y
        Closed subscheme of 2-d affine toric variety defined by:
          x*y,
          x^2
        >>> Y.dimension()
        1

  is_smooth(point=None)

    Test whether the algebraic subscheme is smooth.

    INPUT:

    - `point` – a point or `None` (default); the point to test smoothness at

    OUTPUT:

    boolean; if no point was specified, returns whether the algebraic subscheme is smooth everywhere. Otherwise, smoothness at the specified point is tested.

    EXAMPLES:

    Sage

        sage: # needs sage.libs.singular
        sage: A2.<x,y> = toric_varieties.A2()
        sage: cuspidal_curve = A2.subscheme([y^2 - x^3])
        sage: cuspidal_curve
        Closed subscheme of 2-d affine toric variety defined by:
          -x^3 + y^2
        sage: cuspidal_curve.is_smooth([1,1])
        True
        sage: cuspidal_curve.is_smooth([0,0])
        False
        sage: cuspidal_curve.is_smooth()
        False
        sage: circle = A2.subscheme(x^2 + y^2 - 1)
        sage: circle.is_smooth([1,0])
        True
        sage: circle.is_smooth()
        True

    Python

        >>> from sage.all import *
        >>> # needs sage.libs.singular
        >>> A2 = toric_varieties.A2(names=('x', 'y',)); (x, y,) = A2._first_ngens(2)
        >>> cuspidal_curve = A2.subscheme([y**Integer(2) - x**Integer(3)])
        >>> cuspidal_curve
        Closed subscheme of 2-d affine toric variety defined by:
          -x^3 + y^2
        >>> cuspidal_curve.is_smooth([Integer(1),Integer(1)])
        True
        >>> cuspidal_curve.is_smooth([Integer(0),Integer(0)])
        False
        >>> cuspidal_curve.is_smooth()
        False
        >>> circle = A2.subscheme(x**Integer(2) + y**Integer(2) - Integer(1))
        >>> circle.is_smooth([Integer(1),Integer(0)])
        True
        >>> circle.is_smooth()
        True

    A more complicated example where the ambient toric variety is not smooth:

    Sage

        sage: # needs sage.libs.singular
        sage: X.<x,y> = toric_varieties.A2_Z2()    # 2-d affine space mod Z/2
        sage: X.is_smooth()
        False
        sage: Y = X.subscheme([x*y, x^2])   # (twice the x=0 curve) mod Z/2
        sage: Y
        Closed subscheme of 2-d affine toric variety defined by:
          x*y,
          x^2
        sage: Y.dimension()   # Y is a Weil divisor but not Cartier
        1
        sage: Y.is_smooth()
        True
        sage: Y.is_smooth([0,0])
        True

    [Python]

        >>> from sage.all import *
        >>> # needs sage.libs.singular
        >>> X = toric_varieties.A2_Z2(names=('x', 'y',)); (x, y,) = X._first_ngens(2)# 2-d affine space mod Z/2
        >>> X.is_smooth()
        False
        >>> Y = X.subscheme([x*y, x**Integer(2)])   # (twice the x=0 curve) mod Z/2
        >>> Y
        Closed subscheme of 2-d affine toric variety defined by:
          x*y,
          x^2
        >>> Y.dimension()   # Y is a Weil divisor but not Cartier
        1
        >>> Y.is_smooth()
        True
        >>> Y.is_smooth([Integer(0),Integer(0)])
        True

class sage.schemes.toric.toric_subscheme.AlgebraicScheme_subscheme_toric(toric_variety, polynomials)

  Bases: `AlgebraicScheme_subscheme`

  Construct an algebraic subscheme of a toric variety.

  Warning

  You should not create objects of this class directly. The preferred method to construct such subschemes is to use `subscheme()` method of `toric varieties`.

  INPUT:

  - `toric_variety` – ambient `toric variety`

  - `polynomials` – single polynomial, list, or ideal of defining polynomials in the coordinate ring of `toric_variety`

  OUTPUT: an `algebraic subscheme of a toric variety`.

  affine_algebraic_patch(cone=None, names=None)

    Return the affine patch corresponding to `cone` as an affine algebraic scheme.

    INPUT:

    - `cone` – a `Cone` \(\sigma\) of the fan. It can be omitted for an affine toric variety, in which case the single generating cone is used.

    OUTPUT:

    An `affine algebraic subscheme` corresponding to the patch \(\mathop{Spec}(\sigma^\vee \cap M)\) associated to the cone \(\sigma\).

    See also `affine_patch()`, which expresses the patches as subvarieties of affine toric varieties instead.

    REFERENCES:

    > David A. Cox, “The Homogeneous Coordinate Ring of a Toric Variety”, Lemma 2.2. arXiv alg-geom/9210008v2

    EXAMPLES:

    Sage

        sage: P2.<x,y,z> = toric_varieties.P2()
        sage: cone = P2.fan().generating_cone(0)
        sage: V = P2.subscheme(x^3 + y^3 + z^3)
        sage: V.affine_algebraic_patch(cone)
        Closed subscheme of Affine Space of dimension 2 over Rational Field defined by:
          z0^3 + z1^3 + 1

        sage: # needs fpylll sage.libs.singular
        sage: cone = Cone([(0,1), (2,1)])
        sage: A2Z2.<x,y> = AffineToricVariety(cone)
        sage: A2Z2.affine_algebraic_patch()
        Closed subscheme of Affine Space of dimension 3 over Rational Field defined by:
          -z0*z1 + z2^2
        sage: V = A2Z2.subscheme(x^2 + y^2 - 1)
        sage: patch = V.affine_algebraic_patch();  patch
        Closed subscheme of Affine Space of dimension 3 over Rational Field defined by:
          -z0*z1 + z2^2,
          z0 + z1 - 1
        sage: nbhd_patch = V.neighborhood([1,0]).affine_algebraic_patch();  nbhd_patch
        Closed subscheme of Affine Space of dimension 3 over Rational Field defined by:
          -z0*z1 + z2^2,
          z0 + z1 - 1
        sage: nbhd_patch.embedding_center()
        (0, 1, 0)

    Python

        >>> from sage.all import *
        >>> P2 = toric_varieties.P2(names=('x', 'y', 'z',)); (x, y, z,) = P2._first_ngens(3)
        >>> cone = P2.fan().generating_cone(Integer(0))
        >>> V = P2.subscheme(x**Integer(3) + y**Integer(3) + z**Integer(3))
        >>> V.affine_algebraic_patch(cone)
        Closed subscheme of Affine Space of dimension 2 over Rational Field defined by:
          z0^3 + z1^3 + 1

        >>> # needs fpylll sage.libs.singular
        >>> cone = Cone([(Integer(0),Integer(1)), (Integer(2),Integer(1))])
        >>> A2Z2 = AffineToricVariety(cone, names=('x', 'y',)); (x, y,) = A2Z2._first_ngens(2)
        >>> A2Z2.affine_algebraic_patch()
        Closed subscheme of Affine Space of dimension 3 over Rational Field defined by:
          -z0*z1 + z2^2
        >>> V = A2Z2.subscheme(x**Integer(2) + y**Integer(2) - Integer(1))
        >>> patch = V.affine_algebraic_patch();  patch
        Closed subscheme of Affine Space of dimension 3 over Rational Field defined by:
          -z0*z1 + z2^2,
          z0 + z1 - 1
        >>> nbhd_patch = V.neighborhood([Integer(1),Integer(0)]).affine_algebraic_patch();  nbhd_patch
        Closed subscheme of Affine Space of dimension 3 over Rational Field defined by:
          -z0*z1 + z2^2,
          z0 + z1 - 1
        >>> nbhd_patch.embedding_center()
        (0, 1, 0)

    Here we got two defining equations. The first one describes the singularity of the ambient space and the second is the pull-back of \(x^2+y^2-1\)

    Sage

        sage: lp = LatticePolytope([(1,0,0), (1,1,0), (1,1,1), (1,0,1), (-2,-1,-1)],
        ....:                      lattice=ToricLattice(3))
        sage: X.<x,y,u,v,t> = CPRFanoToricVariety(Delta_polar=lp)
        sage: Y = X.subscheme(x*v + y*u + t)
        sage: cone = Cone([(1,0,0), (1,1,0), (1,1,1), (1,0,1)])
        sage: Y.affine_algebraic_patch(cone)
        Closed subscheme of Affine Space of dimension 4 over Rational Field defined by:
          z0*z2 - z1*z3,
          z1 + z3 + 1

    [Python]

        >>> from sage.all import *
        >>> lp = LatticePolytope([(Integer(1),Integer(0),Integer(0)), (Integer(1),Integer(1),Integer(0)), (Integer(1),Integer(1),Integer(1)), (Integer(1),Integer(0),Integer(1)), (-Integer(2),-Integer(1),-Integer(1))],
        ...                      lattice=ToricLattice(Integer(3)))
        >>> X = CPRFanoToricVariety(Delta_polar=lp, names=('x', 'y', 'u', 'v', 't',)); (x, y, u, v, t,) = X._first_ngens(5)
        >>> Y = X.subscheme(x*v + y*u + t)
        >>> cone = Cone([(Integer(1),Integer(0),Integer(0)), (Integer(1),Integer(1),Integer(0)), (Integer(1),Integer(1),Integer(1)), (Integer(1),Integer(0),Integer(1))])
        >>> Y.affine_algebraic_patch(cone)
        Closed subscheme of Affine Space of dimension 4 over Rational Field defined by:
          z0*z2 - z1*z3,
          z1 + z3 + 1

  affine_patch(i)

    Return the `i`-th affine patch of `self` as an affine toric algebraic scheme.

    INPUT:

    - `i` – integer; index of a generating cone of the fan of the ambient space of `self`

    OUTPUT:

    - subscheme of an affine `toric variety` corresponding to the pull-back of `self` by the embedding morphism of the `i`-th `affine patch of the ambient space` of `self`.

    The result is cached, so the `i`-th patch is always the same object in memory.

    EXAMPLES:

    Sage

        sage: P1xP1 = toric_varieties.P1xP1()
        sage: patch1 = P1xP1.affine_patch(1)
        sage: patch1.embedding_morphism()
        Scheme morphism:
          From: 2-d affine toric variety
          To:   2-d CPR-Fano toric variety covered by 4 affine patches
          Defn: Defined on coordinates by sending [t : x] to [1 : t : x : 1]
        sage: P1xP1.inject_variables()
        Defining s, t, x, y
        sage: P1 = P1xP1.subscheme(x - y)
        sage: subpatch = P1.affine_patch(1)
        sage: subpatch
        Closed subscheme of 2-d affine toric variety defined by:
          x - 1

    Python

        >>> from sage.all import *
        >>> P1xP1 = toric_varieties.P1xP1()
        >>> patch1 = P1xP1.affine_patch(Integer(1))
        >>> patch1.embedding_morphism()
        Scheme morphism:
          From: 2-d affine toric variety
          To:   2-d CPR-Fano toric variety covered by 4 affine patches
          Defn: Defined on coordinates by sending [t : x] to [1 : t : x : 1]
        >>> P1xP1.inject_variables()
        Defining s, t, x, y
        >>> P1 = P1xP1.subscheme(x - y)
        >>> subpatch = P1.affine_patch(Integer(1))
        >>> subpatch
        Closed subscheme of 2-d affine toric variety defined by:
          x - 1

  dimension()

    Return the dimension of `self`.

    OUTPUT: integer; if `self` is empty, \(-1\) is returned

    EXAMPLES:

    Sage

        sage: # needs sage.libs.singular
        sage: P1xP1 = toric_varieties.P1xP1()
        sage: P1xP1.inject_variables()
        Defining s, t, x, y
        sage: P1 = P1xP1.subscheme(s - t)
        sage: P1.dimension()
        1
        sage: P1xP1.subscheme([s - t, (s-t)^2]).dimension()
        1
        sage: P1xP1.subscheme([s, t]).dimension()
        -1

    Python

        >>> from sage.all import *
        >>> # needs sage.libs.singular
        >>> P1xP1 = toric_varieties.P1xP1()
        >>> P1xP1.inject_variables()
        Defining s, t, x, y
        >>> P1 = P1xP1.subscheme(s - t)
        >>> P1.dimension()
        1
        >>> P1xP1.subscheme([s - t, (s-t)**Integer(2)]).dimension()
        1
        >>> P1xP1.subscheme([s, t]).dimension()
        -1

  fan()

    Return the fan of the ambient space.

    OUTPUT: a fan

    EXAMPLES:

    Sage

        sage: P2.<x,y,z> = toric_varieties.P(2)
        sage: E = P2.subscheme([x^2 + y^2 + z^2])
        sage: E.fan()
        Rational polyhedral fan in 2-d lattice N

    Python

        >>> from sage.all import *
        >>> P2 = toric_varieties.P(Integer(2), names=('x', 'y', 'z',)); (x, y, z,) = P2._first_ngens(3)
        >>> E = P2.subscheme([x**Integer(2) + y**Integer(2) + z**Integer(2)])
        >>> E.fan()
        Rational polyhedral fan in 2-d lattice N

  is_nondegenerate()

    Check if `self` is nondegenerate.

    OUTPUT:

    Whether the variety is nondegenerate, that is, the intersection with every open torus orbit is smooth and transversal.

    EXAMPLES:

    Sage

        sage: P2.<x,y,z> = toric_varieties.P2()
        sage: P2.subscheme([x^3 + y^3 + z^3]).is_nondegenerate()
        True
        sage: P2.subscheme([x*y*z]).is_nondegenerate()
        False
        sage: X = P2.subscheme([(x-y)^2*(x+y) + x*y*z + z^3])
        sage: X.is_smooth()
        True
        sage: X.is_nondegenerate()
        False

    Python

        >>> from sage.all import *
        >>> P2 = toric_varieties.P2(names=('x', 'y', 'z',)); (x, y, z,) = P2._first_ngens(3)
        >>> P2.subscheme([x**Integer(3) + y**Integer(3) + z**Integer(3)]).is_nondegenerate()
        True
        >>> P2.subscheme([x*y*z]).is_nondegenerate()
        False
        >>> X = P2.subscheme([(x-y)**Integer(2)*(x+y) + x*y*z + z**Integer(3)])
        >>> X.is_smooth()
        True
        >>> X.is_nondegenerate()
        False

    A K3 surface in \(\mathbf{P}^1 \times \mathbf{P}^1 \times \mathbf{P}^1\):

    Sage

        sage: diamond = lattice_polytope.cross_polytope(3)
        sage: fan = FaceFan(diamond)
        sage: P1xP1xP1 = ToricVariety(fan)
        sage: z0, z1, z2, z3, z4, z5 = P1xP1xP1.gens()
        sage: t = 5
        sage: F = z0^2*z1^2*z2^2 + z1^2*z2^2*z3^2 + z0^2*z2^2*z4^2\
        ....: + z2^2*z3^2*z4^2 + t*z0*z1*z2*z3*z4*z5 + z0^2*z1^2*z5^2\
        ....: + z1^2*z3^2*z5^2 + z0^2*z4^2*z5^2 + z3^2*z4^2*z5^2
        sage: X = P1xP1xP1.subscheme([F])
        sage: X.is_smooth()
        True
        sage: X.is_nondegenerate()
        False

    [Python]

        >>> from sage.all import *
        >>> diamond = lattice_polytope.cross_polytope(Integer(3))
        >>> fan = FaceFan(diamond)
        >>> P1xP1xP1 = ToricVariety(fan)
        >>> z0, z1, z2, z3, z4, z5 = P1xP1xP1.gens()
        >>> t = Integer(5)
        >>> F = z0**Integer(2)*z1**Integer(2)*z2**Integer(2) + z1**Integer(2)*z2**Integer(2)*z3**Integer(2) + z0**Integer(2)*z2**Integer(2)*z4**Integer(2)+ z2**Integer(2)*z3**Integer(2)*z4**Integer(2) + t*z0*z1*z2*z3*z4*z5 + z0**Integer(2)*z1**Integer(2)*z5**Integer(2)+ z1**Integer(2)*z3**Integer(2)*z5**Integer(2) + z0**Integer(2)*z4**Integer(2)*z5**Integer(2) + z3**Integer(2)*z4**Integer(2)*z5**Integer(2)
        >>> X = P1xP1xP1.subscheme([F])
        >>> X.is_smooth()
        True
        >>> X.is_nondegenerate()
        False

    Taking a random change of variables breaks the symmetry, but makes the surface nondegenerate:

    Sage

        sage: F1 = F.subs(z0=1*z0 + 1*z3, z3=1*z0 + 2*z3,
        ....:             z1=-2*z1 + -1*z4, z4=1*z1 + 2*z4,
        ....:             z2=-3*z2 + -1*z5, z5=-3*z2 + 2*z5)
        sage: Y = P1xP1xP1.subscheme([F1])
        sage: Y.is_smooth()
        True
        sage: Y.is_nondegenerate()
        True

    Python

        >>> from sage.all import *
        >>> F1 = F.subs(z0=Integer(1)*z0 + Integer(1)*z3, z3=Integer(1)*z0 + Integer(2)*z3,
        ...             z1=-Integer(2)*z1 + -Integer(1)*z4, z4=Integer(1)*z1 + Integer(2)*z4,
        ...             z2=-Integer(3)*z2 + -Integer(1)*z5, z5=-Integer(3)*z2 + Integer(2)*z5)
        >>> Y = P1xP1xP1.subscheme([F1])
        >>> Y.is_smooth()
        True
        >>> Y.is_nondegenerate()
        True

    This example is from Hamm, arXiv 1106.1826v1. It addresses an issue raised at Issue #15239:

    Sage

        sage: X = toric_varieties.WP([1,4,2,3], names='z0 z1 z2 z3')
        sage: X.inject_variables()
        Defining z0, z1, z2, z3
        sage: g0 = z1^3 + z2^6 + z3^4
        sage: g = g0 - 2*z3^2*z0^6 + z2*z0^10 + z0^12
        sage: Y = X.subscheme([g])
        sage: Y.is_nondegenerate()
        False

    [Python]

        >>> from sage.all import *
        >>> X = toric_varieties.WP([Integer(1),Integer(4),Integer(2),Integer(3)], names='z0 z1 z2 z3')
        >>> X.inject_variables()
        Defining z0, z1, z2, z3
        >>> g0 = z1**Integer(3) + z2**Integer(6) + z3**Integer(4)
        >>> g = g0 - Integer(2)*z3**Integer(2)*z0**Integer(6) + z2*z0**Integer(10) + z0**Integer(12)
        >>> Y = X.subscheme([g])
        >>> Y.is_nondegenerate()
        False

    It handles nonzero characteristic:

    Sage

        sage: P2.<x,y,z> = toric_varieties.P2()
        sage: f = x^5 + 2*x*y^4 + y^5 - 2*y^3*z^2 + x*z^4 - 2*z^5
        sage: P2.change_ring(GF(5)).subscheme([f]).is_nondegenerate()
        True
        sage: P2.change_ring(GF(7)).subscheme([f]).is_nondegenerate()
        False

    Python

        >>> from sage.all import *
        >>> P2 = toric_varieties.P2(names=('x', 'y', 'z',)); (x, y, z,) = P2._first_ngens(3)
        >>> f = x**Integer(5) + Integer(2)*x*y**Integer(4) + y**Integer(5) - Integer(2)*y**Integer(3)*z**Integer(2) + x*z**Integer(4) - Integer(2)*z**Integer(5)
        >>> P2.change_ring(GF(Integer(5))).subscheme([f]).is_nondegenerate()
        True
        >>> P2.change_ring(GF(Integer(7))).subscheme([f]).is_nondegenerate()
        False

  is_schon()

    Check if `self` is schon (nondegenerate).

    See `is_nondegenerate()` for further documentation.

    EXAMPLES:

    Sage

        sage: # needs sage.libs.singular
        sage: P2.<x,y,z> = toric_varieties.P2()
        sage: X = P2.subscheme([(x-y)^2*(x+y) + x*y*z + z^3])
        sage: X.is_smooth()
        True
        sage: X.is_schon()
        False

    Python

        >>> from sage.all import *
        >>> # needs sage.libs.singular
        >>> P2 = toric_varieties.P2(names=('x', 'y', 'z',)); (x, y, z,) = P2._first_ngens(3)
        >>> X = P2.subscheme([(x-y)**Integer(2)*(x+y) + x*y*z + z**Integer(3)])
        >>> X.is_smooth()
        True
        >>> X.is_schon()
        False

  is_smooth(point=None)

    Test whether the algebraic subscheme is smooth.

    INPUT:

    - `point` – a point or `None` (default); the point to test smoothness at

    OUTPUT:

    boolean; if no point was specified, returns whether the algebraic subscheme is smooth everywhere. Otherwise, smoothness at the specified point is tested.

    EXAMPLES:

    Sage

        sage: # needs sage.libs.singular
        sage: P2.<x,y,z> = toric_varieties.P2()
        sage: cuspidal_curve = P2.subscheme([y^2*z - x^3])
        sage: cuspidal_curve
        Closed subscheme of 2-d CPR-Fano toric variety covered by 3 affine patches defined by:
          -x^3 + y^2*z
        sage: cuspidal_curve.is_smooth([1,1,1])
        True
        sage: cuspidal_curve.is_smooth([0,0,1])
        False
        sage: cuspidal_curve.is_smooth()
        False

    Python

        >>> from sage.all import *
        >>> # needs sage.libs.singular
        >>> P2 = toric_varieties.P2(names=('x', 'y', 'z',)); (x, y, z,) = P2._first_ngens(3)
        >>> cuspidal_curve = P2.subscheme([y**Integer(2)*z - x**Integer(3)])
        >>> cuspidal_curve
        Closed subscheme of 2-d CPR-Fano toric variety covered by 3 affine patches defined by:
          -x^3 + y^2*z
        >>> cuspidal_curve.is_smooth([Integer(1),Integer(1),Integer(1)])
        True
        >>> cuspidal_curve.is_smooth([Integer(0),Integer(0),Integer(1)])
        False
        >>> cuspidal_curve.is_smooth()
        False

    Any sufficiently generic cubic hypersurface is smooth:

    Sage

        sage: P2.subscheme([y^2*z-x^3+z^3+1/10*x*y*z]).is_smooth()                  # needs sage.libs.singular
        True

    [Python]

        >>> from sage.all import *
        >>> P2.subscheme([y**Integer(2)*z-x**Integer(3)+z**Integer(3)+Integer(1)/Integer(10)*x*y*z]).is_smooth()                  # needs sage.libs.singular
        True

    A more complicated example:

    Sage

        sage: # needs sage.libs.singular
        sage: dP6.<x0,x1,x2,x3,x4,x5> = toric_varieties.dP6()
        sage: disjointP1s = dP6.subscheme(x0*x3)
        sage: disjointP1s.is_smooth()
        True
        sage: intersectingP1s = dP6.subscheme(x0*x1)
        sage: intersectingP1s.is_smooth()
        False

    Python

        >>> from sage.all import *
        >>> # needs sage.libs.singular
        >>> dP6 = toric_varieties.dP6(names=('x0', 'x1', 'x2', 'x3', 'x4', 'x5',)); (x0, x1, x2, x3, x4, x5,) = dP6._first_ngens(6)
        >>> disjointP1s = dP6.subscheme(x0*x3)
        >>> disjointP1s.is_smooth()
        True
        >>> intersectingP1s = dP6.subscheme(x0*x1)
        >>> intersectingP1s.is_smooth()
        False

    A smooth hypersurface in a compact singular toric variety:

    Sage

        sage: # needs sage.libs.singular
        sage: lp = LatticePolytope([(1,0,0), (1,1,0), (1,1,1), (1,0,1), (-2,-1,-1)],
        ....:                      lattice=ToricLattice(3))
        sage: X.<x,y,u,v,t> = CPRFanoToricVariety(Delta_polar=lp)
        sage: Y = X.subscheme(x*v + y*u + t)
        sage: cone = Cone([(1,0,0), (1,1,0), (1,1,1), (1,0,1)])
        sage: Y.is_smooth()
        True

    [Python]

        >>> from sage.all import *
        >>> # needs sage.libs.singular
        >>> lp = LatticePolytope([(Integer(1),Integer(0),Integer(0)), (Integer(1),Integer(1),Integer(0)), (Integer(1),Integer(1),Integer(1)), (Integer(1),Integer(0),Integer(1)), (-Integer(2),-Integer(1),-Integer(1))],
        ...                      lattice=ToricLattice(Integer(3)))
        >>> X = CPRFanoToricVariety(Delta_polar=lp, names=('x', 'y', 'u', 'v', 't',)); (x, y, u, v, t,) = X._first_ngens(5)
        >>> Y = X.subscheme(x*v + y*u + t)
        >>> cone = Cone([(Integer(1),Integer(0),Integer(0)), (Integer(1),Integer(1),Integer(0)), (Integer(1),Integer(1),Integer(1)), (Integer(1),Integer(0),Integer(1))])
        >>> Y.is_smooth()
        True

  neighborhood(point)

    Return a toric algebraic scheme isomorphic to neighborhood of the `point`.

    INPUT:

    - `point` – a point of the toric algebraic scheme

    OUTPUT:

    An affine toric algebraic scheme (polynomial equations in an affine toric variety) with fixed `embedding_morphism()` and `embedding_center()`.

    EXAMPLES:

    Sage

        sage: # needs sage.libs.singular
        sage: P.<x,y,z> = toric_varieties.P2()
        sage: S = P.subscheme(x + 2*y + 3*z)
        sage: s = S.point([0,-3,2]); s
        [0 : -3 : 2]
        sage: patch = S.neighborhood(s); patch
        Closed subscheme of 2-d affine toric variety defined by:
          x + 2*y + 6
        sage: patch.embedding_morphism()
        Scheme morphism:
          From: Closed subscheme of 2-d affine toric variety defined by: x + 2*y + 6
          To:   Closed subscheme of 2-d CPR-Fano toric variety
                covered by 3 affine patches defined by: x + 2*y + 3*z
          Defn: Defined on coordinates by sending [x : y] to [-2*y - 6 : y : 2]
        sage: patch.embedding_center()
        [0 : -3]
        sage: patch.embedding_morphism()(patch.embedding_center())
        [0 : -3 : 2]

    Python

        >>> from sage.all import *
        >>> # needs sage.libs.singular
        >>> P = toric_varieties.P2(names=('x', 'y', 'z',)); (x, y, z,) = P._first_ngens(3)
        >>> S = P.subscheme(x + Integer(2)*y + Integer(3)*z)
        >>> s = S.point([Integer(0),-Integer(3),Integer(2)]); s
        [0 : -3 : 2]
        >>> patch = S.neighborhood(s); patch
        Closed subscheme of 2-d affine toric variety defined by:
          x + 2*y + 6
        >>> patch.embedding_morphism()
        Scheme morphism:
          From: Closed subscheme of 2-d affine toric variety defined by: x + 2*y + 6
          To:   Closed subscheme of 2-d CPR-Fano toric variety
                covered by 3 affine patches defined by: x + 2*y + 3*z
          Defn: Defined on coordinates by sending [x : y] to [-2*y - 6 : y : 2]
        >>> patch.embedding_center()
        [0 : -3]
        >>> patch.embedding_morphism()(patch.embedding_center())
        [0 : -3 : 2]

    A more complicated example:

    Sage

        sage: # needs sage.libs.singular
        sage: dP6.<x0,x1,x2,x3,x4,x5> = toric_varieties.dP6()
        sage: twoP1 = dP6.subscheme(x0*x3)
        sage: patch = twoP1.neighborhood([0,1,2, 3,4,5]); patch
        Closed subscheme of 2-d affine toric variety defined by:
          3*x0
        sage: patch.embedding_morphism()
        Scheme morphism:
          From: Closed subscheme of 2-d affine toric variety defined by: 3*x0
          To:   Closed subscheme of 2-d CPR-Fano toric variety
                covered by 6 affine patches defined by: x0*x3
          Defn: Defined on coordinates by sending [x0 : x1] to [0 : x1 : 2 : 3 : 4 : 5]
        sage: patch.embedding_center()
        [0 : 1]
        sage: patch.embedding_morphism()(patch.embedding_center())
        [0 : 1 : 2 : 3 : 4 : 5]

    [Python]

        >>> from sage.all import *
        >>> # needs sage.libs.singular
        >>> dP6 = toric_varieties.dP6(names=('x0', 'x1', 'x2', 'x3', 'x4', 'x5',)); (x0, x1, x2, x3, x4, x5,) = dP6._first_ngens(6)
        >>> twoP1 = dP6.subscheme(x0*x3)
        >>> patch = twoP1.neighborhood([Integer(0),Integer(1),Integer(2), Integer(3),Integer(4),Integer(5)]); patch
        Closed subscheme of 2-d affine toric variety defined by:
          3*x0
        >>> patch.embedding_morphism()
        Scheme morphism:
          From: Closed subscheme of 2-d affine toric variety defined by: 3*x0
          To:   Closed subscheme of 2-d CPR-Fano toric variety
                covered by 6 affine patches defined by: x0*x3
          Defn: Defined on coordinates by sending [x0 : x1] to [0 : x1 : 2 : 3 : 4 : 5]
        >>> patch.embedding_center()
        [0 : 1]
        >>> patch.embedding_morphism()(patch.embedding_center())
        [0 : 1 : 2 : 3 : 4 : 5]