morphata 2.0.9__tar.gz → 2.0.10__tar.gz

{morphata-2.0.9 → morphata-2.0.10}/.claude/settings.local.json

@@ -26,7 +26,10 @@
       "Bash(echo \"exit: $?\")",
       "Skill(superpowers:executing-plans)",
       "Bash(ruff check *)",
-      "Bash(ruff format *)"
+      "Bash(ruff format *)",
+      "Bash(python -c \"import algebraic.polynomials as p; print\\(p.__file__\\)\")",
+      "Bash(python -c \"import algebraic; print\\(algebraic.__file__\\)\")",
+      "Bash(python -c \"import algebraic; print\\(algebraic.__path__\\)\")"
     ]
   }
 }

morphata-2.0.10/.codegraph/.gitignore

@@ -0,0 +1,16 @@
+# CodeGraph data files
+# These are local to each machine and should not be committed
+
+# Database
+*.db
+*.db-wal
+*.db-shm
+
+# Cache
+cache/
+
+# Logs
+*.log
+
+# Hook markers
+.dirty

morphata-2.0.10/.codegraph/daemon.pid

@@ -0,0 +1,6 @@
+{
+  "pid": 92,
+  "version": "0.9.9",
+  "socketPath": "/home/anand/workspace/automata-stuff/morphata/.codegraph/daemon.sock",
+  "startedAt": 1780894603056
+}

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

@@ -1,5 +1,19 @@
 # Changelog
 
+## 2.0.10 — 2026-06-08
+
+### Fixed
+
+- Using `SymbolicAutomaton.to_bdd_json` and `SymbolicAutomaton.from_bdd_json` did not
+  preserve the positive normal form of the BDDs because we were using incorrect Shannon
+  cofactor expansion.
+
+### Performance
+
+- The HOA grammar is now LALR compatible! This means we get a huge performance boost
+  even for pretty large automata.
+- Similar thing was done in `logic-asts` and thus, the version will be bumped.
+
 ## 2.0.9 — 2026-06-04
 
 ### Fixed

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

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

@@ -20,6 +20,11 @@ To get pytest-benchmark's tabular wall-time output:
   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).
+- `test_hoa_parser_perf.py` -- ``hoa.parser.parse`` (parse + transform)
+  across the sample corpus, parametrized over ``earley`` vs ``lalr`` from
+  the same grammar to quantify the LALR switch. Run with
+  ``--benchmark-group-by=param:case`` to put the two algorithms side by
+  side per input.
 
 ## Recording results
 

morphata-2.0.10/bench/test_hoa_parser_perf.py

@@ -0,0 +1,114 @@
+"""Micro-benchmarks for ``morphata.hoa.parser.parse``.
+
+Quantifies the Earley -> LALR switch in the HOA parser. Both variants are
+built from the *same* committed grammar (`hoa.lark`); the only difference is
+``parser="earley"`` (the old default) versus ``parser="lalr"`` (current). The
+grammar's ``acceptance_cond`` is stratified, so it is unambiguous and parses
+under both algorithms -- the comparison is purely the parsing algorithm plus
+the shared ``_AstTransformer`` pass, i.e. the full ``parse()`` pipeline.
+
+Cases span the sample corpus from small (``aut1``) to the largest hand-written
+files (``rabin_2pair``, ``streett_2pair``), plus a synthetic ``craftax``
+stress input: a ~36-state min-DFA over 25 APs (the
+``test_min_dfa_of_conjunction_craftax_shaped_stress`` conjunction), exported to
+HOA. At ~18 KB with dense per-edge guards it is ~35x the largest sample file
+and pushes Earley into its superlinear regime, where the LALR win is starkest.
+
+Run with::
+
+    pytest bench/test_hoa_parser_perf.py -v \\
+        --benchmark-columns=mean,median,min,max,rounds \\
+        --benchmark-group-by=param:case
+
+Grouping by ``case`` puts the earley/lalr rows for the same input side by side
+so the speedup is read directly off the table.
+"""
+
+from __future__ import annotations
+
+import functools
+from pathlib import Path
+
+import logic_asts as logic
+import logic_asts.ltl as ltl
+import pytest
+from lark import Lark
+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.hoa.parser import HOA_GRAMMAR_FILE, ParsedAutomaton, _AstTransformer
+from morphata.symbolic.bdd import make_manager
+from morphata.symbolic.compose import min_dfa_of_conjunction
+
+_GRAMMAR = HOA_GRAMMAR_FILE.read_text()
+_HOA_DIR = Path(__file__).resolve().parent.parent / "tests" / "hoa"
+
+# One Lark instance per algorithm, built once and reused across rounds.
+_PARSERS: dict[str, Lark] = {
+    "earley": Lark(_GRAMMAR, start="automaton", parser="earley", maybe_placeholders=True),
+    "lalr": Lark(_GRAMMAR, start="automaton", parser="lalr", maybe_placeholders=True),
+}
+
+# Representative slice of the sample corpus: smallest, a couple of mid-size
+# omega conditions, the two largest acceptance formulas, and a synthetic
+# stress input (built lazily, see ``_craftax_hoa``).
+_CASES = ["aut1", "gen_buchi_3", "aut8", "rabin_2pair", "streett_2pair", "craftax"]
+
+
+@functools.cache
+def _craftax_hoa() -> str:
+    """Export the Craftax ENCHANT_SWORD-shaped min-DFA (~7 conjuncts, |AP|=25).
+
+    Mirrors ``test_min_dfa_of_conjunction_craftax_shaped_stress``. Cached so the
+    min-DFA is built once regardless of how many benchmark rounds run.
+    """
+    aps = {f"p{i}" for i in range(25)}
+    alphabet = powerset_alphabet(aps)
+    p = sorted(aps)
+
+    def F(name: str) -> logic.LTLExpr[str]:  # noqa: N802
+        return ltl.Eventually(logic.Variable(name))
+
+    def U(lhs: logic.LTLExpr[str], rhs: logic.LTLExpr[str]) -> logic.LTLExpr[str]:  # noqa: N802
+        return ltl.Until(lhs, rhs)
+
+    formulas: list[logic.LTLExpr[str]] = [
+        F(p[0]),
+        U(logic.Not(logic.Variable(p[0])), logic.Or((logic.Variable(p[1]), logic.Variable(p[2])))),
+        U(
+            logic.Not(logic.Variable(p[0])),
+            logic.Or((logic.Variable(p[3]), logic.Variable(p[4]), logic.Variable(p[5]))),
+        ),
+        U(logic.Not(logic.Variable(p[0])), logic.Or((logic.Variable(p[6]), logic.Variable(p[7])))),
+        F(p[1]),
+        F(p[4]),
+        F(p[7]),
+    ]
+    sym, _ = min_dfa_of_conjunction(formulas, alphabet=alphabet, manager=make_manager())
+    return symbolic_automaton_to_hoa(sym)
+
+
+def _hoa_text(case: str) -> str:
+    if case == "craftax":
+        return _craftax_hoa()
+    return (_HOA_DIR / f"{case}.hoa").read_text()
+
+
+def _parse_with(lark: Lark, text: str) -> ParsedAutomaton:
+    tree = lark.parse(text)
+    ret = _AstTransformer().transform(tree)
+    assert isinstance(ret, ParsedAutomaton)
+    return ret
+
+
+@pytest.mark.parametrize("kind", ["earley", "lalr"])
+@pytest.mark.parametrize("case", _CASES)
+def test_hoa_parse(benchmark: Benchmark, case: str, kind: str) -> None:
+    text = _hoa_text(case)
+    lark = _PARSERS[kind]
+
+    def _run() -> int:
+        return len(_parse_with(lark, text).body)
+
+    assert benchmark(_run) >= 0

{morphata-2.0.9 → morphata-2.0.10}/mypy.ini

@@ -8,6 +8,8 @@ files = $MYPY_CONFIG_FILE_DIR/src/**/*.py,
 
 cache_dir = $MYPY_CONFIG_FILE_DIR/.mypy_cache
 
+mypy_path = $MYPY_CONFIG_FILE_DIR/typings
+
 exclude_gitignore = True
 
 
@@ -43,3 +45,11 @@ ignore_missing_imports = True
 
 [mypy-wadler_lindig]
 ignore_missing_imports = True
+
+[mypy-spot]
+ignore_missing_imports = True
+disallow_untyped_defs = False
+
+[mypy-spot.*]
+ignore_missing_imports = True
+disallow_untyped_defs = False

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

{morphata-2.0.9 → morphata-2.0.10}/pyrightconfig.json

@@ -2,7 +2,7 @@
   "include": [
     "src",
     "tests",
-    "packages"
+    "bench"
   ],
   "pythonVersion": "3.12",
   "pythonPlatform": "All",

{morphata-2.0.9 → morphata-2.0.10}/src/morphata/hoa/hoa.lark

@@ -38,13 +38,19 @@ state_conj: INT ("&" INT)*
            | "(" label_expr ")"
 
 
-?acceptance_cond: BOOLEAN -> acc_bool
-               | "Fin" "(" acc_set ")" -> acc_fin
-               | "Inf" "(" acc_set ")" -> acc_inf
-               | "Final" "(" acc_set ")" -> acc_final
-               | "(" acceptance_cond ")"
-               | acceptance_cond "&" acceptance_cond -> acc_and
-               | acceptance_cond "|" acceptance_cond -> acc_or
+?acceptance_cond: acc_or
+
+?acc_or  : acc_and
+         | acc_or "|" acc_and -> acc_or
+
+?acc_and : acc_atom
+         | acc_and "&" acc_atom -> acc_and
+
+?acc_atom: BOOLEAN -> acc_bool
+         | "Fin" "(" acc_set ")" -> acc_fin
+         | "Inf" "(" acc_set ")" -> acc_inf
+         | "Final" "(" acc_set ")" -> acc_final
+         | "(" acceptance_cond ")"
 
 acc_set: [INVERT] INT
 INVERT: "!"

{morphata-2.0.9 → morphata-2.0.10}/src/morphata/hoa/parser.py

@@ -365,7 +365,8 @@ with open(HOA_GRAMMAR_FILE, "r") as grammar:
     HOA_GRAMMAR = Lark(
         grammar,
         start="automaton",
-        strict=True,
+        parser="lalr",
+        cache=True,
         maybe_placeholders=True,
     )
 

{morphata-2.0.9 → morphata-2.0.10}/src/morphata/logic/ltl.py

@@ -29,6 +29,7 @@ from morphata.symbolic.bdd import (
     Function,
     Manager,
     bdd_to_boolexpr,
+    bdd_to_positive_boolexpr,
     declare_state_vars,
     mgr_partition_ap_by_state_residual,
     state_var_name,
@@ -117,7 +118,7 @@ def ltl_to_automaton(
             if state_residual == mgr.false:
                 # No transition fires under this AP-cube; omit the row.
                 continue
-            succ_expr = _state_bdd_to_positive_boolexpr(state_residual, mgr)
+            succ_expr = ty.cast("BoolExpr[int]", bdd_to_positive_boolexpr(state_residual))
             guard_expr = ty.cast("BoolExpr[AP]", bdd_to_boolexpr(ap_cube, var_decoder=ap_guard_decoder))
             row_list.append((guard_expr, succ_expr))
         rows[sid] = row_list
@@ -148,143 +149,6 @@ def ltl_to_automaton(
     )
 
 
-def _state_bdd_to_positive_boolexpr(node: Function, mgr: Manager) -> BoolExpr[int]:
-    """Convert a monotone-positive BDD over state vars ``q{i}`` to a positive
-    :class:`BoolExpr[int]` (no ``Not`` over state variables).
-
-    Why a dedicated converter
-    -------------------------
-    The downstream :func:`morphata.symbolic.bdd.boolexpr_to_bdd` rejects
-    ``Not`` over state variables on purpose: the AFA-to-NFA dealternation
-    pipeline (``mgr_minimal_pos_satisfying_subsets``,
-    ``mgr_partition_ap_by_state_residual``, etc.) relies on every
-    successor BDD being monotone-positive in the state vars. The generic
-    :func:`bdd_to_boolexpr` emits the symmetric Shannon form
-    ``(v & high) | (~v & low)`` at the "neither short-circuits" arm,
-    which would slip a ``~q_i`` into the row's successor expression and
-    fail at re-BDD time even though the underlying function is positive.
-
-    Algorithm
-    ---------
-    Memoised post-order walk over the BDD nodes. At each non-terminal
-    node with variable ``v`` and children ``low = walk(n.low)``,
-    ``high = walk(n.high)``::
-
-        if low == high:                       built = low
-        elif low_is_false and high_is_true:   built = var
-        elif low_is_false:                    built = var & high
-        elif high_is_true:                    built = var | low
-        else:                                 built = (var & high) | low
-
-    Terminals decode to ``Literal(True)`` / ``Literal(False)``; the
-    equality test ``n == mgr.true`` already accounts for the complement
-    bit on terminal edges.
-
-    Correctness of ``(v & high) | low`` (the general arm)
-    -----------------------------------------------------
-    The standard Shannon expansion is::
-
-        f = (v & high) | (~v & low)
-
-    For monotone-positive ``f`` the cofactors satisfy ``low <= high``
-    (i.e. ``low ==> high`` -- the set of satisfying assignments of
-    ``low`` is contained in that of ``high``). Therefore
-    ``low == low & high`` and::
-
-        (v & high) | low
-          = (v & high) | (low & high)
-          = high & (v | low)
-          = ((v | low) & high)
-
-    Checking against the standard form:
-
-    * ``v = True``: standard gives ``high``; simplified gives
-      ``True & high | low = high | low = high`` (since ``low <= high``).
-    * ``v = False``: standard gives ``low``; simplified gives
-      ``False & high | low = low``.
-
-    Both match, so the simplified form is equivalent to the standard
-    Shannon expansion at every node, and it never mentions ``~v``.
-
-    Where the monotone-positive invariant comes from
-    ------------------------------------------------
-    The polynomial compiled into ``node`` by
-    :func:`_polynomial_to_bdd` is built from
-    :func:`ltl_symbolic_expansion`, which only ever emits state atoms
-    via ``logic.Variable(("state", obj))`` -- never with a wrapping
-    ``Not``. So the polynomial is positive in state vars by
-    construction, and cofactoring on AP variables (which is what
-    :func:`mgr_partition_ap_by_state_residual` does) cannot introduce
-    a negation on a state var. Every state-residual BDD reaching this
-    function therefore satisfies the contract.
-
-    Guard rails
-    -----------
-    Two ``elif`` arms cover BDD shapes that cannot occur for a
-    monotone-positive function (``high == false`` with ``low != false``,
-    or ``low == true`` with ``high != true``) and raise instead of
-    silently producing an incorrect Shannon form. A non-terminal node
-    whose top edge is complemented (``Function.negated``) would flip the
-    function's value to its negation -- also incompatible with
-    monotone-positivity -- and likewise raises.
-
-    Raises
-    ------
-    ValueError
-        If ``node`` references a non-state variable, has a complement
-        edge on a non-terminal, or otherwise fails the
-        monotone-positive contract.
-    """
-    cache: dict[Function, BoolExpr[int]] = {}
-
-    def walk(n: Function) -> BoolExpr[int]:
-        if n in cache:
-            return cache[n]
-        if n.var is None:
-            result: BoolExpr[int] = logic.Literal(n == mgr.true)
-            cache[n] = result
-            return result
-        if not n.var.startswith("q"):
-            raise ValueError(f"expected state variable, got {n.var!r}")
-        if getattr(n, "negated", False):
-            # A complemented top-edge on a non-terminal would make this
-            # subtree non-monotone in state vars, which contradicts the
-            # caller's contract.
-            raise ValueError("state residual BDD has complement edge; not monotone-positive")
-        idx = int(n.var[1:])
-        var: BoolExpr[int] = logic.Variable(idx)
-        assert n.low is not None and n.high is not None
-        low = walk(n.low)
-        high = walk(n.high)
-        low_is_false = isinstance(low, logic.Literal) and low.value is False
-        low_is_true = isinstance(low, logic.Literal) and low.value is True
-        high_is_false = isinstance(high, logic.Literal) and high.value is False
-        high_is_true = isinstance(high, logic.Literal) and high.value is True
-
-        if low == high:
-            built: BoolExpr[int] = low
-        elif high_is_false:
-            # Monotone-positive plus high=false forces low=false (low<=high),
-            # already handled by low==high above.
-            raise ValueError("non-monotone BDD: high=false but low!=false")
-        elif low_is_true:
-            # Same: low=true forces high=true; handled by low==high.
-            raise ValueError("non-monotone BDD: low=true but high!=true")
-        elif low_is_false and high_is_true:
-            built = var
-        elif low_is_false:
-            built = logic.And((var, high))
-        elif high_is_true:
-            built = logic.Or((var, low))
-        else:
-            # General positive form: (var & high) | low, valid because low <= high.
-            built = logic.Or((logic.And((var, high)), low))
-        cache[n] = built
-        return built
-
-    return walk(node)
-
-
 def _polynomial_to_bdd(
     mgr: Manager,
     poly: BoolExpr[tuple[str, Hashable]],

{morphata-2.0.9 → morphata-2.0.10}/src/morphata/logic/psl.py

@@ -25,7 +25,6 @@ from morphata.logic._common import dualize_polynomial as common_dualize_polynomi
 from morphata.logic._common import make_logic_context
 from morphata.logic.ltl import (
     _polynomial_to_bdd,
-    _state_bdd_to_positive_boolexpr,
     ltl_empty_trace_value,
     ltl_symbolic_expansion,
 )
@@ -41,6 +40,7 @@ from morphata.logic.sere import (
 from morphata.symbolic.bdd import (
     Manager,
     bdd_to_boolexpr,
+    bdd_to_positive_boolexpr,
     declare_state_vars,
     mgr_partition_ap_by_state_residual,
 )
@@ -339,7 +339,7 @@ def psl_to_automaton(
         for ap_cube, state_residual in mgr_partition_ap_by_state_residual(mgr, bdd_poly, ap_var_names):
             if state_residual == mgr.false:
                 continue
-            succ_expr = _state_bdd_to_positive_boolexpr(state_residual, mgr)
+            succ_expr = ty.cast("BoolExpr[int]", bdd_to_positive_boolexpr(state_residual))
             guard_expr = ty.cast(
                 "BoolExpr[AP]",
                 bdd_to_boolexpr(ap_cube, var_decoder=ap_guard_decoder),

{morphata-2.0.9 → morphata-2.0.10}/src/morphata/logic/sere.py

@@ -32,10 +32,11 @@ from morphata.acceptance import Finite
 from morphata.automaton import Automaton, Outgoing
 from morphata.logic._common import dualize_polynomial as _common_dualize_polynomial
 from morphata.logic._common import make_logic_context
-from morphata.logic.ltl import _polynomial_to_bdd, _state_bdd_to_positive_boolexpr
+from morphata.logic.ltl import _polynomial_to_bdd
 from morphata.symbolic.bdd import (
     Manager,
     bdd_to_boolexpr,
+    bdd_to_positive_boolexpr,
     declare_state_vars,
     mgr_partition_ap_by_state_residual,
 )
@@ -485,7 +486,7 @@ def sere_to_automaton(
         for ap_cube, state_residual in mgr_partition_ap_by_state_residual(mgr, bdd_poly, ap_var_names):
             if state_residual == mgr.false:
                 continue
-            succ_expr = _state_bdd_to_positive_boolexpr(state_residual, mgr)
+            succ_expr = ty.cast("BoolExpr[int]", bdd_to_positive_boolexpr(state_residual))
             guard_expr = ty.cast(
                 "BoolExpr[AP]",
                 bdd_to_boolexpr(ap_cube, var_decoder=ap_guard_decoder),

{morphata-2.0.9 → morphata-2.0.10}/src/morphata/symbolic/__init__.py

@@ -31,6 +31,7 @@ from morphata.symbolic.bdd import APRegistry as APRegistry
 from morphata.symbolic.bdd import Function as Function
 from morphata.symbolic.bdd import Manager as Manager
 from morphata.symbolic.bdd import bdd_to_boolexpr as bdd_to_boolexpr
+from morphata.symbolic.bdd import bdd_to_positive_boolexpr as bdd_to_positive_boolexpr
 from morphata.symbolic.bdd import boolexpr_to_bdd as boolexpr_to_bdd
 from morphata.symbolic.bdd import declare_ap_vars as declare_ap_vars
 from morphata.symbolic.bdd import declare_state_vars as declare_state_vars

{morphata-2.0.9 → morphata-2.0.10}/src/morphata/symbolic/automaton.py

@@ -196,7 +196,7 @@ class SymbolicAutomaton(Generic[AP]):
             and there are no rows to serialize.
         """
         from morphata.automaton import Outgoing
-        from morphata.symbolic.bdd import bdd_to_boolexpr
+        from morphata.symbolic.bdd import bdd_to_boolexpr, bdd_to_positive_boolexpr
 
         if self.num_states > 0 and not self.transitions:
             raise ValueError(
@@ -220,7 +220,10 @@ class SymbolicAutomaton(Generic[AP]):
                     "BoolExpr[AP]",
                     bdd_to_boolexpr(guard_bdd, var_decoder=_ap_decode),
                 )
-                succ_expr = typing.cast("BoolExpr[int]", bdd_to_boolexpr(succ_bdd))
+                # Successor BDDs are monotone-positive over the state vars;
+                # decode them so the result stays in positive normal form
+                # (PolynomialOperator rejects Not over state variables).
+                succ_expr = typing.cast("BoolExpr[int]", bdd_to_positive_boolexpr(succ_bdd))
                 decoded_rows.append((guard_expr, succ_expr))
             rows_by_state[s] = decoded_rows
 
@@ -230,7 +233,9 @@ class SymbolicAutomaton(Generic[AP]):
         ) -> Iterable[tuple[BoolExpr[AP], BoolExpr[int]]]:
             return iter(_rows.get(s, []))
 
-        initial_expr = typing.cast("BoolExpr[int]", bdd_to_boolexpr(self.initial))
+        # The initial-state set is monotone-positive over the state vars; keep
+        # it in positive normal form for the same reason as successors above.
+        initial_expr = typing.cast("BoolExpr[int]", bdd_to_positive_boolexpr(self.initial))
 
         return Automaton(
             states=frozenset(range(self.num_states)),

{morphata-2.0.9 → morphata-2.0.10}/src/morphata/symbolic/bdd.py

@@ -53,6 +53,7 @@ __all__ = [
     "Manager",
     "STATE_VAR_FORMAT",
     "bdd_to_boolexpr",
+    "bdd_to_positive_boolexpr",
     "boolexpr_to_bdd",
     "declare_ap_vars",
     "declare_state_vars",
@@ -301,6 +302,109 @@ def bdd_to_boolexpr(
     return walk(node)
 
 
+def bdd_to_positive_boolexpr(
+    node: Function,
+    *,
+    var_decoder: Callable[[str], Hashable] | None = None,
+) -> BoolExpr[Any]:
+    """Decode a *monotone-positive* BDD to a :class:`BoolExpr` without ``Not``.
+
+    The dual of :func:`boolexpr_to_bdd`, which rejects ``Not`` on
+    construction. Use this -- not :func:`bdd_to_boolexpr` -- whenever the
+    BDD encodes a function that is monotone positive in its variables and
+    the decoded expression must stay in positive normal form: AFA
+    successor and initial-state expressions over the ``q{i}`` state
+    namespace are the canonical case (``PolynomialOperator`` rejects
+    ``Not`` over state variables).
+
+    The generic :func:`bdd_to_boolexpr` emits the symmetric Shannon form
+    ``(v & high) | (~v & low)`` at the arm where neither cofactor is
+    constant, slipping a ``~v`` into the output even when the underlying
+    function is positive. For monotone-positive ``f`` the cofactors satisfy
+    ``low <= high``, so ``(v & high) | (~v & low) == (v & high) | low`` --
+    the same function with no negation. This decoder emits the latter.
+
+    Parameters
+    ----------
+    node :
+        Live ``dd.Function`` node encoding a monotone-positive function.
+    var_decoder :
+        Optional mapping from BDD variable name to the user-level variable
+        identifier embedded in the returned ``BoolExpr``. When ``None``
+        (the default), variable names must follow :data:`STATE_VAR_FORMAT`
+        (``q{i}``) and decode to ``int`` indices.
+
+    Returns
+    -------
+    BoolExpr
+        Positive (``Not``-free) expression equal to ``node``. With the
+        default decoder the result is ``BoolExpr[int]`` over state indices.
+
+    Raises
+    ------
+    ValueError
+        If ``node`` has a complement edge on a non-terminal, or otherwise
+        fails the monotone-positive contract (``high == false`` with
+        ``low != false``, or ``low == true`` with ``high != true``). These
+        shapes cannot occur for a monotone-positive function and indicate
+        the input did not satisfy the precondition.
+    """
+
+    def _default_decoder(name: str) -> int:
+        if not name.startswith("q"):
+            raise ValueError(f"Cannot convert BDD with non-state variable {name!r} to BoolExpr[int]")
+        return int(name[1:])
+
+    decode: Callable[[str], Hashable] = var_decoder if var_decoder is not None else _default_decoder
+
+    cache: dict[Function, BoolExpr[Any]] = {}
+
+    def walk(n: Function) -> BoolExpr[Any]:
+        if n in cache:
+            return cache[n]
+        if n.var is None:
+            mgr = n.bdd
+            result: BoolExpr[Any] = logic.Literal(n == mgr.true)
+            cache[n] = result
+            return result
+        if getattr(n, "negated", False):
+            # A complemented top-edge on a non-terminal flips the function to
+            # its negation, which cannot be monotone-positive.
+            raise ValueError("BDD has a complement edge on a non-terminal; not monotone-positive")
+        var: BoolExpr[Any] = logic.Variable(decode(n.var))
+        assert n.low is not None and n.high is not None
+        low = walk(n.low)
+        high = walk(n.high)
+        low_is_false = isinstance(low, logic.Literal) and low.value is False
+        low_is_true = isinstance(low, logic.Literal) and low.value is True
+        high_is_true = isinstance(high, logic.Literal) and high.value is True
+        high_is_false = isinstance(high, logic.Literal) and high.value is False
+
+        built: BoolExpr[Any]
+        if low == high:
+            built = low
+        elif high_is_false:
+            # Monotone-positive plus high=false forces low=false (low<=high),
+            # already handled by low==high above.
+            raise ValueError("non-monotone BDD: high=false but low!=false")
+        elif low_is_true:
+            # Same: low=true forces high=true; handled by low==high.
+            raise ValueError("non-monotone BDD: low=true but high!=true")
+        elif low_is_false and high_is_true:
+            built = var
+        elif low_is_false:
+            built = logic.And((var, high))
+        elif high_is_true:
+            built = logic.Or((var, low))
+        else:
+            # General positive form: (var & high) | low, valid because low <= high.
+            built = logic.Or((logic.And((var, high)), low))
+        cache[n] = built
+        return built
+
+    return walk(node)
+
+
 def mgr_eval_subset(
     mgr: Manager,
     bdd: Function,

{morphata-2.0.9 → morphata-2.0.10}/tests/conftest.py

@@ -101,7 +101,7 @@ def spot_ltlf_hoa(formula: str) -> str:
     """
 
     if HAS_SPOT == "lib":
-        import spot  # type: ignore[import-untyped]
+        import spot
 
         f = spot.from_ltlf(spot.formula(formula))
         aut = f.translate(*SPOT_AUT_ARGS)