morphata 2.0.3__tar.gz → 2.0.4__tar.gz

{morphata-2.0.3 → morphata-2.0.4}/CHANGELOG.md

@@ -1,5 +1,14 @@
 # Changelog
 
+## 2.0.4 — 2026-05-28
+
+### Added
+
+Technically a feature release almost immediately
+after another feature release masquerading as a patch,
+this release adds the ability to translate from a `SymbolicAutomaton` back to an
+`Automaton`, allowing for the `SymbolicAutomaton` to be exported to an HOA file.
+
 ## 2.0.3 — 2026-05-28
 
 ### Added

{morphata-2.0.3 → morphata-2.0.4}/PKG-INFO

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

{morphata-2.0.3 → morphata-2.0.4}/src/morphata/hoa/exporter.py

@@ -7,6 +7,7 @@ The morphata-specific ``Final(n)`` extension is preserved.
 
 from __future__ import annotations
 
+import dataclasses
 import io
 import typing as ty
 from collections.abc import Iterable, Mapping, Sequence
@@ -43,6 +44,7 @@ def automaton_to_hoa(
     if isinstance(aut.delta, Step):
         raise TypeError("HOA export requires an Outgoing delta; got Step.")
 
+    aut = _materialize_sinks(aut)
     states = sorted(_require_int_states(aut))
     ap_order = _ap_order(aut.predicates)
     ap_to_index = {ap: i for i, ap in enumerate(ap_order)}
@@ -70,6 +72,109 @@ def automaton_to_hoa(
     return buf.getvalue()
 
 
+# ---------------------------------------------------------------------------
+# Sink-state materialisation
+# ---------------------------------------------------------------------------
+
+
+def _materialize_sinks(
+    aut: Automaton[int, ty.Any, ty.Any],
+) -> Automaton[int, ty.Any, ty.Any]:
+    """Replace ``Literal(True)`` / ``Literal(False)`` successors with sink states.
+
+    HOA does not have an in-band representation of "accept here" / "reject
+    here" successors. AFAs naturally produce them: a satisfied conjunctive
+    obligation lowers to ``Literal(True)``; a contradiction lowers to
+    ``Literal(False)``. We materialise explicit accepting / rejecting
+    sink states with self-loops and rewrite any ``Literal`` successors
+    (and the initial expression) to point at them.
+
+    Only :class:`~morphata.acceptance.Finite` acceptance is currently
+    supported; omega-regular acceptance conditions with literal
+    successors raise ``NotImplementedError`` because correct sink-set
+    placement depends on the condition's set semantics.
+    """
+    from morphata.acceptance import Finite
+    from morphata.automaton import Outgoing
+
+    if not isinstance(aut.delta, Outgoing):
+        return aut
+
+    states_iter = aut.iter_states()
+    if states_iter is None:
+        return aut
+    states = sorted(states_iter)
+    if not states or not all(isinstance(s, int) for s in states):
+        return aut
+
+    rows_by_state: dict[int, list[tuple[logic.BoolExpr[ty.Any], logic.BoolExpr[int]]]] = {
+        s: list(aut.delta.fn(s)) for s in states
+    }
+
+    needs_true = isinstance(aut.initial, logic.Literal) and bool(aut.initial.value)
+    needs_false = isinstance(aut.initial, logic.Literal) and not aut.initial.value
+    for rows in rows_by_state.values():
+        for _, succ in rows:
+            if isinstance(succ, logic.Literal):
+                if succ.value:
+                    needs_true = True
+                else:
+                    needs_false = True
+
+    if not (needs_true or needs_false):
+        return aut
+
+    if not isinstance(aut.acceptance, Finite):
+        raise NotImplementedError(
+            "HOA export: Literal(True)/Literal(False) successors require "
+            "sink-state materialisation, which is only implemented for "
+            f"Finite acceptance; got {type(aut.acceptance).__name__}."
+        )
+
+    next_id = max(states) + 1
+    true_sink: int | None = None
+    false_sink: int | None = None
+    if needs_true:
+        true_sink = next_id
+        next_id += 1
+    if needs_false:
+        false_sink = next_id
+        next_id += 1
+
+    def _swap(expr: logic.BoolExpr[int]) -> logic.BoolExpr[int]:
+        if isinstance(expr, logic.Literal):
+            if expr.value and true_sink is not None:
+                return logic.Variable(true_sink)
+            if not expr.value and false_sink is not None:
+                return logic.Variable(false_sink)
+        return expr
+
+    new_rows: dict[int, list[tuple[logic.BoolExpr[ty.Any], logic.BoolExpr[int]]]] = {
+        s: [(g, _swap(succ)) for g, succ in rs] for s, rs in rows_by_state.items()
+    }
+    if true_sink is not None:
+        new_rows[true_sink] = [(logic.Literal(True), logic.Variable(true_sink))]
+    if false_sink is not None:
+        new_rows[false_sink] = [(logic.Literal(True), logic.Variable(false_sink))]
+
+    new_initial = _swap(aut.initial)
+    new_accepting = frozenset(aut.acceptance.accepting) | ({true_sink} if true_sink is not None else frozenset[int]())
+
+    def _fn(
+        s: int,
+        _r: dict[int, list[tuple[logic.BoolExpr[ty.Any], logic.BoolExpr[int]]]] = new_rows,
+    ) -> Iterable[tuple[logic.BoolExpr[ty.Any], logic.BoolExpr[int]]]:
+        return iter(_r.get(s, []))
+
+    return dataclasses.replace(
+        aut,
+        states=frozenset(range(next_id)),
+        initial=new_initial,
+        delta=Outgoing(fn=_fn),
+        acceptance=Finite(accepting=new_accepting),
+    )
+
+
 # ---------------------------------------------------------------------------
 # Header
 # ---------------------------------------------------------------------------

{morphata-2.0.3 → morphata-2.0.4}/src/morphata/symbolic/automaton.py

@@ -166,6 +166,76 @@ class SymbolicAutomaton(Generic[AP]):
         """``True`` iff the automaton accepts *word* under finite-word semantics."""
         return self.evaluate_at_accepting(self.run(word))
 
+    def to_automaton(self) -> "Automaton[int, Any, AP]":
+        """Round-trip the BDD-shaped automaton back to the canonical IR.
+
+        Decodes guard BDDs through ``self.ap_registry`` (BDD var name
+        -> AP) and successor BDDs through the default ``q{i} -> int``
+        decoder. Emits one IR row per cached ``(guard_bdd, succ_bdd)``
+        pair; no merging or simplification.
+
+        Raises
+        ------
+        ValueError
+            If ``self`` was constructed with ``cache_transitions=False``
+            and there are no rows to serialize.
+        """
+        from morphata.automaton import Outgoing
+        from morphata.symbolic.bdd import bdd_to_boolexpr
+
+        if self.num_states > 0 and not self.transitions:
+            raise ValueError(
+                "to_automaton requires a populated transition cache; "
+                "reconstruct SymbolicAutomaton with cache_transitions=True."
+            )
+
+        ap_decoder_map: dict[str, AP] = {var: ap for ap, var in self.ap_registry.items()}
+
+        def _ap_decode(name: str) -> AP:
+            try:
+                return ap_decoder_map[name]
+            except KeyError as exc:
+                raise ValueError(f"Guard BDD references unknown variable {name!r}") from exc
+
+        rows_by_state: dict[int, list[tuple[BoolExpr[AP], BoolExpr[int]]]] = {}
+        for s in range(self.num_states):
+            decoded_rows: list[tuple[BoolExpr[AP], BoolExpr[int]]] = []
+            for guard_bdd, succ_bdd in self.transitions.get(s, ()):
+                guard_expr = typing.cast(
+                    "BoolExpr[AP]",
+                    bdd_to_boolexpr(guard_bdd, var_decoder=_ap_decode),
+                )
+                succ_expr = typing.cast("BoolExpr[int]", bdd_to_boolexpr(succ_bdd))
+                decoded_rows.append((guard_expr, succ_expr))
+            rows_by_state[s] = decoded_rows
+
+        def _delta_fn(
+            s: int,
+            _rows: dict[int, list[tuple[BoolExpr[AP], BoolExpr[int]]]] = rows_by_state,
+        ) -> Iterable[tuple[BoolExpr[AP], BoolExpr[int]]]:
+            return iter(_rows.get(s, []))
+
+        initial_expr = typing.cast("BoolExpr[int]", bdd_to_boolexpr(self.initial))
+
+        return Automaton(
+            states=frozenset(range(self.num_states)),
+            predicates=frozenset(self.ap_registry),
+            initial=initial_expr,
+            delta=Outgoing(fn=_delta_fn),
+            acceptance=self.acceptance,
+        )
+
+    def to_hoa(
+        self,
+        *,
+        name: str | None = None,
+        properties: Sequence[str] | None = None,
+    ) -> str:
+        """Serialize ``self`` to an HOA v1 string via :func:`automaton_to_hoa`."""
+        from morphata.hoa import automaton_to_hoa
+
+        return automaton_to_hoa(self.to_automaton(), name=name, properties=properties)
+
     def to_min_dfa(self) -> "SymbolicAutomaton[AP]":
         """Determinize and minimize ``self`` into a minimal DFA.
 

morphata-2.0.4/tests/symbolic/test_to_hoa.py

@@ -0,0 +1,142 @@
+"""Tests for ``SymbolicAutomaton.to_automaton`` and ``SymbolicAutomaton.to_hoa``."""
+
+from __future__ import annotations
+
+import itertools
+from typing import Any
+
+import logic_asts as logic
+import logic_asts.ltl as ltl
+import pytest
+
+import morphata.hoa
+from morphata.acceptance import Finite
+from morphata.alphabet import powerset_alphabet
+from morphata.automaton import Automaton, Outgoing
+from morphata.builder import AutomatonBuilder
+from morphata.symbolic import SymbolicAutomaton
+from morphata.symbolic.bdd import Manager
+
+
+def _lift(aut: Automaton[int, Any, str], mgr: Manager) -> SymbolicAutomaton[str]:
+    alphabet = powerset_alphabet(aut.predicates)
+    return SymbolicAutomaton.from_automaton(aut, alphabet=alphabet, manager=mgr)
+
+
+def _round_trip(sym: SymbolicAutomaton[str], mgr: Manager) -> SymbolicAutomaton[str]:
+    """Export *sym* to HOA, re-parse, and lift back into a SymbolicAutomaton."""
+    hoa_text = sym.to_hoa()
+    parsed = morphata.hoa.parse(hoa_text)
+    aut = Automaton.from_parsed(parsed)
+    return _lift(aut, mgr)
+
+
+def _all_words(aps: frozenset[str], lengths: range) -> list[list[frozenset[str]]]:
+    aps_sorted = sorted(aps)
+    symbols = [frozenset(s) for r in range(len(aps_sorted) + 1) for s in itertools.combinations(aps_sorted, r)]
+    return [list(w) for n in lengths for w in itertools.product(symbols, repeat=n)]
+
+
+# ---------------------------------------------------------------------------
+# to_automaton: structural checks
+# ---------------------------------------------------------------------------
+
+
+class TestToAutomatonStructure:
+    def test_preserves_predicates_and_states(self, mgr: Manager) -> None:
+        b = AutomatonBuilder[int, str]()
+        b.add_state(0, initial=True)
+        b.add_state(1, accepting=True)
+        b.add_transition(0, logic.Variable("a"), 1)
+        b.add_transition(1, logic.Variable("a"), 1)
+        aut = b.build()
+        sym = _lift(aut, mgr)
+
+        roundtrip = sym.to_automaton()
+        assert roundtrip.predicates == frozenset({"a"})
+        assert set(roundtrip.iter_states() or ()) == {0, 1}
+        assert roundtrip.acceptance is sym.acceptance
+        assert isinstance(roundtrip.delta, Outgoing)
+
+    def test_row_count_matches_transition_cache(self, mgr: Manager) -> None:
+        b = AutomatonBuilder[int, str]()
+        b.add_state(0, initial=True, accepting=True)
+        b.add_state(1, accepting=True)
+        b.add_transition(0, logic.Variable("a"), 1)
+        b.add_transition(0, logic.Variable("b"), 0)
+        b.add_transition(1, logic.Variable("a"), 0)
+        aut = b.build()
+        sym = _lift(aut, mgr)
+
+        roundtrip = sym.to_automaton()
+        assert isinstance(roundtrip.delta, Outgoing)
+        for s in range(sym.num_states):
+            assert len(list(roundtrip.delta.fn(s))) == len(sym.transitions[s])
+
+    def test_no_cache_raises(self, mgr: Manager) -> None:
+        b = AutomatonBuilder[int, str]()
+        b.add_state(0, initial=True, accepting=True)
+        b.add_transition(0, logic.Variable("a"), 0)
+        aut = b.build()
+        alphabet = powerset_alphabet(aut.predicates)
+        sym = SymbolicAutomaton.from_automaton(aut, alphabet=alphabet, manager=mgr, cache_transitions=False)
+        with pytest.raises(ValueError, match="cache_transitions=True"):
+            sym.to_automaton()
+
+
+# ---------------------------------------------------------------------------
+# to_hoa: semantic round-trip via HOA parse
+# ---------------------------------------------------------------------------
+
+
+class TestToHoaRoundTrip:
+    def test_builder_dfa(self, mgr_factory: Any) -> None:
+        # Accept words with at least one 'a'.
+        mgr1 = mgr_factory()
+        b = AutomatonBuilder[int, str]()
+        b.add_state(0, initial=True)
+        b.add_state(1, accepting=True)
+        b.add_transition(0, logic.Variable("a"), 1)
+        b.add_transition(0, logic.Not(logic.Variable("a")), 0)
+        b.add_transition(1, logic.Literal(True), 1)
+        aut = b.build()
+        sym = _lift(aut, mgr1)
+
+        mgr2 = mgr_factory()
+        reparsed = _round_trip(sym, mgr2)
+
+        for w in _all_words(frozenset({"a"}), range(0, 4)):
+            assert sym.accepts(w) == reparsed.accepts(w), w
+
+    def test_alternating_ltlf(self, mgr_factory: Any) -> None:
+        # F a -- alternating AFA; produces a Literal(True) successor sink.
+        formula = ltl.Eventually(logic.Variable("a"))
+        mgr1 = mgr_factory()
+        alphabet = powerset_alphabet(frozenset({"a"}))
+        sym = SymbolicAutomaton.from_ltl(formula, alphabet=alphabet, finite=True, manager=mgr1)
+        assert isinstance(sym.acceptance, Finite)
+
+        mgr2 = mgr_factory()
+        reparsed = _round_trip(sym, mgr2)
+
+        for w in _all_words(frozenset({"a"}), range(0, 4)):
+            assert sym.accepts(w) == reparsed.accepts(w), w
+
+    def test_min_dfa_of_ltlf(self, mgr_factory: Any) -> None:
+        # F(a) & G(a -> X b)
+        formula = ltl.And(
+            (
+                ltl.Eventually(logic.Variable("a")),
+                ltl.Always(logic.Implies(logic.Variable("a"), ltl.Next(logic.Variable("b")))),
+            )
+        )
+        mgr1 = mgr_factory()
+        alphabet = powerset_alphabet(frozenset({"a", "b"}))
+        sym = SymbolicAutomaton.from_ltl(formula, alphabet=alphabet, finite=True, manager=mgr1)
+        sym_min = sym.to_min_dfa()
+
+        mgr2 = mgr_factory()
+        reparsed = _round_trip(sym_min, mgr2)
+
+        for w in _all_words(frozenset({"a", "b"}), range(0, 4)):
+            assert sym_min.accepts(w) == reparsed.accepts(w), w

{morphata-2.0.3 → morphata-2.0.4}/uv.lock

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