# Help me understand a simplified CHSH (Bell's) experiment

1. Apr 12, 2014

### midix

Hi all.

At first, I'm not a physicist, I'm a programmer, and English is not my native language, that's why something in my text might sound not quite right.

While researching various quantum entanglement experiments (just a hobby) I found one great article written by supposedly acknowledged physicist Nick Herbert. I don't know much about him, thus if his article is entirely wrong, tell me and I'll close the topic and be done with it.
Here you go:
http://quantumtantra.com/bell2.html

At first I tried to implement his so called SPOT detector in a simple C# program to simulate how it would work with normal "local" behavior. I'm using a random generator and it seems sufficient to achieve statistically meaningful results, which match my expectations. But still there are some things which I'm not sure about and I'd like to ask for help.

Here are my questions:

1) the SPOT is built the way that it detects if a photon is polarized vertically (result is 1) or horizontally (result is 0). Now, if we detect a stream of vertically polarized photons with the SPOT detector and then turn it 45 degrees, we should detect no photons at all because all of them are vertically polarized and there should be no 45 degrees polarized photons. In this case, the SPOT should just completely ignore the photon, and it goes by undetected at all. But Nick Herbert says:

It seems to me, Nick forgot some important details. I have a vague guess what it might be but it would be great if someone could confirm my suspicions with a definite and simple answer:
How does the SPOT detector decide whether a photon is vertically or horizontally polarized and how can it detect any of the vertically polarized photons if the SPOT is turned by 45 degrees?

For example, I have the SPOT turned 0 degrees. In what range of degrees a photon will be detected as being horizontally polarized and in what range it will be detected if vertically polarized?

2) To go on with his simplified experiment, Nick says:

What exactly is polarization of these phase-entangled photons in the scope of this particular experiment? Do I understand correctly, that they are both polarized completely randomly so we don't know the polarization beforehand?

3) There is a nice graph with values for non-local results of the experiment in Nick's article and he explains it as follows:
But he does not explain one important detail - why the value is Cosine Squared (Angle)?
Can this formula be demonstrated using simple math example and statistics without referring to quantum mechanics formulas? If we assume that (in a simplified understanding of quantum mechanics) the rotation of Alice's SPOT has effect on results detected by Bob's SPOT (and vice versa - who ever of them manages to detect the entangled photon first), then how the difference
turns out to be Cosine Squared (Angle)?

For example, Alice has her SPOT at 0 degrees, and Bob has at 30 degrees. Then there comes a photon and Alice's detector gets it first. From the idea of quantum entanglement we know that at this very moment the polarization state of the other twin photon becomes determined. Then Bob receives this entangled photon. Now if they both continue receiving their photons with their detector difference of 30 degrees, how then Cosine Squared (Angle) formula relates to their results?

4) Is Nick's simplified experiment with measuring the difference just between two detectors set to 0 and 60 degree angles really good enough to prove Bell's theorem and "non-locality" of quantum entanglement? If used in real life, will it give close enough results to the values mentioned by Nick (25% mismatch at 30 degrees and 75% mismatch at 60 degrees)?

Nick's example seems much simpler than all the others I see around because other experiments often talk about three various detector positions or about spins instead of polarization, thus making things more confusing than they are presented by Nick Herbert.

Last edited: Apr 12, 2014
2. Apr 12, 2014

Welcome to PF midix!

Nick Herbert is just fine, it's known as one of the best and shortest explanations of Bell's Theorem – in fact John Bell used this example in public lectures.

This is not correct. If you run unpolarized light through a vertical polarizer, and then run this polarized light through a 45° polarizer, there will be a 50/50 chance for the light to pass through.

You can play and test different settings in this Polarizer Applet.

There are different types of polarizers and simplest is the wire-grid polarizer consisting of an array of fine parallel metallic wires. All light that pass through will be polarized perpendicular to the wires.

Unpolarized light polarized vertical

Entangled photons are not* polarized (before measurement).

*They are in a superposition of opposite polarization.

Yes, it's called Malus' law and was published in 1809, and it works for all type of polarization, including classical.

If you want to calculate the correlation between Alice & Bob, and the relative angle between them is 30°, just plug in the number; cos2(30°) = 75% correlation.

Good enough! :thumbs:

I agree, however there are other aspects in Bell's Theorem, like realism and preexisting (hidden) variables that might become somewhat clearer in the case of three detector positions.

I know there is at least one guy in this forum that comply this view, probably you will get some tips from him...

Last edited: Apr 12, 2014
3. Apr 13, 2014

### midix

It seems, for my simulation program in local-reality mode I can roughly assume that if I set receive a photon which is in range of -45 .. 45 degrees in relation to my current SPOT setting, I can set the detector to return 1 (most probably the photon is vertically polarized), but if it's out of this range then I return 0 (most probably the photon is horizontally polarized). As I understand, such simplification would work only for unpolarized light. For polarized light my simulation would be completely wrong because it would violate Malus' law.

I just tried that in my C# code, and it gives me expected results while shooting "random valued photons" at my detectors. I set the random value at the moment of photon generation, thus now my simulation behaves as if QM was wrong.

Now I have to think how to simulate correct QM behavior knowing Malus' law.

Let's say, Alice's SPOT is turned at 0 and Bob's SPOT is turned at 30 degrees.
Now Alice's SPOT is the first one to receive a photon (which is just a random value in range -90 .. 90 degrees in my simulation).

And now the tricky question is: how do I calculate what value should Bob's SPOT receive considering that his SPOT differs 30 degrees from Alice's SPOT and that after collecting multiple "photons" I need to get the result as squared cos of 30 degrees?
Now I know that I can calculate intensity of entire stream of photons using Malus' law but how do I adjust individual "photon values" in my program to force my values to converge to the required result?

Finally, one question to check if I understood the idea correctly.
Can we say that the fact that Malus' law works, is valid evidence of non-locality and violation of Bell's theorem? If there was no non-locality then photon polarization would behave according to "normal" statistics laws and there would be no Malus' law at all, right?

Last edited: Apr 13, 2014
4. Apr 13, 2014

First, to avoid misunderstanding; all commercial computers today are classical in its operation. The only way to mimic Herbert's example is to 'cheat' in one way or another, and the simplest way is to implement a "faster than light channel" between the two detectors, that propagates data about current polarizer settings.

For Herbert's example, I would do it something like this:
• Set timer tmrSource to trigger at a suitable interval, let's say one second (which would be the source sending out two entangled photons).

• When tmrSource triggers; write current time in variable timeSource and two equal random values 1 or 0 (for H/V) in variables photonA and photonB, and put this data in an (public) array arrEntanglement.

• Set timer tmrAlice and tmrBob to trigger at an interval 10 times faster than tmrSource, i.e. in this case 100 milliseconds.

• When tmrAlice triggers; check global array arrEntanglement if there is any new data available for photonA, if there are, read time and value for photonA into an (private) array and erase (nil) the value of photonA in arrEntanglement.

• When tmrBob triggers; same as for tmrAlice, but handle photonB instead.

• Time to rock! When tmrAlice or tmrBob trigger, you are supposed to fulfill the measurement of the received photon. But how do we do that? Well, we must define another (public) array arrMeasurement where Alice or Bob register timeSource + ('local' time) timeLocal + their measurement setting. Note: this is cheating since IRL Alice and Bob are not able to communicate FTL!

• When tmrAlice or tmrBob triggers for a measurement they will first check arrMeasurement to see if there's "anything going on", i.e. if there is existing data (timeLocal) within the span; current time - trigger time (100 ms). If there is an ongoing measurement, Alice or Bob has to abide to be "Idler", if not, Alice or Bob will be "Master" and can perform the measurement without considerations about the other.

• Besides above, we must also set a value for Alice and Bob's polarizer when tmrAlice or tmrBob triggers. Just randomly pick one of the values 0, 30, 60 or 90 and put it in polarizerA (or polarizerB for Bob).

• Actions for "Master": Just take the photon value and let I go straight through the polarizer, and register the value of photonA (or photonB for Bob) in arrMeasurement; + timeSource + timeLocal + polarizerA (or polarizerB for Bob).

• Actions for "Idler": Check the value of polarizerB (or polarizerA for Bob) and calculate the relative angle, i.e. if polarizerA = 90° and polarizerB = 30°, relative angle equals 90 - 30 = 60°. Plug in this value into Malus' law cos2(60°) = 25% match. If photonB (or photonA for Bob) was 1, we know we have to pick a random value that'll give 25% ones and 75% zeros (I let you figure out that one yourself ;), and vice versa if photonB (or photonA for Bob) was 0. Register the value of photonA (or photonB for Bob) in arrMeasurement; + timeSource + timeLocal + polarizerA (or polarizerB for Bob).

After running a number of (predefined) triggers of tmrSource; it's time to compare data in arrMeasurement. All rows that have equal timeSource value are entangled photons and they should confirm Bell's non-locality theorem!

Why?

Because we have cheated, in a real experiment there is no possibility for Alice and Bob to know the other parts polarizer settings by classical means.

Good luck!

Note1: This is a "quick-and-dirty" solution and there are probably some errors, but I hope you'll get the basics and a good start; you most probably have to 'refine' the functionality when coding...

Note2: This obviously requires threading, but it can be solved without. I selected this approach to get as close to the real thing as possible.

Note3: Why variable timeSource? Because in a real experiment most photons will be 'normal' not entangled photons, and it's only by comparing the timestamp you will know that they left the source at same time (as a pair). You could, if you wish to get more 'realism', extend the source with higher speed (i.e. shorter interval then tmrAlice and tmrBob) and a mixing of normal and entangled photons... but I recommend making it work as above, first...

No, Malus' law is a classical law; it has nothing to do with non-locality. The key point in Bell's theorem is that somehow there seems to be some sort of 'influence' between the two entangled photons, which make them produce correlated results that are compatible with Malus' law, but the whole process cannot be explained by classical means only.

5. Apr 13, 2014

### midix

Yes, your description mostly matches what I've implemented, only I left out time differences and threads - I have just one timer which calls Alice's detector and then Bob's detector. In a more fair experiment they should come in random order, or else it means that Alice is closer to the light source and always gets a photon before Bob, which is not fair :)

Oh, this is EXACTLY where I got stuck - how to calculate such value which will give the required result. But as you formulated the problem that way, now I see it more clearly and I remembered some algorithms for putting weight on random values to force randomness to the needed direction.

Thank you again.

6. Apr 13, 2014

Yeah, threading could be a little tricky... but who said (digital) life should be simple? I haven't tested this (of course) but I do think that tmrAlice and tmrBob will be 'wiggling' back and forth in order, since there will be different workload depending on who is "Idler" or "Master"... if not, I just throw in some random junk that would make one thread suffer badly!

It's quite simple:

Code (Text):
Random random = new Random();
int rndNr = random.Next(1, 101);
int rndWeight = 25;
int rndPolarization = 1;

if (rndNr > rndWeight)
{
rndPolarization = 0;
}
No worries mate and good luck!