sofic 0.1.0__py3-none-any.whl

sofic/graph.py

@@ -0,0 +1,135 @@
+"""NetworkX-backed transition graph wrapper."""
+
+from __future__ import annotations
+
+from collections.abc import Hashable, Iterator
+from dataclasses import dataclass
+from typing import Any
+
+import networkx as nx
+
+# Sentinel for NFA epsilon transitions.
+EPSILON = object()
+
+# Node attribute keys.
+ATTR_EMISSION = "emission"
+ATTR_EMISSION_DIST = "emission_dist"
+ATTR_FUTURE_SYMBOL = "future_symbol"
+ATTR_OUTPUT = "output"
+
+# Edge attribute keys.
+ATTR_SYMBOL = "symbol"
+ATTR_PROB = "prob"
+ATTR_QUASIPROB = "quasiprob"
+ATTR_EMISSION_EDGE = "emission"
+ATTR_KIND = "kind"
+ATTR_STACK_SYMBOL = "stack_symbol"
+ATTR_HIER_STATE = "hier_state"
+ATTR_MULTIPLICITY = "multiplicity"
+
+# VPA edge kinds.
+KIND_CALL = "call"
+KIND_RETURN = "return"
+KIND_INTERNAL = "internal"
+
+
+@dataclass(frozen=True, slots=True)
+class Transition:
+    """One directed transition in a :class:`TransitionGraph`."""
+
+    source: Hashable
+    target: Hashable
+    key: int
+    data: dict[str, Any]
+
+
+class TransitionGraph:
+    """NetworkX-backed directed multigraph for sofic models.
+
+    States are nodes; transitions are edges with attribute dictionaries keyed by
+    module constants such as :data:`ATTR_PROB` and :data:`ATTR_EMISSION`.
+
+    Examples
+    --------
+    >>> from sofic.graph import TransitionGraph, ATTR_PROB
+    >>> g = TransitionGraph()
+    >>> g.add_state("A")
+    >>> g.add_transition("A", "A", **{ATTR_PROB: 1.0})
+    >>> len(list(g.transitions()))
+    1
+    """
+
+    __slots__ = ("_g",)
+
+    def __init__(self, graph: nx.MultiDiGraph | None = None) -> None:
+        self._g = graph if graph is not None else nx.MultiDiGraph()
+
+    @property
+    def nx(self) -> nx.MultiDiGraph:
+        return self._g
+
+    def add_state(self, state: Hashable, **attrs: Any) -> None:
+        self._g.add_node(state, **attrs)
+
+    def add_transition(self, source: Hashable, target: Hashable, **attrs: Any) -> int:
+        return self._g.add_edge(source, target, **attrs)
+
+    def states(self) -> Iterator[Hashable]:
+        yield from self._g.nodes
+
+    def transitions(self) -> Iterator[Transition]:
+        for source, target, key, data in self._g.edges(keys=True, data=True):
+            yield Transition(source=source, target=target, key=key, data=dict(data))
+
+    def copy(self) -> TransitionGraph:
+        return TransitionGraph(self._g.copy())
+
+    def has_state(self, state: Hashable) -> bool:
+        return self._g.has_node(state)
+
+    def state_attrs(self, state: Hashable) -> dict[str, Any]:
+        return dict(self._g.nodes[state])
+
+    def out_transitions(self, source: Hashable) -> Iterator[Transition]:
+        for _target in self._g.successors(source):
+            for key, data in self._g.get_edge_data(source, _target).items():
+                yield Transition(source=source, target=_target, key=key, data=dict(data))
+
+    def reverse(self) -> TransitionGraph:
+        """Return a graph with the same nodes/attrs and all edges transposed."""
+        reversed_graph = nx.MultiDiGraph()
+        for state, attrs in self._g.nodes(data=True):
+            reversed_graph.add_node(state, **dict(attrs))
+        for source, target, _key, data in self._g.edges(keys=True, data=True):
+            reversed_graph.add_edge(target, source, **dict(data))
+        return TransitionGraph(reversed_graph)
+
+    def forward_reachable(self, sources: set[Hashable] | frozenset[Hashable]) -> frozenset[Hashable]:
+        """States reachable along directed edges from ``sources``."""
+        from collections import deque
+
+        if not sources:
+            return frozenset()
+        seen = set(sources)
+        queue = deque(sources)
+        while queue:
+            state = queue.popleft()
+            for transition in self.out_transitions(state):
+                target = transition.target
+                if target not in seen:
+                    seen.add(target)
+                    queue.append(target)
+        return frozenset(seen)
+
+    def terminal_recurrent_states(self) -> frozenset[Hashable]:
+        """States in terminal strongly connected components (no exit to outside)."""
+        recurrent: set[Hashable] = set()
+        for component in nx.strongly_connected_components(self._g):
+            if not component:
+                continue
+            exits_component = any(
+                target not in component for source in component for _, target in self._g.out_edges(source)
+            )
+            if not exits_component:
+                recurrent.update(component)
+        return frozenset(recurrent)

sofic/indexing.py

@@ -0,0 +1,31 @@
+"""Dense state indexing for NumPy-backed algorithms."""
+
+from __future__ import annotations
+
+from collections.abc import Hashable, Iterable
+
+
+class StateIndex:
+    """Bidirectional mapping between hashable states and ``0..n-1`` indices."""
+
+    __slots__ = ("_states", "_index")
+
+    def __init__(self, states: Iterable[Hashable]) -> None:
+        self._states = tuple(dict.fromkeys(states))
+        self._index = {state: i for i, state in enumerate(self._states)}
+
+    def index(self, state: Hashable) -> int:
+        return self._index[state]
+
+    def state(self, i: int) -> Hashable:
+        return self._states[i]
+
+    @property
+    def states(self) -> tuple[Hashable, ...]:
+        return self._states
+
+    def __len__(self) -> int:
+        return len(self._states)
+
+    def __contains__(self, state: Hashable) -> bool:
+        return state in self._index

sofic/inference/__init__.py

@@ -0,0 +1,45 @@
+"""Inference algorithms for stochastic generators."""
+
+from sofic.inference import bayesian
+from sofic.inference.model_selection import (
+    ModelScores,
+    WAICResult,
+    compare_information_criteria,
+    count_free_parameters,
+    cross_validated_log_likelihood,
+    information_criterion,
+    rank_topological_epsilon_machines,
+    score_model,
+    waic,
+    waic_epsilon_machine,
+)
+from sofic.inference.spectral import (
+    SpectralInferenceError,
+    hankel_matrices,
+    learn_spectral_wfa,
+    project_to_epsilon_machine,
+    project_to_mealy,
+    project_to_nmachine,
+    spectral_singular_values,
+)
+
+__all__ = [
+    "bayesian",
+    "ModelScores",
+    "WAICResult",
+    "compare_information_criteria",
+    "count_free_parameters",
+    "cross_validated_log_likelihood",
+    "information_criterion",
+    "rank_topological_epsilon_machines",
+    "score_model",
+    "waic",
+    "waic_epsilon_machine",
+    "SpectralInferenceError",
+    "hankel_matrices",
+    "learn_spectral_wfa",
+    "project_to_epsilon_machine",
+    "project_to_mealy",
+    "project_to_nmachine",
+    "spectral_singular_values",
+]

sofic/inference/bayesian/__init__.py

@@ -0,0 +1,68 @@
+"""Bayesian inference for computational mechanics models.
+
+The default implementations use exact conjugate Dirichlet calculations.  PyMC
+support is available through ``as_pymc_model()`` methods and is imported only
+when requested.
+"""
+
+from sofic.inference.bayesian.comparison import ModelComparisonEM, ModelComparisonMC, ModelComparisonMC2
+from sofic.inference.bayesian.counts import (
+    BayesianInferenceError,
+    PathCountEM,
+    WordCountsMC,
+    pretty_symbol,
+    pretty_word,
+    split_word,
+)
+from sofic.inference.bayesian.diversity import (
+    PosteriorDiversityResult,
+    machine_diversity,
+    posterior_mean_word_distribution,
+    posterior_process_diversity,
+    process_identification_word_length,
+    word_distribution_to_pmf,
+)
+from sofic.inference.bayesian.epsilon import DirichletDistributionEM, EpsilonMachinePosterior, InferEM
+from sofic.inference.bayesian.hdp_hmm import HDPHMMPosterior, infer_hdp_hmm
+from sofic.inference.bayesian.markov import DirichletPriorMC, InferMC, MarkovChainPosterior
+from sofic.inference.bayesian.stack_hmm import (
+    DirichletDistributionStackHMM,
+    ModelComparisonStackHMM,
+    PathCountStackHMM,
+    StackHMMPosterior,
+)
+
+BayesianMCException = BayesianInferenceError
+BayesianEMException = BayesianInferenceError
+
+__all__ = [
+    "BayesianEMException",
+    "BayesianMCException",
+    "BayesianInferenceError",
+    "DirichletDistributionEM",
+    "DirichletDistributionStackHMM",
+    "DirichletPriorMC",
+    "EpsilonMachinePosterior",
+    "HDPHMMPosterior",
+    "infer_hdp_hmm",
+    "InferEM",
+    "InferMC",
+    "MarkovChainPosterior",
+    "ModelComparisonEM",
+    "ModelComparisonMC",
+    "ModelComparisonMC2",
+    "PosteriorDiversityResult",
+    "machine_diversity",
+    "posterior_mean_word_distribution",
+    "posterior_process_diversity",
+    "process_identification_word_length",
+    "word_distribution_to_pmf",
+    "ModelComparisonStackHMM",
+    "PathCountEM",
+    "PathCountStackHMM",
+    "StackHMMPosterior",
+    "WordCountsMC",
+    "pretty_symbol",
+    "pretty_word",
+    "split_word",
+]

sofic/inference/bayesian/comparison.py

@@ -0,0 +1,199 @@
+"""Bayesian model comparison utilities."""
+
+from __future__ import annotations
+
+from collections.abc import Iterable, Sequence
+from typing import TYPE_CHECKING, Any
+
+import numpy as np
+
+from sofic.generators.mealy import MealyHMM
+from sofic.inference.bayesian.counts import BayesianInferenceError, posterior_weights
+from sofic.inference.bayesian.markov import MarkovChainPosterior
+
+if TYPE_CHECKING:
+    from sofic.inference.bayesian.diversity import PosteriorDiversityResult
+
+
+class ModelComparisonMC:
+    """Compare Markov-chain orders using exact conjugate evidences."""
+
+    def __init__(
+        self,
+        alphabet: Sequence[Any],
+        data: Sequence[Any],
+        min_order: int,
+        max_order: int,
+        mc_prior: str = "uniform",
+        mo_prior: str = "uniform",
+    ):
+        if min_order < 0 or max_order < min_order:
+            raise BayesianInferenceError("invalid min/max Markov orders")
+        self.alphabet = tuple(alphabet)
+        self.min_order = int(min_order)
+        self.max_order = int(max_order)
+        self.markov_chain_prior = mc_prior
+        self.model_order_prior = mo_prior
+        self.mc_dict = {
+            order: MarkovChainPosterior(self.alphabet, data, order, prior_type=mc_prior)
+            for order in range(self.min_order, self.max_order + 1)
+        }
+
+    def log_evidence(self) -> dict[int, float]:
+        return {order: posterior.log_evidence() for order, posterior in sorted(self.mc_dict.items())}
+
+    def _log_prior_penalty(self, order: int) -> float:
+        if self.model_order_prior == "uniform":
+            return 0.0
+        if self.model_order_prior == "penalty":
+            a = len(self.alphabet)
+            return -float((a**order) * (a - 1))
+        raise BayesianInferenceError("unknown model-order prior")
+
+    def model_probabilities(self) -> dict[int, float]:
+        orders = sorted(self.mc_dict)
+        log_evidences = [self.mc_dict[order].log_evidence() + self._log_prior_penalty(order) for order in orders]
+        weights, _ = posterior_weights(orders, log_evidences)
+        return weights
+
+    def most_probable_model(self) -> MealyHMM:
+        probs = self.model_probabilities()
+        order = max(probs, key=probs.get)
+        return self.mc_dict[order].generate_mealy_hmm(method="PME")
+
+
+class ModelComparisonMC2(ModelComparisonMC):
+    """Compare an explicit list of Markov-chain orders."""
+
+    def __init__(
+        self,
+        alphabet: Sequence[Any],
+        data: Sequence[Any],
+        orders: int | Sequence[int],
+        mc_prior: str = "uniform",
+        mo_prior: str = "uniform",
+    ):
+        order_list = list(range(orders + 1)) if isinstance(orders, int) else sorted(int(order) for order in orders)
+        if not order_list or min(order_list) < 0:
+            raise BayesianInferenceError("invalid Markov orders")
+        self.alphabet = tuple(alphabet)
+        self.min_order = min(order_list)
+        self.max_order = max(order_list)
+        self.orders = order_list
+        self.markov_chain_prior = mc_prior
+        self.model_order_prior = mo_prior
+        self.mc_dict = {
+            order: MarkovChainPosterior(self.alphabet, data, order, prior_type=mc_prior) for order in order_list
+        }
+
+
+class ModelComparisonEM:
+    """Compare candidate unifilar topologies using epsilon-machine evidences."""
+
+    def __init__(
+        self,
+        machines: Iterable[MealyHMM],
+        data: Sequence[Any] | None = None,
+        beta: float = 0.0,
+        state_path: bool = False,
+    ):
+        from sofic.inference.bayesian.epsilon import EpsilonMachinePosterior
+
+        self.beta = float(beta)
+        self.data = data
+        self.em_dict: dict[str, EpsilonMachinePosterior] = {}
+        self.numMachines = 0
+        self.possMachines = 0
+        for index, machine in enumerate(machines):
+            self.numMachines += 1
+            posterior = EpsilonMachinePosterior(machine, data, state_path=state_path)
+            if posterior.log_evidence() > -np.inf:
+                self.possMachines += 1
+                name = getattr(machine, "name", None) or f"Machine-{index}"
+                self.em_dict[str(name)] = posterior
+        self.evidence_dictionary: dict[str, float] = {}
+        self.probs: dict[str, float] = {}
+        self.set_evidence = -np.inf
+
+    def log_evidence(self) -> dict[str, float]:
+        if not self.evidence_dictionary:
+            self.evidence_dictionary = {name: posterior.log_evidence() for name, posterior in self.em_dict.items()}
+        return dict(self.evidence_dictionary)
+
+    def model_probabilities(self) -> dict[str, float]:
+        if self.probs:
+            return dict(self.probs)
+        evidence = self.log_evidence()
+        names = list(evidence)
+        log_evidences = [evidence[name] - self.beta * len(self.em_dict[name].dirichlet.nodes) for name in names]
+        self.probs, self.set_evidence = posterior_weights(names, log_evidences)
+        return dict(self.probs)
+
+    def generate_sample(self, rng: np.random.Generator | None = None) -> tuple[Any, MealyHMM]:
+        generator = rng if rng is not None else np.random.default_rng()
+        probs = self.model_probabilities()
+        names = tuple(probs)
+        weights = np.array([probs[name] for name in names], dtype=float)
+        choice = names[int(generator.choice(len(names), p=weights))]
+        return self.em_dict[choice].generate_sample(rng=generator)
+
+    def information_criteria(self, *, include_initial: bool = False) -> dict[str, Any]:
+        """Score every candidate topology with classical information criteria.
+
+        Fits each topology's posterior-mean parameters and scores it against the
+        stored data with :func:`sofic.inference.model_selection.score_model`,
+        returning a mapping ``name -> ModelScores``. This is a frequentist
+        alternative to the Bayesian :meth:`model_probabilities` (AIC/AICc/BIC/MDL,
+        lower is better). Requires ``data`` to have been supplied.
+        """
+        from sofic.inference.model_selection import score_model
+
+        if self.data is None:
+            raise BayesianInferenceError("information criteria require data")
+        scores: dict[str, Any] = {}
+        for name, posterior in self.em_dict.items():
+            machine = posterior.posterior_mean_machine()
+            if machine is None:
+                continue
+            scores[name] = score_model(machine, self.data, include_initial=include_initial)
+        return scores
+
+    def best_by_information_criterion(self, criterion: str = "bic", *, include_initial: bool = False) -> str | None:
+        """Return the topology name minimizing ``criterion`` (``aic``/``aicc``/``bic``/``mdl``)."""
+        scores = self.information_criteria(include_initial=include_initial)
+        if not scores:
+            return None
+        return min(scores, key=lambda name: scores[name].value(criterion))
+
+    def machine_diversity(self) -> float:
+        """Shannon entropy (bits) of the topology posterior weights.
+
+        See :func:`~sofic.inference.bayesian.diversity.machine_diversity`.
+        """
+        from sofic.inference.bayesian.diversity import machine_diversity
+
+        return machine_diversity(self)
+
+    def process_diversity(
+        self,
+        *,
+        method: str = "posterior_mean",
+        n_samples: int = 500,
+        rng: np.random.Generator | None = None,
+        convention: str = "paz",
+        word_length: int | None = None,
+    ) -> PosteriorDiversityResult:
+        """Weighted JSD over length-:math:`L` word distributions in the posterior.
+
+        See :func:`~sofic.inference.bayesian.diversity.posterior_process_diversity`.
+        """
+        from sofic.inference.bayesian.diversity import posterior_process_diversity
+
+        return posterior_process_diversity(
+            self,
+            method=method,
+            n_samples=n_samples,
+            rng=rng,
+            convention=convention,
+            word_length=word_length,
+        )

sofic/inference/bayesian/counts.py

@@ -0,0 +1,219 @@
+"""Counting utilities for conjugate Bayesian process inference."""
+
+from __future__ import annotations
+
+from collections import defaultdict
+from collections.abc import Hashable, Iterable, Sequence
+from dataclasses import dataclass
+from typing import Any
+
+import numpy as np
+from scipy.special import gammaln
+
+from sofic.generators.mealy import MealyHMM
+from sofic.graph import ATTR_EMISSION
+
+
+class BayesianInferenceError(ValueError):
+    """Raised when Bayesian inference inputs are inconsistent."""
+
+
+def dirichlet_multinomial_log_evidence(
+    row_alpha: float,
+    row_count: float,
+    cells: Iterable[tuple[float, float]],
+) -> float:
+    """Log marginal likelihood contribution of one Dirichlet-multinomial row.
+
+    Computes ``lnΓ(A) - lnΓ(A + N) + Σ_i [lnΓ(α_i + n_i) - lnΓ(α_i)]`` for a row
+    with concentration ``row_alpha`` (``A``), observed total ``row_count`` (``N``)
+    and per-cell ``(alpha_i, count_i)`` pairs.
+    """
+    evidence = gammaln(row_alpha) - gammaln(row_alpha + row_count)
+    for alpha, count in cells:
+        evidence += gammaln(alpha + count) - gammaln(alpha)
+    return float(evidence)
+
+
+def posterior_weights(
+    keys: Sequence[Any],
+    log_evidences: Sequence[float],
+) -> tuple[dict[Any, float], float]:
+    """Normalize log-evidences into posterior weights via a softmax.
+
+    Returns ``(weights, log_norm)`` where ``weights[key]`` is the posterior
+    probability of each key and ``log_norm`` is the log-sum-exp normalizer
+    (``-inf`` when there are no keys). ``log_evidences`` should already include
+    any log-prior penalty terms.
+    """
+    from scipy.special import logsumexp
+
+    values = np.asarray(log_evidences, dtype=float)
+    if values.size == 0:
+        return {}, float("-inf")
+    log_norm = float(logsumexp(values))
+    weights = {key: float(np.exp(value - log_norm)) for key, value in zip(keys, values, strict=True)}
+    return weights, log_norm
+
+
+def pretty_symbol(symbol: Any) -> str:
+    """Format a symbol like cmpy's Bayesian inference utilities."""
+    if isinstance(symbol, str):
+        return symbol
+    try:
+        iterator = iter(symbol)
+    except TypeError:
+        return str(symbol)
+    return ":".join(map(str, iterator))
+
+
+def pretty_word(word: Sequence[Any]) -> str:
+    """Format a word as comma-separated symbols."""
+    return ",".join(pretty_symbol(symbol) for symbol in word)
+
+
+def split_word(word: Sequence[Any]) -> tuple[tuple[Any, ...], Any]:
+    """Split a word into ``(history, next_symbol)``."""
+    word = tuple(word)
+    return tuple(word[:-1]), word[-1]
+
+
+class WordCountsMC:
+    """Counts of length-``order`` contexts and following symbols."""
+
+    def __init__(self, data: Sequence[Any], order: int):
+        if order < 0:
+            raise ValueError("order must be nonnegative")
+        self.counts: defaultdict[tuple[tuple[Any, ...], Any], float] = defaultdict(float)
+        self.order = int(order)
+        self.add_counts_from(data)
+
+    def __str__(self) -> str:
+        if not self.counts:
+            return "No counts."
+        formatted = {
+            f"{pretty_word(context)} -> {pretty_symbol(symbol)}": (context, symbol) for context, symbol in self.counts
+        }
+        integer_counts = all(float(value).is_integer() for value in self.counts.values())
+        lines = []
+        for label in sorted(formatted):
+            value = self.counts[formatted[label]]
+            value_repr = str(int(value)) if integer_counts else str(value)
+            lines.append(f"n({label}) = {value_repr}")
+        return "\n".join(lines) + "\n"
+
+    def add_counts_from(self, data: Sequence[Any]) -> None:
+        data = tuple(data)
+        for index in range(0, max(0, len(data) - self.order)):
+            context = data[index : index + self.order]
+            symbol = data[index + self.order]
+            self.counts[(context, symbol)] += 1
+            self.counts[(context, "*")] += 1
+
+    def clear_word_counts(self) -> None:
+        self.counts = defaultdict(float)
+
+    def get_word_count(self, word: Sequence[Any]) -> float:
+        return self.counts.get(split_word(word), 0.0)
+
+    def set_word_count(self, word: Sequence[Any], value: float) -> None:
+        context, symbol = split_word(word)
+        previous = self.counts.get((context, symbol), 0.0)
+        self.counts[(context, symbol)] = float(value)
+        self.counts[(context, "*")] = self.counts.get((context, "*"), 0.0) - previous + float(value)
+
+
+def scan_unifilar_topology(
+    machine: MealyHMM,
+) -> tuple[dict[tuple[Hashable, Any], Hashable], list[tuple[Hashable, Any]]]:
+    """Scan ``machine`` transitions into a ``(trace, sorted_edges)`` topology.
+
+    ``trace`` maps each ``(source, emission)`` edge to its target; ``edges`` is the
+    sorted list of distinct edge keys. Raises :class:`BayesianInferenceError` if
+    two transitions share a ``(source, emission)`` key (non-unifilar topology).
+    """
+    trace: dict[tuple[Hashable, Any], Hashable] = {}
+    edges: list[tuple[Hashable, Any]] = []
+    for transition in machine.transitions():
+        symbol = transition.data.get(ATTR_EMISSION)
+        key = (transition.source, symbol)
+        if key in trace:
+            raise BayesianInferenceError("non-unifilar topology is not allowed")
+        trace[key] = transition.target
+        edges.append(key)
+    edges.sort(key=repr)
+    return trace, edges
+
+
+@dataclass(frozen=True)
+class PathTrace:
+    """Counts and terminal state for one assumed start state."""
+
+    counts: dict[Hashable | tuple[Hashable, Any], int]
+    last_state: Hashable | None
+    state_path: tuple[Hashable, ...] = ()
+
+
+class PathCountEM:
+    """State and edge counts for a unifilar candidate topology."""
+
+    def __init__(self, machine: MealyHMM, data: Sequence[Any] | None, state_path: bool = False):
+        self.machine = machine
+        self.collect_state_path = state_path
+        self.edges: list[tuple[Hashable, Any]] = []
+        self.nodes: list[Hashable] = list(machine.states())
+        self.trace: dict[tuple[Hashable, Any], Hashable] = {}
+        self.counts: dict[Hashable, PathTrace] = {}
+        self.possible_start_nodes: list[Hashable] = []
+        self._process_machine()
+        self._generate_counts(tuple(data or ()))
+
+    def _process_machine(self) -> None:
+        self.trace, self.edges = scan_unifilar_topology(self.machine)
+
+    def _generate_counts(self, data: tuple[Any, ...]) -> None:
+        for start in self.nodes:
+            state = start
+            counts: dict[Hashable | tuple[Hashable, Any], int] = {}
+            path = [state]
+            valid = True
+            for symbol in data:
+                counts[state] = counts.get(state, 0) + 1
+                edge = (state, symbol)
+                counts[edge] = counts.get(edge, 0) + 1
+                if edge not in self.trace:
+                    valid = False
+                    state = None
+                    path = []
+                    counts = {}
+                    break
+                state = self.trace[edge]
+                path.append(state)
+            if valid:
+                self.possible_start_nodes.append(start)
+            self.counts[start] = PathTrace(
+                counts=counts,
+                last_state=state,
+                state_path=tuple(path) if self.collect_state_path else (),
+            )
+
+    def get_edges(self) -> list[tuple[Hashable, Any]]:
+        return list(self.edges)
+
+    def get_nodes(self) -> list[Hashable]:
+        return list(self.nodes)
+
+    def get_edge_count(self, start_node: Hashable, edge: tuple[Hashable, Any]) -> int | None:
+        return self.counts[start_node].counts.get(edge)
+
+    def get_node_count(self, start_node: Hashable, node: Hashable) -> int | None:
+        return self.counts[start_node].counts.get(node)
+
+    def get_possible_start_nodes(self) -> list[Hashable]:
+        return list(self.possible_start_nodes)
+
+    def get_last_node(self, start_node: Hashable) -> Hashable | None:
+        return self.counts[start_node].last_state
+
+    def get_state_path(self, start_node: Hashable) -> tuple[Hashable, ...]:
+        return self.counts[start_node].state_path