scikit-complexity 0.2.0__tar.gz → 0.3.0__tar.gz

{scikit_complexity-0.2.0 → scikit_complexity-0.3.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: scikit-complexity
-Version: 0.2.0
+Version: 0.3.0
 Summary: A Python package to create and simulate complex systems.
 Author-Email: Georgios Douzas <gdouzas@icloud.com>
 License-Expression: MIT
@@ -13,6 +13,7 @@ Classifier: Programming Language :: Python :: 3
 Classifier: Programming Language :: Python :: 3 :: Only
 Classifier: Programming Language :: Python :: 3.12
 Classifier: Programming Language :: Python :: 3.13
+Classifier: Programming Language :: Python :: 3.14
 Classifier: Topic :: Documentation
 Classifier: Topic :: Software Development
 Classifier: Topic :: Utilities
@@ -24,7 +25,7 @@ Project-URL: Repository, https://github.com/georgedouzas/scikit-complexity
 Project-URL: Issues, https://github.com/georgedouzas/scikit-complexity/issues
 Project-URL: Discussions, https://github.com/georgedouzas/scikit-complexity/discussions
 Project-URL: Funding, https://github.com/sponsors/georgedouzas
-Requires-Python: <3.14,>=3.12
+Requires-Python: <3.15,>=3.12
 Requires-Dist: numpy>=2.1.0
 Requires-Dist: scipy>=1.13.0
 Requires-Dist: passagemath-symbolics>=10.8.13
@@ -38,7 +39,7 @@ Requires-Dist: mpich>=4.3.0
 Requires-Dist: mesa>=3.5.0
 Requires-Dist: networkx>=3.3
 Requires-Dist: igraph>=1.0.0
-Requires-Dist: xgi>=0.10.2
+Requires-Dist: xgi<2,>=1.0.0
 Requires-Dist: scikit-learn>=1.5.1
 Requires-Dist: SALib>=1.5
 Requires-Dist: pandas>=2.2.2
@@ -52,7 +53,7 @@ Requires-Dist: ennemi>=1.6.0
 Requires-Dist: tidynamics>=1.1.2
 Requires-Dist: mrestimator>=0.2.0
 Requires-Dist: kramersmoyal>=0.4.1
-Requires-Dist: deeptime>=0.4.5
+Requires-Dist: pydtmc>=10.1.0
 Requires-Dist: dit>=2.3
 Requires-Dist: qutip<6,>=5.3
 Requires-Dist: matching>=1.4.3
@@ -158,8 +159,8 @@ interactions change it through laws, and systems nest and compose. Learn it once
 
 ## Installation
 
-`scikit-complexity` supports Python 3.12 and 3.13 on Linux and on macOS 13 or later with Apple silicon, and is available on
-PyPI:
+`scikit-complexity` supports Python 3.12, 3.13, and 3.14 on Linux and on macOS 13 or later with Apple silicon, and is
+available on PyPI. On Python 3.14 the install builds `memory-allocator` from source, so it needs a C compiler:
 
 ```bash
 pip install scikit-complexity

{scikit_complexity-0.2.0 → scikit_complexity-0.3.0}/README.md

@@ -89,8 +89,8 @@ interactions change it through laws, and systems nest and compose. Learn it once
 
 ## Installation
 
-`scikit-complexity` supports Python 3.12 and 3.13 on Linux and on macOS 13 or later with Apple silicon, and is available on
-PyPI:
+`scikit-complexity` supports Python 3.12, 3.13, and 3.14 on Linux and on macOS 13 or later with Apple silicon, and is
+available on PyPI. On Python 3.14 the install builds `memory-allocator` from source, so it needs a C compiler:
 
 ```bash
 pip install scikit-complexity

{scikit_complexity-0.2.0 → scikit_complexity-0.3.0}/pyproject.toml

@@ -12,7 +12,7 @@ authors = [
 ]
 license = "MIT"
 readme = "README.md"
-requires-python = ">=3.12, <3.14"
+requires-python = ">=3.12, <3.15"
 keywords = []
 dynamic = []
 classifiers = [
@@ -25,6 +25,7 @@ classifiers = [
     "Programming Language :: Python :: 3 :: Only",
     "Programming Language :: Python :: 3.12",
     "Programming Language :: Python :: 3.13",
+    "Programming Language :: Python :: 3.14",
     "Topic :: Documentation",
     "Topic :: Software Development",
     "Topic :: Utilities",
@@ -44,7 +45,7 @@ dependencies = [
     "mesa>=3.5.0",
     "networkx>=3.3",
     "igraph>=1.0.0",
-    "xgi>=0.10.2",
+    "xgi>=1.0.0,<2",
     "scikit-learn>=1.5.1",
     "SALib>=1.5",
     "pandas>=2.2.2",
@@ -58,7 +59,7 @@ dependencies = [
     "tidynamics>=1.1.2",
     "mrestimator>=0.2.0",
     "kramersmoyal>=0.4.1",
-    "deeptime>=0.4.5",
+    "pydtmc>=10.1.0",
     "dit>=2.3",
     "qutip<6,>=5.3",
     "matching>=1.4.3",
@@ -72,7 +73,7 @@ dependencies = [
     "optax>=0.2.8",
     "diffrax>=0.7.2",
 ]
-version = "0.2.0"
+version = "0.3.0"
 
 [project.urls]
 Homepage = "https://georgedouzas.github.io/scikit-complexity"
@@ -332,7 +333,6 @@ DEP002 = [
     "powerlaw",
     "mrestimator",
     "kramersmoyal",
-    "deeptime",
     "dit",
     "igraph",
     "pysindy",

{scikit_complexity-0.2.0 → scikit_complexity-0.3.0}/src/skcomplex/analysis/_markov.py

@@ -7,10 +7,9 @@ from collections.abc import Sequence
 
 import numpy as np
 import numpy.typing as npt
-from deeptime.markov import TransitionCountEstimator
-from deeptime.markov.msm import MarkovStateModel as DeeptimeModel
-from deeptime.markov.msm import MaximumLikelihoodMSM
+from pydtmc import MarkovChain
 from scipy import linalg
+from scipy.sparse import csgraph
 
 from ..engine.runtime import Trajectory
 from ..errors import AnalysisError
@@ -19,8 +18,11 @@ from ._base import BaseAnalysis
 from .types import Source
 
 MATRIX_DIMENSIONS = 2
+MIN_CONNECTED_STATES = 2
+MAX_ITERATIONS = 1_000_000
 
 TOLERANCE = 1e-10
+FIT_TOLERANCE = 1e-8
 KINDS = ('transition-matrix', 'stationary', 'spectral-gap', 'state-model', 'timescales')
 MATRICES = ('transition', 'rate')
 SETTINGS = {
@@ -41,8 +43,8 @@ class MarkovAnalysis(BaseAnalysis):
     - `'transition-matrix'`: the transitions after `lag` steps counted along the paths and normalized by row.
     - `'stationary'`: the stationary law `pi` of the matrix, `pi P = pi` or `pi Q = 0` for rates.
     - `'spectral-gap'`: the gap `1 - |lambda_2|`, or `-Re lambda_2` for rates, and the relaxation time of every mode.
-    - `'state-model'`: the maximum-likelihood Markov state model of the largest connected set, estimated with
-      deeptime, with its metastable sets found by PCCA+.
+    - `'state-model'`: the maximum-likelihood Markov state model of the largest connected set, with its metastable
+      sets found by PCCA+.
     - `'timescales'`: the slowest implied timescales of Markov state models at every lag of `lags`, which do not
       depend on the lag for a Markovian discretization.
 
@@ -164,6 +166,9 @@ class MarkovAnalysis(BaseAnalysis):
         if self.dt <= 0:
             error_msg = f'{type(self).__name__} has dt={self.dt!r}. Use a positive time step.'
             raise AnalysisError(error_msg)
+        if self.n_metastable is not None and not self.reversible:
+            error_msg = f'{type(self).__name__} finds metastable sets of reversible models only. Use reversible=True.'
+            raise AnalysisError(error_msg)
 
     def _get_data_kind(self) -> DataKind:
         """Return the path kind."""
@@ -188,21 +193,12 @@ class MarkovAnalysis(BaseAnalysis):
 
     def _run_state_model(self) -> None:
         """Estimate the Markov state model and its metastable sets."""
-        model = self._fit(self._get_states(), self.lag, reversible=self.reversible)
-        symbols = np.asarray(model.count_model.state_symbols, dtype=np.int64)
-        self.states_ = symbols
-        self.transition_matrix_ = np.asarray(model.transition_matrix, dtype=float)
-        self.stationary_ = np.asarray(model.stationary_distribution, dtype=float)
-        self.timescales_ = np.asarray(model.timescales(), dtype=float) * self.dt
+        self.states_, self.transition_matrix_ = self._fit(self.path_, self.lag, reversible=self.reversible)
+        self.stationary_ = self._stationary_distribution(self.transition_matrix_)
+        self.timescales_ = self._implied_timescales(self.transition_matrix_, self.lag) * self.dt
         self.metastable_sets_ = []
         if self.n_metastable is not None:
-            self.metastable_sets_ = [
-                symbols[np.asarray(found, dtype=np.int64)] for found in model.pcca(self.n_metastable).sets
-            ]
-
-    def _get_states(self) -> npt.NDArray[np.int64]:
-        """Return one path as a row, or several paths as rows, as deeptime reads them."""
-        return self.path_[0] if self.path_.shape[0] == 1 else self.path_
+            self.metastable_sets_ = self._metastable_sets(self.transition_matrix_, self.states_, self.n_metastable)
 
     def _run(self, inputs: object = None) -> None:
         """Compute the quantity of the kind."""
@@ -219,10 +215,12 @@ class MarkovAnalysis(BaseAnalysis):
         elif self.kind == 'state-model':
             self._run_state_model()
         else:
-            states = self._get_states()
             self.timescales_ = np.asarray(
                 [
-                    self._fit(states, lag, reversible=self.reversible).timescales(self.n_timescales) * self.dt
+                    self._implied_timescales(self._fit(self.path_, lag, reversible=self.reversible)[1], lag)[
+                        : self.n_timescales
+                    ]
+                    * self.dt
                     for lag in self.lags
                 ],
                 dtype=float,
@@ -295,9 +293,50 @@ class MarkovAnalysis(BaseAnalysis):
         return np.sort(-dt / np.log(moduli))[::-1]
 
     @staticmethod
-    def _fit(states: npt.ArrayLike, lag: int, *, reversible: bool) -> DeeptimeModel:
-        """Return the maximum-likelihood model of the largest connected set of states at a lag."""
-        paths = np.asarray(states, dtype=np.int32)
-        trajectories = list(paths) if paths.ndim > 1 else paths
-        counts = TransitionCountEstimator(lagtime=lag, count_mode='sliding').fit(trajectories).fetch_model()
-        return MaximumLikelihoodMSM(reversible=reversible).fit(counts.submodel_largest()).fetch_model()
+    def _reversible_matrix(counts: Array) -> Array:
+        """Return the reversible maximum-likelihood transition matrix of counts, by a fixed-point iteration on flows."""
+        symmetric = counts + counts.T
+        totals = counts.sum(axis=1)
+        flows = symmetric / symmetric.sum()
+        for _ in range(MAX_ITERATIONS):
+            ratios = totals / flows.sum(axis=1)
+            updated = symmetric / (ratios[:, np.newaxis] + ratios)
+            updated /= updated.sum()
+            change = np.abs(updated.sum(axis=1) - flows.sum(axis=1)).max()
+            flows = updated
+            if change < FIT_TOLERANCE:
+                return flows / flows.sum(axis=1, keepdims=True)
+        error_msg = f'The reversible fit did not converge in {MAX_ITERATIONS} iterations. Use more data.'
+        raise AnalysisError(error_msg)
+
+    @staticmethod
+    def _fit(states: npt.ArrayLike, lag: int, *, reversible: bool) -> tuple[npt.NDArray[np.int64], Array]:
+        """Return the largest connected set of states and its maximum-likelihood transition matrix at a lag."""
+        counts = MarkovAnalysis._transition_counts(states, lag=lag).astype(float)
+        labels = csgraph.connected_components(counts, connection='strong')[1]
+        connected = np.flatnonzero(labels == np.bincount(labels).argmax())
+        if connected.size < MIN_CONNECTED_STATES:
+            error_msg = f'A Markov state model needs {MIN_CONNECTED_STATES} connected states, and the paths have fewer.'
+            raise AnalysisError(error_msg)
+        kept = counts[np.ix_(connected, connected)]
+        if reversible:
+            return connected, MarkovAnalysis._reversible_matrix(kept)
+        return connected, kept / kept.sum(axis=1, keepdims=True)
+
+    @staticmethod
+    def _implied_timescales(matrix: Array, lag: int) -> Array:
+        """Return the implied timescales in steps of every mode but the stationary one, slowest first."""
+        return np.asarray(MarkovChain(matrix).implied_timescales, dtype=float)[1:] * lag
+
+    @staticmethod
+    def _metastable_sets(matrix: Array, states: npt.NDArray[np.int64], n_sets: int) -> list[npt.NDArray[np.int64]]:
+        """Return the states of every metastable set of a reversible transition matrix."""
+        if not 1 <= n_sets <= states.size:
+            error_msg = f'A Markov state model of {states.size} states has 1 to {states.size} sets, not {n_sets}.'
+            raise AnalysisError(error_msg)
+        if n_sets == 1:
+            return [states]
+        if n_sets == states.size:
+            return list(states.reshape(-1, 1))
+        chain = MarkovChain(matrix, [str(state) for state in states.tolist()])
+        return [np.asarray(found.split(','), dtype=np.int64) for found in chain.metastable_aggregation(n_sets).states]

{scikit_complexity-0.2.0 → scikit_complexity-0.3.0}/src/skcomplex/analysis/_passage.py

@@ -7,7 +7,7 @@ from collections.abc import Sequence
 
 import numpy as np
 import numpy.typing as npt
-from deeptime.markov.tools import analysis as msm_analysis
+from pydtmc import MarkovChain
 
 from ..engine.runtime import Trajectory
 from ..errors import AnalysisError
@@ -215,6 +215,26 @@ class PassageAnalysis(BaseAnalysis):
         returns = np.flatnonzero((signs == 0) | crossing)
         self.return_times_ = np.diff(self.times_[returns])
 
+    def _get_indices(self, states: Sequence[float] | None) -> list[int]:
+        """Return a set of states as the indices of the rows of the matrix."""
+        return [int(state) for state in self._get_states(states)]
+
+    def _run_committor(self) -> None:
+        """Compute the forward committor from the origin to the target states."""
+        chain = MarkovChain(self.matrix_)
+        origin, target = self._get_indices(self.origin), self._get_indices(self.target)
+        self.committor_ = np.asarray(chain.committor_probabilities('forward', origin, target), dtype=float)
+
+    def _run_mean_first_passage(self) -> None:
+        """Compute the mean first-passage time to the target states, from the origin in its stationary weights."""
+        times = MarkovChain(self.matrix_).first_passage_times_to('mean', self._get_indices(self.target))
+        if times is None:
+            error_msg = f'{type(self).__name__} needs a transition matrix with one stationary law, not a reducible one.'
+            raise AnalysisError(error_msg)
+        origin = self._get_indices(self.origin)
+        weights = MarkovAnalysis._stationary_distribution(self.matrix_)[origin]
+        self.mean_first_passage_time_ = float(weights @ times[origin] / weights.sum() * self.lag * self.dt)
+
     def _run(self, inputs: object = None) -> None:
         """Compute the passage of the kind."""
         if self.kind == 'first-passage':
@@ -224,12 +244,9 @@ class PassageAnalysis(BaseAnalysis):
         elif self.kind == 'return-times':
             self._run_returns()
         elif self.kind == 'committor':
-            origin, target = self._get_states(self.origin), self._get_states(self.target)
-            self.committor_ = np.asarray(msm_analysis.committor(self.matrix_, origin, target))
+            self._run_committor()
         else:
-            origin, target = self._get_states(self.origin), self._get_states(self.target)
-            time = msm_analysis.mfpt(self.matrix_, target, origin=origin, tau=self.lag)
-            self.mean_first_passage_time_ = float(time * self.dt)
+            self._run_mean_first_passage()
 
     @staticmethod
     def _rows(paths: npt.ArrayLike) -> Array:

{scikit_complexity-0.2.0 → scikit_complexity-0.3.0}/src/skcomplex/core/spaces/_network.py

@@ -135,7 +135,7 @@ class NetworkSpace(BaseSpace):
         if not isinstance(self.hyperedges, xgi.Hypergraph):
             return [tuple(hyperedge) for hyperedge in self.hyperedges]
         order = {node: number for number, node in enumerate(self.graph.nodes)}
-        members = self.hyperedges.edges.members()
+        members = self.hyperedges.edges.members(dtype=list)
         return [
             tuple(sorted(hyperedge, key=lambda node: order.get(node, len(order))))
             for hyperedge in members

{scikit_complexity-0.2.0 → scikit_complexity-0.3.0}/src/skcomplex/engine/viz/_rerun.py

@@ -4,8 +4,10 @@
 # License: MIT
 
 import math
+import os
 import re
 import sys
+import warnings
 from collections.abc import Callable, Iterator
 from pathlib import Path
 from typing import Literal
@@ -37,6 +39,7 @@ from ._scalars import ScalarsVisual
 from ._sites import SiteVisual
 
 _RENEWAL_MEMBERS = 20
+_VIEWER_FLUSH_SECONDS = 30.0
 _EXTRA = 'extra'
 _UNSAFE = re.compile(r'[^A-Za-z0-9_/.-]')
 _MAX_SERIES_PER_VIEW = 6
@@ -226,7 +229,10 @@ class RerunObserver(BaseObserver):
             self.recording_.save(self.save_path, default_blueprint=self.blueprint_)
             if self.blueprint_ is not None:
                 self.blueprint_.save(self.application_id, Path(self.save_path).with_suffix('.rbl'))
-        if self.spawn:
+        if self.spawn and self._display_is_missing():
+            warning_msg = 'The Rerun viewer needs a display, and this machine has none, so no viewer opens.'
+            warnings.warn(warning_msg, UserWarning, stacklevel=2)
+        elif self.spawn:
             rr.spawn(
                 executable_path=self._viewer_executable(),
                 recording=self.recording_,
@@ -241,6 +247,12 @@ class RerunObserver(BaseObserver):
                 self.recording_.log(group.path, rr.GraphEdges(edges, graph_type='undirected'), static=True)
         self.logged_frames_ = 0
 
+    @staticmethod
+    def _display_is_missing() -> bool:
+        """Return whether this is a Linux machine without a display, where the viewer exits and Rerun waits for it."""
+        names = ('DISPLAY', 'WAYLAND_DISPLAY', 'WAYLAND_SOCKET')
+        return sys.platform == 'linux' and not any(os.environ.get(name) for name in names)
+
     def _visual_of(self, element: CompiledElementSpec | CompiledAgentsSpec) -> BaseVisual:
         """Return the visual the spec of an element names, built with the options of the spec."""
         spec = element.visual
@@ -389,8 +401,15 @@ class RerunObserver(BaseObserver):
         self.logged_frames_ += 1
 
     def _release(self) -> None:
-        """Flush the recording."""
-        self.recording_.flush()
+        """Flush the recording, and warn after a while rather than wait forever for a viewer that cannot be reached."""
+        if not (self.spawn or self.connect):
+            self.recording_.flush()
+            return
+        try:
+            self.recording_.flush(timeout_sec=_VIEWER_FLUSH_SECONDS)
+        except RuntimeError as error:
+            warning_msg = f'The Rerun viewer did not receive the whole recording: {error}'
+            warnings.warn(warning_msg, UserWarning, stacklevel=2)
 
     def _log_extra(self, path: str, archetype: rr.AsComponents, *, static: bool = False) -> None:
         """Log an archetype of a subclass's own under `extra/<path>`, apart from the paths of the system's entities.

{scikit_complexity-0.2.0 → scikit_complexity-0.3.0}/src/skcomplex/models/physics/synchronization/_hypergraphs.py

@@ -144,7 +144,7 @@ def hypergraph_kuramoto(
     """
     hypergraph = _simplices(n_oscillators, links, triangles, seed)
     space = NetworkSpace(nx.complete_graph(n_oscillators), hyperedges=hypergraph)
-    sizes = [len(members) for members in hypergraph.edges.members()]
+    sizes = [len(members) for members in hypergraph.edges.members(dtype=list)]
     mean_links = max(PAIR * sizes.count(PAIR) / n_oscillators, 1.0)
     mean_triangles = max(3 * sizes.count(3) / n_oscillators, 1.0)
     rng = np.random.default_rng(seed + 1)

{scikit_complexity-0.2.0 → scikit_complexity-0.3.0}/src/skcomplex/models/social/spreading/_simplicial.py

@@ -23,7 +23,7 @@ TRIANGLE = 3
 def _simplicial_complex(n_nodes: int, links: float, triangles: float, seed: int) -> tuple[nx.Graph, list[tuple]]:
     """Return a random simplicial complex: random links, and random filled triangles whose sides join the links."""
     simplices = xgi.random_simplicial_complex(n_nodes, [links, triangles], seed=seed)
-    members = [tuple(sorted(edge)) for edge in simplices.edges.members()]
+    members = [tuple(sorted(edge)) for edge in simplices.edges.members(dtype=list)]
     graph = nx.Graph()
     graph.add_nodes_from(range(n_nodes))
     graph.add_edges_from(edge for edge in members if len(edge) == PAIR)

{scikit_complexity-0.2.0 → scikit_complexity-0.3.0}/tests/analysis/test_embedding.py

@@ -36,9 +36,9 @@ def _henon(size: int) -> np.ndarray:
 
 
 def test_embed_lorenz():
-    """Test that 20,000 samples of the Lorenz x every 0.01 give a delay between 0.10 and 0.20 and dimension 3."""
+    """Test that 20,000 samples of the Lorenz x every 0.01 give a delay between 0.10 and 0.25 and dimension 3."""
     embedding = _embedding('delay', _lorenz_states(28.0, 0.01, 200.0)[:20_000, 0], max_delay=60)
-    assert 0.10 <= embedding.delay_ * 0.01 <= 0.20
+    assert 0.10 <= embedding.delay_ * 0.01 <= 0.25
     assert embedding.dimension_ == 3
     assert embedding.points_.shape[1] == 3
     assert embedding.mutual_information_.size == 61

{scikit_complexity-0.2.0 → scikit_complexity-0.3.0}/tests/analysis/test_markov.py

@@ -18,6 +18,19 @@ def _markov(kind: str, source: object, **settings: object) -> MarkovAnalysis:
 
 
 THREE_STATES = np.asarray([[0.90, 0.08, 0.02], [0.04 / 0.3, 1 - 0.04 / 0.3 - 0.12, 0.12], [0.05, 0.18, 0.77]])
+FOUR_STATES = np.asarray(
+    [[0.90, 0.09, 0.01, 0.0], [0.08, 0.90, 0.02, 0.0], [0.0, 0.02, 0.90, 0.08], [0.01, 0.0, 0.09, 0.90]],
+)
+DOUBLE_WELL = np.asarray(
+    [
+        [0.8, 0.2, 0.0, 0.0, 0.0, 0.0],
+        [0.3, 0.5, 0.2, 0.0, 0.0, 0.0],
+        [0.0, 0.45, 0.5, 0.05, 0.0, 0.0],
+        [0.0, 0.0, 0.05, 0.5, 0.45, 0.0],
+        [0.0, 0.0, 0.0, 0.2, 0.5, 0.3],
+        [0.0, 0.0, 0.0, 0.0, 0.2, 0.8],
+    ],
+)
 
 
 def _chain(matrix: np.ndarray, steps: int, rng: np.random.Generator) -> np.ndarray:
@@ -94,6 +107,132 @@ def test_markov_state_model_double_well_on_two_domains():
         assert model.timescales_[0] == pytest.approx(1 / (1 / there + 1 / back), rel=0.2)
 
 
+@pytest.mark.parametrize(
+    ('settings', 'matrix', 'stationary', 'timescales'),
+    [
+        (
+            {'reversible': True},
+            [
+                [0.904124, 0.086266, 0.005074, 0.004535],
+                [0.081714, 0.896502, 0.021784, 0.0],
+                [0.003981, 0.018042, 0.898018, 0.079959],
+                [0.004589, 0.0, 0.103147, 0.892264],
+            ],
+            [0.231562, 0.244462, 0.295165, 0.228811],
+            [34.048475, 5.093107, 4.434706],
+        ),
+        (
+            {'reversible': True, 'lag': 3, 'dt': 0.5},
+            [
+                [0.755455, 0.214517, 0.017822, 0.012206],
+                [0.203109, 0.737574, 0.054408, 0.004909],
+                [0.013976, 0.045062, 0.750127, 0.190835],
+                [0.012347, 0.005245, 0.246176, 0.736233],
+            ],
+            [0.231485, 0.244487, 0.295194, 0.228834],
+            [17.354038, 2.529955, 2.224246],
+        ),
+        (
+            {'reversible': False},
+            [
+                [0.904124, 0.085727, 0.010149, 0.0],
+                [0.082225, 0.896502, 0.021272, 0.0],
+                [0.0, 0.018465, 0.898018, 0.083517],
+                [0.009178, 0.0, 0.098558, 0.892264],
+            ],
+            [0.231562, 0.244462, 0.295165, 0.228811],
+            [33.785728, 5.065865, 4.461684],
+        ),
+        (
+            {'reversible': False, 'lag': 3, 'dt': 0.5},
+            [
+                [0.755455, 0.213437, 0.028516, 0.002592],
+                [0.204132, 0.737574, 0.055226, 0.003068],
+                [0.00559, 0.044384, 0.750127, 0.199898],
+                [0.022072, 0.007212, 0.234484, 0.736233],
+            ],
+            [0.231485, 0.244487, 0.295194, 0.228834],
+            [17.223849, 2.520568, 2.236057],
+        ),
+    ],
+)
+def test_state_model_keeps_its_reference_values(
+    settings: dict[str, object],
+    matrix: list[list[float]],
+    stationary: list[float],
+    timescales: list[float],
+):
+    """Test the fits of a fixed path against the values recorded from the previous library."""
+    model = _markov('state-model', _chain(FOUR_STATES, 20_000, np.random.default_rng(0)), **settings)
+    assert model.states_.tolist() == [0, 1, 2, 3]
+    np.testing.assert_allclose(model.transition_matrix_, matrix, rtol=1e-3, atol=1e-6)
+    np.testing.assert_allclose(model.stationary_, stationary, rtol=1e-3)
+    np.testing.assert_allclose(model.timescales_, timescales, rtol=1e-3)
+
+
+def test_state_model_of_several_paths_keeps_its_reference_values():
+    """Test that the rows of two paths count together, against the recorded values."""
+    path = _chain(FOUR_STATES, 20_000, np.random.default_rng(0))
+    model = _markov('state-model', np.vstack([path[:10_000], path[10_000:]]))
+    np.testing.assert_allclose(model.stationary_, [0.231573, 0.244474, 0.29513, 0.228823], rtol=1e-3)
+    np.testing.assert_allclose(model.timescales_, [34.047193, 5.09301, 4.434383], rtol=1e-3)
+
+
+def test_state_model_keeps_the_largest_connected_set():
+    """Test that a transient state leaves the model and that a tie gives the later set, as recorded."""
+    transient = _markov('state-model', [3, 0, 1, 0, 1, 1, 0, 1, 0, 0, 1])
+    assert transient.states_.tolist() == [0, 1]
+    np.testing.assert_allclose(transient.transition_matrix_, [[0.2, 0.8], [0.75, 0.25]], rtol=1e-3)
+    np.testing.assert_allclose(transient.stationary_, [0.483871, 0.516129], rtol=1e-3)
+    np.testing.assert_allclose(transient.timescales_, [1.672697], rtol=1e-3)
+    tie = _markov('state-model', [0, 1, 0, 1, 0, 2, 3, 2, 3, 2], reversible=False)
+    assert tie.states_.tolist() == [2, 3]
+    assert tie.timescales_.tolist() == [np.inf]
+
+
+def test_state_model_finds_the_recorded_metastable_sets():
+    """Test the partition of a double-well chain and its timescales against the recorded values."""
+    model = _markov('state-model', _chain(DOUBLE_WELL, 20_000, np.random.default_rng(1)), n_metastable=2)
+    assert sorted(found.tolist() for found in model.metastable_sets_) == [[0, 1, 2], [3, 4, 5]]
+    np.testing.assert_allclose(model.timescales_, [82.644678, 2.623531, 2.207486, 0.557418, 0.467036], rtol=1e-3)
+
+
+def test_timescales_keep_their_reference_values():
+    """Test the timescales at every lag of both fits, and that a large number stops at the modes there are."""
+    path = _chain(FOUR_STATES, 20_000, np.random.default_rng(0))
+    reversible = _markov('timescales', path, lags=[1, 3], n_timescales=2, dt=0.5).timescales_
+    np.testing.assert_allclose(reversible, [[17.024238, 2.546553], [17.354038, 2.529955]], rtol=1e-3)
+    irreversible = _markov('timescales', path, lags=[1, 3], n_timescales=2, reversible=False).timescales_
+    np.testing.assert_allclose(irreversible, [[33.785728, 5.065865], [34.447698, 5.041137]], rtol=1e-3)
+    every = _markov('timescales', path, n_timescales=9).timescales_
+    np.testing.assert_allclose(every, [[34.048475, 5.093107, 4.434706]], rtol=1e-3)
+
+
+def test_state_model_needs_two_connected_states():
+    """Test that a path with no two connected states raises an error."""
+    with pytest.raises(AnalysisError, match='connected'):
+        _markov('state-model', [2, 2, 2])
+    with pytest.raises(AnalysisError, match='connected'):
+        _markov('state-model', [0, 1], reversible=False)
+
+
+def test_metastable_sets_of_every_number_of_sets():
+    """Test one set, one set per state, and too many sets, as recorded from the previous library."""
+    path = _chain(DOUBLE_WELL, 20_000, np.random.default_rng(1))
+    whole = _markov('state-model', path, n_metastable=1).metastable_sets_
+    assert [found.tolist() for found in whole] == [[0, 1, 2, 3, 4, 5]]
+    apart = _markov('state-model', path, n_metastable=6).metastable_sets_
+    assert [found.tolist() for found in apart] == [[0], [1], [2], [3], [4], [5]]
+    with pytest.raises(AnalysisError, match='sets'):
+        _markov('state-model', path, n_metastable=7)
+
+
+def test_metastable_sets_need_a_reversible_model():
+    """Test that metastable sets of a model without detailed balance raise an error."""
+    with pytest.raises(AnalysisError, match='reversible'):
+        MarkovAnalysis('state-model', n_metastable=2, reversible=False).check()
+
+
 def test_stationary_distribution_ehrenfest_urn_and_ring_walk():
     """Test the binomial law of the Ehrenfest urn and the spectral gap of the lazy walk on a cycle of 11 nodes."""
     balls = 20

{scikit_complexity-0.2.0 → scikit_complexity-0.3.0}/tests/analysis/test_passage.py

@@ -77,6 +77,46 @@ def test_hitting_probabilities_fixation_of_a_mutant():
     assert absorbed + fixed == pytest.approx(1, abs=0.01)
 
 
+def test_committor_and_mean_first_passage_time_keep_their_reference_values():
+    """Test a chain of four states, with sets, a lag, and a time step, against the recorded values."""
+    chain = np.asarray(
+        [[0.90, 0.09, 0.01, 0.0], [0.08, 0.90, 0.02, 0.0], [0.0, 0.02, 0.90, 0.08], [0.01, 0.0, 0.09, 0.90]],
+    )
+    one = _passage('committor', chain, origin=[0], target=[3]).committor_
+    np.testing.assert_allclose(one, [0.0, 0.166667, 0.833333, 1.0], rtol=1e-3, atol=1e-9)
+    two = _passage('committor', chain, origin=[0, 1], target=[3]).committor_
+    np.testing.assert_allclose(two, [0.0, 0.0, 0.8, 1.0], rtol=1e-3, atol=1e-9)
+    time = _passage('mean-first-passage', chain, origin=[0], target=[3]).mean_first_passage_time_
+    assert time == pytest.approx(96.428571, rel=1e-3)
+    both = _passage('mean-first-passage', chain, origin=[0, 1], target=[2, 3], lag=2, dt=0.5)
+    assert both.mean_first_passage_time_ == pytest.approx(65.959821, rel=1e-3)
+    overlap = _passage('mean-first-passage', chain, origin=[0, 3], target=[3]).mean_first_passage_time_
+    assert overlap == pytest.approx(49.876847, rel=1e-3)
+
+
+def test_committor_and_mean_first_passage_time_of_periodic_chains():
+    """Test a ring of four states, which never settles, and a chain of two states that swap."""
+    ring = np.roll(np.eye(4), 1, axis=1)
+    np.testing.assert_allclose(_passage('committor', ring, origin=[0], target=[2]).committor_, [0, 1, 1, 0], atol=1e-9)
+    assert _passage('mean-first-passage', ring, origin=[0], target=[2]).mean_first_passage_time_ == pytest.approx(2.0)
+    swap = [[0.0, 1.0], [1.0, 0.0]]
+    assert _passage('mean-first-passage', swap, origin=[0], target=[1]).mean_first_passage_time_ == pytest.approx(1.0)
+
+
+def test_committor_of_an_absorbing_walk():
+    """Test the committor of a walk absorbed at both ends, which is linear in the state."""
+    walk = [[1.0, 0.0, 0.0, 0.0], [0.5, 0.0, 0.5, 0.0], [0.0, 0.5, 0.0, 0.5], [0.0, 0.0, 0.0, 1.0]]
+    committor = _passage('committor', walk, origin=[0], target=[3]).committor_
+    np.testing.assert_allclose(committor, [0.0, 1 / 3, 2 / 3, 1.0], atol=1e-9)
+
+
+def test_mean_first_passage_time_of_a_reducible_chain_raises_an_error():
+    """Test that a chain with no single stationary law raises an error rather than give a time."""
+    walk = [[1.0, 0.0, 0.0, 0.0], [0.5, 0.0, 0.5, 0.0], [0.0, 0.5, 0.0, 0.5], [0.0, 0.0, 0.0, 1.0]]
+    with pytest.raises(AnalysisError, match='reducible'):
+        _passage('mean-first-passage', walk, origin=[0], target=[3])
+
+
 def test_committor_and_mean_first_passage_time_of_a_walk():
     """Test the committor of a lazy walk on a path of 5 states and its mean first-passage time."""
     walk = np.zeros((5, 5))

{scikit_complexity-0.2.0 → scikit_complexity-0.3.0}/tests/core/test_base.py

@@ -149,10 +149,13 @@ def _modules():
 
 
 def _hand_written(cls):
-    """Return the magic methods a class defines itself in source code, leaving out those dataclasses generate."""
+    """Return the magic methods a class defines itself in source code, leaving out those Python generates.
+
+    Dataclasses generate methods, and from Python 3.14 the annotations of a class compile to `__annotate_func__`.
+    """
     names = []
     for name, value in vars(cls).items():
-        if not (name.startswith('__') and name.endswith('__')) or not callable(value):
+        if not (name.startswith('__') and name.endswith('__')) or not callable(value) or name == '__annotate_func__':
             continue
         code = getattr(value, '__code__', None)
         if code is not None and code.co_filename.startswith(SOURCE):

{scikit_complexity-0.2.0 → scikit_complexity-0.3.0}/tests/engine/compile/test_compile.py

@@ -576,6 +576,7 @@ def test_compile_system_time_grows_linearly_with_interactions():
     assert _compile_time(800) <= 2.5 * _compile_time(400)
 
 
+@pytest.mark.benchmark
 def test_compile_group_time_does_not_grow_with_size():
     """Test that compiling 100000 members takes no longer than 10 members within a factor of 2."""
 

{scikit_complexity-0.2.0 → scikit_complexity-0.3.0}/tests/engine/compile/test_draw_lowering.py

@@ -490,6 +490,7 @@ def _elapsed(problem, rng):
     return min(elapsed)
 
 
+@pytest.mark.benchmark
 def test_compile_system_runs_compiled_chains_fast():
     """Test that 100000 two-state chains take less than 10 times a deterministic map of the same size."""