sofic 0.1.0__py3-none-any.whl

sofic/generators/pfa.py

@@ -0,0 +1,100 @@
+"""Probabilistic finite automata."""
+
+from __future__ import annotations
+
+from collections.abc import Hashable, Sequence
+from typing import Any
+
+import numpy as np
+
+from sofic.generators.base import StochasticModel
+from sofic.generators.edge_emissions import validate_stochastic_edge_emissions
+from sofic.generators.mealy import MealyHMM
+from sofic.graph import ATTR_EMISSION, ATTR_PROB
+
+
+class ProbabilisticFiniteAutomaton(StochasticModel):
+    """String generator with joint symbol+probability on edges."""
+
+    output_alphabet: frozenset[Any]
+
+    def __init__(self, output_alphabet: frozenset[Any] | None = None, **kwargs: Any) -> None:
+        super().__init__(**kwargs)
+        self.output_alphabet = output_alphabet if output_alphabet is not None else frozenset()
+
+    def add_transition(self, source: Hashable, target: Hashable, symbol: Any, prob: float, **attrs: Any) -> int:
+        """Add an edge carrying joint output probability ``P(target, symbol | source)``."""
+        return self.graph.add_transition(
+            source,
+            target,
+            **{ATTR_EMISSION: symbol, ATTR_PROB: float(prob), **attrs},
+        )
+
+    def validate_stochastic(self) -> None:
+        super().validate_stochastic()
+        validate_stochastic_edge_emissions(
+            self,
+            alphabet=self.output_alphabet,
+            alphabet_name="output",
+            row_mass_label="outgoing masses",
+            negative_probability_label="negative probability",
+        )
+
+    def is_unifilar(self) -> bool:
+        """Return whether each state emits at most one edge per symbol."""
+        from sofic.properties import is_unifilar_emissions
+
+        return is_unifilar_emissions(self)
+
+    def to_mealy(self) -> MealyHMM:
+        from sofic.generators.conversions import pfa_to_mealy
+
+        return pfa_to_mealy(self)
+
+    def string_probability(self, word: Sequence[Any]) -> float:
+        if not word:
+            return sum(self.initial_distribution.values())
+        idx = self.reindex()
+        n = len(idx)
+        mass = np.zeros(n, dtype=float)
+        for state, prob in self.initial_distribution.items():
+            mass[idx.index(state)] = float(prob)
+        for symbol in word:
+            updated = np.zeros(n, dtype=float)
+            for transition in self.transitions():
+                if transition.data.get(ATTR_EMISSION) != symbol:
+                    continue
+                i = idx.index(transition.source)
+                j = idx.index(transition.target)
+                updated[j] += mass[i] * float(transition.data.get(ATTR_PROB, 0.0))
+            mass = updated
+        return float(mass.sum())
+
+    def words_of_length(self, length: int) -> dict[tuple[Any, ...], float]:
+        """Return output words of ``length`` and their probabilities."""
+        from sofic.generators.words import pfa_words_of_length
+
+        return pfa_words_of_length(self, length)
+
+    def sample(self, n: int, rng: np.random.Generator | None = None) -> list[Any]:
+        generator = rng if rng is not None else np.random.default_rng()
+        idx = self.reindex()
+        probs = np.array([self.initial_distribution.get(s, 0.0) for s in idx.states], dtype=float)
+        if probs.sum() <= 0.0:
+            return []
+        state = int(generator.choice(len(idx), p=probs / probs.sum()))
+        output: list[Any] = []
+        for _ in range(n):
+            outgoing = list(self.graph.out_transitions(idx.state(state)))
+            if not outgoing:
+                break
+            edge_probs = np.array([float(t.data.get(ATTR_PROB, 0.0)) for t in outgoing], dtype=float)
+            if edge_probs.sum() <= 0.0:
+                break
+            edge_probs /= edge_probs.sum()
+            edge = outgoing[int(generator.choice(len(outgoing), p=edge_probs))]
+            emission = edge.data.get(ATTR_EMISSION)
+            if emission is not None:
+                output.append(emission)
+            state = idx.index(edge.target)
+        return output

sofic/generators/prob.py

@@ -0,0 +1,291 @@
+"""Probability scalars: floats or sympy expressions."""
+
+from __future__ import annotations
+
+from collections.abc import Iterable, Sequence
+from typing import Any
+
+import numpy as np
+
+Prob = Any  # float | sympy.Expr
+
+
+def _sympy():
+    try:
+        import sympy
+    except ImportError as exc:  # pragma: no cover - optional dependency
+        raise ImportError("Symbolic probabilities require sympy. Install with: pip install sofic[symbolic]") from exc
+    return sympy
+
+
+def is_symbolic(value: Any) -> bool:
+    """Return whether ``value`` is an exact sympy expression (not a Python float).
+
+    Exact rationals / integers and expressions with free symbols are symbolic.
+    ``sympy.Float`` is treated as numeric and will be coerced to ``float``.
+    """
+    try:
+        import sympy
+    except ImportError:
+        return False
+    if not isinstance(value, sympy.Expr):
+        return False
+    return not isinstance(value, sympy.Float)
+
+
+def has_symbolic(values: Iterable[Any]) -> bool:
+    """Return whether any entry in ``values`` is symbolic."""
+    return any(is_symbolic(value) for value in values)
+
+
+def as_prob(value: Any) -> Prob:
+    """Coerce ``value`` to a stored probability: sympy Expr pass-through, else float.
+
+    Plain Python ``int`` values are left unchanged so they compose with sympy
+    without introducing ``Float`` coefficients (``0 + a`` stays exact).
+    """
+    if is_symbolic(value):
+        return value
+    if isinstance(value, bool):
+        return float(value)
+    if isinstance(value, int):
+        return value
+    try:
+        import sympy
+
+        if isinstance(value, sympy.Basic):
+            return float(value)
+    except ImportError:
+        pass
+    return float(value)
+
+
+def simplify_prob(value: Prob) -> Prob:
+    """Simplify a symbolic probability; return floats/ints unchanged."""
+    if not is_symbolic(value):
+        return value
+    sp = _sympy()
+    return sp.simplify(value)
+
+
+def is_zero(value: Prob, *, atol: float = 1e-15) -> bool:
+    """Return whether ``value`` is (numerically or symbolically) zero."""
+    if is_symbolic(value):
+        sp = _sympy()
+        return sp.simplify(value) == 0
+    if isinstance(value, int):
+        return value == 0
+    try:
+        return abs(float(value)) <= atol
+    except (TypeError, ValueError):
+        return False
+
+
+def is_positive_mass(value: Prob, *, atol: float = 1e-15) -> bool:
+    """Return whether ``value`` carries positive probability mass.
+
+    Symbolic expressions with free symbols are treated as positive unless they
+    simplify to a non-positive number (matching dit's free-symbol convention).
+    """
+    if is_zero(value, atol=atol):
+        return False
+    if is_symbolic(value):
+        sp = _sympy()
+        simplified = sp.simplify(value)
+        if simplified.free_symbols:
+            return simplified.is_nonpositive is not True
+        try:
+            return float(simplified) > atol
+        except (TypeError, ValueError):
+            return simplified != 0
+    return float(value) > atol
+
+
+def probs_equal(
+    left: Prob,
+    right: Prob,
+    *,
+    rtol: float = 1e-9,
+    atol: float = 1e-12,
+    constraints: SymbolConstraints | None = None,
+) -> bool:
+    """Equality for probability scalars (exact sympy simplify, else numeric close).
+
+    When ``constraints`` are supplied and either operand is symbolic, equality is
+    tested modulo the constraint ideal (see :class:`SymbolConstraints`), so
+    expressions that coincide only under a parameter's minimal polynomial are
+    recognized as equal.
+    """
+    if is_symbolic(left) or is_symbolic(right):
+        sp = _sympy()
+        if constraints is not None:
+            return constraints.equal(left, right)
+        return sp.simplify(sp.sympify(left) - sp.sympify(right)) == 0
+    return bool(np.isclose(float(left), float(right), rtol=rtol, atol=atol))
+
+
+def sum_probs(values: Iterable[Prob]) -> Prob:
+    """Sum probability scalars, preserving sympy when any term is symbolic."""
+    items = list(values)
+    if not items:
+        return 0
+    if has_symbolic(items):
+        sp = _sympy()
+        total = sp.Integer(0)
+        for value in items:
+            total += sp.sympify(value)
+        return simplify_prob(total)
+    return float(sum(float(value) for value in items))
+
+
+def row_sums_to_one(probs: Sequence[Prob], *, atol: float = 1e-9) -> bool:
+    """Return whether ``probs`` sum to one (exact sympy or numeric close)."""
+    if not probs:
+        return True
+    total = sum_probs(probs)
+    if is_symbolic(total) or has_symbolic(probs):
+        sp = _sympy()
+        # Free symbols: accept rows that are identically 1, else skip (dit-style).
+        if getattr(total, "free_symbols", None):
+            return True
+        return sp.simplify(sp.sympify(total) - 1) == 0
+    return bool(np.isclose(float(total), 1.0, atol=atol))
+
+
+def zeros(shape: tuple[int, ...], *, symbolic: bool = False) -> np.ndarray:
+    """Allocate a probability array (object dtype when ``symbolic``)."""
+    if symbolic:
+        sp = _sympy()
+        array = np.empty(shape, dtype=object)
+        array.fill(sp.Integer(0))
+        return array
+    return np.zeros(shape, dtype=float)
+
+
+def array_sum(array: np.ndarray) -> Prob:
+    """Sum an array, using Python reduction for object (sympy) arrays."""
+    flat = np.asarray(array).ravel()
+    if flat.dtype == object or has_symbolic(flat):
+        return sum_probs(flat.tolist())
+    return float(flat.sum())
+
+
+def matvec(row: np.ndarray, matrix: np.ndarray) -> np.ndarray:
+    """Row-vector times matrix, supporting object-dtype sympy entries."""
+    if row.dtype == object or matrix.dtype == object or has_symbolic(row) or has_symbolic(matrix.ravel()):
+        sp = _sympy()
+        n = matrix.shape[1]
+        out = np.empty(n, dtype=object)
+        for j in range(n):
+            total = sp.Integer(0)
+            for i in range(matrix.shape[0]):
+                total += sp.sympify(row[i]) * sp.sympify(matrix[i, j])
+            out[j] = simplify_prob(total)
+        return out
+    return row @ matrix
+
+
+def canonical_prob_key(value: Prob, constraints: SymbolConstraints | None = None) -> Any:
+    """Hash-stable key for partition signatures (simplified sympy or float).
+
+    With ``constraints`` the key is taken in the constraint residue field, so
+    two probabilities that are equal modulo the constraints share a key.
+    """
+    if constraints is not None:
+        return constraints.key(value)
+    if is_symbolic(value):
+        sp = _sympy()
+        return sp.srepr(sp.simplify(value))
+    return float(value)
+
+
+class SymbolConstraints:
+    """Algebraic side-relations (each ``expr == 0``) over probability symbols.
+
+    Used to compare symbolic probabilities modulo the ideal they generate, so
+    that states which coincide only under a parameter's minimal polynomial (for
+    example the Misiurewicz root ``a**3 - 2*a - 2 == 0``) are recognized as
+    equal when de-duplicating beliefs or merging causal states.
+
+    When the relations reduce to a single univariate polynomial in one symbol,
+    equality and keys are computed exactly in the residue field
+    ``Q[s] / (minpoly)`` via ``p * q^{-1} mod minpoly``.  Otherwise a
+    Groebner-basis ideal-membership test (with a plain ``simplify`` fallback) is
+    used for equality, and the simplified ``srepr`` for keys.
+    """
+
+    def __init__(self, relations: Iterable[Any]) -> None:
+        sp = _sympy()
+        rels = tuple(sp.sympify(relation) for relation in relations)
+        self.relations = rels
+        symbols: set[Any] = set()
+        for relation in rels:
+            symbols |= relation.free_symbols
+        self._symbols = tuple(sorted(symbols, key=str))
+        self._var: Any | None = None
+        self._minpoly: Any | None = None
+        if len(rels) == 1 and len(self._symbols) == 1:
+            var = self._symbols[0]
+            try:
+                self._minpoly = sp.Poly(rels[0], var, domain=sp.QQ)
+                self._var = var
+            except sp.PolynomialError:
+                self._minpoly = None
+                self._var = None
+
+    def __repr__(self) -> str:
+        return f"SymbolConstraints({list(self.relations)!r})"
+
+    def __eq__(self, other: Any) -> bool:
+        return isinstance(other, SymbolConstraints) and self.relations == other.relations
+
+    def __hash__(self) -> int:
+        return hash(self.relations)
+
+    def _residue_key(self, value: Prob) -> tuple[Any, ...] | None:
+        """Residue-field representative coefficients, or ``None`` if unavailable."""
+        if self._minpoly is None or self._var is None:
+            return None
+        if value.free_symbols - {self._var}:
+            return None
+        sp = _sympy()
+        from sympy.polys.polyerrors import NotInvertible
+
+        try:
+            num, den = sp.fraction(sp.together(value))
+            num_poly = sp.Poly(num, self._var, domain=sp.QQ)
+            den_poly = sp.Poly(den, self._var, domain=sp.QQ)
+            den_inv = sp.invert(den_poly, self._minpoly)
+            rep = sp.rem((num_poly * den_inv).as_expr(), self._minpoly.as_expr(), self._var)
+            coeffs = sp.Poly(rep, self._var, domain=sp.QQ).all_coeffs()
+        except (sp.PolynomialError, NotInvertible, ValueError, ZeroDivisionError):
+            return None
+        return tuple(coeffs)
+
+    def key(self, value: Prob) -> Any:
+        """Canonical, hashable key equal for probabilities equal modulo the ideal."""
+        if not is_symbolic(value):
+            return float(value)
+        residue = self._residue_key(value)
+        if residue is not None:
+            return ("mod", residue)
+        return canonical_prob_key(value)
+
+    def equal(self, left: Prob, right: Prob) -> bool:
+        """Return whether ``left`` and ``right`` are equal modulo the constraints."""
+        sp = _sympy()
+        left_residue = self._residue_key(sp.sympify(left)) if is_symbolic(left) else None
+        right_residue = self._residue_key(sp.sympify(right)) if is_symbolic(right) else None
+        if left_residue is not None and right_residue is not None:
+            return left_residue == right_residue
+        diff = sp.sympify(left) - sp.sympify(right)
+        if self.relations:
+            try:
+                num = sp.numer(sp.together(diff))
+                basis = sp.groebner(self.relations, *self._symbols, order="lex")
+                _, remainder = sp.reduced(sp.expand(num), basis, *self._symbols)
+                if sp.simplify(remainder) == 0:
+                    return True
+            except (sp.PolynomialError, ValueError, ZeroDivisionError):
+                pass
+        return sp.simplify(diff) == 0

sofic/generators/process_equivalence.py

@@ -0,0 +1,207 @@
+"""Finite-state process equivalence for HMM presentations.
+
+The algorithm follows the sufficient history/future word-list construction used
+by CMPy, based on Dan Upper's finite-dimensional process-equivalence test.
+"""
+
+from __future__ import annotations
+
+from collections import deque
+from collections.abc import Hashable, Mapping, Sequence
+from dataclasses import dataclass, field
+from typing import Any
+
+import numpy as np
+
+from sofic.generators.base import HiddenMarkovModel
+from sofic.generators.hmm_inference import _emission_transition_tensors_from_mealy
+from sofic.generators.words import _start_vector
+
+_DEFAULT_RTOL = 1e-9
+_DEFAULT_ATOL = 1e-12
+
+
+def is_equal_process(
+    g1: HiddenMarkovModel,
+    g2: HiddenMarkovModel,
+    *,
+    start1: Hashable | Mapping[Hashable, float] | Sequence[float] | np.ndarray | None = None,
+    start2: Hashable | Mapping[Hashable, float] | Sequence[float] | np.ndarray | None = None,
+    rtol: float | None = None,
+    atol: float | None = None,
+) -> bool:
+    """Return whether two finite HMMs generate the same word process.
+
+    The test compares finite bases for the history and future spaces rather
+    than brute-force enumerating all words up to a fixed cutoff.
+    """
+    if set(g1.observation_alphabet) != set(g2.observation_alphabet):
+        return False
+
+    rtol = _DEFAULT_RTOL if rtol is None else float(rtol)
+    atol = _DEFAULT_ATOL if atol is None else float(atol)
+
+    hf1 = _HistoryFutureWordList.from_hmm(g1, start=start1)
+    hf2 = _HistoryFutureWordList.from_hmm(g2, start=start2)
+
+    history_words = _sorted_words(set(hf1.history_word_list()) | set(hf2.history_word_list()))
+    future_words = _sorted_words(set(hf1.future_word_list()) | set(hf2.future_word_list()))
+
+    if not _compare_future_probabilities(hf1, hf2, future_words, rtol=rtol, atol=atol):
+        return False
+    if not _compare_conditional_tables(hf1, hf2, history_words, future_words, rtol=rtol, atol=atol):
+        return False
+
+    one_step_future_words = set(future_words)
+    for word in future_words:
+        for symbol in hf1.alphabet:
+            one_step_future_words.add((symbol,) + word)
+    extended_future_words = _sorted_words(one_step_future_words)
+    return _compare_conditional_tables(hf1, hf2, history_words, extended_future_words, rtol=rtol, atol=atol)
+
+
+@dataclass
+class _HistoryFutureWordList:
+    alphabet: tuple[Any, ...]
+    matrices: dict[Any, np.ndarray]
+    start: np.ndarray
+    _word_matrices: dict[tuple[Any, ...], np.ndarray] = field(default_factory=dict)
+    _future_words: list[tuple[Any, ...]] | None = None
+    _history_words: list[tuple[Any, ...]] | None = None
+
+    @classmethod
+    def from_hmm(
+        cls,
+        hmm: HiddenMarkovModel,
+        *,
+        start: Hashable | Mapping[Hashable, float] | Sequence[float] | np.ndarray | None = None,
+    ) -> _HistoryFutureWordList:
+        mealy = hmm.to_mealy()
+        pi, matrices = _emission_transition_tensors_from_mealy(mealy)
+        return cls(
+            alphabet=tuple(sorted(mealy.observation_alphabet, key=repr)),
+            matrices=matrices,
+            start=_start_vector(mealy, pi, start),
+        )
+
+    @property
+    def dimension(self) -> int:
+        return len(self.start)
+
+    def word_matrix(self, word: tuple[Any, ...]) -> np.ndarray:
+        if not self._word_matrices:
+            self._word_matrices[()] = np.eye(self.dimension, dtype=float)
+        cached = self._word_matrices.get(word)
+        if cached is not None:
+            return cached
+        if not word:
+            return self._word_matrices[()]
+
+        prefix = word[:-1]
+        prefix_matrix = self.word_matrix(prefix)
+        symbol_matrix = self.matrices.get(word[-1])
+        if symbol_matrix is None:
+            matrix = np.zeros((self.dimension, self.dimension), dtype=float)
+        else:
+            matrix = prefix_matrix @ symbol_matrix
+        self._word_matrices[word] = matrix
+        return matrix
+
+    def future_vector(self, word: tuple[Any, ...]) -> np.ndarray:
+        return self.word_matrix(word) @ np.ones(self.dimension, dtype=float)
+
+    def history_vector(self, word: tuple[Any, ...]) -> np.ndarray:
+        vector = self.start @ self.word_matrix(word)
+        total = float(vector.sum())
+        if total != 0.0:
+            vector = vector / total
+        return vector
+
+    def future_word_list(self) -> list[tuple[Any, ...]]:
+        if self._future_words is not None:
+            return list(self._future_words)
+
+        queue: deque[tuple[Any, ...]] = deque([()])
+        words: list[tuple[Any, ...]] = []
+        basis: list[np.ndarray] = []
+        rank = 0
+        while queue:
+            word = queue.popleft()
+            candidate = self.future_vector(word)
+            matrix = np.vstack([*basis, candidate]) if basis else np.asarray([candidate])
+            new_rank = np.linalg.matrix_rank(matrix)
+            if new_rank <= rank:
+                continue
+            rank = int(new_rank)
+            basis.append(candidate)
+            words.append(word)
+            for symbol in self.alphabet:
+                queue.append((symbol,) + word)
+
+        self._future_words = _sorted_words(words)
+        return list(self._future_words)
+
+    def history_word_list(self) -> list[tuple[Any, ...]]:
+        if self._history_words is not None:
+            return list(self._history_words)
+
+        queue: deque[tuple[Any, ...]] = deque([()])
+        words: list[tuple[Any, ...]] = []
+        basis: list[np.ndarray] = []
+        rank = 0
+        while queue:
+            word = queue.popleft()
+            candidate = self.history_vector(word)
+            matrix = np.vstack([*basis, candidate]) if basis else np.asarray([candidate])
+            new_rank = np.linalg.matrix_rank(matrix)
+            if new_rank <= rank:
+                continue
+            rank = int(new_rank)
+            basis.append(candidate)
+            words.append(word)
+            for symbol in self.alphabet:
+                queue.append(word + (symbol,))
+
+        self._history_words = _sorted_words(words)
+        return list(self._history_words)
+
+    def future_matrix(self, words: Sequence[tuple[Any, ...]]) -> np.ndarray:
+        if not words:
+            return np.zeros((self.dimension, 0), dtype=float)
+        return np.column_stack([self.future_vector(word) for word in words])
+
+    def history_matrix(self, words: Sequence[tuple[Any, ...]]) -> np.ndarray:
+        if not words:
+            return np.zeros((0, self.dimension), dtype=float)
+        return np.vstack([self.history_vector(word) for word in words])
+
+
+def _compare_future_probabilities(
+    hf1: _HistoryFutureWordList,
+    hf2: _HistoryFutureWordList,
+    future_words: Sequence[tuple[Any, ...]],
+    *,
+    rtol: float,
+    atol: float,
+) -> bool:
+    probs1 = hf1.start @ hf1.future_matrix(future_words)
+    probs2 = hf2.start @ hf2.future_matrix(future_words)
+    return bool(np.allclose(probs1, probs2, rtol=rtol, atol=atol))
+
+
+def _compare_conditional_tables(
+    hf1: _HistoryFutureWordList,
+    hf2: _HistoryFutureWordList,
+    history_words: Sequence[tuple[Any, ...]],
+    future_words: Sequence[tuple[Any, ...]],
+    *,
+    rtol: float,
+    atol: float,
+) -> bool:
+    table1 = hf1.history_matrix(history_words) @ hf1.future_matrix(future_words)
+    table2 = hf2.history_matrix(history_words) @ hf2.future_matrix(future_words)
+    return bool(np.allclose(table1, table2, rtol=rtol, atol=atol))
+
+
+def _sorted_words(words: Sequence[tuple[Any, ...]] | set[tuple[Any, ...]]) -> list[tuple[Any, ...]]:
+    return sorted(words, key=lambda word: (len(word), tuple(repr(symbol) for symbol in word)))

sofic/generators/quasi_inference.py

@@ -0,0 +1,74 @@
+"""Matrix operations for quasi-stochastic generators."""
+
+from __future__ import annotations
+
+from collections.abc import Sequence
+from typing import Any
+
+import numpy as np
+
+from sofic.exceptions import QuasiStochasticValidationError
+from sofic.generators.base import QuasiStochasticModel
+from sofic.graph import ATTR_EMISSION, ATTR_QUASIPROB
+
+
+def transition_matrices(model: QuasiStochasticModel) -> dict[Any, np.ndarray]:
+    idx = model.reindex()
+    n = len(idx)
+    matrices: dict[Any, np.ndarray] = {}
+    for transition in model.transitions():
+        emission = transition.data.get(ATTR_EMISSION)
+        if emission is None:
+            continue
+        matrix = matrices.setdefault(emission, np.zeros((n, n), dtype=float))
+        i = idx.index(transition.source)
+        j = idx.index(transition.target)
+        matrix[i, j] += float(transition.data.get(ATTR_QUASIPROB, 0.0))
+    return matrices
+
+
+def stationary_quasidistribution(model: QuasiStochasticModel) -> np.ndarray:
+    idx = model.reindex()
+    n = len(idx)
+    if n == 0:
+        return np.array([], dtype=float)
+
+    combined = np.zeros((n, n), dtype=float)
+    for matrix in transition_matrices(model).values():
+        combined += matrix
+
+    distribution = np.zeros(n, dtype=float)
+    for state, mass in model.initial_quasidistribution.items():
+        distribution[idx.index(state)] = float(mass)
+
+    if distribution.sum() <= 0.0:
+        distribution = np.full(n, 1.0 / n, dtype=float)
+
+    for _ in range(10_000):
+        updated = distribution @ combined
+        if np.allclose(updated, distribution, rtol=1e-10, atol=1e-12):
+            distribution = updated
+            break
+        distribution = updated
+
+    total = distribution.sum()
+    if abs(total) <= 0.0:
+        raise QuasiStochasticValidationError("failed to compute stationary quasidistribution")
+    return distribution / total
+
+
+def word_probability(model: QuasiStochasticModel, word: Sequence[Any]) -> float:
+    idx = model.reindex()
+    n = len(idx)
+    pi = np.zeros(n, dtype=float)
+    for state, mass in model.initial_quasidistribution.items():
+        pi[idx.index(state)] = float(mass)
+    ones = np.ones(n, dtype=float)
+    matrices = transition_matrices(model)
+    result = pi
+    for symbol in word:
+        matrix = matrices.get(symbol)
+        if matrix is None:
+            return 0.0
+        result = result @ matrix
+    return float(result @ ones)