File size: 6,169 Bytes
875f067
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
"""The envelope of one turn: what a node receives, what it hands back, and what survives the trip.

A dossier is a nest of exact rationals, and the channel between two nodes is a JSON string inside a
natural language field. The two things that have to survive that trip are the value of a number and
the memory of what the earlier nodes saw, so these tests watch both closely: a number that arrives
rounded, or a dossier that arrives with the earlier turns forgotten, would silently turn a verified
answer into an unsupported one.
"""

import json
import re
from fractions import Fraction
from pathlib import Path

import pytest

from lgphys import agents, families, pipeline, protocol, smt

ROOT = Path(__file__).resolve().parents[1]
CONVERT = "convert 5 km/h to m/s"


def _chain(question: str):
    """Run the eleven nodes the way the orchestrator would, one envelope at a time."""
    seed = json.loads((ROOT / "nodes" / "arbiter" / "seed_payload.json").read_text(encoding="utf-8"))
    seed["payload"]["naturalLanguage"] = question
    seed["payload"]["abstractSyntaxTree"] = "PhysicsProblem " + question
    handed, envelopes = seed, []
    for name in agents.ALL_AGENTS:
        handed = protocol.respond(name, handed, name)
        envelopes.append(handed)
    return envelopes


def test_a_fraction_survives_the_trip_unchanged():
    dossier = protocol.start(CONVERT)
    dossier["roads"] = {"read_a": Fraction(25, 18), "read_b": Fraction(25, 18)}
    text = protocol.encode(CONVERT, dossier)
    assert "25/18" in text
    assert not re.search(r"\d+\.\d", text), "a decimal point in an exact rational"
    problem, back = protocol.decode(text)
    assert problem == CONVERT
    assert Fraction(back["roads"]["read_a"]) == Fraction(25, 18)
    assert Fraction(back["roads"]["read_b"]) == Fraction(25, 18)


def test_the_marker_keeps_the_prose_and_the_memory_apart():
    text = protocol.encode(CONVERT, protocol.start(CONVERT))
    assert text.startswith(CONVERT + "\n" + protocol.MARK)
    assert text.count(protocol.MARK) == 1


def test_an_envelope_carries_the_three_parts_of_a_claim():
    claim = (["declare-fun x () Int"], ["(assert (> x 0))"], "sat")
    envelope = protocol.envelope("reader_a", "arbiter", 3, 7, CONVERT, protocol.start(CONVERT), claim)
    assert envelope["sender"] == "reader_a" and envelope["recipient"] == "arbiter"
    assert envelope["turn"] == 3 and envelope["volatileState"]["internalTimeTick"] == 7
    payload = envelope["payload"]
    assert payload["abstractSyntaxTree"].startswith("PhysicsProblem")
    assert payload["smtConstraints"] == {"declarations": ["declare-fun x () Int"],
                                         "assertions": ["(assert (> x 0))"], "z3Status": "sat"}


def test_an_envelope_without_a_recipient_omits_the_field():
    envelope = protocol.envelope("arbiter", None, 0, 0, "", protocol.start(""), ([], ["(assert true)"], "sat"))
    assert "recipient" not in envelope


def test_a_node_echoes_the_turn_it_was_handed():
    handed = protocol.envelope("reader_b", "reader_a", 4, 11, CONVERT, protocol.start(CONVERT),
                               ([], ["(assert true)"], "sat"))
    outgoing = protocol.respond("reader_a", handed, "reader_a")
    # The orchestrator keeps the count of the turns; a node that booked its own turn would end the
    # session early or run it past the pipeline the topology declares.
    assert outgoing["turn"] == 4
    assert outgoing["volatileState"]["internalTimeTick"] == 11
    assert outgoing["sender"] == "reader_a" and outgoing["recipient"] == "reader_b"


def test_a_node_that_stops_leaves_a_note_instead_of_stopping_the_chain(monkeypatch):
    def explode(role, dossier):
        raise ZeroDivisionError("the reading fell over")

    monkeypatch.setattr(agents, "run_step", explode)
    handed = protocol.envelope("domain_a", "reader_b", 2, 5, CONVERT, protocol.start(CONVERT),
                               ([], ["(assert true)"], "sat"))
    outgoing = protocol.respond("domain_a", handed, "domain_a")
    _problem, dossier = protocol.decode(outgoing["payload"]["naturalLanguage"])
    assert "ZeroDivisionError" in dossier["crash"]["domain_a"]
    assert outgoing["payload"]["smtConstraints"]["assertions"] == ["(assert true)"]
    assert outgoing["payload"]["smtConstraints"]["z3Status"] == "sat"


@pytest.fixture(scope="module")
def envelopes():
    """One chain run, shared by the tests that read it: eleven nodes and one question."""
    return _chain(CONVERT)


@pytest.fixture(scope="module")
def carried(envelopes):
    """The dossier as it stands in the last envelope of that chain."""
    return protocol.decode(envelopes[-1]["payload"]["naturalLanguage"])[1]


@pytest.fixture(scope="module")
def referee(envelopes):
    """Each claim re-checked by Z3 over the ontology of the node that wrote it."""
    checked = []
    for name, envelope in zip(agents.ALL_AGENTS, envelopes):
        base = (ROOT / "nodes" / name / "ontology.smt2").read_text(encoding="utf-8")
        constraints = envelope["payload"]["smtConstraints"]
        checked.append({"sender": name, "claimed": constraints["z3Status"],
                        "referee": smt.referee(base, constraints["declarations"],
                                               constraints["assertions"])})
    return checked


def test_the_chain_hands_the_same_answer_through_envelopes_as_in_one_process(carried):
    assert not carried.get("crash"), carried.get("crash")
    inside = pipeline.run(CONVERT)
    assert carried.get("answer") == inside["dossier"].get("answer")
    assert sorted(carried.get("states")) == sorted(agents.ALL_AGENTS)


def test_every_claim_holds_against_the_ontology_of_the_node_that_made_it(referee):
    for record in referee:
        assert record["referee"] == record["claimed"], record


def test_the_verdict_of_the_envelope_chain_is_the_verdict_of_the_session(carried, referee):
    decision = pipeline.checked_verdict(carried, referee)
    assert decision["status"] == "VERIFIED"
    assert decision["assurance"] == 2
    family = families.family_for(str(carried.get("kind")))
    assert family.gold_equal(carried["answer"], {"value": "25/18", "unit": "m/s"})