morphata 2.0.1__tar.gz → 2.0.3__tar.gz

{morphata-2.0.1 → morphata-2.0.3}/.claude/settings.local.json

@@ -15,7 +15,18 @@
       "Bash(.venv/bin/python -m pytest *)",
       "Skill(superpowers:writing-plans)",
       "Skill(superpowers:subagent-driven-development)",
-      "Bash(grep -v \"AssertionError\\\\|Traceback\\\\|File \\\\|^\\\\s*$\")"
+      "Bash(grep -v \"AssertionError\\\\|Traceback\\\\|File \\\\|^\\\\s*$\")",
+      "Skill(superpowers:brainstorming)",
+      "Bash(jj log *)",
+      "Bash(jj st *)",
+      "Bash(jj diff *)",
+      "Skill(superpowers:requesting-code-review)",
+      "Bash(timeout 15 python -c ' *)",
+      "Read(//tmp/**)",
+      "Bash(echo \"exit: $?\")",
+      "Skill(superpowers:executing-plans)",
+      "Bash(ruff check *)",
+      "Bash(ruff format *)"
     ]
   }
 }

{morphata-2.0.1 → morphata-2.0.3}/.envrc

@@ -24,7 +24,3 @@ dotenv_if_exists
 
 watch_file pixi.lock
 eval "$(pixi shell-hook -e "$PIXI_ENV")"
-
-if [[ -d "$CONDA_PREFIX" ]]; then
-  export VIRTUAL_ENV="$CONDA_PREFIX"
-fi

{morphata-2.0.1 → morphata-2.0.3}/AGENTS.md

@@ -9,73 +9,81 @@ It packages structural automaton representations together with semiring-valued
 The development shell already has the project virtual environment activated,
 so `pytest`, `mypy`, `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.
+Just invoke the tool.
+If a tool is missing, stop and tell the user rather than trying to bootstrap
+or reinstall the environment.
 
 ## Core Architecture
 
-### IR layer (`morphata.automaton`, `morphata.alphabet`, `morphata.acceptance`)
+### IR Layer (`morphata.automaton`, `morphata.alphabet`, `morphata.acceptance`)
 
 **`morphata.automaton`** : the canonical automaton IR.
-- `Automaton[State, Symbol, AP]` : the single automaton dataclass.  Fields:
-  `states`, `predicates`, `initial: BoolExpr[State]`, `delta: Delta`,
+
+- `Automaton[State, Symbol, AP]` : the single automaton dataclass.
+  Fields: `states`, `predicates`, `initial: BoolExpr[State]`, `delta: Delta`,
   `acceptance: AcceptanceCondition[State]`, plus a derived ``variant``.
-- `Outgoing[State, AP]` : canonical predicate-row delta.  ``fn(state)``
+- `Outgoing[State, AP]` : canonical predicate-row delta. ``fn(state)``
   yields ``(guard: BoolExpr[AP], successor: BoolExpr[State])`` pairs.
-- `Step[State, Symbol]` : escape-hatch delta for input-dependent state
-  spaces.  ``fn(state, symbol) -> BoolExpr[State]``.  Used by STREL.
+- `Step[State, Symbol]` : escape-hatch delta for input-dependent state spaces.
+  ``fn(state, symbol) -> BoolExpr[State]``.
+  Used by STREL.
   Not symbolically liftable.
 - `Delta` : union of ``Outgoing`` and ``Step``.
 - `DeltaKind` : ``DETERMINISTIC``, ``NONDETERMINISTIC``, ``UNIVERSAL``,
   ``ALTERNATING``.
 - `classify_delta(delta, states)` : classifies a delta into a
-  ``DeltaKind``.  ``Step`` always classifies as ``ALTERNATING``.
+  ``DeltaKind``. ``Step`` always classifies as ``ALTERNATING``.
 - `BoolExpr[Var]` : alias for ``logic_asts.base.BaseExpr[Var]``.
 
-**`morphata.alphabet`** : input alphabet abstractions. Guards in the IR
-stay symbolic; the alphabet bundles the symbol-side metadata with the
-function that interprets a guard against a symbol.
-- `Alphabet[Symbol, AP, V]` (``Protocol``) : the operator-facing
-  contract. Exposes ``predicates`` and ``weight(symbol, guard) -> V``.
-- `BooleanAlphabet[Symbol, AP]` : carries a labeling
-  ``L: Symbol -> AbstractSet[AP]``. ``weight`` evaluates the guard in
-  Boolean semantics against the AP-truth set ``L(symbol)``. Satisfies
-  ``Alphabet[Symbol, AP, bool]``.
-- `WeightedAlphabet[Symbol, AP, V]` : carries an arbitrary
-  ``weight_fn: (Symbol, BoolExpr[AP]) -> V``. Satisfies
-  ``Alphabet[Symbol, AP, V]``.
+**`morphata.alphabet`** : input alphabet abstractions.
+Guards in the IR stay symbolic;
+the alphabet bundles the symbol-side metadata with the function
+that interprets a guard against a symbol.
+
+- `Alphabet[Symbol, AP, V]` (``Protocol``) : the operator-facing contract.
+  Exposes ``predicates`` and ``weight(symbol, guard) -> V``.
+- `BooleanAlphabet[Symbol, AP]` : carries a labeling ``L: Symbol -> AbstractSet[AP]``.
+  ``weight`` evaluates the guard in Boolean semantics against the AP-truth set
+  ``L(symbol)``.
+  Satisfies ``Alphabet[Symbol, AP, bool]``.
+- `WeightedAlphabet[Symbol, AP, V]` : carries an arbitrary ``weight_fn:
+  (Symbol, BoolExpr[AP]) -> V``.
+  Satisfies ``Alphabet[Symbol, AP, V]``.
 - Factories: ``powerset_alphabet(aps)`` (Sigma = 2^AP, identity
   labeling), ``finite_alphabet(aps)`` (Sigma = AP, one-hot labeling),
   ``weighted_alphabet(weight_fn, *, predicates)``.
 - ``WeightedAlphabet.from_boolean(boolean, semiring)`` lifts a Boolean
   alphabet into ``V`` via evaluate-then-lift (the guard is evaluated in
   ``bool`` and the result is mapped to ``semiring.zero`` / ``one``).
-- ``WeightedAlphabet.from_predicates(predicates, semiring)`` builds a
-  weight function from per-AP predicates over ``V``. Replaces the
-  former ``morphata.weights`` module.
+- ``WeightedAlphabet.from_predicates
+  (predicates, semiring)`` builds a weight function from per-AP predicates over ``V``.
+  Replaces the former ``morphata.weights`` module.
 
-The reverse direction (``WeightedAlphabet -> BooleanAlphabet``) requires
-extra ordering / threshold structure (cf. STL quantitative semantics)
-and is deliberately not provided.
+The reverse direction (``WeightedAlphabet -> BooleanAlphabet``) requires extra ordering
+/ threshold structure (cf.
+STL quantitative semantics) and is deliberately not provided.
 
-**`morphata.acceptance`** : expression-based acceptance conditions
-used by the HOA parser and the rest of the stack - ``Finite``,
-``Buchi``, ``CoBuchi``, ``GeneralizedBuchi``, ``GeneralizedCoBuchi``,
-``Rabin``, ``Streett``, plus a ``GenericCondition`` fallback for
-acceptance formulas that do not match a named condition.
+**`morphata.acceptance`** :
+expression-based acceptance conditions used by the HOA parser
+and the rest of the stack - ``Finite``, ``Buchi``, ``CoBuchi``, ``GeneralizedBuchi``,
+``GeneralizedCoBuchi``, ``Rabin``, ``Streett``,
+plus a ``GenericCondition`` fallback for acceptance formulas
+that do not match a named condition.
 
 **`morphata.hoa`** : Hanoi Omega-Automata v1 parser.
+
 - ``parser.py`` : LALR-based parser; supports the ``Final(n)``
   extension for finite-word acceptance.
 - ``acc_expr.py`` : acceptance-formula AST shared with the parser.
 - ``exporter.py`` : HOA v1 serializer; round-trips parser input via
   ``automaton_to_hoa``.
 
-### Construction layer
+### Construction Layer
+
+**`morphata.builder.AutomatonBuilder[State, AP]`** :
+the mutable builder that produces an ``Automaton`` IR on ``build()``.
+Replaces the deleted ``morphata.constructions.nfa.NFA``.
 
-**`morphata.builder.AutomatonBuilder[State, AP]`** : the mutable builder
-that produces an ``Automaton`` IR on ``build()``.  Replaces the deleted
-``morphata.constructions.nfa.NFA``.
 - ``add_state(state, *, initial=False, accepting=False)``.
 - ``add_transition(src, guard, succ)`` where ``succ`` may be a single
   state, a set of states (lifted to ``Or`` / ``And`` per variant), or a
@@ -88,35 +96,40 @@ LTL/LTLf -> alternating ``Automaton`` with an ``Outgoing`` delta.
 ``finite=True`` -> ``Finite`` acceptance; ``finite=False`` -> ``Buchi``.
 
 **`morphata.logic.strel.strel_to_automata(expr, dist_attr, label_fn, ...)`** :
-STREL over labelled graphs.  Returns an ``Automaton`` with a ``Step``
-delta - the transition consumes the labelled graph eagerly, so STREL
-automata are not symbolically liftable.  Operators: Reach, Escape,
-Somewhere, Everywhere.  Boolean-only.
-
-**`morphata.logic.sere.sere_to_automaton(expr)`** : SERE -> alternating
-finite automaton.  Supports ``Concat``, ``Fusion``, ``Repeat`` (bounded
-and unbounded), ``Inter``, ``Alt``, and Boolean leaves over AP.
-Acceptance is always ``Finite``; the accepting-state set is exactly
-the *nullable* states (those that match the empty word).
-
-**`morphata.logic.psl.psl_to_automaton(phi, *, finite=False)`** : PSL ->
-alternating automaton.  Wraps pure-LTL subformulas in an internal
-``_LTL`` tag and dispatches to the LTL expansion rule; closure
-operators (``{r}!``, ``{r}``, ``!{r}``, ``{r}<>-> f``, ``{r}[]-> f``)
-become their own tagged states with SERE-step expansion.  Suffix
-implications follow Spot's overlapping semantics: the last symbol of
-``r`` and the first position of ``f`` coincide.  ``finite=True`` ->
-``Finite`` acceptance (PSLf); ``finite=False`` -> ``Buchi``.
-
-Hand-written automata are built with ``AutomatonBuilder``; the package
-has no separate ``constructions`` namespace.
-
-### Operator layer (`morphata.operators`)
-
-Algebraic morphisms that turn an ``Automaton`` plus an ``Alphabet`` into
-a computable interpretation over an algebraic domain.
+STREL over labelled graphs.
+Returns an ``Automaton`` with a ``Step`` delta - the transition consumes the labelled
+graph eagerly, so STREL automata are not symbolically liftable.
+Operators: Reach, Escape, Somewhere, Everywhere.
+Boolean-only.
+
+**`morphata.logic.sere.sere_to_automaton(expr)`** :
+SERE -> alternating finite automaton.
+Supports ``Concat``, ``Fusion``, ``Repeat``
+(bounded and unbounded), ``Inter``, ``Alt``, and Boolean leaves over AP.
+Acceptance is always ``Finite``;
+the accepting-state set is exactly the *nullable* states
+(those that match the empty word).
+
+**`morphata.logic.psl.psl_to_automaton(phi, *, finite=False)`** :
+PSL -> alternating automaton.
+Wraps pure-LTL subformulas in an internal ``_LTL`` tag
+and dispatches to the LTL expansion rule; closure operators (``{r}!
+``, ``{r}``, ``!{r}``, ``{r}<>-> f``, ``{r}[]-> f``) become their own tagged states with
+SERE-step expansion.
+Suffix implications follow Spot's overlapping semantics:
+the last symbol of ``r`` and the first position of ``f`` coincide.
+``finite=True`` -> ``Finite`` acceptance (PSLf); ``finite=False`` -> ``Buchi``.
+
+Hand-written automata are built with ``AutomatonBuilder``;
+the package has no separate ``constructions`` namespace.
+
+### Operator Layer (`morphata.operators`)
+
+Algebraic morphisms that turn an ``Automaton`` plus an ``Alphabet`` into a computable
+interpretation over an algebraic domain.
 
 **`morphata.operators.matrix.MatrixOperator`** :
+
 - Weighted finite-word NFA semantics as semiring matrix multiplication.
 - Fields: ``initial_weights``, ``final_weights``, ``semiring``, an
   ``alphabet`` bound at construction, and a frozen ``(src, dst, guard)``
@@ -129,6 +142,7 @@ a computable interpretation over an algebraic domain.
 - ``cost_transitions(x)`` returns an ``algebraic.AlgebraicArray``.
 
 **`morphata.operators.polynomial.PolynomialOperator`** :
+
 - Alternating finite automata as multilinear polynomials over a
   bounded distributive lattice (typically Boolean).
 - The alphabet is bound at construction. ``step(current, symbol)``
@@ -139,51 +153,64 @@ a computable interpretation over an algebraic domain.
   ``PolynomialOperator.from_ltl(formula, algebra, *, alphabet, finite=True, ...)``.
 - Backed by ``algebraic.polynomials.RankDecomposition``.
 
-**`morphata.operators._backend`** : ``resolve_backend(...)`` and the
-``_StaticAux`` JAX-pytree helper.  Inferred from any provided
-``AlgebraicArray`` or specified explicitly via ``backend=``.
+**`morphata.operators._backend`** :
+``resolve_backend(...)`` and the ``_StaticAux`` JAX-pytree helper.
+Inferred from any provided ``AlgebraicArray`` or specified explicitly via ``backend=``.
 
-### Symbolic layer (`morphata.symbolic`)
+### Symbolic Layer (`morphata.symbolic`)
 
-BDD-backed representation of an ``Automaton``.  Structural / runtime
-layer: no target algebra, no semiring.
+BDD-backed representation of an ``Automaton``.
+Structural / runtime layer: no target algebra, no semiring.
 
-**`morphata.symbolic.bdd`** : thin bridge between ``BoolExpr`` and the
-``dd`` BDD package.  Exports ``make_manager(reordering=True)``,
-``declare_state_vars``, ``state_var_name``, ``STATE_VAR_FORMAT``,
-``boolexpr_to_bdd(expr, mgr, num_vars) -> dd.Function``,
-``bdd_to_boolexpr(node) -> BoolExpr[int]``.  Nothing else in
-``morphata`` imports ``dd`` directly.
+**`morphata.symbolic.bdd`** :
+thin bridge between ``BoolExpr`` and the ``dd`` BDD package.
+Exports ``make_manager(reordering=True)``, ``declare_state_vars``, ``state_var_name``,
+``STATE_VAR_FORMAT``, ``boolexpr_to_bdd
+(expr, mgr, num_vars) -> dd.Function``, ``bdd_to_boolexpr(node) -> BoolExpr[int]``.
+Nothing else in ``morphata`` imports ``dd`` directly.
 
 **`morphata.symbolic.automaton.SymbolicAutomaton`** :
-- Wraps an ``Automaton`` so the initial-state set and every cached
-  transition are live ``dd.Function`` nodes in a single ``dd.BDD``
-  manager.  Acceptance is stored as given; only ``accepts(word)``
-  requires ``Finite`` acceptance.
+
+- Wraps an ``Automaton`` so the initial-state set
+  and every cached transition are live ``dd.Function`` nodes in a single ``dd.BDD``
+  manager.
+  Acceptance is stored as given; only ``accepts(word)`` requires ``Finite`` acceptance.
 - Requires ``aut.delta`` to be ``Outgoing``; ``Step`` deltas (STREL)
   raise ``TypeError``.
-- Constructor: ``SymbolicAutomaton.from_automaton(aut, *, alphabet,
-  manager=None, reordering=True, cache_transitions=True, name_fn=None)``.
+- Constructor: ``SymbolicAutomaton.from_automaton
+  (aut, *, alphabet, manager=None, reordering=True, cache_transitions=True,
+  name_fn=None)``.
   Convenience ``from_ltl`` / ``from_hoaf`` constructors compose with
-  ``ltl_to_automaton`` and the HOA parser, and likewise require
-  ``alphabet=``.
-- Per-step primitives: ``step(current, symbol)``, ``run(word)``,
-  ``accepts(word)``. The alphabet is bound at construction and must be a
-  ``BooleanAlphabet``; the BDD cofactor path generalises to any
-  user-supplied labeling.
+  ``ltl_to_automaton`` and the HOA parser, and likewise require ``alphabet=``.
+- Per-step primitives: ``step(current, symbol)``, ``run(word)``, ``accepts(word)``.
+  The alphabet is bound at construction and must be a ``BooleanAlphabet``;
+  the BDD cofactor path generalises to any user-supplied labeling.
 - State variables in the manager are always named ``q0..q{n-1}``;
   callers who want their own variable names should apply ``mgr.let``
   with an alias map.
 
-**`morphata.symbolic.transforms`** : BDD-level structural transforms
-over ``SymbolicAutomaton`` -- ``nfa_from_afa`` (dealternation),
-``determinize`` (subset construction with an explicit sink), and
-``minimize`` (Hopcroft partition refinement). The three compose to
-``SymbolicAutomaton.to_min_dfa``.
-
-**`morphata.symbolic.equivalence`** : language-equivalence and
-isomorphism checks for DFA-shaped symbolic automata --
-``language_equivalent``, ``canonical_form``, ``isomorphic``.
+**`morphata.symbolic.transforms`** :
+BDD-level structural transforms over ``SymbolicAutomaton`` -- ``nfa_from_afa``
+(dealternation), ``determinize`` (subset construction with an explicit sink), and
+``minimize`` (Hopcroft partition refinement).
+The three compose to ``SymbolicAutomaton.to_min_dfa``.
+
+**`morphata.symbolic.compose`** :
+compositional min-DFA construction on top of ``minimize``.
+``compose_min_dfa(left, right, op)`` takes the product of two DFA-shaped
+``SymbolicAutomaton`` instances over a shared manager and minimizes the result; ``op``
+is ``"and"`` or ``"or"``.
+``min_dfa_of_conjunction(formulas, *, alphabet)`` builds each conjunct's min-DFA over a
+shared manager with a canonical AP ``name_fn`` derived from the alphabet's predicate
+set, then folds them under ``compose_min_dfa(..., op="and")``.
+For top-level LTLf conjunctions where each conjunct has a small min-DFA
+but the monolithic AFA explodes under ``determinize``,
+the layered path can be orders of magnitude faster.
+
+**`morphata.symbolic.equivalence`** :
+language-equivalence and isomorphism checks
+for DFA-shaped symbolic automata -- ``language_equivalent``, ``canonical_form``,
+``isomorphic``.
 
 ## Dependencies
 
@@ -194,18 +221,18 @@ isomorphism checks for DFA-shaped symbolic automata --
 - Optional: `jax` (for the JAX backend), `torch` (for the PyTorch
   backend), `pydot` (for `.dot` exports).
 
-`morphata` operators that use `equinox` are JAX-flavoured; `algebraic`
-is backend-agnostic via `backend=`.
+`morphata` operators that use `equinox` are JAX-flavoured;
+`algebraic` is backend-agnostic via `backend=`.
 
 ## Design Principles
 
-1. **Single IR shape** : everything is a
-   ``morphata.automaton.Automaton``.  Variants (det / nondet / univ /
-   alt) are derived from the rows, not encoded in separate classes.
-2. **Alphabet-Carried Characteristic Function** : guards stay symbolic
-   in the IR.  ``Alphabet.weight(symbol, guard)`` lifts a symbol against
-   a guard.  Match the alphabet's ``V`` type to your consumer (``bool``
-   for symbolic evaluation, semiring elements for weighted evaluation).
+1. **Single IR shape** : everything is a ``morphata.automaton.Automaton``.
+   Variants (det / nondet / univ / alt) are derived from the rows,
+   not encoded in separate classes.
+2. **Alphabet-Carried Characteristic Function** : guards stay symbolic in the IR.
+   ``Alphabet.weight(symbol, guard)`` lifts a symbol against a guard.
+   Match the alphabet's ``V`` type to your consumer
+   (``bool`` for symbolic evaluation, semiring elements for weighted evaluation).
 3. **Semiring-Agnostic Operators** : operator factories accept the
    target algebra and the alphabet separately; the alphabet does not
    know about the algebra.
@@ -221,31 +248,36 @@ is backend-agnostic via `backend=`.
 
 ## Usage Notes and Limitations
 
-- STREL automata use a ``Step`` delta (the transition consumes the input
-  graph eagerly), so they cannot be lifted to ``SymbolicAutomaton`` and
-  are not consumable by ``MatrixOperator`` / ``PolynomialOperator``.
+- STREL automata use a ``Step`` delta
+  (the transition consumes the input graph eagerly),
+  so they cannot be lifted to ``SymbolicAutomaton``
+  and are not consumable by ``MatrixOperator`` / ``PolynomialOperator``.
   STREL itself is Boolean-only.
-- ``MatrixOperator`` targets finite-word acceptance; omega-regular
-  acceptance is not implemented for it.  Successor expressions must be
-  single ``Variable(dst)`` per row (no alternation / universal lifting).
+- ``MatrixOperator`` targets finite-word acceptance;
+  omega-regular acceptance is not implemented for it.
+  Successor expressions must be single ``Variable(dst)`` per row
+  (no alternation / universal lifting).
 - ``PolynomialOperator`` is tested with Boolean algebra; other semirings
   may require additional validation.
-- **State-based acceptance only.** Acceptance sets are sets of states, not
-  sets of transitions. The HOA parser ingests ``{n}`` markers from
-  ``State:`` declarations; per-edge ``{n}`` markers are ignored. Convert
-  transition-based HOA files to state-based form before loading them.
-- ``psl_to_automaton`` requires the continuation of any
-  ``SuffixImpliesExist`` / ``SuffixImpliesUniv`` to be a pure-LTL
-  formula in v1.  Nested PSL closures inside a suffix-implication
-  continuation raise ``NotImplementedError``.  Likewise, LTL temporal
-  operators wrapping a PSL closure at the top level
-  (e.g. ``Always(StrongClosure(r))``) are not yet decomposed; lift the
-  PSL fragment out of the LTL temporal operator before calling.
+- **State-based acceptance only.**
+  Acceptance sets are sets of states, not sets of transitions.
+  The HOA parser ingests ``{n}`` markers from ``State:`` declarations;
+  per-edge ``{n}`` markers are ignored.
+  Convert transition-based HOA files to state-based form before loading them.
+- ``psl_to_automaton`` requires the continuation of any ``SuffixImpliesExist`` /
+  ``SuffixImpliesUniv`` to be a pure-LTL formula in v1.
+  Nested PSL closures inside a suffix-implication continuation raise
+  ``NotImplementedError``.
+  Likewise, LTL temporal operators wrapping a PSL closure at the top level
+  (e.g. ``Always(StrongClosure(r))``)
+  are not yet decomposed; lift the PSL fragment out of the LTL temporal operator
+  before calling.
 - The PSL Buchi acceptance classification is the natural per-tag rule
-  (strong-closure non-accepting, weak-closure accepting, etc.).  It has
-  not been cross-checked against a published reference for every
-  combination of operators; consult ``docs/superpowers/specs/`` before
-  relying on omega-language semantics in production.
+  (strong-closure non-accepting, weak-closure accepting, etc.).
+  It has not been cross-checked against a published reference
+  for every combination of operators;
+  consult ``docs/superpowers/specs/``
+  before relying on omega-language semantics in production.
 
 ## Testing
 
@@ -379,6 +411,8 @@ matrix_product = algebraic.matmul(arr1, arr2)
 - `src/morphata/operators/polynomial.py` : ``PolynomialOperator``.
 - `src/morphata/symbolic/automaton.py` : ``SymbolicAutomaton``.
 - `src/morphata/symbolic/bdd.py` : ``BoolExpr`` / ``dd`` bridge.
+- `src/morphata/symbolic/compose.py` : ``compose_min_dfa`` and
+  ``min_dfa_of_conjunction``.
 - `src/morphata/symbolic/transforms.py` : ``nfa_from_afa`` /
   ``determinize`` / ``minimize``.
 - `src/morphata/symbolic/equivalence.py` : language equivalence and

{morphata-2.0.1 → morphata-2.0.3}/CHANGELOG.md

@@ -1,47 +1,132 @@
 # Changelog
 
-## Unreleased
+## 2.0.3 — 2026-05-28
 
 ### Added
 
-- `morphata.logic.sere.sere_to_automaton(formula)` — converts a
-  SERE expression to an alternating finite automaton. Supports
-  `Concat`, `Fusion`, `Alt`, `Inter` (length-matching), `Repeat`
-  (bounded and unbounded), and Boolean leaves (`Literal`, `Variable`,
-  `Not`, `And`, `Or`).
-- `morphata.logic.psl.psl_to_automaton(phi, *, finite=False)` —
-  converts a PSL expression to an alternating automaton, with
-  `Finite` acceptance for PSLf (`finite=True`) and `Büchi` acceptance
-  for full PSL (`finite=False`). Supports the strong / weak /
-  negated-strong closure operators and existential / universal
-  suffix implication. Suffix implications follow Spot's overlapping
-  semantics: the last symbol matched by the SERE prefix is shared
-  with the first position at which the continuation is evaluated.
+Added a new `morphata.symbolic.compose` API
+that provides some helper functions to construct `SymbolicAutomaton` from composing two
+minimal DFAs or to construct minimal DFAs from LTLf formula with a lot of overlapping
+conjunctive clauses (essentially uses `compose_min_dfa`).
+
+This helps fix some downstream issues where the AFA can have maybe 20 states
+(like in Craftax tech trees),
+but always using the `SymbolicAutomaton.to_min_dfa()` pipeline causes us to hit the
+worst-case exponential blow up.
+But, since these specifications have the structure of being conjunctive clauses of much
+smaller minimal DFAs, having a better composition operation benefits us.
+
+## 2.0.2 — 2026-05-27
+
+### Added
+
+- The rest of the SERE surface that needed real work, rather than a desugaring rule:
+  non-length-matching intersection
+  (`NLMInter`, the `&` operator), `Complement` (`~`), and `FirstMatch`.
+  NLM intersection is handled by a local rewrite in the expansion polynomial;
+  complement dualises the polynomial and gets a small BFS-loop special case
+  so the state space stays compact.
+  `GotoRepeat`, `EqualRepeat`,
+  and bounded `FusionRepeat` desugar through `logic_asts.spec.Expr.expand`.
+  Unbounded `FusionRepeat[:*i..]` deliberately raises `NotImplementedError` —
+  I don't have a clean expansion for it yet.
+- Benchmarking script for SERE NLM intersection, so I can see when I
+  break the perf curve.
 
 ### Changed
 
-- `morphata.logic.ltl` factored its per-call BDD scratch-space
-  construction into a shared helper
-  `morphata.logic._common.make_logic_context`, reused by the SERE
-  and PSL converters. Two LTL helpers (`_aut_symbolic_expansion`,
-  `_empty_trace_value`) were renamed to `ltl_symbolic_expansion` /
-  `ltl_empty_trace_value` so PSL can delegate to them for pure-LTL
-  subformulas.
+- `morphata.logic.psl` dropped a layer of in-tree wrappers
+  and leans on `logic_asts` types directly now
+  that the upstream package carries the extended SERE surface I needed.
+  Less code, fewer places for the two sides to disagree.
+
+### Miscellaneous
+
+- The README is linked from `pyproject.toml`, so it actually shows up
+  on PyPI.
+
+## 2.0.1 — 2026-05-24
+
+The point release that delivers the SERE
+and PSL frontends originally promised alongside 2.0,
+plus the perf work that made the symbolic pipeline actually finish on formulas of
+interest.
+
+### Added
+
+- `morphata.logic.sere.sere_to_automaton(formula)` —
+  converts a SERE expression to an alternating finite automaton.
+  Supports `Concat`, `Fusion`, `Alt`, `Inter` (length-matching), `Repeat`
+  (bounded and unbounded),
+  and Boolean leaves (`Literal`, `Variable`, `Not`, `And`, `Or`).
+- `morphata.logic.psl.psl_to_automaton(phi, *, finite=False)` —
+  converts a PSL expression to an alternating automaton,
+  with `Finite` acceptance for PSLf (`finite=True`) and `Büchi` acceptance
+  for full PSL (`finite=False`).
+  Supports the strong / weak / negated-strong closure operators
+  and existential / universal suffix implication.
+  Suffix implications follow Spot's overlapping semantics:
+  the last symbol matched by the SERE prefix is shared with the first position at
+  which the continuation is evaluated.
+
+### Changed
 
-### Known limitations
+- `morphata.logic.ltl` factored its per-call BDD scratch-space construction into a
+  shared helper `morphata.logic._common.make_logic_context`, reused by the SERE and PSL
+  converters.
+  Two LTL helpers (`_aut_symbolic_expansion`, `_empty_trace_value`) were renamed to
+  `ltl_symbolic_expansion` / `ltl_empty_trace_value` so PSL can delegate to them for
+  pure-LTL subformulas.
+- Moved off `uv` and onto Pixi. `uv`'s handling of CUDA packages and
+  the way it churns the lockfile weren't working for me; Pixi does.
+
+### Fixed
+
+- New BDD constructions in `morphata.logic` take an explicit manager parameter instead
+  of silently spinning up their own.
+- `bdd_to_boolexpr` in `morphata.symbolic.bdd` was silently folding `~x`
+  and `x` together because the CUDD complement-edge flag on the current node wasn't
+  being respected on the recursive walk.
+  Caught while rewriting `ltl_to_automaton`; fixed there.
+
+### Performance
+
+- `ltl_to_automaton` no longer iterates `2^|AP|` input symbols per AFA state.
+  The closure BFS keeps APs symbolic, builds an expansion polynomial with tagged atoms
+  (one tag for guard atoms, one for successor states),
+  compiles it to a per-call BDD,
+  and partitions AP-space by distinct state cofactors via the new
+  `mgr_partition_ap_by_state_residual` helper.
+  Per-AFA-state cost drops from `O(2^|AP|)` to `O(distinct successor classes)`,
+  and AP variables that don't affect a given cofactor get pruned.
+  A depth-15 sequential conjunction `F(a_0) & X(F(a_1) & X(...))`
+  that used to take ~330s and OOM at depth 20 now builds in ~0.02s.
+  The remaining wall-clock on those formulas lives in `nfa_from_afa`,
+  which is intrinsic `2^N` in macro state count.
+- `SymbolicAutomaton.to_min_dfa()` is tractable on formulas with non-trivial `|AP|`
+  (`~5+` for monotone conjunctions, `~10+` for sequential), where it used to hang.
+  Three pieces: prime-implicant DFS (`mgr_minimal_pos_satisfying_subsets`) replaces the
+  old `2^(2^|AP|)` BDD-evaluation pass in `_nfa_macro_step` after dealternation;
+  symbolic AP-space partition helpers (`mgr_partition_ap_by_classifiers` and
+  `mgr_partition_ap_by_state_residual`) replace explicit `2^|AP|` minterm enumeration in
+  `determinize` and `nfa_from_afa`; and `_extract_dfa_target` parses the single
+  state-variable name directly instead of linear-scanning every state in the manager,
+  removing an `O(num_states^2)` per-refinement-round cost inside `minimize()`.
+
+Sadly (but not really sadly),
+these performance fixes make the BDD manager a viral argument in `morphata.logic`,
+but it isn't too bad as it is optional,
+and the `morphata.logic.*_to_automaton` functions will automatically create a
+short-lived manager for these things.
+
+### Known Limitations
 
 - `psl_to_automaton` does not yet decompose LTL temporal operators
-  that wrap PSL closures at the top level
-  (e.g. `Always(StrongClosure(r))`). Lift the PSL fragment out of
-  the surrounding LTL temporal operator before calling.
+  that wrap PSL closures at the top level (e.g. `Always(StrongClosure(r))`).
+  Lift the PSL fragment out of the surrounding LTL temporal operator before calling.
 - The continuation of a `SuffixImpliesExist` / `SuffixImpliesUniv`
   must be a pure-LTL formula; nested PSL closures inside a
   continuation raise `NotImplementedError`.
-- The Büchi acceptance classification for PSL has not been
-  cross-checked against a published reference for every operator
-  combination; finite-trace (PSLf) acceptance is exercised end-to-end
-  via `SymbolicAutomaton.accepts` and is high-confidence, but Büchi
-  is currently only smoke-tested for construction.
 
 ## 2.0.0 — 2026-05-23