God Has Not Been Playing Dice All Along: Einstein's Determinism as a Statement about Operational Structure, and Probability as a Feature of Its Description
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))
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))
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))
Einstein initially objected to the probabilistic aspect of quantum mechanics— the idea that God is playing at dice. Later he changed his ground, and focussed instead on the point that the Copenhagen Interpretation leads to what Einstein saw as the abandonment of physical realism. We argue here that Einstein’s initial intuition was perfectly sound, and that it is precisely the fact that quantum mechanics is a fundamentally probabilistic theory which is at the root of all the controversies regarding its interpretation. Probability is an intrinsically logical concept. This means that the quantum state has an essentially logical significance. It is extremely difficult to reconcile that fact with Einstein’s belief, that it is the task of physics to give us a vision of the world apprehended sub specie aeternitatis. Quantum mechanics thus presents us with a simple choice: either to follow Einstein in looking for a theory which is not probabilistic at the fundamental level, or else to accept that physics does not in fact put us in the position of God looking down on things from above. There is a widespread fear that the latter alternative must inevitably lead to a greatly impoverished,
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)).")
Albert Einstein once said that he does not believe in a God who plays dice. He was referring to the fundamental principle that quantum theory permits only statistical assertions concerning the values of physical quantities. This issue, namely, whether the description of Nature in statistical terms is complete or even consistent, was the subject of a very lively debate-dialogue between Einstein and Niels Bohr in the years 1920-1930. Nowadays there is no debate as the principles of quantum theory have been verified countless times in experiments. In this lecture (which requires no previous background) I shall discuss both classical and quantum probabilities. Although the meaning of probability remains the same in both contexts, the method of calculating them is different. I shall explain the strange but beautiful manner in which quantum probabilities are calculated, explaining the mathematical foundations in an elementary manner. The meaning of probability
One of the most enduring philosophical disputes in physics is encapsulated in a briefexchange between Albert Einstein and Niels Bohr. Einstein objected to quantummechanics by insisting that “God does not play dice with the universe,” while Bohr retortedthat Einstein should “stop telling God what to do.” This exchange is often framed as adisagreement between determinism and randomness. In this paper, we revisit that debatethrough the lens of the Space-Phase-Three (SP3) framework. We argue that SP3 supportsthe empirical reality of quantum uncertainty without invoking fundamental randomness.Instead, uncertainty emerges from observers and matter being embedded within aconditioned, memory-bearing space-phase. From this perspective, neither Einstein norBohr was fully wrong; rather, both were describing different facets of a deeper physicalstructure that neither had access to. In SP3, God does not play dice—but observersnecessarily experience probabilities.
Niels Bohr stands at the head of the interpretation of quantum mechanics, as its philosophical pillar and its organizer, although the formalism of the new mechanics was made by others. This paper asks what Bohr was, and shows that the question comes down to one question about the doctrine of complementarity. The frame is that of Operatiology (Japanese: Sousa Genron, 操作原論), the executive layer of Cognitional Mechanics (Japanese: Chinou Rikigaku, 知能力学), which stands under the regulative layer of Noology (Japanese: 知学). The frame separates a Tier-2 layer, made of states, operations, words of operations and classes of states, which is deterministic, from a Tier-3 layer of description, which is commutative, analytic and classical, and in which Hilbert space, measure and probability are found. In this frame a pair of descriptions that cannot be held together arises when operations whose results depend on their order are written in a language of description that does not depend on order. Bohr saw correctly that the exclusion is a relation between descriptions; he then stated its cause as exclusive aspects of nature. The statistical character of the theory is likewise a feature of the measure in Tier-3, and Bohr read it as a trait of nature. The two senses in which the theory has been called complete concern two different maps and do not contradict each other. The formalisms fit complementarity because they share one source, which is not evidence that the aspects belong to the object. Bohr was the person who found the problem correctly and assigned its cause to the wrong place. The break is confined to the layer of interpretive premises; the empirical content of the formalism is untouched. A finite model and numerical checks of every arithmetic statement used are given in Appendix A. The Python program below is Appendix A of the paper. It uses Python 3 with numpy and the standard library only, and checks finite arithmetic statements and only those. In the four-state model it checks the two operations, their composition orders and the classes of states they generate. It counts the composition-preserving maps of the three-element structure into the maps of finite sets and examines which of them preserve the difference of the two operations. It checks the Kennard inequality for the spreads of a position distribution and a momentum distribution, the way the classes of states refine when an operation is added to the family, the two maps behind the two senses of "complete" on one model, the push of a measure on states to classes and a readout that the operations cannot see, and the realizations of one noncommutative structure by maps and by matrices. The program checks nothing about nature, about history or about any person. Run it as python3 -I a1.py. # Appendix A. Verification code for the Bohr paper (Python 3, numpy only). # Every check prints one line; an assertion stops the run if a check fails. # The code checks finite arithmetic facts only. It does not check any # statement about nature, about history, or about a person. import itertools import random from fractions import Fraction import numpy as np # ---------------------------------------------------------------------- # Section 0. Tools: maps on a finite set, composition, closure, classes # ---------------------------------------------------------------------- NAMES = ('p', 'q', 'r', 'r2') # the four states of the model N = len(NAMES) def amap(d, names=NAMES): """A map given as a dict of names; stored as a tuple of indices.""" idx = {s: i for i, s in enumerate(names)} return tuple(idx[d[s]] for s in names) def comp(f, g): """(f o g)(s) = f(g(s)); a map is the tuple of its values.""" return tuple(f[g[i]] for i in range(len(g))) def closure(gens, n): """All finite compositions of the generators, including the empty one.""" ident = tuple(range(n)) seen = {ident} frontier = [ident] while frontier: nxt = [] for f in frontier: for g in gens: h = comp(g, f) if h not in seen: seen.add(h) nxt.append(h) frontier = nxt return seen def partition(monoid, n): """Operational partition (Definition 2.2 of the Math V5 paper): s1 ~ s2 iff w(s1) = w(s2) for every non-identity map w of the monoid.""" ident = tuple(range(n)) hist = sorted(w for w in monoid if w != ident) cls = {} for s in range(n): cls.setdefault(tuple(w[s] for w in hist), []).append(s) return sorted(cls.values()) def refines(fine, coarse): return all(any(set(c) <= set(d) for d in coarse) for c in fine) def label(part, names): return '{' + ', '.join('{' + ','.join(names[i] for i in c) + '}' for c in part) + '}' def class_of(part, n): out = [None] * n for k, c in enumerate(part): for s in c: out[s] = k return out def induced(w, part, n): """The action of the map w on classes; checks that it is well defined.""" cof = class_of(part, n) res = [] for c in part: targets = {cof[w[s]] for s in c} assert len(targets) == 1, 'not well defined on classes' res.append(targets.pop()) return tuple(res) # ---------------------------------------------------------------------- # Section 1. The four-state model (Example 2.9 of the Math V5 paper) # ---------------------------------------------------------------------- print('== 1. The four-state model ==') E = tuple(range(N)) A = amap({'p': 'p', 'q': 'q', 'r': 'p', 'r2': 'p'}) B = amap({'p': 'p', 'q': 'q', 'r': 'q', 'r2': 'q'}) O = closure([A, B], N) TAG = {E: 'e', A: 'A', B: 'B'} assert O == {E, A, B} assert comp(A, B) == B and comp(B, A) == A assert comp(A, A) == A and comp(B, B) == B print('closure of {A,B} has', len(O), 'elements: e, A, B') print('A o B = B, B o A = A, A o A = A, B o B = B : verified') r = NAMES.index('r') print('witness state r: (A o B)(r) =', NAMES[comp(A, B)[r]], ', (B o A)(r) =', NAMES[comp(B, A)[r]]) assert comp(A, B)[r] != comp(B, A)[r] PI_O = partition(O, N) print('partition PiO =', label(PI_O, NAMES)) assert PI_O == [[0], [1], [2, 3]] subs = [{E}, {E, A}, {E, B}, {E, A, B}] equal_to_PiO = [] for sub in subs: assert all(comp(f, g) in sub for f in sub for g in sub) part = partition(sub, N) print(' submonoid', sorted(TAG[f] for f in sub), '->', label(part, NAMES)) if part == PI_O: equal_to_PiO.append(sub) assert equal_to_PiO == [{E, A, B}] print('only the whole monoid reaches PiO: Cmin = O') # ---------------------------------------------------------------------- # Section 2. Exclusion: no commutative target carries both A and B # ---------------------------------------------------------------------- print() print('== 2. Composition-preserving maps of {e,A,B} into T(n) ==') def exclusion_count(n): ident = tuple(range(n)) T = list(itertools.product(range(n), repeat=n)) idem = [t for t in T if comp(t, t) == t] homs = [(a, b) for a in idem for b in idem if comp(a, b) == b and comp(b, a) == a] faithful = [(a, b) for a, b in homs if len({ident, a, b}) == 3] commuting = [(a, b) for a, b in homs if comp(a, b) == comp(b, a)] comm_faithful = [(a, b) for a, b in commuting if len({ident, a, b}) == 3] assert all(a == b for a, b in commuting) return len(T), len(homs), len(faithful), len(commuting), \ len(comm_faithful), faithful def orbits(pairs, n): perms = list(itertools.permutations(range(n))) def conj(p, f): inv = [0] * n for i, x in enumerate(p): inv[x] = i return tuple(p[f[inv[i]]] for i in range(n)) seen, count = set(), 0 for pr in pairs: if pr in seen: continue count += 1 for p in perms: seen.add((conj(p, pr[0]), conj(p, pr[1]))) return count print(' n |T(n)| homs faithful commuting commuting&faithful') faithful3 = None for n in (2, 3, 4): t, h, f, c, cf, fl = exclusion_count(n) print('%2d %7d %5d %9d %10d %19d' % (n, t, h, f, c, cf)) assert cf == 0 if n == 2: assert f == 0 if n == 3: faithful3 = fl assert f > 0 print('no commuting image is faithful: psi(A) = psi(B) whenever the image commutes') print('faithful images need n >= 3 points; on n = 3 the number of orbits under') print('relabelling is', orbits(faithful3, 3)) assert orbits(faithful3, 3) == 1 # the two submonoids {e,A} and {e,B} are each faithful in a commutative target mult = {(x, y): x * y for x in (0, 1) for y in (0, 1)} for name, g in (('A', A), ('B', B)): psi = {E: 1, g: 0} assert all(psi[comp(f, h)] == mult[(psi[f], psi[h])] for f in psi for h in psi) assert len(set(psi.values())) == 2 print('submonoid {e,%s} -> ({0,1}, x): composition-preserving and injective' % name) joint = [] for a in (0, 1): for b in (0, 1): psi = {E: 1, A: a, B: b} if all(psi[comp(f, h)] == mult[(psi[f], psi[h])] for f in psi for h in psi): joint.append((a, b)) print('joint maps of {e,A,B} into ({0,1}, x):', joint, '-> psi(A) = psi(B) in each') assert all(a == b for a, b in joint) # ---------------------------------------------------------------------- # Section 3. The Kennard inequality as a relation between two distributions # ---------------------------------------------------------------------- print() print('== 3. Spreads of position and momentum distributions (hbar = 1) ==') NG = 2 ** 15 X = np.linspace(-60.0, 60.0, NG, endpoint=False) DX = X[1] - X[0] K = np.fft.fftshift(2 * np.pi * np.fft.fftfreq(NG, d=DX)) DK = K[1] - K[0] def spreads(psi): px = np.abs(psi) ** 2 px = px / (px.sum() * DX) mx = (X * px).sum() * DX sx = np.sqrt((((X - mx) ** 2) * px).sum() * DX) pk = np.abs(np.fft.fftshift(np.fft.fft(psi))) ** 2 pk = pk / (pk.su