morphata 2.0.8__tar.gz → 2.0.10__tar.gz

{morphata-2.0.8 → 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.8 → morphata-2.0.10}/CHANGELOG.md

@@ -1,5 +1,41 @@
 # 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
+
+- `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

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

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

@@ -16,6 +16,15 @@ 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).
+- `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_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.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.8 → 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.8 → 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.8"
+version = "2.0.10"
 requires-python = ">=3.12"
 classifiers = [
   "Intended Audience :: Science/Research",

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

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

{morphata-2.0.8 → morphata-2.0.10}/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.8 → 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.8 → 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,
     )