"Stop Telling God What to Do, You Too": Niels Bohr's Complementarity as a Relation between Mathematical Descriptions instead of Aspects of Nature, 1924–1935
T.O.
Abstract
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