Datasets:
Modalities:
Text
Formats:
json
Size:
< 1K
Tags:
multilingual
mathematical-word-problems
natural-language-to-formal-language
multi-agent-systems
benchmark
conversational-interfaces
Download tests/test_faults.py from tailot/math-stratum: direct link, hf CLI and curl.
- Browser
- Download file 4.63 kB
-
https://huggingface.co/datasets/tailot/math-stratum/resolve/main/tests/test_faults.py
- Command line
-
hf download hf://datasets/tailot/math-stratum/tests/test_faults.py
-
curl -L -o test_faults.py https://huggingface.co/datasets/tailot/math-stratum/resolve/main/tests/test_faults.py
4.63 kB
| """The faults this bundle can switch on, and what each of them is required to leave behind. | |
| The catalogue is the counterpart of the one the math stratum runs: here the misbehaviour is in the | |
| reading and in the reporting, never in the mathematics. A fault is worth having only if the stratum | |
| reports it, so every experiment below ends by asking the same question -- did the assurance fall, and | |
| did the reason name the node that fell short? | |
| """ | |
| import pytest | |
| from lgstratum import agents, canonical, corpus, faults, pipeline | |
| ITEMS = {item["id"]: item for item in corpus.load()} | |
| ONE = "it-01" | |
| def _ask(item_id, fault_spec=(), active=agents.ORDER): | |
| item = ITEMS[item_id] | |
| return pipeline.ask(str(item["question"]), str(item["lang"]), active=active, fault_spec=fault_spec) | |
| def test_the_catalogue_names_nodes_of_this_topology_only(): | |
| assert set(faults.CATALOG) <= set(agents.ORDER) | |
| # The invoker is not in the catalogue: it reads nothing and proves nothing, it only asks the math | |
| # stratum a question, so there is no shortcut it could take. | |
| assert "invoker" not in faults.CATALOG | |
| faults.configure(()) | |
| for node, kinds in faults.CATALOG.items(): | |
| assert kinds, node | |
| assert len(set(kinds)) == len(kinds), node | |
| for kind in kinds: | |
| assert not faults.has(node, kind), (node, kind) | |
| def test_a_fault_configured_is_a_fault_fired_once(): | |
| faults.configure(["reader_a:merge_slots", "reader_a:merge_slots", "coverage:rubber_stamp"]) | |
| assert faults.has("reader_a", "merge_slots") | |
| faults.fire("reader_a", "merge_slots") | |
| faults.fire("reader_a", "merge_slots") | |
| assert faults.fired("reader_a") == ["reader_a:merge_slots"] | |
| # Configured is not the same as fired: only a fault that really changed something is recorded, so | |
| # the ablation can tell an activated fault from a dormant one. | |
| assert faults.has("coverage", "rubber_stamp") | |
| assert "coverage:rubber_stamp" not in faults.FIRED | |
| assert faults.FIRED == ["reader_a:merge_slots"] | |
| faults.configure(()) | |
| assert not faults.has("reader_a", "merge_slots") | |
| def test_the_reader_faults_damage_a_reading_that_carries_them(): | |
| # A reading of an integral carries four slots, and three of them hold a number: every fault of a | |
| # reader has something to bite on. Each one leaves a sentence the math stratum would happily | |
| # solve, which is what makes the experiment measure the readers and not the parser. | |
| kind = "integral" | |
| order = canonical.slots_for(kind) | |
| base = {name: "1" + name for name in order} | |
| for fault in faults.CATALOG["reader_a"]: | |
| faults.configure(["reader_a:" + fault]) | |
| changed, was_changed = faults.mutate_reading("reader_a", kind, base, order) | |
| assert was_changed is True, fault | |
| assert changed != base, fault | |
| assert faults.fired("reader_a") == ["reader_a:" + fault], fault | |
| assert canonical.balanced(canonical.print_math(kind, changed)) is True, fault | |
| faults.configure(()) | |
| def test_a_reader_that_shifts_a_number_is_found_out_by_the_other_reader(): | |
| honest = _ask(ONE) | |
| shifted = _ask(ONE, ["reader_a:shift_number"]) | |
| assert honest["final"]["assurance"] > 0 | |
| assert shifted["final"]["state"] == "DISPUTED", shifted["final"] | |
| assert shifted["final"]["assurance"] == 0 | |
| assert shifted["final"]["answer"] == "" | |
| assert "disagree" in shifted["final"]["reasons"] or "literal_count" in shifted["final"]["reasons"] | |
| def test_a_math_layer_that_answers_another_sentence_is_reported_as_tampering(): | |
| tampered = _ask(ONE, ["boundary:tamper_math"]) | |
| assert tampered["final"]["state"] == "TAMPERED", tampered["final"] | |
| assert tampered["final"]["assurance"] == 0 | |
| assert tampered["final"]["answer"] == "" | |
| assert "boundary" in tampered["final"]["reasons"] | |
| def test_an_arbiter_that_lifts_the_assurance_is_overruled_by_the_tools(): | |
| honest = _ask(ONE) | |
| forced = _ask(ONE, ["arbiter:force_assurance"]) | |
| assert any(record["claimed"] != record["referee"] for record in forced["records"]), forced["records"] | |
| assert forced["final"]["assurance"] <= honest["final"]["assurance"], forced["final"] | |
| assert forced["final"]["assurance"] <= 2 | |
| assert "arbiter" in (forced["final"].get("detected") or []) | |
| def test_no_single_fault_lifts_the_assurance_above_the_honest_one(node): | |
| honest = _ask(ONE) | |
| for kind in faults.CATALOG[node]: | |
| outcome = _ask(ONE, ["%s:%s" % (node, kind)]) | |
| shown = outcome["final"] | |
| assert shown["assurance"] <= min(2, honest["final"]["assurance"]), (node, kind, shown) | |