- Match complicated mathematical patterns (regex for maths)
- Work with expressions that are huge (your disk space is the limit)
- State-of-the art polynomial arithmetic and expression optimization
- Framework for numerical integration
- APIs for Python, Rust and C++

Perform easy mathematical manipulations on expressions and create expressions in a format very close to Python’s own notation:

```
e1 = (y+x^2+2*x*y)*f(5)*f(x,f(x,y))
d/dx e2 = -y*(x*y+1)^-2
e3 = (y+x^2+2*x*y)*f(5)*f(x,f(x^2))
```

Perform low-level operations with ultimate flexiblity:

```
use symbolica::{
printer::{PrintOptions, RationalPolynomialPrinter},
representations::Atom,
rings::{
integer::IntegerRing, rational::RationalField, rational_polynomial::RationalPolynomial,
},
state::{State, Workspace},
};
fn main() {
let mut state = State::new();
let workspace = Workspace::default();
let expr = Atom::parse(
"(x*y^2*5+5)^2/(2*x+5)+(x+4)/(6*x^2+1)",
&mut state,
&workspace,
)
.unwrap();
let rat: RationalPolynomial<IntegerRing, u8> = expr
.as_view()
.to_rational_polynomial(
&workspace,
&state,
RationalField::new(),
IntegerRing::new(),
None,
)
.unwrap();
println!(
"{}",
RationalPolynomialPrinter::new(&rat, &state, PrintOptions::default())
);
}
```

Symbolica is designed to be used as a library and has bindings to Python, Rust, C++ and Mathematica. Try it out in your project!

Match mathematical patterns with advanced wildcards. The matcher is aware of symmetric functions and other properties.

Each term in an expression can be manipulated independently and in parallel.

Symbolica has dedicated polynomial algebra routines and has one of the fastest greatest common divisor implementation for multivariate polynomials.

Symbolica is free for students and hobbyists. Try it out! University staff and companies have to obtain a license.

The complete code and development process is open and available on GitHub.