morphata 2.0.8__tar.gz → 2.0.9__tar.gz

{morphata-2.0.8 → morphata-2.0.9}/CHANGELOG.md

@@ -1,5 +1,27 @@
 # Changelog
 
+## 2.0.9 — 2026-06-04
+
+### Fixed
+
+- `dd._copy` was using `shelve` to create a hard-coded `__shelve__` directory in the
+  current working directory.
+  This caused a clash whenever we ran multiple data generation processes
+  (either different runs or multiprocessing), and a fatal error.
+  This release fixes that by, unfortunately,
+  duplicating the code that is used to serialize/deserialize BDDs in `dd`,
+  but using a `tempfile.mkdtemp` block to ensure the `shelve` is in a namespaced
+  directory.
+
+### Performance
+
+- This is a major performance thing.
+  In addition to all the previous things we have done,
+  we now ensure that `symbolic_automaton_to_hoa`
+  (and in-effect, `SymbolicAutomaton.to_hoa`) **does not materialize any `BoolExpr`**.
+  Instead, we opt to use a (locally cached) BDD to label/guard expression function,
+  which increases throughput like CRAZY!!!
+
 ## 2.0.8 — 2026-06-03
 
 ### Added

{morphata-2.0.8 → morphata-2.0.9}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: morphata
-Version: 2.0.8
+Version: 2.0.9
 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.8 → morphata-2.0.9}/bench/README.md

@@ -16,6 +16,10 @@ To get pytest-benchmark's tabular wall-time output:
 - `test_sere_nlm_perf.py` -- NLM-intersection state-space blowup.
   Cases: `NLMInter(a0..a_{n-1})` for n in 2..6, `NLMInter(a_i;b_i)`
   for n in 2..4, plus length-matching `Inter` baselines.
+- `test_hoa_exporter_perf.py` -- ``symbolic_automaton_to_hoa`` end-to-end
+  wall time across regimes that stress the per-row guard/successor
+  caching (small DFA, sparse-big-alphabet DFA, conjunction min-DFA, raw
+  AFA without minimization).
 
 ## Recording results
 

morphata-2.0.9/bench/test_hoa_exporter_perf.py

@@ -0,0 +1,124 @@
+"""Micro-benchmarks for ``symbolic_automaton_to_hoa``.
+
+Targets the per-row ``bdd_to_boolexpr`` work in
+``morphata.hoa.exporter.symbolic_automaton_to_hoa``. The export walks
+every cached ``(guard_bdd, succ_bdd)`` row, decodes both BDDs into
+``BoolExpr`` trees, and renders text. In real workloads the same
+``dd.Function`` recurs heavily across rows -- canonical guards shared by
+many transitions, and successor BDDs shared by many guards in DFAs --
+so caching the per-Function rendering is expected to dominate raw
+``bdd_to_boolexpr`` cost.
+
+These cases hit the three regimes that matter:
+
+- ``small_alphabet_dfa``: small AP universe, dense DFA. Baseline; cache
+  effect should be small (few distinct guards anyway).
+- ``sparse_big_alphabet_dfa``: large AP universe but sparse guards
+  (mirrors ``test_equivalence_perf``). Many rows, few distinct
+  ``guard_bdd`` Functions -> label cache pays.
+- ``conjunction_min_dfa``: ``Eventually(a) & ... & Eventually(d)`` min-DFA
+  with extra padding APs. Both caches pay: same guards across many
+  states, and many guards point to the same successor partition.
+- ``afa_no_minimize``: raw LTL -> AFA without minimization. Exercises
+  the un-determinized regime where successor BDDs are richer (one per
+  conjunctive obligation).
+
+Run with: ``pytest bench/test_hoa_exporter_perf.py -v``
+"""
+
+from __future__ import annotations
+
+import logic_asts.ltl as ltl
+from pytest_benchmark.fixture import BenchmarkFixture as Benchmark
+
+from morphata.alphabet import powerset_alphabet
+from morphata.hoa.exporter import symbolic_automaton_to_hoa
+from morphata.symbolic.automaton import SymbolicAutomaton
+from morphata.symbolic.bdd import Manager
+
+
+def _small_alphabet_dfa(mgr: Manager) -> SymbolicAutomaton[str]:
+    aps = frozenset({"a", "b"})
+    formula = ltl.Eventually(ltl.And((ltl.Variable("a"), ltl.Variable("b"))))
+    alphabet = powerset_alphabet(aps)
+    return SymbolicAutomaton.from_ltl(formula, alphabet=alphabet, manager=mgr, finite=True).to_min_dfa()
+
+
+def _sparse_big_alphabet_dfa(mgr: Manager) -> SymbolicAutomaton[str]:
+    aps = frozenset({f"p{i}" for i in range(15)} | {"a", "b", "c", "d"})
+    formula = ltl.And(
+        (
+            ltl.Eventually(ltl.Variable("a")),
+            ltl.Eventually(ltl.Variable("b")),
+            ltl.Eventually(ltl.Variable("c")),
+            ltl.Eventually(ltl.Variable("d")),
+        )
+    )
+    alphabet = powerset_alphabet(aps)
+    return SymbolicAutomaton.from_ltl(formula, alphabet=alphabet, manager=mgr, finite=True).to_min_dfa()
+
+
+def _conjunction_min_dfa(mgr: Manager) -> SymbolicAutomaton[str]:
+    aps = frozenset({f"q{i}" for i in range(8)} | {"a", "b", "c", "d", "e"})
+    formula = ltl.And(
+        (
+            ltl.Eventually(ltl.Variable("a")),
+            ltl.Eventually(ltl.Variable("b")),
+            ltl.Eventually(ltl.Variable("c")),
+            ltl.Eventually(ltl.Variable("d")),
+            ltl.Eventually(ltl.Variable("e")),
+        )
+    )
+    alphabet = powerset_alphabet(aps)
+    return SymbolicAutomaton.from_ltl(formula, alphabet=alphabet, manager=mgr, finite=True).to_min_dfa()
+
+
+def _afa_no_minimize(mgr: Manager) -> SymbolicAutomaton[str]:
+    aps = frozenset({"a", "b", "c", "d"})
+    formula = ltl.Until(
+        ltl.Variable("a"),
+        ltl.And(
+            (
+                ltl.Variable("b"),
+                ltl.Eventually(ltl.And((ltl.Variable("c"), ltl.Eventually(ltl.Variable("d"))))),
+            )
+        ),
+    )
+    alphabet = powerset_alphabet(aps)
+    return SymbolicAutomaton.from_ltl(formula, alphabet=alphabet, manager=mgr, finite=True)
+
+
+def test_hoa_export_small_alphabet_dfa(benchmark: Benchmark, bench_mgr: Manager) -> None:
+    sym = _small_alphabet_dfa(bench_mgr)
+
+    def _run() -> int:
+        return len(symbolic_automaton_to_hoa(sym))
+
+    assert benchmark(_run) > 0
+
+
+def test_hoa_export_sparse_big_alphabet_dfa(benchmark: Benchmark, bench_mgr: Manager) -> None:
+    sym = _sparse_big_alphabet_dfa(bench_mgr)
+
+    def _run() -> int:
+        return len(symbolic_automaton_to_hoa(sym))
+
+    assert benchmark(_run) > 0
+
+
+def test_hoa_export_conjunction_min_dfa(benchmark: Benchmark, bench_mgr: Manager) -> None:
+    sym = _conjunction_min_dfa(bench_mgr)
+
+    def _run() -> int:
+        return len(symbolic_automaton_to_hoa(sym))
+
+    assert benchmark(_run) > 0
+
+
+def test_hoa_export_afa_no_minimize(benchmark: Benchmark, bench_mgr: Manager) -> None:
+    sym = _afa_no_minimize(bench_mgr)
+
+    def _run() -> int:
+        return len(symbolic_automaton_to_hoa(sym))
+
+    assert benchmark(_run) > 0

{morphata-2.0.8 → morphata-2.0.9}/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.8"
+version = "2.0.9"
 requires-python = ">=3.12"
 classifiers = [
   "Intended Audience :: Science/Research",

{morphata-2.0.8 → morphata-2.0.9}/src/morphata/hoa/exporter.py

@@ -205,13 +205,7 @@ def symbolic_automaton_to_hoa(
 
     ap_order = sorted(sym.ap_registry, key=repr)
     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
+    bdd_var_to_ap_index: dict[str, int] = {var: ap_to_index[ap] for ap, var in sym.ap_registry.items()}
 
     acc_name, acc_expr_text, num_sets, acc_state_sets = _acceptance_to_hoa(sym.acceptance)
     if true_sink is not None:
@@ -248,11 +242,22 @@ def symbolic_automaton_to_hoa(
     if properties:
         buf.write("properties: " + " ".join(properties) + "\n")
 
+    # Per-call caches keyed by dd.Function identity. Guards and successor
+    # BDDs recur heavily across rows (shared canonical guards; many guards
+    # leading to the same target set in DFAs). With the pick_iter-based
+    # renderers below the per-Function rendering cost is much smaller
+    # than it was with the bdd_to_boolexpr + _label_to_hoa pipeline, but
+    # the caches still pay back on shared Functions. Kept as two separate
+    # dicts since the pipelines produce different shapes (str vs list[str]);
+    # freed explicitly before return to limit Function references held
+    # against the CUDD backend.
+    label_cache: dict[ty.Any, str] = {}
+    dsts_cache: dict[ty.Any, list[str]] = {}
+    marker_by_state = _markers_by_state(acc_state_sets)
+
     buf.write("--BODY--\n")
     for s in states:
-        sets_for_s = sorted(idx for idx, members in acc_state_sets.items() if s in members)
-        marker = (" {" + " ".join(str(i) for i in sets_for_s) + "}") if sets_for_s else ""
-        buf.write(f"State: {s}{marker}\n")
+        buf.write(f"State: {s}{marker_by_state.get(s, '')}\n")
         for guard_bdd, succ_bdd in sym.transitions.get(s, ()):
             if succ_bdd == mgr.true:
                 assert true_sink is not None
@@ -260,22 +265,27 @@ def symbolic_automaton_to_hoa(
             elif succ_bdd == mgr.false:
                 assert false_sink is not None
                 dsts = [str(false_sink)]
+            elif succ_bdd in dsts_cache:
+                dsts = dsts_cache[succ_bdd]
+            else:
+                dsts = _bdd_state_cubes(succ_bdd, mgr=mgr)
+                dsts_cache[succ_bdd] = dsts
+            if guard_bdd in label_cache:
+                label = label_cache[guard_bdd]
             else:
-                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)
+                label = _bdd_to_hoa_label(guard_bdd, mgr=mgr, bdd_var_to_ap_index=bdd_var_to_ap_index)
+                label_cache[guard_bdd] = label
             for dst in dsts:
                 buf.write(f"[{label}] {dst}\n")
     for sink in (true_sink, false_sink):
         if sink is None:
             continue
-        sets_for_sink = sorted(idx for idx, members in acc_state_sets.items() if sink in members)
-        marker = (" {" + " ".join(str(i) for i in sets_for_sink) + "}") if sets_for_sink else ""
-        buf.write(f"State: {sink}{marker}\n")
+        buf.write(f"State: {sink}{marker_by_state.get(sink, '')}\n")
         buf.write(f"[t] {sink}\n")
     buf.write("--END--\n")
 
+    del label_cache, dsts_cache
+
     if owns_buffer:
         assert isinstance(buf, io.StringIO)
         return buf.getvalue()
@@ -475,11 +485,10 @@ def _write_body(
     from morphata.automaton import Outgoing
 
     assert isinstance(aut.delta, Outgoing)
+    marker_by_state = _markers_by_state(acc_state_sets)
     buf.write("--BODY--\n")
     for s in states:
-        sets_for_s = sorted(idx for idx, members in acc_state_sets.items() if s in members)
-        marker = (" {" + " ".join(str(i) for i in sets_for_s) + "}") if sets_for_s else ""
-        buf.write(f"State: {s}{marker}\n")
+        buf.write(f"State: {s}{marker_by_state.get(s, '')}\n")
         for guard, succ in aut.delta.fn(s):
             label_text = _label_to_hoa(guard, ap_to_index)
             for dst_text in _state_expr_to_edges(succ):
@@ -595,6 +604,34 @@ def _cube_to_hoa_label(
     return "(" + " & ".join(parts) + ")"
 
 
+def _bdd_to_hoa_label(
+    node: "Function",
+    *,
+    mgr: "Manager",
+    bdd_var_to_ap_index: Mapping[str, int],
+) -> str:
+    """Render a guard BDD as a single HOA label string.
+
+    Bypasses :func:`~morphata.symbolic.bdd.bdd_to_boolexpr` -- which
+    walks the BDD via Shannon expansion, builds a ``logic_asts``
+    ``BoolExpr`` tree, and runs NNF normalisation -- by enumerating the
+    BDD's cubes directly with ``mgr.pick_iter`` and joining their HOA
+    renderings with ``|``. Output shape matches the prior
+    ``bdd_to_boolexpr`` + :func:`_label_to_hoa` pipeline for HOA
+    consumers: one label per row, possibly disjunctive.
+    """
+    if node == mgr.true:
+        return "t"
+    if node == mgr.false:
+        return "f"
+    cube_labels = [_cube_to_hoa_label(cube, bdd_var_to_ap_index) for cube in mgr.pick_iter(node)]
+    if not cube_labels:
+        return "f"
+    if len(cube_labels) == 1:
+        return cube_labels[0]
+    return "(" + " | ".join(cube_labels) + ")"
+
+
 def _bdd_state_cubes(node: "Function", *, mgr: "Manager") -> list[str]:
     """Enumerate satisfying cubes of *node* over state variables as HOA dst strings.
 
@@ -629,6 +666,23 @@ def _bdd_state_cubes(node: "Function", *, mgr: "Manager") -> list[str]:
 # ---------------------------------------------------------------------------
 
 
+def _markers_by_state(
+    acc_state_sets: Mapping[int, AbstractSet[int]],
+) -> dict[int, str]:
+    """Invert ``acc_state_sets`` into per-state ``" {i j ...}"`` markers.
+
+    Replaces the per-state ``sorted(idx for ... if s in members)`` scan
+    in the body loop, which is O(|states| * |acc_sets|). Inverting once
+    is O(sum of set sizes). Only states with at least one membership get
+    an entry; callers default to ``""`` via ``dict.get(s, "")``.
+    """
+    by_state: dict[int, list[int]] = {}
+    for idx, members in acc_state_sets.items():
+        for s in members:
+            by_state.setdefault(s, []).append(idx)
+    return {s: " {" + " ".join(str(i) for i in sorted(indices)) + "}" for s, indices in by_state.items()}
+
+
 def _acceptance_to_hoa(
     cond: AcceptanceCondition[int],
 ) -> tuple[str | None, str, int, Mapping[int, AbstractSet[int]]]:

{morphata-2.0.8 → morphata-2.0.9}/src/morphata/symbolic/persistence.py

@@ -44,8 +44,12 @@ semantics should write to a scratch directory and rename the directory.
 from __future__ import annotations
 
 import json
+import shutil
+import tempfile
 from pathlib import Path
-from typing import TYPE_CHECKING, Any
+from typing import TYPE_CHECKING, Any, cast
+
+from dd import _copy as _dd_copy
 
 from morphata.acceptance import (
     AcceptanceCondition,
@@ -143,6 +147,37 @@ def _meta_path_for(bdd_path: Path) -> Path:
     return Path(str(bdd_path) + ".meta.json")
 
 
+# dd's public ``dump_json`` / ``load_json`` wrappers open a ``shelve`` at a
+# hardcoded relative ``__shelve__`` directory and ``os.makedirs`` it without
+# ``exist_ok``, so a stale dir from a crashed prior run breaks the next call
+# and concurrent calls collide. The underscore variants take the cache as a
+# parameter, so we re-wrap them against a per-call tempdir.
+def _dump_json_safe(nodes: dict[str, Function], file_name: str) -> None:
+    shelve_dir = Path(tempfile.mkdtemp(prefix="morphata-dd-"))
+    try:
+        shelf_path = shelve_dir / "shelf"
+        with (
+            _dd_copy._open_shelf(str(shelf_path)) as cache,
+            open(file_name, "w") as fd,
+        ):
+            _dd_copy._dump_json(cast(Any, nodes), fd, cache)
+    finally:
+        shutil.rmtree(shelve_dir, ignore_errors=True)
+
+
+def _load_json_safe(file_name: str, bdd: Manager, load_order: bool = False) -> dict[str, Function]:
+    shelve_dir = Path(tempfile.mkdtemp(prefix="morphata-dd-"))
+    try:
+        shelf_path = shelve_dir / "shelf"
+        with (
+            _dd_copy._open_shelf(str(shelf_path)) as cache,
+            open(file_name) as fd,
+        ):
+            return cast("dict[str, Function]", _dd_copy._load_json(fd, bdd, load_order, cache))
+    finally:
+        shutil.rmtree(shelve_dir, ignore_errors=True)
+
+
 def to_bdd_json(sym: "SymbolicAutomaton[Any]", path: str | Path) -> None:
     """Persist *sym* to ``path`` (BDD JSON) plus a ``<path>.meta.json`` sidecar.
 
@@ -232,7 +267,7 @@ def to_bdd_json(sym: "SymbolicAutomaton[Any]", path: str | Path) -> None:
     }
 
     if bdd_roots:
-        mgr.dump(str(bdd_partial), roots=bdd_roots, filetype="json")
+        _dump_json_safe(bdd_roots, str(bdd_partial))
     with open(meta_partial, "w") as f:
         json.dump(meta, f, indent=2, sort_keys=True)
 
@@ -296,7 +331,7 @@ def from_bdd_json(
     if meta.get("bdd_file_empty", False):
         roots: dict[str, Function] = {}
     else:
-        loaded = manager.load(str(bdd_path))
+        loaded = _load_json_safe(str(bdd_path), manager)
         if not isinstance(loaded, dict):
             raise ValueError(
                 f"BDD JSON load returned {type(loaded).__name__}; expected a "

{morphata-2.0.8 → morphata-2.0.9}/uv.lock

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