morphata 2.3.0__tar.gz → 2.3.1__tar.gz

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.3.0 → morphata-2.3.1}/AGENTS.md

@@ -46,6 +46,13 @@ 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

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

@@ -1,5 +1,71 @@
 # 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,
@@ -16,9 +82,9 @@ which has allowed me to harden `morphata` and also add a bunch of relevant featu
   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).
+- `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`.
@@ -64,13 +130,14 @@ which has allowed me to harden `morphata` and also add a bunch of relevant featu
   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.
+  `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.
+- 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,
@@ -144,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
@@ -170,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.
@@ -198,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.
@@ -226,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
@@ -298,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.
@@ -324,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
@@ -341,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
 
@@ -355,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
 
@@ -409,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
 
@@ -453,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
 
@@ -469,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
 
@@ -497,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
 
@@ -552,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
 
@@ -564,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
 
@@ -599,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
 
@@ -646,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
 
@@ -711,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.
@@ -741,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.**
@@ -754,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.**
@@ -774,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.**
@@ -788,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.
 
@@ -813,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.3.0 → morphata-2.3.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: morphata
-Version: 2.3.0
+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

{morphata-2.3.0 → morphata-2.3.1}/docs/api/modules.rst

@@ -16,3 +16,4 @@
    morphata.hoa
    morphata.builder
    morphata.storage
+   morphata.utils

{morphata-2.3.0 → morphata-2.3.1}/docs/api/morphata.storage.rst

@@ -34,3 +34,22 @@ Persistent automata
 .. autofunction:: morphata.storage.automaton_to_json
 
 .. autofunction:: morphata.storage.automaton_from_json
+
+Running persistent automata
+---------------------------
+
+These functions run a :class:`~morphata.storage.PersistentAutomaton` without a BDD
+manager. A run configuration is a positive state formula in minimal form.
+
+.. automodule:: morphata.storage.run
+   :no-members:
+
+.. autofunction:: morphata.storage.minimal_state_sop
+
+.. autofunction:: morphata.storage.step
+
+.. autofunction:: morphata.storage.is_accepting
+
+.. autofunction:: morphata.storage.run_semantics
+
+.. autofunction:: morphata.storage.distinguishing_words

{morphata-2.3.0 → morphata-2.3.1}/docs/api/morphata.symbolic.rst

@@ -22,6 +22,8 @@
 
 .. autofunction:: morphata.symbolic.language_separation_distance
 
+.. autofunction:: morphata.symbolic.distance.dfa_from_symbolic_automaton
+
 .. autoclass:: morphata.symbolic.MacroStateLimitError
 
 .. autofunction:: morphata.symbolic.minimize_dfa

morphata-2.3.1/docs/api/morphata.utils.rst

@@ -0,0 +1,61 @@
+``morphata.utils``
+==================
+
+.. automodule:: morphata.utils
+   :no-members:
+
+Distinguishing words
+--------------------
+
+.. automodule:: morphata.utils.witness
+   :no-members:
+
+.. autoclass:: morphata.utils.RunSemantics
+   :members: initial, step, is_accepting
+
+.. autofunction:: morphata.utils.distinguishing_words
+
+Edit distances between DFAs
+---------------------------
+
+.. automodule:: morphata.utils.edit_distance
+   :no-members:
+
+.. autoclass:: morphata.utils.DFATable
+   :members: initial, transitions, accepting
+
+.. autofunction:: morphata.utils.dfa_unsigned_levenshtein_distance
+
+.. autofunction:: morphata.utils.dfa_signed_levenshtein_distance
+
+.. autofunction:: morphata.utils.dfa_language_separation_distance
+
+.. autofunction:: morphata.utils.dfa_from_persistent
+
+Sampling automata
+-----------------
+
+.. automodule:: morphata.utils.sampling
+   :no-members:
+
+.. autofunction:: morphata.utils.sampling.random_dfa
+
+.. autofunction:: morphata.utils.sampling.fresh_random_afa
+
+.. autofunction:: morphata.utils.sampling.reverse_random_dfa
+
+.. autofunction:: morphata.utils.sampling.kth_from_end
+
+.. autofunction:: morphata.utils.sampling.modular_counters
+
+.. autofunction:: morphata.utils.sampling.eventually_conjunction
+
+.. autofunction:: morphata.utils.sampling.safety_conjunction
+
+.. autofunction:: morphata.utils.sampling.locally_testable
+
+.. autofunction:: morphata.utils.sampling.finite_trace_pattern
+
+.. autofunction:: morphata.utils.sampling.mutate
+
+.. autofunction:: morphata.utils.sampling.vary

{morphata-2.3.0 → morphata-2.3.1}/docs/concepts/acceptance.rst

@@ -2,11 +2,11 @@ Acceptance Conditions
 =====================
 
 An :class:`~morphata.acceptance.AcceptanceCondition` decides when a run
-of an automaton is considered accepting. morphata supports both
+of an automaton is considered accepting. ``morphata`` supports both
 **finite-word** and **omega-regular** acceptance.
 
 Omega-regular support is structural: conditions can be represented, imported,
-exported, and complemented. morphata does not evaluate infinite runs.
+exported, and complemented. ``morphata`` does not evaluate infinite runs.
 :meth:`~morphata.symbolic.SymbolicAutomaton.accepts`, operators, language
 equivalence, and current transforms implement finite-word semantics only.
 

{morphata-2.3.0 → morphata-2.3.1}/docs/concepts/hoa.rst

@@ -2,7 +2,7 @@ HOA Format
 ==========
 
 The `Hanoi Omega-Automata (HOA) <https://adl.github.io/hoaf/>`_ format
-is a standard text representation for omega-automata. morphata provides
+is a standard text representation for omega-automata. ``morphata`` provides
 a parser for HOA v1, extended with a ``Final(n)`` operator for
 finite-word acceptance.
 
@@ -76,7 +76,7 @@ The ``Final(n)`` Extension
 
 Standard HOA defines ``Inf(n)`` (visit set *n* infinitely often) and
 ``Fin(n)`` (visit set *n* finitely often) for omega-regular acceptance.
-morphata adds ``Final(n)`` for finite-word automata:
+``morphata`` adds ``Final(n)`` for finite-word automata:
 
 - ``Final(n)``: accept if the run **ends in** a state marked with
   acceptance set *n*.
@@ -122,7 +122,7 @@ This automaton accepts exactly the finite words that contain ``a``.
 State-based acceptance only
 ---------------------------
 
-morphata reads only state-based acceptance markers (``{n}`` attached
+``morphata`` reads only state-based acceptance markers (``{n}`` attached
 to ``State:`` declarations). Per-edge ``{n}`` markers in transition
 lines are ignored. Convert transition-based HOA files to state-based
 form before loading them.