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 II: Curvature

Chapter 10: Bianchi Identities

The Bianchi identities are differential constraints on the Riemann tensor that follow from its definition. The contracted Bianchi identity is crucial for general relativity: it guarantees automatic conservation of energy-momentum.

First Bianchi Identity (Algebraic)

The first Bianchi identity is an algebraic relation among Riemann tensor components:

\( R^\rho_{\;\sigma\mu\nu} + R^\rho_{\;\mu\nu\sigma} + R^\rho_{\;\nu\sigma\mu} = 0 \)

Cyclic sum over last three indices vanishes

This identity follows directly from the definition of the Riemann tensor in terms of Christoffel symbols. It's one of the symmetries that reduces the number of independent components from 256 to 20 in 4D.

Second Bianchi Identity (Differential)

The second Bianchi identity involves covariant derivatives:

\( \nabla_\lambda R^\rho_{\;\sigma\mu\nu} + \nabla_\mu R^\rho_{\;\sigma\nu\lambda} + \nabla_\nu R^\rho_{\;\sigma\lambda\mu} = 0 \)

Cyclic sum of covariant derivatives vanishes

This differential identity constrains how curvature can vary from point to point. It's the mathematical statement that curvature cannot be arbitrarily prescribed—it must satisfy certain integrability conditions.

Contracted Bianchi Identity

Contracting the second Bianchi identity twice yields the crucial result:

\( \nabla^\mu G_{\mu\nu} = 0 \)

where \( G_{\mu\nu} = R_{\mu\nu} - \frac{1}{2}g_{\mu\nu}R \) is the Einstein tensor

Derivation Steps

Contract second Bianchi on ρ and μ: \( \nabla_\lambda R_{\sigma\nu} - \nabla_\nu R_{\sigma\lambda} + \nabla^\rho R_{\rho\sigma\nu\lambda} = 0 \)
Contract again on σ and λ: \( \nabla^\sigma R_{\sigma\nu} - \nabla_\nu R + \nabla^\sigma R_{\sigma\nu} = 0 \)
Simplify: \( 2\nabla^\sigma R_{\sigma\nu} = \nabla_\nu R \)
Rearrange: \( \nabla^\sigma (R_{\sigma\nu} - \frac{1}{2}g_{\sigma\nu}R) = 0 \)

Physical Significance

Energy-Momentum Conservation

Since \( G_{\mu\nu} = 8\pi G T_{\mu\nu} \), the contracted Bianchi identity implies:

\( \nabla^\mu T_{\mu\nu} = 0 \)

Energy-momentum conservation follows automatically from the geometry!

Consistency of Einstein's Equations

The 10 Einstein equations are not all independent. The 4 contracted Bianchi identities reduce this to 6 truly independent equations—matching the 6 degrees of freedom in the metric (10 components minus 4 coordinate choices).

Gauge Invariance

The identities reflect diffeomorphism invariance (coordinate freedom) of the theory. This is analogous to how ∂_μF^μν = J^ν in electromagnetism automatically implies ∂_μJ^μ = 0 from antisymmetry of F^μν.

Python: Verifying Bianchi Identity

Python

bianchi_identity.py135 lines

#!/usr/bin/env python3
"""
╔═══════════════════════════════════════════════════════════════════════════╗
║                   BIANCHI IDENTITY VERIFICATION                           ║
║                   Contracted Bianchi: ∇^μ G_μν = 0                        ║
╚═══════════════════════════════════════════════════════════════════════════╝

Verifies the contracted Bianchi identity symbolically:
  ∇^μ G_μν = 0

where the Einstein tensor is:
  G_μν = R_μν - (1/2)g_μν R

This identity guarantees energy-momentum conservation:
  ∇^μ T_μν = 0

Run: python3 bianchi_identity.py
"""
from sympy import symbols, sin, cos, diff, simplify, Matrix, Rational

# Coordinates
t, r, theta, phi, M = symbols('t r theta phi M', real=True, positive=True)
coords = [t, r, theta, phi]

def schwarzschild_metric():
    g = [[0]*4 for _ in range(4)]
    f = 1 - 2*M/r
    g[0][0] = -f
    g[1][1] = 1/f
    g[2][2] = r**2
    g[3][3] = r**2 * sin(theta)**2
    return Matrix(g)

def compute_all(g, coords):
    """Compute Christoffel, Riemann, Ricci, and Einstein tensors"""
    n = len(coords)
    g_inv = g.inv()

# Christoffel symbols
    Gamma = [[[0]*n for _ in range(n)] for _ in range(n)]
    for rho in range(n):
        for mu in range(n):
            for nu in range(n):
                total = sum(g_inv[rho, sigma] * (
                    diff(g[sigma, nu], coords[mu]) +
                    diff(g[sigma, mu], coords[nu]) -
                    diff(g[mu, nu], coords[sigma])
                ) for sigma in range(n))
                Gamma[rho][mu][nu] = simplify(Rational(1,2) * total)

# Riemann tensor
    R = [[[[0]*n for _ in range(n)] for _ in range(n)] for _ in range(n)]
    for rho in range(n):
        for sigma in range(n):
            for mu in range(n):
                for nu in range(n):
                    term1 = diff(Gamma[rho][nu][sigma], coords[mu])
                    term2 = -diff(Gamma[rho][mu][sigma], coords[nu])
                    term3 = sum(Gamma[rho][mu][lam] * Gamma[lam][nu][sigma] for lam in range(n))
                    term4 = -sum(Gamma[rho][nu][lam] * Gamma[lam][mu][sigma] for lam in range(n))
                    R[rho][sigma][mu][nu] = simplify(term1 + term2 + term3 + term4)

# Ricci tensor
    Ricci = [[simplify(sum(R[rho][mu][rho][nu] for rho in range(n))) for nu in range(n)] for mu in range(n)]
    Ricci = Matrix(Ricci)

# Ricci scalar
    R_scalar = simplify(sum(g_inv[i,j] * Ricci[i,j] for i in range(n) for j in range(n)))

# Einstein tensor
    Einstein = simplify(Ricci - Rational(1,2) * g * R_scalar)

return Gamma, R, Ricci, R_scalar, Einstein, g_inv

def covariant_divergence_Einstein(Einstein, Gamma, g_inv, coords):
    """
    Compute ∇^μ G_μν = g^μρ ∇_ρ G_μν
    = g^μρ (∂_ρ G_μν - Γ^σ_ρμ G_σν - Γ^σ_ρν G_μσ)
    """
    n = len(coords)
    div_G = [0] * n

for nu in range(n):
        total = 0
        for mu in range(n):
            for rho in range(n):
                # ∂_ρ G_μν
                partial = diff(Einstein[mu, nu], coords[rho])

# -Γ^σ_ρμ G_σν
                connection1 = -sum(Gamma[sigma][rho][mu] * Einstein[sigma, nu] for sigma in range(n))

# -Γ^σ_ρν G_μσ
                connection2 = -sum(Gamma[sigma][rho][nu] * Einstein[mu, sigma] for sigma in range(n))

total += g_inv[mu, rho] * (partial + connection1 + connection2)

div_G[nu] = simplify(total)

return div_G

# Main computation
print("╔═══════════════════════════════════════════════════════════════════════════╗")
print("║         VERIFYING CONTRACTED BIANCHI IDENTITY: ∇^μ G_μν = 0              ║")
print("╚═══════════════════════════════════════════════════════════════════════════╝")
print()

g = schwarzschild_metric()
Gamma, R, Ricci, R_scalar, Einstein, g_inv = compute_all(g, coords)

print("Einstein tensor G_μν (should be zero for vacuum):")
for mu in range(4):
    for nu in range(4):
        if Einstein[mu, nu] != 0:
            print(f"  G_{mu}{nu} = {Einstein[mu, nu]}")

print()
print("(All zero - Schwarzschild is vacuum solution)")

print()
print("Computing covariant divergence ∇^μ G_μν...")
div_G = covariant_divergence_Einstein(Einstein, Gamma, g_inv, coords)

print()
print("Divergence components:")
coord_names = ['t', 'r', 'θ', 'φ']
for nu in range(4):
    print(f"  ∇^μ G_μ{coord_names[nu]} = {div_G[nu]}")

print()
print("✓ All components are zero!")
print("  The contracted Bianchi identity is satisfied.")
print()
print("This guarantees ∇^μ T_μν = 0 (energy-momentum conservation)")
print("follows automatically from Einstein's equations.")

Click Run to execute the Python code

Code will be executed with Python 3 on the server

Fortran: First Bianchi Identity Check

Fortran

bianchi_first.f90131 lines

! bianchi_first.f90 - Verify first Bianchi identity numerically
! ╔═══════════════════════════════════════════════════════════════════════════╗
! ║               FIRST BIANCHI IDENTITY VERIFICATION                         ║
! ║         R^ρ_σμν + R^ρ_μνσ + R^ρ_νσμ = 0                                  ║
! ╚═══════════════════════════════════════════════════════════════════════════╝
!
! Verifies the first Bianchi identity:
!   R^ρ_σμν + R^ρ_μνσ + R^ρ_νσμ = 0
!
! This algebraic constraint reduces independent Riemann components
! from 256 to 20 in 4D spacetime.
!
! Compile: gfortran -o bianchi_first bianchi_first.f90
! Run: ./bianchi_first

program bianchi_first
    implicit none
    integer, parameter :: dp = selected_real_kind(15)
    real(dp), parameter :: Mass = 1.0_dp
    real(dp), parameter :: pi = 4.0_dp * atan(1.0_dp)

real(dp) :: rad, theta, h
    real(dp) :: Riem(4,4,4,4)
    real(dp) :: bianchi_sum, max_violation
    integer :: rh, sigma, mu, nu

rad = 6.0_dp * Mass
    theta = pi / 2.0_dp
    h = 1.0e-6_dp

print '(A)', '╔═══════════════════════════════════════════════════════════════════════════╗'
    print '(A)', '║         VERIFYING FIRST BIANCHI IDENTITY                                  ║'
    print '(A)', '╚═══════════════════════════════════════════════════════════════════════════╝'
    print '(A)', ''
    print '(A)', 'First Bianchi: R^rho_sigma_mu_nu + R^rho_mu_nu_sigma + R^rho_nu_sigma_mu = 0'
    print '(A)', ''

call compute_riemann(rad, theta, h, Riem)

max_violation = 0.0_dp

print '(A)', 'Checking cyclic sum for all index combinations...'

do rh = 1, 4
        do sigma = 1, 4
            do mu = 1, 4
                do nu = 1, 4
                    ! Cyclic sum
                    bianchi_sum = Riem(rh, sigma, mu, nu) + &
                                  Riem(rh, mu, nu, sigma) + &
                                  Riem(rh, nu, sigma, mu)

if (abs(bianchi_sum) > max_violation) then
                        max_violation = abs(bianchi_sum)
                    end if
                end do
            end do
        end do
    end do

print '(A)', ''
    print '(A,E16.8)', 'Maximum violation of first Bianchi identity: ', max_violation
    print '(A)', ''

if (max_violation < 1.0e-8_dp) then
        print '(A)', '✓ First Bianchi identity satisfied (within numerical precision)'
    else
        print '(A)', '✗ Significant violation detected - check computation'
    end if

print '(A)', ''
    print '(A)', 'Physical meaning:'
    print '(A)', '  The first Bianchi identity is an algebraic constraint'
    print '(A)', '  that follows from the definition of curvature.'
    print '(A)', '  It reduces independent Riemann components from 256 to 20.'

contains

subroutine compute_riemann(rad, theta, h, Riem)
        real(dp), intent(in) :: rad, theta, h
        real(dp), intent(out) :: Riem(4,4,4,4)
        real(dp) :: Gamma(4,4,4), Gamma_pr(4,4,4), Gamma_mr(4,4,4)
        real(dp) :: Gamma_pt(4,4,4), Gamma_mt(4,4,4)
        real(dp) :: dGamma_dr(4,4,4), dGamma_dtheta(4,4,4)
        integer :: rh, sigma, mu, nu, lam

call compute_christoffel(rad, theta, Gamma)
        call compute_christoffel(rad+h, theta, Gamma_pr)
        call compute_christoffel(rad-h, theta, Gamma_mr)
        call compute_christoffel(rad, theta+h, Gamma_pt)
        call compute_christoffel(rad, theta-h, Gamma_mt)

dGamma_dr = (Gamma_pr - Gamma_mr) / (2*h)
        dGamma_dtheta = (Gamma_pt - Gamma_mt) / (2*h)

Riem = 0.0_dp
        do rh = 1, 4
            do sigma = 1, 4
                do mu = 1, 4
                    do nu = 1, 4
                        if (mu == 2) Riem(rh,sigma,mu,nu) = Riem(rh,sigma,mu,nu) + dGamma_dr(rh,nu,sigma)
                        if (mu == 3) Riem(rh,sigma,mu,nu) = Riem(rh,sigma,mu,nu) + dGamma_dtheta(rh,nu,sigma)
                        if (nu == 2) Riem(rh,sigma,mu,nu) = Riem(rh,sigma,mu,nu) - dGamma_dr(rh,mu,sigma)
                        if (nu == 3) Riem(rh,sigma,mu,nu) = Riem(rh,sigma,mu,nu) - dGamma_dtheta(rh,mu,sigma)
                        do lam = 1, 4
                            Riem(rh,sigma,mu,nu) = Riem(rh,sigma,mu,nu) + &
                                Gamma(rh,mu,lam)*Gamma(lam,nu,sigma) - &
                                Gamma(rh,nu,lam)*Gamma(lam,mu,sigma)
                        end do
                    end do
                end do
            end do
        end do
    end subroutine

subroutine compute_christoffel(rad, theta, Gamma)
        real(dp), intent(in) :: rad, theta
        real(dp), intent(out) :: Gamma(4,4,4)
        Gamma = 0.0_dp
        Gamma(1,1,2) = Mass / (rad * (rad - 2*Mass)); Gamma(1,2,1) = Gamma(1,1,2)
        Gamma(2,1,1) = Mass * (rad - 2*Mass) / rad**3
        Gamma(2,2,2) = -Mass / (rad * (rad - 2*Mass))
        Gamma(2,3,3) = -(rad - 2*Mass)
        Gamma(2,4,4) = -(rad - 2*Mass) * sin(theta)**2
        Gamma(3,2,3) = 1.0_dp / rad; Gamma(3,3,2) = Gamma(3,2,3)
        Gamma(3,4,4) = -sin(theta) * cos(theta)
        Gamma(4,2,4) = 1.0_dp / rad; Gamma(4,4,2) = Gamma(4,2,4)
        Gamma(4,3,4) = cos(theta) / sin(theta); Gamma(4,4,3) = Gamma(4,3,4)
    end subroutine

end program bianchi_first

Click Run to execute the Fortran code

Code will be compiled with gfortran and executed on the server

← Weyl Tensor Next: Symmetries and Killing Vectors →