Probability as Translation, Not a Property of Nature: The Born Rule and the Deterministic Core of the Schrödinger Equation
T.O.
This paper relocates the Schrödinger equation, the Born probability rule, and the definiteness of experience from a single undifferentiated account into two layers: a deterministic structural layer (Tier-2) and a translation layer (Tier-3), the layer of commutative, analytic, classical description. No part of the mathematical content of wave mechanics is changed; what changes is only the layer to which each statement belongs.The main result is the following. The probabilistic reading of the Born rule presupposes three Tier-3 choices: (P1) realising the state as a complex-valued state functional; (P2) restricting that functional to a commutative subalgebra and constructing a measure from the spectral theorem; and (P3) adopting a rule that reads the measure as a distribution of measurement outcomes. Each choice adds structure that Tier-2 does not determine, so the passage from Tier-2 is a non-invertible translation and the probabilistic reading is representation-dependent. Probability is therefore not a primitive property of nature. The evolution of the state, by contrast, is the generator equation of a strongly continuous unitary group; it is smooth and deterministic, and its statement is independent of P1–P3. Within physics (Tier-3), the paper also assigns complementary roles to the two original mechanics: matrix mechanics, the non-commutative algebra of observables, is the theoretical pillar, and wave mechanics is the implementation that makes concrete models tractable. For finitely many degrees of freedom they are unitarily equivalent, so the asymmetry between them lies in tractability and not in content. The paper does not deny the validity or the empirical adequacy of the Born rule. It does not resolve the meaning of probability, does not derive the selection of an individual outcome, does not derive the post-measurement update rule, and does not claim to derive the Born rule from Tier-2. Its aim is an account that Schrödinger himself could accept: smooth deterministic evolution, with probability placed outside the dynamics. This paper follows the author's three papers on the uncertainty principle (https://doi.org/10.5281/zenodo.23073559, https://doi.org/10.5281/zenodo.23128791, https://doi.org/10.5281/zenodo.23130407) and applies the same structural analysis to the Born rule and the Schrödinger equation. Appendix A of the paper contains five self-contained Python 3 verification scripts (NumPy only); Code 1, which exhibits a pair of representations sharing one wave function, is reproduced below. import math import numpy as np hbar, m, sigma0 = 1.0, 1.0, 1.0 k = hbar / (2.0 * m * sigma0**2) # d(tau)/dt, tau = k t def psi(x, t): """Exact free Gaussian packet psi_0 ~ exp(-x^2/(4 sigma0^2)).""" tau = k * t c = 1.0 + 1j * tau return (2*np.pi*sigma0**2)**-0.25 * c**-0.5 * np.exp(-x**2 / (4*sigma0**2*c)) def psi_x_over_psi(x, t): return -x / (2.0 * sigma0**2 * (1.0 + 1j * k * t)) def velocity(x, t): # guidance equation v = (hbar/m) Im(psi_x/psi) return (hbar / m) * np.imag(psi_x_over_psi(x, t)) def trajectories(x0, T, steps=2000): # deterministic RK4 x, dt = x0.copy(), T / steps for i in range(steps): t = i * dt k1 = velocity(x, t); k2 = velocity(x + 0.5*dt*k1, t + 0.5*dt) k3 = velocity(x + 0.5*dt*k2, t + 0.5*dt); k4 = velocity(x + dt*k3, t + dt) x = x + dt * (k1 + 2*k2 + 2*k3 + k4) / 6.0 return x # (a) psi solves the free Schroedinger equation (finite-difference residual) x = np.linspace(-8, 8, 4001); h, dt, t0 = x[1]-x[0], 1e-4, 1.3 dpsi_dt = (psi(x, t0+dt) - psi(x, t0-dt)) / (2*dt) lap = (psi(x[2:], t0) - 2*psi(x[1:-1], t0) + psi(x[:-2], t0)) / h**2 res = np.max(np.abs(1j*hbar*dpsi_dt[1:-1] + hbar**2/(2*m)*lap)) print("Schroedinger residual :", f"{res:.2e}") assert res < 1e-5 # (b) trajectories are deterministic functions of x0; they match the closed form rng = np.random.default_rng(12345) x0 = rng.normal(0.0, sigma0, 200000) # the ONLY random input: initial positions T = 3.0 xT = trajectories(x0, T) closed = x0 * math.sqrt(1.0 + (k*T)**2) err = np.max(np.abs(xT - closed)) print("max |RK4 - closed form| :", f"{err:.2e}") assert err < 1e-8 assert np.array_equal(xT, trajectories(x0, T)) # same x0 -> same x(T), bit for bit # (c) equivariance: ignorance measure |psi_0|^2 at t=0 is carried to |psi_T|^2 sigT = sigma0 * math.sqrt(1.0 + (k*T)**2) print("std of positions at T / sigma(T) :", f"{xT.std():.4f} / {sigT:.4f}") assert abs(xT.std()/sigT - 1.0) < 5e-3 s = np.sort(xT) cdf = np.array([0.5*(1.0 + math.erf(v/(sigT*math.sqrt(2.0)))) for v in s]) ks = np.max(np.abs(cdf - (np.arange(1, s.size+1)/s.size))) print("KS distance to |psi(x,T)|^2 :", f"{ks:.4f}") assert ks < 3.0 / math.sqrt(s.size) # approx. 99.9 percent level print("PASS")
•Oct 6, 2026•0 citations