Max Born gave quantum mechanics its name in 1924, carried infinite matrices and then operators into Heisenberg’s algebra in 1925–1926, gave the wave function its probabilistic reading in the summer of 1926, and in 1927 signed, with Heisenberg, a report that called the theory complete. The results of these steps are well known; his own part in them, and the point in his record at which the confusion begins, are the subject of this paper. Part I compiles his publications and statements of 1924–1927 and of the Nobel lecture of 1954, each with the status of its source, and sets out who did what: the matrices with Jordan, the operators with Wiener, the two communications on collisions received twenty-six days apart, and the report of 1927, whose section on physical interpretation he drafted. Part II reads the record in the vocabulary of Operatiology (Japanese: Sousa Genron, 操作原論), an independent line of work that distinguishes a Tier-2 layer (states, operations, classes of states; deterministic) from a Tier-3 layer of description (Hilbert space, measure, probability, outcomes). We show that the three acts of Part I build one tool, a relation realized in two ways and one reading attached to both, and that the confusion of quantum mechanics can be located in the record: in the step from the absence of a determination in a description to the absence of a determination in nature, taken as a leaning in June 1926 and stated in October 1927 as the fundamental character of the probabilistic aspect of a theory called complete. The formalism that Born built is correct for the question it answers. A numerical check of the continuity of the tool is given in Appendix A. The program below (Appendix A, code A1) checks the following for the harmonic oscillator with ħ = 1. In the matrix realization, built from the truncated number basis, it checks the commutator QP − PQ on the diagonal and its trace for the truncation size N = 40. In the grid realization, with M = 1601 points on [−10, 10], it checks the commutator acting on a Gaussian away from the ends and its trace. It compares the lowest eight energy levels of the Hamiltonian in the two realizations with n + 1/2 and with each other. For the coherent state of initial position 1 and momentum 1/2 it compares the probabilities of the first ten energy levels computed from the matrix amplitudes and from the grid amplitudes, and it evolves the state on the grid to t = 1 and t = 2, comparing the mean position with the classical path and the energy-level probabilities with those at t = 0. import numpy as np hbar = 1.0 np.set_printoptions(precision=6, suppress=True) results = [] def check(name, ok, detail): results.append(bool(ok)) print(f"[{'PASS' if ok else 'FAIL'}] {name}: {detail}") # --------------------------------------------------------------- # Realization 1 (matrices, 1925): truncated number-basis matrices # --------------------------------------------------------------- def matrices(N): a = np.diag(np.sqrt(np.arange(1, N)), 1).astype(complex) q = (a + a.conj().T) / np.sqrt(2.0) p = -1j * (a - a.conj().T) / np.sqrt(2.0) return q, p # --------------------------------------------------------------- # Realization 2 (differential operators, 1925-1926): grid on [-L, L] # --------------------------------------------------------------- def grid(M, L): x = np.linspace(-L, L, M) h = x[1] - x[0] X = np.diag(x).astype(complex) S = np.eye(M, k=1) + np.eye(M, k=-1) P = -1j * hbar * (np.eye(M, k=1) - np.eye(M, k=-1)) / (2 * h) K = (2 * np.eye(M) - S) / h**2 # -d^2/dx^2 (Dirichlet ends) return x, h, X, P, K # (1) The commutation relation in the matrix realization N = 40 q, p = matrices(N) C = q @ p - p @ q diag = np.diag(C) err_bulk = np.max(np.abs(diag[:-1] - 1j * hbar)) last = diag[-1] check("matrices: [q,p] = i*hbar on all but the last diagonal entry", err_bulk < 1e-12 and abs(last - 1j * hbar * (1 - N)) < 1e-12, f"bulk error {err_bulk:.2e}; last entry {last.real:+.1f}{last.imag:+.1f}j " f"(= i*hbar*(1-N) = {1j*hbar*(1-N)})") check("matrices: trace of [q,p] is zero in every finite truncation", abs(np.trace(C)) < 1e-9 and abs(1j * hbar * N) > 1, f"|trace| = {abs(np.trace(C)):.2e}, while trace(i*hbar*1) = {1j*hbar*N}") # (2) The commutation relation in the differential-operator realization M, L = 1601, 10.0 x, h, X, P, K = grid(M, L) f = np.exp(-x**2 / 2) Cf = (X @ P - P @ X) @ f inner = np.abs(x) < 5 err_grid = np.max(np.abs(Cf[inner] - 1j * hbar * f[inner])) check("grid: ([X,P] f)(x) = i*hbar f(x) for a smooth f, away from the ends", err_grid < 1e-3, f"max error {err_grid:.2e} on |x|<5 (step h = {h:.4f})") Cg = X @ P - P @ X check("grid: trace of [X,P] is zero for the finite grid", abs(np.trace(Cg)) < 1e-9, f"|trace| = {abs(np.trace(Cg)):.2e}") # (3) The same Hamiltonian in both realizations: same spectrum Hm = 0.5 * (q @ q + p @ p) Em = np.sort(np.linalg.eigvalsh(Hm))[:8] Hg = 0.5 * (X @ X + K) Eg, Vg = np.linalg.eigh(Hg) Eg8 = Eg[:8] levels = np.arange(8) + 0.5 check("spectrum: matrix realization gives n + 1/2", np.max(np.abs(Em - levels)) < 1e-9, f"max deviation {np.max(np.abs(Em - levels)):.2e}") check("spectrum: grid realization gives n + 1/2", np.max(np.abs(Eg8 - levels)) < 1e-3, f"max deviation {np.max(np.abs(Eg8 - levels)):.2e}") check("spectrum: the two realizations agree", np.max(np.abs(Em - Eg8)) < 1e-3, f"max difference {np.max(np.abs(Em - Eg8)):.2e}") # (4) The probabilities of energy levels for one state, in both realizations q0, p0 = 1.0, 0.5 alpha = (q0 + 1j * p0) / np.sqrt(2.0) n = np.arange(N) logfact = np.cumsum(np.log(np.maximum(n, 1))) c = np.exp(-abs(alpha) ** 2 / 2 + n * np.log(abs(alpha)) - 0.5 * logfact) \ * np.exp(1j * n * np.angle(alpha)) prob_m = np.abs(c) ** 2 psi = np.pi ** -0.25 * np.exp(-(x - q0) ** 2 / 2 + 1j * p0 * x) psi = psi / np.sqrt(np.sum(np.abs(psi) ** 2) * h) amp_g = Vg.conj().T @ psi prob_g = np.abs(amp_g) ** 2 prob_g = prob_g / prob_g.sum() dev = np.max(np.abs(prob_m[:10] - prob_g[:10])) check("probabilities: |<n|psi>|^2 from matrices and from the grid agree (n = 0..9)", dev < 1e-3 and abs(prob_m.sum() - 1) < 1e-9, f"max difference {dev:.2e}; sum over the {N} matrix levels = {prob_m.sum():.12f}") # (5) The wave propagates by a deterministic law; only the read-out is probabilistic def evolve(t): return Vg @ (np.exp(-1j * Eg * t) * (Vg.conj().T @ psi)) ok5 = True details = [] for t in (1.0, 2.0): pt = evolve(t) mean_x = np.real(np.sum(np.conj(pt) * x * pt) * h) target = q0 * np.cos(t) + p0 * np.sin(t) ok5 = ok5 and abs(mean_x - target) < 1e-3 details.append(f"t={t}: <x> = {mean_x:.6f}, q0 cos t + p0 sin t = {target:.6f}") prob_t = np.abs(Vg.conj().T @ pt) ** 2 ok5 = ok5 and np.max(np.abs(prob_t[:10] / prob_t.sum() - prob_g[:10])) < 1e-9 check("propagation: the evolved amplitude is a function of (psi, t); <x>(t) follows " "the classical path and the energy-level probabilities do not change", ok5, "; ".join(details)) print("ALL CHECKS PASSED:", all(results))
Max Born gave quantum mechanics its name in 1924, carried infinite matrices and then operators into Heisenberg’s algebra in 1925–1926, gave the wave function its probabilistic reading in the summer of 1926, and in 1927 signed, with Heisenberg, a report that called the theory complete. The results of these steps are well known; his own part in them, and the point in his record at which the confusion begins, are the subject of this paper. Part I compiles his publications and statements of 1924–1927 and of the Nobel lecture of 1954, each with the status of its source, and sets out who did what: the matrices with Jordan, the operators with Wiener, the two communications on collisions received twenty-six days apart, and the report of 1927, whose section on physical interpretation he drafted. Part II reads the record in the vocabulary of Operatiology (Japanese: Sousa Genron, 操作原論), an independent line of work that distinguishes a Tier-2 layer (states, operations, classes of states; deterministic) from a Tier-3 layer of description (Hilbert space, measure, probability, outcomes). We show that the three acts of Part I build one tool, a relation realized in two ways and one reading attached to both, and that the confusion of quantum mechanics can be located in the record: in the step from the absence of a determination in a description to the absence of a determination in nature, taken as a leaning in June 1926 and stated in October 1927 as the fundamental character of the probabilistic aspect of a theory called complete. The formalism that Born built is correct for the question it answers. A numerical check of the continuity of the tool is given in Appendix A. The program below (Appendix A, code A1) checks the following for the harmonic oscillator with ħ = 1. In the matrix realization, built from the truncated number basis, it checks the commutator QP − PQ on the diagonal and its trace for the truncation size N = 40. In the grid realization, with M = 1601 points on [−10, 10], it checks the commutator acting on a Gaussian away from the ends and its trace. It compares the lowest eight energy levels of the Hamiltonian in the two realizations with n + 1/2 and with each other. For the coherent state of initial position 1 and momentum 1/2 it compares the probabilities of the first ten energy levels computed from the matrix amplitudes and from the grid amplitudes, and it evolves the state on the grid to t = 1 and t = 2, comparing the mean position with the classical path and the energy-level probabilities with those at t = 0. import numpy as np hbar = 1.0 np.set_printoptions(precision=6, suppress=True) results = [] def check(name, ok, detail): results.append(bool(ok)) print(f"[{'PASS' if ok else 'FAIL'}] {name}: {detail}") # --------------------------------------------------------------- # Realization 1 (matrices, 1925): truncated number-basis matrices # --------------------------------------------------------------- def matrices(N): a = np.diag(np.sqrt(np.arange(1, N)), 1).astype(complex) q = (a + a.conj().T) / np.sqrt(2.0) p = -1j * (a - a.conj().T) / np.sqrt(2.0) return q, p # --------------------------------------------------------------- # Realization 2 (differential operators, 1925-1926): grid on [-L, L] # --------------------------------------------------------------- def grid(M, L): x = np.linspace(-L, L, M) h = x[1] - x[0] X = np.diag(x).astype(complex) S = np.eye(M, k=1) + np.eye(M, k=-1) P = -1j * hbar * (np.eye(M, k=1) - np.eye(M, k=-1)) / (2 * h) K = (2 * np.eye(M) - S) / h2 # -d^2/dx^2 (Dirichlet ends) return x, h, X, P, K # (1) The commutation relation in the matrix realization N = 40 q, p = matrices(N) C = q @ p - p @ q diag = np.diag(C) err_bulk = np.max(np.abs(diag[:-1] - 1j * hbar)) last = diag[-1] check("matrices: [q,p] = ihbar on all but the last diagonal entry", err_bulk < 1e-12 and abs(last - 1j * hbar * (1 - N)) < 1e-12, f"bulk error {err_bulk:.2e}; last entry {last.real:+.1f}{last.imag:+.1f}j " f"(= ihbar*(1-N) = {1jhbar(1-N)})") check("matrices: trace of [q,p] is zero in every finite truncation", abs(np.trace(C)) < 1e-9 and abs(1j * hbar * N) > 1, f"|trace| = {abs(np.trace(C)):.2e}, while trace(ihbar1) = {1jhbarN}") # (2) The commutation relation in the differential-operator realization M, L = 1601, 10.0 x, h, X, P, K = grid(M, L) f = np.exp(-x2 / 2) Cf = (X @ P - P @ X) @ f inner = np.abs(x) < 5 err_grid = np.max(np.abs(Cf[inner] - 1j * hbar * f[inner])) check("grid: ([X,P] f)(x) = i*hbar f(x) for a smooth f, away from the ends", err_grid < 1e-3, f"max error {err_grid:.2e} on |x|<5 (step h = {h:.4f})") Cg = X @ P - P @ X check("grid: trace of [X,P] is zero for the finite grid", abs(np.trace(Cg)) < 1e-9, f"|trace| = {abs(np.trace(Cg)):.2e}") # (3) The same Hamiltonian in both realizations: same spectrum Hm = 0.5 * (q @ q + p @ p) Em = np.sort(np.linalg.eigvalsh(Hm))[:8] Hg = 0.5 * (X @ X + K) Eg, Vg = np.linalg.eigh(Hg) Eg8 = Eg[:8] levels = np.arange(8) + 0.5 check("spectrum: matrix realization gives n + 1/2", np.max(np.abs(Em - levels)) < 1e-9, f"max deviation {np.max(np.abs(Em - levels)):.2e}") check("spectrum: grid realization gives n + 1/2", np.max(np.abs(Eg8 - levels)) < 1e-3, f"max deviation {np.max(np.abs(Eg8 - levels)):.2e}") check("spectrum: the two realizations agree", np.max(np.abs(Em - Eg8)) < 1e-3, f"max difference {np.max(np.abs(Em - Eg8)):.2e}") # (4) The probabilities of energy levels for one state, in both realizations q0, p0 = 1.0, 0.5 alpha = (q0 + 1j * p0) / np.sqrt(2.0) n = np.arange(N) logfact = np.cumsum(np.log(np.maximum(n, 1))) c = np.exp(-abs(alpha) ** 2 / 2 + n * np.log(abs(alpha)) - 0.5 * logfact) \ * np.exp(1j * n * np.angle(alpha)) prob_m = np.abs(c) ** 2 psi = np.pi ** -0.25 * np.exp(-(x - q0) ** 2 / 2 + 1j * p0 * x) psi = psi / np.sqrt(np.sum(np.abs(psi) ** 2) * h) amp_g = Vg.conj().T @ psi prob_g = np.abs(amp_g) ** 2 prob_g = prob_g / prob_g.sum() dev = np.max(np.abs(prob_m[:10] - prob_g[:10])) check("probabilities: |<n|psi>|^2 from matrices and from the grid agree (n = 0..9)", dev < 1e-3 and abs(prob_m.sum() - 1) < 1e-9, f"max difference {dev:.2e}; sum over the {N} matrix levels = {prob_m.sum():.12f}") # (5) The wave propagates by a deterministic law; only the read-out is probabilistic def evolve(t): return Vg @ (np.exp(-1j * Eg * t) * (Vg.conj().T @ psi)) ok5 = True details = [] for t in (1.0, 2.0): pt = evolve(t) mean_x = np.real(np.sum(np.conj(pt) * x * pt) * h) target = q0 * np.cos(t) + p0 * np.sin(t) ok5 = ok5 and abs(mean_x - target) < 1e-3 details.append(f"t={t}: <x> = {mean_x:.6f}, q0 cos t + p0 sin t = {target:.6f}") prob_t = np.abs(Vg.conj().T @ pt) ** 2 ok5 = ok5 and np.max(np.abs(prob_t[:10] / prob_t.sum() - prob_g[:10])) < 1e-9 check("propagation: the evolved amplitude is a function of (psi, t); <x>(t) follows " "the classical path and the energy-level probabilities do not change", ok5, "; ".join(details)) print("ALL CHECKS PASSED:", all(results))
This paper argues that the Heisenberg uncertainty principle is not a theorem of the matrix mechanics that Heisenberg introduced in 1925, nor is it a statement about a feature of nature; it is a product of a Tier-3 translation that imported classical-continuous assumptions into a framework originally committed to purely observable, algebraic relations. We trace the principle's genealogy across four stages: (i) the algebraic origin in Heisenberg's 1925 Umdeutung paper and its completion by Born and Jordan, (ii) the 1927 rupture, where the paper reverses the direction of the 1925 programme: it re-establishes kinematic concepts with semi-classical materials and treats the uncertainty relation both as a foundation and as a consequence of the formalism, (iii) the descent into the Tier-3 infrastructure of ℏ, the trace condition, and L²(ℝ), and (iv) Robertson's 1929 reformulation, which reduced the principle to a general operator inequality whose only content beyond the Fourier theorem is the assumption p = ℏk. We further examine the Ozawa–BLW dispute of the 2000s–2010s, in which both camps share the Tier-3 substrate and therefore argue within a translation layer rather than about physical structure. In Appendix B we introduce the vocabulary of Operatiology V5 and locate each stage within the Tier-2/Tier-3 hierarchy. The conclusion is that the uncertainty principle, as canonically formulated, is a Tier-3 artefact: it is neither forced by the algebraic structure of quantum mechanics nor does it describe a primitive property of nature independent of representational choices. Version 2 (October 2026): Section 3 and Proposition 3.1 are revised to state the relation of the 1927 paper to the 1925 programme as a reversal of direction, with the Abstract, the Conclusion and Theorem B.6 aligned. Statements on the 1925 papers are corrected against the sources, B(H) is replaced by operators on a Hilbert space, and all changes are recorded in the new Appendix C (Revision History). The following code (Code 1, Appendix A) numerically verifies the Stone–von Neumann uniqueness theorem by confirming that two structurally distinct finite-dimensional truncations of the CCR algebra yield spectrally equivalent harmonic-oscillator Hamiltonians. import numpy as np from numpy.linalg import eigh hbar = 1.0 # Representation A: Ladder / number-state truncation N = 120 ns = np.arange(N) a = np.diag(np.sqrt(ns[1:]), k=1) adag = a.T Q_A = np.sqrt(hbar / 2.0) * (a + adag) P_A = 1j * np.sqrt(hbar / 2.0) * (adag - a) H_A = 0.5 * (P_A @ P_A + Q_A @ Q_A) evals_A, _ = eigh(np.real(H_A)) comm_A = Q_A @ P_A - P_A @ Q_A - 1j * hbar * np.eye(N) interior_residual_A = np.max(np.abs(comm_A[:-1, :-1])) # Representation B: Position-grid second-derivative (Dirichlet b.c.) M = 2000 L = 15.0 x = np.linspace(-L, L, M + 2)[1:-1] dx = x[1] - x[0] diag0 = (5.0 / 2.0) * np.ones(M) / dx**2 diag1 = (-4.0 / 3.0) * np.ones(M - 1) / dx**2 diag2 = (1.0 / 12.0) * np.ones(M - 2) / dx**2 T_B = (hbar**2 / 2.0) * ( np.diag(diag0) + np.diag(diag1, 1) + np.diag(diag1, -1) + np.diag(diag2, 2) + np.diag(diag2, -2)) V_B = np.diag(0.5 * x**2) H_B = T_B + V_B evals_B, _ = eigh(H_B) # Comparison n_show = 12 expected_evals = hbar * (np.arange(n_show) + 0.5) spectral_gap = np.max(np.abs(evals_A[:n_show] - evals_B[:n_show])) print(f"CCR interior residual: {interior_residual_A:.2e}") print(f"Max spectral discrepancy (A vs B, {n_show} levels): {spectral_gap:.2e}") # Output: # CCR interior residual: 3.24e-14 # Max spectral discrepancy (A vs B, 12 levels): 1.08e-06
The mathematical equivalence of matrix mechanics and wave mechanics is among the most settled facts of quantum theory. This paper argues, first, that the settlement is an effect of the frame in which it was made. Both theories reached their equivalent final forms inside one Hilbert-space frame, and in that frame the commutation relation of Born and Jordan, a relation that no finite matrices can satisfy, fixes the representation up to unitary equivalence. We separate the layer at which the state spaces are identified, which needs only the frame, from the layer at which the operators are identified, which needs the commutation relation, and we show that the premises of the equivalence proof are fixed on the wave side, so that the equivalence is asymmetric in a precisely defined sense. We argue, second, by exploring a counterfactual that is structural and not empirical, that what the equivalence compares is not Heisenberg’s original idea but a special case of it. The multiplication rule of 1925, whose non-commutativity Heisenberg himself recorded, was completed within months by a defining relation that entered through the correspondence principle from classical mechanics, and with that relation infinite dimension entered the theory. We call the general structure the hypothetical “algebraic mechanics” (Japanese: Maboroshi no Daisuu Rikigaku, まぼろしの“代数力学”). An independent line of work, Operatiology (Japanese: Sousa Genron, 操作原論), which fixes the defining relations by structural necessity and not by borrowing, arrives at a finite-dimensional algebra that is unique under its axioms. The two lines meet at one fact stated from two sides: the commutation relation requires infinite dimension, and the axiom of finite rank requires finite dimension. The counterfactual is hypothetical in the structural sense; the paper makes no claim that Heisenberg could have derived a finite-dimensional theory from the observations of 1925. Program P1 below checks the finite-dimensional fact behind the fork for n = 2, …, 6: the trace of XP − PX vanishes identically, and no pair (X, P) comes closer to iħI than the trivial pair X = P = 0, at distance √n. The proof for every n is given in the paper. """P1. Trace argument: no n x n matrices satisfy XP - PX = i*hbar*I (hbar = 1).""" import numpy as np, sympy as sp from scipy.optimize import minimize # (a) symbolic: tr(XP - PX) vanishes identically for generic entries for n in range(2, 7): X = sp.Matrix(n, n, lambda i, j: sp.Symbol(f"x{i}{j}")) P = sp.Matrix(n, n, lambda i, j: sp.Symbol(f"p{i}{j}")) t = sp.expand((X * P - P * X).trace()) assert t == 0, (n, t) print(f"n={n}: tr(XP-PX) = {t} identically; tr(i*I) = {sp.I*n} != 0") # (b) quantitative: ||XP-PX-iI||_F >= sqrt(n) for all X, P (bound from the trace). rng = np.random.default_rng(0) def resid(v, n): m = n * n a = v[:2 * m].reshape(2, m); b = v[2 * m:].reshape(2, m) X = (a[0] + 1j * a[1]).reshape(n, n); P = (b[0] + 1j * b[1]).reshape(n, n) return np.linalg.norm(X @ P - P @ X - 1j * np.eye(n)) for n in range(2, 7): best = np.inf for _ in range(12): v0 = rng.normal(size=4 * n * n) * rng.uniform(0.1, 2.0) r = minimize(resid, v0, args=(n,), method="BFGS") best = min(best, r.fun) print(f"n={n}: min residual = {best:.10f}, bound sqrt(n) = {np.sqrt(n):.10f}") assert best >= np.sqrt(n) - 1e-6 print("OK: nothing beats the trivial pair X=P=0 (residual sqrt(n)).")
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")
Abstract The new quantum mechanics consists of a scheme of equations which are very closely analogous to the equations of classical mechanics, with the fundamental difference that the dynamical variables do not obey the commutative law of multiplication, but satisfy instead the well-known quantum conditions. It follows that one cannot suppose the dynamical variables to be ordinary numbers (c-numbers), but may call them numbers of a special type (q-numbers). The theory shows that these q-numbers can in general be represented by matrices whose elements are c-numbers (functions of a time parameter). When one has performed the calculations with the q-numbers and obtained all the matrices one wants, the question arises how one is to get physical results from the theory, i. e., how can one obtain c-numbers from the theory that one can compare with experimental values ? Hitherto this has been done with the help of a number of special assumptions. In Heisenberg’s original matrix mechanics it was assumed that the elements of the diagonal matrix that represents the energy are the energy levels of the system, and the elements of the matrix that represents the total polarisation, which are periodic functions of the time, determine the frequencies and intensities of the spectral lines in analogy to the classical theory. Schrodinger’s wave representation of the quantum mechanics has provided new ways of obtaining physical results from the theory, based on the assumption that the square of the amplitude of the wave function can in certain cases be interpreted as a probability. From this assumption one can, for instance, work out the probability of a transition being produced in a system (or the number of transitions produced in an assembly of like systems) by an arbitrary external perturbing force, and can thus, by supposing the perturbation to consist of incident radiation, obtain directly Einstein’s B coefficients. Again in Born’s treatment of collision problems it is assumed that the square of the amplitude of the wave function scattered in any direction determines the probability of the colliding electron (or other body) being scattered in that direction.
Einstein’s conviction that nature does not play dice is usually reported as a dispute that he lost. This paper separates what he said from what is attached to it, and asks in which sense he was right. Part I compiles his statements, from the letter to Born of December 1926 through the article of 1948 to the last appendix of The Meaning of Relativity (1955), each with the status of its source. Part II comments on them in the vocabulary of Operatiology (Japanese: Sousa Genron, 操作原論), an independent line of work in which a Tier-2 layer (states, operations, classes of states) is distinguished from a Tier-3 layer of description (spacetime, Hilbert space, measure, probability, the time parameter, outcomes). We argue that his diagnosis, that probability is not a primitive property of nature but a feature of an incomplete and indirect description, was right in direction, within that vocabulary and under bridge premises, stated as such in the text, that connect an elementary structure to quantum mechanics; and we show in the elementary case how a deterministic law yields probabilities once the situation is recorded by a class of states and not by a state, and a class is carried into more than one class. We argue that his limits are two. The first is historical: he saw the limit of the continuum and called for a purely algebraic theory, but stated that nobody knew how to obtain its basis. The second is structural: he tied separability, a premise stated in terms of spatially separated regions and therefore belonging to the description layer, to physical reality; this rests on a further bridge premise about the form of his own formulation. The paper does not refute Bell’s theorem and does not decide whether the quantum state describes nature completely. Numerical verification. The Python code below (Code A1, Appendix A of the paper) checks the mathematical facts on a composite system that the separability part relies on. For random pure states of 2×2, 2×3 and 3×3 systems it checks that a state is a product state if and only if its Schmidt rank is one, if and only if its reduced state is pure, if and only if its best overlap with a product vector is one. For the Bell state it checks that the reduced state is maximally mixed and that no pure state of one part reproduces the statistics of all observables on that part. It also checks that the Bell state and the product state |+>|+> have the same marginals and different joint distributions. import numpy as np # Code A1: separability of a pure bipartite state, reduced states, and marginals. rng = np.random.default_rng(20261031) def schmidt(psi, dA, dB): s = np.linalg.svd(psi.reshape(dA, dB), compute_uv=False) return s # Schmidt coefficients sqrt(lambda_i), descending def reduced_A(psi, dA, dB): M = psi.reshape(dA, dB) return M @ M.conj().T def purity(rho): return float(np.real(np.trace(rho @ rho))) def max_product_overlap(psi, dA, dB): # max over unit vectors a, b of |<a (x) b | psi>|^2 equals the largest squared Schmidt coefficient. return float(schmidt(psi, dA, dB)[0] ** 2) ok = True # (1) Random states: product iff Schmidt rank 1 iff reduced state pure. for (dA, dB) in [(2, 2), (2, 3), (3, 3)]: for trial in range(200): if trial % 2 == 0: # a product state a = rng.normal(size=dA) + 1j * rng.normal(size=dA); a /= np.linalg.norm(a) b = rng.normal(size=dB) + 1j * rng.normal(size=dB); b /= np.linalg.norm(b) psi = np.kron(a, b) else: # a generic state psi = rng.normal(size=dA * dB) + 1j * rng.normal(size=dA * dB); psi /= np.linalg.norm(psi) s = schmidt(psi, dA, dB) rank = int(np.sum(s > 1e-10)) pur = purity(reduced_A(psi, dA, dB)) ovl = max_product_overlap(psi, dA, dB) is_prod = (rank == 1) ok &= (is_prod == (abs(pur - 1.0) < 1e-10)) and (is_prod == (abs(ovl - 1.0) < 1e-10)) if trial % 2 == 0: ok &= is_prod print("(1) product <=> Schmidt rank 1 <=> pure reduced state <=> overlap 1:", ok) # (2) Bell state: reduced state is maximally mixed, best product overlap is 1/2. bell = np.array([1, 0, 0, 1], dtype=complex) / np.sqrt(2) rhoA = reduced_A(bell, 2, 2) print("(2) Bell reduced state:\n", np.round(rhoA.real, 6)) print(" purity of reduced state: %.6f ; best product overlap: %.6f" % (purity(rhoA), max_product_overlap(bell, 2, 2))) ok &= abs(purity(rhoA) - 0.5) < 1e-12 and abs(max_product_overlap(bell, 2, 2) - 0.5) < 1e-12 # (3) No unit vector phi on A reproduces the statistics of all observables on A: # expectation of X in |phi> equals tr(rhoA X) for all Hermitian X iff rhoA = |phi><phi|. best = 0.0 for _ in range(20000): phi = rng.normal(size=2) + 1j * rng.normal(size=2); phi /= np.linalg.norm(phi) d = np.linalg.norm(np.outer(phi, phi.conj()) - rhoA) # Frobenius distance of density matrices best = d if best == 0.0 else min(best, d) print("(3) smallest distance between rhoA and any sampled pure state: %.4f (positive; exact value %.4f)" % (best, np.sqrt(0.5))) ok &= best > 0.5 # (4) Same marginals, different joint distributions (computational basis): plus = np.array([1, 1], dtype=complex) / np.sqrt(2) prod = np.kron(plus, plus) def joint(psi): return (np.abs(psi) ** 2).reshape(2, 2) for name, psi in [("Bell", bell), ("|+>|+>", prod)]: J = joint(psi) print("(4) %-7s joint:" % name, np.round(J.flatten(), 4), "marginal A:", np.round(J.sum(1), 4), "marginal B:", np.round(J.sum(0), 4)) Jb, Jp = joint(bell), joint(prod) same_marg = np.allclose(Jb.sum(1), Jp.sum(1)) and np.allclose(Jb.sum(0), Jp.sum(0)) diff_joint = not np.allclose(Jb, Jp) print(" same marginals:", same_marg, "; different joint distributions:", diff_joint) ok &= same_marg and diff_joint print("ALL CHECKS PASSED:", bool(ok))