Compression, Noise, and Informational Tradeoffs: How Linear Algebra Balances Simplification, Signal, and Loss

Last Updated July 3, 2026

Compression, noise, and informational tradeoffs explain how mathematical models simplify high-dimensional systems while deciding what structure to preserve, what variation to suppress, and what information to lose. In linear algebra, compression often appears through low-rank approximation, singular value truncation, principal components, projections, sparse representation, filtering, denoising, and residual analysis.

This article concludes Part VI of the Linear Algebra for Systems Modeling series by connecting singular value decomposition, principal component analysis, dimensionality reduction, latent structure, low-rank approximation, compression, noise filtering, reconstruction error, residual diagnostics, information loss, weak signals, rare events, validation, and responsible interpretation.

The central modeling question is not only “Can the system be compressed?” It is “What structure does compression preserve, what variation does it discard, which residuals are treated as noise, and whether the simplified representation remains trustworthy for the system purpose?”

Compression is the act of representing a system with fewer numbers, dimensions, components, variables, or parameters. Noise refers to variation treated as random, irrelevant, measurement error, or uninformative for a particular purpose. Informational tradeoffs arise because compression and denoising always change what the model can see.

Linear algebra makes these tradeoffs visible. Singular values rank structural strength. Low-rank approximations show how much of a matrix can be reconstructed from fewer components. Residuals show what has been discarded. Norms quantify reconstruction error. Projections determine which subspaces are retained. PCA explains variance retained by reduced components. Sparse representations reduce storage. Matrix factorizations extract latent structure. Every one of these operations simplifies, but none is neutral.

Why Compression and Noise Matter

Compression matters because systems data can be too large, high-dimensional, noisy, redundant, expensive, or complex to use directly. A climate simulation may produce massive spatial-temporal fields. Infrastructure networks may generate continuous sensor streams. Public health systems may track hundreds of correlated indicators. Machine learning pipelines may operate on high-dimensional feature spaces. Text systems may contain enormous document-term matrices or embeddings.

Noise matters because measurements are imperfect and systems are variable. Some variation reflects random measurement error. Some reflects short-term fluctuation. Some reflects omitted structure. Some reflects rare events. Some reflects a weak signal that becomes important later. The problem is that mathematics alone does not always tell which is which.

Compression is useful because it simplifies. It is risky because simplification can erase what matters.

Back to top ↑

Compression as Representation

Compression is not merely storage reduction. It is a representation choice. A compressed model decides which aspects of a system are important enough to keep and which aspects can be approximated, summarized, filtered, or discarded.

A generic compression workflow can be written as:

A compressed representation can be useful even when it is not perfectly faithful. The key is knowing what kind of fidelity matters for the task.

Back to top ↑

Noise as a Modeling Judgment

Noise is often described as unwanted variation. But “unwanted” depends on purpose. A fluctuation that looks like noise in a compression workflow may be an early warning signal in a safety workflow. A residual that looks random globally may be structured for a subgroup, region, time period, or rare event.

Noise is not purely mathematical. It is a claim about relevance, reliability, purpose, and acceptable loss.

Back to top ↑

Low-Rank Approximation

Low-rank approximation is one of the central linear algebra tools for compression. A matrix \(X\) is approximated by a matrix \(X_k\) of rank \(k\), where \(k\) is smaller than the original rank:

Low-rank approximation is useful when data contain redundancy, correlated variables, dominant modes, latent structure, or compressible patterns. It is common in image compression, recommendation systems, scientific simulations, sensor systems, text analysis, signal processing, and reduced-order modeling.

Low-rank approximation is not just a numerical shortcut. It is a statement that the system can be meaningfully summarized by fewer structural degrees of freedom.

Back to top ↑

SVD Compression

Singular value decomposition provides the standard framework for low-rank compression. If:

Then the rank-\(k\) truncated approximation is:

The Eckart-Young-Mirsky theorem explains why truncated SVD is so central: among all rank-\(k\) approximations, \(X_k\) is optimal under common matrix norms such as the Frobenius norm and spectral norm.

SVD compression is mathematically elegant because it ranks directions by strength. It still requires judgment because strength is not the same as meaning.

Back to top ↑

PCA Compression

PCA compresses centered data by retaining leading principal components. If \(X_c\) is centered and \(V_k\) contains the first \(k\) principal directions, the compressed coordinates are:

The reconstructed approximation is:

PCA compression is useful when the leading variance directions represent structure worth retaining. That assumption should be checked rather than assumed.

Back to top ↑

Denoising and Filtering

Denoising uses mathematical structure to suppress variation interpreted as noise. In SVD-based denoising, the leading singular components may be retained while smaller components are discarded:

This can be effective when the signal is low-rank and the noise is weak, random, or spread across many directions. It is risky when important signals are weak, sparse, local, rare, nonlinear, or hidden in smaller components.

Denoising should not be confused with truth extraction. It is a filtering decision under assumptions about signal and noise.

Back to top ↑

Reconstruction Error

Reconstruction error measures how much information is lost when compressed data are reconstructed. A common relative error is:

For SVD compression, the Frobenius reconstruction error has a direct relationship to discarded singular values:

Reconstruction error is necessary but not sufficient. A compressed model can have low aggregate error while failing precisely where the system is most vulnerable.

Back to top ↑

Residuals and Lost Information

The residual matrix is where compression leaves traces of what was not preserved:

Residuals should be examined rather than ignored. They may contain noise, measurement error, local structure, rare events, omitted variables, nonlinear dynamics, subgroup differences, regime changes, or early warning signals.

Residual analysis is the accountability layer of compression. It asks what the compressed model failed to carry forward.

Back to top ↑

Weak Signals and Rare Events

Compression often prioritizes dominant structure. That creates a risk: weak signals and rare events may be treated as noise. In many systems, however, weak or rare patterns are exactly what matter most. Early infrastructure stress, emerging disease clusters, ecological threshold changes, small subgroup harms, financial instability, cyber anomalies, and extreme climate signals may all begin as weak residual patterns.

A compression workflow should not automatically optimize away the weak. It should ask whether weak structure matters for the purpose of the model.

Back to top ↑

Sparse Representation

Sparse representation compresses systems by using many zeros or few active coefficients. A sparse vector or matrix can store meaningful structure efficiently when only a small number of entries carry most of the signal.

Sparsity appears in network adjacency matrices, incidence matrices, document-term matrices, recommender systems, high-dimensional features, optimization, compressed sensing, and scientific computing. Sparse representation is a form of compression because it stores only the structure that is present or active.

Sparsity can clarify structure, but zeros are also modeling claims. They require interpretation.

Back to top ↑

Compression Ratio and Storage

Compression ratio compares the size of the original representation to the size of the compressed representation. For a dense matrix \(X\in\mathbb{R}^{m\times n}\), storing the full matrix requires \(mn\) values. A rank-\(k\) SVD approximation stores \(U_k\), \(\Sigma_k\), and \(V_k\), requiring roughly:

The compression ratio can be written as:

Storage savings are not the only goal. A compressed representation should also preserve the structure needed for interpretation and use.

Back to top ↑

Information Loss and Model Purpose

Information loss is not inherently bad. Every useful model simplifies. The question is whether the loss is acceptable for the purpose. A compressed image may look visually faithful while losing pixel-level detail. A reduced simulation may preserve broad dynamics while losing local extremes. A denoised signal may improve trend detection while suppressing anomalies. A PCA reduction may retain most variance while losing group-specific structure.

Compression should be evaluated against purpose-specific loss, not only mathematical elegance.

Back to top ↑

Validation of Compressed Models

A compressed model should be validated before it is trusted. Validation should examine reconstruction error, residual structure, stability across ranks, sensitivity to preprocessing, subgroup error, downstream performance, and domain plausibility.

Validation converts compression from a mathematical trick into a defensible modeling workflow.

Back to top ↑

Compression in Systems Modeling

Systems modeling often depends on compression because real systems generate more information than can be directly interpreted. Compression supports reduced-order models, sensor monitoring, scenario analysis, embeddings, network analysis, climate simulation, public health dashboards, infrastructure resilience, and machine learning pipelines.

Compression is often necessary. Its risks can be managed only when loss, residuals, and assumptions are made visible.

Back to top ↑

Mathematical Deepening

This section adds a more formal layer. Compression, noise, and informational tradeoffs connect low-rank approximation, singular value truncation, matrix norms, reconstruction error, sparse representation, denoising, filtering, residual diagnostics, rank selection, validation, and information governance.

Back to top ↑

Back to top ↑

Computation and Reproducible Workflows

Computational workflows for compression and denoising should document the original matrix, preprocessing, scaling, retained rank, singular values, retained energy, compression ratio, reconstructed approximation, reconstruction error, row residuals, column residuals, discarded energy, threshold choices, weak-signal review, validation context, and interpretation warnings.

The companion repository treats compression as an auditable approximation workflow. 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 compression diagnostics.

For this article, the computational examples focus on SVD-based compression, retained energy, compression ratio, reconstruction error, residual diagnostics, weak-signal warnings, SQL governance tables, and responsible simplification.

Back to top ↑

Python Workflow: Compression and Noise Audit

The Python workflow below computes a compression audit for a synthetic systems measurement matrix. It performs SVD compression, reports retained energy, compression ratio, reconstruction error, residual diagnostics, and weak-signal warnings.

from __future__ import annotations

from dataclasses import asdict, dataclass
from pathlib import Path
import csv
import json
import numpy as np


@dataclass(frozen=True)
class CompressionNoiseAudit:
    model_name: str
    rows: int
    columns: int
    method: str
    preprocessing: str
    retained_rank: int
    retained_energy_ratio: float
    discarded_energy_ratio: float
    compression_ratio: float
    relative_reconstruction_error: float
    maximum_row_residual: float
    highest_residual_row: int
    noise_warning: str
    interpretation_warning: str


def build_measurement_matrix() -> np.ndarray:
    return np.array(
        [
            [82.0, 71.0, 18.0, 22.0, 41.0, 3.2],
            [79.0, 69.0, 17.0, 20.0, 39.0, 3.0],
            [85.0, 73.0, 20.0, 25.0, 43.0, 3.5],
            [48.0, 52.0, 35.0, 40.0, 62.0, 6.1],
            [51.0, 54.0, 38.0, 42.0, 64.0, 6.4],
            [46.0, 50.0, 34.0, 39.0, 60.0, 5.9],
            [68.0, 61.0, 27.0, 31.0, 52.0, 4.8],
            [70.0, 63.0, 29.0, 33.0, 54.0, 5.0],
            [90.0, 78.0, 42.0, 47.0, 71.0, 7.8],
        ],
        dtype=float,
    )


def standardize(x: np.ndarray) -> np.ndarray:
    return (x - x.mean(axis=0)) / x.std(axis=0, ddof=1)


def compression_noise_audit(retained_rank: int = 2) -> tuple[CompressionNoiseAudit, np.ndarray, np.ndarray]:
    x = build_measurement_matrix()
    xs = standardize(x)

    u, singular_values, vt = np.linalg.svd(xs, full_matrices=False)

    uk = u[:, :retained_rank]
    sk = singular_values[:retained_rank]
    vtk = vt[:retained_rank, :]

    reconstructed = uk @ np.diag(sk) @ vtk
    residuals = xs - reconstructed

    retained_energy = float(np.sum(sk ** 2) / np.sum(singular_values ** 2))
    discarded_energy = 1.0 - retained_energy

    rows, columns = xs.shape
    original_storage = rows * columns
    compressed_storage = retained_rank * (rows + columns + 1)
    compression_ratio = original_storage / compressed_storage

    relative_error = float(np.linalg.norm(residuals, ord="fro") / np.linalg.norm(xs, ord="fro"))
    row_residuals = np.sqrt(np.sum(residuals * residuals, axis=1))
    highest_residual_row = int(np.argmax(row_residuals))

    audit = CompressionNoiseAudit(
        model_name="synthetic_compression_noise_audit",
        rows=rows,
        columns=columns,
        method="svd_low_rank_compression",
        preprocessing="centered_and_standardized",
        retained_rank=retained_rank,
        retained_energy_ratio=round(retained_energy, 12),
        discarded_energy_ratio=round(discarded_energy, 12),
        compression_ratio=round(float(compression_ratio), 12),
        relative_reconstruction_error=round(relative_error, 12),
        maximum_row_residual=round(float(row_residuals.max()), 12),
        highest_residual_row=highest_residual_row,
        noise_warning=(
            "Discarded components are not automatically noise. They may contain weak signals, "
            "localized structure, subgroup patterns, anomalies, or early warning behavior."
        ),
        interpretation_warning=(
            "Compression preserves selected structure while losing or distorting other information. "
            "Retained rank, preprocessing, thresholds, residuals, and validation context should be documented."
        ),
    )

    return audit, singular_values, row_residuals


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, singular_values, row_residuals = compression_noise_audit()
    row = asdict(audit)

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

    with (output_dir / "tables" / "singular_value_energy.csv").open(
        "w", newline="", encoding="utf-8"
    ) as handle:
        writer = csv.DictWriter(handle, fieldnames=["index", "singular_value", "energy_share"])
        writer.writeheader()
        total_energy = float(np.sum(singular_values ** 2))
        for index, value in enumerate(singular_values):
            writer.writerow({
                "index": index + 1,
                "singular_value": round(float(value), 12),
                "energy_share": round(float(value ** 2 / total_energy), 12),
            })

    with (output_dir / "tables" / "row_residuals.csv").open(
        "w", newline="", encoding="utf-8"
    ) as handle:
        writer = csv.DictWriter(handle, fieldnames=["row_index", "residual_norm"])
        writer.writeheader()
        for index, value in enumerate(row_residuals):
            writer.writerow({
                "row_index": index,
                "residual_norm": round(float(value), 12),
            })

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


if __name__ == "__main__":
    write_outputs(Path("outputs"))
    print("Compression, noise, and informational tradeoff audit complete.")

This workflow keeps retained rank, compression ratio, reconstruction error, discarded energy, residual diagnostics, and interpretation warnings together.

Back to top ↑

R Workflow: Low-Rank Compression Diagnostics

R can support low-rank compression diagnostics using SVD, retained energy, reconstruction error, and residual norms.

X <- matrix(
  c(
    82, 71, 18, 22, 41, 3.2,
    79, 69, 17, 20, 39, 3.0,
    85, 73, 20, 25, 43, 3.5,
    48, 52, 35, 40, 62, 6.1,
    51, 54, 38, 42, 64, 6.4,
    46, 50, 34, 39, 60, 5.9,
    68, 61, 27, 31, 52, 4.8,
    70, 63, 29, 33, 54, 5.0,
    90, 78, 42, 47, 71, 7.8
  ),
  nrow = 9,
  byrow = TRUE
)

retained_rank <- 2
scaled_X <- scale(X, center = TRUE, scale = TRUE)
svd_result <- svd(scaled_X)

U_k <- svd_result$u[, 1:retained_rank, drop = FALSE]
S_k <- diag(svd_result$d[1:retained_rank], retained_rank, retained_rank)
V_k_t <- t(svd_result$v[, 1:retained_rank, drop = FALSE])

reconstructed <- U_k %*% S_k %*% V_k_t
residuals <- scaled_X - reconstructed

retained_energy_ratio <-
  sum(svd_result$d[1:retained_rank]^2) / sum(svd_result$d^2)

discarded_energy_ratio <- 1 - retained_energy_ratio

relative_reconstruction_error <-
  sqrt(sum(residuals^2)) / sqrt(sum(scaled_X^2))

row_residuals <- sqrt(rowSums(residuals^2))

original_storage <- nrow(scaled_X) * ncol(scaled_X)
compressed_storage <- retained_rank * (nrow(scaled_X) + ncol(scaled_X) + 1)
compression_ratio <- original_storage / compressed_storage

audit_record <- data.frame(
  model_name = "synthetic_compression_noise_audit",
  rows = nrow(X),
  columns = ncol(X),
  method = "svd_low_rank_compression",
  preprocessing = "centered_and_standardized",
  retained_rank = retained_rank,
  retained_energy_ratio = retained_energy_ratio,
  discarded_energy_ratio = discarded_energy_ratio,
  compression_ratio = compression_ratio,
  relative_reconstruction_error = relative_reconstruction_error,
  maximum_row_residual = max(row_residuals),
  highest_residual_row = which.max(row_residuals) - 1,
  noise_warning = paste(
    "Discarded components are not automatically noise. They may contain weak signals,",
    "localized structure, subgroup patterns, anomalies, or early warning behavior."
  ),
  interpretation_warning = paste(
    "Compression preserves selected structure while losing or distorting other information."
  )
)

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

write.csv(audit_record, "outputs/tables/r_compression_noise_audit.csv", row.names = FALSE)
write.csv(data.frame(index = seq_along(svd_result$d),
                     singular_value = svd_result$d,
                     energy_share = svd_result$d^2 / sum(svd_result$d^2)),
          "outputs/tables/r_singular_value_energy.csv",
          row.names = FALSE)
write.csv(data.frame(row_index = seq_along(row_residuals) - 1,
                     residual_norm = row_residuals),
          "outputs/tables/r_row_residuals.csv",
          row.names = FALSE)

print(audit_record)

This R workflow keeps compression metrics, residuals, discarded energy, and weak-signal warnings auditable.

Back to top ↑

Haskell Workflow: Typed Compression Records

Haskell can represent compression audit output as typed records, keeping retained rank, retained energy, compression ratio, reconstruction error, and warnings attached to the result.

module Main where

data CompressionNoiseAudit = CompressionNoiseAudit
  { modelName :: String
  , rows :: Int
  , columns :: Int
  , method :: String
  , preprocessing :: String
  , retainedRank :: Int
  , retainedEnergyRatio :: Double
  , discardedEnergyRatio :: Double
  , compressionRatio :: Double
  , relativeReconstructionError :: Double
  , maximumRowResidual :: Double
  , highestResidualRow :: Int
  , noiseWarning :: String
  , interpretationWarning :: String
  } deriving (Show)

buildAudit :: CompressionNoiseAudit
buildAudit =
  CompressionNoiseAudit
    "synthetic_compression_noise_audit"
    9
    6
    "svd_low_rank_compression"
    "centered_and_standardized"
    2
    0.962
    0.038
    1.6875
    0.195
    1.43
    8
    "Discarded components are not automatically noise; they may contain weak signals, localized structure, subgroup patterns, anomalies, or early warning behavior."
    "Compression preserves selected structure while losing or distorting other information."

main :: IO ()
main =
  print buildAudit

The typed record prevents compression metrics from being separated from the warnings that make them interpretable.

Back to top ↑

SQL Workflow: Compression Governance Registry

SQL can document compression assumptions when low-rank approximation, denoising, embeddings, feature reduction, dashboards, or scientific workflows support operational decisions.

CREATE TABLE compression_governance_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 compression_governance_registry VALUES
(
  'original_representation',
  'Original representation',
  'Defines the original matrix, signal, feature table, image, field, or state representation.',
  'Determines what compression can preserve or lose.',
  'Compression is only as meaningful as the original representation.'
);

INSERT INTO compression_governance_registry VALUES
(
  'preprocessing',
  'Preprocessing',
  'Defines centering, scaling, normalization, transformation, filtering, and weighting.',
  'Determines which structure appears dominant or discardable.',
  'Preprocessing choices can change compression results.'
);

INSERT INTO compression_governance_registry VALUES
(
  'compression_method',
  'Compression method',
  'Defines how the original representation is encoded, approximated, reconstructed, or filtered.',
  'Determines what structure is preserved.',
  'Different compression methods preserve different structure.'
);

INSERT INTO compression_governance_registry VALUES
(
  'retained_rank',
  'Retained rank',
  'Defines how many components or directions are kept.',
  'Controls compression ratio, reconstruction error, residuals, and interpretability.',
  'Rank choice should be justified and sensitivity-tested.'
);

INSERT INTO compression_governance_registry VALUES
(
  'noise_definition',
  'Noise definition',
  'Defines which variation is treated as noise or discardable residual.',
  'Determines what is suppressed or ignored.',
  'Discarded variation is not automatically noise.'
);

INSERT INTO compression_governance_registry VALUES
(
  'reconstruction_error',
  'Reconstruction error',
  'Measures how much original structure is not recovered by the compressed representation.',
  'Supports fidelity review.',
  'Aggregate error can hide localized loss.'
);

INSERT INTO compression_governance_registry VALUES
(
  'residual_review',
  'Residual review',
  'Defines how lost or unexplained information is examined.',
  'Supports discovery of weak signals, anomalies, omitted structure, or subgroup mismatch.',
  'Residuals should be reviewed before being dismissed.'
);

INSERT INTO compression_governance_registry VALUES
(
  'responsible_simplification',
  'Responsible simplification',
  'Defines how compression is explained, validated, and governed.',
  'Prevents compressed models from hiding consequential information loss.',
  'Compression should clarify structure without concealing uncertainty or harm.'
);

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

This registry keeps compression workflows tied to original representation, preprocessing, method choice, retained rank, noise definition, reconstruction error, residual review, and responsible simplification.

Back to top ↑

GitHub Repository

The companion repository for this article is designed as a reproducible mathematical-modeling workspace. It supports compression audits, SVD-based low-rank approximation, retained-energy summaries, compression-ratio calculations, reconstruction-error tables, residual diagnostics, weak-signal review, SQL governance tables, generated outputs, advanced mathematical audit reports, and reusable calculator scripts.

Back to top ↑

Interpretive Limits and Responsible Use

Compression is powerful because it makes complex systems easier to store, compute, visualize, denoise, and interpret. It can reveal dominant structure, reduce redundancy, suppress random variation, stabilize models, and support efficient workflows. Its limits arise because every compressed representation loses information. The question is not whether loss occurs, but whether the loss is understood, measured, justified, and acceptable for the purpose.

A discarded singular component is not automatically noise. A low-variance pattern is not automatically irrelevant. A low reconstruction error is not automatic fidelity. A compressed embedding is not automatic meaning. A denoised signal is not automatic truth. A sparse representation is not automatic structure. A dominant component may reflect scale, bias, sampling, or majority structure. A residual may contain anomaly, omitted dynamics, subgroup mismatch, rare events, local failures, or early warning signals.

Responsible use requires documenting original representation, preprocessing, scaling, compression method, retained rank, threshold choices, compression ratio, retained energy, discarded energy, reconstruction error, residual diagnostics, weak-signal review, validation context, and interpretation limits. Compression should make complexity manageable without hiding what has been simplified away.

Back to top ↑

Related Articles

• What Is Linear Algebra for Systems Modeling?
• Latent Structure and Signal Extraction
• Dimensionality Reduction Techniques
• Principal Component Analysis
• Singular Value Decomposition
• Orthogonal Decomposition and Structured Approximation
• Machine Learning and Linear Algebra
• Large-Scale Matrix Computation
• Sparse Matrices and Computational Efficiency
• Numerical Stability and Conditioning
• Decomposition Workflows for Systems Analysis
• Scaling, Normalization, and Comparative Structure
• When Linear Models Clarify and When They Distort
• Interpretation, Approximation, and Responsible Mathematical Modeling
• Linear Algebra for Systems Modeling
• Mathematical Modeling
• Systems Modeling
• Algorithms & Computational Reasoning
• Scientific Computing for Systems Modeling

Back to top ↑

Further Reading

• Candès, E.J., Romberg, J. and Tao, T. (2006) ‘Robust uncertainty principles: exact signal reconstruction from highly incomplete frequency information’, IEEE Transactions on Information Theory, 52(2), pp. 489–509. Available at: https://doi.org/10.1109/TIT.2005.862083.
• Cover, T.M. and Thomas, J.A. (2006) Elements of Information Theory. 2nd edn. Hoboken, NJ: Wiley. Available at: https://onlinelibrary.wiley.com/doi/book/10.1002/047174882X.
• Donoho, D.L. (2006) ‘Compressed sensing’, IEEE Transactions on Information Theory, 52(4), pp. 1289–1306. Available at: https://doi.org/10.1109/TIT.2006.871582.
• Eckart, C. and Young, G. (1936) ‘The approximation of one matrix by another of lower rank’, Psychometrika, 1, pp. 211–218. Available at: https://doi.org/10.1007/BF02288367.
• Golub, G.H. and Van Loan, C.F. (2013) Matrix Computations. 4th edn. Baltimore, MD: Johns Hopkins University Press. Available at: https://jhupbooks.press.jhu.edu/title/matrix-computations.
• Hansen, P.C. (2010) Discrete Inverse Problems: Insight and Algorithms. Philadelphia, PA: SIAM. Available at: https://epubs.siam.org/doi/book/10.1137/1.9780898718836.
• Jolliffe, I.T. (2002) Principal Component Analysis. 2nd edn. New York: Springer. Available at: https://link.springer.com/book/10.1007/b98835.
• Mallat, S. (2009) A Wavelet Tour of Signal Processing: The Sparse Way. 3rd edn. Burlington, MA: Academic Press. Available at: https://www.sciencedirect.com/book/9780123743701/a-wavelet-tour-of-signal-processing.
• Shannon, C.E. (1948) ‘A mathematical theory of communication’, Bell System Technical Journal, 27(3), pp. 379–423. Available at: https://doi.org/10.1002/j.1538-7305.1948.tb01338.x.
• Trefethen, L.N. and Bau, D. (1997) Numerical Linear Algebra. Philadelphia, PA: SIAM. Available at: https://epubs.siam.org/doi/book/10.1137/1.9780898719574.

Back to top ↑

References

• Candès, E.J., Romberg, J. and Tao, T. (2006) ‘Robust uncertainty principles: exact signal reconstruction from highly incomplete frequency information’, IEEE Transactions on Information Theory, 52(2), pp. 489–509. Available at: https://doi.org/10.1109/TIT.2005.862083.
• Cover, T.M. and Thomas, J.A. (2006) Elements of Information Theory. 2nd edn. Hoboken, NJ: Wiley. Available at: https://onlinelibrary.wiley.com/doi/book/10.1002/047174882X.
• Donoho, D.L. (2006) ‘Compressed sensing’, IEEE Transactions on Information Theory, 52(4), pp. 1289–1306. Available at: https://doi.org/10.1109/TIT.2006.871582.
• Eckart, C. and Young, G. (1936) ‘The approximation of one matrix by another of lower rank’, Psychometrika, 1, pp. 211–218. Available at: https://doi.org/10.1007/BF02288367.
• Golub, G.H. and Van Loan, C.F. (2013) Matrix Computations. 4th edn. Baltimore, MD: Johns Hopkins University Press. Available at: https://jhupbooks.press.jhu.edu/title/matrix-computations.
• Hansen, P.C. (2010) Discrete Inverse Problems: Insight and Algorithms. Philadelphia, PA: SIAM. Available at: https://epubs.siam.org/doi/book/10.1137/1.9780898718836.
• Jolliffe, I.T. (2002) Principal Component Analysis. 2nd edn. New York: Springer. Available at: https://link.springer.com/book/10.1007/b98835.
• Mallat, S. (2009) A Wavelet Tour of Signal Processing: The Sparse Way. 3rd edn. Burlington, MA: Academic Press. Available at: https://www.sciencedirect.com/book/9780123743701/a-wavelet-tour-of-signal-processing.
• Shannon, C.E. (1948) ‘A mathematical theory of communication’, Bell System Technical Journal, 27(3), pp. 379–423. Available at: https://doi.org/10.1002/j.1538-7305.1948.tb01338.x.
• Trefethen, L.N. and Bau, D. (1997) Numerical Linear Algebra. Philadelphia, PA: SIAM. Available at: https://epubs.siam.org/doi/book/10.1137/1.9780898719574.

Back to top ↑