_Relativistic Economics_

Time Is Money: A Relativistic Theory of Wages

Trent Carter

_Working Paper — December 2025_

Abstract

_We develop a correspondence between the spacetime constraint of special relativity and the time-allocation constraint of labor economics. By defining wages as proportional to proper time rather than coordinate time, we derive a "relativistic wage curve" that exhibits counterintuitive properties: income decreases monotonically with spatial velocity. We extend this framework to general relativity, demonstrating gravitational wage arbitrage, and discuss pedagogical applications for teaching both time dilation and opportunity cost._

1. Introduction

The aphorism "time is money" encodes a deep economic truth: time is the fundamental scarce resource against which all labor is measured. In selling one's time for wages, a worker trades leisure for income along a fixed temporal budget constraint. This paper observes that an identical mathematical structure underlies special relativity, where motion through space and motion through time compete along a fixed spacetime interval.

We exploit this isomorphism to construct a thought experiment: a labor contract in which wages are paid per unit of _proper time_ experienced by the worker, while shift duration is measured in _coordinate time_ on a stationary clock. The resulting "relativistic wage model" produces a paycheck that shrinks with spatial velocity—a pedagogically rich scenario that illuminates both the physics of time dilation and the economics of opportunity cost.

2. Mathematical Framework 2.1 The Relativistic Constraint

In special relativity, an object's four-velocity has constant magnitude _c_. Decomposing into spatial and temporal components:

_v_x2 + _v_t2 = _c_2          (1)

where _v_x is spatial velocity and _v_t = _dτ/dt_ · _c_ represents "temporal velocity." This constraint describes a circle of radius _c_ in velocity space: increasing spatial velocity necessarily decreases temporal velocity.

2.2 The Economic Constraint

A worker faces an analogous budget constraint. Given a fixed time endowment _T_:

_T_work + _T_leisure = _T_          (2)

Both equations describe conservation laws forcing allocation along a fixed budget. The key difference is that Equation (1) is quadratic (Pythagorean on the spacetime manifold) while Equation (2) is linear. We resolve this by noting that the Lorentz factor provides a natural projection from the circular constraint onto a linear scale.

2.3 The Coordinate Transformation

The Lorentz factor _γ_ relates proper time _τ_ (time experienced by a moving observer) to coordinate time _t_ (time on a stationary clock):

_τ_ = _t_ / _γ_ = _t_ √(1 − _v_2/_c_2)          (3)

This equation is the bridge between relativistic and economic space. It maps the circular constraint (1) onto a scalar quantity (proper time) that decreases monotonically with spatial velocity.

3. The Relativistic Wage Model 3.1 Contract Specification

We define a labor contract with the following terms:

Shift Duration: The factory clock (stationary reference frame) measures an 8-hour shift. This is coordinate time _t_ = 8 hours. Hourly Rate: The worker is paid rate _R_ per hour of _proper time_ experienced. Worker Velocity: The worker moves at constant velocity _v_relative to the factory. 3.2 Wage Derivation

The worker's total compensation _W_ is:

_W_(_v_) = _R_ · _τ_ = _R_ · _t_ · √(1 − _v_2/_c_2)          (4)

This is the Relativistic Wage Equation. Key properties:

At _v_ = 0: _W_ = _Rt_ (maximum wage, achieved by stationary workers)

At _v_ → _c_: _W_ → 0 (wage approaches zero as velocity approaches light speed)

At _v_ = 0.866_c_: _γ_ = 2, so _W_ = _Rt_/2 (half pay)

3.3 The Incentive Structure

Equation (4) creates a perverse incentive: _laziness is rewarded_. To maximize income, workers must remain perfectly stationary. Any spatial motion—walking to the water cooler, commuting between departments, or operating moving machinery—reduces billable hours. The optimal strategy is complete immobility at the highest available gravitational potential (see Section 4).

4. Extensions to General Relativity 4.1 Gravitational Time Dilation

In general relativity, proper time is also affected by gravitational potential _Φ_. For a weak gravitational field:

_τ_ ≈ _t_ √(1 − _v_2/_c_2) · √(1 + 2_Φ_/_c_2)          (5)

Since gravitational potential is negative near massive objects, clocks run slower at lower altitudes. Workers in basement offices experience less proper time than those on upper floors.

4.2 Gravitational Wage Arbitrage

This creates a gravitational arbitrage opportunity: executives literally belong in penthouses. The CFO on the 50th floor accumulates more proper time than the IT technician in the basement. Over an 8-hour coordinate shift, the altitude difference produces a (negligible but nonzero) wage differential.

For Earth's surface gravity, the proper time difference between floors separated by height _h_ is approximately:

Δ_τ_/_τ_ ≈ _gh_/_c_2 ≈ 10−16 per meter          (6)

While economically insignificant, this effect has been measured experimentally and reinforces the pedagogical point: in relativistic economics, your office location matters.

5. The Twin Paradox of Wealth

Consider twins A and B employed at the same factory:

Twin A (Stationary): Remains at their workstation. Their watch advances 8 hours. They invoice for 8 hours at rate _R_. Total pay: _W_A = 8_R_. Twin B (Commuter): Travels around the factory at _v_ = 0.866_c_. When the factory clock reads 8 hours (shift over), Twin B's watch shows only 4 hours. They invoice for 4 hours. Total pay: _W_B = 4_R_.

The asymmetry is physical, not accounting fraud: Twin B has genuinely experienced half as much time. In this economy, "time is money" becomes literally true, with the crucial caveat that _only proper time is legal tender_.

6. Philosophical Implications 6.1 The Velocity of Money Paradox

Standard economics rewards high monetary velocity—frequent transactions, rapid capital turnover, and active markets. Our relativistic economy punishes high spatial velocity. This inversion illuminates an interesting philosophical point: the metaphorical "velocity" of money operates in economic phase space, not physical spacetime. Conflating the two reveals our Galilean intuitions about time.

6.2 Productivity vs. Apparent Activity

The relativistic wage model accidentally captures a real tension in knowledge work: _appearing busy_ (high spatial velocity around the office) versus _deep focus_ (sitting still, thinking). Many organizations implicitly reward motion over contemplation. Our model inverts this, rewarding the physicist who sits motionless at a blackboard over the manager who paces anxiously between meetings.

6.3 Galilean Economic Intuitions

The counterintuitive nature of relativistic wages reveals that our economic intuitions are fundamentally Galilean: we assume time flows identically for all observers regardless of their motion. This assumption, embedded in every labor contract and hourly wage, works perfectly well at human velocities. But it fails philosophically—we _expect_ time to be absolute even though physics tells us it isn't.

7. Pedagogical Applications

This framework serves as an effective teaching tool for several concepts:

Time Dilation: The wage curve provides an intuitive, economic consequence of the Lorentz factor. Students can calculate their "pay cut" at various velocities. Proper vs. Coordinate Time: The distinction becomes concrete: coordinate time is what the boss measures; proper time is what you experience and get paid for. Opportunity Cost: The spacetime constraint mirrors the time-allocation constraint, making the physics of tradeoffs tangible. The Twin Paradox: Recasting it as a wealth inequality problem adds narrative stakes and makes the asymmetry memorable. 8. Conclusion

We have constructed a formal mapping between special relativity and labor economics, demonstrating that the spacetime constraint and the time-budget constraint share identical mathematical structure. By defining wages in terms of proper time, we derive a relativistic wage equation that rewards stillness and penalizes motion—an inversion of both physical intuition and economic norms.

The model extends naturally to general relativity, producing gravitational wage arbitrage, and offers pedagogical value for teaching time dilation, the twin paradox, and the economics of opportunity cost. Most fundamentally, it reveals that our intuitions about time—physical and economic—remain stubbornly Galilean.

In this universe, "time is money" is not merely metaphor. It is Lorentz-covariant accounting.

References

[1] Einstein, A. (1905). "On the Electrodynamics of Moving Bodies." _Annalen der Physik_, 17(10), 891-921.

[2] Minkowski, H. (1908). "Space and Time." Address to the 80th Assembly of German Natural Scientists and Physicians.

[3] Becker, G. (1965). "A Theory of the Allocation of Time." _The Economic Journal_, 75(299), 493-517.

[4] Hafele, J.C. & Keating, R.E. (1972). "Around-the-World Atomic Clocks." _Science_, 177(4044), 166-170.

"""

Relativistic Economics: Time Is Money

=====================================

Companion code for "Time Is Money: A Relativistic Theory of Wages"

This module implements the relativistic wage model and produces

visualizations demonstrating the relationship between spatial

velocity and compensation.

"""

import numpy as np

import matplotlib.pyplot as plt

from matplotlib.patches import FancyArrowPatch

from dataclasses import dataclass

Constants

c = 1.0  # Speed of light (normalized)

@dataclass

class LaborContract:

    """A relativistic labor contract specification."""

    coordinate_time: float  # hours (factory clock)

    hourly_rate: float      # $/hour (proper time)

    def wage(self, v: float) -> float:

        """Calculate total wage at velocity v (as fraction of c)."""

        gamma = 1 / np.sqrt(1 - v2 / c2)

        proper_time = self.coordinate_time / gamma

        return self.hourly_rate proper_time

    def proper_time(self, v: float) -> float:

        """Calculate proper time experienced at velocity v."""

        gamma = 1 / np.sqrt(1 - v2 / c2)

        return self.coordinate_time / gamma

    def max_wage(self) -> float:

        """Maximum wage (at v=0)."""

        return self.coordinate_time self.hourly_rate

def lorentz_factor(v: float) -> float:

    """Calculate Lorentz factor γ for velocity v (as fraction of c)."""

    return 1 / np.sqrt(1 - v2 / c2)

def plot_relativistic_wage_curve(contract: LaborContract, save_path: str = None):

    """

    Generate the primary visualization: wage as a function of velocity.

    """

    plt.style.use('dark_background')

    fig, ax = plt.subplots(figsize=(10, 7))

    v = np.linspace(0, 0.999, 500)

    pay = np.array([contract.wage(vel) for vel in v])

    max_pay = contract.max_wage()

    # Main curve

    ax.plot(v, pay, color='#00ffcc', linewidth=3, label='Relativistic Wage W(v)')

    ax.fill_between(v, pay, color='#00ffcc', alpha=0.1)

    # Reference lines

    ax.axhline(y=max_pay/2, color='#ff6b6b', linestyle='--', alpha=0.5, label='Half Pay (v = 0.866c)')

    ax.axhline(y=max_pay, color='#4ecdc4', linestyle='--', alpha=0.5, label='Max Pay (v = 0)')

    # Annotations

    ax.annotate(f'Max Pay (${max_pay:.0f})\nStationary Worker', 

                xy=(0, max_pay), xytext=(0.15, max_pay 0.92),

                fontsize=10, color='white',

                arrowprops=dict(facecolor='white', shrink=0.05, width=1))

    ax.annotate(f'Half Pay (${max_pay/2:.0f})\nv = 0.866c, γ = 2', 

                xy=(0.866, max_pay/2), xytext=(0.6, max_pay 0.6),

                fontsize=10, color='white',

                arrowprops=dict(facecolor='white', shrink=0.05, width=1))

    ax.annotate('Zero Pay\nLight Speed', 

                xy=(1, 0), xytext=(0.75, max_pay 0.15),

                fontsize=10, color='white',

                arrowprops=dict(facecolor='white', shrink=0.05, width=1))

    # Formatting

    ax.set_title('The Relativistic Wage Curve\n' + 

                 f'({contract.coordinate_time:.0f}-Hour Shift, ${contract.hourly_rate:.0f}/hr Proper Time)',

                 fontsize=14, pad=15)

    ax.set_xlabel('Spatial Velocity (v/c)', fontsize=12)

    ax.set_ylabel('Total Compensation ($)', fontsize=12)

    ax.set_xlim(0, 1.05)

    ax.set_ylim(0, max_pay 1.1)

    ax.grid(True, alpha=0.3, linestyle='--')

    ax.legend(loc='upper right', fontsize=9)

    # Equation annotation

    eq_text = r'$W(v) = R \cdot t \cdot \sqrt{1 - v^2/c^2}$'

    ax.text(0.5, max_pay 0.25, eq_text, fontsize=14, color='#00ffcc',

            ha='center', style='italic')

    plt.tight_layout()

    if save_path:

        plt.savefig(save_path, dpi=150, bbox_inches='tight', facecolor='#1a1a2e')

    return fig, ax

def plot_spacetime_velocity_constraint():

    """

    Visualize the spacetime velocity constraint: v_x² + v_t² = c²

    Shows how spatial and temporal velocity trade off.

    """

    plt.style.use('dark_background')

    fig, ax = plt.subplots(figsize=(8, 8))

    # Draw the constraint circle

    theta = np.linspace(0, np.pi/2, 100)

    vx = c np.sin(theta)

    vt = c np.cos(theta)

    ax.plot(vx, vt, color='#00ffcc', linewidth=3, label='Spacetime Velocity Constraint')

    ax.fill_between(vx, 0, vt, color='#00ffcc', alpha=0.1)

    # Mark key points

    points = [

        (0, c, 'Stationary\n(v_x=0, v_t=c)\nMax Proper Time'),

        (c np.sin(np.pi/6), c np.cos(np.pi/6), 'v = 0.5c\nγ ≈ 1.15'),

        (c np.sin(np.pi/3), c np.cos(np.pi/3), 'v = 0.866c\nγ = 2'),

        (c, 0, 'Light Speed\n(v_x=c, v_t=0)\nNo Proper Time')

    ]

    for vx_pt, vt_pt, label in points:

        ax.plot(vx_pt, vt_pt, 'o', color='#ff6b6b', markersize=10)

        offset = (0.05, 0.05) if vx_pt < 0.8 else (-0.15, 0.05)

        ax.annotate(label, xy=(vx_pt, vt_pt), xytext=(vx_pt + offset[0], vt_pt + offset[1]),

                   fontsize=9, color='white', ha='left')

    # Axes

    ax.axhline(y=0, color='white', linewidth=0.5)

    ax.axvline(x=0, color='white', linewidth=0.5)

    ax.set_xlabel('Spatial Velocity v_x (fraction of c)', fontsize=12)

    ax.set_ylabel('Temporal Velocity v_t (fraction of c)', fontsize=12)

    ax.set_title('Spacetime Velocity Constraint\n' + r'$v_x^2 + v_t^2 = c^2$', fontsize=14)

    ax.set_xlim(-0.1, 1.2)

    ax.set_ylim(-0.1, 1.2)

    ax.set_aspect('equal')

    ax.grid(True, alpha=0.3, linestyle='--')

    plt.tight_layout()

    return fig, ax

def plot_twin_paradox_wealth():

    """

    Visualize the Twin Paradox of Wealth scenario.

    """

    plt.style.use('dark_background')

    fig, axes = plt.subplots(1, 2, figsize=(14, 6))

    contract = LaborContract(coordinate_time=8, hourly_rate=50)

    # Left panel: Time experienced

    ax1 = axes[0]

    twins = ['Twin A\n(Stationary)', 'Twin B\n(v = 0.866c)']

    coord_time = [8, 8]

    proper_time = [8, 4]

    x = np.arange(len(twins))

    width = 0.35

    bars1 = ax1.bar(x - width/2, coord_time, width, label='Coordinate Time (Factory Clock)', color='#4ecdc4')

    bars2 = ax1.bar(x + width/2, proper_time, width, label='Proper Time (Personal Watch)', color='#ff6b6b')

    ax1.set_ylabel('Hours', fontsize=12)

    ax1.set_title('Time Experienced During Shift', fontsize=14)

    ax1.set_xticks(x)

    ax1.set_xticklabels(twins)

    ax1.legend()

    ax1.set_ylim(0, 10)

    for bar in bars1:

        ax1.text(bar.get_x() + bar.get_width()/2, bar.get_height() + 0.2, 

                f'{bar.get_height():.0f}h', ha='center', fontsize=11)

    for bar in bars2:

        ax1.text(bar.get_x() + bar.get_width()/2, bar.get_height() + 0.2,

                f'{bar.get_height():.0f}h', ha='center', fontsize=11)

    # Right panel: Wages earned

    ax2 = axes[1]

    wages = [contract.wage(0), contract.wage(0.866)]

    bars = ax2.bar(twins, wages, color=['#4ecdc4', '#ff6b6b'], width=0.5)

    ax2.set_ylabel('Total Compensation ($)', fontsize=12)

    ax2.set_title('Wages Earned (Paid per Proper Hour)', fontsize=14)

    ax2.set_ylim(0, 500)

    for bar, wage in zip(bars, wages):

        ax2.text(bar.get_x() + bar.get_width()/2, bar.get_height() + 10,

                f'${wage:.0f}', ha='center', fontsize=14, fontweight='bold')

    # Add inequality annotation

    ax2.annotate('', xy=(0.7, 200), xytext=(0.3, 400),

                arrowprops=dict(arrowstyle='->', color='white', lw=2))

    ax2.text(0.5, 320, '50% wealth gap\nfrom velocity alone', ha='center', fontsize=10, color='white')

    plt.tight_layout()

    return fig, axes

def plot_economic_relativity_isomorphism():

    """

    Side-by-side comparison of relativistic and economic constraints.

    """

    plt.style.use('dark_background')

    fig, axes = plt.subplots(1, 2, figsize=(14, 6))

    # Left: Relativistic constraint (quadratic/circular)

    ax1 = axes[0]

    theta = np.linspace(0, 2np.pi, 100)

    x = np.cos(theta)

    y = np.sin(theta)

    ax1.plot(x, y, color='#00ffcc', linewidth=3)

    ax1.fill(x, y, color='#00ffcc', alpha=0.1)

    # Arrow showing trade-off

    ax1.annotate('', xy=(0.7, 0.7), xytext=(0, 1),

                arrowprops=dict(arrowstyle='->', color='#ff6b6b', lw=2))

    ax1.annotate('', xy=(0.7, 0.7), xytext=(1, 0),

                arrowprops=dict(arrowstyle='->', color='#ff6b6b', lw=2))

    ax1.set_xlabel(r'$v_x / c$ (Spatial Velocity)', fontsize=12)

    ax1.set_ylabel(r'$v_t / c$ (Temporal Velocity)', fontsize=12)

    ax1.set_title('Relativistic Constraint\n' + r'$v_x^2 + v_t^2 = c^2$', fontsize=14)

    ax1.set_xlim(-1.3, 1.3)

    ax1.set_ylim(-1.3, 1.3)

    ax1.set_aspect('equal')

    ax1.axhline(y=0, color='white', linewidth=0.5, alpha=0.5)

    ax1.axvline(x=0, color='white', linewidth=0.5, alpha=0.5)

    ax1.grid(True, alpha=0.2, linestyle='--')

    ax1.text(0.3, 0.5, 'Any point on circle\nsatisfies constraint', fontsize=9, color='white')

    # Right: Economic constraint (linear)

    ax2 = axes[1]

    t_work = np.linspace(0, 1, 100)

    t_leisure = 1 - t_work

    ax2.plot(t_work, t_leisure, color='#00ffcc', linewidth=3)

    ax2.fill_between(t_work, 0, t_leisure, color='#00ffcc', alpha=0.1)

    ax2.set_xlabel(r'$T_{work} / T_{total}$', fontsize=12)

    ax2.set_ylabel(r'$T_{leisure} / T_{total}$', fontsize=12)

    ax2.set_title('Economic Constraint\n' + r'$T_{work} + T_{leisure} = T_{total}$', fontsize=14)

    ax2.set_xlim(-0.1, 1.1)

    ax2.set_ylim(-0.1, 1.1)

    ax2.set_aspect('equal')

    ax2.axhline(y=0, color='white', linewidth=0.5, alpha=0.5)

    ax2.axvline(x=0, color='white', linewidth=0.5, alpha=0.5)

    ax2.grid(True, alpha=0.2, linestyle='--')

    ax2.text(0.2, 0.5, 'Any point on line\nsatisfies constraint', fontsize=9, color='white')

    # Add connection text

    fig.text(0.5, 0.02, 

             'Isomorphism: Both are conservation laws forcing allocation along a fixed budget.\n' +

             'The Lorentz factor γ projects the circular constraint onto a linear wage scale.',

             ha='center', fontsize=11, color='#4ecdc4', style='italic')

    plt.tight_layout()

    plt.subplots_adjust(bottom=0.15)

    return fig, axes

def calculate_gravitational_wage_differential(height_m: float, shift_hours: float = 8) -> dict:

    """

    Calculate the wage differential due to gravitational time dilation.

    Args:

        height_m: Height difference in meters

        shift_hours: Shift duration in hours

    Returns:

        Dictionary with proper time difference and fractional wage difference

    """

    g = 9.81  # m/s²

    c_mps = 299792458  # m/s

    # Fractional time dilation: Δτ/τ ≈ gh/c²

    fractional_diff = g height_m / c_mps2

    # Time difference over shift

    shift_seconds = shift_hours 3600

    time_diff_ns = fractional_diff shift_seconds 1e9

    return {

        'height_m': height_m,

        'fractional_difference': fractional_diff,

        'time_difference_ns': time_diff_ns,

        'description': f'Worker at +{height_m}m earns {fractional_diff:.2e} more per dollar'

    }

Main execution

if __name__ == "__main__":

    # Create standard contract

    contract = LaborContract(coordinate_time=8, hourly_rate=50)

    print("=" 60)

    print("RELATIVISTIC ECONOMICS: Time Is Money")

    print("=" 60)

    print(f"\nContract: {contract.coordinate_time}hr shift, ${contract.hourly_rate}/hr proper time")

    print(f"Maximum wage (v=0): ${contract.max_wage():.2f}")

    print()

    # Calculate wages at various velocities

    velocities = [0, 0.1, 0.5, 0.866, 0.9, 0.99, 0.999]

    print("Velocity (v/c) | γ (Lorentz) | Proper Time | Wage")

    print("-" 55)

    for v in velocities:

        gamma = lorentz_factor(v)

        tau = contract.proper_time(v)

        wage = contract.wage(v)

        print(f"    {v:.3f}       |   {gamma:6.3f}    |   {tau:5.2f} hr   | ${wage:7.2f}")

    print("\n" + "=" 60)

    print("GRAVITATIONAL ARBITRAGE")

    print("=" 60)

    # Calculate gravitational effects

    for height in [1, 10, 100, 443]:  # 443m = Empire State Building

        result = calculate_gravitational_wage_differential(height)

        print(f"\nHeight: {height}m")

        print(f"  Fractional wage advantage: {result['fractional_difference']:.2e}")

        print(f"  Extra proper time per 8hr shift: {result['time_difference_ns']:.2f} nanoseconds")

    # Generate all figures

    print("\n" + "=" 60)

    print("GENERATING FIGURES...")

    print("=" * 60)

    fig1, ax1 = plot_relativistic_wage_curve(contract, '/mnt/user-data/outputs/fig1_wage_curve.png')

    print("✓ Figure 1: Relativistic Wage Curve")

    fig2, ax2 = plot_spacetime_velocity_constraint()

    fig2.savefig('/mnt/user-data/outputs/fig2_spacetime_constraint.png', dpi=150, bbox_inches='tight', facecolor='#1a1a2e')

    print("✓ Figure 2: Spacetime Velocity Constraint")

    fig3, ax3 = plot_twin_paradox_wealth()

    fig3.savefig('/mnt/user-data/outputs/fig3_twin_paradox.png', dpi=150, bbox_inches='tight', facecolor='#1a1a2e')

    print("✓ Figure 3: Twin Paradox of Wealth")

    fig4, ax4 = plot_economic_relativity_isomorphism()

    fig4.savefig('/mnt/user-data/outputs/fig4_isomorphism.png', dpi=150, bbox_inches='tight', facecolor='#1a1a2e')

    print("✓ Figure 4: Economic-Relativistic Isomorphism")

    print("\nAll outputs saved to /mnt/user-data/outputs/")