mmarco's profile - activity

If the changes you make also affect the interface of the library (that is, the name or parameters of the exposed functions), you might need to also replace the corresponding header file in the local/include directory of your sage install, and then modify the file src/sage/libs/braiding.pyxand rebuild the sage library with sage -b

Hi

I am the maintainer of libbraiding. If the changes you want to make are relevant, you can try to make a pull request with them and I might merge them and release a new version.

If you just want to try some things in your machine, maybe the simplest way is to compile libbraiding with your changes with the usual cycle:

autoreconf --install
./configure
make

and then use the generated files in the lib/.libs directory to replace the corresponding ones in the /local/lib/ directroy of your sage installation.

You can conjugate the braid so there are no unused strands anynore. In order to prevent the simplification, you can use two expressions of the same braid.

In your example:

cb1 = B([1,2,1]) cb2 = B([-2,-1,-2])

mybraid = B([1])

myconjbraid = cb1mybraidcb2

myconjbraid produces the same link as mybraid, but since it has no unused strands, it will contain also the trivial components.

Oh, sorry, i understood that you meant the $a_i$ to be constants.

So what you want are basically the remainders of the division of $f$ by $v$, $v^2$, $v^3$ and so on.

What you want to do is not always possible (for instance, if $f$ has lower degree than $v$). But when there exists an answer, what you want is just an inverse image of the polynomial $f$ by the map that sends $x$ to $v(x)$.

this can be done using elimination techniques:

sage: R.<x,t> = QQ[]
sage: v = x^2 + x + 1
sage: f = x^4 + 2*x^3 + 6*x^2 + 5*x + 2
sage: I = R.ideal([t - v, f])
sage: L = I.elimination_ideal(x)
sage: L
Ideal (t^2 + 3*t - 2) of Multivariate Polynomial Ring in x, t over Rational Field
sage: L.gen(0)(t=v) == f
True

In this case there was a solution. When there is not, you will get some polynomial whose image is a multiple of what you wanted.

I think the function you are looking for is list_plot.

If what you are interested in is computing values of this function, you can use numerical integration instead of symbolic:

sage: el = lambda theta: -numerical_integral(log(abs(2*sin(u))), 0, theta)[0]
sage: plot(el, 0, pi)

There is not a single command to achieve that, but in this particular case you can do the following:

sage: k = GF(5)
sage: M = MatrixSpace(k,2,2)
sage: units = [m for m in M if m.is_invertible()]
sage: nonunits = [m for m in M if not m.is_invertible()]
sage: len(units)
480
sage: len(nonunits)
145

Since every ideal must be generated by some nonunits, but also changing a generator by a unit times it does not change the ideal, let's check how many essentially distinct generators can we have:

sage: associated = []
sage: for m in nonunits:
....:     if not True in [a*m in associated for a in units]:
....:         associated.append(m)
....:         
sage: associated
[
[0 0]  [1 0]  [0 1]  [1 1]  [2 1]  [1 2]  [4 1]
[0 0], [0 0], [0 0], [0 0], [0 0], [0 0], [0 0]
]

That is, you only want to check for subsets of that set as possible generators of your ideals. But it is clear that two of those elements actually generate the other four, so you just need to check for ideals generated by up to two generators.

You have the trivial ideal, the other 6 principal ideals generated by the other elements in associated, and the only thing you need to check is if the ideal generated by two of them is the total one. It is easy to see that it is, but in case you don't notice at first sight you can just check it directly:

sage: for (a,b) in Tuples(units,2):
....:     if (a*associated[1] + b*associated[2]).is_invertible():
....:         print a
....:         print b
....:         break
....:     
[0 1]
[1 0]
[1 0]
[0 1]

There you are: only six nontrivial ideals, that happen to be principal.

Amit Jamadagni has been working on a knot theory module in this year's GSoC program, under my mentoring. The result is a Link class with some basic functionality (mainly conversion between different representations of a link, and computation of some invariants). It still needs polishing, but i expect we can have something ready to be merged in sage in the following weeks.

From that, there would still be a lot of work to do to improve it, but the basic infrastructure would be there.

https://www.google-melange.com/gsoc/p...

Rename your file to my.sage

Then, when you run sage my.sage it will be automatically preparsed. A my.py with all the needed extra python code will be produced and loaded automatically.

In your particular example, you are doing the computation on the free algebra on ax,ay,az,b over the polynomial ring on px,py,pz,m.

sage: R.<px,py,pz,m>=QQ[]
sage: F.<ax,ay,az,b>=FreeAlgebra(R)
sage: (ax*px+ay*py+az*pz+m*b)^2
px^2*ax^2 + px*py*ax*ay + px*pz*ax*az + px*m*ax*b + px*py*ay*ax + py^2*ay^2 + py*pz*ay*az + py*m*ay*b + px*pz*az*ax + py*pz*az*ay + pz^2*az^2 + pz*m*az*b + px*m*b*ax + py*m*b*ay + pz*m*b*az + m^2*b^2

A very simple way to use paralelism is provided by the @parallel decorator.

Just write a function that does what you want,with the decorator at the beginning. Then you can pass it a list of entries, and the output will be an iterator with the answers.

Example:

sage: @parallel
....: def f(a):
....:     return a^2
....: 
sage: r=f([1,2,3,4])
sage: r.next()
(((1,), {}), 1)
sage: r.next()
(((2,), {}), 4)
sage: r.next()
(((3,), {}), 9)
sage: r.next()
(((4,), {}), 16)
sage: r.next()
---------------------------------------------------------------------------
StopIteration                             Traceback (most recent call last)

You can download the source code and follow the instructions to compile it. It may sound scary, but it's actually quite easy (basically you need to install a few packages, uncompress the source tar file, and type 'make'). The readme file contains the details.

There are torrent clients that you don't need to install. For example, at www.bitlet.org you have a torrent downloader in a java applet run in the browser.

They are all kind of the same question. The situation is this: i administer a sage server for educational purposes. One of the teachers wants to use Octave. In particular, he wants to do image and sound manipulations. I want to know if there is a way to do it in the server.

Is there a way to see the graphs when running octave from the sage notebook? And play the sounds?

When running sage locally things work reasonably, but how can they work when running sage in a remote server?

Is there any work on rewriting the whole integration functions in sage?

Just a comment for completeness: the groebner basis aproach is the right way to go... if we care about solutions in a field that is algebraically closed. If we are trying to discuss if a system of equations has real solutions, its a much harder problem.

Using the sagenb.notebook.nbotebook.Notebook class one can edit different properties of a given notebook. The changes are suposed to be saved using the .save() procedure. But if the notebook is active, this procedire doesn't work.

Is there a way to do modifications to an actove notebook without stopping it?

maybe adding a "is_true" procedure or similar for this kind of objects would be a good idea?

You can do the following:

R.ideal([f.reduce(J.groebner_basis()) for f in I.gens()])

That is basically what singular does: reduce the generators of I w.r.t. J.