Allgemeine Relativitätstheorie mit dem Computer

General Theory of Relativity on the Computer

Vorlesung gehalten an der J.W.Goethe-Universität in Frankfurt am Main (Sommersemester 2021)

von Dr.phil.nat. Dr.rer.pol. Matthias Hanauske

Frankfurt am Main 04.04.2021

Erster Vorlesungsteil: Allgemeine Relativitätstheorie mit Python

Grundlegende Größen der Allgemeinen Relativitätstheorie mit EinsteinPy

Beispiel: Die Schwarzschildmetrik

Im Folgenden werden einige grundlegende Größen der allgemeinen Relativitätstheorie mit dem Python Modul "EinsteinPy" berechnet. Zunächst wird das Python Modul "EinsteinPy" eingebunden, welches auf dem Modul SymPy basiert und symbolische Berechnungen in der Allgemeinen Relativitätstheorie relativ einfach möglich macht. EinsteinPy kann einfach mit "pip install einsteinpy" in einem Terminal installiert werden und stellt zusammen mit dem Modul SymPy ein wichtiges Tool der Computer Algebra Systeme im Bereich der allgemeinen Relativitätstheorie dar. Weiteres über das Modul finden Sie unter EinsteinPy - Making Einstein possible in Python.

Bereits einige Monate nach der Publikation von Einsteins Artikel zur Allgemeinen Relativitätstheorie (siehe Einstein, A. 1915, Preuss. Akad.Wiss. Berlin, Sitzungsber., 778-786) erarbeitete Karl Schwarzschild in zwei Arbeiten mögliche analytische Lösungen der neuen Theorie der Raumzeitkrümmung. In der ersten dieser Arbeiten ("Über das Gravitationsfeld eines Massenpunktes nach der Einsteinschen Theorie", siehe Schwarzschild, K., Sitzungsberichte der Königlich-Preussischen Akademie der Wissenschaften. Reimer, Berlin 1916, S. 189–196) betrachtete Herr Schwarzschild die Einstein-Gleichung für den freien, leeren Raum ($T_{\mu\nu}=0 \quad \rightarrow \quad R_{\mu\nu}=0$), wobei er annahm, dass sich die gesamte Materie/Energie in einem singulären Punkt im Ursprung befindet (Massenpunkt der Masse $M$). Er benutzte einen zeitunabhängigen und sphärisch symmetrische Ansatz der Metrik und die so von ihm gefundene Lösung der resultierenden Feldgleichungen ist heutzutage unter dem Namen "Schwarzschild-Lösung" bekannt.

Die kovariante Raumzeit-Metrik der Schwarzschild-Lösung lautet:

$$ g_{\mu\nu}=\left( \begin{array}{ccc} 1-\frac{2\,M}{r} & 0 & 0 & 0\\ 0& -\frac{1}{1-\frac{2\,M}{r}}& 0&0 \\ 0& 0& -r^2& 0\\ 0& 0& 0& -r^2 \hbox{sin}^2(\theta)\end{array} \right)$$

Diese Lösung ist von besonderer Bedeutung für astrophysikalische Betrachtungen, denn sie beschreibt einerseits die Metrik eines nicht-rotierenden Schwarzen Lochs und andererseits, aufgrund des Birkhoff-Theorem, die Metrik außerhalb eines einzelnen isolierten, nichtrotierenden Sterns.

In [1]:
from sympy import *
init_printing()
from einsteinpy.symbolic import *
In [2]:
t, r, theta, phi, M = symbols('t, r, theta, phi, M')
Metric = diag((1-2*M/r), -1/(1-2*M/r), -r**2, -r**2*sin(theta)**2).tolist()
g = MetricTensor(Metric, [t, r, theta, phi])
In [3]:
g.tensor()
Out[3]:
$$\left[\begin{matrix}- \frac{2 M}{r} + 1 & 0 & 0 & 0\\0 & - \frac{1}{- \frac{2 M}{r} + 1} & 0 & 0\\0 & 0 & - r^{2} & 0\\0 & 0 & 0 & - r^{2} \sin^{2}{\left (\theta \right )}\end{matrix}\right]$$

Kontravariante Form der Metrik: $g^{\mu\nu}$

In [4]:
gInv=g.inv()
gInv.tensor()
Out[4]:
$$\left[\begin{matrix}\frac{r}{- 2 M + r} & 0 & 0 & 0\\0 & \frac{2 M - r}{r} & 0 & 0\\0 & 0 & - \frac{1}{r^{2}} & 0\\0 & 0 & 0 & - \frac{1}{r^{2} \sin^{2}{\left (\theta \right )}}\end{matrix}\right]$$

Die Chistoffel Symbole (zweiter Art): $$ \Gamma^{\sigma}_{\mu \nu} = \frac{1}{2}g^{\sigma \alpha} \left( g_{\nu \alpha| \mu} + g_{\mu \alpha| \nu} - g_{\mu \nu| \alpha} \right)$$

Hier speziell $$ \Gamma^{1}_{1 1} = \Gamma^{r}_{r r}$$

In [5]:
chr = ChristoffelSymbols.from_metric(g)
print(chr.config)
chr.tensor()[1,1,1]

ull
Out[5]:
$$\frac{2 M \left(\frac{M}{r} - \frac{1}{2}\right)}{r^{2} \left(- \frac{2 M}{r} + 1\right)^{2}}$$

Die Chistoffel Symbole in kovarianter Form (erster Art): $$ \Gamma_{\mu \nu \sigma} = \Gamma^{\rho}_{\mu \nu} g_{\rho \sigma} = \frac{1}{2} \left( g_{\nu \sigma| \mu} + g_{\mu \sigma| \nu} - g_{\mu \nu| \sigma} \right)$$

Hier speziell $$ \Gamma_{2 2 2} = \Gamma_{r r r}$$

In [6]:
chr_lll = chr.change_config('lll') 
print(chr_lll.config)
chr_lll.tensor()[1,1,1]

lll
Out[6]:
$$\frac{M}{\left(2 M - r\right)^{2}}$$

Der Riemann Tensor: $$ R^{\mu}{}\!_{\nu \rho \sigma} = \frac{\partial \Gamma^{\mu}_{\nu \sigma}}{\partial x^{\rho}} - \frac{\partial \Gamma^{\mu}_{\nu \rho}}{\partial x^{\sigma}} + \Gamma^{\alpha}_{\nu \sigma}\Gamma^{\mu}_{\rho \alpha} - \Gamma^{\alpha}_{\nu \rho}\Gamma^{\mu}_{\sigma \alpha} $$

Hier speziell $$ R^{0}{}\!_{2 0 2} = R^{t}{}\!_{\theta t \theta} $$

In [7]:
rm = RiemannCurvatureTensor.from_christoffels(chr)
print(rm.config)
rm[0,2,0,2]

ulll
Out[7]:
$$- \frac{M}{r}$$

Der Riemann Tensor (kovariante Form): $$ R_{\mu \nu \rho \sigma} = \frac{\partial \Gamma_{\mu \nu \sigma}}{\partial x^{\rho}} - \frac{\partial \Gamma_{\mu \nu \rho}}{\partial x^{\sigma}} + \Gamma^{\alpha}_{\ \nu \sigma}\Gamma_{\mu \rho \alpha} - \Gamma^{\alpha}_{\ \nu \rho}\Gamma_{\mu \sigma \alpha} - \frac{\partial g_{\mu \alpha}}{\partial x^{\rho}}\Gamma^{\alpha}_{\ \nu \sigma} + \frac{\partial g_{\mu \alpha}}{\partial x^{\sigma}}\Gamma^{\alpha}_{\ \nu \rho} $$

Hier speziell $$ R_{1 3 1 3} = R_{t \theta t \theta} $$

In [8]:
rm_llll = rm.change_config('llll')
rm_llll[0,2,0,2]
Out[8]:
$$\frac{M \left(2 M - r\right)}{r^{2}}$$

Der Ricci Tensor:

$$ R_{\mu \nu} = R^{\sigma}_{\mu \sigma \nu} = \frac{\partial \Gamma^{\sigma}_{\mu \nu}}{\partial x^{\sigma}} - \frac{\partial \Gamma^{\sigma}_{\mu \sigma}}{\partial x^{\nu}} + \Gamma^{\rho}_{\mu \nu}\Gamma^{\sigma}_{\rho \sigma} - \Gamma^{\sigma}_{\mu \rho}\Gamma^{\rho}_{\nu \sigma} $$
In [9]:
ric = RicciTensor.from_metric(g)
print(ric.config)
ric.simplify()

ll
Out[9]:
$$\left[\begin{matrix}0 & 0 & 0 & 0\\0 & 0 & 0 & 0\\0 & 0 & 0 & 0\\0 & 0 & 0 & 0\end{matrix}\right]$$

Der Ricci Skalar ergibt sich aus der Kontraktion des Ricci Tensors: $R = R^{\mu}{}_{\!\mu} = g^{\mu \nu}R_{\nu \mu}$

In [10]:
R = RicciScalar.from_riccitensor(ric)
R.tensor()
Out[10]:
$$0$$

Der Einstein Tensor:$$ G_{\mu \nu} = R_{\mu \nu} - \frac{1}{2}g_{\mu \nu}R $$

In [11]:
einst = EinsteinTensor.from_metric(g)
print(einst.config)
einst.simplify()

ll
Out[11]:
$$\left[\begin{matrix}0 & 0 & 0 & 0\\0 & 0 & 0 & 0\\0 & 0 & 0 & 0\\0 & 0 & 0 & 0\end{matrix}\right]$$

Die Eigenschaft, dass der Ricci-Tensor $R_{\mu \nu}$ und als Folge dessen auch der Einstein-Tensor $G_{\mu \nu}$ identisch verschwindet, ist nicht verwunderlich, da die Schwarzschildmetrik eine Lösung der Einsteingleichung im Vakuum (Energie-Impuls-Tensor $T_{\mu\nu} \equiv 0$) darstellt:

$$ R_{\mu\nu} - \frac{1}{2} g_{\mu\nu} R ~=~ -8 \pi \, T_{\mu\nu} ~=~ 0 \, \rightarrow \quad R_{\mu\nu} ~=~ 0 \quad . $$

Die Schwarzschildmetrik beschreibt das raumzeitliche Verhalten eines kugelsymmetrischen, nicht rotierenden und nicht geladenen schwarzen Loches der Masse M, wobei die gesamte Masse des schwarzen Loches in einem singulären Punkt im Zentrum vereint ist. Die skalare Invariante des vollständig kontrahierten Quadrates des Riemannschen Krümmungstensors $K = R_{\mu \nu \rho \sigma} R^{\mu \nu \rho \sigma}$, der sogenannte Kretschmann-Skalar $K$, der Schwarzschildmetrik wird im Ursprung singulär. Die Schwarzschildmetrik Metrik besitzt daher eine echte Singularität bei r = 0.

Wir berechnen den Kretschmann-Skalar $K$

$$ K = R_{\mu \nu \rho \sigma} R^{\mu \nu \rho \sigma} \quad ,$$

und definieren den noch nicht kontrahierten Tensor des Tensorproduktes der beiden Riemann Tensoren $R_{\mu \nu \rho \sigma} R^{\alpha \beta \gamma \delta}$:

In [12]:
rm_uuuu = rm.change_config('uuuu')
RmalR=tensorproduct(rm_llll.tensor(),rm_uuuu.tensor())
RmalRT=Tensor(RmalR,config="lllluuuu")

und kontrahieren diesen zum Kretschmann-Skalar $K$.

In [13]:
K=tensorcontraction(RmalR, (0, 4),(1, 5),(2, 6),(3, 7))
K.expand()
Out[13]:
$$\frac{48 M^{2}}{r^{6}}$$

Man erkennt in dem oberen Ausdruck, dass der Kretschmann-Skalar $K$ im Ursprung ($r=0$) singulär wird. Die Schwarzschildmetrik Metrik besitzt daher eine echte Singularität bei r = 0.

Wir berechnen nun das infinitesimale Weglängenelement $ds$. Es ist wie folgt definiert:

$$ds^2=g_{\mu\nu} dx^\mu dx^\nu \quad ,$$

wobei $dx^\mu = \left(dx^0,dx^1,dx^2,dx^3 \right) = \left(dt,dr,d\theta,d\phi \right)$ eine infinitesimale Raumzeitvariation beschreibt.

Zunächst definieren wir uns die kontravarianten Raumzeitvariation $dx^\mu$:

In [14]:
dt, dr, dtheta, dphi = symbols('dt, dr, d\\theta, d\\phi')
dx=GenericVector([dt, dr, dtheta, dphi],[t, r, theta, phi], config='u',parent_metric=Metric)
dx.tensor()
Out[14]:
$$\left[\begin{matrix}dt & dr & d\theta & d\phi\end{matrix}\right]$$

, bilden das Tensorprodukt $dx^\mu dx^\nu$:

In [15]:
dxdx=tensorproduct(dx.tensor(),dx.tensor())
dxdxT=Tensor(dxdx,config="uu")
dxdxT.tensor()
Out[15]:
$$\left[\begin{matrix}dt^{2} & dr dt & d\theta dt & d\phi dt\\dr dt & dr^{2} & d\theta dr & d\phi dr\\d\theta dt & d\theta dr & d\theta^{2} & d\phi d\theta\\d\phi dt & d\phi dr & d\phi d\theta & d\phi^{2}\end{matrix}\right]$$

und berechnen uns $ds^2$:

In [16]:
ds2a=tensorproduct(g.tensor(),dxdxT.tensor())
ds2aT=Tensor(ds2a,config="lluu")
ds2=tensorcontraction(ds2aT.tensor(), (0, 2),(1, 3))
ds2
Out[16]:
$$- d\phi^{2} r^{2} \sin^{2}{\left (\theta \right )} - d\theta^{2} r^{2} - \frac{dr^{2}}{- \frac{2 M}{r} + 1} + dt^{2} \left(- \frac{2 M}{r} + 1\right)$$

Visualisierung der raumzeitlichen Struktur der Schwarzschildmetrik

Eingebettete Diagramme der räumlichen Hypersphäre der Mannigfaltigkeit

Die Struktur der Raumzeit kann man auf unterschiedliche Weisen visualisieren. Wir betrachten uns zunächst die sogenannten eingebettete Diagramme der räumlichen Hypersphäre $\Sigma_t$ der Mannigfaltigkeit ${\cal M}$. Aufgrund der Zeitunabhängigkeit der Metrik betrachtet man sich die Raumzeit zu einem festen, beliebigen Zeitpunkt, d.h. auf einer räumlichen Hyperfläche $\Sigma_t$ mit t=const. Aufgrund der sphärischen Symmetrie sind alle Flächen mit $\theta= const$ gleichbedeutend, sodass wir den Raum in einem Schnitt durch die Äquatorialebene $\theta= \pi/2$ betrachten können. Das Weglängenelement schreibt sich dadurch wie folgt:

In [17]:
ds2.subs({(dt,0),(dtheta,0),(theta,pi/2)})
Out[17]:
$$- d\phi^{2} r^{2} - \frac{dr^{2}}{- \frac{2 M}{r} + 1}$$

Die durch das Weglängenelement beschriebene gekrümmte zweidimensionale Geometrie betten wir nun (zur Visualisierung) in einen dreidimensionalen euklidischen Raum ein, den wir durch zylindrische Koordinaten $(z, r, \phi)$ beschreiben. Das Weglängenelement in diesem flachen euklidischen Visualisierungsraum lautet:

$$ds^2=-dz^2 - dr^2 -r^2\, d\phi^2 \quad .$$

Wir setzen nun beide Weglängenelemente gleich und beschreiben dadurch die Abweichungen der gekrümmten Raumzeit von der flachen, euklidischen Geometrie durch die Koordinate $z=z(r)$, den sogenannten ’Lift’.

In [18]:
dz = symbols('dz')
Eq1=Eq(ds2.subs({(dt,0),(dtheta,0),(theta,pi/2)}),-dz**2 - dr**2 - r**2*dphi**2)
Eq1
Out[18]:
$$- d\phi^{2} r^{2} - \frac{dr^{2}}{- \frac{2 M}{r} + 1} = - d\phi^{2} r^{2} - dr^{2} - dz^{2}$$

und lösen die Gleichung nach z auf:

In [19]:
solve(Eq1,dz)
Out[19]:
$$\left [ - \sqrt{2} dr \sqrt{- \frac{M}{2 M - r}}, \quad \sqrt{2} dr \sqrt{- \frac{M}{2 M - r}}\right ]$$

Wir nehmen die positive Lösung und integrieren diese über den Radius dr:

In [20]:
solve(Eq1,dz)[1]/dr
Out[20]:
$$\sqrt{2} \sqrt{- \frac{M}{2 M - r}}$$
In [21]:
Loes_z=integrate(solve(Eq1,dz)[1]/dr, r)
Loes_z2=Loes_z**2
Loes_z=sqrt(Loes_z2.simplify())
Loes_z
Out[21]:
$$2 \sqrt{2} \sqrt{M \left(- 2 M + r\right)}$$

Die Funktion z(r) veranschaulicht nun die Schwarzschildmetrik in einem euklidischen Visualisierungsraum. Setzen wir z.B. die Masse des schwarzen Lochs auf M=1, dann erhalten wir folgendes Diagramm:

In [23]:
plot(Loes_z.subs(M,1),(r, 0, 10),xlabel="r",ylabel="z(r)")
Out[23]:
<sympy.plotting.plot.Plot at 0x7f243861a828>

.bzw in dreidimensionaler Darstellung:

In [24]:
from sympy.plotting import plot3d
x,y = symbols('x,y')
plot3d(Loes_z.subs({(M,1),(r,sqrt(x**2+y**2))}), (x, -10, 10), (y, -10, 10),xlabel="r",ylabel="y",zlabel="z");

Die Visualisierung kann man auch mittels der "Plotly Python Open Source Graphing Library" erstellen. In dieser Bibliothek ist es möglich interaktive Abbildungen in Python darzustellen ( siehe https://plotly.com/python/ ).

In [25]:
import plotly.graph_objects as go
import numpy as np
In [26]:
R = np.linspace(2.00001, 10, 300)
PHI = np.linspace(0, 2*np.pi, 300)
R, PHI = np.meshgrid(R, PHI)
X = R*np.cos(PHI)
Y = R*np.sin(PHI)
zlam = lambdify((x,y), Loes_z.subs({(M,1),(r,sqrt(x**2+y**2))}))
ZF = np.array(list(np.real(zlam(X,Y))))
In [27]:
fig = go.Figure(go.Surface(x=X, y=Y, z=ZF, colorscale='Blues', showscale=True))

fig.update_layout(autosize=True,
                  width=700, height=700,
                  margin=dict(l=15, r=50, b=65, t=90),
                  scene_aspectmode='cube')
fig.update_layout(scene = dict(
                    xaxis_title='x',
                    yaxis_title='y',
                    zaxis_title='f'))

Das eingebettete Diagramm kann man auch mittels des Moduls Matplotlib visualisieren:

In [28]:
import matplotlib.pyplot as plt 
from mpl_toolkits.mplot3d import Axes3D
import matplotlib
from matplotlib import cm
In [29]:
params = {
    'figure.figsize'    : [11,7],
#    'text.usetex'       : True,
    'axes.titlesize' : 14,
    'axes.labelsize' : 16,  
    'xtick.labelsize' : 14 ,
    'ytick.labelsize' : 14 
}
matplotlib.rcParams.update(params)
In [30]:
fig = plt.figure()
ax = fig.gca(projection='3d')
surf = ax.plot_surface(X, Y, ZF, cmap=cm.Blues, linewidth=0, alpha=1)
ax.view_init(azim=35, elev=20)
fig.colorbar(surf, shrink=0.5, aspect=10)
ax.set_xlabel("x")
ax.set_ylabel("y")
ax.set_zlabel("z");

Die eingebettete Diagramme der räumlichen Hypersphäre der Mannigfaltigkeit der Schwarzschildmetrik zeigen eine Koordinatensingularität bei dem sogenannten Schwarzschild-Radius $R_S=2M$. Die Metrik besitzt daher eine echte im Zentrum bei (r = 0) und eine Koordinatensystem bedingte, uneigendliche Singularität bei $R_S=2M$. Um die Eigenschaften dieser Schwarzschild-Singularität zu verstehen, betrachten wir im Folgenden radial in das schwarze Loch einfallende bzw. auslaufende Lichtstrahlen, d.h. die Klasse der radialen Nullgeodäten.

Raumzeit-Diagramm der Schwarzschildmetrik in Schwarzschild-Koordinaten

Im Folgenden werden zwei Darstellungsarten der raumzeitlichen Struktur der Schwarzschildmetrik behandelt. Zunächst betrachten wir das Raumzeit-Diagramm der Schwarzschildmetrik in Schwarzschild-Koordinaten. Wir starten wieder vom infinitesimalen Weglängenelement der Schwarzschildmetrik $ds^2$:

In [31]:
ds2
Out[31]:
$$- d\phi^{2} r^{2} \sin^{2}{\left (\theta \right )} - d\theta^{2} r^{2} - \frac{dr^{2}}{- \frac{2 M}{r} + 1} + dt^{2} \left(- \frac{2 M}{r} + 1\right)$$

Wir betrachten uns die Gleichung eines radial einfallenden bzw. herausgehenden Lichtstahls ($d\phi=d\theta=0$ und $ds^2=0$):

In [32]:
Eq2=Eq(ds2.subs({(dphi,0),(dtheta,0)}),0)
Eq2
Out[32]:
$$- \frac{dr^{2}}{- \frac{2 M}{r} + 1} + dt^{2} \left(- \frac{2 M}{r} + 1\right) = 0$$

Wir lösen diese Gleichung nach $dt$ auf und erhalten zwei Lösungen, die die einlaufenden (+) und auslaufenden (-) Lichtstrahle beschreiben.

In [33]:
solve(Eq2,dt)
Out[33]:
$$\left [ \frac{dr r}{- 2 M + r}, \quad \frac{dr r}{2 M - r}\right ]$$
In [34]:
Loes_t0=integrate(solve(Eq2,dt)[0]/dr, r)
Loes_t0
Out[34]:
$$2 M \log{\left (- 2 M + r \right )} + r$$
In [35]:
Loes_t1=integrate(solve(Eq2,dt)[1]/dr, r)
Loes_t1
Out[35]:
$$- 2 M \log{\left (- 2 M + r \right )} - r$$
In [36]:
Loes_t0=Loes_t0.subs(-2*M+r,Abs(-2*M+r))
Loes_t1=Loes_t1.subs(-2*M+r,Abs(-2*M+r))

Die zwei Lösungen der einlaufenden und auslaufenden Lichtstrahlen sind nur bis auf eine Konstante bestimmt, die wir zur allgemeinen Lösung hinzuaddieren müssen und die die Anfangsbedingung des Lichtstrahls beschreibt. Im Folgenden stellen wir mehrere solcher einlaufenden (rote Kurven) und auslaufenden (blaue Kurven) Lichtstrahlen dar, wobei wir die Masse des schwarzen Lochs auf $M=1$ setzen.

In [37]:
params = {
    'figure.figsize'    : [10,8],
#    'text.usetex'       : True,
    'axes.titlesize' : 14,
    'axes.labelsize' : 16,  
    'xtick.labelsize' : 14 ,
    'ytick.labelsize' : 14 
}
matplotlib.rcParams.update(params)
In [38]:
L_aus = lambdify(r,Loes_t0.subs(M,1))
L_ein = lambdify(r,Loes_t1.subs(M,1))
rval = np.linspace(0.000001, 3, 5005)
In [39]:
plt.cla()
plt.xlim(0,3)
plt.ylim(0,6)
plt.ylabel(r"$\rm Zeit \,\,t$")
plt.xlabel(r"$\rm Radius \,\,r$")
const = 1
while const < 6:
    plt.plot(rval,np.real(L_aus(rval))+const,c="blue", linewidth=1.5, linestyle='-');
    plt.plot(rval,np.real(L_ein(rval))+const,c="red", linewidth=1.5, linestyle='-');
    const = const + 1
plt.axvline(x=2, linewidth=3.5, color="black")
plt.text(2, 6, r"$R_S=2M$", size=20, rotation=0.,ha="center", va="center",
         bbox=dict(boxstyle="round",ec="black",fc="white"));

Das Raumzeitdiagramm beschreibt das raumzeitliche Verhalten eines kugelsymmetrischen schwarzen Loches aus dem Betrachtungsstandpunkt eines im Unendlichen ruhenden Beobachters (Schwarzschild Koordinaten). Für den äußeren Beobachter erscheint es, als ob die Raumzeit in zwei Bereiche geteilt ist (Bereich I: $r > R_S$ und Bereich II: $r < R_S$), die untereinander keinerlei Informationen austauschen können. Nähert man sich vom Bereich I dem Schwarzschildradius an ($r\rightarrow R_s$, $r > R_S$), so verengt sich der Lichtkegel so stark, dass man im Grenzfall unendlich lange Zeit benötigen würde um $R_S$ erreichen zu können. Im Bereich II dagegen hat die Raum- und Zeitkoordinate anscheinend ihren Sinn getauscht – die Zukunftslichtkegel zeigen unweigerlich in Richtung der echten Singularität im Ursprung. Ein Teilchen, das sich an einem Ort im Bereich II befindet muss sich zwangsläufig in Richtung der echten Singularität bewegen. Einem äußeren Beobachter erscheint die Kugelfläche des Schwarzschildradius demnach als eine Grenze eines Ereignishorizontes. Vom Bereich I kann keine Information in den Bereich II, und von dem Bereich II kann man nicht in den Bereich I vordringen. Die anscheinende Abgeschlossenheit beider Bereiche ist jedoch vom Standpunkt der Betrachtung d.h. von den zugrunde liegenden Koordinaten abhängig. Einem im unendlichen ruhenden Beobachter erscheint es als ob ein in das schwarze Loch fallender Körper, kurz vor Erreichen des Ereignishorizontes, immer langsamer wird und diesen in endlicher Zeit nicht überschreiten wird – der Körper selbst jedoch überschreitet den Ereignishorizont ohne Hindernisse, wie wir im Folgenden Sehen werden.

Raumzeit-Diagramm der Schwarzschildmetrik in Eddington-Finkelstein Koordinaten

Die Koordinatensingularität der Schwarzschildmetrik kann man mittels spezieller Koordinatentransformationen beseitigen. Transformiert man z.B. in ein Koordinatensystem, welches sich mit einem in das schwarze Loch einfallenden Photon bewegt, so gelangt man zu den sogenannten avancierten (einlaufenden) Eddington-Finkelstein Koordinaten. In dieser Koordinatentransformation wird ein neuer Zeitparameter $\nu$ definiert ($\nu = t + r + 2M {\rm log}( |r/(2M) -1| ) $), der die Bewegung der einlaufenden Photonen im Raumzeit-Diagramm zu Geraden transformiert.

Wir starten mit der Definition der kovarianten Raumzeit-Metrik eines schwarzen Lochs der Masse M in Eddington-Finkelstein Koordinaten:

In [40]:
nu, r, theta, phi, M = symbols('nu, r, theta, phi, M')
Metric = Matrix([[(1-2*M/r), -1, 0, 0], [-1, 0, 0, 0], [0, 0, -r**2, 0], [0, 0, 0, -r**2*sin(theta)**2]]).tolist()
g = MetricTensor(Metric, [nu, r, theta, phi])
g.tensor()
Out[40]:
$$\left[\begin{matrix}- \frac{2 M}{r} + 1 & -1 & 0 & 0\\-1 & 0 & 0 & 0\\0 & 0 & - r^{2} & 0\\0 & 0 & 0 & - r^{2} \sin^{2}{\left (\theta \right )}\end{matrix}\right]$$

und berechnen uns das infinitesimale Weglängenelement $ds^2$:

In [41]:
dnu, dr, dtheta, dphi = symbols('d\\nu, dr, d\\theta, d\\phi')
dx=GenericVector([dnu, dr, dtheta, dphi],[nu, r, theta, phi], config='u',parent_metric=Metric)
dxdx=tensorproduct(dx.tensor(),dx.tensor())
dxdxT=Tensor(dxdx,config="uu")
ds2a=tensorproduct(g.tensor(),dxdxT.tensor())
ds2aT=Tensor(ds2a,config="lluu")
ds2=tensorcontraction(ds2aT.tensor(), (0, 2),(1, 3))
ds2
Out[41]:
$$d\nu^{2} \left(- \frac{2 M}{r} + 1\right) - 2 d\nu dr - d\phi^{2} r^{2} \sin^{2}{\left (\theta \right )} - d\theta^{2} r^{2}$$

Wieder betrachten wir uns die Gleichung für einen radial einfallenden bzw. herausgehenden Lichtstahl ($d\phi=d\theta=0$ und $ds^2=0$):

In [42]:
Eq3=Eq(ds2.subs({(dphi,0),(dtheta,0)}),0)
Eq3
Out[42]:
$$d\nu^{2} \left(- \frac{2 M}{r} + 1\right) - 2 d\nu dr = 0$$

Wir lösen diese Gleichung nach $d\nu$ auf und erhalten zwei Lösungen, die die einlaufenden und auslaufenden Lichtstrahle beschreiben.

In [43]:
solve(Eq3,dnu)
Out[43]:
$$\left [ 0, \quad \frac{2 dr r}{- 2 M + r}\right ]$$
In [44]:
Loes_t0=integrate(solve(Eq3,dnu)[0]/dr, r)
Loes_t0
Out[44]:
$$0$$
In [45]:
Loes_t1=integrate(solve(Eq3,dnu)[1]/dr, r)
Loes_t1
Out[45]:
$$4 M \log{\left (- 2 M + r \right )} + 2 r$$
In [46]:
Loes_t1=Loes_t1.subs(-2*M+r,Abs(-2*M+r))

Die zwei Lösungen der einlaufenden und auslaufenden Lichtstrahle sind wieder nur bis auf eine Konstante bestimmt, die wir zur allgemeinen Lösung hinzu addieren müssen und die die Anfangsbedingung des Lichtstrahls beschreibt. Im Folgenden stellen wir mehrere solcher einlaufenden (rote Kurven) und auslaufenden (blaue Kurven) Lichtstrahle dar, wobei wir die Masse des schwarzen Lochs auf $M=1$ setzen.

In [47]:
L_aus = lambdify(r,Loes_t0.subs(M,1))
L_ein = lambdify(r,Loes_t1.subs(M,1))
rval = np.linspace(0, 3, 5005)

Wir visualisieren die Lösungen in einem Raumzeit-Diagramm, wobei $y=\nu - r$ und $x=r$ ist. Die blauen Geraden veranschaulichen die in das schwarze Loch einfallenden Photonen:

In [48]:
plt.cla()
plt.xlim(0,3)
plt.ylim(0,6)
plt.ylabel(r"$\rm Zeitparameter \,\,\nu -r$")
plt.xlabel(r"$\rm Radius \,\,r$")
const = 1
while const < 10:
    plt.plot(rval,np.real(L_aus(rval))-rval+const,c="blue", linewidth=1.5, linestyle='-');
    plt.plot(rval,np.real(L_ein(rval))-rval+const,c="red", linewidth=1.5, linestyle='-');
    const = const + 1
plt.axvline(x=2, linewidth=3.5, color="black")
plt.text(2, 6, r"$R_S=2M$", size=20, rotation=0.,ha="center", va="center",
         bbox=dict(boxstyle="round",ec="black",fc="white"));

Das obere Raumzeitdiagramm zeigt die radial ein- und auslaufenden Nullgeodäten in avancierten (einlaufenden) Eddington-Finkelstein Koordinaten. Man erkennt, dass ein radial einfallendes Teilchen (blaue Kurven) zwar den Ereignishorizont überschreiten kann, es jedoch nach dem Überschreiten keine Möglichkeit mehr gibt Information nach Außen zu senden.