Hallo, ich möchte diesen Thread als eine Art Werkstatt-Projekt nutzen, um die Spezielle Relativitätstheorie (SRT) für mich systematisch aufzuarbeiten.

Das Ziel ist es, physikalische Modelle nicht nur theoretisch zu betrachten, sondern sie durch mathematische Herleitungen und begleitende Python-Simulationen greifbar zu machen. Mein Ansatz ist dabei „Physik erkennen“: Ich möchte die mathematischen Zusammenhänge, die der SRT zugrunde liegen, numerisch verifizieren und so die physikalische Logik hinter den Formeln transparent machen.

Gern würde ich dies mit Interessierten diskutieren, um das Thema durch diesen Austausch noch besser zu durchdringen. In unregelmäßigen Abständen werde ich hier einzelne Themenkomplexe behandeln, meine Berechnungen dokumentieren und den entsprechenden Python-Code zur Veranschaulichung bereitstellen. Fragen werde ich versuchen zu beantworten.

Erster Arbeitsschritt: Geschwindigkeitsaddition

Ein zentraler Punkt für das Verständnis ist der Vergleich zwischen der klassischen (Newtonschen) Addition und der relativistischen Addition nach Einstein. Ich habe dazu eine erste numerische Gegenüberstellung vorbereitet, um die Auswirkungen bei hohen Geschwindigkeiten (nahe c) zu verdeutlichen.

Hier ist die numerische Gegenüberstellung bei v = 0.5c (als Beispiel):

Vergleich: Newton vs. Einstein v = 0.5c
------------------------------------------
Geschw. (u) | Newton (w) | Einstein (w)
------------------------------------------
 0.0c       |  0.50c     |  0.50c
 0.5c       |  1.00c     |  0.80c
 0.8c       |  1.30c     |  0.92c
 1.0c       |  1.50c     |  1.00c

Schöner und interessanter sieht es aus, wenn man das für verschiedene Geschwindigkeiten berechnet und grafisch darstellt. Der beigefügte Python-Code bildet die Basis für eine solche Simulation, mit der sich die Krümmung der relativistischen Kurve bei unterschiedlichen Systemgeschwindigkeiten (v) direkt visualisieren lässt.

import numpy as np
import matplotlib.pyplot as plt

# Geschwindigkeit des Objekts (u) und Systemgeschwindigkeit (v)
u = np.linspace(-1, 1, 400)
v = 0.5

w_newton = u + v
w_einstein = (u + v) / (1 + (u * v))

plt.figure(figsize=(10, 6))
plt.plot(u, w_newton, label='Newton', linestyle='--')
plt.plot(u, w_einstein, label='Einstein')
plt.title('Geschwindigkeitsaddition: Newton vs. Einstein')
plt.xlabel('u/c')
plt.ylabel('w/c')
plt.grid(True)
plt.legend()
plt.show()

Gern veröffentliche ich hier Grafiken – vor allem für Interessierte ohne Python-Interesse – sobald es dazu eine einfache Möglichkeit hier gibt.

Ich verstehe diesen Thread als ein fortlaufendes Projekt. Wer fachlich interessiert ist, kann hier gerne mitlesen, die Simulationen nachvollziehen oder ergänzende Ansätze zur numerischen Modellierung einbringen. Ich freue mich auf den Austausch.

Gedanken zur SRT: Die Lorentz-Transformation mathematisch herleiten

Nachdem wir in der Geschwindigkeitsaddition gesehen haben, dass Newton bei hohen Geschwindigkeiten versagt, stellt sich die Frage: Welche mathematische Struktur ersetzt die klassische Galilei-Transformation, um die Konstanz der Lichtgeschwindigkeit für alle Beobachter zu wahren?

Die mathematische Anforderung:

Wir suchen eine Transformation zwischen zwei Systemen, S und S', die sich mit der Geschwindigkeit v zueinander bewegen. Das Postulat der SRT besagt: Ein Lichtstrahl, der sich in S mit c ausbreitet, muss sich auch in S' mit c ausbreiten.

Mathematisch führt das auf die Forderung:

Die Herleitung:

Wir betrachten zwei Inertialsysteme S und S'. Ein Lichtsignal startet zur Zeit t = 0 am Ort x = 0.
In S gilt:

In S' muss ebenfalls gelten:

.

Wir setzen den linearen Ansatz

voraus. Da die Natur homogen ist, muss die Rücktransformation dieselbe Form haben:

Setzen wir den Ausdruck für x' in die Gleichung für x ein:

Stellen wir nach t' um:

Damit nun

für alle x=ct gilt, muss der Faktor

zwingend folgende Form haben:

Das ist der Schlüssel zur Relativität. Sobald v klein gegenüber c ist, wird

und wir landen wieder bei Newton. Nähert sich v aber der Lichtgeschwindigkeit, dehnt sich dieser Faktor

massiv aus.

Numerische Umsetzung:

Hier ist der Code, um den Einfluss von

auf die Längenkontraktion zu visualisieren. Damit können wir direkt prüfen, wie stark die relativistischen Effekte bei verschiedenen Geschwindigkeiten zunehmen:

import numpy as np
import matplotlib.pyplot as plt

# Gamma-Faktor berechnen
def get_gamma(v_c):
    # Verhindert Division durch Null bei v_c = 1
    return 1 / np.sqrt(1 - np.clip(v_c**2, 0, 0.999999))

# Geschwindigkeiten von 0 bis 0.99c
v_c = np.linspace(0, 0.99, 500)
gamma = get_gamma(v_c)

# Plot erstellen
plt.figure(figsize=(10, 6))
plt.plot(v_c, gamma, label=r'$\gamma = \frac{1}{\sqrt{1-v^2/c^2}}$', color='blue', linewidth=2)

# Achsenbeschriftung und Raster
plt.title('Der Lorentz-Faktor Gamma in Abhaengigkeit von v/c')
plt.xlabel('Geschwindigkeit v/c')
plt.ylabel('Lorentz-Faktor Gamma')
plt.grid(True, which='both', linestyle='--', linewidth=0.5)
plt.axhline(1, color='black', linewidth=1)
plt.axvline(0, color='black', linewidth=1)
plt.legend()

# Plot anzeigen
plt.show()

Die folgende Tabelle verdeutlicht die numerischen Auswirkungen. Man erkennt sehr gut, wie der Lorentz-Faktor bei niedrigen Geschwindigkeiten nahe 1 bleibt, aber bei Annäherung an die Lichtgeschwindigkeit steil ansteigt:

# Zusammenhang: Geschwindigkeit v/c und Lorentz-Faktor Gamma
# ---------------------------------------------------------
# v/c     | Gamma
# ---------------------------------------------------------
# 0.0     | 1.000
# 0.5     | 1.155
# 0.8     | 1.667
# 0.9     | 2.294
# 0.99    | 7.089

Dies ist der zweite Baustein meiner SRT-Werkstatt. Ich möchte hiermit zeigen, dass

nicht einfach „da ist“, sondern ein notwendiger Korrekturfaktor, der aus der Geometrie der Raumzeit folgt.

Ich halte den direkten Zugang über die 3er-Geschwindigkeit für nicht so geschickt.

Es ist m.E. vorteilhaft, sich den Zusammenhang zwischen 4er- und 3er-Geschwindigkeit klarzumachen, und statt der relativistischen Geschwindigkeitsaddition die Lorentz-Transformation zu bemühen. Man lernt die Zusammenhänge besser zu verstehen, die Verallgemeinerung ist einfacher, die Mathematik nicht komplizierter.

SRT- Übergang zum Vierer-Formalismus

nachdem wir gestern die mathematischen Grundlagen der Transformation gestreift haben, möchte ich heute den konsequenten Schritt zum Vierer-Formalismus vollziehen.

Wie TomS und Ralf in der Diskussion bereits angedeutet haben, ist der Weg über die klassische 3er-Geschwindigkeit

zwar intuitiv, aber koordinatenabhängig. Für eine robuste SRT-Beschreibung verlassen wir daher diesen Pfad und nutzen die Vierergeschwindigkeit

1. Die geometrische Definition

Wir definieren die Vierergeschwindigkeit

als Ableitung des Orts-Vierervektors

nach der invarianten Eigenzeit

:

Dabei nutzen wir die Minkowski-Metrik

,

um die geometrischen Eigenschaften der Raumzeit abzubilden.

2. Symbolische Verifikation

Um die Transformation und die daraus resultierende Invarianz der Norm

nicht nur zu behaupten, sondern mathematisch zu verifizieren, habe ich das folgende symbolische Jupyter-Programm (basierend auf sympy) erstellt. Dies erlaubt uns, die Lorentz-Transformation als lineare Operation (gemäß Ralfs Hinweis auf 1. Ordnung) exakt durchzuführen:

import sympy as sp
from IPython.display import display

# 1. Symbole definieren
beta, c, v = sp.symbols('beta c v')
gamma = 1 / sp.sqrt(1 - beta**2)

# Metrik-Tensor (Minkowski-Metrik)
eta = sp.diag(1, -1, -1, -1)

# 2. Lorentz-Boost Matrix fuer einen Boost in x-Richtung
Lambda = sp.Matrix([
    [gamma, -gamma * beta, 0, 0],
    [-gamma * beta, gamma, 0, 0],
    [0, 0, 1, 0],
    [0, 0, 0, 1]
])

# 3. Vierergeschwindigkeit U^mu
U = sp.Matrix([gamma * c, gamma * v, 0, 0])

# 4. Transformation berechnen: U' = Lambda * U
U_prime = Lambda * U
U_prime_simplified = sp.simplify(U_prime)

print("--- LaTeX-Code fuer den transformierten Vierervektor U' ---")
print(sp.latex(U_prime_simplified))
display(U_prime_simplified)

# 5. Invarianzpruefung: U_mu * U^mu
U_mu = eta * U
invarianz = U_mu.dot(U)
invarianz_simplified = sp.simplify(invarianz)

print("\n--- LaTeX-Code (vor Substitution): ---")
print(sp.latex(invarianz_simplified))

# 6. Substitution beta = v/c zur finalen Bestaetigung
invarianz_fertig = invarianz_simplified.subs(beta, v/c)
invarianz_fertig_sim = sp.simplify(invarianz_fertig)

print("\n--- LaTeX-Code (nach Substitution, Endergebnis): ---")
print(sp.latex(invarianz_fertig_sim))
display(invarianz_fertig_sim)

3. Invarianz als Beweis

Der größte Vorteil: Die „Länge“ (Norm) dieses Vektors ist ein Invariante. Berechnet man das Skalarprodukt unter Berücksichtigung der Metrik

, erhält man im obigen Programm (Latexcode vor der Substitution):

Das bedeutet: Egal wie wir das Bezugssystem wählen, der Vierervektor rotiert zwar im Raum, behält aber seine fundamentale physikalische Norm bei.

4. Mathematische Verifikation (Lineare Transformation)

Wie Ralf anmerkte, arbeiten wir hier mit einer linearen Abbildung (1. Ordnung). Die Transformation eines Vierervektors in ein bewegtes System S' erfolgt über die Lorentz-Matrix

:

die LaTeX-Ausgabe des Programms für den transformierten Vektor zeigt sich für die Komponenten:

Setzt man die physikalische Identität

ein, bestätigt sich symbolisch die Invarianz (Latexcode nach der Substitution:

Fazit: Der Vierer-Formalismus ist keine „Spielerei“, sondern das notwendige Werkzeug, um die SRT kovariant zu beschreiben. Ich werde meine weiteren Module nun ausschließlich auf dieser Basis aufbauen, da sie mathematisch starr und weniger fehleranfällig ist.

Wie seht ihr die Kopplung von Linearität (Ralf) und kovarianter Invarianz bei diesem Übergang?

Die Invarianz der Vierergeschwindigkeit: Warum

Wir müssen die Geometrie der Raumzeit (die Minkowski-Metrik) in die Arithmetik zwingen. Hier ist der Faktencheck, warum diese Multiplikation (das Skalarprodukt) für den Vierer-Geschwindigkeitsvektor

zwingend

ergeben muss:

1. Das mathematische „Warum“

In der klassischen Mechanik nutzen wir den Euklidischen Raum:

In der Relativitätstheorie nutzen wir den Minkowski-Raum. Um den Sprung von der klassischen Kinematik in die vierdimensionale SRT-Welt zu verstehen, also um den Vierervektor

zu erhalten, müssen wir das Differential der Raumzeit-Koordinaten

durch das Differential der Eigenzeit d

teilen. Der Vierer-Geschwindigkeitsvektor ist definiert als:

Diese Definition leitet sich wie folgt her:

2. Die Definition der Eigenzeit​

Wir betrachten die Eigenzeit

als die Zeit, die eine Uhr anzeigt, die sich mit dem Objekt mitbewegt. Aus der Zeitdilatation wissen wir, dass das Verhältnis zwischen der Zeit eines ruhenden Beobachters (t) und der Eigenzeit (d

) durch den Lorentz-Faktor

gegeben ist:

wobei bekanntermaßen

gilt.

3. Der Raumzeit-Vektor

Wir betrachten einen infinitesimalen Weg im Minkowski-Raum:

Hierbei ist c dt die Zeitkomponente (mit c als Skalierungsfaktor für die Dimension) und (dx, dy, dz) die räumliche Verschiebung.

4. Die Bildung der Vierergeschwindigkeit​

Die Vierergeschwindigkeit

ist die Ableitung des Raumzeit-Vektors

nach der Eigenzeit:

Wenden wir die Kettenregel an (z. B.

), um nach t abzuleiten (da wir unsere räumlichen Geschwindigkeiten

etc. kennen):

Da bekannt ist, dass

ist, ergibt sich für jede Komponente:

Zeitkomponente (

Räumliche Komponenten (

(Analog für

und

) ergibt letztendlich

Zusammenfassung​

Zusammengesetzt erhalten wir gesuchten Vektor:

Warum ist das wichtig?
In der klassischen Mechanik ist die Geschwindigkeit einfach

. Die Vierergeschwindigkeit „füttert“ diese räumliche Geschwindigkeit mit dem

-Faktor und fügt die Zeitkomponente (

c) hinzu.

Damit ist die Vierergeschwindigkeit immer tangential an die Weltlinie des Objekts in der Raumzeit. Wenn man die Zeitdilatation (

) mit der klassischen Geschwindigkeit multipliziert, „spürt“ man mathematisch genau den Effekt, dass Zeit und Raum nicht mehr unabhängig voneinander sind.

Python-Werkstatt: Der Viererimpuls in der Simulation​

Dieses kleine Skript berechnet den Viererimpuls für ein Teilchen bei verschiedenen Geschwindigkeiten. Es zeigt, wie die Energie (

import numpy as np
import matplotlib.pyplot as plt

# Parameter
v_values = np.linspace(0, 0.99, 100) # Geschwindigkeiten von 0 bis fast c
m = 1.0

# Hyperbel berechnen: E^2 - p^2 = m^2 => E = sqrt(m^2 + p^2)
p_x = np.linspace(0, 3, 100)
E = np.sqrt(m**2 + p_x**2)

plt.figure(figsize=(8, 6))

# Hyperbel zeichnen
plt.plot(p_x, E, label='Massenschale (Hyperbel)', color='blue', lw=2)

# Vektoren für verschiedene Geschwindigkeiten einzeichnen
v_test = [0, 0.6, 0.8]
for v in v_test:
    gamma = 1 / np.sqrt(1 - v**2)
    px = m * gamma * v
    E_val = m * gamma
    plt.arrow(0, 0, px, E_val, head_width=0.1, head_length=0.15, fc='black', ec='black')
    plt.text(px, E_val, f' v={v}c', fontsize=10)

# Diagramm-Design
plt.axhline(0, color='black', linewidth=1)
plt.axvline(0, color='black', linewidth=1)
plt.xlabel('Impuls $p_x$')
plt.ylabel('Energie $E/c$')
plt.title('Viererimpuls-Hyperbel (Massenschale)')
plt.grid(True, linestyle='--')
plt.legend()
plt.show()

Wer die Grafik selbst generieren möchte, kann diesen Code in einem lokalen Python-Interpreter oder online (z.B. Google Colab) ausführen.

Dieses Programm dient als numerischer Check. Es zeigt für beliebige Geschwindigkeiten v, dass die Energie E zwar mit dem Lorentz-Faktor

ansteigt, das Skalarprodukt

jedoch – unabhängig vom gewählten v – immer exakt bei

landet. Damit verifizieren wir rechnerisch, dass der Viererimpuls die Energie-Impuls-Relation korrekt abbildet und unsere Invariante m stets gewahrt bleibt.

Python:

import numpy as np
import matplotlib.pyplot as plt

def plot_viererimpuls_analyse(v_test=[0, 0.6, 0.8]):
    m = 1.0
    c = 1.0
    
    # 1. Hyperbel (Massenschale)
    p_x_range = np.linspace(0, 2.5, 100)
    E_range = np.sqrt(m**2 + p_x_range**2)
    
    fig, (ax1, ax2) = plt.subplots(1, 2, figsize=(14, 5))
    
    # Grafik Links: Massenschale
    ax1.plot(p_x_range, E_range, label='Massenschale ($m=1$)', color='blue', lw=2)
    
    # Grafik Rechts: Kästchendiagramm (Energie-Impuls-Bilanz)
    bar_width = 0.25
    x_positions = np.arange(len(v_test))
    
    for i, v in enumerate(v_test):
        gamma = 1 / np.sqrt(1 - v**2)
        p0 = m * gamma * c
        px = m * gamma * v
        
        # Plot in Links
        ax1.scatter(px, p0, color='black', zorder=5)
        ax1.annotate(f' v={v}c', (px, p0), xytext=(5, 5), textcoords='offset points')
        
        # Plot in Rechts (Bilanz: p0^2 - px^2 = m^2)
        ax2.bar(i - 0.15, p0**2, width=bar_width, color='orange', label='(E/c)^2' if i==0 else "")
        ax2.bar(i + 0.15, -px**2, width=bar_width, color='blue', label='-(px)^2' if i==0 else "")
        ax2.axhline(0, color='black', lw=1)
        ax2.text(i, 0.1, f'm²={p0**2 - px**2:.1f}', ha='center', va='bottom')

    ax1.set_xlabel('Impuls $p_x$'); ax1.set_ylabel('Energie $E/c$')
    ax1.set_title('Massenschale (Hyperbel)'); ax1.grid(True); ax1.legend()
    
    ax2.set_xticks(x_positions); ax2.set_xticklabels([f'v={v}c' for v in v_test])
    ax2.set_title('Bilanz: $E^2 - p^2 = m^2$'); ax2.legend()
    
    plt.show()

plot_viererimpuls_analyse()

Die Brücke: Von der Dynamik zur Geometrie der Weltlinien​

Nachdem wir den Viererimpuls

als unerschütterliche Invariante kennengelernt haben, stellt sich eine fundamentale Frage: Warum „dehnt“ sich dann die Zeit oder „schrumpft“ der Raum für bewegte Beobachter?

Die Antwort liegt in der Geometrie: Es ist eine reine Projektionsfrage.

1. Die mathematische Brücke

Die Zeitdilatation ist kein „mechanischer“ Effekt der Uhr, sondern eine Konsequenz aus der Invarianz des Raumzeit-Intervalls

. Für jeden Beobachter muss gelten:

Wenn ein Objekt mit der Geschwindigkeit v an uns vorbeifliegt, gilt für seinen Weg

. Setzen wir das ein:

Nach

aufgelöst ergibt das:

2. Die physikalische Deutung (Das Schatten-Prinzip)

Man stelle sich einen Stab (unser Vierervektor) in der Raumzeit vor. Wenn man ihn kippt (Beschleunigung), ändert sich die Projektion auf unsere Koordinatenachsen.

• Was man als Zeitdilatation misst, ist lediglich die Projektion der Weltlinie des Objekts auf unsere Zeitachse.
• Was man als Längenkontraktion misst, ist die Projektion auf unsereOrtsachse.

Die Invariante (die „echte“ Länge des Vierervektors) bleibt immer gleich – wir sehen lediglich unterschiedliche Schatten an der Wand.

Wir brauchen keine „Phantasie-Uhren“, um Zeitdilatation zu erklären. Wir brauchen nur die Geometrie der Metrik. Wenn ein Beobachter eine andere Zeit misst, ist das geometrisch gesehen nur die Folge davon, dass er auf einer anderen „Achse“ in der Raumzeit unterwegs ist.

Visualisierung der Perspektive (Python-Werkstatt)​

Um diese „Projektion“ greifbar zu machen, schauen wir uns an, wie sich die Achsen eines bewegten Systems in unserem Minkowski-Diagramm verhalten. Die Achsen „kippen“ symmetrisch zur Lichtlinie.

import numpy as np
import matplotlib.pyplot as plt

def plot_minkowski(v=0.6):
    # Die Achsen kippen symmetrisch zur Lichtlinie (x=t)
    t = np.linspace(-2, 2, 100)
    x = np.linspace(-2, 2, 100)
  
    plt.figure(figsize=(7,7))
  
    # Achsen des ruhenden Systems S
    plt.axhline(0, color='black', lw=2)
    plt.axvline(0, color='black', lw=2)
  
    # Achsen des bewegten Systems S'
    # t'-Achse: Steigung 1/v im (t,x)-Diagramm oder x = v*t
    plt.plot(v*t, t, color='red', label="t'-Achse (Zeit des bewegten Systems)")
    # x'-Achse: Steigung v im (t,x)-Diagramm oder t = v*x
    plt.plot(x, v*x, color='red', label="x'-Achse (Ort des bewegten Systems)", linestyle='--')
  
    # Lichtlinie zum Vergleich
    plt.plot(t, t, color='green', linestyle=':', label="Lichtlinie (v=c)")
  
    plt.xlim(-2, 2); plt.ylim(-2, 2)
    plt.xlabel("Ort x"); plt.ylabel("Zeit t")
    plt.title(f"Minkowski-Diagramm: Perspektivwechsel bei v={v}c")
    plt.legend(); plt.grid(True)
    plt.show()

plot_minkowski(v=0.6)

Erklärung zur Visualisierung: Die Grafik zeigt uns das „Skelett“ der SRT: Die Achsen eines bewegten Systems (t' und x') kippen symmetrisch zur Lichtlinie (der grünen gepunkteten Linie, v=c). Wenn ein Beobachter eine andere Zeit misst, ist das geometrisch gesehen nur die Folge davon, dass er auf einer anderen „Achse“ in der Raumzeit unterwegs ist. Was wir als Zeitdilatation wahrnehmen, ist lediglich die Projektion seiner Zeitachse auf unsere Koordinaten. Das Minkowski-Diagramm macht diesen Perspektivwechsel sichtbar: Je schneller das System S' ist, desto mehr schmiegen sich seine Achsen an die Lichtlinie an – und desto stärker werden die Projektionseffekte, die wir als Zeit- und Längeneffekte interpretieren. Damit ist die Kinematik kein mysteriöser Effekt mehr, sondern eine zwingende Konsequenz aus der Geometrie unserer Raumzeit.

Der nächste Schritt: Die Längenkontraktion (Der "Schnitt")​

Wenn die Zeitdilatation die Projektion auf die t'-Achse ist, dann ist die Längenkontraktion die Projektion auf die x'-Achse. Hier ist die mathematische Brücke:

Die Längenkontraktion als Schnitt in der Raumzeit​

In der klassischen Physik ist ein Stab ein Objekt, das „einfach da ist“. In der SRT ist ein Objekt eine Ansammlung von Weltlinien. Wenn man die Länge eines bewegten Stabes messen will, muss man seine beiden Enden gleichzeitig im System S messen.

1. Die Mathematik:

Das Raumzeit-Intervall muss für die Endpunkte des Stabes invariant bleiben. Wenn der Stab in seinem Ruhesystem S' die Länge

hat (die Enden sind bei

und

), dann sind das zwei Ereignisse, die im Ruhesystem gleichzeitig stattfinden (

).

Wenn wir diese Endpunkte mittels Lorentz-Transformation in unser System S umrechnen (mit

) ), erhalten wir für den Abstand der Enden bei gleichzeitigem Messen in S(t = 0):

Der Stab erscheint in unserem System S also verkürzt.

2. Die geometrische Deutung (Der "Schnitt"):

Längenkontraktion bedeutet, dass wir den Stab zu zwei verschiedenen Zeiten im Ruhesystem des Stabes „schneiden“. Wir messen den vorderen Punkt zu einem Zeitpunkt

und den hinteren Punkt zu einem Zeitpunkt

. Weil der Stab sich bewegt, „fehlt“ uns ein Teil der Länge, wenn wir versuchen, ihn in unserem System gleichzeitig „einzufangen“.

Python-Werkstatt: Der Stab im Minkowski-Diagramm​

Wir zeichnen ein „Welt-Röhrchen“ (einen Stab, der durch die Zeit läuft) und zeigen, wie die Kontraktion durch das Schneiden der Weltlinien bei t=0 entsteht. Das Programm vergleicht den Ruhezustand (strichpunktiert) mit dem bewegten Zustand (durchgezogen) und markiert die Differenz durch die orangefarbene Referenzlinie.

import numpy as np
import matplotlib.pyplot as plt

def plot_laengenkontraktion_werkstatt(v=0.6, L0=0.5):
    """
    Erstellt die Grafik für das Werkstatt-Archiv.
    - Strichpunktierte Linien: Stab in Ruhe (v=0)
    - Durchgezogene Linien: Stab in Bewegung (v)
    """
    fig, ax = plt.subplots(figsize=(8, 6))
   
    gamma = 1 / np.sqrt(1 - v**2)
    t = np.linspace(-0.3, 0.3, 100)
   
    # 1. Weltlinien in Ruhe (v=0) - Strichpunktiert
    ax.plot(np.zeros_like(t), t, 'r-.', lw=1.5, alpha=0.4, label="WL 1 (Ruhe, v=0)")
    ax.plot(L0 * np.ones_like(t), t, 'b-.', lw=1.5, alpha=0.4, label="WL 2 (Ruhe, v=0)")
   
    # 2. Weltlinien in Bewegung (v) - Durchgezogen
    ax.plot(v*t, t, 'r-', lw=2, label="WL 1 (Bewegung)")
    ax.plot(v*t + L0/gamma, t, 'b-', lw=2, label="WL 2 (Bewegung)")
   
    # 3. Referenz bei L0 (Ruheposition)
    ax.axvline(L0, color='orange', linestyle='--', linewidth=2, alpha=0.5, label="Ruhe-Position (L0)")
   
    # 4. Messung bei t=0
    ax.axhline(0, color='black', linestyle=':', label="Messung t=0")
   
    # 5. Längenvergleich (Grüner Pfeil für L)
    x1, x2 = 0, L0/gamma
    ax.annotate("", xy=(x2, 0), xytext=(x1, 0), arrowprops=dict(arrowstyle="<->", color='green', lw=2))
    ax.text((x1+x2)/2, 0.05, f'L={x2-x1:.2f}', color='green', ha='center', fontweight='bold')
   
    # 6. Ruhelänge L0 als grüne gepunktete Linie (oberhalb)
    ax.annotate("", xy=(L0, 0.08), xytext=(0, 0.08), arrowprops=dict(arrowstyle="<->", color='green', linestyle=':', lw=2))
    ax.text(L0/2, 0.10, f'Ruhelänge L0={L0}', color='green', ha='center', fontsize=10, style='italic')
   
    ax.set_xlim(-0.1, 0.6); ax.set_ylim(-0.2, 0.2)
    ax.set_title(f"Längenkontraktion im Vergleich (v={v}c)")
    ax.set_xlabel("Ort x"); ax.set_ylabel("Zeit t")
    ax.legend(loc='upper right', fontsize='x-small')
    ax.grid(True)
   
    plt.show()
    plt.close('all')

# Ausführung
plot_laengenkontraktion_werkstatt(v=0.6, L0=0.5)

Zusammenfassung​

Diese geometrische Darstellung entlarvt die Längenkontraktion als ein Phänomen der „Perspektive“ in der Raumzeit. Wir messen keine physische Stauchung des Stabes, sondern wir sehen die Auswirkung des schrägen Schnitts durch die Welt-Röhre. Die orangefarbene Referenzlinie macht dabei unmissverständlich klar: Die Differenz zwischen

und L ist kein Messfehler, sondern die direkte geometrische Konsequenz der Lorentz-Transformation. Mit diesem Bild ist die „Längenkontraktion“ nicht mehr nur eine Formel im Lehrbuch, sondern ein konstruktives Element on der Werkstatt-Dokumentation.