morphata 2.0.5__tar.gz → 2.0.7__tar.gz

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

@@ -1,5 +1,25 @@
 # 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
+
+- A major regression where the streaming `to_hoa` stuff changed the label enumeration
+  semantics to be _minterms_ instead of _cubes_.
+  This is now fixed.
+
+### Added
+
+- Added a free-floating function that helps enumerate the successor BDDs from a symbolic
+  automaton state, given a specific alphabet and set of symbols.
+
 ## 2.0.5 — 2026-06-01
 
 ### Added

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: morphata
-Version: 2.0.5
+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.5 → 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.5"
+version = "2.0.7"
 requires-python = ">=3.12"
 classifiers = [
   "Intended Audience :: Science/Research",

{morphata-2.0.5 → morphata-2.0.7}/src/morphata/hoa/exporter.py

@@ -136,11 +136,13 @@ def symbolic_automaton_to_hoa(
     """Serialize a :class:`SymbolicAutomaton` to HOA v1 directly from its BDDs.
 
     Walks ``sym.transitions`` row-by-row. For each cached
-    ``(guard_bdd, succ_bdd)`` pair, enumerates AP-cubes of ``guard_bdd``
-    via ``BDD.pick_iter`` (over the BDD's support, no ``care_vars``) and
-    successor-state cubes of ``succ_bdd`` the same way, and emits one
-    HOA ``[label] dst`` edge per (guard cube x successor cube). No
-    ``logic_asts.BoolExpr`` tree is constructed.
+    ``(guard_bdd, succ_bdd)`` pair, decodes both BDDs into compact
+    ``logic_asts.BoolExpr`` trees via Shannon expansion
+    (:func:`~morphata.symbolic.bdd.bdd_to_boolexpr`) and emits one HOA
+    edge per disjunct of the successor expression, with a single label
+    expression per row. Cube structure of the guard is preserved -- variables
+    absent from a given path through the BDD are projected out -- so the
+    output size is proportional to the BDD shape, not to ``2^|support|``.
 
     ``out`` semantics match :func:`automaton_to_hoa`: when ``None``, an
     internal ``StringIO`` accumulates the output and is returned;
@@ -164,6 +166,7 @@ def symbolic_automaton_to_hoa(
         acceptance condition is not :class:`~morphata.acceptance.Finite`.
     """
     from morphata.acceptance import Finite
+    from morphata.symbolic.bdd import bdd_to_boolexpr
 
     if sym.num_states > 0 and not sym.transitions:
         raise ValueError(
@@ -201,7 +204,15 @@ def symbolic_automaton_to_hoa(
     total_states = next_idx
 
     ap_order = sorted(sym.ap_registry, key=repr)
-    bdd_var_to_ap_index: dict[str, int] = {sym.ap_registry[ap]: i for i, ap in enumerate(ap_order)}
+    ap_to_index: dict[ty.Any, int] = {ap: i for i, ap in enumerate(ap_order)}
+    ap_decoder_map: dict[str, ty.Any] = {var: ap for ap, var in sym.ap_registry.items()}
+
+    def _ap_decode(name: str) -> ty.Any:  # noqa: ANN401
+        try:
+            return ap_decoder_map[name]
+        except KeyError as exc:
+            raise ValueError(f"Guard BDD references variable {name!r} not in the AP registry.") from exc
+
     acc_name, acc_expr_text, num_sets, acc_state_sets = _acceptance_to_hoa(sym.acceptance)
     if true_sink is not None:
         # Finite acceptance: extend set 0 (the accepting set) with the
@@ -226,7 +237,8 @@ def symbolic_automaton_to_hoa(
         assert false_sink is not None
         buf.write(f"Start: {false_sink}\n")
     else:
-        for start_line in _bdd_state_cubes(sym.initial, mgr=mgr):
+        initial_expr = ty.cast("logic.BoolExpr[int]", bdd_to_boolexpr(sym.initial))
+        for start_line in _initial_start_lines(initial_expr):
             buf.write(f"Start: {start_line}\n")
     ap_words = " ".join(f'"{ap}"' for ap in ap_order)
     buf.write(f"AP: {len(ap_order)}{(' ' + ap_words) if ap_order else ''}\n")
@@ -249,11 +261,12 @@ def symbolic_automaton_to_hoa(
                 assert false_sink is not None
                 dsts = [str(false_sink)]
             else:
-                dsts = _bdd_state_cubes(succ_bdd, mgr=mgr)
-            for cube in mgr.pick_iter(guard_bdd):
-                label = _cube_to_hoa_label(cube, bdd_var_to_ap_index)
-                for dst in dsts:
-                    buf.write(f"[{label}] {dst}\n")
+                succ_expr = ty.cast("logic.BoolExpr[int]", bdd_to_boolexpr(succ_bdd))
+                dsts = _state_expr_to_edges(succ_expr)
+            guard_expr = bdd_to_boolexpr(guard_bdd, var_decoder=_ap_decode)
+            label = _label_to_hoa(guard_expr, ap_to_index)
+            for dst in dsts:
+                buf.write(f"[{label}] {dst}\n")
     for sink in (true_sink, false_sink):
         if sink is None:
             continue

{morphata-2.0.5 → morphata-2.0.7}/src/morphata/symbolic/__init__.py

@@ -10,7 +10,10 @@ This subpackage provides:
 - :mod:`morphata.symbolic.automaton`: :class:`SymbolicAutomaton`, a
   representation that wraps an :class:`~morphata.automaton.Automaton`
   so the initial state set and every cached transition are live BDD
-  nodes in a single ``dd.BDD`` manager.
+  nodes in a single ``dd.BDD`` manager.  Also exposes
+  :func:`successors_for_alphabet`, a freestanding enumerator that
+  yields ``(symbol, succ_bdd)`` per declared symbol without
+  materialising a per-state transition relation.
 - :mod:`morphata.symbolic.transforms`: BDD-level structural transforms
   -- :func:`~morphata.symbolic.transforms.nfa_from_afa` (dealternation),
   :func:`~morphata.symbolic.transforms.determinize` (subset construction
@@ -21,6 +24,7 @@ This subpackage provides:
 """
 
 from morphata.symbolic.automaton import SymbolicAutomaton as SymbolicAutomaton
+from morphata.symbolic.automaton import successors_for_alphabet as successors_for_alphabet
 from morphata.symbolic.bdd import AP_VAR_FORMAT as AP_VAR_FORMAT
 from morphata.symbolic.bdd import STATE_VAR_FORMAT as STATE_VAR_FORMAT
 from morphata.symbolic.bdd import APRegistry as APRegistry

{morphata-2.0.5 → morphata-2.0.7}/src/morphata/symbolic/automaton.py

@@ -32,7 +32,7 @@ see :mod:`morphata.symbolic.transforms`.
 from __future__ import annotations
 
 import typing
-from collections.abc import Callable, Hashable, Iterable, Mapping, Sequence
+from collections.abc import Callable, Hashable, Iterable, Iterator, Mapping, Sequence
 from collections.abc import Set as AbstractSet
 from dataclasses import dataclass, field
 from typing import TYPE_CHECKING, Any, Generic
@@ -44,6 +44,8 @@ from morphata.automaton import Automaton, BoolExpr
 from morphata.hoa import ParsedAutomaton
 
 if TYPE_CHECKING:
+    from pathlib import Path
+
     from typing_extensions import Writer
 
     from morphata.alphabet import BooleanAlphabet
@@ -245,6 +247,31 @@ class SymbolicAutomaton(Generic[AP]):
 
         return symbolic_automaton_to_hoa(self, name=name, properties=properties, out=out)
 
+    def to_bdd_json(self, path: "str | Path") -> None:
+        """Persist ``self`` to a BDD JSON cache via :func:`to_bdd_json`.
+
+        Writes ``path`` (the BDD nodes, via :mod:`dd`'s multi-root JSON
+        dump) and a sibling ``path + ".meta.json"`` (acceptance, AP
+        registry, transition root layout). Intended as an internal
+        fast-path cache; HOA remains the right format for sharing
+        automata with other tools.
+        """
+        from morphata.symbolic.persistence import to_bdd_json
+
+        to_bdd_json(self, path)
+
+    @staticmethod
+    def from_bdd_json(
+        path: "str | Path",
+        *,
+        alphabet: "BooleanAlphabet[Any, str]",
+        manager: Manager | None = None,
+    ) -> "SymbolicAutomaton[str]":
+        """Reload a :class:`SymbolicAutomaton` written by :meth:`to_bdd_json`."""
+        from morphata.symbolic.persistence import from_bdd_json
+
+        return from_bdd_json(path, alphabet=alphabet, manager=manager)
+
     def to_min_dfa(self) -> "SymbolicAutomaton[AP]":
         """Determinize and minimize ``self`` into a minimal DFA.
 
@@ -358,6 +385,83 @@ class SymbolicAutomaton(Generic[AP]):
         )
 
 
+# ---------------------------------------------------------------------------
+# Alphabet-aware enumeration
+# ---------------------------------------------------------------------------
+
+
+def successors_for_alphabet(
+    sym_aut: "SymbolicAutomaton[AP]",
+    source: int,
+    alphabet: "BooleanAlphabet[Any, AP]",
+    symbols: Iterable[Any],
+) -> Iterator[tuple[Any, Function]]:
+    """Yield ``(symbol, succ_bdd)`` for each ``symbol in symbols`` whose
+    cofactor of the source's outgoing transitions is not ``mgr.false``.
+
+    Each yielded ``succ_bdd`` is a BDD over state variables encoding the
+    set of successors of ``source`` on ``symbol``. For DFA-shaped
+    automata it is a single state variable; for non-deterministic
+    shapes it is the OR of active successors.
+
+    Cost is bounded by ``|symbols| * len(sym_aut.transitions[source])``
+    ``mgr.let`` calls on per-row guards (each typically very small).
+    No per-state transition relation is materialised.
+
+    Yield order is a stable contract: pairs are yielded in the same
+    order ``symbols`` is iterated, with ``mgr.false`` symbols omitted.
+    Callers may walk the input alongside the yielded pairs with a two-
+    pointer pattern instead of materialising an intermediate dict.
+
+    Equivalence to ``step``: for any ``symbol``, the yielded
+    ``succ_bdd`` equals ``sym_aut.step(mgr.var(state_var_name(source)),
+    symbol)``; symbols whose ``step`` result is ``mgr.false`` are not
+    yielded.
+
+    Parameters
+    ----------
+    sym_aut
+        SymbolicAutomaton constructed with ``cache_transitions=True``.
+    source
+        Source state index in ``range(sym_aut.num_states)``.
+    alphabet
+        Boolean labeling alphabet over the same AP space as
+        ``sym_aut.ap_registry``.
+    symbols
+        Symbols to enumerate. Iterated exactly once.
+
+    Raises
+    ------
+    ValueError
+        If ``sym_aut`` was constructed with ``cache_transitions=False``
+        (no per-row pairs to cofactor), or if ``alphabet.predicates``
+        contains an AP not present in ``sym_aut.ap_registry``.
+    """
+    if sym_aut.num_states > 0 and not sym_aut.transitions:
+        raise ValueError(
+            "successors_for_alphabet requires a populated transition cache; "
+            "reconstruct SymbolicAutomaton with cache_transitions=True."
+        )
+    unknown = set(alphabet.predicates) - set(sym_aut.ap_registry)
+    if unknown:
+        raise ValueError(f"alphabet has unknown predicates not in ap_registry: {sorted(map(repr, unknown))}")
+
+    mgr = sym_aut.manager
+    rows = sym_aut.transitions[source]
+    ap_registry = sym_aut.ap_registry
+
+    for symbol in symbols:
+        truths = alphabet.labeling(symbol)
+        ap_point: dict[str, Function] = {ap_registry[ap]: (mgr.true if ap in truths else mgr.false) for ap in ap_registry}
+        succ_acc: Function = mgr.false
+        for guard_bdd, succ_bdd in rows:
+            restricted = mgr.let(ap_point, guard_bdd)
+            if restricted == mgr.true:
+                succ_acc = mgr.apply("or", succ_acc, succ_bdd)
+        if succ_acc != mgr.false:
+            yield symbol, succ_acc
+
+
 # ---------------------------------------------------------------------------
 # Private helpers
 # ---------------------------------------------------------------------------

morphata-2.0.7/src/morphata/symbolic/persistence.py

@@ -0,0 +1,346 @@
+"""Binary-ish BDD-level persistence for :class:`SymbolicAutomaton`.
+
+Persists a :class:`SymbolicAutomaton` to two files via :mod:`dd`'s native
+JSON dump:
+
+- ``<path>``: the BDD nodes themselves, written by ``Manager.dump(...,
+  filetype='json')`` as a multi-root JSON file. Cross-root structural
+  sharing in the manager is preserved at the file-format level (each
+  unique BDD node appears once; roots reference node ids).
+- ``<path>.meta.json``: a sidecar JSON file holding the surrounding
+  ``SymbolicAutomaton`` metadata that is not carried by the BDDs
+  themselves (state count, accepting states, acceptance condition, AP
+  registry, transition root-name layout).
+
+Motivation
+----------
+HOA is the right on-disk format for sharing automata with downstream
+tooling, but for an internal cache it has two costs:
+
+1. The HOA body writes each row's label as fresh text, so the file size
+   grows with (rows x label bytes) rather than with the manager's
+   unique node count.
+2. Parsing HOA back into a :class:`SymbolicAutomaton` goes through a
+   lark parser that allocates per-token Python AST nodes; on
+   million-line HOA files this dominates load time and memory.
+
+The BDD JSON format here avoids both: dd's loader is C-level (no lark),
+and node deduplication keeps the unique-node table proportional to the
+manager's reachable node count rather than the per-row text footprint.
+
+The format is intended as a cache, not a portable artifact: it bakes in
+the AP and state variable naming conventions used by morphata, so the
+loader can reconstruct the manager into the same variable namespace.
+
+Atomic write
+------------
+Each file is written via a ``.partial`` sibling and then ``Path.replace``-d
+into place. The two replaces are sequential, so a crash between them can
+leave the BDD file in place without the sidecar; both files always land
+*together* only modulo that window. Callers that need both-or-neither
+semantics should write to a scratch directory and rename the directory.
+"""
+
+from __future__ import annotations
+
+import json
+from pathlib import Path
+from typing import TYPE_CHECKING, Any
+
+from morphata.acceptance import (
+    AcceptanceCondition,
+    AccPair,
+    Buchi,
+    CoBuchi,
+    Finite,
+    GeneralizedBuchi,
+    GeneralizedCoBuchi,
+    Rabin,
+    Streett,
+)
+from morphata.symbolic.bdd import (
+    AP_VAR_FORMAT,
+    STATE_VAR_FORMAT,
+    Function,
+    Manager,
+    declare_state_vars,
+    make_manager,
+)
+
+if TYPE_CHECKING:
+    from morphata.alphabet import BooleanAlphabet
+    from morphata.symbolic.automaton import SymbolicAutomaton
+
+
+SCHEMA_VERSION = "1"
+"""Sidecar schema version. Bump on any breaking change to the JSON layout."""
+
+
+# ---------------------------------------------------------------------------
+# Acceptance condition <-> JSON
+# ---------------------------------------------------------------------------
+
+
+def _acceptance_to_json(cond: AcceptanceCondition[int]) -> dict[str, Any]:
+    if isinstance(cond, Finite):
+        return {"kind": "Finite", "accepting": sorted(cond.accepting)}
+    if isinstance(cond, Buchi):
+        return {"kind": "Buchi", "accepting": sorted(cond.accepting)}
+    if isinstance(cond, CoBuchi):
+        return {"kind": "CoBuchi", "rejecting": sorted(cond.rejecting)}
+    if isinstance(cond, GeneralizedBuchi):
+        return {
+            "kind": "GeneralizedBuchi",
+            "accepting": [sorted(s) for s in cond.accepting],
+        }
+    if isinstance(cond, GeneralizedCoBuchi):
+        return {
+            "kind": "GeneralizedCoBuchi",
+            "rejecting": [sorted(s) for s in cond.rejecting],
+        }
+    if isinstance(cond, Rabin):
+        return {
+            "kind": "Rabin",
+            "pairs": [[sorted(p.rejecting), sorted(p.accepting)] for p in cond.pairs],
+        }
+    if isinstance(cond, Streett):
+        return {
+            "kind": "Streett",
+            "pairs": [[sorted(p.rejecting), sorted(p.accepting)] for p in cond.pairs],
+        }
+    raise NotImplementedError(
+        f"BDD JSON cache: cannot serialize acceptance condition of type "
+        f"{type(cond).__name__}; supported: Finite, Buchi, CoBuchi, "
+        "GeneralizedBuchi, GeneralizedCoBuchi, Rabin, Streett."
+    )
+
+
+def _acceptance_from_json(data: dict[str, Any]) -> AcceptanceCondition[int]:
+    kind = data["kind"]
+    if kind == "Finite":
+        return Finite(frozenset(data["accepting"]))
+    if kind == "Buchi":
+        return Buchi(frozenset(data["accepting"]))
+    if kind == "CoBuchi":
+        return CoBuchi(frozenset(data["rejecting"]))
+    if kind == "GeneralizedBuchi":
+        return GeneralizedBuchi(tuple(frozenset(s) for s in data["accepting"]))
+    if kind == "GeneralizedCoBuchi":
+        return GeneralizedCoBuchi(tuple(frozenset(s) for s in data["rejecting"]))
+    if kind == "Rabin":
+        return Rabin(tuple(AccPair(frozenset(r), frozenset(a)) for r, a in data["pairs"]))
+    if kind == "Streett":
+        return Streett(tuple(AccPair(frozenset(r), frozenset(a)) for r, a in data["pairs"]))
+    raise ValueError(f"BDD JSON cache: unknown acceptance kind {kind!r}")
+
+
+# ---------------------------------------------------------------------------
+# Top-level dump / load
+# ---------------------------------------------------------------------------
+
+
+def _meta_path_for(bdd_path: Path) -> Path:
+    return Path(str(bdd_path) + ".meta.json")
+
+
+def to_bdd_json(sym: "SymbolicAutomaton[Any]", path: str | Path) -> None:
+    """Persist *sym* to ``path`` (BDD JSON) plus a ``<path>.meta.json`` sidecar.
+
+    Roots written to the BDD file:
+
+    - ``initial``: the initial-state BDD.
+    - ``g_{s}_{k}``, ``s_{s}_{k}``: the guard and successor BDDs of the
+      k-th cached transition out of state ``s``.
+
+    The sidecar JSON holds everything else needed to rehydrate the
+    automaton (state count, accepting states, acceptance condition, AP
+    registry mapping AP value -> manager var name, and the per-state
+    list of ``(guard_root_name, succ_root_name)`` pairs).
+
+    Raises
+    ------
+    ValueError
+        If ``sym.num_states > 0`` and the transition cache is empty.
+    NotImplementedError
+        If the AP registry contains a non-string AP value, or the
+        acceptance condition is not one of the named conditions handled
+        by :func:`_acceptance_to_json`.
+    """
+    if sym.num_states > 0 and not sym.transitions:
+        raise ValueError(
+            "to_bdd_json requires a populated transition cache; reconstruct SymbolicAutomaton with cache_transitions=True."
+        )
+
+    bdd_path = Path(path)
+    meta_path = _meta_path_for(bdd_path)
+    bdd_partial = Path(str(bdd_path) + ".partial")
+    meta_partial = Path(str(meta_path) + ".partial")
+
+    mgr = sym.manager
+    roots: dict[str, Function] = {"initial": sym.initial}
+    transitions_layout: dict[str, list[list[str]]] = {}
+    for s in range(sym.num_states):
+        rows_for_s: list[list[str]] = []
+        for k, (g, n) in enumerate(sym.transitions.get(s, ())):
+            g_name = f"g_{s}_{k}"
+            s_name = f"s_{s}_{k}"
+            roots[g_name] = g
+            roots[s_name] = n
+            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):
+            raise NotImplementedError(
+                f"BDD JSON cache currently supports only str-valued APs; got AP value {ap!r} of type {type(ap).__name__}."
+            )
+        ap_registry_json[ap] = var
+
+    meta: dict[str, Any] = {
+        "schema_version": SCHEMA_VERSION,
+        "num_states": sym.num_states,
+        "accepting_states": sorted(sym.accepting_states),
+        "acceptance": _acceptance_to_json(sym.acceptance),
+        "ap_registry": ap_registry_json,
+        "state_var_format": STATE_VAR_FORMAT,
+        "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,
+    }
+
+    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)
+
+    if bdd_roots:
+        bdd_partial.replace(bdd_path)
+    elif bdd_path.exists():
+        bdd_path.unlink()
+    meta_partial.replace(meta_path)
+
+
+def from_bdd_json(
+    path: str | Path,
+    *,
+    alphabet: "BooleanAlphabet[Any, str]",
+    manager: Manager | None = None,
+) -> "SymbolicAutomaton[str]":
+    """Reload a :class:`SymbolicAutomaton` from :func:`to_bdd_json`'s output.
+
+    Declares state and AP variables in *manager* (a fresh one if not
+    given) matching the writer's namespace, loads the BDD JSON into the
+    manager via ``Manager.load``, and reassembles
+    :attr:`SymbolicAutomaton.transitions` from the sidecar layout.
+
+    AP values are returned as ``str`` (the only AP value type supported
+    by :func:`to_bdd_json`).
+
+    Raises
+    ------
+    ValueError
+        If the sidecar schema version is unknown, if its
+        ``state_var_format`` does not match morphata's, or if a root
+        named by the sidecar is missing from the BDD file.
+    """
+    from morphata.symbolic.automaton import SymbolicAutomaton
+
+    bdd_path = Path(path)
+    meta_path = _meta_path_for(bdd_path)
+
+    with open(meta_path) as f:
+        meta = json.load(f)
+
+    schema = meta.get("schema_version")
+    if schema != SCHEMA_VERSION:
+        raise ValueError(f"BDD JSON cache schema mismatch: file has {schema!r}, loader expected {SCHEMA_VERSION!r}.")
+    if meta.get("state_var_format") != STATE_VAR_FORMAT:
+        raise ValueError(
+            f"state_var_format mismatch: file uses {meta.get('state_var_format')!r}, loader expects {STATE_VAR_FORMAT!r}."
+        )
+
+    num_states = int(meta["num_states"])
+    ap_registry_meta: dict[str, str] = dict(meta["ap_registry"])
+
+    if manager is None:
+        manager = make_manager(reordering=True)
+    declare_state_vars(manager, num_states)
+    existing = set(manager.vars)
+    to_add = [name for name in ap_registry_meta.values() if name not in existing]
+    if to_add:
+        manager.declare(*to_add)
+
+    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:
+        initial = roots[initial_name]
+    except KeyError as exc:
+        raise ValueError(f"BDD JSON file is missing initial root {initial_name!r}") from exc
+
+    transitions: dict[int, list[tuple[Function, Function]]] = {}
+    for s_str, rows in meta["transitions"].items():
+        s = int(s_str)
+        pairs: list[tuple[Function, Function]] = []
+        for entry in rows:
+            g_name, n_name = entry
+            try:
+                pairs.append((roots[g_name], roots[n_name]))
+            except KeyError as exc:
+                raise ValueError(
+                    f"BDD JSON file is missing root {exc.args[0]!r} referenced by sidecar state {s} row layout."
+                ) from exc
+        transitions[s] = pairs
+
+    accepting_states = frozenset(int(s) for s in meta["accepting_states"])
+    acceptance = _acceptance_from_json(meta["acceptance"])
+
+    return SymbolicAutomaton(
+        manager=manager,
+        initial=initial,
+        transitions=transitions,
+        ap_registry=ap_registry_meta,
+        accepting_states=accepting_states,
+        num_states=num_states,
+        acceptance=acceptance,
+        alphabet=alphabet,
+    )

{morphata-2.0.5 → morphata-2.0.7}/tests/hoa/test_exporter_streaming.py

@@ -220,6 +220,54 @@ class TestSymbolicSinkMaterialisation:
         assert "State: 2 {0}\n[t] 2\n" in hoa_text
 
 
+class TestSymbolicCubeNotMinterm:
+    """Regression for the 2.0.5 bug where the streaming exporter emitted one
+    HOA edge per BDD minterm instead of per cube.
+
+    ``dd.cudd.BDD.pick_iter(u)`` defaults ``care_vars`` to ``support(u)`` and
+    then enumerates *minterms* (fully-assigned models) over that support, so
+    a guard with non-trivial support like ``a | b`` would produce three
+    edges (``a&b``, ``a&!b``, ``!a&b``) instead of the single cube ``(a | b)``.
+    """
+
+    def _build_disjunctive_guard_dfa(self) -> SymbolicAutomaton[str]:
+        # Two-state DFA over {a, b}. State 0 transitions to state 1 under
+        # the guard ``a | b`` (BDD support = {a, b}; pre-fix expands to 3
+        # minterms). Otherwise loops in state 0.
+        b = AutomatonBuilder[int, str]()
+        b.add_state(0, initial=True)
+        b.add_state(1, accepting=True)
+        b.add_transition(0, logic.Or((logic.Variable("a"), logic.Variable("b"))), 1)
+        b.add_transition(
+            0,
+            logic.And((logic.Not(logic.Variable("a")), logic.Not(logic.Variable("b")))),
+            0,
+        )
+        b.add_transition(1, logic.Variable("a"), 1)
+        b.add_transition(1, logic.Not(logic.Variable("a")), 1)
+        aut = b.build()
+        return SymbolicAutomaton.from_automaton(aut, alphabet=powerset_alphabet(aut.predicates))
+
+    def test_disjunctive_guard_emits_single_cube_edge(self) -> None:
+        sym = self._build_disjunctive_guard_dfa()
+        hoa_text = symbolic_automaton_to_hoa(sym)
+        assert hoa_text is not None
+        # Find the body block for state 0.
+        body = hoa_text.split("--BODY--\n", 1)[1]
+        state0_block = body.split("State: 0", 1)[1].split("State:", 1)[0]
+        edges_to_1 = [line for line in state0_block.splitlines() if line.endswith(" 1")]
+        # Post-fix: a single edge labelled with the disjunction goes to 1.
+        # Pre-fix (the bug): three minterm edges go to 1.
+        assert len(edges_to_1) == 1, f"expected one cube edge to state 1, got {len(edges_to_1)}: {edges_to_1!r}"
+
+    def test_writer_vs_string_byte_identical_on_disjunctive_guard(self) -> None:
+        sym = self._build_disjunctive_guard_dfa()
+        string_form = symbolic_automaton_to_hoa(sym)
+        buf = io.StringIO()
+        symbolic_automaton_to_hoa(sym, out=buf)
+        assert buf.getvalue() == string_form
+
+
 class TestSymbolicErrorPaths:
     def test_literal_successor_with_non_finite_acceptance_raises(self) -> None:
         from morphata.acceptance import Buchi