Interface to Singular - Interpreter Interfaces

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

# Interface to Singular

## Introduction

This interface is extremely flexible, since it’s exactly like typing into the Singular interpreter, and anything that works there should work here.

The Singular interface will only work if Singular is installed on your computer; this should be the case, since Singular is included with Sage. The interface offers three pieces of functionality:

1. `singular_console()` – a function that dumps you into an interactive command-line Singular session.

2. `singular(expr, type='def')` – creation of a Singular object. This provides a Pythonic interface to Singular. For example, if `f=singular(10)`, then `f.factorize()` returns the factorization of \(10\) computed using Singular.

3. `singular.eval(expr)` – evaluation of arbitrary Singular expressions, with the result returned as a string.

Of course, there are polynomial rings and ideals in Sage as well (often based on a C-library interface to Singular). One can convert an object in the Singular interpreter interface to Sage by the method `sage()`.

## Tutorial

EXAMPLES: First we illustrate multivariate polynomial factorization:

Sage

    sage: R1 = singular.ring(0, '(x,y)', 'dp')
    sage: R1
    polynomial ring, over a field, global ordering
    // coefficients: QQ...
    // number of vars : 2
    //        block   1 : ordering dp
    //                  : names    x y
    //        block   2 : ordering C
    sage: f = singular('9x16 - 18x13y2 - 9x12y3 + 9x10y4 - 18x11y2 + 36x8y4 + 18x7y5 - 18x5y6 + 9x6y4 - 18x3y6 - 9x2y7 + 9y8')
    sage: f
    9*x^16-18*x^13*y^2-9*x^12*y^3+9*x^10*y^4-18*x^11*y^2+36*x^8*y^4+18*x^7*y^5-18*x^5*y^6+9*x^6*y^4-18*x^3*y^6-9*x^2*y^7+9*y^8
    sage: f.parent()
    Singular

Python

    >>> from sage.all import *
    >>> R1 = singular.ring(Integer(0), '(x,y)', 'dp')
    >>> R1
    polynomial ring, over a field, global ordering
    // coefficients: QQ...
    // number of vars : 2
    //        block   1 : ordering dp
    //                  : names    x y
    //        block   2 : ordering C
    >>> f = singular('9x16 - 18x13y2 - 9x12y3 + 9x10y4 - 18x11y2 + 36x8y4 + 18x7y5 - 18x5y6 + 9x6y4 - 18x3y6 - 9x2y7 + 9y8')
    >>> f
    9*x^16-18*x^13*y^2-9*x^12*y^3+9*x^10*y^4-18*x^11*y^2+36*x^8*y^4+18*x^7*y^5-18*x^5*y^6+9*x^6*y^4-18*x^3*y^6-9*x^2*y^7+9*y^8
    >>> f.parent()
    Singular

Sage

    sage: F = f.factorize(); F
    [1]:
       _[1]=9
       _[2]=x^6-2*x^3*y^2-x^2*y^3+y^4
       _[3]=-x^5+y^2
    [2]:
       1,1,2

[Python]

    >>> from sage.all import *
    >>> F = f.factorize(); F
    [1]:
       _[1]=9
       _[2]=x^6-2*x^3*y^2-x^2*y^3+y^4
       _[3]=-x^5+y^2
    [2]:
       1,1,2

Sage

    sage: F[1]
    9,
    x^6-2*x^3*y^2-x^2*y^3+y^4,
    -x^5+y^2
    sage: F[1][2]
    x^6-2*x^3*y^2-x^2*y^3+y^4

Python

    >>> from sage.all import *
    >>> F[Integer(1)]
    9,
    x^6-2*x^3*y^2-x^2*y^3+y^4,
    -x^5+y^2
    >>> F[Integer(1)][Integer(2)]
    x^6-2*x^3*y^2-x^2*y^3+y^4

We can convert \(f\) and each exponent back to Sage objects as well.

Sage

    sage: g = f.sage(); g
    9*x^16 - 18*x^13*y^2 - 9*x^12*y^3 + 9*x^10*y^4 - 18*x^11*y^2 + 36*x^8*y^4 + 18*x^7*y^5 - 18*x^5*y^6 + 9*x^6*y^4 - 18*x^3*y^6 - 9*x^2*y^7 + 9*y^8
    sage: F[1][2].sage()
    x^6 - 2*x^3*y^2 - x^2*y^3 + y^4
    sage: g.parent()
    Multivariate Polynomial Ring in x, y over Rational Field

[Python]

    >>> from sage.all import *
    >>> g = f.sage(); g
    9*x^16 - 18*x^13*y^2 - 9*x^12*y^3 + 9*x^10*y^4 - 18*x^11*y^2 + 36*x^8*y^4 + 18*x^7*y^5 - 18*x^5*y^6 + 9*x^6*y^4 - 18*x^3*y^6 - 9*x^2*y^7 + 9*y^8
    >>> F[Integer(1)][Integer(2)].sage()
    x^6 - 2*x^3*y^2 - x^2*y^3 + y^4
    >>> g.parent()
    Multivariate Polynomial Ring in x, y over Rational Field

This example illustrates polynomial GCD’s:

Sage

    sage: R2 = singular.ring(0, '(x,y,z)', 'lp')
    sage: a = singular.new('3x2*(x+y)')
    sage: b = singular.new('9x*(y2-x2)')
    sage: g = a.gcd(b)
    sage: g
    x^2+x*y

Python

    >>> from sage.all import *
    >>> R2 = singular.ring(Integer(0), '(x,y,z)', 'lp')
    >>> a = singular.new('3x2*(x+y)')
    >>> b = singular.new('9x*(y2-x2)')
    >>> g = a.gcd(b)
    >>> g
    x^2+x*y

This example illustrates computation of a Groebner basis:

Sage

    sage: R3 = singular.ring(0, '(a,b,c,d)', 'lp')
    sage: I = singular.ideal(['a + b + c + d', 'a*b + a*d + b*c + c*d', 'a*b*c + a*b*d + a*c*d + b*c*d', 'a*b*c*d - 1'])
    sage: I2 = I.groebner()
    sage: I2
    c^2*d^6-c^2*d^2-d^4+1,
    c^3*d^2+c^2*d^3-c-d,
    b*d^4-b+d^5-d,
    b*c-b*d^5+c^2*d^4+c*d-d^6-d^2,
    b^2+2*b*d+d^2,
    a+b+c+d

[Python]

    >>> from sage.all import *
    >>> R3 = singular.ring(Integer(0), '(a,b,c,d)', 'lp')
    >>> I = singular.ideal(['a + b + c + d', 'a*b + a*d + b*c + c*d', 'a*b*c + a*b*d + a*c*d + b*c*d', 'a*b*c*d - 1'])
    >>> I2 = I.groebner()
    >>> I2
    c^2*d^6-c^2*d^2-d^4+1,
    c^3*d^2+c^2*d^3-c-d,
    b*d^4-b+d^5-d,
    b*c-b*d^5+c^2*d^4+c*d-d^6-d^2,
    b^2+2*b*d+d^2,
    a+b+c+d

The following example is the same as the one in the Singular - Gap interface documentation:

Sage

    sage: R  = singular.ring(0, '(x0,x1,x2)', 'lp')
    sage: I1 = singular.ideal(['x0*x1*x2 -x0^2*x2', 'x0^2*x1*x2-x0*x1^2*x2-x0*x1*x2^2', 'x0*x1-x0*x2-x1*x2'])
    sage: I2 = I1.groebner()
    sage: I2
    x1^2*x2^2,
    x0*x2^3-x1^2*x2^2+x1*x2^3,
    x0*x1-x0*x2-x1*x2,
    x0^2*x2-x0*x2^2-x1*x2^2
    sage: I2.sage()
    Ideal (x1^2*x2^2, x0*x2^3 - x1^2*x2^2 + x1*x2^3, x0*x1 - x0*x2 - x1*x2, x0^2*x2 - x0*x2^2 - x1*x2^2) of Multivariate Polynomial Ring in x0, x1, x2 over Rational Field

Python

    >>> from sage.all import *
    >>> R  = singular.ring(Integer(0), '(x0,x1,x2)', 'lp')
    >>> I1 = singular.ideal(['x0*x1*x2 -x0^2*x2', 'x0^2*x1*x2-x0*x1^2*x2-x0*x1*x2^2', 'x0*x1-x0*x2-x1*x2'])
    >>> I2 = I1.groebner()
    >>> I2
    x1^2*x2^2,
    x0*x2^3-x1^2*x2^2+x1*x2^3,
    x0*x1-x0*x2-x1*x2,
    x0^2*x2-x0*x2^2-x1*x2^2
    >>> I2.sage()
    Ideal (x1^2*x2^2, x0*x2^3 - x1^2*x2^2 + x1*x2^3, x0*x1 - x0*x2 - x1*x2, x0^2*x2 - x0*x2^2 - x1*x2^2) of Multivariate Polynomial Ring in x0, x1, x2 over Rational Field

This example illustrates moving a polynomial from one ring to another. It also illustrates calling a method of an object with an argument.

Sage

    sage: R = singular.ring(0, '(x,y,z)', 'dp')
    sage: f = singular('x3+y3+(x-y)*x2y2+z2')
    sage: f
    x^3*y^2-x^2*y^3+x^3+y^3+z^2
    sage: R1 = singular.ring(0, '(x,y,z)', 'ds')
    sage: f = R.fetch(f)
    sage: f
    z^2+x^3+y^3+x^3*y^2-x^2*y^3

[Python]

    >>> from sage.all import *
    >>> R = singular.ring(Integer(0), '(x,y,z)', 'dp')
    >>> f = singular('x3+y3+(x-y)*x2y2+z2')
    >>> f
    x^3*y^2-x^2*y^3+x^3+y^3+z^2
    >>> R1 = singular.ring(Integer(0), '(x,y,z)', 'ds')
    >>> f = R.fetch(f)
    >>> f
    z^2+x^3+y^3+x^3*y^2-x^2*y^3

We can calculate the Milnor number of \(f\):

Sage

    sage: _=singular.LIB('sing.lib')     # assign to _ to suppress printing
    sage: f.milnor()
    4

Python

    >>> from sage.all import *
    >>> _=singular.LIB('sing.lib')     # assign to _ to suppress printing
    >>> f.milnor()
    4

The Jacobian applied twice yields the Hessian matrix of \(f\), with which we can compute.

Sage

    sage: H = f.jacob().jacob()
    sage: H
    6*x+6*x*y^2-2*y^3,6*x^2*y-6*x*y^2,  0,
    6*x^2*y-6*x*y^2,  6*y+2*x^3-6*x^2*y,0,
    0,                0,                2
    sage: H.sage()
    [6*x + 6*x*y^2 - 2*y^3     6*x^2*y - 6*x*y^2                     0]
    [    6*x^2*y - 6*x*y^2 6*y + 2*x^3 - 6*x^2*y                     0]
    [                    0                     0                     2]
    sage: H.det()   # This is a polynomial in Singular
    72*x*y+24*x^4-72*x^3*y+72*x*y^3-24*y^4-48*x^4*y^2+64*x^3*y^3-48*x^2*y^4
    sage: H.det().sage()   # This is the corresponding polynomial in Sage
    72*x*y + 24*x^4 - 72*x^3*y + 72*x*y^3 - 24*y^4 - 48*x^4*y^2 + 64*x^3*y^3 - 48*x^2*y^4

[Python]

    >>> from sage.all import *
    >>> H = f.jacob().jacob()
    >>> H
    6*x+6*x*y^2-2*y^3,6*x^2*y-6*x*y^2,  0,
    6*x^2*y-6*x*y^2,  6*y+2*x^3-6*x^2*y,0,
    0,                0,                2
    >>> H.sage()
    [6*x + 6*x*y^2 - 2*y^3     6*x^2*y - 6*x*y^2                     0]
    [    6*x^2*y - 6*x*y^2 6*y + 2*x^3 - 6*x^2*y                     0]
    [                    0                     0                     2]
    >>> H.det()   # This is a polynomial in Singular
    72*x*y+24*x^4-72*x^3*y+72*x*y^3-24*y^4-48*x^4*y^2+64*x^3*y^3-48*x^2*y^4
    >>> H.det().sage()   # This is the corresponding polynomial in Sage
    72*x*y + 24*x^4 - 72*x^3*y + 72*x*y^3 - 24*y^4 - 48*x^4*y^2 + 64*x^3*y^3 - 48*x^2*y^4

The 1x1 and 2x2 minors:

Sage

    sage: H.minor(1)
    2,
    6*y+2*x^3-6*x^2*y,
    6*x^2*y-6*x*y^2,
    6*x^2*y-6*x*y^2,
    6*x+6*x*y^2-2*y^3,
    0,
    0,
    0,
    0
    sage: H.minor(2)
    12*y+4*x^3-12*x^2*y,
    12*x^2*y-12*x*y^2,
    12*x^2*y-12*x*y^2,
    12*x+12*x*y^2-4*y^3,
    -36*x*y-12*x^4+36*x^3*y-36*x*y^3+12*y^4+24*x^4*y^2-32*x^3*y^3+24*x^2*y^4,
    0,
    0,
    0,
    0

Python

    >>> from sage.all import *
    >>> H.minor(Integer(1))
    2,
    6*y+2*x^3-6*x^2*y,
    6*x^2*y-6*x*y^2,
    6*x^2*y-6*x*y^2,
    6*x+6*x*y^2-2*y^3,
    0,
    0,
    0,
    0
    >>> H.minor(Integer(2))
    12*y+4*x^3-12*x^2*y,
    12*x^2*y-12*x*y^2,
    12*x^2*y-12*x*y^2,
    12*x+12*x*y^2-4*y^3,
    -36*x*y-12*x^4+36*x^3*y-36*x*y^3+12*y^4+24*x^4*y^2-32*x^3*y^3+24*x^2*y^4,
    0,
    0,
    0,
    0

Sage

    sage: _=singular.eval('option(redSB)')
    sage: H.minor(1).groebner()
    1

[Python]

    >>> from sage.all import *
    >>> _=singular.eval('option(redSB)')
    >>> H.minor(Integer(1)).groebner()
    1

## Computing the Genus

We compute the projective genus of ideals that define curves over \(\QQ\). It is very important to load the `normal.lib` library before calling the `genus` command, or you’ll get an error message.

EXAMPLES:

Sage

    sage: singular.lib('normal.lib')
    sage: R = singular.ring(0,'(x,y)','dp')
    sage: i2 = singular.ideal('y9 - x2*(x-1)^9 + x')
    sage: i2.genus()
    40

Python

    >>> from sage.all import *
    >>> singular.lib('normal.lib')
    >>> R = singular.ring(Integer(0),'(x,y)','dp')
    >>> i2 = singular.ideal('y9 - x2*(x-1)^9 + x')
    >>> i2.genus()
    40

Note that the genus can be much smaller than the degree:

Sage

    sage: i = singular.ideal('y9 - x2*(x-1)^9')
    sage: i.genus()
    0

[Python]

    >>> from sage.all import *
    >>> i = singular.ideal('y9 - x2*(x-1)^9')
    >>> i.genus()
    0

## An Important Concept

The following illustrates an important concept: how Sage interacts with the data being used and returned by Singular. Let’s compute a Groebner basis for some ideal, using Singular through Sage.

Sage

    sage: singular.lib('polylib.lib')
    sage: singular.ring(32003, '(a,b,c,d,e,f)', 'lp')
    polynomial ring, over a field, global ordering
    // coefficients: ZZ/32003...
    // number of vars : 6
    //        block   1 : ordering lp
    //                        : names    a b c d e f
    //        block   2 : ordering C
    sage: I = singular.ideal('cyclic(6)')
    sage: g = singular('groebner(I)')
    Traceback (most recent call last):
    ...
    TypeError: Singular error:
    ...

Python

    >>> from sage.all import *
    >>> singular.lib('polylib.lib')
    >>> singular.ring(Integer(32003), '(a,b,c,d,e,f)', 'lp')
    polynomial ring, over a field, global ordering
    // coefficients: ZZ/32003...
    // number of vars : 6
    //        block   1 : ordering lp
    //                        : names    a b c d e f
    //        block   2 : ordering C
    >>> I = singular.ideal('cyclic(6)')
    >>> g = singular('groebner(I)')
    Traceback (most recent call last):
    ...
    TypeError: Singular error:
    ...

We restart everything and try again, but correctly.

Sage

    sage: singular.quit()
    sage: singular.lib('polylib.lib'); R = singular.ring(32003, '(a,b,c,d,e,f)', 'lp')
    sage: I = singular.ideal('cyclic(6)')
    sage: I.groebner()
    f^48-2554*f^42-15674*f^36+12326*f^30-12326*f^18+15674*f^12+2554*f^6-1,
    ...

[Python]

    >>> from sage.all import *
    >>> singular.quit()
    >>> singular.lib('polylib.lib'); R = singular.ring(Integer(32003), '(a,b,c,d,e,f)', 'lp')
    >>> I = singular.ideal('cyclic(6)')
    >>> I.groebner()
    f^48-2554*f^42-15674*f^36+12326*f^30-12326*f^18+15674*f^12+2554*f^6-1,
    ...

It’s important to understand why the first attempt at computing a basis failed. The line where we gave singular the input ‘groebner(I)’ was useless because Singular has no idea what ‘I’ is! Although ‘I’ is an object that we computed with calls to Singular functions, it actually lives in Sage. As a consequence, the name ‘I’ means nothing to Singular. When we called `I.groebner()`, Sage was able to call the groebner function on ‘I’ in Singular, since ‘I’ actually means something to Sage.

## Long Input

The Singular interface reads in even very long input (using files) in a robust manner, as long as you are creating a new object.

Sage

    sage: t = '"%s"'%10^15000   # 15 thousand character string (note that normal Singular input must be at most 10000)
    sage: a = singular.eval(t)
    sage: a = singular(t)

Python

    >>> from sage.all import *
    >>> t = '"%s"'%Integer(10)**Integer(15000)   # 15 thousand character string (note that normal Singular input must be at most 10000)
    >>> a = singular.eval(t)
    >>> a = singular(t)

AUTHORS:

- David Joyner and William Stein (2005): first version

- Neal Harris (unknown): perhaps added “An Important Concept”

- Martin Albrecht (2006-03-05): code so singular.[tab] and x = singular(…), x.[tab] includes all singular commands.

- Martin Albrecht (2006-03-06): This patch adds the equality symbol to singular. Also fix a problem in which “ “ as prompt means comparison will break all further communication with Singular.

- Martin Albrecht (2006-03-13): added current_ring() and current_ring_name()

- William Stein (2006-04-10): Fixed problems with ideal constructor

- Martin Albrecht (2006-05-18): added sage_poly.

- Simon King (2010-11-23): Reduce the overhead caused by waiting for the Singular prompt by doing garbage collection differently.

- Simon King (2011-06-06): Make conversion from Singular to Sage more flexible.

- Simon King (2015): Extend pickling capabilities.

class sage.interfaces.singular.Singular(maxread=None, script_subdirectory=None, logfile=None, server=None, server_tmpdir=None, seed=None)

  Bases: `ExtraTabCompletion`, `Expect`

  Interface to the Singular interpreter.

  EXAMPLES: A Groebner basis example.

  Sage

      sage: R = singular.ring(0, '(x0,x1,x2)', 'lp')
      sage: I = singular.ideal([ 'x0*x1*x2 -x0^2*x2', 'x0^2*x1*x2-x0*x1^2*x2-x0*x1*x2^2', 'x0*x1-x0*x2-x1*x2'])
      sage: I.groebner()
      x1^2*x2^2,
      x0*x2^3-x1^2*x2^2+x1*x2^3,
      x0*x1-x0*x2-x1*x2,
      x0^2*x2-x0*x2^2-x1*x2^2

  Python

      >>> from sage.all import *
      >>> R = singular.ring(Integer(0), '(x0,x1,x2)', 'lp')
      >>> I = singular.ideal([ 'x0*x1*x2 -x0^2*x2', 'x0^2*x1*x2-x0*x1^2*x2-x0*x1*x2^2', 'x0*x1-x0*x2-x1*x2'])
      >>> I.groebner()
      x1^2*x2^2,
      x0*x2^3-x1^2*x2^2+x1*x2^3,
      x0*x1-x0*x2-x1*x2,
      x0^2*x2-x0*x2^2-x1*x2^2

  AUTHORS:

  - David Joyner and William Stein

  LIB(lib, reload=False)

    alias of `lib()`.

  clear(var)

    Clear the variable named `var`.

    EXAMPLES:

    Sage

        sage: singular.set('int', 'x', '2')
        sage: singular.get('x')
        '2'
        sage: singular.clear('x')

    Python

        >>> from sage.all import *
        >>> singular.set('int', 'x', '2')
        >>> singular.get('x')
        '2'
        >>> singular.clear('x')

    “Clearing the variable” means to allow to free the memory that it uses in the Singular sub-process. However, the actual deletion of the variable is only committed when the next element in the Singular interface is created:

    Sage

        sage: singular.get('x')
        '2'
        sage: a = singular(3)
        sage: singular.get('x')
        '`x`'

    [Python]

        >>> from sage.all import *
        >>> singular.get('x')
        '2'
        >>> a = singular(Integer(3))
        >>> singular.get('x')
        '`x`'

  console()

    EXAMPLES:

    Sage

        sage: singular_console() #not tested
                             SINGULAR                             /  Development
         A Computer Algebra System for Polynomial Computations   /   version 3-0-4
                                                               0<
             by: G.-M. Greuel, G. Pfister, H. Schoenemann        \   Nov 2007
        FB Mathematik der Universitaet, D-67653 Kaiserslautern    \

    Python

        >>> from sage.all import *
        >>> singular_console() #not tested
                             SINGULAR                             /  Development
         A Computer Algebra System for Polynomial Computations   /   version 3-0-4
                                                               0<
             by: G.-M. Greuel, G. Pfister, H. Schoenemann        \   Nov 2007
        FB Mathematik der Universitaet, D-67653 Kaiserslautern    \

  cputime(t=None)

    Return the amount of CPU time that the Singular session has used. If `t` is not None, then it returns the difference between the current CPU time and `t`.

    EXAMPLES:

    Sage

        sage: t = singular.cputime()
        sage: R = singular.ring(0, '(x0,x1,x2)', 'lp')
        sage: I = singular.ideal([ 'x0*x1*x2 -x0^2*x2', 'x0^2*x1*x2-x0*x1^2*x2-x0*x1*x2^2', 'x0*x1-x0*x2-x1*x2'])
        sage: gb = I.groebner()
        sage: singular.cputime(t) #random
        0.02

    Python

        >>> from sage.all import *
        >>> t = singular.cputime()
        >>> R = singular.ring(Integer(0), '(x0,x1,x2)', 'lp')
        >>> I = singular.ideal([ 'x0*x1*x2 -x0^2*x2', 'x0^2*x1*x2-x0*x1^2*x2-x0*x1*x2^2', 'x0*x1-x0*x2-x1*x2'])
        >>> gb = I.groebner()
        >>> singular.cputime(t) #random
        0.02

  current_ring()

    Return the current ring of the running Singular session.

    EXAMPLES:

    Sage

        sage: r = PolynomialRing(GF(127),3,'xyz', order='invlex')
        sage: r._singular_()
        polynomial ring, over a field, global ordering
        // coefficients: ZZ/127...
        // number of vars : 3
        //        block   1 : ordering ip
        //                  : names    x y z
        //        block   2 : ordering C
        sage: singular.current_ring()
        polynomial ring, over a field, global ordering
        // coefficients: ZZ/127...
        // number of vars : 3
        //        block   1 : ordering ip
        //                  : names    x y z
        //        block   2 : ordering C

    Python

        >>> from sage.all import *
        >>> r = PolynomialRing(GF(Integer(127)),Integer(3),'xyz', order='invlex')
        >>> r._singular_()
        polynomial ring, over a field, global ordering
        // coefficients: ZZ/127...
        // number of vars : 3
        //        block   1 : ordering ip
        //                  : names    x y z
        //        block   2 : ordering C
        >>> singular.current_ring()
        polynomial ring, over a field, global ordering
        // coefficients: ZZ/127...
        // number of vars : 3
        //        block   1 : ordering ip
        //                  : names    x y z
        //        block   2 : ordering C

  current_ring_name()

    Return the Singular name of the currently active ring in Singular.

    OUTPUT: currently active ring’s name

    EXAMPLES:

    Sage

        sage: r = PolynomialRing(GF(127),3,'xyz')
        sage: r._singular_().name() == singular.current_ring_name()
        True

    Python

        >>> from sage.all import *
        >>> r = PolynomialRing(GF(Integer(127)),Integer(3),'xyz')
        >>> r._singular_().name() == singular.current_ring_name()
        True

  eval(x, allow_semicolon=True, strip=True, **kwds)

    Send the code x to the Singular interpreter and return the output as a string.

    INPUT:

    - `x` – string (of code)

    - `allow_semicolon` – (default: `False`) if `False` then raise a `TypeError` if the input line contains a semicolon

    - `strip` – ignored

    EXAMPLES:

    Sage

        sage: singular.eval('2 > 1')
        '1'
        sage: singular.eval('2 + 2')
        '4'

    Python

        >>> from sage.all import *
        >>> singular.eval('2 > 1')
        '1'
        >>> singular.eval('2 + 2')
        '4'

    if the verbosity level is \(> 1\) comments are also printed and not only returned.

    Sage

        sage: r = singular.ring(0,'(x,y,z)','dp')
        sage: i = singular.ideal(['x^2','y^2','z^2'])
        sage: s = i.std()
        sage: singular.eval('hilb(%s)'%(s.name()))
        '...// dimension (affine) = 0\n//
        degree (affine) = 8'

    [Python]

        >>> from sage.all import *
        >>> r = singular.ring(Integer(0),'(x,y,z)','dp')
        >>> i = singular.ideal(['x^2','y^2','z^2'])
        >>> s = i.std()
        >>> singular.eval('hilb(%s)'%(s.name()))
        '...// dimension (affine) = 0\n//
        degree (affine) = 8'

    Sage

        sage: from sage.misc.verbose import set_verbose
        sage: set_verbose(1)
        sage: o = singular.eval('hilb(%s)'%(s.name()))
        ...// dimension (affine) = 0
        // degree (affine)  = 8

    Python

        >>> from sage.all import *
        >>> from sage.misc.verbose import set_verbose
        >>> set_verbose(Integer(1))
        >>> o = singular.eval('hilb(%s)'%(s.name()))
        ...// dimension (affine) = 0
        // degree (affine)  = 8

    This is mainly useful if this method is called implicitly. Because then intermediate results, debugging outputs and printed statements are printed

    Sage

        sage: o = s.hilb()
        ...// dimension (affine) = 0
        // degree (affine)  = 8
        // ** right side is not a datum, assignment...ignored
        ...

    [Python]

        >>> from sage.all import *
        >>> o = s.hilb()
        ...// dimension (affine) = 0
        // degree (affine)  = 8
        // ** right side is not a datum, assignment...ignored
        ...

    rather than ignored

    Sage

        sage: set_verbose(0)
        sage: o = s.hilb()

    Python

        >>> from sage.all import *
        >>> set_verbose(Integer(0))
        >>> o = s.hilb()

  get(var)

    Get string representation of variable named var.

    EXAMPLES:

    Sage

        sage: singular.set('int', 'x', '2')
        sage: singular.get('x')
        '2'

    Python

        >>> from sage.all import *
        >>> singular.set('int', 'x', '2')
        >>> singular.get('x')
        '2'

  ideal(*gens)

    Return the ideal generated by gens.

    INPUT:

    - `gens` – list or tuple of Singular objects (or objects that can be made into Singular objects via evaluation)

    OUTPUT: the Singular ideal generated by the given list of gens

    EXAMPLES: A Groebner basis example done in a different way.

    Sage

        sage: _ = singular.eval("ring R=0,(x0,x1,x2),lp")
        sage: i1 = singular.ideal([ 'x0*x1*x2 -x0^2*x2', 'x0^2*x1*x2-x0*x1^2*x2-x0*x1*x2^2', 'x0*x1-x0*x2-x1*x2'])
        sage: i1
        -x0^2*x2+x0*x1*x2,
        x0^2*x1*x2-x0*x1^2*x2-x0*x1*x2^2,
        x0*x1-x0*x2-x1*x2

    Python

        >>> from sage.all import *
        >>> _ = singular.eval("ring R=0,(x0,x1,x2),lp")
        >>> i1 = singular.ideal([ 'x0*x1*x2 -x0^2*x2', 'x0^2*x1*x2-x0*x1^2*x2-x0*x1*x2^2', 'x0*x1-x0*x2-x1*x2'])
        >>> i1
        -x0^2*x2+x0*x1*x2,
        x0^2*x1*x2-x0*x1^2*x2-x0*x1*x2^2,
        x0*x1-x0*x2-x1*x2

    Sage

        sage: i2 = singular.ideal('groebner(%s);'%i1.name())
        sage: i2
        x1^2*x2^2,
        x0*x2^3-x1^2*x2^2+x1*x2^3,
        x0*x1-x0*x2-x1*x2,
        x0^2*x2-x0*x2^2-x1*x2^2

    [Python]

        >>> from sage.all import *
        >>> i2 = singular.ideal('groebner(%s);'%i1.name())
        >>> i2
        x1^2*x2^2,
        x0*x2^3-x1^2*x2^2+x1*x2^3,
        x0*x1-x0*x2-x1*x2,
        x0^2*x2-x0*x2^2-x1*x2^2

  lib(lib, reload=False)

    Load the Singular library named lib.

    Note that if the library was already loaded during this session it is not reloaded unless the optional reload argument is `True` (the default is `False`).

    EXAMPLES:

    Sage

        sage: singular.lib('sing.lib')
        sage: singular.lib('sing.lib', reload=True)

    Python

        >>> from sage.all import *
        >>> singular.lib('sing.lib')
        >>> singular.lib('sing.lib', reload=True)

  list(x)

    Create a list in Singular from a Sage list `x`.

    EXAMPLES:

    Sage

        sage: singular.list([1,2])
        [1]:
           1
        [2]:
           2

        sage: singular.list([1,2,[3,4]])
        [1]:
           1
        [2]:
           2
        [3]:
           [1]:
              3
           [2]:
              4

        sage: R.<x,y> = QQ[]
        sage: singular.list([1,2,[x,ideal(x,y)]])
        [1]:
           1
        [2]:
           2
        [3]:
           [1]:
              x
           [2]:
              _[1]=x
              _[2]=y

    Python

        >>> from sage.all import *
        >>> singular.list([Integer(1),Integer(2)])
        [1]:
           1
        [2]:
           2

        >>> singular.list([Integer(1),Integer(2),[Integer(3),Integer(4)]])
        [1]:
           1
        [2]:
           2
        [3]:
           [1]:
              3
           [2]:
              4

        >>> R = QQ['x, y']; (x, y,) = R._first_ngens(2)
        >>> singular.list([Integer(1),Integer(2),[x,ideal(x,y)]])
        [1]:
           1
        [2]:
           2
        [3]:
           [1]:
              x
           [2]:
              _[1]=x
              _[2]=y

    Strings have to be escaped before passing them to this method:

    Sage

        sage: singular.list([1,2,'"hi"'])
        [1]:
           1
        [2]:
           2
        [3]:
           hi

    [Python]

        >>> from sage.all import *
        >>> singular.list([Integer(1),Integer(2),'"hi"'])
        [1]:
           1
        [2]:
           2
        [3]:
           hi

  load(lib, reload=False)

    alias of `lib()`.

  matrix(nrows, ncols, entries=None)

    EXAMPLES:

    Sage

        sage: singular.lib("matrix")
        sage: R = singular.ring(0, '(x,y,z)', 'dp')
        sage: A = singular.matrix(3,2,'1,2,3,4,5,6')
        sage: A
        1,2,
        3,4,
        5,6
        sage: A.gauss_col()
        2,-1,
        1,0,
        0,1

    Python

        >>> from sage.all import *
        >>> singular.lib("matrix")
        >>> R = singular.ring(Integer(0), '(x,y,z)', 'dp')
        >>> A = singular.matrix(Integer(3),Integer(2),'1,2,3,4,5,6')
        >>> A
        1,2,
        3,4,
        5,6
        >>> A.gauss_col()
        2,-1,
        1,0,
        0,1

    AUTHORS:

    - Martin Albrecht (2006-01-14)

  option(cmd=None, val=None)

    Access to Singular’s options as follows:

    Syntax: option() Returns a string of all defined options.

    Syntax: option( ‘option_name’ ) Sets an option. Note to disable an option, use the prefix no.

    Syntax: option( ‘get’ ) Returns an intvec of the state of all options.

    Syntax: option( ‘set’, intvec_expression ) Restores the state of all options from an intvec (produced by option(‘get’)).

    EXAMPLES:

    Sage

        sage: singular.option()
        //options: redefine loadLib usage prompt
        sage: singular.option('get')
        0,
        10321
        sage: old_options = _
        sage: singular.option('noredefine')
        sage: singular.option()
        //options: loadLib usage prompt
        sage: singular.option('set', old_options)
        sage: singular.option('get')
        0,
        10321

    Python

        >>> from sage.all import *
        >>> singular.option()
        //options: redefine loadLib usage prompt
        >>> singular.option('get')
        0,
        10321
        >>> old_options = _
        >>> singular.option('noredefine')
        >>> singular.option()
        //options: loadLib usage prompt
        >>> singular.option('set', old_options)
        >>> singular.option('get')
        0,
        10321

  ring(char=0, vars='(x)', order='lp')

    Create a Singular ring and makes it the current ring.

    INPUT:

    - `char` – string; a string specifying the characteristic of the base ring, in the format accepted by Singular (see examples below)

    - `vars` – tuple or string defining the variable names

    - `order` – string; the monomial order (default: `'lp'`)

    OUTPUT: a Singular ring

    Note

    This function is not identical to calling the Singular `ring` function. In particular, it also attempts to “kill” the variable names, so they can actually be used without getting errors, and it sets printing of elements for this range to short (i.e., with *’s and carets).

    EXAMPLES: We first declare \(\QQ[x,y,z]\) with degree reverse lexicographic ordering.

    Sage

        sage: R = singular.ring(0, '(x,y,z)', 'dp')
        sage: R
        polynomial ring, over a field, global ordering
        // coefficients: QQ...
        // number of vars : 3
        //        block   1 : ordering dp
        //                  : names    x y z
        //        block   2 : ordering C

    Python

        >>> from sage.all import *
        >>> R = singular.ring(Integer(0), '(x,y,z)', 'dp')
        >>> R
        polynomial ring, over a field, global ordering
        // coefficients: QQ...
        // number of vars : 3
        //        block   1 : ordering dp
        //                  : names    x y z
        //        block   2 : ordering C

    Sage

        sage: R1 = singular.ring(32003, '(x,y,z)', 'dp')
        sage: R2 = singular.ring(32003, '(a,b,c,d)', 'lp')

    [Python]

        >>> from sage.all import *
        >>> R1 = singular.ring(Integer(32003), '(x,y,z)', 'dp')
        >>> R2 = singular.ring(Integer(32003), '(a,b,c,d)', 'lp')

    This is a ring in variables named x(1) through x(10) over the finite field of order \(7\):

    Sage

        sage: R3 = singular.ring(7, '(x(1..10))', 'ds')

    Python

        >>> from sage.all import *
        >>> R3 = singular.ring(Integer(7), '(x(1..10))', 'ds')

    This is a polynomial ring over the transcendental extension \(\QQ(a)\) of \(\QQ\):

    Sage

        sage: R4 = singular.ring('(0,a)', '(mu,nu)', 'lp')

    [Python]

        >>> from sage.all import *
        >>> R4 = singular.ring('(0,a)', '(mu,nu)', 'lp')

    This is a ring over the field of single-precision floats:

    Sage

        sage: R5 = singular.ring('real', '(a,b)', 'lp')

    Python

        >>> from sage.all import *
        >>> R5 = singular.ring('real', '(a,b)', 'lp')

    This is over 50-digit floats:

    Sage

        sage: R6 = singular.ring('(real,50)', '(a,b)', 'lp')
        sage: R7 = singular.ring('(complex,50,i)', '(a,b)', 'lp')

    [Python]

        >>> from sage.all import *
        >>> R6 = singular.ring('(real,50)', '(a,b)', 'lp')
        >>> R7 = singular.ring('(complex,50,i)', '(a,b)', 'lp')

    To use a ring that you’ve defined, use the set_ring() method on the ring. This sets the ring to be the “current ring”. For example,

    Sage

        sage: R = singular.ring(7, '(a,b)', 'ds')
        sage: S = singular.ring('real', '(a,b)', 'lp')
        sage: singular.new('10*a')
        (1.000e+01)*a
        sage: R.set_ring()
        sage: singular.new('10*a')
        3*a

    Python

        >>> from sage.all import *
        >>> R = singular.ring(Integer(7), '(a,b)', 'ds')
        >>> S = singular.ring('real', '(a,b)', 'lp')
        >>> singular.new('10*a')
        (1.000e+01)*a
        >>> R.set_ring()
        >>> singular.new('10*a')
        3*a

  set(type, name, value)

    Set the variable with given name to the given value.

    REMARK:

    If a variable in the Singular interface was previously marked for deletion, the actual deletion is done here, before the new variable is created in Singular.

    EXAMPLES:

    Sage

        sage: singular.set('int', 'x', '2')
        sage: singular.get('x')
        '2'

    Python

        >>> from sage.all import *
        >>> singular.set('int', 'x', '2')
        >>> singular.get('x')
        '2'

    We test that an unused variable is only actually deleted if this method is called:

    Sage

        sage: a = singular(3)
        sage: n = a.name()
        sage: del a
        sage: singular.eval(n)
        '3'
        sage: singular.set('int', 'y', '5')
        sage: singular.eval('defined(%s)'%n)
        '0'

    [Python]

        >>> from sage.all import *
        >>> a = singular(Integer(3))
        >>> n = a.name()
        >>> del a
        >>> singular.eval(n)
        '3'
        >>> singular.set('int', 'y', '5')
        >>> singular.eval('defined(%s)'%n)
        '0'

  set_ring(R)

    Set the current Singular ring to \(R\).

    EXAMPLES:

    Sage

        sage: R = singular.ring(7, '(a,b)', 'ds')
        sage: S = singular.ring('real', '(a,b)', 'lp')
        sage: singular.current_ring()
        polynomial ring, over a field, global ordering
        // coefficients: Float()...
        // number of vars : 2
        //        block   1 : ordering lp
        //                  : names    a b
        //        block   2 : ordering C
        sage: singular.set_ring(R)
        sage: singular.current_ring()
        polynomial ring, over a field, local ordering
        // coefficients: ZZ/7...
        // number of vars : 2
        //        block   1 : ordering ds
        //                  : names    a b
        //        block   2 : ordering C

    Python

        >>> from sage.all import *
        >>> R = singular.ring(Integer(7), '(a,b)', 'ds')
        >>> S = singular.ring('real', '(a,b)', 'lp')
        >>> singular.current_ring()
        polynomial ring, over a field, global ordering
        // coefficients: Float()...
        // number of vars : 2
        //        block   1 : ordering lp
        //                  : names    a b
        //        block   2 : ordering C
        >>> singular.set_ring(R)
        >>> singular.current_ring()
        polynomial ring, over a field, local ordering
        // coefficients: ZZ/7...
        // number of vars : 2
        //        block   1 : ordering ds
        //                  : names    a b
        //        block   2 : ordering C

  set_seed(seed=None)

    Set the seed for singular interpreter.

    The seed should be an integer at least 1 and not more than 30 bits. See http://www.singular.uni-kl.de/Manual/html/sing_19.htm#SEC26 and http://www.singular.uni-kl.de/Manual/html/sing_283.htm#SEC323

    EXAMPLES:

    Sage

        sage: s = Singular()
        sage: s.set_seed(1)
        1
        sage: [s.random(1,10) for i in range(5)]
        [8, 10, 4, 9, 1]

    Python

        >>> from sage.all import *
        >>> s = Singular()
        >>> s.set_seed(Integer(1))
        1
        >>> [s.random(Integer(1),Integer(10)) for i in range(Integer(5))]
        [8, 10, 4, 9, 1]

  setring(R)

    alias of `set_ring()`.

  string(x)

    Create a Singular string from a Sage string. Note that the Sage string has to be “double-quoted”.

    EXAMPLES:

    Sage

        sage: singular.string('"Sage"')
        Sage

    Python

        >>> from sage.all import *
        >>> singular.string('"Sage"')
        Sage

  version()

    Return the version of Singular being used.

    EXAMPLES:

    Sage

        sage: singular.version()
        "Singular ... version 4...

    Python

        >>> from sage.all import *
        >>> singular.version()
        "Singular ... version 4...

class sage.interfaces.singular.SingularElement(parent, type, value, is_name=False)

  Bases: `ExtraTabCompletion`, `ExpectElement`, `SingularElement`

  EXAMPLES:

  Sage

      sage: a = singular(2)
      sage: loads(dumps(a))
      2

  Python

      >>> from sage.all import *
      >>> a = singular(Integer(2))
      >>> loads(dumps(a))
      2

  attrib(name, value=None)

    Get and set attributes for `self`.

    INPUT:

    - `name` – string to choose the attribute

    - `value` – boolean value or `None` for reading, (default: `None`)

    VALUES: isSB - the standard basis property is set by all commands computing a standard basis like groebner, std, stdhilb etc.; used by lift, dim, degree, mult, hilb, vdim, kbase isHomog - the weight vector for homogeneous or quasihomogeneous ideals/modules isCI - complete intersection property isCM - Cohen-Macaulay property rank - set the rank of a module (see nrows) withSB - value of type ideal, resp. module, is std withHilb - value of type intvec is hilb(_,1) (see hilb) withRes - value of type list is a free resolution withDim - value of type int is the dimension (see dim) withMult - value of type int is the multiplicity (see mult)

    EXAMPLES:

    Sage

        sage: P.<x,y,z> = PolynomialRing(QQ)
        sage: I = Ideal([z^2, y*z, y^2, x*z, x*y, x^2])
        sage: Ibar = I._singular_()
        sage: Ibar.attrib('isSB')
        0
        sage: singular.eval('vdim(%s)'%Ibar.name()) # sage7 name is random
        // ** sage7 is no standard basis
        4
        sage: Ibar.attrib('isSB',1)
        sage: singular.eval('vdim(%s)'%Ibar.name())
        '4'

    Python

        >>> from sage.all import *
        >>> P = PolynomialRing(QQ, names=('x', 'y', 'z',)); (x, y, z,) = P._first_ngens(3)
        >>> I = Ideal([z**Integer(2), y*z, y**Integer(2), x*z, x*y, x**Integer(2)])
        >>> Ibar = I._singular_()
        >>> Ibar.attrib('isSB')
        0
        >>> singular.eval('vdim(%s)'%Ibar.name()) # sage7 name is random
        // ** sage7 is no standard basis
        4
        >>> Ibar.attrib('isSB',Integer(1))
        >>> singular.eval('vdim(%s)'%Ibar.name())
        '4'

  is_string()

    Tell whether this element is a string.

    EXAMPLES:

    Sage

        sage: singular('"abc"').is_string()
        True
        sage: singular('1').is_string()
        False

    Python

        >>> from sage.all import *
        >>> singular('"abc"').is_string()
        True
        >>> singular('1').is_string()
        False

  sage_flattened_str_list()

    EXAMPLES:

    Sage

        sage: R=singular.ring(0,'(x,y)','dp')
        sage: RL = R.ringlist()
        sage: RL.sage_flattened_str_list()
        ['0', 'x', 'y', 'dp', '1,1', 'C', '0', '_[1]=0']

    Python

        >>> from sage.all import *
        >>> R=singular.ring(Integer(0),'(x,y)','dp')
        >>> RL = R.ringlist()
        >>> RL.sage_flattened_str_list()
        ['0', 'x', 'y', 'dp', '1,1', 'C', '0', '_[1]=0']

  sage_global_ring()

    Return the current basering in Singular as a polynomial ring or quotient ring.

    EXAMPLES:

    Sage

        sage: singular.eval('ring r1 = (9,x),(a,b,c,d,e,f),(M((1,2,3,0)),wp(2,3),lp)')
        ''
        sage: R = singular('r1').sage_global_ring()
        sage: R
        Multivariate Polynomial Ring in a, b, c, d, e, f over Finite Field in x of size 3^2
        sage: R.term_order()
        Block term order with blocks:
        (Matrix term order with matrix
        [1 2]
        [3 0],
         Weighted degree reverse lexicographic term order with weights (2, 3),
         Lexicographic term order of length 2)

    Python

        >>> from sage.all import *
        >>> singular.eval('ring r1 = (9,x),(a,b,c,d,e,f),(M((1,2,3,0)),wp(2,3),lp)')
        ''
        >>> R = singular('r1').sage_global_ring()
        >>> R
        Multivariate Polynomial Ring in a, b, c, d, e, f over Finite Field in x of size 3^2
        >>> R.term_order()
        Block term order with blocks:
        (Matrix term order with matrix
        [1 2]
        [3 0],
         Weighted degree reverse lexicographic term order with weights (2, 3),
         Lexicographic term order of length 2)

    Sage

        sage: singular.eval('ring r2 = (0,x),(a,b,c),dp')
        ''
        sage: singular('r2').sage_global_ring()
        Multivariate Polynomial Ring in a, b, c over Fraction Field of Univariate Polynomial Ring in x over Rational Field

    [Python]

        >>> from sage.all import *
        >>> singular.eval('ring r2 = (0,x),(a,b,c),dp')
        ''
        >>> singular('r2').sage_global_ring()
        Multivariate Polynomial Ring in a, b, c over Fraction Field of Univariate Polynomial Ring in x over Rational Field

    Sage

        sage: singular.eval('ring r3 = (3,z),(a,b,c),dp')
        ''
        sage: singular.eval('minpoly = 1+z+z2+z3+z4')
        ''
        sage: singular('r3').sage_global_ring()
        Multivariate Polynomial Ring in a, b, c over Finite Field in z of size 3^4

    Python

        >>> from sage.all import *
        >>> singular.eval('ring r3 = (3,z),(a,b,c),dp')
        ''
        >>> singular.eval('minpoly = 1+z+z2+z3+z4')
        ''
        >>> singular('r3').sage_global_ring()
        Multivariate Polynomial Ring in a, b, c over Finite Field in z of size 3^4

    Real and complex fields in both Singular and Sage are defined with a precision. The precision in Singular is given in terms of digits, but in Sage it is given in terms of bits. So, the digit precision is internally converted to a reasonable bit precision:

    Sage

        sage: singular.eval('ring r4 = (real,20),(a,b,c),dp')
        ''
        sage: singular('r4').sage_global_ring()
        Multivariate Polynomial Ring in a, b, c over Real Field with 70 bits of precision

    [Python]

        >>> from sage.all import *
        >>> singular.eval('ring r4 = (real,20),(a,b,c),dp')
        ''
        >>> singular('r4').sage_global_ring()
        Multivariate Polynomial Ring in a, b, c over Real Field with 70 bits of precision

    The case of complex coefficients is not fully supported, yet, since the generator of a complex field in Sage is always called “I”:

    Sage

        sage: singular.eval('ring r5 = (complex,15,j),(a,b,c),dp')
        ''
        sage: R = singular('r5').sage_global_ring(); R
        Multivariate Polynomial Ring in a, b, c over Complex Field with 54 bits of precision
        sage: R.base_ring()('k')
        Traceback (most recent call last):
        ...
        ValueError: given string 'k' is not a complex number
        sage: R.base_ring()('I')
        1.00000000000000*I

    Python

        >>> from sage.all import *
        >>> singular.eval('ring r5 = (complex,15,j),(a,b,c),dp')
        ''
        >>> R = singular('r5').sage_global_ring(); R
        Multivariate Polynomial Ring in a, b, c over Complex Field with 54 bits of precision
        >>> R.base_ring()('k')
        Traceback (most recent call last):
        ...
        ValueError: given string 'k' is not a complex number
        >>> R.base_ring()('I')
        1.00000000000000*I

    An example where the base ring is a polynomial ring over an extension of the rational field:

    Sage

        sage: singular.eval('ring r7 = (0,a), (x,y), dp')
        ''
        sage: singular.eval('minpoly = a2 + 1')
        ''
        sage: singular('r7').sage_global_ring()
        Multivariate Polynomial Ring in x, y over Number Field in a with defining polynomial a^2 + 1

    [Python]

        >>> from sage.all import *
        >>> singular.eval('ring r7 = (0,a), (x,y), dp')
        ''
        >>> singular.eval('minpoly = a2 + 1')
        ''
        >>> singular('r7').sage_global_ring()
        Multivariate Polynomial Ring in x, y over Number Field in a with defining polynomial a^2 + 1

    In our last example, the base ring is a quotient ring:

    Sage

        sage: singular.eval('ring r6 = (9,a), (x,y,z),lp')
        ''
        sage: Q = singular('std(ideal(x^2,x+y^2+z^3))', type='qring')
        sage: Q.sage_global_ring()
        Quotient of Multivariate Polynomial Ring in x, y, z over Finite Field in a of size 3^2 by the ideal (y^4 - y^2*z^3 + z^6, x + y^2 + z^3)

    Python

        >>> from sage.all import *
        >>> singular.eval('ring r6 = (9,a), (x,y,z),lp')
        ''
        >>> Q = singular('std(ideal(x^2,x+y^2+z^3))', type='qring')
        >>> Q.sage_global_ring()
        Quotient of Multivariate Polynomial Ring in x, y, z over Finite Field in a of size 3^2 by the ideal (y^4 - y^2*z^3 + z^6, x + y^2 + z^3)

    AUTHOR:

    - Simon King (2011-06-06)

  sage_matrix(R, sparse=True)

    Return Sage matrix for `self`.

    INPUT:

    - `R` – (default: `None`) an optional ring, over which the resulting matrix is going to be defined. By default, the output of `sage_global_ring()` is used.

    - `sparse` – boolean (default: `True`); whether the resulting matrix is sparse or not

    EXAMPLES:

    Sage

        sage: R = singular.ring(0, '(x,y,z)', 'dp')
        sage: A = singular.matrix(2,2)
        sage: A.sage_matrix(ZZ)
        [0 0]
        [0 0]
        sage: A.sage_matrix(RDF)
        [0.0 0.0]
        [0.0 0.0]

    Python

        >>> from sage.all import *
        >>> R = singular.ring(Integer(0), '(x,y,z)', 'dp')
        >>> A = singular.matrix(Integer(2),Integer(2))
        >>> A.sage_matrix(ZZ)
        [0 0]
        [0 0]
        >>> A.sage_matrix(RDF)
        [0.0 0.0]
        [0.0 0.0]

  sage_poly(R=None, kcache=None)

    Return a Sage polynomial in the ring r matching the provided poly which is a singular polynomial.

    INPUT:

    - `R` – (default: `None`) an optional polynomial ring. If it is provided, then you have to make sure that it matches the current singular ring as, e.g., returned by `singular.current_ring()`. By default, the output of `sage_global_ring()` is used.

    - `kcache` – (default: `None`) an optional dictionary for faster finite field lookups, this is mainly useful for finite extension fields

    OUTPUT: MPolynomial

    EXAMPLES:

    Sage

        sage: R = PolynomialRing(GF(2^8,'a'), 'x,y')
        sage: f = R('a^20*x^2*y+a^10+x')
        sage: f._singular_().sage_poly(R) == f
        True
        sage: R = PolynomialRing(GF(2^8,'a'), 'x', implementation='singular')
        sage: f = R('a^20*x^3+x^2+a^10')
        sage: f._singular_().sage_poly(R) == f
        True

    Python

        >>> from sage.all import *
        >>> R = PolynomialRing(GF(Integer(2)**Integer(8),'a'), 'x,y')
        >>> f = R('a^20*x^2*y+a^10+x')
        >>> f._singular_().sage_poly(R) == f
        True
        >>> R = PolynomialRing(GF(Integer(2)**Integer(8),'a'), 'x', implementation='singular')
        >>> f = R('a^20*x^3+x^2+a^10')
        >>> f._singular_().sage_poly(R) == f
        True

    Sage

        sage: P.<x,y> = PolynomialRing(QQ, 2)
        sage: f = x*y**3 - 1/9 * x + 1; f
        x*y^3 - 1/9*x + 1
        sage: singular(f)
        x*y^3-1/9*x+1
        sage: P(singular(f))
        x*y^3 - 1/9*x + 1

    [Python]

        >>> from sage.all import *
        >>> P = PolynomialRing(QQ, Integer(2), names=('x', 'y',)); (x, y,) = P._first_ngens(2)
        >>> f = x*y**Integer(3) - Integer(1)/Integer(9) * x + Integer(1); f
        x*y^3 - 1/9*x + 1
        >>> singular(f)
        x*y^3-1/9*x+1
        >>> P(singular(f))
        x*y^3 - 1/9*x + 1

    AUTHORS:

    - Martin Albrecht (2006-05-18)

    - Simon King (2011-06-06): Deal with Singular’s short polynomial representation, automatic construction of a polynomial ring, if it is not explicitly given.

    Note

    For very simple polynomials `eval(SingularElement.sage_polystring())` is faster than SingularElement.sage_poly(R), maybe we should detect the crossover point (in dependence of the string length) and choose an appropriate conversion strategy

  sage_polystring()

    If this Singular element is a polynomial, return a string representation of this polynomial that is suitable for evaluation in Python. Thus * is used for multiplication and ** for exponentiation. This function is primarily used internally.

    The short=0 option must be set for the parent ring or this function will not work as expected. This option is set by default for rings created using `singular.ring` or set using `ring_name.set_ring()`.

    EXAMPLES:

    Sage

        sage: R = singular.ring(0,'(x,y)')
        sage: f = singular('x^3 + 3*y^11 + 5')
        sage: f
        x^3+3*y^11+5
        sage: f.sage_polystring()
        'x**3+3*y**11+5'

    Python

        >>> from sage.all import *
        >>> R = singular.ring(Integer(0),'(x,y)')
        >>> f = singular('x^3 + 3*y^11 + 5')
        >>> f
        x^3+3*y^11+5
        >>> f.sage_polystring()
        'x**3+3*y**11+5'

  sage_structured_str_list()

    If `self` is a Singular list of lists of Singular elements, return corresponding Sage list of lists of strings.

    EXAMPLES:

    Sage

        sage: R=singular.ring(0,'(x,y)','dp')
        sage: RL=R.ringlist()
        sage: RL
        [1]:
           0
        [2]:
           [1]:
              x
           [2]:
              y
        [3]:
           [1]:
              [1]:
                 dp
              [2]:
                 1,1
           [2]:
              [1]:
                 C
              [2]:
                 0
        [4]:
           _[1]=0
        sage: RL.sage_structured_str_list()
        ['0', ['x', 'y'], [['dp', '1,\n1'], ['C', '0']], '0']

    Python

        >>> from sage.all import *
        >>> R=singular.ring(Integer(0),'(x,y)','dp')
        >>> RL=R.ringlist()
        >>> RL
        [1]:
           0
        [2]:
           [1]:
              x
           [2]:
              y
        [3]:
           [1]:
              [1]:
                 dp
              [2]:
                 1,1
           [2]:
              [1]:
                 C
              [2]:
                 0
        [4]:
           _[1]=0
        >>> RL.sage_structured_str_list()
        ['0', ['x', 'y'], [['dp', '1,\n1'], ['C', '0']], '0']

  set_ring()

    Set the current ring in Singular to be `self`.

    EXAMPLES:

    Sage

        sage: R = singular.ring(7, '(a,b)', 'ds')
        sage: S = singular.ring('real', '(a,b)', 'lp')
        sage: singular.current_ring()
        polynomial ring, over a field, global ordering
        // coefficients: Float()...
        // number of vars : 2
        //        block   1 : ordering lp
        //                  : names    a b
        //        block   2 : ordering C
        sage: R.set_ring()
        sage: singular.current_ring()
        polynomial ring, over a field, local ordering
        // coefficients: ZZ/7...
        // number of vars : 2
        //        block   1 : ordering ds
        //                  : names    a b
        //        block   2 : ordering C

    Python

        >>> from sage.all import *
        >>> R = singular.ring(Integer(7), '(a,b)', 'ds')
        >>> S = singular.ring('real', '(a,b)', 'lp')
        >>> singular.current_ring()
        polynomial ring, over a field, global ordering
        // coefficients: Float()...
        // number of vars : 2
        //        block   1 : ordering lp
        //                  : names    a b
        //        block   2 : ordering C
        >>> R.set_ring()
        >>> singular.current_ring()
        polynomial ring, over a field, local ordering
        // coefficients: ZZ/7...
        // number of vars : 2
        //        block   1 : ordering ds
        //                  : names    a b
        //        block   2 : ordering C

  type()

    Return the internal type of this element.

    EXAMPLES:

    Sage

        sage: R = PolynomialRing(GF(2^8,'a'),2,'x')
        sage: R._singular_().type()
        'ring'
        sage: fs = singular('x0^2','poly')
        sage: fs.type()
        'poly'

    Python

        >>> from sage.all import *
        >>> R = PolynomialRing(GF(Integer(2)**Integer(8),'a'),Integer(2),'x')
        >>> R._singular_().type()
        'ring'
        >>> fs = singular('x0^2','poly')
        >>> fs.type()
        'poly'

exception sage.interfaces.singular.SingularError

  Bases: `RuntimeError`

  Raised if Singular printed an error message

class sage.interfaces.singular.SingularFunction(parent, name)

  Bases: `ExpectFunction`

class sage.interfaces.singular.SingularFunctionElement(obj, name)

  Bases: `FunctionElement`

class sage.interfaces.singular.SingularGBDefaultContext(singular=None)

  Bases: `object`

  Within this context all Singular Groebner basis calculations are reduced automatically.

  AUTHORS:

  - Martin Albrecht

  - Simon King

class sage.interfaces.singular.SingularGBLogPrettyPrinter(verbosity=1)

  Bases: `object`

  A device which prints Singular Groebner basis computation logs more verbatim.

  cri_hilb = re.compile('h')
  crt_lne1 = re.compile('product criterion:(\\d+) chain criterion:(\\d+)')
  crt_lne2 = re.compile('NF:(\\d+) product criterion:(\\d+), ext_product criterion:(\\d+)')
  deg_lead = re.compile('\\d+')
  flush()

    EXAMPLES:

    Sage

        sage: from sage.interfaces.singular import SingularGBLogPrettyPrinter
        sage: s3 = SingularGBLogPrettyPrinter(verbosity=3)
        sage: s3.flush()

    Python

        >>> from sage.all import *
        >>> from sage.interfaces.singular import SingularGBLogPrettyPrinter
        >>> s3 = SingularGBLogPrettyPrinter(verbosity=Integer(3))
        >>> s3.flush()

  global_pattern = re.compile('(\\[\\d+:\\d+\\]|s|-|\\.|h|H\\(\\d+\\)|\\(\\d+\\)|\\(S:\\d+\\)|\\d+|M\\[\\d+,[b,e]*\\d+\\]|b|e).*')
  hig_corn = re.compile('H\\(\\d+\\)')
  new_elem = re.compile('s')
  non_mini = re.compile('e')
  num_crit = re.compile('\\(\\d+\\)')
  pat_sync = re.compile('1\\+(\\d+);')
  red_betr = re.compile('b')
  red_num = re.compile('\\(S:\\d+\\)')
  red_para = re.compile('M\\[(\\d+),(\\d+)\\]')
  red_post = re.compile('\\.')
  red_zero = re.compile('-')
  rng_chng = re.compile('\\[\\d+:\\d+\\]')
  write(s)

    EXAMPLES:

    Sage

        sage: from sage.interfaces.singular import SingularGBLogPrettyPrinter
        sage: s3 = SingularGBLogPrettyPrinter(verbosity=3)
        sage: s3.write("(S:1337)")
        Performing complete reduction of 1337 elements.
        sage: s3.write("M[389,12]")
        Parallel reduction of 389 elements with 12 nonzero output elements.

    Python

        >>> from sage.all import *
        >>> from sage.interfaces.singular import SingularGBLogPrettyPrinter
        >>> s3 = SingularGBLogPrettyPrinter(verbosity=Integer(3))
        >>> s3.write("(S:1337)")
        Performing complete reduction of 1337 elements.
        >>> s3.write("M[389,12]")
        Parallel reduction of 389 elements with 12 nonzero output elements.

sage.interfaces.singular.get_docstring(name, prefix=False, code=False)

  Return the docstring for the function `name`.

  INPUT:

  - `name` – a Singular function name

  - `prefix` – boolean (default: `False`); whether or not to include the prefix stating that what follows is from the Singular documentation.

  - `code` – boolean (default: `False`); whether or not to format the result as a reStructuredText code block. This is intended to support the feature requested in Issue #11268.

  OUTPUT:

  A string describing the Singular function `name`. A `KeyError` is raised if the function was not found in the Singular documentation. If the “info” is not on the user’s `PATH`, an `OSError` will be raised. If “info” was found but failed to execute, a `subprocess.CalledProcessError` will be raised instead.

  EXAMPLES:

  Sage

      sage: from sage.interfaces.singular import get_docstring
      sage: 'groebner' in get_docstring('groebner')  # needs_info
      True
      sage: 'standard.lib' in get_docstring('groebner')  # needs info
      True

  Python

      >>> from sage.all import *
      >>> from sage.interfaces.singular import get_docstring
      >>> 'groebner' in get_docstring('groebner')  # needs_info
      True
      >>> 'standard.lib' in get_docstring('groebner')  # needs info
      True

  The `prefix=True` form is used in Sage’s generated docstrings:

  Sage

      sage: from sage.interfaces.singular import get_docstring
      sage: print(get_docstring("factorize", prefix=True))  # needs info
      The Singular documentation for "factorize" is given below.
      ...

  [Python]

      >>> from sage.all import *
      >>> from sage.interfaces.singular import get_docstring
      >>> print(get_docstring("factorize", prefix=True))  # needs info
      The Singular documentation for "factorize" is given below.
      ...

sage.interfaces.singular.reduce_load_Singular()

  EXAMPLES:

  Sage

      sage: from sage.interfaces.singular import reduce_load_Singular
      sage: reduce_load_Singular()
      Singular

  Python

      >>> from sage.all import *
      >>> from sage.interfaces.singular import reduce_load_Singular
      >>> reduce_load_Singular()
      Singular

sage.interfaces.singular.singular_console()

  Spawn a new Singular command-line session.

  EXAMPLES:

  Sage

      sage: singular_console() #not tested
                           SINGULAR                             /  Development
       A Computer Algebra System for Polynomial Computations   /   version 3-0-4
                                                             0<
           by: G.-M. Greuel, G. Pfister, H. Schoenemann        \   Nov 2007
      FB Mathematik der Universitaet, D-67653 Kaiserslautern    \

  Python

      >>> from sage.all import *
      >>> singular_console() #not tested
                           SINGULAR                             /  Development
       A Computer Algebra System for Polynomial Computations   /   version 3-0-4
                                                             0<
           by: G.-M. Greuel, G. Pfister, H. Schoenemann        \   Nov 2007
      FB Mathematik der Universitaet, D-67653 Kaiserslautern    \

sage.interfaces.singular.singular_gb_standard_options(func)

  Decorator to force a reduced Singular groebner basis.

  Note

  This decorator is used automatically internally so the user does not need to use it manually.

sage.interfaces.singular.singular_version()

  Return the version of Singular being used.

  EXAMPLES:

  Sage

      sage: singular.version()
      "Singular ... version 4...

  Python

      >>> from sage.all import *
      >>> singular.version()
      "Singular ... version 4...