morphata 2.0.1__tar.gz → 2.0.2__tar.gz

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

@@ -15,7 +15,15 @@
       "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: $?\")"
     ]
   }
 }

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

@@ -1,47 +1,116 @@
 # Changelog
 
-## Unreleased
+## 2.0.2 — 2026-05-27
 
 ### 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.
+- 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
 

{morphata-2.0.1 → morphata-2.0.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: morphata
-Version: 2.0.1
+Version: 2.0.2
 Summary: Representation theory for automata, made practical.
 Project-URL: Documentation, https://docs.anandb.dev/morphata
 Project-URL: Repository, https://git.anandb.dev/morphata.git
@@ -16,7 +16,7 @@ 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.0
+Requires-Dist: logic-asts>=1.6.2
 Requires-Dist: networkx
 Requires-Dist: numpy
 Requires-Dist: types-networkx

morphata-2.0.2/bench/README.md

@@ -0,0 +1,28 @@
+# morphata bench
+
+Opt-in benchmark suite. Not collected by the default `pytest`
+invocation.
+
+## Running
+
+    pytest bench/ -v
+
+To get pytest-benchmark's tabular wall-time output:
+
+    pytest bench/ -v --benchmark-columns=mean,median,min,max,rounds
+
+## Suites
+
+- `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.
+
+## Recording results
+
+After running, paste the resulting tables (state count + wall time)
+into the spec doc at:
+`docs/superpowers/specs/2026-05-26-psl-refactor-and-nlm-perf-design.md`
+
+The Phase 2 fix (memoization / pre-pass canonicalization / first-class
+`_NLMInter` state) is chosen based on the numbers; the choice is
+recorded as a follow-up plan.

morphata-2.0.2/bench/conftest.py

@@ -0,0 +1,53 @@
+"""pytest fixtures for the morphata bench suite.
+
+The bench/ tree is opt-in: invoke with `pytest bench/` (or
+`pytest bench/test_sere_nlm_perf.py`). It is not collected by the
+default `pytest` invocation.
+"""
+
+from __future__ import annotations
+
+import gc
+from collections.abc import Iterator
+
+import pytest
+
+from morphata.logic.sere import _expansion_call_counter
+from morphata.symbolic.bdd import Manager, make_manager
+
+
+@pytest.fixture
+def bench_mgr() -> Iterator[Manager]:
+    """Shared BDD manager scoped to one bench test (= many benchmark rounds).
+
+    Bench tests pass this manager to ``sere_to_automaton(..., manager=mgr)``
+    so the per-call ``make_manager()`` path is skipped. That path leaks
+    ~12 MB of CUDD-internal state per call, which compounds across the
+    ~100-1000 rounds pytest-benchmark runs per test and exhausts host
+    RAM. Sharing the manager keeps RSS flat.
+    """
+    manager = make_manager()
+    try:
+        yield manager
+    finally:
+        gc.collect()
+
+
+@pytest.fixture
+def expansion_calls() -> Iterator[list[int]]:
+    """Activate the expansion-call counter for the duration of one test.
+
+    Yields a single-element list whose entry is filled in by the test
+    with the final call count snapshot (`current_expansion_call_count()`).
+    """
+    token = _expansion_call_counter.set(0)
+    try:
+        yield [0]
+    finally:
+        _expansion_call_counter.reset(token)
+
+
+def current_expansion_call_count() -> int:
+    """Read the current expansion-call counter value (0 if inactive)."""
+    val = _expansion_call_counter.get()
+    return val if val is not None else 0

morphata-2.0.2/bench/test_sere_nlm_perf.py

@@ -0,0 +1,84 @@
+"""Benchmark suite for SERE NLMInter state-space behaviour.
+
+Run with: ``pytest bench/test_sere_nlm_perf.py -v``
+
+Records state count, expansion-call count, and wall time for
+NLM-intersection of n branches, plus length-matching Inter as a
+baseline.
+
+History note: the original spec hypothesised an exponential blowup
+in branch count for ``NLMInter``. Direct measurement (see the spec's
+"Phase 1 Benchmark Results" section) showed no such blowup -- state
+count stays at 3 for arbitrarily many AP-literal branches and grows
+linearly (2n+3) for length-2-concat branches. The bench is retained
+as a regression guard.
+
+A separate finding from this investigation: ``make_manager()`` leaks
+~12 MB of CUDD-internal state per call, so the bench passes a single
+``bench_mgr`` fixture into ``sere_to_automaton(..., manager=mgr)``
+to keep RSS flat across the ~100-1000 rounds pytest-benchmark runs
+per test. Without that, repeated calls compound to GiB-scale RSS and
+hang the host.
+"""
+
+from __future__ import annotations
+
+import logic_asts as logic
+import logic_asts.sere as sere
+import pytest
+from pytest_benchmark.fixture import BenchmarkFixture as Benchmark
+
+from morphata.logic.sere import sere_to_automaton
+from morphata.symbolic.bdd import Manager
+
+from .conftest import current_expansion_call_count
+
+
+def _nlm_of_aps(n: int) -> logic.Expr:
+    return sere.NLMInter(tuple(sere.Variable(f"a{i}") for i in range(n)))
+
+
+def _lm_of_aps(n: int) -> logic.Expr:
+    return sere.Inter(tuple(sere.Variable(f"a{i}") for i in range(n)))
+
+
+def _nlm_of_concats(n: int) -> logic.Expr:
+    return sere.NLMInter(tuple(sere.Concat((sere.Variable(f"a{i}"), sere.Variable(f"b{i}"))) for i in range(n)))
+
+
+def _run_and_measure(formula: logic.Expr, mgr: Manager) -> tuple[int, int]:
+    """Return ``(state_count, expansion_call_count)``."""
+    aut = sere_to_automaton(formula, manager=mgr)
+    states = aut.states
+    n_states = len(states) if states is not None and not callable(states) else 0
+    return (n_states, current_expansion_call_count())
+
+
+@pytest.mark.timeout(10)
+@pytest.mark.parametrize("n", list(range(2, 10)))
+def test_bench_nlm_of_aps(benchmark: Benchmark, expansion_calls: list[int], bench_mgr: Manager, n: int) -> None:
+    formula = _nlm_of_aps(n)
+    result = benchmark(_run_and_measure, formula, bench_mgr)
+    state_count, call_count = result
+    expansion_calls[0] = call_count
+    print(f"\nNLMInter(a0..a{n - 1}): states={state_count} expansion_calls={call_count}")
+
+
+@pytest.mark.timeout(10)
+@pytest.mark.parametrize("n", list(range(2, 10)))
+def test_bench_lm_of_aps_baseline(benchmark: Benchmark, expansion_calls: list[int], bench_mgr: Manager, n: int) -> None:
+    formula = _lm_of_aps(n)
+    result = benchmark(_run_and_measure, formula, bench_mgr)
+    state_count, call_count = result
+    expansion_calls[0] = call_count
+    print(f"\nInter(a0..a{n - 1}): states={state_count} expansion_calls={call_count}")
+
+
+@pytest.mark.timeout(10)
+@pytest.mark.parametrize("n", list(range(2, 10)))
+def test_bench_nlm_of_concats(benchmark: Benchmark, expansion_calls: list[int], bench_mgr: Manager, n: int) -> None:
+    formula = _nlm_of_concats(n)
+    result = benchmark(_run_and_measure, formula, bench_mgr)
+    state_count, call_count = result
+    expansion_calls[0] = call_count
+    print(f"\nNLMInter(a_i;b_i) n={n}: states={state_count} expansion_calls={call_count}")

morphata-2.0.2/ci/make-release

@@ -0,0 +1,131 @@
+#!/usr/bin/env bash
+set -euo pipefail
+
+# Usage ------------------------------------------------------------------
+usage() {
+  cat <<EOF
+Usage: $(basename "$0") <bump>
+
+  bump      Version bump kind passed to 'uv version --bump'
+            (patch, minor, major, etc.)
+
+Examples:
+  $(basename "$0") patch
+  $(basename "$0") minor
+EOF
+  exit 1
+}
+
+if [[ $# -ne 1 ]]; then
+  usage
+fi
+
+PROJECT_DIR="$(cd "$(dirname "$(realpath "${BASH_SOURCE[0]}")")/.." && pwd)"
+cd "$PROJECT_DIR"
+
+BUMP="$1"
+
+# Helpers ----------------------------------------------------------------
+is_jj() { [[ -d "$PROJECT_DIR/.jj" ]]; }
+
+check_clean() {
+  if is_jj; then
+    if [[ -n "$(jj diff --summary 2>/dev/null)" ]]; then
+      echo "error: working copy is not clean (jj diff shows changes)" >&2
+      exit 1
+    fi
+  else
+    if [[ -n "$(git status --porcelain)" ]]; then
+      echo "error: working copy is not clean (git status shows changes)" >&2
+      exit 1
+    fi
+  fi
+}
+
+# Lint & type-check
+echo "==> Running linters and type checkers..."
+just lint
+
+# Ensure working copy is clean
+echo -n "==> Checking working copy is clean... "
+check_clean
+echo "    OK"
+
+# CHANGELOG.md is hand-authored under an `## Unreleased` heading; this
+# script promotes that heading to the new version and dates it.
+# Make sure that the Unreleased section is correctly there
+
+UNRELEASED_COUNT="$(grep -c '^## Unreleased$' CHANGELOG.md || true)"
+if [[ "$UNRELEASED_COUNT" -eq 0 ]]; then
+  echo "error: CHANGELOG.md has no '## Unreleased' section to promote" >&2
+  exit 1
+elif [[ "$UNRELEASED_COUNT" -gt 1 ]]; then
+  echo "error: CHANGELOG.md has ${UNRELEASED_COUNT} '## Unreleased' sections; expected exactly one" >&2
+  exit 1
+fi
+
+# Bump version and check tag
+OLD_VERSION="$(uv version --short)"
+NEW_VERSION="$(uv version --bump "$BUMP" --dry-run --short)"
+TAG="v${NEW_VERSION}"
+RELEASE_DATE="$(date +%Y-%m-%d)"
+
+echo "==> Bumping $BUMP version..."
+echo "    Current version: $OLD_VERSION"
+echo "    New version:     $NEW_VERSION"
+echo "    Tag:             $TAG"
+echo "    Date:            $RELEASE_DATE"
+
+if git rev-parse -q --verify "refs/tags/$TAG" >/dev/null 2>&1; then
+  echo "error: tag '$TAG' already exists" >&2
+  echo "error: refusing to bump $BUMP version" >&2
+  exit 1
+fi
+uv version --bump "$BUMP"
+
+# Promote CHANGELOG `Unreleased` to the new version
+echo "==> Promoting CHANGELOG Unreleased -> ${NEW_VERSION} (${RELEASE_DATE})"
+sed -i "s/^## Unreleased$/## ${NEW_VERSION} \xe2\x80\x94 ${RELEASE_DATE}/" CHANGELOG.md
+
+# Commit
+COMMIT_MSG="chore(release): ${NEW_VERSION}"
+echo "==> Committing: $COMMIT_MSG"
+
+if is_jj; then
+  jj commit -m "$COMMIT_MSG"
+else
+  git add pyproject.toml CHANGELOG.md
+  git commit -m "$COMMIT_MSG"
+fi
+
+# Build the tag annotation from the just-promoted CHANGELOG section.
+# Title is "release: $(uv version)"; body is the section content (the
+# lines between the new `## <ver> ...` heading and the next `## ` heading).
+TAG_TITLE="release: $(uv version)"
+TAG_BODY="$(awk -v ver="$NEW_VERSION" -v prev="$OLD_VERSION" '
+  $0 ~ "^## " ver "( |$)" { capture = 1; next }
+  capture && /^## / {
+    if ($0 !~ "^## " prev "( |$)") {
+      printf "error: expected next changelog heading to be %s, got: %s\n", \
+        "## " prev, $0 > "/dev/stderr"
+      exit 2
+    }
+    exit
+  }
+  capture { print }
+' CHANGELOG.md)"
+
+# Tag
+echo "==> Tagging $TAG"
+if is_jj; then
+  jj git import 2>/dev/null || true
+fi
+printf '%s\n\n%s\n' "$TAG_TITLE" "$TAG_BODY" \
+  | git tag -a "$TAG" --cleanup=verbatim -F -
+if is_jj; then
+  jj git import 2>/dev/null || true
+fi
+
+echo ""
+echo "Done! Created tag: ${TAG}"
+echo "To publish, push the tag:  git push origin ${TAG}"