Coverage for local/lib/python2.7/site-packages/sage/interfaces/singular.py : 70%

r""" 

Interface to Singular 

AUTHORS: 

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

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

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: 

#. ``singular_console()`` - A function that dumps you 

into an interactive command-line Singular session. 

#. ``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. 

#. ``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: 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 

:: 

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 

:: 

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 

We can convert `f` and each exponent back to Sage objects 

as well. 

:: 

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 

This example illustrates polynomial GCD's:: 

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 

This example illustrates computation of a Groebner basis:: 

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 

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

interface documentation:: 

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 

This example illustrates moving a polynomial from one ring to 

another. It also illustrates calling a method of an object with an 

argument. 

:: 

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 

We can calculate the Milnor number of `f`:: 

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

sage: f.milnor() 

4 

The Jacobian applied twice yields the Hessian matrix of 

`f`, with which we can compute. 

:: 

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 

The 1x1 and 2x2 minors:: 

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 

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 

:: 

sage: _=singular.eval('option(redSB)') 

sage: H.minor(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: 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 

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

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

sage: i.genus() 

0 

An Important Concept 

-------------------- 

AUTHORS: 

- Neal Harris 

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: singular.lib('poly.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: 

... 

We restart everything and try again, but correctly. 

:: 

sage: singular.quit() 

sage: singular.lib('poly.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, 

... 

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: 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) 

TESTS: 

We test an automatic coercion:: 

sage: a = 3*singular('2'); a 

6 

sage: type(a) 

<class 'sage.interfaces.singular.SingularElement'> 

sage: a = singular('2')*3; a 

6 

sage: type(a) 

<class 'sage.interfaces.singular.SingularElement'> 

Create a ring over GF(9) to check that ``gftables`` has been installed, 

see :trac:`11645`:: 

sage: singular.eval("ring testgf9 = (9,x),(a,b,c,d,e,f),(M((1,2,3,0)),wp(2,3),lp);") 

'' 

""" 

#***************************************************************************** 

# Copyright (C) 2005 David Joyner and William Stein 

# 

# This program is free software: you can redistribute it and/or modify 

# it under the terms of the GNU General Public License as published by 

# the Free Software Foundation, either version 2 of the License, or 

# (at your option) any later version. 

# http://www.gnu.org/licenses/ 

#***************************************************************************** 

from __future__ import print_function 

from __future__ import absolute_import 

from six.moves import range 

from six import integer_types, string_types 

import os 

import re 

import sys 

import pexpect 

from time import sleep 

from .expect import Expect, ExpectElement, FunctionElement, ExpectFunction 

from sage.interfaces.tab_completion import ExtraTabCompletion 

from sage.structure.sequence import Sequence 

from sage.structure.element import RingElement 

import sage.rings.integer 

from sage.misc.misc import get_verbose 

from sage.misc.superseded import deprecation 

from sage.docs.instancedoc import instancedoc 

from six import reraise as raise_ 

class SingularError(RuntimeError): 

""" 

Raised if Singular printed an error message 

""" 

pass 

class Singular(ExtraTabCompletion, Expect): 

r""" 

Interface to the Singular interpreter. 

EXAMPLES: A Groebner basis example. 

:: 

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 

AUTHORS: 

- David Joyner and William Stein 

""" 

def __init__(self, maxread=None, script_subdirectory=None, 

logfile=None, server=None,server_tmpdir=None, 

seed=None): 

""" 

EXAMPLES:: 

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

True 

""" 

prompt = '> ' 

Expect.__init__(self, 

terminal_echo=False, 

name = 'singular', 

prompt = prompt, 

# no tty, fine grained cputime() 

# and do not display CTRL-C prompt 

command = "Singular -t --ticks-per-sec 1000 --cntrlc=a", 

server = server, 

server_tmpdir = server_tmpdir, 

script_subdirectory = script_subdirectory, 

restart_on_ctrlc = True, 

verbose_start = False, 

logfile = logfile, 

eval_using_file_cutoff=100 if os.uname()[0]=="SunOS" else 1000) 

self.__libs = [] 

self._prompt_wait = prompt 

self.__to_clear = [] # list of variable names that need to be cleared. 

self._seed = seed 

def set_seed(self,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: s = Singular() 

sage: s.set_seed(1) 

1 

sage: [s.random(1,10) for i in range(5)] 

[8, 10, 4, 9, 1] 

""" 

if seed is None: 

seed = self.rand_seed() 

self.eval('system("--random",%d)' % seed) 

self._seed = seed 

return seed 

def _start(self, alt_message=None): 

""" 

EXAMPLES:: 

sage: s = Singular() 

sage: s.is_running() 

False 

sage: s._start() 

sage: s.is_running() 

True 

sage: s.quit() 

""" 

self.__libs = [] 

Expect._start(self, alt_message) 

# Load some standard libraries. 

self.lib('general') # assumed loaded by misc/constants.py 

# these options are required by the new coefficient rings 

# supported by Singular 3-1-0. 

self.option("redTail") 

self.option("redThrough") 

self.option("intStrategy") 

self._saved_options = self.option('get') 

# set random seed 

self.set_seed(self._seed) 

def __reduce__(self): 

""" 

EXAMPLES:: 

sage: singular.__reduce__() 

(<function reduce_load_Singular at 0x...>, ()) 

""" 

return reduce_load_Singular, () 

def _equality_symbol(self): 

""" 

EXAMPLES:: 

sage: singular._equality_symbol() 

'==' 

""" 

return '==' 

def _true_symbol(self): 

""" 

EXAMPLES:: 

sage: singular._true_symbol() 

'1' 

""" 

return '1' 

def _false_symbol(self): 

""" 

EXAMPLES:: 

sage: singular._false_symbol() 

'0' 

""" 

return '0' 

def _quit_string(self): 

""" 

EXAMPLES:: 

sage: singular._quit_string() 

'quit' 

""" 

return 'quit' 

def _send_interrupt(self): 

""" 

Send an interrupt to Singular. If needed, additional 

semi-colons are sent until we get back at the prompt. 

TESTS: 

The following works without restarting Singular:: 

sage: a = singular(1) 

sage: _ = singular._expect.sendline('1+') # unfinished input 

sage: try: 

....: alarm(0.5) 

....: singular._expect_expr('>') # interrupt this 

....: except KeyboardInterrupt: 

....: pass 

Control-C pressed. Interrupting Singular. Please wait a few seconds... 

We can still access a:: 

sage: 2*a 

2 

""" 

# Work around for Singular bug 

# http://www.singular.uni-kl.de:8002/trac/ticket/727 

sleep(0.1) 

E = self._expect 

E.sendline(chr(3)) 

for i in range(5): 

try: 

E.expect_upto(self._prompt, timeout=1.0) 

return 

except Exception: 

pass 

E.sendline(";") 

def _read_in_file_command(self, filename): 

r""" 

EXAMPLES:: 

sage: singular._read_in_file_command('test') 

'< "...";' 

sage: filename = tmp_filename() 

sage: f = open(filename, 'w') 

sage: _ = f.write('int x = 2;\n') 

sage: f.close() 

sage: singular.read(filename) 

sage: singular.get('x') 

'2' 

""" 

return '< "%s";'%filename 

def eval(self, x, allow_semicolon=True, strip=True, **kwds): 

r""" 

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: singular.eval('2 > 1') 

'1' 

sage: singular.eval('2 + 2') 

'4' 

if the verbosity level is `> 1` comments are also printed 

and not only returned. 

:: 

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())) 

'// 1 t^0\n// -3 t^2\n// 3 t^4\n// -1 t^6\n\n// 1 t^0\n// 

3 t^1\n// 3 t^2\n// 1 t^3\n// dimension (affine) = 0\n// 

degree (affine) = 8' 

:: 

sage: set_verbose(1) 

sage: o = singular.eval('hilb(%s)'%(s.name())) 

// 1 t^0 

// -3 t^2 

// 3 t^4 

// -1 t^6 

// 1 t^0 

// 3 t^1 

// 3 t^2 

// 1 t^3 

// 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: o = s.hilb() 

// 1 t^0 

// -3 t^2 

// 3 t^4 

// -1 t^6 

// 1 t^0 

// 3 t^1 

// 3 t^2 

// 1 t^3 

// dimension (affine) = 0 

// degree (affine) = 8 

// ** right side is not a datum, assignment ignored 

... 

rather than ignored 

:: 

sage: set_verbose(0) 

sage: o = s.hilb() 

""" 

# Simon King: 

# In previous versions, the interface was first synchronised and then 

# unused variables were killed. This created a considerable overhead. 

# By trac ticket #10296, killing unused variables is now done inside 

# singular.set(). Moreover, it is not done by calling a separate _eval_line. 

# In that way, the time spent by waiting for the singular prompt is reduced. 

# Before #10296, it was possible that garbage collection occured inside 

# of _eval_line. But collection of the garbage would launch another call 

# to _eval_line. The result would have been a dead lock, that could only 

# be avoided by synchronisation. Since garbage collection is now done 

# without an additional call to _eval_line, synchronisation is not 

# needed anymore, saving even more waiting time for the prompt. 

# Uncomment the print statements below for low-level debugging of 

# code that involves the singular interfaces. Everything goes 

# through here. 

x = str(x).rstrip().rstrip(';') 

x = x.replace("> ",">\t") #don't send a prompt (added by Martin Albrecht) 

if not allow_semicolon and x.find(";") != -1: 

raise TypeError("singular input must not contain any semicolons:\n%s"%x) 

if len(x) == 0 or x[len(x) - 1] != ';': 

x += ';' 

s = Expect.eval(self, x, **kwds) 

if s.find("error") != -1 or s.find("Segment fault") != -1: 

raise SingularError('Singular error:\n%s'%s) 

if get_verbose() > 0: 

for line in s.splitlines(): 

if line.startswith("//"): 

print(line) 

return s 

else: 

return s 

def set(self, 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: singular.set('int', 'x', '2') 

sage: singular.get('x') 

'2' 

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

is called:: 

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' 

""" 

cmd = ''.join('if(defined(%s)){kill %s;};'%(v,v) for v in self.__to_clear) 

cmd += '%s %s=%s;'%(type, name, value) 

self.__to_clear = [] 

self.eval(cmd) 

def get(self, var): 

""" 

Get string representation of variable named var. 

EXAMPLES:: 

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

sage: singular.get('x') 

'2' 

""" 

return self.eval('print(%s);'%var) 

def clear(self, var): 

""" 

Clear the variable named ``var``.