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

tensor_contraction.f9097 lines

! tensor_contraction.f90 - Compute tensor contractions
!
! ╔══════════════════════════════════════════════════════════════════════════════╗
! ║                         TENSOR CONTRACTION                                   ║
! ║                    Index Lowering and Contractions                           ║
! ╚══════════════════════════════════════════════════════════════════════════════╝
!
! Demonstrates tensor operations: contraction and index lowering.
!
! KEY EQUATIONS:
! -------------
! Trace (contraction):
!   \( \text{Tr}(A) = A^\mu_\mu = \sum_{\mu=0}^3 A^\mu_\mu \)
!
! Index lowering with metric:
!   \( A_{\mu\nu} = g_{\mu\rho} A^\rho_\nu \)
!
! Double contraction:
!   \( A^{\mu\nu} A_{\mu\nu} = \sum_{\mu,\nu} A^{\mu\nu} A_{\mu\nu} \)
!
! Minkowski metric (signature +---):
!   \( \eta_{\mu\nu} = \text{diag}(1, -1, -1, -1) \)
!
! Compile: gfortran -o tensor_contraction tensor_contraction.f90
! Run: ./tensor_contraction

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

! Minkowski metric (signature +---)
    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

! Example tensor A^mu_nu (mixed)
    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

! Compute trace: A^mu_mu
    trace_A = 0.0_dp
    do i = 1, 4
        trace_A = trace_A + A(i,i)
    end do

print '(A)', 'Tensor Operations in General Relativity'
    print '(A)', '========================================'
    print '(A)', ''
    print '(A)', 'Minkowski metric g_mu_nu:'
    do i = 1, 4
        print '(4F10.4)', (g(i,j), j=1,4)
    end do

print '(A)', ''
    print '(A)', 'Tensor A^mu_nu:'
    do i = 1, 4
        print '(4F10.4)', (A(i,j), j=1,4)
    end do

print '(A)', ''
    print '(A,F10.4)', 'Trace A^mu_mu = ', trace_A

! Contract with metric to get A_mu_nu = g_mu_rho A^rho_nu
    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

print '(A)', ''
    print '(A)', 'Lower first index: A_mu_nu = g_mu_rho A^rho_nu:'
    do i = 1, 4
        print '(4F10.4)', (B(i,j), j=1,4)
    end do

! Compute A^mu_nu A_mu_nu (double contraction)
    contraction = 0.0_dp
    do i = 1, 4
        do j = 1, 4
            contraction = contraction + A(i,j) * B(i,j)
        end do
    end do

print '(A)', ''
    print '(A,F10.4)', 'Double contraction A^mu_nu A_mu_nu = ', contraction

end program tensor_contraction

Click Run to execute the Fortran code

Code will be compiled with gfortran and executed 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 →