Trajectories that respect your bounds, with audit evidence attached.
Industrial and clinical trajectories have physical limits: pressures that can't spike, tank levels that can't cross a valve limit, heart rates that can't step-change by twenty beats in a tick. A generator that ignores those limits ships data nobody can trust downstream.
Physics Model is the contract-driven post-processor that enforces per-signal envelopes, step-over-step rate limits and bound-release smoothing on every trajectory. It reads the guardrails from the same sealed contract the generator used, projects the trajectory onto the feasible region, and ships a per-step correction ledger plus a determinism hash inside the evidence bundle — so your auditor sees exactly when and where the projector acted.
- Per-signal envelopes & rate caps
- Bound-recovery smoothing (no flat-line artifacts)
- Per-step correction ledger
- Deterministic under seed + contract
$ rady physics run \
--contract ./contract.json \
--trajectory ./upstream.ndjson \
--output ./corrected.ndjson
reading guardrails ......... box bounds · rate limits · recoveries
projecting trajectory ...... onto the feasible region, per step
writing correction ledger .. original -> corrected, per touch
✓ Envelopes enforced on every step
✓ Per-step correction ledger sealed in the evidence bundle
✓ Determinism hash written — re-runnable under the same seed
final violations: 0
-> evidence bundle: rady evidence get <job_id>Three buyers, one problem.
A generator that produces physically-impossible data is worse than no generator at all — the downstream model learns the impossible as normal, and the first time a regulator or plant engineer looks at the dataset they catch it in seconds. Physics Model is the guardrail that keeps generated data inside the limits your real process actually has.
Plant operators and OT integrators
A pump pressure cannot spike to 500 PSI in one scan cycle. A tank level cannot go negative. A valve cannot jump from 10% to 90% without a command. Physics Model enforces those guardrails on every generated trajectory, so the dataset you hand to your SOC or IDS vendor looks exactly the way real plant telemetry looks — no impossible transitions, no envelope violations.
Technical · Per-signal box bounds, step-over-step rate limits, recovery smoothing. Every correction recorded in the evidence bundle with timestamp and magnitude. Deterministic under a sealed seed.
Biostatisticians and clinical-data teams
Heart rate does not step-change by twenty beats in one tick. Serum glucose does not oscillate on a minute scale. Oxygen saturation does not cross 120%. Physics Model keeps generated clinical time series inside the physiological envelopes your protocol declares, so a synthetic cohort passes a biostatistician's sniff test on first read.
Technical · Declarative envelope contracts per signal, recovery handling for transient excursions, a full per-step correction ledger for auditability — shipped with the trajectory so a regulator can see exactly where the projector acted.
Risk, fraud, and market-data teams
Portfolio balances do not go negative. Transaction timestamps do not move backwards. A cumulative column does not decrease. Physics Model enforces the monotonicity and sign constraints downstream risk models implicitly assume, so a synthetic training set behaves the way real books and tapes behave.
Technical · Monotonicity constraints, non-negativity, sum-conservation, and per-column rate caps. Every violation counted, every correction recorded, every run re-runnable byte-for-byte a year from now.
The duct-tape scripts your team maintains today.
Most teams we talk to are already doing this job — badly — with a rotating stack of Python scripts, pandas clamp statements, ad-hoc rolling means, and “if value > threshold, replace with threshold” fixups. Those scripts work on Monday. They don't work on Thursday when a new operator forgets to run them. They produce no audit trail, don't tell you which rows were corrected, how much, or why — and when a regulator asks how the data was conditioned, the answer is an email thread and a half-remembered ticket.
Physics Model replaces that entire workflow with one declarative envelope contract that travels with the job, one deterministic projector, one auditable correction ledger, and one sealed evidence record per run. The team stops maintaining 600 lines of fragile post-processing and starts shipping data with a guarantee attached.
For the buyer evaluating us: the time-to-value argument isn't model sophistication. It's that the people doing this by hand today get back their week, and the data downstream stops being the weakest link in every conversation with your compliance officer.
Every correction, timestamped. Every run, deterministic.
The Physics Model ledger pairs every correction the projector made with the original value, the corrected value, the contract rule that fired (box bound, rate limit, or recovery smoother), and the exact step it was applied at. The violation counts land in the same sealed evidence bundle every engine produces — shown here as the Evidence Summary's constraint checks on a real run.
- A spike that decays to zero reads as the projector working correctly; a flat line of violations reads as a contract that needs widening or a generator that needs retraining.
- Each run carries a determinism hash sealed into the evidence bundle, so the exact correction series is reproducible on any machine under the same seed and contract — forever.
- Before Physics Model, a “clean” trajectory was an opinion held by whoever wrote the last clamp script. After, it's a verifiable artefact attached to every dataset.
Bounds, rates, recoveries — in your contract.
You declare the guardrails your trajectories must respect — per-signal physical envelopes, step-over-step change limits, recovery handling for bound releases — inside a single contract that travels with your run. Physics Model reads that contract and enforces it. Real processes don't step discontinuously at an envelope edge; they ease back, and the projector handles that smoothly rather than leaving an unrealistic flat line. Tuning knobs are private to the engine; your contract keeps the envelope declarations only.
# Contract guardrail block (shape only)
{
"constraints": {
"box_bounds": [ /* per-signal envelopes */ ],
"rate_limits": [ /* step-over-step caps */ ],
"recoveries": [ /* bound-release easing */ ]
}
}{
"engine": "physics",
"steps_taken": ...,
"final_violations": 0,
"constraint_violations_per_step": "/* per-step series */",
"determinism_hash": "/* sealed in evidence */",
"seed": "/* your seed */"
}Violations counted. Corrections recorded.
Every Physics Model run ships a per-step violation count, a total final-violation count, a step count, and a determinism hash inside the sealed evidence bundle. A separate correction ledger captures when, where, and by how much each value was adjusted, so a downstream analyst can reconstruct exactly where the projector acted — no silent smoothing, every touch accounted for.
A post-processor you can trust.
Physics Model runs after another engine produces trajectories and before the evidence bundle is sealed. The contract declares the envelopes; Physics Model enforces them and records every correction.
Industrial SCADA
Physical envelopes for process tags, plus step-over-step ceilings for actuated variables.
Healthcare time series
Vital-sign physiological ranges and between-measurement change limits.
Financial
Non-negative balances, daily-change ceilings, circuit-breaker rules expressed as rate limits.
Energy grid
Substation voltage / frequency bands plus ramp-rate ceilings.
Bounded trajectories, audit-ready.
Physics Model ships alongside our synthesis engines under one sealed contract. Access is enterprise-contracted.