Rank, Nullity, and Structural Dependence: How Linear Algebra Reveals Independent Structure and Hidden Freedom

Last Updated June 28, 2026

Rank, nullity, and structural dependence explain how linear algebra measures independent structure, remaining freedom, and hidden dependency inside a system. Rank tells us how many independent directions a matrix actually contains. Nullity tells us how many directions remain unconstrained. Structural dependence tells us where rows, columns, variables, equations, or modeled relationships repeat, collapse, or fail to add new information.

This article introduces rank and nullity as core tools for understanding systems of linear equations, coefficient matrices, solution spaces, model identifiability, redundancy, freedom, and solvability. It connects pivot structure, column spaces, row spaces, null spaces, rank-nullity, dependence, independence, redundancy, underdetermination, and structural interpretation.

The central modeling question is not only “What is the rank?” It is “What does the rank reveal about the independent structure of the system, and what does nullity reveal about the freedom the model does not control?”

Rank and nullity are among the most important interpretive concepts in linear algebra. Rank measures how much independent structure a matrix contains. Nullity measures how many independent directions are mapped to zero. Together, they explain why some systems have unique solutions, why others have infinitely many solutions, why some variables remain free, and why some equations are redundant.

For systems modeling, rank and nullity are diagnostic. They reveal whether a model has enough independent constraints to determine unknowns, whether variables are identifiable, whether equations repeat information, whether targets are reachable, whether hidden tradeoffs exist, and whether degrees of freedom remain after all modeled constraints are applied.

Why Rank and Nullity Matter

Rank and nullity matter because they reveal what a matrix actually does. A matrix may look large, with many rows and columns, but its true independent structure may be smaller. Some rows may repeat information. Some columns may depend on others. Some variables may be invisible to the equations. Some constraints may fail to determine the system.

Rank measures independent structure. Nullity measures remaining freedom. Together, they explain the relationship between what a system constrains and what it leaves unconstrained.

In systems modeling, this distinction is essential. A model with high apparent complexity may have low rank. A system with many equations may still leave variables undetermined. A model with a unique-looking output may hide unobserved degrees of freedom. Rank and nullity help expose these conditions.

Rank and nullity therefore help modelers ask whether the system is truly constrained or merely complicated.

Back to top ↑

Rank as Independent Structure

The rank of a matrix measures the dimension of its independent structure. It can be understood as the number of pivot columns, the number of pivot rows, the dimension of the column space, or the dimension of the row space.

In a linear system, rank tells how many independent constraints or independent variable directions the matrix contains. A high row count does not guarantee high rank. A high column count does not guarantee many independent variables. Rank reveals the effective structure beneath the visible dimensions.

Rank is not the number of rows or columns. It is the number of independent directions that survive dependency.

Back to top ↑

Nullity as Remaining Freedom

Nullity is the dimension of the null space of a matrix. The null space contains all vectors that the matrix maps to zero. These are directions of change that do not affect the modeled output.

In systems modeling, nullity is often more than an abstract dimension. It can represent flexibility, hidden substitution, underdetermination, non-identifiability, unobserved directions, compensating tradeoffs, or missing constraints.

Nullity reveals what the model cannot see or control. This makes it crucial for responsible interpretation.

Back to top ↑

The Rank-Nullity Theorem

The rank-nullity theorem states that for an \(m\times n\) matrix \(A\), the rank of \(A\) plus the nullity of \(A\) equals \(n\), the number of columns.

This theorem is central because it connects determination and freedom. If rank increases, nullity decreases. If rank is deficient, nullity grows. For a system with \(n\) unknowns, rank tells how many independent variable directions are constrained, while nullity tells how many remain free.

Rank-nullity is a compact theorem with a large modeling implication: independent structure and remaining freedom must balance.

Back to top ↑

Structural Dependence

Structural dependence occurs when rows, columns, equations, variables, or modeled relationships are not independent. One part of the system can be expressed as a combination of other parts. This reduces rank and often increases nullity.

In systems modeling, structural dependence may be expected or problematic. Accounting identities may intentionally create dependent rows. Repeated measurements may create redundancy. Highly correlated variables may produce near dependence. Missing distinctions between variables may cause a model to look richer than it really is.

Dependence is not always an error. But it must be understood because it changes what the model can determine.

Back to top ↑

Row Rank and Column Rank

The row rank of a matrix is the dimension of its row space. The column rank is the dimension of its column space. A fundamental result of linear algebra is that these are always equal.

This equality is powerful because rows and columns often have different modeling meanings. Rows may represent constraints, observations, locations, balances, or measurements. Columns may represent variables, flows, features, activities, or parameters. Rank links these two sides of the model.

The equality of row rank and column rank helps explain why row reduction can reveal column-space structure, even though row operations act on rows.

Back to top ↑

Column Space and Reachability

The column space of \(A\) contains all vectors that can be produced by \(A\mathbf{x}\). In the equation \(A\mathbf{x}=\mathbf{b}\), solvability depends on whether \(\mathbf{b}\) lies in this column space.

Rank determines the dimension of this reachable space. If rank is small, the matrix can produce only a limited set of targets. If a target lies outside that space, the system is inconsistent.

Column-space interpretation makes rank a question of reachability: what can this model actually produce?

Back to top ↑

Null Space and Hidden Freedom

The null space contains all inputs that produce no output change. If \(\mathbf{z}\in N(A)\), then adding \(\mathbf{z}\) to a solution does not change \(A\mathbf{x}\).

This explains why a consistent system with nonzero nullity has infinitely many solutions. If one solution exists, then adding any null-space vector gives another solution.

Null space analysis is therefore crucial for understanding what a model cannot distinguish.

Back to top ↑

Rank, Nullity, and Solvability

Rank and nullity help classify the solution behavior of \(A\mathbf{x}=\mathbf{b}\). Consistency depends on whether \(\mathbf{b}\) lies in the column space of \(A\). Uniqueness depends on whether the nullity is zero.

This separation matters. A system may be inconsistent because the target is unreachable. A system may be consistent but non-unique because null-space freedom remains. A system may be consistent and unique when the target is reachable and nullity is zero.

Existence and uniqueness are different questions. Rank and nullity help keep them separate.

Back to top ↑

Rank Deficiency

A matrix is rank deficient when its rank is less than the maximum possible rank. For an \(m\times n\) matrix, the maximum possible rank is \(\min(m,n)\). Rank deficiency means the matrix has dependencies.

Rank deficiency can signal redundant constraints, dependent variables, insufficient information, non-identifiability, or structural collapse. In numerical computing, near rank deficiency can make solutions unstable.

Rank deficiency is a structural warning. It may be meaningful, acceptable, or problematic, depending on the system and purpose.

Back to top ↑

Identifiability and Underdetermination

A variable or parameter is identifiable when the available equations contain enough independent information to determine it. Rank and nullity are central to identifiability. If nullity is positive, multiple input vectors can produce the same output, meaning some directions are not identifiable.

This matters in modeling, estimation, and decision support. If a model cannot distinguish two different system states, then choosing between them requires additional evidence, assumptions, constraints, or values.

Rank and nullity help distinguish what the model determines from what the model leaves open.

Back to top ↑

Numerical Rank and Tolerance

In exact mathematics, rank is precise. In numerical computing, rank may depend on tolerance. A value that is theoretically nonzero may be so small that treating it as a pivot creates unstable conclusions. Numerical rank often depends on singular values, scaling, conditioning, and threshold choices.

This matters for applied modeling because data often include measurement error, simulation approximations, rounding, normalization, and unit differences. Near dependence can make a system appear full rank under one tolerance and rank deficient under another.

Numerical rank should be treated as a modeling judgment supported by computation, not as an unquestioned fact.

Back to top ↑

Systems Modeling Interpretation

Rank, nullity, and structural dependence help modelers interpret the internal structure of linear systems. Rank reveals how many independent relationships the model contains. Nullity reveals how many input directions remain unresolved. Dependence reveals where equations, variables, features, or constraints repeat or collapse into one another.

In infrastructure models, rank may show whether flow constraints determine network behavior or leave alternative routing choices. In economic models, rank may show whether sector relationships are independent or structurally linked. In ecological models, nullity may reveal compensating pathways. In policy models, dependence may reveal repeated indicators or overlapping constraints. In scientific computing, numerical rank may determine whether a discretized model is well-posed.

Responsible interpretation should document row meanings, column meanings, coefficient units, rank method, nullity calculation, tolerance choices, dependence findings, solution implications, and practical feasibility conditions.

Back to top ↑

Mathematical Deepening

This section adds a more formal layer for mathematically advanced readers. Rank, nullity, and structural dependence connect the fundamental theorem of linear algebra, row spaces, column spaces, null spaces, left null spaces, linear transformations, bases, dimension, singular values, numerical rank, and model identifiability.

Back to top ↑

Back to top ↑

Computation and Reproducible Workflows

Computational workflows for rank, nullity, and dependence should document the original matrix, row and column meanings, rank method, nullity value, pivot columns, free columns, rank deficiency, tolerance choices, numerical warnings, and interpretation notes. A rank calculation should not be isolated from the model it describes.

The companion repository treats rank-nullity analysis 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 rank calculation, nullity calculation, free-variable counts, dependence warnings, and model-governance records.

Back to top ↑

Python Workflow: Rank-Nullity Audit

The Python workflow below computes rank and nullity from row reduction, records free-variable count, and attaches an interpretation warning.

from __future__ import annotations

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


Matrix = list[list[float]]


@dataclass(frozen=True)
class RankNullityAudit:
    system_name: str
    row_count: int
    column_count: int
    rank: int
    nullity: int
    rank_deficient: bool
    pivot_columns: str
    free_columns: str
    tolerance: float
    interpretation_warning: str


def rref(matrix: Matrix, tolerance: float = 1e-10) -> tuple[Matrix, list[int]]:
    rows = [row[:] for row in matrix]
    row_count = len(rows)
    column_count = len(rows[0]) if rows else 0
    pivot_columns: list[int] = []
    pivot_row = 0

    for column in range(column_count):
        pivot = None
        for row in range(pivot_row, row_count):
            if abs(rows[row][column]) > tolerance:
                pivot = row
                break

        if pivot is None:
            continue

        rows[pivot_row], rows[pivot] = rows[pivot], rows[pivot_row]
        pivot_value = rows[pivot_row][column]
        rows[pivot_row] = [value / pivot_value for value in rows[pivot_row]]

        for row in range(row_count):
            if row != pivot_row:
                factor = rows[row][column]
                rows[row] = [
                    current - factor * pivot_current
                    for current, pivot_current in zip(rows[row], rows[pivot_row])
                ]

        pivot_columns.append(column)
        pivot_row += 1

        if pivot_row == row_count:
            break

    cleaned = [
        [0.0 if abs(value) < tolerance else round(value, 10) for value in row]
        for row in rows
    ]
    return cleaned, pivot_columns


def build_audit() -> RankNullityAudit:
    A = [
        [1.0, 1.0, 0.0],
        [0.0, 1.0, 1.0],
        [1.0, 0.0, 1.0],
    ]

    tolerance = 1e-10
    _, pivots = rref(A, tolerance=tolerance)
    column_count = len(A[0])
    rank = len(pivots)
    nullity = column_count - rank
    free_columns = [column for column in range(column_count) if column not in pivots]
    maximum_rank = min(len(A), column_count)

    return RankNullityAudit(
        system_name="three_constraint_resource_balance_matrix",
        row_count=len(A),
        column_count=column_count,
        rank=rank,
        nullity=nullity,
        rank_deficient=rank < maximum_rank,
        pivot_columns=",".join(str(column) for column in pivots),
        free_columns=",".join(str(column) for column in free_columns) if free_columns else "none",
        tolerance=tolerance,
        interpretation_warning=(
            "Rank and nullity reveal algebraic structure, but dependence and freedom "
            "must be interpreted using row meanings, column meanings, units, and modeling purpose."
        ),
    )


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


if __name__ == "__main__":
    write_outputs(Path("outputs"))
    print("Rank-nullity audit complete.")

This workflow treats rank and nullity as documented model diagnostics rather than isolated numerical outputs.

Back to top ↑

R Workflow: Rank and Freedom Diagnostics

R can support rank and nullity diagnostics using QR decomposition. The workflow below records rank, nullity, rank deficiency, and interpretation warnings.

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

rank_A <- qr(A)$rank
column_count <- ncol(A)
row_count <- nrow(A)
nullity_A <- column_count - rank_A
maximum_rank <- min(row_count, column_count)
rank_deficient <- rank_A < maximum_rank

audit_record <- data.frame(
  system_name = "three_constraint_resource_balance_matrix",
  row_count = row_count,
  column_count = column_count,
  rank = rank_A,
  nullity = nullity_A,
  rank_deficient = rank_deficient,
  interpretation_warning = paste(
    "Rank and nullity reveal algebraic structure;",
    "model meaning depends on row definitions, column definitions, units, and purpose."
  )
)

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

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

print(audit_record)

This R workflow is useful when rank diagnostics support statistical modeling, feature review, calibration, scientific computing, or policy analysis.

Back to top ↑

Haskell Workflow: Typed Rank-Nullity Records

Haskell can represent rank-nullity audits with explicit fields for rank, nullity, dependence, free columns, and interpretation warnings.

module Main where

data RankNullityAudit = RankNullityAudit
  { systemName :: String
  , rowCount :: Int
  , columnCount :: Int
  , rankValue :: Int
  , nullityValue :: Int
  , rankDeficient :: Bool
  , pivotColumns :: String
  , freeColumns :: String
  , tolerance :: Double
  , interpretationWarning :: String
  } deriving (Show)

buildAudit :: RankNullityAudit
buildAudit =
  RankNullityAudit
    "three_constraint_resource_balance_matrix"
    3
    3
    3
    0
    False
    "0,1,2"
    "none"
    1.0e-10
    "Rank and nullity reveal structure, but model meaning requires row and column interpretation."

main :: IO ()
main =
  print buildAudit

The typed workflow keeps rank-nullity conclusions attached to governance context instead of treating them as context-free facts.

Back to top ↑

SQL Workflow: Structural Dependence Registry

SQL can document rank, nullity, and dependence assumptions when matrix diagnostics support dashboards, planning systems, scientific-computing pipelines, optimization workflows, or institutional reports.

CREATE TABLE rank_nullity_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 rank_nullity_assumption_registry VALUES
(
  'rank',
  'Rank',
  'Measures the dimension of independent row or column structure.',
  'Shows the effective number of independent constraints, features, or output directions.',
  'Rank is not the same as model adequacy or truth.'
);

INSERT INTO rank_nullity_assumption_registry VALUES
(
  'nullity',
  'Nullity',
  'Measures the dimension of the null space.',
  'Shows how many independent freedom directions remain uncontrolled by the matrix.',
  'Nullity may indicate useful flexibility, missing information, or non-identifiability.'
);

INSERT INTO rank_nullity_assumption_registry VALUES
(
  'rank_nullity',
  'Rank-nullity theorem',
  'States that rank plus nullity equals the number of columns.',
  'Connects independent structure with remaining freedom in the model.',
  'The theorem is formal; interpretation depends on row and column meanings.'
);

INSERT INTO rank_nullity_assumption_registry VALUES
(
  'row_dependence',
  'Row dependence',
  'Indicates equations that are linear combinations of other equations.',
  'Signals redundant, repeated, or structurally linked constraints.',
  'Dependence may be meaningful or problematic depending on purpose.'
);

INSERT INTO rank_nullity_assumption_registry VALUES
(
  'column_dependence',
  'Column dependence',
  'Indicates variables or features that are linear combinations of others.',
  'Signals non-identifiability or overlapping variable effects.',
  'Dependent columns can make separate interpretation unreliable.'
);

INSERT INTO rank_nullity_assumption_registry VALUES
(
  'numerical_rank',
  'Numerical rank',
  'Classifies rank under finite precision and tolerance rules.',
  'Supports applied computation with noisy, scaled, or approximate data.',
  'Tolerance choices should be documented and sensitivity tested.'
);

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

This registry keeps rank-nullity analysis tied to independence, dependence, identifiability, tolerance, and responsible interpretation.

Back to top ↑

GitHub Repository

The companion repository for this article is designed as a reproducible mathematical-modeling workspace. It supports rank-nullity audits, structural dependence diagnostics, pivot and free-column reports, null-space freedom summaries, rank-deficiency checks, SQL governance tables, generated outputs, advanced mathematical audit reports, and reusable calculator scripts.

Back to top ↑

Interpretive Limits and Responsible Use

Rank, nullity, and structural dependence are powerful because they reveal independent structure and hidden freedom. They are limited because they analyze the matrix supplied. They do not validate the data, units, assumptions, omitted variables, measurement process, institutional context, or practical feasibility of decisions based on the model.

High rank does not guarantee a good model. Low rank does not necessarily mean a bad model. Nullity may represent useful flexibility or dangerous underdetermination. Dependence may be intentional or accidental. Numerical rank may depend on tolerance. A rank-nullity calculation should therefore be interpreted as evidence about structure, not as a final judgment about the real system.

Responsible use requires documenting row meanings, column meanings, coefficient units, data sources, rank method, numerical tolerance, dependence findings, null-space interpretation, identifiability limits, and the difference between algebraic structure and real-world validity.

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
• 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/.
• 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.) Singular Value Decomposition: scipy.linalg.svd. SciPy Documentation. Available at: https://docs.scipy.org/doc/scipy/reference/generated/scipy.linalg.svd.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/.
• 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.) Singular Value Decomposition: scipy.linalg.svd. SciPy Documentation. Available at: https://docs.scipy.org/doc/scipy/reference/generated/scipy.linalg.svd.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 ↑