Simulated optics experiment/Data analysis
In this task, you will write a program to analyze the "raw data" outputted by one of the Simulated optics experiment/Simulator implementations. The analysis will estimate the following numbers:
- Four correlation coefficients: one for each of the four possible combinations of the two polarizing beam splitter angles. These measure the interrelatedness of light detection events on the two sides of the experiment.
- A CHSH contrast, which is derived from the correlation coefficients.
The estimated CHSH contrast is what we are really interested in, because what we intend to show is that it contradicts what many physicists believe.
Quantum mechanics predicts a CHSH contrast of approximately . The Simulated optics experiment/Simulator simulation will be shown (by our analysis) to have a CHSH contrast very close to that. Note that our simulation does not employ any quantum mechanics, but instead simulates light "classically". Also our simulation clearly involves only causation that in each instance takes a finite amount of forward-moving time. That is, there is no "instantaneous action at a distance".
The prevailing view in physics, however, is that a CHSH contrast greater than 2 (which we certainly achieve) is possible only with quantum mechanics, and also that taking measurements on one side of the apparatus "instantaneously" determines what the measurements will be on the other side. Although quantum mechanics actually has no concept of "causation", this "determination" is often described as being "instantaneous action at a distance".
Thus, we are left with a conundrum: we clearly get a CHSH contrast not only greater than 2, but in fact very close to the theoretical value that quantum mechanics predicts. This is, in fact, a validation of the quantum mechanical mathematics: the mathematics is producing the correct result for this kind of experiment. On the other hand, the strong prevailing view in physics is that this cannot be happening if the physics involved is "classical"--which our simulated physics very much is. The prevailing view is that experiments similar to ours prove that "instantaneous action at a distance" is a real thing that exists. One sometimes sees such "proof" touted in the popular media.
I leave it to each individual to think about that conundrum and come to their own opinions. I am not a physicist and probably neither are you, so we can think whatever we want, and no one cares. But we likely are both computer programmers. What we mainly want to do here is demonstrate the use of computers to simulate physical events and analyze the data generated.
You will write a program to perform the mathematical data analysis described in the open access paper
A. F. Kracklauer, ‘EPR-B correlations: non-locality or geometry?’, J. Nonlinear Math. Phys. 11 (Supp.) 104–109 (2004). https://doi.org/10.2991/jnmp.2004.11.s1.13
The program will read the raw data that was outputted by any of the Simulated optics experiment/Simulator implementations. The Python program below can serve as a reference implementation.
The analysis proceeds as follows.
- Read in the raw data. You do not have to retain the order of the data lines. In other words, you can, if you wish, store the data in a set structure.
- For each of the data lines, if its first entry is a "1", then swap the last two entries with each other, and do the same with the two entries before them. This is to account for the difference in geometry: the original light pulses are rotated 90° with respect to the apparatus, relative to if the first entry were a "0".
- Split the data into four groups, based on the values of the second and third line entries. In other words, one group for lines that look like , one for lines that look like , one for lines that look like , and one for lines that look like . Thus each group corresponds to a particular setting of the two polarizing beam splitters.
- Separately compute a correlation coefficient for each group. This is done as follows.
- Let equal the total number of lines in a group.
- Let equal the number of lines that have a "1" in the fourth entry. This is the number of detections by one of the light detectors on the left side.
- Let equal the number of lines that have a "1" in the fifth entry. This is the number of detections by the other light detector on the left side.
- Add up similar numbers for the right side: for the sixth entry in a line, and for the seventh entry.
- Compute the following numbers: , , , and . These numbers represent an estimate of the orientations of the two beam splitters, by inference from detection events in the light detectors.
- Compute and . These are angle difference formulas from trigonometry. We are "eliminating the coordinate system".
- Compute . This is the correlation coefficient for the group, estimated by inference from detection events.
- Designate each of the four correlation coefficients according to which group it is for. The Python example, for instance, refers to them as
kappaL1R1,kappaL1R2,kappaL2R1, andkappaL2R2. - Compute the estimated CHSH contrast:
-kappaL1R1 + kappaL1R2 + kappaL2R2 + kappaL2R2. - Display the number of "pulse pair events" that were simulated, the four correlation coefficients, and the estimated CHSH contrast. Also display the theoretical value of the CHSH contrast () and the difference between the estimated CHSH contrast and the theoretical value. Also display what we will call the CHSH violation: the difference between the estimated CHSH contrast and the number 2. Any value significantly greater than zero seems to be supposed to mean that the simulation is inherently "quantum mechanical" and involves "instantaneous action at a distance". But you can decide for yourself whether it really means that. Just do the calculations and print them. One should get an estimated CHSH contrast that is close to the theoretical value, and thus a relatively "huge" CHSH violation of about +0.8.
Here is a snapshot of that contains a thought experiment I have been working on: http://web.archive.org/web/20230529223105/https://crudfactory.com/Bell-assumes-his-conclusion.pdf The thought experiment concerns the same subject as this task, but more directly addresses the conundrum. It aims to illustrate the fallaciousness (despite their widespread acceptance by people regarded as "experts") of certain arguments underlying the conundrum, and thus to resolve the technical aspects of the conundrum. Whether it succeeds is up to you to decide. I am just a computer programmer, after all. And, even if I succeed in resolving the technical aspects of the conundrum, I have barely touched on the social aspects of it. Nevertheless, the thought experiment begs to be computer-animated, and I am not that kind of a programmer.
For extra "credit" (in the form of contribution to the community), write an animation or animations of the thought experiment.
--Chemoelectric (talk) 22:50, 29 May 2023 (UTC)
Python
The program takes one optional command line argument: the filename of the raw data saved by one of the Simulated optics experiment/Simulator implementations. If the argument is omitted or is "-", the raw data is read from standard input.
#!/bin/env -S python3
#
# Reference:
#
# A. F. Kracklauer, ‘EPR-B correlations: non-locality or geometry?’,
# J. Nonlinear Math. Phys. 11 (Supp.) 104–109 (2004).
# https://doi.org/10.2991/jnmp.2004.11.s1.13 (Open access, CC BY-NC)
#
import sys
from math import atan2, cos, floor, pi, radians, sin, sqrt
class PulseData():
'''The data for one light pulse.'''
def __init__(self, logS, logL, logR, detectedL1, detectedL2,
detectedR1, detectedR2):
self.logS = logS
self.logL = logL
self.logR = logR
self.detectedL1 = detectedL1
self.detectedL2 = detectedL2
self.detectedR1 = detectedR1
self.detectedR2 = detectedR2
def __repr__(self):
return ("PulseData(" + str(self.logS) + ", "
+ str(self.logL) + ", "
+ str(self.logR) + ", "
+ str(self.detectedL1) + ", "
+ str(self.detectedL2) + ", "
+ str(self.detectedR1) + ", "
+ str(self.detectedR2) + ")")
def swap_L_channels(self):
'''Swap detectedL1 and detectedL2.'''
(self.detectedL1, self.detectedL2) = \
(self.detectedL2, self.detectedL1)
def swap_R_channels(self):
'''Swap detectedR1 and detectedR2.'''
(self.detectedR1, self.detectedR2) = \
(self.detectedR2, self.detectedR1)
def swap_LR_channels(self):
'''Swap channels on both right and left. This is done if the
light source was (1,90°) instead of (1,0°). For in that case
the orientations of the polarizing beam splitters, relative to
the light source, is different by 90°.'''
self.swap_L_channels()
self.swap_R_channels()
def split_data(predicate, data):
'''Split the data into two subsets, according to whether a set
item satisfies a predicate. The return value is a tuple, with
those items satisfying the predicate in the first tuple entry, the
other items in the second entry.
'''
subset1 = {x for x in data if predicate(x)}
subset2 = data - subset1
return (subset1, subset2)
def adjust_data_for_light_pulse_orientation(data):
'''Some data items are for a (1,0°) light pulse. The others are
for a (1,90°) light pulse. Thus the light pulses are oriented
differently with respect to the polarizing beam splitters. We
adjust for that distinction here.'''
data0, data90 = split_data(lambda item: item.logS == 0, data)
for item in data90:
item.swap_LR_channels()
return (data0 | data90) # Set union.
def split_data_according_to_PBS_setting(data):
'''Split the data into four subsets: one subset for each
arrangement of the two polarizing beam splitters.'''
dataL1, dataL2 = split_data(lambda item: item.logL == 0, data)
dataL1R1, dataL1R2 = \
split_data(lambda item: item.logR == 0, dataL1)
dataL2R1, dataL2R2 = \
split_data(lambda item: item.logR == 0, dataL2)
return (dataL1R1, dataL1R2, dataL2R1, dataL2R2)
def compute_correlation_coefficient(angleL, angleR, data):
'''Compute the correlation coefficient for the subset of the data
that corresponding to a particular setting of the polarizing beam
splitters.'''
# We make certain the orientations of beam splitters are
# represented by perpendicular angles in the first and fourth
# quadrant. This restriction causes no loss of generality, because
# the orientation of the beam splitter is actually a rotated "X".
assert (all(0 <= x and x < 90 for x in (angleL, angleR)))
perpendicularL = angleL - 90 # In Quadrant 4.
perpendicularR = angleR - 90 # In Quadrant 4.
# Note that the sine is non-negative in Quadrant 1, and the cosine
# is non-negative in Quadrant 4. Thus we can use the following
# estimates for cosine and sine. This is Equation (2.4) in the
# reference. (Note, one can also use Quadrants 1 and 2 and reverse
# the roles of cosine and sine. And so on like that.)
N = len(data)
NL1 = 0
NL2 = 0
NR1 = 0
NR2 = 0
for item in data:
NL1 += item.detectedL1
NL2 += item.detectedL2
NR1 += item.detectedR1
NR2 += item.detectedR2
sinL = sqrt(NL1 / N)
cosL = sqrt(NL2 / N)
sinR = sqrt(NR1 / N)
cosR = sqrt(NR2 / N)
# Now we can apply the reference's Equation (2.3).
cosLR = (cosR * cosL) + (sinR * sinL)
sinLR = (sinR * cosL) - (cosR * sinL)
# And then Equation (2.5).
kappa = (cosLR * cosLR) - (sinLR * sinLR)
return kappa
def read_raw_data(filename):
'''Read the raw data. Its order does not actually matter, so we
return the data as a set.'''
def make_record(line):
x = line.split()
record = PulseData(logS = int(x[0]),
logL = int(x[1]),
logR = int(x[2]),
detectedL1 = int(x[3]),
detectedL2 = int(x[4]),
detectedR1 = int(x[5]),
detectedR2 = int(x[6]))
return record
def read_data(f):
num_pulses = int(f.readline())
data = set()
for i in range(num_pulses):
data.add(make_record(f.readline()))
return data
if filename != "-":
with open(filename, "r") as f:
data = read_data(f)
else:
data = read_data(sys.stdin)
return data
if __name__ == '__main__':
if len(sys.argv) != 1 and len(sys.argv) != 2:
print("Usage: " + sys.argv[0] + " [RAW_DATA_FILE]")
sys.exit(1)
raw_data_filename = (sys.argv[1] if len(sys.argv) == 2 else "-")
# Polarizing beam splitter orientations commonly used in actual
# experiments. These must match the values used in the simulation
# itself. They are by design all either zero degrees or in the
# first quadrant.
anglesL = (0.0, 45.0)
anglesR = (22.5, 67.5)
assert (all(0 <= x and x < 90 for x in anglesL + anglesR))
data = read_raw_data(raw_data_filename)
data = adjust_data_for_light_pulse_orientation(data)
dataL1R1, dataL1R2, dataL2R1, dataL2R2 = \
split_data_according_to_PBS_setting(data)
kappaL1R1 = \
compute_correlation_coefficient (anglesL[0], anglesR[0],
dataL1R1)
kappaL1R2 = \
compute_correlation_coefficient (anglesL[0], anglesR[1],
dataL1R2)
kappaL2R1 = \
compute_correlation_coefficient (anglesL[1], anglesR[0],
dataL2R1)
kappaL2R2 = \
compute_correlation_coefficient (anglesL[1], anglesR[1],
dataL2R2)
chsh_contrast = -kappaL1R1 + kappaL1R2 + kappaL2R2 + kappaL2R2
# The nominal value of the CHSH contrast for the chosen polarizer
# orientations is 2*sqrt(2).
chsh_contrast_nominal = 2 * sqrt(2.0)
print()
print(" light pulse events %9d" % len(data))
print()
print(" correlation coefs")
print(" %2d° %2d° %+9.6f" % (anglesL[0], anglesR[0],
kappaL1R1))
print(" %2d° %2d° %+9.6f" % (anglesL[0], anglesR[1],
kappaL1R2))
print(" %2d° %2d° %+9.6f" % (anglesL[1], anglesR[0],
kappaL2R1))
print(" %2d° %2d° %+9.6f" % (anglesL[1], anglesR[1],
kappaL2R2))
print()
print(" CHSH contrast %+9.6f" % chsh_contrast)
print(" 2*sqrt(2) = nominal %+9.6f" % chsh_contrast_nominal)
print(" difference %+9.6f" % (chsh_contrast -
chsh_contrast_nominal))
# A "CHSH violation" occurs if the CHSH contrast is >2.
# https://en.wikipedia.org/w/index.php?title=CHSH_inequality&oldid=1142431418
print()
print(" CHSH violation %+9.6f" % (chsh_contrast - 2))
print()
- Output:
An example using data from the Python implementation of Simulated optics experiment/Simulator.
light pulse events 100000
correlation coefs
0° 22° -0.707806
0° 67° +0.705415
45° 22° +0.712377
45° 67° +0.718882
CHSH contrast +2.850985
2*sqrt(2) = nominal +2.828427
difference +0.022558
CHSH violation +0.850985