morphata 2.0.9__tar.gz → 2.1.0__tar.gz

morphata-2.1.0/.basedpyright/baseline.json

@@ -0,0 +1,3 @@
+{
+    "files": {}
+}

{morphata-2.0.9 → morphata-2.1.0}/AGENTS.md

@@ -7,7 +7,7 @@ It packages structural automaton representations together with semiring-valued
 ## Development Environment
 
 The development shell already has the project virtual environment activated,
-so `pytest`, `mypy`, `ruff`, `sphinx-build`, etc. are on `PATH` directly.
+so `pytest`, `zuban`, `basedpyright`, `ruff`, `sphinx-build`, etc. are on `PATH` directly.
 **Do not** prefix commands with `uv run`, `pixi run`, `poetry run`, or similar.
 Just invoke the tool.
 If a tool is missing, stop and tell the user rather than trying to bootstrap
@@ -242,7 +242,7 @@ for DFA-shaped symbolic automata -- ``language_equivalent``, ``canonical_form``,
    ``backend=``; do not bake backend-only assumptions into operator
    code.
 6. **No Deprecation** : delete old code instead of wrapping it.
-7. **Type Safety** : all new code must pass ``mypy --strict``.
+7. **Type Safety** : all new code must pass ``zuban`` and ``basedpyright``.
 8. **Prefer Refactoring** : update existing patterns rather than
    special-casing.
 
@@ -282,7 +282,7 @@ for DFA-shaped symbolic automata -- ``language_equivalent``, ``canonical_form``,
 ## Testing
 
 - **Framework** : pytest with jaxtyping.
-- **Type Safety** : 100% `mypy --strict`.
+- **Type Safety** : `zuban` and `basedpyright` (both must pass; preferred over mypy for spec conformance and performance).
 - **Layout** : tests live under `tests/`:
   - flat suites at the top: ``test_alphabet.py``, ``test_automaton.py``,
     ``test_builder.py``, ``test_from_parsed.py``;

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

@@ -1,5 +1,55 @@
 # Changelog
 
+## 2.1.0 — 2026-06-11
+
+### Added
+
+- Add `morphata.symbolic.prune` that does a cheap, language-preserving structural
+  pruning of an AFA. The idea here is to try and reduce the number of states in the AFA
+  (no guarantees) by performing a forward reachability pass, dead-state pruning, and
+  a parameterized number of passes for one-step acceptance-partition deduplication.
+
+### Changed
+
+- `MatrixOperator` and `PolynomialOperator` are generic now — `MatrixOperator[Symbol, AP]`
+  and `PolynomialOperator[Symbol, AP]`, just like `SymbolicAutomaton`. When I first banged
+  these out I left them un-parameterized (read: `Any` smeared everywhere), so now the
+  symbol and AP types actually flow through and `MatrixOperator[frozenset[str], str]`
+  means something. Nothing changes at runtime; the one thing you might notice is your
+  type-checker nudging you to fill in the params if you were annotating a bare
+  `MatrixOperator` or `PolynomialOperator`.
+- The BDD-JSON sidecar cache jumped to schema **v2**. Acceptance conditions now
+  (de)serialize through `cattrs` instead of the hand-rolled `meta.get(...)` dance, and
+  Rabin/Streett pairs are written as objects (`{"rejecting": ..., "accepting": ...}`)
+  rather than nested lists. Heads up: old `v1` `.bdd.json` caches will politely refuse
+  to load (clean error, not a silent miscompile) --- just regenerate them and you're good.
+  Remember, this is a *cache*, not a portable format, so this shouldn't bite anyone hard.
+- STREL conversion shed ~120 lines. All the timed-interval unrolling (`G[a,b]`, `F[a,b]`,
+  `U[t1,t2]`, `X[n]`) and the spatial `Somewhere`/`Everywhere` desugaring used to be
+  hand-rolled in `strel.py`, but `logic-asts` already does all of it in `.expand()` — so
+  I ripped them out and just lean on the upstream rules. This needs the newer `logic-asts`
+  (the one with the spatial `expand()` rules), so that dep gets bumped along with it.
+
+### Miscellaneous
+
+- Housekeeping, but worth saying: the whole package now type-checks clean under *both*
+  `zuban` and `basedpyright` (0 errors, 0 warnings), so contributing should be a bit less
+  whack-a-mole.
+
+## 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.1.0}/CONTRIBUTING.md

@@ -39,20 +39,21 @@ just fmt
 # OR
 ruff format
 ruff check --output-format concise --fix --exit-non-zero-on-fix
-
-# Format + type check
-just lint
 ```
 
 **Type Checking** :
 ```bash
 # Run all type checkers
 just type-check
-
+# OR
 # Run specific type checkers
-mypy --strict
-ty check --output-format concise
-pyrefly check --output-format min-text
+zuban check
+basedpyright
+```
+
+**Formatting + Type Checking together**:
+```bash
+just lint
 ```
 
 **Development Setup** :
@@ -60,7 +61,7 @@ pyrefly check --output-format min-text
 # Set up dev environment (sync dependencies)
 just dev
 # OR
-uv sync --frozen --inexact --dev
+pixi install
 
 # For CUDA support (set CUDA_VERSION=12 or 13)
 CUDA_VERSION=12 just dev
@@ -74,7 +75,7 @@ One can also copy the included `.envrc.recommended` file to `.envrc` and use it
 
 ### Type Annotations
 
-- All code must pass `mypy --strict` . Use explicit type annotations.
+- All code must pass `zuban` and `basedpyright`. Use explicit type annotations.
 - Use Python 3.12+ syntax: `type` aliases, `|` for unions, generic classes and functions
   with `[T]`
 - Always specify return types, including `-> None`
@@ -89,42 +90,3 @@ One can also copy the included `.envrc.recommended` file to `.envrc` and use it
 - Format: NumPy-style docstrings with sections: Parameters, Returns,
   Raises, Notes, Examples.
 - Inline comments should say _why_ something is done, not _what_.
-
-## Source Layout
-
-```
-morphata/
-├── src/morphata/
-│   ├── automaton.py            # Automaton IR + Outgoing/Step deltas
-│   ├── alphabet.py             # Input alphabet + characteristic function
-│   ├── builder.py              # AutomatonBuilder (mutable IR builder)
-│   ├── acceptance.py           # Finite + omega-regular acceptance
-│   ├── weights.py              # Guard-based weight predicates
-│   ├── logic/
-│   │   ├── ltl.py              # LTL/LTLf -> AFA
-│   │   └── strel.py            # STREL automaton (Step delta)
-│   ├── hoa/                    # Extended HOA v1 parser
-│   │   ├── parser.py
-│   │   ├── exporter.py         # placeholder; not yet implemented
-│   │   └── acc_expr.py
-│   ├── operators/              # Semiring-valued morphisms
-│   │   ├── matrix.py           # MatrixOperator (weighted NFAs)
-│   │   ├── polynomial.py       # PolynomialOperator (AFAs)
-│   │   └── _backend.py         # backend resolution + JAX pytree aux
-│   └── symbolic/               # BDD-backed structural layer
-│       ├── automaton.py        # SymbolicAutomaton
-│       ├── bdd.py              # BoolExpr <-> dd.Function bridge
-│       ├── transforms.py       # determinize, minimize, nfa_from_afa
-│       └── equivalence.py      # language_equivalent, isomorphic, canonical_form
-│
-└── tests/                      # Mirrors the package layout
-    ├── test_alphabet.py
-    ├── test_automaton.py
-    ├── test_builder.py
-    ├── test_from_parsed.py
-    ├── test_weights.py
-    ├── hoa/
-    ├── logic/
-    ├── operators/
-    └── symbolic/
-```

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: morphata
-Version: 2.0.9
+Version: 2.1.0
 Summary: Representation theory for automata, made practical.
 Project-URL: Documentation, https://docs.anandb.dev/morphata
 Project-URL: Repository, https://git.anandb.dev/morphata.git
@@ -13,10 +13,11 @@ Classifier: Topic :: Scientific/Engineering :: Mathematics
 Requires-Python: >=3.12
 Requires-Dist: algebraic-arrays>=1.3.0
 Requires-Dist: attrs>=25.4.0
+Requires-Dist: cattrs>=26.1.0
 Requires-Dist: dd>=0.6.0
 Requires-Dist: jaxtyping>=0.3
 Requires-Dist: lark>=1.3.1
-Requires-Dist: logic-asts>=1.6.2
+Requires-Dist: logic-asts>=1.7
 Requires-Dist: networkx
 Requires-Dist: numpy
 Requires-Dist: types-networkx

{morphata-2.0.9 → morphata-2.1.0}/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.9 → morphata-2.1.0}/bench/conftest.py

@@ -12,7 +12,9 @@ from collections.abc import Iterator
 
 import pytest
 
-from morphata.logic.sere import _expansion_call_counter
+from morphata.logic.sere import (
+    _expansion_call_counter,  # pyright: ignore[reportPrivateUsage]
+)
 from morphata.symbolic.bdd import Manager, make_manager
 
 
@@ -30,7 +32,7 @@ def bench_mgr() -> Iterator[Manager]:
     try:
         yield manager
     finally:
-        gc.collect()
+        _ = gc.collect()
 
 
 @pytest.fixture

{morphata-2.0.9 → morphata-2.1.0}/bench/test_hoa_exporter_perf.py

@@ -41,7 +41,9 @@ 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()
+    return SymbolicAutomaton.from_ltl(
+        formula, alphabet=alphabet, manager=mgr, finite=True
+    ).to_min_dfa()
 
 
 def _sparse_big_alphabet_dfa(mgr: Manager) -> SymbolicAutomaton[str]:
@@ -55,7 +57,9 @@ def _sparse_big_alphabet_dfa(mgr: Manager) -> SymbolicAutomaton[str]:
         )
     )
     alphabet = powerset_alphabet(aps)
-    return SymbolicAutomaton.from_ltl(formula, alphabet=alphabet, manager=mgr, finite=True).to_min_dfa()
+    return SymbolicAutomaton.from_ltl(
+        formula, alphabet=alphabet, manager=mgr, finite=True
+    ).to_min_dfa()
 
 
 def _conjunction_min_dfa(mgr: Manager) -> SymbolicAutomaton[str]:
@@ -70,7 +74,9 @@ def _conjunction_min_dfa(mgr: Manager) -> SymbolicAutomaton[str]:
         )
     )
     alphabet = powerset_alphabet(aps)
-    return SymbolicAutomaton.from_ltl(formula, alphabet=alphabet, manager=mgr, finite=True).to_min_dfa()
+    return SymbolicAutomaton.from_ltl(
+        formula, alphabet=alphabet, manager=mgr, finite=True
+    ).to_min_dfa()
 
 
 def _afa_no_minimize(mgr: Manager) -> SymbolicAutomaton[str]:
@@ -80,15 +86,21 @@ def _afa_no_minimize(mgr: Manager) -> SymbolicAutomaton[str]:
         ltl.And(
             (
                 ltl.Variable("b"),
-                ltl.Eventually(ltl.And((ltl.Variable("c"), ltl.Eventually(ltl.Variable("d"))))),
+                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)
+    return SymbolicAutomaton.from_ltl(
+        formula, alphabet=alphabet, manager=mgr, finite=True
+    )
 
 
-def test_hoa_export_small_alphabet_dfa(benchmark: Benchmark, bench_mgr: Manager) -> None:
+def test_hoa_export_small_alphabet_dfa(
+    benchmark: Benchmark, bench_mgr: Manager
+) -> None:
     sym = _small_alphabet_dfa(bench_mgr)
 
     def _run() -> int:
@@ -97,7 +109,9 @@ def test_hoa_export_small_alphabet_dfa(benchmark: Benchmark, bench_mgr: Manager)
     assert benchmark(_run) > 0
 
 
-def test_hoa_export_sparse_big_alphabet_dfa(benchmark: Benchmark, bench_mgr: Manager) -> None:
+def test_hoa_export_sparse_big_alphabet_dfa(
+    benchmark: Benchmark, bench_mgr: Manager
+) -> None:
     sym = _sparse_big_alphabet_dfa(bench_mgr)
 
     def _run() -> int:
@@ -106,7 +120,9 @@ def test_hoa_export_sparse_big_alphabet_dfa(benchmark: Benchmark, bench_mgr: Man
     assert benchmark(_run) > 0
 
 
-def test_hoa_export_conjunction_min_dfa(benchmark: Benchmark, bench_mgr: Manager) -> None:
+def test_hoa_export_conjunction_min_dfa(
+    benchmark: Benchmark, bench_mgr: Manager
+) -> None:
     sym = _conjunction_min_dfa(bench_mgr)
 
     def _run() -> int:

morphata-2.1.0/bench/test_hoa_parser_perf.py

@@ -0,0 +1,128 @@
+"""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,  # pyright: ignore[reportPrivateUsage]
+)
+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.1.0}/bench/test_sere_nlm_perf.py

@@ -43,7 +43,12 @@ def _lm_of_aps(n: int) -> logic.Expr:
 
 
 def _nlm_of_concats(n: int) -> logic.Expr:
-    return sere.NLMInter(tuple(sere.Concat((sere.Variable(f"a{i}"), sere.Variable(f"b{i}"))) for i in range(n)))
+    return sere.NLMInter(
+        tuple(
+            sere.Concat((sere.Variable(f"a{i}"), sere.Variable(f"b{i}")))
+            for i in range(n)
+        )
+    )
 
 
 def _run_and_measure(formula: logic.Expr, mgr: Manager) -> tuple[int, int]:
@@ -56,17 +61,23 @@ def _run_and_measure(formula: logic.Expr, mgr: Manager) -> tuple[int, int]:
 
 @pytest.mark.timeout(10)
 @pytest.mark.parametrize("n", list(range(2, 10)))
-def test_bench_nlm_of_aps(benchmark: Benchmark, expansion_calls: list[int], bench_mgr: Manager, n: int) -> None:
+def test_bench_nlm_of_aps(
+    benchmark: Benchmark, expansion_calls: list[int], bench_mgr: Manager, n: int
+) -> None:
     formula = _nlm_of_aps(n)
     result = benchmark(_run_and_measure, formula, bench_mgr)
     state_count, call_count = result
     expansion_calls[0] = call_count
-    print(f"\nNLMInter(a0..a{n - 1}): states={state_count} expansion_calls={call_count}")
+    print(
+        f"\nNLMInter(a0..a{n - 1}): states={state_count} expansion_calls={call_count}"
+    )
 
 
 @pytest.mark.timeout(10)
 @pytest.mark.parametrize("n", list(range(2, 10)))
-def test_bench_lm_of_aps_baseline(benchmark: Benchmark, expansion_calls: list[int], bench_mgr: Manager, n: int) -> None:
+def test_bench_lm_of_aps_baseline(
+    benchmark: Benchmark, expansion_calls: list[int], bench_mgr: Manager, n: int
+) -> None:
     formula = _lm_of_aps(n)
     result = benchmark(_run_and_measure, formula, bench_mgr)
     state_count, call_count = result
@@ -76,9 +87,13 @@ def test_bench_lm_of_aps_baseline(benchmark: Benchmark, expansion_calls: list[in
 
 @pytest.mark.timeout(10)
 @pytest.mark.parametrize("n", list(range(2, 10)))
-def test_bench_nlm_of_concats(benchmark: Benchmark, expansion_calls: list[int], bench_mgr: Manager, n: int) -> None:
+def test_bench_nlm_of_concats(
+    benchmark: Benchmark, expansion_calls: list[int], bench_mgr: Manager, n: int
+) -> None:
     formula = _nlm_of_concats(n)
     result = benchmark(_run_and_measure, formula, bench_mgr)
     state_count, call_count = result
     expansion_calls[0] = call_count
-    print(f"\nNLMInter(a_i;b_i) n={n}: states={state_count} expansion_calls={call_count}")
+    print(
+        f"\nNLMInter(a_i;b_i) n={n}: states={state_count} expansion_calls={call_count}"
+    )

{morphata-2.0.9 → morphata-2.1.0}/docs/conf.py

@@ -36,7 +36,9 @@ autodoc_default_options = {
 autodoc_typehints = "description"
 autosummary_generate = True
 
-intersphinx_mapping: dict[str, tuple[str, None | str | tuple[str, tuple[str | None, ...]]]] = {
+intersphinx_mapping: dict[
+    str, tuple[str, None | str | tuple[str, tuple[str | None, ...]]]
+] = {
     "equinox": ("https://docs.kidger.site/equinox", None),
     "algebraic": ("https://docs.anandb.dev/algebraic", None),
 }

{morphata-2.0.9 → morphata-2.1.0}/docs/symbolic-transforms.rst

@@ -19,6 +19,27 @@ For the common case of running the whole pipeline, call
 <morphata.symbolic.automaton.SymbolicAutomaton.to_min_dfa>`, which
 composes the three transforms in order.
 
+Best-effort pruning
+-------------------
+
+:func:`morphata.symbolic.transforms.prune` shrinks an alternating
+automaton in place *without* determinising it. Unlike
+:meth:`~morphata.symbolic.automaton.SymbolicAutomaton.to_min_dfa`, it
+preserves the alternating structure (successor BDDs keep their
+conjunctive shape) and is *best-effort*, not minimal. It applies, in
+order: forward reachability, an AFA-aware dead-state fixpoint, and one or
+more rounds (``passes``, default 1) of one-step acceptance-partition
+bisimulation dedup. Requires :class:`~morphata.acceptance.Finite`
+acceptance. ``num_states`` never increases and the accepted language is
+preserved.
+
+.. code-block:: python
+
+    from morphata.symbolic.transforms import prune
+
+    sym_aut = SymbolicAutomaton.from_ltl(formula, alphabet=ba, finite=True)
+    sym_aut = prune(sym_aut)
+
 BDD-shape invariants
 --------------------
 

{morphata-2.0.9 → morphata-2.1.0}/justfile

@@ -42,16 +42,18 @@ pyrefly-check:
 mypy-check:
     mypy --strict
 
+[no-cd]
+[private]
+zuban-check:
+    zuban check
+
 [no-cd]
 [private]
 pyright-check:
     basedpyright
 
-# [parallel]
-type-check: mypy-check
-
-# pyright-check
-# ty-check pyrefly-check
+[parallel]
+type-check: zuban-check pyright-check
 
 # Run both formatting and type checking
 [no-cd]

{morphata-2.0.9 → morphata-2.1.0}/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