ries 1.1.1

Find algebraic equations given their solution - Rust implementation
Documentation

ries-rs

CI Coverage Crates.io PyPI Live Demo License: MIT

ries-rs is a Rust implementation of Robert P. Munafo's RIES inverse equation solver. Given a target number, it searches for algebraic equations that have that number as a solution.

The historical acronym is RIES, for "RILYBOT Inverse Equation Solver". This repository aims to be a modern, documented, reproducible reference implementation rather than a historical clone.

Project page: maxwellsantoro.com/projects/ries-rs
Live demo: maxwellsantoro.com/projects/ries-rs/app/

RIES-RS web UI

Who It's For

  • Researchers who want reproducible constant-recognition runs with structured output
  • Programmers who want a library or CLI for equation search instead of an interactive calculator
  • Math enthusiasts exploring compact identities for familiar constants or strange decimals
  • Educators and demo authors who want Python and browser-facing interfaces in addition to the CLI

Why Use ries-rs

  • Rust implementation with a cleaner architecture and broad regression coverage
  • Deterministic mode for reproducible output ordering
  • Structured JSON and manifests for automation and research workflows
  • Browser and library integrations in addition to the CLI
  • Public benchmark artifacts and explicit parity tracking against older versions

Install

CLI

The crates.io package is named ries; the installed binary is ries-rs.

cargo install ries --locked

Prebuilt Linux, macOS, and Windows archives are attached to each GitHub release.

For unreleased development builds:

cargo install --git https://github.com/maxwellsantoro/ries-rs --locked

# Or, from a local checkout:
cargo install --path . --locked

Python Bindings

pip install ries-rs

For local source development of the bindings:

pip install maturin
cd ries-py
maturin develop --release

Web App / WASM

GitHub releases include a ries-rs-wasm.tar.gz artifact with the generated WASM packages. To build the browser bundle locally, install the JS dependencies and the nightly Rust toolchain first:

npm install
rustup toolchain install nightly
npm run build:web:site

Deploy the contents of dist/web-site/ to a path such as https://example.com/projects/ries-rs/.

The current local WASM build scripts use nightly wasm-pack via -Z build-std.

For the public deployment, use the canonical landing page at https://maxwellsantoro.com/projects/ries-rs and the standalone app at https://maxwellsantoro.com/projects/ries-rs/app/.

Detailed setup guides:

Quick Start

Basic search:

ries-rs 3.141592653589793

# Example output:
#                    x = pi                       ('exact' match) {14}
#                  x-3 = 1/7                      for x = T + 1.26e-3 {24}

Classic-style output:

ries-rs --classic 2.5063

Deterministic machine-readable output:

ries-rs 3.141592653589793 --deterministic --json --emit-manifest run.json

For the authoritative option list:

ries-rs --help

Project Scope

ries-rs is intended to be a disciplined, modern reference implementation:

  • Faithful reimplementation of the core RIES search model
  • Deterministic and documented execution modes
  • Memory-safe Rust implementation with optional parallel search
  • Structured output for automation (--json, --emit-manifest)
  • CLI, Rust library, Python bindings, and WebAssembly builds
  • Modular presets, profiles, and extension points

Not primary goals of this repository:

  • Symbolic AI or conjecture systems
  • PSLQ research-platform ambitions beyond the shipped CLI mode
  • Experimental search branches outside the core RIES model

Performance

Performance claims are tracked conservatively with separate benchmark artifacts for end-to-end CLI runs and generation-only scaling:

Raw benchmark artifacts live under docs/benchmarks/artifacts/.

Compatibility

ries-rs tracks behavior against two historical baselines:

  1. The original RIES by Robert Munafo
  2. The clsn/ries fork with additional compatibility-oriented CLI behavior

Current status in brief:

  • Core equation search and classic-style output flow are implemented
  • Legacy CLI semantics and diagnostic channels are supported substantially more completely than in early versions
  • Internal generation and ranking are Rust-native, so exact ordering and complexity numbers can still differ on some targets

See docs/PARITY_STATUS.md for the detailed status and historical notes.

How It Works

  1. Enumerate valid postfix expressions up to the current complexity limit
  2. Check fast-path exact matches against well-known constants when possible
  3. Generate left-hand-side and right-hand-side expression candidates
  4. Use Newton refinement to solve LHS(x) = RHS
  5. Filter, deduplicate, and refine candidate equations
  6. Rank matches by exactness, error, and parity-style or complexity-style order

Documentation

Additional Interfaces

Python

The Python bindings expose ries_rs.search() and typed match objects through PyO3. See docs/PYTHON_BINDINGS.md for PyPI install, source development, API details, and troubleshooting.

WebAssembly

The WASM build supports browser, Node.js, bundler, and static-site workflows. See docs/WASM_BINDINGS.md for the JS/TS API and web/README.md for the browser UI and static hosting flow.

PSLQ

The CLI includes PSLQ integer-relation detection via --pslq, --pslq-extended, and --pslq-max-coeff. This is part of the shipped tool, but it is not the primary focus of the repository.

How to Cite

If you use ries-rs in academic work, cite the project version you used. CITATION.cff is the canonical metadata source.

@software{ries-rs2026,
  author       = {Santoro, Maxwell},
  title        = {ries-rs: A Rust Implementation of the RIES Inverse Equation Solver},
  year         = {2026},
  version      = {1.1.1},
  url          = {https://maxwellsantoro.com/projects/ries-rs},
  license      = {MIT},
  note         = {Features parallel search, deterministic mode, and run manifest for reproducibility}
}

GitHub releases may also be archived on Zenodo. Record a release DOI in CITATION.cff, this README, and the release notes only after it has actually been minted and verified.

For reproducible research runs, prefer --deterministic together with --emit-manifest.

License

MIT License. See LICENSE.

References