File size: 8,760 Bytes
e9dac18
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
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
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
#!/usr/bin/env python3
"""Ask a question in a human language and get the answer of the math stratum back in that language.

    python tools/ask.py --lang it "risolvi x^2 - 5*x + 6 = 0 per x"
    python tools/ask.py --lang en "solve x^2 - 5*x + 6 = 0 for x" --json
    python tools/ask.py --lang ar --corpus problems/corpus.jsonl --limit 6

Run from this folder (it is ``datasets/math-stratum`` inside the LingoLOGOS repository, and the
bundle root when the dataset is cloned on its own).

The script builds a throw away workspace (node datasets, seed with the question and its language,
launcher), runs the eight node processes through ``MultiInstanceOrchestrator``, and then re-derives
the verdict from the transcript: it recomputes the arbiter's decision from the evidence the envelopes
carry, and checks that the Z3 run of the orchestrator agrees with what every node claimed about its
own envelope. What is printed is that re-derived verdict, not the one the arbiter wrote.

The prose of this script and of its labels stays English, as the repository requires; the answer
block is the one piece of data that is deliberately written in the language of the question, because
that answer is the object this bundle studies.
"""

import argparse
import json
import os
import shutil
import stat
import sys
import tempfile
from pathlib import Path
from typing import Any, Dict, List

ROOT = Path(__file__).resolve().parents[1]
sys.path.insert(0, str(ROOT))
# Inside the repository this bundle sits at <repo>/datasets/math-stratum, so the orchestrator
# package is no longer a sibling of the bundle. Walk up the tree until an ancestor carries it.
for _parent in ROOT.parents:
    _candidate = _parent / "src"
    if (_candidate / "lingologos_orchestrator").is_dir():
        sys.path.insert(0, str(_candidate))
        break

from lgstratum import corpus, pipeline, protocol, render  # noqa: E402


def _launcher(directory: Path) -> Path:
    agent = ROOT / "agents" / "stratum_agent"
    if os.name == "nt":
        path = directory / "stratum_agent.cmd"
        path.write_text('@echo off\r\n"%s" "%s" %%*\r\n' % (sys.executable, agent))
    else:
        path = directory / "stratum_agent.sh"
        path.write_text('#!/bin/sh\nexec "%s" "%s" "$@"\n' % (sys.executable, agent))
        path.chmod(path.stat().st_mode | stat.S_IXUSR | stat.S_IXGRP | stat.S_IXOTH)
    return path


def ask(question: str, lang: str, faults_spec: str = "", keep: bool = False) -> Dict[str, Any]:
    """Run one question through the real orchestrator and return the checked verdict."""
    from lingologos_orchestrator.orchestrator import MultiInstanceOrchestrator
    from lingologos_orchestrator.schema import OrchestratorError

    workspace = Path(tempfile.mkdtemp(prefix="lgstratum_"))
    try:
        datasets = workspace / "datasets"
        shutil.copytree(ROOT / "nodes", datasets)
        seed_path = datasets / "arbiter" / "seed_payload.json"
        seed = json.loads(seed_path.read_text(encoding="utf-8"))
        seed["payload"]["naturalLanguage"] = pipeline.seed(question, lang)["payload"]["naturalLanguage"]
        seed_path.write_text(json.dumps(seed, ensure_ascii=False), encoding="utf-8")
        launcher = _launcher(workspace)
        topology = json.loads((ROOT / "topology.json").read_text(encoding="utf-8"))
        for instance in topology["instances"]:
            instance["executable"] = str(launcher)
        topology_path = workspace / "topology.json"
        topology_path.write_text(json.dumps(topology), encoding="utf-8")
        previous = os.environ.get("LGSTRATUM_FAULTS")
        os.environ["LGSTRATUM_FAULTS"] = faults_spec
        try:
            orchestrator = MultiInstanceOrchestrator.from_config_file(
                config_path=topology_path, datasets_dir=datasets,
                runtime_state_dir=workspace / "runtime_state", workspace_dir=workspace)
            result = orchestrator.run_session().to_dict()
        except OrchestratorError as exc:
            return {"final": _unknown("orchestrator error: %s" % str(exc)[:200]), "referee": [],
                    "records": [], "reply": None}
        finally:
            if previous is None:
                os.environ.pop("LGSTRATUM_FAULTS", None)
            else:
                os.environ["LGSTRATUM_FAULTS"] = previous
        return _check(result)
    finally:
        if keep:
            print("workspace kept at %s" % workspace, file=sys.stderr)
        else:
            shutil.rmtree(workspace, ignore_errors=True)


def _unknown(reason: str) -> Dict[str, Any]:
    return {"state": "NONE", "assurance": 0, "ceiling": 0, "math_assurance": 0, "math_status": None,
            "answer": "", "reasons": [reason], "consulted_math": False, "detected": []}


def _check(result: Dict[str, Any]) -> Dict[str, Any]:
    records: List[Dict[str, Any]] = result["records"]
    referee = [{"sender": r["sender"], "claimed": r["envelope"]["payload"]["smtConstraints"]["z3Status"],
                "referee": r["smt_result"]["status"]} for r in records]
    dossier = protocol.decode(records[-1]["envelope"]["payload"]["naturalLanguage"])
    final = pipeline.checked_verdict(dossier, referee, arbiter_expected=True)
    return {"final": final, "referee": referee, "records": referee, "transcript": records,
            "dossier": dossier, "reply": render.reply(dossier, final, referee), "turns": result["total_turns"]}


def _describe(outcome: Dict[str, Any]) -> str:
    final = outcome["final"]
    lines = []
    lines.append("Reading state         : %s" % final["state"])
    lines.append("Assurance shown       : %d (reading ceiling %d, math assurance %s)"
                 % (final["assurance"], final.get("ceiling", 0),
                    final.get("math_assurance")))
    lines.append("Math layer status     : %s" % (final.get("math_status") or "-"))
    if final["reasons"]:
        lines.append("Notes                 : %s" % "; ".join(final["reasons"]))
    if final.get("detected"):
        lines.append("Detected              : %s" % ", ".join(str(item) for item in final["detected"]))
    if outcome["referee"]:
        agree = sum(1 for r in outcome["referee"] if r["claimed"] == r["referee"])
        lines.append("Orchestrator Z3 check : %d of %d envelopes confirmed" % (agree, len(outcome["referee"])))
    reply = outcome.get("reply")
    if reply:
        lines.append("")
        lines.append("Answer in the language of the question (%s):" % reply["language"])
        for line in reply["lines"]:
            lines.append("  %s" % line)
    return "\n".join(lines)


def main() -> int:
    parser = argparse.ArgumentParser(description=__doc__, formatter_class=argparse.RawDescriptionHelpFormatter)
    parser.add_argument("question", nargs="?", help="the question, written in the language given by --lang")
    parser.add_argument("--lang", default="it", help="language of the question: it, en, es, zh, hi or ar")
    parser.add_argument("--json", action="store_true", help="print the full machine readable outcome")
    parser.add_argument("--faults", default="", help="comma separated node:fault pairs (experiments only)")
    parser.add_argument("--keep", action="store_true", help="keep the temporary workspace")
    parser.add_argument("--corpus", help="run every question of a corpus file and compare with its gold expectations")
    parser.add_argument("--limit", type=int, default=0, help="with --corpus: only the first N questions")
    args = parser.parse_args()
    if args.corpus:
        rows = corpus.load(args.corpus)
        rows = rows[: args.limit] if args.limit else rows
        tally: Dict[str, int] = {}
        for item in rows:
            outcome = ask(item["question"], item["lang"], args.faults, args.keep)
            verdict = corpus.grade(item, outcome)
            label = "ok" if verdict["ok"] else "wrong"
            tally[label] = tally.get(label, 0) + 1
            print("%-8s %-6s %-14s %s" % (verdict["id"], label, verdict["state"], item["question"]))
            for problem in verdict["problems"]:
                print("         %s" % problem)
        print(json.dumps(tally, sort_keys=True))
        return 0 if tally.get("wrong", 0) == 0 else 1
    if not args.question:
        parser.error("a question or --corpus is required")
    outcome = ask(args.question, args.lang, args.faults, args.keep)
    if args.json:
        printable = {key: value for key, value in outcome.items() if key != "records"}
        print(json.dumps(printable, indent=2, ensure_ascii=False, default=str))
    else:
        print(_describe(outcome))
    if outcome["final"].get("detected"):
        return 3
    return 0 if int(outcome["final"].get("assurance", 0) or 0) > 0 else 2


if __name__ == "__main__":
    sys.exit(main())