morphata 2.0.2__tar.gz → 2.0.3__tar.gz

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

@@ -23,7 +23,10 @@
       "Skill(superpowers:requesting-code-review)",
       "Bash(timeout 15 python -c ' *)",
       "Read(//tmp/**)",
-      "Bash(echo \"exit: $?\")"
+      "Bash(echo \"exit: $?\")",
+      "Skill(superpowers:executing-plans)",
+      "Bash(ruff check *)",
+      "Bash(ruff format *)"
     ]
   }
 }

{morphata-2.0.2 → 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.2 → morphata-2.0.3}/CHANGELOG.md

@@ -1,5 +1,21 @@
 # Changelog
 
+## 2.0.3 — 2026-05-28
+
+### Added
+
+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

morphata-2.0.3/PKG-INFO

@@ -0,0 +1,137 @@
+Metadata-Version: 2.4
+Name: morphata
+Version: 2.0.3
+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: dd>=0.6.0
+Requires-Dist: jaxtyping>=0.3
+Requires-Dist: lark>=1.3.1
+Requires-Dist: logic-asts>=1.6.2
+Requires-Dist: networkx
+Requires-Dist: numpy
+Requires-Dist: types-networkx
+Requires-Dist: typing-extensions
+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/markdown
+
+# morphata
+
+**morphata** does representation theory for automata, and makes it practical.
+
+An automaton -- its states, transitions, and acceptance condition -- is a
+*structural* object. *Operators* turn that structure into a quantitative
+interpretation: a matrix-valued morphism over a semiring, a multilinear
+polynomial over a bounded distributive lattice, or a BDD-canonicalised
+symbolic representation. ``morphata`` packages both halves -- the structures
+and the morphisms that interpret them -- in one library.
+
+It builds on [`algebraic`](https://docs.anandb.dev/algebraic) for
+backend-agnostic semiring algebra (NumPy, JAX, PyTorch).
+
+## Quick Start
+
+### Installation
+
+```bash
+pip install morphata
+```
+
+### Basic Usage
+
+```python
+import algebraic
+import jax.numpy as jnp
+from morphata.builder import AutomatonBuilder
+from morphata.alphabet import weighted_alphabet
+from morphata.operators.matrix import MatrixOperator
+import logic_asts as logic
+
+builder: AutomatonBuilder[int, str] = AutomatonBuilder()
+builder.add_state(0, initial=True)
+builder.add_state(1, accepting=True)
+builder.add_transition(0, guard=logic.Variable("a"), succ=1)
+aut = builder.build()
+
+def xi(x, guard):
+    return float(x[0])
+
+alphabet = weighted_alphabet(xi=xi)
+maxplus = algebraic.semirings.tropical_semiring(minplus=False)
+op = MatrixOperator.from_nfa(aut, semiring=maxplus, alphabet=alphabet)
+
+x = jnp.array([2.0])
+transitions = op.cost_transitions(x)
+```
+
+For more, see the [documentation](https://docs.anandb.dev/morphata).
+
+## Citation
+
+If you use the matrix operator or this package, please cite one of:
+
+- For differentiable weighted automata in general:
+
+```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:
+
+```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:
+
+```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 LICENSE file for details.

{morphata-2.0.2 → morphata-2.0.3}/pyproject.toml

@@ -2,13 +2,14 @@
 name = "morphata"
 authors = [{ name = "Anand Balakrishnan", email = "anandbala1597@gmail.com" }]
 description = "Representation theory for automata, made practical."
-version = "2.0.2"
+version = "2.0.3"
 requires-python = ">=3.12"
 classifiers = [
   "Intended Audience :: Science/Research",
   "Topic :: Scientific/Engineering :: Mathematics",
 ]
 license = "BSD-3-Clause"
+readme = "README.md"
 
 dependencies = [
   "attrs>=25.4.0",

{morphata-2.0.2 → morphata-2.0.3}/src/morphata/symbolic/__init__.py

@@ -34,9 +34,12 @@ from morphata.symbolic.bdd import guard_to_bdd as guard_to_bdd
 from morphata.symbolic.bdd import make_ap_registry as make_ap_registry
 from morphata.symbolic.bdd import make_manager as make_manager
 from morphata.symbolic.bdd import state_var_name as state_var_name
+from morphata.symbolic.compose import compose_min_dfa as compose_min_dfa
+from morphata.symbolic.compose import min_dfa_of_conjunction as min_dfa_of_conjunction
 from morphata.symbolic.equivalence import canonical_form as canonical_form
 from morphata.symbolic.equivalence import isomorphic as isomorphic
 from morphata.symbolic.equivalence import language_equivalent as language_equivalent
 from morphata.symbolic.transforms import determinize as determinize
+from morphata.symbolic.transforms import extract_dfa_target as extract_dfa_target
 from morphata.symbolic.transforms import minimize as minimize
 from morphata.symbolic.transforms import nfa_from_afa as nfa_from_afa