Are the courses on CoursesHub.World free?

Yes, all courses on CoursesHub.World are completely free and open access. We believe in democratizing education and making university-level science courses available to everyone worldwide.

What subjects are covered on CoursesHub.World?

CoursesHub.World offers courses in physics (Quantum Mechanics, General Relativity, QFT, Plasma Physics, Cosmology), biology (Molecular Biology, Cell Physiology, Pharmacology), and earth sciences (Oceanography, Atmospheric Science, Climatology).

What level are the courses?

Our courses are designed at the graduate and advanced undergraduate level. They include rigorous mathematical derivations and are suitable for physics students, researchers, and serious self-learners.

Where do the video lectures come from?

Our 400+ video lectures come from world-renowned sources including MIT OpenCourseWare, Stanford, lectures by Nobel laureates, and other leading universities and educators.

← Back to Part I: Differential Geometry

Chapter 2: Tensor Analysis

Tensors are the natural mathematical objects that transform properly under coordinate changes. They form the language of general relativity, expressing physical laws in coordinate-independent form.

What is a Tensor?

A tensor of type (r, s) is a multilinear map that takes r covectors and s vectors as inputs and produces a real number. In component form:

$ T^{\mu_1...\mu_r}_{\;\;\;\;\;\;\;\nu_1...\nu_s} $

r contravariant indices (upper), s covariant indices (lower)

Transformation Law

Under coordinate transformation x^μ → x^μ', tensor components transform as:

$ T'^{\mu'}_{\;\;\nu'} = \frac{\partial x^{\mu'}}{\partial x^\mu} \frac{\partial x^\nu}{\partial x^{\nu'}} T^{\mu}_{\;\;\nu} $

Important Tensor Types

Scalars (0,0)

Invariant quantities: proper time τ, rest mass m, spacetime interval ds²

Vectors (1,0) and Covectors (0,1)

Vectors: $ V^\mu = (V^0, V^1, V^2, V^3) $ — tangent to curves

Covectors: $ \omega_\mu = (\omega_0, \omega_1, \omega_2, \omega_3) $ — gradients of functions

The Metric Tensor (0,2)

$ g_{\mu\nu} $ — defines distances, angles, and raises/lowers indices

The Riemann Tensor (1,3)

$ R^\rho_{\;\sigma\mu\nu} $ — encodes spacetime curvature

Tensor Operations

Addition

$ (A + B)^{\mu\nu} = A^{\mu\nu} + B^{\mu\nu} $

Same type tensors only

Tensor Product

$ (A \otimes B)^{\mu\nu} = A^\mu B^\nu $

Creates higher-rank tensor

Contraction

$ A^\mu_{\;\mu} = \sum_\mu A^\mu_{\;\mu} $

Reduces rank by 2

Index Raising/Lowering

$ V_\mu = g_{\mu\nu}V^\nu $

Uses metric tensor

Python: Tensor Transformations

Python

tensor_transform.py94 lines

#!/usr/bin/env python3
"""
╔══════════════════════════════════════════════════════════════════════════════╗
║                        TENSOR TRANSFORMATIONS                                ║
║                    Coordinate Transformations in SR/GR                       ║
╚══════════════════════════════════════════════════════════════════════════════╝

Demonstrates tensor transformation under Lorentz boosts.

KEY EQUATIONS:
-------------
Lorentz boost matrix (velocity v in x-direction):
  $ \Lambda^\mu_\nu = \begin{pmatrix} \gamma & -\gamma\beta & 0 & 0 \\\\ -\gamma\beta & \gamma & 0 & 0 \\\\ 0 & 0 & 1 & 0 \\\\ 0 & 0 & 0 & 1 \end{pmatrix} $

where $ \gamma = \frac{1}{\sqrt{1-\beta^2}} $, $ \beta = v/c $

Contravariant vector transformation:
  $ V'^\mu = \Lambda^\mu_\nu V^\nu $

Covariant vector transformation:
  $ \omega'_\mu = (\Lambda^{-1})^\nu_\mu \omega_\nu $

(0,2) tensor transformation:
  $ T'_{\mu\nu} = (\Lambda^{-1})^\alpha_\mu (\Lambda^{-1})^\beta_\nu T_{\alpha\beta} $

Invariant interval:
  $ u_\mu u^\mu = \eta_{\mu\nu} u^\mu u^\nu = 1 $ (for 4-velocity)

Run: python3 tensor_transform.py
"""
import numpy as np

def lorentz_boost(v, c=1.0):
    """Create Lorentz boost matrix for velocity v in x-direction"""
    beta = v / c
    gamma = 1.0 / np.sqrt(1 - beta**2)
    Lambda = np.array([
        [gamma, -gamma*beta, 0, 0],
        [-gamma*beta, gamma, 0, 0],
        [0, 0, 1, 0],
        [0, 0, 0, 1]
    ])
    return Lambda

def transform_vector(V, Lambda):
    """Transform contravariant vector: V'^mu = Lambda^mu_nu V^nu"""
    return Lambda @ V

def transform_covector(omega, Lambda):
    """Transform covariant vector: omega'_mu = (Lambda^-1)^nu_mu omega_nu"""
    Lambda_inv = np.linalg.inv(Lambda)
    return omega @ Lambda_inv

def transform_tensor_02(T, Lambda):
    """Transform (0,2) tensor: T'_mu_nu = (L^-1)^a_mu (L^-1)^b_nu T_ab"""
    L_inv = np.linalg.inv(Lambda)
    return L_inv.T @ T @ L_inv

# Example: Minkowski metric under Lorentz boost
eta = np.diag([1, -1, -1, -1])  # Minkowski metric (+---)

v = 0.6  # velocity as fraction of c
Lambda = lorentz_boost(v)

print("Lorentz boost matrix (v = 0.6c):")
print(Lambda)
print()

# Transform the metric
eta_prime = transform_tensor_02(eta, Lambda)
print("Minkowski metric after boost:")
print(np.round(eta_prime, 10))
print()
print("Note: eta_prime = eta (Lorentz invariance!)")
print()

# Transform a 4-velocity
u = np.array([1, 0, 0, 0])  # particle at rest
u_prime = transform_vector(u, Lambda)
gamma = 1/np.sqrt(1 - v**2)
print(f"4-velocity at rest: {u}")
print(f"4-velocity after boost: {u_prime}")
print(f"Expected: [gamma, gamma*v, 0, 0] = [{gamma:.4f}, {gamma*v:.4f}, 0, 0]")
print()

# Verify invariant: u_mu u^mu = 1
u_cov = eta @ u  # lower the index
invariant = u @ u_cov
print(f"u_mu u^mu (rest frame) = {invariant}")

u_prime_cov = eta_prime @ u_prime
invariant_prime = u_prime @ u_prime_cov
print(f"u'_mu u'^mu (boosted frame) = {invariant_prime:.10f}")
print("Invariant is preserved!")

Click Run to execute the Python code

Code will be executed with Python 3 on the server

Fortran: Tensor Contraction

Fortran + Python: Tensor Operations

Python

Compiles Fortran tensor code and visualizes components as heatmaps

tensor_plot.py123 lines

import subprocess, sys
import numpy as np
import matplotlib
matplotlib.use('Agg')
import matplotlib.pyplot as plt

fortran_source = r"""
program tensor_contraction
    implicit none
    integer, parameter :: dp = selected_real_kind(15)
    real(dp) :: g(4,4), A(4,4), B(4,4)
    real(dp) :: trace_A, contraction
    integer :: i, j, k

g = 0.0_dp
    g(1,1) = 1.0_dp; g(2,2) = -1.0_dp; g(3,3) = -1.0_dp; g(4,4) = -1.0_dp

A = 0.0_dp
    A(1,1) = 2.0_dp; A(1,2) = 1.0_dp
    A(2,1) = 1.0_dp; A(2,2) = 3.0_dp
    A(3,3) = 1.0_dp; A(4,4) = 1.0_dp

trace_A = 0.0_dp
    do i = 1, 4
        trace_A = trace_A + A(i,i)
    end do

write(*,'(A)') 'Tensor Operations in GR'
    write(*,'(A)') '========================'
    write(*,'(A,F10.4)') 'Trace A^mu_mu = ', trace_A

B = 0.0_dp
    do i = 1, 4
        do j = 1, 4
            do k = 1, 4
                B(i,j) = B(i,j) + g(i,k) * A(k,j)
            end do
        end do
    end do

contraction = 0.0_dp
    do i = 1, 4
        do j = 1, 4
            contraction = contraction + A(i,j) * B(i,j)
        end do
    end do
    write(*,'(A,F10.4)') 'Double contraction = ', contraction
    write(*,'(A)') ''

write(*,'(A)') 'DATA_START'
    write(*,'(A)') 'row,col,A_up,A_down,g'
    do i = 1, 4
        do j = 1, 4
            write(*,'(I2,A,I2,A,F12.6,A,F12.6,A,F12.6)') &
                i, ',', j, ',', A(i,j), ',', B(i,j), ',', g(i,j)
        end do
    end do
    write(*,'(A)') 'DATA_END'
end program tensor_contraction
"""

with open('tensor.f90', 'w') as f:
    f.write(fortran_source)

comp = subprocess.run(['gfortran', '-o', './tensor', 'tensor.f90'],
                      capture_output=True, text=True)
if comp.returncode != 0:
    print("Compilation error:", comp.stderr)
    sys.exit(1)

result = subprocess.run(['./tensor'], capture_output=True, text=True, timeout=30)

lines = result.stdout.strip().split('\n')
data_lines = []
in_data = False
for line in lines:
    if 'DATA_START' in line:
        in_data = True
        continue
    if 'DATA_END' in line:
        in_data = False
        continue
    if in_data:
        data_lines.append(line.strip())
    else:
        print(line)

data = np.array([[float(x) for x in line.split(',')] for line in data_lines[1:]])
A_up = data[:, 2].reshape(4, 4)
A_down = data[:, 3].reshape(4, 4)

fig, (ax1, ax2) = plt.subplots(1, 2, figsize=(12, 5))
fig.patch.set_facecolor('#0f172a')

labels = ['t', 'x', 'y', 'z']
im1 = ax1.imshow(A_up, cmap='coolwarm', aspect='equal', vmin=-3, vmax=3)
ax1.set_xticks(range(4)); ax1.set_yticks(range(4))
ax1.set_xticklabels(labels, color='#cbd5e1')
ax1.set_yticklabels(labels, color='#cbd5e1')
for i in range(4):
    for j in range(4):
        ax1.text(j, i, f'{A_up[i,j]:.1f}', ha='center', va='center',
                color='white' if abs(A_up[i,j]) > 1.5 else '#cbd5e1', fontsize=12, fontweight='bold')
ax1.set_title(r'$A^\mu{}_\nu$ (mixed tensor)', color='#e2e8f0', fontsize=14, fontweight='bold')
fig.colorbar(im1, ax=ax1, shrink=0.8)
ax1.set_facecolor('#1e293b')

im2 = ax2.imshow(A_down, cmap='coolwarm', aspect='equal', vmin=-3, vmax=3)
ax2.set_xticks(range(4)); ax2.set_yticks(range(4))
ax2.set_xticklabels(labels, color='#cbd5e1')
ax2.set_yticklabels(labels, color='#cbd5e1')
for i in range(4):
    for j in range(4):
        ax2.text(j, i, f'{A_down[i,j]:.1f}', ha='center', va='center',
                color='white' if abs(A_down[i,j]) > 1.5 else '#cbd5e1', fontsize=12, fontweight='bold')
ax2.set_title(r'$A_{\mu\nu}=g_{\mu\rho}A^\rho{}_\nu$', color='#e2e8f0', fontsize=14, fontweight='bold')
fig.colorbar(im2, ax=ax2, shrink=0.8)
ax2.set_facecolor('#1e293b')

plt.tight_layout()
plt.savefig('output.png', dpi=150, bbox_inches='tight', facecolor='#0f172a')
print("\nVisualization saved to output.png")

Click Run to execute the Python code

Code will be executed with Python 3 on the server

Einstein Summation Convention

Repeated indices (one up, one down) are implicitly summed over:

$ A^\mu B_\mu \equiv \sum_{\mu=0}^{3} A^\mu B_\mu = A^0 B_0 + A^1 B_1 + A^2 B_2 + A^3 B_3 $

This convention eliminates cumbersome summation symbols and makes equations more readable. Free indices must match on both sides of an equation.

← Manifolds and Coordinates Next: The Metric Tensor →