Lecture 36: Symbolic Computation with sympy

SymPy is pure Python package for symbolic computation. The pure means that, unlike in SageMath, no modifications to the Python scripting language have been made. SymPy is integrated in SageMath and at times we need to be aware of how to use its functionality properly. SageMath is licensed under the GNU GPL, whereas the license of SymPy is BSD.

sympy outside SageMath

Outside SageMath, we can compute with SymPy as in the Sage cell server, point your browser to the URL <http://live.sympy.org>.

A comparison of SymPy versus SageMath is given at <https://github.com/sympy/sympy/wiki/SymPy-vs.-Sage>.

SymPy is one of the core packages of the SciPy stack <http://www.scipy.org>.

sympy inside SageMath

We explicitly applied sympy to define a generator for the terms in a Taylor series.

If we use sympy in SageMath, then we may have to be explicit about the use of its functions. For example, the var in SageMath is different from the var in sympy.

import sympy
x = sympy.var('x')

We see that the type of x is sympy.core.symbol.Symbol.

Observe the difference with the var that we are normally using in SageMath:

y = var('y')

and the type is sage.symbolic.expression.Expression.

If we use the sqrt() on a variable that is a sympy symbol, then we get a symbolic expression of SageMath on return.


In both cases we see the same type. We can make a generator object on the sqrt(1-x). That works.

tsqrtx = sympy.series(sqrt(1-x),x,0,n=None)
print([next(tsqrtx) for k in range(10)])

But it will not work on sqrt(1-y).

tsqrty = sympy.series(sqrt(1-y),y,0,n=None)

Although tsqrty is also some type of generator, the second application of the generator triggers the StopIteration exception.

So for the generating function for the Catalan numbers, we must use a sympy symbol x and not a SageMath variable y.

g = (1 - sqrt(1-4*x))/(2*x)
cg = sympy.series(g,x,0,n=None)
print([next(cg) for k in range(11)])

Pattern Matching

Another feature better in SymPy than in SageMath is pattern matching, which can be useful when combined with substitution. To run this code we can also open a Terminal session, select Misc, and select python.

from sympy import *
x = Symbol('x')
y = Wild('y')
d = (10*x**3).match(y*x**3)

On return is a dictionary that has y_ as key with 10 as corresponding value, which expresses the match between y and 10 in the expressions 10*x**3 and y*x**3.

Solving Recurrence Relations

SymPy can solve recurrence relations. Consider the Fibonacci numbers, defined as \(f(n) = f(n-1) + f(n-2)\). We import rsolve and declare f as a function of n.

from sympy import Function, rsolve
from sympy.abc import n
f = Function('f')

The equation \(f(n) = f(n-1) + f(n-2)\) is entered as f(n+2) - f(n+1) - f(n) and assigned to the variable Fib. This variable is the first argument of rsolve and we solve for f(n).

Fib = f(n+2) - f(n+1) - f(n)
print('solving', Fib)
s = rsolve(Fib, f(n))

The solution s has the following form: C0*(1/2 + sqrt(5)/2)**n + C1*(-sqrt(5)/2 + 1/2)**n. Because we have a two terms relation, for a unique solution, we need to initial conditions, as an additional dictionary argument.

s2 = rsolve(Fib, f(n), {f(0): 0, f(1): 1})

and the solution s2 equals sqrt(5)*(1/2 + sqrt(5)/2)**n/5 - sqrt(5)*(-sqrt(5)/2 + 1/2)**n/5. As a verification, let us apply the formula to compute the first 10 Fibonacci numbers. But first, we need to convert the SymPy s2 into a SageMath expression:

fs2 = SR(s2)

Now we can evaluate and expand the expressions involving sqrt(5), which are then automatically simplified.

[fs2(n=k).expand() for k in range(10)]

The Nearest Algebraic Number

SymPy depends only on mpmath and mpmath exports the pslq function which allows to compute the nearest algebraic number, given a floating-point approximation. Let us illustrate this with \(\sqrt{2}\) which is a root of x^2 - 2.

from mpmath import pslq
s2 = RR(sqrt(2))
pwrs = [s2**k for k in range(3)]

In pwrs are the first three powers of s2 starting at the zeroth power.

cff = pslq(pwrs, verbose=True)

The output in cff is the list [2, 0, -1] which are the coefficients of the polynomial \(2 - x^2\). This is the polynomial for which s2 is an approximate roots with 53 bits of precision.


  1. What happens if you ask SageMath or sympy to compute a Taylor series expansion of sqrt(x) at x = 0? Explain the result.

  2. The cost \(T(n)\) of a merge sort on a list of \(n\) numbers is governed by the following recurrence relation:

    \[T(n) = 2 T\left(\frac{n}{2}\right) + n-1, \quad T(1) = 0.\]

    Use rsolve to find an explicit solution for \(T(n)\). Simplify so you can see \(T(n)\) is \(O(n \log(n))\).