认知神经科学研究报告【20260102】

Technical Document: Computing Matrix Rank and Linear Space Dimension in Python

Version 1.0
Date 2026-06-28
Subject Numerical determination of the maximum number of linearly independent vectors (rank) for an ( n \times n ) matrix, with a specific focus on the ( 100 \times 100 ) case.

1. Introduction

In linear algebra, the dimension of the vector space spanned by a set of vectors is equal to the maximum number of linearly independent vectors within that set. For a matrix ( A \in \mathbb{R}^{m \times n} ), this value is formally defined as the rank of the matrix:

$$\text{rank}(A)=\dim (\text{col}(A))=\dim (\text{row}(A))$$

This document details the standard Python methodology for calculating this rank, with benchmark examples specifically tailored to a 100 × 100 dense matrix.

2. Methodology

Python relies on two primary libraries for rank computation, depending on the required precision:

Underlying Algorithm (NumPy):
The function computes the Singular Value Decomposition (SVD):

$$A=U\Sigma V^T$$

The rank is determined by counting the number of singular values ( \sigma_i ) (diagonal entries of ( \Sigma )) that exceed a given numerical tolerance ( \tau ).

3. Implementation for a 100×100 Matrix

The following script demonstrates two typical scenarios:

1. A random matrix (generically full rank, i.e., rank = 100).
2. A low-rank matrix constructed as the product of two thin matrices (rank ≤ 10).

Code Example

import numpy as np
import time

# Set seed for reproducible results
np.random.seed(42)

N = 100
print(f"Matrix Dimension: {N}x{N}")
print("-" * 50)

# ------------------------------------------------------------------
# Scenario 1: Full-Rank Random Matrix
# ------------------------------------------------------------------
A_full = np.random.rand(N, N)

tic = time.perf_counter()
rank_full = np.linalg.matrix_rank(A_full)
toc = time.perf_counter()

print(f"[Full Rank] Computed rank: {rank_full}")
print(f"Execution time: {(toc - tic) * 1000:.3f} ms\n")

# ------------------------------------------------------------------
# Scenario 2: Low-Rank Matrix (Rank Deficient)
# A = (100x10) @ (10x100) => rank <= 10
# ------------------------------------------------------------------
A_low = np.random.rand(N, 10) @ np.random.rand(10, N)

tic = time.perf_counter()
rank_low = np.linalg.matrix_rank(A_low)
toc = time.perf_counter()

print(f"[Low Rank] Computed rank: {rank_low} (Expected: 10)")
print(f"Execution time: {(toc - tic) * 1000:.3f} ms\n")

4. Numerical Considerations: The Tolerance Parameter

For a 100×100 matrix, floating-point representation errors can cause theoretically zero singular values to appear as extremely small non-zero values (e.g., ( 10^{-15} )).

NumPy automatically applies a default tolerance:

$$\tau =\text{tol}=\text{max}(M,N)\cdot {\sigma }_{\text{max}}\cdot ϵ$$

Where:

• ( \sigma_{\text{max}} ) is the largest singular value.
• ( \epsilon ) is the machine epsilon (np.finfo(float).eps ≈ 2.22e-16).

For a 100×100 matrix, the default tolerance is approximately 100 * σ_max * 2.22e-16, which suffices for well-conditioned matrices.

Manual override: In cases of noisy measurements or ill-conditioned data, you can explicitly set a tolerance:

# Custom tolerance: treat singular values < 1e-10 as zero
rank_custom = np.linalg.matrix_rank(A_full, tol=1e-10)
print(f"Rank with custom tol (1e-10): {rank_custom}")

5. Exact Computation (SymPy)

If your 100×100 matrix consists of integers or fractions and you require an exact rank without numerical thresholding (e.g., for proof-of-concept or cryptographic applications), use SymPy:

from sympy import Matrix, randMatrix

# Generate a random 100x100 integer matrix (values between -10 and 10)
M_sym = randMatrix(100, 100, min=-10, max=10)

# Exact rank (performs Gaussian elimination over rationals)
rank_exact = M_sym.rank()
print(f"Exact SymPy rank: {rank_exact}")

Note: For a 100×100 dense symbolic matrix, this operation is significantly slower (seconds vs. milliseconds) compared to NumPy due to rational arithmetic overhead. Use exclusively when exactness is mandatory.

6. Performance Benchmark (100×100)

Result: For large-scale or time-critical applications (e.g., real-time signal processing), NumPy’s SVD-based approach is the industrial standard.

7. Conclusion

• The dimension of a linear space generated by the rows/columns of a 100×100 matrix is equal to its rank.
• For numerical applications, np.linalg.matrix_rank provides a fast, reliable metric using SVD, with default tolerances calibrated for double-precision arithmetic.
• For exact mathematical results, sympy.Matrix.rank remains the definitive tool, albeit with a significant performance trade-off.
• The provided code snippets are production-ready and require only standard installations (pip install numpy sympy).

Appendix: Quick Reference

Function signature:

numpy.linalg.matrix_rank(A, tol=None, hermitian=False)

• A : array_like, shape (M, N)
• tol : float, optional. Threshold below which SVD values are considered zero.
• hermitian : bool, optional. If True, assumes A is Hermitian (improves performance).

Return: Integer rank of the matrix.