morphata 2.2.3__tar.gz → 2.3.1__tar.gz

{morphata-2.2.3 → morphata-2.3.1}/.envrc

@@ -21,4 +21,6 @@ fi
 
 dotenv_if_exists
 
+export PIXI_FROZEN=true
+
 eval "$(pixi shell-hook)"

morphata-2.3.1/.rstcheck.cfg

@@ -0,0 +1,43 @@
+[rstcheck]
+ignore_directives =
+    automodule,
+    autoclass,
+    autofunction,
+    autotype,
+    autodata,
+    autoexception,
+    bibliography,
+    footbibliography
+ignore_roles =
+    external:py:mod,
+    cite,
+    cite:p,
+    cite:ps,
+    cite:t,
+    cite:ts,
+    cite:ct,
+    cite:cts,
+    cite:empty,
+    cite:alp,
+    cite:alps,
+    cite:label,
+    cite:labelpar,
+    cite:year,
+    cite:yearpar,
+    cite:author,
+    cite:authors,
+    cite:authorpar,
+    cite:authorpars,
+    cite:cauthor,
+    cite:cauthors,
+    footcite,
+    footcite:p,
+    footcite:ps,
+    footcite:t,
+    footcite:ts,
+    footcite:ct,
+    footcite:cts
+report_level = WARNING
+
+
+# vim: set ft=dosini

{morphata-2.2.3 → morphata-2.3.1}/AGENTS.md

@@ -29,6 +29,13 @@ The narrow exception: a **surgical, already-decided edit** the author has spelle
 Do exactly that and nothing more.
 When unsure whether a change qualifies, treat it as out of scope and ask.
 
+## Project Boundaries
+
+Morphata owns automata representations, algebraic operations, semiring operators,
+and execution. Automata Encoders owns symbolic input features, trainable
+encoders, training/evaluation tools, and comparison baselines. Morphata must
+not depend on Automata Encoders.
+
 ## Development Environment
 
 The development shell already has the project virtual environment activated,
@@ -38,3 +45,15 @@ etc. are on `PATH` directly.
 Just invoke the tool.
 If a tool is missing, stop and tell the user rather than trying to bootstrap
 or reinstall the environment.
+
+## Tests
+
+Write tests to verify the common case and edge cases with distinct failure modes.
+Do not add tests solely to increase coverage. Check expected behavior against
+the public contract or an independent reference; avoid tests that merely repeat
+the implementation. Each test should identify a behavior or failure it checks.
+
+## Documentation
+
+Use NumPy/numpydoc-style sections for Python docstrings. Use RST math markup
+inside those sections and in the main docstring body.

{morphata-2.2.3 → morphata-2.3.1}/CHANGELOG.md

@@ -1,5 +1,159 @@
 # Changelog
 
+## 2.3.1 — 2026-11-11
+
+This isn't a hefty release,
+but does have some nice QoL things as well as some performance updates and bug fixes.
+A large chunk of these was discovered/needed
+while dogfooding my learned automata embeddings project,
+so I guess they are informed by "real-world" scenarios.
+
+### Added
+
+- `SymbolicAutomaton.distinguishing_words` finds the shortest words accepted by exactly
+  one of two automata.
+  You can ask for several witnesses, set a minimum length, and randomize ties.
+  Works with alternating automata too, without first determinizing them,
+  and the two automata can use different BDD managers.
+
+- Persistent automata can now be run directly through `morphata.storage`,
+  without reconstructing a symbolic automaton or needing a BDD manager.
+  There is a `distinguishing_words` helper for these too.
+
+- Edit distances for DFAs given as explicit transition tables,
+  through `DFATable` and the `dfa_*` distance functions in `morphata.utils`.
+  These cover unsigned and signed directed Levenshtein distances,
+  and minimum language separation, without BDD operations.
+  Helpers convert deterministic symbolic and persistent automata to tables.
+  The unsigned distance also accepts a `cap`,
+  useful when you only care how far apart the languages are up to some budget.
+
+- `CanonicalDfaHasher.residual_digests_from_table` computes residual digests directly
+  from a complete DFA table.
+  Gives the same digests as the symbolic path with `minimize=False`,
+  without going through BDDs.
+
+### Performance
+
+- Symbolic language repair distance now starts with small edit budgets
+  and increases them until it finds one that works.
+  Small distances no longer require building the automaton
+  for the full finite-repair bound before the search even starts.
+
+- Transition partitioning does less repeated BDD work.
+  Transformations also retain known determinism and alternation flags,
+  saving checks whose answers the construction already knows.
+
+### Fixed
+
+- Matrix operators built from specifications now materialize constant accepting
+  and rejecting sinks.
+  Those successors need actual states in the matrix representation too.
+
+- BDD caches used during partitioning, determinization,
+  and dealternation are now cleared when their scope ends,
+  fixing memory leaks from retained BDD references.
+
+- Alphabet domains are now applied when compiling specifications,
+  exposing transition partitions, and reversing DFA transitions.
+  Impossible predicate valuations no longer contribute edges in these paths.
+
+- Automata with constant initial formulas and no states now compose correctly.
+  Previously, composition assumed there was at least one state to remap.
+
+### Documentation
+
+- The automaton sampling helpers now have API documentation, covering random automata,
+  structured language families, and mutations.
+
+## 2.3.0 — 2026-10-21
+
+This is *another* hefty release,
+and has been the culmination of `morphata` being used to dogfood multiple other
+projects --- I will not reveal the level of success of those other projects though ---
+which has allowed me to harden `morphata` and also add a bunch of relevant features.
+
+### Added
+
+- `BooleanAlphabet.as_guard` turns a concrete symbol into its BDD guard.
+
+- `to_min_rfsa`, also available as `SymbolicAutomaton.to_min_rfsa`,
+  constructs canonical residual finite-state automata using cover-aware subset
+  exploration and language reversal, without building the full DFA.
+  Follows the same API as the other transformers.
+
+- `SymbolicAutomaton` now has helpers for determining if its language is empty,
+  whether it contains the language of another automaton,
+  and a helper to return relational edges (for nondeterministic automata only).
+
+- `JaxBatchedMatrixOperator` runs batches of integer-encoded words over dense matrix
+  operators using JAX's `lax.scan`.
+  You can run every word on every operator, or pair each word with one operator.
+  Padded words with different lengths are supported too.
+
+- A JAX min-max Boolean algebra with a choice of native or smooth surrogate gradients.
+  The forward pass still computes exact min and max;
+  the surrogate gives the backward pass a smoother signal.
+
+- Automaton sampling helpers in `morphata.utils.sampling`,
+  covering random DFAs and AFAs, structured language families, temporal specifications,
+  and local mutations.
+  Useful when you want some variety in the automata you are working with.
+
+- `factor_initial=True` on `remove_alternation`, `determinize`,
+  and `to_min_dfa` transforms the components of the initial formula separately,
+  then combines them smallest-first.
+  Another option for constructions where exploring everything together gets large.
+
+- `EditDistanceAutomaton` converts a given symbolic automaton to a min-plus weighted
+  automaton that computes the edit distance between a word and the given automaton.
+  Additionally, we have lifted this word-language edit distance to a quasimetric
+  that computes a directed Hausdorff distance to the `EditDistanceAutomaton` from some
+  other automaton.
+
+- `unsigned_levenshtein_distance` computes the worst-case number of edits needed to
+  repair a source word into the target language.
+  It returns zero when the source language is contained in the target.
+  `signed_levenshtein_distance` reports a containment margin
+  when the source language is contained in the target,
+  and the same repair cost otherwise.
+
+- `language_separation_distance` computes the minimum edit distance between any pair of
+  words from two languages.
+  It returns infinity if either is empty.
+
+### Changed
+
+- Persistent automata now retain the original predicate objects.
+  `morphata.storage.configure_converter` lets you use your own cattrs converter
+  and predicate serialization hooks, with consistent ordering across backends.
+  The JSON helpers remain for string predicates.
+
+- Custom alphabet domain callbacks now need to accept `care_vars`.
+  `BooleanAlphabet.intersect_with_domain` uses this to constrain guards using only the
+  predicates those guards actually mention.
+
+### Fixed
+
+- DFA minimization now compares guards on the full alphabet domain,
+  so guards that differ only on impossible predicate valuations do not split equivalent
+  states.
+
+- Symbolic transformations reuse alphabet domains within each construction stage.
+  Dealternation, determinization,
+  and RFSA subset exploration cache projected domains by the combined relation's
+  predicate support and apply them before partitioning.
+
+- Canonical finite-alphabet traversal now restricts transitions before partitioning,
+  so impossible predicate valuations do not affect BFS state numbering.
+
+- `compose_automata` now removes pruned states from the finite accepting set too.
+  Previously, accepting states could survive in the bookkeeping
+  after their transition rows had been removed.
+
+- `has_conjunctive_state_terms` previously did not correctly handle successor states
+  that were just Boolean constants, i.e., unmaterialized accepting/rejecting sinks.
+
 ## 2.2.3 — 2026-09-22
 
 This is a hefty release, but all really cool things that I am super proud of
@@ -57,8 +211,8 @@ so I will just be making this a patch release
   which keeps finite-alphabet guards compact without changing their meaning.
 
 - Symbolic automaton transformations accept an optional initial state formula,
-  allowing a transformation to start from a formula other than the automaton's
-  stored initial condition without modifying the source automaton.
+  allowing a transformation to start from a formula other than the automaton's stored
+  initial condition without modifying the source automaton.
 
 - `prune_unreachable`, which removes the states unreachable from an automaton's initial
   states and, with `remove_sink_states=True`, the materialized sink states too (an
@@ -83,9 +237,9 @@ so I will just be making this a patch release
   since the manager's variable levels are not stable under reordering.
   The partition is recomputed on each call.
 
-- A `make_sink_states` keyword on `remove_alternation`, `determinize`, and
-  `minimize_dfa`, controlling whether constant `True` and `False` successors are
-  materialized as indexed sink states.
+- A `make_sink_states` keyword on `remove_alternation`, `determinize`,
+  and `minimize_dfa`, controlling whether constant `True`
+  and `False` successors are materialized as indexed sink states.
 
 - A `reverse_language` utility that produces an automaton
   that accepts the reversed language.
@@ -111,12 +265,12 @@ so I will just be making this a patch release
 - Add a signed version of the Levenshtein distance between two nondeterministic finite
   automata.
 
-- `SemiringAlphabet` now has two optional fields that allows one to enumerate all
-  symbols in the alphabet (not just predicates), and test if some symbol is contained in
-  the alphabet.
+- `SemiringAlphabet` now has two optional fields
+  that allows one to enumerate all symbols in the alphabet
+  (not just predicates), and test if some symbol is contained in the alphabet.
 
-  - In addition, `BooleanAlphabet` now have a mandatory `domain` keyword argument which
-    constrains the universe of allowed predicate valuations as a BDD.
+  - In addition, `BooleanAlphabet` now have a mandatory `domain` keyword argument
+    which constrains the universe of allowed predicate valuations as a BDD.
 
 - `morphata.storage` has means to store canonical representations (morphata-specific) of
   `SymbolicAutomaton` to disk.
@@ -139,9 +293,11 @@ so I will just be making this a patch release
 
 ### Developer Experience
 
-- The Pixi environments now describe CPU, CUDA 12, and CUDA 13 targets with virtual
-  packages, so dependency resolution does not have to guess which machine it is
-  eventually going to meet. `sphinx-autobuild` also joins the development toolbox
+- The Pixi environments now describe CPU, CUDA 12,
+  and CUDA 13 targets with virtual packages,
+  so dependency resolution does not have to guess
+  which machine it is eventually going to meet.
+  `sphinx-autobuild` also joins the development toolbox
   for faster documentation tinkering.
 
 ### Fixed
@@ -211,9 +367,9 @@ and increase the surface area of properly typed code.
   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.
+- 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.
@@ -237,8 +393,9 @@ and increase the surface area of properly typed code.
   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`,
+  `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
@@ -254,12 +411,13 @@ and increase the surface area of properly typed code.
 ### 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.
+- 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
 
@@ -268,9 +426,9 @@ and increase the surface area of properly typed code.
   `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.
+- 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
 
@@ -322,9 +480,9 @@ and increase the surface area of properly typed code.
 
 ### 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.
+- 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
 
@@ -366,10 +524,9 @@ and increase the surface area of properly typed code.
   but minimization can merge classes such
   that a representative's per-factor successor lands on a non-representative tuple,
   so the full surjection has to be there.
-- `iter_composed_transitions` enumerates `(state, symbol, successor)`
-  of a composed DFA without building the product BDD, walking factor
-  deltas directly and hitting `tuple_to_class` once per
-  `(state, symbol)`.
+- `iter_composed_transitions` enumerates `(state, symbol, successor)` of a composed DFA
+  without building the product BDD, walking factor deltas directly and hitting
+  `tuple_to_class` once per `(state, symbol)`.
 
 ### Performance
 
@@ -382,23 +539,22 @@ and increase the surface area of properly typed code.
   and per-class point dicts across same-support rows.
   Conjunction-fold DFAs get 1.3-1.6x; `F a & F b & F c & F d` q1 went ~343us -> ~175us.
 - `isomorphic` routes through a compact support-reduced fingerprint
-  and skips the broadcast expansion. `|AP|=19` sparse case:
-  ~333ms -> ~83ms.
+  and skips the broadcast expansion.
+  `|AP|=19` sparse case: ~333ms -> ~83ms.
 
 ### Changed
 
-- `SymbolicAutomaton` carries a derived `ap_inverse: Mapping[str, AP]`
-  populated in `__post_init__`; `to_automaton` and
-  `compose._merge_managers` route through it.
-- New symbolic benches are pytest-benchmark cases, so timings get
-  recorded rather than gated on a hard-coded threshold.
+- `SymbolicAutomaton` carries a derived `ap_inverse: Mapping[str, AP]` populated in
+  `__post_init__`; `to_automaton` and `compose._merge_managers` route through it.
+- New symbolic benches are pytest-benchmark cases,
+  so timings get recorded rather than gated on a hard-coded threshold.
 
 ## 2.0.7 — 2026-06-02
 
 ### Fixed
 
-- The BDD JSON exporter in `dd.cudd` needed to be worked around because of a bug where
-  `mgr.true` and `mrg.false` do not survive a round trip serialization.
+- The BDD JSON exporter in `dd.cudd` needed to be worked around because of a bug
+  where `mgr.true` and `mrg.false` do not survive a round trip serialization.
 
 ## 2.0.6 — 2026-06-02
 
@@ -410,8 +566,9 @@ and increase the surface area of properly typed code.
 
 ### Added
 
-- Added a free-floating function that helps enumerate the successor BDDs from a symbolic
-  automaton state, given a specific alphabet and set of symbols.
+- Added a free-floating function
+  that helps enumerate the successor BDDs from a symbolic automaton state,
+  given a specific alphabet and set of symbols.
 
 ## 2.0.5 — 2026-06-01
 
@@ -465,8 +622,8 @@ smaller minimal DFAs, having a better composition operation benefits us.
   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.
+- Benchmarking script for SERE NLM intersection,
+  so I can see when I break the perf curve.
 
 ### Changed
 
@@ -477,8 +634,7 @@ smaller minimal DFAs, having a better composition operation benefits us.
 
 ### Miscellaneous
 
-- The README is linked from `pyproject.toml`, so it actually shows up
-  on PyPI.
+- The README is linked from `pyproject.toml`, so it actually shows up on PyPI.
 
 ## 2.0.1 — 2026-05-24
 
@@ -512,8 +668,9 @@ interest.
   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.
+- 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
 
@@ -559,9 +716,8 @@ short-lived manager for these things.
 - `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.
-- The continuation of a `SuffixImpliesExist` / `SuffixImpliesUniv`
-  must be a pure-LTL formula; nested PSL closures inside a
-  continuation raise `NotImplementedError`.
+- The continuation of a `SuffixImpliesExist` / `SuffixImpliesUniv` must be a pure-LTL
+  formula; nested PSL closures inside a continuation raise `NotImplementedError`.
 
 ## 2.0.0 — 2026-05-23
 
@@ -624,9 +780,10 @@ which will be summarized below.
   and `WeightedAlphabet.from_predicates(...)` folds per-AP predicates through the
   semiring.
   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.
+  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.
   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.
@@ -654,9 +811,11 @@ 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.**
@@ -667,17 +826,19 @@ 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.**
@@ -687,8 +848,9 @@ 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.**
@@ -701,23 +863,23 @@ which will be summarized below.
 
 Documentation and tooling cleanup.
 
-- Replaced stray non-ASCII characters in docs (those that survived from
-  copy-paste rather than authored content).
+- Replaced stray non-ASCII characters in docs
+  (those that survived from copy-paste rather than authored content).
 - Started publishing CHANGELOGs and wired them into the Sphinx docs.
 - Added a `pytest-timeout` dev dependency so hanging tests fail loudly.
-- Added a mypy override for the `dd` BDD library so type-checking is
-  clean for symbolic code.
+- Added a mypy override for the `dd` BDD library so type-checking is clean
+  for symbolic code.
 
 ## 1.0.2 — 2026-04-17
 
-- Added `dd` as a dependency along with a small in-tree wrapper, in
-  preparation for the BDD-backed symbolic layer.
-- Fixed a queue ordering bug in `ltl_to_automaton` that produced
-  incorrect successor expansions for some operator combinations.
-- First pass at user-facing documentation (README, LICENSE, package
-  URLs) and at RST linting for the docs.
-- Trimmed CI to a single type checker (`mypy`) and stopped silently
-  hiding missing-import errors.
+- Added `dd` as a dependency along with a small in-tree wrapper,
+  in preparation for the BDD-backed symbolic layer.
+- Fixed a queue ordering bug in `ltl_to_automaton`
+  that produced incorrect successor expansions for some operator combinations.
+- First pass at user-facing documentation
+  (README, LICENSE, package URLs) and at RST linting for the docs.
+- Trimmed CI to a single type checker (`mypy`)
+  and stopped silently hiding missing-import errors.
 - Ported all operators to the current `algebraic` API.
   This is source-incompatible with the previous internal `automatix` algebra module.
 
@@ -726,15 +888,15 @@ Documentation and tooling cleanup.
 Initial wave of feature work that established the current shape of the library.
 
 - Boolean polynomials implemented on top of BDDs.
-- STREL: Lark-based parser for STREL expressions and a translation to
-  alternating finite automata, including the spatial Reach/Escape
-  operators.
+- STREL: Lark-based parser for STREL expressions
+  and a translation to alternating finite automata,
+  including the spatial Reach/Escape operators.
 - LTL/LTLf to alternating Büchi / finite automata.
 - Algebraic structures moved to the separate `algebraic` package.
-- HOA parsing moved out into a dedicated `hoaparser` package (later
-  re-integrated as `morphata.hoa`).
-- JAX and PyTorch made optional dependencies; both backends are picked
-  up automatically by `algebraic` when installed.
+- HOA parsing moved out into a dedicated `hoaparser` package
+  (later re-integrated as `morphata.hoa`).
+- JAX and PyTorch made optional dependencies;
+  both backends are picked up automatically by `algebraic` when installed.
 - Test suite rebuilt against the new APIs.
 
 ## Pre-1.0

{morphata-2.2.3 → morphata-2.3.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: morphata
-Version: 2.2.3
+Version: 2.3.1
 Summary: Representation theory for automata, made practical.
 Project-URL: Documentation, https://docs.anandb.dev/morphata
 Project-URL: Repository, https://git.anandb.dev/morphata.git
@@ -11,7 +11,7 @@ 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: algebraic-arrays>=1.3.10
 Requires-Dist: attrs>=25.4.0
 Requires-Dist: bitarray>=3.10.0
 Requires-Dist: cattrs>=26.1.0
@@ -24,7 +24,8 @@ 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'
+Requires-Dist: flax; extra == 'jax'
+Requires-Dist: jax<0.11.2,>=0.8; extra == 'jax'
 Provides-Extra: torch
 Requires-Dist: torch>=2.0; extra == 'torch'
 Description-Content-Type: text/x-rst

{morphata-2.2.3 → morphata-2.3.1}/bench/README.md

@@ -20,6 +20,12 @@ To get pytest-benchmark's tabular wall-time output:
   JAX-only scale cases are opt-in via
   `MORPHATA_RUN_SCALE_BENCHMARKS=1`; run each scale case in a fresh process under
   a hard memory limit.
+- `test_transforms_perf.py` -- alternation removal and determinization over
+  single-root conjoined-eventuality and until-chain AFA families, plus composed
+  eventuality AFAs whose initial formulas have multiple state variables. The
+  composed cases compare the monolithic and opt-in factored-initial
+  constructions. Results are grouped by transform, construction, and formula
+  size. Regular cases stop at size 10.
 - `test_sere_nlm_perf.py` -- NLM-intersection state-space blowup.
   Cases: `NLMInter(a0..a_{n-1})` for n in 2..6, `NLMInter(a_i;b_i)`
   for n in 2..4, plus length-matching `Inter` baselines.