Algebraic Topology

Algebraic topology uses tools from abstract algebra to study topological spaces. The goal is to find algebraic invariants that classify topological spaces up to homeomorphism or homotopy equivalence.

Euler Characteristic and Simplicial Complexes

A simplicial complex is a space built from “building blocks” called simplices (points, line segments, triangles, tetrahedra). The Euler Characteristic $\chi$ is a topological invariant defined for a finite simplicial complex as: $\chi = V - E + F$ where $V, E, F$ are the numbers of vertices, edges, and faces respectively. More generally: $\chi = \sum_{n=0}^{\infty} (-1)^n c_n$ where $c_n$ is the number of $n$-simplices.

def calculate_euler(v, e, f):
  return v - e + f

# Tetrahedron: 4 vertices, 6 edges, 4 faces
print(f"Tetrahedron chi: {calculate_euler(4, 6, 4)}")

# Cube: 8 vertices, 12 edges, 6 faces
print(f"Cube chi:        {calculate_euler(8, 12, 6)}")

# Torus (triangulated): chi should be 0
v, e, f = 9, 27, 18
print(f"Torus chi:       {calculate_euler(v, e, f)}")

Homology Groups

Homology is a way of associating a sequence of abelian groups $H_n(X)$ to a topological space. Informally, $H_n(X)$ represents the ” $n$-dimensional holes” in $X$.

• $H_0(X)$ counts path-connected components.
• $H_1(X)$ counts “loops” or 1D holes.
• $H_2(X)$ counts “voids” or 2D holes.

The Fundamental Group

The fundamental group $\pi_1(X, x_0)$ consists of equivalence classes of loops based at $x_0$ under homotopy. For a circle $S^1$, $\pi_1(S^1) \cong \mathbb{Z}$, representing the number of times a loop winds around the circle.

def winding_number(points):
  """Simple discrete winding number calculation around origin."""
  import numpy as np
  angles = np.arctan2([p[1] for p in points], [p[0] for p in points])
  diffs = np.diff(angles)
  # Adjust for wrap-around
  diffs[diffs > np.pi] -= 2*np.pi
  diffs[diffs < -np.pi] += 2*np.pi
  return round(np.sum(diffs) / (2*np.pi))

# A circle loop
theta = np.linspace(0, 2*np.pi, 100)
circle_loop = [(np.cos(t), np.sin(t)) for t in theta]
print(f"Winding number (1 loop): {winding_number(circle_loop)}")

# A double loop
double_loop = [(np.cos(2*t), np.sin(2*t)) for t in theta]
print(f"Winding number (2 loops): {winding_number(double_loop)}")

Differential Geometry

Differential geometry uses the techniques of differential and integral calculus to study the geometry of curves and surfaces.

Geometry of Curves

A space curve is defined by a vector function $\mathbf{r}(t)$. The key invariants are curvature ($\kappa$) and torsion ($\tau$).

import numpy as np

def calculate_curvature(t_val, dr_dt, d2r_dt2):
  v1 = dr_dt(t_val)
  v2 = d2r_dt2(t_val)
  cross_product = np.cross(v1, v2)
  norm_v1 = np.linalg.norm(v1)
  kappa = np.linalg.norm(cross_product) / (norm_v1**3)
  return kappa

# Helix: r(t) = (cos t, sin t, t)
dr_dt = lambda t: np.array([-np.sin(t), np.cos(t), 1])
d2r_dt2 = lambda t: np.array([-np.cos(t), -np.sin(t), 0])

print(f"Curvature of Helix at t=0: {calculate_curvature(0, dr_dt, d2r_dt2):.3f}")
print("Curvature is constant for a helix.")

Gaussian Curvature

For surfaces, Gaussian Curvature ($K$) is the product of the two principal curvatures. It is an intrinsic property, meaning it can be determined by measuring distances along the surface without reference to the surrounding space.

Gauss-Bonnet Theorem

The Gauss-Bonnet Theorem links the total curvature of a surface to its topology (Euler characteristic $\chi$): $\int_M K dA + \int_{\partial M} k_g ds = 2\pi \chi(M)$

def euler_characteristic(v, e, f):
  return v - e + f

# Cube: 8 vertices, 12 edges, 6 faces
print(f"Cube χ: {euler_characteristic(8, 12, 6)}")
# Tetrahedron: 4 vertices, 6 edges, 4 faces
print(f"Tetrahedron χ: {euler_characteristic(4, 6, 4)}")

Measure Theory & Lebesgue Integration

The Riemann integral, while foundational for introductory calculus, fails for functions that are “too discontinuous.” Measure theory provides a more robust framework by partitioning the range of a function rather than its domain.

1. The Failure of Riemann Integration

Consider the Dirichlet function, which is $1$ for rationals and $0$ for irrationals: $\mathbf{1}_{\mathbb{Q}}(x) = \begin{cases} 1 & x \in \mathbb{Q} \\ 0 & x \notin \mathbb{Q} \end{cases}$

In Riemann integration, any sub-interval contains both a rational and an irrational number. Thus, the lower rectangles always have height $0$ and the upper rectangles height $1$. They never meet.

The Lebesgue approach asks: “How ‘big’ is the set of rationals vs the set of irrationals?“. Since the rationals are countable, they have measure zero. The integral is effectively $0 \cdot (\text{size of irrationals}) + 1 \cdot (\text{size of rationals}) = 0$.

2. Measurable Spaces and $\sigma$-Algebras

To measure a set, we must first decide which sets are “legal” to measure.

Definition: $\sigma$-Algebra

A collection $\mathcal{F}$ of subsets of $X$ is a $\sigma$-algebra if:

1. $X \in \mathcal{F}$
2. $A \in \mathcal{F} \implies A^c \in \mathcal{F}$ (Closed under complements)
3. $A_n \in \mathcal{F} \implies \bigcup_{n=1}^\infty A_n \in \mathcal{F}$ (Closed under countable unions)

Definition: Measure

A measure $\mu$ is a function $\mu: \mathcal{F} \to [0, \infty]$ such that:

1. $\mu(\emptyset) = 0$
2. Countable Additivity: For disjoint sets $A_i$, $\mu(\bigcup_{i=1}^\infty A_i) = \sum_{i=1}^\infty \mu(A_i)$.

3. Measurable Functions

A function $f: X \to \mathbb{R}$ is measurable if for every Borel set $B \in \mathcal{B}(\mathbb{R})$, the preimage $f^{-1}(B)$ is in $\mathcal{F}$. Equivalently: $\{x \in X : f(x) > a \} \in \mathcal{F} \quad \forall a \in \mathbb{R}$

import numpy as np
import matplotlib.pyplot as plt

# A "discontinuous" function: 1 if sin(x) > 0, else 0
x = np.linspace(0, 10, 1000)
y = (np.sin(x) > 0).astype(float)

# In Lebesgue terms, we are measuring the set {x : f(x) = 1}
# This set is a collection of intervals [0, pi], [2pi, 3pi], etc.
# These intervals are easy to measure!

plt.figure(figsize=(10, 4))
plt.plot(x, y, label="f(x)")
plt.fill_between(x, y, alpha=0.3)
plt.title("Step Function (Easily Lebesgue Integrable)")
plt.legend()
plt.show()

4. The Lebesgue Integral Construction

The Lebesgue integral is built in three stages:

1. Simple Function: $s(x) = \sum_{i=1}^n a_i \mathbf{1}_{E_i}(x)$, where $E_i$ are measurable disjoint sets.
2. Integral of Simple Function: $\int_X s \, d\mu = \sum_{i=1}^n a_i \mu(E_i)$.
3. General Integrable Function: For a non-negative measurable function $f$: $\int_X f \, d\mu = \sup \left\{ \int_X s \, d\mu : 0 \le s \le f, s \text{ is simple} \right\}$

For general $f$, we split it into $f^+ = \max(f, 0)$ and $f^- = \max(-f, 0)$ and compute $\int f^+ d\mu - \int f^- d\mu$.

5. Almost Everywhere (a.e.)

In measure theory, we don’t care about what happens on “tiny” sets of measure zero. We say a property holds almost everywhere if the set of points where it fails has measure zero.

Example: If $f(x) = g(x)$ for all $x$ except at $x=0$, their Lebesgue integrals are identical. This is why we can integrate functions with “holes” or infinite spikes (as long as the spikes aren’t too “fat”).

6. Convergence Theorems

The true power of Lebesgue theory is how well it handles limits.

• Monotone Convergence: If $f_n$ grows towards $f$, the integrals grow towards the integral of $f$.
• Dominated Convergence: If $f_n \to f$ and all $f_n$ stay under some “umbrella” function $g$ that is integrable, then the limit of the integrals is the integral of the limit.

Riemannian Geometry

Riemannian geometry is the branch of differential geometry that studies Riemannian manifolds—manifolds equipped with a metric tensor.

The Metric Tensor

A Riemannian metric $g$ is a collection of inner products on the tangent spaces of a manifold. In coordinates, it is represented by a symmetric matrix $g_{ij}$.

import numpy as np

def calculate_length_on_manifold(g, path, dt):
  # Length L = integral sqrt(g_ij * dx^i/dt * dx^j/dt) dt
  length = 0
  for i in range(len(path) - 1):
      v = (path[i+1] - path[i]) / dt
      # Simplified: assumes g is constant locally
      speed = np.sqrt(v.T @ g @ v)
      length += speed * dt
  return length

# Polar metric: g = diag(1, r^2)
def polar_metric(r):
  return np.array([[1, 0], [0, r**2]])

# Circle path at r=1: (1, t) for t in [0, 2*pi]
dt = 0.01
t = np.arange(0, 2 * np.pi, dt)
path = np.column_stack((np.ones_like(t), t))

g = polar_metric(1.0)
print(f"Circumference (r=1): {calculate_length_on_manifold(g, path, dt):.3f}")

Geodesics

Geodesics are the “straightest possible” paths on a manifold. They generalize the notion of a line to curved spaces. In GR, particles move along geodesics in spacetime.

Curvature Tensors

Curvature in Riemannian geometry is captured by the Riemann Curvature Tensor $R^l_{ijk}$. It measures the extent to which parallel transport depends on the path taken.

def christoffel_symbol_approx(g_inv, dg_dx):
  # Very simplified version of Gamma calculations
  pass

print("Riemannian manifolds are the foundation of modern gravitation theory.")

General Topology

Topology is the study of properties that are preserved under continuous deformations, such as stretching and bending, but not tearing or gluing.

Metric Spaces

A metric space $(X, d)$ is a set $X$ with a distance function $d: X \times X \to \mathbb{R}$ satisfying:

1. Positivity: $d(x, y) \ge 0$, and $d(x, y) = 0 \iff x = y$.
2. Symmetry: $d(x, y) = d(y, x)$.
3. Triangle Inequality: $d(x, z) \le d(x, y) + d(y, z)$.

def check_metric_axioms(X, d):
  for x in X:
      for y in X:
          # Positivity
          if d(x, y) < 0: return False, "Negative distance"
          if x != y and d(x, y) == 0: return False, "Zero distance for distinct points"
          # Symmetry
          if d(x, y) != d(y, x): return False, "Symmetry failed"
          for z in X:
              # Triangle Inequality
              if d(x, z) > d(x, y) + d(y, z) + 1e-9:
                  return False, f"Triangle inequality failed for {x}, {y}, {z}"
  return True, "Valid Metric"

# Manhattan Distance
def taxicab(p1, p2):
  return abs(p1[0] - p2[0]) + abs(p1[1] - p2[1])

points = [(0,0), (1,1), (2,3), (10, 0)]
print(f"Taxicab metric: {check_metric_axioms(points, taxicab)}")

# Discrete Metric
def discrete(p1, p2):
  return 0 if p1 == p2 else 1

print(f"Discrete metric: {check_metric_axioms(points, discrete)}")

Topological Spaces

A topological space $(X, \tau)$ is a set $X$ with a collection of subsets $\tau$ (the open sets) such that:

1. $\emptyset \in \tau$ and $X \in \tau$.
2. Arbitrary unions of sets in $\tau$ are in $\tau$.
3. Finite intersections of sets in $\tau$ are in $\tau$.

def is_topology(X, tau):
  X_set = set(X)
  tau_sets = [set(s) for s in tau]
  
  # Empty set and X
  if set() not in tau_sets or X_set not in tau_sets:
      return False, "Missing empty set or X"
  
  # Finite Intersections
  import itertools
  for s1, s2 in itertools.combinations(tau_sets, 2):
      if s1.intersection(s2) not in tau_sets:
          return False, f"Intersection of {s1} and {s2} not in tau"
          
  # Binary Unions (covers arbitrary unions for finite sets)
  for s1, s2 in itertools.combinations(tau_sets, 2):
      if s1.union(s2) not in tau_sets:
          return False, f"Union of {s1} and {s2} not in tau"
          
  return True, "Valid Topology"

X = [1, 2, 3]
indiscrete = [[], [1, 2, 3]]
print(f"Indiscrete Topology: {is_topology(X, indiscrete)}")

overlap = [[], [1], [2], [1, 2, 3]]
print(f"Partial Overlap: {is_topology(X, overlap)}")

Continuity

A function $f: X \to Y$ is continuous if the preimage of every open set in $Y$ is open in $X$.

• Formally: $f$ is continuous if $\forall V \in \tau_Y, f^{-1}(V) \in \tau_X$.

In a Metric Space, this is equivalent to the $\epsilon-\delta$ definition: $f$ is continuous at $x_0$ if: $\forall \epsilon > 0, \exists \delta > 0 \text{ such that } d_X(x, x_0) < \delta \implies d_Y(f(x), f(x_0)) < \epsilon$

Compactness and Connectedness

A space is compact if every open cover has a finite subcover. A space is connected if it cannot be partitioned into two disjoint non-empty open sets.