morphata 2.1.0__tar.gz → 2.2.0__tar.gz

{morphata-2.1.0 → morphata-2.2.0}/.envrc

@@ -1,6 +1,6 @@
 #!/usr/bin/env bash
 
-set -euo pipefail
+# set -euo pipefail
 
 info() {
   DIRENV_LOG_FORMAT="envrc: %s" log_status "$@"
@@ -23,4 +23,4 @@ export PIXI_ENV
 dotenv_if_exists
 
 watch_file pixi.lock
-eval "$(pixi shell-hook -e "$PIXI_ENV")"
+eval "$(pixi shell-hook --as-is -e "$PIXI_ENV")"

{morphata-2.1.0 → morphata-2.2.0}/.rstcheck.cfg

@@ -3,6 +3,8 @@ ignore_directives =
     automodule,
     autoclass,
     autofunction,
+    autotype,
+    autoexception,
 ignore_roles =
     external:py:mod,
 report_level = WARNING

morphata-2.2.0/AGENTS.md

@@ -0,0 +1,40 @@
+# Morphata: Agent Context
+
+`morphata` does representation theory for automata, and makes it practical.
+It packages structural automaton representations together with semiring-valued
+*operators* that turn an automaton into a computable interpretation.
+
+## What Agents Are for Here
+
+This codebase is written and maintained by a single, highly opinionated author.
+The default mode for an LLM here is **read-only**: understand the code, explain it,
+answer questions, and locate things.
+That is the job.
+
+**Do not write or restructure code.**
+Assume every design decision was made deliberately.
+If you think something should change, say so and stop — do not implement it.
+In particular, never:
+
+- introduce new modules, abstractions, or layers of indirection;
+- refactor, rename, or "clean up" working code;
+- add compatibility shims, fallbacks, or defensive scaffolding;
+- broaden an API or generalize past what was asked;
+- follow a tangent into a rabbit hole.
+  When the task grows past a line or two of obvious change,
+  stop and report instead of chasing it.
+
+The narrow exception: a **surgical, already-decided edit** the author has spelled out
+(a typo, a one-line fix, a mechanical sweep).
+Do exactly that and nothing more.
+When unsure whether a change qualifies, treat it as out of scope and ask.
+
+## Development Environment
+
+The development shell already has the project virtual environment activated,
+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
+or reinstall the environment.

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

@@ -1,40 +1,124 @@
 # Changelog
 
+## 2.2.0 — 2026-08-19
+
+This is a major release as it cleans up a lot of bad code,
+attempts to make the design choices more consistent,
+and increase the surface area of properly typed code.
+
+### Added
+
+- Add finite-word composition directly to `SymbolicAutomaton`: `&`, `|`, `^`,
+  and `~` implement intersection, union, symmetric difference, and complement.
+  The variadic `compose_automata`, `is_language_equivalent`,
+  and `forward_bisim_reduction` helpers cover composition, equivalence checking,
+  and language-preserving quotienting without leaving the symbolic representation.
+- Add a typed `BDDManager`/`Function` API and symbolic utilities for replacing a
+  manager, reindexing or quotienting states, materializing sinks, traversing reachable
+  states, and constructing universal acceptors and rejectors.
+- Support arbitrary HOA v1 acceptance expressions through `GenericCondition`,
+  in addition to the concrete finite, Büchi, co-Büchi, generalized Büchi/co-Büchi,
+  Rabin, and Streett conditions.
+  Omega acceptance remains structural only:
+  run evaluation and transforms still implement finite-word semantics.
+
+### Changed
+
+- **The primary automaton API is now `SymbolicAutomaton`.**
+  The intermediate `morphata.automaton.Automaton` representation has been removed.
+  Logic conversion, hand construction, transforms, composition, HOA conversion,
+  and operators now work directly with the BDD-backed type.
+  Migrate logic calls to `formula_to_automaton(...)`
+  or `SymbolicAutomaton.from_specification(...)`,
+  and use the instance methods `remove_alternation()`, `determinize()`,
+  and `to_min_dfa()` instead of the old transform functions.
+- `AutomatonBuilder` now accepts integer state identifiers
+  and `build()` returns a `SymbolicAutomaton`; pass a `labeling_fn`
+  (and optionally a shared `BDDManager`).
+  Set-valued successors are disjunctions;
+  use a Boolean state expression for an alternating conjunction.
+  The old `variant`/`DeltaKind` construction API is gone.
+- Alphabets now separate symbol labeling from guard weighting.
+  `BooleanAlphabet.labeling` returns an `AP -> bool` mapping, while operator weight
+  functions receive guards in sum-of-products form. `Alphabet`, `WeightedAlphabet`,
+  and `weighted_alphabet` are replaced by `BooleanAlphabet`, `SemiringAlphabet`,
+  `powerset_alphabet`, and `finite_alphabet`.
+- `MatrixOperator` and `PolynomialOperator` are constructed with
+  `from_symbolic_automaton` or `from_specification`.
+  Pass `weight_fn` directly rather than an alphabet;
+  matrix construction also requires `backend`.
+  Their `accepts()` methods return a scalar `AlgebraicArray`,
+  and transition generation is exposed as `op.delta(symbol)`.
+- HOA conversion now goes through `ParsedAutomaton`:
+  use `SymbolicAutomaton.from_hoaf(parsed, alphabet=...)` and `str(aut.to_hoaf())`.
+  State IDs need not be dense, and states without outgoing edges survive round trips.
+
+### Fixed
+
+- Correct symbolic derivatives for negated variables and SERE nodes.
+- Fix breadth-first traversal ordering, symbolic language equivalence, and transition
+  partitioning when multiple guards have the same residual.
+- Correct `step()` labeling and the structural checks for deterministic and
+  forward-progressing automata.
+- Make builders, HOA conversion, and both operators handle sparse external state IDs
+  consistently by using dense indices only internally.
+
+### Removed
+
+- Remove the old `morphata.automaton` IR, STREL translator,
+  BDD-JSON persistence/cache API, and the former `symbolic.transforms`,
+  `symbolic.equivalence`, and `symbolic.compose` modules.
+  Their surviving operations now live on `SymbolicAutomaton` or in `morphata.symbolic`;
+  there is no replacement for STREL or BDD-JSON persistence in this release.
+- Remove the specialized composition-map/transition-enumeration APIs and structural
+  `prune`; use general symbolic composition and `forward_bisim_reduction` where those
+  semantics fit.
+
 ## 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.
+- 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`
+- `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.
+- 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
 
@@ -46,8 +130,8 @@
 
 ### Performance
 
-- The HOA grammar is now LALR compatible! This means we get a huge performance boost
-  even for pretty large automata.
+- 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
@@ -123,7 +207,7 @@
 ### Fixed
 
 - A major regression where the streaming `to_hoa` stuff changed the label enumeration
-  semantics to be _minterms_ instead of _cubes_.
+  semantics to be *minterms* instead of *cubes*.
   This is now fixed.
 
 ### Added
@@ -344,8 +428,7 @@ which will be summarized below.
   The reverse direction is deliberately omitted —
   recovering Boolean semantics from arbitrary `V` needs an ordering and a cut (cf.
   STL), and pretending otherwise would silently produce garbage.
-- **Ergonomic construction.**
-  `AutomatonBuilder` replaces the old NFA builder.
+- **Ergonomic construction.** `AutomatonBuilder` replaces the old NFA builder.
   Add states, add transitions with a guard and a successor
   (single state, set of states, or a raw `BoolExpr` for full alternation),
   and `build()` cleans up by merging rows that share a successor.
@@ -373,11 +456,9 @@ which will be summarized below.
   The BDD cofactor path works for any `BooleanAlphabet`,
   so you can feed a `SymbolicAutomaton` over integers, graph nodes, whatever —
   as long as you can write a labeling.
-- **The AFA-to-min-DFA pipeline actually exists now.**
-  `nfa_from_afa` (dealternation), `determinize`
-  (subset construction with a sink),
-  `minimize` (Hopcroft) — all share one BDD manager
-  and successively tighten the invariants on successor BDDs.
+- **The AFA-to-min-DFA pipeline actually exists now.** `nfa_from_afa` (dealternation),
+  `determinize` (subset construction with a sink), `minimize` (Hopcroft) —
+  all share one BDD manager and successively tighten the invariants on successor BDDs.
   `SymbolicAutomaton.to_min_dfa` chains the three.
   Finite-word only for now; omega-regular determinisation is a different beast.
 - **DFA equivalence checks.**
@@ -388,19 +469,17 @@ which will be summarized below.
 
 ### Operators
 
-- **One per-step shape.**
-  `SymbolicAutomaton`, `MatrixOperator`,
+- **One per-step shape.** `SymbolicAutomaton`, `MatrixOperator`,
   and `PolynomialOperator` all expose the same `step(current, symbol)` / `run(word)` /
   `accepts(word)` shape.
   Each binds its alphabet at construction
   (matching how the semiring / algebra were already bound),
   so the per-call API is monomorphic and `V` is pinned end-to-end.
   Wanted symmetry between the layers; got it.
-- **`PolynomialOperator` evaluates lazily.**
-  `step` evaluates guards against `alphabet.weight` on the fly,
-  with no per-symbol precomputation —
-  important because the natural LTL alphabet is `Σ = 2^AP`,
-  and you really don't want to materialise `2^|AP|` polynomials up front.
+- **`PolynomialOperator` evaluates lazily.** `step` evaluates guards against
+  `alphabet.weight` on the fly, with no per-symbol precomputation — important because
+  the natural LTL alphabet is `Σ = 2^AP`, and you really don't want to materialise
+  `2^|AP|` polynomials up front.
   The AFA's row structure stays static
   (good for JAX tracing), and the alphabet decides whether to memoise.
 - **Polynomial performance.**
@@ -410,9 +489,8 @@ which will be summarized below.
 
 ### Tooling and Tests
 
-- **Hand-written changelogs.**
-  `git cliff` was producing entries that needed enough editing that I might
-  as well write them by hand.
+- **Hand-written changelogs.** `git cliff` was producing entries
+  that needed enough editing that I might as well write them by hand.
   `ci/make-release` no longer touches `CHANGELOG.md` or tag messages.
   Run `git cliff` separately if you want a draft to crib from.
 - **Tests.**

morphata-2.2.0/PKG-INFO

@@ -0,0 +1,134 @@
+Metadata-Version: 2.4
+Name: morphata
+Version: 2.2.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
+Project-URL: Changelog, https://docs.anandb.dev/morphata/changelog.html
+Author-email: Anand Balakrishnan <anandbala1597@gmail.com>
+License-Expression: BSD-3-Clause
+License-File: LICENSE
+Classifier: Intended Audience :: Science/Research
+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.8
+Requires-Dist: numpy
+Requires-Dist: typing-extensions>=4.14
+Provides-Extra: dot
+Requires-Dist: pydot>=4.0.1; extra == 'dot'
+Provides-Extra: jax
+Requires-Dist: jax>=0.8; extra == 'jax'
+Provides-Extra: torch
+Requires-Dist: torch>=2.0; extra == 'torch'
+Description-Content-Type: text/x-rst
+
+Morphata
+========
+
+**morphata** does representation theory for automata.
+An automaton -- its states, transitions,
+and acceptance condition -- is a *structural* object.
+``SymbolicAutomaton`` is the BDD-backed structural representation.
+``MatrixOperator`` and ``PolynomialOperator`` interpret that structure over
+semiring and bounded-distributive-lattice domains.
+
+It builds on `algebraic <https://docs.anandb.dev/algebraic>`_ for
+backend-agnostic semiring algebra (NumPy, JAX, PyTorch).
+
+To install the latest release of ``morphata``, install from
+`PyPI <https://pypi.org/project/morphata/>`_:
+
+.. code-block:: bash
+
+   pip install morphata
+
+Or from the latest Git head:
+
+.. code-block:: bash
+
+   pip install 'morphata @ git+https://git.anandb.dev/morphata.git@main'
+
+For more, see the `documentation <https://docs.anandb.dev/morphata>`_.
+
+.. code-block:: python
+
+   >>> import logic_asts as logic
+   >>> import logic_asts.ltl as ltl
+
+   >>> from morphata.alphabet import powerset_alphabet
+   >>> from morphata.logic import formula_to_automaton
+
+   >>> a = logic.Variable("a")
+   >>> aut = formula_to_automaton(
+   ...     ltl.Eventually(a), alphabet=powerset_alphabet({"a"}), finite=True
+   ... )
+   >>> aut.accepts([set(), {"a"}])
+   True
+
+Omega-regular conditions are supported structurally, but infinite-run acceptance
+evaluation is not implemented. See the full documentation for details.
+
+Citation
+--------
+
+To cite the use of this package or the papers
+that are derived from it you can use the below BibTeX entries.
+
+- For differentiable weighted automata in general:
+
+  .. code-block:: bibtex
+
+     @inproceedings{balakrishnan2024differentiable,
+       title = {Differentiable {{Weighted Automata}}},
+       booktitle = {{{ICML}} 2024 {{Workshop}} on {{Differentiable Almost Everything}}: {{Differentiable Relaxations}}, {{Algorithms}}, {{Operators}}, and {{Simulators}}},
+       author = {Balakrishnan, Anand and Deshmukh, Jyotirmoy V.},
+       year = 2024,
+       month = jun,
+       url = {https://openreview.net/forum?id=k2hIQYqHTh},
+       copyright = {All rights reserved},
+       langid = {english}
+     }
+
+- For weighted automata in motion planning:
+
+  .. code-block:: bibtex
+
+     @inproceedings{balakrishnan2024motion,
+       title = {Motion {{Planning}} for {{Automata-based Objectives}} Using {{Efficient Gradient-based Methods}}},
+       booktitle = {2024 {{IEEE}}/{{RSJ International Conference}} on {{Intelligent Robots}} and {{Systems}} ({{IROS}})},
+       author = {Balakrishnan, Anand and Atasever, Merve and Deshmukh, Jyotirmoy V.},
+       year = 2024,
+       month = oct,
+       pages = {13734--13740},
+       issn = {2153-0866},
+       doi = {10.1109/IROS58592.2024.10802177}
+     }
+
+- For alternating weighted automata in multi-agent systems:
+
+  .. code-block:: bibtex
+
+     @inproceedings{balakrishnan2025monitoring,
+       title = {Monitoring {{Spatially Distributed Cyber-Physical Systems}} with {{Alternating Finite Automata}}},
+       booktitle = {Proceedings of the 28th {{ACM International Conference}} on {{Hybrid Systems}}: {{Computation}} and {{Control}}},
+       author = {Balakrishnan, Anand and Paul, Sheryl and Silvetti, Simone and Nenzi, Laura and Deshmukh, Jyotirmoy V.},
+       year = 2025,
+       month = may,
+       pages = {1--11},
+       publisher = {ACM},
+       address = {Irvine CA USA},
+       doi = {10.1145/3716863.3718033},
+       isbn = {979-8-4007-1504-4},
+       langid = {english}
+     }
+
+License
+-------
+
+See the ``LICENSE`` file for details.

morphata-2.2.0/README.rst

@@ -0,0 +1,104 @@
+Morphata
+========
+
+**morphata** does representation theory for automata.
+An automaton -- its states, transitions,
+and acceptance condition -- is a *structural* object.
+``SymbolicAutomaton`` is the BDD-backed structural representation.
+``MatrixOperator`` and ``PolynomialOperator`` interpret that structure over
+semiring and bounded-distributive-lattice domains.
+
+It builds on `algebraic <https://docs.anandb.dev/algebraic>`_ for
+backend-agnostic semiring algebra (NumPy, JAX, PyTorch).
+
+To install the latest release of ``morphata``, install from
+`PyPI <https://pypi.org/project/morphata/>`_:
+
+.. code-block:: bash
+
+   pip install morphata
+
+Or from the latest Git head:
+
+.. code-block:: bash
+
+   pip install 'morphata @ git+https://git.anandb.dev/morphata.git@main'
+
+For more, see the `documentation <https://docs.anandb.dev/morphata>`_.
+
+.. code-block:: python
+
+   >>> import logic_asts as logic
+   >>> import logic_asts.ltl as ltl
+
+   >>> from morphata.alphabet import powerset_alphabet
+   >>> from morphata.logic import formula_to_automaton
+
+   >>> a = logic.Variable("a")
+   >>> aut = formula_to_automaton(
+   ...     ltl.Eventually(a), alphabet=powerset_alphabet({"a"}), finite=True
+   ... )
+   >>> aut.accepts([set(), {"a"}])
+   True
+
+Omega-regular conditions are supported structurally, but infinite-run acceptance
+evaluation is not implemented. See the full documentation for details.
+
+Citation
+--------
+
+To cite the use of this package or the papers
+that are derived from it you can use the below BibTeX entries.
+
+- For differentiable weighted automata in general:
+
+  .. code-block:: bibtex
+
+     @inproceedings{balakrishnan2024differentiable,
+       title = {Differentiable {{Weighted Automata}}},
+       booktitle = {{{ICML}} 2024 {{Workshop}} on {{Differentiable Almost Everything}}: {{Differentiable Relaxations}}, {{Algorithms}}, {{Operators}}, and {{Simulators}}},
+       author = {Balakrishnan, Anand and Deshmukh, Jyotirmoy V.},
+       year = 2024,
+       month = jun,
+       url = {https://openreview.net/forum?id=k2hIQYqHTh},
+       copyright = {All rights reserved},
+       langid = {english}
+     }
+
+- For weighted automata in motion planning:
+
+  .. code-block:: bibtex
+
+     @inproceedings{balakrishnan2024motion,
+       title = {Motion {{Planning}} for {{Automata-based Objectives}} Using {{Efficient Gradient-based Methods}}},
+       booktitle = {2024 {{IEEE}}/{{RSJ International Conference}} on {{Intelligent Robots}} and {{Systems}} ({{IROS}})},
+       author = {Balakrishnan, Anand and Atasever, Merve and Deshmukh, Jyotirmoy V.},
+       year = 2024,
+       month = oct,
+       pages = {13734--13740},
+       issn = {2153-0866},
+       doi = {10.1109/IROS58592.2024.10802177}
+     }
+
+- For alternating weighted automata in multi-agent systems:
+
+  .. code-block:: bibtex
+
+     @inproceedings{balakrishnan2025monitoring,
+       title = {Monitoring {{Spatially Distributed Cyber-Physical Systems}} with {{Alternating Finite Automata}}},
+       booktitle = {Proceedings of the 28th {{ACM International Conference}} on {{Hybrid Systems}}: {{Computation}} and {{Control}}},
+       author = {Balakrishnan, Anand and Paul, Sheryl and Silvetti, Simone and Nenzi, Laura and Deshmukh, Jyotirmoy V.},
+       year = 2025,
+       month = may,
+       pages = {1--11},
+       publisher = {ACM},
+       address = {Irvine CA USA},
+       doi = {10.1145/3716863.3718033},
+       isbn = {979-8-4007-1504-4},
+       langid = {english}
+     }
+
+License
+-------
+
+See the ``LICENSE`` file for details.

morphata-2.2.0/bench/conftest.py

@@ -0,0 +1,32 @@
+"""pytest fixtures for the morphata bench suite.
+
+The bench/ tree is opt-in: invoke with `pytest bench/` (or
+`pytest bench/test_sere_nlm_perf.py`). It is not collected by the
+default `pytest` invocation.
+"""
+
+from __future__ import annotations
+
+import gc
+from collections.abc import Iterator
+
+import pytest
+
+from morphata.symbolic.bdd import BDDManager
+
+
+@pytest.fixture
+def bench_mgr() -> Iterator[BDDManager[str, int]]:
+    """Shared BDD manager scoped to one bench test (= many benchmark rounds).
+
+    Bench tests pass this manager to ``sere_to_automaton(..., manager=mgr)``
+    so the per-call ``BDDManager()`` allocation is skipped. That path leaks
+    ~12 MB of CUDD-internal state per call, which compounds across the
+    ~100-1000 rounds pytest-benchmark runs per test and exhausts host
+    RAM. Sharing the manager keeps RSS flat.
+    """
+    manager = BDDManager[str, int]()
+    try:
+        yield manager
+    finally:
+        _ = gc.collect()

{morphata-2.1.0 → morphata-2.2.0}/bench/test_equivalence_perf.py

@@ -2,8 +2,8 @@
 
 The case: an LTLf min-DFA whose AP universe is large (|aps| ~ 19) but
 whose guards mention only 4 APs. Pre-rewrite this regime explodes;
-post-rewrite the per-pair (language_equivalent) and per-automaton
-(isomorphic) support reductions keep work bounded.
+post-rewrite the per-pair (``is_language_equivalent``) support reduction
+keeps work bounded.
 
 pytest-benchmark records the timing distribution; no hard-coded
 thresholds, the dataset is the regression signal.
@@ -13,18 +13,18 @@ Run with: ``pytest bench/test_equivalence_perf.py -v``
 
 from __future__ import annotations
 
+from collections.abc import Set as AbstractSet
+
 import logic_asts.ltl as ltl
+import pytest
 from pytest_benchmark.fixture import BenchmarkFixture as Benchmark
 
 from morphata.alphabet import powerset_alphabet
-from morphata.automaton import Automaton
-from morphata.logic.ltl import Input, ltl_to_automaton
-from morphata.symbolic import isomorphic
 from morphata.symbolic.automaton import SymbolicAutomaton
-from morphata.symbolic.equivalence import language_equivalent
+from morphata.symbolic.utils import is_language_equivalent
 
 
-def _sparse_big_alphabet_dfa() -> SymbolicAutomaton[str]:
+def _sparse_big_alphabet_dfa() -> SymbolicAutomaton[str, AbstractSet[str]]:
     aps = frozenset({f"p{i}" for i in range(15)} | {"a", "b", "c", "d"})
     formula = ltl.And(
         (
@@ -35,23 +35,15 @@ def _sparse_big_alphabet_dfa() -> SymbolicAutomaton[str]:
         )
     )
     alphabet = powerset_alphabet(aps)
-    aut: Automaton[int, Input[str], str] = ltl_to_automaton(formula, finite=True)
-    return SymbolicAutomaton.from_automaton(aut, alphabet=alphabet).to_min_dfa()
+    aut = SymbolicAutomaton.from_specification(formula, alphabet=alphabet, finite=True)
+    return aut.to_min_dfa()
 
 
+@pytest.mark.limit_memory("2 GB")
 def test_language_equivalent_sparse_big_alphabet(benchmark: Benchmark) -> None:
     dfa = _sparse_big_alphabet_dfa()
 
     def _run() -> bool:
-        return language_equivalent(dfa, dfa)
-
-    assert benchmark(_run)
-
-
-def test_isomorphic_sparse_big_alphabet(benchmark: Benchmark) -> None:
-    dfa = _sparse_big_alphabet_dfa()
-
-    def _run() -> bool:
-        return isomorphic(dfa, dfa)
+        return is_language_equivalent(dfa, dfa)
 
     assert benchmark(_run)