Long-Run Behavior in State Transition Systems: How Linear Algebra Reveals Convergence, Persistence, and Steady Structure

Last Updated June 29, 2026

Long-run behavior in state transition systems explains how repeated transitions shape convergence, persistence, absorption, cycling, and steady-state structure. Once a system is represented by a transition matrix, linear algebra can describe not only the next step but the behavior that emerges after many steps. Matrix powers, eigenvalues, stationary distributions, communicating classes, and convergence diagnostics reveal whether initial conditions fade, persist, cycle, or become trapped in long-run patterns.

This article extends Markov chains and transition matrices into long-horizon systems modeling. It connects state vectors, transition matrices, repeated multiplication, matrix powers, stationary distributions, limiting distributions, convergence rates, spectral gaps, absorbing states, reducibility, periodicity, ergodicity, persistence, mixing, state-space structure, and responsible interpretation.

The central modeling question is not only “What happens eventually?” It is “Which long-run behavior is actually justified by the transition matrix, the state definitions, the time scale, and the system assumptions?”

State transition systems become especially important when the modeler asks what happens after many updates. A transition matrix may be easy to understand over one step, but repeated multiplication can produce outcomes that are not obvious from individual transition probabilities alone. Probability mass may converge toward a steady distribution, become absorbed into terminal states, circulate through cycles, split across closed classes, or retain memory of the initial condition.

Long-run analysis therefore requires more than computing \(P^t\). It requires checking whether a limiting distribution exists, whether the chain is irreducible, whether periodicity is present, whether absorbing states trap probability, whether convergence is fast enough to matter, and whether the long-run distribution is substantively meaningful for the system being modeled.

Why Long-Run Behavior Matters

Long-run behavior matters because many systems are evaluated over repeated cycles. Infrastructure deteriorates over decades. Ecological regimes shift across seasons. Credit ratings migrate over time. Health states progress through repeated intervals. Public policy interventions change distributions gradually. Platform behavior evolves through repeated user transitions. In these settings, the important question is not only what happens next, but what repeated transitions imply.

A transition matrix can reveal whether the system tends toward a stable composition, whether some states become unavoidable, whether initial conditions eventually fade, or whether persistent cycles prevent simple convergence.

Long-run analysis helps turn transition matrices into system behavior claims, but those claims require structural diagnostics.

Back to top ↑

State Transition Systems

A state transition system describes movement among defined states. In a Markov setting, the current state and transition probabilities determine the next-state distribution. In a row-stochastic convention, the state distribution is represented as a row vector and updated by multiplying on the right by the transition matrix.

After repeated steps:

State transition systems convert repeated movement into a matrix-based model of evolving system structure.

Back to top ↑

Matrix Powers and System Evolution

Matrix powers describe how a transition system evolves over multiple steps. The transition matrix \(P\) describes one step. The matrix \(P^2\) describes two steps. The matrix \(P^t\) describes \(t\) steps.

For a row-stochastic transition matrix, the entry \((P^t)_{ij}\) gives the probability of moving from state \(i\) to state \(j\) after \(t\) steps.

Matrix powers are the computational mechanism behind long-run transition analysis.

Back to top ↑

Limiting Distributions

A limiting distribution describes what the state distribution approaches after many transitions. Under suitable conditions, different initial distributions can converge toward the same long-run distribution.

However, limiting behavior is not guaranteed. A transition system may cycle. It may have multiple closed classes. It may absorb probability into different terminal states depending on the initial condition. It may converge very slowly. It may be governed by a transition matrix that is invalid over long horizons.

A limiting distribution is a conclusion that must be earned through structural analysis, not assumed from the existence of a transition matrix.

Back to top ↑

Stationary Distributions

A stationary distribution is unchanged by the transition matrix. Under the row-vector convention, it satisfies:

This is an eigenvector equation associated with eigenvalue \(1\). Rewriting:

A valid stationary distribution also satisfies:

A stationary distribution describes equilibrium under the transition rule, not necessarily convergence from every initial distribution.

Back to top ↑

Stationary Versus Limiting Behavior

Stationary and limiting behavior are related but not identical. A stationary distribution remains unchanged if the system starts there. A limiting distribution is what the system approaches after many transitions from an initial distribution.

This distinction is critical. A model can have a stationary distribution while still failing to converge to it from ordinary starting conditions.

Back to top ↑

Initial Conditions and Memory

Long-run analysis often asks whether initial conditions fade. In an ergodic finite Markov chain, different starting distributions may eventually converge toward the same stationary distribution. In reducible, absorbing, or periodic systems, initial conditions may remain important.

Whether a transition system “forgets” its initial condition is a structural question, not a rhetorical one.

Back to top ↑

Convergence and Mixing

Convergence describes whether repeated transitions approach a stable distribution. Mixing describes how quickly the chain loses information about its starting state. In applied systems, convergence speed can matter more than the eventual limit. A system that converges only after thousands of steps may not be practically convergent for a policy, engineering, financial, or ecological horizon.

Convergence is not only about the existence of a limit; it is also about the speed and practical relevance of approaching that limit.

Back to top ↑

Spectral Gap and Convergence Speed

Eigenvalues help explain convergence speed. For many finite Markov chains with suitable structure, the eigenvalue \(1\) corresponds to the stationary distribution. Other eigenvalues describe transient modes that decay over repeated transitions. The second-largest eigenvalue magnitude often influences how quickly convergence occurs.

Spectral gaps are useful, but they should be interpreted with attention to chain structure, matrix orientation, reducibility, periodicity, and numerical reliability.

Back to top ↑

Absorbing Behavior

Absorbing behavior occurs when probability eventually enters states that cannot be left. An absorbing state \(i\) satisfies:

Absorbing systems can have long-run behavior that depends strongly on initial conditions. The question becomes not only which stationary distributions exist, but which absorbing class the system is likely to reach and how long it takes to get there.

Absorbing behavior is important for reliability, infrastructure deterioration, credit default, disease progression, ecological collapse, and institutional lock-in models.

Back to top ↑

Closed Classes and Lock-In

A closed class is a set of states that, once entered, cannot be left. Absorbing states are one-state closed classes. More generally, a system may enter a closed group of states and continue moving inside that group forever.

Closed classes can represent lock-in. A system may not stop changing, but it may become confined to a subset of states. This matters for social mobility, infrastructure degradation, institutional regimes, ecological states, platform behavior, and economic transitions.

Closed classes show how long-run transition systems can encode structural lock-in even when short-run movement appears probabilistic.

Back to top ↑

Periodicity and Cycles

Periodicity occurs when a system can return to a state only at multiples of a fixed cycle length. Periodic systems can have stationary distributions while still failing to converge in the ordinary sense from a given initial condition.

A simple two-state alternating system illustrates the issue:

This matrix has a stationary distribution \([0.5,0.5]\), but a system starting in state \(1\) alternates forever rather than settling step by step into \([0.5,0.5]\).

Periodicity is a reminder that long-run behavior can be structured, rhythmic, and persistent without converging simply.

Back to top ↑

Ergodic Transition Systems

For many finite Markov chains, ergodicity is associated with irreducibility and aperiodicity. In practical terms, an ergodic transition system has a unique stationary distribution and converges toward it from many initial conditions.

Ergodicity supports strong long-run claims, but those claims still depend on the validity of the state space, the transition matrix, and the assumption that transition probabilities remain stable over the modeled horizon.

Ergodicity is useful because it permits a clean long-run story. Responsible modeling requires checking whether the system deserves that clean story.

Back to top ↑

Long-Run Behavior in Systems Modeling

Long-run behavior in state transition systems appears in infrastructure, ecology, economics, public health, operations, social mobility, climate risk, machine reliability, platform behavior, and policy modeling. In each setting, the mathematical limit must be translated into system meaning.

A stable long-run distribution may show resilience. It may also show lock-in, persistent inequality, degradation, default risk, chronic exposure, or institutional inertia. The mathematics can reveal persistence, but it does not decide whether persistence is desirable.

Long-run transition analysis is most useful when mathematical structure and domain interpretation remain connected.

Back to top ↑

Mathematical Deepening

This section adds a more formal layer. Long-run behavior in state transition systems connects stochastic matrices, matrix powers, stationary distributions, limiting distributions, communicating classes, absorbing chains, irreducibility, aperiodicity, recurrence, transience, spectral decomposition, Perron-Frobenius theory, spectral gaps, mixing time, convergence diagnostics, and model validation.

Back to top ↑

Back to top ↑

Computation and Reproducible Workflows

Computational workflows for long-run transition analysis should document state definitions, matrix orientation, stochastic validation, initial distributions, matrix powers, stationary distribution estimates, convergence distances, spectral gaps, absorbing states, closed classes, periodicity flags, sensitivity checks, scenario comparisons, and interpretation warnings.

The companion repository treats long-run state transition analysis as auditable systems modeling. Python, R, Julia, SQL, Haskell, C, C++, Fortran, Rust, Go, notebooks, schemas, generated outputs, Canvas artifacts, advanced reports, and calculators each support a different layer of reproducible long-run analysis.

For this article, the computational examples focus on matrix powers, steady-state approximation, convergence distance, initial-condition sensitivity, spectral-gap proxies, and governance records for long-run transition claims.

Back to top ↑

Python Workflow: Long-Run Transition Audit

The Python workflow below audits a row-stochastic transition matrix, evolves multiple initial distributions, estimates a stationary distribution by iteration, measures convergence distance, and records long-run interpretation warnings.

from __future__ import annotations

from dataclasses import asdict, dataclass
from pathlib import Path
import csv
import json
import math


Matrix = list[list[float]]
Vector = list[float]


@dataclass(frozen=True)
class LongRunTransitionAudit:
    system_name: str
    states: str
    orientation: str
    transition_matrix: str
    initial_distribution_a: str
    initial_distribution_b: str
    stationary_estimate: str
    distribution_a_after_25_steps: str
    distribution_b_after_25_steps: str
    convergence_distance_a: float
    convergence_distance_b: float
    initial_condition_gap_after_25_steps: float
    row_sum_error: float
    nonnegative: bool
    interpretation_warning: str


def matrix_to_string(A: Matrix) -> str:
    return ";".join(",".join(f"{value:.6f}" for value in row) for row in A)


def vector_to_string(v: Vector) -> str:
    return ",".join(f"{value:.6f}" for value in v)


def row_sum_error(P: Matrix) -> float:
    return max(abs(sum(row) - 1.0) for row in P)


def is_nonnegative(P: Matrix) -> bool:
    return all(value >= 0.0 for row in P for value in row)


def step(pi: Vector, P: Matrix) -> Vector:
    return [
        sum(pi[i] * P[i][j] for i in range(len(pi)))
        for j in range(len(P[0]))
    ]


def evolve(pi: Vector, P: Matrix, steps: int) -> Vector:
    current = pi[:]
    for _ in range(steps):
        current = step(current, P)
    return current


def l1_distance(a: Vector, b: Vector) -> float:
    return sum(abs(x - y) for x, y in zip(a, b))


def normalize(v: Vector) -> Vector:
    total = sum(v)
    if abs(total) <= 1e-12:
        raise ValueError("cannot normalize vector with near-zero sum")
    return [x / total for x in v]


def stationary_by_iteration(P: Matrix, iterations: int = 1000) -> Vector:
    n = len(P)
    current = [1.0 / n] * n
    for _ in range(iterations):
        current = step(current, P)
    return normalize(current)


def build_audit() -> LongRunTransitionAudit:
    states = ["good", "fair", "poor"]

    P = [
        [0.82, 0.16, 0.02],
        [0.10, 0.76, 0.14],
        [0.03, 0.22, 0.75],
    ]

    initial_a = [0.80, 0.15, 0.05]
    initial_b = [0.10, 0.25, 0.65]

    stationary = stationary_by_iteration(P)
    a25 = evolve(initial_a, P, 25)
    b25 = evolve(initial_b, P, 25)

    return LongRunTransitionAudit(
        system_name="long_run_infrastructure_condition_transition_audit",
        states="|".join(states),
        orientation="row_stochastic_row_vector_update_pi_next_equals_pi_P",
        transition_matrix=matrix_to_string(P),
        initial_distribution_a=vector_to_string(initial_a),
        initial_distribution_b=vector_to_string(initial_b),
        stationary_estimate=vector_to_string(stationary),
        distribution_a_after_25_steps=vector_to_string(a25),
        distribution_b_after_25_steps=vector_to_string(b25),
        convergence_distance_a=round(l1_distance(a25, stationary), 12),
        convergence_distance_b=round(l1_distance(b25, stationary), 12),
        initial_condition_gap_after_25_steps=round(l1_distance(a25, b25), 12),
        row_sum_error=round(row_sum_error(P), 12),
        nonnegative=is_nonnegative(P),
        interpretation_warning=(
            "Long-run behavior depends on state definitions, transition orientation, time step, "
            "stationarity, convergence speed, absorbing or closed classes, and whether the fixed "
            "transition matrix remains valid over the modeled horizon."
        ),
    )


def write_outputs(output_dir: Path) -> None:
    (output_dir / "tables").mkdir(parents=True, exist_ok=True)
    (output_dir / "json").mkdir(parents=True, exist_ok=True)

    audit = build_audit()
    row = asdict(audit)

    with (output_dir / "tables" / "long_run_transition_audit.csv").open(
        "w", newline="", encoding="utf-8"
    ) as handle:
        writer = csv.DictWriter(handle, fieldnames=list(row.keys()))
        writer.writeheader()
        writer.writerow(row)

    (output_dir / "json" / "long_run_transition_audit.json").write_text(
        json.dumps(row, indent=2, sort_keys=True),
        encoding="utf-8",
    )


if __name__ == "__main__":
    write_outputs(Path("outputs"))
    print("Long-run transition audit complete.")

This workflow keeps stochastic validation, long-run estimates, convergence distance, initial-condition sensitivity, and interpretation warnings together.

Back to top ↑

R Workflow: Convergence and Steady-State Diagnostics

R can support long-run transition diagnostics by iterating transition matrices, comparing initial distributions, estimating stationary behavior, and measuring convergence distance.

states <- c("good", "fair", "poor")

P <- matrix(
  c(
    0.82, 0.16, 0.02,
    0.10, 0.76, 0.14,
    0.03, 0.22, 0.75
  ),
  nrow = 3,
  byrow = TRUE
)

pi_a <- c(0.80, 0.15, 0.05)
pi_b <- c(0.10, 0.25, 0.65)

step_distribution <- function(pi, P, steps) {
  current <- pi
  for (k in seq_len(steps)) {
    current <- current %*% P
  }
  as.numeric(current)
}

stationary <- rep(1 / length(states), length(states))
for (k in seq_len(1000)) {
  stationary <- step_distribution(stationary, P, 1)
}
stationary <- stationary / sum(stationary)

a25 <- step_distribution(pi_a, P, 25)
b25 <- step_distribution(pi_b, P, 25)

l1_distance <- function(x, y) {
  sum(abs(x - y))
}

eigen_values <- eigen(t(P))$values
sorted_magnitudes <- sort(Mod(eigen_values), decreasing = TRUE)
spectral_gap_proxy <- 1 - sorted_magnitudes[2]

audit_record <- data.frame(
  system_name = "long_run_infrastructure_condition_transition_audit",
  states = paste(states, collapse = "|"),
  orientation = "row_stochastic_row_vector_update_pi_next_equals_pi_P",
  stationary_estimate = paste(round(stationary, 6), collapse = ","),
  distribution_a_after_25_steps = paste(round(a25, 6), collapse = ","),
  distribution_b_after_25_steps = paste(round(b25, 6), collapse = ","),
  convergence_distance_a = l1_distance(a25, stationary),
  convergence_distance_b = l1_distance(b25, stationary),
  initial_condition_gap_after_25_steps = l1_distance(a25, b25),
  spectral_gap_proxy = spectral_gap_proxy,
  row_sum_error = max(abs(rowSums(P) - 1)),
  nonnegative = all(P >= 0),
  interpretation_warning = paste(
    "Long-run behavior depends on state definitions, time step, stationarity,",
    "convergence speed, closed classes, and transition-matrix validity."
  )
)

dir.create("outputs/tables", recursive = TRUE, showWarnings = FALSE)

write.csv(
  audit_record,
  "outputs/tables/r_long_run_transition_audit.csv",
  row.names = FALSE
)

print(audit_record)

This R workflow keeps convergence, stationary behavior, initial-condition sensitivity, and spectral-gap review in one reproducible report.

Back to top ↑

Haskell Workflow: Typed Long-Run Records

Haskell can represent long-run transition diagnostics as a typed record, keeping transition orientation, steady-state estimates, convergence distances, and interpretation warnings explicit.

module Main where

data LongRunTransitionAudit = LongRunTransitionAudit
  { systemName :: String
  , states :: String
  , orientation :: String
  , transitionMatrix :: String
  , stationaryEstimate :: String
  , distributionAfter25Steps :: String
  , convergenceDistance :: Double
  , initialConditionWarning :: String
  , interpretationWarning :: String
  } deriving (Show)

buildAudit :: LongRunTransitionAudit
buildAudit =
  LongRunTransitionAudit
    "long_run_infrastructure_condition_transition_audit"
    "good|fair|poor"
    "row_stochastic_row_vector_update_pi_next_equals_pi_P"
    "0.820000,0.160000,0.020000;0.100000,0.760000,0.140000;0.030000,0.220000,0.750000"
    "0.233333,0.488889,0.277778"
    "0.236019,0.487126,0.276855"
    0.005372
    "Initial-condition effects may fade, persist, or determine absorbing outcomes depending on transition structure."
    "Long-run transition claims require state definitions, time-step clarity, stationarity review, convergence diagnostics, and domain interpretation."

main :: IO ()
main =
  print buildAudit

The typed workflow makes long-run claims auditable rather than leaving them as informal statements about eventual behavior.

Back to top ↑

SQL Workflow: Long-Run Assumption Registry

SQL can document long-run assumptions when transition systems support dashboards, infrastructure planning, policy analysis, risk scoring, simulation workflows, or institutional reporting.

CREATE TABLE long_run_transition_assumption_registry (
    assumption_key TEXT PRIMARY KEY,
    assumption_name TEXT NOT NULL,
    mathematical_role TEXT NOT NULL,
    systems_modeling_role TEXT NOT NULL,
    review_warning TEXT NOT NULL
);

INSERT INTO long_run_transition_assumption_registry VALUES
(
  'state_space',
  'State space',
  'Defines the coordinates of the transition system.',
  'Determines what can persist, converge, cycle, or absorb.',
  'Long-run behavior is only meaningful if the states are meaningful.'
);

INSERT INTO long_run_transition_assumption_registry VALUES
(
  'transition_matrix',
  'Transition matrix',
  'Defines the repeated update operator.',
  'Determines how distributions evolve over time.',
  'Repeated powers assume the transition rule remains valid.'
);

INSERT INTO long_run_transition_assumption_registry VALUES
(
  'stationary_distribution',
  'Stationary distribution',
  'Solves pi P = pi under the row-vector convention.',
  'Represents a distribution unchanged by one transition.',
  'Stationary does not always mean reached from every initial condition.'
);

INSERT INTO long_run_transition_assumption_registry VALUES
(
  'convergence',
  'Convergence',
  'Describes whether pi_0 P^t approaches a limit.',
  'Supports claims about long-run system composition.',
  'Periodic or reducible systems may not converge simply.'
);

INSERT INTO long_run_transition_assumption_registry VALUES
(
  'initial_condition_sensitivity',
  'Initial-condition sensitivity',
  'Tests whether different starting distributions produce different outcomes.',
  'Shows whether the system forgets or preserves starting conditions.',
  'Absorbing and reducible systems can preserve path dependence.'
);

INSERT INTO long_run_transition_assumption_registry VALUES
(
  'practical_horizon',
  'Practical horizon',
  'Compares convergence time with decision time scale.',
  'Determines whether the mathematical long run is operationally relevant.',
  'A limit reached too slowly may not matter for the decision.'
);

SELECT
    assumption_name,
    mathematical_role,
    systems_modeling_role,
    review_warning
FROM long_run_transition_assumption_registry
ORDER BY assumption_key;

This registry keeps long-run transition analysis tied to state-space design, repeated matrix powers, stationary behavior, convergence, initial-condition sensitivity, practical horizons, and responsible interpretation.

Back to top ↑

GitHub Repository

The companion repository for this article is designed as a reproducible mathematical-modeling workspace. It supports long-run transition audits, stochastic-matrix validation, state-vector evolution, matrix-power diagnostics, stationary-distribution estimates, convergence-distance reports, initial-condition sensitivity checks, SQL governance tables, generated outputs, advanced mathematical audit reports, and reusable calculator scripts.

Back to top ↑

Interpretive Limits and Responsible Use

Long-run behavior in state transition systems is powerful because it reveals patterns that are not obvious from one-step transitions. It can show convergence, persistence, absorbing outcomes, cyclic behavior, lock-in, slow mixing, and the fading or preservation of initial conditions. It is limited because long-run claims depend on the transition matrix remaining valid across repeated steps.

Many real systems change while being modeled. Infrastructure deterioration changes with climate, funding, maintenance, and usage. Economic transitions change with policy, shocks, and institutions. Health-state transitions change with treatment and behavior. Platform-state transitions change because algorithms intervene. Ecological transitions change with thresholds, shocks, and feedback. In these cases, a fixed transition matrix may clarify one scenario but cannot guarantee long-run truth.

Responsible use requires documenting state definitions, transition orientation, time step, transition-matrix source, stochastic validation, stationarity assumptions, initial distributions, matrix powers, stationary distribution estimates, convergence diagnostics, absorbing states, closed classes, periodicity, spectral-gap indicators, uncertainty, validation results, and whether the long-run distribution represents resilience, degradation, risk concentration, inequality, lock-in, or another substantive system meaning.

Back to top ↑

Related Articles

• What Is Linear Algebra for Systems Modeling?
• Scalars, Vectors, and System States
• Vector Spaces and System Representation
• Span, Linear Independence, and Basis
• Dimension and the Structure of Solution Spaces
• Matrices and the Organization of Multivariable Systems
• Matrix Arithmetic and the Logic of Combination
• Systems of Linear Equations
• Gaussian Elimination and Row Reduction
• Pivot Structure and Solvability
• Rank, Nullity, and Structural Dependence
• Determinants and Invertibility
• Inverse Matrices and Structural Recovery
• Overdetermined Systems and Least Squares Thinking
• Linear Transformations and Model Behavior
• Matrix Multiplication and Interaction Effects
• Change of Basis and Alternative Representations
• Projections, Reflections, and Geometric Interpretation
• Orthogonality and Structured Simplification
• Inner Products, Norms, and Distance in State Space
• Eigenvalues, Eigenvectors, and System Modes
• Diagonalization and Decoupled System Behavior
• Stability Analysis with Eigenvalues
• Markov Chains and Transition Matrices
• Linear Algebra for Systems Modeling
• Mathematical Modeling
• Systems Modeling
• Scientific Computing for Systems Modeling

Back to top ↑

Further Reading

• Boyd, S. and Vandenberghe, L. (2018) Introduction to Applied Linear Algebra: Vectors, Matrices, and Least Squares. Cambridge: Cambridge University Press. Available at: https://vmls-book.stanford.edu/.
• Boyd, S. and Vandenberghe, L. (2018) Introduction to Applied Linear Algebra: Vectors, Matrices, and Least Squares. PDF edition. Stanford University and UCLA. Available at: https://web.stanford.edu/~boyd/vmls/vmls.pdf.
• Durrett, R. (2019) Probability: Theory and Examples. 5th edn. Cambridge: Cambridge University Press. Available at: https://services.math.duke.edu/~rtd/PTE/PTE5_011119.pdf.
• Georgia Institute of Technology (n.d.) Interactive Linear Algebra. Georgia Institute of Technology. Available at: https://textbooks.math.gatech.edu/ila/.
• Grinstead, C.M. and Snell, J.L. (1997) Introduction to Probability. Providence, RI: American Mathematical Society. Available at: https://www.ams.org/open-math-notes/omn-view-listing?listingId=110645.
• Higham, N.J. (2002) Accuracy and Stability of Numerical Algorithms. 2nd edn. Philadelphia, PA: Society for Industrial and Applied Mathematics. Available at: https://epubs.siam.org/doi/book/10.1137/1.9780898718027.
• Horn, R.A. and Johnson, C.R. (2013) Matrix Analysis. 2nd edn. Cambridge: Cambridge University Press. Available at: https://www.cambridge.org/highereducation/books/matrix-analysis/FDA3627DC2B9F5C3DF2FD8C3CC136B48.
• Kemeny, J.G. and Snell, J.L. (1976) Finite Markov Chains. New York: Springer. Available at: https://link.springer.com/book/10.1007/978-1-4684-9455-6.
• Levin, D.A., Peres, Y. and Wilmer, E.L. (2017) Markov Chains and Mixing Times. 2nd edn. Providence, RI: American Mathematical Society. Available at: https://pages.uoregon.edu/dlevin/MARKOV/.
• Massachusetts Institute of Technology OpenCourseWare (2013) Introduction to Probability. Cambridge, MA: MIT OpenCourseWare. Available at: https://ocw.mit.edu/courses/6-041sc-probabilistic-systems-analysis-and-applied-probability-fall-2013/.
• Meyer, C.D. (2023) Matrix Analysis and Applied Linear Algebra. 2nd edn. Philadelphia, PA: Society for Industrial and Applied Mathematics. Available at: https://epubs.siam.org/doi/book/10.1137/1.9781611977448.
• MIT Mathematics (2023) Introduction to Linear Algebra, Sixth Edition. Cambridge, MA: Massachusetts Institute of Technology. Available at: https://math.mit.edu/~gs/linearalgebra/ila6/indexila6.html.
• Norris, J.R. (1997) Markov Chains. Cambridge: Cambridge University Press. Available at: https://www.cambridge.org/highereducation/books/markov-chains/4ED5AB94CE50FE6A4A03C0C742D1E900.
• Ross, S.M. (2014) Introduction to Probability Models. 11th edn. Amsterdam: Academic Press. Available at: https://www.elsevier.com/books/introduction-to-probability-models/ross/978-0-12-407948-9.
• SciPy Developers (n.d.) Linear Algebra: scipy.linalg. SciPy Documentation. Available at: https://docs.scipy.org/doc/scipy/reference/linalg.html.
• Stewart, W.J. (1994) Introduction to the Numerical Solution of Markov Chains. Princeton, NJ: Princeton University Press. Available at: https://press.princeton.edu/books/hardcover/9780691036990/introduction-to-the-numerical-solution-of-markov-chains.
• Strang, G. (2016) Introduction to Linear Algebra. Wellesley, MA: Wellesley-Cambridge Press. Available at: https://math.mit.edu/~gs/linearalgebra/.
• Trefethen, L.N. and Bau, D. (1997) Numerical Linear Algebra. Philadelphia, PA: Society for Industrial and Applied Mathematics. Available at: https://epubs.siam.org/doi/book/10.1137/1.9780898719574.

Back to top ↑

References

• Boyd, S. and Vandenberghe, L. (2018) Introduction to Applied Linear Algebra: Vectors, Matrices, and Least Squares. Cambridge: Cambridge University Press. Available at: https://vmls-book.stanford.edu/.
• Durrett, R. (2019) Probability: Theory and Examples. 5th edn. Cambridge: Cambridge University Press. Available at: https://services.math.duke.edu/~rtd/PTE/PTE5_011119.pdf.
• Grinstead, C.M. and Snell, J.L. (1997) Introduction to Probability. Providence, RI: American Mathematical Society. Available at: https://www.ams.org/open-math-notes/omn-view-listing?listingId=110645.
• Higham, N.J. (2002) Accuracy and Stability of Numerical Algorithms. 2nd edn. Philadelphia, PA: Society for Industrial and Applied Mathematics. Available at: https://epubs.siam.org/doi/book/10.1137/1.9780898718027.
• Horn, R.A. and Johnson, C.R. (2013) Matrix Analysis. 2nd edn. Cambridge: Cambridge University Press. Available at: https://www.cambridge.org/highereducation/books/matrix-analysis/FDA3627DC2B9F5C3DF2FD8C3CC136B48.
• Kemeny, J.G. and Snell, J.L. (1976) Finite Markov Chains. New York: Springer. Available at: https://link.springer.com/book/10.1007/978-1-4684-9455-6.
• Levin, D.A., Peres, Y. and Wilmer, E.L. (2017) Markov Chains and Mixing Times. 2nd edn. Providence, RI: American Mathematical Society. Available at: https://pages.uoregon.edu/dlevin/MARKOV/.
• Massachusetts Institute of Technology OpenCourseWare (2013) Introduction to Probability. Cambridge, MA: MIT OpenCourseWare. Available at: https://ocw.mit.edu/courses/6-041sc-probabilistic-systems-analysis-and-applied-probability-fall-2013/.
• Meyer, C.D. (2023) Matrix Analysis and Applied Linear Algebra. 2nd edn. Philadelphia, PA: Society for Industrial and Applied Mathematics. Available at: https://epubs.siam.org/doi/book/10.1137/1.9781611977448.
• Norris, J.R. (1997) Markov Chains. Cambridge: Cambridge University Press. Available at: https://www.cambridge.org/highereducation/books/markov-chains/4ED5AB94CE50FE6A4A03C0C742D1E900.
• Ross, S.M. (2014) Introduction to Probability Models. 11th edn. Amsterdam: Academic Press. Available at: https://www.elsevier.com/books/introduction-to-probability-models/ross/978-0-12-407948-9.
• Stewart, W.J. (1994) Introduction to the Numerical Solution of Markov Chains. Princeton, NJ: Princeton University Press. Available at: https://press.princeton.edu/books/hardcover/9780691036990/introduction-to-the-numerical-solution-of-markov-chains.
• Strang, G. (2016) Introduction to Linear Algebra. Wellesley, MA: Wellesley-Cambridge Press. Available at: https://math.mit.edu/~gs/linearalgebra/.
• Trefethen, L.N. and Bau, D. (1997) Numerical Linear Algebra. Philadelphia, PA: Society for Industrial and Applied Mathematics. Available at: https://epubs.siam.org/doi/book/10.1137/1.9780898719574.

Back to top ↑