Symbolic Expressions, Variables, and Functions

Symbolic Variables

Mathematical variables can be represented as symbolic variables that stand in for an unspecified number. In SymPy, symbolic variables can be created as follows:

x, y = sp.symbols("x, y", real=True)  # Create two real variables

The string passed to sp.symbols() can separate variables with commas and/or whitespace. The type of unspecified number being represented by the symbolic variables listed is assumed to be complex unless an optional argument is passed declaring otherwise. Here we have declared that x and y are real with the predicate real. Other common predicates include the following:

• Integers: integer, noninteger, even, and odd
• Real numbers: real, positive, nonnegative, nonzero, nonpositive, and negative
• Complex numbers: complex (default) and imaginary

The predicate of a symbolic variable determines the assumptions SymPy will make about it when it appears in a symbolic expression. For instance, consider the following symbolic expressions:

z = sp.symbols("z")  # Complex
p = sp.symbols("p", positive=True)
sp.sqrt(z**2)
sp.sqrt(x**2)  # Using real x from above
sp.sqrt(p**2)

We see that the expression automatically simplifies based on the predicates provided for each variable. This will prove especially useful once we begin using the symbolic expression manipulation techniques described in the following sections.

Symbolic Functions

A mathematical function can be represented in SymPy by a symbolic function. There are a few different ways to create these, and we will consider only the simplest and most common cases here. An undefined function $f$ that should be treated as monolithic and as having no special properties can be defined as follows:

f = sp.Function("f")  # Type: sp.core.function.UndefinedFunction
f(x) + 3 * f(x)  # Using x from above

Predicates can be applied to functions, as well; for instance,

g = sp.Function("g", real=True)
f(x) + g(x, y) * g(3, -3)

An applied undefined function is an undefined function that has been given an argument. For instance,

h = sp.Function("h")(x)  # Types: h, sp.core.function.AppliedUndef
3 * h  ## Leave off the argument

Undefined functions are never evaluated. At times we want to define a function that is always to be evaluated; in SymPy such a function is called a fully evaluated function. A fully evaluated function can be created as a regular Python function, as in the following case:

def F(x):
    return x**2 - 4
F(x)**2

For piecewise functions, regular Python functions with if statements will work, but it is preferable to use the sp.Piecewise() function. For instance,

G = sp.Piecewise(
    (x**2, x <= 0),  # $x^2$ for $x \le 0$
    (3*x, True)  # $3 x$ for $x > 0$
)

Many common mathematical functions are built in to SymPy, including those shown in tbl. ¿tbl:sympy-math-functions?.

In rare cases, we must define a custom function; that is, a subclass of the sp.Function class. Such a function needs to have its behavior thoroughly defined. Once it is completed, it should behave just as built-in functions like sp.sin(). For a tutorial on writing custom functions, see sp2023a.