morphata 2.0.6__tar.gz → 2.0.7__tar.gz

{morphata-2.0.6 → morphata-2.0.7}/CHANGELOG.md

@@ -1,5 +1,12 @@
 # Changelog
 
+## 2.0.7 — 2026-06-02
+
+### Fixed
+
+- The BDD JSON exporter in `dd.cudd` needed to be worked around because of a bug where
+  `mgr.true` and `mrg.false` do not survive a round trip serialization.
+
 ## 2.0.6 — 2026-06-02
 
 ### Fixed

{morphata-2.0.6 → morphata-2.0.7}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: morphata
-Version: 2.0.6
+Version: 2.0.7
 Summary: Representation theory for automata, made practical.
 Project-URL: Documentation, https://docs.anandb.dev/morphata
 Project-URL: Repository, https://git.anandb.dev/morphata.git

{morphata-2.0.6 → morphata-2.0.7}/pyproject.toml

@@ -2,7 +2,7 @@
 name = "morphata"
 authors = [{ name = "Anand Balakrishnan", email = "anandbala1597@gmail.com" }]
 description = "Representation theory for automata, made practical."
-version = "2.0.6"
+version = "2.0.7"
 requires-python = ">=3.12"
 classifiers = [
   "Intended Audience :: Science/Research",

{morphata-2.0.6 → morphata-2.0.7}/src/morphata/symbolic/persistence.py

@@ -189,6 +189,23 @@ def to_bdd_json(sym: "SymbolicAutomaton[Any]", path: str | Path) -> None:
             rows_for_s.append([g_name, s_name])
         transitions_layout[str(s)] = rows_for_s
 
+    # dd's JSON dump/load round-trip is buggy for terminal roots on the
+    # CUDD backend: ``_dump_bdd_info`` emits a numeric id for True/False
+    # roots while ``_dump_bdd`` short-circuits terminals as ``"T"`` /
+    # ``"F"`` and never writes a body for those ids, so ``manager.load``
+    # raises KeyError. Sidestep by filtering terminal roots out of the
+    # dict handed to dd.dump and recording their names in the sidecar.
+    true_root_names: list[str] = []
+    false_root_names: list[str] = []
+    bdd_roots: dict[str, Function] = {}
+    for name, node in roots.items():
+        if node == mgr.true:
+            true_root_names.append(name)
+        elif node == mgr.false:
+            false_root_names.append(name)
+        else:
+            bdd_roots[name] = node
+
     ap_registry_json: dict[str, str] = {}
     for ap, var in sym.ap_registry.items():
         if not isinstance(ap, str):
@@ -207,13 +224,22 @@ def to_bdd_json(sym: "SymbolicAutomaton[Any]", path: str | Path) -> None:
         "ap_var_format": AP_VAR_FORMAT,
         "initial_root_name": "initial",
         "transitions": transitions_layout,
+        "true_root_names": sorted(true_root_names),
+        "false_root_names": sorted(false_root_names),
+        # dd's dump raises if roots={}, so flag the all-terminal case and
+        # skip the BDD file altogether; the sidecar carries everything.
+        "bdd_file_empty": not bdd_roots,
     }
 
-    mgr.dump(str(bdd_partial), roots=roots, filetype="json")
+    if bdd_roots:
+        mgr.dump(str(bdd_partial), roots=bdd_roots, filetype="json")
     with open(meta_partial, "w") as f:
         json.dump(meta, f, indent=2, sort_keys=True)
 
-    bdd_partial.replace(bdd_path)
+    if bdd_roots:
+        bdd_partial.replace(bdd_path)
+    elif bdd_path.exists():
+        bdd_path.unlink()
     meta_partial.replace(meta_path)
 
 
@@ -267,14 +293,23 @@ def from_bdd_json(
     if to_add:
         manager.declare(*to_add)
 
-    loaded = manager.load(str(bdd_path))
-    if not isinstance(loaded, dict):
-        raise ValueError(
-            f"BDD JSON load returned {type(loaded).__name__}; expected a "
-            "dict of named roots. The file may have been written by a "
-            "different tool."
-        )
-    roots: dict[str, Function] = loaded
+    if meta.get("bdd_file_empty", False):
+        roots: dict[str, Function] = {}
+    else:
+        loaded = manager.load(str(bdd_path))
+        if not isinstance(loaded, dict):
+            raise ValueError(
+                f"BDD JSON load returned {type(loaded).__name__}; expected a "
+                "dict of named roots. The file may have been written by a "
+                "different tool."
+            )
+        roots = loaded
+
+    # Restore terminal roots that were filtered out at dump time.
+    for name in meta.get("true_root_names", []):
+        roots[name] = manager.true
+    for name in meta.get("false_root_names", []):
+        roots[name] = manager.false
 
     initial_name = meta["initial_root_name"]
     try:

{morphata-2.0.6 → morphata-2.0.7}/tests/symbolic/test_persistence.py

@@ -112,6 +112,56 @@ class TestAcceptanceRoundTrip:
         assert _acceptance_from_json(_acceptance_to_json(cond)) == cond
 
 
+class TestTerminalRoots:
+    """Regression tests for the dd CUDD-backend terminal-root dump bug.
+
+    Why: ``mgr.dump(..., filetype='json')`` emits a numeric node id for
+    True/False roots without a body, and ``mgr.load`` then KeyError's
+    when looking up that id. ``to_bdd_json`` works around it by lifting
+    terminal roots into the sidecar.
+    """
+
+    def test_a_u_b_round_trip(self, tmp_path: Path) -> None:
+        # Min-DFA for `a U b` has a True-guarded accepting sink; the
+        # row pointing at it produces a terminal-True succ root.
+        a = logic.Variable("a")
+        b = logic.Variable("b")
+        builder = AutomatonBuilder[int, str]()
+        builder.add_state(0, initial=True)
+        builder.add_state(1, accepting=True)
+        builder.add_state(2)
+        builder.add_transition(0, b, 1)
+        builder.add_transition(0, logic.And((a, logic.Not(b))), 0)
+        builder.add_transition(0, logic.And((logic.Not(a), logic.Not(b))), 2)
+        builder.add_transition(1, logic.Literal(True), 1)
+        builder.add_transition(2, logic.Literal(True), 2)
+        aut = builder.build()
+        sym = SymbolicAutomaton.from_automaton(aut, alphabet=powerset_alphabet(aut.predicates))
+
+        cache = tmp_path / "aub.bdd.json"
+        sym.to_bdd_json(cache)
+        loaded = SymbolicAutomaton.from_bdd_json(cache, alphabet=powerset_alphabet(frozenset(sym.ap_registry)))
+        assert loaded.num_states == sym.num_states
+        assert loaded.accepting_states == sym.accepting_states
+        assert language_equivalent(sym, loaded)
+
+    def test_all_terminal_roots(self, tmp_path: Path) -> None:
+        # 1-state automaton, only edge is a True-guarded self-loop.
+        # Every root (initial + guard + succ) is terminal.
+        builder = AutomatonBuilder[int, str]()
+        builder.add_state(0, initial=True, accepting=True)
+        builder.add_transition(0, logic.Literal(True), 0)
+        aut = builder.build()
+        sym = SymbolicAutomaton.from_automaton(aut, alphabet=powerset_alphabet(aut.predicates))
+
+        cache = tmp_path / "one.bdd.json"
+        sym.to_bdd_json(cache)
+        loaded = SymbolicAutomaton.from_bdd_json(cache, alphabet=powerset_alphabet(frozenset(sym.ap_registry)))
+        assert loaded.num_states == 1
+        assert loaded.accepting_states == frozenset({0})
+        assert language_equivalent(sym, loaded)
+
+
 class TestSchemaGuard:
     def test_mismatched_schema_version_raises(self, tmp_path: Path) -> None:
         sym = _two_state_dfa()

{morphata-2.0.6 → morphata-2.0.7}/uv.lock

@@ -1049,7 +1049,7 @@ wheels = [
 
 [[package]]
 name = "morphata"
-version = "2.0.6"
+version = "2.0.7"
 source = { editable = "." }
 dependencies = [
     { name = "algebraic-arrays" },