Zero-Trust Physics

 ⟨230 unchanged words⟩ the plan at 4194304 bytes (OPEN_MAX_DATASET_ANSWER_BYTES) and 4000042500 characters, up to about 140150 summary rows; a plan of solves holds the ⟨110 unchanged words⟩ 

 ⟨44 unchanged words⟩  record_every sets which steps are recorded, about 230262 characters each; the final state comes back in ⟨299 unchanged words⟩ 

 ⟨562 unchanged words⟩ ,"run_seal":{"pattern":"^[0-9a-f]{6496}$","type":"string"}},"required ⟨305 unchanged words⟩  the answer follows from the request: about 230262 characters for each recorded state, plus the  ⟨8 unchanged words⟩ 8000 characters for the final state and the seals.seals; a flagged state adds about 400 characters for each limit it is past (exceedances). So 10,000 steps with record_every 1 answer ⟨537 unchanged words⟩ 

 ⟨82 unchanged words⟩ ,"run_seal":{"pattern":"^[0-9a-f]{6496}$","type":"string"}},"required ⟨236 unchanged words⟩ 

 ⟨85 unchanged words⟩ who computed. commitment, optional, opens a salted SHA-256SHA-384 the measurements were locked with before the comparison ⟨234 unchanged words⟩ 

 ⟨54 unchanged words⟩  before this comparison, opened by this request. sha256sha384 is the SHA-256SHA-384 of these bytes: the line zero-trust-physics/measurement-commitment/v1zero-trust-physics/measurement-commitment/v2 and a line break; the sealed form ( ⟨74 unchanged words⟩ that the data are not found from the sha256sha384 by trying values. The engine makes the digest ⟨43 unchanged words⟩  of the wrong form as CommitmentMalformed, and sha256sha384 or salt left out as InputMissing; nothing is ⟨43 unchanged words⟩ it was made is shown by where its sha256sha384 was published before the comparison.","properties":{"salt":{"description":"The salt the sha256sha384 was made with: 32 to 128 lowercase hex digits, 16 to 64 bytes.","type":"string"},"sha256sha384":{"description":"The SHA-256SHA-384 committed, 6496 lowercase hex digits.","pattern":"^[0-9a-f]{6496}$","type":"string"}},"required":["sha256sha384","salt"],"type":"object"}, ⟨607 unchanged words⟩ 

 ⟨201 unchanged words⟩ the plan at 4194304 bytes (OPEN_MAX_DATASET_ANSWER_BYTES) and 4000042500 characters, up to about 140150 summary rows; a plan of solves holds the ⟨110 unchanged words⟩ 

 ⟨220 unchanged words⟩  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 checked 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. The signature of a dataset follows its head's receipt.","properties":{"dataset_seal":{"description": ⟨57 unchanged words⟩  and frames_hex.","pattern":"^[0-9a-f]{6496}$","type":"string"},"frames_hex" ⟨31 unchanged words⟩  answer carries.","type":"object"},"public_key":{"description":"The base64 of the ML-DSA-87 public key (2,592 bytes) to check the answer's signature with; without it, this engine's own.","type":"string"},"request":{"description":"With dataset_seal alone:  ⟨115 unchanged words⟩ :\"<the dataset_seal of its run_dataset answer, 6496 lowercase hex digits>\"}.","type":" ⟨16 unchanged words⟩ ) carries.","items":{"type":"object"},"type":"array"},"seen_nonces":{"description":"Nonces of signatures already seen: one of them again is SignatureNonceReplayed.","items":{"pattern":"^[0-9a-f]{64}$","type":"string"},"type":"array"}},"type":"object"}

 ⟨41 unchanged words⟩  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.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 ⟨74 unchanged words⟩ 

 ⟨16 unchanged words⟩  of a dataset written as its JSON text. A signature after the receipt is checked against public_key or else this engine's own key, and reported under signature.","properties":{"public_key":{"description":"The base64 of the ML-DSA-87 public key (2,592 bytes) to check the answer's signature with; without it, this engine's own.","type":"string"},"response_text":{"description":"The exact text of a response as it was received, ending with the receipt.receipt, and the engine's signature after it when it carries one.","type":"string"},"seen_nonces":{"description":"Nonces of signatures already seen: one of them again is SignatureNonceReplayed.","items":{"pattern":"^[0-9a-f]{64}$","type":"string"},"type":"array"}},"required":["response_text"],"type":"object"}

 ⟨64 unchanged words⟩ seal the request solves to), recomputed_solution_seal and recomputed_receipt_sha256recomputed_receipt_sha384 when it holds (else no seal: solve ⟨246 unchanged words⟩ 

 ⟨39 unchanged words⟩  outcome, iterations, reject, result, invariants, field_sha256field_sha384, seal_parts and solution_seal are then all required.  ⟨185 unchanged words⟩  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 checked 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.","properties":{"engine_version":{"type":"string"},"field_sha256field_sha384":{"type":["string","null"] ⟨94 unchanged words⟩ ,"outcome":{"type":"string"},"public_key":{"description":"The base64 of the ML-DSA-87 public key (2,592 bytes) to check the answer's signature with; without it, this engine's own.","type":"string"},"reject":{"type":["string","null" ⟨63 unchanged words⟩ :\"<the solution_seal of its solve answer, 6496 lowercase hex digits>\"}.","type":" ⟨9 unchanged words⟩ {"engine_version":{"type":"string"},"field_sha256field_sha384":{"type":"string"},"inputs": ⟨12 unchanged words⟩ inputs","engine_version","result","invariants","field_sha256field_sha384","outcome"],"type":"object"},"seen_nonces":{"description":"Nonces of signatures already seen: one of them again is SignatureNonceReplayed.","items":{"pattern":"^[0-9a-f]{64}$","type":"string"},"type":"array"},"solution_seal":{"description":"The solution_seal of the ⟨9 unchanged words⟩  whole answer.","pattern":"^[0-9a-f]{6496}$","type":"string"}},"type":"object"}

 ⟨66 unchanged words⟩ ,"run_seal":{"pattern":"^[0-9a-f]{6496}$","type":"string"}},"required ⟨84 unchanged words⟩ 

 ⟨83 unchanged words⟩ " when it is not), recomputed_run_seal and recomputed_receipt_sha256recomputed_receipt_sha384 when it holds (else no seal: run_trajectory ⟨247 unchanged words⟩ 

 ⟨314 unchanged words⟩  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 checked 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.","properties":{"chain_seal":{"description": ⟨6 unchanged words⟩  answer's chain_seal.","pattern":"^[0-9a-f]{6496}$","type":"string"},"final_residual_conservation_error_hex" ⟨96 unchanged words⟩ ,"outcome":{"type":"string"},"public_key":{"description":"The base64 of the ML-DSA-87 public key (2,592 bytes) to check the answer's signature with; without it, this engine's own.","type":"string"},"reject":{"type":["string","null" ⟨112 unchanged words⟩ :\"<the run_seal of its run_trajectory answer, 6496 lowercase hex digits>\"}.","type":" ⟨16 unchanged words⟩  whole answer.","pattern":"^[0-9a-f]{96}$","type":"string"},"seen_nonces":{"description":"Nonces of signatures already seen: one of them again is SignatureNonceReplayed.","items":{"pattern":"^[0-9a-f]{64}$","type":"string"},"type":"array"},"state_digest":{"type":["string" ⟨8 unchanged words⟩ 

 ⟨33 unchanged words⟩ first request: what the model is of, howthe itevidence didbehind againstit measurementin numbers, each input with its unit and range, the names of its stops, and a worked request. Only theThe full form, the answer when form is left out, hasadds each bound's reason, the validation record and each stop's meaning: it is the form that explains a refusal and the form a result is relied on with.meaning.

 ⟨33 unchanged words⟩  first (the words that matched, and model_of,: the one real thing it is a model of) and then accuracy (compared_with, the data it was fitted to and the data held back and compared, and accuracy_against_measurement: how it did against the pass marks its record states); a model's range) and stops are in describe_card orthen describe_solver.accuracy: against_measurement, givesthe thatevidence verdictbehind it in one of sixthree words, the wordas list_cards and list_solvers give onit every("compared row:with "metmeasurement", "metheld into part"a andreference "missedcalculation" say how the model did against the pass marks its record states, and its validation record says whether that comparisonor was"company blindspecimen"); andcompared_with, wherewhat it was not, what wasfitted seenon; and when; "calibrated to the record" is a companion whose structureaccuracy_against_measurement, orwhat constantsit werewas chosencompared with the record of a scoredoutside originalthe openfit, so its comparison is not a blindwithin testwhat, and the original is served besidegap, itin undernumbers. itsFit ownand word;accuracy "heldare toseparate: a reference calculation" is comparedmodel with a published calculation, and "not held to a measurement"gap is the company's own specimen.still Itthe isserved accuracymodel andof notits fit.thing. TheA twomodel area separate:newer aone modelsupersedes thatcarries failedsuperseded_by itsand passcomes marksafter isit, still the served model ofunder its thing.own ID. The names it gives (domain and card,  ⟨12 unchanged words⟩ describe_card, describe_solver, cite and every other tool take.take; describe_card or describe_solver gives the range and every refusal. When nothing served fits it says so,  ⟨76 unchanged words⟩ 

 ⟨12 unchanged words⟩  and count, how many there are. against_measurement says in one ofnames sixthe wordsevidence howbehind the model stands against measurement. "met", "met in part" and "missed" say how itone didof againstthree thewords: pass"compared markswith itsmeasurement" record(a states,real andobject; its validation record, in describe_card or describe_solver,description says whether thatwhat comparisonit was blindfitted andon, wherewhat it was not, what was seen and when. "calibrated to the record" is a companion whose structure or constants were chosencompared with the recordoutside ofthe afit scoredand originalwithin openwhat, so its comparison is not a blind test; the original isgap, servedand besidewhere it under its own word.refuses), "held to a reference calculation" is (compared with a published calculation), andor "not held to acompany measurementspecimen" is the company's own specimen. It is(an accuracyobject andthe notcompany fitspecified, and a model thatevery missedconstant isstated). stillThe thenumbers servedsay modelhow ofgood itsit thing.is.

 ⟨11 unchanged words⟩  and count, how many there are. against_measurement says in one ofnames sixthe wordsevidence howbehind the model stands against measurement. "met", "met in part" and "missed" say how itone didof againstthree thewords: pass"compared markswith itsmeasurement" record(a states,real andobject; its validation record, in describe_card or describe_solver,description says whether thatwhat comparisonit was blindfitted andon, wherewhat it was not, what was seen and when. "calibrated to the record" is a companion whose structure or constants were chosencompared with the recordoutside ofthe afit scoredand originalwithin openwhat, so its comparison is not a blind test; the original isgap, servedand besidewhere it under its own word.refuses), "held to a reference calculation" is (compared with a published calculation), andor "not held to acompany measurementspecimen" is the company's own specimen. It is(an accuracyobject andthe notcompany fitspecified, and a model thatevery missedconstant isstated). stillThe thenumbers servedsay modelhow ofgood itsit thing.is.

 ⟨53 unchanged words⟩  as inputs.","type":"string"},"from":{"additionalProperties":false,"description":"Optional: a sealed card run handed in through a coupling, as run_trajectory takes it.","properties":{"coupling":{"type":"string"},"request":{"type":"object"},"run_seal":{"pattern":"^[0-9a-f]{64}$","type":"string"}},"required":["request","run_seal","coupling"],"type":"object"},"parameters":{"description":"The inputs of the ⟨225 unchanged words⟩ 

 ⟨56 unchanged words⟩  hash of the measurements, under one seal. There is no pass or failIt andsets no threshold: the numbers are not athe verdict.answer. The seal has no key, so it  ⟨256 unchanged words⟩ 

 ⟨22 unchanged words⟩ sealed with a hash of the measurements. It holdssets no verdict.threshold. A request holds run or solves, not  ⟨895 unchanged words⟩ 

 ⟨186 unchanged words⟩  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 ⟨93 unchanged words⟩ 

 ⟨250 unchanged words⟩ "type":["string","null"]},"from":{"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).","type":"object"},"inputs":{"description":"The inputs of the ⟨183 unchanged words⟩ 

 ⟨202 unchanged words⟩ On this open connection a dataset is returned in the answer (return "inline") and holds at most 300 runs (OPEN_MAX_DATASET_ROWS), 1000000 steps in totalall (OPEN_MAX_DATASET_STEPS), 10000 recorded statesframes and an answer counted from the plan at 4194304 bytes (OPEN_MAX_DATASET_ANSWER_BYTES); and 40000 characters, up to about 140 summary rows; a plan of solves holds the engine's own 64 and at most 15 s of them, each solveor countedone, at itseach solver's measured time, which describe_solver states with  ⟨89 unchanged words⟩ 

 ⟨34 unchanged words⟩ <= 100000000, stored frames <= 16777216; inline: rowsan answer counted from the plan <= 100040000 characters, frameswhich <=a 10000plan reaches first, ana answergrid countedon fromone theaxis at about 140 summary rows and a list sooner, its head repeating each run's request (a plan <=of 40000more characters;than 1000 rows is refused before it is counted, as too large to return inline), and frames <= 10000; solves <= 64. With return \"file\"  ⟨1183 unchanged words⟩ 

 ⟨451 unchanged words⟩ 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);  ⟨962 unchanged words⟩ 

 ⟨234 unchanged words⟩  and at most 15 s of them, each solveor countedone, at itseach solver's measured time, which describe_solver states with  ⟨89 unchanged words⟩ 

 ⟨173 unchanged words⟩ On this open connection a dataset is returned in the answer (return "inline") and holds at most 300 runs (OPEN_MAX_DATASET_ROWS), 1000000 steps in totalall (OPEN_MAX_DATASET_STEPS), 10000 recorded statesframes and an answer counted from the plan at 4194304 bytes (OPEN_MAX_DATASET_ANSWER_BYTES); and 40000 characters, up to about 140 summary rows; a plan of solves holds the engine's own 64 and at most 15 s of them, each solveor countedone, at itseach solver's measured time, which describe_solver states with  ⟨89 unchanged words⟩ 

 ⟨21 unchanged words⟩ was sent, with its readout and its from, whose request has none, when it had them (the answer's inputs  ⟨304 unchanged words⟩ 

 ⟨463 unchanged words⟩  it had them (the answer's inputs holds neitherneither; the upstream request in that from goes without a readout, as run_trajectory took it). It is run again, under a  ⟨113 unchanged words⟩ 

 ⟨12 unchanged words⟩  and count, how many there are. against_measurement is how thesays modelin didone againstof itssix ownwords measurements,how inthe onemodel ofstands sixagainst words,measurement. "met", "missed", "met in part", "calibratedand to"missed" thesay record",how "heldit todid aagainst referencethe calculation"pass ormarks "notits heldrecord tostates, aand measurement":its itvalidation isrecord, accuracyin anddescribe_card notor fitdescribe_solver, and asays modelwhether that missedcomparison iswas stillblind theand, servedwhere modelit ofwas itsnot, thing.what was seen and when. "calibrated to the record": theis model'sa companion whose structure or constants were chosen with the record itof isa comparedscored withoriginal open, so theits comparison shown is not a blind test; the original model, compared blind, is served beside it under its own word. "held to a reference calculation" is compared with a published calculation, and "not held to a measurement" is the company's own specimen. It is accuracy and not fit, and a model that missed is still the served model of its thing.

 ⟨11 unchanged words⟩  and count, how many there are. against_measurement is how thesays modelin didone againstof itssix ownwords measurements,how inthe onemodel ofstands sixagainst words,measurement. "met", "missed", "met in part", "calibratedand to"missed" thesay record",how "heldit todid aagainst referencethe calculation"pass ormarks "notits heldrecord tostates, aand measurement":its itvalidation isrecord, accuracyin anddescribe_card notor fitdescribe_solver, and asays modelwhether that missedcomparison iswas stillblind theand, servedwhere modelit ofwas itsnot, thing.what was seen and when. "calibrated to the record": theis model'sa companion whose structure or constants were chosen with the record itof isa comparedscored withoriginal open, so theits comparison shown is not a blind test; the original model, compared blind, is served beside it under its own word. "held to a reference calculation" is compared with a published calculation, and "not held to a measurement" is the company's own specimen. It is accuracy and not fit, and a model that missed is still the served model of its thing.

 ⟨23 unchanged words⟩  against its own measurements, in one of fivesix words, "met", "missed", "met in part", "calibrated to the record", "held to a reference calculation" or "not  ⟨15 unchanged words⟩  is still the served model of its thing. "calibrated to the record": the model's structure or constants were chosen with the record it is compared with open, so the comparison shown is not a blind test; the original model, compared blind, is served beside it under its own word.

 ⟨183 unchanged words⟩ burst, a capsule's flown parachute deployment, a mission'scrater lastthat daystops growing, thea endcell's ofrunaway aonce record'severy clockreactant oris trackconsumed) is not refused: outcome is \"ended\ ⟨1219 unchanged words⟩ 

 ⟨85 unchanged words⟩ does not show who measured or who computed. genesis_sealcommitment, verify-validationoptional, rebuildsopens a salted SHA-256 the sealmeasurements andwere locked with before the statisticscomparison: fromdata that are not the answercommitted aloneones are refused before computing (CommitmentDoesNotMatch), ofand athe runseal orcovers ofit. agenesis_seal planverify-validation ofrebuilds solves.the seal, the statistics and the commitment from the answer alone. In place of run, solves takes a plan ⟨6 unchanged words⟩ (solver and plan, at most 64 solves): quantity is one number the solver publishes in its result, and each measurement is {"row": <theat plan'sa row, fromof 0>,the "value"plan: <number>}. Thethe solves are sealed under one dataset_seal as run_dataset seals them, and the comparison is sealed by the same statistics, measurement hash and validation seal as a run's,rules with the dataset_seal in the place of the ⟨153 unchanged words⟩ 

 ⟨37 unchanged words⟩ or solves, not both.","properties":{"commitment":{"additionalProperties":false,"description":"Optional: a commitment the measurements were locked with before this comparison, opened by this request. sha256 is the SHA-256 of these bytes: the line zero-trust-physics/measurement-commitment/v1 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 sha256 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 sha256 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 sha256 was published before the comparison.","properties":{"salt":{"description":"The salt the sha256 was made with: 32 to 128 lowercase hex digits, 16 to 64 bytes.","type":"string"},"sha256":{"description":"The SHA-256 committed, 64 lowercase hex digits.","pattern":"^[0-9a-f]{64}$","type":"string"}},"required":["sha256","salt"],"type":"object"},"component":{"description":"0, 1 or  ⟨602 unchanged words⟩ 

 ⟨41 unchanged words⟩  in no way: it has no key. A response that names an engine_version has it said beside matches, with whether it is this engine's. The receipt covers the request as it was  ⟨74 unchanged words⟩ 

 ⟨24 unchanged words⟩  against its own measurements, in one of fourfive words, "met", "missed", "met in part", "held to a reference calculation" or "not held to a measurement": ⟨19 unchanged words⟩ 

 ⟨23 unchanged words⟩  against its own measurements, in one of fourfive words, "met", "missed", "met in part", "held to a reference calculation" or "not held to a measurement": ⟨19 unchanged words⟩ 

 ⟨240 unchanged words⟩  (OPEN_MAX_DATASET_ANSWER_BYTES); a plan of solves holds atthe mostengine's 5own of64 step_flow_armaly,and at most 15 s of tokamak_dt_beam_targetthem, 15each ofsolve ablator_slab,counted 30at ofits atom_dftsolver's andmeasured 64time, ofwhich everydescribe_solver otherstates solverwith the count (OPEN_PLAN_SECONDS). One address holds at most 1 ⟨19 unchanged words⟩  of more than 10000 steps, or a checkverification that computes one again) runs 1 at  ⟨45 unchanged words⟩ 

 ⟨1184 unchanged words⟩ it comes to more than 40000 characters. verify_dataset checksverifies a plan of solves by its request and ⟨45 unchanged words⟩ 

 ⟨245 unchanged words⟩  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  ⟨30 unchanged words⟩  of more than 10000 steps, or a checkverification that computes one again) runs 1 at  ⟨45 unchanged words⟩ 

 ⟨319 unchanged words⟩ 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 missing or unknown, a value of the wrong type,  ⟨202 unchanged words⟩ array of three numbers), and no other key.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 themthe fields, with each unit and bound.","type" ⟨314 unchanged words⟩ ,"type":"integer"},"segments":{"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.","items":{"additionalProperties":false,"properties":{" ⟨16 unchanged words⟩  gives them, with each unit and bound.","type":"object"},"signed":{"additionalProperties":false,"description":"An instrument's Ed25519 signature over this reading, by the rule run_trajectory's input schema gives at segments.","properties":{"alg":{"enum":["ed25519"],"type":"string"},"challenge":{"type":["string","null"]},"instrument":{"maxLength":200,"minLength":1,"type":"string"},"key":{"pattern":"^[0-9a-f]{64}$","type":"string"},"prev":{"type":["string","null"]},"seq":{"maximum":9007199254740991,"minimum":0,"type":"integer"},"sig":{"pattern":"^[0-9a-f]{128}$","type":"string"},"time":{"type":"string"}},"required":["alg","key","instrument","time","seq","prev","challenge","sig"],"type":"object"},"steps":{" ⟨22 unchanged words⟩ 

 ⟨131 unchanged words⟩ answers is not a sign of tampering. verify_solution checksverifies a solution later from this request, or  ⟨34 unchanged words⟩  of more than 10000 steps, or a checkverification that computes one again) runs 1 at  ⟨45 unchanged words⟩ 

 ⟨80 unchanged words⟩  as describe_solver gives it, and no other key.key but signed. Every number of a solve request must be  ⟨66 unchanged words⟩  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"},"solver":{ ⟨13 unchanged words⟩ 

 ⟨227 unchanged words⟩ this open connection a plan of solves holds atthe mostengine's 5own of64 step_flow_armaly,and at most 15 s of tokamak_dt_beam_targetthem, 15each ofsolve ablator_slab,counted 30at ofits atom_dftsolver's andmeasured 64time, ofwhich everydescribe_solver otherstates solverwith the count (OPEN_PLAN_SECONDS). One address holds at most 1 ⟨19 unchanged words⟩  of more than 10000 steps, or a checkverification that computes one again) runs 1 at  ⟨45 unchanged words⟩ 

 ⟨153 unchanged words⟩ "minimum":0,"type":"integer"},"signed":{"additionalProperties":false,"description":"An instrument's Ed25519 signature over this reading, by the rule run_trajectory's input schema gives at segments.","properties":{"alg":{"enum":["ed25519"],"type":"string"},"challenge":{"type":["string","null"]},"instrument":{"maxLength":200,"minLength":1,"type":"string"},"key":{"pattern":"^[0-9a-f]{64}$","type":"string"},"prev":{"type":["string","null"]},"seq":{"maximum":9007199254740991,"minimum":0,"type":"integer"},"sig":{"pattern":"^[0-9a-f]{128}$","type":"string"},"time":{"type":"string"}},"required":["alg","key","instrument","time","seq","prev","challenge","sig"],"type":"object"},"step":{"description":"With run: the  ⟨170 unchanged words⟩ array of three numbers), and no other key.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 themthe fields, with each unit and bound.","type" ⟨27 unchanged words⟩  gives them, with each unit and bound.","type":"object"},"signed":{"additionalProperties":false,"description":"An instrument's Ed25519 signature over this reading, by the rule run_trajectory's input schema gives at segments.","properties":{"alg":{"enum":["ed25519"],"type":"string"},"challenge":{"type":["string","null"]},"instrument":{"maxLength":200,"minLength":1,"type":"string"},"key":{"pattern":"^[0-9a-f]{64}$","type":"string"},"prev":{"type":["string","null"]},"seq":{"maximum":9007199254740991,"minimum":0,"type":"integer"},"sig":{"pattern":"^[0-9a-f]{128}$","type":"string"},"time":{"type":"string"}},"required":["alg","key","instrument","time","seq","prev","challenge","sig"],"type":"object"},"steps":{" ⟨84 unchanged words⟩ 

ChecksVerifies the seal of a dataset. Short form:  ⟨14 unchanged words⟩  its answer gave. The plan is run again, under therun_dataset's permits and the limits of run_dataset, whatever its answer form, andlimits; the answer is holds, cause ("dataset_seal" ⟨10 unchanged words⟩  runs to), recomputed_dataset_seal when it holds (when it does not,else no seal is returned: run_dataset gives the true one), a sentence of what was checkedcompared, and text_not_compared: the short form compares no rows the agent holds.holds are compared. A plan of solves is checkedverified by this short form only. Long form, which takes no physics permit: head, rows and frames_hex, the three parts a full answer carries (answer "full"), alltogether, threeas together.they came. The rows, the root and the seal are recomputed;recomputed, and row and fault name the first row changed, swapped, dropped or repeated,repeated; andthen athe decimalplan thatis differsrun fromagain itsunder exactrun_dataset's hex,permits whichand nolimits sealand covers.the holdsengine's doesanswer notcompared coverwith theit, receipt.value Aby datasetvalue madeand withoutbyte thefor enginebyte can(cause passanswer_text, thewith longdiffers_at form;and replayingrow): aholds rowis throughtrue run_trajectoryonly showswhen every byte is the engineengine's, madevalues_hold it.when every value is. On this open connection a dataset is returned  ⟨30 unchanged words⟩  (OPEN_MAX_DATASET_ANSWER_BYTES); a plan of solves holds atthe mostengine's 5own of64 step_flow_armaly,and at most 15 s of tokamak_dt_beam_targetthem, 15each ofsolve ablator_slab,counted 30at ofits atom_dftsolver's andmeasured 64time, ofwhich everydescribe_solver otherstates solverwith the count (OPEN_PLAN_SECONDS). One address holds at most 1 ⟨19 unchanged words⟩  of more than 10000 steps, or a checkverification that computes one again) runs 1 at  ⟨45 unchanged words⟩ 

 ⟨18 unchanged words⟩ 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 nothe physicsparts run.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, isits checkedseals recomputed from its files and its plan run again into a folder of its own, the stored files compared with nothat physicsrun's run.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.

ChecksVerifies the receipt at the end of one response ⟨91 unchanged words⟩  Replaying the request through run_trajectory, solve or verify_stepcompute_step shows the engine produced it; verify_tape, verify_solution  ⟨15 unchanged words⟩ 

{"additionalProperties":false,"description":"The text of one response from verify_stepcompute_step, run_trajectory or solve, or the head of ⟨30 unchanged words⟩ 

ChecksVerifies the seal of a solution. Short form,  ⟨61 unchanged words⟩ ), recomputed_solution_seal and recomputed_receipt_sha256 when it holds (when it does not,else no seal is returned: solve gives the true one), a sentence of what was checkedcompared, and text_not_compared: the short form compares no answer text the agent holds, sois acompared. copyLong withform: athe decimalwhole changedsolve stillanswer holds;sent verify_receiptback checksas ait copycame, againstwithout therequest. receiptIts thatsolution copyseal carries,is recomputed from its exact hex values and the checkpart that fails is completenamed, onlythen whenits thatrequest receiptis equalssolved recomputed_receipt_sha256again here.under Longa form:physics thepermit wholeand solvethe engine's answer sentcompared backwith it, withoutvalue request;by itvalue takesand nobyte physicsfor permitbyte, recomputesreceipt theincluded: solutionholds sealis andtrue namesonly thewhen partevery thatbyte failsis the engine's, andvalues_hold checkswhen onlyevery thevalue exactis, hexelse valuescause andnames the sealspart, notsolution_seal (the decimalrequest copiessolves ofto theanother valuesseal), andanswer_text not(with differs_at, the receipt,first asfield itsthat differs) or engine_version (an answer says.of another version). Nothing is stored, so each form answers the ⟨33 unchanged words⟩  of more than 10000 steps, or a checkverification that computes one again) runs 1 at  ⟨45 unchanged words⟩ 

 ⟨21 unchanged words⟩  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_sha256, seal_parts and solution_seal are then all required,required. theThe solution seal is recomputed from its exact hex values and the part that fails is namednamed; 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 physicskey: run.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.","properties":{"engine_version":{"type": ⟨18 unchanged words⟩ 

Computes one anchored step of one card and returns the state it lands on, in decimals and exact hex, with its cryptographic proof (sha256_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 whosecompute_step landingdoes: stateverify_step is outside the card is refusedearlier inname oneof sentencecompute_step, with the refusal'sserved namefor inthis roundone bracketsversion whenbeside it has one, and notakes proofthe issame issuedarguments forand thatgives state.the Withsame fromanswer, the step startsbyte fromfor abyte. sealedThe run,name whichcompute_step is computedthe againone first.that stays. On this open connection one address holds at  ⟨21 unchanged words⟩  of more than 10000 steps, or a checkverification that computes one again) runs 1 at  ⟨45 unchanged words⟩ 

 ⟨113 unchanged words⟩ 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.","type":"object"}},"required": ⟨5 unchanged words⟩ 

ChecksVerifies the seal of a run. Short form,  ⟨75 unchanged words⟩ ), recomputed_run_seal and recomputed_receipt_sha256 when it holds (when it does not,else no seal is returned: run_trajectory gives the true one), a sentence of what was checkedcompared, and text_not_compared: the short form compares no answer text the agent holds, sois acompared. copyLong withform: athe decimalwhole changedrun_trajectory stillanswer holds;sent verify_receiptback checksas ait copycame, againstwithout therequest. receiptIts thatstate copydigest carriesand run seal are recomputed from its exact hex values, andthen theits checkrequest is completecomputed onlyagain whenunder thata receiptphysics equalspermit recomputed_receipt_sha256and here.the Longengine's form:answer thecompared wholewith run_trajectoryit, answervalue sentby backvalue and byte for byte, withoutreceipt request;included: itholds takesis notrue physicsonly permit,when recomputesevery thebyte chain,is the stateengine's, digestvalues_hold andwhen theevery runvalue sealis, andelse checkscause names the exactseal, hexload_signature values(a andsigned theload seals,that does not theverify), decimalanswer_text copies(with ofdiffers_at, the valuesfirst andfield notthat thediffers) receipt.or engine_version (an answer of another version). A chain is checkedverified by its request with from, run_seal and chain_seal, computed again; or by links, its answers in order, witheach nocomputed physics.again from the links before it; a chained answer alone is refused (AnswerCarriesNoRequest). Nothing is stored, so each form answers the ⟨33 unchanged words⟩  of more than 10000 steps, or a checkverification that computes one again) runs 1 at  ⟨45 unchanged words⟩ 

 ⟨27 unchanged words⟩ sent back as it was returned, without request, the long form: inputs, frames, outcome, steps_landed, reject, ⟨3 unchanged words⟩  max_residual_conservation_error_hex and state_digest are then all required, andalong 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 physicskey: run.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.