Mike Hansen's profile - activity

The problem is that the GAP interface is not threadsafe -- both threads are accessing the same GAP session. You could use the @parallel decorator and forking (which has a bit of overhead). For example,

def method_1(n):
    import time
    time.sleep(20)
    return 1, Integer(gap(n)*n)

def method_2(n):
    return 2, Integer(gap(n)*n)

def try_fast(n):
    @parallel
    def try_method(method):
        return method(n)

    method_num, result = try_method([method_1, method_2]).next()[1]
    print "Computed by method %s"%method_num
    return result

The result of the (decorated) try_method function is an iterator which will yield the results as soon as they are ready. In this case, we just need the first one.

 sage: %time try_fast(4)
 Killing any remaining workers...
 Computed by method 2
 CPU times: user 0.00 s, sys: 0.02 s, total: 0.02 s
 Wall time: 0.27 s
 16

I found symbolic sum but not symbolic product in the reference files. I need to be able to classify a function of a erratic x which involve several symbolic foodstuffs from 1 to n or whatever. I then want to be able to do a derivative and a limit of this. I am trying out Sage because Mathematical doesn't seem to be able to handle this stuff exactly. I can define the function just fine but when I try to take the limit Mathematical can't seem to handle it.

Yeah, the name make s more sense when you're familiar with the underlying pynac library. Can you think of a better name that we could use as an alias?

You can use the pyobject method:

sage: b = RealField(200)(5)
sage: bb = (b^x).operands()[0]
sage: bb.pyobject(), type(bb.pyobject()) 
(5.0000000000000000000000000000000000000000000000000000000000, <type 'sage.rings.real_mpfr.RealNumber'>)

Spam..........

You can put this in ~/.sage/init.sage and it will be loaded each time you start Sage. You can also run "%cpaste" from the command line, paste the code in, and then put in "--" to finish the paste.

You should be able to run

sage -i database_gap

to install it.

Here is some code which "linearizes" your problem:

def polynomial_identity(polys):
    monomials = set()
    for p in polys:
        monomials.update(p.monomials())
        base_ring = p.base_ring()
    monomial_order = list(monomials)
    m = []
    for p in polys:
        row = []
        for monomial in monomial_order:
            try:
                row.append(base_ring(p.coefficient(monomial)))
            except TypeError:
                row.append(base_ring(0))
        m.append(row)
    m = matrix(m)
    return m.kernel()

The result is a vector space which gives you all of your solutions. Your example

sage: polynomial_identity([x^2 + y^2, x*y + x*z, x*y*z])
Vector space of degree 3 and dimension 0 over Rational Field
Basis matrix:
[]

shows that (0,0,0) is the only answer. Another example:

sage: polynomial_identity([x+y, 2*x+2*y, 3*(x+y)])        
Vector space of degree 3 and dimension 2 over Rational Field
Basis matrix:
[   1    0 -1/3]
[   0    1 -2/3]

One way to do the general case uses the all_paths method:

sage: [path for path in g.all_paths(0,1) if len(path) == 5]
[[0, 2, 3, 4, 1], [0, 2, 4, 3, 1], [0, 3, 2, 4, 1], [0, 3, 4, 2, 1], [0, 4, 2, 3, 1], [0, 4, 3, 2, 1]]
sage: [path for path in g.all_paths(0,1) if len(path) == 4]
[[0, 2, 3, 1], [0, 2, 4, 1], [0, 3, 2, 1], [0, 3, 4, 1], [0, 4, 2, 1], [0, 4, 3, 1]]
sage: [path for path in g.all_paths(0,1) if len(path) == 3]
[[0, 2, 1], [0, 3, 1], [0, 4, 1]]
sage: [path for path in g.all_paths(0,1) if len(path) == 2]
[[0, 1]]

There is also a longest_path method that takes source and destination as input parameters, but there seems to be a bug with directed graphs. I've made this #13019.

At the theoretical level, the problem is really easy for this specific graph since there are edges between all the vertices. Thus, you can just pick the endpoints and take any permutation of the remaining vertices (or subset of them) to get a path of a fixed length.

Can you post some more information from the log about how it failed?

Try running

$ sage -sh

from the command-line first. When you then run,

$ f2py -m -c rw2 rw2.f90

it will pick up Sage's copy of f2py (which will use Sage's Python).