Module 1a: Core Linear Algebra for Computational Astrophysics

Quick Navigation Guide¶

📚 Choose Your Learning Path¶

🎯 Navigation by Project Needs¶

Prerequisites Self-Check¶

Learning Objectives¶

By the end of this module, you will be able to:

• (1) Translate physical problems into vector and matrix representations 🔴

• (2) Apply conservation laws to identify invariant mathematical structures 🟡

• (3) Calculate eigenvalues and eigenvectors for 2×2 and 3×3 matrices by hand 🟡

• (4) Choose the appropriate matrix operations for computational efficiency 🔴

• (5) Connect linear algebra concepts to N-body dynamics and Monte Carlo methods 🟡

• (6) Debug numerical issues using condition numbers and matrix properties 🔴

Prerequisites Review¶

Module Overview¶

This module builds your understanding from first principles, following the progression of Projects 1-3. We start with scalars and vectors describing individual stellar properties and positions (Project 1), build to matrices transforming entire systems (Project 2), and explore how eigenvalues reveal stability and oscillation modes (Project 3). Module 0b will extend these foundations to statistical methods and machine learning.

Part 1: The Opening - A Globular Cluster as a Mathematical Universe¶

Priority: 🟡 Important - Provides physical context for abstract concepts

1.1 The Physical System That Motivates Everything¶

Consider Omega Centauri, the most massive globular cluster orbiting our galaxy. It contains approximately 10 million stars, all gravitationally bound, orbiting their common center of mass for the past 12 billion years. At its core, stellar densities reach thousands of stars per cubic parsec – if Earth orbited a star there, our night sky would blaze with thousands of stars brighter than Venus.

To simulate this cluster, we need to track for each star:

• Position: $\vec{r}_i = (x_i, y_i, z_i)$ measured from the cluster center

• Velocity: $\vec{v}_i = (v_{x,i}, v_{y,i}, v_{z,i})$ relative to the cluster’s motion

That’s 6 million numbers evolving according to Newton’s laws. The gravitational force on star $i$ is:

Each star feels forces from all others. For $N = 10^7$ stars (Omega Centauri’s estimated count), the number of unique pairwise interactions is $N(N-1)/2 ≈ 5×10^{13}$. That’s approximately 50 trillion unique force pair calculations per timestep! Without linear algebra, this would be impossible. With it, we can organize these calculations efficiently, identify conserved quantities, and understand the cluster’s long-term evolution.

1.2 Conservation Laws: The Hidden Structure¶

Priority: 🟡 Important - Fundamental for understanding physical constraints

The cluster’s apparent chaos hides profound order. Despite the complex individual stellar orbits, certain quantities never change:

Here are the updated equations with terms properly introduced at first appearance:

Total Energy:

where $m_i$ is the mass of star $i$, $\vec{v}_i$ is its velocity vector, $G$ is the gravitational constant, and $|\vec{r}_i - \vec{r}_j|$ is the distance between stars $i$ and $j$. The first term is the total kinetic energy and the second term is the total gravitational potential energy (summed over all unique pairs).

Total Momentum:

This vector sum represents the net momentum of the entire cluster.

Total Angular Momentum:

where $\vec{r}_i$ is the position vector of star $i$ from the cluster center and $\times$ denotes the cross product. This measures the total rotational momentum of the system.

These conservation laws aren’t accidents – they arise from fundamental symmetries of space and time. Emmy Noether proved that every continuous symmetry implies a conservation law:

These symmetries manifest mathematically as properties of vectors and matrices. Translation invariance means physics doesn’t change when we add the same vector to all positions. Rotational invariance means physics is preserved under orthogonal transformations.

1.3 The Phase Space Perspective¶

Priority: 🟡 Important - Conceptual foundation for Projects 2-6

Here’s the profound insight that changes everything: the million-star cluster isn’t really moving through 3D space. It’s tracing a trajectory through a 6-million-dimensional phase space where each axis represents one position or velocity component. The system’s entire state is a single point in this vast space, and its time evolution is a trajectory through it.

This perspective reveals hidden simplicities:

• Conservation laws constrain the trajectory to a lower-dimensional surface - Just as a ball rolling in a bowl is confined to the bowl’s 2D surface despite existing in 3D space, the cluster’s evolution is restricted to a much smaller subspace where energy, momentum, and angular momentum remain constant. The 6-million dimensions collapse to far fewer effective dimensions.

• Near equilibrium, motion decomposes into independent oscillation modes (eigenvectors) - Like a drum that vibrates in distinct patterns (fundamental, overtones), the cluster has natural oscillation modes. Small disturbances trigger these modes independently, each oscillating at its own characteristic frequency - these are the eigenvectors and eigenvalues of the system.

• Statistical properties emerge from the geometry of this high-dimensional space - Velocity dispersion, dynamical stability, and evolution rates aren’t separate properties but geometric features of how the system explores phase space. The volume it occupies relates to entropy, the shape of its trajectory relates to energy distribution, and the curvature of energy surfaces determines bound vs. unbound orbits. (See Module 1a, Section 4 for the deep connection between stellar dynamics and statistical mechanics.)

Part 2: Vectors - The Atoms of Physical Description¶

Priority: 🔴 Essential - Foundation for everything that follows

2.1 From Scalars to Vectors: Building Deep Understanding {#part-2-vectors}¶

The simplest quantities in physics are scalars – single numbers that have magnitude but no direction. Mass ($2×10^{33}$ g), temperature (5800 K), luminosity ($3.8×10^{33}$ erg/s), and density (1.4 g/cm³) are all scalars. They tell us “how much” but not “which way.” For many physical quantities, however, magnitude alone is insufficient – we need direction too. This is where vectors enter.

A vector is simultaneously three complementary things, and masterful computational scientists fluidly shift between these perspectives:

• Physical Perspective: A vector represents any quantity with both magnitude and direction. The velocity of Earth orbiting the Sun is a vector — it has a speed (30 km/s) and a direction (tangent to the orbit). Forces, electric fields, angular momenta — all are vectors because they have this magnitude-direction character that scalars cannot express.

• Geometric Perspective: A vector is an arrow in space. Crucially, this arrow is free — it doesn’t have a fixed starting point. The displacement “3 km north” is the same vector whether you start from your house or from campus. This freedom is what allows us to add forces acting at different points on a rigid body.

• Algebraic Perspective: A vector is an ordered list of numbers — its components in some coordinate system. Earth’s velocity might be written as:

But here’s the crucial insight: these numbers are not the vector itself – they’re just one representation. The vector exists independently of any coordinate system.

2.2 Vector Spaces: The Mathematical Framework¶

Priority: 🟡 Important - Theoretical foundation

A vector space is a set equipped with two operations (vector addition and scalar multiplication) that satisfy eight axioms. These axioms aren’t arbitrary mathematical rules – each captures an essential physical property:

Linear independence means vectors cannot be written as combinations of each other - they represent truly independent directions in space.

2.3 The Dot Product: Projection, Angle, and Energy¶

Priority: 🔴 Essential - Used constantly throughout all projects

The dot product is perhaps the most important operation in physics because it answers a fundamental question: “How much does one vector contribute in the direction of another?”

Definition and Formula:

But why are these two formulas equal? Let’s derive this connection from first principles.

Physical Applications of the Dot Product:

Work Done by a Force:

Only the component of force along the displacement does work. A force perpendicular to motion (like the normal force on a sliding block) does zero work.

Power from Solar Panels:

where $\vec{S}$ is the solar flux vector and $\hat{n}$ is the panel’s normal. Maximum power when facing the sun ($\theta = 0$), zero when edge-on ($\theta = 90°$).

2.4 The Cross Product: Creating Perpendicularity¶

Priority: 🔴 Essential - Critical for angular momentum in Project 2

The cross product creates a vector perpendicular to two input vectors:

Memory Aid - The Determinant Method:

The cross product can be computed as a determinant:

Expanding this determinant along the first row:

Alternative Pattern Method:

• i-component: Take the y and z components: $(a_y b_z - a_z b_y)$

• j-component: Take the x and z components with a minus sign: $-(a_x b_z - a_z b_x)$

• k-component: Take the x and y components: $(a_x b_y - a_y b_x)$

Notice the pattern: each component uses the two coordinates that aren’t its own, and the j-component has a negative sign (this comes from the alternating signs in determinant expansion).

Geometric Intuition: To find the direction of $\vec{a} \times \vec{b}$, use the right-hand rule: curl your right hand’s fingers from the first vector $\vec{a}$ toward the second vector $\vec{b}$ through the smaller angle. Your thumb points in the direction of the cross product. This isn’t arbitrary - it ensures consistency with our choice of right-handed coordinate systems.

Key Properties:

• Magnitude: $|\vec{a} \times \vec{b}| = |\vec{a}||\vec{b}|\sin\theta$ (area of parallelogram)

• Direction: Right-hand rule

• Anti-commutative: $\vec{a} \times \vec{b} = -\vec{b} \times \vec{a}$

Physical Meaning - Angular Momentum:

For a star at position $\vec{r}$ with momentum $\vec{p} = m\vec{v}$:

This vector is perpendicular to the orbital plane. Its magnitude equals twice the rate of area swept out—this is Kepler’s second law!

2.5 Orthogonality: When Vectors Don’t Talk¶

Priority: 🟡 Important - Essential for understanding basis vectors

Two vectors are orthogonal (perpendicular) when their dot product is zero: $\vec{a} \cdot \vec{b} = 0$. This isn’t just a geometric curiosity - orthogonality is why we can decompose complex systems into independent components.

Why Orthogonal Bases Are Special:

When basis vectors are orthonormal (orthogonal AND unit length), calculations become dramatically simpler:

• Projections are independent: The component along one axis doesn’t affect others

• Pythagoras works: $|\vec{v}|^2 = v_x^2 + v_y^2 + v_z^2$

• Rotations preserve dot products: Orthogonal transformations preserve angles and lengths

Physical Example: In quantum mechanics, energy eigenstates are orthogonal. This means measuring one energy level doesn’t affect the probability of finding the system in another level. The orthogonality of spherical harmonics is why we can decompose the cosmic microwave background into independent multipole moments!

Astrophysical Application: When tracking stellar proper motions, observations often come in non-orthogonal coordinate systems (right ascension, declination, radial velocity). Orthogonalization creates independent velocity components where each represents truly independent motion - essential for understanding 3D stellar kinematics and discovering moving groups in the solar neighborhood.

2.6 Basis Vectors and Coordinate Systems¶

Priority: 🟡 Important - Needed when changing coordinate systems

A basis is a set of linearly independent vectors that span the entire space. The familiar Cartesian basis:

These are orthonormal: mutually perpendicular and unit length.

Any vector can be decomposed:

The coefficients are found by projection (via the dot product):

Progressive Problems: Vectors¶

Part 3: Matrices - Transformations That Preserve Structure¶

Priority: 🔴 Essential - Core to all computational methods

3.1 Matrices ARE Linear Transformations¶

You’ve mastered vectors - quantities with magnitude and direction. But what happens when you need to transform many vectors simultaneously? This is where matrices emerge naturally. A matrix isn’t just a grid of numbers - it’s a machine that transforms entire vector spaces. When you multiply a matrix by a vector, you’re asking: “Where does this vector go under this transformation?” This perspective transforms matrices from abstract number arrays into concrete geometric operations. When we multiply matrix $A$ by vector $\vec{v}$, we get a new vector $A\vec{v}$. The crucial property is linearity:

3.2 Building Intuition with Concrete Examples¶

Priority: 🔴 Essential - Recognize these patterns in your code

Let’s see actual matrices and understand what they do:

The Identity Matrix (the “do nothing” transformation):

Notice the diagonal of ones! For any vector: $I\vec{v} = \vec{v}$. Visually, this leaves all vectors exactly where they are - no rotation, no scaling, no shearing.

A Rotation Matrix (30° around z-axis):

Note: $\frac{\sqrt{3}}{2} \approx 0.866$ and $\frac{1}{2} = 0.5$. The $z$-component is unchanged (last row is [0, 0, 1]) because we rotate around $z$. Imagine looking down the $z$-axis: this matrix spins everything counterclockwise by 30° like a record player, preserving all lengths.

A Diagonal Matrix (scaling transformation):

Doubles $x$, triples $y$, leaves $z$ unchanged. Only diagonal elements are non-zero! This stretches space non-uniformly - imagine stretching a rubber sheet more in one direction than another.

A Symmetric Matrix (moment of inertia):

Notice $I_{ij} = I_{ji}$ (boxed elements show symmetry). Symmetric matrices represent reciprocal relationships - if $x$ affects $y$, then $y$ affects $x$ equally.

The Transpose Matrix:

The transpose swaps rows and columns: $(A^T)_{ij} = A_{ji}$.

Critical for covariance matrices where $\Sigma = \Sigma^T$ (symmetry). The transpose appears everywhere in physics:

• Inner products: $\vec{u} \cdot \vec{v} = \vec{u}^T \vec{v}$

• Quadratic forms: $\vec{x}^T A \vec{x}$

• Normal equations: $A^T A \vec{x} = A^T \vec{b}$

3.3 Matrix Multiplication: Composition of Transformations¶

Priority: 🔴 Essential - Fundamental operation

Matrix multiplication encodes function composition. The element in row $i$, column $j$ of product $AB$ is:

This seemingly weird formula ensures that:

Why Order Matters:

Consider rotating 90° around x-axis, then 90° around z-axis, versus the opposite order:

Different orders give different results! This is why $AB \neq BA$ in general.

Understanding Determinants - Three Levels:

Level 1 (Concrete): Det = 0 means “information is lost”

• Example: Projecting 3D onto 2D loses depth information

Level 2 (Geometric): Det measures volume scaling

• Example: det=2 means volumes double under transformation

Level 3 (Abstract): Det is the product of eigenvalues

• This connects spectrum to geometry to invertibility!

3.4 The Determinant: Volume, Orientation, and Information¶

Priority: 🟡 Important - Helps understand singularity and numerical stability

The determinant tells us three crucial things:

When $\det(A) = 0$, the matrix is singular and has rank less than its dimension. Let’s understand what this really means:

Intuitive Understanding of Rank:

• Full rank (rank = n for n×n matrix): All rows/columns point in independent directions. The matrix preserves dimensionality—3D space stays 3D.

• Rank deficient (rank < n): Some rows/columns are linear combinations of others. The matrix collapses space—maybe 3D becomes a 2D plane or even a 1D line.

Physical Example: Consider measuring stellar properties:

# Columns: [mass, luminosity, log(luminosity)]
data = np.array([
    [1.0,  1.0,  0.0],
    [2.0,  8.0,  0.9],
    [0.5,  0.125, -0.9]
])

This matrix has rank 2, not 3! The third column (log luminosity) is completely determined by the second column. We’re really only measuring 2 independent quantities, not 3. The covariance matrix of this data would be singular—we can’t invert it because one dimension is redundant.

Geometric Interpretation:

• Rank 3 matrix: Maps 3D space to full 3D space

• Rank 2 matrix: Squashes 3D space onto a 2D plane

• Rank 1 matrix: Collapses 3D space onto a 1D line

• Rank 0 matrix: Maps everything to a single point (zero matrix)

Specifically, an $n \times n$ matrix with rank $r < n$ maps $n$-dimensional space onto an $r$-dimensional subspace, losing $(n-r)$ dimensions of information.

For a 2×2 matrix:

Geometric interpretation: For 2×2 matrices, the determinant equals the (signed) area of the parallelogram formed by the column vectors. For 3×3 matrices, it’s the (signed) volume of the parallelepiped.

For a 3×3 matrix, the determinant can be computed by cofactor expansion along any row or column. The pattern extends to larger matrices, though computation becomes expensive ($O(n!)$ operations).

3.5 The Inverse: Undoing Transformations¶

Priority: 🟡 Important - Critical for solving systems

The inverse matrix $A^{-1}$ satisfies:

For a 2×2 matrix:

Notice you divide by the determinant – this is why singular matrices (det = 0) have no inverse!

Bridge to Module 0b: These matrix operations become statistical in Module 0b, where $A^T A$ creates covariance matrices encoding correlations. The transpose operation you learned here will be essential for understanding how data matrices generate covariance structures.

Progressive Problems: Matrices¶

Part 4: Eigenvalues and Eigenvectors - Finding Invariant Structure¶

Priority: 🟡 Important - Critical for stability analysis and convergence

4.1 The Eigenvalue Equation: Directions That Don’t Rotate {#part-4-eigenvalues}¶

Some special vectors are only scaled by a transformation:

These eigenvectors $\vec{v}$ and their eigenvalues $\lambda$ reveal fundamental structure.

Geometric Intuition: Imagine stretching a rubber sheet. Most directions get rotated as the sheet deforms, but along eigenvector directions, points only move closer to or farther from the origin without changing direction. These are the “natural axes” of the transformation.

Physical Example - Spinning Objects:

Consider a football. It has three principal axes:

• Long axis (through the points)

• Two short axes (perpendicular to long axis)

  • Spin it around the long axis → stable rotation

  • Spin it around a short axis → stable rotation

  • Spin it at any other angle → it wobbles!

The principal axes are eigenvectors of the moment of inertia tensor.

4.2 Finding Eigenvalues: The Characteristic Equation¶

To find eigenvalues:

1. Rearrange: $(A - \lambda I)\vec{v} = \vec{0}$

2. For non-trivial solutions: $\det(A - \lambda I) = 0$

3. This gives the characteristic equation

For an $n×n$ matrix, the characteristic polynomial has degree $n$, potentially yielding $n$ eigenvalues (counting multiplicity) in the complex numbers. The trace (sum of diagonal elements) equals the sum of eigenvalues.

4.3 Physical Meaning Throughout Your Projects¶

Physical Intuition: Why eigenvalues determine stability

Consider a star cluster near equilibrium. Small perturbations evolve as:

• If $\lambda < 0$: perturbation decays → stable (like a ball in a valley)

• If $\lambda > 0$: perturbation grows → unstable (like a ball on a hill)

• If $\lambda$ is complex: oscillation with growth/decay (spiral behavior)

The largest eigenvalue determines the fate: even one positive eigenvalue means the system will eventually fly apart!

For instance, a 2D rotation matrix has eigenvalues $e^{±iθ}$, where the imaginary unit explicitly encodes the rotation angle $θ$. This shows how complex eigenvalues naturally describe oscillatory behavior in physical systems.

Eigenvalues appear in most projects in this course:

Progressive Problems: Eigenvalues¶

Part 5: Numerical Reality - When Mathematics Meets Silicon (Essential Sections)¶

Priority: 🔴 Essential - Critical for debugging all projects

7.1 The Harsh Truth About Floating-Point Arithmetic¶

Computers can’t store infinite decimals, so they approximate real numbers using a finite representation:

where $m$ is the mantissa (fractional part) and $e$ is the exponent. Think of it as scientific notation in binary.

What This Means for 64-bit Doubles:

• 15-17 significant decimal digits (53 bits of mantissa precision, guaranteeing at least 15 decimal digits)

• Largest number: ~10^308 (exponent can go up to 1023)

• Smallest positive normal: ~10^-308 (exponent down to -1022)

• Machine epsilon: ~2.22×10^-16 (smallest distinguishable relative difference near 1.0)

The Shocking Truth About 0.1:

0.1 + 0.2 == 0.3  # False!
print(f"{0.1 + 0.2:.17f}")  # 0.30000000000000004

# Why? 0.1 in binary is actually:
# 0.00011001100110011001100110011... (repeating forever!)
# The computer truncates this at 53 bits, creating rounding error

Just like 1/3 = 0.333... repeats forever in decimal, 1/10 repeats forever in binary. The computer must truncate, introducing tiny errors that compound.

Catastrophic Cancellation - The Silent Killer:

When you subtract nearly equal numbers, you lose precision catastrophically. Here’s why:

# Example: Computing small angles in astronomy
star_position_1 = 89.99999999  # degrees (16 digits total)
star_position_2 = 90.00000001  # degrees (16 digits total)

angle_difference = star_position_2 - star_position_1
# Result: 0.00000002 (only 1 significant digit!)
# We went from 16 digits of precision to 1!

# Better approach: Reformulate to avoid subtraction
# Instead of (A + small) - A, compute small directly

Real Project 2 Example - Gravitational Forces:

# BAD: Force between very close stars
def gravitational_force_bad(pos1, pos2, m1, m2):
    dx = pos2[0] - pos1[0]  # Catastrophic if positions nearly equal!
    dy = pos2[1] - pos1[1]
    dz = pos2[2] - pos1[2]
    r_squared = dx**2 + dy**2 + dz**2  # Can become 0 or negative!
    return G * m1 * m2 / r_squared  # Division by ~0!

# GOOD: With softening parameter (regularization)
def gravitational_force_good(pos1, pos2, m1, m2, epsilon=1e-4):
    dx = pos2[0] - pos1[0]
    dy = pos2[1] - pos1[1]
    dz = pos2[2] - pos1[2]
    r_squared = dx**2 + dy**2 + dz**2 + epsilon**2  # Never zero!
    return G * m1 * m2 / r_squared

7.2 Condition Numbers: Measuring Numerical Danger¶

The condition number tells you how much input errors get amplified:

This means: relative error in solution ≤ condition number × relative error in input.

Intuitive Understanding:

• κ = 1: Perfect! Errors don’t amplify

• κ = 100: 1% input error → up to 100% output error

• κ = 10^6: Lose 6 digits of accuracy

• κ = 10^16: Complete garbage (for float64)

Real Example - Why Your Stellar Population Fits Fail:

# Fitting mass-luminosity relation: L = a*M^b
# Taking logs: log(L) = log(a) + b*log(M)

# Design matrix for 3 stars with similar masses
M = np.array([0.99, 1.00, 1.01])  # Solar masses
X = np.column_stack([np.ones(3), np.log(M)])

# Check condition number
print(f"Condition number: {np.linalg.cond(X):.1e}")
# Output: 4.5e+03 (problematic!)

# Why? The log(M) values are nearly identical!
# log(0.99) ≈ -0.0101, log(1.00) = 0, log(1.01) ≈ 0.0100
# The columns are nearly parallel → high condition number

# Fix: Use centered/scaled variables
M_scaled = (M - M.mean()) / M.std()
X_better = np.column_stack([np.ones(3), M_scaled])
print(f"Better condition number: {np.linalg.cond(X_better):.1e}")
# Output: 2.4e+00 (excellent!)

Emergency Debugging Checklist¶

Essential SciPy Linear Algebra Reference {#essential-scipy-reference}¶

Priority: 🔴 Essential - Keep this open while coding

One-Page Cheat Sheet¶

Glossary of Terms¶

All terms introduced in this module:

• basis: A set of linearly independent vectors that span the entire vector space

• characteristic equation: $\det(A - \lambda I) = 0$, whose roots are eigenvalues

• components: The scalar coefficients representing a vector in a chosen basis

• condition number: κ(A) = σ_max/σ_min, ratio of largest to smallest singular value; measures how much errors amplify

• conservation law: A physical quantity that remains constant over time due to an underlying symmetry

• cross product: Vector operation producing a perpendicular vector: $\vec{a} \times \vec{b}$

• determinant: Scalar value measuring how a linear transformation scales volumes

• dot product: Scalar operation on vectors: $\vec{a} \cdot \vec{b} = |\vec{a}||\vec{b}|\cos\theta$

• eigenvalue: The scaling factor for an eigenvector

• eigenvector: A vector that is only scaled (not rotated) by a transformation

• floating-point: Computer representation of real numbers with finite precision using scientific notation in binary

• globular cluster: A spherical collection of 10⁴ to 10⁶ stars bound by gravity, orbiting as satellites of galaxies

• linear algebra: The branch of mathematics concerning vector spaces and linear transformations between them

• linear independence: Vectors that cannot be written as linear combinations of each other

• linearity: Property where $f(αx + βy) = αf(x) + βf(y)$ for all scalars α, β and vectors x, y

• machine epsilon: Smallest distinguishable floating-point increment (~2.2×10⁻¹⁶ for float64); the gap between 1 and the next representable number

• matrix: A linear transformation represented as a rectangular array of numbers

• matrix inverse: The transformation that undoes another: $A^{-1}A = I$

• matrix multiplication: Operation combining two transformations into one: $(AB)\vec{v} = A(B\vec{v})$

• orthogonal: Perpendicular; vectors with zero dot product

• orthonormal: Basis vectors that are both orthogonal (perpendicular) and normalized (unit length)

• parameter: Most fundamentally: a number that controls the behavior of a mathematical function or system. In physics: quantities like mass, temperature, or coupling constants that define system properties but are not the variables being solved for

• parameter space: The space of all possible parameter values; each point represents a different configuration or model of the system

• phase space: The space of all possible states of a system; for N particles in 3D, has 6N dimensions (3 position + 3 velocity per particle)

• rank: The number of linearly independent rows (or columns) in a matrix; the dimension of the space the matrix actually maps to

• scalar: A quantity with magnitude only, represented by a single number

• symplectic: Transformation preserving phase space volume (determinant = 1)

• trace: Sum of diagonal elements, equals sum of eigenvalues

• trajectory: The path traced by a system’s state through phase space as it evolves in time

• transformation: A function mapping vectors to vectors that preserves vector space structure

• transpose: Operation swapping rows and columns: $(A^T)_{ij} = A_{ji}$

• vector: A mathematical object with both magnitude and direction that transforms according to specific rules

• vector space: A set equipped with addition and scalar multiplication operations satisfying eight specific axioms

Main Takeaways¶

Essential NumPy/SciPy Reference for Module 0a¶

Priority: 🔴 Essential - Keep this open while coding Projects 1-3

Module 0a Quick Reference Card¶

Next Steps¶

With this mathematical foundation firmly in place, you’re ready to tackle the computational challenges of modern astrophysics. In Project 1, you’ll immediately apply vector operations and matrix manipulations to handle stellar populations efficiently. In Project 2, you’ll see how eigenvalues determine orbital stability.

Module 0b continues with positive definite matrices, advanced topics, and the bridge to machine learning. Together, these modules provide the complete linear algebra foundation for computational astrophysics.

Remember: every algorithm you implement ultimately reduces to linear algebra. When numerical issues arise – and they will – return to these foundations. Check condition numbers, verify matrix properties, use appropriate decompositions. The mathematics you’ve learned here isn’t separate from computation – it IS computation in its purest form.

Welcome to computational astrophysics. You now speak its language.