Datasets:
Modalities:
Text
Formats:
json
Size:
< 1K
Tags:
multilingual
mathematical-word-problems
natural-language-to-formal-language
multi-agent-systems
benchmark
conversational-interfaces
|
Download README.md from tailot/math-stratum: direct link, hf CLI and curl.
- Browser
- Download file 20.9 kB
-
https://huggingface.co/datasets/tailot/math-stratum/resolve/main/README.md
- Command line
-
hf download hf://datasets/tailot/math-stratum/README.md
-
curl -L -o README.md https://huggingface.co/datasets/tailot/math-stratum/resolve/main/README.md
20.9 kB
| language: | |
| - it | |
| - en | |
| - es | |
| - zh | |
| - hi | |
| - ar | |
| tags: | |
| - multilingual | |
| - mathematical-word-problems | |
| - natural-language-to-formal-language | |
| - multi-agent-systems | |
| - benchmark | |
| - conversational-interfaces | |
| - formal-verification | |
| - semantic-parsing | |
| pretty_name: "LingoLOGOS math-stratum: a question in six written varieties, the answer of the math stratum, and an assurance that includes the reading" | |
| configs: | |
| - config_name: corpus | |
| data_files: | |
| - split: train | |
| path: problems/corpus.jsonl | |
| size_categories: | |
| - n<1K | |
| # LingoLOGOS math-stratum topology | |
| A conversational layer over the `math` topology: a person asks in one of six written varieties, and | |
| gets the answer of the math stratum back in that same language, at an assurance that includes the | |
| fallibility of the reading. The layer never decides a problem and never raises a verdict; the only | |
| direction it can move the assurance of the math stratum is down. | |
| ``` | |
| python tools/ask.py --lang it "risolvi x^2 - 5*x + 6 = 0 per x" | |
| Reading state : AGREED | |
| Assurance shown : 2 (reading ceiling 2, math assurance 3) | |
| Math layer status : VERIFIED | |
| Orchestrator Z3 check : 8 of 8 envelopes confirmed | |
| Answer in the language of the question (italiano): | |
| Stato: accordata: due lettori indipendenti piu il vincolo SMT | |
| Problema capito (solve): solve x^2-5*x+6=0 for x | |
| Risposta: {2, 3} | |
| livello 2 di 3 | |
| strato matematico: VERIFIED | |
| Controllo SMT dello strato : 8 di 8 buste confermate | |
| ``` | |
| This dataset is the `math-stratum/` folder of the LingoLOGOS project published as it stands: 67 files, | |
| code and data together, plus this card in place of their README. Only the standard library and | |
| `z3-solver` are required, and `pytest` for the tests; both are named in `requirements.txt`. Every | |
| command below is written from inside the folder. The mathematics is not part of this dataset: it lives | |
| in the `math` bundle, published at https://huggingface.co/datasets/tailot/lingologos-math, and section | |
| 10 says how to point this folder at a copy of it. | |
| ## 1. What the stratum is, and what it refuses | |
| The certainty of a translation cannot be verified the way the certainty of a proof can: there is no | |
| SMT check that says that a sentence of Hindi was read correctly. That is the definition this bundle | |
| works with, and it is why the topology is built the way it is: two readers that reach their sentence | |
| by different roads, an SMT claim about what each reading kept, a referee that rechecks every envelope, | |
| and a decision that is re-derived from the transcript instead of being trusted from the arbiter. | |
| The rule the whole bundle exists to enforce: | |
| ``` | |
| assurance shown = min(assurance of the math stratum, ceiling of the reading) | |
| ``` | |
| | Reading state | ceiling | when | | |
| |---|---|---| | |
| | `AGREED` | 2 | both readers produced the same sentence, and the math stratum is what decides it | | |
| | `PASSTHROUGH` | 2 | the question was already a sentence of the math language: nothing was translated | | |
| | `SINGLE` | 1 | one reader understood it and the other abstained: no witness, one level less | | |
| | `DISPUTED` | 0 | the two readers produced different sentences, or a reading lost a number: the math stratum is not even asked | | |
| | `AMBIGUOUS` | 0 | a reader reports that the question announces more than one problem, or leaves a slot with several readings: the person has to choose | | |
| | `NOT COVERED` | 0 | neither reader found anything: this variety does not say it in a covered way | | |
| | `TAMPERED` | 0 | the math stratum says it solved something other than the agreed sentence | | |
| Three is never shown. Level three belongs to the math stratum, whose two formalizers and two | |
| checkers work on a sentence they wrote themselves; a sentence in a human language adds one fallible | |
| step before that, and this layer is that step. | |
| The ceiling is not the only thing that holds on its own. The count of literals is checked on a lone | |
| reading too: a reading that no longer holds the numbers the person wrote is a different problem, not a | |
| weaker reading of the same one, and it ends `DISPUTED` even when it is the only reader that understood | |
| the question. A single witness therefore answers at level one only when it kept every number. | |
| ## 2. The eight nodes | |
| The session runs through the orchestrator (`src/lingologos_orchestrator`) with the same envelope | |
| protocol as the `math` topology: a marker `@@DOSSIER@@` inside `payload.naturalLanguage`, and | |
| `payload.smtConstraints` carrying what each node claims about its own output, which the referee of | |
| every node recomputes with Z3. The seed sits in the `arbiter`; `maxTurns` is the number of arcs. | |
| | Node | What it does | The claim it carries | | |
| |---|---|---| | |
| | `reader_a` | reads the question against the frames written in the lexicon | the numerals of the question are still in my sentence | | |
| | `reader_b` | reads it by following the joints of the math language | the same, independently | | |
| | `equivalence` | proves the two sentences the same, slot by slot and then with SMT | `not (A = B)` is unsatisfiable | | |
| | `coverage` | counts that every literal the person wrote survived into the sentence | conjunction of the element equalities | | |
| | `invoker` | asks the math stratum, in a separate process, the agreed sentence | the sentence I sent equals the one that came back | | |
| | `boundary` | checks the echo of the math stratum instead of trusting it | elementwise on the echo, or the empty claim | | |
| | `adversary` | re-derives the bound and writes its negation | `shown > ceiling` is unsatisfiable | | |
| | `arbiter` | runs the decision and renders the answer in the language of the question | the same inequality | | |
| ## 3. Two readers, one lexicon | |
| `read_a.py` matches the shapes stored in `lexicon/<lang>.json` (`patterns`: one template per kind of | |
| problem, with slots). `read_b.py` never looks at those shapes: it finds the verb that announces a | |
| problem, then walks the joints of the math language (`for`, `over Z`, `from ... to`, `subject to`, | |
| `wrt`) and cuts the slots out of the gaps between them. They share only the lexicon, the atomizer | |
| (`segment.py`) and the templates of the math language (`canonical.py`). | |
| That sharing is deliberate and it is also the known blind spot: a wrong description of a variety is | |
| a wrong description for both readers, and the topology cannot see it. What shows it is the corpus of | |
| section 5, whose questions were written and checked by a person. When the two readers disagree the | |
| assurance goes down, never up: `DISPUTED` does not even consult the math stratum. | |
| ## 4. Talking to the math stratum | |
| `invoker.py` is the only door. It launches `python <root>/tools/solve.py --json <sentence>` as a | |
| separate process and reads its JSON verdict back; nothing in this folder imports the solver of the | |
| math stratum to decide anything here. The referee then checks the echo: the sentence the math stratum | |
| says it solved has to be the sentence the readers agreed on, otherwise the session is `TAMPERED`. | |
| | Variable | Meaning | | |
| |---|---| | |
| | `LGSTRATUM_MATH_ROOT` | where the `math` bundle is (default: the sibling folder `datasets/math`) | | |
| | `LGSTRATUM_MATH_BACKEND` | `subprocess` (default), or `none` to disable the math layer entirely | | |
| | `LGSTRATUM_FAULTS` | comma separated `node:fault` pairs, experiments only | | |
| A disabled math layer is not tampering: the reading stands, the assurance falls to zero because there | |
| is no math assurance to take the minimum with, and no answer is shown. | |
| ## 5. The corpus | |
| `problems/corpus.jsonl` holds 73 questions: 12 kinds of problem in 6 varieties, plus items that mix | |
| varieties, full width digits, unspelled matrices, gibberish, questions with an empty slot and | |
| questions whose mathematics is out of reach of the math stratum. Each line carries what the answer | |
| has to look like (`state`, `sentence`, `answer_contains`, `min_assurance`, `max_assurance`, | |
| `no_answer`, `referee_clean`) and a `why` that says why, including the cases where the expected | |
| outcome is an abstention. | |
| Graded against the in-process pipeline: **73 of 73** rows agree with their gold (`lgstratum/corpus.py` | |
| grades one row, `tests/test_corpus.py` runs all of them). With the math layer switched off the states | |
| come out 57 `AGREED`, 2 `SINGLE`, 11 `NOT COVERED`, 3 `PASSTHROUGH`; `tools/coverage_report.py` writes | |
| `results/coverage.json` and counts **57** questions read by both readers, **2** by `reader_a` alone and | |
| **14** by neither. Seven rows (`it-13`, `en-11`, `en-12`, `es-09`, `zh-11`, `hi-11`, `ar-12`) are agreed | |
| readings on which the math stratum abstains: assurance 0 and no answer, which is the layer refusing to | |
| add an availability it does not have. Two rows (`hi-05`, `hi-10`) stay at `SINGLE`, assurance 1, for the | |
| reason in section 7. | |
| ## 6. Commands | |
| ``` | |
| python tools/ask.py --lang it "quanto fa 2+2?" # one session, eight processes | |
| python tools/ask.py --lang en --json "solve x + 1 = 2 for x" | |
| python tools/ask.py --lang ar --corpus problems/corpus.jsonl --limit 6 | |
| python tools/coverage_report.py --out results/coverage.json # which frames each variety carries | |
| python tools/ablation.py --probe 12 --out results/ablation.json | |
| ``` | |
| `tools/ask.py` prints the verdict it re-derives from the transcript, not the one the arbiter wrote, | |
| and exits with code 3 when that re-derivation disagrees with a node about its own envelope, with code | |
| 2 when the assurance is zero, and with code 1 in corpus mode when a gold expectation fails. | |
| `tools/ablation.py` walks the configurations of the topology | |
| one node at a time, injects every fault of the catalogue singly and in pairs, and reports each cell as | |
| `raised | lowered | masked | caught | abstained | silent_error`: a cell counted `raised` is a violation | |
| of the rule of section 1, and the tool exits 1 if any happened. A `caught` cell is one where an answer | |
| was shown that the gold does not accept, but the session said so itself -- a claim fell to the referee | |
| of its node, or the assurance sits below the honest one because the configuration lost a node. | |
| On this checkout `--probe 6` (one question per variety) fills **147 cells** and **882 sessions**, the | |
| fault takes hold in **510** of them, and the totals are `raised 0`, `lowered 0`, `silent_error 0`, | |
| `caught 18`, `abstained 366`, `masked 126` -- about fifteen minutes. Nothing was ever raised above the | |
| honest assurance, and the 18 `caught` cells all sit in the configuration without `reader_b`, where a | |
| rubber stamped verification node cannot buy back the level the missing witness costs. | |
| ## 7. Limits that are written down, not hidden | |
| * Two varieties place their joints after the slot instead of before it. `reader_b` cannot cut the | |
| slots there, so those questions are read by one reader only and stay at `SINGLE`, assurance 1 | |
| (`hi-05`, `hi-10`). `tools/coverage_report.py` shows them as one of two readers. | |
| * A missing written accent can collide with a connective: `qual e il determinante di ...` is not read, | |
| because the folded copula is the same atom as the conjunction `e`. | |
| * The fragment of the math stratum is unchanged here: powers inside integer terms and non linear | |
| programs end in `UNKNOWN`, so the assurance is zero even when the reading is agreed. The corpus | |
| keeps those questions as probes (`it-13`, `en-11`, `en-12`, `es-09`, `zh-11`, `hi-11`, `ar-12`). | |
| * The two readers share their data, so a systematic error in the description of a variety is invisible | |
| to the topology and can only be found in the corpus. | |
| ## 8. Tests | |
| From the repository root: | |
| ``` | |
| python -m pytest -q datasets/math-stratum/tests | |
| ``` | |
| The suite is **290** tests: 121 on the two readers against every row of the corpus, 79 on the corpus | |
| itself, 38 on the pinned invariant, 14 on the topology file, 13 on the faults, 13 on the decision | |
| table, 10 on the lexicons and 2 end-to-end sessions. It checks the topology file against the node | |
| order, the shape and the completeness of the lexicons, both readers against the corpus, the decision | |
| table, the faults, and every gold answer of the corpus; `tests/test_pinned_invariant.py` runs the same questions through every node | |
| configuration and every fault and asserts that the verdict of the math stratum does not move, and | |
| that nothing is ever shown above it. `tests/test_orchestrator_e2e.py` runs two real sessions through | |
| the orchestrator and is skipped when `lingologos_orchestrator` is not importable. The corpus and the | |
| invariant tests call the solver of the math stratum as subprocesses, which here means a copy of the | |
| `math` dataset named by `LGSTRATUM_MATH_ROOT` (section 10); the suite took 3 minutes 52 seconds inside a | |
| LingoLOGOS checkout, and the two end to end tests skip on their own when `lingologos_orchestrator` is | |
| not importable. | |
| Real sessions, measured: `risolvi x^2 - 5*x + 6 = 0 per x` comes back `AGREED` at assurance 2 against a | |
| math assurance of 3, with **8 of 8** envelope claims confirmed by the referee of the session, and | |
| `python tools/ask.py --corpus problems/corpus.jsonl --limit 8` grades **8 of 8** real sessions against | |
| gold. One question per variety outside Italian (`zh-01`, `ar-01`, `hi-03`, `es-02`) comes back the same | |
| way: `AGREED`, assurance 2, the math stratum `VERIFIED`, 8 of 8 claims confirmed, nothing detected -- | |
| and the block the person reads is written in the language of the question (48, 97 and 104 non-ASCII | |
| characters in the Chinese, Arabic and Hindi replies). | |
| A gate in `tests/test_topology.py` keeps every Python source of this bundle ASCII only, and pins that | |
| `lgmath` may be imported for its SMT plumbing by `lgstratum/compare.py` alone. | |
| ## 9. Language policy | |
| The prose of this folder -- code, docstrings, comments, tool output, test messages -- is English, and | |
| the Python sources are ASCII, as the repository requires. The exception is the language under study, | |
| and it is confined to data: `lexicon/*.json` (the words, frames, joints and labels of the six | |
| varieties), `problems/corpus.jsonl` (the questions and their gold answers), and the answer block that | |
| `tools/ask.py` shows a person, which is written in the language of the question because that block is | |
| the object this bundle measures. | |
| ## 10. Putting this dataset back into a LingoLOGOS checkout | |
| This dataset is 67 files plus this card: 73 questions in one corpus file, the six lexicons, the eight | |
| node definitions, the two readers, the decision rule of section 1, the corpus grading and fault results | |
| under `results/`, and the fault catalogue of section 6. To run the mathematics it needs the `math` | |
| bundle: download https://huggingface.co/datasets/tailot/lingologos-math somewhere, set | |
| `LGSTRATUM_MATH_ROOT` to that copy, and the `invoker` node calls `tools/solve.py` there as a separate | |
| process, which is the only door through which this bundle ever reaches a solver. Inside a LingoLOGOS | |
| checkout the folder sits at `datasets/math-stratum`, finds `datasets/math` by itself, and needs | |
| `src/lingologos_orchestrator` importable for the two end to end sessions of section 8. On the hub this | |
| README is rewritten as a dataset card whose sections 1 to 10 keep the wording and numbers of this file, | |
| and sections 11 to 14 are added there for readers who met the bundle on the hub rather than in a | |
| checkout: the fields of the corpus file, how to load it, rights and citation. Every file but this README was compared by sha256 after the upload: the hub holds one object | |
| per file of this folder plus `.gitattributes`, so the remote count is one above the number | |
| `tools/publish_dataset.py` prints here. What the LingoLOGOS repository carries is the link to this | |
| dataset in the table of published resources at the top of its README; the documentation of the asset | |
| lives here, in this card, and not in the technical documentation of the project. `tools/publish_dataset.py` | |
| in the folder of the project republishes a changed working copy with the token taken from an environment | |
| variable. Republishing is a separate step, never a side effect of a | |
| test run: `tools/publish_dataset.py` does it with the token taken from an environment variable and | |
| verifies the tree by sha256. | |
| ## 11. The corpus file | |
| `problems/corpus.jsonl` holds 73 questions, one JSON object per line, written and checked by a person. | |
| It is a benchmark for the stratum: there is no prompt, no response pair and nothing to fine tune on. | |
| Each row says what the session has to end like, including the rows whose expected outcome is a refusal | |
| to answer, and a `why` that says why. | |
| | Field | Type | Meaning | | |
| |---|---|---| | |
| | `id` | string | unique; the prefix names the variety (`it`, `en`, `es`, `zh`, `hi`, `ar`), or `mixed` on the 5 rows that mix varieties, write digits in full width form or are gibberish | | |
| | `lang` | string | one of `it`, `en`, `es`, `zh`, `hi`, `ar`: the variety the question is written in | | |
| | `kind` | string | one of the 12 problem kinds, or `negative` (14 rows that must not be read) or `passthrough` (2 rows already written in the math language) | | |
| | `question` | string | the question, between 5 and 53 characters, in the script of its variety | | |
| | `why` | string | the reason the row behaves as it does, written by the person who wrote the row | | |
| | `expect` | object | the expectation, described below | | |
| | Variety (`lang`) | Rows | Id prefix | Rows | Kind | Rows | | |
| |---|---|---|---|---|---| | |
| | `it` | 13 | `it` | 13 | `evaluate` | 7 | | |
| | `en` | 13 | `en` | 12 | `solve` | 6 | | |
| | `es` | 10 | `es` | 9 | `solvez` | 3 | | |
| | `zh` | 12 | `zh` | 11 | `prove` | 5 | | |
| | `hi` | 12 | `hi` | 11 | `provez` | 8 | | |
| | `ar` | 13 | `ar` | 12 | `derivative` | 4 | | |
| | mixed rows | 5 | `mixed` | 5 | `integral` | 5 | | |
| | | | | | `det`, `rank` | 3, 3 | | |
| | | | | | `inverse` | 4 | | |
| | | | | | `maximize`, `minimize` | 3, 6 | | |
| | | | | | `negative` | 14 | | |
| | | | | | `passthrough` | 2 | | |
| The fields of `expect` are optional except `referee_clean`, which is present on every row. | |
| | Field | Rows | Meaning | | |
| |---|---|---| | |
| | `state` | 65 | the reading state the session must end in: `AGREED` 55, `PASSTHROUGH` 3, `SINGLE` 2, `NOT COVERED` 5 | | |
| | `sentence` | 60 | the sentence of the math language both readers have to produce, exactly | | |
| | `answer_contains` | 29 | a substring the answer has to contain, exact rationals written as strings | | |
| | `min_assurance` | 51 | the lowest assurance that is acceptable, on the scale of section 1 | | |
| | `max_assurance` | 22 | the highest assurance that is acceptable: this is what pins the probes that must not rise | | |
| | `no_answer` | 15 | `true` where the row is graded by the refusal: no answer may be shown at all | | |
| | `referee_clean` | 73 | every envelope claim of the session must match what the referee of its node recomputed | | |
| The eight rows with no `state` are graded on an assurance or on an answer instead: they check that the | |
| reading holds while the math stratum abstains, so the assurance must be 0 and no answer may appear. | |
| Seven of them are the agreed readings on which the mathematics is out of reach (`it-13`, `en-11`, | |
| `en-12`, `es-09`, `zh-11`, `hi-11`, `ar-12`), which is the stratum refusing to add an availability it | |
| does not have. | |
| ## 12. Loading it | |
| Load the file with the `datasets` library, or with one `json.loads` per line, which needs no | |
| dependency: | |
| ```python | |
| from datasets import load_dataset | |
| rows = load_dataset("tailot/math-stratum", "corpus", split="train") | |
| print(rows[0]) | |
| ``` | |
| This is the same file `tools/ask.py --corpus` walks over, and `lgstratum/corpus.py` plus | |
| `tests/test_corpus.py` read it to grade the stratum against the gold. Graded on this checkout: 73 of 73 | |
| rows agree with what they expect. | |
| ## 13. Rights | |
| No license is declared for this dataset, its lexicons, its corpus or its code: reuse is not granted by | |
| this page. The six lexicons, the 73 questions with their gold expectations, the grammar specifications, | |
| the node data and the Python sources were written by hand as part of the LingoLOGOS project. 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`. The lexicons of Hindi, Arabic and Chinese describe written | |
| varieties as this project needs them for arithmetic questions: they are not a general purpose | |
| dictionary of those languages. | |
| ## 14. Citation | |
| ``` | |
| @misc{lingologos_math_stratum, | |
| title = {LingoLOGOS math-stratum: a question in six written varieties, the answer of the math stratum, and an assurance that includes the reading}, | |
| author = {LingoLOGOS project}, | |
| year = {2026}, | |
| url = {https://huggingface.co/datasets/tailot/math-stratum}, | |
| note = {bundle of the math-stratum folder of the LingoLOGOS repository: 73 questions in six written | |
| varieties, six lexicons, two independent readers, eight node definitions with SMT claims, the | |
| assurance rule min(math, reading) with the reading capped at 2, fault catalogue and ablation | |
| over the node configurations, 290 tests} | |
| } | |
| ``` | |