Occam

Use this when you need a capability that Occam doesn't currently
offer. Requests are logged and used to prioritize development.

Rate limit: 5 requests/hour per IP, 50/hour global — stricter than
the compute tools' 10/hour to prevent log flooding. Descriptions
longer than 500 characters are truncated.

Discovers algebraic equations y = f(x1, x2, ...) from feature/target
data. Returns a Pareto front ranked by the complexity/accuracy
tradeoff. Slower than SINDy (10-60s); searches often terminate early
on convergence. For differential equations from time series, use
sindy_run instead.

Pricing: free tier up to 100 rows × 8 features, 60s timeout. Beyond
that, $0.25 + $0.03 per 100 extra rows + $0.01 per extra feature
squared, timeout up to 300s (5 min), via x402 (USDC on Base) or
MPP/Stripe. MPP/Stripe adds a flat $0.35 per-transaction fee (Stripe
processing), so the MPP challenge amount in a `payment_required`
response is $0.35 higher than the x402 amount for the same base
price; x402 gets the lower rate. Omit `payment` for free-tier
requests; paid requests without a valid credential receive a
`payment_required` result with pricing and accepted schemes. Full
pricing: occam://pricing

Advisory limits: jobs over 50,000 rows or 20 features are accepted
but may not converge; response carries a top-level `warning`.

Operators: fixed supported set only — custom operators (e.g.
'inv(x) = 1/x') are rejected. Unary: sin, cos, tan, exp, log, log2,
log10, sqrt, abs, sinh, cosh, tanh. Binary: +, -, *, /, ^.
See also prompt `supported_operators`.

Loss metric: `loss` (in `pareto_front[].loss` and `best_loss`) is
mean squared error between model prediction and `y` on the full
training set — not RMSE, and not normalized by Var(y). A threshold
appropriate for one dataset scales with y's magnitude, so set
`loss_threshold` with that in mind (e.g. for y values near 1.0,
1e-6 is a tight fit; for y near 1000, the equivalent is 1.0).

Early termination: set `loss_threshold` to stop at your noise floor.
The server also stops when the search stalls (<1% improvement in the
last third of the budget); disable with `stall_detection=false`.
Response `stop_reason` is one of: loss_threshold, stall, timeout,
natural.

If `feature_names` is supplied, its length must equal the number of
columns in `X`; a mismatch is rejected with a validation error.

Follow-up: call `pysr_uncertainty` with a chosen expression and the
same dataset for bootstrap confidence intervals on its fit constants
and optional prediction bands.

Rate limit: 10 requests/hour per IP, 200/hour global, max queue
depth 20 (shared with sindy_run and pysr_uncertainty).

Response (success) includes `pareto_front[]` (each with `complexity`,
`loss`, `expression`, `expression_latex`), `best_expression`,
`best_expression_latex`, `best_loss`, `best_complexity`, `stop_reason`,
`elapsed_seconds`, `queue_seconds` (>0 = server saturated; use as
backoff signal), optional `warning`, optional `_meta` (MPP receipt).
Full response and payment-required schemas: occam://tool-schemas

Example request:
  X=[[0.0], [1.0], [2.0], [3.0], [4.0]], y=[1.0, 3.0, 5.0, 7.0, 9.0],
  feature_names=["x"], max_complexity=10, timeout_seconds=15

Policy: occam://privacy-policy — Citation: occam://citation-info

Typical flow: call pysr_run, pick an expression from the response
(best_expression or a pareto_front entry), pass it back here with
the same dataset to get CIs on its fit constants.

Returns frequentist bootstrap confidence intervals, not Bayesian
credible intervals — posterior inference over expression structures
is an open research problem. This tool freezes the expression
chosen by the caller and bootstraps only its numeric constants;
uncertainty about *which* expression is correct is not quantified.

Bootstrap semantics:
  - If y_sigma is supplied, uses parametric bootstrap
    (y_b = y + Normal(0, y_sigma)). CI reflects user-stated
    measurement noise.
  - Otherwise uses residual bootstrap: fit once, resample residuals.
    CI reflects estimated-from-residuals noise.

Only Float constants in the expression become free parameters.
Integers stay structural (the 2 in x**2 is a function-class choice,
not a fit constant). Expressions with no Float constants
(e.g. "x + y") will be rejected with a validation error.

Expression grammar: the `expression` string is parsed by sympy.
Accepted operators are the same set pysr_run emits: unary `sin`,
`cos`, `tan`, `exp`, `log`, `log2`, `log10`, `sqrt`, `abs`, `sinh`,
`cosh`, `tanh`; binary `+`, `-`, `*`, `/`, `^` (or `**`). Whitespace
and parenthesization are free. Every free symbol in the expression
must correspond to an entry in `feature_names` — an unrecognised
symbol is silently treated as a fresh sympy Symbol and the fit will
fail downstream rather than reject early. Parse failures (syntax
errors, malformed operators) surface as tool errors.

If `feature_names` is supplied, its length must equal the number of
columns in `X`; a mismatch is rejected with a validation error.

Pricing: always free, regardless of dataset size. This tool has no
`payment` parameter and is never subject to the x402/Stripe gate.
Large bootstrap jobs still count against the shared rate limit
below, so budget `n_resamples` accordingly.

Rate limit: 10 requests/hour per IP, 200/hour global, max queue
depth 20 (shared with sindy_run and pysr_run).

Recovers governing differential equations (dx/dt = f(x)) from time
series data. Returns human-readable sparse expressions. Fast (seconds).
For algebraic y = f(x) relationships without time structure, use
pysr_run instead.

Pricing: free tier up to 100 rows and 8 variables. Beyond that,
$0.05 + $0.01 per 100 extra rows + $0.01 per extra variable squared,
via x402 (USDC on Base) or MPP/Stripe. MPP/Stripe adds a flat $0.35
per-transaction fee (Stripe processing), so the MPP challenge amount
in a `payment_required` response is $0.35 higher than the x402 amount
for the same base price; x402 gets the lower rate. Omit `payment`
for free-tier requests; paid requests without a valid credential
receive a `payment_required` result with pricing and accepted schemes.
Full pricing table as structured JSON: occam://pricing

Advisory limits: jobs over 500,000 rows or 50 variables are accepted
but may not converge within the time budget; the response carries a
top-level `warning` the agent should surface and treat as tentative.

If `feature_names` is supplied, its length must equal the number of
data columns; a mismatch is rejected with a validation error.

Rate limit: 10 requests/hour per IP, 200/hour global, max queue
depth 20 (shared with pysr_run and pysr_uncertainty).

Response (success) includes `equations[]` (each with `variable`,
`equation`, `expression`, `expression_latex`, `r2`), `library_terms`,
`nonzero_terms`, `elapsed_seconds`, `canonical_match` (dict with
`system`, `form`, `variable_map`, `parameter_map`, `confidence` if
the discovered system matches one of Lorenz / Lotka-Volterra /
Van der Pol / Duffing; `null` otherwise), optional `warning`,
optional `_meta` (MPP receipt on paid calls). Full response and
payment-required schemas: occam://tool-schemas

Example request:
  data=[[1.0, 0.0], [0.95, -0.31], [0.81, -0.59]], t=[0.0, 0.1, 0.2],
  feature_names=["x", "y"], poly_degree=2, threshold=0.1

Policy: occam://privacy-policy — Citation: occam://citation-info