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 |
- 1. The language
- 2. The eleven nodes
- 3. What the verdict means, and how much confidence goes with it
- 4. Why eleven nodes, and what each one is for
- 5. Running
- 6. Layout
- 7. Verification of the pieces
- 8. The collaboration with the mathematics dataset, and how to place the two
- 9. Making a node misbehave
- 10. Known limits
- 11. The corpus file, the topology file, and the measured results
- 12. Rights
- 13. Citation
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 ofequivalencestates that the two roads produced the same scalars, so with it removed every answer of a full chain drops toSINGLE_PROVERwhile both readers keep working. Section 4's table shows it as the rowwithout equivalence. - The applicability of a law is checked by
domain_a(guards, the regime of the model) and the model itself bydomain_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:
boundaryrecomputes the answer by another route and against the ontology of constants,verifierre-decides with Z3 every claim the chain has collected. They are deliberately not copies of each other. adversarydoes 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 andtests/test_decision.pychecks 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.
arbiterandboundarytogether. With the recomputation gone and the copy of it gone,invoker:corrupt_answerhas no witness at all, and all four core answer questions close atVERIFIEDwith 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 oneboundarywrites, so its note becomesadversary_has_nothing_to_check.arbiteranddomain_atogether. 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 alieof 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
Gor about the fine structure constant is decided over an interval rather than over a false exact value.boundaryreportsconstant_table_matches_ontologyand 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_recomputeis 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
arbiterandboundarygone the answer corrupted by theinvokerhas no witness left, and witharbiteranddomain_agone the regime guard has none; in both cases the chain closes atVERIFIEDwith 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 thearbiterrestates the check the other one owns. Section 4 states the two pairs and their counts, andtests/test_decision.pypins 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.jsonlwere 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