Speciale Relativiteit in de ORT#
De ORT is gebaseerd op twee principes:
Alles beweegt met lichtsnelheid \(c\) — alleen de richting door de ruimtetijd varieert, de snelheid niet
Invariantie van Zijn — het product \(m \cdot v_{tijd} = m_0 \cdot c\) is behouden
Uit deze twee principes volgt de volledige speciale relativiteit: tijddilatatie, lengtecontractie, de Lorentz-transformatie, \(E_0 = m_0 c^2\), en de energie-impulsrelatie.
import sys, pathlib
sys.path.insert(0, str(pathlib.Path().resolve().parent / 'shared'))
from ort_core import (C, ORT, NewtonModel, EinsteinModel)
from ort_plots import (velocity_circle, velocity_circle_interactive, gamma_curve,
simultaneity_diagram, lorentz_transform_grid, zijn_vector_diagram,
model_comparison_bar, unit_circle_diagram, lorentz_decomposition_diagram,
duality_diagram, light_ship_diagram, observer_axes_diagram,
lc_symmetry_diagram)
import math
import numpy as np
%matplotlib inline
1 De snelheidscirkel#
Kernprincipe: elk object beweegt altijd met precies de lichtsnelheid \(c\) door de vierdimensionale ruimtetijd. Tijd is een bewegingsrichting net als de drie ruimtedimensies. Een object in rust beweegt met 1 seconde per seconde door de tijd — en dat is de lichtsnelheid \(c\). Versnellen in de ruimte betekent de snelheidsvector draaien van de tijdrichting naar de ruimterichting.
Dit enkele principe reproduceert alle kinematische effecten van de speciale relativiteit: tijddilatatie, lengtecontractie, de Lorentz-transformatie, snelheidsoptelling en rapiditeit.
1.1 Richting θ en de snelheidscirkel#
De snelheidsnorm#
Dit is een cirkel met straal \(c\) in de snelheidsruimte — de 2D-doorsnede van een 4D-bol in de richting van de beweging. De hoek \(\theta\) meet de richting van de snelheidsvector ten opzichte van de tijdas.
Parametrisatie met θ#
\(\theta = 0\): object in rust, beweegt met \(c\) door de tijd
\(\theta = 90°\): foton, beweegt met \(c\) door de ruimte, geen voortgang door de tijd
Tijddilatatie — direct uit de geometrie#
De eigentijd \(\tau\) van een bewegend object tikt trager met factor \(\cos\theta\) — de projectie van de snelheidsvector op de tijdas.
# De Snelheidsbol (2D-doorsnede)
velocity_circle(lang='nl')
pass
1.2 De bewegende waarnemer#
Licht beweegt voor iedereen met c#
Een astronaut in een bewegend ruimteschip doet een lamp aan in het midden. Zij ziet het licht tegelijkertijd de voor- en achterkant raken — het licht beweegt immers met \(c\) in beide richtingen, en de afstanden zijn gelijk.
Een waarnemer die stilstaat ziet hetzelfde licht ook met \(c\) bewegen — maar het schip beweegt. De achterkant komt het licht tegemoet, de voorkant beweegt weg. Het licht bereikt de achterkant dus eerder dan de voorkant.
Twee gebeurtenissen die voor de astronaut gelijktijdig zijn, zijn dat niet voor de waarnemer die stilstaat. Dit is de relativiteit van gelijktijdigheid — een direct gevolg van het feit dat beide waarnemers licht met dezelfde snelheid \(c\) zien bewegen.
Dualiteit: gelijktijdigheid en gelijkplaatsigheid#
Het ruimtetijddiagram hieronder toont de wereldlijnen van het schip en de lichtstralen vanuit de lamp. De lijn door de twee aankomstpunten is de gelijktijdigheidslijn (\(x'\)-as) van de astronaut — voor haar gebeuren die twee gebeurtenissen tegelijk. De wereldlijn van het schip is de gelijkplaatsigheidslijn (\(ct'\)-as) — voor haar is dat steeds dezelfde plek.
Beide assen kantelen over dezelfde hoek \(\alpha = \arctan(v/c)\): de wereldlijn vanuit de \(ct\)-as, de gelijktijdigheidslijn vanuit de \(x\)-as. Ze zijn symmetrisch rond de lichtlijn.
# Licht in het ruimteschip: gelijktijdig voor de astronaut, niet voor de stilstaande waarnemer
light_ship_diagram(beta=0.5, lang='nl')
pass
Relativiteit van gelijktijdigheid#
Twee gebeurtenissen die gelijktijdig zijn in S (\(\Delta t = 0\)) maar gescheiden door afstand \(\Delta x\), zijn in S’ (\(v = c\sin\theta\)) niet gelijktijdig. Het tijdsverschil is:
Dit is het speciale geval (\(\Delta t = 0\)) van de algemene Lorentz-tijdtransformatie (formule 6b hieronder).
Lengtecontractie#
Als tijd dilateert met \(\cos\theta\), moet ruimte met dezelfde factor contracteren — anders zou de lichtsnelheid veranderen:
Tijddilatatie en lengtecontractie zijn dezelfde geometrie: projectie van een eenheidsvector op de as van de waarnemer. In §1.3 wordt dit visueel samengevat in de eenheidscirkel.
De volledige Lorentz-transformatie#
Met \(ct\) als tijdcoördinaat worden de formules volledig symmetrisch. De vier ingrediënten zijn:
Tijddilatatie (\(c\tau = ct\cos\theta\))
Lengtecontractie (\(L = L_0\cos\theta\))
Relativiteit van gelijktijdigheid (\(c\,\Delta t' = \tan\theta\,\Delta x\) bij \(\Delta t = 0\))
Ruimtelijke verschuiving (\(x - \sin\theta \cdot ct\))
Samen geven zij:
De symmetrie is exact: beide formules hebben \(\cos\theta\) op de diagonaal en \(-\sin\theta\) als kruisterm. Dit is identiek aan de Lorentz-transformatie uit de SRT: \(x' = \gamma(x - \beta\,ct)\) en \(ct' = \gamma(ct - \beta\,x)\).
Inverse Lorentz-transformatie#
De inverse transformatie (van het bewegende frame terug naar het rustframe) volgt door \(\theta \to -\theta\) (de beweging is omgekeerd):
De diagonaal is \(1/\cos\theta = \gamma\), de kruistermen bevatten \(\tan\theta\). Dit is de hyperbolische “rotatie” van de ruimtetijd — analoog aan een gewone rotatie, maar met \(\cosh\) en \(\sinh\) (via rapiditeit \(\varphi = \text{artanh}(\sin\theta)\)).
1.3 De eenheidscirkel#
De eenheidsvectoren van een bewegende waarnemer, geroteerd over \(\theta\), geven de vier factoren van de Lorentz-transformatie.
In het diagram hieronder zijn de tijd- en ruimterichting als eenheidsvectoren getekend op een cirkel met straal 1, met assen \(x\) (lichtseconden) en \(ct\) (lichtseconden):
De tijdrichting (blauw) projecteert op de \(ct\)-as met \(\cos\theta\) → tijddilatatie
De ruimterichting (rood) projecteert op de \(x\)-as met \(\cos\theta\) → lengtecontractie
De kruistermen (\(\sin\theta\) en \(-\sin\theta\)) tonen de menging tussen ruimte en tijd — precies de kruistermen uit de Lorentz-transformatie (formules 6a en 6b)
Omdat alle snelheden op een cirkel liggen (\(v_r^2 + v_t^2 = c^2\)), levert de cirkelgeometrie automatisch de twee ingrediënten van de Lorentz-transformatie:
Cirkel |
Lorentz-transformatie |
Rol |
|---|---|---|
\(\sin\theta\) |
\(-\sin\theta \cdot ct\) en \(-\sin\theta \cdot x\) |
translatie — verschuiving tussen ruimte en tijd |
\(\cos\theta\) |
\(\div\,\cos\theta\) (\(= \times\,\gamma\)) |
schaling — tijddilatatie en lengtecontractie |
De volledige Lorentz-transformatie is dus een geometrisch gevolg van het feit dat snelheid op een eenheidscirkel ligt. De hoek \(\theta\) bepaalt de verdeling — sinus en cosinus doen de rest.
# Eenheidsvectoren van de bewegende waarnemer: beide projecties geven cos(theta)
observer_axes_diagram(theta_deg=30, lang='nl')
pass
1.4 Snelheidsoptelling en rapiditeit#
In Newtons mechanica tellen snelheden gewoon op: \(v_{totaal} = v_1 + v_2\). Hiermee kan de snelheid groter worden dan de lichtsnelheid.
De relativistische snelheidsoptelling volgt uit de rapiditeit \(\varphi = \text{artanh}(\sin\theta) = \text{artanh}(\beta)\). Rapiditeit is de hyperbolische hoek van de boost — hyperbolische hoeken tellen op net als gewone rotatiehoeken: \(\varphi_{totaal} = \varphi_1 + \varphi_2\). Via \(v = c \tanh(\varphi)\) geeft dit:
Dit is identiek aan de relativistische snelheidsoptelling uit de SRT. Resultaat: twee objecten die elk met \(0.8c\) bewegen, zien elkaar niet met \(1.6c\) maar met \(\approx 0.976c\) — altijd onder \(c\).
# Snelheidsoptelling: 0.8c + 0.8c geeft NIET 1.6c
v1 = 0.8 * C
v2 = 0.8 * C
v_newton = NewtonModel.velocity_addition(v1, v2)
v_srt = EinsteinModel.velocity_addition(v1, v2)
v_ort = ORT.velocity_addition(v1, v2)
print(f"Snelheidsoptelling: {v1/C:.1f}c + {v2/C:.1f}c")
print(f" Newton: {v_newton/C:.4f}c (FOUT: overschrijdt c!)")
print(f" SRT: {v_srt/C:.4f}c")
print(f" ORT: {v_ort/C:.4f}c (= SRT)")
print()
# Rapiditeitsverificatie -- SRT en ORT
phi1_srt = math.atanh(v1 / C)
phi2_srt = math.atanh(v2 / C)
phi_total_srt = phi1_srt + phi2_srt
v_from_phi_srt = C * math.tanh(phi_total_srt)
phi1_ort = ORT.rapidity(v1)
phi2_ort = ORT.rapidity(v2)
phi_total_ort = phi1_ort + phi2_ort
v_from_phi_ort = C * math.tanh(phi_total_ort)
print(f"Rapiditeit (SRT): phi1={phi1_srt:.4f} + phi2={phi2_srt:.4f} = {phi_total_srt:.4f}")
print(f" v = c*tanh(phi_totaal) = {v_from_phi_srt/C:.4f}c")
print(f"Rapiditeit (ORT): phi1={phi1_ort:.4f} + phi2={phi2_ort:.4f} = {phi_total_ort:.4f}")
print(f" v = c*tanh(phi_totaal) = {v_from_phi_ort/C:.4f}c")
print(f" Verschil SRT vs ORT: {abs(phi_total_srt - phi_total_ort):.2e} (identiek)")
Snelheidsoptelling: 0.8c + 0.8c
Newton: 1.6000c (FOUT: overschrijdt c!)
SRT: 0.9756c
ORT: 0.9756c (= SRT)
Rapiditeit (SRT): phi1=1.0986 + phi2=1.0986 = 2.1972
v = c*tanh(phi_totaal) = 0.9756c
Rapiditeit (ORT): phi1=1.0986 + phi2=1.0986 = 2.1972
v = c*tanh(phi_totaal) = 0.9756c
Verschil SRT vs ORT: 0.00e+00 (identiek)
2 Invariantie van Zijn#
Principe: het product van de massa van een object en zijn snelheid door de tijd is behouden en onafhankelijk van de waarnemer: \(m \cdot v_t = m_0 \cdot c\).
De naam Ontologische Relativiteitstheorie verwijst naar dit begrip: ontologie is de filosofische studie van wat bestaat. De ORT vertrekt vanuit het Zijn — het fundamentele bestaan van een object (\(m_0\)) — als invariant.
Wanneer een object sneller door de ruimte beweegt en dus trager door de tijd, neemt zijn massa evenredig toe, zodat het product \(m \cdot v_t\) onveranderd blijft.
2.1 Het Zijn-principe#
Massa-Zijn (invariant)#
Energie-gevolg (afgeleid)#
Dit volgt direct uit (8) en \(E = m_{rel} c^2\) (formule 12, afgeleid in §2.2).
Relativistische massa#
Uit \(S_m = m_0 c\) en \(v_{tijd} = c\cos\theta\) volgt:
De relativistische massa volgt hier rechtstreeks uit het Zijn-principe. In de SRT wordt hetzelfde resultaat (\(\gamma m_0\)) bereikt via impulsbehoud onder de Lorentz-transformatie.
# Verificatie: Invariantie van Zijn voor diverse snelheden
m0 = 1.0 # kg (eenheidsmassa)
print(f"Invariantie van Zijn: S_m = m_rel * v_tijd = m0 * c = {m0 * C:.6e} kg*m/s")
print()
print(f"{'beta':>6} {'m_rel (gamma*m0)':>16} {'v_tijd (m/s)':>14} {'S_m':>14} {'= m0*c?':>10}")
print("-" * 70)
for beta in [0.0, 0.3, 0.5, 0.8, 0.9, 0.99]:
stv = ORT.from_beta(beta)
m_rel = stv.relativistic_mass(m0)
v_t = stv.v_time
s_m = m_rel * v_t
match = abs(s_m - m0 * C) < 1e-6
print(f"{beta:6.2f} {m_rel:16.6f} {v_t:14.2f} {s_m:14.6e} {'JA' if match else 'NEE':>10}")
print()
print("De Zijn-waarde is constant -- onafhankelijk van de snelheid!")
Invariantie van Zijn: S_m = m_rel * v_tijd = m0 * c = 2.997925e+08 kg*m/s
beta m_rel (gamma*m0) v_tijd (m/s) S_m = m0*c?
----------------------------------------------------------------------
0.00 1.000000 299792458.00 2.997925e+08 JA
0.30 1.048285 285983777.98 2.997925e+08 JA
0.50 1.154701 259627884.49 2.997925e+08 JA
0.80 1.666667 179875474.80 2.997925e+08 JA
0.90 2.294157 130676502.85 2.997925e+08 JA
0.99 7.088812 42290930.54 2.997925e+08 JA
De Zijn-waarde is constant -- onafhankelijk van de snelheid!
2.2 De arbeidsintegraal#
De factor \(c^2\) in \(E = mc^2\) volgt uit de arbeidsintegraal. De sleutel is de standaard definitie van kinetische energie als arbeid:
We kennen \(v\) en \(p\) beide als functie van \(\theta\). Met \(m_{rel} = m_0/\cos\theta\) (formule 10) volgt de impuls \(p = m_{rel} \cdot v = (m_0/\cos\theta) \cdot c\sin\theta = m_0 c \tan\theta\):
De oorsprong van \(c^2\): het product \(v \cdot dp\) bevat \(c \cdot c\): één \(c\) uit de snelheid \(v = c\sin\theta\), één \(c\) uit de impuls \(p = m_0 c \tan\theta\). De factor \(c^2\) is een rekenkundig gevolg.
De totale energie is:
In rust (\(\theta = 0\)) reduceert dit tot \(E_0 = m_0 c^2\).
Zijn voor energie#
Dit bevestigt formule (9) uit §2.1: ook het product \(E \cdot v_t\) is invariant.
# Numerieke verificatie: arbeid-integraal E_kin = integral(v dp) = m0 c^2 (1/cos(theta) - 1)
# Dit is de NIET-CIRCULAIRE afleiding van E = mc^2 (formule 11)
m0 = 1.0 # kg
print("Arbeid-integraal: E_kin = ∫ v dp = m₀c² (1/cos(θ) - 1)")
print(f"{'':>58} {'Numeriek':>14} {'Analytisch':>14} {'Verschil':>14}")
print("-" * 100)
for beta in [0.1, 0.3, 0.5, 0.8, 0.9, 0.95, 0.99]:
stv = ORT.from_beta(beta)
# Numerieke integraal via de nieuwe methode
E_numerical = stv.kinetic_energy_integral(m0, n_steps=1_000_000)
# Analytisch resultaat: (gamma - 1) m0 c^2
E_analytical = stv.kinetic_energy(m0)
rel_diff = abs(E_numerical - E_analytical) / E_analytical if E_analytical > 0 else 0
print(f" β = {beta:.2f} θ = {math.degrees(stv.theta):6.2f}° γ = {stv.gamma:8.4f} "
f"{E_numerical:14.6e} {E_analytical:14.6e} {rel_diff:14.2e}")
print()
print("De numerieke arbeid-integraal matcht het analytische resultaat.")
print("c² ontstaat als c · c: één c uit v = c·sin(θ), één c uit p = m₀c·tan(θ).")
Arbeid-integraal: E_kin = ∫ v dp = m₀c² (1/cos(θ) - 1)
Numeriek Analytisch Verschil
----------------------------------------------------------------------------------------------------
β = 0.10 θ = 5.74° γ = 1.0050 4.527763e+14 4.527763e+14 3.06e-14
β = 0.30 θ = 17.46° γ = 1.0483 4.339625e+15 4.339625e+15 2.56e-14
β = 0.50 θ = 30.00° γ = 1.1547 1.390379e+16 1.390379e+16 6.47e-14
β = 0.80 θ = 53.13° γ = 1.6667 5.991701e+16 5.991701e+16 3.59e-13
β = 0.90 θ = 64.16° γ = 2.2942 1.163131e+17 1.163131e+17 8.31e-13
β = 0.95 θ = 71.81° γ = 3.2026 1.979565e+17 1.979565e+17 1.83e-12
β = 0.99 θ = 81.89° γ = 7.0888 5.472351e+17 5.472351e+17 9.84e-12
De numerieke arbeid-integraal matcht het analytische resultaat.
c² ontstaat als c · c: één c uit v = c·sin(θ), één c uit p = m₀c·tan(θ).
# Verificatie: energie-impulsrelatie E^2 = (pc)^2 + (m0*c^2)^2
m0 = 1.0 # kg
print("Energie-impulsrelatie (formule 16):")
print(f" m0*c^2 = {m0 * C**2:.6e} J\n")
for beta in [0.0, 0.5, 0.8, 0.99]:
stv = ORT.from_beta(beta)
E = stv.total_energy(m0)
p = stv.momentum(m0)
lhs = E**2
rhs = (p * C)**2 + (m0 * C**2)**2
print(f" beta={beta:.2f}: E={E:.6e} J, p={p:.6e} kg*m/s")
print(f" E^2 = {lhs:.6e}")
print(f" (pc)^2+(m0c^2)^2 = {rhs:.6e}")
print(f" Klopt: {abs(lhs - rhs) / lhs < 1e-12}\n")
Energie-impulsrelatie (formule 16):
m0*c^2 = 8.987552e+16 J
beta=0.00: E=8.987552e+16 J, p=0.000000e+00 kg*m/s
E^2 = 8.077609e+33
(pc)^2+(m0c^2)^2 = 8.077609e+33
Klopt: True
beta=0.50: E=1.037793e+17 J, p=1.730853e+08 kg*m/s
E^2 = 1.077014e+34
(pc)^2+(m0c^2)^2 = 1.077014e+34
Klopt: True
beta=0.80: E=1.497925e+17 J, p=3.997233e+08 kg*m/s
E^2 = 2.243780e+34
(pc)^2+(m0c^2)^2 = 2.243780e+34
Klopt: True
beta=0.99: E=6.371107e+17 J, p=2.103921e+09 kg*m/s
E^2 = 4.059100e+35
(pc)^2+(m0c^2)^2 = 4.059100e+35
Klopt: True
2.3 De Zijn-vector#
De Zijn-vector \(\vec{S}\) heeft twee componenten:
Zijn is tijdimpuls: de tijdcomponent \(S_{tijd} = m_{rel} \cdot v_{tijd} = m_0 c\) is de ‘impuls door de tijd’. De structuur is symmetrisch:
Door de ruimte |
Door de tijd |
|
|---|---|---|
Snelheid |
\(v = c\sin\theta\) |
\(v_{tijd} = c\cos\theta\) |
“Impuls” |
\(p = m_{rel} \cdot v\) |
\(m_{rel} \cdot v_{tijd} = m_0 c\) |
De grootte van de Zijn-vector:
Met \(S_{ruimte} = p\) en \(S_{tijd} = m_0 c\) en \(|\vec{S}|^2 = S_{ruimte}^2 + S_{tijd}^2\) volgt via Pythagoras de energie-impulsrelatie:
# Zijn-vector diagram
zijn_vector_diagram(lang='nl')
pass
2.4 De vierimpuls#
De Zijn-vector bevat dezelfde fysica als de vierimpuls \(p^\mu\) uit de SRT, maar de presentatie verschilt wezenlijk:
Component |
Vierimpuls \(p^\mu\) (SRT) |
Zijn-vector \(\vec{S}\) (ORT) |
|---|---|---|
Ruimte |
\(p\) |
\(S_{ruimte} = p\) |
Tijd |
\(p^0 = E/c\) |
\(S_{tijd} = m_0 c\) |
Norm |
\(m_0 c\) (als \(\sqrt{p^\mu p_\mu}\)) |
\(\lvert\vec{S}\rvert = E/c\) |
In de vierimpuls verschijnt \(m_0\) als norm (\(\sqrt{p^\mu p_\mu} = m_0 c\)); in de Zijn-vector is \(m_0\) direct zichtbaar als component: \(S_{tijd} = m_0 c\).
Fysische interpretatie#
Waarom massa stijgt: bij toenemende snelheid daalt \(v_{tijd}\), dus moet \(m_{rel}\) stijgen om \(S_{tijd} = m_0 c\) in stand te houden.
Lichtbarrière: bij \(\theta \to 90°\) gaat \(m_{rel} \to \infty\). Oneindige energie is nodig om een massief object tot \(c\) te versnellen.
Fotonen: \(\theta = 90°\), \(m_0 = 0\), \(S_{tijd} = 0\). De Zijn-vector wijst volledig in de ruimterichting: \(|\vec{S}| = p = E/c\).
De afleidingsketen#
3 ORT en SRT vergeleken#
ORT en Einsteins SRT zijn wiskundig equivalent. De ORT vertrekt vanuit de snelheidscirkel (\(\theta\)) en Invariantie van Zijn; de SRT vanuit het relativiteitsprincipe en de constantheid van \(c\). Beide leiden tot identieke formules.
3.1 Formuleoverzicht#
De Lorentz-factor#
De Lorentz-factor uit de SRT is simpelweg de secans van \(\theta\). In de ORT is \(\gamma\) een afgeleide notatie, niet het fundamentele uitgangspunt.
Energie#
Impuls#
Complete formuletabel#
Nr |
Naam |
ORT (\(\theta\)) |
Zijn-formule |
Interpretatie |
|---|---|---|---|---|
(1) |
Snelheidsnorm |
\(v_r^2 + v_t^2 = c^2\) |
— |
Alles beweegt met \(c\) |
(2) |
Componenten |
\(v_r = c\sin\theta\), \(v_t = c\cos\theta\) |
— |
Richting bepaalt verdeling |
(3) |
Tijddilatatie |
\(d\tau/dt = \cos\theta\) |
— |
Projectie op tijdas |
(4) |
Gelijktijdigheid |
\(c\,\Delta t' = \tan\theta\,\Delta x\) |
— |
Kruisterm uit Lorentz |
(5) |
Lengtecontractie |
\(L = L_0\cos\theta\) |
— |
Projectie op ruimteas |
(6) |
Lorentz-transformatie |
\(x' = (x - \sin\theta\cdot ct)/\cos\theta\) |
— |
Ruimte-tijd menging |
(7) |
Snelheidsoptelling |
\((v_1+v_2)/(1+v_1v_2/c^2)\) |
— |
Via rapiditeiten |
(8) |
Massa-Zijn |
\(m_{rel} \cdot v_t = m_0 c\) |
\(S_m\) |
Invariant |
(9) |
Energie-Zijn |
\(E \cdot v_t = m_0 c^3\) |
\(S_E\) |
Afgeleid uit (8) |
(10) |
Rel. massa |
\(m_0/\cos\theta\) |
uit (8) |
Uit Invariantie van Zijn |
(11) |
Kin. energie |
\((1/\cos\theta - 1)\,m_0 c^2\) |
\(\int v\,dp\) |
Arbeid verricht |
(12) |
Totale energie |
\(m_0 c^2/\cos\theta\) |
uit (10) + integraal |
Massa × \(c^2\) |
(13) |
Impuls (Zijn-ruimte) |
\(m_0 c\tan\theta\) |
\(S_{ruimte}\) |
Ruimtelijke impuls |
(14) |
Zijn-tijd |
\(m_0 c\) |
\(S_{tijd}\) |
Invariante component |
(15) |
Zijn-grootte |
\(m_0 c/\cos\theta = E/c\) |
\(\lvert\vec{S}\rvert\) |
Norm van Zijn-vector |
(16) |
Energie-impuls |
\(E^2 = (pc)^2 + (m_0c^2)^2\) |
Pythagoras op \(\vec{S}\) |
Uit (13)+(14) |
(17) |
Lorentz-factor |
\(1/\cos\theta\) |
— |
Secans van \(\theta\) |
# Gamma-curve: hoe gamma stijgt met toenemende snelheid
gamma_curve(lang='nl')
pass
# Bereken gamma voor diverse snelheden
print(f"{'beta':>8} {'theta (graden)':>15} {'gamma':>10} {'v_tijd/c':>10}")
print("-" * 50)
for beta in [0.0, 0.1, 0.3, 0.5, 0.8, 0.9, 0.95, 0.99, 0.999]:
stv = ORT.from_beta(beta)
print(f"{beta:8.3f} {math.degrees(stv.theta):15.2f} {stv.gamma:10.4f} {stv.v_time/C:10.6f}")
beta theta (graden) gamma v_tijd/c
--------------------------------------------------
0.000 0.00 1.0000 1.000000
0.100 5.74 1.0050 0.994987
0.300 17.46 1.0483 0.953939
0.500 30.00 1.1547 0.866025
0.800 53.13 1.6667 0.600000
0.900 64.16 2.2942 0.435890
0.950 71.81 3.2026 0.312250
0.990 81.89 7.0888 0.141067
0.999 87.44 22.3663 0.044710
3.2 SRT-formules in ORT-notatie#
Formule |
SRT (\(\gamma, \beta\)) |
ORT (\(\theta\)) |
|---|---|---|
Tijddilatatie |
\(\tau = t/\gamma\) |
\(\tau = t\cos\theta\) |
Lengtecontractie |
\(L = L_0/\gamma\) |
\(L = L_0\cos\theta\) |
Rel. massa |
\(\gamma m_0\) |
\(m_0/\cos\theta\) |
Impuls |
\(\gamma m_0 v\) |
\(m_0 c\tan\theta\) |
Totale energie |
\(\gamma m_0 c^2\) |
\(m_0 c^2/\cos\theta\) |
Kin. energie |
\((\gamma-1)m_0 c^2\) |
\((1/\cos\theta - 1)m_0 c^2\) |
Snelheidsoptelling |
\(\frac{v_1+v_2}{1+v_1v_2/c^2}\) |
idem (via rapiditeit) |
Lorentz-transf. (x) |
\(\gamma(x-\beta\,ct)\) |
\((x - \sin\theta \cdot ct)/\cos\theta\) |
Lorentz-transf. (ct) |
\(\gamma(ct-\beta\,x)\) |
\((ct - \sin\theta \cdot x)/\cos\theta\) |
Simultaneiteit |
\(\Delta t' = \gamma v \Delta x/c^2\) |
\(c\,\Delta t' = \tan\theta\,\Delta x\) |
Energie-impuls |
\(E^2 = (pc)^2 + (m_0c^2)^2\) |
idem (Pythagoras op \(\vec{S}\)) |
Rapiditeit |
\(\text{artanh}(\beta)\) |
\(\text{artanh}(\sin\theta)\) |
Alle formules zijn identiek — het verschil is alleen notatie. \(\gamma = 1/\cos\theta\) en \(\beta = \sin\theta\) vertalen direct tussen beide.
# Relativistische effecten bij v = 0.8c -- Newton vs SRT vs ORT
beta = 0.8
v = beta * C
stv = ORT.from_beta(beta)
m0 = 1.0 # kg
L0 = 1.0 # m (rustlengte)
t_coord = 1.0 # s (coordinaattijd)
theta_deg = math.degrees(stv.theta)
print(f"=== Relativistische effecten bij beta = {beta} ===")
print(f" theta = {theta_deg:.2f} graden, gamma = {stv.gamma:.6f}")
print()
# --- Tijddilatatie ---
td_newton = NewtonModel.proper_time(t_coord, v)
td_srt = EinsteinModel.proper_time(t_coord, v)
td_ort = stv.proper_time(t_coord)
print(f"Tijddilatatie (tau voor t = {t_coord} s):")
print(f" {'Newton':>8}: {td_newton:.6f} s (geen dilatatie)")
print(f" {'SRT':>8}: {td_srt:.6f} s (= t/gamma)")
print(f" {'ORT':>8}: {td_ort:.6f} s (= t*cos(theta))")
print()
# --- Lengtecontractie ---
lc_newton = L0 # Newton: geen contractie
lc_srt = EinsteinModel.length(L0, v)
lc_ort = stv.length_contraction(L0)
print(f"Lengtecontractie (L0 = {L0} m):")
print(f" {'Newton':>8}: {lc_newton:.6f} m (geen contractie)")
print(f" {'SRT':>8}: {lc_srt:.6f} m (= L0/gamma)")
print(f" {'ORT':>8}: {lc_ort:.6f} m (= L0*cos(theta))")
print()
# --- Impuls ---
p_newton = NewtonModel.momentum(m0, v)
p_srt = EinsteinModel.momentum(m0, v)
p_ort = stv.momentum(m0)
print(f"Impuls (m0 = {m0} kg):")
print(f" {'Newton':>8}: {p_newton:.6e} kg*m/s (= m0*v)")
print(f" {'SRT':>8}: {p_srt:.6e} kg*m/s (= gamma*m0*v)")
print(f" {'ORT':>8}: {p_ort:.6e} kg*m/s (= m0*c*tan(theta))")
print()
# --- Kinetische energie ---
ek_newton = NewtonModel.kinetic_energy(m0, v)
ek_srt = EinsteinModel.kinetic_energy(m0, v)
ek_ort = stv.kinetic_energy(m0)
print(f"Kinetische energie:")
print(f" {'Newton':>8}: {ek_newton:.6e} J (= 0.5*m0*v^2)")
print(f" {'SRT':>8}: {ek_srt:.6e} J (= (gamma-1)*m0*c^2)")
print(f" {'ORT':>8}: {ek_ort:.6e} J (= (1/cos(theta)-1)*m0*c^2)")
print()
# --- Verificatie SRT = ORT ---
print("Verificatie SRT = ORT:")
print(f" Tijddilatatie: verschil = {abs(td_srt - td_ort):.2e}")
print(f" Lengtecontractie: verschil = {abs(lc_srt - lc_ort):.2e}")
print(f" Impuls: verschil = {abs(p_srt - p_ort):.2e}")
print(f" Kinetische energie: verschil = {abs(ek_srt - ek_ort):.2e}")
print(" SRT en ORT geven identieke resultaten!")
=== Relativistische effecten bij beta = 0.8 ===
theta = 53.13 graden, gamma = 1.666667
Tijddilatatie (tau voor t = 1.0 s):
Newton: 1.000000 s (geen dilatatie)
SRT: 0.600000 s (= t/gamma)
ORT: 0.600000 s (= t*cos(theta))
Lengtecontractie (L0 = 1.0 m):
Newton: 1.000000 m (geen contractie)
SRT: 0.600000 m (= L0/gamma)
ORT: 0.600000 m (= L0*cos(theta))
Impuls (m0 = 1.0 kg):
Newton: 2.398340e+08 kg*m/s (= m0*v)
SRT: 3.997233e+08 kg*m/s (= gamma*m0*v)
ORT: 3.997233e+08 kg*m/s (= m0*c*tan(theta))
Kinetische energie:
Newton: 2.876017e+16 J (= 0.5*m0*v^2)
SRT: 5.991701e+16 J (= (gamma-1)*m0*c^2)
ORT: 5.991701e+16 J (= (1/cos(theta)-1)*m0*c^2)
Verificatie SRT = ORT:
Tijddilatatie: verschil = 1.11e-16
Lengtecontractie: verschil = 1.11e-16
Impuls: verschil = 5.96e-08
Kinetische energie: verschil = 1.60e+01
SRT en ORT geven identieke resultaten!
# Modelvergelijking: tijddilatatie bij verschillende snelheden
betas_compare = [0.1, 0.3, 0.5, 0.8, 0.9, 0.99]
labels = [f'{b}c' for b in betas_compare]
newton_td = [1.0 for _ in betas_compare] # Newton: geen dilatatie
einstein_td = []
spacetime_td = []
for beta in betas_compare:
v = beta * C
stv = ORT.from_beta(beta)
einstein_td.append(EinsteinModel.proper_time(1.0, v))
spacetime_td.append(stv.proper_time(1.0))
values = {
'labels': labels,
'newton': newton_td,
'einstein': einstein_td,
'spacetime': spacetime_td
}
model_comparison_bar('Tijddilatatie (tau/t)', values, lang='nl')
pass
# Gedetailleerde vergelijkingstabel
m0 = 1.0 # kg
print(f"{'beta':>6} | {'Newton tau':>12} {'Einstein tau':>14} {'ORT tau':>14} | "
f"{'Newton p':>14} {'Einstein p':>14} {'ORT p':>14}")
print("-" * 100)
for beta in [0.1, 0.3, 0.5, 0.8, 0.9, 0.95, 0.99]:
v = beta * C
stv = ORT.from_beta(beta)
# Eigentijd voor 1 seconde coordinaattijd
tau_n = NewtonModel.proper_time(1.0, v)
tau_e = EinsteinModel.proper_time(1.0, v)
tau_st = stv.proper_time(1.0)
# Impuls
p_n = NewtonModel.momentum(m0, v)
p_e = EinsteinModel.momentum(m0, v)
p_st = stv.momentum(m0)
print(f"{beta:6.2f} | {tau_n:12.6f} {tau_e:14.6f} {tau_st:14.6f} | "
f"{p_n:14.6e} {p_e:14.6e} {p_st:14.6e}")
print("\nEinstein (SRT) en ORT geven identieke resultaten.")
print("Newton wijkt steeds verder af bij hogere snelheden.")
beta | Newton tau Einstein tau ORT tau | Newton p Einstein p ORT p
----------------------------------------------------------------------------------------------------
0.10 | 1.000000 0.994987 0.994987 | 2.997925e+07 3.013028e+07 3.013028e+07
0.30 | 1.000000 0.953939 0.953939 | 8.993774e+07 9.428037e+07 9.428037e+07
0.50 | 1.000000 0.866025 0.866025 | 1.498962e+08 1.730853e+08 1.730853e+08
0.80 | 1.000000 0.600000 0.600000 | 2.398340e+08 3.997233e+08 3.997233e+08
0.90 | 1.000000 0.435890 0.435890 | 2.698132e+08 6.189940e+08 6.189940e+08
0.95 | 1.000000 0.312250 0.312250 | 2.848028e+08 9.120990e+08 9.120990e+08
0.99 | 1.000000 0.141067 0.141067 | 2.967945e+08 2.103921e+09 2.103921e+09
Einstein (SRT) en ORT geven identieke resultaten.
Newton wijkt steeds verder af bij hogere snelheden.
3.3 Drie afleidingswegen#
Hoe leiden Newton, Einstein, en de ORT elk tot dezelfde relativistische formules?
Stap |
Newton |
Einstein (SRT) |
ORT |
|---|---|---|---|
Startpunt |
Absolute ruimte en tijd |
Relativiteitsprincipe + \(c\) constant |
Alles beweegt met \(c\) + Invariantie van Zijn |
Ruimte en tijd |
Onafhankelijk, universeel |
Verweven: ruimtetijd |
Verweven: snelheidsbol |
Massa |
Constant |
Invariante rustmassa; \(\gamma m_0\) in impuls |
\(m_0/\cos\theta\) uit Zijn-principe |
Impuls |
\(p = mv\) |
\(p = \gamma m_0 v\) (impulsbehoud + Lorentz) |
\(p = m_0 c\tan\theta\) (uit \(m_{rel} \cdot v\)) |
Energie |
\(E_k = \tfrac{1}{2}mv^2\) |
\(E = \gamma m_0 c^2\) (arbeid-integraal) |
\(E = m_0 c^2/\cos\theta\) (arbeid-integraal) |
Lorentz-transf. |
Galilei: \(x' = x - vt\) |
Uit postulaten (lichtsnelheidsinvariantie) |
Uit §1.2 (ruimtelijke verschuiving + \(\cos\theta\) schaling) |
De arbeid-integraal \(E_k = \int v \, dp\) is in SRT en ORT identiek — het verschil zit alleen in hoe \(m_{rel}\) wordt gemotiveerd.
Invariantie: impulsbehoud vs. Zijn#
Beide theorieën gebruiken een invariantieprincipe om relativistische massa af te leiden, maar de ORT-route is directer:
SRT |
ORT |
|
|---|---|---|
Principe |
Impulsbehoud onder Lorentz |
Invariantie van Zijn: \(m \cdot v_{tijd} = m_0 c\) |
Geldt voor |
Systemen bij botsingen (voor = na) |
Elk object afzonderlijk, altijd |
Vereist eerst |
Lorentz-transformatie |
Alleen de snelheidscirkel |
Afleiding |
Postulaten → Lorentz → impulsbehoud → \(\gamma m_0\) |
\(m \cdot c\cos\theta = m_0 c\) → \(m_0/\cos\theta\) |
Stappen |
4 |
1 |
Impulsbehoud en Invariantie van Zijn zijn verwante principes — beide eisen dat een grootheid onveranderd blijft. Het verschil: impulsbehoud is een eigenschap van interacties en heeft de Lorentz-transformatie als tussenstap nodig; Invariantie van Zijn is een eigenschap van elk object en geeft relativistische massa direct uit de cirkelgeometrie.
3.4 Toepassingen#
Drie scenario’s uit de speciale relativiteit, berekend met zowel SRT als ORT.
Tweelingparadox#
Alice blijft op aarde, Bob reist met \(v = 0.8c\) naar een ster op 10 lichtjaar en terug.
Muonverval#
Muonen ontstaan op ~10 km hoogte en bewegen met \(v \approx 0.998c\). Zonder relativiteit vervallen ze na ~660 m.
GPS-correctie (SRT-deel)#
GPS-satellieten bewegen met ~3.87 km/s. Speciale relativiteit veroorzaakt een meetbare tijdvertraging.
# 9.1 Tweelingparadox
print("=== Tweelingparadox ===")
beta_bob = 0.8
distance_ly = 10 # lichtjaar enkele reis
stv_bob = ORT.from_beta(beta_bob)
theta_bob = math.degrees(stv_bob.theta)
# Reistijd voor Alice (op aarde)
t_alice_one_way = distance_ly / beta_bob
t_alice_total = 2 * t_alice_one_way
# ORT: eigentijd Bob = t * cos(theta)
t_bob_ort = t_alice_total * math.cos(stv_bob.theta)
# SRT: eigentijd Bob = t / gamma
t_bob_srt = t_alice_total / stv_bob.gamma
print(f" Bob reist met {beta_bob}c naar een ster op {distance_ly} lichtjaar")
print(f" theta = {theta_bob:.2f} graden")
print()
print(f" Alice (aarde): {t_alice_total:.2f} jaar")
print(f" Bob (ORT): tau = t * cos(theta) = {t_alice_total:.2f} * cos({theta_bob:.2f}) = {t_bob_ort:.2f} jaar")
print(f" Bob (SRT): tau = t / gamma = {t_alice_total:.2f} / {stv_bob.gamma:.4f} = {t_bob_srt:.2f} jaar")
print(f" Verschil ORT vs SRT: {abs(t_bob_ort - t_bob_srt):.2e} jaar (identiek)")
print()
print(f" Bob is {t_alice_total - t_bob_ort:.2f} jaar jonger bij terugkomst")
=== Tweelingparadox ===
Bob reist met 0.8c naar een ster op 10 lichtjaar
theta = 53.13 graden
Alice (aarde): 25.00 jaar
Bob (ORT): tau = t * cos(theta) = 25.00 * cos(53.13) = 15.00 jaar
Bob (SRT): tau = t / gamma = 25.00 / 1.6667 = 15.00 jaar
Verschil ORT vs SRT: 0.00e+00 jaar (identiek)
Bob is 10.00 jaar jonger bij terugkomst
# 9.2 Muon-verval
print("=== Muon-verval ===")
beta_muon = 0.998
tau_muon = 2.2e-6 # rustlevensduur in seconden
h_atmosphere = 10000 # hoogte in meter
stv_muon = ORT.from_beta(beta_muon)
theta_muon = math.degrees(stv_muon.theta)
# Zonder relativiteit
d_classical = beta_muon * C * tau_muon
# ORT: levensduur = tau / cos(theta)
t_ort = tau_muon / math.cos(stv_muon.theta)
d_ort = beta_muon * C * t_ort
# SRT: levensduur = tau * gamma
t_srt = tau_muon * stv_muon.gamma
d_srt = beta_muon * C * t_srt
print(f" Muon snelheid: {beta_muon}c, theta = {theta_muon:.2f} graden")
print(f" Rustlevensduur: {tau_muon*1e6:.1f} microseconde")
print()
print(f" Zonder relativiteit:")
print(f" Afstand = {d_classical:.0f} m ({d_classical/1000:.2f} km) -- bereikt de grond NIET")
print()
print(f" ORT: levensduur = tau / cos(theta) = {t_ort*1e6:.1f} us")
ort_bereikt = "JA" if d_ort > h_atmosphere else "NEE"
print(f" Afstand = {d_ort/1000:.1f} km -- bereikt de grond: {ort_bereikt}")
print()
print(f" SRT: levensduur = tau * gamma = {t_srt*1e6:.1f} us")
srt_bereikt = "JA" if d_srt > h_atmosphere else "NEE"
print(f" Afstand = {d_srt/1000:.1f} km -- bereikt de grond: {srt_bereikt}")
print()
print(f" Verschil ORT vs SRT: {abs(d_ort - d_srt):.2e} m (identiek)")
=== Muon-verval ===
Muon snelheid: 0.998c, theta = 86.38 graden
Rustlevensduur: 2.2 microseconde
Zonder relativiteit:
Afstand = 658 m (0.66 km) -- bereikt de grond NIET
ORT: levensduur = tau / cos(theta) = 34.8 us
Afstand = 10.4 km -- bereikt de grond: JA
SRT: levensduur = tau * gamma = 34.8 us
Afstand = 10.4 km -- bereikt de grond: JA
Verschil ORT vs SRT: 0.00e+00 m (identiek)
# 9.3 GPS SRT-correctie
print("=== GPS Speciale Relativiteit Correctie ===")
v_gps = 3870 # m/s (orbitale snelheid GPS-satelliet)
stv_gps = ORT.from_v(v_gps)
theta_gps = stv_gps.theta
seconds_per_day = 86400
# ORT: eigentijd = t * cos(theta)
tau_ort = seconds_per_day * math.cos(theta_gps)
delta_ort = seconds_per_day - tau_ort
# SRT: eigentijd = t / gamma
tau_srt = seconds_per_day / stv_gps.gamma
delta_srt = seconds_per_day - tau_srt
print(f" Orbitale snelheid: {v_gps} m/s")
print(f" theta = {math.degrees(theta_gps):.6f} graden")
print()
print(f" ORT: tau = t * cos(theta)")
print(f" Tijdvertraging per dag: {delta_ort*1e9:.2f} nanoseconde")
print()
print(f" SRT: tau = t / gamma")
print(f" Tijdvertraging per dag: {delta_srt*1e9:.2f} nanoseconde")
print()
print(f" Verschil ORT vs SRT: {abs(delta_ort - delta_srt)*1e9:.4f} ns (identiek)")
print()
print(f" De satellietklok loopt LANGZAMER door beweging (SRT).")
print(f" (NB: ART geeft een VERSNELLING door minder zwaartekracht, die groter is.)")
=== GPS Speciale Relativiteit Correctie ===
Orbitale snelheid: 3870 m/s
theta = 0.000740 graden
ORT: tau = t * cos(theta)
Tijdvertraging per dag: 7198.86 nanoseconde
SRT: tau = t / gamma
Tijdvertraging per dag: 7198.86 nanoseconde
Verschil ORT vs SRT: 0.0000 ns (identiek)
De satellietklok loopt LANGZAMER door beweging (SRT).
(NB: ART geeft een VERSNELLING door minder zwaartekracht, die groter is.)