morphata 2.2.1__tar.gz → 2.2.2__tar.gz

{morphata-2.2.1 → morphata-2.2.2}/CHANGELOG.md

@@ -1,5 +1,28 @@
 # Changelog
 
+## 2.2.2 — 2026-08-23
+
+### Fixed
+
+- Fixes a bug with complement and composition of nondeterministic automata
+
+  `__invert__` dualized each
+  (guard, successor)
+  pair on its own, leaving the implicit disjunction across a state's pairs undualized.
+  Read each state's relation back through `partition_by_state_residual` first,
+  so the disjunction sits inside one residual per disjoint guard class;
+  missing moves come back as a `false` residual, whose dual is the correct `true`.
+
+  `compose_automata` remapped only the reachable states,
+  so a fresh index could land on an unreachable state that kept its own index
+  and silently overwrite a transition row.
+  Remap every state and prune the unreachable rows afterwards.
+  `reindex_states` now rejects an assignment whose image collides with a state it does
+  not remap, so the same mistake raises instead of corrupting.
+
+  Together these made `is_language_equivalent` report False
+  for automata with identical languages.
+
 ## 2.2.1 — 2026-08-20
 
 This version bump is mostly a cleanup after the 2.2.0 rewrite,

{morphata-2.2.1 → morphata-2.2.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: morphata
-Version: 2.2.1
+Version: 2.2.2
 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.2.1 → morphata-2.2.2}/src/morphata/_version.py

@@ -18,7 +18,7 @@ version_tuple: tuple[int | str, ...]
 commit_id: str | None
 __commit_id__: str | None
 
-__version__ = version = '2.2.1'
-__version_tuple__ = version_tuple = (2, 2, 1)
+__version__ = version = '2.2.2'
+__version_tuple__ = version_tuple = (2, 2, 2)
 
 __commit_id__ = commit_id = None

{morphata-2.2.1 → morphata-2.2.2}/src/morphata/symbolic/automaton.py

@@ -531,16 +531,31 @@ class SymbolicAutomaton[AP: Hashable, Symbol]:
     ) -> SymbolicAutomaton[AP, Symbol]:
         """Return a new symbolic automaton with the states reindexed based on the assignments.
 
-        States absent from ``assignment`` keep their index. This reindexes state
-        identity everywhere it is encoded: the BDD functions (via
-        ``let_state_vars``), the transition-dict keys, and the acceptance
+        States absent from ``assignment`` keep their index, so the assignment
+        must not map any state onto the index of a state it leaves alone. This
+        reindexes state identity everywhere it is encoded: the BDD functions
+        (via ``let_state_vars``), the transition-dict keys, and the acceptance
         condition. The state-keyed lazy caches are left to rebuild on demand;
         the ``deterministic`` / ``alternating`` flags are preserved because a
         reindexing is a bijective relabelling.
+
+        Raises
+        ------
+        ValueError
+            If the image of ``assignment`` collides with a state that
+            ``assignment`` does not remap. Such a collision silently drops the
+            colliding transition row (and merges the acceptance sets) instead
+            of relabelling.
         """
         if not assignment:
             return self
 
+        collisions = set(assignment.values()) & (set(self.states) - set(assignment))
+        if collisions:
+            raise ValueError(
+                f"reindexing assignment maps onto states it does not remap: {sorted(collisions)!r}"
+            )
+
         manager = self.manager
 
         def _transfer(fn: Function[AP, int]) -> Function[AP, int]:
@@ -689,9 +704,21 @@ class SymbolicAutomaton[AP: Hashable, Symbol]:
         """
         mgr = self.manager
         initial = mgr.dualize_state_expr(self.initial)
+        # A state's outgoing pairs are read disjunctively (see
+        # `transition_relation`), so the dual has to flip that outer disjunction
+        # too. Dualizing each `succ` in isolation would leave it in place, which
+        # is unsound as soon as two guards of a state overlap. Reading the
+        # relation back through `partition_by_state_residual` puts the whole
+        # disjunction inside one residual per (disjoint) guard class; missing
+        # moves show up as a `false` residual, whose dual is `true`.
         transitions = {
-            q: [(guard, mgr.dualize_state_expr(succ)) for guard, succ in outgoing]
-            for q, outgoing in self.transitions.items()
+            q: [
+                (guard, mgr.dualize_state_expr(succ))
+                for guard, succ in mgr.partition_by_state_residual(
+                    self.transition_relation(q)
+                )
+            ]
+            for q in self.transitions
         }
         # A fresh (empty) transition-relation cache is used implicitly --
         # inheriting self's would serve stale, pre-dual relations.

{morphata-2.2.1 → morphata-2.2.2}/src/morphata/symbolic/utils.py

@@ -33,7 +33,7 @@ from collections.abc import (
     Sequence,
 )
 from collections.abc import Set as AbstractSet
-from dataclasses import dataclass, field
+from dataclasses import dataclass, field, replace
 from typing import override
 
 from morphata.acceptance import Finite
@@ -684,7 +684,7 @@ def compose_automata[AP: Hashable, Symbol](
                 f"incompatible manager for automaton at position {idx}; use `replace_manager` to ensure they have the same manager."
             )
 
-        # Loop through the reachable automaton states and find the remapping.
+        # Loop through the automaton states and find the remapping.
         # TODO: THIS CURRENTLY DOES NOT COLLAPSE SINKS
         # A sink is one that has outgoing == mgr.true (if the automaton is complete, which it should be)
         # So we just need to check if the sink is accepting or not.
@@ -693,12 +693,27 @@ def compose_automata[AP: Hashable, Symbol](
         # 1. if the condition is Finite, just check
         # 2. if omega, partition by which acceptance set it is part of
         remap = {
-            q: state_var_manager.get_or_declare((idx, QVar(q))).name
-            for q in aut.reachable_states()
+            q: state_var_manager.get_or_declare((idx, QVar(q))).name for q in aut.states
         }
         assert len(remap) > 0
+        # Every state is remapped, not just the reachable ones: a partial
+        # assignment can hand a fresh index to one state while another keeps
+        # that same index, and the collision silently drops a transition row.
+        # The unreachable rows are pruned after the relabelling instead.
+        live = {remap[q] for q in aut.reachable_states()}
         # remap all the functions in the current automaton
         remapped = aut.reindex_states(remap)
+        remapped = replace(
+            remapped,
+            transitions={
+                q: outgoing for q, outgoing in remapped.transitions.items() if q in live
+            },
+            _transition_rel_cache={
+                q: rel
+                for q, rel in remapped._transition_rel_cache.items()  # pyright: ignore[reportPrivateUsage]
+                if q in live
+            },
+        )
         if carry is None:
             carry = remapped
         else:

{morphata-2.2.1 → morphata-2.2.2}/tests/symbolic/test_compose.py

@@ -2,6 +2,7 @@
 
 from __future__ import annotations
 
+import itertools
 from collections.abc import Set as AbstractSet
 from typing import Literal
 
@@ -175,3 +176,97 @@ def test_min_dfa_of_conjunction_empty() -> None:
     assert result.accepts([])
     assert result.accepts([frozenset(), frozenset({"a"}), frozenset({"a", "b"})])
     assert result.accepts([frozenset({"b"})] * 4)
+
+
+# ---------------------------------------------------------------------------
+# State-index collisions with unreachable states
+# ---------------------------------------------------------------------------
+
+
+def _words(max_len: int = 4) -> list[list[AbstractSet[str]]]:
+    letters: list[AbstractSet[str]] = [frozenset(), frozenset({"a"})]
+    return [
+        list(w)
+        for n in range(max_len + 1)
+        for w in itertools.product(letters, repeat=n)
+    ]
+
+
+def _ends_with_a(
+    mgr: BDDManager[str, int], *, spare_states: int = 0
+) -> SymbolicAutomaton[str, AbstractSet[str]]:
+    """DFA for "the word ends with ``a``", plus ``spare_states`` unreachable states.
+
+    The spare states are what makes the composition remap partial: they are not
+    reachable, so a remap keyed on the reachable states alone leaves them at
+    their old index -- which is exactly the index a reachable state is being
+    moved to.
+    """
+    mgr.declare_ap_vars("a")
+    mgr.declare_state_vars(0, 1, *range(2, 2 + spare_states))
+    a, q = mgr.ap_var("a"), mgr.q_var
+    transitions = {
+        0: [(a, q(1)), (~a, q(0))],
+        1: [(a, q(1)), (~a, q(0))],
+    }
+    for spare in range(2, 2 + spare_states):
+        transitions[spare] = [(mgr.true, q(spare))]
+    return SymbolicAutomaton[str, AbstractSet[str]](
+        mgr,
+        q(0),
+        transitions,
+        Finite(frozenset({1})),
+        alphabet=powerset_alphabet({"a"}),
+    )
+
+
+def _starts_with_a(
+    mgr: BDDManager[str, int],
+) -> SymbolicAutomaton[str, AbstractSet[str]]:
+    """DFA for "the word starts with ``a``"; states 3, 4, 5 to avoid a clash."""
+    mgr.declare_ap_vars("a")
+    mgr.declare_state_vars(3, 4, 5)
+    a, q = mgr.ap_var("a"), mgr.q_var
+    return SymbolicAutomaton[str, AbstractSet[str]](
+        mgr,
+        q(3),
+        {
+            3: [(a, q(4)), (~a, q(5))],
+            4: [(mgr.true, q(4))],
+            5: [(mgr.true, q(5))],
+        },
+        Finite(frozenset({4})),
+        alphabet=powerset_alphabet({"a"}),
+    )
+
+
+@pytest.mark.parametrize("op", ["and", "or"])
+def test_compose_with_unreachable_states(
+    mgr: BDDManager[str, int], op: Literal["and", "or"]
+) -> None:
+    """Unreachable states must not cost the composition a transition row.
+
+    ``compose_automata`` hands every operand a fresh block of indices. When the
+    remap covers only the reachable states, a fresh index can land on an
+    unreachable state that keeps its old index, and the reindexed row for the
+    reachable state is overwritten by the unreachable one's.
+    """
+    lhs = _starts_with_a(mgr)
+    rhs = _ends_with_a(mgr, spare_states=2)
+    composed = compose_automata(op, lhs, rhs)
+
+    expected = [
+        (lhs.accepts(w) and rhs.accepts(w))
+        if op == "and"
+        else (lhs.accepts(w) or rhs.accepts(w))
+        for w in _words()
+    ]
+    assert [composed.accepts(w) for w in _words()] == expected
+
+
+def test_compose_drops_unreachable_states(mgr: BDDManager[str, int]) -> None:
+    """The product carries the reachable states of its operands and nothing else."""
+    lhs = _starts_with_a(mgr)
+    rhs = _ends_with_a(mgr, spare_states=2)
+
+    assert compose_automata("and", lhs, rhs).num_states == 5

{morphata-2.2.1 → morphata-2.2.2}/tests/symbolic/test_language_equivalence.py

@@ -20,7 +20,7 @@ import logic_asts as logic
 import pytest
 from logic_asts import ltl
 
-from morphata.acceptance import Buchi
+from morphata.acceptance import Buchi, Finite
 from morphata.alphabet import powerset_alphabet
 from morphata.symbolic import SymbolicAutomaton
 from morphata.symbolic.bdd import BDDManager
@@ -154,3 +154,53 @@ def test_requires_finite_acceptance(mgr: BDDManager[str, int]) -> None:
         is_language_equivalent(non_finite, a)
     with pytest.raises(TypeError):
         is_language_equivalent(a, non_finite)
+
+
+# ---------------------------------------------------------------------------
+# Nondeterministic operands
+# ---------------------------------------------------------------------------
+
+
+def _nfa_a_two_before_the_end(
+    mgr: BDDManager[str, int], *, spare_state: bool
+) -> SymbolicAutomaton[str, AbstractSet[str]]:
+    """NFA for "some ``a`` occurs at least two positions before the end".
+
+    State 0 is nondeterministic: on ``a`` both of its pairs fire, so the
+    equivalence check has to dualize the disjunction across them. With
+    ``spare_state``, an unreachable state is added, which does not change the
+    language but does shift the state indexing the composition works with.
+    """
+    mgr.declare_ap_vars("a")
+    states = [0, 1, 2] + ([3] if spare_state else [])
+    mgr.declare_state_vars(*states)
+    av, q = mgr.ap_var("a"), mgr.q_var
+    transitions = {
+        0: [(av, q(1)), (mgr.true, q(0))],
+        1: [(mgr.true, q(2))],
+        2: [(mgr.true, q(2))],
+    }
+    if spare_state:
+        transitions[3] = [(mgr.true, q(2))]
+    return SymbolicAutomaton[str, AbstractSet[str]](
+        mgr,
+        q(0),
+        transitions,
+        Finite(frozenset({2})),
+        alphabet=powerset_alphabet({"a"}),
+    )
+
+
+def test_nondeterministic_pair_with_a_spare_state(mgr: BDDManager[str, int]) -> None:
+    """Two spellings of one language, one of them carrying an unreachable state."""
+    a = _nfa_a_two_before_the_end(mgr, spare_state=False)
+    b = _nfa_a_two_before_the_end(mgr, spare_state=True)
+
+    assert _brute_force_equivalent(a, b)
+    assert is_language_equivalent(a, b)
+
+
+def test_nondeterministic_against_its_min_dfa(mgr: BDDManager[str, int]) -> None:
+    a = _nfa_a_two_before_the_end(mgr, spare_state=False)
+
+    assert is_language_equivalent(a, a.to_min_dfa())

{morphata-2.2.1 → morphata-2.2.2}/tests/symbolic/test_symbolic_automaton.py

@@ -2,6 +2,7 @@
 
 from __future__ import annotations
 
+import itertools
 from collections.abc import Callable, Mapping
 from collections.abc import Set as AbstractSet
 from typing import assert_type
@@ -460,3 +461,150 @@ class TestReplaceManager:
         alphabet = powerset_alphabet(_AB_PREDICATES)
         aut = _build_a_then_b_dfa().build(labeling_fn=alphabet.labeling, manager=mgr)
         assert aut.replace_manager(mgr) is aut
+
+
+# ---------------------------------------------------------------------------
+# Complement by dualization
+# ---------------------------------------------------------------------------
+
+
+def _words_over_a(max_len: int = 5) -> list[list[frozenset[str]]]:
+    """Every word up to ``max_len`` over the powerset alphabet on ``{"a"}``."""
+    letters = [sym(), sym("a")]
+    return [
+        list(w)
+        for n in range(max_len + 1)
+        for w in itertools.product(letters, repeat=n)
+    ]
+
+
+def _dfa_last_letter_was_a(
+    mgr: BDDManager[str, int],
+) -> SymbolicAutomaton[str, AbstractSet[str]]:
+    """Deterministic: accepts iff the word ends with ``a``."""
+    mgr.declare_ap_vars("a")
+    mgr.declare_state_vars(0, 1)
+    a, q = mgr.ap_var("a"), mgr.q_var
+    return SymbolicAutomaton[str, AbstractSet[str]](
+        mgr,
+        q(0),
+        {0: [(a, q(1)), (~a, q(0))], 1: [(a, q(1)), (~a, q(0))]},
+        Finite(frozenset({1})),
+        alphabet=powerset_alphabet(frozenset({"a"})),
+    )
+
+
+def _nfa_overlapping_guards(
+    mgr: BDDManager[str, int],
+) -> SymbolicAutomaton[str, AbstractSet[str]]:
+    """Nondeterministic: some ``a`` occurs at least two positions before the end.
+
+    State 0 has two outgoing pairs whose guards both fire on ``a``. That outer
+    disjunction is the part :meth:`SymbolicAutomaton.__invert__` has to dualize.
+    """
+    mgr.declare_ap_vars("a")
+    mgr.declare_state_vars(0, 1, 2)
+    a, q = mgr.ap_var("a"), mgr.q_var
+    return SymbolicAutomaton[str, AbstractSet[str]](
+        mgr,
+        q(0),
+        {
+            0: [(a, q(1)), (mgr.true, q(0))],
+            1: [(mgr.true, q(2))],
+            2: [(mgr.true, q(2))],
+        },
+        Finite(frozenset({2})),
+        alphabet=powerset_alphabet(frozenset({"a"})),
+    )
+
+
+def _conjunctive_monitors(
+    mgr: BDDManager[str, int],
+) -> SymbolicAutomaton[str, AbstractSet[str]]:
+    """Alternating: the initial state forks into two monitors that must both hold."""
+    mgr.declare_ap_vars("a")
+    mgr.declare_state_vars(0, 1, 2)
+    a, q = mgr.ap_var("a"), mgr.q_var
+    return SymbolicAutomaton[str, AbstractSet[str]](
+        mgr,
+        q(0),
+        {0: [(mgr.true, q(1) & q(2))], 1: [(a, q(1))], 2: [(mgr.true, q(2))]},
+        Finite(frozenset({1, 2})),
+        alphabet=powerset_alphabet(frozenset({"a"})),
+    )
+
+
+@pytest.mark.parametrize(
+    ("make", "deterministic", "alternating"),
+    [
+        (_dfa_last_letter_was_a, True, False),
+        (_nfa_overlapping_guards, False, False),
+        (_conjunctive_monitors, False, True),
+    ],
+    ids=["deterministic", "nondeterministic", "alternating"],
+)
+def test_invert_complements_the_language(
+    mgr: BDDManager[str, int],
+    make: Callable[[BDDManager[str, int]], SymbolicAutomaton[str, AbstractSet[str]]],
+    deterministic: bool,
+    alternating: bool,
+) -> None:
+    """``~x`` accepts exactly the words ``x`` rejects, whatever the branching mode.
+
+    The nondeterministic case is the regression guard: dualizing each
+    ``(guard, successor)`` pair on its own leaves the implicit disjunction
+    across a state's pairs undualized, which is only invisible when at most one
+    pair can fire per input.
+    """
+    aut = make(mgr)
+    assert aut.is_deterministic() is deterministic
+    assert aut.is_alternating() is alternating
+
+    complement = ~aut
+    disagreements = [
+        w for w in _words_over_a() if complement.accepts(w) == aut.accepts(w)
+    ]
+    assert disagreements == []
+
+
+def test_double_invert_preserves_the_language(mgr: BDDManager[str, int]) -> None:
+    from morphata.symbolic.utils import is_language_equivalent
+
+    aut = _nfa_overlapping_guards(mgr)
+    assert is_language_equivalent(~~aut, aut)
+
+
+# ---------------------------------------------------------------------------
+# reindex_states
+# ---------------------------------------------------------------------------
+
+
+def test_reindex_states_rejects_a_colliding_assignment(
+    mgr: BDDManager[str, int],
+) -> None:
+    """A fresh index that names a state left alone would drop that state's row."""
+    aut = _nfa_overlapping_guards(mgr)
+
+    with pytest.raises(ValueError, match="does not remap"):
+        _ = aut.reindex_states({0: 2})
+
+
+def test_reindex_states_allows_a_permutation(mgr: BDDManager[str, int]) -> None:
+    aut = _nfa_overlapping_guards(mgr)
+    swapped = aut.reindex_states({1: 2, 2: 1})
+
+    assert set(swapped.states) == {0, 1, 2}
+    assert swapped.acceptance == Finite(frozenset({1}))
+    assert [swapped.accepts(w) for w in _words_over_a(3)] == [
+        aut.accepts(w) for w in _words_over_a(3)
+    ]
+
+
+def test_reindex_states_allows_a_partial_move_to_fresh_indices(
+    mgr: BDDManager[str, int],
+) -> None:
+    aut = _nfa_overlapping_guards(mgr)
+    mgr.declare_state_vars(7)
+    moved = aut.reindex_states({0: 7})
+
+    assert set(moved.states) == {7, 1, 2}