Breaking the Cosmic Speed Limit

by Alex Younger

Introduction

~300,000 kilometers per second. The constant velocity of light.

This is the sacred number, ogled at us from every angle of modern science, as the maximum speed of causality itself.

It is this one assumption — the constant velocity of light — that makes the foundation of Einstein’s relativity theory. It has been repeated for so long that most have forgotten its origins and the intense debate that came with it.

I am here to convince you there is tremendous reason to doubt the theory of relativity.

The real-world applications of relativity are vastly overstated, the empirical testing appears wildly overconfident, and there are dozens of cases where relativity gets credit for something that can, and should, be explained by classical mechanics. Given that the overwhelming majority of modern physics can be modeled with classical Newtonian mechanics, rewriting the entire universe under a relativistic paradigm is unnecessary and problematic.

The theory is valid as algebra. The question is whether the world can run it. Valid logic can still produce unworkable outcomes. Relativity is unable to model complex objects with consistent properties and produces race conditions — situations in which competing processes leave the final state undefined. When such problems are pointed out, the theory hardens itself into something approaching unfalsifiability. That will be the main focus of this article.

This should not be read as a condemnation of Einstein. He is very difficult to dislike. I deeply admire his creativity and his drive toward clarity, and I don’t think it is unfair to rank him among the most intelligent and creative people who ever lived. I just happen to think his theory doesn’t hold up to scrutiny. It took me years to figure out why.

My goal is to explain relativity — its history, how to interpret it, the shortcomings of its math, and where its claims become overconfident — in the simplest, clearest terms I can.

This article should require little more than a high-school understanding of math. In fact, I won’t even use math. Wherever you would normally need an equation, I will use Python that reads like English.

The paper comes in two parts. Part 1 is the logic: what relativity claims, and why those claims break when you treat the universe as a running process. Part 2 is the experiments: what the evidence actually shows, and what it merely assumes.

And, in the spirit of Einstein, we’ll use some train metaphors.

Abstract

I will present the following conclusions as simply as I can:

1. The constant velocity of light is still an assumption.
2. The theory of relativity is a valid model, but it still produces unworkable race conditions and inconsistencies.

Part 1: The Logic

The Constant Velocity of Light

The core assumption of relativity is not that light has a speed limit. There is nothing exotic about speed limits in nature. Sound has a speed limit, which can be explained with the same phenomenon found in a slinky. Light may even have a natural speed limit, and there is some evidence for this — though I don’t think we can be as confident as we are about this claim. But Einstein’s claim is far stronger than this.

The core claim of relativity is that light travels at one speed from every possible reference frame.

A reference frame is a point of view — the perspective of some object or observer. This might not be intuitive, but a few thought experiments will make it easier to understand.

If you’re in a car traveling at 60 mph and someone in the left lane is traveling at 61 mph, that car appears to creep ahead of you at only 1 mph. That is intuitive.

Einstein says this is not how it works with light.

Light always travels at the same measured speed, regardless of your own speed. To return to our car analogy: imagine the car in the left lane is composed of light and travels at a constant 100 mph. Even if you were already doing 60 mph, your radar would still measure that car passing you at the full 100 mph — not the 40 mph you would normally expect.

This is Einstein’s core assumption. If you were in a spaceship traveling at 99% of the speed of light, you would still measure light traveling at ~300,000 km/s. How can that be? Wouldn’t the two speeds add together, making the light travel at nearly twice its normal speed?

Under relativity, no — and although there is a coherent logic behind that answer, it leads to absurd consequences.

The Speed of Waves

There is only one way to measure the speed of anything: you need time and space. Speed is how much space is traveled over a period of time. For waves, the concept is the same.

Waves can be described as “formations of quantities,” because we don’t always know the fundamental composition of a wave. We don’t need to know what light is made of in order to measure its speed. We can see that something is making a disturbance in the world, and we can measure the patterns of those disturbances. Whether light is a particle or a wave makes little difference for our purposes here.

The speed of a wave is its frequency multiplied by its wavelength. Frequency tells us how many waves pass a point over a period of time. Wavelength tells us the distance from one wave peak to the next. Frequency is measured in hertz (Hz), meaning cycles per second.

For example:

frequency = 2
wavelength = 2
wave_velocity = frequency * wavelength
print(f"Wave speed: {wave_velocity} m/s")

Wave speed: 4 m/s

An Einsteinian Beach

This thought experiment expands on an idea I first read in a paper by Pentcho Valev, who is the person who first introduced me to the logical problems of relativity, and is much of the inspiration for this article.

Imagine you’re standing on the shore. Every second, one wave crashes on shore, so the frequency is 1 Hz. The distance from one wave peak to the next is 2 meters, so the wavelength is 2 meters. From those two measurements, we can calculate the speed of the waves.

frequency = 1
wavelength = 2
wave_velocity = frequency * wavelength
print(f"Wave speed: {wave_velocity} m/s")

Wave speed: 2 m/s

The waves are moving at 2 m/s.

Now let’s imagine we begin to walk forward into the ocean. You notice the waves approaching you at what looks like a faster pace.

Let’s say you walk forward at 1 meter per second. Under normal Newtonian mechanics the speeds combine. Relative to you, the waves now approach at 3 m/s.

wave_speed = 2
walking_speed = 1
relative_speed = wave_speed + walking_speed
print(f"Relative wave speed: {relative_speed} m/s")

Relative wave speed: 3 m/s

Again, this is intuitive. This is a very simple example of the Doppler Effect.

You would even feel the waves strike with greater force as you walked into them. More importantly, everyone can use simple arithmetic to agree on the waves’ actual speed.

Our measurements might differ depending on how we measure — standing still on the beach, or walking forward into the waves — but the waves themselves are still moving at a single, absolute, objective speed that everyone can agree on. This is not the way it works under the relativistic paradigm. Relativity does not allow for a global state of reference — more on this later.

Now let’s imagine an Einsteinian beach. Things work differently here.

On this beach, the waves behave the way Einstein claims light behaves: they maintain one single speed from every possible reference frame.

For the sake of the thought experiment, we are going to pretend that you can experience relativistic effects at normal everyday speeds, just so the logic is easier to comprehend. You should know that these effects are not supposed to be noticeable until you reach high fractions of the speed of light.

You stand on the shore and watch the waves approach at 2 m/s, just as they did on the last beach. Everything appears normal. Then you start walking forward.

The very moment you begin to walk, you watch the entire landscape of the ocean change in front of you. The ocean contracts.

Why?

The only way the logic of the speed equation remains intact is if another variable in our equation changes: distance. Space itself contracts.

Time also changes, but let’s table that variable for now and focus on the consequences of relative space.

To calculate this change, we will use a Lorentz transformation and calculate a Doppler factor. This math is fundamental to relativity; it is a function used to translate measurements of time and space between reference frames.

The details of this function are not important, and this math is not intuitive. We only need to understand the result. If the code below looks dense, skip to the final line.

import math

# Speed values in m/s
frequency = 1
wavelength = 2
wave_speed = 2
walking_speed = 1

# Your speed expressed as a fraction of the constant wave_speed (c).
fractional_wave_speed = walking_speed / wave_speed
print(f"Fractional wave speed: {fractional_wave_speed}")

# Relative speeds of the wave and the observer
observer_frame_speed = 1 + fractional_wave_speed
source_frame_speed = 1 - fractional_wave_speed

doppler_factor = math.sqrt(observer_frame_speed / source_frame_speed)
print(f"Doppler factor: {doppler_factor}")

relativistic_frequency = frequency * doppler_factor
print(f"Relativistic frequency: {relativistic_frequency} Hz")

relativistic_wavelength = wavelength / doppler_factor
print(f"Relativistic wavelength: {relativistic_wavelength} m")

wave_velocity = relativistic_frequency * relativistic_wavelength
print(f"Relativistic wave velocity: {wave_velocity} m/s")

Fractional wave speed: 0.5
Doppler factor: 1.7320508075688772
Relativistic frequency: 1.7320508075688772 Hz
Relativistic wavelength: 1.1547005383792517 m
Relativistic wave velocity: 2.0 m/s

The important part is the result. To keep the measured wave speed at 2 m/s, both measurements change. The distance between wave peaks contracts from 2 meters to 1.155 meters, while the frequency rises from 1 wave per second to 1.732 waves per second.

This is not a trick of perception.

In this model, the ocean and time are now physically different. The distance between its waves is shorter — along with every physical consequence of that change. This is a very important point. You may hear people who speak of relativity say that objects appear to expand or contract at relativistic speeds, but this is not the right word. They physically are different. Relativity wants to treat shape as an arbitrary feature of existence, but shape itself has properties which have second-order consequences. This is where we will run into problems.

No Global State

Let’s stay on our Einsteinian beach a while longer.

Imagine there are people lying on the beach. What do they see?

For them, nothing about the ocean has changed. The wave peaks are still 2 meters apart. Instead, they see something strange happen to you. From their perspective, you, not the waves, contract. You become thinner in the direction you are moving.

Again, this is not merely a perception. In their frame, you have physically contracted. Your 30-inch waist is now 17 inches.

This is all valid on paper, but by walking into the ocean, we have created two descriptions of the same world with different physical properties. Those physical properties interact with the world in fundamentally different ways. This is not something the relativists seem to have fully thought through. Shape cannot become arbitrary, as we will examine shortly.

This makes relativity an inherently local model, and gives us no global state: one shared description of the entire universe at a particular moment. The global state can only be coincidental.

Programmers will recognize the consequences of this problem immediately. What I am describing is essentially multiprocessing.

Classical mechanics has a global state. I can say that two events happened at the same time, or that an object is objectively 2 meters long. Different observers may begin with different measurements, but they can translate those measurements into one shared answer. For every object, there is only ever one universal set of features that we can agree on.

Relativity does not allow the same universal statements. Two events that happen at the same time for one observer may happen at different times for another. An object that is 2 meters long in one frame may have a different length in another. Each frame supplies its own clock and yardstick. There is no global clock or yardstick shared by everyone. Every object receives multiple sets of features, a new set of features for each reference frame, that are all equally valid.

This idea is called the relativity of simultaneity, that there is no global clock, so you can never say that any event happens at the same time as another event.

Einstein’s logic is coherent. But it leads to serious problems that programmers hit every working day.

To sum up, here are the things to keep in mind. Relativity gives up the idea of a global state; it is a local model of the universe, where every object may have a distinct set of physical features based on its relative motion. There is no shared clock or universal concept of shape. Unlike classical mechanics, space and time are arbitrary.

Math Is Bad Code

Math, philosophy, and code are all just different ways of writing logic. But math increasingly seems too simple to model the full complexity of the world.

I used to say, tongue-in-cheek, “math is just bad code.” It was a jab at mathematicians and their esoteric symbolism, which seems unnecessary in a world where computers can compile languages that read almost like English, or nowadays comprehend English itself. Academic writing also rewards people for hiding simple reasoning behind obnoxious, esoteric symbols. Somewhere along the way, the symbols stopped serving the reasoning and started guarding it. Conveniently their conclusions are always clear while their reasoning remains blurry. It seems like a pragmatic weaponization of the bullshit asymmetry principle: nonsense can be produced in seconds but may take years to untangle.

Programmers adopted the opposite culture. They constantly debate how to make their thinking clearer, cleaner, and simpler. They may disagree about the best method, but the goal is always present: clarity.

My opinion of math has grown far less forgiving. I’ve come to believe that formal math may actually cause much of the confusion in physics. I think we might have outgrown much of it; it does not seem sufficient for modern complex problems.

Procedural Thinking

The physicists and the mathematicians tend to model the world using timeless relationships and equalities, often ignoring important concepts like processes, time, and the one-directional nature of causality. Code struggles to represent bidirectional relationships — but so does the real world. In the real world, complex natural processes are irreversible. The real world appears to be procedural. One event causes the next, step by step. Math does not represent the world this way unless we deliberately add those steps.

Here is the simplest version of the problem. Consider the equation for the surface area of a sphere: A = 4πr².

A mathematician may present this expression and say, “Problem solved.” But the universe still has to run that. The number pi never ends or repeats. Written exactly, the equation therefore contains an infinite amount of information that a program could never finish calculating.

Are we supposed to assume that the universe processes infinite information in finite time? Perhaps a question for another time.

The problem I am circling is something programmers refer to as runtime — what happens when valid logic is run as a process. When logic is carried out as a process, we introduce what we call state: the exact condition of everything at one step in the process. State is not an inconsequential variable, it is something that must be kept track of or risk running into errors.

Take a familiar high school example: y = mx + b, the equation for a line. When finding an inverse, you may be told to swap x and y. If y = 2x + 3, the swap gives us x = 2y + 3. Swapping these symbols seems harmless enough, but there is a hidden step you’re doing without realizing it.

If you wanted to describe every step in this swap process, x and y can’t be timeless symbols that you overwrite — they have state. Notice how this fails to swap the variables:

x = 4
y = 11
x = y
y = x

print(f"x: {x}, y: {y}")

x: 11, y: 11

This fails to swap the variables because each line changes the state inherited by the next line. At step 3, where we say x = y, we lose the value 4. It no longer exists anywhere in the process. We cannot later assign the old value of x to y, because we have already overwritten it.

Swapping those values requires us to preserve the old state before changing it. When doing this on paper, your brain was acting as the temporary storage vehicle, preserving 4 as you transferred it to y — but you took this step for granted.

x = 4
y = 11

# Preserve the original value of x
old_x = x

# Put y's value into x
x = y

# Put x's original value into y
y = old_x

print(f"x: {x}, y: {y}")

x: 11, y: 4

Most of the math you learn in school, along with its reasoning, will not run on computers. Sure, some of this is due to the inherent discreteness of computers. But sometimes expressions were actually incomplete, and sometimes an assumption was never tested as a process.

A simple example you may have heard of is the factorial of zero. A factorial multiplies a whole number by every positive whole number below it. For example, 3! = 3 × 2 × 1 = 6. But calculators also tell us:

0! = 1

This result is hard-coded into calculators. Factorial 0 cannot equal 1 through a sequence of ordinary multiplication; the mathematician must define it as 1. He cannot prove this, but ask for a proof, and he will still claim he can provide one.

All of this is to say: math is not inherently procedural, and it has no built-in model of time. You have to bring your own time. A programmer must track each change of state and every link in the chain of cause and effect.

Timeless Mathematical Objects

Using timeless math to describe complex processes confuses people.

If you take the equations of Einstein’s relativity literally, you may find yourself a proponent of the Block Universe Theory. It describes the universe as a timeless, 4-dimensional, unchanging object. The three familiar dimensions of space make up the first three dimensions; time is the fourth. Past, present, and future all exist as parts of one complete object.

This idea came about in 1908, when Hermann Minkowski — Einstein’s former mathematics professor from Zurich, who had once dismissed him as a lazy dog who never bothered with mathematics — recast special relativity as a four-dimensional geometry and gave the world the word spacetime. Opening his lecture, he declared:

“Henceforth space by itself, and time by itself, are doomed to fade away into mere shadows, and only a kind of union of the two will preserve an independent reality.” — Hermann Minkowski, Space and Time (1908)

That sentence gave rise to the Block Universe. Einstein initially balked, calling the formulation “superfluous learnedness” — and then went on to build general relativity on that very same geometry. Einstein eventually came to feel the mathematics had swallowed the theory whole.

“Since the mathematicians have invaded the theory of relativity, I do not understand it myself anymore.” - Albert Einstein

When the founder of a theory can no longer recognize it, that is not a triumph of mathematics. But Einstein changed his mind a few times in his life, and this may have been one of those times.

Although we don’t know for certain, Einstein may have eventually come to be persuaded by this literal interpretation. We have some loose quotes which suggest he was potentially sympathetic to the idea.

“The distinction between past, present and future has only the significance of a persistent illusion.” — Albert Einstein, letter to the son and sister of Besso (1955)

The entire universe, modeled as one mathematical object that does not execute. It simply is.

But describing a completed object is not the same as explaining how that object executes. How do we get changing state without execution? You can’t. You’re just making a blanket claim. You’re saying something like, “I am storing all possible information — including information that is undecidable, logically impossible to obtain until it is run as a process — in a bunch of Greek symbols and then heading out for lunch.”

Entire books have tried to untangle this confusion. Many are good, but a little time spent programming makes the underlying problem much easier to see.

Almost nothing about relativity is procedural. The equations are all flat relations and expressions. The Lorentz transformation translates measurements from one geometry to another; it does not describe a sequence of instructions being carried out.

Race Conditions of Relativity

We can now reach the crux of the problem. Math does not naturally express runtime, state, or a sequence of causes and effects, which makes it easy to overlook the procedural problems hidden inside relativity.

There is one more thing math does not model well: parallel processes, or multiprocessing — multiple sequences of events unfolding independently.

Einstein essentially modeled a world in which all processes run in parallel. Every object in motion gets its own reference frame. In programming terms, each frame is like a thread: an independent sequence of instructions running on its own timeline.

This point is worth defending, because the relativists will almost certainly object to this, but the burden of proof remains on the relativist to explain how you can run a process that abolishes global state, shape and time, without necessarily introducing parallel processing. They have created an asynchronous universe.

I actually don’t think the relativists understand the implications of the claims they’re making, and this often leads them to use a kind of motte and bailey tactic of occasionally being forced to reference a global state, despite saying no such global state exists. But the programmers do understand what they’re doing. More on this later.

What Is a Race Condition?

A race condition is a logical error that occurs when a system has independent processes competing for the same shared resources or state — one thread changes or removes a value that another thread depends on.

Race conditions are the most common examples of valid code that leads to errors at runtime.

We have two threads that both use the same shared variable x, set to 42. But what if one thread deletes x?

import threading
import time

x = 42

def thread_a():
    time.sleep(0.1)
    print(x)

def thread_b():
    global x
    time.sleep(0.05)
    del x

a = threading.Thread(target=thread_a)
b = threading.Thread(target=thread_b)

a.start()
b.start()

a.join()
b.join()

Program completed without output.

Exception in thread Thread-1 (thread_a):
Traceback (most recent call last):
  File "/usr/lib/python3.14/threading.py", line 1082, in _bootstrap_inner
    self._context.run(self.run)
    ~~~~~~~~~~~~~~~~~^^^^^^^^^^
  File "/usr/lib/python3.14/threading.py", line 1024, in run
    self._target(*self._args, **self._kwargs)
    ~~~~~~~~~~~~^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
  File "<stdin>", line 8, in thread_a
NameError: name 'x' is not defined

This results in a fatal error: thread A can never print the value of x, because x was deleted by the separate thread B.

Every reference frame should be modeled as a separate process. The properties of matter can be viewed like our variable x — and in each frame, we have physically different properties, which interact with the rest of the world in different ways.

Shared State, Parallel Processes

Let’s try to model Einstein’s relativity as closely as we can using an analogy of computers. Under relativity, time is essentially the speed at which information can propagate. That is not a bad framing of time, and we can model the concept with two computers, where processing speed represents the passage of time.

Imagine two computers running similar programs. One is a powerful new machine; the other is a very old one. Each machine has a speed at which information propagates through its CPU. The old machine will lag the new machine in virtually every aspect — it processes all instructions much more slowly.

The new computer might process one hundred events while the old computer processes only ten. They are asynchronous: they do not advance at the same rate or finish each step at the same moment.

But it’s not just time itself that changes between machines — the properties of shared variables change too.

Here is a simple program that runs on both machines, where the state of the shared variable x differs slightly on each. On each machine there is a bomb trigger that could destroy the value of x, and this bomb is triggered by x breaching a certain threshold value.

This might be some heavier code for the uninitiated, but perhaps I can make that introduction. Here’s a crash course in Python:

In Python, we use tabs to create “blocks” of code, usually a “function”, a thing that takes some input and produces some output. A “class” is basically just a bigger block that we can put smaller blocks of code in, like functions and variables, and use it like a blueprint. And in Python, the “def” keyword means to “define a function”. Then we can say things like SharedProgram.run() which runs the “run” function under SharedProgram

import threading
import time

# Our shared object of x
x = 42

class SharedProgram:
	def __init__(self):
		self.time_offset = 1 # default time at rest
		self.shape_offset = 2 # default shape at rest

	def run(self, x):
		time.sleep(self.time_offset)
		x = x * self.shape_offset

		print(f"Measuring x: {x}")

		if x > 85:
			print("X VALUE OVER LIMIT. BOMB TRIGGERED. DESTROYING X...")
			del x

		return self.next(x) # Warning: x is possibly unbound.

	def next(self, x):
		print(f"We have reached the next step with x at {x}")

class FastMachine(SharedProgram):
	def __init__(self):
		self.time_offset = 0.1
		self.shape_offset = 1.9

class SlowMachine(SharedProgram):
	def __init__(self):
		self.time_offset = 1
		self.shape_offset = 2.1

fast_machine = FastMachine()
slow_machine = SlowMachine()

a = threading.Thread(target=fast_machine.run, args=[x])
b = threading.Thread(target=slow_machine.run, args=[x])

a.start()
b.start()

a.join()
b.join()

Measuring x: 79.8
We have reached the next step with x at 79.8
Measuring x: 88.2
X VALUE OVER LIMIT. BOMB TRIGGERED. DESTROYING X...

Exception in thread Thread-2 (run):
Traceback (most recent call last):
  File "/usr/lib/python3.14/threading.py", line 1082, in _bootstrap_inner
    self._context.run(self.run)
    ~~~~~~~~~~~~~~~~~^^^^^^^^^^
  File "/usr/lib/python3.14/threading.py", line 1024, in run
    self._target(*self._args, **self._kwargs)
    ~~~~~~~~~~~~^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
  File "<stdin>", line 22, in run
UnboundLocalError: cannot access local variable 'x' where it is not associated with a value

We have two machines, FastMachine and SlowMachine, and each receives the same SharedProgram. It is the relativistic offsets of each machine that change the value of x. The threshold limit is the same for each machine: if x ever gets above 85, the bomb explodes. That program produces a race condition: x is supposed to exist in both frames for the flow of coherent time to continue, but in one thread, x has been destroyed — and in the other, it has not. The result is a fatal error.

We can resolve this fatal error in one of two ways:

1. x becomes a truly local variable, meaning there is absolutely no shared concept of x. The consequence is the spawning of divergent timelines that cannot be merged. Two universes, essentially. In one universe, x exists because the bomb was not triggered; in the other, x was destroyed. There is no longer a shared timeline of events.
2. Time and shape are universal properties, and cannot be changed by either thread, leading to a coherent timeline of events.

This little program doesn’t prove anything, it is simply here to show you the concept of race conditions. But I say this to prime the reader for what the relativist will have to face in a moment, which is to face the full consequences of local state, and admit that relativity gives rise to parallel threads of reality, a quasi “Many Worlds Hypothesis”, or to admit that classical mechanics got it right the first time: there is global state.

The Solar Express

Now, as promised, a train metaphor.

Imagine a train that must occasionally pass over an old bridge. The bridge is one-tenth the length of the train, and it can support only one-tenth of the train’s total weight. Under normal conditions, this is just enough: because the train’s weight is evenly distributed from front to rear, no more than one-tenth of its weight rests on the bridge at any one time.

The percentage itself is not what breaks the bridge. The load does. We use the fraction of the train only because its weight is evenly distributed, so twice as much train means twice as much load.

Now along comes a breakthrough: a train that can travel at nearly the speed of light. Call it The Solar Express.

The Solar Express can achieve such immense speeds that its Lorentz factor is 10. At full speed, to anyone standing on the ground, the train contracts to one-tenth of its length: one meter of train becomes ten centimeters.

An engineer, standing on the riverbank, points out a serious problem. He shares the bridge’s reference frame, so to him it is the train that contracts — and it contracts to exactly the length of the bridge. There is one instant of the crossing where the entire train is on the bridge at the same time, its full weight bearing down: ten times the load limit. The bridge would fail.

The conductor, riding on the train, says there is nothing to worry about. In his reference frame, the train keeps its full length while the bridge contracts to one-tenth of its own length — just one-hundredth the length of the train. At most, one-hundredth of the train can be over the bridge at once. That is only one-tenth of the bridge’s load limit. The bridge would hold.

The conductor, being well-read in physics, expounds on his last point: don’t worry, this just sounds like a Ladder Paradox. Remember, under relativity, we can never say that the front and the rear of the train are both on the bridge at the same time. This problem, he says, is resolved through the relativity of simultaneity.

But the engineer persists. “This isn’t a Ladder Paradox at all, sir!” The problem is not whether the entire train can be on the bridge at one moment. The problem is whether the load on the bridge ever exceeds its limit.

The conductor thinks for a moment, but is unperturbed. Being a persuasive man, he convinces everyone to let him prove it.

The train hurtles down the tracks at nearly the speed of light and reaches the bridge. What happens next? Who is right?

According to Einstein and the theory of relativity, both are right. The bridge is both collapsed and stable.

This is not the classic Ladder Paradox. That paradox asks whether the entire train fits on the bridge at one moment, and changing the order of events — which end arrives or leaves first — can dissolve the apparent contradiction.

Our question is different. The bridge collapses if its load exceeds one-tenth of the train’s weight at any point. Because the weight is evenly distributed, two-tenths of the train would place twice the allowed load on the bridge. Rearranging which event happens first does not answer whether the bridge is overloaded. The relativity of simultaneity does not resolve this paradox.

The bridge is shared state. The conductor’s thread and the engineer’s thread are both writing to the same variable — how much train is on the bridge — and they are writing contradictory values. Under classical mechanics, this is a non-problem: there is a global state to arbitrate, one length is simply correct, and both observers can agree on it after the fact. Under relativity, these are parallel processes competing for the same shared resource. Both writes are locally valid. This is a race condition.

There are two escape hatches the relativist can use here:

1. Prioritize one frame as the “proper” measurement.
2. Abandon another universal property of matter, such as structural rigidity.
3. Allow the frames to produce separate timelines, giving up one shared history of events.

This is not some exotic corner case I dreamed up. The scenario is a variation of the Rod and Slit Paradox, first proposed by W. Rindler in the American Journal of Physics in 1961. Its proposed resolution relies on relativistic rigidity.

Relativistic Rigidity, and Other Bug Fixes

What is relativistic rigidity? It’s exhausting.

But truly, it is a patch — a bug fix. Here is a trend I noticed as I dug deeper into relativity, and I am not the first to notice it: whenever such an error is revealed, the consensus resolution is to redefine terms in a way that moves the theory closer to unfalsifiability. Relativistic rigidity entered the field soon after Einstein’s famous 1905 paper, when the tortured genius (and murderer) Paul Ehrenfest correctly discovered that relativity had no good model for a rotating disk. The problem is now called the Ehrenfest Paradox.

How do we model a spinning disk under relativity? Points near the outer edge move faster than points near the center, so different parts of the disk contract by different amounts. Imagine placing tiny observers at different distances from the center. Each would produce a different measurement of the disk’s circumference. The disk therefore has no coherent global state. It cannot begin spinning while preserving all its proper distances — the distances measured by observers riding on the disk.

The resolution was to say, in effect: well, we just can’t ask those kinds of questions. We will simply say that relativity allows nothing to be perfectly rigid. It is one thing to say that objects are squishy at some level; if you push one end of a bar, the other end cannot respond instantly. But the relativists take this a step further, claiming that shape itself is an arbitrary property — and this leads to complex objects having undefined states.

Under relativity, certain properties have to be redefined — circumference, for example — declared yet another property that we cannot state universally. But how can that work if every object exists in one shared universe? The simple fact is that it can’t.

Relativity becomes a motte and bailey. Relativity’s ambitious claim is that it describes one coherent universe shared by all objects. When pressed, it retreats to the safer claim that no global state exists. Those positions cannot both do the work being asked of them. The result is a race condition.

Relativity Cannot Model Complex Objects

We have already seen how relativity struggles to model trains crossing poorly-constructed bridges and rotating disks. Now let’s go further — and this time, we will not settle for a thought experiment. We will run one as a full mechanical simulation.

Imagine an engine. A sealed cylinder, a piston on one end, a fixed wall on the other, and a gas trapped between them. This is a relativistic engine. The piston drives toward the wall at 95% of the speed of light, compressing the gas as it goes. The gas is 1,000 particles, bounced off the piston and the wall, with the piston doing real work on them at every bounce.

Something we’re very interested in here is how the consequences of arbitrary shape lead to fundamentally different processes being carried out in each respective reference frame. An object has features of existence, like shape, but shape also has logical properties, like for instance, increasing the overall surface area of a piston in an engine chamber.

We have two reference frames in this simulation, the piston and the chamber wall. As the piston accelerates, the chamber itself will contract, which increases the density of gas particles within the chamber. But density also has logical properties which lead to increases in pressure. And pressure also has logical properties which lead to increases in temperatures.

The full source code for this simulation can be found here.

Both simulations read temperature the ordinary way — pressure times volume over the amount of gas, the ideal-gas law, nothing exotic — and both share one thermometer scale, calibrated so the gas starts at a comfortable 70 degrees Fahrenheit in the wall’s frame.

Here is what the run produced:

  STAGE  FRAME       VOLUME    PRESSURE    TEMP (deg F)
----------------------------------------------------------
   0.0%  WALL        10.0000       4.07           70.00
         PISTON       3.1225     992.89       39,876.61
  25.0%  WALL         7.5000     792.29       76,850.39
         PISTON       2.3419   1,325.62       39,930.40
  50.0%  WALL         5.0000   2,104.80      136,462.21
         PISTON       1.5613   2,191.91       44,063.64
  75.0%  WALL         2.5000   6,330.00      205,430.94
         PISTON       0.7806  86,098.58      873,983.01

Read the first row carefully, because it is the whole argument in miniature. Same gas. Same moment. Same thermometer. The wall’s frame reports a mild 70°F — a pleasant spring day. The piston’s frame reports 39,877°F — roughly four times the temperature of the Sun’s surface.

Why? In the piston’s frame, the wall is what’s moving — the whole cylinder and its gas come rushing toward the piston at nearly the speed of light. The chamber is Lorentz-contracted to less than a third of its length, and every particle in the gas carries a large directed velocity. That bulk flow is real in this frame, and it gets folded into the reading. Nothing is broken. The bookkeeping balances in both runs — energy and momentum are conserved exactly. Neither frame is cheating. I have done nothing to cheat relativity here, this is precisely what they say would happen between frames.

And the disagreement is not even one-directional: the two frames cannot agree on which frame is hotter. At the start, the piston’s frame reads vastly hotter. At the halfway point, the wall’s frame reads hotter — 136,462°F against 44,064°F. At 75%, the piston’s frame is engulfed at 873,983°F, more than four times the wall frame’s reading.

We could take this further and propose a very realistic hypothetical, that somewhere near 800,000°F, the piston melts. Based on our measurements, it would only melt in one frame. This is not merely a disagreement about when something happened. It is a disagreement about whether it happened at all. The piston has melted and not melted. Once again, we have a race condition. The universe should simply error out here or produce a different timeline.

Where is the escape hatch for the relativist?

I don’t think there is one. Relativity does not have a good way to translate temperature between frames. Physicists have argued about how — or whether — temperature transforms between frames for over a century, and the argument has never been settled. It seems to have a poor method for measuring temperature in general, which makes sense because temperature is a complex, emergent phenomenon produced by the interactions between atoms.

And that is just the temperature we are considering. The two frames also assign different densities, pressures, momentum distributions, and energy densities to the same engine — and each of those could just as easily create some second-order consequence that once again leads to a divergent timeline. The gas could change in thermal conductivity, chemical reaction rates, phase — and then all of the properties that may change due to those changes.

The Proper Dodge

The relativist does usually have a prepared answer to these kinds of questions.

When two frames disagree about a property — the length of a bar, the ticking of a clock, the temperature of a gas — relativity instructs us to prefer the proper measurement: the one taken in the rest frame of the object being measured. Proper time. Proper length. Proper temperature. The proper frame’s answer, we are told, is the real one; every other frame’s reading is merely an artifact of its own motion.

But the “proper” frame is not derived from the theory; it is hard-coded into it. And the move quietly reinstalls the global state that relativity spent the last century denying. A theory based on the concept that no frame is privileged resolves every concrete disagreement by privileging a frame — chosen quite conveniently. This is the motte-and-bailey again. The ambitious claim is that all frames are equally valid.

The dodge also fails on its own terms. Declaring the wall frame’s 70°F “real” does not make the piston frame’s 39,877°F go away. That reading was produced by honest math in a frame doing exactly what relativity tells it to do. That piston is still only melting in one frame. The race condition is not resolved.

And no experiment could ever catch this move — which is not a side effect, it is the point. Any measurement that contradicts the proper answer is, by definition, an artifact. This moves towards unfalsifiability.

The Odd Man Out

Physics has a famous bridge problem: relativity and quantum mechanics cannot be reconciled. This engine has just shown us that the trouble is bigger than that. Temperature is a statistical property. It belongs to a population — a summary of a thousand particles jostling at random. Pressure, density, entropy: all of these live in statistical mechanics, the branch of physics whose entire job is deriving the behavior of large populations from their individual parts.

Relativity cannot speak that language. It knows only individual observers and their local frames. It has no vocabulary for a property that belongs to a crowd — which is why, when we ran the engine, it could not tell us the temperature until we first decided whose thermometer counts. Quantum mechanics and statistical mechanics talk to each other constantly; statistical mechanics is largely what makes quantum mechanics usable at human scale. Relativity is the odd man out.

And this inverts the sales pitch. Relativity is sold as a practical tool — the theory that runs your GPS, we are told. But ask it a question as old as the thermometer — how hot is this gas? — and it has no answer. Not an answer that is hard to compute: no answer, after a hundred years, not even an agreement on how the question should be asked. A tool that requires you to settle a metaphysical dispute before it will read a thermometer is not a tool.

Even deciding a privileged reference frame in this example still has costs. To decide whether the piston melts, you need the true temperature of the gas: the reading from the gas’s own rest frame, with the bulk motion stripped away — and the gas is not one object! It is a thousand particles, each with its own velocity, each colliding and jostling, each occupying its own little reference frame. To measure everything from a local frame, one object at a time, you would have to visit all thousand particles, correct each measurement, and then somehow decide which of those thousand private answers belonged to the gas. Emergent properties like temperature do not make much sense under that procedure. A property that takes a thousand private reference frames to assemble is not a property of anything anyone can check.

The mistake of relativity is the assumption that space can be arbitrary without consequence. But space, and shape, have properties that are not irrelevant, and they interact with the world in distinct ways. A gas that is a pleasant spring day in one frame and hotter than the surface of the Sun in another is not a reporting discrepancy. It is two different processes happening to the same machine — and only one of them ends with a molten piston.

Part 2: Experiments

A theory can survive logical discomfort if experiments leave us no other choice. So now we have to ask the harder question: what does the experimental evidence actually prove?

Relativity is often presented as one of the most thoroughly tested theories in history. That statement sounds decisive, but it bundles many different claims together. An experiment may confirm a predicted frequency shift, a change in clock time, or an interference pattern without directly proving that light travels at the same speed in every possible reference frame. Bundling is an old trick: tie the untestable claim to a dozen testable ones, and let the small victories vouch for the grand article of faith.

Here is the experimental record, examined closely — with credit given where relativity genuinely earns it.

Measuring Speed From Frequency Alone

Imagine a person assigned to measure traffic on a roadway. He is locked inside a Kafkaesque booth with no windows. Every time a car passes, a red light flashes.

After an hour, he can tell us exactly how often cars passed his booth. If the light flashes once every second, he has measured a frequency: one car per second.

But he cannot tell us how fast the cars were traveling. They might be moving slowly, close together. They might be moving quickly, far apart. The same number of cars can pass his booth under either arrangement.

To calculate speed, he would need more information. He would need to know the distance between the cars, or he would need to measure a known stretch of road and time how long a car takes to cross it.

This is how the vast majority of physics experiments measured the speed of light — with the implicit assumption that the wavelength of light changes in response to the frequency.