morphata 2.0.7__tar.gz → 2.0.8__tar.gz

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

@@ -1,5 +1,44 @@
 # Changelog
 
+## 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.8}/PKG-INFO

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

{morphata-2.0.7 → morphata-2.0.8}/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

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

@@ -32,6 +32,7 @@ see :mod:`morphata.symbolic.transforms`.
 from __future__ import annotations
 
 import typing
+from collections import defaultdict
 from collections.abc import Callable, Hashable, Iterable, Iterator, Mapping, Sequence
 from collections.abc import Set as AbstractSet
 from dataclasses import dataclass, field
@@ -88,6 +89,10 @@ class SymbolicAutomaton(Generic[AP]):
         variables.  Both live in :attr:`manager`.
     ap_registry : APRegistry[AP]
         Maps each AP value to its BDD variable name in :attr:`manager`.
+    ap_inverse : Mapping[str, AP]
+        Derived inverse of :attr:`ap_registry`. Maps each manager
+        variable name back to its AP. Excludes state variables.
+        Populated in ``__post_init__``; not serialised.
     accepting_states : frozenset[int]
         Indices of accepting states.  Populated when the acceptance condition
         is :class:`~morphata.acceptance.Finite`; empty otherwise.
@@ -111,6 +116,12 @@ class SymbolicAutomaton(Generic[AP]):
     num_states: int
     acceptance: AcceptanceCondition[int] = field()
     alphabet: "BooleanAlphabet[Any, AP]" = field(kw_only=True)
+    ap_inverse: Mapping[str, AP] = field(init=False)
+
+    def __post_init__(self) -> None:
+        # Derived inverse of ``ap_registry``. Manager-var-name -> AP.
+        # Excludes state vars (they are not in ``ap_registry``).
+        object.__setattr__(self, "ap_inverse", {var: ap for ap, var in self.ap_registry.items()})
 
     # ------------------------------------------------------------------
     # Symbolic primitives
@@ -193,7 +204,7 @@ class SymbolicAutomaton(Generic[AP]):
                 "reconstruct SymbolicAutomaton with cache_transitions=True."
             )
 
-        ap_decoder_map: dict[str, AP] = {var: ap for ap, var in self.ap_registry.items()}
+        ap_decoder_map: Mapping[str, AP] = self.ap_inverse
 
         def _ap_decode(name: str) -> AP:
             try:
@@ -449,17 +460,62 @@ def successors_for_alphabet(
     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
+    ap_inverse = sym_aut.ap_inverse
+
+    # Materialise the symbol list and precompute AP-truth sets once.
+    symbols_list = list(symbols)
+    n = len(symbols_list)
+    truths_list: list[AbstractSet[AP]] = [alphabet.labeling(s) for s in symbols_list]
+    accumulators: list[Function] = [mgr.false] * n
+
+    # Bucket rows by their support shape. Rows in the same bucket
+    # share the partition over input symbols and the per-class
+    # ``point`` dict; only the cofactor target ``guard_bdd`` varies.
+    buckets: dict[frozenset[str], list[tuple[Function, Function]]] = defaultdict(list)
+    for guard_bdd, succ_bdd in rows:
+        sup_key = frozenset(guard_bdd.support)
+        buckets[sup_key].append((guard_bdd, succ_bdd))
+
+    for sup, group_rows in buckets.items():
+        if not sup:
+            # Constant-guard bucket: no cofactor needed.
+            for guard_bdd, succ_bdd in group_rows:
+                if guard_bdd == mgr.true:
+                    for i in range(n):
+                        accumulators[i] = mgr.apply("or", accumulators[i], succ_bdd)
+                # ``mgr.false`` rows contribute nothing.
+            continue
+
+        # Translate manager-var-names in ``sup`` back to AP labels.
+        sup_aps: list[AP] = [ap_inverse[name] for name in sup]
+
+        # Partition symbol indices by their projection onto ``sup_aps``.
+        classes: dict[frozenset[AP], list[int]] = defaultdict(list)
+        for i, truths in enumerate(truths_list):
+            proj = frozenset(ap for ap in sup_aps if ap in truths)
+            classes[proj].append(i)
+
+        # Per-class ``point`` dicts are determined by ``sup_aps`` and
+        # the projection; hoist out of the row loop. Materialise the
+        # parallel ``(point, indices)`` list once so the per-row inner
+        # loop is a tight zip with no dict lookups.
+        class_points_indices: list[tuple[dict[str, Function], list[int]]] = [
+            (
+                {ap_registry[ap]: (mgr.true if ap in proj else mgr.false) for ap in sup_aps},
+                indices,
+            )
+            for proj, indices in classes.items()
+        ]
+
+        for guard_bdd, succ_bdd in group_rows:
+            for point, indices in class_points_indices:
+                if mgr.let(point, guard_bdd) == mgr.true:
+                    for i in indices:
+                        accumulators[i] = mgr.apply("or", accumulators[i], succ_bdd)
+
+    for i in range(n):
+        if accumulators[i] != mgr.false:
+            yield symbols_list[i], accumulators[i]
 
 
 # ---------------------------------------------------------------------------