14 releases (6 breaking)

new 0.6.0 May 27, 2024
0.4.0 Apr 15, 2024
0.3.0 Mar 18, 2024
0.1.4 Dec 5, 2023
0.0.0 Jan 11, 2023

#120 in Math

Download history 15/week @ 2024-02-25 5/week @ 2024-03-03 2/week @ 2024-03-10 146/week @ 2024-03-17 1/week @ 2024-03-24 101/week @ 2024-03-31 172/week @ 2024-04-07 136/week @ 2024-04-14 2/week @ 2024-04-21 134/week @ 2024-05-12 34/week @ 2024-05-19

168 downloads per month
Used in spenso

Custom license and LGPL-3.0+

40K SLoC


Symbolica website Zulip Chat Symbolica website Codecov


Symbolica is a blazing fast and modern computer algebra system which aims to handle huge expressions. It can easily be incorporated into existing projects using its Python, Rust or C++ bindings. Check out the live Jupyter Notebook demo!

For documentation and more, see symbolica.io.

Quick Example

Symbolica allows you to build and manipulate mathematical expressions through matching and replacing patterns, similar to regex for text:

You are able to perform these operations from the comfort of a programming language that you (probably) already know, by using Symbolica's bindings to Python, Rust and C++:

A demo of Symbolica


Visit the Get Started page for detailed installation instructions.


Symbolica can be installed for Python >3.5 using pip:

pip install symbolica

The installation may take some time on Mac OS and Windows, as it may have to compile Symbolica.


If you want to use Symbolica as a library in Rust, simply include it in the Cargo.toml:

symbolica = "0.6"


Below we list some examples of the features of Symbolica. Check the guide for a complete overview.

Pattern matching

Variables ending with a _ are wildcards that match to any subexpression. In the following example we try to match the pattern f(w1_,w2_):

from symbolica import Expression
x, y, w1_, w2_ = Expression.vars('x','y','w1_','w2_')
f = Expression.fun('f')
e = f(3,x)*y**2+5
r = e.replace_all(f(w1_,w2_), f(w1_ - 1, w2_**2))

which yields y^2*f(2,x^2)+5.

Solving a linear system

Solve a linear system in x and y with a parameter c:

from symbolica import Expression

x, y, c = Expression.vars('x', 'y', 'c')
f = Expression.fun('f')

x_r, y_r = Expression.solve_linear_system(
    [f(c)*x + y + c, y + c**2], [x, y])
print('x =', x_r, ', y =', y_r)

which yields x = (-c+c^2)*f(c)^-1 and y = -c^2.

Series expansion

Perform the Taylor series in x of an expression that contains a user-defined function f:

from symbolica import Expression

x, y = Expression.vars('x', 'y')
f = Expression.fun('f')

e = 2* x**2 * y + f(x)
e = e.taylor_series(x, 0, 2)


which yields f(0)+x*der(1,f(0))+1/2*x^2*(4*y+der(2,f(0))).

Rational arithmetic

Symbolica is world-class in rational arithmetic, outperforming Mathematica, Maple, Form, Fermat, and other computer algebra packages. Simply convert an expression to a rational polynomial:

from symbolica import Expression
x, y = Expression.vars('x','y')
p = Expression.parse('(x*y^2*5+5)^2/(2*x+5)+(x+4)/(6*x^2+1)').to_rational_polynomial()

which yields (45+13*x+50*x*y^2+152*x^2+25*x^2*y^4+300*x^3*y^2+150*x^4*y^4)/(5+2*x+30*x^2+12*x^3).


Follow the development and discussions on Zulip!


~1M SLoC