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_decide.py from tailot/math-stratum: direct link, hf CLI and curl.
- Browser
- Download file 7.11 kB
-
https://huggingface.co/datasets/tailot/math-stratum/resolve/main/tests/test_decide.py
- Command line
-
hf download hf://datasets/tailot/math-stratum/tests/test_decide.py
-
curl -L -o test_decide.py https://huggingface.co/datasets/tailot/math-stratum/resolve/main/tests/test_decide.py
7.11 kB
| """The decision rule, and the ceiling that the stratum is not allowed to cross.""" | |
| import copy | |
| from lgstratum import decide, pipeline | |
| def _reading(sentence, kind="evaluate", slots=None, notes=()): | |
| return {"status": "READ", "kind": kind, "math": sentence, "slots": slots or {}, "notes": list(notes)} | |
| def _math(status="VERIFIED", assurance=3, answer="4", sentence="evaluate 2+2", **extra): | |
| verdict = {"status": status, "assurance": assurance, "answer_text": answer, "problem_math": sentence} | |
| verdict.update(extra) | |
| return verdict | |
| def _dossier(readings, comparison, coverage, math_verdict, direct=None, echo_ok=True): | |
| dossier = {"question": "quanto fa 2+2?", "lang": "it", "sent": "evaluate 2+2", | |
| "reading_a": readings[0] if len(readings) > 0 else {}, | |
| "reading_b": readings[1] if len(readings) > 1 else {}, | |
| "compare": comparison, "coverage": coverage, "math": math_verdict, | |
| "echo_ok": echo_ok} | |
| if direct is not None: | |
| dossier["reading_direct"] = direct | |
| return dossier | |
| def test_no_state_carries_the_top_level_of_the_math_stratum(): | |
| # Three belongs to the math stratum: it is what its own two formalizers and two checkers give a | |
| # proved sentence. A question written in a human language adds one fallible step before that, so | |
| # every state of this stratum is capped below three. | |
| assert set(decide.STATES) == set(decide.CEILING) | |
| assert max(decide.CEILING.values()) == 2 | |
| for state in decide.STATES: | |
| assert decide.CEILING[state] < 3, state | |
| def test_two_agreeing_readers_take_the_minimum_with_the_math_answer(): | |
| readings = [_reading("evaluate 2+2"), _reading("evaluate 2+2")] | |
| for status, assurance, expected in (("VERIFIED", 3, 2), ("SINGLE_PROVER", 2, 2), ("UNKNOWN", 0, 0)): | |
| final = decide.decide(_dossier(readings, {"same": True}, {"ok": True}, | |
| _math(status, assurance, "" if status == "UNKNOWN" else "4"))) | |
| assert final["state"] == "AGREED" | |
| assert final["ceiling"] == 2 | |
| assert final["assurance"] == min(2, assurance), (status, final) | |
| assert final["math_assurance"] == assurance | |
| def test_a_missing_witness_caps_the_session_at_one(): | |
| readings = [_reading("evaluate 2+2"), {}] | |
| final = decide.decide(_dossier(readings, None, None, _math())) | |
| assert final["state"] == "SINGLE" | |
| assert final["assurance"] == 1 | |
| # The cap is not the only thing that holds with one reader: the count of literals still does, so a | |
| # witness that stands alone does not thereby get to answer another problem. | |
| kept = decide.decide(_dossier(readings, None, {"ok": True}, _math())) | |
| assert kept["state"] == "SINGLE" | |
| assert kept["assurance"] == 1 | |
| def test_a_lone_reading_that_lost_a_number_answers_a_different_problem(): | |
| # What the ablation of the topology found: with the second reader switched out, a number shifted by | |
| # the first one used to reach the person as a single witness answer. The ceiling said one, but the | |
| # answer was of another problem, so the count of the literals refuses it instead. | |
| readings = [_reading("evaluate 2+3"), {}] | |
| final = decide.decide(_dossier(readings, None, {"ok": False}, _math(sentence="evaluate 2+3"))) | |
| assert final["state"] == "DISPUTED" | |
| assert final["assurance"] == 0 | |
| assert final["answer"] == "" | |
| assert "literal_count" in final["reasons"] | |
| def test_a_question_that_announces_two_kinds_of_problem_is_left_to_the_user(): | |
| readings = [{"status": "AMBIGUOUS", "kind": None, "math": "", "slots": {}, | |
| "notes": [{"reason": "two_verbs"}]}, {}] | |
| final = decide.decide(_dossier(readings, None, None, None)) | |
| assert final["state"] == "AMBIGUOUS" | |
| assert final["ceiling"] == 0 | |
| assert final["assurance"] == 0 | |
| assert "two_verbs" in final["reasons"] | |
| def test_a_question_this_language_does_not_write_is_not_covered(): | |
| final = decide.decide(_dossier([{}, {}], None, None, None)) | |
| assert final["state"] == "NOT COVERED" | |
| assert final["assurance"] == 0 | |
| assert final["consulted_math"] is False | |
| assert final["answer"] == "" | |
| def test_a_disagreement_is_never_resolved_by_the_math_stratum(): | |
| readings = [_reading("evaluate 2+2"), _reading("evaluate 2+3")] | |
| final = decide.decide(_dossier(readings, {"same": False, "why": "text"}, {"ok": True}, _math())) | |
| assert final["state"] == "DISPUTED" | |
| assert final["assurance"] == 0 | |
| assert final["answer"] == "" | |
| assert "disagree" in final["reasons"] | |
| def test_a_reading_that_lost_a_number_is_disputed_even_when_the_readers_agree(): | |
| readings = [_reading("evaluate 2+2"), _reading("evaluate 2+2")] | |
| final = decide.decide(_dossier(readings, {"same": True}, {"ok": False}, _math())) | |
| assert final["state"] == "DISPUTED" | |
| assert "literal_count" in final["reasons"] | |
| assert final["assurance"] == 0 | |
| def test_an_echo_that_names_another_sentence_is_reported_as_tampering(): | |
| readings = [_reading("evaluate 2+2"), _reading("evaluate 2+2")] | |
| final = decide.decide(_dossier(readings, {"same": True}, {"ok": True}, _math(), echo_ok=False)) | |
| assert final["state"] == "TAMPERED" | |
| assert final["assurance"] == 0 | |
| assert "boundary" in final["reasons"] | |
| def test_a_sentence_already_written_in_the_math_language_passes_through(): | |
| direct = {"kind": "evaluate", "math": "evaluate 2+2", "slots": {"T": "2+2"}} | |
| final = decide.decide(_dossier([{}, {}], None, {"ok": True}, _math(), direct=direct)) | |
| assert final["state"] == "PASSTHROUGH" | |
| assert final["ceiling"] == 2 | |
| assert final["assurance"] == 2 | |
| def test_no_answer_is_shown_when_the_math_stratum_did_not_answer(): | |
| readings = [_reading("evaluate 2+2"), _reading("evaluate 2+2")] | |
| final = decide.decide(_dossier(readings, {"same": True}, {"ok": True}, _math("UNKNOWN", 0, ""))) | |
| assert final["assurance"] == 0 | |
| assert final["answer"] == "" | |
| assert "math_unknown" in final["reasons"] | |
| def test_the_decision_is_pure_and_leaves_the_evidence_as_it_found_it(): | |
| dossier = _dossier([_reading("evaluate 2+2"), _reading("evaluate 2+2")], {"same": True}, | |
| {"ok": True}, _math()) | |
| before = copy.deepcopy(dossier) | |
| first = decide.decide(dossier) | |
| second = decide.decide(dossier) | |
| assert first == second | |
| assert dossier == before | |
| def test_a_claimed_assurance_is_marked_and_the_tools_lower_it_again(): | |
| honest = decide.decide(_dossier([_reading("evaluate 2+2"), _reading("evaluate 2+2")], | |
| {"same": True}, {"ok": True}, _math())) | |
| forced = decide.raise_assurance(honest, 3) | |
| assert forced["assurance"] == 3 | |
| assert forced["claimed_above_evidence"] is True | |
| # The tools do not show what the arbiter wrote: they re-run the decision on the transcript, and | |
| # what stands is the more cautious of the two. | |
| checked = pipeline.referee_adjusted(forced, [{"sender": "arbiter", "claimed": "unsat", "referee": "sat"}]) | |
| assert checked["assurance"] <= min(2, honest["assurance"]) | |
| assert "arbiter" in (checked.get("detected") or []) | |