list_units

Static Big-O estimate from code structure, parsed with tree-sitter (every supported language). Reports analysis: tree-sitter\

Programmer-mode integer facts and operations, selected by mode: analysis (was bitanalysis), op (was bitop), widths (was intwidths), repr (was baserepr) — those four former standalone tools were retired in 0.12.0 (CHANGELOG.md)

python3 only. Decides, with z3, which if/elif/else arms and while/for(range, static bounds) loops in ONE function can ever be taken for ANY input — reachable/dead/unknown per branch, a witness when reachable, and boundaryinputs (min/max/equality-edge, via z3 Optimize) shaped for compareedgecases's t

EXACT arithmetic: 0.1+0.2 == 0.3 is True; arbitrary-precision ints, bitwise ops inline, whitelisted math funcs, pi/e/tau

mean, median, sample stdev, CV (CV > 0.2 = noise swamps the effect)

Birthday-bound hash collision: 1e5 items/32 bits ≈ 0.69, 1e6/64 ≈ 2.7e-8

Run the same logic in N languages on edge-case inputs (empty, zero, negative, float precision) and flag behavioral divergence

Exact threshold verdict with shortfall: ('1/25', '>', '0.05') → False, shortfall 1/100

Dimensional unit conversion via sympy: length, mass, time, speed, energy, power, force, pressure, temperature (°C/°F/K), volume, area, data, frequency

Byte sizes both ways: KiB/MiB (binary) AND KB/MB (decimal)

Epoch s/ms/µs/ns → ISO 8601 UTC, implausible readings suppressed

Symbolic math: integrate(x2, x), sqrt(144) + 210

Run code in any language → stdout/stderr/exitcode/verdict (OK/TLE/MLE/OLE/RTE)/cpums/peakmemorykb; per-call limits (maxmemorymb, maxoutputkb, maxcpu), nonet, compact. With a session and no explicit maxoutputkb, oversized output spills into the session workspace (stdoutspill/stderrspill) instead of j

Provider-selected execution using the same canonical limits as executecode, with progress + partial output when the provider supports streaming

Pull a named function + its dependency closure (imports, referenced helpers) into a standalone program and run it (ast-exact for python3, best-effort elsewhere)

What binary64 actually stores: exact value, raw bits, ULP, neighbours, representable-or-not

Humanised duration + per-day/per-30d rates

Install packages (uv pip/npm/gem/go/cargo...) into a session or shared cache

Execution-provider identity, interface version, host class, and machine-readable capabilities

31 languages with extension, compile flag, runtime availability

Structured matrix ops: det/inverse/eigenvalues/transpose/rank/trace on a rows array — never a caller string through sympify, so evaluateexpression's [/] RCE screen never applies. Each entry screened individually

Exact share and percentage of PART/TOTAL (rationals accepted)

p50/p90/p95/p99 by nearest-rank AND interpolation; warns n<100

22 physical constants with values (c, h, NA, kB, G, g, me, R, ...)

Any base 2..36, fractions included, non-termination flagged (0.1 base 2)

Cancel a background run; idempotent on an already-terminal run, honest about providers that cannot cancel mid-flight

Poll a background run: status while running, the full executecode result shape once terminal

Submit code for background execution; returns a runid immediately instead of holding the call open

List files created by executed code (results, images, CSVs)

Multi-file programs: execute an entry file that imports other session files (helper.py, data/...) in the workspace

Archive a session's workspace to a snapshot stored OUTSIDE the jailed workspace (action="save"), or restore one into a new session or, with replace=True, back into the same session (action="restore"); action="list"/"delete" manage them. Files only — never a stateful session's REPL variables. Snapsho

Persistent session; python3/node get a stateful REPL worker (variables/imports persist across calls), other languages a workspace dir

Symbolic algebra, selected by op: solve (was solveexpression), solvelinear (was solvelinear, name unchanged), simplify (was simplifyexpression), limit (was limitexpression) — those four former standalone tools were retired in 0.12.0 (CHANGELOG.md)

python3 only. Runs the same sandboxed executor executecode uses, plus a per-line event trace (events: line/call/return/exception, changed locals per step) and a static branch/line-coverage report (branches, linesexecuted, linesneverexecuted) from an AST parse — answers "which lines ran, in what orde

Boolean algebra: a and b or not c, p xor q, a implies b

Prove an optimisation: you write the candidate, the executor confirms it still agrees with the original AND times both — accepted only if equivalent and measurably faster. Accepted is graded crosschecked

Prove a port is equivalent: you write the translation, the executor runs both versions on the same inputs and reports match / diverged / inconclusive per input. A pass is graded crosschecked (see Grade vocabulary)

SMT-LIB2 satisfiability + model. An unsat verdict is graded solverproven; sat is graded ungraded (decided, but not proof-shaped — see Grade vocabulary)