Symbolics.jl

Symbolics.jl is a high-performance Computer Algebra System (CAS) built for Julia. Because it leverages Julia's multiple dispatch, many generic functions in Base Julia work directly with symbolic expressions (e.g., performing LU-factorization on matrices of symbolic expressions).

Key features include:

• Symbolic Arithmetic: Supports type information and multiple dispatch.
• Algebraic Operations: Polynomials, trigonometric functions, and non-standard algebras (non-commutative symbols).
• Calculus & Math: Differentiation, pattern matching, simplification, substitution, and discrete math (summations, products, binomial coefficients).
• Linear Algebra: Symbolic factorizations, inversion, determinants, and eigencomputations.
• Equation Solving: Symbolic equation solving and conversion to arbitrary precision.
• Code Generation: Automatic conversion of Julia code to symbolic code and generation of high-performance, parallelized functions from symbolic expressions.
• Sparsity: Fast automated sparsity detection and generation of sparse Jacobians and Hessians.
• Special Functions: Support for functions provided by SpecialFunctions.jl.

Symbolics.jl is designed specifically for symbolic-numerics: the combination of symbolic computing with numerical methods for high-performance computing (HPC). While SymPy is a general-purpose symbolic math library in Python, Symbolics.jl is optimized for performance and integration into high-speed simulation workflows.

Key differentiators include:

• Performance: Built natively in Julia to provide much higher performance bars than Python-based alternatives.
• build_function: Unlike SymPy's lambdify, Symbolics.jl's build_function generates fast, JIT-compiled Julia functions. It supports HPC-specific features like static arrays, non-allocating functions via mutation, and optimized operations on sparse matrices.
• Parallelism: Features pervasive parallelism, including built-in parallelism in symbolic simplification (via SymbolicUtils.jl), thread-parallelized functions, and compatibility with GPU libraries like CUDA.jl.
• Extensibility: Because it is written in pure Julia, users can extend the library by adding new simplification rules or derivatives directly in Julia code.
• Ecosystem Integration: Deeply integrated with the SciML ecosystem. It leverages automatic differentiation, Julia Base linear algebra, and tools like DataDrivenDiffEq.jl (for reconstructing expressions from data) and NeuralPDE.jl (for solving PDEs via physics-informed neural networks).

Symbolics.jl provides two distinct ways to handle arrays containing symbolic elements. Choosing the right one depends on whether you prioritize ease of use or computational efficiency.

1. Arrays of Symbolic Expressions: These are standard Julia arrays (e.g., Vector or Matrix) containing Symbolics.jl objects.

   • Behavior: Indexing returns a scalar symbolic value. Operations use Julia's standard array functionality and perform symbolic operations on the individual scalar values.
   • Pros: High accessibility; works with almost all existing symbolic operations.
   • Cons: Can lead to very large, expanded expressions during operations.

2. Symbolic Arrays: These are $O(1)$ symbolic representations of an entire array.

   • Behavior: Indexing (e.g., A[1,1]) does not return a variable, but a symbolic expression representing the indexing operation itself. It holds linear algebra expressions in a non-expanded form.
   • Pros: Much more efficient for large-scale linear algebra; keeps expressions compact.
   • Cons: Requires operations to use registered symbolic array functions (lower coverage than scalar symbolics).

Recommendation: Default to Arrays of Symbolic Expressions unless you specifically require the expression simplification benefits of the Symbolic Array approach.

Because Symbolics.jl expressions respect Julia semantics, you can generate symbolic expressions by passing Symbolics variables (@variables) into existing imperative Julia code. This process, called tracing, transforms the imperative code into a declarative symbolic graph composed of pre-registered primitive functions (like * or -).

Limitations:

• Tracing only works if the code is composed of already registered functions. Calls to unregistered functions (e.g., C code) will cause an error.
• Tracing does not guarantee the exact numerical result, as the symbolic system may re-distribute arithmetic or simplify expressions. If a function is highly sensitive to numerical details, you should register it as a primitive instead of tracing it.
• To maximize the power of symbolic manipulations (like simplification), minimize the number of registered functions; only register when necessary, as registered functions are treated as black-box imperative code.

using Symbolics
function lorenz(du,u,p,t)
 du[1] = 10.0(u[2]-u[1])
 du[2] = u[1]*(28.0-u[3]) - u[2]
 du[3] = u[1]*u[2] - (8/3)*u[3]
end
@variables t p[1:3] u(t)[1:3]
du = Array{Any}(undef, 3)
lorenz(du,u,p,t)
du