Alkahest

PyPI • crates.io • Docs • Website • RL environment • Demo

Alkahest is a high-performance computer algebra system built for both humans and agents. It is especially well suited for autoresearch agents doing work in pure and applied mathematics. Available as a Python package or a Rust crate.

The main stack is: Rust kernel → FLINT/Arb (polynomials, ball arithmetic) → egglog + colored e-graphs (simplification) → Cranelift/LLVM JIT + MLIR (native and GPU codegen) → PyO3 → Python

Highlights

Verifiable by construction. Every computation produces a derivation log; a meaningful subset can export Lean 4 proofs for independent verification.
520× faster than SymPy on trig-identity simplification — and 77× faster than Mathematica on the same task (cross-CAS report).
~40× faster than SymPy on 2-variable quadratic systems, via FLINT-backed polynomial arithmetic and a compiled F4 core (solving guide).
GPU codegen is a routine operation, not a research project — 16.2× over the CPU JIT on a 1M-point polynomial evaluation (NVPTX sm_86, RTX 3090). Requires a source build with --features cuda; the PyPI wheel has no GPU support (GPU guide).
A trained RL environment. GRPO against the CAS verifier moved Qwen2.5-1.5B-Instruct from 11.7% → 15.1% on elementary integrals (+29% relative) with no stored reference answers — the CAS grades every rollout, including honest refusal on non-elementary integrands.
Built for agent loops. String entry point (ak.parse), per-candidate Budgets, batched *_many fan-out, and compact JSON envelopes for cheap logging.
No silent performance cliffs. Expr, UniPoly, MultiPoly, ArbBall and friends are explicit representations; conversion between them is always an opt-in call.

Install

Python 3.9–3.13:

pip install alkahest
pip install "alkahest[rl]"   # RL environments; Python >= 3.10

Rust users: alkahest-cas = "2" — see Rust crate.

Default wheels are batteries-included: e-graph simplification, the Gröbner solver (so alkahest.solve, Diophantine, and homotopy work out of the box), and the pure-Rust Cranelift CPU JIT, with no system LLVM required. They do not include LLVM JIT or parallel — for those, use a PyTorch-style opt-in +jit / +full Linux wheel from GitHub Releases, not the default PyPI resolver path.

Install matrix (default vs opt-in wheels)

Probe your environment after install: alkahest.capabilities()["features"] and alkahest.jit_is_available().

Artifact	Where	OS / arch (CI)	Python	Cranelift JIT	LLVM JIT	`parallel`
Default (`pip install alkahest`)	PyPI	Linux manylinux x86_64; macOS arm64; Windows x86_64	3.9–3.13	yes	no	no
`+jit` (`X.Y.Z+jit`)	GitHub Releases only	Linux x86_64	3.9–3.13	no	yes	no
`+full` (`X.Y.Z+full`)	GitHub Releases only	Linux x86_64	3.9–3.13	no	yes	yes

macOS / Windows: default PyPI wheels include Cranelift JIT. +jit and +full are not built in CI (LLVM / MSYS2 constraints); use building from source with --features jit (and parallel for F4 parallelism) on those platforms.

Linux LLVM wheels vendor LLVM and related .so files under site-packages/alkahest.libs/. If import alkahest fails with a missing libffi-*.so or libLLVM-*.so, prepend that directory to LD_LIBRARY_PATH.

Opt-in Linux wheels: `+jit` and `+full` (PyTorch-style)

Why a separate index or direct wheel URL: feature-heavy wheels use a PEP 440 local version (for example 3.8.0+jit or 3.8.0+full). Those builds must not be mixed into the main PyPI project’s simple API for the same reason PyTorch publishes CUDA wheels on download.pytorch.org: otherwise pip install alkahest could resolve a +jit / +full build as “newer” than 3.8.0 and pull LLVM (or a much larger binary) when you wanted the default wheel.

There is no pip install alkahest[jit] / alkahest[full] that swaps the native extension: pip extras only add Python dependencies, not alternate binaries for the same wheel slot.

Until a dedicated PEP 503 simple index is published, tagged releases attach Linux linux_x86_64 wheels on GitHub Releases (CI builds them on ubuntu-22.04, not the manylinux image used for default wheels). Pick the .whl whose tags match your Python (cp311, etc.) and linux_x86_64.

Local version	Cargo features	When to use
(default PyPI)	`egraph groebner cranelift`	Cranelift CPU JIT on all published platforms; no system LLVM.
`+jit`	`egraph groebner jit`	LLVM CPU JIT (Linux only in CI; larger than default; no Cranelift).
`+full`	`egraph groebner jit parallel`	LLVM JIT plus parallel F4 S-polynomial reduction (largest wheel; Linux only in CI).

Direct-install examples (adjust tag and filename after checking the release assets):

pip install "https://github.com/alkahest-cas/alkahest/releases/download/v3.8.0/alkahest-3.8.0+full-cp311-cp311-linux_x86_64.whl"
pip install "https://github.com/alkahest-cas/alkahest/releases/download/v3.8.0/alkahest-3.8.0+jit-cp311-cp311-linux_x86_64.whl"

These wheels vendor LLVM (for JIT) and related .so files under site-packages/alkahest.libs/. If import alkahest fails with a missing libffi-*.so or libLLVM-*.so, prepend that directory to LD_LIBRARY_PATH (or install matching system packages). Release CI uses the same LD_LIBRARY_PATH step when smoke-testing wheels.

If your client chokes on + in the URL, use percent-encoding (3.8.0%2Bfull in the filename segment).

After installing the default wheel, alkahest.jit_is_available() is True (Cranelift). After +jit or +full, it is also True (LLVM). Gröbner-backed APIs such as alkahest.solve are available in all wheels since groebner became a default feature.

See the install matrix for per-platform coverage.

Target layout (roadmap): a small extra index URL (PEP 503) hosting only +jit / +full wheels, mirroring PyTorch’s --extra-index-url workflow:

pip install 'alkahest==3.8.0+full' --extra-index-url https://EXAMPLE/alkahest-extras/simple

From source

Required to enable optional features (jit, cuda, parallel) or for development. The groebner and egraph features are already built into default wheels; a source build inherits them automatically. Prerequisites:

Rust stable ≥ 1.76 and nightly:

curl --proto '=https' --tlsv1.2 -sSf https://sh.rustup.rs | sh
rustup toolchain install nightly

uv (recommended Python tool manager): curl -LsSf https://astral.sh/uv/install.sh | sh
LLVM 15: apt install llvm-15 libllvm15 llvm-15-dev / brew install llvm@15
FLINT ≥ 2.9 (includes GMP and MPFR): apt install libflint-dev / brew install flint

# Install dev tools (maturin, pytest, ruff, ty, …) without building the Rust extension:
uv sync --no-install-project --group dev
# Build and install the extension into the project venv:
uv run maturin develop --manifest-path alkahest-py/Cargo.toml --release --features "parallel egraph jit groebner"

Without uv, install maturin directly and run the same develop command:

pip install maturin
maturin develop --manifest-path alkahest-py/Cargo.toml --release --features "parallel egraph jit groebner"

Optional Cargo features: parallel (sharded pool + parallel F4 + numpy_eval_par), egraph (vendored egglog backend; default in PyPI wheels), groebner (Gröbner solver + Diophantine + homotopy; default in both the Rust crate and PyPI wheels), cranelift (pure-Rust Tier-1 JIT), jit (LLVM JIT), cuda (NVPTX codegen — needs LLVM 15 with the NVPTX target; adds compile_cuda), groebner-cuda (CUDA Macaulay-matrix kernel — needs only cudarc, and is a Rust-crate entry point that no Python call reaches). Neither GPU feature is in any published wheel: see the GPU guide.

Rust crate

alkahest-cas is also published on crates.io (docs.rs) for use directly from Rust without a Python runtime:

[dependencies]
alkahest-cas = "3"

# groebner is included by default; add other optional features as needed:
# alkahest-cas = { version = "3", features = ["parallel", "egraph"] }

System prerequisites (same libraries as the Python build — must be present before cargo build):

# Debian / Ubuntu
sudo apt-get install -y libflint-dev libgmp-dev libmpfr-dev

# macOS
brew install flint

The jit feature additionally requires LLVM 15 dev headers (apt install llvm-15-dev / brew install llvm@15). A self-contained runnable example is in examples/rust_quickstart/.

Quick start

import alkahest as ak

caps = ak.capabilities()  # groebner, jit, egraph, parallel
pool = ak.ExprPool()
x = pool.symbol("x")

# Python int literals work in arithmetic (pool still required for symbols)
expr = x**2 + 1

# Differentiation with derivation log
result = ak.diff(ak.sin(expr), x)
print(result.value)   # 2*x*cos(x^2 + 1)
print(result.steps)   # list of rewrite steps

# Integration
r = ak.integrate(ak.exp(x), x)
print(r.value)        # exp(x)

# Simplification — use simplify_trig for sin²+cos², not the catch-all simplify
s = ak.simplify(x + 0)
print(s.value)        # x
print(ak.simplify_trig(ak.sin(x)**2 + ak.cos(x)**2).value)  # 1

# JIT-compile to native code (interpreter fallback when caps["jit"] is False)
f = ak.compile_expr(x**2 + 1, [x])
print(f([3.0]))       # 10.0

# String entry point for agents / notebooks (bindings optional)
e = ak.parse("sin(x)^2 + cos(x)^2", pool, {"x": x})
print(ak.simplify_trig(e).value)  # 1

Partial fractions, definite integration, and Lean certificates:

import alkahest as ak

pool = ak.ExprPool()
x = pool.symbol("x")

f = 1 / (x**2 - pool.integer(1))
print(ak.apart(f, x))  # partial fractions over ℚ

r = ak.integrate(x**2, x, pool.integer(0), pool.integer(1))  # ∫₀¹ x² dx = 1/3
print(r.value)
print(r.certificate)  # Lean 4 proof term when available

More runnable examples live in examples/ — polynomials, Risch integration, Lean certificates, agent workflows, and more.

Features

Area	What you get	Entry points
Calculus	Differentiation, Risch integration (definite and indefinite), limits, series expansion, residues	`diff` · `integrate` · `limit` · `series` · `residue`
Simplification	Rule engine plus e-graph saturation, with domain-specific passes instead of one catch-all	`simplify` · `simplify_trig` · `simplify_log_exp` · `simplify_egraph`
Polynomials	FLINT-backed univariate and multivariate arithmetic, factorization over ℤ and 𝔽ₚ, sparse GCD and interpolation, resultants, partial fractions	`UniPoly.factor_z` · `factor_univariate_mod_p` · `gcd_sparse` · `resultant` · `apart` · `cancel`
Solving	Gröbner bases (F4), triangular decomposition, primary decomposition, real root isolation via CAD, numerical fallback	`solve` · `real_roots` · `triangularize` · `cad_project` · `primary_decomposition` · `solve_numerical`
Sums and products	Gosper and Zeilberger creative telescoping, WZ pair verification, linear recurrence solving	`sum_indefinite` · `sum_definite` · `zeilberger` · `verify_wz_pair` · `rsolve`
Linear algebra	Symbolic matrices, eigenvalues and eigenvectors, Jacobians, Routh–Hurwitz stability	`Matrix.eigenvals` · `jacobian` · `routh_hurwitz`
ODEs and DAEs	Symbolic ODE/DAE systems, Pantelides index reduction, sensitivity and adjoint systems, acausal component modeling	`ODE` · `DAE` · `pantelides` · `dae_index_reduce` · `sensitivity_system`
Number theory	FLINT-backed integer theory, Diophantine equations, LLL lattice reduction, PSLQ integer-relation detection	`number_theory` · `diophantine` · `lattice` · `guess_relation`
Rigorous numerics	Arb ball arithmetic — every float carries a proven error bound	`ArbBall` · `interval_eval` · `refine_root`
Code generation	JIT to native CPU code (Cranelift or LLVM), NVPTX GPU kernels, C source, StableHLO, vectorized NumPy	`compile_expr` · `jit` · `numpy_eval` · `emit_c` · `to_stablehlo` · `compile_cuda`
Program transforms	JAX-style `trace` / `grad` / `jit` over Python functions, plus symbolic gradients and forward-mode dual-number AD	`trace_fn` · `grad` · `symbolic_grad` · `diff_forward`
Verification	Derivation logs on every result, Lean 4 certificate export, coverage reporting	`DerivedResult.steps` · `to_lean` · `certifiable` · `certificate_coverage`
Agent loops	String parsing, budgets and cancellation, batched fan-out, claim graphs for session provenance	`parse` · `Budget` · `batch_map` · `research`
Assumptions	Domain-aware reasoning (`x > 0`, ℤ vs ℝ) with a decision procedure over quantified statements	`Assumptions` · `Domain` · `Forall` · `decide` · `satisfiable`
Output	LaTeX, Unicode pretty-printing, plots (2D/3D, implicit, parametric, DAG structure)	`latex` · `unicode_str` · `plot` · `plot3d` · `plot_dag`

Full listing in the Python API reference.

Expression representations

Type	Description
`Expr`	Generic hash-consed symbolic expression
`UniPoly`	Dense univariate polynomial (FLINT-backed)
`MultiPoly`	Sparse multivariate polynomial over ℤ
`MultiPolyFp`	Sparse multivariate polynomial over 𝔽ₚ (modular arithmetic)
`RationalFunction`	Quotient of polynomials with GCD normalization
`ArbBall`	Real interval with rigorous error bounds (Arb)

Representation types are explicit — no silent performance cliffs. Conversion between them is always an opt-in call (UniPoly.from_symbolic(...), etc.).

Result objects

Most transforming operations (diff, simplify, integrate, sum_*, …) return a DerivedResult with:

.value — the result expression
.steps — derivation log (list of rewrite rules applied)
.certificate — Lean 4 proof term, when available
.to_dict() / .to_json() — versioned machine-parseable envelope; use mode="compact" in agent loops

Exceptions: limit returns a bare Expr, and series returns a Series (with its own .polynomial / .order fields). Use .value only on DerivedResult.

Search plumbing (agent loops)

Need	Entry point
Bound one candidate	`Budget` + `context(budget=…)` → `BudgetExceededError` (`E-BUDGET-*`)
Fan out without aborting	`batch_map` / `integrate_many` / `simplify_many` / `diff_many`
Compact logs	`DerivedResult.to_dict(mode="compact")`
Session provenance	`alkahest.research` claim graphs
Propose and fit a parametric family	`alkahest.ansatz`
Differential-test against another CAS	`alkahest.crosscheck`
Hand off a discrete / mixed int-real subproblem	`alkahest.smt`

Docs: Autoresearch / agent loops.

Modules for autoresearch loops

Three submodules new in 3.8, aimed at unattended search. Each has its own chapter in the documentation site.

Module	What it does
`alkahest.ansatz`	Parametric families with named unknown coefficients — `polynomial`, `rational`, `exponential_polynomial`, `linear_combination`, `quadratic_form` — plus `fit` (solve for the coefficients from a residual, with a verification status), `enumerate_family`, and `certify_nonneg`. This is the "guess the shape, let the CAS pin the constants" loop, done once instead of re-improvised per problem.
`alkahest.crosscheck`	Differential testing against an external CAS. `check(op, …)` runs one comparison through a ladder of increasingly semantic rungs (syntactic → normalised → numeric → invariant) and reports `agree` / `diverge` / `incomparable` / `unavailable`; `sweep()` generates a seeded corpus of them; `run_frozen_corpus()` replays the pinned cases. A missing oracle is reported as `unavailable`, never as agreement.
`alkahest.smt`	SMT-LIB 2 export (`to_smtlib`) and a bridge to z3 / cvc5 (`solve`, `supported`, `solvers`). A `sat` model is lifted to exact rationals and substituted back and checked in-process; an `unsat` is reported as `externally_asserted` and is deliberately not counted as machine-checked. Algebraic-number witnesses are refused (`E-SMT-003`) rather than truncated to floats.

import alkahest as ak

pool = ak.ExprPool()
x = pool.symbol("x")

# Fit an ansatz
from alkahest.ansatz import polynomial, fit
A = polynomial(pool, [x], degree=2)
sol = fit(A, A.expr - (x**2 - pool.integer(3) * x + pool.integer(2)))
print(sol.expr, sol.status)          # (2 + x^2 + (x * -3))  exactly_verified

# Cross-check a result against SymPy
print(ak.crosscheck.check("integrate", x**2, x).outcome)     # 'agree'

# Ask whether the SMT route applies before paying for it
print(ak.smt.supported(pool.gt(x, pool.integer(0))).recommendation)   # 'prefer_in_tree'

Known limits

Alkahest is meant to be run unattended, so the limits are documented as prominently as the features. These are properties of the design, not open bugs — write the loop around them.

ExprPool never reclaims. The expression arena is append-only: no clear, no refcount, no GC. The only way to free interned nodes is to drop the whole pool, and every Expr / Matrix / DerivedResult holds a strong reference to its pool, so keeping one result keeps everything. Growth is roughly 200 bytes per node and linear forever (~2–3.5 KB per integrate call) while per-call latency stays flat — so a long-running loop on one pool dies by OOM with no slowdown to warn you first. Use one pool per problem and carry to_dict() envelopes, not live Expr handles. Details.
wall_ms is cooperative and its granularity is one primitive operation. A call stops at the first checkpoint after the deadline. Past a certain degree that operation is a FLINT call, which no cooperative mechanism can interrupt — a 300 ms budget on a degree-62 integrand returns after ~2 s. Only an OS-level timeout goes below that.
run_with_wall_fallback does not bound wall time for an uncooperative callee. It joins its worker before raising, so it returns when the callee returns: run_with_wall_fallback(time.sleep, 3.0, budget=Budget(wall_ms=50)) raises after 3000 ms. It exists to turn a silent truncation into a coded error, not to contain an unknown callee. Only integrate and limit currently honour the cooperative budget and release the GIL, so only they can be cancelled while already running.
decide refuses rather than answering in cases it cannot establish. It covers polynomial bodies in ≤ 2 real variables with a ≤ 2-quantifier prefix, and inside that fragment it raises E-CAD-001 when the only candidate solutions sit at an irrational boundary point that rational sampling cannot test. Same for linear algebra: an entry or determinant whose vanishing is undecidable gives E-LINALG-010 / E-MAT-004 instead of a guessed branch. A refusal means undecided, not false — a search loop that records it as a negative result closes a branch it never explored.
Matrix.eigenvals() can emit casus-irreducibilis cube roots. These are correct under Alkahest's real cube-root convention — eval_expr refuses them honestly and interval_eval returns an unbounded ball — but a principal-branch evaluator (SymPy, NumPy) returns a confident number that is not an eigenvalue. Evaluate inside Alkahest before exporting a radical expression to another tool. Details.

Reinforcement learning

alkahest.rl exposes verifiable RL environments backed by the CAS. The core layer (alkahest.rl.core) is trainer-agnostic; domain environments live under alkahest.rl.envs.* and optionally integrate with Prime Intellect Verifiers.

pip install "alkahest[rl]"   # Python ≥ 3.10; adds verifiers + datasets

from alkahest.rl.envs.integration import IntegrationVerifier, load_environment

verifier = IntegrationVerifier()
# reward = verifier.verify(model_output, {"f_expr": f, "is_elementary": True, "pool": pool})

env = load_environment(difficulty_tier=0, n_train=1000, n_eval=100, adaptive=True)

Component	Description
`IntegrationVerifier`	Layered check: symbolic diff → e-graph → interval spot checks; rewards honest refusal on NonElementary integrands
`load_environment()`	Returns a `verifiers.SingleTurnEnv` with Risch-tier curriculum
`recipes/verl_integration_reward.py`	Drop-in reward for veRL

Environments Hub: alkahest/alkahest-symbolic-integration — install with prime env install alkahest/alkahest-symbolic-integration. Publish updates from python/alkahest/rl/envs/integration/ with prime env push. Full checklist in the RL guide.

Documentation and further reading

Documentation site — full API reference and user guide
ARCHITECTURE.md — crates, directory layout, and key files
ROADMAP.md — planned milestones
CONTRIBUTING.md — Rust vs Python layer guide
TESTING.md — property-based testing, fuzzing, sanitizers, CI tiers
BENCHMARKS.md — criterion and Python benchmark suites
examples/ — runnable end-to-end examples
demo-playground/ — notebook UI, agent chat, and demo recording stack (the hosted playground is the WASM build of it)
LICENSE — Apache 2.0 license

Stability

Alkahest follows semantic versioning from 1.0. The stable surface is everything re-exported from alkahest_cas::stable (Rust) and alkahest.__all__ (Python). Experimental APIs live under alkahest_cas::experimental and alkahest.experimental and may change in minor releases.

Download files

Download the file for your platform. If you're not sure which to choose, learn more about installing packages.

Source Distributions

No source distribution files available for this release.See tutorial on generating distribution archives.

Built Distributions

If you're not sure about the file name format, learn more about wheel file names.

The dropdown lists show the available interpreters, ABIs, and platforms. Enable javascript to be able to filter the list of wheel files.

alkahest-3.8.0-cp313-cp313-win_amd64.whl (34.4 MB view details)

Uploaded Aug 13, 2026 CPython 3.13Windows x86-64

alkahest-3.8.0-cp313-cp313-manylinux_2_28_x86_64.whl (23.6 MB view details)

Uploaded Aug 13, 2026 CPython 3.13manylinux: glibc 2.28+ x86-64

alkahest-3.8.0-cp313-cp313-macosx_11_0_arm64.whl (4.6 MB view details)

Uploaded Aug 13, 2026 CPython 3.13macOS 11.0+ ARM64

alkahest-3.8.0-cp312-cp312-win_amd64.whl (34.4 MB view details)

Uploaded Aug 13, 2026 CPython 3.12Windows x86-64

alkahest-3.8.0-cp312-cp312-manylinux_2_28_x86_64.whl (23.6 MB view details)

Uploaded Aug 13, 2026 CPython 3.12manylinux: glibc 2.28+ x86-64

alkahest-3.8.0-cp312-cp312-macosx_11_0_arm64.whl (4.6 MB view details)

Uploaded Aug 13, 2026 CPython 3.12macOS 11.0+ ARM64

alkahest-3.8.0-cp311-cp311-win_amd64.whl (34.4 MB view details)

Uploaded Aug 13, 2026 CPython 3.11Windows x86-64

alkahest-3.8.0-cp311-cp311-manylinux_2_28_x86_64.whl (23.6 MB view details)

Uploaded Aug 13, 2026 CPython 3.11manylinux: glibc 2.28+ x86-64

alkahest-3.8.0-cp311-cp311-macosx_11_0_arm64.whl (4.6 MB view details)

Uploaded Aug 13, 2026 CPython 3.11macOS 11.0+ ARM64

alkahest-3.8.0-cp310-cp310-win_amd64.whl (34.4 MB view details)

Uploaded Aug 13, 2026 CPython 3.10Windows x86-64

alkahest-3.8.0-cp310-cp310-manylinux_2_28_x86_64.whl (23.6 MB view details)

Uploaded Aug 13, 2026 CPython 3.10manylinux: glibc 2.28+ x86-64

alkahest-3.8.0-cp310-cp310-macosx_11_0_arm64.whl (4.6 MB view details)

Uploaded Aug 13, 2026 CPython 3.10macOS 11.0+ ARM64

alkahest-3.8.0-cp39-cp39-win_amd64.whl (34.4 MB view details)

Uploaded Aug 13, 2026 CPython 3.9Windows x86-64

alkahest-3.8.0-cp39-cp39-manylinux_2_28_x86_64.whl (23.6 MB view details)

Uploaded Aug 13, 2026 CPython 3.9manylinux: glibc 2.28+ x86-64

alkahest-3.8.0-cp39-cp39-macosx_11_0_arm64.whl (4.6 MB view details)

Uploaded Aug 13, 2026 CPython 3.9macOS 11.0+ ARM64

File details

Details for the file alkahest-3.8.0-cp313-cp313-win_amd64.whl.

File metadata

Download URL: alkahest-3.8.0-cp313-cp313-win_amd64.whl
Upload date: Aug 13, 2026
Size: 34.4 MB
Tags: CPython 3.13, Windows x86-64
Uploaded using Trusted Publishing? Yes
Uploaded via: twine/7.0.0 CPython/3.13.14

File hashes

Hashes for alkahest-3.8.0-cp313-cp313-win_amd64.whl
Algorithm	Hash digest
SHA256	`4afbd8b29f2a586a3f3eb0f90e137d3dd1302d96f2b6d7fe7da8a98e7d805a4f`
MD5	`d5f5759a85c8e0ed51519aa81dea7033`
BLAKE2b-256	`bd14e1cf0d49549a4f474b1976e6d180d7564a1fde0f8d319a0ca4b053e55e6a`

Algorithm	Hash digest
SHA256	`6135ac21c04ac5b9310624a0049c3c74a2367a010fc8606d42a8f20f350744a1`
MD5	`39c50b69e9109bed795a81c9cd67b432`
BLAKE2b-256	`0cf7ef112571400f979994e4f369d5ec78c45ea2d154b434c61f24a996d3278e`

Algorithm	Hash digest
SHA256	`04fa5be2f0fadb21c06c0f27f1b85990192286caa1775dd9a1878614bc5ec8ef`
MD5	`cd5a2ea9660eb422dafeeb48c51c487c`
BLAKE2b-256	`c8fb025c32e7eb9e7a21bd6ae6ab3f27634c78abf0e755bce38344c843d713b3`

Algorithm	Hash digest
SHA256	`34a3356bb84aa839d0e59b31f4d0cfb875dd5b2988202fb3f1a542d6cfefe081`
MD5	`69bd731c365db2e4fab9273bd93494c5`
BLAKE2b-256	`e5d27214bb5aeeda872f7e2bd952a7c19db6593b1c6c40c13992d0ba049ddb9c`

Algorithm	Hash digest
SHA256	`52f9a01bc969f815c774c67b23ad007371b2d7792153724925aa047fa5d208a6`
MD5	`df34d8a21a9f558a202bf1cff494ea6b`
BLAKE2b-256	`1260e1ab22549950519c6a39395ee485c6c83654d9c047bb66511a9b1b8920e3`

Algorithm	Hash digest
SHA256	`2c557a3eda54a15b89b079ab6f8e8c0a9006640341493e588250fd91f4591be4`
MD5	`353ddf2c46dc46b09e0de3d594f824bc`
BLAKE2b-256	`94e6a9d5748254a0bf9338352eb887362d6aad6a6b481699d981c37e9253142a`

Algorithm	Hash digest
SHA256	`223c065d1ede5e034e5a9fd3362e37ddadf4ceebfad02fe9465773722239d354`
MD5	`cd33469d8c6d054f944065a5dc53e153`
BLAKE2b-256	`0ef63c0d97d311460149493fd9ea45a67a340dcd9f09bec56800c6170445c214`

Algorithm	Hash digest
SHA256	`7c7713f072129b04e49ac23b9a5a38f448a11606cd6fca4841f4d7f0d9506c8f`
MD5	`f680187e008e93235bb67f0939ce0963`
BLAKE2b-256	`d13c2aedda12e8cc4920cf44f77be2ed6da6fe2753e337778f808854c5c57b93`

Algorithm	Hash digest
SHA256	`15bfe3b4b814552d55ce1d088f3be891d969aca8b70a94e6ad31828c879652af`
MD5	`3c90479ce29d6b30c3cb377c367e0338`
BLAKE2b-256	`1cbaca55811750de3b40027bce410416b1d5b3c9f774ad83f4bfef23124c0cd1`

Algorithm	Hash digest
SHA256	`c5a465296e4a927a5538387afb1e15df30c82d28b8454d7ed653040e6bca3849`
MD5	`03afca613ef74b6542c7893a166b87a5`
BLAKE2b-256	`3f8df136d93bac346fd9c2cbcdc10b67b947ff649d1a8514d98be86b4bf4e4e5`

Algorithm	Hash digest
SHA256	`39945e019e999a155611b5732dc48d04f0d15e55332d2259225d33706a260006`
MD5	`1f615d3830916605eacc7bc04aa330b4`
BLAKE2b-256	`0857c8b338a4c1dd65d3a410f69570123935eeab862eb307592d17486b72ba3b`

Algorithm	Hash digest
SHA256	`2c2bce463c3e14e1ac02718edb8b7960b62c62aa5f6f402b9b29ba4afcf6efa0`
MD5	`e88a016b968dd7403f3c62b257d01a11`
BLAKE2b-256	`aacd6d9db8f6e2eda611c2df3003e3e6bab7e43dde581999ce13549387d92ad1`

Algorithm	Hash digest
SHA256	`39be5bd45b67690021da4a98387419bdd70d86ce82ca0b9f4819ab5c1e67e28d`
MD5	`32a440b7701124fa53fed03ba921e253`
BLAKE2b-256	`cc682407fa60d30b077d3808daeeb5a80f159d0df88c0186e11a35a4e754a409`

Algorithm	Hash digest
SHA256	`7a388b4683f77b02b81ad47033fdb1cfb24cf54be1af5bed096a53c87eb6d6c2`
MD5	`bcdc8cba35335363b62221dcdc223171`
BLAKE2b-256	`b0396ca096a14b8136b9a6ab4510ad79d65cb0dd62c21e3fa2560477e0c856e4`

Algorithm	Hash digest
SHA256	`c8fdfe8e671d2abd50c45117c0bc46c255ddc7ceae6587fec8402fad0ab7f461`
MD5	`4804222230aafce3592b3a4a04af44b9`
BLAKE2b-256	`bdfca1f83f5a813aa3692976b7afac6be1b37dbf6dfd4f589018161a302c990f`

alkahest 3.8.0

Alkahest

PyPI • crates.io • Docs • Website • RL environment • Demo

Highlights

Install

Install matrix (default vs opt-in wheels)

Opt-in Linux wheels: +jit and +full (PyTorch-style)

From source

Rust crate

Quick start

Features

Expression representations

Result objects

Search plumbing (agent loops)

Modules for autoresearch loops

Known limits

Reinforcement learning

Documentation and further reading

Stability

Project links

Key dates

1 maintainer

Credits

GitHub Statistics

License

Requires

Provides Extra

Classifiers

Download files

Source Distributions

Built Distributions

File details

File metadata

File hashes

Provenance

File details

File metadata

File hashes

Provenance

File details

File metadata

File hashes

Provenance

File details

File metadata

File hashes

Provenance

File details

File metadata

File hashes

Provenance

File details

File metadata

File hashes

Provenance

File details

File metadata

File hashes

Provenance

File details

File metadata

File hashes

Provenance

File details

File metadata

File hashes

Provenance

File details

File metadata

File hashes

Provenance

File details

File metadata

File hashes

Provenance

File details

File metadata

File hashes

Provenance

File details

Opt-in Linux wheels: `+jit` and `+full` (PyTorch-style)