Dataset Viewer
Auto-converted to Parquet Duplicate
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

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_a reads the head of the question first, parse_b reads 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_a assembles and solves the direct stiffness system, solver_b writes 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: remove solver_b, or remove equivalence, and every answer of a full chain falls to SINGLE_PROVER while the number itself stays correct. That is the row without solver_b of the table below.
  • The applicability of a law is checked by axioms_a (the hypotheses of the model) and by axioms_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_a and convention_b watch 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.
  • coverage is 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, and coverage:corrupt_delegate is visible.
  • verifier does 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 is guard, and it blocks deflect 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_tree and reader_b:corrupt_tree at 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 is VERIFIED at 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_answer leaves 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 by tests/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.gf of 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
-