Dataset Viewer
Auto-converted to Parquet Duplicate
id
stringlengths
2
2
text
stringlengths
15
107
kind
stringclasses
5 values
expect
stringclasses
4 values
expected_math
stringclasses
2 values
gold
unknown
c1
convert 3 km to m
convert
VERIFIED
VERIFIED
{ "value": "3000", "unit": "m", "exponents": [ 0, 1, 0, 0, 0, 0, 0 ] }
c2
convert 5 km/h to m/s
convert
VERIFIED
VERIFIED
{ "value": "25/18", "unit": "m/s", "exponents": [ 0, 1, -1, 0, 0, 0, 0 ] }
c3
convert 1 eV to J
convert
VERIFIED
VERIFIED
{ "value": "801088317/5000000000000000000000000000", "unit": "J", "exponents": [ 1, 2, -2, 0, 0, 0, 0 ] }
c4
convert 1 day to s
convert
VERIFIED
VERIFIED
{ "value": "86400", "unit": "s", "exponents": [ 0, 0, 1, 0, 0, 0, 0 ] }
c5
convert 3 m to s
convert
REFUSED
NOT_ASKED
null
a1
audit ( F * t ) = ( m * v )
audit
VERIFIED
NOT_ASKED
{ "holds": true, "residue": "0", "exponents": [ 0, 0, 0, 0, 0, 0, 0 ] }
a2
audit E = m * g * hgt
audit
VERIFIED
NOT_ASKED
{ "holds": true, "residue": "0", "exponents": [ 0, 0, 0, 0, 0, 0, 0 ] }
a3
audit P = E / t
audit
VERIFIED
NOT_ASKED
{ "holds": true, "residue": "0", "exponents": [ 0, 0, 0, 0, 0, 0, 0 ] }
a4
audit V = I * R
audit
VERIFIED
NOT_ASKED
{ "holds": true, "residue": "0", "exponents": [ 0, 0, 0, 0, 0, 0, 0 ] }
a5
audit m * v ^ 2 = m * v
audit
REFUSED
NOT_ASKED
null
p1
pi period from mass, stiffness
pi
VERIFIED
VERIFIED
{ "names": [ "mass", "stiffness" ], "exponents": [ "1/2", "-1/2" ] }
p2
pi speed from length, gravity
pi
VERIFIED
VERIFIED
{ "names": [ "length", "gravity" ], "exponents": [ "1/2", "1/2" ] }
v1
potential node 1 circuit 3 resistors [ 1 2 10 ; 2 3 20 ] sources [ 1 1 ] size 1/10 frequency 50
potential
VERIFIED
VERIFIED
{ "node": 1, "value": "30" }
v2
potential node 1 circuit 3 resistors [ 1 2 10 ; 2 3 20 ] sources [ 1 1 ] size 1000000 frequency 50000000000
potential
GUARD_BLOCKED
NOT_ASKED
null
v3
potential node 3 circuit 4 resistors [ 1 2 10 ; 2 3 20 ] sources [ 1 1 ] size 1/10 frequency 50
potential
REFUSED
NOT_ASKED
null
v4
potential node 1 circuit 2 resistors [ 1 2 10 ; 1 2 20 ] sources [ 1 1 ] size 1/10 frequency 50
potential
VERIFIED
VERIFIED
{ "node": 1, "value": "20/3" }
x1
what is the meaning of life
none
REFUSED
NOT_ASKED
null
x2
predict the exact position and momentum of one particle
none
ABSTAINED
NOT_ASKED
null

LingoLOGOS physics topology

An eleven agent topology that answers questions written in a small physics language, and answers either with a verified result, or with an explicit refusal of the question, or with UNKNOWN. It never guesses, and it never hands a number to the mathematics it is not willing to justify.

python tools/ask.py "convert 3 km to m"
Question as read      : convert, 2 road(s)
Status                : VERIFIED (assurance level 2 of 2)
Answer                : 3 km = 3000 m (L)
Asked of mathematics  : evaluate 3 * 1000 / 1 [VERIFIED]
Notes                 : the_perturbation_was_visible; adversary_failed_perturbation_visible
Orchestrator Z3 check : 11 of 11 envelopes confirmed

Only the standard library and z3-solver are required, and pytest for the tests; all three are named in requirements.txt. This dataset is that folder published as it stands, code and data together: a self contained bundle of 71 files. It collaborates with the mathematics dataset of the same project as a separate process, and it does not import a single module of it: section 8 states the contract, and tests/test_isolation.py enforces it from the source text and from the syntax trees. The other dataset is https://huggingface.co/datasets/tailot/lingologos-math, and with it nowhere to be found the physics roads still run and still refuse, only the confidence of a delegated answer falls to 0 (section 8 says how to place the two folders so that the delegation is vouched for).

1. The language

Family Sentence Answer
conversion convert <number> <unit> to <unit> the same quantity in the asked unit, exact rational
dimensional audit audit <term> = <term> true, or the residue of the equation as exponents of the seven bases
dimensional analysis pi <quantity> from <quantity>, <quantity>, ... the exponents of a dimensionless product that reaches the asked quantity
resistor networks potential node <k> circuit <n> resistors [ a b r ; ... ] sources [ node current ; ... ] size <s> frequency <f> the potential of that node, exact rational, in volts

Units are the SI ones plus the composites this physics needs - ohm, V, J, W, Hz, C, eV, day, min, h, and a compound written as a numerator over a denominator such as km/h - and a name that is not in the table is refused rather than guessed (39 quantity symbols and the unit table live in lgphys/units.py). A number is exact: 3, 1/10, -25/18, and a decimal such as 3.5 is read as the rational 7/2, because no module of this dataset has ever seen a floating point number. The comma separates the quantities of a pi list, and and is not a separator.

Fragment. Everything outside it ends in a refusal with a reason, never in a guess. A conversion needs two units that are in the table and have the same dimension. An audit equation is a product of powers of known symbols. A pi sentence names a target and a list of known quantities, and the answer is the monomial that reaches the target - when no monomial of that set reaches it, that is said instead of being solved for the closest one. A network sentence needs at least two nodes, resistances that are positive rationals, endpoints and sources that name real nodes, an asked node that exists, and a conductance matrix that is not singular: a node with no path to the reference has no determined potential, and the network says so by name. There is no calculus, no differential equation, no vector field, no geometry (the compendium's geometry band is deliberately left out of this version), and no quantum or relativistic computation: those bands appear as reasons for not answering, in section 3.

The abstract syntax of the fragment is also given in nodes/*/grammar.gf; that file is a specification that has not been compiled with the GF toolchain, and the reference parsers are Python. Two of them exist, lgphys/parse_a.py (a token walker) and lgphys/parse_b.py (a dimensional reading that recovers the sentence from its units), and a question is only answered when both write the same canonical sentence.

2. The eleven nodes

Node Role Job What it is willing to be believed for
reader_a read reads the sentence on road A, a token walker same_dimension
reader_b read reads it again on road B, a dimensional reading same_dimension
domain_a regime asks whether the law behind the question applies at all same_dimension, unit_table_consistent
domain_b model builds the model of the family (factor, equation, network) same_dimension, factor_is_a_number
equivalence agree proves the two readings are the same question agree_read_b
coverage shape checks that every token of the sentence is used by the model token_*, tokens_declared
invoker compose forms the arithmetic sentence, asks the mathematics dataset, compares answer_is_the_number_asked, physics_and_mathematics_agree
boundary recheck recomputes the answer by an independent route, and cross checks the constants against the ontology of its own node answer_recomputed, constant_table_matches_ontology
verifier verify re-decides with its own Z3 run every claim the constructive nodes have made so far the checks of the others, 15 of them on a conversion
adversary attack perturbs the answer on purpose and asks whether the perturbation left a trace perturbation_visible, plus dimension_field_perturbation_visible on a conversion and node_field_perturbation_visible and guard_field_perturbation_visible on a network
arbiter final applies the decision rule and writes the one line verdict answer_survives_recomputation, same_dimension

Every node starts as a separate process, reads one JSON envelope on standard input and writes one on standard output (agents/physics_agent). An envelope is the LingoLOGOS envelope: sender, recipient, turn, volatileState.internalTimeTick, and a payload with naturalLanguage, abstractSyntaxTree and smtConstraints. The prose and the memory of the session are separated inside naturalLanguage by the marker @@DOSSIER@@: what a node writes for a human, and what it hands to the next node. A node never advances turn or tick; the orchestrator counts them.

Wiring. topology.json is a fixed pipeline of eleven edges (terminationCondition FIXED_PIPELINE, maxTurns 11). The question is seeded in the last node of the routing list, because in this orchestrator a sender receives what its recipient was holding: the pairs are a reversed chain, so the work order is reader_a, reader_b, domain_a, domain_b, equivalence, coverage, invoker, boundary, verifier, adversary, arbiter. Each node hands the envelope to the node that works after it, and the arbiter's outgoing envelope is the answer.

Claims. What each node believes is stated as SMT-LIB in the same envelope: the numbers it pinned as declarations, and one assertion that is the disjunction of the negations of its own checks. A node that believes all of its checks produced something Z3 finds unsatisfiable against the ontology of that node; a node with nothing to check writes (assert true). The orchestrator re-checks every claim against the ontology that the claiming node itself carries (nodes/<id>/ontology.smt2), which is what the line Orchestrator Z3 check : 11 of 11 envelopes confirmed counts. The ontology of each node declares the seven constants of lgphys/consts.py: c, e, h, k_B and N_A as exact values, G and the fine structure constant as intervals, because their last digits are measured and not defined. The verifier is the one node that states no belief of its own: it has no invariant to be believed for, which is why it is the only node with no role of its own in the classification of lgphys/agents.py. What it contributes is a second decision, in its own Z3 run, of the checks the other nodes closed with.

3. What the verdict means, and how much confidence goes with it

The arbiter applies one rule, in this order. A failure carries a burden: model, guard and content belong to the world and to the sentence; agreement and soundness belong to the chain.

Verdict When Confidence shown
ABSTAINED the question falls in a band that is refused by design (open or undecidable problem, a state the theory does not allow, a chaotic system past its predictability time) 0
REFUSED a burden of content, model or guard failed: the question is not a physics question of this fragment, the units do not allow the operation, or the law stops applying 2, or 1 with one reading only
GUARD_BLOCKED a guard of a stated law failed (the same class of failure, reported by its own name) 2, or 1
UNKNOWN the answer was reached but the chain cannot vouch for it: two nodes disagree, a claim was not what its own node's ontology says, a perturbation left no trace, a node stopped while working, or the arithmetic was needed and did not come back verified 0
VERIFIED two independent readings agree, every check of every node holds, the answer was recomputed independently, arithmetic agreed where it was asked, and no claim was contradicted 2
SINGLE_PROVER the same, with one reading instead of two 1

Confidence is the minimum over the independent readers: two roads give 2, one road alone gives 1, and disagreement gives 0 - and two roads count only when a node certified that they agree. The pipeline records whether the two canonical texts came out equal, but a fact nobody vouched for is not a reason for a level, so the node whose role is agreement has to compare the scalars the two roads produced inside a claim that its own Z3 run decides. Remove that node and both roads are still read and still agree, yet the ceiling falls back to one road by itself; section 4 measures this. A level of 3 is never shown, because the chain has no third source that is not one of the first two. When the question asked for arithmetic, the confidence shown is also capped by what the mathematics dataset returned: if it did not return VERIFIED, the confidence shown is 0 even when both physics roads agree, because the number in the answer is the number mathematics was supposed to supply.

Three more rules are part of the ladder rather than details. A verdict that has no answer under it is not a verdict: if the node that produces the answer is missing from the chain, the ladder refuses to certify the checks that remain and closes at zero confidence with the reason no_answer_was_recorded, because every other check could still be green over an empty answer. A question that physics already refused never reaches the arithmetic: no_arithmetic_for_a_question_physics_did_not_accept appears in the notes, because asking evaluate 3 * 1 / 1 about a conversion between metres and seconds would make a refusal look like a solved problem. And the arbiter is not trusted with its own report: after the verdict is written, lgphys/pipeline.py re-derives it from the dossier, and if the arbiter wrote something the evidence does not support the verdict is replaced and the reason the_arbiter_reported_<status> is recorded. That is why arbiter:force_accept cannot turn a refusal into a verification.

The bands refused by design are the five rows of ABSTENTIONS in lgphys/laws.py: the regularity of three dimensional Navier-Stokes, the spectral gap of an arbitrary local Hamiltonian, the wave function of the universe, the predictability horizon of a chaotic system, and a state with exactly determined position and momentum. They come from the compendium of formal laws, and they are reported as ABSTAINED, not as REFUSED: the sentence was understood, there is simply nothing to compute.

4. Why eleven nodes, and what each one is for

The shape is not the math topology repeated: it is the same protocol applied to physics, where the two things that can fail silently are reading the question and the domain of a law.

  • Reading is trusted work, so it is done twice by two different programs (parse_a, parse_b) and the agreement is checked by a third node, equivalence. One reader plus one checker is not enough: a reader that mis-parses a sentence has nothing to disagree with. The confidence level rests on that node too: the ceiling is 2 only while a claim of equivalence states that the two roads produced the same scalars, so with it removed every answer of a full chain drops to SINGLE_PROVER while both readers keep working. Section 4's table shows it as the row without equivalence.
  • The applicability of a law is checked by domain_a (guards, the regime of the model) and the model itself by domain_b, because the compendium's whole point is that a correct law used outside the range it was stated for gives a wrong number with no sign of error.
  • Two nodes check the chain from outside: boundary recomputes the answer by another route and against the ontology of constants, verifier re-decides with Z3 every claim the chain has collected. They are deliberately not copies of each other.
  • adversary does not try to prove the answer right: it perturbs it on purpose and reports whether the perturbation left a trace anywhere downstream. It reads the fields the answer is made of and not only its number, so it asks separately about the dimension a conversion carries, the node a potential names and the regime number written beside it. A perturbation that leaves no trace is a hole in the chain, and the honest verdict then is UNKNOWN, not VERIFIED. In the current chain every perturbation of the catalogue leaves a trace, which is what the last row of section 9 states and tests/test_decision.py checks flavour by flavour.

Measured, not argued: tools/ablation.py runs the chain with one node removed at a time and with two nodes removed at a time, and inside each configuration it runs the whole fault catalogue of section 9 plus the pairs of faults that are only visible together. Three numbers are kept apart, because they mean different things. A silent error is a run in which the chain was confident about something the corpus line does not support: a VERIFIED or SINGLE_PROVER verdict whose answer is not the gold answer, a confident answer to a question the line says must be refused, or a confident verdict with no answer under it. A missed answer is the opposite mistake, refusing a question the line expects to be answered. An abstention is a run that closes at UNKNOWN with zero confidence: the chain says it cannot vouch for the number instead of claiming it. The eight core questions are one per family plus one impossible conversion, one off-language sentence, one guard-blocked network and one abstention, so each row shows a chain that still refuses and not only a chain that still answers. The last column counts runs whose status and answer are what the gold line expects, which is stricter than getting the number right: a right number carried by one road where two were expected scores there as a loss of confidence.

Configuration agents clean run, of 8: verified / one road / refused / guard / by design / no claim fault runs faults that fired silent errors missed answers runs that abstained verdict as the gold line expects
full eleven 11 4 / 0 / 2 / 1 / 1 / 0 128 98 0 0 30 98
without reader_a 10 0 / 4 / 2 / 1 / 1 / 0 112 83 0 0 21 46, and 45 more had the right number on one road
without reader_b 10 0 / 4 / 2 / 1 / 1 / 0 112 83 0 0 21 46, and 45 more had the right number on one road
without invoker 10 0 / 0 / 2 / 1 / 1 / 4 112 83 0 0 66 46
without boundary 10 4 / 0 / 3 / 1 / 0 / 0 112 88 0 0 28 70, and 14 changed state over an unchanged answer
without domain_a 10 4 / 0 / 2 / 1 / 1 / 0 120 91 0 0 26 80
without coverage 10 1 / 0 / 2 / 1 / 1 / 3 112 88 0 0 55 57
without adversary 10 4 / 0 / 2 / 1 / 1 / 0 120 90 0 0 24 96
without arbiter 10 4 / 0 / 2 / 1 / 1 / 0 120 90 0 0 30 90
without verifier 10 4 / 0 / 2 / 1 / 1 / 0 120 91 0 0 28 92
without domain_b 10 4 / 0 / 2 / 1 / 1 / 0 120 91 0 0 29 91
without equivalence 10 0 / 4 / 2 / 1 / 1 / 0 120 98 0 0 22 49, and 49 more had the right number on one road

A fault run is one of the eight questions under one catalogue entry that still names a node present in that configuration, so the count of runs follows the catalogue; the pairs add 32 runs to every row. The twelve rows are 1888 sessions, 1408 single-fault and 384 paired ones. The file results/ablation.json holds sixty seven rows and not twelve: the same sweep also removes two nodes at a time, and those fifty five rows are 7960 sessions more, so the whole experiment is 9848 sessions and the rows record 6825 s of measured time between them. That is why the tool splits by configuration with --parts 4 --part k and merges the parts afterwards. The two rows without coverage and without invoker finish in seconds while the others take two or three minutes each, because in those two rows no envelope ever reaches the mathematics.

What the table says. In the full chain and in each of the eleven chains missing one node, no run produced a confident wrong answer and none refused a question it should have answered: 0 silent errors and 0 missed answers over the 1408 single-fault runs and the 384 paired ones. What removing a node costs is confidence and reach. Without either reader the chain never again reaches VERIFIED: four of the eight clean questions fall to a single road, and in 45 of the 112 fault runs the number is still right on one road only, which is a loss of assurance and not a wrong physics. Without coverage or invoker the chain loses the arithmetic itself, and most of the row abstains rather than claims: 66 of the 112 fault runs close at UNKNOWN once the invoker is gone. Without boundary the cost is over-refusal: 14 runs change state over an answer that did not change, and the row ends at 70 verdicts as expected instead of 98. And without equivalence the number is still right everywhere while the confidence is not: no clean question and no fault run of that row reaches VERIFIED, because the ceiling of 2 needs a node that certified that the two roads agree (section 3), so 49 of its 120 fault runs sit on one road where the full chain would have carried them at 2.

The fifty five rows that remove two nodes at a time are where the sweep found something. Their 5760 single-fault runs and 1760 paired runs hold at 0 silent errors in fifty three of the fifty five configurations, and at 0 missed answers everywhere; 2482 of those runs abstain and 3608 end as the gold line expects. Two configurations break the record, and they break it in the same way: the arbiter does not only write the verdict, it restates two checks, answer_survives_recomputation (the one boundary owns) and epsilon_regime_holds (the one domain_a owns), and it is the last witness left when the owner of a check is gone.

  • arbiter and boundary together. With the recomputation gone and the copy of it gone, invoker:corrupt_answer has no witness at all, and all four core answer questions close at VERIFIED with confidence 2 over an answer that is not the gold one: 4 runs of that single-fault sweep and 4 more under its paired sweep. The adversary cannot help, because the recomputation it perturbs against is the one boundary writes, so its note becomes adversary_has_nothing_to_check.
  • arbiter and domain_a together. With the regime guard gone and the copy of it gone, the network question whose band says the model does not hold is answered instead of refused, at confidence 2: 10 runs, eight of them under a lie of any other node and one under the pair that corrupts both readers.

Fifty three rows stay clean, so the reading is not that the chain is weak but that two specific pairs of nodes are load bearing: 18 silent errors out of the 9312 fault runs of the sixty seven rows, against 0 in every row that removes a single node. tests/test_decision.py pins the boundary: the same fault on the full chain, or on either of the two chains missing one of those nodes, closes at UNKNOWN, and on the pair of them it closes at VERIFIED over a wrong answer.

One finding came out of running this, rather than into it, and it was closed in this version. The equivalence node used to be invisible to the sweep: with it removed every fault that was caught was still caught and its row was as green as the full one, because boundary recomputes the answer by its own route and the ceiling counted the readings that exist instead of asking for a node that proved they agree. The rule now asks for it, and the row above is what the rule costs: the same 98 faults fire there as fire in the full chain, and 49 fault runs end on one road rather than being certified at 2.

The other finding was not a fault's doing either: with the invoker removed every surviving check was green and the arbiter wrote VERIFIED over a dossier that held no answer at all, because the answer is a product of that node. That is now a rule of the ladder and not a property of one node - a chain with no answer under it closes at UNKNOWN with the reason no_answer_was_recorded, stated in section 3 - and the invoker row is what the rule costs: 4 of the 8 clean questions and 66 of the 112 fault runs now abstain. The 30 abstentions in the full row are not failures of the chain either: they are the chain declining to be confident, which is the only thing UNKNOWN is for.

5. Running

python tools/ask.py "convert 5 km/h to m/s"
python tools/ask.py "audit ( F * t ) = ( m * v )"
python tools/ask.py "pi period from mass, stiffness"
python tools/ask.py "potential node 1 circuit 3 resistors [ 1 2 10 ; 2 3 20 ] sources [ 1 1 ] size 1/10 frequency 50"
Command What it does
python tools/ask.py "<sentence>" starts the eleven node programs through the orchestrator and prints the checked verdict
python tools/ask.py --json "<sentence>" the same, as one machine readable object (dossier, referee records, answer)
python tools/ask.py --in-process "<sentence>" the eleven agents in one interpreter: no envelope transport, same code, same claims
python tools/ask.py --no-math "<sentence>" the mathematics dataset is not asked; the physics roads answer alone
python tools/ask.py --faults reader_a:corrupt_road "<sentence>" the same session with nodes instructed to misbehave (section 9)
python tools/ask.py --corpus problems/corpus.jsonl every question of the corpus, compared with its gold line
python tools/make_nodes.py regenerates the eleven node folders (grammar, ontology, seed) from the Python modules
python tools/ablation.py --level all --problems core the ablation experiment of section 4: --level single is the full chain plus the eleven missing one node, --level all adds the fifty five missing two
python -m pytest tests -q the test suite of the dataset

ask.py exits 0 for a verdict the chain is confident about, 2 for UNKNOWN, and 1 when a corpus run disagrees with its gold line. ablation.py writes results/ablation.json; with --parts N --part k the configurations are split across processes and joined back with --merge.

The exit code is not the answer: a REFUSED verdict exits 0, because refusing a question that has to be refused is a correct result.

6. Layout

topology.json            the eleven instances, the reversed chain, maxTurns, FIXED_PIPELINE
agents/physics_agent     the node program: reads an envelope, works its role, writes an envelope
nodes/<id>/              one folder per node: grammar.gf, ontology.smt2, seed_payload.json
lgphys/units.py          the seven bases, the unit table, the 39 quantity symbols
lgphys/terms.py          monomials, the dimensional matrix of a term
lgphys/tree.py           the canonical form of a parsed sentence, shared by both readers
lgphys/parse_a.py        road A, the token walker
lgphys/parse_b.py        road B, the reading that starts from the units
lgphys/linalg.py         exact rational elimination, Cramer, the residue of a system
lgphys/circuit.py        the Laplacian of a resistive network, its guards, its potentials
lgphys/pi.py             dimensional analysis: which monomial reaches the asked quantity
lgphys/laws.py           the guards of the laws in the fragment, the bands refused by design
lgphys/consts.py         the seven constants, their uncertainty, the ontology text they generate
lgphys/families.py       the four families: facts, delegate sentence, answer, invariants, perturbations
lgphys/smt.py            pinning, the claim of a node, the referee's own Z3 decision
lgphys/invoker.py        the only contact with the mathematics dataset: one process, one sentence, one JSON
lgphys/protocol.py       the envelope, the dossier marker, the containment wrapper of a node
lgphys/agents.py         the eleven steps, the ladder of verdicts, the one line verdict
lgphys/pipeline.py       the in-process session, and the verdict re-derived from the records
lgphys/faults.py         the catalogue of misbehaviour and the two ways a node can lie
lgphys/corpus.py         the corpus file and the comparison with the gold answer
problems/corpus.jsonl    eighteen questions, with their gold answers and their expected state
tests/                   134 tests: the pieces, the wiring, the ladder, the faults, the corpus
tools/                   ask.py, make_nodes.py, ablation.py, publish_dataset.py
results/                 what the ablation measured

The eleven node folders are generated, not written by hand: tools/make_nodes.py regenerates them from lgphys/consts.py and lgphys/families.py, so the ontology of every node and the grammar of the fragment cannot drift away from the Python that uses them. The seed of the session lives in nodes/arbiter/seed_payload.json.

7. Verification of the pieces

tests/test_physics_kernel.py pins the physics itself: the dimension of ohm and of J, that J and kg m^2 / s^2 are the same dimension, that 10 and 20 ohm in parallel carrying 1 A give exactly 20/3 V, that a network with a node touching nothing has no potentials, that the period of a mass on a spring is mass^(1/2) stiffness^(-1/2), that a dimension the set of quantities cannot reach is said so instead of being solved, and that both readers write the same canonical sentence.

tests/test_topology.py pins the wiring: eleven instances with one role each, the reversed chain, maxTurns equal to the number of edges, the seed carried by exactly one node, every node carrying the same constants block, and every claim form the same grammar.

tests/test_protocol.py runs the eleven nodes as eleven envelopes, the way the orchestrator does: the dossier survives, a node echoes the turn it was handed, a node that raises an exception hands a claim that is decidable ((assert true), sat) and leaves a note in the dossier instead of stopping the session, and the eleven claims of a real chain each come out unsat or sat exactly as the ontology of their own node says.

tests/test_decision.py pins the ladder end to end: two roads and verified arithmetic give 2; removing reader_b keeps the same number and drops the confidence to 1, and so does removing equivalence, whose claim is what certifies that the two roads agree; a burden of the world gives a confident refusal while a disagreement gives zero; a node that claims a green check Z3 rejects is caught by the referee; a lie with nothing to hide stays dormant; a chain that lost the node producing the answer refuses to certify the checks that survived it; the confidence shown is never above 2 and never 3; every perturbation of the catalogue is seen in the field it touches; and the pair of nodes that removes the last witness of a check is the case where the chain goes confident about a result the gold line does not support, while a chain missing only one of that pair does not.

tests/test_faults.py runs every entry of the catalogue over two baseline questions and asserts the contract of section 9: a fault with nothing to take advantage of leaves the verdict exactly as it was, and a fault that bites costs the confidence. tests/test_corpus.py runs the eighteen corpus lines and compares them with their gold. tests/test_orchestrator_e2e.py starts a real session with real node processes and reads back what the orchestrator itself recorded, including its Z3 check of each claim.

tests/test_isolation.py is the one that keeps the collaboration honest: no module of lgphys and no tool of this folder imports anything from lgmath, mentions lgmath in its text, uses float, round or a decimal literal, or reaches outside the folder with ../.

8. The collaboration with the mathematics dataset, and how to place the two

The physics dataset does not do its own arithmetic when the answer depends on arithmetic, and it does not embed the mathematics dataset either. lgphys/invoker.py starts it as a separate process:

python <math>/tools/solve.py --json "linsolve [[1, 1], [0, -2]] [0, 1]"

and reads back {final, referee, records, turns}. The sentence it sends is not invented by the node that asks: lgphys/families.py writes it from the model (a conversion becomes an evaluate, a dimensional analysis becomes a linsolve on the dimensional matrix, a network becomes a linsolve on the reduced Laplacian), and coverage is the node that checks the sentence still mentions every token of the question.

Variable Meaning
LGPHYS_MATH_ROOT where the mathematics folder is; by default the folder math standing next to
this one, which on the hub means a clone of tailot/lingologos-math placed beside a clone of this
dataset
LGPHYS_MATH_BACKEND subprocess (the default) or none to run the physics roads alone

Two rules hold this together. The physics may only ask arithmetic that it has already accepted as a question: a refusal never forms a delegate. And the confidence shown is capped by the answer that came back: VERIFIED from mathematics is what allows VERIFIED here, anything else - UNKNOWN, no process, a refusal from the mathematics side - brings the shown confidence to 0 while still printing what the physics roads computed, because the reader is owed the number and the reason it is not vouched for.

One orchestrated session starts one mathematics process for the node that asks, and none for a question that physics refused. Nothing in this folder imports a module of the other, and the two folders can be installed apart: LGPHYS_MATH_ROOT is the only link. On the hub that separation is the normal case: the two datasets are two repositories, so either clone tailot/lingologos-math next to this one or point LGPHYS_MATH_ROOT at wherever that folder stands, and a third of the corpus then stops abstaining on the delegation and reports the confidence the mathematics side actually carried. Neither side installs anything of the other.

9. Making a node misbehave

lgphys/faults.py is a catalogue of the ways a node can go wrong, read from the environment (--faults on the command line, LGPHYS_FAULTS for the node processes) so that a session does not need to be rebuilt to be attacked. A fault is one of two kinds: a lie, where the node reports green checks that its own claim does not support, and a corruption, where the node hands a wrong number to the next one while its own claim stays honest.

Node Faults
reader_a, reader_b lie, corrupt_road
domain_a, domain_b, equivalence lie
coverage lie, corrupt_delegate
invoker lie, corrupt_answer
boundary lie, skip_recompute
verifier lie
adversary rubber_stamp
arbiter force_accept

The experiment of tests/test_faults.py states what each of them is allowed to achieve. A lie is dormant when the node has no failing check to hide - on a healthy session a lying reader fires nothing and changes nothing - and where it does bite the referee is the one that notices: the claim of the node and the ontology of that node disagree, and the verdict becomes UNKNOWN with confidence 0. A corruption is caught by the nodes that are there to disagree: a reader that hands a wrong number breaks agree_read_b, a delegate rewritten on its way to the arithmetic breaks physics_and_mathematics_agree, an answer rewritten by the node that brought it back breaks answer_recomputed.

Two rows are honest exceptions rather than successes. An arbiter instructed to accept an answer the evidence already supports is not a fault against that answer, and where the evidence refuses it, its report is discounted instead of believed. And a boundary that skips its recomputation leaves no trace at all while everything else is right: it only becomes visible when a second node is also wrong, which is why ablation.py runs the pairs of MULTI and not only single faults. Measured numbers for all of this are in results/ablation.json and in section 4's experiment below.

One kind of check is written the other way round from all the others, and it is the one a reader is most likely to misread: the adversary reports a perturbation check as green when its own perturbation left no trace, because that is the fault case. So in a verified answer the notes the_perturbation_was_visible; adversary_failed_perturbation_visible are the healthy lines, and a silent adversary is the alarming one. The note names the check that saw the mistake, so the line differs with the field that was touched: adversary_failed_dimension_field_perturbation_visible when a conversion had its dimension field rewritten, adversary_failed_node_field_perturbation_visible when a potential named another node than the one asked for, adversary_failed_guard_field_perturbation_visible when the regime number of a network was moved under it.

Measured on the pairs, from the same file: the four pairs of MULTI ran against the eight questions in every configuration, 384 runs in the twelve rows of section 4 and 2144 runs over all sixty seven rows. Not one of those 384 produced a silent error or a missed answer; among the two-node rows 5 of the 1760 paired runs do, in the two configurations section 4 names. In the full chain each pair fired in 8 of 8 runs; the pair invoker:corrupt_answer with boundary:skip_recompute left 4 of 8 runs as the gold line expects and the other 4 abstaining, which is the measured form of the sentence above - a skipped redundancy is seen only when the thing it covered is wrong, and the chain then stops claiming rather than claiming wrongly. The pair that corrupts both readers in the same way is invisible to the readers themselves and still ends as expected in 8 of 8 runs of the full chain, while with one of the two readers gone 4 of those 8 fall to a single road. Measured on the single faults: three of the lie entries - boundary, equivalence, invoker - fire in none of the eight core questions, because on those runs the node has nothing to hide, and the other six fire in 7 of 8; a fault that fires nowhere is reported as such rather than counted as a defence.

10. Known limits

  • The fragment is small on purpose: four families, exact rationals only, no calculus, no fields, no geometry. A question outside it is refused, which is a result and not a failure, but the dataset does not answer physics beyond those four families.
  • The guard of the resistor network is a declared numerical threshold, size * frequency / c < 1/10, not the symbol << of the compendium: a strict infinitesimal is not decidable in linear real arithmetic, so the quasi-static limit is written as a convention and stated as one. The monomial of the guard is derived by dimensional analysis on road B and compared with the table on road A, so the convention itself is checked and not only asserted.
  • The uncertainty of a measured constant is carried as an interval in the ontology, so a claim about G or about the fine structure constant is decided over an interval rather than over a false exact value. boundary reports constant_table_matches_ontology and says so if the table and the ontology of its node disagree.
  • The adversary probes the fields of the answer it is handed, not the history that produced them: the number, the dimension a conversion carries, the node a potential names, the regime number written beside it. Every perturbation in the catalogue is seen in the field it touches, which since this version includes the three that used to slip through - a conversion whose dimension field was rewritten, a potential asking for another node, a network with its regime number dropped. What the probe cannot see is a change written so that the fields still agree: the dimension of a conversion is compared as one number, a sum with base 100 per base, so two exponent changes chosen to cancel each other would pass. The catalogue holds no such perturbation, and a chain that was fooled by one would report it as a green check and answer UNKNOWN rather than claim the number.
  • boundary:skip_recompute is not detectable on its own, by construction: it removes a redundancy, and a redundancy is only visible when the thing it redundantly checks is wrong.
  • Two nodes removed at a time is where the sweep found the pairs that hold the chain up. With arbiter and boundary gone the answer corrupted by the invoker has no witness left, and with arbiter and domain_a gone the regime guard has none; in both cases the chain closes at VERIFIED with confidence 2 over a result the gold line does not support, 18 runs out of the 9312 fault runs of the sixty seven rows. Removing only one of those nodes stays clean, because the arbiter restates the check the other one owns. Section 4 states the two pairs and their counts, and tests/test_decision.py pins that boundary rather than claiming it away.
  • The session is a pipeline, not a debate: eleven nodes each work once. A node that abstains does not get asked again, which keeps the turn count and the assurance meaning fixed.
  • The gold answers in problems/corpus.jsonl were written by hand from the physics - the definitions of the units, the seven base dimensions, the current divider - and not from this code. That is the whole point of the corpus: it can be wrong about the code, and so far it has not been.

11. The corpus file, the topology file, and the measured results

problems/corpus.jsonl holds 18 questions, one JSON object per line, written by hand. It is a benchmark for the topology: there is no prompt, no response pair and nothing to fine tune on.

Field Type Meaning
id string unique; the prefix names the family (c conversion, a audit, p dimensional analysis, v network, x outside the fragment)
kind string convert, audit, pi, potential, or none for a sentence the fragment does not cover
text string the question in the language of section 1, between 15 and 107 characters
expect string the verdict this topology has to reach: VERIFIED (12 lines), REFUSED (4), GUARD_BLOCKED (1), ABSTAINED (1)
expected_math string what the delegated mathematics has to return: VERIFIED (8 lines) or NOT_ASKED (10 lines, including every refusal)
gold object the answer to compare with, in the shape of its family, or null for the two off-language lines

The shape of gold is what lgphys/corpus.py compares against, family by family: a value, a unit and the seven exponents for a conversion; an exponent vector and its dimensional residue for an audit; the names of the quantities and their exponents for a dimensional analysis; the node and the value for a potential. tools/ask.py --corpus problems/corpus.jsonl walks the file and prints one line per question ending with {"correct": 18}; tests/test_corpus.py asserts the same comparison.

topology.json is the declaration of the session: the eleven instances with their roles, the reversed chain that carries the seed, maxTurns equal to the number of edges, and FIXED_PIPELINE as the termination condition. It is the file the orchestrator reads, and tests/test_topology.py pins it.

results/ablation.json is the measured answer to section 4, not a summary of it: 67 configurations of the topology (the full chain, eleven missing one node, fifty five missing two), each holding the tally of a clean sweep over the eight core questions, a sweep of the fault catalogue, and a sweep of the pairs of faults that are only visible together. Each sweep records the status of every run, the reason notes the chain wrote, and how the run compares with the gold line. tools/ablation.py writes it, and the sections 4 and 9 numbers are read out of it.

Load the corpus with the datasets library, or with one json.loads per line, which needs no dependency:

from datasets import load_dataset
corpus = load_dataset("tailot/lingologos-physics", "corpus", split="train")
print(corpus[0])

12. Rights

No license is declared for this dataset, its corpus, or its code: reuse is not granted by this page. The eighteen questions and their gold answers, the eleven node definitions, the four sentence families, the guards and the bands refused by design, the fault catalogue and the Python sources were written by hand as part of the LingoLOGOS project, and the laws they guard follow a compendium of formal physical laws and their epistemic limits written by hand in Italian for that project; the English summary of those bands in lgphys/laws.py is the working form used here. Ask before redistributing or building on them, and expect the answer to be yes for academic work with attribution. Z3 is a separate product with its own license and is not redistributed here; z3-solver is only named as a dependency in requirements.txt.

13. Citation

@misc{lingologos_physics,
  title  = {LingoLOGOS physics topology: eleven agents, a verified answer or an explicit UNKNOWN},
  author = {LingoLOGOS project},
  year   = {2026},
  url    = {https://huggingface.co/datasets/tailot/lingologos-physics},
  note   = {bundle of the physics folder of the LingoLOGOS repository: 18 questions with their gold
            answers, eleven node definitions with their ontologies, four sentence families, decision
            rule, fault catalogue of 16 entries, ablation over 67 configurations of the topology, and
            the collaboration with the mathematics dataset as a separate process}
}
Downloads last month
45