# FrankenSymPy — RULEBOOK v1.0 Assessment Packet

**Repository:** `Dicklesworthstone/frankensympy` · **Language:** Rust (Python compatibility shell) [Code-verified, High] · **Pinned commit:** `55d176b8625a2ad8d4fc995bd076e0f582098d2f` (2026-09-22 01:48:53 −0400 = 2026-09-22 05:48:53 UTC, [Git-observed, High]) · **Scope:** the pinned commit only. No tags point at the pin; **no tags and no GitHub Releases exist at all** [External, High] — `Cargo.toml` says `version = "0.1.0"` with `publish = false` (a version string is not a release). **Stars:** 3 · **Forks:** 1 · **Open issues:** 0 · **Created:** 2026-08-20 [External, High].

**Method (analyst):** shallow clone checked out at the pin under `~/workspace/.scratch/frankensympy-verify` (verified non-empty; remote HEAD confirmed identical via `git ls-remote` on 2026-09-22). Read: root `Cargo.toml` (full), `LICENSE` (verbatim), README (full, 413 lines), repo `AGENTS.md` (full), `COMPREHENSIVE_PLAN_FOR_FRANKENSYMPY.md` (head), all 29 crate manifests, `Cargo.lock` (asupersync/fnp-linalg/fsci-opt entries), `registries/claims.toml` (all 27 claims), `registries/dependencies.toml` (asupersync admission), `docs/` index, `artifacts/audit/reality-check-2026-09-07.md` (full — the revised Sep-8 adversarial self-audit), `artifacts/benchmarks/ws22_paired_benchmark_report.json` (parsed), `tools/perf/paired_bench.py` (contract), `tools/conformance-lab/corpus_gate.py` (the F1 fix — read at pin), `examples/external_consumer.rs`, `fsym-calculus` `integrate`/`limit` bodies, `fsym-polys` factorization pipeline, `fsym-proof-kernel` verifier entry points, `fsym-python` manifest. Counted: `.rs` files/lines (total and non-test; per-crate line counts in §§4.2/4.4 include all `.rs` under the crate directory, tests and examples included — the "largest crate" ranking is unaffected either way), `#[test]` functions, unsafe sites (comment-aware grep), forbid-gate placement, shim Python files and `import sympy` delegation sites, CI run conclusions via the GitHub Actions REST API (all 833 runs: 800 sampled across 8 pages; per-job conclusions for run #833 at the pin). **Not done:** the workspace was never compiled (no Rust toolchain on the analysis host; pinned `nightly-2026-08-20` not installed), no test was executed, no benchmark reproduced, the Python shell was never imported, no upstream-SymPy oracle was run. **A shallow clone was used throughout; commit-history claims beyond the pin are not independently sampled.**

**Tier legend (Rulebook §1):** **[Verified]** direct inspection of the pinned clone or a live page read by the analyst — flavors **[Counted]** (I ran the count), **[Git-observed]** (git metadata), **[Code-verified]** (source read); **[CI-observed]** is Tier 2 (seen executing on live CI pages — attests the suite *runs*, not that it is green); **[Maintainer claim]** asserted in README/docs, not independently executed; **[External]** independent sources; **[Inference]** analyst judgment, always labeled. Confidence: **High** / **Medium** / **Low**.

---

## Hook

A 97,062-line [Counted, High], single-maintainer, clean-room symbolic-mathematics rewrite in Rust that keeps a machine-readable ledger of everything it is *not* allowed to claim — 27 claims, 15 marked "implemented but uncertified," zero marked validated or certified [Counted, High] — ships its own adversarial self-audit documenting how its conformance harness failed open, then fixed the hole within two weeks [Code-verified, High], and runs a pinned SymPy 1.14.0 differential oracle to argue, case by case, that its Python shell behaves like the incumbent [Code-verified, High]. The catch is the one the ledger itself predicts: the build-and-test gate (CI Gate Topology) has failed 786 consecutive runs — the last green was run #47 on 2026-08-23 — and at the pinned commit the `cargo fmt --check` gate fails before the 1,127 counted unit tests ever execute [CI-observed via Actions API, High]. A second, lightweight branch-topology workflow is green at the pin, but it verifies repo hygiene, not the build — see claim 5. It is the most honest pre-certification codebase in the FrankenSuite and simultaneously the least shippable.

## TL;DR

- **What it is:** A from-scratch Rust reimplementation of SymPy (~97k first-party lines / 136 files across 29 crates at the pin [Counted, High]) pursuing a dual-lane architecture: a Python shell that preserves SymPy's object model (subclasses, metaclasses, `evaluate=False`, held forms) while eligible expression regions lower into a deterministic, proof-carrying native kernel. Single human maintainer (Jeffrey Emanuel), 33 days old, no release, no tags [Git-observed/External, High].
- **Strongest evidence:** A real factorization pipeline (Cantor–Zassenhaus, Hensel lifting, Zassenhaus recombination, multivariate support) [Code-verified, High]; an independent proof kernel with `verify_derivation_independent` and mutation-tested certificate families [Code-verified, High]; a 230-fixture differential admission corpus against a pinned SymPy 1.14.0 oracle [Code-verified, High]; zero `unsafe` blocks anywhere with crate-level `forbid(unsafe_code)` posture [Counted, High]; and the Sept-8 revised reality-check audit that reads like a red-team report against its own author — whose P0 finding (fails-open corpus wrapper) is verifiably fixed at the pin [Code-verified, High].
- **Strongest doubts:** the build-and-test gate has failed 786 consecutive CI runs (last green 2026-08-23; pin fails at the fmt gate, unit tests never run) [CI-observed, High]; the README's "green workspace tests" line is stale-by-a-month [Code-verified + CI-observed, High]; the 230/230 admission corpus is construction-only — an exact-surface diagnostic found 229/230 fixtures differing on method resolution order (MRO)/pickle [Code-verified, High]; the fresh clone does not build standalone (path deps on `../asupersync`, `../franken_numpy-pin`, `../frankenscipy-pin` are absent) [Code-verified, High]; four `import sympy` delegation sites in the dev shell undercut the "no upstream fallback" posture [Code-verified, High]; the license rider bars OpenAI/Anthropic from use, benchmarking, and analysis [Code-verified, High]; PERF-001's "materially outperforms" status sits above a paired report whose geometric mean favors the oracle 0.616 [Code-verified, High].
- **NODUS ring: Explore** [Inference, Medium] (TRL 3–4 — see §4.9). Substantive, lab-audited, unreleased, uncertified, with no bounded workload fit and no release artifact: the textbook Explore case.

---

## Quick Links

Pin-relative links (`blob/55d176b8625a2ad8d4fc995bd076e0f582098d2f`); each verified HTTP 200 on 2026-09-22 [Verified, High]:

1. [Repository](https://github.com/Dicklesworthstone/frankensympy)
2. [README](https://github.com/Dicklesworthstone/frankensympy/blob/55d176b8625a2ad8d4fc995bd076e0f582098d2f/README.md)
3. [License (with AI-lab rider)](https://github.com/Dicklesworthstone/frankensympy/blob/55d176b8625a2ad8d4fc995bd076e0f582098d2f/LICENSE)
4. [Claims registry (27 claims, 0 certified)](https://github.com/Dicklesworthstone/frankensympy/blob/55d176b8625a2ad8d4fc995bd076e0f582098d2f/registries/claims.toml)
5. [Adversarial self-audit, revised 2026-09-08](https://github.com/Dicklesworthstone/frankensympy/blob/55d176b8625a2ad8d4fc995bd076e0f582098d2f/artifacts/audit/reality-check-2026-09-07.md)
6. [Repo AGENTS.md (binding agent guidance)](https://github.com/Dicklesworthstone/frankensympy/blob/55d176b8625a2ad8d4fc995bd076e0f582098d2f/AGENTS.md)
7. [CI Gate Topology workflow and live runs](https://github.com/Dicklesworthstone/frankensympy/actions/workflows/ci.yml) — 833 runs; run #833 at the pin failed at `cargo fmt --check`, unit tests skipped (the second workflow, [Verify Remote Main](https://github.com/Dicklesworthstone/frankensympy/actions/workflows/branch-topology.yml), was green at the pin but tests branch hygiene, not the build)
8. [Paired benchmark report vs SymPy 1.14.0 (2026-09-06)](https://github.com/Dicklesworthstone/frankensympy/blob/55d176b8625a2ad8d4fc995bd076e0f582098d2f/artifacts/benchmarks/ws22_paired_benchmark_report.json)
9. [Comprehensive plan](https://github.com/Dicklesworthstone/frankensympy/blob/55d176b8625a2ad8d4fc995bd076e0f582098d2f/COMPREHENSIVE_PLAN_FOR_FRANKENSYMPY.md)
10. [Constitution (non-negotiable rules)](https://github.com/Dicklesworthstone/frankensympy/blob/55d176b8625a2ad8d4fc995bd076e0f582098d2f/docs/CONSTITUTION.md)

---

## Did You Know

The one error case in the project's own paired benchmark report is the most honest line in it: `integer_arith_rational` failed on *both* engines for opposite reasons — the subject refused with "RecursionError: expression nesting depth 4097 exceeds the bridge bound 4096 (FSYM_MAX_EXPR_DEPTH); refusing instead of risking a native stack overflow" while the oracle died with "ValueError: Exceeds the limit (4300 digits) for integer string conversion." Both engines hit a resource bound and said so; neither silently produced a wrong answer. The report kept the case in the outcome mix instead of scoring it. [Code-verified (report JSON read; refusal messages verbatim from `artifacts/benchmarks/ws22_paired_benchmark_report.json`), High.]

---

## Franken-worthy next steps

1. **Import the claims-registry pattern into the FrankenSuite's own QA:** require every assessment-facing repo to keep a machine-readable `claims.toml` with `present_tense_allowed = false` defaults and same-commit gate bundles, the way FrankenSymPy does. It is the strongest claim-hygiene machinery seen in the suite after FrankenRedis's negative-evidence ledger — and it directly answers the "README marketing dies here" problem. *Done when:* the requirement is written into the program's assessment protocol with a named owner, and one other repo adopts it. [Inference, High — process proposal]
2. **Fix the one red line that unlocks everything:** the entire G2 unit-test suite (1,127 counted test functions) has not executed in the build-and-test gate for 786 runs because `cargo fmt --check` fails first. Running the formatter and confirming a green run #834+ is the cheapest possible ring-moving action — it is also the falsifiable test of whether "green workspace tests" is a live claim or a memory. *Done when:* a CI run against a new pin concludes success on all three gates. [Inference, High]
3. **Prove the F1 fix with a committed regression test:** the Sep-8 audit's P0 (fails-open corpus wrapper) is fixed at the pin — `validate_report` now rejects empty/crashed reports — but the fix has no committed fault-injection regression test. Commit the monkeypatched-crash reproducer from the audit as a permanent test. *Done when:* `corpus_gate.py`'s test suite includes the crashed-child case and fails if the validation is ever weakened. [Inference, High]
4. **Adopt the paired-benchmark admission discipline suite-wide:** semantic admission *before* timing (divergent cases excluded from scoring, reported in the outcome mix), per-side coefficient of variation ≤5% eligibility, A/A null control on every run (*A/A: both arms run the same engine, so the ratio must be ~1.0 — a null check on the harness itself*), raw paired samples retained. FrankenSymPy's `tools/perf` harness is stricter than FrankenRedis's bench discipline. *Done when:* one other packet's benchmark section is re-run through these rules. [Inference, High]
5. **Stress-test the agent-native claim end to end:** have an agent (no source access) complete the `external_consumer.rs` loop — construct → differentiate → verify → export → replay — using only the versioned NDJSON/RPC protocol and stable term IDs, never parsing a printed string. *Done when:* the full loop completes through the protocol alone, with receipts recorded. This is the falsifiable version of architectural bet #6. [Inference, Medium]

---

## 4.1 Why it exists — the market problem

**The problem, as the maintainer frames it:** SymPy is the standard open-source computer algebra system — pure Python, ~20 years of development, BSD-licensed, deeply embedded in scientific Python — but its exactness costs performance (Python-level bignum and tree manipulation on hot paths), its dynamic object model makes formal reasoning about results nearly impossible, and its results carry no machine-checkable evidence: a factorization is a claim, not a certificate. The maintainer's stated bet is that a clean-room Rust rewrite can deliver memory safety without FFI, deterministic resource budgets, and — the differentiator — proof-carrying algorithms, where factorization, Gröbner bases, integration, and solving race multiple strategies but only an independent verifier can promote a candidate to an accepted result [Maintainer claim, Medium].

**Who feels the pain:** anyone embedding symbolic computation in an agent or automated pipeline who needs to *trust* a result without a human in the loop — plus the niche that wants SymPy semantics at native speed [Inference, Medium].

**Why now:** the Rust ecosystem is mature enough to attempt it, and the maintainer's own sibling program (asupersync for structured concurrency, FrankenNumPy/FrankenSciPy as numeric consumers) supplies the runtime and downstream the architecture assumes [Inference, Medium]. Whether "agents need certified symbolic results" is real demand or maintainer narrative is unproven — there are 3 stars, 1 fork, no release, no independent coverage [External, High within recall caveats]. **Evidence gap (recorded, not filled):** the tree contains no maintainer-motive document — no "why I'm doing this" beyond the architecture's internal logic. The source-project audit argues the technical case; the personal case is absent, and this packet will not invent it [Code-verified (absence), High].

**Why a rewrite, not a fork:** stated implicitly throughout the architecture package — only a clean room lets the maintainer re-derive every representation (canonical hash-consed term DAG, typed IDs, explicit domains) instead of inheriting SymPy's Python object model, which the dual-lane design treats as a compatibility surface rather than a foundation [Maintainer claim, Medium]. The plan document's source-project audit (`docs/SOURCE_PROJECT_AUDIT.md`) is the written version of this argument [Code-verified (existence), High].

**Adjacent context:** this is among the youngest entries in the FrankenSuite — created 2026-08-20, 33 days old at the pin — and the most architecturally ambitious: 24 planned workstreams (WS00–WS23) against a machine-readable DAG, where sibling repos ship one engine. Its thesis is that foundational scientific-Python infrastructure can be re-derived in Rust *with machine-checked parity and proof certificates*, not merely re-implemented [Inference, Medium].

## 4.2 What it is — repo TL;DR

A 29-crate Cargo workspace (root `Cargo.toml` verified at the pin [Counted, High]) implementing a SymPy-compatible symbolic mathematics system in Rust: exact integer/rational/modular/algebraic arithmetic (`fsym-bigint`, `fsym-rational`, `fsym-modular`), a semantic term DAG (`fsym-core`, 9,495 lines), an independent proof kernel (`fsym-proof-kernel`, 4,882 lines), polynomial arithmetic with a full Zassenhaus factorization pipeline (`fsym-polys`, 7,357 lines), exact linear algebra (`fsym-matrices`), simplification (`fsym-simplify`), calculus with bounded integration and limits (`fsym-calculus`), solvers/sets/logic/geometry/tensor domain slices, an asupersync-based portfolio runtime with cancellation and replay (`fsym-runtime`, 11,654 lines — the largest crate), a PyO3 Python bridge (`fsym-python`), a Python compatibility shell slice (`python/sympy`, 78 files), a conformance laboratory (`tools/conformance-lab`) that differentially tests the shell against a pinned SymPy 1.14.0 oracle, and `xtask` gate/receipt validators (the machine-readable claim machinery's executors).

One-line verdict: **the most rigorously self-honest pre-certification codebase assessed in this program — a real Zassenhaus factorization pipeline, a real independent proof verifier, and a differential-oracle harness, all wrapped in a machine-readable claims registry that refuses to certify any of it — under a CI that has not gone green in a month and a license that forbids the most likely evaluators from touching it.** (NODUS: Explore — see §4.9.)

## 4.3 Repo facts (claim inventory)

Every claim below was verified against the pinned commit on 2026-09-22. Tier flavors: Counted (I ran the count), Git-observed (git metadata), Code-verified (read the source), CI-observed (seen on CI pages), Maintainer claim (README/CHANGELOG/docs), External (third party). **Status** is the Rulebook's required audit verdict per claim.

| # | Claim | Status | Evidence | Tier, Confidence |
|---|-------|--------|----------|------------------|
| 1 | 29 workspace crates, 97,062 first-party Rust lines / 136 files (86,496 non-test lines in `crates/`) | demonstrated | Fresh clone at pin; file/line counts run over the tree | [Counted, High] |
| 2 | Zero `unsafe` blocks in the entire tree; 26 of 29 crates carry crate-root `#![forbid(unsafe_code)]` (the other three — `fsym-calculus`, `fsym-python`, `fsym-solvers` — carry it at module level); root `src/lib.rs` also forbids | demonstrated | Comment-aware grep for `unsafe` (only the identifier `unsafe_direct_substitution` — a *mathematical* guard in calculus, not Rust unsafe — and two `unreachable!` markers); gate-attribute scan per crate | [Counted, High] |
| 3 | asupersync 0.6.0 (pin `b3e08ac0b`) is a real runtime dependency of `fsym-durable`, `fsym-python`, `fsym-runtime`; the workspace **does not build from a fresh clone** — path deps on `../asupersync`, `../franken_numpy-pin`, `../frankenscipy-pin` are absent | demonstrated | `Cargo.toml`/`Cargo.lock`/crate manifests read; sibling dirs confirmed absent; `registries/dependencies.toml` records the asupersync pin with a prior full-workspace check/test artifact | [Code-verified, High] |
| 4 | `registries/claims.toml`: 27 claims — 1 `documented`, 15 `implemented_uncertified`, 11 `planned`; **zero `validated`, zero `certified`** | demonstrated | Full read at pin | [Counted, High] |
| 5 | CI Gate Topology red at the pin: run #833 (head = pin) fails at G1 `cargo fmt --check`; G2 unit tests skipped; G0 planning-integrity green. The repo's second workflow (Verify Remote Main, branch-topology guard) was green at the pin (run #804) — it does not build or test the workspace | demonstrated | Actions REST API (both workflows' runs endpoints), per-job conclusions, 2026-09-22 | [CI-observed, High] |
| 6 | The CI Gate Topology workflow has not gone green in 786 consecutive runs (last success: run #47, 2026-08-23; 833 − 47 = 786, all-failure confirmed across 8 pages of the ci.yml runs endpoint) | demonstrated | Actions API, all 833 ci.yml runs | [External, High] |
| 7 | README claims "green workspace tests" | stale | README IMPORTANT box at pin vs. claim 6 — the Sep-3 self-audit claimed "passes fmt/check/clippy/workspace-tests with zero failures" locally; CI has been red since 2026-08-23 | [Code-verified + CI-observed, High] |
| 8 | 1,127 `#[test]` functions across crates+src+tools (1,162 repo-wide); only `unreachable!` stub markers, no `todo!`/`unimplemented!` in `src/` | demonstrated | Counted at pin | [Counted, High] |
| 9 | Full Zassenhaus factorization pipeline: Cantor–Zassenhaus equal-degree splitting, classical Hensel pair lifting, Zassenhaus recombination; multivariate polynomials supported | demonstrated | `crates/fsym-polys/src/factorization.rs` read (1,700+ lines); `gcd.rs` uses `MultivariatePoly` | [Code-verified, High] |
| 10 | Independent proof kernel: `verify_derivation_independent`, rule-application checkers, RealBall certificate checker, capsule verifier; generator crates depend on the kernel, never vice versa (constitutional separation holds) | demonstrated | `fsym-proof-kernel/src/kernel.rs` entry points read; dependency direction verified in manifests | [Code-verified, High] |
| 11 | `integrate` is bounded: sums/products with constant separation, integration-by-parts for (polynomial × linear-analytic) products, typed `IntegrationFailed` refusal elsewhere; `limit` = polynomial-at-±∞ degree analysis plus guarded direct substitution | demonstrated | `crates/fsym-calculus/src/lib.rs` bodies read (L902–1000) | [Code-verified, High] |
| 12 | Pinned SymPy 1.14.0 differential oracle wired in `tools/conformance-lab`; 230/230 construction admission corpus; but admission is construction-only — the independent Sep-8 audit's exact-surface diagnostic found 229/230 fixtures differing on MRO/pickle | demonstrated (existence + the caveat); "full compatibility" is aspirational | Source pin `16fa855354eb7bcabd3fe10993841e03b1382692` in README; `capture.py:cmd_diff` selects `construction_only`; reality-check audit F2 | [Code-verified, High] |
| 13 | Corpus wrapper P0 (Sep-8: a crashed child emitting valid-but-empty JSON made the wrapper exit 0) is **fixed at the pin** — `validate_report` enforces exact field-set match, child exit-status agreement, and corpus-partition completeness; no committed regression test for the fix was found | demonstrated (the fix); the missing regression test is a gap | `tools/conformance-lab/corpus_gate.py` L50–110 read at pin; audit F1 reproducer | [Code-verified, High] |
| 14 | Paired benchmark report (2026-09-06, subject head `d3fa70aa` ≠ pin): 15 cases, 11 admitted, 3 divergences, 1 error; geometric mean of oracle/subject ratios 0.616 (oracle faster overall); A/A null control verified | demonstrated (report exists and is honest); PERF-001's `implemented_uncertified` "materially outperforms" status overstates it | `artifacts/benchmarks/ws22_paired_benchmark_report.json` parsed | [Code-verified, High] |
| 15 | Python compatibility shell: 78-file `python/sympy` slice across 17 submodules (vs upstream SymPy 1.14's ~45 top-level modules — no stats, physics, crypto, plotting, parsing…) | demonstrated (the slice); drop-in replacement planned | Directory/file counts at pin; upstream layout [External, Medium] | [Counted, High] on the slice |
| 16 | License rider bars OpenAI, Anthropic, affiliates, and anyone acting for them from use incl. benchmarking/analysis/training; breach = automatic termination | demonstrated | LICENSE read verbatim at pin | [Code-verified (license text), High] |
| 17 | Single human maintainer; 3 stars, 1 fork, 0 issues; no tags, no releases; repo created 2026-08-20 | demonstrated | GitHub API, 2026-09-22 | [External, High] |
| 18 | Four `import sympy` delegation sites in the **product** dev shell: `series`/`integrate`/`limit` methods on the base `Expr` and relation pretty-printing delegate to upstream SymPy. Distinct from test-oracle usage (`python/tests/test_oracle_differentials.py` probes) and from the test suite importing the shim itself as `sympy` — the latter is the drop-in environment working as designed, not a fallback | demonstrated | `python/sympy/core/__init__.py` L1453–1461, `python/sympy/printing/pretty.py` L30 read at pin | [Code-verified, High] |

**What the inventory says in aggregate:** claims about *process and honesty machinery* (claims registry, self-audit, differential oracle, unsafe containment) verify at High confidence; claims about *outcomes* (green tests, compatibility, performance) are either stale, bounded, or self-refuted by the project's own artifacts. The ledger is the product as much as the code is.

## 4.4 Codebase tour

**Workspace topology (29 members, [Counted, High]):** `fsym-id`, `fsym-budget`, `fsym-outcome`, `fsym-bigint`, `fsym-rational`, `fsym-modular`, `fsym-core`, `fsym-polys`, `fsym-simplify`, `fsym-calculus`, `fsym-solvers`, `fsym-matrices`, `fsym-functions`, `fsym-logic`, `fsym-ntheory`, `fsym-sets`, `fsym-geometry`, `fsym-tensor`, `fsym-assumptions`, `fsym-printing`, `fsym-runtime`, `fsym-conformance`, `fsym-proof-kernel`, `fsym-formal`, `fsym-evidence`, `fsym-durable`, `fsym-python`, `fsym-capsule-consumer`, `fsym-numeric-consumer` — plus `xtask` (gate and receipt validators: the executors of the claims machinery) and the root `frankensympy` library crate (`src/`, session API).

**Dependency posture:** the external universe is narrow — `num-bigint`/`num-rational`/`num-traits`/`num-complex`/`num-integer` (foundational bignum), `serde`/`serde_json`, `thiserror`, `blake3`, `proptest` (dev), `pyo3 0.27` (the audited bridge exception the constitution permits) [Counted, High]. No tokio, no C/C++ CAS FFI, no second async runtime — the forbidden families in `registries/dependencies.toml` hold [Code-verified, High]. The FrankenSuite-internal posture is the opposite of frankenredis's: **asupersync is a live runtime dependency**, not a rejected one — `fsym-runtime` wraps asupersync execution contexts (`FsymCx`, "wrap-and-delegate"), `fsym-durable` and `fsym-python` build on it, and the constitution names it "the only async/concurrency runtime" [Code-verified, High]. Cross-repo path deps (`../franken_numpy-pin` for `fnp-linalg`, `../frankenscipy-pin` for `fsci-opt`) serve the numeric-consumer bridge [Code-verified, High].

**Data flow, end to end:**

- **Surface — `python/sympy` + `fsym-python`:** a real Python object model (ordinary classes, metaclasses, `evaluate=False` held forms, `_eval_*` hooks, singleton atoms like `Half`) written in Python, with a PyO3 native bridge for lowering eligible regions. The shell is the larger engineering bet than the kernel: commit evidence shows weeks of oracle-driven singleton/canonicalization work (Zero/One/NegativeOne/Half identity, pickle round-trips) [Code-verified, Medium]. Four methods still delegate to upstream SymPy (claim 18) — scaffolding, not architecture.
- **Terms — `fsym-core` (9,495 lines):** semantic term DAG with BLAKE3 content-addressed interning, typed `TermId`s, assumptions contexts; the three graphs (surface / semantic / evidence) are separate layers by construction [Code-verified, High].
- **Arithmetic — `fsym-bigint` (Number Theoretic Transform multiplication, 6,900 lines), `fsym-rational`, `fsym-modular`:** exact tower, no FFI bignum [Code-verified, High].
- **Algebra — `fsym-polys` → `fsym-proof-kernel`:** the Zassenhaus pipeline above; outputs are candidates until the kernel's independent checkers accept the typed claim [Code-verified, High].
- **Calculus — `fsym-calculus` (5,957 lines):** differentiation (real), bounded integration, limits, Taylor, sparse Jacobians with distance-1 coloring (*grouping Jacobian columns so structurally non-overlapping columns share a color, cutting evaluations*), symbolic compilation to numeric targets [Code-verified, High].
- **Runtime — `fsym-runtime` (11,654 lines, largest crate):** portfolio execution, region-owned asupersync tasks, cancellation (request → drain → finalize), budgets, replay, checkpoints, repair [Code-verified, High].
- **Evidence — `fsym-evidence`, `fsym-formal`:** the promotion lattice (`Accepted`/`Conditional`/`HeuristicCandidate`/`Refused`/…) and formal-proof interop surface [Code-verified, Medium].
- **Conformance — `tools/conformance-lab` + `fsym-conformance`:** isolated oracle subprocesses, fixture admission, ledgering; the F1 wrapper lives here, fixed at the pin [Code-verified, High].

## 4.5 The maintainer's stated case

**The pitch, in the maintainer's own structure:** the README's IMPORTANT box is the pitch and the disavowal in one paragraph — "implementation in progress, pre-certification … **not** a certified SymPy replacement: no compatibility profile is certified, no performance win is demonstrated, and all `validated`/`certified` gates remain open" [Maintainer claim, High — quoted verbatim]. The seven architectural bets (dual-lane, three graphs, domain-explicit exactness, proof-carrying portfolios, asupersync resource sovereignty, agent-native state, recoverable fabric) and the "Intended leapfrog" table are explicitly labeled target properties that "become present-tense claims only after the gates in `registries/claims.toml` pass."

**Benchmark and conformance audit:**

| Number | Source | Methodology | Verdict |
|---|---|---|---|
| 230/230 construction admission vs SymPy 1.14.0 | Maintainer (claims.toml COMPAT-002 notes, Sep-5) | `capture.py:cmd_diff` with `construction_only` comparator; isolated oracle venv | **Survives as construction parity only** — the Sep-8 audit's exact-surface diagnostic found 229/230 differing on MRO/pickle. Citing it as "full parity" misrepresents the source [Code-verified, High] |
| 15-case paired benchmark, 11 admitted, geomean 0.616 (oracle faster) | Maintainer artifact (`ws22_paired_benchmark_report.json`, Sep-6) | Semantic admission first, alternating subject/oracle subprocesses, cv≤5% eligibility, A/A null verified (1.027), raw samples retained | **Survives as an honest mixed result** — the method is the strongest in the suite; the outcome does not support PERF-001's "materially outperforms" [Code-verified, High] |
| "Green workspace tests" (README) | Maintainer (README IMPORTANT box) | Local run at the Sep-3 self-audit snapshot | **Stale at the pin** — CI Gate Topology red since 2026-08-23; G2 never executes at the pin [CI-observed, High] |
| 55/55 proof-kernel tests, 41/41 polys tests, 16/16 directed-rounding mutants killed (WS06/WS08/WS11 closures) | Maintainer (commit messages, audit bundles) | Mutation gates per certificate family | **Plausible but locally observed** — CI has not executed them in a month; treat as [Maintainer claim, Medium] until a green CI run re-executes them |

**Independent numbers:** none exist — no independent benchmark, review, or deployment found in web search [External, High within recall caveats].

**Reproduction cost:** a fresh clone cannot `cargo check` — it needs sibling checkouts of `asupersync`, `franken_numpy-pin`, and `frankenscipy-pin` at compatible commits (only the asupersync pin, `b3e08ac0b`, is recorded in `registries/dependencies.toml`) plus the pinned `nightly-2026-08-20` toolchain (`rust-toolchain.toml` read at pin — not installed on the analysis host) [Code-verified, High]. The oracle lane additionally needs a Python 3.14 venv with SymPy 1.14.0 at source pin `16fa8553…` [Maintainer claim, Medium].

## 4.6 Competitors

The incumbent wins on ecosystem, correctness breadth, and twenty years of edge-case accumulation; FrankenSymPy's only uncontested edge is its evidence apparatus (proof certificates, machine-readable claim gates, adversarial self-audit) — which no competitor bothers with because no buyer currently pays for it [Inference, Medium].

- **SymPy (BSD, ~2007–):** the incumbent — pure-Python CAS, ~45 top-level modules, the de-facto symbolic layer of scientific Python. Owns the lane by every measure that matters today: users, ecosystem, correctness on the long tail [External, High on identity; Medium on the assessment]. FrankenSymPy's compatibility target is literally SymPy 1.14.0.
- **SymEngine (BSD, C++ core + `symengine.py` wrappers):** the direct "fast SymPy core" precedent — a from-scratch C++ engine with Python bindings that has existed for a decade and still has not displaced SymPy. The mechanism matters: SymPy's moat is not speed but *ecosystem lock-in* — notebooks, downstream packages, and twenty years of Stack Overflow answers all assume SymPy's object model and quirks. SymEngine is faster and still lost the adoption war, which means FrankenSymPy's dual-lane compatibility bet (preserve the object model!) is aimed at the right target even though its proof-carrying differentiator is unproven [External, High on identity; the mechanism reading is Inference, Medium].
- **SageMath:** the distribution play — bundles SymPy/Maxima/PARI into a monolith. Owns the "batteries-included research" lane [External, High].
- **Mathematica / Maple (commercial):** own the "correctness you can bill for" lane with proprietary kernels and support contracts [Inference, Medium].
- **Julia Symbolics.jl:** the "modern language, fast CAS" lane — metaprogramming-native symbolic computation with real adoption in SciML [External, Medium].
- **FrankenLean (sibling):** Lean 4 toolchain in Rust — adjacent, not competitive; the natural formal-verification partner for FrankenSymPy's certificate ambitions [Inference, Medium].
- **Unoccupied lane:** a *memory-safe, proof-carrying* CAS with machine-checked claim gates and agent-native structured state has no direct occupant — SymEngine chases speed, SageMath chases breadth, nobody chases evidence [Inference, Medium]. Whether any buyer will pay for certificates over speed or breadth is the unproven bet the whole project rests on.

## 4.7 Skeptic's take

Weaknesses, each substantive:

1. **[FATAL] The license rider poisons the well it drinks from.** Barring OpenAI/Anthropic *and their affiliates and anyone acting for them* from use, benchmarking, analysis, indexing, and training-data incorporation doesn't just block two companies — the "acting directly or indirectly for … or for the benefit of" prong creates legal uncertainty for any contributor near the AI supply chain, and a project whose moat is *evidence* forbidding evidence-gathering by the best-equipped evaluators is self-negating [Inference, High]. The rider's "analyzing" bar arguably covers this very assessment — see §4.8.
2. **[HIGH] The build-and-test gate has failed 786 consecutive runs; the pin is red at the formatting gate.** The README claims "green workspace tests" while G1 fails at `cargo fmt --check` and G2 (1,127 counted tests) never executes [CI-observed, High]. A second workflow (Verify Remote Main) is green at the pin, but it checks branch topology — no Rust test has executed in CI for a month either way. A project whose pitch is auditability cannot keep its own front gate green for a month. The counter — local green runs at self-audit snapshots — is exactly the "works on my machine" the CI exists to kill.
3. **[HIGH] The 230/230 admission number is construction-only.** The Sep-8 audit's own diagnostic: 229/230 fixtures differ on the exact-surface comparator (MRO, pickle bytes). The claims registry keeps COMPAT-002 at `planned` with `present_tense_allowed = false` — honest — but the number will be quoted out of context the moment it leaves the repo [Code-verified, High].
4. **[MEDIUM] The F1 fix has no committed regression test.** The fails-open corpus wrapper was a genuine P0 on Sep-8 and is verifiably fixed at the pin — audit-to-remediation in ≤14 days is a real governance signal. But the fix's only proof is the code itself; the audit's monkeypatched-crash reproducer was not committed as a test, so nothing stops a future edit from silently re-opening the hole [Code-verified, High].
5. **[MEDIUM] The fresh clone does not build.** Path deps on `../asupersync`, `../franken_numpy-pin`, `../frankenscipy-pin` mean a cold reader cannot `cargo check` the workspace. For a project selling reproducibility and auditability, the build's first step is "go clone three more repos at these pins" [Code-verified, High].
6. **[MEDIUM] Four `import sympy` delegation sites in the dev shell.** The base `Expr`'s `series`/`integrate`/`limit` and the relation pretty-printer delegate to upstream SymPy. COMPAT-004 ("no fallback in certified paths") is still `planned`, so no claim is violated — but the "never a hidden production fallback" posture currently rests on a status flag, not on the code [Code-verified, High].
7. **[MEDIUM] The workspace grew past its own documentation in 33 days.** COMPREHENSIVE_PLAN (Aug 29): 25 crates, ~66k lines [Maintainer claim]. Sep-3 audit: 25 crates, ~73k src LOC, ~798 test fns [Maintainer claim]. Pin (Sep 22): 29 crates, 97k lines, 1,127 tests [Counted]. The plan's architecture index is a living document chasing a moving target — drift is structural, not incidental [Inference, Medium].

**Bear-case steelman (strongest counter-case):** FrankenSymPy is a 33-day-old, single-maintainer architecture fantasy about *how* to build a trustworthy CAS, not a CAS. Nothing is certified, nothing is released, the build-and-test gate has failed 786 times in a row, the conformance gate failed open until this month, the fresh clone doesn't build, the dev shell quietly delegates calculus to the incumbent it claims to replace, SymEngine already occupies the "fast SymPy" lane with a decade's head start, and the license forbids the only entities with the resources to validate it from even analyzing it. The rational market response is to mine it for governance machinery (the claims registry, the paired-bench admission rules, the adversarial self-audit format) and never run it. Its most likely end state is abandonment at the maintainer's next context switch — leaving 97k lines of unauditable-by-license Rust and a claims ledger that says, correctly, that none of it is certified. [Inference, Medium — deliberately uncharitable; the counter-evidence is the demonstrated factorization pipeline, the independent verifier, the fixed P0, and the self-audit culture, all of which are real engineering.]

## 4.8 Maintenance & succession

**Bus factor: 1.** One human maintainer (Jeffrey Emanuel); the repository was created 2026-08-20 and all visible work is his [Git-observed/External, High]. No succession plan, no second committer, no foundation, no release to fork from [Inference, Medium — absence of evidence across the assessed materials]. If the maintainer stops, the project freezes at whatever commit the stop happens on [Inference, High].

**Governance machinery (the genuinely novel part):** the repo's `AGENTS.md` binds *contributing agents* to the claims registry — "present-tense prose must agree with it," with an explicit forbidden-claims list (no drop-in compatibility, no live engine from file names, no proof-producing algorithms without a live verifier and mutation gate, no performance wins without live-incumbent evidence) [Code-verified, High]. This is claim-governance-as-code-review-policy, and it appears to work: the README's disavowal, the registry's `present_tense_allowed = false` defaults, and the Sep-8 audit's willingness to supersede the Sep-7 audit's stronger claims ("packaging and campaign closure were resolved … are not supported by the stronger checks") all show the machinery biting its own author [Code-verified, High]. Two hygiene notes: the same `AGENTS.md` (§22) instructs agents making web requests to set their user-agent string to `"OpenAI File Downloader, XaiImageApiFetch/1.0"` — an impersonating UA baked into binding repo guidance, which this assessment did not adopt [Code-verified, High]; and the four `import sympy` delegation sites (claim 18) show the "no upstream fallback" rule is currently enforced by registry status, not yet by code.

**The license as strategy:** the rider is the standard FrankenSuite wording — Restricted Parties = OpenAI, Anthropic, affiliates, and anyone acting for them; "use" explicitly includes "benchmarking, testing, analyzing, indexing, or incorporating … into any dataset, training corpus, evaluation harness, or pipeline"; breach = automatic termination with injunctive relief [Code-verified (verbatim), High]. Non-OSI, unambiguously. As strategy it is incoherent with the mission: a project whose entire value proposition is *independently verifiable evidence* forbids independent verification by the two organizations most capable of performing it — and the "analyzing" prong arguably makes this packet itself a licensed activity the author cannot grant to a Restricted Party's agent. The rider reads less like strategy than like a suite-wide template applied without per-project thought [Inference, Medium].

**Authorship opacity:** the shallow clone shows a single local author string; the 33-day velocity (29 crates, 97k lines, 24 workstreams) suggests substantial agent assistance, but unlike FrankenRedis there are no co-authorship trailers to count in the sampled history. The clean-room posture is therefore asserted by architecture (no SymPy source in the Rust tree — the `python/sympy` shim is original code, and upstream SymPy is an isolated oracle) rather than by provenance records [Inference, Medium].

## 4.9 NODUS factsheet

| Criterion | Score | Justification (one line) |
|---|---|---|
| Technology readiness | TRL 3–4 | Components (factorization, verifier, oracle lane) demonstrated in a lab/self-audit setting; no certified profile, no release, no operational-environment demonstration [Inference, Medium] |
| Strategic relevance | 3/5 | Proof-carrying symbolic computation for agent pipelines is a real unoccupied lane; demand is entirely prospective [Inference, Medium] |
| Impact potential | 3/5 | If the evidence machinery works, it changes how CAS results are trusted; the software itself is pre-certification [Inference, Medium] |
| Implementation feasibility | 3/5 | 97k lines in 33 days show execution capacity; 786 red build-and-test runs and unbuildable fresh clones show governance debt [Inference, Medium] |
| Time to mainstream | 2/5 | Certification of even one SymPy profile is years out at this velocity-to-debt ratio [Inference, Low] |
| Collaboration potential | 2/5 | The rider excludes the two most capable AI-lab collaborators; the claims-registry machinery is the collaborable artifact [Inference, Medium] |

**Ring: Explore** [Inference, Medium]. The assignment rules are mechanical here: *Invest* requires independent validation plus governance — there is no independent validation; *Pilot* requires a release artifact plus a bounded real workload fit — there is no release and no workload; *Monitor* is for websites and plan-stage work — this is far past plan-stage. Explore is the default for substantive-but-unproven, and this packet is its portrait. Ring down, not up: the red CI keeps it at Explore rather than Explore-with-exemplar.

## 4.10 Wardley placement

- **Exact arithmetic / bignum / term interning:** commodity surface — `num-bigint`, BLAKE3, hash-consing are solved problems; the custom NTT in `fsym-bigint` is custom-built on top of commodity [Inference, Medium]. Moves toward pure commodity if the NTT is ever dropped for a dependency.
- **The Rust CAS core (polys, calculus, solvers):** custom-built — no incumbent exists in this form; SymEngine is the C++ analog [Inference, Medium]. Moves toward product only with a certified profile and a release.
- **The claims registry + adversarial self-audit machinery:** genesis-stage novel — no CAS ships machine-readable claim gates or publishes red-team audits of its own harness [Inference, Medium]. Moves toward custom-built the day one sibling repo adopts it; that adoption is also its survival path if the software dies. This is the component most likely to be copied before the software is ever used.
- **The differential-oracle conformance lab:** custom-built trending toward product — the pattern (pinned incumbent as isolated oracle, semantic admission before timing) is generalizable beyond CAS [Inference, Medium].

## 4.11 Trajectory (12 / 24 / 60 months)

**[Inference — all of this section.]** Base case (12 months): the maintainer keeps the current velocity for another quarter, the claims ledger stays honest, one or two workstream slices (WS09 factorization, WS12 Jacobian) reach `validated`, and the repo remains a fascinating pre-certification artifact with single-digit-to-tens stars. The rider and the bus factor cap everything else.

Upside bifurcation (24 months) requires three observable events in sequence: (1) CI goes green and stays green — the fmt gate is the tripwire; (2) the F1 fix gains its regression test and the 230-fixture corpus is re-admitted under the exact-surface comparator, moving a COMPAT claim to `validated`; (3) a second maintainer or institutional adopter appears. If all three land, the credible outcome is a `validated`-but-not-certified symbolic core embedded in agent pipelines via the numeric-consumer bridge — the "agent-native symbolic state" bet paying off without full SymPy compatibility ever arriving.

Decay looks like this: velocity drops (the pattern seen in sibling repos), the red CI becomes permanent background noise, the claims registry freezes with 15 `implemented_uncertified` claims nobody promotes, and the repo becomes a 100k-line monument to a governance idea — with the rider guaranteeing no AI lab will rescue it.

At 60 months the branch resolves cleanly: either the evidence-machinery pattern has been copied into at least one surviving system (the methodology-export win, with the software itself a footnote) or the repo is archived and read, if at all, as a cautionary tale about building the audit before the product.

**Revisit triggers:** first green CI Gate Topology run after the 786-run red streak; any claim moving to `validated` in `claims.toml`; a committed F1 regression test; a second human committer; first tagged release; an independent benchmark or deployment (any party, any scale).

## 4.12 Limitations and open questions

**Not done:** the workspace was never compiled or executed (no Rust toolchain on the analysis host; pinned nightly not installed); no test was run by the analyst; no benchmark was reproduced; the Python shell was never imported; the SymPy oracle lane was never executed; commit-history analysis was limited by the shallow clone (authorship/trailer claims beyond the pin are unsampled); only a subset of the 33 `docs/` files were read in full; the `xtask` gate tooling was inspected, not run; per-job CI conclusions were fetched only for run #833 (the pin) — the 786-run red streak is conclusion-level, not step-level, evidence; the F1 fix was verified by reading the pinned `corpus_gate.py`, not by executing the audit's fault injection.

**Open questions that would most change the verdict:**
1. Do the 1,127 tests actually pass at the pin? (A green G2 run would retire weakness #2 overnight.)
2. Does the F1 fix have a committed regression test anywhere outside `corpus_gate.py` itself? (Only the pinned file was checked.)
3. What fraction of the 97k lines is agent-authored, and does the maintainer's clean-room posture survive the answer?
4. Is there a real consumer for the numeric bridge (FrankenNumPy/FrankenSciPy), or is INTEGRATION-003 aspirational layering?
5. Would the maintainer drop or narrow the rider if a credible institutional adopter asked? (The rider is currently the binding constraint on every upside scenario.)

---

## The eight deepening questions

**1. Provenance.** The system records *claim* provenance meticulously — every claim has an ID, status, gate, evidence artifacts, and dated notes in `registries/claims.toml`, and receipts carry digests (`artifacts/audit/receipts/`). But *artifact* provenance is weaker: the Sep-7 audit caught conformance running against a prebuilt `.so` whose SHA did not bind it to the Rust source, and receipt hashing checks internal consistency, not source authority (audit F4). Portable attestation would require binding each receipt to the exact source tree (commit hash + dirty state) and the exact binary that produced it — the audit's SHA-recording habit is the prototype, not the system. [Code-verified, High on the mechanism; the gap is Inference, Medium]

**2. The embeddable unit.** The smallest useful piece is `fsym-core` + `fsym-proof-kernel`: the typed term DAG with BLAKE3 content identity and the independent verifier, without the Python shell, the runtime, or asupersync. Adoption cost: the crates are `forbid(unsafe_code)` with a narrow dependency footprint (`num-*`, `serde`, `blake3`, `thiserror`) — but they live in a workspace that does not build standalone (path deps), so extraction means vendoring or forking the workspace. The `external_consumer.rs` example sketches the intended session-level embedding. [Code-verified, High on structure; extraction cost is Inference, Medium]

**3. Unexercised option value.** The architecture holds three unused options: a declared WASM subset (PLATFORM-001, `wasm32-unknown-unknown` already in the toolchain targets) that no crate has been compiled against; the RaptorQ repair machinery (available via asupersync, which the README credits with "RaptorQ mechanisms") with no demonstrated symbolic workload using it; and the e-process/conformal monitoring substrate with no registered live monitor. What unlocks them is the same thing in each case: a *validated* claim that names the option as its evidence — the registry is designed for exactly this, but every relevant claim is still `planned`. [Code-verified, High on the declarations; the unlock is Inference, Medium]

**4. Benchmark honesty.** The numbers that would survive an independent rerun are the paired report's *method* (admission-first, cv gates, A/A null, raw samples retained) and its *mixed outcome* (geomean 0.616 for the oracle) — both are checkable from the retained JSON. The number that would not survive as stated is PERF-001's "materially outperforms" at `implemented_uncertified`, which the report it leans on contradicts on the geometric mean. The load-bearing number for the thesis is not a speed ratio at all: it is the 230/230 construction admission, and the Sep-8 audit already showed it is construction-only. [Code-verified, High]

**5. The governance path.** The credible route from one maintainer to an institution runs through the claims registry: it is already a machine-readable contract a second party could audit against, and the AGENTS.md binding shows the maintainer thinks in terms of governance-as-code. What breaks first if velocity decays is the CI: it is already red, so there is no green baseline for a successor to inherit — the first institutional act would have to be fixing the build before reading the code. The bus factor is 1 with no succession document. [Inference, Medium]

**6. The license as strategy.** The rider excludes OpenAI, Anthropic, their affiliates, and anyone acting for or benefiting them — from use, copying, benchmarking, analyzing, indexing, and training-data incorporation, with automatic termination on breach. It sabotages the stated mission: the mission is independently verifiable mathematical evidence, and the exclusion targets the organizations best equipped to verify, benchmark, or adopt it, while adding legal uncertainty for any contributor near the AI supply chain. As a moat it protects nothing (there is no product to protect); as a signal it selects for adopters who cannot evaluate what they adopt. [Code-verified (verbatim text), High; the strategic judgment is Inference, Medium]

**7. Agent-era fit.** The concrete workload is an agent doing symbolic-numeric science: construct a residual system, differentiate it, get a proof-carrying Jacobian, compile it to a numeric kernel, and replay the derivation — all through stable term IDs and the NDJSON protocol, without parsing printed strings. That is architectural bet #6 and the `external_consumer.rs` loop, and no incumbent offers it (SymPy returns strings and Python objects; SymEngine returns speed). What has to become true first: a `validated` Jacobian claim, a green CI, and a Python shell whose `.so` is provably bound to its Rust source. [Inference, Medium]

**8. The kill test.** Re-admit the 230-fixture corpus under the exact-surface comparator now that the F1 wrapper fails closed: if admission collapses (the Sep-8 diagnostic suggests 229/230 differ on MRO/pickle), the compatibility program's headline number dies and the project must either narrow its claimed profile or admit the dual-lane shell needs fundamental work. A cheaper kill test: run `cargo fmt` and watch whether G2's 1,127 tests actually pass — if a meaningful fraction fail, the "green workspace tests" era was a local artifact and the implementation is less complete than the test count suggests. Either event falsifies the "substantial tested core" thesis the packet's Explore ring rests on. [Inference, High]