paperproof-mcp 0.1.0__py3-none-any.whl

paperproof_mcp/__main__.py

@@ -0,0 +1,9 @@
+from paperproof_mcp.server import mcp
+
+
+def main():
+    mcp.run()
+
+
+if __name__ == "__main__":
+    main()

paperproof_mcp/converter.py

@@ -0,0 +1,375 @@
+"""
+Faithful port of Paperproof's app/src/services/converter.ts.
+
+Turns a LeanProofTree (list of ProofStep dicts, exactly as emitted by
+Paperproof's BetterParser) into a ConvertedProofTree (boxes + tactics + arrows).
+The input dicts use Paperproof's Lean JSON field names.
+"""
+from __future__ import annotations
+
+from typing import Any, Optional
+
+FAKE_POSITION = {"line": 0, "character": 0}
+
+
+class _Converter:
+    def __init__(self) -> None:
+        self.box_id = 1
+        self.tactic_id = 1
+        self.pretty: dict[str, Any] = {"boxes": [], "tactics": [], "equivalentIds": {}}
+
+    def _new_box_id(self) -> str:
+        v = str(self.box_id)
+        self.box_id += 1
+        return v
+
+    def _new_tactic_id(self) -> str:
+        v = str(self.tactic_id)
+        self.tactic_id += 1
+        return v
+
+    def get_displayed_id(self, id_: Optional[str]) -> Optional[str]:
+        if id_ is None:
+            return None
+        for displayed_id, inferiors in self.pretty["equivalentIds"].items():
+            if any(inferior == id_ for inferior in inferiors):
+                return displayed_id
+        return id_
+
+    def add_to_equivalent_ids(self, before_id: str, after_id: str) -> None:
+        key = self.get_displayed_id(before_id)
+        existing = self.pretty["equivalentIds"].get(key)
+        if existing is not None:
+            existing.append(after_id)
+        else:
+            self.pretty["equivalentIds"][before_id] = [after_id]
+
+    def get_box_by_goal_id(self, goal_id: str) -> Optional[dict]:
+        displayed = self.get_displayed_id(goal_id)
+        for box in self.pretty["boxes"]:
+            if any(g["id"] == displayed for g in box["goalNodes"]):
+                return box
+        return None
+
+    def create_new_box(self, parent_id: str) -> dict:
+        new_box = {
+            "id": self._new_box_id(),
+            "parentId": parent_id,
+            "goalNodes": [],
+            "hypLayers": [],
+            "hypTables": [],
+        }
+        self.pretty["boxes"].append(new_box)
+        return new_box
+
+    def _weird_situation(self, hyp_after: dict) -> None:
+        # A hyp changed name/type but kept its id: mutate the already-drawn node.
+        hyp_after_id = self.get_displayed_id(hyp_after["id"])
+        for box in self.pretty["boxes"]:
+            for layer in box["hypLayers"]:
+                for node in layer["hypNodes"]:
+                    if node["id"] == hyp_after_id:
+                        node["name"] = hyp_after["username"]
+                        node["text"] = hyp_after["type"]
+
+    def draw_new_hypothesis_layer(
+        self, hyps_before: list[dict], hyps_after: list[dict]
+    ) -> tuple[list[dict], list[dict]]:
+        pretty_hyp_nodes: list[dict] = []
+        pretty_hyp_arrows: list[dict] = []
+        hyps_after_matched: list[dict] = []
+        hyps_before_matched: list[dict] = []
+
+        # 1. Hyps clearly connected to a particular previous hyp.
+        for hyp_after in hyps_after:
+            hyp_before_by_id = next(
+                (h for h in hyps_before if h["id"] == hyp_after["id"]), None
+            )
+            hyp_before_by_name = next(
+                (
+                    hb
+                    for hb in hyps_before
+                    if hb["username"] == hyp_after["username"]
+                    and not any(
+                        h["id"] == hb["id"] and h["id"] != hyp_after["id"]
+                        for h in hyps_after
+                    )
+                ),
+                None,
+            )
+
+            if hyp_before_by_id:
+                hyps_after_matched.append(hyp_after)
+                hyps_before_matched.append(hyp_before_by_id)
+                same_name = hyp_after["username"] == hyp_before_by_id["username"]
+                same_type = hyp_after["type"] == hyp_before_by_id["type"]
+                if same_name and same_type:
+                    pass
+                else:
+                    self._weird_situation(hyp_after)
+            elif hyp_before_by_name:
+                hyps_after_matched.append(hyp_after)
+                hyps_before_matched.append(hyp_before_by_name)
+                same_id = hyp_after["id"] == hyp_before_by_name["id"]
+                same_type = hyp_after["type"] == hyp_before_by_name["type"]
+                if same_id and same_type:
+                    pass
+                elif same_id and not same_type:
+                    self._weird_situation(hyp_after)
+                elif not same_id and same_type:
+                    self.add_to_equivalent_ids(hyp_before_by_name["id"], hyp_after["id"])
+                else:
+                    pretty_hyp_nodes.append(
+                        {
+                            "text": hyp_after["type"],
+                            "name": hyp_after["username"],
+                            "id": hyp_after["id"],
+                            "isProof": hyp_after["isProof"],
+                        }
+                    )
+                    pretty_hyp_arrows.append(
+                        {
+                            "fromId": hyp_before_by_name["id"],
+                            "toIds": [hyp_after["id"]],
+                            "shardId": "temporary",
+                        }
+                    )
+
+        # 2. Hyps that disappeared / appeared from nowhere.
+        matched_before_ids = {h["id"] for h in hyps_before_matched}
+        matched_after_ids = {id(h) for h in hyps_after_matched}
+        hyps_before_disappeared = [
+            h for h in hyps_before if h["id"] not in matched_before_ids
+        ]
+        hyps_after_appeared = [
+            h for h in hyps_after if id(h) not in matched_after_ids
+        ]
+
+        if not hyps_before_disappeared and not hyps_after_appeared:
+            pass
+        elif not hyps_before_disappeared and hyps_after_appeared:
+            for hyp_after in hyps_after_appeared:
+                pretty_hyp_nodes.append(
+                    {
+                        "text": hyp_after["type"],
+                        "name": hyp_after["username"],
+                        "id": hyp_after["id"],
+                        "isProof": hyp_after["isProof"],
+                    }
+                )
+            pretty_hyp_arrows.append(
+                {
+                    "fromId": None,
+                    "toIds": [h["id"] for h in hyps_after_appeared],
+                    "shardId": "temporary",
+                }
+            )
+        elif hyps_before_disappeared and not hyps_after_appeared:
+            pass
+        else:
+            branching_hyp_before = hyps_before_disappeared[0]
+            for hyp_after in hyps_after_appeared:
+                pretty_hyp_nodes.append(
+                    {
+                        "text": hyp_after["type"],
+                        "name": hyp_after["username"],
+                        "id": hyp_after["id"],
+                        "isProof": hyp_after["isProof"],
+                    }
+                )
+            pretty_hyp_arrows.append(
+                {
+                    "fromId": branching_hyp_before["id"],
+                    "toIds": [h["id"] for h in hyps_after_appeared],
+                    "shardId": "temporary",
+                }
+            )
+
+        return pretty_hyp_nodes, pretty_hyp_arrows
+
+    def handle_tactic_app(self, tactic: dict) -> None:
+        goal_before = tactic["goalBefore"]
+        current_box = self.get_box_by_goal_id(goal_before["id"])
+        if not current_box:
+            return
+
+        goals_after = list(tactic["goalsAfter"])
+        pretty_goal_arrows: list[dict] = []
+        by_box_ids: list[str] = []
+        have_box_ids: list[str] = []
+
+        # CASE_1: `have`-like, spawnedGoals become haveBoxes.
+        if len(goals_after) == 1 and goals_after[0]["type"] == goal_before["type"]:
+            self.add_to_equivalent_ids(goal_before["id"], tactic["goalsAfter"][0]["id"])
+            boxes = []
+            for goal in tactic["spawnedGoals"]:
+                new_box = self.create_new_box("haveBox")
+                new_box["goalNodes"].append(
+                    {"text": goal["type"], "name": goal["username"], "id": goal["id"]}
+                )
+                boxes.append(new_box)
+            have_box_ids = [b["id"] for b in boxes]
+        else:
+            # CASE_2: anonymous `by` calls, spawnedGoals become byBoxes.
+            if len(tactic["goalsAfter"]) >= 1 and len(tactic["spawnedGoals"]) >= 1:
+                boxes = []
+                for goal in tactic["spawnedGoals"]:
+                    new_box = self.create_new_box("byBox")
+                    new_box["goalNodes"].append(
+                        {"text": goal["type"], "name": goal["username"], "id": goal["id"]}
+                    )
+                    boxes.append(new_box)
+                by_box_ids = [b["id"] for b in boxes]
+            # CASE_3: `calc` subgoals.
+            else:
+                for goal in tactic["spawnedGoals"]:
+                    goals_after.append({**goal, "isSpawned": True})
+
+            for goal in goals_after:
+                pretty_goal_arrows.append(
+                    {"fromId": goal_before["id"], "toId": goal["id"]}
+                )
+
+        pretty_hyp_arrows: list[dict] = []
+        tactic_id = self._new_tactic_id()
+        for goal in goals_after:
+            pretty_hyp_nodes, arrows_for_child = self.draw_new_hypothesis_layer(
+                goal_before["hyps"], goal["hyps"]
+            )
+            pretty_hyp_arrows.extend(arrows_for_child)
+
+            box = (
+                self.create_new_box(current_box["id"])
+                if len(goals_after) > 1
+                else current_box
+            )
+            last_goal = box["goalNodes"][-1] if box["goalNodes"] else None
+            if not last_goal or last_goal["text"] != goal["type"]:
+                box["goalNodes"].append(
+                    {"text": goal["type"], "name": goal["username"], "id": goal["id"]}
+                )
+            if pretty_hyp_nodes:
+                box["hypLayers"].append(
+                    {"tacticId": tactic_id, "hypNodes": pretty_hyp_nodes}
+                )
+
+        self.pretty["tactics"].append(
+            {
+                "id": tactic_id,
+                "text": tactic["tacticString"],
+                "dependsOnIds": tactic["tacticDependsOn"],
+                "goalArrows": pretty_goal_arrows,
+                "hypArrows": pretty_hyp_arrows,
+                "successGoalId": goal_before["id"] if len(goals_after) == 0 else None,
+                "haveBoxIds": have_box_ids,
+                "byBoxIds": by_box_ids,
+                "position": tactic["position"],
+                "theorems": tactic["theorems"],
+            }
+        )
+
+    def draw_initial_goal(self, lean_proof_tree: list[dict]) -> None:
+        tactic_id = self._new_tactic_id()
+        initial_goal = lean_proof_tree[0]["goalBefore"]
+        hyp_nodes = [
+            {
+                "text": hyp["type"],
+                "name": hyp["username"],
+                "id": hyp["id"],
+                "isProof": hyp["isProof"],
+            }
+            for hyp in initial_goal["hyps"]
+        ]
+        initial_box = {
+            "id": self._new_box_id(),
+            "parentId": None,
+            "goalNodes": [
+                {
+                    "text": initial_goal["type"],
+                    "name": initial_goal["username"],
+                    "id": initial_goal["id"],
+                }
+            ],
+            "hypLayers": [{"tacticId": tactic_id, "hypNodes": hyp_nodes}]
+            if hyp_nodes
+            else [],
+            "hypTables": [],
+        }
+        self.pretty["boxes"].append(initial_box)
+        self.pretty["tactics"].append(
+            {
+                "id": tactic_id,
+                "text": "init",
+                "dependsOnIds": [],
+                "goalArrows": [],
+                "hypArrows": [
+                    {
+                        "fromId": None,
+                        "toIds": [n["id"] for n in hyp_nodes],
+                        "shardId": "temporary",
+                    }
+                ],
+                "haveBoxIds": [],
+                "byBoxIds": [],
+                "position": {"start": FAKE_POSITION, "stop": FAKE_POSITION},
+                "theorems": [],
+            }
+        )
+
+    def postprocess(self) -> None:
+        for tactic in self.pretty["tactics"]:
+            tactic["goalArrows"] = [
+                {
+                    "fromId": self.get_displayed_id(a["fromId"]),
+                    "toId": self.get_displayed_id(a["toId"]),
+                }
+                for a in tactic["goalArrows"]
+            ]
+            tactic["hypArrows"] = [
+                {
+                    "shardId": str(index),
+                    "fromId": self.get_displayed_id(a["fromId"]),
+                    "toIds": [self.get_displayed_id(t) for t in a["toIds"]],
+                }
+                for index, a in enumerate(tactic["hypArrows"])
+            ]
+            tactic["dependsOnIds"] = [
+                self.get_displayed_id(i) for i in tactic["dependsOnIds"]
+            ]
+            if tactic.get("successGoalId"):
+                tactic["successGoalId"] = self.get_displayed_id(tactic["successGoalId"])
+
+
+def _remove_particular_hyps_from_tactic(tactic: dict) -> None:
+    # Universe hyps are `variable` noise (common in Mathlib) with nothing to do
+    # with the proof.
+    goals = [*tactic["goalsAfter"], tactic["goalBefore"], *tactic["spawnedGoals"]]
+    for goal in goals:
+        goal["hyps"] = [h for h in goal["hyps"] if h["isProof"] != "universe"]
+
+
+def _filter_backtracking_steps(steps: list[dict]) -> list[dict]:
+    # Steps can be generated by backtracking (e.g. `first | ... | ...`); keep only
+    # the last step from each goal.
+    result: list[dict] = []
+    from_goals = [s["goalBefore"]["id"] for s in steps]
+    for i in range(len(steps)):
+        if from_goals[i] not in from_goals[i + 1:]:
+            result.append(steps[i])
+    return result
+
+
+def converter(lean_proof_tree: list[dict]) -> dict:
+    c = _Converter()
+    if not lean_proof_tree:
+        return c.pretty
+
+    for tactic in lean_proof_tree:
+        _remove_particular_hyps_from_tactic(tactic)
+    lean_proof_tree = _filter_backtracking_steps(lean_proof_tree)
+
+    c.draw_initial_goal(lean_proof_tree)
+    for tactic in lean_proof_tree:
+        c.handle_tactic_app(tactic)
+    c.postprocess()
+    return c.pretty