psaegert/simplipy-assets

simplipy assets

Rule sets and engine configurations for simplipy, a fast, contract-sound simplification engine for symbolic mathematical expressions.

Install an engine by name (downloads this repository's files on first use):

pip install simplipy

import simplipy as sp

engine = sp.SimpliPyEngine.from_config(sp.get_path("acj-4-3"))   # or "acj-3-2", "acj-2-1"

engine.simplify(('/', '<constant>', '*', '/', '*', 'x3', '<constant>', 'x3', 'log', 'x3'))
# ('<mul>', '<constant>', '<div>', 'log', 'x3', '</mul>')

engine.simplify('x3 * sin(<constant> + 1) / (x3 * x3)')
# '<constant>/x3'

Artifact-to-package compatibility: simplipy ≥ 0.12 (the AC engine with the clean 23-operator vocabulary) pairs with the acj-* artifacts and the base config below. The pre-0.12 artifacts (2-1, 3-2, 4-3, dev_*) use the retired hyper-operator vocabulary (mult3, pow2, ...) and load only on simplipy ≤ 0.11 — pin pip install "simplipy<0.12" to use them.

simplipy ≥ 0.12 artifacts (AC engine, clean vocabulary)

Artifact	Sources ≤	Targets ≤	Rules	Mined with
acj-2-1	2	1	8	simplipy 0.12.0
acj-3-2	3	2	32	simplipy 0.12.0
acj-4-3	4	3	520	simplipy 0.12.0
base	—	—	—	bare 23-operator config, the mining starting point

Soundness correction (2026-07-29): acj-4-3 originally shipped 525 rules; the independent rule-complete gate (simplipy.verify.verify_ruleset) subsequently killed 5 of them (rootn applied with an expression-position index that is a non-integer almost everywhere — the left side is NaN a.e., so each rewrite is a positive-measure domain extension). The published set is the filtered 520; the removal is recorded in the provenance sidecar (post_filter), and the remaining rules gate clean (486 CERTIFIED + 34 TOLERATED).

Each engines/acj-<S>-<T>/ directory is self-contained and reproducible with the same one-command invocation shown below (deterministic — re-mining produces byte-identical rules; for acj-4-3 the re-mine reproduces the original 525, from which the 5 post_filter rules listed in the provenance are removed). The acj cells mine the complete source universe of the 23-operator vocabulary with the AC engine itself as judge: a candidate rule is accepted only if it strictly descends the engine's own reduction ordering, so nothing ships dead-on-arrival. The LLM proposal channel is off. The provenance sidecar's core_build field pins the exact code commit that produced the mine (<version>+g<sha>). Rule counts are small by design: the AC engine's canonical constructors already perform arithmetic, collection, and ordering natively, so rules only cover genuine mathematical identities.

Release gates (400-expression corpus, recorded at mining time): idempotence 0 failures, commutative-permutation invariance 0 failures on all three artifacts.

Legacy mined artifacts (simplipy ≤ 0.11)

Each artifact directory engines/<S>-<T>/ is self-contained and reproducible from one config and one command:

Artifact	Sources ≤	Targets ≤	Rules	Mined with
2-1	2	1	602	simplipy 0.8.0
3-2	3	2	647	simplipy 0.8.0
4-3	4	3	3,492	simplipy 0.8.0

The (S, T) cell mines the complete universe of source patterns up to length S against all candidate targets up to length T, augments the result with the certified survivors of a fixed 740-candidate LLM proposal batch (LLM_PROPOSALS_v1.json, identical across artifacts, sha256-pinned in each provenance sidecar), prunes rules whose effect the remaining rules already achieve compositionally, and promotes every rule to the strongest sound sort (_ arbitrary subtree, ! certified-finite subtree, ? variable-leaf) so each rule fires as generally as it soundly can. Larger cells subsume smaller ones; the smaller artifacts exist for fast loading and as fully-exhaustive reference points.

Every rule is independently verified: simplipy.verify.verify_ruleset gates each artifact (gate-clean, 0 KILL / 0 ENGINE-MISALIGN) and simplipy.verify.monitor_ruleset sweeps the deployed engine over an adversarial+sampled corpus (0 attributed violations) — a second soundness authority independent of the miner.

Each artifact ships:

• rules.json — the mined + proposed, covered-pruned, sort-promoted rule set
• config.yaml — the engine configuration (operator set; points at rules.json)
• mine.yaml — the exact mining configuration
• rules.json.provenance.json — everything that determines the mine: package and core build versions, host, parameters, seeds, the evaluation-matrix specification, per-length universe coverage, the proposals file's sha256 and per-outcome counts, per-length rule counts
• LLM_PROPOSALS_v1.json — the co-located proposal batch (also published once at proposals/LLM_PROPOSALS_v1.json)

Reproduce any artifact byte-for-byte (mining is deterministic, single-command):

pip install "simplipy>=0.8.0,<0.12"    # legacy artifacts; use "simplipy>=0.12" for acj-*
cd engines/2-1
simplipy find-rules -e config.yaml -c mine.yaml -o rules.json -v --reset-rules

The mine.yaml sets promote_sorts: true, so this single command mines, certifies the proposals, prunes, and sort-promotes — the whole pipeline. Verify the result independently:

from simplipy.verify import verify_ruleset, monitor_ruleset
verify_ruleset("rules.json")                         # per-rule gate: only CERTIFIED/TOLERATED
monitor_ruleset("rules.json", "config.yaml", run_selftest=True)   # deployed-corpus sweep

Development engines (simplipy ≤ 0.11)

Engine	Description
dev_7-3	Development engine (sources ≤ 7, targets ≤ 3) used by flash-ansr
dev_7-2	Development engine (sources ≤ 7, targets ≤ 2)

The development engines predate the 0.5.0 certification overhaul and the 0.7.x special-point certification; they are kept for compatibility with published experiments. The mined artifacts above are the recommended starting point for new work.

LLM proposal batch

proposals/LLM_PROPOSALS_v1.json contains 740 candidate rewrite rules proposed by a language model. Proposals carry zero authority: every candidate runs through the identical certification chain as mined rules (find_rules(..., proposals=...)), and only certified survivors join an artifact. The batch is a permanent, versioned input: artifacts pin it by sha256 in their provenance.