scikit-complexity 0.2.0__py3-none-any.whl

skcomplex/analysis/_collapse.py

@@ -0,0 +1,318 @@
+"""Measure collapses of curves: finite-size scaling, aging, distributions scaled by age, and crossings of curves."""
+
+# Author: Georgios Douzas <gdouzas@icloud.com>
+# License: MIT
+
+import itertools
+from collections.abc import Mapping, Sequence
+
+import numpy as np
+from scipy import optimize
+
+from ..errors import AnalysisError
+from ..types import Array, DataKind
+from ._base import BaseAnalysis
+from .types import Source
+
+KINDS = ('scaling', 'aging', 'distribution', 'crossings')
+FITTED = ('critical', 'nu', 'exponent')
+SETTINGS = {
+    'scaling': {'parameters', 'critical', 'nu', 'exponent', 'fit'},
+    'aging': {'waiting', 'lags'},
+    'distribution': {'ratios'},
+    'crossings': {'parameters'},
+}
+"""Settings every kind reads, besides `kind`."""
+
+MIN_SIZES = 2
+GRID = 50
+
+
+class CollapseAnalysis(BaseAnalysis):
+    """Collapse of curves or distributions of several sizes or ages onto one, of one kind.
+
+    The kinds read the curves or the samples of every size or age:
+
+    - `'scaling'`: the finite-size scaling collapse of curves `y_L(p) = L^a f((p - p_c) L^(1/nu))` of every size
+      `L`, against the control `parameters`, with the names of `fit` among `'critical'`, `'nu'`, and `'exponent'`
+      fitted by minimizing the quality.
+    - `'aging'`: how far correlation curves of several waiting times stay apart against the lag and against
+      `tau / t_w`, from one curve per waiting time, as the two-time correlation of `CorrelationAnalysis` gives them.
+    - `'distribution'`: the densities `t P(tau, t)` of samples of `tau` at several ages `t` against `tau / t`, which
+      collapse under aging.
+    - `'crossings'`: where the curves of consecutive sizes cross against the control `parameters`, by linear
+      interpolation of their difference, such as the Binder cumulants of several lattice sizes at the critical point.
+
+    Args:
+        kind:
+            The collapse to compute, one of the kinds above.
+
+        parameters:
+            The control parameter values, shared by every curve of `'scaling'` and `'crossings'`.
+
+        critical:
+            The critical value, or the starting value of a fit.
+
+        nu:
+            The correlation length exponent, or the starting value of a fit.
+
+        exponent:
+            The exponent `a` of the scaled curves `y L^-a`, such as `gamma / nu` for a susceptibility, or the
+            starting value of a fit.
+
+        fit:
+            The names among `'critical'`, `'nu'`, and `'exponent'` to fit.
+
+        waiting:
+            The waiting times of the curves of `'aging'`.
+
+        lags:
+            The lags shared by every curve of `'aging'`.
+
+        ratios:
+            The edges of the bins of `tau / t`, or `None` for 20 logarithmic bins from 0.01 to 10.
+
+    Attributes:
+        values_:
+            The curve of every size, the curves of every waiting time, or the samples of every age.
+
+        labels_:
+            The size, waiting time, or age of every curve.
+
+        critical_:
+            The critical value used or fitted.
+
+        nu_:
+            The correlation length exponent used or fitted.
+
+        exponent_:
+            The exponent `a` used or fitted.
+
+        quality_:
+            The mean squared relative distance between the scaled curves, 0 for a perfect collapse.
+
+        time_spread_:
+            The largest difference between the curves against the lag, 0 without aging.
+
+        ratio_spread_:
+            The largest difference between the curves against `tau / t_w`, 0 under simple aging.
+
+        ratios_:
+            The centres of the bins of `tau / t`.
+
+        densities_:
+            One row per age of `t P(tau, t)` on the bins.
+
+        spread_:
+            The largest relative difference between the rows where every row is positive.
+
+        crossings_:
+            The first crossing of the curves of every pair of consecutive sizes, `nan` where they do not cross.
+
+    Examples:
+        >>> import numpy as np
+        >>> from skcomplex.analysis import CollapseAnalysis
+        >>> grid = np.linspace(-1, 1, 401)
+        >>> curves = {size: np.tanh(grid * size) for size in (8, 16, 32)}
+        >>> collapse = CollapseAnalysis(parameters=grid, critical=0.2, nu=1.5, fit=('critical', 'nu'))
+        >>> round(collapse.check().prepare(curves).run().nu_, 1)
+        1.0
+        >>> lags = np.linspace(1, 100, 100)
+        >>> curves = [np.exp(-lags / tw) for tw in (10, 100)]
+        >>> aging = CollapseAnalysis('aging', waiting=[10, 100], lags=lags).check().prepare(curves).run()
+        >>> round(aging.ratio_spread_, 2), aging.time_spread_ > 0.5
+        (0.0, True)
+        >>> curves = {8: [0.6, 0.5, 0.2], 16: [0.65, 0.5, 0.1]}
+        >>> CollapseAnalysis('crossings', parameters=[1.0, 2.0, 3.0]).check().prepare(curves).run().crossings_.tolist()
+        [2.0]
+    """
+
+    def __init__(
+        self,
+        kind: str = 'scaling',
+        *,
+        parameters: Sequence[float] | None = None,
+        critical: float | None = None,
+        nu: float | None = None,
+        exponent: float = 0.0,
+        fit: Sequence[str] = (),
+        waiting: Sequence[float] | None = None,
+        lags: Sequence[float] | None = None,
+        ratios: Sequence[float] | None = None,
+    ) -> None:
+        self.kind = kind
+        self.parameters = parameters
+        self.critical = critical
+        self.nu = nu
+        self.exponent = exponent
+        self.fit = fit
+        self.waiting = waiting
+        self.lags = lags
+        self.ratios = ratios
+
+    def _check(self) -> None:
+        """Validate the kind, the fitted names, the settings the kind needs, and that it reads every changed one."""
+        self._check_choice('kind', self.kind, KINDS)
+        for name in self.fit:
+            self._check_choice('fit', name, FITTED)
+        self._check_settings('kind', SETTINGS[self.kind])
+        if self.kind == 'scaling' and (self.parameters is None or self.critical is None or self.nu is None):
+            error_msg = f'{type(self).__name__} of kind scaling needs parameters, critical, and nu. Give all three.'
+            raise AnalysisError(error_msg)
+        if self.kind == 'crossings' and self.parameters is None:
+            error_msg = f'{type(self).__name__} of kind crossings needs the control parameter values. Set `parameters`.'
+            raise AnalysisError(error_msg)
+        if self.kind == 'aging' and (self.waiting is None or self.lags is None):
+            error_msg = f'{type(self).__name__} of kind aging needs waiting times and lags. Give both.'
+            raise AnalysisError(error_msg)
+
+    def _get_data_kind(self) -> DataKind:
+        """Return the ensemble kind, since every curve or sample comes from a run or a set of runs."""
+        return DataKind.ENSEMBLE
+
+    def _prepare(self, source: Source) -> None:
+        """Read the curves or the samples of every size or age, or the rows of an array of curves."""
+        if isinstance(source, Mapping):
+            self.values_: dict[float, Array] | Array = {
+                key: np.asarray(value, dtype=np.float64) for key, value in source.items()
+            }
+            self.labels_: list[float] = [float(key) for key in source]
+            return
+        self.values_ = np.asarray(source, dtype=np.float64)
+        self.labels_ = (
+            [float(item) for item in self.waiting] if self.waiting is not None else list(range(len(self.values_)))
+        )
+
+    def _curves_by_key(self) -> dict[float, Array]:
+        """Return the curves or the samples by size or age, which the kinds scaling and densities read."""
+        if not isinstance(self.values_, dict):
+            error_msg = f'{type(self).__name__} of kind {self.kind} reads a mapping from size or age to its values.'
+            raise AnalysisError(error_msg)
+        return self.values_
+
+    def _run(self, inputs: object = None) -> None:
+        """Compute the collapse of the kind."""
+        if self.kind in {'scaling', 'crossings'} and len(self.values_) < MIN_SIZES:
+            error_msg = (
+                f'{type(self).__name__} needs at least {MIN_SIZES} sizes, not {len(self.values_)}. Give more sizes.'
+            )
+            raise AnalysisError(error_msg)
+        if self.kind == 'scaling':
+            if self.critical is None or self.nu is None:
+                error_msg = f'{type(self).__name__} of kind scaling needs critical and nu. Give both.'
+                raise AnalysisError(error_msg)
+            start = {'critical': self.critical, 'nu': self.nu, 'exponent': self.exponent}
+            grid = np.asarray(self.parameters, dtype=np.float64)
+            values, self.quality_ = self._scaling_collapse(grid, self._curves_by_key(), start, self.fit)
+            self.critical_, self.nu_, self.exponent_ = values['critical'], values['nu'], values['exponent']
+        elif self.kind == 'aging':
+            if self.waiting is None:
+                error_msg = f'{type(self).__name__} of kind aging needs waiting times. Give them.'
+                raise AnalysisError(error_msg)
+            grid = np.asarray(self.lags, dtype=np.float64)
+            curves = np.asarray(self.values_, dtype=float)
+            self.time_spread_ = self._spread([(grid, row) for row in curves])
+            self.ratio_spread_ = self._spread(
+                [(grid / start, row) for start, row in zip(self.waiting, curves, strict=True)],
+            )
+        elif self.kind == 'crossings':
+            given = self.values_
+            rows = np.asarray([given[size] for size in sorted(given)]) if isinstance(given, dict) else given
+            self.crossings_ = self._crossings(np.asarray(self.parameters, dtype=np.float64), rows)
+        else:
+            edges = np.geomspace(0.01, 10, 21) if self.ratios is None else np.asarray(self.ratios, dtype=float)
+            self.densities_, self.spread_ = self._scaled_densities(self._curves_by_key(), edges)
+            self.ratios_ = np.sqrt(edges[1:] * edges[:-1])
+
+    @staticmethod
+    def _scaled(
+        grid: Array,
+        curves: Mapping[float, Array],
+        critical: float,
+        nu: float,
+        exponent: float,
+    ) -> list[tuple[Array, Array]]:
+        """Return every curve against `(p - p_c) L^(1/nu)` and scaled by `L^-exponent`."""
+        return [
+            ((grid - critical) * size ** (1 / nu), curve * float(size) ** (-exponent)) for size, curve in curves.items()
+        ]
+
+    @staticmethod
+    def _quality(scaled: list[tuple[Array, Array]]) -> float:
+        """Return the mean squared relative distance of every point to the other curves where they overlap."""
+        residuals = []
+        for (x, y), (u, v) in itertools.permutations(scaled, 2):
+            inside = (x >= u.min()) & (x <= u.max())
+            residuals.append((y[inside] - np.interp(x[inside], u, v)) ** 2)
+        joined = np.concatenate(residuals) if residuals else np.zeros(0)
+        if not joined.size:
+            return float('inf')
+        scale = np.mean(np.concatenate([y for _, y in scaled]) ** 2)
+        return float(joined.mean() / scale)
+
+    @staticmethod
+    def _scaling_collapse(
+        grid: Array,
+        curves: Mapping[float, Array],
+        values: dict[str, float],
+        fit: Sequence[str],
+    ) -> tuple[dict[str, float], float]:
+        """Return the critical value, `nu`, and the exponent, fitted by minimizing the quality, and the quality."""
+
+        def objective(free: Array) -> float:
+            """Return the quality with the fitted values replaced."""
+            chosen = {**values, **dict(zip(fit, free, strict=True))}
+            if chosen['nu'] <= 0:
+                return float('inf')
+            return CollapseAnalysis._quality(
+                CollapseAnalysis._scaled(grid, curves, chosen['critical'], chosen['nu'], chosen['exponent']),
+            )
+
+        values = dict(values)
+        if fit:
+            result = optimize.minimize(objective, [values[name] for name in fit], method='Nelder-Mead')
+            values.update(dict(zip(fit, (float(item) for item in result.x), strict=True)))
+        return values, CollapseAnalysis._quality(
+            CollapseAnalysis._scaled(grid, curves, values['critical'], values['nu'], values['exponent']),
+        )
+
+    @staticmethod
+    def _spread(curves: list[tuple[Array, Array]]) -> float:
+        """Return the largest difference between curves interpolated on the overlap of their abscissas."""
+        low = max(float(x.min()) for x, _ in curves)
+        high = min(float(x.max()) for x, _ in curves)
+        if low >= high:
+            return float('nan')
+        grid = np.linspace(low, high, GRID)
+        values = np.asarray([np.interp(grid, x, y) for x, y in curves])
+        return float(np.max(values.max(axis=0) - values.min(axis=0)))
+
+    @staticmethod
+    def _scaled_densities(samples: Mapping[float, Array], edges: Array) -> tuple[Array, float]:
+        """Return the densities `t P(tau, t)` of samples at every age against `tau / t`, and their largest spread."""
+        ages = sorted(samples)
+        densities = np.asarray(
+            [np.histogram(samples[age] / age, bins=edges)[0] / (samples[age].size * np.diff(edges)) for age in ages],
+        )
+        positive = np.all(densities > 0, axis=0)
+        spread = float('nan')
+        if positive.any():
+            kept = densities[:, positive]
+            spread = float(np.max((kept.max(axis=0) - kept.min(axis=0)) / kept.mean(axis=0)))
+        return densities, spread
+
+    @staticmethod
+    def _crossings(grid: Array, curves: Array) -> Array:
+        """Return the first crossing of every pair of consecutive curves, one per row, `nan` without one."""
+        crossings = []
+        for small, large in itertools.pairwise(curves):
+            difference = large - small
+            changes = np.flatnonzero(np.sign(difference[:-1]) * np.sign(difference[1:]) <= 0)
+            if not changes.size:
+                crossings.append(np.nan)
+                continue
+            index = int(changes[0])
+            left, right = difference[index], difference[index + 1]
+            share = left / (left - right) if left != right else 0.0
+            crossings.append(grid[index] + share * (grid[index + 1] - grid[index]))
+        return np.asarray(crossings, dtype=float)

skcomplex/analysis/_complexity.py

@@ -0,0 +1,129 @@
+"""Place series and fields on the complexity-entropy plane of their ordinal patterns."""
+
+# Author: Georgios Douzas <gdouzas@icloud.com>
+# License: MIT
+
+from collections.abc import Sequence
+
+import numpy as np
+import ordpy
+
+from ..errors import AnalysisError
+from ..types import DataKind
+from ._base import SNAPSHOT_DIMENSIONS, BaseAnalysis
+from ._entropy import TIES, EntropyAnalysis
+from .types import Source
+
+
+class ComplexityAnalysis(BaseAnalysis):
+    """Place of every series of a source, or of every frame of a field, on Rosso's complexity-entropy plane.
+
+    The entropy is the normalized permutation entropy of the ordinal patterns, and the complexity is that entropy times
+    the Jensen-Shannon divergence of the patterns from uniform ones, computed with `ordpy`. Noise has entropy near 1 and
+    complexity near 0, regular series both near 0, and chaos lies in between with high complexity.
+
+    Args:
+        variables:
+            The variables of a trajectory to read, or `None` for every scalar series, or the first field for a field.
+
+        dimension:
+            The length of the patterns of a series, or the window `(columns, rows)` of the patterns of a field.
+
+        delay:
+            The number of steps between the values of a pattern.
+
+        ties:
+            `'order'` to rank equal values by position, or `'random'` to rank them at random.
+
+        random_state:
+            The seed of the random ranks of equal values.
+
+    Attributes:
+        values_:
+            The series, one per column, or the frames of the field.
+
+        labels_:
+            The label of every series, or of the field.
+
+        entropy_:
+            The normalized permutation entropy of every series or frame.
+
+        complexity_:
+            The statistical complexity of every series or frame.
+
+        minimum_:
+            The curve of least complexity, one row of entropy and complexity per point.
+
+        maximum_:
+            The curve of largest complexity, one row of entropy and complexity per point.
+
+    Examples:
+        >>> import numpy as np
+        >>> from skcomplex.analysis import ComplexityAnalysis
+        >>> noise = np.random.default_rng(0).standard_normal(50_000)
+        >>> plane = ComplexityAnalysis(dimension=4).check().prepare(noise).run()
+        >>> plane.entropy_.round(2).tolist(), plane.complexity_.round(2).tolist()
+        ([1.0], [0.0])
+    """
+
+    def __init__(
+        self,
+        variables: Sequence[str] | None = None,
+        *,
+        dimension: int | tuple[int, int] = 6,
+        delay: int = 1,
+        ties: str = 'order',
+        random_state: int | None = None,
+    ) -> None:
+        self.variables = variables
+        self.dimension = dimension
+        self.delay = delay
+        self.ties = ties
+        self.random_state = random_state
+
+    def _check(self) -> None:
+        """Validate the ties, the pattern length or window, and the delay."""
+        if self.ties not in TIES:
+            error_msg = f'{type(self).__name__} has ties={self.ties!r}. Use one of {", ".join(TIES)}.'
+            raise AnalysisError(error_msg)
+        sizes = self.dimension if isinstance(self.dimension, tuple) else (self.dimension,)
+        if any(int(size) < 1 for size in sizes) or self.delay < 1:
+            error_msg = (
+                f'{type(self).__name__} has dimension={self.dimension!r} and delay={self.delay!r}. Use 1 or more.'
+            )
+            raise AnalysisError(error_msg)
+
+    def _get_data_kind(self) -> DataKind:
+        """Return the field kind for windows of a field, and the series kind otherwise."""
+        return DataKind.FIELD if isinstance(self.dimension, tuple) else DataKind.SERIES
+
+    def _prepare(self, source: Source) -> None:
+        """Read the series of the source as columns, or the frames of a field for windows."""
+        if self._get_data_kind() == DataKind.FIELD:
+            name = self.variables[0] if self.variables else None
+            frames = self._read_fields(source, name)
+            self.values_ = frames[None] if frames.ndim == SNAPSHOT_DIMENSIONS else frames
+            self.labels_ = [name or 'field']
+            return
+        series = self._read_series(source, self.variables)
+        self.values_ = series.values
+        self.labels_ = series.labels
+
+    def _run(self, inputs: object = None) -> None:
+        """Compute the place of every series or frame on the plane, and the bounds of the plane."""
+        dx, dy = (self.dimension, 1) if isinstance(self.dimension, int) else self.dimension
+        items = self.values_ if self._get_data_kind() == DataKind.FIELD else self.values_.T
+        places = [
+            ordpy.complexity_entropy(
+                EntropyAnalysis._break_ties(item, self.ties, self.random_state),
+                dx=dx,
+                dy=dy,
+                taux=self.delay,
+                tauy=self.delay,
+            )
+            for item in items
+        ]
+        self.entropy_ = np.asarray([entropy for entropy, _ in places], dtype=float)
+        self.complexity_ = np.asarray([complexity for _, complexity in places], dtype=float)
+        self.minimum_ = np.asarray(ordpy.minimum_complexity_entropy(dx=dx, dy=dy), dtype=float)
+        self.maximum_ = np.asarray(ordpy.maximum_complexity_entropy(dx=dx, dy=dy), dtype=float)

skcomplex/analysis/_computational_mechanics.py

@@ -0,0 +1,220 @@
+"""Reconstruct the ε-machine of a discrete series by causal-state splitting."""
+
+# Author: Georgios Douzas <gdouzas@icloud.com>
+# License: MIT
+
+from collections import Counter
+from collections.abc import Sequence
+
+import numpy as np
+from scipy import stats
+
+from ..errors import AnalysisError
+from ..types import DataKind, IntArray, IntTuple
+from ._base import BaseAnalysis
+from .types import Source
+
+
+class EpsilonMachineAnalysis(BaseAnalysis):
+    """Epsilon-machine of a discrete series reconstructed by causal-state splitting (CSSR).
+
+    Histories up to `max_length` symbols join the state whose law of the next symbol they share by a chi-square
+    test, and states are then split until their transitions are deterministic.
+
+    Args:
+        variables:
+            The variable of a trajectory to read, a list of one name, or `None` for the only scalar series.
+
+        max_length:
+            The longest history, kept well below the logarithm of the series length in the alphabet size.
+
+        significance:
+            The significance level of the test that splits a history from a state.
+
+    Attributes:
+        values_:
+            The series of symbols.
+
+        labels_:
+            The label of the series.
+
+        alphabet_:
+            The distinct symbols, whose positions are the codes of the histories and of the columns.
+
+        histories_:
+            The histories of every causal state, as codes of their symbols, oldest first.
+
+        transitions_:
+            The state reached from every state on every symbol, -1 for symbols a state never emits.
+
+        probabilities_:
+            The probability of every symbol from every state.
+
+        stationary_:
+            The fraction of time spent in every state.
+
+        statistical_complexity_:
+            The entropy of the stationary distribution of the causal states in bits.
+
+        entropy_rate_:
+            The mean entropy of the next symbol given the causal state in bits.
+
+    Examples:
+        >>> from skcomplex.analysis import EpsilonMachineAnalysis
+        >>> machine = EpsilonMachineAnalysis(max_length=3).check().prepare([0, 0, 1] * 300).run()
+        >>> len(machine.histories_), round(machine.statistical_complexity_, 3), round(machine.entropy_rate_, 3)
+        (3, 1.585, 0.0)
+    """
+
+    def __init__(
+        self,
+        variables: Sequence[str] | None = None,
+        *,
+        max_length: int = 3,
+        significance: float = 0.001,
+    ) -> None:
+        self.variables = variables
+        self.max_length = max_length
+        self.significance = significance
+
+    def _check(self) -> None:
+        """Validate the longest history and the significance level."""
+        if self.max_length < 1 or not 0 < self.significance < 1:
+            error_msg = (
+                f'{type(self).__name__} has max_length={self.max_length!r} and significance={self.significance!r}. '
+                'Use a longest history of 1 or more and a significance between 0 and 1.'
+            )
+            raise AnalysisError(error_msg)
+
+    def _get_data_kind(self) -> DataKind:
+        """Return the series kind."""
+        return DataKind.SERIES
+
+    def _prepare(self, source: Source) -> None:
+        """Read the one series of symbols of the source."""
+        series = self._read_series(source, self.variables)
+        if series.values.shape[1] != 1:
+            error_msg = (
+                f'{type(self).__name__} reads one series of symbols, but the source has {series.values.shape[1]}. '
+                'Select one with `variables`.'
+            )
+            raise AnalysisError(error_msg)
+        self.values_ = series.values[:, 0]
+        self.labels_ = series.labels
+
+    def _run(self, inputs: object = None) -> None:
+        """Reconstruct the causal states, their transitions, and their stationary distribution."""
+        alphabet, codes = np.unique(self.values_, return_inverse=True)
+        if not self.max_length < codes.size:
+            error_msg = f'The longest history must be shorter than the series of length {codes.size}. Lower max_length.'
+            raise AnalysisError(error_msg)
+        codes = codes.astype(np.int64)
+        size = alphabet.size
+        counts = [self._history_counts(codes, length, size) for length in range(self.max_length + 1)]
+        states = self._determinize(self._homogenize(counts, size, self.significance), counts[self.max_length])
+        index = {history: number for number, state in enumerate(states) for history in state}
+        pooled = np.asarray([self._pooled(state, counts) for state in states], dtype=float)
+        totals = pooled.sum(axis=1)
+        self.alphabet_ = alphabet
+        self.histories_ = tuple(tuple(state) for state in states)
+        self.transitions_ = np.asarray(
+            [self._transitions(state, counts[self.max_length], index) for state in states],
+            dtype=np.int64,
+        )
+        self.probabilities_ = pooled / totals[:, None]
+        self.stationary_ = totals / totals.sum()
+        self.statistical_complexity_ = float(stats.entropy(self.stationary_, base=2))
+        self.entropy_rate_ = float(self.stationary_ @ stats.entropy(self.probabilities_, base=2, axis=1))
+
+    @staticmethod
+    def _history_counts(codes: IntArray, length: int, size: int) -> dict[IntTuple, IntArray]:
+        """Return the counts of the next symbol after every observed history of a length, oldest symbol first."""
+        windows = np.lib.stride_tricks.sliding_window_view(codes, length + 1)
+        weights = size ** np.arange(length, -1, -1, dtype=np.int64)
+        table = np.bincount(windows @ weights, minlength=size ** (length + 1)).reshape(-1, size)
+        observed = np.flatnonzero(table.sum(axis=1))
+        return {
+            tuple(int(index // size ** (length - 1 - place) % size) for place in range(length)): table[index]
+            for index in observed
+        }
+
+    @staticmethod
+    def _is_same_law(first: IntArray, second: IntArray, significance: float) -> bool:
+        """Return whether two counts of next symbols come from one law by a chi-square test of homogeneity."""
+        table = np.vstack([first, second])
+        table = table[:, table.sum(axis=0) > 0]
+        if table.shape[1] <= 1:
+            return True
+        return bool(stats.chi2_contingency(table, correction=False).pvalue > significance)
+
+    @staticmethod
+    def _pooled(state: list[IntTuple], counts: list[dict[IntTuple, IntArray]]) -> IntArray:
+        """Return the counts of the next symbol pooled over the histories of a state."""
+        return np.sum([counts[len(history)][history] for history in state], axis=0)
+
+    @staticmethod
+    def _assign(
+        child: IntTuple,
+        states: list[list[IntTuple]],
+        parent: list[IntTuple],
+        counts: list[dict[IntTuple, IntArray]],
+        significance: float,
+    ) -> None:
+        """Add a history to its parent's state, to the first other state with its law, or to a new state."""
+        child_counts = counts[len(child)][child]
+        for state in [parent, *(state for state in states if state is not parent)]:
+            if EpsilonMachineAnalysis._is_same_law(
+                child_counts,
+                EpsilonMachineAnalysis._pooled(state, counts),
+                significance,
+            ):
+                state.append(child)
+                return
+        states.append([child])
+
+    @staticmethod
+    def _homogenize(counts: list[dict[IntTuple, IntArray]], size: int, significance: float) -> list[list[IntTuple]]:
+        """Return the states of histories with the same law of the next symbol, grown one past symbol at a time."""
+        states: list[list[IntTuple]] = [[()]]
+        for length in range(len(counts) - 1):
+            for state in list(states):
+                children = [(symbol, *history) for history in state if len(history) == length for symbol in range(size)]
+                for child in [child for child in children if child in counts[length + 1]]:
+                    EpsilonMachineAnalysis._assign(child, states, state, counts, significance)
+        longest = len(counts) - 1
+        kept = [[history for history in state if len(history) == longest] for state in states]
+        return [state for state in kept if state]
+
+    @staticmethod
+    def _successors(history: IntTuple, counts: IntArray, index: dict[IntTuple, int]) -> tuple[int, ...]:
+        """Return the state reached from a history on every symbol, -1 for symbols it never emits."""
+        return tuple(
+            index.get((*history[1:], symbol), -1) if count else -1 for symbol, count in enumerate(counts.tolist())
+        )
+
+    @staticmethod
+    def _determinize(states: list[list[IntTuple]], counts: dict[IntTuple, IntArray]) -> list[list[IntTuple]]:
+        """Return the states split until every symbol leads from a state to a single state."""
+        while True:
+            index = {history: number for number, state in enumerate(states) for history in state}
+            split: list[list[IntTuple]] = []
+            for state in states:
+                groups: dict[IntTuple, list[IntTuple]] = {}
+                for history in state:
+                    groups.setdefault(EpsilonMachineAnalysis._successors(history, counts[history], index), []).append(
+                        history,
+                    )
+                split.extend(groups.values())
+            if len(split) == len(states):
+                return split
+            states = split
+
+    @staticmethod
+    def _transitions(state: list[IntTuple], counts: dict[IntTuple, IntArray], index: dict[IntTuple, int]) -> list[int]:
+        """Return the state most histories of a state reach on every symbol, -1 for symbols none of them emits."""
+        signatures = [EpsilonMachineAnalysis._successors(history, counts[history], index) for history in state]
+        reached = [
+            Counter(signature[symbol] for signature in signatures if signature[symbol] >= 0)
+            for symbol in range(len(signatures[0]))
+        ]
+        return [found.most_common(1)[0][0] if found else -1 for found in reached]