morphata 2.0.7__tar.gz → 2.0.9__tar.gz

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

@@ -1,5 +1,66 @@
 # 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
+
+- `compose_min_dfa` and `min_dfa_of_conjunction` are variadic now
+  and always return a `CompositionMap`: the per-factor automata,
+  the representative-to-tuple map,
+  and the full surjection from reachable per-factor tuples to composed states.
+  I initially wanted the section-only view,
+  but minimization can merge classes such
+  that a representative's per-factor successor lands on a non-representative tuple,
+  so the full surjection has to be there.
+- `iter_composed_transitions` enumerates `(state, symbol, successor)`
+  of a composed DFA without building the product BDD, walking factor
+  deltas directly and hitting `tuple_to_class` once per
+  `(state, symbol)`.
+
+### Performance
+
+- `successors_for_alphabet` drops the `|Sigma| * |rows|` cofactor sweep
+  for a per-row support-projected symbol partition with a constant-guard fast path.
+  Fixes the small-row regression from 2.0.6 while keeping the wide-state win.
+  Same treatment for `language_equivalent` and `canonical_form`,
+  so sparse guards over a big AP universe stop iterating the full powerset.
+- Bucketing rows by guard support amortizes the partition
+  and per-class point dicts across same-support rows.
+  Conjunction-fold DFAs get 1.3-1.6x; `F a & F b & F c & F d` q1 went ~343us -> ~175us.
+- `isomorphic` routes through a compact support-reduced fingerprint
+  and skips the broadcast expansion. `|AP|=19` sparse case:
+  ~333ms -> ~83ms.
+
+### Changed
+
+- `SymbolicAutomaton` carries a derived `ap_inverse: Mapping[str, AP]`
+  populated in `__post_init__`; `to_automaton` and
+  `compose._merge_managers` route through it.
+- New symbolic benches are pytest-benchmark cases, so timings get
+  recorded rather than gated on a hard-coded threshold.
+
 ## 2.0.7 — 2026-06-02
 
 ### Fixed

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: morphata
-Version: 2.0.7
+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.7 → 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_equivalence_perf.py

@@ -0,0 +1,57 @@
+"""Micro-benchmarks for the rewritten equivalence functions.
+
+The case: an LTLf min-DFA whose AP universe is large (|aps| ~ 19) but
+whose guards mention only 4 APs. Pre-rewrite this regime explodes;
+post-rewrite the per-pair (language_equivalent) and per-automaton
+(isomorphic) support reductions keep work bounded.
+
+pytest-benchmark records the timing distribution; no hard-coded
+thresholds, the dataset is the regression signal.
+
+Run with: ``pytest bench/test_equivalence_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.automaton import Automaton
+from morphata.logic.ltl import Input, ltl_to_automaton
+from morphata.symbolic import isomorphic
+from morphata.symbolic.automaton import SymbolicAutomaton
+from morphata.symbolic.equivalence import language_equivalent
+
+
+def _sparse_big_alphabet_dfa() -> 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)
+    aut: Automaton[int, Input[str], str] = ltl_to_automaton(formula, finite=True)
+    return SymbolicAutomaton.from_automaton(aut, alphabet=alphabet).to_min_dfa()
+
+
+def test_language_equivalent_sparse_big_alphabet(benchmark: Benchmark) -> None:
+    dfa = _sparse_big_alphabet_dfa()
+
+    def _run() -> bool:
+        return language_equivalent(dfa, dfa)
+
+    assert benchmark(_run)
+
+
+def test_isomorphic_sparse_big_alphabet(benchmark: Benchmark) -> None:
+    dfa = _sparse_big_alphabet_dfa()
+
+    def _run() -> bool:
+        return isomorphic(dfa, dfa)
+
+    assert benchmark(_run)

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.9/bench/test_successors_for_alphabet_perf.py

@@ -0,0 +1,124 @@
+"""Micro-benchmarks for :func:`morphata.symbolic.successors_for_alphabet`.
+
+Two cases:
+
+- Wide-cofactor: source = initial state of the min-DFA for
+  ``F a & F b & F c & F d``; many outgoing rows, ~1-4 APs in support
+  per row. Exercises the support-projection win.
+- Narrow-cofactor: source = a deep-BFS state of the same DFA after
+  most eventualities discharged; few rows, narrow support. Exercises
+  non-regression vs. the pre-rewrite ``T_src`` shape.
+
+Run with: ``pytest bench/test_successors_for_alphabet_perf.py -v``
+"""
+
+from __future__ import annotations
+
+import time
+
+import logic_asts.ltl as ltl
+from pytest_benchmark.fixture import BenchmarkFixture as Benchmark
+
+from morphata.alphabet import BooleanAlphabet, finite_alphabet
+from morphata.symbolic import SymbolicAutomaton, successors_for_alphabet
+
+
+def _build_min_dfa() -> SymbolicAutomaton[str]:
+    formula = ltl.And(
+        (
+            ltl.Eventually(ltl.Variable("a")),
+            ltl.Eventually(ltl.Variable("b")),
+            ltl.Eventually(ltl.Variable("c")),
+            ltl.Eventually(ltl.Variable("d")),
+        )
+    )
+    alphabet = finite_alphabet(frozenset({"a", "b", "c", "d"}))
+    sym = SymbolicAutomaton.from_ltl(formula, alphabet=alphabet, finite=True)
+    return sym.to_min_dfa()
+
+
+def _wide_alphabet_with_overlap() -> BooleanAlphabet[str, str]:
+    """26-symbol alphabet over AP universe {a, b, c, d}.
+
+    sym_0..sym_3 carry the AP truths for a/b/c/d (one each); sym_4..sym_25
+    carry no AP truth. Forces ``successors_for_alphabet`` to iterate over
+    a moderate-size symbol list with non-trivial classes per row.
+    """
+    aps = frozenset({"a", "b", "c", "d"})
+    labels: dict[str, frozenset[str]] = {f"sym_{i}": frozenset() for i in range(26)}
+    labels["sym_0"] = frozenset({"a"})
+    labels["sym_1"] = frozenset({"b"})
+    labels["sym_2"] = frozenset({"c"})
+    labels["sym_3"] = frozenset({"d"})
+    return BooleanAlphabet(predicates=aps, labeling=lambda s: labels[s])
+
+
+def _initial_index(sym: SymbolicAutomaton[str]) -> int:
+    for k in range(sym.num_states):
+        if sym.initial == sym.manager.var(f"q{k}"):
+            return k
+    raise AssertionError("min-DFA initial must be a single state variable")
+
+
+def test_wide_cofactor_state_runs_quickly() -> None:
+    """Initial state of F a & F b & F c & F d: many outgoing rows, wide support."""
+    sym = _build_min_dfa()
+    alphabet = _wide_alphabet_with_overlap()
+    symbols = [f"sym_{i}" for i in range(26)]
+    initial = _initial_index(sym)
+
+    t0 = time.perf_counter()
+    pairs = list(successors_for_alphabet(sym, initial, alphabet, symbols))
+    elapsed = time.perf_counter() - t0
+
+    assert pairs, "expected at least one successor for the initial state"
+    # Generous bound; rewrite runs in well under 1s on this case.
+    assert elapsed < 1.0, f"successors_for_alphabet on initial took {elapsed:.3f}s"
+
+
+def test_narrow_cofactor_state_runs_quickly() -> None:
+    """A deep-BFS state with few rows must not regress vs. the old T_src path."""
+    sym = _build_min_dfa()
+    alphabet = _wide_alphabet_with_overlap()
+    symbols = [f"sym_{i}" for i in range(26)]
+
+    # Walk a few steps from the initial state to discharge a/b/c.
+    cur = sym.initial
+    for s in ("sym_0", "sym_1", "sym_2"):
+        cur = sym.step(cur, s)
+    deep_index = -1
+    for k in range(sym.num_states):
+        if cur == sym.manager.var(f"q{k}"):
+            deep_index = k
+            break
+    assert deep_index != -1, "expected to land on a single state after three steps"
+
+    t0 = time.perf_counter()
+    pairs = list(successors_for_alphabet(sym, deep_index, alphabet, symbols))
+    elapsed = time.perf_counter() - t0
+
+    assert pairs, "expected at least one successor"
+    assert elapsed < 0.5, f"deep-state enumeration took {elapsed:.3f}s"
+
+
+def test_q1_post_discharge_state_per_call_cost(benchmark: Benchmark) -> None:
+    """Per-call cost of successors_for_alphabet at the 16-row / sup-4 state.
+
+    q1 has 16 outgoing rows that all share support {a, b, c, d}. With
+    per-bucket amortization the symbol partition and per-class point
+    dicts are built once for the bucket and shared across the 16
+    rows; the per-row cost reduces to |classes| cofactor calls.
+    pytest-benchmark records the timing distribution -- no hard-coded
+    threshold here, the dataset is the regression signal.
+    """
+    sym = _build_min_dfa()
+    alphabet = _wide_alphabet_with_overlap()
+    symbols = [f"sym_{i}" for i in range(26)]
+
+    q1 = next(k for k in range(sym.num_states) if len(sym.transitions[k]) == 16)
+
+    def _run() -> int:
+        return sum(1 for _ in successors_for_alphabet(sym, q1, alphabet, symbols))
+
+    n_yielded = benchmark(_run)
+    assert n_yielded > 0

{morphata-2.0.7 → morphata-2.0.9}/docs/api/morphata.symbolic.rst

@@ -33,6 +33,13 @@ Structural Transforms
    :members:
    :show-inheritance:
 
+Composition
+-----------
+
+.. automodule:: morphata.symbolic.compose
+   :members:
+   :show-inheritance:
+
 Language Equivalence
 --------------------
 

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

{morphata-2.0.7 → 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.7 → morphata-2.0.9}/src/morphata/symbolic/__init__.py

@@ -38,7 +38,9 @@ from morphata.symbolic.bdd import guard_to_bdd as guard_to_bdd
 from morphata.symbolic.bdd import make_ap_registry as make_ap_registry
 from morphata.symbolic.bdd import make_manager as make_manager
 from morphata.symbolic.bdd import state_var_name as state_var_name
+from morphata.symbolic.compose import CompositionMap as CompositionMap
 from morphata.symbolic.compose import compose_min_dfa as compose_min_dfa
+from morphata.symbolic.compose import iter_composed_transitions as iter_composed_transitions
 from morphata.symbolic.compose import min_dfa_of_conjunction as min_dfa_of_conjunction
 from morphata.symbolic.equivalence import canonical_form as canonical_form
 from morphata.symbolic.equivalence import isomorphic as isomorphic