Inverse Matrices and Structural Recovery: How Linear Algebra Recovers System States

Last Updated June 28, 2026

Inverse matrices and structural recovery explain when outputs can be traced back to unique inputs through a linear system. An inverse matrix is not just a computational device. It represents a strong structural condition: the transformation must preserve enough independent information for recovery to be possible.

This article introduces inverse matrices as tools for reversibility, recovery, identifiability, and systems interpretation. It connects invertibility, determinants, full rank, pivots, null spaces, condition numbers, numerical stability, structural recovery, and the difference between algebraic reversal and real-world reconstruction.

The central modeling question is not only “Can we compute \(A^{-1}\)?” It is “Does the system preserve enough reliable structure for recovering inputs from outputs to make mathematical, computational, and practical sense?”

Inverse matrices are often introduced as a way to solve equations. If \(A\mathbf{x}=\mathbf{b}\) and \(A^{-1}\) exists, then \(\mathbf{x}=A^{-1}\mathbf{b}\). But the deeper meaning is structural: the matrix \(A\) must be square, full rank, nonsingular, and information-preserving enough that each output corresponds to exactly one input.

For systems modeling, this matters because recovery claims are strong. If a model says that observed outputs can be used to reconstruct hidden inputs, resource flows, production requirements, initial states, or system drivers, it is relying on invertibility or some weaker approximate recovery method. Inverse matrices help explain when exact recovery is possible, when it is fragile, and when it is not justified.

Why Inverse Matrices Matter

Inverse matrices matter because they formalize reversal. If a matrix transforms an input state into an output state, its inverse reverses that transformation. This makes inverse matrices central to solving systems, recovering hidden variables, reversing transformations, interpreting dependencies, and understanding when model outputs uniquely determine model inputs.

But inverses exist only under strict conditions. A matrix must be square and full rank. It must not collapse any nonzero direction into zero. Its determinant must be nonzero. Its null space must be trivial. Every column and every row must carry independent structure.

For systems modeling, this is a powerful but demanding idea. Recovery is not just a matter of algebra. It depends on whether the model structure, data quality, units, conditioning, and real-world assumptions support the claim that outputs can be traced back to inputs.

Inverse matrices therefore help distinguish exact structural recovery from hopeful reconstruction.

Back to top ↑

What Is an Inverse Matrix?

An inverse matrix \(A^{-1}\) is a matrix that reverses the effect of a square matrix \(A\). If \(A\) maps \(\mathbf{x}\) to \(\mathbf{y}\), then \(A^{-1}\) maps \(\mathbf{y}\) back to \(\mathbf{x}\).

An inverse can exist only for square matrices. Non-square matrices can have left inverses, right inverses, pseudoinverses, or approximate recovery procedures in special cases, but they do not have ordinary two-sided inverses.

The existence of an inverse is therefore not merely a computational convenience. It is a claim about the structure of the transformation.

Back to top ↑

Inverse Matrices and Linear Systems

For a square system \(A\mathbf{x}=\mathbf{b}\), if \(A^{-1}\) exists, then the solution can be written as \(\mathbf{x}=A^{-1}\mathbf{b}\). This is the classic algebraic use of inverse matrices.

In applied computation, however, directly forming \(A^{-1}\) is often not the best way to solve a system. Numerical linear algebra typically solves \(A\mathbf{x}=\mathbf{b}\) using factorizations such as LU, QR, or Cholesky when appropriate. The inverse remains conceptually important, but stable solving often avoids explicitly computing it.

The formula \(A^{-1}\mathbf{b}\) explains the structure of recovery. Numerical practice decides how recovery should be computed responsibly.

Back to top ↑

Structural Recovery

Structural recovery means recovering input states, hidden variables, initial conditions, or causes from observed outputs through a modeled relationship. In linear algebra, exact structural recovery through a square matrix requires invertibility.

This is a strong modeling claim. It says the transformation does not merge distinct inputs into the same output. It says no nonzero direction is invisible. It says the coefficient structure preserves enough information to make exact recovery algebraically possible.

Structural recovery is not automatically justified by writing down a matrix. It must be earned through rank, invertibility, conditioning, and substantive model review.

Back to top ↑

Invertibility Conditions

For a square \(n\times n\) matrix, several conditions are equivalent to invertibility. These equivalent tests form one of the central diagnostic clusters in linear algebra.

These conditions look different, but they all express the same structural fact: the transformation preserves full-dimensional independent information.

These equivalences help modelers avoid treating inverse matrices as isolated formulas. Invertibility is a structural property shared by determinant, rank, pivot, and null-space diagnostics.

Back to top ↑

Determinants, Rank, and Nullity

Inverse matrices are closely connected to determinants, rank, and nullity. A nonzero determinant means the square matrix has full rank. Full rank means nullity is zero. Nullity zero means no nonzero vector is mapped to zero.

If nullity is positive, then different inputs can produce the same output. If \(\mathbf{z}\in N(A)\) and \(\mathbf{z}\neq\mathbf{0}\), then \(A\mathbf{x}=A(\mathbf{x}+\mathbf{z})\). Recovery is no longer unique.

Determinant, rank, and nullity are therefore not separate topics. They are different lenses on the same recovery question.

Back to top ↑

Input-Output Reversibility

A matrix transformation is reversible when it maps distinct inputs to distinct outputs and covers the full output space. In finite-dimensional square systems, this is exactly invertibility.

In systems modeling, reversibility may describe recovering original resource flows from observed totals, reconstructing sector production requirements from final demand, inferring internal system states from measured outputs, or reversing a coordinate transformation. But algebraic reversibility does not automatically mean real-world reversibility. Some processes lose information physically, institutionally, or observationally even if a mathematical submodel is invertible.

Inverse matrices answer the first layer. Responsible modeling must address the rest.

Back to top ↑

When Inverses Do Not Exist

An inverse does not exist when a square matrix is singular. Singularity means at least one independent direction has collapsed. The determinant is zero, rank is deficient, and the null space contains nonzero vectors.

When inverses do not exist, the model may still be useful. It may reveal redundancy, conservation structure, underdetermination, aggregation, missing variables, repeated indicators, or deliberate dimensional reduction. The problem is not always the model itself. The problem is making recovery claims that the model cannot support.

Non-invertibility is not a failure by itself. It is a warning about what cannot be recovered uniquely.

Back to top ↑

Left and Right Inverses

Ordinary inverse matrices require square matrices. For non-square matrices, one may encounter left inverses or right inverses under special rank conditions. These do not provide the same two-sided recovery as \(A^{-1}\), but they are important for understanding overdetermined and underdetermined systems.

A tall full-column-rank matrix may have a left inverse. A wide full-row-rank matrix may have a right inverse. These ideas lead naturally to least-squares thinking, pseudoinverses, and approximate recovery.

These cases prepare the transition from exact inverse matrices to overdetermined systems and least-squares thinking.

Back to top ↑

Inverse Matrices versus Solving Systems

Although \(A^{-1}\mathbf{b}\) is a valid formula when \(A\) is invertible, applied numerical work often avoids explicitly computing \(A^{-1}\). Solving a system directly through factorization is usually more efficient and stable.

This distinction is important. The inverse explains why a unique solution exists and what structural recovery means. A solver computes the solution in a way that respects numerical realities. Treating inverse computation as the default can be inefficient, unstable, and misleading for large or ill-conditioned systems.

Good modeling distinguishes the inverse as an interpretive object from inversion as a computational habit.

Back to top ↑

Condition Numbers and Recovery Fragility

An inverse may exist but still be unreliable. If a matrix is ill-conditioned, small changes in \(\mathbf{b}\) or \(A\) can produce large changes in the recovered \(\mathbf{x}\). This makes structural recovery fragile.

A large condition number means the matrix is close to singular in a numerical sense. Recovery may be formally possible but practically unreliable. This is especially important in empirical systems, high-dimensional models, calibrated simulations, and models with noisy measurements.

Invertibility says recovery is possible in exact algebra. Conditioning asks whether recovery is trustworthy in computation.

Back to top ↑

Pseudoinverses and Approximate Recovery

When ordinary inverses do not exist, pseudoinverses can support approximate recovery. The Moore-Penrose pseudoinverse generalizes inverse-like behavior to rectangular and rank-deficient matrices. It is especially important for least-squares problems, minimum-norm solutions, and SVD-based diagnostics.

Pseudoinverse recovery should not be confused with exact inverse recovery. It often chooses a best-fit or minimum-norm solution under a particular criterion. That criterion must be interpreted, justified, and documented.

This is the bridge to least-squares thinking: when exact recovery fails or data are noisy, modelers need principled approximation.

Back to top ↑

Systems Modeling Interpretation

Inverse matrices help modelers understand when a system can be reversed. In infrastructure systems, an inverse may recover component flows from balanced outputs. In economic input-output models, inverse structure may show how final demand implies upstream production requirements. In ecological models, inversion may estimate hidden interaction terms or equilibrium responses. In decision systems, inverse reasoning may reconstruct required inputs from desired outputs.

But structural recovery is fragile. An invertible matrix may be poorly conditioned. A recovered input may violate practical constraints. A mathematical inverse may not correspond to a causal process. A model may omit variables that matter. Observed outputs may be noisy. A square coefficient system may appear precise while hiding scale problems or measurement error.

Responsible interpretation should document invertibility conditions, determinant, rank, nullity, condition number, row and column meanings, units, data quality, sensitivity, and whether recovery is algebraic, numerical, empirical, causal, or decision-oriented.

Back to top ↑

Mathematical Deepening

This section adds a more formal layer for mathematically advanced readers. Inverse matrices connect linear isomorphisms, automorphisms of vector spaces, bases, determinant nonvanishing, rank-nullity, spectral structure, condition numbers, LU factorization, SVD, pseudoinverses, and regularized recovery.

Back to top ↑

Back to top ↑

Computation and Reproducible Workflows

Computational workflows for inverse matrices and structural recovery should document the original matrix, row and column meanings, determinant, rank, nullity, invertibility status, condition number, recovery residual, solver method, and interpretation warnings. A recovered vector should never appear without information about how reliable the recovery is.

The companion repository treats inverse recovery as auditable mathematical 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 systems modeling.

For this article, the computational examples focus on invertibility checks, inverse recovery, residuals, condition warnings, and model-governance records.

Back to top ↑

Python Workflow: Inverse Recovery Audit

The Python workflow below computes an inverse for a small square matrix when appropriate, recovers a solution vector, records the residual, and attaches conditioning and 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 InverseRecoveryAudit:
    system_name: str
    matrix_size: int
    determinant: float
    invertible: bool
    rank: int
    nullity: int
    recovered_solution: str
    residual_norm: float
    condition_warning: str
    tolerance: float
    interpretation_warning: str


def determinant_3x3(A: Matrix) -> float:
    return (
        A[0][0] * (A[1][1] * A[2][2] - A[1][2] * A[2][1])
        - A[0][1] * (A[1][0] * A[2][2] - A[1][2] * A[2][0])
        + A[0][2] * (A[1][0] * A[2][1] - A[1][1] * A[2][0])
    )


def inverse_3x3(A: Matrix) -> Matrix:
    det = determinant_3x3(A)
    if abs(det) <= 1e-12:
        raise ValueError("Matrix is singular or effectively singular.")

    cofactors = [
        [
            A[1][1] * A[2][2] - A[1][2] * A[2][1],
            -(A[1][0] * A[2][2] - A[1][2] * A[2][0]),
            A[1][0] * A[2][1] - A[1][1] * A[2][0],
        ],
        [
            -(A[0][1] * A[2][2] - A[0][2] * A[2][1]),
            A[0][0] * A[2][2] - A[0][2] * A[2][0],
            -(A[0][0] * A[2][1] - A[0][1] * A[2][0]),
        ],
        [
            A[0][1] * A[1][2] - A[0][2] * A[1][1],
            -(A[0][0] * A[1][2] - A[0][2] * A[1][0]),
            A[0][0] * A[1][1] - A[0][1] * A[1][0],
        ],
    ]

    adjugate = [[cofactors[j][i] for j in range(3)] for i in range(3)]
    return [[value / det for value in row] for row in adjugate]


def matvec(A: Matrix, x: Vector) -> Vector:
    return [sum(a * b for a, b in zip(row, x)) for row in A]


def vector_subtract(a: Vector, b: Vector) -> Vector:
    return [x - y for x, y in zip(a, b)]


def norm2(v: Vector) -> float:
    return math.sqrt(sum(x * x for x in v))


def build_audit() -> InverseRecoveryAudit:
    A = [
        [1.0, 1.0, 0.0],
        [0.0, 1.0, 1.0],
        [1.0, 0.0, 1.0],
    ]
    b = [100.0, 80.0, 90.0]
    tolerance = 1e-10

    det_value = determinant_3x3(A)
    invertible = abs(det_value) > tolerance
    rank = 3 if invertible else 2
    nullity = len(A) - rank

    if invertible:
        A_inv = inverse_3x3(A)
        recovered = matvec(A_inv, b)
        residual = vector_subtract(matvec(A, recovered), b)
        residual_norm = norm2(residual)
    else:
        recovered = []
        residual_norm = float("nan")

    condition_warning = (
        "inverse exists for this example; still review conditioning, units, and sensitivity"
        if invertible
        else "inverse does not exist; use rank, pseudoinverse, or least-squares diagnostics"
    )

    return InverseRecoveryAudit(
        system_name="three_constraint_structural_recovery_system",
        matrix_size=len(A),
        determinant=round(det_value, 10),
        invertible=invertible,
        rank=rank,
        nullity=nullity,
        recovered_solution=",".join(f"{value:.6f}" for value in recovered) if recovered else "not_available",
        residual_norm=round(residual_norm, 12) if invertible else residual_norm,
        condition_warning=condition_warning,
        tolerance=tolerance,
        interpretation_warning=(
            "Inverse recovery is algebraic; practical recovery requires review of conditioning, "
            "measurement error, units, constraints, and model meaning."
        ),
    )


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" / "inverse_recovery_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" / "inverse_recovery_audit.json").write_text(
        json.dumps(row, indent=2, sort_keys=True),
        encoding="utf-8",
    )


if __name__ == "__main__":
    write_outputs(Path("outputs"))
    print("Inverse recovery audit complete.")

This workflow treats inverse recovery as a documented modeling claim. It reports not only the recovered solution, but also determinant, invertibility, rank, nullity, residual norm, tolerance, and interpretation warnings.

Back to top ↑

R Workflow: Inverse and Conditioning Diagnostics

R can support inverse recovery using matrix solving, determinant checks, rank diagnostics, and residual review. The workflow below records recovery and warns against treating inversion as self-validating.

A <- matrix(
  c(
    1, 1, 0,
    0, 1, 1,
    1, 0, 1
  ),
  nrow = 3,
  byrow = TRUE
)

b <- c(100, 80, 90)

tolerance <- 1e-10
det_value <- det(A)
rank_A <- qr(A)$rank
matrix_size <- nrow(A)
nullity_A <- ncol(A) - rank_A
invertible <- abs(det_value) > tolerance && rank_A == matrix_size

if (invertible) {
  recovered_solution <- solve(A, b)
  residual_norm <- sqrt(sum((A %*% recovered_solution - b)^2))
} else {
  recovered_solution <- rep(NA_real_, ncol(A))
  residual_norm <- NA_real_
}

audit_record <- data.frame(
  system_name = "three_constraint_structural_recovery_system",
  matrix_size = matrix_size,
  determinant = det_value,
  invertible = invertible,
  rank = rank_A,
  nullity = nullity_A,
  recovered_solution = paste(round(recovered_solution, 6), collapse = ","),
  residual_norm = residual_norm,
  condition_warning = paste(
    "Inverse recovery should be paired with conditioning,",
    "sensitivity, units, and model review."
  ),
  tolerance = tolerance,
  interpretation_warning = paste(
    "Algebraic recovery does not guarantee practical recovery;",
    "data quality and model meaning remain decisive."
  )
)

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

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

print(audit_record)

This R workflow is useful when inverse reasoning supports economic models, infrastructure systems, scientific computing, calibration, or policy target planning.

Back to top ↑

Haskell Workflow: Typed Recovery Records

Haskell can represent inverse recovery as a typed record with explicit fields for determinant, invertibility, rank, nullity, recovered solution, residual, and interpretation warning.

module Main where

data InverseRecoveryAudit = InverseRecoveryAudit
  { systemName :: String
  , matrixSize :: Int
  , determinantValue :: Double
  , invertible :: Bool
  , rankValue :: Int
  , nullityValue :: Int
  , recoveredSolution :: String
  , residualNorm :: Double
  , tolerance :: Double
  , interpretationWarning :: String
  } deriving (Show)

buildAudit :: InverseRecoveryAudit
buildAudit =
  InverseRecoveryAudit
    "three_constraint_structural_recovery_system"
    3
    2.0
    True
    3
    0
    "55.000000,45.000000,35.000000"
    0.0
    1.0e-10
    "Inverse recovery is algebraic; practical recovery requires conditioning and model review."

main :: IO ()
main =
  print buildAudit

The typed workflow keeps recovery conclusions attached to numerical and interpretive context.

Back to top ↑

SQL Workflow: Structural Recovery Registry

SQL can document recovery assumptions when inverse reasoning supports dashboards, planning systems, scientific-computing pipelines, optimization workflows, risk models, or institutional reports.

CREATE TABLE inverse_recovery_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 inverse_recovery_assumption_registry VALUES
(
  'inverse_matrix',
  'Inverse matrix',
  'A two-sided matrix inverse satisfying A inverse times A equals the identity.',
  'Supports exact recovery of inputs from outputs when the transformation is invertible.',
  'An inverse exists only for square full-rank matrices.'
);

INSERT INTO inverse_recovery_assumption_registry VALUES
(
  'structural_recovery',
  'Structural recovery',
  'Uses the inverse transformation to reconstruct inputs from outputs.',
  'Represents a strong claim that modeled outputs preserve enough information for recovery.',
  'Recovery claims require conditioning, data quality, and substantive interpretation review.'
);

INSERT INTO inverse_recovery_assumption_registry VALUES
(
  'trivial_null_space',
  'Trivial null space',
  'Only the zero vector maps to zero.',
  'Means no nonzero input direction disappears under the transformation.',
  'A nontrivial null space prevents unique recovery.'
);

INSERT INTO inverse_recovery_assumption_registry VALUES
(
  'condition_number',
  'Condition number',
  'Measures sensitivity of inverse recovery to perturbations.',
  'Shows whether algebraic recovery is numerically stable.',
  'Large condition numbers make recovery fragile even when an inverse exists.'
);

INSERT INTO inverse_recovery_assumption_registry VALUES
(
  'explicit_inverse',
  'Explicit inverse',
  'Computes A inverse directly.',
  'Useful for interpretation and small examples.',
  'Numerical workflows usually prefer solving systems directly with factorizations.'
);

INSERT INTO inverse_recovery_assumption_registry VALUES
(
  'pseudoinverse',
  'Pseudoinverse',
  'Generalizes inverse-like recovery to rectangular or rank-deficient systems.',
  'Supports approximate, least-squares, or minimum-norm recovery.',
  'Pseudoinverse solutions reflect criteria and assumptions, not exact reversal.'
);

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

This registry keeps inverse recovery tied to invertibility, null-space structure, conditioning, solver choice, approximation, and responsible interpretation.

Back to top ↑

GitHub Repository

The companion repository for this article is designed as a reproducible mathematical-modeling workspace. It supports inverse-recovery audits, invertibility diagnostics, determinant checks, rank and nullity reports, condition warnings, residual checks, SQL governance tables, generated outputs, advanced mathematical audit reports, and reusable calculator scripts.

Back to top ↑

Interpretive Limits and Responsible Use

Inverse matrices are powerful because they formalize exact recovery. They are limited because exact algebraic recovery is not the same as practical recovery. A matrix can be invertible while the system is poorly conditioned, data are noisy, variables are poorly measured, units are inconsistent, or the real process is not actually reversible.

An inverse matrix should not be used as proof that a model is valid. It only proves that the matrix transformation is algebraically reversible under exact assumptions. In applied systems, recovery claims require residual checks, condition estimates, sensitivity analysis, unit review, data-quality assessment, and substantive interpretation.

Responsible use requires documenting matrix meaning, row and column definitions, determinant, rank, nullity, solver method, condition number, residuals, tolerance choices, and the difference between formal inverse recovery and real-world reconstruction.

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
• Linear Algebra for Systems Modeling
• Mathematical Modeling
• Systems Modeling
• Scientific Computing for Systems Modeling

Back to top ↑

Further Reading

• Axler, S. (2024) Linear Algebra Done Right. 4th edn. Cham: Springer. Available at: https://linear.axler.net/.
• 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.
• Georgia Institute of Technology (n.d.) Interactive Linear Algebra. Georgia Institute of Technology. Available at: https://textbooks.math.gatech.edu/ila/.
• Hefferon, J. (n.d.) Linear Algebra. Saint Michael’s College. Available at: https://joshua.smcvt.edu/linearalgebra/.
• Massachusetts Institute of Technology OpenCourseWare (2011) Linear Algebra. Cambridge, MA: MIT OpenCourseWare. Available at: https://ocw.mit.edu/courses/18-06sc-linear-algebra-fall-2011/.
• Massachusetts Institute of Technology OpenCourseWare (2018) Matrix Methods in Data Analysis, Signal Processing, and Machine Learning. Cambridge, MA: MIT OpenCourseWare. Available at: https://ocw.mit.edu/courses/18-065-matrix-methods-in-data-analysis-signal-processing-and-machine-learning-spring-2018/.
• 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.
• Strang, G. (2016) Introduction to Linear Algebra. Wellesley, MA: Wellesley-Cambridge Press. Available at: https://math.mit.edu/~gs/linearalgebra/.
• Treil, S. (2017) Linear Algebra Done Wrong. Providence, RI: Brown University. Available at: https://www.math.brown.edu/streil/papers/LADW/LADW.html.
• van de Geijn, R. and Myers, M. (n.d.) Linear Algebra: Foundations to Frontiers. Austin, TX: The University of Texas at Austin. Available at: https://www.cs.utexas.edu/~flame/laff/laff/LAFF-2.00M.pdf.
• Golub, G.H. and Van Loan, C.F. (2013) Matrix Computations. 4th edn. Baltimore, MD: Johns Hopkins University Press. Available at: https://www.press.jhu.edu/books/title/10678/matrix-computations.
• 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.
• 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.
• 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.
• National Institute of Standards and Technology (n.d.) Matrix Market. NIST Mathematical and Computational Sciences Division. Available at: https://math.nist.gov/MatrixMarket/.
• Netlib (n.d.) BLAS — Basic Linear Algebra Subprograms. Netlib Repository. Available at: https://www.netlib.org/blas/.
• Netlib (n.d.) LAPACK — Linear Algebra PACKage. Netlib Repository. Available at: https://www.netlib.org/lapack/.
• Netlib and SIAM (1999) LAPACK Users’ Guide. 3rd edn. Philadelphia, PA: Society for Industrial and Applied Mathematics. Available at: https://www.netlib.org/lapack/lug/.
• NumPy Developers (n.d.) Linear Algebra: numpy.linalg. NumPy Documentation. Available at: https://numpy.org/doc/stable/reference/routines.linalg.html.
• SciPy Developers (n.d.) Linear Algebra: scipy.linalg. SciPy Documentation. Available at: https://docs.scipy.org/doc/scipy/reference/linalg.html.
• SciPy Developers (n.d.) Matrix Inverse: scipy.linalg.inv. SciPy Documentation. Available at: https://docs.scipy.org/doc/scipy/reference/generated/scipy.linalg.inv.html.
• SciPy Developers (n.d.) Moore-Penrose Pseudoinverse: scipy.linalg.pinv. SciPy Documentation. Available at: https://docs.scipy.org/doc/scipy/reference/generated/scipy.linalg.pinv.html.
• R Core Team and Matrix Package Authors (n.d.) Matrix: Sparse and Dense Matrix Classes and Methods. CRAN. Available at: https://cran.r-project.org/package=Matrix.
• Julia Documentation (n.d.) Linear Algebra — Julia Standard Library. Julia Documentation. Available at: https://docs.julialang.org/en/v1/stdlib/LinearAlgebra/.

Back to top ↑

References

• Axler, S. (2024) Linear Algebra Done Right. 4th edn. Cham: Springer. Available at: https://linear.axler.net/.
• 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/.
• Georgia Institute of Technology (n.d.) Interactive Linear Algebra. Georgia Institute of Technology. Available at: https://textbooks.math.gatech.edu/ila/.
• Golub, G.H. and Van Loan, C.F. (2013) Matrix Computations. 4th edn. Baltimore, MD: Johns Hopkins University Press. Available at: https://www.press.jhu.edu/books/title/10678/matrix-computations.
• Hefferon, J. (n.d.) Linear Algebra. Saint Michael’s College. Available at: https://joshua.smcvt.edu/linearalgebra/.
• 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.
• Julia Documentation (n.d.) Linear Algebra — Julia Standard Library. Julia Documentation. Available at: https://docs.julialang.org/en/v1/stdlib/LinearAlgebra/.
• Massachusetts Institute of Technology OpenCourseWare (2011) Linear Algebra. Cambridge, MA: MIT OpenCourseWare. Available at: https://ocw.mit.edu/courses/18-06sc-linear-algebra-fall-2011/.
• Massachusetts Institute of Technology OpenCourseWare (2018) Matrix Methods in Data Analysis, Signal Processing, and Machine Learning. Cambridge, MA: MIT OpenCourseWare. Available at: https://ocw.mit.edu/courses/18-065-matrix-methods-in-data-analysis-signal-processing-and-machine-learning-spring-2018/.
• 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.
• Netlib (n.d.) BLAS — Basic Linear Algebra Subprograms. Netlib Repository. Available at: https://www.netlib.org/blas/.
• Netlib (n.d.) LAPACK — Linear Algebra PACKage. Netlib Repository. Available at: https://www.netlib.org/lapack/.
• Netlib and SIAM (1999) LAPACK Users’ Guide. 3rd edn. Philadelphia, PA: Society for Industrial and Applied Mathematics. Available at: https://www.netlib.org/lapack/lug/.
• NumPy Developers (n.d.) Linear Algebra: numpy.linalg. NumPy Documentation. Available at: https://numpy.org/doc/stable/reference/routines.linalg.html.
• R Core Team and Matrix Package Authors (n.d.) Matrix: Sparse and Dense Matrix Classes and Methods. CRAN. Available at: https://cran.r-project.org/package=Matrix.
• SciPy Developers (n.d.) Linear Algebra: scipy.linalg. SciPy Documentation. Available at: https://docs.scipy.org/doc/scipy/reference/linalg.html.
• SciPy Developers (n.d.) Matrix Inverse: scipy.linalg.inv. SciPy Documentation. Available at: https://docs.scipy.org/doc/scipy/reference/generated/scipy.linalg.inv.html.
• SciPy Developers (n.d.) Moore-Penrose Pseudoinverse: scipy.linalg.pinv. SciPy Documentation. Available at: https://docs.scipy.org/doc/scipy/reference/generated/scipy.linalg.pinv.html.
• Strang, G. (2016) Introduction to Linear Algebra. Wellesley, MA: Wellesley-Cambridge Press. Available at: https://math.mit.edu/~gs/linearalgebra/.
• Treil, S. (2017) Linear Algebra Done Wrong. Providence, RI: Brown University. Available at: https://www.math.brown.edu/streil/papers/LADW/LADW.html.
• 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.
• van de Geijn, R. and Myers, M. (n.d.) Linear Algebra: Foundations to Frontiers. Austin, TX: The University of Texas at Austin. Available at: https://www.cs.utexas.edu/~flame/laff/laff/LAFF-2.00M.pdf.

Back to top ↑