Datasets:
id stringlengths 3 3 | text stringlengths 31 316 | kind stringlengths 3 11 | expect stringclasses 3
values | expected_math stringclasses 2
values | gold unknown |
|---|---|---|---|---|---|
s01 | classify frame nodes [ 1 0 0 ; 2 2 0 ; 3 4 0 ] members [ 1 1 2 ; 2 2 3 ] props [ 1 210000000 1/5 2/1875 ; 2 210000000 1/5 2/1875 ] supports [ 1 pin ; 3 roller 0 1 ] loads [ member 1 udl 0 -15 ; member 2 udl 0 -15 ] | classify | VERIFIED | NOT_ASKED | {
"redundancy": 0,
"mechanisms": 0
} |
s02 | classify frame nodes [ 1 0 0 ; 2 2 0 ; 3 4 0 ; 4 6 0 ] members [ 1 1 2 ; 2 2 3 ; 3 3 4 ] props [ 1 210000000 1/5 2/1875 ; 2 210000000 1/5 2/1875 ; 3 210000000 1/5 2/1875 ] supports [ 1 pin ; 2 roller 0 1 ; 4 roller 0 1 ] loads [ member 3 point 1 0 -10 ] hinges [ 3 ] | classify | VERIFIED | NOT_ASKED | {
"redundancy": 0,
"mechanisms": 0
} |
s03 | classify frame nodes [ 1 0 0 ; 2 0 3 ; 3 4 3 ; 4 4 0 ] members [ 1 1 2 ; 2 2 3 ; 3 3 4 ] props [ 1 210000000 1/5 2/1875 ; 2 210000000 1/5 2/1875 ; 3 210000000 1/5 2/1875 ] supports [ 1 fixed ; 4 fixed ] loads [ member 2 udl 0 -15 ] | classify | VERIFIED | NOT_ASKED | {
"redundancy": 3,
"mechanisms": 0
} |
s04 | reactions frame nodes [ 1 0 0 ; 2 2 0 ; 3 4 0 ] members [ 1 1 2 ; 2 2 3 ] props [ 1 210000000 1/5 2/1875 ; 2 210000000 1/5 2/1875 ] supports [ 1 pin ; 3 roller 0 1 ] loads [ member 1 udl 0 -15 ; member 2 udl 0 -15 ] | reactions | VERIFIED | NOT_ASKED | {
"reactions": {
"1_first": "0",
"1_second": "30",
"3_second": "30"
}
} |
s05 | reactions frame nodes [ 1 0 0 ; 2 4 0 ] members [ 1 1 2 ] props [ 1 210000000 1/5 2/1875 ] supports [ 1 fixed ; 2 roller 0 1 ] loads [ member 1 udl 0 -15 ] | reactions | VERIFIED | NOT_ASKED | {
"reactions": {
"1_first": "0",
"1_rotation": "30",
"1_second": "75/2",
"2_second": "45/2"
}
} |
s06 | reactions frame nodes [ 1 0 0 ; 2 2 0 ; 3 4 0 ] members [ 1 1 2 ; 2 2 3 ] props [ 1 210000000 1/5 2/1875 ; 2 210000000 1/5 2/1875 ] supports [ 1 fixed ; 3 fixed ] loads [ member 1 udl 0 -15 ; member 2 udl 0 -15 ] | reactions | VERIFIED | NOT_ASKED | {
"reactions": {
"1_second": "30",
"1_rotation": "20",
"3_second": "30",
"3_rotation": "-20"
}
} |
s07 | reactions frame nodes [ 1 0 0 ; 2 2 0 ] members [ 1 1 2 ] props [ 1 210000000 1/5 2/1875 ] supports [ 1 fixed ] loads [ node 2 force 0 -10 ] | reactions | VERIFIED | NOT_ASKED | {
"reactions": {
"1_first": "0",
"1_second": "10",
"1_rotation": "20"
}
} |
s08 | reactions frame nodes [ 1 0 0 ; 2 2 0 ; 3 4 0 ; 4 6 0 ] members [ 1 1 2 ; 2 2 3 ; 3 3 4 ] props [ 1 210000000 1/5 2/1875 ; 2 210000000 1/5 2/1875 ; 3 210000000 1/5 2/1875 ] supports [ 1 pin ; 2 roller 0 1 ; 4 roller 0 1 ] loads [ member 3 point 1 0 -10 ] hinges [ 3 ] | reactions | VERIFIED | NOT_ASKED | {
"reactions": {
"1_first": "0",
"1_second": "-5",
"2_second": "10",
"4_second": "5"
}
} |
s09 | reactions frame nodes [ 1 0 0 ; 2 3 4 ] members [ 1 1 2 ] props [ 1 210000000 1/5 2/1875 ] supports [ 1 pin ; 2 roller -4/5 3/5 ] loads [ member 1 udl 0 -15 ] | reactions | VERIFIED | NOT_ASKED | {
"reactions": {
"1_first": "18",
"1_second": "123/2",
"2_second": "45/2"
}
} |
s10 | reactions frame nodes [ 1 0 0 ; 2 0 3 ; 3 4 3 ; 4 4 0 ] members [ 1 1 2 ; 2 2 3 ; 3 3 4 ] props [ 1 210000000 1/5 2/1875 ; 2 210000000 1/5 2/1875 ; 3 210000000 1/5 2/1875 ] supports [ 1 fixed ; 4 fixed ] loads [ member 2 udl 0 -15 ] | reactions | VERIFIED | NOT_ASKED | {
"reactions": {
"1_second": "30",
"4_second": "30"
}
} |
s11 | cut member 1 at 1 frame nodes [ 1 0 0 ; 2 2 0 ; 3 4 0 ] members [ 1 1 2 ; 2 2 3 ] props [ 1 210000000 1/5 2/1875 ; 2 210000000 1/5 2/1875 ] supports [ 1 pin ; 3 roller 0 1 ] loads [ member 1 udl 0 -15 ; member 2 udl 0 -15 ] | cut | VERIFIED | NOT_ASKED | {
"normal": "0",
"shear": "15",
"moment": "45/2"
} |
s12 | peak moment frame nodes [ 1 0 0 ; 2 2 0 ; 3 4 0 ] members [ 1 1 2 ; 2 2 3 ] props [ 1 210000000 1/5 2/1875 ; 2 210000000 1/5 2/1875 ] supports [ 1 pin ; 3 roller 0 1 ] loads [ member 1 udl 0 -15 ; member 2 udl 0 -15 ] | peak | VERIFIED | NOT_ASKED | {
"value": "30",
"place": "2"
} |
s13 | peak moment frame nodes [ 1 0 0 ; 2 2 0 ; 3 4 0 ; 4 6 0 ] members [ 1 1 2 ; 2 2 3 ; 3 3 4 ] props [ 1 210000000 1/5 2/1875 ; 2 210000000 1/5 2/1875 ; 3 210000000 1/5 2/1875 ] supports [ 1 pin ; 2 roller 0 1 ; 4 roller 0 1 ] loads [ member 3 point 1 0 -10 ] hinges [ 3 ] | peak | VERIFIED | NOT_ASKED | {
"value": "10",
"place": "2"
} |
s14 | deflect node 2 vertical frame nodes [ 1 0 0 ; 2 2 0 ; 3 4 0 ] members [ 1 1 2 ; 2 2 3 ] props [ 1 210000000 1/5 2/1875 ; 2 210000000 1/5 2/1875 ] supports [ 1 pin ; 3 roller 0 1 ] loads [ member 1 udl 0 -15 ; member 2 udl 0 -15 ] | deflect | VERIFIED | VERIFIED | {
"value": "-1/4480"
} |
s15 | deflect node 2 vertical frame nodes [ 1 0 0 ; 2 2 0 ] members [ 1 1 2 ] props [ 1 210000000 1/5 2/1875 ] supports [ 1 fixed ] loads [ node 2 force 0 -10 ] | deflect | VERIFIED | VERIFIED | {
"value": "-1/8400"
} |
s16 | deflect node 2 rotation frame nodes [ 1 0 0 ; 2 2 0 ] members [ 1 1 2 ] props [ 1 210000000 1/5 2/1875 ] supports [ 1 fixed ] loads [ node 2 force 0 -10 ] | deflect | VERIFIED | VERIFIED | {
"value": "-1/11200"
} |
s17 | properties section rect 1/5 2/5 | properties | VERIFIED | VERIFIED | {
"area": "2/25",
"centroid": "0",
"inertia": "2/1875",
"modulus": "2/375",
"statical": "1/250"
} |
s18 | properties section shapes [ rect 1 1/2 0 ; rect 1/2 1/2 1/2 ; rect 1 1/2 1 ] | properties | VERIFIED | VERIFIED | {
"area": "5/4",
"centroid": "1/2",
"inertia": "53/192",
"modulus": "53/144",
"statical": "17/64"
} |
s19 | verify bending member 1 at 2 section rect 1/5 2/5 limit 16000 frame nodes [ 1 0 0 ; 2 2 0 ; 3 4 0 ] members [ 1 1 2 ; 2 2 3 ] props [ 1 210000000 1/5 2/1875 ; 2 210000000 1/5 2/1875 ] supports [ 1 pin ; 3 roller 0 1 ] loads [ member 1 udl 0 -15 ; member 2 udl 0 -15 ] | verify | VERIFIED | VERIFIED | {
"sigma": "5625",
"holds": true
} |
s20 | verify shear member 1 at 0 section rect 1/5 2/5 limit 1200 frame nodes [ 1 0 0 ; 2 2 0 ; 3 4 0 ] members [ 1 1 2 ; 2 2 3 ] props [ 1 210000000 1/5 2/1875 ; 2 210000000 1/5 2/1875 ] supports [ 1 pin ; 3 roller 0 1 ] loads [ member 1 udl 0 -15 ; member 2 udl 0 -15 ] | verify | VERIFIED | VERIFIED | {
"tau": "1125/2",
"holds": true
} |
s21 | verify vonmises member 1 at 1 section rect 1/5 2/5 limit 256000000 frame nodes [ 1 0 0 ; 2 2 0 ; 3 4 0 ] members [ 1 1 2 ; 2 2 3 ] props [ 1 210000000 1/5 2/1875 ; 2 210000000 1/5 2/1875 ] supports [ 1 pin ; 3 roller 0 1 ] loads [ member 1 udl 0 -15 ; member 2 udl 0 -15 ] | verify | VERIFIED | VERIFIED | {
"sigma": "16875/4",
"tau": "1125/4",
"holds": true
} |
s22 | euler ends pinned pinned length 21/10 modulus 210000000 section rect 1/10 1/10 | euler | VERIFIED | VERIFIED | {
"coefficient": "25000/63",
"power": 2,
"lambda_squared": "5292"
} |
s23 | euler ends fixed pinned length 21/10 modulus 210000000 section rect 1/10 1/10 | euler | VERIFIED | VERIFIED | {
"coefficient": "50000/63",
"power": 2,
"lambda_squared": "2646"
} |
s24 | cut member 1 at 2 frame nodes [ 1 0 0 ; 2 2 0 ; 3 4 0 ] members [ 1 1 2 ; 2 2 3 ] props [ 1 210000000 1/5 2/1875 ; 2 210000000 1/5 2/1875 ] supports [ 1 pin ; 3 roller 0 1 ] loads [ member 1 udl 0 -15 ; member 2 udl 0 -15 ] | cut | GUARD_BLOCKED | NOT_ASKED | null |
s25 | cut member 3 at 1 frame nodes [ 1 0 0 ; 2 2 0 ; 3 4 0 ; 4 6 0 ] members [ 1 1 2 ; 2 2 3 ; 3 3 4 ] props [ 1 210000000 1/5 2/1875 ; 2 210000000 1/5 2/1875 ; 3 210000000 1/5 2/1875 ] supports [ 1 pin ; 2 roller 0 1 ; 4 roller 0 1 ] loads [ member 3 point 1 0 -10 ] hinges [ 3 ] | cut | GUARD_BLOCKED | NOT_ASKED | null |
s26 | deflect member 1 at 1 vertical frame nodes [ 1 0 0 ; 2 2 0 ; 3 4 0 ] members [ 1 1 2 ; 2 2 3 ] props [ 1 210000000 1/5 2/1875 ; 2 210000000 1/5 2/1875 ] supports [ 1 pin ; 3 roller 0 1 ] loads [ member 1 udl 0 -15 ; member 2 udl 0 -15 ] | deflect | GUARD_BLOCKED | NOT_ASKED | null |
s27 | verify shear member 3 at 1 section rect 1/5 2/5 limit 1200 frame nodes [ 1 0 0 ; 2 2 0 ; 3 4 0 ; 4 6 0 ] members [ 1 1 2 ; 2 2 3 ; 3 3 4 ] props [ 1 210000000 1/5 2/1875 ; 2 210000000 1/5 2/1875 ; 3 210000000 1/5 2/1875 ] supports [ 1 pin ; 2 roller 0 1 ; 4 roller 0 1 ] loads [ member 3 point 1 0 -10 ] hinges [ 3 ] | verify | GUARD_BLOCKED | VERIFIED | null |
s28 | calculate the wind pressure on the third floor of the tower | outside | REFUSED | NOT_ASKED | null |
s29 | reactions frame nodes [ 1 0 0 ; 2 2 0 ; 3 4 0 ] members [ 1 1 2 ; 2 2 3 ] props [ 1 210000000 1/5 2/1875 ] supports [ 1 pin ; 3 roller 0 1 ] loads [ member 1 udl 0 -15 ; member 2 udl 0 -15 ] | incomplete | REFUSED | NOT_ASKED | null |
s30 | reactions frame nodes [ 1 0 0 ; 2 4 0 ] members [ 1 1 2 ] props [ 1 210000000 1/5 2/1875 ] supports [ 1 roller 0 1 ; 2 roller 0 1 ] loads [ member 1 udl 0 -15 ] | labile | REFUSED | NOT_ASKED | null |
s31 | reactions frame nodes [ 1 0 0 ; 2 0 3 ; 3 4 3 ; 4 4 0 ] members [ 1 1 2 ; 2 2 3 ; 3 3 4 ; 4 4 1 ; 5 2 4 ] props [ 1 210000000 1/5 2/1875 ; 2 210000000 1/5 2/1875 ; 3 210000000 1/5 2/1875 ; 4 210000000 1/5 2/1875 ; 5 210000000 1/5 2/1875 ] supports [ 1 fixed ; 4 fixed ] loads [ member 2 udl 0 -15 ] | hyperstatic | REFUSED | NOT_ASKED | null |
- 1. The language
- 2. The thirteen nodes
- 3. What the verdict means, and how much confidence goes with it
- 4. Why thirteen 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 structures topology
A thirteen agent topology that answers questions of structural engineering written in a small controlled language, and answers either with a verified number, or with an explicit refusal of the question, or with UNKNOWN. It never quotes a reaction, an internal force, a displacement or a stress that two different methods of structural analysis have not both produced, in exact rationals, from the same reading of the same frame.
python tools/ask.py "reactions frame nodes [ 1 0 0 ; 2 2 0 ; 3 4 0 ] members [ 1 1 2 ; 2 2 3 ] props
[ 1 210000000 1/5 2/1875 ; 2 210000000 1/5 2/1875 ] supports [ 1 pin ; 3 roller 0 1 ] loads
[ member 1 udl 0 -15 ; member 2 udl 0 -15 ]"
Question as read : reactions, 2 road(s)
Status : VERIFIED (assurance level 2 of 2)
Answer : reaction at 1 first is 0; reaction at 1 second is 30; reaction at 3 second is 30
Asked of mathematics : nothing this question can hand over [NOT_ASKED]
Orchestrator Z3 check : 13 of 13 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 89 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 two
structural roads still answer, still agree and still refuse; only the eleven questions of the corpus that
hand their arithmetic over lose their witness, and their verdict becomes UNKNOWN (section 8 says how to
place the two folders so that the delegation is vouched for).
1. The language
| Family | Sentence | The answer is |
|---|---|---|
| classification | classify <frame> |
the structure named by its kind, its constraints and its degree of redundancy |
| reactions | reactions <frame> |
the components taken at each support: 1_first, 1_second, 1_rotation |
| internal forces | cut member <m> at <p> <frame> |
normal, shear and bending moment at that abscissa, as one number |
| envelope | peak moment|shear|axial <frame> |
the largest of that quantity, and the member and abscissa where it sits |
| displacement | deflect node <n> vertical|horizontal|rotation <frame> |
the displacement of that node, exact rational |
| section properties | properties section rect <b> <h>, properties section shapes [ <b> <h> <c> ; ... ] |
area, centroid, moment of inertia, elastic modulus, statical moment |
| verification | verify bending|shear|vonmises member <m> at <p> section <s> limit <q> <frame> |
the stress, the limit asked for, and whether the section carries it |
| stability | euler ends <e1> <e2> length <l> modulus <E> section <s> |
the critical load as a coefficient times pi^2, and the slenderness it came from |
A frame is one block, and the same block is repeated inside every question that needs a structure:
frame nodes [ <id> <x> <y> ; ... ]
members [ <id> <from> <to> ; ... ]
props [ <id> <E> <A> <I> ; ... ]
supports [ <id> pin | <id> roller <x> <y> | <id> fixed ]
loads [ member <id> udl <a> <b> | member <id> point <p> <x> <y>
| member <id> couple <p> <x> <y> | node <id> force <x> <y> ]
[ hinges [ <member ids> ] ]
Fragment. Everything outside it ends in a refusal with a reason, never in a guess. The frame is
planar, with at most five nodes and eight members, a section constant along each member, and direction
cosines that are exact rationals: a bar at 30 degrees is refused because its cosine is not a rational,
and the refusal says so. The degree of static redundancy is at most three, which is what the force
method of statics.py solves by compatibility; a frame with redundancy nine is refused by name rather
than solved approximately. Loads are of degree zero: no time, no moving load, no moving truck, no
spectrum. A section is one rectangle or a pile of rectangles given by width, height and centre; there is
no I profile, no circle, no welded plate with a weld. A displacement is asked at a node, because at a
node the two roads of section 2 both exist; a point along a member has only the Mohr road, and the
chain says that instead of answering on one road. A cut exactly at a support, at a hinge or under a
concentrated action is blocked, because the diagram jumps there.
Numbers are exact ratios: 2, -15, 1/5, 21/10, and a decimal point in a sentence of this language
is a mistake, not a rounding. No module of this dataset has ever seen a floating point number:
tests/test_isolation.py reads the syntax trees of every module and fails on float, on round, and on
an import of math. What cannot be written as a ratio is carried as it is: the critical load of Euler
comes back as the pair 25000/63 and pi^2, and a resultant along a 3-4-5 bar as a rational
combination of a square root bracket. The units are length in metre, force in kilo newton, mass in
tonne, and the derived names of lgstruc/units.py; an audit of a formula repeats it in the second unit
system, and the check that comes out of it is a check about dimensions, not about the number.
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, lgstruc/parse_a.py (road A, which reads the head of the question first and then the numbers)
and lgstruc/parse_b.py (road B, which reads the declaration first and takes each number in its place),
and a question is only answered when both write the same canonical sentence.
2. The thirteen nodes
| Node | Role | What it does | What it signs its name to |
|---|---|---|---|
reader_a |
read | reads the sentence along road A, head of the question first | lg_read_carries_<k>, one per number it read |
reader_b |
read | reads the same sentence again along road B, declaration first | the same echoes, from its own reading |
axioms_a |
model | states the hypotheses the answer rests on: small displacements, linear elastic material, slender bar (Bernoulli-Navier) | where a road may be taken: cut_before_the_far_end, cut_after_the_near_end, cut_not_on_a_load, same_shear_on_both_roads |
axioms_b |
regime | states the regime each law is valid in: the Saint-Venant distance for Jourawski, the slenderness for Euler, the reference length | the_column_is_slender_enough on a column, the_point_is_a_node_of_the_mesh on a displacement |
convention_a |
signs | writes the sign convention down and checks that every member carries a rotation | member_<id>_direction_cosines_are_a_rotation, the_sign_convention_is_written_down |
convention_b |
units | repeats each law in the second unit system and audits the dimensions | the_unit_of_euler_survives_the_second_system, and the rotations again |
equivalence |
agree | checks that the two methods reached the same scalars of the answer | agree_1_first, agree_normal, agree_two_forms_of_the_critical_load: one per scalar |
coverage |
shape | echoes every number of the question, and writes the sentences to be handed to mathematics | token_<n> per number, tokens_declared |
solver_a |
answer | answers with the direct stiffness method (twelve by twelve member matrices assembled in rationals) and asks mathematics the arithmetic it owes | balance_abscissa, balance_ordinate, balance_couple, and the family checks of the model |
solver_b |
answer | answers again with statics: the force method, the redundants from compatibility, Mohr for the displacements, without looking at solver_a |
solver_b_repeats_forces, solver_b_repeats_stiffness, and the same family checks |
verifier |
verify | re-decides the conjunction of every bundle the chain closed before it, and invents no check of its own | all of them: 20 on a reaction question, 23 on a question of Euler, 36 on a displacement |
adversary |
attack | moves the answer by one and asks whether anything downstream notices | the_answer_moved_by_one_is_caught, plus the agreement of the two roads |
arbiter |
final | applies the decision rule to the records, and writes the one line the caller reads | the scalar agreements, the three balances, agree_stiffness |
The thirteen node folders are generated, not written by hand: tools/make_nodes.py regenerates
grammar.gf, ontology.smt2 and seed_payload.json of every node from lgstruc/families.py and the
roster of lgstruc/agents.py, so a claim form cannot drift away from the Python that produces it. The
node program is agents/struc_agent: it reads one envelope, decodes the notebook carried after the
marker @@DOSSIER@@, runs the one role that topology assigns to it, and writes an envelope back. A node
that raises an exception does not stop the session: it hands a claim that is decidable
((assert true), sat) and leaves a note in the notebook naming the exception, and the verdict of the
session then says what that note cost.
topology.json wires the thirteen instances in the order of the table, as a chain that the routing
matrix reads backwards: the last instance points at the first, maxTurns equals the number of edges
(13), the termination condition is FIXED_PIPELINE, and the seed of the session is carried by exactly
one instance, the one the first arcata points at. Each envelope carries sender, recipient, turn,
volatileState.internalTimeTick and a payload of three parts: the sentence in natural language, the
abstract syntax tree, and the SMT claim of the node. The claim is what makes the orchestrator a witness
and not a postman: it declares the numbers the node pinned as SMT constants, asserts the conditions it
wants them to satisfy together with the negation of what it reported, and the orchestrator runs its own
Z3 over that text and against the ontology of that node. A claim whose Z3 answer is not the one the node
reported is a claim the node cannot make: the reason recorded is
claims the refree did not confirm: <node>.
Nine of the thirteen nodes write a state into the notebook, and four do not: axioms_a, axioms_b,
convention_a and convention_b stay silent for as long as nothing is wrong with the model, the regime,
the signs or the units. Their claim is still emitted and still refereed, and what they sign is not a
restatement of their own good behaviour: on a question of reactions axioms_a and axioms_b sign an
empty bundle, because for a statically determinate beam there is no hypothesis of the model that needs
writing down, while the two convention nodes sign the rotations of the members, the three balances and,
on a question of Euler, the audit of the critical load in the second unit system, a name that no solver
signs and that therefore is witnessed once and refereed once. The roster matters when one of them is
missing: see section 3.
3. What the verdict means, and how much confidence goes with it
| Status | Assurance | When the chain reaches it |
|---|---|---|
VERIFIED |
2 | the reading is shared by both roads, every guard holds, and the two methods give the same number for every scalar of the answer |
SINGLE_PROVER |
1 | the number stands on one road, or one guard of the chain did not run: a missing axioms_b, a missing convention_a |
REFUSED |
2 | the sentence is not of this language, the structure is outside the fragment, or the model itself is wrong: a labile frame, a redundancy of nine, a missing props block |
GUARD_BLOCKED |
2 | the question is well formed, the structure is in the fragment, and a regime guard of the law says the law does not apply here |
ABSTAINED |
2 | the sentence names a band the dataset declares out of its reach, and the chain has nothing firm to say about it |
UNKNOWN |
0 | the chain disagrees with itself, a load-bearing node left no bundle, or a check with the burden of soundness failed |
The burden of a check is part of the check: model and content mean the premises are wrong, and the
chain refuses; guard means a law was asked outside the range it is stated for, and the chain blocks the
question; agreement and soundness mean the chain is not entitled to its own number, and the verdict
falls to UNKNOWN with the reason the chain disagreed with itself. A VERIFIED answer at assurance 2
means something narrow and checkable: on the question asked, the stiffness method and the static road
produced the same exact ratio for every number of the answer, the three global balances close, the
cosines of every member are a rotation, the dimensions of every formula survive the second unit system,
every number of the sentence was echoed back by coverage, and the referee confirmed every claim of the
thirteen nodes. It does not mean that the model is the right model of a real building: see section 10.
The thirteen nodes are not equally load-bearing, and the rule says so out loud. Eight of them are
load-bearing (reader_a, reader_b, equivalence, coverage, solver_a, solver_b, verifier,
arbiter): if one of those hands over no bundle the verdict is UNKNOWN with the reason
no bundle from <node>, because there is a witness missing and not merely a witness that would have been
nice. The other five are guards (axioms_a, axioms_b, convention_a, convention_b, adversary):
with one of them missing the number still stands on two roads, so the verdict is SINGLE_PROVER at
assurance 1 and the reason says a guard of the chain did not run: <node>. That distinction is not a
mercy: it is what keeps a chain of twelve honest nodes from being reported as a chain that knows nothing,
and what keeps a chain that lost its verifier from being reported as verified.
The arbiter is not trusted with its own report. After the verdict is written, lgstruc/pipeline.py
re-derives it from the records of the thirteen turns, and if the arbiter announced something the evidence
does not support the verdict is replaced and the first reason becomes the arbiter announced <STATUS>.
That is why the fault arbiter:force_accept cannot turn a refusal into a verification: the best it can
do is add a reason naming the attempt. The adversary works the other way round: it does not try to prove
the answer right, it moves the answer by one and asks whether the chain notices. A perturbation that
leaves no trace anywhere downstream is a hole in the chain, and the reason an answer moved by one still passed the chain costs the run the witness that made it confident, so it closes at assurance 1 or below
instead of printing the number. tests/test_agents.py measures that on the beam of section 1: a clean run
reports the perturbation caught, while the same frame with its answer shifted by a whole unit closes at
UNKNOWN, with that reason among its notes.
The bands this dataset deliberately does not answer are the fourteen entries of ABSTENTIONS in
lgstruc/strength.py: plastic analysis and collapse load, torsional buckling and post critical behaviour,
cracked and reinforced concrete, second order and large displacement, creep and fatigue, shear
deformation, dynamic response, support settlement and imposed temperature. Each of them states its
trigger, its reason and the axiom of the manual that excludes it. In the fragment of section 1 they are
stated rather than reached: their trigger words are not words the two grammars read, so a sentence
naming one of them ends as REFUSED with the parse error as its reason. The grade ABSTAINED is
nonetheless part of the ladder, and tests/test_agents.py pins it by writing the note the readers would
have written.
4. Why thirteen nodes, and what each one is for
The shape is not the mathematics topology repeated: it is the same protocol applied to structures, where the two things that can fail silently are the reading of the structure and the regime of a law.
- Reading is trusted work, so it is done twice by two different programs (
parse_areads the head of the question first,parse_breads the declaration first) and the agreement is checked by a third node,equivalence, which compares canonical sentences rather than prose. One reader plus one checker is not enough: a reader that mis-parses a frame has nothing to disagree with. - The answer is computed twice by two methods that share no code:
solver_aassembles and solves the direct stiffness system,solver_bwrites the equilibrium of the same frame and obtains the redundants from compatibility, with the Mohr integrals for the displacements. They are deliberately not copies of each other, and the ceiling of 2 assurance rests on their agreement: removesolver_b, or removeequivalence, and every answer of a full chain falls toSINGLE_PROVERwhile the number itself stays correct. That is the rowwithout solver_bof the table below. - The applicability of a law is checked by
axioms_a(the hypotheses of the model) and byaxioms_b(the regime of the law), because the whole point of the manual is that a correct formula used outside the range it was stated for gives a wrong number with no sign of error: Jourawski near a point of application of a load, Euler for a stocky column, the small displacement axiom where a second order effect lives. convention_aandconvention_bwatch the two things that make a structural answer meaningless rather than wrong: a sign convention that was never written down, and a formula whose dimensions do not survive a change of unit system.coverageis the node that makes the collaboration with mathematics auditable: it echoes every number of the question and writes the sentences to be handed over, so the sentences the partner receives were written by a node whose claim is refereed, andcoverage:corrupt_delegateis visible.verifierdoes not invent checks: it takes the conjunction of every bundle the chain closed and re-decides it, which is what makes an injected fault at node six still visible at node eleven.
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 six core questions are one classification, one question of
reactions, one displacement whose arithmetic belongs to mathematics, one question of a section, one guard
that stops a law and one sentence outside the fragment, 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 6: verified / one road / refused / guard / no claim | fault runs | faults that fired | silent errors | missed answers | runs that abstained | verdict as the gold line expects |
|---|---|---|---|---|---|---|---|---|
| full thirteen | 13 | 4 / 0 / 1 / 1 / 0 | 144 | 71 | 2 | 0 | 24 | 118 |
without reader_a |
12 | 0 / 0 / 0 / 0 / 6 | 132 | 60 | 0 | 0 | 132 | 0 |
without reader_b |
12 | 0 / 0 / 0 / 1 / 5 | 132 | 65 | 0 | 0 | 110 | 22 |
without axioms_a |
12 | 0 / 4 / 1 / 1 / 0 | 138 | 70 | 2 | 0 | 24 | 46 |
without axioms_b |
12 | 0 / 4 / 1 / 1 / 0 | 138 | 71 | 2 | 0 | 24 | 46 |
without convention_a |
12 | 0 / 4 / 1 / 1 / 0 | 138 | 71 | 2 | 0 | 24 | 46 |
without convention_b |
12 | 0 / 4 / 1 / 1 / 0 | 132 | 65 | 2 | 0 | 20 | 44 |
without equivalence |
12 | 0 / 0 / 1 / 1 / 4 | 138 | 71 | 0 | 0 | 92 | 46 |
without coverage |
12 | 0 / 0 / 1 / 1 / 4 | 132 | 64 | 0 | 0 | 88 | 44 |
without solver_a |
12 | 0 / 0 / 1 / 1 / 4 | 132 | 68 | 0 | 0 | 88 | 44 |
without solver_b |
12 | 0 / 0 / 1 / 1 / 4 | 132 | 64 | 0 | 0 | 88 | 44 |
without verifier |
12 | 0 / 0 / 1 / 1 / 4 | 138 | 70 | 0 | 0 | 92 | 46 |
without adversary |
12 | 0 / 4 / 1 / 1 / 0 | 138 | 71 | 2 | 0 | 24 | 46 |
without arbiter |
12 | 0 / 0 / 1 / 1 / 4 | 132 | 59 | 0 | 0 | 88 | 44 |
The four pairs of faults are played inside every configuration. A fault run is one of the six
questions under one catalogue entry of section 9 that still names a node present in that
configuration, so the number of runs follows the catalogue: 120 single faults under the full chain,
132 or 138 under a chain of twelve, because a spec aimed at a node that has been removed is dropped
rather than played. The four pairs add up to twenty four runs where the nodes they need are present,
and fewer where one of them has been removed. The ninety two configurations of the sweep wrote 12,240
sessions: 552 clean, 9,480 single fault and 2,208 paired, and 9667.7 s of measured time between them.
That is why the tool splits the work with --parts 4 --part k and joins the parts afterwards: the
full chain takes 195.0 s of that total, and a chain without either reader takes 0.7 s, because in that
row no question is ever read at all.
What the table says. Removing any one of the thirteen nodes ends every clean run that was verified.
The five rows of the guard tier keep answering: four of the six questions come back SINGLE_PROVER,
at assurance 1, and the reason names the guard that did not run. The eight rows of the load bearing
tier answer nothing at all: four to six of the six clean questions close at UNKNOWN, because a
bundle is missing rather than because an arithmetic failed. All seventy eight configurations missing
two nodes answer nothing with assurance 2. Nobody refused a question the gold line wanted answered:
0 missed answers in 12,240 sessions, in every one of the ninety two configurations. And 0 runs in
those sessions reached ABSTAINED, which is the measurement behind the sentence of section 3 that
this ladder holds a grade the fragment cannot reach.
Sixteen of the ninety two configurations do hold a silent error, and each of them holds two, always the same pair of runs: the question of the deflection and the question of the section, under the pair of faults that corrupts both readers in the same direction. The table above shows six of those sixteen, the rows that keep both readers and lose a guard, and the pair is the last paragraph of section 9 and the second to last bullet of section 10. Everything else the sweep measured is a chain that answered what it should answer, or abstained where it should abstain.
5. Running
Run from inside this folder; on a hub clone the folder is the dataset, in a checkout it is
datasets/struc.
| Command | What it does |
|---|---|
python tools/ask.py "<question>" |
the real session: thirteen node processes routed by MultiInstanceOrchestrator, the transcript read back, the verdict re-derived from it |
python tools/ask.py --in-process "<question>" |
the same thirteen agents inside one process, which is the quicker path and the one the tests use |
python tools/ask.py --json "<question>" |
the same verdict as one JSON object: status, assurance, answer, roads, states, the delegation and its state |
python tools/ask.py --corpus problems/corpus.jsonl |
every question of the corpus, and a line per question that disagrees with its gold line |
python tools/ask.py --no-math "<question>" |
the two structural roads alone, with the channel to mathematics closed |
python tools/ablation.py --level all --problems core |
the ablation of section 4: --level single is the full chain plus the thirteen missing one node, --level all adds the seventy eight missing two |
python -m pytest tests -q |
the test suite of the dataset, 235 tests |
python tools/make_nodes.py |
regenerate the thirteen node folders from the Python that uses them |
python tools/make_topology.py |
regenerate topology.json from the roster and the reversed chain |
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 thirteen instances, the reversed chain, maxTurns, FIXED_PIPELINE
agents/struc_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
lgstruc/exact.py rationals, the pi bracket, the square root bracket, the printing of a number
lgstruc/units.py the dimensions of the fragment and the second unit system of the audit
lgstruc/poly.py polynomials in one variable with exact rational coefficients
lgstruc/linalg.py elimination, rank and null space over the rationals
lgstruc/tree.py the canonical tree both readers must hand over, and the fingerprint of a reading
lgstruc/parse_a.py road A: the head of the question first, then the numbers
lgstruc/parse_b.py road B: the declaration first, each number taken in its place
lgstruc/structure.py the frame as a model: its classification, its hypotheses, its mesh
lgstruc/sections.py area, centroid, inertia, elastic modulus and statical moment of a section
lgstruc/fields.py the internal forces of one member as exact polynomials along its own axis
lgstruc/balance.py the unknowns and the equations of a frame, and the exact rank that decides
lgstruc/frame.py the direct stiffness method, in rationals: road one
lgstruc/statics.py the force method with Mohr: road two, and the guards of the fragment
lgstruc/strength.py the verification laws, their regime guards, the fourteen declared abstentions
lgstruc/conventions.py signs, rotations, and the audit of a formula in the second unit system
lgstruc/families.py the eight families: facts, delegation, answer, invariants, perturbations, gold
lgstruc/smt.py pinning, the claim of a node, the referee's own Z3 decision
lgstruc/invoker.py the only contact with the mathematics dataset: one process, one sentence, one JSON
lgstruc/protocol.py the envelope, the notebook marker, the containment wrapper of a node
lgstruc/agents.py the thirteen steps, the ladder of verdicts, the one line verdict
lgstruc/pipeline.py the in-process session, and the verdict re-derived from the records
lgstruc/faults.py the catalogue of misbehaviour and the ways a node can lie or rewrite
lgstruc/corpus.py the corpus file, and the comparison of a verdict with its gold line
problems/corpus.jsonl thirty one questions, with their gold answers and their expected state
requirements.txt z3-solver and pytest: nothing else this folder needs
tests/ 235 tests: the mechanics, the wiring, the ladder, the faults, the corpus
tools/ ask.py, make_nodes.py, make_topology.py, ablation.py, publish_dataset.py
results/ what the ablation measured
The seed of the session lives in nodes/arbiter/seed_payload.json, because the routing matrix is
written backwards and the first arcata of that matrix leaves the arbiter.
7. Verification of the pieces
tests/test_statics.py (17) and tests/test_frame.py (46) pin the two roads against numbers derived
by hand from the manual: the reactions of a beam four metres long under fifteen per metre are 30 and
30; a propped cantilever gives 75/2 at the wall and 45/2 at the prop; a fixed fixed beam gives
the rotations 20 and -20, the end moments -20 and 10 at mid span; a Gerber frame carries 5 at
the end of its suspended span and reaches 10 as the largest moment of the diagram; a closed portal of
three members is pinned by what it has to be rather than by a number nobody checked, a thrust that is
not zero and equal and opposite at the two feet, and two rotations that cancel each other; a 3-4-5
rafter standing on a roller whose normal is -4/5, 3/5 gives 18, 123/2 and 45/2 as its support
components, a normal of -60 at one foot and a peak moment of 225/8 inside the inclined member. The
same two files check that the roads leave the same diagrams on every one of those frames, and that the
unit load method moves the same nodes as the stiffness method, the inclined roller included, because
that is where a transposed projection shows up. tests/test_sections.py (7) pins 2/25, 0,
2/1875, 2/375, 1/250 for a rectangle of one fifth by two fifths, and the area 17/200, the
inertia 4673/960000 and the statical moment 71/8000 of an I shaped pile of three rectangles.
tests/test_balance.py (11) pins the degree of redundancy, the rank and the guards: a labile frame, a
mechanism through a hinge, a redundancy of nine. tests/test_families.py (26) pins the eight families on
their two roads, the delegation each family is allowed to hand to mathematics, one perturbation of an
answer, and the fact that every claim form of every family is buildable and says what it claims.
tests/test_strength.py (12) pins Jourawski, the von Mises combination, the slenderness of Euler and the
regime guards that stop them.
tests/test_topology.py (22) pins the wiring: thirteen instances with one role each, the reversed chain,
maxTurns equal to the number of edges, the seed carried by exactly one node, thirteen claim forms from
one grammar, and the ceiling of fifteen nodes the protocol of the orchestrator allows.
tests/test_protocol.py (11) runs the thirteen nodes as thirteen envelopes, the way the orchestrator
does: a ratio survives the journey as a string and never as a decimal, the dossier survives the marker,
the seed of an idle node carries no marker, a node echoes the turn and the tick it was handed, a node that
raises hands a decidable claim and leaves its note in the notebook, and the thirteen claims of a real
chain each come out exactly as the ontology of their own node says. The same file checks that the answer
travelled inside envelopes is the byte for byte answer of the in-process path.
tests/test_agents.py (15) runs the corpus questions of the ladder through thirteen turns and checks
that no node doubts itself where the chain certifies an answer, that a refused question leaves no number
behind, that the adversary catches a perturbation by default, and that an invented FAILED state or a
fabricated abstention reaches the grade the ladder promises. tests/test_decision.py (28) pins the ladder
end to end: removing each load-bearing node gives UNKNOWN, removing each guard gives SINGLE_PROVER at
1, a diverging canonical reading gives UNKNOWN, closing the channel to mathematics turns a displacement
into UNKNOWN while a question that never asked it stays VERIFIED, and a report of the arbiter that
the evidence does not support is discounted by name. tests/test_faults.py (19) walks the catalogue of
section 9: every spec is listed, every spec that can do something does it, a fault aimed at a node that
is not in the configuration is ignored, a run never inherits the faults of the run before it, and the
environment variable and the flag of the tool are the same door. tests/test_corpus.py (12) reads the
corpus as a promise: thirty one numbered lines, a family and a grade for each of them, a gold number for
every question that is certified and no gold number for any refusal, the same grade reached by the real
chain, and the same number reached exactly.
tests/test_orchestrator_e2e.py (4) is the file that cannot be run inside one process: thirteen node
programs, thirteen envelopes, and the Z3 answers of the orchestrator set beside what each node claimed.
8. The collaboration with the mathematics dataset, and how to place the two
The structures chain keeps the geometry, the equilibrium and the constitutive law to itself, and hands over the arithmetic it would rather not do alone: a rational expression to evaluate, a polynomial to integrate between two abscissas, a small linear system to solve. The channel is one subprocess per question, one sentence per delegation, one JSON object back:
python <math folder>/tools/solve.py --json "integral ( 28125 / 8 ) * z^3 - ... from 0 to 2 wrt z"
The three forms the chain is allowed to ask are evaluate <expression>, integral <polynomial> from <a> to <b> wrt z and linsolve <matrix> <vector> with a matrix of at most five by five. They are written by
coverage, recorded in the notebook, and sent by lgstruc/invoker.py. The state of the channel is part
of the verdict, and it is one of four: NOT_ASKED for a question that had nothing to hand over,
VERIFIED when the partner answered with the number the road had already reached, UNAVAILABLE when the
partner is not there or did not answer, and INVALID when the partner answered something the road does
not accept. A delegated answer that the partner did not confirm is not demoted, it is withdrawn: the
verdict becomes UNKNOWN with the reason naming the delegation. Nothing in this folder imports a module
of the other, and the two folders can be installed apart: LGSTRUC_MATH_ROOT is the only link.
| Variable | Meaning |
|---|---|
LGSTRUC_MATH_BACKEND |
subprocess (the default), or none to keep the channel closed and see the two structural roads alone |
LGSTRUC_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 | |
LGSTRUC_MATH_TIMEOUT |
seconds the partner may take, 30 by default |
LGSTRUC_FAULTS |
the faults of section 9 to play on this run, comma separated |
One orchestrated session starts one mathematics process for the node that asks, and none for a question
the structures chain refused. The same rule holds with --no-math: the two roads still answer, still
agree, and still refuse, and only the questions that hand their arithmetic over lose the witness. 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 LGSTRUC_MATH_ROOT at wherever that folder stands,
and eleven questions of the corpus then stop reporting UNKNOWN over the delegation and report instead the
confidence the mathematics side actually carried. Neither side installs anything of the other.
9. Making a node misbehave
A chain that has never been seen wrong is a chain nobody has measured. lgstruc/faults.py holds the
catalogue, and the faults are played by the tool, not by editing the code:
python tools/ask.py --faults "solver_a:corrupt_answer,verifier:lie" "<the question of section 1>"
python tools/ablation.py --configs full --multi yes # every spec, and the pairs of specs
The flag writes LGSTRUC_FAULTS for the duration of the run and puts back what the environment held
before it. The tests and the ablation reach the same catalogue through the fault_spec argument of a
run, and the variable is the channel for a chain started without this tool at all.
| Spec | What the node does | What the chain then says |
|---|---|---|
<any node>:lie |
reports PASS over the checks of its own bundle while those checks do not hold |
the lie is only told where the node has something to be wrong about; where its bundle already holds, the fault is a no-op, and the ablation counts it as one |
reader_a:corrupt_tree, reader_b:corrupt_tree |
hands over a tree that is not the one it read | UNKNOWN, the two grammars read two different questions |
convention_b:corrupt_reading |
rewrites the reading of the second road where the two readings are compared | the same reason, from a node that was not a reader |
coverage:corrupt_delegate |
alters the sentences written for mathematics | UNKNOWN, the sentences handed to mathematics were altered on the way |
solver_a:corrupt_answer |
answers with a number that is not the one its method produced | UNKNOWN, the agreement of the two roads fails by name |
solver_b:corrupt_answer |
the same, on the second road | nothing at all: the verdict stays VERIFIED with the gold number. Measured and reported in section 10 |
arbiter:force_accept |
announces VERIFIED when the rule says otherwise |
the grade does not change, and the first reason is the arbiter announced VERIFIED |
Thirteen nodes each own one lie; seven of the twenty specs rewrite something rather than report it. A
spec aimed at a node that the configuration does not contain is ignored rather than guessed at, and a
spec with a name that is not in the catalogue is ignored rather than played as a no-op and counted as a
firing. The fault runs of the ablation include four pairs, to ask whether a second fault can hide the first:
an answer altered on one road together with a verifier that lies about the conjunction, a delegation altered together with a verifier that lies, both readers corrupting the tree in
the same direction, and an arbiter forcing acceptance together with a lying verifier.
What the twenty specs do to the full chain, over the six questions. The seven rewriting specs fire on
all six questions each, 42 runs. Of the thirteen lies, five find something to be wrong about,
arbiter:lie, axioms_a:lie, solver_a:lie, solver_b:lie and verifier:lie, one question each;
the other eight fire nowhere, because those nodes hold nothing on those questions that a lie could be
about. That is the 47 of 120 the table of section 4 reports as fired. Eighteen of those runs close at
UNKNOWN, and none of the 120 leaves a confident answer that the gold line does not support. Two
specs fire on all six questions and change nothing the chain ends up saying: arbiter:force_accept,
which the re-derivation from the records neutralises, and solver_b:corrupt_answer, the blind spot of
section 10. The other five rewriting specs cost the chain the runs they are played on:
reader_a:corrupt_tree, reader_b:corrupt_tree and convention_b:corrupt_reading leave the two
questions that were never answerable as they were and close the other four at UNKNOWN,
coverage:corrupt_delegate leaves four of the six, and solver_a:corrupt_answer leaves two.
The four pairs run 24 times and every one of them fires. Three of the four are caught: a verifier that
lies about the conjunction does not save an altered answer, an altered delegation or a forced
acceptance, and each of those pairs lands where the single fault lands. The fourth pair is a hole. A
corrupt_tree on both readers misreads one digit in each of the two readings, and because the
misreading is the same one the two grammars still agree, both roads solve the structure that was
misread, and the chain certifies it at assurance 2. On the question of the deflection it prints
-420000001/1881600008960 where the gold line of the corpus says -1/4480, the eighth significant
digit of a number whose Young modulus is the digit that was misread; on the question of the section it
prints an area of 7/25 where the gold line says 2/25, which is the area of the rectangle the fault
wrote instead of the one that was asked. Two runs out of the 12,240 of the sweep, and the only two
in it.
10. Known limits
- The fragment is a cap and not a style: five nodes, eight members, redundancy three, exact cosines, section constant along a member, loads of degree zero. A frame of four nodes and a diagonal that makes its redundancy nine is refused by name, and the reason quotes the cap; the fragment is what makes the second road solvable in exact rationals, not a convenience.
- A displacement is asked at a node. The check is called
the_point_is_a_node_of_the_mesh, its burden isguard, and it blocksdeflect member <m> at <p>because along a member only the Mohr road exists, and assurance 2 in this dataset means two roads. The internal forces of a cut at an interior abscissa are answered at assurance 2, because there both roads do exist. - The fourteen declared abstentions of section 3 are out of the reach of the language, not out of the reach of the ladder: a sentence naming one of them does not parse, so the chain answers with a refusal whose reason is the parse error. The grade exists, is pinned by a test, and the corpus contains no question that reaches it.
- Assurance 2 is a statement about this question, this reading and these two methods. It is not a statement that the model describes a building: the small displacement axiom, the plane section axiom and the constant section per member are premises the user supplied, and the gold numbers of the corpus were derived by hand from the manual, not from this code. That is the point of the corpus: it can be wrong about the code, and so far it has not been.
- The two readers are a defence against two different misreadings, not against the same misreading
played twice. The sweep of section 4 has two runs in which the chain is confident about a number the
corpus does not support, and both come from
reader_a:corrupt_treeandreader_b:corrupt_treeat the same moment: each reader misreads the same digit, the two readings agree with each other, the two structural roads agree about the structure that was misread, and the verdict isVERIFIEDat assurance 2. Nothing inside a chain of agreeing agents notices a common mode failure, which is one reason the gold of the corpus is written by hand and not by this code. - The catalogue of section 9 has one measured hole.
solver_b:corrupt_answerleaves the verdict untouched: the roads the corrupting node rewrote are not read again downstream, and the answer line is drawn from the model rather than from the road that reported it. The fault is therefore scored as a no-op and pinned as one bytests/test_faults.py, rather than reported as caught. - Dropping two nodes is where a chain stops being a chain, and the sweep says so on every row: none
of the seventy eight configurations missing two nodes produced a verified answer on the six clean
questions. What none of them did either is let a wrong number through, and the sweep says that too:
0 missed answers and no silent error anywhere a node is missing. The confident wrong answers the
sweep found are the two of the bullet above, and they sit inside a chain that has all thirteen nodes
and was sabotaged twice in the same direction. The whole sweep is the file
results/ablation.json, published with this folder, and every number of this section can be recomputed from it. - The session is a pipeline, not a debate: thirteen nodes each work once. A node that abstains does not get asked again, which keeps the turn count and the meaning of the assurance levels fixed. The protocol of the orchestrator numbers a node in four bits, so fifteen is the ceiling; thirteen is what this fragment needs, and two slots are left.
- The
grammar.gfof every node is a specification of the language and of the claim form. It has not been compiled with the GF toolchain in the authoring environment, and nothing in this dataset depends on that compilation: the parsers that decide what the chain can read are the two Python readers.
11. The corpus file, the topology file, and the measured results
problems/corpus.jsonl holds 31 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, s01 to s31 |
kind |
string | one of the eight families (classify, reactions, cut, peak, deflect, properties, verify, euler), or outside, incomplete, labile, hyperstatic for the four lines that have to be refused |
text |
string | the question in the language of section 1, between 31 and 316 characters |
expect |
string | the verdict this topology has to reach: VERIFIED (23 lines), GUARD_BLOCKED (4), REFUSED (4) |
expected_math |
string | what the delegated mathematics has to return: VERIFIED (11 lines) or NOT_ASKED (20 lines, including every refusal) |
gold |
object | the answer to compare with, in the shape of its family, or null for the eight lines that end with a verdict and no number under it |
The shape of gold is what lgstruc/corpus.py compares against, family by family: the kind and the
degree of redundancy for a classification; a map from support component to number for a question of
reactions; normal, shear and bending moment for a cut; the value with the member and the abscissa that
reach it for an envelope; one rational for a displacement; area, centroid, inertia, elastic modulus and
statical moment for a section; the stress and the limit it was measured against for a verification; the
coefficient and the power of pi for the critical load of Euler. A rational written another way is the
same rational, and a number that differs by one is not. tools/ask.py --corpus problems/corpus.jsonl walks the file, prints one line per question and ends with the tally
{"correct": 31}; tests/test_corpus.py asserts the same comparison.
topology.json is the declaration of the session: the thirteen 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: 92 configurations of
the topology (the full chain, thirteen missing one node, seventy eight missing two), each holding the
tally of a clean sweep over the six core questions, a sweep of the twenty entry fault catalogue, and a
sweep of the four 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 numbers of sections 4 and 9 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-struc", "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
thirty one questions and their gold answers, the thirteen node definitions, the eight sentence families,
the guards and the fragment the language refuses, the fault catalogue and the Python sources were written
by hand as part of the LingoLOGOS project, and the laws they guard follow a complete manual of structural
engineering, written by hand in Italian for that project, whose sections on exact statics, the theory of
sections, the verification laws and their regime of validity are 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_struc,
title = {LingoLOGOS structures topology: thirteen agents, a verified answer or an explicit UNKNOWN},
author = {LingoLOGOS project},
year = {2026},
url = {https://huggingface.co/datasets/tailot/lingologos-struc},
note = {bundle of the structures folder of the LingoLOGOS repository: 31 questions with their gold
answers, thirteen node definitions with their ontologies, eight sentence families, decision
rule, fault catalogue of 20 entries, ablation over 92 configurations of the topology, and
the collaboration with the mathematics dataset as a separate process}
}
- Downloads last month
- -