Ticket #7797: trac_7797-letterplace_ring_hack.patch

module_list.py

@@ -491 +491 @@
               include_dirs = [SAGE_ROOT +'/local/include/singular'],
               depends = [SAGE_ROOT + "/local/include/libsingular.h"]),
 
+    Extension('sage.libs.singular.letterplace_ring',
+              sources = ['sage/libs/singular/letterplace_ring.pyx'],
+              libraries = ['m', 'readline', 'singular', 'givaro', 'gmpxx', 'gmp'],
+              language="c++",
+              include_dirs = [SAGE_ROOT +'/local/include/singular'],
+              depends = [SAGE_ROOT + "/local/include/libsingular.h"]),
+
     Extension('sage.libs.symmetrica.symmetrica',
               sources = ["sage/libs/symmetrica/%s"%s for s in ["symmetrica.pyx"]],
               include_dirs = ['/usr/include/malloc/'],

new file sage/libs/singular/letterplace_ring.pyx

@@ +1 @@
+###############################################################################
+#   Sage: Open Source Mathematical Software
+#       Copyright (C) 2009 Burcin Erocal <burcin@erocal.org>
+#  Distributed under the terms of the GNU General Public License (GPL),
+#  version 2 or any later version.  The full text of the GPL is available at:
+#                  http://www.gnu.org/licenses/
+###############################################################################
+
+from sage.libs.singular.function cimport RingWrap
+from sage.libs.singular.decl cimport ring
+from sage.rings.polynomial.multi_polynomial_libsingular cimport \
+        MPolynomialRing_libsingular
+
+from sage.rings.polynomial.multi_polynomial_ring_generic import \
+        MPolynomialRing_generic
+from sage.rings.polynomial.term_order import TermOrder
+
+include "../../ext/stdsage.pxi"
+
+def temporary_MPolynomialRing_from_letterplace_ring(RingWrap wrapped_ring,
+        base_ring, tuple alg_gens, int dbound):
+    """
+    Given a letterplace ring corresponding to a free algebra over the given
+    `base_ring` with the generators `alg_gens` and degree bound `dbound`
+    returns two dictionaries, one for converting free algebra elements to
+    elements of a newly created MPolynomialRing and another to convert back.
+
+    EXAMPLE::
+
+        sage: from sage.libs.singular.function import lib as singular_lib
+        sage: from sage.libs.singular.function import singular_function
+        sage: singular_lib("freegb.lib")
+        sage: F.<x,y,z> = FreeAlgebra(QQ, 3)
+        sage: R = PolynomialRing(QQ, F.variable_names())
+        sage: make_letter_place_ring = singular_function("makeLetterplaceRing")
+        sage: ring_wrap = make_letter_place_ring(10, ring=R)
+        sage: from sage.libs.singular.letterplace_ring import temporary_MPolynomialRing_from_letterplace_ring
+        sage: to_letterplace, from_letterplace = temporary_MPolynomialRing_from_letterplace_ring(ring_wrap, F.base_ring(), F.gens(), 10)
+        sage: to_letterplace
+        {y: [y(1), y(2), y(3), y(4), y(5), y(6), y(7), y(8), y(9), y(10)], x: [x(1), x(2), x(3), x(4), x(5), x(6), x(7), x(8), x(9), x(10)], z: [z(1), z(2), z(3), z(4), z(5), z(6), z(7), z(8), z(9), z(10)]}
+        sage: to_letterplace.keys()[0]
+        y
+        sage: to_letterplace.keys()[0].parent()
+        Free Algebra on 3 generators (x, y, z) over Rational Field
+        sage: from_letterplace
+        {x(1): (1, x), z(1): (1, z), y(2): (2, y), y(7): (7, y), x(3): (3, x), z(10): (10, z), y(5): (5, y), x(10): (10, x), z(4): (4, z), y(9): (9, y), x(4): (4, x), z(6): (6, z), z(8): (8, z), x(6): (6, x), x(8): (8, x), y(1): (1, y), x(2): (2, x), z(2): (2, z), x(7): (7, x), y(3): (3, y), y(10): (10, y), z(9): (9, z), x(5): (5, x), x(9): (9, x), y(4): (4, y), z(3): (3, z), y(8): (8, y), y(6): (6, y), z(7): (7, z), z(5): (5, z)}
+    """
+    cdef MPolynomialRing_libsingular fake_ring = \
+            <MPolynomialRing_libsingular>PY_NEW(MPolynomialRing_libsingular)
+    fake_ring._ring = wrapped_ring._ring
+
+    # create a fake MPolynomialRing_generic object
+    # this will be used as a parent of the polynomials representing letterplace     # elements in Singular
+    cdef int nvars = len(alg_gens)*dbound
+    MPolynomialRing_generic.__init__(fake_ring, base_ring, nvars,
+            ['x'+str(i) for i in range(nvars)], TermOrder('lex', nvars))
+    fake_ring._has_singular = True
+
+    gens = fake_ring.gens()
+
+    # fill a dictionary indexed by the free algebra generators, used to convert     # free algebra elements to letterplace polynomials
+    res = dict([(x, [0]*dbound) for x in alg_gens])
+    alg_names = dict([(str(x), x) for x in alg_gens])
+    # reverse conversion dictionary
+    # maps letterplace ring generator to a tuple (n, x) where n is the index,
+    # and x is the corresponding free algebra generator
+    reverse = {}
+    for g in gens:
+        gstr = str(g)
+        for name in alg_names.iterkeys():
+            # found which free algebra generator this polynomial ring generator
+            # corresponds to
+            if gstr.startswith(name):
+                #TODO: fix this assumption of a prefix code
+                index = int(gstr[len(name)+1:-1])
+                alg_gen = alg_names[name]
+                res[alg_gen][index-1] = g
+
+                reverse[g] = (index, alg_gen)
+                break
+        else:
+            raise RuntimeError, "cannot find corresponding free algebra generator for letterplace element %s"%(gstr)
+
+    return res, reverse