A physics verifier for Super Intelligence. Every answer comes with a cryptographic proof.
Maintain this server? Claim it
Call this server's tools from your browser. Nothing to install.
Requests go through mcptry because browsers can't call most MCP servers directly. Header values are sent to the server for that request only and are never stored or logged.
Tool list from our last check. Connect live to refresh it.
Gives how to cite a card or a solver: the service itself first (Zero-Trust Physics, its maker and its address) and the paper (https://doi.org/10.5281/zenodo.23517223), then the people whose measurements the model stands on (authors, title, year, address, and what each asks of those who use its data), each as text and BibTeX. With domain and card, or solver, the answer is for that model; with neither, it is how to cite the service itself: its name, who made it, its address and the paper.
With card: a card, by the name find_model or list_cards gives; the two give the same names.
In place of domain and card: a solver, by the name find_model or list_solvers gives.
Gives how to cite a card or a solver: the service itself first (Zero-Trust Physics, its maker and its address) and the paper (https://doi.org/10.5281/zenodo.23517223), then the people whose measurements the model stands on (authors, title, year, address, and what each asks of those who use its data), each as text and BibTeX. With domain and card, or solver, the answer is for that model; with neither, it is how to cite the service itself: its name, who made it, its address and the paper.
| Argument | Type | Description |
|---|---|---|
| card | string | |
| domain | string | With card: a card, by the name find_model or list_cards gives; the two give the same names. |
| solver | string | In place of domain and card: a solver, by the name find_model or list_solvers gives. |
{
"type": "object",
"properties": {
"card": {
"type": "string"
},
"domain": {
"type": "string",
"description": "With card: a card, by the name find_model or list_cards gives; the two give the same names."
},
"solver": {
"type": "string",
"description": "In place of domain and card: a solver, by the name find_model or list_solvers gives."
}
},
"additionalProperties": false
}Computes one anchored step of one card and returns the state it lands on, in decimals and exact hex, with its cryptographic proof (sha384_seal) and a receipt. parameters holds the card's phase fields, its load fields and dt_s, as describe_card gives them. A step whose request or whose landing state is outside the card is refused in one sentence, with the refusal's name in round brackets when it has one, and no proof is issued for that state. With from, the step starts from a sealed run, which is computed again first. On this open connection one address holds at most 1 physics permit at a time, and long work (a solve, a plan of runs or of solves, a run of more than 10000 steps, or a verification that computes one again) runs 1 at a time. A call that finds no permit or no place is answered "Too many concurrent physics tasks." and nothing waits: the same call sent later is answered once one is free. An answer is waited for 60 seconds, and long work is stopped there.
| Argument | Type | Description |
|---|---|---|
| card* | string | The card of the pair, as list_cards names it. |
| from | object | Optional: a sealed run to start from, as run_trajectory takes it. |
| domain* | string | The domain of the pair, as list_cards names it. |
| parameters* | object | The step's inputs: the card's phase fields, its load fields and dt_s, each a number (a vector field is an array of three numbers), and no other key. describe_card gives the fields of the pair, with each unit and bound. A required field left out is refused as InputMissing, in a sentence that names the field, and a card the engine does not serve as UnknownCard; nothing is filled in. |
Describes one domain and card pair: inputs, units, bounds, step limits, reject names and meanings, advisory flags, frame slots, and worked examples. With form "short" the answer is a page, enough to write a first request: what the model is of, the evidence behind it in numbers, each input with its unit and range, the names of its stops, and a worked request. The full form, the answer when form is left out, adds each bound's reason, the validation record and each stop's meaning.
| Argument | Type | Description |
|---|---|---|
| card* | string | The card of the pair, as list_cards names it. |
| form | string | Leave this key out, or "full", for the whole description; "short" for a page that is enough to write a first request. |
| domain* | string | The domain of the pair, as list_cards names it. |
{
"type": "object",
"required": [
"domain",
"card"
],
"properties": {
"card": {
"type": "string",
"description": "The card of the pair, as list_cards names it."
},
"form": {
"enum": [
"short",
"full"
],
"type": "string",
"description": "Leave this key out, or \"full\", for the whole description; \"short\" for a page that is enough to write a first request."
},
"domain": {
"type": "string",
"description": "The domain of the pair, as list_cards names it."
}
},
"description": "Full limits, fields, reject names and meanings, advisory flags, frame slots, and worked examples for one pair.",
"additionalProperties": false
}Describes one solver: inputs and bounds, outputs, invariants and tolerances, refusal names and meanings, the published reference, and a worked example. With form "short" the answer is a page, enough to write a first request: what the model is of, the evidence behind it in numbers, each input with its unit and range, the names of its stops, and a worked request. The full form, the answer when form is left out, adds each bound's reason, the validation record and each stop's meaning.
| Argument | Type | Description |
|---|---|---|
| form | string | Leave this key out, or "full", for the whole description; "short" for a page that is enough to write a first request. |
| part | string | Leave this key out to get the solver's whole description. Some long descriptions name, under 'more', parts kept back for asking: set part to one of the names listed there for that part alone. Only a name listed under 'more' is a part. |
| solver* | string | The solver, as list_solvers names it. |
{
"type": "object",
"required": [
"solver"
],
"properties": {
"form": {
"enum": [
"short",
"full"
],
"type": "string",
"description": "Leave this key out, or \"full\", for the whole description; \"short\" for a page that is enough to write a first request."
},
"part": {
"type": "string",
"description": "Leave this key out to get the solver's whole description. Some long descriptions name, under 'more', parts kept back for asking: set part to one of the names listed there for that part alone. Only a name listed under 'more' is a part."
},
"solver": {
"type": "string",
"description": "The solver, as list_solvers names it."
}
},
"description": "Inputs and bounds, outputs, invariants and tolerances, refusals and meanings, the published reference, and a worked example for one solver.",
"additionalProperties": false
}Designs a run: from a target end state to the loads of each segment that reach it, computed by the engine with no randomness, so the same request gives the same bits. request is a run_trajectory request; its numbers at the places vary names are the start, and vary gives each load's span inside the card's bounds. target is a number of the final state, a value and a tolerance. Every candidate is an ordinary run with its run_seal; one that crosses a limit is recorded refused by its name, and no value is moved back. The answer gives the timeline, its run_trajectory request and run_seal, the value reached and the miss, every candidate in order as a run_dataset plan with its dataset_seal, and a design_seal. Outcome reached; not_reached, meaning this search found none inside its caps, which is not a limit of the physics; or refused: TargetOutsideCard for a target outside the card's range, TargetBeyondReach where the card's map is monotone and a corner of the loads allowed falls short. The search is coordinate bisection, capped at 64 candidates (DESIGN_MAX_CANDIDATES), 1000000 steps (DESIGN_MAX_STEPS) and 10000 recorded frames (DESIGN_MAX_FRAMES) in all, and 4 sweeps (DESIGN_MAX_SWEEPS). verify_tape, given this whole answer as it came, designs it again and compares the two, byte for byte (the long form). On this open connection a design is long work whenever its candidates may take more than 10000 steps together. One address holds at most 1 physics permit at a time, and long work (a solve, a plan of runs or of solves, a run of more than 10000 steps, or a verification that computes one again) runs 1 at a time. A call that finds no permit or no place is answered "Too many concurrent physics tasks." and nothing waits: the same call sent later is answered once one is free. An answer is waited for 60 seconds, and long work is stopped there.
| Argument | Type | Description |
|---|---|---|
| vary* | array | From 1 to 8 loads the search sets, in the order a sweep takes them. The search sets loads only, never a start value, the step or the steps, and each load is held constant through its segment. low and high are the span the actuator allows; each lies at or inside the card's declared bound of the load, and a load the card bounds by nothing of its own (the cold plate's heat_power_w) is bounded by this span alone. |
Finds where an outcome changes, and gives the run on each side. request is a run_trajectory or solve request written out, its domain and card or its solver by the name find_model or the lists give, with no from, readout or example; vary is the place of the one number to change, such as "segments[0].load.current_a", "initial.soc", "dt_s" or "parameters.load_n"; low and high are the two ends of the span, in either order: the smaller is taken as low. The span is halved to the place where the outcome or the stop name changes or, with level, where a published quantity of the final state (of a solve: of result) crosses a value or a flag turns. When both ends give the same, 7 values between them (3 for solves) are run to find a band, and the answer says so. The answer gives the run on each side as a request ready to send again, with its outcome, its stop name and sentence and the run_seal or solution_seal that request has when sent alone, the two values in decimals and exact hex, and the width between them. A side that stops before computing has no proof. The same request gives the same pair. A search is bounded, and names the bound that stops it: 64 runs (FLIP_MAX_RUNS), 1000000 steps in all (FLIP_MAX_STEPS), or 64 solves (FLIP_MAX_SOLVES), the ends included, and no new solve once those made are counted at 20 s (FLIP_MAX_SECONDS); the pair it gives, sent back as the span, narrows it further. On this open connection a search is long work whenever it varies a solve or its runs may take more than 10000 steps together. One address holds at most 1 physics permit at a time, and long work (a solve, a plan of runs or of solves, a run of more than 10000 steps, or a verification that computes one again) runs 1 at a time. A call that finds no permit or no place is answered "Too many concurrent physics tasks." and nothing waits: the same call sent later is answered once one is free. An answer is waited for 60 seconds, and long work is stopped there.
| Argument | Type | Description |
|---|---|---|
| low* | number | One end of the span. low and high may come in either order; the smaller is taken as low. |
Finds the served model for a real thing described in plain words, such as "a lithium cell discharging in the cold". It returns the best few cards and solvers, each with fit first (the words that matched, and model_of: the one real thing it is a model of, and its range) and then accuracy: against_measurement, the evidence behind it in one of three words, as list_cards and list_solvers give it ("compared with measurement", "held to a reference calculation" or "company specimen"); compared_with, what it was fitted on; and accuracy_against_measurement, what it was compared with outside the fit, within what, and the gap, in numbers. Fit and accuracy are separate: a model with a gap is still the served model of its thing. The names it gives (domain and card, or solver) are the names list_cards and list_solvers give and the names describe_card, describe_solver, cite and every other tool take; describe_card or describe_solver gives the range and every refusal. When nothing served fits it says so, having compared every card and solver, names the nearest by words and why they are not it, or says that there is no near one, and says where requests for a model go. A model is set aside when the description names another thing of its kind (another gas, another maker's cell, another planet's probe). It is matched against a fixed list of terms with no model call: the same words give the same answer.
| Argument | Type | Description |
|---|---|---|
| limit | integer | How many models to return; 3 when left out. |
| description* | string | The real thing, in plain words. |
{
"type": "object",
"required": [
"description"
],
"properties": {
"limit": {
"type": "integer",
"maximum": 5,
"minimum": 1,
"description": "How many models to return; 3 when left out."
},
"description": {
"type": "string",
"description": "The real thing, in plain words."
}
},
"additionalProperties": false
}Lists every domain and card this connection serves, each with one sentence, and count, how many there are. against_measurement names the evidence behind the model, in one of three words: "compared with measurement" (a real object; its description says what it was fitted on, what it was compared with outside the fit and within what, the gap, and where it refuses), "held to a reference calculation" (compared with a published calculation), or "company specimen" (an object the company specified, every constant stated). The numbers say how good it is.
No arguments.
{
"type": "object",
"properties": {},
"description": "No arguments. Returns every domain/card pair.",
"additionalProperties": false
}Lists every field solver this connection serves, each with one sentence, and count, how many there are. against_measurement names the evidence behind the model, in one of three words: "compared with measurement" (a real object; its description says what it was fitted on, what it was compared with outside the fit and within what, the gap, and where it refuses), "held to a reference calculation" (compared with a published calculation), or "company specimen" (an object the company specified, every constant stated). The numbers say how good it is.
No arguments.
{
"type": "object",
"properties": {},
"description": "No arguments. Returns every solver.",
"additionalProperties": false
}Runs a declared plan of runs on one card, or of solves of one solver, and seals the rows under one root. A plan is a list of runs, a grid over a base run, or a seeded sample over a base run; a run is a run_trajectory request without domain and card. A plan of solves names solver in place of domain and card and is a list or a grid of solve requests. The answer is small by default: the head, which holds the request, the counts and the dataset_seal, and one summary row per run; answer "states" adds each final state in decimals and "full" gives every row whole, under the same dataset_seal. A row is completed, ended, refused or unadmitted: an ended or a refused row is a run sealed up to its last landed step, and an unadmitted row is a request turned away before computing, with no seal. The seal shows the dataset was not altered after it was sealed. It does not show the engine made it: a row's request sent to run_trajectory gives the run seal to compare. The input schema says how each input is written, with a worked plan of each kind. On this open connection a dataset is returned inline and holds at most 300 runs (OPEN_MAX_DATASET_ROWS), 1000000 steps in all (OPEN_MAX_DATASET_STEPS), 10000 frames and an answer counted from the plan at 4194304 bytes (OPEN_MAX_DATASET_ANSWER_BYTES) and 42500 characters, up to about 150 summary rows; a plan of solves holds the engine's own 64 and at most 15 s of them, or one, at each solver's measured time, which describe_solver states with the count (OPEN_PLAN_SECONDS). One address holds at most 1 physics permit at a time, and long work (a solve, a plan of runs or of solves, a run of more than 10000 steps, or a verification that computes one again) runs 1 at a time. A call that finds no permit or no place is answered "Too many concurrent physics tasks." and nothing waits: the same call sent later is answered once one is free. An answer is waited for 60 seconds, and long work is stopped there.
| Argument | Type | Description |
|---|---|---|
| card | string | |
| plan |
Runs one card from a start state through segments of steps, each under its own load, and seals the run. The answer holds the outcome, the final state in decimals and exact hex, a frame for each recorded step, the run_seal and a receipt. record_every sets which steps are recorded, about 262 characters each; the final state comes back in full whatever is recorded. readout gives named quantities in decimals without the frames, with each one's minimum and maximum over every landed step and the first step past a level; it is not part of the sealed request. from starts the run from a sealed run, which is computed again first. A run comes back in one of four ways. outcome "completed": every step landed. outcome "ended": the run reached an end its card declares, which describe_card lists under declared_ends; reject holds the end's name. outcome "refused": a step part way was refused; reject holds the name (null when the cause has none) and reject_detail the sentence. An ended or a refused run is sealed up to its last landed step, steps_landed. An error, not a result: the request was turned away before computing, in one sentence with the refusal's name in round brackets when it has one, and nothing is sealed. A sentence that begins "Physical Failure" says the state asked for or reached is outside the card; one that begins "Physical Violation" says the request, or a number in it or computed from it, is not one the engine takes. A load may be signed; load_source says by whom. The input schema says each of these in full. On this open connection one address holds at most 1 physics permit at a time, and long work (a solve, a plan of runs or of solves, a run of more than 10000 steps, or a verification that computes one again) runs 1 at a time. A call that finds no permit or no place is answered "Too many concurrent physics tasks." and nothing waits: the same call sent later is answered once one is free. An answer is waited for 60 seconds, and long work is stopped there.
| Argument | Type | Description |
|---|---|---|
| card* | string | The card of the pair, as list_cards names it. |
Solves one field problem with one solver and seals the solution: the outcome, the result in decimals and exact hex, its invariants, the solution_seal and a receipt. parameters holds the solver's inputs as describe_solver gives them. example, in their place, is the name of a worked example describe_solver lists (example_solve, or a key beginning example_solve_), so a long worked input need not be typed again; the request is filled with that example's parameters, and the filled request is the one solved, sealed and returned as inputs. The receipt covers the request as it was written, number spellings included, while a seal covers its values: a request sent with 310 and the same request sent with 310.0 give different receipts and the same seal, so a receipt that differs between two such answers is not a sign of tampering. A chained solve, from a sealed card run through a coupling (from), takes each handed value in parameters bit for bit: decode it from the run's frame_hex or a _hex value, not a decimal readout, or it is refused as CouplingLedgerBreach. verify_solution verifies a solution later from this request, or its inputs, and its solution_seal. On this open connection one address holds at most 1 physics permit at a time, and long work (a solve, a plan of runs or of solves, a run of more than 10000 steps, or a verification that computes one again) runs 1 at a time. A call that finds no permit or no place is answered "Too many concurrent physics tasks." and nothing waits: the same call sent later is answered once one is free. An answer is waited for 60 seconds, and long work is stopped there.
| Argument | Type | Description |
|---|---|---|
| from | object | Optional: a sealed card run handed in through a coupling, as run_trajectory takes it. Each handed value goes into parameters bit for bit, read from the run's frame_hex or a _hex value, not a decimal (CouplingLedgerBreach). |
| solver* | string | The solver, as list_solvers names it. |
Runs a run_trajectory request (without a readout) and compares one published quantity with the agent's measurements, each at a landed step. The answer is the error in numbers (rms, mean signed, greatest absolute, model minus measurement, each with its exact hex), the model value at every compared step in decimals (model_values) and exact (model_values_hex), and a hash of the measurements, under one seal. It sets no threshold: the numbers are the answer. The seal has no key, so it does not show who measured or who computed. commitment, optional, opens a salted SHA-384 the measurements were locked with before the comparison: data that are not the committed ones are refused before computing (CommitmentDoesNotMatch), and the seal covers it. genesis_seal verify-validation rebuilds the seal, the statistics and the commitment from the answer alone. In place of run, solves takes a plan of solves as run_dataset takes it (solver and plan, at most 64 solves), each measurement at a row of the plan: the solves are sealed under one dataset_seal, and the comparison by the same rules with the dataset_seal in the place of the run seal and the row in the place of the step; a measured row whose solve did not converge is counted in not_reached. The same request sent again gives the same seal. On this open connection a plan of solves holds the engine's own 64 and at most 15 s of them, or one, at each solver's measured time, which describe_solver states with the count (OPEN_PLAN_SECONDS). One address holds at most 1 physics permit at a time, and long work (a solve, a plan of runs or of solves, a run of more than 10000 steps, or a verification that computes one again) runs 1 at a time. A call that finds no permit or no place is answered "Too many concurrent physics tasks." and nothing waits: the same call sent later is answered once one is free. An answer is waited for 60 seconds, and long work is stopped there.
| Argument | Type | Description |
|---|---|---|
| run | object | One anchored run. Total steps must be <= 1000000. Recorded frames must be <= 10000. The shape of initial and of each segment's load depends on the pair: describe_card gives it. |
Verifies the seal of a dataset. Short form: request is the run_dataset request as it was sent, and dataset_seal is the seal its answer gave. The plan is run again under run_dataset's permits and limits; the answer is holds, cause ("dataset_seal" when the seal given is not the seal the plan runs to), recomputed_dataset_seal when it holds (else no seal: run_dataset gives the true one), compared, and text_not_compared: no rows the agent holds are compared. A plan of solves is verified by this short form only. Long form: head, rows and frames_hex, the three parts a full answer carries (answer "full"), together, as they came. The rows, the root and the seal are recomputed, and row and fault name the first row changed, swapped, dropped or repeated; then the plan is run again under run_dataset's permits and limits and the engine's answer compared with it, value by value and byte for byte (cause answer_text, with differs_at and row): holds is true only when every byte is the engine's, values_hold when every value is. On this open connection a dataset is returned inline and holds at most 300 runs (OPEN_MAX_DATASET_ROWS), 1000000 steps in all (OPEN_MAX_DATASET_STEPS), 10000 frames and an answer counted from the plan at 4194304 bytes (OPEN_MAX_DATASET_ANSWER_BYTES) and 42500 characters, up to about 150 summary rows; a plan of solves holds the engine's own 64 and at most 15 s of them, or one, at each solver's measured time, which describe_solver states with the count (OPEN_PLAN_SECONDS). One address holds at most 1 physics permit at a time, and long work (a solve, a plan of runs or of solves, a run of more than 10000 steps, or a verification that computes one again) runs 1 at a time. A call that finds no permit or no place is answered "Too many concurrent physics tasks." and nothing waits: the same call sent later is answered once one is free. An answer is waited for 60 seconds, and long work is stopped there.
| Argument | Type | Description |
|---|---|---|
| head | object | With rows and frames_hex: the head a run_dataset answer carries. |
Verifies the receipt at the end of one response against the text before it. It takes no physics permit. The receipt covers every byte of the response before it, the decimal values included, and shows who produced the response or when in no way: it has no key. matches true proves only that those bytes are unchanged since the receipt was written; anyone can write a matching receipt for any text, so it is not a verification of the answer. A response that names an engine_version has it said beside matches, with whether it is this engine's; origin needs engine_version_is_this_engines true and a replay. match_proves says this in each answer. The receipt covers the request as it was written, number spellings included, while a seal covers its values: a request sent with 310 and the same request sent with 310.0 give different receipts and the same seal, so a receipt that differs between two such answers is not a sign of tampering. Replaying the request through run_trajectory, solve or compute_step shows the engine produced it; verify_tape, verify_solution and verify_dataset with the request and its seal do that replay and compare the seals.
| Argument | Type | Description |
|---|---|---|
| public_key | string | The base64 of the ML-DSA-87 public key (2,592 bytes) to verify the answer's signature with; without it, this engine's own. |
| seen_nonces | array | Nonces of signatures already seen: one of them again is SignatureNonceReplayed. |
| response_text* | string | The exact text of a response as it was received, ending with the receipt, and the engine's signature after it when it carries one. |
Verifies the seal of a solution. Short form, which needs only what is short: request is the solve request as it was sent (the answer's inputs), and solution_seal is the seal its answer gave. The request is solved again, under a physics permit and the limits and refusals of solve, and the answer is holds, cause ("solution_seal" when the seal given is not the seal the request solves to), recomputed_solution_seal and recomputed_receipt_sha384 when it holds (else no seal: solve gives the true one), compared, and text_not_compared: no answer text the agent holds is compared. Long form: the whole solve answer sent back as it came, without request. Its solution seal is recomputed from its exact hex values and the part that fails is named, then its request is solved again under a physics permit and the engine's answer compared with it, value by value and byte for byte, receipt included: holds is true only when every byte is the engine's, values_hold when every value is, else cause names the part, solution_seal (the request solves to another seal), answer_text (with differs_at, the first field that differs) or engine_version (an answer of another version). A chained solve: its whole answer with from beside it; the upstream run is computed again and the chain held too (cause chain), with recomputed_chain_seal. Alone it is refused (AnswerCarriesNoRequest). Nothing is stored, so each form answers the same on every connection. On this open connection one address holds at most 1 physics permit at a time, and long work (a solve, a plan of runs or of solves, a run of more than 10000 steps, or a verification that computes one again) runs 1 at a time. A call that finds no permit or no place is answered "Too many concurrent physics tasks." and nothing waits: the same call sent later is answered once one is free. An answer is waited for 60 seconds, and long work is stopped there.
| Argument | Type | Description |
|---|---|---|
| from | object | Beside the whole answer of a chained solve: the from solve took (request, run_seal, coupling). The upstream run is computed again and held to its seal, each handed value to it, and the request solved again with it; the answer alone is refused (AnswerCarriesNoRequest). |
Computes one anchored step of one card, as compute_step does: verify_step is the earlier name of compute_step, served for this one version beside it, and takes the same arguments and gives the same answer, byte for byte. The name compute_step is the one that stays. On this open connection one address holds at most 1 physics permit at a time, and long work (a solve, a plan of runs or of solves, a run of more than 10000 steps, or a verification that computes one again) runs 1 at a time. A call that finds no permit or no place is answered "Too many concurrent physics tasks." and nothing waits: the same call sent later is answered once one is free. An answer is waited for 60 seconds, and long work is stopped there.
| Argument | Type | Description |
|---|---|---|
| card* | string | The card of the pair, as list_cards names it. |
| from | object | Optional: a sealed run to start from, as run_trajectory takes it. |
| domain* | string | The domain of the pair, as list_cards names it. |
| parameters* | object | The step's inputs: the card's phase fields, its load fields and dt_s, each a number (a vector field is an array of three numbers), and no other key. describe_card gives the fields of the pair, with each unit and bound. A required field left out is refused as InputMissing, in a sentence that names the field, and a card the engine does not serve as UnknownCard; nothing is filled in. |
Verifies the seal of a run. Short form, which needs only what is short: request is the run_trajectory request as it was sent, with its readout and its from, whose request has none, when it had them (the answer's inputs holds neither), and run_seal is the seal its answer gave. The run is computed again, under a physics permit and the limits and refusals of run_trajectory, and the answer is holds (the seal given is the seal the request runs to), cause ("run_seal" when it is not), recomputed_run_seal and recomputed_receipt_sha384 when it holds (else no seal: run_trajectory gives the true one), compared, and text_not_compared: no answer text the agent holds is compared. Long form: the whole run_trajectory answer sent back as it came, without request. Its state digest and run seal are recomputed from its exact hex values, then its request is computed again under a physics permit and the engine's answer compared with it, value by value and byte for byte, receipt included: holds is true only when every byte is the engine's, values_hold when every value is, else cause names the seal, load_signature (a signed load that does not verify), answer_text (with differs_at, the first field that differs) or engine_version (an answer of another version). A chain is verified by its request with from, run_seal and chain_seal, or by links, its answers in order, each computed again from the links before it; a chained answer alone is refused (AnswerCarriesNoRequest). Nothing is stored, so each form answers the same on every connection. On this open connection one address holds at most 1 physics permit at a time, and long work (a solve, a plan of runs or of solves, a run of more than 10000 steps, or a verification that computes one again) runs 1 at a time. A call that finds no permit or no place is answered "Too many concurrent physics tasks." and nothing waits: the same call sent later is answered once one is free. An answer is waited for 60 seconds, and long work is stopped there.
| Argument | Type | Description |
|---|---|---|
| links | array | Alone: a chain's answers in order. |
{
"type": "object",
"required": [
"domain",
"card",
"parameters"
],
"properties": {
"card": {
"type": "string",
"description": "The card of the pair, as list_cards names it."
},
"from": {
"type": "object",
"required": [
"request",
"run_seal"
],
"properties": {
"request": {
"type": "object"
},
"coupling": {
"type": "string"
},
"run_seal": {
"type": "string",
"pattern": "^[0-9a-f]{96}$"
}
},
"description": "Optional: a sealed run to start from, as run_trajectory takes it.",
"additionalProperties": false
},
"domain": {
"type": "string",
"description": "The domain of the pair, as list_cards names it."
},
"parameters": {
"type": "object",
"description": "The step's inputs: the card's phase fields, its load fields and dt_s, each a number (a vector field is an array of three numbers), and no other key. describe_card gives the fields of the pair, with each unit and bound. A required field left out is refused as InputMissing, in a sentence that names the field, and a card the engine does not serve as UnknownCard; nothing is filled in."
}
},
"description": "One anchored step. The shape of parameters depends on the pair: describe_card gives it.",
"additionalProperties": false
}| target* | object | The end state to reach: the quantity of the run's final state within value plus or minus tolerance, after its last step, or, for a run that ends at an end its card declares (a reactor past its first maximum of power), where the event finished. A run refused part way gives no value. A target outside the range the card declares for that quantity is refused before any run (TargetOutsideCard). |
| request* | object | A run_trajectory request as that tool takes it, with no from or readout, and a number at every place vary names: the search's start. Nothing is filled in. |
{
"type": "object",
"required": [
"request",
"vary",
"target"
],
"properties": {
"vary": {
"type": "array",
"items": {
"type": "object",
"required": [
"place",
"low",
"high"
],
"properties": {
"low": {
"type": "number",
"description": "The low end of the span the actuator allows, at or inside the card's declared bound of the load."
},
"high": {
"type": "number",
"description": "The high end, above low."
},
"place": {
"type": "string",
"description": "segments[<i>].load.<name> for one segment's load, or segments[*].load.<name> for one value held through every segment. The load is one number of the card."
}
},
"additionalProperties": false
},
"maxItems": 8,
"minItems": 1,
"description": "From 1 to 8 loads the search sets, in the order a sweep takes them. The search sets loads only, never a start value, the step or the steps, and each load is held constant through its segment. low and high are the span the actuator allows; each lies at or inside the card's declared bound of the load, and a load the card bounds by nothing of its own (the cold plate's heat_power_w) is bounded by this span alone."
},
"target": {
"type": "object",
"required": [
"quantity",
"value",
"tolerance"
],
"properties": {
"value": {
"type": "number",
"description": "The value the run's final state is to reach."
},
"quantity": {
"type": "string",
"description": "A number the card publishes in the final state, such as temperature_k."
},
"tolerance": {
"type": "number",
"description": "How near is reached: the final value within value plus or minus tolerance. Above zero."
}
},
"description": "The end state to reach: the quantity of the run's final state within value plus or minus tolerance, after its last step, or, for a run that ends at an end its card declares (a reactor past its first maximum of power), where the event finished. A run refused part way gives no value. A target outside the range the card declares for that quantity is refused before any run (TargetOutsideCard).",
"additionalProperties": false
},
"request": {
"type": "object",
"description": "A run_trajectory request as that tool takes it, with no from or readout, and a number at every place vary names: the search's start. Nothing is filled in."
}
},
"additionalProperties": false
}| high* | number | The other end. |
| vary* | string | The place of the one number to vary: "segments[0].load.current_a", "segments[*].load.current_a" for every segment, "initial.soc", "dt_s", "segments[0].steps", "parameters.load_n". A count is varied in whole numbers. |
| level | object | Optional. {"quantity": <a published quantity>, "value": <number>}: the span is halved to where that quantity of the final state (of a solve: of result) crosses the value. {"quantity": <a flag>}: to where a true-or-false value of it turns. |
| request* | object | A run_trajectory or solve request as that tool takes it. A search of solves makes no new solve once those made are counted at 20 s (FLIP_MAX_SECONDS), each at the time describe_solver states for one solve of its solver (open_connection), and always makes at least 3, both ends and one value between them: a count, not a clock, so the same request stops at the same solve on any machine. A search of runs is held by its steps (FLIP_MAX_STEPS). |
{
"type": "object",
"required": [
"request",
"vary",
"low",
"high"
],
"properties": {
"low": {
"type": "number",
"description": "One end of the span. low and high may come in either order; the smaller is taken as low."
},
"high": {
"type": "number",
"description": "The other end."
},
"vary": {
"type": "string",
"description": "The place of the one number to vary: \"segments[0].load.current_a\", \"segments[*].load.current_a\" for every segment, \"initial.soc\", \"dt_s\", \"segments[0].steps\", \"parameters.load_n\". A count is varied in whole numbers."
},
"level": {
"type": "object",
"required": [
"quantity"
],
"properties": {
"value": {
"type": [
"number",
"boolean"
]
},
"quantity": {
"type": "string"
}
},
"description": "Optional. {\"quantity\": <a published quantity>, \"value\": <number>}: the span is halved to where that quantity of the final state (of a solve: of result) crosses the value. {\"quantity\": <a flag>}: to where a true-or-false value of it turns.",
"additionalProperties": false
},
"request": {
"type": "object",
"description": "A run_trajectory or solve request as that tool takes it. A search of solves makes no new solve once those made are counted at 20 s (FLIP_MAX_SECONDS), each at the time describe_solver states for one solve of its solver (open_connection), and always makes at least 3, both ends and one value between them: a count, not a clock, so the same request stops at the same solve on any machine. A search of runs is held by its steps (FLIP_MAX_STEPS)."
}
},
"additionalProperties": false
}| any |
| A path names one number: initial.<field>, dt_s, or segments[0].load.<field>, with the segment's number in square brackets and [0], [1] or [2] after a 3-vector field for one of its components. steps and record_every are not paths and cannot vary: every row of a grid or a sample takes them from the base run. A value an axis or a draw sets replaces the base's value of that field, and the answer's base_replaced names each field replaced; a 3-vector the base sets whole is replaced only when the paths set all three of its components. Two paths may not set one number. Each row of a grid is held to the card's bounds alone, as each run of a list is: a value outside a bound makes that row unadmitted and the other rows run. A sample's interval or choice outside a bound refuses the plan. One worked plan of each kind, each a whole request: list: {"domain":"energy","card":"thermal","plan":{"kind":"list","runs":[{"initial":{"temperature_k":293.15},"dt_s":1.0,"segments":[{"steps":60,"load":{"heat_power_w":5.0,"ambient_k":293.15}}],"record_every":60}]},"store":"none","return":"inline"} grid: {"domain":"energy","card":"thermal","plan":{"kind":"grid","base":{"initial":{},"dt_s":1.0,"segments":[{"steps":60,"load":{"ambient_k":293.15}}],"record_every":60},"axes":[{"path":"initial.temperature_k","values":[283.15,293.15]},{"path":"segments[0].load.heat_power_w","values":[0.0,5.0,10.0]}]},"store":"none","return":"inline"} sample: {"domain":"energy","card":"thermal","plan":{"kind":"sample","base":{"initial":{},"dt_s":1.0,"segments":[{"steps":60,"load":{"ambient_k":293.15}}],"record_every":60},"rows":4,"generator":"splitmix64_counter_v1","seed_hex":"0000000000000001","draws":[{"path":"initial.temperature_k","choice":[283.15,293.15]},{"path":"segments[0].load.heat_power_w","uniform":{"low":0.0,"high":10.0}}]},"store":"none","return":"inline"}. |
| store | string |
| answer | string | Leave out, or "summary", for the head and one short summary row per row: the values it sets, outcome, steps landed, refusal name and seal; "states" adds each run's final state in decimals; "full" gives every row whole. With return "file" the answer is the head and the names of the files whatever this says. Not part of the sealed request. The head and the dataset_seal are the same in all three forms. A summary row holds row, set (the values a grid's or a sample's row sets), outcome, steps_landed, reject and run_seal; the quantities of one row are read by sending its request to run_trajectory with a readout. An ended row is a run that stopped at an end its card declares: it has a run seal, the end's reject name in reject and the sentence naming the end in reject_detail. A refused row is a run the card refused part way: it has a run seal, the refusal's name in reject and its sentence in reject_detail. An unadmitted row is a request turned away before computing: it has no run seal, and its sentence, with the refusal's name in round brackets when the sentence gives one, is its reject_detail; its summary row gives that name in reject. What a sentence that begins "Physical Failure" or "Physical Violation" means is in the description of run_trajectory. An inline answer is counted from the plan before anything runs, and one above 42500 characters is refused with what to change: a summary row counts 220 characters and the values it sets; with states, each number of the final state adds its name and 28 characters (84 for a 3-vector, 9 for a flag); a whole row counts its own request and 1900 characters, and for each number twice its name and 60 characters (150 for a 3-vector, 9 for a flag); store "frames" adds 128 characters for each recorded state to a full answer; the head repeats the request. |
| domain | string |
| return | string |
| solver | string | A plan of solves: the solver, in place of domain and card. It takes no store and no return. A plan of solves is answered inline: a list, {"kind":"list","solves":[{"parameters":{...}}]}, or a grid, {"kind":"grid","base":{"parameters":{...}},"axes":[{"path":"parameters.<input>","values":[...]}]}, of at most 64 solves. Each row is a solve request, solved as solve solves it and carrying the solution_seal solve gives it; a request turned away without a seal, by the rules of a request or by the solver, is an unadmitted row. The rows are sealed under one dataset_seal by the rules of a plan of runs, with solution_seal in the leaf in the place of run_seal, and completed in the counts counts the solves that converged. A summary row has row, set, outcome, reject, solution_seal and every single number of the result in decimals; answer "full" gives every solution whole, and is refused when it comes to more than 42500 characters. verify_dataset verifies a plan of solves by its request and dataset_seal, and validate_series compares one number of its results with measurements. Worked plan of solves: {"solver":"atom_dft","plan":{"kind":"list","solves":[{"parameters":{"atomic_number":10}}]}}. |
{
"type": "object",
"required": [
"plan"
],
"properties": {
"card": {
"type": "string"
},
"plan": {
"oneOf": [
{
"type": "object",
"required": [
"kind",
"runs"
],
"properties": {
"kind": {
"const": "list"
},
"runs": {
"type": "array",
"items": {
"type": "object"
},
"minItems": 1
}
},
"description": "A list of runs. Each is a run_trajectory request without domain and card.",
"additionalProperties": false
},
{
"type": "object",
"required": [
"kind",
"solves"
],
"properties": {
"kind": {
"const": "list"
},
"solves": {
"type": "array",
"items": {
"type": "object"
},
"minItems": 1
}
},
"description": "With solver: a list of solves. Each is a solve request without solver.",
"additionalProperties": false
},
{
"type": "object",
"required": [
"kind",
"base",
"axes"
],
"properties": {
"axes": {
"type": "array",
"items": {
"type": "object",
"required": [
"path",
"values"
],
"properties": {
"path": {
"type": "string"
},
"values": {
"type": "array",
"minItems": 1
}
},
"additionalProperties": false
},
"minItems": 1
},
"base": {
"type": "object"
},
"kind": {
"const": "grid"
}
},
"description": "A base run (with solver: a base solve request without solver) and axes of explicit values. The rows are the product of the axes, the last axis varying fastest.",
"additionalProperties": false
},
{
"type": "object",
"required": [
"kind",
"base",
"rows",
"generator",
"seed_hex",
"draws"
],
"properties": {
"base": {
"type": "object"
},
"kind": {
"const": "sample"
},
"rows": {
"type": "integer",
"minimum": 1
},
"draws": {
"type": "array",
"items": {
"type": "object",
"required": [
"path"
],
"properties": {
"path": {
"type": "string"
},
"choice": {
"type": "array",
"minItems": 1
},
"uniform": {
"type": "object",
"required": [
"low",
"high"
],
"properties": {
"low": {
"type": "number"
},
"high": {
"type": "number"
}
},
"additionalProperties": false
}
},
"additionalProperties": false
},
"minItems": 1
},
"seed_hex": {
"type": "string",
"pattern": "^[0-9a-f]{16}$"
},
"generator": {
"const": "splitmix64_counter_v1"
}
},
"description": "A base run and draws from the counter sampler. Row n is worked out without the rows before it.",
"additionalProperties": false
}
],
"description": "A path names one number: initial.<field>, dt_s, or segments[0].load.<field>, with the segment's number in square brackets and [0], [1] or [2] after a 3-vector field for one of its components. steps and record_every are not paths and cannot vary: every row of a grid or a sample takes them from the base run. A value an axis or a draw sets replaces the base's value of that field, and the answer's base_replaced names each field replaced; a 3-vector the base sets whole is replaced only when the paths set all three of its components. Two paths may not set one number. Each row of a grid is held to the card's bounds alone, as each run of a list is: a value outside a bound makes that row unadmitted and the other rows run. A sample's interval or choice outside a bound refuses the plan. One worked plan of each kind, each a whole request: list: {\"domain\":\"energy\",\"card\":\"thermal\",\"plan\":{\"kind\":\"list\",\"runs\":[{\"initial\":{\"temperature_k\":293.15},\"dt_s\":1.0,\"segments\":[{\"steps\":60,\"load\":{\"heat_power_w\":5.0,\"ambient_k\":293.15}}],\"record_every\":60}]},\"store\":\"none\",\"return\":\"inline\"} grid: {\"domain\":\"energy\",\"card\":\"thermal\",\"plan\":{\"kind\":\"grid\",\"base\":{\"initial\":{},\"dt_s\":1.0,\"segments\":[{\"steps\":60,\"load\":{\"ambient_k\":293.15}}],\"record_every\":60},\"axes\":[{\"path\":\"initial.temperature_k\",\"values\":[283.15,293.15]},{\"path\":\"segments[0].load.heat_power_w\",\"values\":[0.0,5.0,10.0]}]},\"store\":\"none\",\"return\":\"inline\"} sample: {\"domain\":\"energy\",\"card\":\"thermal\",\"plan\":{\"kind\":\"sample\",\"base\":{\"initial\":{},\"dt_s\":1.0,\"segments\":[{\"steps\":60,\"load\":{\"ambient_k\":293.15}}],\"record_every\":60},\"rows\":4,\"generator\":\"splitmix64_counter_v1\",\"seed_hex\":\"0000000000000001\",\"draws\":[{\"path\":\"initial.temperature_k\",\"choice\":[283.15,293.15]},{\"path\":\"segments[0].load.heat_power_w\",\"uniform\":{\"low\":0.0,\"high\":10.0}}]},\"store\":\"none\",\"return\":\"inline\"}."
},
"store": {
"enum": [
"frames",
"none"
],
"type": "string"
},
"answer": {
"enum": [
"summary",
"states",
"full"
],
"type": "string",
"description": "Leave out, or \"summary\", for the head and one short summary row per row: the values it sets, outcome, steps landed, refusal name and seal; \"states\" adds each run's final state in decimals; \"full\" gives every row whole. With return \"file\" the answer is the head and the names of the files whatever this says. Not part of the sealed request. The head and the dataset_seal are the same in all three forms. A summary row holds row, set (the values a grid's or a sample's row sets), outcome, steps_landed, reject and run_seal; the quantities of one row are read by sending its request to run_trajectory with a readout. An ended row is a run that stopped at an end its card declares: it has a run seal, the end's reject name in reject and the sentence naming the end in reject_detail. A refused row is a run the card refused part way: it has a run seal, the refusal's name in reject and its sentence in reject_detail. An unadmitted row is a request turned away before computing: it has no run seal, and its sentence, with the refusal's name in round brackets when the sentence gives one, is its reject_detail; its summary row gives that name in reject. What a sentence that begins \"Physical Failure\" or \"Physical Violation\" means is in the description of run_trajectory. An inline answer is counted from the plan before anything runs, and one above 42500 characters is refused with what to change: a summary row counts 220 characters and the values it sets; with states, each number of the final state adds its name and 28 characters (84 for a 3-vector, 9 for a flag); a whole row counts its own request and 1900 characters, and for each number twice its name and 60 characters (150 for a 3-vector, 9 for a flag); store \"frames\" adds 128 characters for each recorded state to a full answer; the head repeats the request."
},
"domain": {
"type": "string"
},
"return": {
"enum": [
"inline",
"file"
],
"type": "string"
},
"solver": {
"type": "string",
"description": "A plan of solves: the solver, in place of domain and card. It takes no store and no return. A plan of solves is answered inline: a list, {\"kind\":\"list\",\"solves\":[{\"parameters\":{...}}]}, or a grid, {\"kind\":\"grid\",\"base\":{\"parameters\":{...}},\"axes\":[{\"path\":\"parameters.<input>\",\"values\":[...]}]}, of at most 64 solves. Each row is a solve request, solved as solve solves it and carrying the solution_seal solve gives it; a request turned away without a seal, by the rules of a request or by the solver, is an unadmitted row. The rows are sealed under one dataset_seal by the rules of a plan of runs, with solution_seal in the leaf in the place of run_seal, and completed in the counts counts the solves that converged. A summary row has row, set, outcome, reject, solution_seal and every single number of the result in decimals; answer \"full\" gives every solution whole, and is refused when it comes to more than 42500 characters. verify_dataset verifies a plan of solves by its request and dataset_seal, and validate_series compares one number of its results with measurements. Worked plan of solves: {\"solver\":\"atom_dft\",\"plan\":{\"kind\":\"list\",\"solves\":[{\"parameters\":{\"atomic_number\":10}}]}}."
}
},
"description": "A plan of runs on one card (domain, card, plan, store and return, all required) or of solves of one solver (solver and plan). Rows <= 100000, steps in total <= 100000000, stored frames <= 16777216; inline: an answer counted from the plan <= 42500 characters, which a plan reaches first, a grid on one axis at about 150 summary rows and a list sooner, its head repeating each run's request (a plan of more than 1000 rows is refused before it is counted, as too large to return inline), and frames <= 10000; solves <= 64. With return \"file\" the answer is the head and the names of the files stored, on a connection started with a directory for them.",
"additionalProperties": false
}| dt_s* | number | Step, in seconds. Held for the whole run. |
| from | object | Optional: start from a sealed run. request: that run_trajectory request as sent, less its readout if it had one: a readout is not part of a run's seal, and a request here that carries one is refused (it may hold its own from); run_seal: its seal; coupling: absent to continue the same card (describe_card says how), or a coupling's name. The upstream is computed again; each carried value must equal its sealed value bit for bit, and a request whose upstream seal or carried value does not hold is refused by name. The run_seal is that of this request without from; chain.chain_seal commits it to the upstream. |
| domain* | string | The domain of the pair, as list_cards names it. |
| initial* | object | The phase fields of the card at the start of the run, each a number (a vector field is an array of three numbers), and no other key but signed: an instrument's signature over the rest of initial, under the key "initial", by the rule of a segment's signed. describe_card gives the fields, with each unit and bound. |
| readout | object | Optional. Reads quantities without the frames: {"quantities": [names the card publishes], "first_past": {"quantity": <one of them>, "above" or "below": <level>}}. The answer then holds the named quantities in decimals at the recorded steps, each one's minimum and maximum over every landed step with its step, its time (the step times dt_s) and every other listed quantity at that step (at_minimum, at_maximum), and first_past when asked. With record_every equal to the steps, one state is recorded and the readout gives the extremes of every step. Not part of the sealed request: the run_seal is that of the same run without it, and the receipt covers it. |
| segments* | array | A segment may carry signed beside its load: an instrument's signature over the load. signed holds alg "ed25519"; key, the instrument's public key as 64 hex digits, its identity; instrument, the name it gives itself, a label of at most 200 characters; time, its clock, RFC 3339 in UTC ending in Z; seq, its reading counter, below 2^53; prev, the SHA-256 of its previous reading's signed text, or null; challenge, hex the relying party chose, or null; and sig, the signature as 128 hex digits. The instrument signs the bytes "zero-trust-physics/signed-reading/v1" and a line break, then the sealed form (the text a request's seal is taken over: keys sorted by their bytes, each number x and the 16 hex digits of its 64-bit float, no spaces) of the object of alg, key, instrument, time, seq, prev and challenge with the reading under its place's key: "load" for a segment's load, "initial", "parameters" or "measurement" for the object it sits in, without signed. Ed25519 as RFC 8032 section 5.1.7, strict: the key and R canonical points of more than small order, S below the group order, the cofactorless equation. It is verified before computing, every field required and none filled in: a signature that does not verify is refused as LoadSignatureDoesNotVerify, a field of the wrong form as LoadSignatureMalformed, an alg other than "ed25519" as LoadSignatureAlgorithmNotServed, and a plan or search that would set a signed value as SignedLoadReplaced. The seal covers the signature, since it covers the request. A signature shows that the holder of the key stated the reading; whether the key is a real instrument's is the verifier's list. Every run answer carries load_source: for a run with no signed load, the count of segments, none signed, and a sentence that each load is the number the request states; for a signed run, how many loads are signed, whether initial is, whether each key's readings form one unbroken stream (prev and seq), and for each key its fingerprint, the name it gives itself, its places, times, seq and challenges. It is outside the run seal, follows from inputs, which the seal covers, and is covered by the receipt. |
| record_every* | integer | A state is recorded at each multiple of record_every and at the last landed step. The size of the answer follows from the request: about 262 characters for each recorded state, plus the request as it was sent, plus up to 8000 characters for the final state and the seals; a flagged state adds about 400 characters for each limit it is past (exceedances). So 10,000 steps with record_every 1 answer with about 2.3 million characters, and the same steps with record_every 10000 with one recorded state. What keeps it small: a larger record_every; the final state is returned in full whatever is recorded. |
{
"type": "object",
"required": [
"domain",
"card",
"initial",
"dt_s",
"segments",
"record_every"
],
"properties": {
"card": {
"type": "string",
"description": "The card of the pair, as list_cards names it."
},
"dt_s": {
"type": "number",
"description": "Step, in seconds. Held for the whole run."
},
"from": {
"type": "object",
"required": [
"request",
"run_seal"
],
"properties": {
"request": {
"type": "object"
},
"coupling": {
"type": "string"
},
"run_seal": {
"type": "string",
"pattern": "^[0-9a-f]{96}$"
}
},
"description": "Optional: start from a sealed run. request: that run_trajectory request as sent, less its readout if it had one: a readout is not part of a run's seal, and a request here that carries one is refused (it may hold its own from); run_seal: its seal; coupling: absent to continue the same card (describe_card says how), or a coupling's name. The upstream is computed again; each carried value must equal its sealed value bit for bit, and a request whose upstream seal or carried value does not hold is refused by name. The run_seal is that of this request without from; chain.chain_seal commits it to the upstream.",
"additionalProperties": false
},
"domain": {
"type": "string",
"description": "The domain of the pair, as list_cards names it."
},
"initial": {
"type": "object",
"description": "The phase fields of the card at the start of the run, each a number (a vector field is an array of three numbers), and no other key but signed: an instrument's signature over the rest of initial, under the key \"initial\", by the rule of a segment's signed. describe_card gives the fields, with each unit and bound."
},
"readout": {
"type": "object",
"required": [
"quantities"
],
"properties": {
"first_past": {
"type": "object",
"properties": {
"above": {
"type": "number"
},
"below": {
"type": "number"
},
"quantity": {
"type": "string"
}
},
"description": "A quantity of the list and one of above or below: the first landed step at which it is strictly above (or below) that level, with its time, its value and every other listed quantity at that step (at_step); null when no landed step passes it.",
"additionalProperties": false
},
"quantities": {
"type": "array",
"items": {
"type": "string"
},
"maxItems": 8,
"minItems": 1,
"description": "Names of numbers the card publishes in its state; one component of a 3-vector is written name[0], name[1] or name[2]."
}
},
"description": "Optional. Reads quantities without the frames: {\"quantities\": [names the card publishes], \"first_past\": {\"quantity\": <one of them>, \"above\" or \"below\": <level>}}. The answer then holds the named quantities in decimals at the recorded steps, each one's minimum and maximum over every landed step with its step, its time (the step times dt_s) and every other listed quantity at that step (at_minimum, at_maximum), and first_past when asked. With record_every equal to the steps, one state is recorded and the readout gives the extremes of every step. Not part of the sealed request: the run_seal is that of the same run without it, and the receipt covers it.",
"additionalProperties": false
},
"segments": {
"type": "array",
"items": {
"type": "object",
"required": [
"steps",
"load"
],
"properties": {
"load": {
"type": "object",
"description": "The load fields of the card for this segment, and no other key. describe_card gives them, with each unit and bound."
},
"steps": {
"type": "integer",
"minimum": 1
},
"signed": {
"type": "object",
"required": [
"alg",
"key",
"instrument",
"time",
"seq",
"prev",
"challenge",
"sig"
],
"properties": {
"alg": {
"enum": [
"ed25519"
],
"type": "string"
},
"key": {
"type": "string",
"pattern": "^[0-9a-f]{64}$"
},
"seq": {
"type": "integer",
"maximum": 9007199254740991,
"minimum": 0
},
"sig": {
"type": "string",
"pattern": "^[0-9a-f]{128}$"
},
"prev": {
"type": [
"string",
"null"
]
},
"time": {
"type": "string"
},
"challenge": {
"type": [
"string",
"null"
]
},
"instrument": {
"type": "string",
"maxLength": 200,
"minLength": 1
}
},
"description": "An instrument's Ed25519 signature over this reading, by the rule run_trajectory's input schema gives at segments.",
"additionalProperties": false
}
},
"additionalProperties": false
},
"minItems": 1,
"description": "A segment may carry signed beside its load: an instrument's signature over the load. signed holds alg \"ed25519\"; key, the instrument's public key as 64 hex digits, its identity; instrument, the name it gives itself, a label of at most 200 characters; time, its clock, RFC 3339 in UTC ending in Z; seq, its reading counter, below 2^53; prev, the SHA-256 of its previous reading's signed text, or null; challenge, hex the relying party chose, or null; and sig, the signature as 128 hex digits. The instrument signs the bytes \"zero-trust-physics/signed-reading/v1\" and a line break, then the sealed form (the text a request's seal is taken over: keys sorted by their bytes, each number x and the 16 hex digits of its 64-bit float, no spaces) of the object of alg, key, instrument, time, seq, prev and challenge with the reading under its place's key: \"load\" for a segment's load, \"initial\", \"parameters\" or \"measurement\" for the object it sits in, without signed. Ed25519 as RFC 8032 section 5.1.7, strict: the key and R canonical points of more than small order, S below the group order, the cofactorless equation. It is verified before computing, every field required and none filled in: a signature that does not verify is refused as LoadSignatureDoesNotVerify, a field of the wrong form as LoadSignatureMalformed, an alg other than \"ed25519\" as LoadSignatureAlgorithmNotServed, and a plan or search that would set a signed value as SignedLoadReplaced. The seal covers the signature, since it covers the request. A signature shows that the holder of the key stated the reading; whether the key is a real instrument's is the verifier's list. Every run answer carries load_source: for a run with no signed load, the count of segments, none signed, and a sentence that each load is the number the request states; for a signed run, how many loads are signed, whether initial is, whether each key's readings form one unbroken stream (prev and seq), and for each key its fingerprint, the name it gives itself, its places, times, seq and challenges. It is outside the run seal, follows from inputs, which the seal covers, and is covered by the receipt."
},
"record_every": {
"type": "integer",
"minimum": 1,
"description": "A state is recorded at each multiple of record_every and at the last landed step. The size of the answer follows from the request: about 262 characters for each recorded state, plus the request as it was sent, plus up to 8000 characters for the final state and the seals; a flagged state adds about 400 characters for each limit it is past (exceedances). So 10,000 steps with record_every 1 answer with about 2.3 million characters, and the same steps with record_every 10000 with one recorded state. What keeps it small: a larger record_every; the final state is returned in full whatever is recorded."
}
},
"description": "One anchored run. Total steps must be <= 1000000. Recorded frames must be <= 10000. The shape of initial and of each segment's load depends on the pair: describe_card gives it. A run can be refused in two ways, and they come back differently. A request turned away before computing is an error, not a result: its text is one sentence, nothing is sealed, and when the sentence gives the card's name for the refusal the name is in round brackets. A run that starts and is refused part way is a result: outcome is \"refused\", reject holds the name (null when the cause has none), reject_detail holds the sentence, which ends \"The run is sealed to step N. The state at step N+1 was refused and is not sealed.\", and the run is sealed up to that last landed step N: steps_landed is N, the count of steps that landed, so the step that was refused is steps_landed + 1. A run that reaches an end its card declares (the first maximum of power of a reactor burst, a capsule's flown parachute deployment, a crater that stops growing, a cell's runaway once every reactant is consumed) is not refused: outcome is \"ended\", reject holds the end's name, reject_detail a sentence beginning \"Ended\" that names the end, and the run is sealed up to its last landed step; describe_card lists a card's declared ends under declared_ends. A sentence that begins \"Physical Failure\" says the state asked for or reached is outside the card: past a published bound, a limit of the specimen, or the conservation ledger. A sentence that begins \"Physical Violation\" says the request, or a number in it or computed from it, is not one the engine takes: its shape, a missing or unknown key, the number rule, the step floor or ceiling, a load rule, a size limit, or a value that is not finite. A required key left out is named InputMissing, and a card the engine does not serve UnknownCard. A sentence with no name in round brackets is of a request that is not well formed (a key unknown, a value of the wrong type, a number the number rule refuses, a count or a size past the tool's own limit) or of a value that is not finite: no model stopped, and the request is what is corrected.",
"additionalProperties": false
}| example | string | In place of parameters: the name of one of the solver's worked examples as describe_solver keys it (example_solve, or a key that begins example_solve_). The request is filled with that example's parameters, and the filled request is the one solved, sealed and returned as inputs. |
| parameters | object | The inputs of the solver named in 'solver', each a number, a whole number, a word, a flag or an array as describe_solver gives it, and no other key but signed. Every number of a solve request must be a finite, normal 64-bit number or zero, and a number written as non-zero must not read as zero. This rule is the one every card's request follows, and it stands beside each input's range and refuses some values inside it: a subnormal such as 5e-324 is refused wherever zero and larger numbers are accepted. A solution has no frame, so the card's rule that a number fit a 32-bit frame slot does not apply. A required input left out is refused as InputMissing, and an input given with a choice it does not go with as InputNotWithChoice, each in a sentence that names the input, and a solver the engine does not serve as UnknownSolver; nothing is filled in. parameters may also carry signed, an instrument's signature over the other parameters under the key "parameters", by the rule run_trajectory's input schema gives at segments; it is verified before solving, the solver takes the other parameters, and the answer then carries load_source, naming the key. A solve answer without load_source holds no signed parameter. |
{
"type": "object",
"required": [
"solver"
],
"properties": {
"from": {
"type": "object",
"required": [
"request",
"run_seal",
"coupling"
],
"properties": {
"request": {
"type": "object"
},
"coupling": {
"type": "string"
},
"run_seal": {
"type": "string",
"pattern": "^[0-9a-f]{96}$"
}
},
"description": "Optional: a sealed card run handed in through a coupling, as run_trajectory takes it. Each handed value goes into parameters bit for bit, read from the run's frame_hex or a _hex value, not a decimal (CouplingLedgerBreach).",
"additionalProperties": false
},
"solver": {
"type": "string",
"description": "The solver, as list_solvers names it."
},
"example": {
"type": "string",
"description": "In place of parameters: the name of one of the solver's worked examples as describe_solver keys it (example_solve, or a key that begins example_solve_). The request is filled with that example's parameters, and the filled request is the one solved, sealed and returned as inputs."
},
"parameters": {
"type": "object",
"description": "The inputs of the solver named in 'solver', each a number, a whole number, a word, a flag or an array as describe_solver gives it, and no other key but signed. Every number of a solve request must be a finite, normal 64-bit number or zero, and a number written as non-zero must not read as zero. This rule is the one every card's request follows, and it stands beside each input's range and refuses some values inside it: a subnormal such as 5e-324 is refused wherever zero and larger numbers are accepted. A solution has no frame, so the card's rule that a number fit a 32-bit frame slot does not apply. A required input left out is refused as InputMissing, and an input given with a choice it does not go with as InputNotWithChoice, each in a sentence that names the input, and a solver the engine does not serve as UnknownSolver; nothing is filled in. parameters may also carry signed, an instrument's signature over the other parameters under the key \"parameters\", by the rule run_trajectory's input schema gives at segments; it is verified before solving, the solver takes the other parameters, and the answer then carries load_source, naming the key. A solve answer without load_source holds no signed parameter."
}
},
"description": "One sealed solution.",
"additionalProperties": false
}| solves | object | In place of run: a plan of solves as run_dataset takes it (solver and plan, a list or a grid, at most 64 solves). quantity is then one number the solver publishes in its result, and each measurement names a row of the plan, numbered from 0, in place of a step. |
| quantity* | string | The name of one number the card publishes in its state, a plain name that has a '_hex' sibling in the state. A flag is refused. |
| component | integer | 0, 1 or 2: which of the three components of a 3-vector quantity is compared. Required when the quantity is a 3-vector, and refused when it is not. Any other value is refused. |
| commitment | object | Optional: a commitment the measurements were locked with before this comparison, opened by this request. sha384 is the SHA-384 of these bytes: the line zero-trust-physics/measurement-commitment/v2 and a line break; the sealed form (the text a request's seal is taken over: keys sorted by their bytes, each number x and the 16 hex digits of its 64-bit float, no spaces) of {"component": <this request's component, or null>, "measurements": <this request's measurements>, "quantity": <this request's quantity>}; a line break; and the salt's bytes, its hex decoded. salt is 32 to 128 lowercase hex digits, 16 to 64 bytes, kept back until the comparison so that the data are not found from the sha384 by trying values. The engine makes the digest again from the request before computing: data that do not open it (a value, a step or a row changed, moved, added or dropped, another quantity or another salt) are refused as CommitmentDoesNotMatch, a salt shorter than 16 bytes as CommitmentSaltTooShort, a field of the wrong form as CommitmentMalformed, and sha384 or salt left out as InputMissing; nothing is computed and nothing is sealed. Opened, the comparison runs as it runs without one, validation_seal takes the commitment as a sixth part, and the answer says so in commitment_opened. A commitment shows that the data were not changed after it was made; when it was made is shown by where its sha384 was published before the comparison. |
| measurements* | array | At most 10000. A measurement is compared with the state after landed step k. There is no interpolation and no time matching: a measurement is placed by its step, its time since the start divided by dt_s. |
{
"type": "object",
"required": [
"quantity",
"measurements"
],
"properties": {
"run": {
"type": "object",
"required": [
"domain",
"card",
"initial",
"dt_s",
"segments",
"record_every"
],
"properties": {
"card": {
"type": "string",
"description": "The card of the pair, as list_cards names it."
},
"dt_s": {
"type": "number",
"description": "Step, in seconds. Held for the whole run."
},
"domain": {
"type": "string",
"description": "The domain of the pair, as list_cards names it."
},
"initial": {
"type": "object",
"description": "The phase fields of the card at the start of the run, each a number (a vector field is an array of three numbers), and no other key but signed: an instrument's signature over the rest of initial, under the key \"initial\", by the rule of a segment's signed. describe_card gives the fields, with each unit and bound."
},
"segments": {
"type": "array",
"items": {
"type": "object",
"required": [
"steps",
"load"
],
"properties": {
"load": {
"type": "object",
"description": "The load fields of the card for this segment, and no other key. describe_card gives them, with each unit and bound."
},
"steps": {
"type": "integer",
"minimum": 1
},
"signed": {
"type": "object",
"required": [
"alg",
"key",
"instrument",
"time",
"seq",
"prev",
"challenge",
"sig"
],
"properties": {
"alg": {
"enum": [
"ed25519"
],
"type": "string"
},
"key": {
"type": "string",
"pattern": "^[0-9a-f]{64}$"
},
"seq": {
"type": "integer",
"maximum": 9007199254740991,
"minimum": 0
},
"sig": {
"type": "string",
"pattern": "^[0-9a-f]{128}$"
},
"prev": {
"type": [
"string",
"null"
]
},
"time": {
"type": "string"
},
"challenge": {
"type": [
"string",
"null"
]
},
"instrument": {
"type": "string",
"maxLength": 200,
"minLength": 1
}
},
"description": "An instrument's Ed25519 signature over this reading, by the rule run_trajectory's input schema gives at segments.",
"additionalProperties": false
}
},
"additionalProperties": false
},
"minItems": 1
},
"record_every": {
"type": "integer",
"minimum": 1
}
},
"description": "One anchored run. Total steps must be <= 1000000. Recorded frames must be <= 10000. The shape of initial and of each segment's load depends on the pair: describe_card gives it.",
"additionalProperties": false
},
"solves": {
"type": "object",
"description": "In place of run: a plan of solves as run_dataset takes it (solver and plan, a list or a grid, at most 64 solves). quantity is then one number the solver publishes in its result, and each measurement names a row of the plan, numbered from 0, in place of a step."
},
"quantity": {
"type": "string",
"description": "The name of one number the card publishes in its state, a plain name that has a '_hex' sibling in the state. A flag is refused."
},
"component": {
"type": "integer",
"maximum": 2,
"minimum": 0,
"description": "0, 1 or 2: which of the three components of a 3-vector quantity is compared. Required when the quantity is a 3-vector, and refused when it is not. Any other value is refused."
},
"commitment": {
"type": "object",
"required": [
"sha384",
"salt"
],
"properties": {
"salt": {
"type": "string",
"description": "The salt the sha384 was made with: 32 to 128 lowercase hex digits, 16 to 64 bytes."
},
"sha384": {
"type": "string",
"pattern": "^[0-9a-f]{96}$",
"description": "The SHA-384 committed, 96 lowercase hex digits."
}
},
"description": "Optional: a commitment the measurements were locked with before this comparison, opened by this request. sha384 is the SHA-384 of these bytes: the line zero-trust-physics/measurement-commitment/v2 and a line break; the sealed form (the text a request's seal is taken over: keys sorted by their bytes, each number x and the 16 hex digits of its 64-bit float, no spaces) of {\"component\": <this request's component, or null>, \"measurements\": <this request's measurements>, \"quantity\": <this request's quantity>}; a line break; and the salt's bytes, its hex decoded. salt is 32 to 128 lowercase hex digits, 16 to 64 bytes, kept back until the comparison so that the data are not found from the sha384 by trying values. The engine makes the digest again from the request before computing: data that do not open it (a value, a step or a row changed, moved, added or dropped, another quantity or another salt) are refused as CommitmentDoesNotMatch, a salt shorter than 16 bytes as CommitmentSaltTooShort, a field of the wrong form as CommitmentMalformed, and sha384 or salt left out as InputMissing; nothing is computed and nothing is sealed. Opened, the comparison runs as it runs without one, validation_seal takes the commitment as a sixth part, and the answer says so in commitment_opened. A commitment shows that the data were not changed after it was made; when it was made is shown by where its sha384 was published before the comparison.",
"additionalProperties": false
},
"measurements": {
"type": "array",
"items": {
"type": "object",
"required": [
"value"
],
"properties": {
"row": {
"type": "integer",
"minimum": 0,
"description": "With solves, in place of step: the row of the plan whose solve the value is compared with, numbered from 0. The rows rise strictly."
},
"step": {
"type": "integer",
"minimum": 1,
"description": "With run: the landed step the value is compared with. The steps rise strictly and none is past the run's total."
},
"value": {
"type": "number",
"description": "The measurement, in the unit of the quantity."
},
"signed": {
"type": "object",
"required": [
"alg",
"key",
"instrument",
"time",
"seq",
"prev",
"challenge",
"sig"
],
"properties": {
"alg": {
"enum": [
"ed25519"
],
"type": "string"
},
"key": {
"type": "string",
"pattern": "^[0-9a-f]{64}$"
},
"seq": {
"type": "integer",
"maximum": 9007199254740991,
"minimum": 0
},
"sig": {
"type": "string",
"pattern": "^[0-9a-f]{128}$"
},
"prev": {
"type": [
"string",
"null"
]
},
"time": {
"type": "string"
},
"challenge": {
"type": [
"string",
"null"
]
},
"instrument": {
"type": "string",
"maxLength": 200,
"minLength": 1
}
},
"description": "An instrument's Ed25519 signature over this reading, by the rule run_trajectory's input schema gives at segments.",
"additionalProperties": false
}
},
"additionalProperties": false
},
"maxItems": 10000,
"minItems": 1,
"description": "At most 10000. A measurement is compared with the state after landed step k. There is no interpolation and no time matching: a measurement is placed by its step, its time since the start divided by dt_s."
}
},
"description": "One run, or one plan of solves, and measurements of one quantity. The answer is the error in numbers, sealed with a hash of the measurements. It sets no threshold. A request holds run or solves, not both.",
"additionalProperties": false
}| rows |
| array |
| With head and frames_hex: the rows a full run_dataset answer (answer "full") carries. |
| request | object | With dataset_seal alone: the run_dataset request as it was sent (the head's request). The plan is run again, under the permits and the limits of run_dataset, and its seal is compared with dataset_seal. Nothing is stored or read from storage, so it works whatever the return mode and on every connection. Its fields are run_dataset's. Worked example of the short form, as the whole arguments: {"request":{"domain":"energy","card":"thermal","plan":{"kind":"list","runs":[{"initial":{"temperature_k":293.15},"dt_s":1.0,"segments":[{"steps":60,"load":{"heat_power_w":5.0,"ambient_k":293.15}}],"record_every":60}]},"store":"none","return":"inline"},"dataset_seal":"<the dataset_seal of its run_dataset answer, 96 lowercase hex digits>"}. |
| frames_hex | string | null | With head and rows: the frames a run_dataset answer carries, or null. |
| public_key | string | The base64 of the ML-DSA-87 public key (2,592 bytes) to verify the answer's signature with; without it, this engine's own. |
| seen_nonces | array | Nonces of signatures already seen: one of them again is SignatureNonceReplayed. |
| dataset_seal | string | With request: the dataset_seal of the run_dataset answer, compared with the seal the plan runs to. Alone: the seal of a dataset stored as files (return "file"), read from the connection's own folder of that name. A dataset returned in the answer is not stored: it is verified with its request, or by its head, rows and frames_hex. |
{
"type": "object",
"properties": {
"head": {
"type": "object",
"description": "With rows and frames_hex: the head a run_dataset answer carries."
},
"rows": {
"type": "array",
"items": {
"type": "object"
},
"description": "With head and frames_hex: the rows a full run_dataset answer (answer \"full\") carries."
},
"request": {
"type": "object",
"description": "With dataset_seal alone: the run_dataset request as it was sent (the head's request). The plan is run again, under the permits and the limits of run_dataset, and its seal is compared with dataset_seal. Nothing is stored or read from storage, so it works whatever the return mode and on every connection. Its fields are run_dataset's. Worked example of the short form, as the whole arguments: {\"request\":{\"domain\":\"energy\",\"card\":\"thermal\",\"plan\":{\"kind\":\"list\",\"runs\":[{\"initial\":{\"temperature_k\":293.15},\"dt_s\":1.0,\"segments\":[{\"steps\":60,\"load\":{\"heat_power_w\":5.0,\"ambient_k\":293.15}}],\"record_every\":60}]},\"store\":\"none\",\"return\":\"inline\"},\"dataset_seal\":\"<the dataset_seal of its run_dataset answer, 96 lowercase hex digits>\"}."
},
"frames_hex": {
"type": [
"string",
"null"
],
"pattern": "^([0-9a-f]{2})*$",
"description": "With head and rows: the frames a run_dataset answer carries, or null."
},
"public_key": {
"type": "string",
"description": "The base64 of the ML-DSA-87 public key (2,592 bytes) to verify the answer's signature with; without it, this engine's own."
},
"seen_nonces": {
"type": "array",
"items": {
"type": "string",
"pattern": "^[0-9a-f]{64}$"
},
"description": "Nonces of signatures already seen: one of them again is SignatureNonceReplayed."
},
"dataset_seal": {
"type": "string",
"pattern": "^[0-9a-f]{96}$",
"description": "With request: the dataset_seal of the run_dataset answer, compared with the seal the plan runs to. Alone: the seal of a dataset stored as files (return \"file\"), read from the connection's own folder of that name. A dataset returned in the answer is not stored: it is verified with its request, or by its head, rows and frames_hex."
}
},
"description": "One of three forms. request and dataset_seal, the short form: the plan is run again and its seal compared. The three parts a full run_dataset answer carries (head, rows and frames_hex, all three required together, as they came), the long form: the rows, the root and the seal are recomputed from their exact values, then the head's plan is run again under the permits and the limits of run_dataset and the engine's full answer to it compared with the parts sent, value by value and then byte for byte, so a dataset that holds is every byte the engine's. dataset_seal alone: the stored dataset of that seal, its seals recomputed from its files and its plan run again into a folder of its own, the stored files compared with that run's byte for byte. The long form's answer carries holds, true when the answer sent is every byte the engine's, and values_hold beside it, true when every value of it is the engine's answer to its request computed again, whatever its spelling: each number by its 64-bit value, strings, flags and null exactly, keys and their order, the receipt string among them. A copy whose numbers a client wrote again in its own spelling (0.0001 for 1.0e-4, 12 for 12.0) has holds false and values_hold true, and differs_at names the first place its text differs. An answer the engine signed (signature, ML-DSA-87 over its receipt, with issued_at, expires_at and nonce) has its signature verified first, against public_key or else this engine's own key: one that does not hold is cause signature, named (SignatureDoesNotVerify, SignatureExpired, SignatureNonceReplayed, SignatureKeyMismatch, ReceiptDoesNotMatch, SignatureAbsent when public_key is given and there is none), and nothing is computed. A signed answer a client wrote again in its own spacing or key order has its signature verified over the receipt it carries; where that receipt does not cover the bytes sent, signature names ReceiptDoesNotMatch with written_again, and the answer is computed again: holds, values_hold and differs_at say what changed. The signature of a dataset follows its head's receipt.",
"additionalProperties": false
}{
"type": "object",
"required": [
"response_text"
],
"properties": {
"public_key": {
"type": "string",
"description": "The base64 of the ML-DSA-87 public key (2,592 bytes) to verify the answer's signature with; without it, this engine's own."
},
"seen_nonces": {
"type": "array",
"items": {
"type": "string",
"pattern": "^[0-9a-f]{64}$"
},
"description": "Nonces of signatures already seen: one of them again is SignatureNonceReplayed."
},
"response_text": {
"type": "string",
"description": "The exact text of a response as it was received, ending with the receipt, and the engine's signature after it when it carries one."
}
},
"description": "The text of one response from compute_step, run_trajectory or solve, or the head of a dataset written as its JSON text. A signature after the receipt is verified against public_key or else this engine's own key, and reported under signature.",
"additionalProperties": false
}| inputs | object | The inputs of the solve answer, sent back as returned: the request that was solved. It is hashed, and solved again under a physics permit and the limits of solve. |
| reject | string | null |
| result | object | null |
| outcome | string |
| request | object | With solution_seal alone: the solve request as it was sent (the answer's inputs). It is solved again, under a physics permit and the limits of solve, and its seal is compared with solution_seal. Its fields are solve's. Worked example of the short form, as the whole arguments: {"request":{"solver":"atom_dft","parameters":{"atomic_number":10}},"solution_seal":"<the solution_seal of its solve answer, 96 lowercase hex digits>"}. |
| invariants | object | null |
| iterations | integer | null |
| public_key | string | The base64 of the ML-DSA-87 public key (2,592 bytes) to verify the answer's signature with; without it, this engine's own. |
| seal_parts | object |
| seen_nonces | array | Nonces of signatures already seen: one of them again is SignatureNonceReplayed. |
| field_sha384 | string | null |
| solution_seal | string | The solution_seal of the solve answer: with request, or as part of the whole answer. |
| engine_version | string |
{
"type": "object",
"properties": {
"from": {
"type": "object",
"description": "Beside the whole answer of a chained solve: the from solve took (request, run_seal, coupling). The upstream run is computed again and held to its seal, each handed value to it, and the request solved again with it; the answer alone is refused (AnswerCarriesNoRequest)."
},
"inputs": {
"type": "object",
"description": "The inputs of the solve answer, sent back as returned: the request that was solved. It is hashed, and solved again under a physics permit and the limits of solve."
},
"reject": {
"type": [
"string",
"null"
]
},
"result": {
"type": [
"object",
"null"
]
},
"outcome": {
"type": "string"
},
"request": {
"type": "object",
"description": "With solution_seal alone: the solve request as it was sent (the answer's inputs). It is solved again, under a physics permit and the limits of solve, and its seal is compared with solution_seal. Its fields are solve's. Worked example of the short form, as the whole arguments: {\"request\":{\"solver\":\"atom_dft\",\"parameters\":{\"atomic_number\":10}},\"solution_seal\":\"<the solution_seal of its solve answer, 96 lowercase hex digits>\"}."
},
"invariants": {
"type": [
"object",
"null"
]
},
"iterations": {
"type": [
"integer",
"null"
],
"minimum": 0
},
"public_key": {
"type": "string",
"description": "The base64 of the ML-DSA-87 public key (2,592 bytes) to verify the answer's signature with; without it, this engine's own."
},
"seal_parts": {
"type": "object",
"required": [
"inputs",
"engine_version",
"result",
"invariants",
"field_sha384",
"outcome"
],
"properties": {
"inputs": {
"type": "string"
},
"result": {
"type": "string"
},
"outcome": {
"type": "string"
},
"invariants": {
"type": "string"
},
"field_sha384": {
"type": "string"
},
"engine_version": {
"type": "string"
}
},
"additionalProperties": true
},
"seen_nonces": {
"type": "array",
"items": {
"type": "string",
"pattern": "^[0-9a-f]{64}$"
},
"description": "Nonces of signatures already seen: one of them again is SignatureNonceReplayed."
},
"field_sha384": {
"type": [
"string",
"null"
]
},
"solution_seal": {
"type": "string",
"pattern": "^[0-9a-f]{96}$",
"description": "The solution_seal of the solve answer: with request, or as part of the whole answer."
},
"engine_version": {
"type": "string"
}
},
"description": "Either request and solution_seal alone, the short form: the request is solved again and its seal compared with solution_seal. Or the whole solve answer sent back as it came, without request, the long form: inputs, engine_version, outcome, iterations, reject, result, invariants, field_sha384, seal_parts and solution_seal are then all required. The solution seal is recomputed from its exact hex values and the part that fails is named; then its request is solved again under a physics permit and the limits of solve, and the engine's whole answer to it compared with the answer sent, value by value and then byte for byte, the receipt included, so an answer that holds is every byte the engine's. A seal has no key: an answer whose values were rewritten with its seal parts, seal and receipt worked out again holds every seal, and only the solve shows it is not the engine's (cause solution_seal). The long form's answer carries holds, true when the answer sent is every byte the engine's, and values_hold beside it, true when every value of it is the engine's answer to its request computed again, whatever its spelling: each number by its 64-bit value, strings, flags and null exactly, keys and their order, the receipt string among them. A copy whose numbers a client wrote again in its own spelling (0.0001 for 1.0e-4, 12 for 12.0) has holds false and values_hold true, and differs_at names the first place its text differs. An answer the engine signed (signature, ML-DSA-87 over its receipt, with issued_at, expires_at and nonce) has its signature verified first, against public_key or else this engine's own key: one that does not hold is cause signature, named (SignatureDoesNotVerify, SignatureExpired, SignatureNonceReplayed, SignatureKeyMismatch, ReceiptDoesNotMatch, SignatureAbsent when public_key is given and there is none), and nothing is computed. A signed answer a client wrote again in its own spacing or key order has its signature verified over the receipt it carries; where that receipt does not cover the bytes sent, signature names ReceiptDoesNotMatch with written_again, and the answer is computed again: holds, values_hold and differs_at say what changed.",
"additionalProperties": true
}{
"type": "object",
"required": [
"domain",
"card",
"parameters"
],
"properties": {
"card": {
"type": "string",
"description": "The card of the pair, as list_cards names it."
},
"from": {
"type": "object",
"required": [
"request",
"run_seal"
],
"properties": {
"request": {
"type": "object"
},
"coupling": {
"type": "string"
},
"run_seal": {
"type": "string",
"pattern": "^[0-9a-f]{96}$"
}
},
"description": "Optional: a sealed run to start from, as run_trajectory takes it.",
"additionalProperties": false
},
"domain": {
"type": "string",
"description": "The domain of the pair, as list_cards names it."
},
"parameters": {
"type": "object",
"description": "The step's inputs: the card's phase fields, its load fields and dt_s, each a number (a vector field is an array of three numbers), and no other key. describe_card gives the fields of the pair, with each unit and bound. A required field left out is refused as InputMissing, in a sentence that names the field, and a card the engine does not serve as UnknownCard; nothing is filled in."
}
},
"description": "One anchored step. The shape of parameters depends on the pair: describe_card gives it.",
"additionalProperties": false
}| frames |
| array |
| inputs | object | The inputs of the run_trajectory answer, sent back as returned: the request that was run. It is hashed, and run again, with the answer's readout when it has one, under a physics permit and the limits of run_trajectory. A card's fields, units and bounds are in describe_card. |
| reject | string | null |
| outcome | string |
| request | object | With run_seal alone: the run_trajectory request as it was sent, with its readout and its from when it had them (the answer's inputs holds neither; the upstream request in that from goes without a readout, as run_trajectory took it). It is run again, under a physics permit and the limits of run_trajectory, and its seal is compared with run_seal. Its fields are run_trajectory's. Worked example of the short form, as the whole arguments: {"request":{"domain":"energy","card":"thermal","initial":{"temperature_k":293.15},"dt_s":1.0,"segments":[{"steps":60,"load":{"heat_power_w":5.0,"ambient_k":293.15}}],"record_every":60},"run_seal":"<the run_seal of its run_trajectory answer, 96 lowercase hex digits>"}. |
| run_seal | string | The run_seal of the run_trajectory answer: with request, or as part of the whole answer. |
| chain_seal | string | With request and run_seal: a chained answer's chain_seal. |
| public_key | string | The base64 of the ML-DSA-87 public key (2,592 bytes) to verify the answer's signature with; without it, this engine's own. |
| final_state | any |
| seen_nonces | array | Nonces of signatures already seen: one of them again is SignatureNonceReplayed. |
| state_digest | string | null |
| steps_landed | integer |
| max_residual_conservation_error_hex | string | null |
| final_residual_conservation_error_hex | string | null |
{
"type": "object",
"properties": {
"links": {
"type": "array",
"items": {
"type": "object"
},
"description": "Alone: a chain's answers in order."
},
"frames": {
"type": "array",
"items": {
"type": "object",
"required": [
"step",
"frame_hex",
"link"
],
"properties": {
"link": {
"type": "string"
},
"step": {
"type": "integer",
"minimum": 1
},
"frame_hex": {
"type": "string"
}
},
"additionalProperties": false
}
},
"inputs": {
"type": "object",
"description": "The inputs of the run_trajectory answer, sent back as returned: the request that was run. It is hashed, and run again, with the answer's readout when it has one, under a physics permit and the limits of run_trajectory. A card's fields, units and bounds are in describe_card."
},
"reject": {
"type": [
"string",
"null"
]
},
"outcome": {
"type": "string"
},
"request": {
"type": "object",
"description": "With run_seal alone: the run_trajectory request as it was sent, with its readout and its from when it had them (the answer's inputs holds neither; the upstream request in that from goes without a readout, as run_trajectory took it). It is run again, under a physics permit and the limits of run_trajectory, and its seal is compared with run_seal. Its fields are run_trajectory's. Worked example of the short form, as the whole arguments: {\"request\":{\"domain\":\"energy\",\"card\":\"thermal\",\"initial\":{\"temperature_k\":293.15},\"dt_s\":1.0,\"segments\":[{\"steps\":60,\"load\":{\"heat_power_w\":5.0,\"ambient_k\":293.15}}],\"record_every\":60},\"run_seal\":\"<the run_seal of its run_trajectory answer, 96 lowercase hex digits>\"}."
},
"run_seal": {
"type": "string",
"pattern": "^[0-9a-f]{96}$",
"description": "The run_seal of the run_trajectory answer: with request, or as part of the whole answer."
},
"chain_seal": {
"type": "string",
"pattern": "^[0-9a-f]{96}$",
"description": "With request and run_seal: a chained answer's chain_seal."
},
"public_key": {
"type": "string",
"description": "The base64 of the ML-DSA-87 public key (2,592 bytes) to verify the answer's signature with; without it, this engine's own."
},
"final_state": {},
"seen_nonces": {
"type": "array",
"items": {
"type": "string",
"pattern": "^[0-9a-f]{64}$"
},
"description": "Nonces of signatures already seen: one of them again is SignatureNonceReplayed."
},
"state_digest": {
"type": [
"string",
"null"
]
},
"steps_landed": {
"type": "integer",
"minimum": 0
},
"max_residual_conservation_error_hex": {
"type": [
"string",
"null"
]
},
"final_residual_conservation_error_hex": {
"type": [
"string",
"null"
]
}
},
"description": "Either request and run_seal alone, the short form: the run is computed again and its seal compared with run_seal. Or the whole run_trajectory answer sent back as it was returned, without request, the long form: inputs, frames, outcome, steps_landed, reject, run_seal, final_state, final_residual_conservation_error_hex, max_residual_conservation_error_hex and state_digest are then all required, along with the rest of the answer. The trajectory chain, the state digest and the run seal are recomputed from its exact hex values; then its request is computed again under a physics permit and the limits of run_trajectory, and the engine's whole answer to it compared with the answer sent, value by value and then byte for byte, the receipt included, so an answer that holds is every byte the engine's. A seal has no key: an answer whose values were rewritten with its seals worked out again holds every seal, and only the computation shows it is not the engine's. An answer that continues a sealed upstream run (its chain names upstream_run_seal) carries the upstream's seal and not its request, and its long form is refused (AnswerCarriesNoRequest): its chain's answers in order, as links, carry each request, and each link is computed again from the links before it. Or links alone: a chain's answers in order, held as the long form holds one. A design_run answer sent whole is designed again and held the same way. The long form's answer carries holds, true when the answer sent is every byte the engine's, and values_hold beside it, true when every value of it is the engine's answer to its request computed again, whatever its spelling: each number by its 64-bit value, strings, flags and null exactly, keys and their order, the receipt string among them. A copy whose numbers a client wrote again in its own spelling (0.0001 for 1.0e-4, 12 for 12.0) has holds false and values_hold true, and differs_at names the first place its text differs. An answer the engine signed (signature, ML-DSA-87 over its receipt, with issued_at, expires_at and nonce) has its signature verified first, against public_key or else this engine's own key: one that does not hold is cause signature, named (SignatureDoesNotVerify, SignatureExpired, SignatureNonceReplayed, SignatureKeyMismatch, ReceiptDoesNotMatch, SignatureAbsent when public_key is given and there is none), and nothing is computed. A signed answer a client wrote again in its own spacing or key order has its signature verified over the receipt it carries; where that receipt does not cover the bytes sent, signature names ReceiptDoesNotMatch with written_again, and the answer is computed again: holds, values_hold and differs_at say what changed.",
"additionalProperties": true
}