symtorch (distribution: libsymtorch)

SymPy-to-Torch transcompilation and numerical integration library designed for extremely fast, batched evaluation on GPUs and CPUs.

Note: this module was first developed for libphysics — then it was split out into a standalone library to tackle generalized parallel computational bottlenecks.

Install (dev)

pip install -e .

Install (PyPI)

pip install libsymtorch

Requirements

This project depends on the packages listed in requirements.txt. The primary runtime requirements are:

• Python 3.8+
• torch==2.5.1+cu121 (or another torch build appropriate for your platform)
• sympy==1.13.1
• torchquad==0.5.0
• numpy==2.4.2
• scipy==1.17.0
• loguru==0.7.3

To install the pinned packages, run:

pip install -r requirements.txt

If you intend to use GPU acceleration, please install a torch wheel that matches your CUDA version (the example above is a CUDA-enabled wheel). For CPU-only environments, install the CPU torch wheel instead.

Quick Usage

symtorch bridges the gap between SymPy's symbolic manipulation and PyTorch's highly optimized batched tensor operations. You can transcompile symbolic integrals directly into callable PyTorch engines.

import torch
import symtorch
import sympy as sp

# 1. Define your integrands symbolically
x = sp.Symbol("x", real=True)
p = sp.Symbol("p", real=True)
expr = sp.Integral(sp.exp(-p * x**2), (x, -sp.oo, sp.oo))

# 2. Compile to SymTorch engine
lt = symtorch.SymTorch()
texpr = lt.torchify(expr)

# 3. Evaluate massively batched parameter grids on accelerators
p_grid = torch.linspace(0.5, 100.0, 10000, dtype=torch.float64, device="cuda").unsqueeze(-1)
re, im = texpr.torch_integrate_batched(
    params_values=p_grid,
    method="gauss-legendre",
    N=501,                       # Force high quadrature scaling for difficult integrands
    device="cuda",               # Target accelerator natively
    dtype=torch.float64,         
    chunk_size_params=4096       # Automatically chunks massive batches to avoid OOM
)
print("Real part:", re)

Parameter Reference

When evaluating continuous integrals dynamically using torch_integrate_batched(), you have granular control over numerical performance constraints:

• params_values (torch.Tensor): Array parameter map corresponding to all substituted free variables defining your symbolic integral.
• method (str): The mapped quadrature strategy (e.g. "gauss-legendre").
• N (int): Limits Quadrature nodes. Higher N bounds push stability on deeply oscillatory configurations (allowing you to surpass typical recursion bottlenecks) but proportionately scales VRAM and FLOP demands.
• device (str or torch.device): Device mapping (e.g., "cpu", "cuda", "mps").
• dtype (torch.dtype): Evaluative precision schema (use torch.float64 for analytic comparisons or exponential limits).
• chunk_size_params (int): Sub-array partitioning for the grid parameters. Ex: With a $1,000,000$ point map and $N=2000$, setting this to 2048 iteratively offloads pressure allowing safe calculation without Out-Of-Memory hazards.

⚡ Universals Benchmarks & Capabilities

A major component of SymTorch is overcoming conventional scaling walls embedded heavily in dynamic Python CPU evaluators (e.g., SciPy's recursive quad).

SymTorch evaluates integrals up to ~2,640× faster than SciPy with similar accuracy, and can uniquely utilize massive static grids to achieve mathematically narrower error bounds on notoriously difficult oscillatory problems.

Evaluation constraints: Uniform sequential sweeps covering $p \in [0.5, 100.0]$ across a $10,000$ point grid resolving analytical ground truths. N represents quadrature scaling depth.

Tabular Comparisons

*To access raw LaTeX arrays, inspect: tests/benchmarks/ultimate_universal_benchmark.tex

Key Identifications:

• Speedup Range: Depending on the quadrature depth (N) and integrand complexity, speedups scale dynamically from $\sim2\times$ (at massive $N=2001$ limits) up to $\sim2641\times$ (at standard $N=121$ baselines).
• Oscillatory Bypassing: When SciPy encounters intense structural oscillations (Case 2), its adaptive iteration bottoms out (capping at $10^{-10}$ error margins). By structurally projecting massive arrays via SymTorch (N=1001+) we cleanly break past recursive thresholds achieving up to $10^{-13}$ true numerical accuracy while retaining ~ $40\times$ faster wall-times!

Running Tests

To run the benchmarking suite locally across symtorch implementations:

pytest tests/ -v
pytest tests/test_benchmark_ultimate.py -s  # Generates local .csv, .md, & .tex format drops safely 

Examples & Tutorials

For more extensive usage—including plotting workflows and physics applications—check the examples/notebooks/ directory which includes:

• 01_the_basics.ipynb
• 02_parameter_sweeps.ipynb
• 03_scattering_and_wigner.ipynb

License

Please see the LICENSE file in the root of the repository for usage and distribution terms.