Basis and Dimension

import numpy as np

# Change of basis
B = np.array([[1, 1], [1, -1]])  # New basis vectors as columns
B_inv = np.linalg.inv(B)

# Vector in standard basis
x_standard = np.array([3, 1])

# Coordinates in basis B
x_in_B = B_inv @ x_standard
print(f"Coordinates in new basis: {x_in_B}")  # [2. 1.]

# Verify: reconstruct from new coordinates
x_reconstructed = B @ x_in_B
print(f"Reconstructed: {x_reconstructed}")  # [3. 1.]

import numpy as np
from scipy.linalg import null_space

A = np.array([[1, 2, 0],
              [0, 0, 1],
              [0, 0, 0]])

ns = null_space(A)
print("Null space basis:")
print(ns)
# [[-0.89442719]
#  [ 0.4472136 ]
#  [ 0.        ]]

import numpy as np
from scipy.linalg import null_space, orth

def analyze_vector_space(A):
    """Comprehensive analysis of a matrix's vector space properties."""
    m, n = A.shape
    
    print(f"Matrix A ({m}x{n}):")
    print(A)
    print()
    
    # Rank
    rank = np.linalg.matrix_rank(A)
    print(f"Rank: {rank}")
    
    # Nullity
    nullity = n - rank
    print(f"Nullity: {nullity}")
    print(f"Rank + Nullity = {rank} + {nullity} = {rank + nullity} = n ✓")
    
    # Null space
    ns = null_space(A)
    print(f"\nNull space basis ({nullity} vectors):")
    print(ns) if ns.size > 0 else print("  {0}")
    
    # Column space
    cs = orth(A)
    print(f"\nColumn space basis ({rank} vectors):")
    print(cs)
    
    # Check if Ax = b has solutions
    b = np.array([1, 2, 3])
    try:
        x, residuals, rank_check, sv = np.linalg.lstsq(A, b, rcond=None)
        if np.allclose(A @ x, b):
            print(f"\nAx = b has solution: x = {x}")
        else:
            print(f"\nAx = b has no solution (b not in column space)")
    except:
        print(f"\nAx = b has no solution")
    
    return rank, nullity

# Example
A = np.array([[1, 2, 3],
              [4, 5, 6],
              [7, 8, 9]])

rank, nullity = analyze_vector_space(A)

print("\n" + "="*50)

# Finding a basis for the column space
def column_space_basis(A):
    """Find a basis for the column space using row reduction."""
    # Row reduce and find pivot columns
    U = np.array(A, dtype=float)
    pivot_cols = []
    row, col = 0, 0
    
    while row < U.shape[0] and col < U.shape[1]:
        # Find pivot
        max_row = np.argmax(np.abs(U[row:, col])) + row
        if U[max_row, col] == 0:
            col += 1
            continue
        
        # Swap rows
        U[[row, max_row]] = U[[max_row, row]]
        pivot_cols.append(col)
        
        # Eliminate below
        for i in range(row + 1, U.shape[0]):
            if U[i, col] != 0:
                U[i] -= U[i, col] / U[row, col] * U[row]
        
        row += 1
        col += 1
    
    return A[:, pivot_cols], pivot_cols

basis, pivots = column_space_basis(A)
print(f"Pivot columns: {pivots}")
print(f"Column space basis:")
print(basis)

# Linear independence check
def check_linear_independence(vectors):
    """Check if a set of vectors is linearly independent."""
    if vectors.shape[1] == 0:
        return True
    rank = np.linalg.matrix_rank(vectors)
    return rank == vectors.shape[1]

# Examples
v1 = np.array([[1], [0], [0]])
v2 = np.array([[0], [1], [0]])
v3 = np.array([[1], [1], [0]])
v4 = np.array([[1], [1], [1]])

print("\n{[1,0,0], [0,1,0]}:", check_linear_independence(np.hstack([v1, v2])))
print("{[1,0,0], [0,1,0], [1,1,0]}:", check_linear_independence(np.hstack([v1, v2, v3])))
print("{[1,0,0], [0,1,0], [1,1,1]}:", check_linear_independence(np.hstack([v1, v2, v4])))

# Change of basis
def change_of_basis(x_standard, P):
    """Change coordinates from standard basis to basis P."""
    P_inv = np.linalg.inv(P)
    return P_inv @ x_standard

# Vector in standard basis
x = np.array([3, 1])

# New basis: rotated 45 degrees
theta = np.pi / 4
P = np.array([[np.cos(theta), -np.sin(theta)],
              [np.sin(theta),  np.cos(theta)]])

x_new = change_of_basis(x, P)
print(f"\nVector {x} in standard basis")
print(f"Coordinates in rotated basis: {x_new}")
print(f"Verification: {P @ x_new}")

# PCA as change of basis
from sklearn.decomposition import PCA
import numpy as np

# Generate sample data
np.random.seed(42)
n_samples = 200
X = np.random.randn(n_samples, 2) @ np.array([[3, 1], [1, 2]])

# PCA finds the optimal basis
pca = PCA(n_components=2)
X_transformed = pca.fit_transform(X)

print("Original data shape:", X.shape)
print("Transformed data shape:", X_transformed.shape)
print("Explained variance ratio:", pca.explained_variance_ratio_)
print("Principal components (new basis):")
print(pca.components_)  # These are the basis vectors

# The principal components form an orthonormal basis
dot_product = np.dot(pca.components_[0], pca.components_[1])
print(f"Dot product of components (should be 0): {dot_product:.10f}")

# Reconstruction: X ≈ X_transformed @ pca.components_
X_reconstructed = X_transformed @ pca.components_ + pca.mean_
reconstruction_error = np.mean((X - X_reconstructed) ** 2)
print(f"Reconstruction MSE: {reconstruction_error:.6f}")