# Python Symbolics

In the twenty-first century there is little or no reason to compute complicated integrals and derivatives by hand. We can instead use any of various python packages to do exact arithmetic, perform algebraic operations, and evaluate limits, integrals and other calculus constructions easily. One package for python that is somewhat mature is called Sage. This depends upon python, but builds on top of it, rather than being a simple package such as numpy. We will instead use sympy, a relatively new and less than mature package with a bright future. Ultimately, the point is that symbolic math packages are a dime a dozen these days, and learning one will demonstrate most of the ideas anchoring all of them, though the details of syntax vary from one package to another.

The first thing to note about sympy is that it prefers to treat numbers as exact. This means that each number is an object in itself, with various means of interpretation, including approximation to an arbitrary number of digits of accuracy. Thus, numpy provides a fixed floating point approximation to π, but sympy treats π as a real number that can be evaluated in floating point arithmetic to any number of digits you require.

>>> from numpy import * >>> pi 3.141592653589793 >>> from sympy import * >>> pi pi >>> pi.evalf() 3.14159265358979 >>> pi.evalf(50) 3.1415926535897932384626433832795028841971693993751

There are several significant things here.
First, when you do arithmetic with sympy objects
you might not get the simple numbers you expect - learn to change
your expectations. The second thing is that working with
symbolic objects will be *much* slower than working with
ordinary python numbers. Do not use sympy objects unless you
really need to do exact or symbolic calculations.

Another thing to be careful with here is that if it is not clear
that the object we are dealing with is a sympy object, then ordinary
python rules apply. Thus, `1/3` is treated as an integer
arithmetic operation, with result `0`. Likewise, `1.0/3` is
treated as a floating point operation, with result `0.3333333333333333`.
However, if we want to do an exact calculation, we must make
a rational expression. As soon as python realizes it is working
with one rational, it treats an entire expression as if it is rational.

>>> q=Rational(1,3) >>> q 1/3 >>> q.evalf(50) 0.33333333333333333333333333333333333333333333333333 >>> q=Rational(1)/3 >>> q 1/3

The whole point of working with a symbolic package is to permit
us to do calculations with symbolic variables. Sympy allows us
to define symbolic variables and then work with them. There are two
ways to start this: we can use the `symbols` command, or we
can use the `var` command. New variables formed using
symbolic variables are themselves symbolic.

>>> x,y=symbols('x,y') >>> var('u,v') (u, v) >>> x-x 0 >>> x+x 2*x >>> expr=(u+v)**4 >>> expr (u + v)**4

Symbolic variables have many functions associated with them that allow
us to do various algebraic and calculus operations.
The whole point of using e.g. the `var` command to declare
the variable was for python to create an entire class around that name,
together with associated mathematical associations and operations.
We get to these using the usual method notation: the variable name,
followed by a period and the name of the method we want to apply.
For example, the
`expand` function expands polynomial expressions. We can reverse
this by using `factor`. If we need to substitute one expression
for another, there is a `subs` method to do that.

>>> newexpr=expr.expand() >>> newexpr u**4 + 4*u**3*v + 6*u**2*v**2 + 4*u*v**3 + v**4 >>> newexpr.factor() (u + v)**4 >>> newexpr.subs(u,2) v**4 + 8*v**3 + 24*v**2 + 32*v + 16 >>> (newexpr.subs(u,2)).factor() (v + 2)**4

Notice in the last expression that we simply put parentheses around a computed quantity, which was symbolic because it was created from symbolic expressions, and then used a method associated with this new symbolic object. Once again for emphasis: any time we perform a computation that uses a symbolic variable, the result is itself symbolic, and hence has access to all the methods associated with symbolic variables.

When we use symbolic expressions, we really don't want to have to look at all that "**" stuff. We want to see something that resembles ordinary mathematical notation. Many symbolic packages call this "pretty printing". Regrettably, the result is not always pretty, but most of the time it produce result that are more legible than the straight python syntax. To do pretty printing using sympy, run three commands in your session:

>>> import sys >>> oh=sys.displayhook >>> sys.displayhook=pprintAfter that is done, your expressions should be "pretty printed".

>>> u=1/((y+3)*(y-4)**2) >>> u 1/((y - 4)**2*(y + 3)) >>> import sys >>> oh=sys.displayhook >>> sys.displayhook=pprint >>> u 1 ---------------- 2 (y - 4) *(y + 3)

In all further discussion of the sympy package, we will suppose that you have run these commands.

Sympy can manipulate fractional expressions. For example,
it contains a command that every symbolic manipulation program in
history has had: `simplify`.

>>> simplify(newexpr/(u+v)) 3 2 2 3 u + 3*u *v + 3*u*v + v >>> (newexpr/(u+v)).simplify() 3 2 2 3 u + 3*u *v + 3*u*v + v >>> trigexp=sin(u)**2+cos(u)**2 >>> trigexp 2 2 sin (u) + cos (u) >>> trigexp.simplify() 1

Simplify looks for common factors in the numerator and denominator of an expression and cancels them if they are found. It also tries to apply some simple rules about exponents and trigonometric functions.

Another requirement in dealing with fractional expressions is combining
and breaking up expressions with different denominators. For this
sympy gives us `together` and `apart`. The point is that
`apart` is doing partial fraction decompositions for you.

>>> expr = 1/((u+1)*(u-3)) >>> newexpr=apart(expr) >>> newexpr 1 1 - --------- + --------- 4*(u + 1) 4*(u - 3) >>> together(newexpr) 1 --------------- (u - 3)*(u + 1)