Formación de agujeros negros: equilibrio hidrostático, colapso gravitacional y horizontes

Esta lección autocontenida explica cómo se forman los agujeros negros desde la Relatividad General y la astrofísica de objetos compactos. Recorremos las ecuaciones de Einstein, el equilibrio hidrostático relativista (TOV), el teorema de Buchdahl, el colapso de Oppenheimer–Snyder, superficies atrapadas y horizontes.

— Incluye heurística, demostraciones, ejemplos numéricos y código en Python

Introducción y Motivación

Un agujero negro aparece cuando la presión y los efectos cuántico-degenerativos ya no bastan para sostener una masa contra su propia gravedad, creando una región de la que ni la luz puede escapar. Este fenómeno surge en:

• Colapso de estrellas masivas: Cuando el combustible nuclear se agota
• Fusiones de objetos compactos: Sistemas binarios en espiral
• Colapso directo de gas primordial: En el universo temprano
• Escenarios primordiales: Fluctuaciones de densidad extremas

Comprender su formación exige combinar geometría del espacio-tiempo, materia relativista e invariantes causales.

Mapa Conceptual Mínimo

Análisis Preliminar: De la Heurística a lo Formal

Intuición Física

Si una masa \(M\) queda comprimida en un radio \(R\) comparable con \(r_s=2GM/c^2\), los conos de luz se inclinan hacia el interior. Para \(R\le r_s\), la salida causal se bloquea.

En equilibrio, la presión interna debe satisfacer las ecuaciones TOV. Si no existe solución físicamente aceptable por debajo de cierto radio, el sistema no puede sostenerse y colapsa.

Colapso Oppenheimer–Snyder: Polvo Homogéneo

El modelo OS considera una esfera de polvo homogéneo en caída libre. El interior es FRW cerrado y el exterior, Schwarzschild. La superficie colapsa en tiempo propio finito y se forma un horizonte antes de la singularidad.

Horizontes, Atrapamiento y Censura Cósmica

La ecuación de Raychaudhuri para congruencias nulas con la condición de energía nula implica focos en tiempo afín finito, favoreciendo la formación de superficies atrapadas.

Canales de Formación en Astrofísica

Ejemplos Escalonados

Recetas de Procedimiento

1. Evaluar riesgo de colapso: Calcular \(\mathcal{C}=2GM/(Rc^2)\). Si \(\mathcal{C}\gtrsim 1\), el atrapamiento es inminente.
2. Integrar TOV: Con EoS dada \(p(\rho)\), elegir \(\rho_c\), integrar desde \(r=0\) hasta \(p=0\).
3. Detección de horizonte aparente: Verificar \(1-2Gm(r)/(rc^2)=0\).
4. Modelo OS: Usar el lema para el tiempo propio de colapso.

Código en Python (Reproducible)

Los siguientes fragmentos implementan constantes, un integrador TOV con ecuación de estado politrópica, el cálculo de compacidad y un modelo paramétrico OS.

Constantes y Utilidades

import numpy as np

# Constantes SI
G  = 6.67430e-11  # Constante gravitacional
c  = 2.99792458e8  # Velocidad de la luz
Ms = 1.98847e30   # Masa solar
km = 1e3          # Kilómetro en metros

def r_schwarzschild(M):
    """Calcula el radio de Schwarzschild para una masa M"""
    return 2*G*M/c**2

def compacidad(M, R):
    """Calcula la compacidad adimensional 2GM/(Rc²)"""
    return 2*G*M/(R*c**2)

def format_km(x):
    """Utilidad de impresión para convertir metros a km"""
    return f"{x/km:.3f} km"

# Ejemplo de uso
M_ejemplo = 10 * Ms
print(f"Radio de Schwarzschild: {format_km(r_schwarzschild(M_ejemplo))}")
print(f"Compacidad para R=30km: {compacidad(M_ejemplo, 30*km):.3f}")
    

Integración TOV con EoS Politrópica

from math import isfinite
from dataclasses import dataclass

@dataclass
class TOVResult:
    """Resultado de la integración TOV"""
    radius: float
    mass: float
    profiles: dict

def tov_rhs(r, y, K, gamma):
    """
    Lado derecho del sistema TOV para EoS politrópica p = K*ρ^γ
    
    Args:
        r: Radio coordenada
        y: [m(r), p(r)] - masa y presión
        K: Constante politrópica
        gamma: Índice politrópico
    
    Returns:
        [dm/dr, dp/dr]
    """
    m, p = y
    if p <= 0:  # Condición de vacío
        return np.array([0.0, 0.0])
    
    # EoS: p = K * rho^gamma => rho = (p/K)^(1/gamma)
    rho = (p / K) ** (1.0/gamma)
    
    # Denominador de la ecuación TOV
    denom = r * (r - 2*G*m/c**2)
    
    # Ecuaciones TOV
    dpdr = -G * (rho*c**2 + p) * (m*c**2 + 4*np.pi*r**3*p) / (c**4 * denom)
    dmdr = 4*np.pi*r**2 * rho
    
    return np.array([dmdr, dpdr])

def integrate_tov(r0, p_c, K, gamma, dr=5.0, rmax=5e6):
    """
    Integra las ecuaciones TOV usando Runge-Kutta de 4º orden
    
    Args:
        r0: Radio inicial (pequeño, ~1m)
        p_c: Presión central
        K, gamma: Parámetros de la EoS
        dr: Paso de integración
        rmax: Radio máximo
    
    Returns:
        TOVResult con radio, masa y perfiles
    """
    r, m, p = r0, 0.0, p_c
    rs, ms, ps, rlist = [], [], [], []
    
    while p > 0 and r < rmax:
        y = np.array([m, p])
        
        # Runge-Kutta 4
        k1 = tov_rhs(r, y, K, gamma)
        k2 = tov_rhs(r + dr/2, y + dr*k1/2, K, gamma)
        k3 = tov_rhs(r + dr/2, y + dr*k2/2, K, gamma)
        k4 = tov_rhs(r + dr, y + dr*k3, K, gamma)
        
        y_next = y + (dr/6)*(k1 + 2*k2 + 2*k3 + k4)
        m, p = float(y_next[0]), float(y_next[1])
        r += dr
        
        if not (isfinite(m) and isfinite(p)):
            break
            
        rs.append(r)
        ms.append(m)
        ps.append(max(p, 0.0))
        rlist.append(r)
        
        # Criterio de horizonte aparente (diagnóstico)
        if r - 2*G*m/c**2 <= 0:
            print(f"¡Horizonte aparente detectado en r = {format_km(r)}!")
            break
    
    R, M = r, m
    return TOVResult(
        radius=R, 
        mass=M, 
        profiles={
            "r": np.array(rlist),
            "m": np.array(ms),
            "p": np.array(ps)
        }
    )
    

Diagnóstico de Buchdahl y Análisis

def diagnostico_buchdahl(M, R):
    """
    Realiza diagnóstico completo de compacidad y límites físicos
    
    Args:
        M: Masa en kg
        R: Radio en metros
    
    Returns:
        dict con análisis completo
    """
    C = compacidad(M, R)
    r_s = r_schwarzschild(M)
    buchdahl_limit = 8.0/9.0
    min_radius_buchdahl = (9.0/8.0) * r_s
    
    return {
        "compacidad": C,
        "radio_schwarzschild_km": format_km(r_s),
        "criterio_buchdahl": C < buchdahl_limit,
        "limite_buchdahl": buchdahl_limit,
        "radio_minimo_buchdahl_km": format_km(min_radius_buchdahl),
        "horizonte_formado": R <= r_s,
        "fraccion_schwarzschild": R / r_s,
        "presion_central_diverge": C >= buchdahl_limit,
        "status": "ESTABLE" if C < buchdahl_limit else "COLAPSO INMINENTE"
    }

# Ejemplo: Estrella de neutrones típica
M_ns = 1.4 * Ms  # Masa de Chandrasekhar
R_ns = 12.0 * km  # Radio típico

resultado = diagnostico_buchdahl(M_ns, R_ns)
print("=== DIAGNÓSTICO DE ESTRELLA DE NEUTRONES ===")
for key, value in resultado.items():
    print(f"{key}: {value}")
    

Modelo de Colapso Oppenheimer-Snyder

def tiempo_colapso_OS(R0, M):
    """
    Calcula el tiempo propio de colapso en el modelo OS
    
    Args:
        R0: Radio inicial en metros
        M: Masa total en kg
    
    Returns:
        Tiempo de colapso en segundos
    """
    return np.pi * R0**1.5 / (2.0 * np.sqrt(2*G*M))

def analisis_colapso_completo(R0, M):
    """Análisis completo del colapso OS"""
    tau_colapso = tiempo_colapso_OS(R0, M)
    r_s = r_schwarzschild(M)
    tiempo_luz = R0 / c
    
    return {
        "radio_inicial_km": format_km(R0),
        "masa_masas_solares": M / Ms,
        "tiempo_colapso_s": tau_colapso,
        "tiempo_colapso_ms": tau_colapso * 1000,
        "tiempo_luz_s": tiempo_luz,
        "ratio_colapso_luz": tau_colapso / tiempo_luz,
        "radio_schwarzschild_km": format_km(r_s),
        "compacidad_inicial": compacidad(M, R0)
    }

# Ejemplo: Estrella masiva pre-colapso
R0_estrella = 1e7  # 10,000 km
M_estrella = 20 * Ms

resultado_colapso = analisis_colapso_completo(R0_estrella, M_estrella)
print("\n=== ANÁLISIS DE COLAPSO OS ===")
for key, value in resultado_colapso.items():
    print(f"{key}: {value}")
    

Ejemplo Reproducible: Curva Masa-Radio

import matplotlib.pyplot as plt

def curva_mr_politropo(K, gamma, rho_c_list, dr=5.0):
    """
    Genera curva masa-radio para politropo dado
    
    Args:
        K: Constante politrópica
        gamma: Índice politrópico  
        rho_c_list: Lista de densidades centrales
        dr: Paso de integración
    
    Returns:
        Array de (masa, radio) en unidades SI
    """
    MR = []
    for rho_c in rho_c_list:
        p_c = K * rho_c**gamma
        try:
            res = integrate_tov(1.0, p_c, K, gamma, dr=dr)
            MR.append((res.mass, res.radius))
        except:
            continue  # Saltar configuraciones problemáticas
    
    return np.array(MR)

# Parámetros del politropo
K = 1e5  # Constante politrópica (unidades SI)
gamma = 2.0  # Índice politrópico

# Barrido de densidades centrales
rho_c_min = 5e16  # kg/m³
rho_c_max = 2e18  # kg/m³
n_points = 50

rho_c_list = np.logspace(np.log10(rho_c_min), np.log10(rho_c_max), n_points)

# Generar curva M-R
print("Generando curva masa-radio...")
MR_data = curva_mr_politropo(K, gamma, rho_c_list, dr=10.0)

if len(MR_data) > 0:
    masas = MR_data[:, 0] / Ms  # En masas solares
    radios = MR_data[:, 1] / km  # En kilómetros
    
    # Encontrar máximo (límite TOV)
    idx_max = np.argmax(masas)
    M_max = masas[idx_max]
    R_max = radios[idx_max]
    
    print(f"Límite TOV encontrado:")
    print(f"M_max = {M_max:.2f} masas solares")
    print(f"R_max = {R_max:.1f} km")
    print(f"Compacidad máxima = {compacidad(M_max*Ms, R_max*km):.3f}")
    
    # Verificar Buchdahl para cada punto
    for i, (M, R) in enumerate(zip(masas, radios)):
        C = compacidad(M*Ms, R*km)
        if C >= 8.0/9.0:
            print(f"¡Violación de Buchdahl en punto {i}: C = {C:.3f}!")
            break
else:
    print("No se pudieron generar datos válidos")
      

Errores Frecuentes y Cómo Evitarlos

Mini-Ejercicios Propuestos

1. Demuestra que si \(p=0\) en el interior, no hay equilibrio a presión nula para \(\rho>0\).
2. Para \(M=1.4\,M_\odot\), encuentra el rango de radios permitido por Buchdahl.
3. Estima \(\tau_{\text{colapso}}\) para \(M=5\,M_\odot\) y \(R_0=10^7\ \text{m}\).
4. Implementa detección de horizonte aparente: primer \(r\) con \(1-2Gm/(rc^2)=0\).
5. Explica por qué superficies atrapadas bloquean extensión estática.

Fórmulas de Referencia

Conclusión

La formación de un agujero negro combina tres elementos fundamentales:

1. Límite de equilibrio hidrostático (TOV) y su cota geométrica (Buchdahl)
2. Dinámica de colapso (OS como modelo canónico)
3. Criterios locales de atrapamiento y horizontes

El patrón general es claro: al crecer la compacidad y fallar la presión de sostén, la geometría obliga a focos nulos y a la aparición de superficies atrapadas.

Desde aquí se conectan extensiones naturales: rotación (Kerr), anisotropías, acreción y colapso crítico. Los fragmentos de Python permiten reproducir curvas M–R y tiempos de colapso, cerrando el ciclo teoría–cálculo–verificación.