Coming Soon!

[FrediFizzx]

Take your final, stable version and run a short test with m = 30 or 40. Now compare the input lists outA and outB to the output list outA5 and outB5. You will find that nearly each time f1 appears in one of the outA measurements, the same outB5 measurement will have the detector value with a changed sign. The same thing happens with the outB and outA5 lists. I said nearly because sometimes this doesn't happen, but it almost always does.

This could be done with much simpler programming. It would be interesting to see how this sign flip affects the CHSH values and final plot.

You have do that for proper matching of constrained events vs. non-constrained. If the signs are the same it doesn't change. This was the most simple local programming I could figure out. If you don't do it I believe the final plot will be straight lines.
.

Your program is doing the sign flips. This is a non-local calculation since Alice has to have information from Bob about his experiments in order to change the signs. The non-locality is clear in the way your program uses the routine Intersection. You should read up on what it is doing. The arguments for Intersection are outA1 (Alice's experiments) and listbd (Bob's experiment numbers). This uses information from Bob's experiments to change Alice's experiments. That's non-local.

It doesn't matter at this point since only the trial numbers are being matched by the intersection function. In a real experiment they use time tags to do the matching. In this thought experiment we have the luxury of actually tagging every particle with the trial number.
.

[Joy Christian]

Take your final, stable version and run a short test with m = 30 or 40. Now compare the input lists outA and outB to the output list outA5 and outB5. You will find that nearly each time f1 appears in one of the outA measurements, the same outB5 measurement will have the detector value with a changed sign. The same thing happens with the outB and outA5 lists. I said nearly because sometimes this doesn't happen, but it almost always does.

This could be done with much simpler programming. It would be interesting to see how this sign flip affects the CHSH values and final plot.

You have do that for proper matching of constrained events vs. non-constrained. If the signs are the same it doesn't change. This was the most simple local programming I could figure out. If you don't do it I believe the final plot will be straight lines.
.

Your program is doing the sign flips. This is a non-local calculation since Alice has to have information from Bob about his experiments in order to change the signs. The non-locality is clear in the way your program uses the routine Intersection. You should read up on what it is doing. The arguments for Intersection are outA1 (Alice's experiments) and listbd (Bob's experiment numbers). This uses information from Bob's experiments to change Alice's experiments. That's non-local.

It doesn't matter at this point since only the trial numbers are being matched by the intersection function. In a real experiment they use time tags to do the matching. In this thought experiment we have the luxury of actually tagging every particle with the trial number.

It wouldn't matter if your program simply reads off the outcomes A and B after matching their trial numbers. But your program actually changes the outcomes after matching their trial numbers. That is what makes your prescription nonlocal. It would be a real challenge to convince anyone that that kind of change in outcomes is not nonlocal.
.

[FrediFizzx]

It doesn't matter at this point since only the trial numbers are being matched by the intersection function. In a real experiment they use time tags to do the matching. In this thought experiment we have the luxury of actually tagging every particle with the trial number.

It wouldn't matter if your program simply reads off the outcomes A and B after matching their trial numbers. But your program actually changes the outcomes after matching their trial numbers. That is what makes your prescription nonlocal. It would be a real challenge to convince anyone that that kind of change in outcomes is not nonlocal.
.

Well, you have to understand the process to see why it is local. That is why I exposed my black box related to Gill's impossibility challenge. I never use information from B to change the signs of the A non-constrained events to make them constrained. Likewise for B. I think I already explained the process to you via email. Let me know if I need to explain again.
.

[Joy Christian]

It doesn't matter at this point since only the trial numbers are being matched by the intersection function. In a real experiment they use time tags to do the matching. In this thought experiment we have the luxury of actually tagging every particle with the trial number.

It wouldn't matter if your program simply reads off the outcomes A and B after matching their trial numbers. But your program actually changes the outcomes after matching their trial numbers. That is what makes your prescription nonlocal. It would be a real challenge to convince anyone that that kind of change in outcomes is not nonlocal.
.

Well, you have to understand the process to see why it is local. That is why I exposed my black box related to Gill's impossibility challenge. I never use information from B to change the signs of the A non-constrained events to make them constrained. Likewise for B. I think I already explained the process to you via email. Let me know if I need to explain again.

Clearly, I have not understood your process. John Reed also seems to have failed to unpack your process. As far as I can see, there are no unconstrained events at all. The events are either constrained by the cosine function or by the sine function, and that covers all possible events. If I can understand your process, then I can easily write down the analytical functions A(a, h) and B(b, h). If such functions can be written down explicitly (as I have done for my 3-sphere and 7-sphere models), then no one can claim that your model is nonlocal. And this applies to all the claimed models in this forum. Failure to write down the local functions A(a, h) and B(b, h) for a claimed model is a clear indication that some form of nonlocality has been smuggled in.
.

[FrediFizzx]

Ok, here we go. A step by step explanation of the matching section.

1. First 4 lines separate the constrained events (those less than the HV) from the non-constrained events so that we have,
outA1 = non-constrained
outA2 = constrained
outB1 = non-constrained
outB2 = constrained

2. Next 4 lines match the trial numbers of outA1 and outB1 and produce two new lists listAa1 and listBb1 that are events where the trial numbers match. This is basically the same as experimenters do when they match time tags of events. Here we have the luxury of tagging with trial numbers.

3. Next 4 lines compares outA1 with listAa1 and selects the events where the trial numbers didn't match and produces listAa3. Completely local.

4. Next 4 lines does the same thing for outB1 and listBb1 to produce listBb3.

5. The next set of lines down to listAa7 is a bit complicated. I'm comparing the out A result from listAa3 with what the result would have been if constrained from listAa3 and makes listAa7. If it is different it is changed. Completely local.

6. The next set of lines down to listBb7 does the same thing from listBb3.

7. The next 4 lines just puts it all together and sorts the lists and gives outA5 and outB5. Completely local.

8. The last line just extracts the info from outA5 and outB5 to feed to the analysis. Completely local.
.

[Joy Christian]

.
Ok. Thanks. That is much easier to understand. I will try to write down analytical functions A(a, h) and B(b, h). That ought to be possible.
.

[Joy Christian]

.
So I think that your outA5 and outB5 ought to be written out as analytical functions outA5(a, h) and outB5(b, h), where h is some elaborate function that fully accounts for your matching process, in addition to the hidden variable lambda. That is the task. But some information is still missing from what you have explained above. Therefore I am unable to write down these functions. What is missing is an analytical formula that tells us which trial numbers didn't match.
.

[FrediFizzx]

.
So I think that your outA5 and outB5 ought to be written out as analytical functions outA5(a, h) and outB5(b, h), where h is some elaborate function that fully accounts for your matching process, in addition to the hidden variable lambda. That is the task. But some information is still missing from what you have explained above. Therefore I am unable to write down these functions. What is missing is an analytical formula that tells us which trial numbers didn't match.
.

Well, too much brain fog right now but let's take a stab at it. I should have labelled those outputs as A and B which I can easily do. So, we will have A_n and B_n where n is the trial number. So, I guess you need something like this,

If n_A != n_B, then what?

That is all I can do right now.
.

[FrediFizzx]

Oops, that is not exactly right. The A_n and B_n outcomes are in that last line in the matching section which I have labelled A1 and B1. So, we will switch those to call them A and B with A and B from the Do loops and the Do loops will be A1 and B1. Then your h in A(a, h) needs to be A(a, h1) because h is not the same for A and B. So, h1 = the HV, C1, AA and h2 = the HV, C2, BB. I suppose since I'm recording the trial numbers, you could add to that n_A and n_B. Since λ is common for both, A(a, λ, h1) and B(b, λ, h2).

When I feel a little better I will try the analytic form for the first intersection process where we are using n_A = n_B.
.

[Joy Christian]

.
By the way, calling some events constrained events and the rest non-constrained events is confusing. They are all constrained by lambda, albeit differently. It is better to call them something like "those that are less than lambda" and "those that are more than lambda" because you are counting ALL events. None are missed.
.

[FrediFizzx]

.
By the way, calling some events constrained events and the rest non-constrained events is confusing. They are all constrained by lambda, albeit differently. It is better to call them something like "those that are less than lambda" and "those that are more than lambda" because you are counting ALL events. None are missed.
.

Hmm... I thought I got that from your papers.
.

[Joy Christian]

.
By the way, calling some events constrained events and the rest non-constrained events is confusing. They are all constrained by lambda, albeit differently. It is better to call them something like "those that are less than lambda" and "those that are more than lambda" because you are counting ALL events. None are missed.
.

Hmm... I thought I got that from your papers.

In my papers, the terminology is fine because only constrained states are actually existing states. But there too, now that I think about it, it is not the best terminology.

Also, the functions we are looking for are of the form A(a, g, lambda) and B(b, h, lambda), where only lambda is shared between Alice and Bob. And g is just your h1 and h is your h2.

If we can write out your prescription like this, then no one will be able to claim it to be nonlocal or raise any other objection. In fact, the Bell-fanatics will all disappear from the forum.
,

[FrediFizzx]

.
By the way, calling some events constrained events and the rest non-constrained events is confusing. They are all constrained by lambda, albeit differently. It is better to call them something like "those that are less than lambda" and "those that are more than lambda" because you are counting ALL events. None are missed.
.

Hmm... I thought I got that from your papers.

In my papers, the terminology is fine because only constrained states are actually existing states. But there too, now that I think about it, it is not the best terminology.

Also, the functions we are looking for are of the form A(a, g, lambda) and B(b, h, lambda), where only lambda is shared between Alice and Bob. And g is just your h1 and h is your h2.

If we can write out your prescription like this, then no one will be able to claim it to be nonlocal or raise any other objection. In fact, the Bell-fanatics will all disappear from the forum.

Ok, here we go for the first matching function,

If[n_A = n_B, then listAa1 = outA1 and/or listBb1 = outB1].

Second non-matching function,

If[n_outA1 != n_listAa1, then listAa3 = outA1]

Third,

If[n_outB1 != n_listBb1, then listBb3 = outB1]

I think that covers those intersection functions.
.

[FrediFizzx]

I'm on a roll here. Let's try the next sections,

If[A2_listAa3 = A5_listAa3, then A2 = A2, else A2 = A5]

If[B2_listBb3 = B5_listBb3, then B2 = B2, else B2 = B5]

Make new lists listAa7 and listBb7 from listAa3 and listBb3.

Then the rest is putting the appropriate lists together and sorting.

I suppose this is like pseudo-code.
.

[jreed]

Since you apparently haven't done the test with a small number of experiments, here are the results of what I got when I did this. This is the final Mathematica version with m = 30. I took the difference between the output of the "black box", outA5, and the input, outA. Any differences will show up as a non-zero entry. Sign flips of the detector will show up as +/-2 in the second entry. The second set are the records of outB. Notice that the sign flips in the outA records occur only at experiment numbers where an f2 is present in outB, showing a non-local calculation is being done. You can keep talking about local computations only, but the results don't bear this out.

In[115]:= outA5 - outA

Out[115]= {{0, 0, 0, f1 - g1, 0}, {0, 0, 0, 0, 0}, {0, 0, 0, 0,
0}, {0, 0, 0, 0, 0}, {0, 0, 0, 0, 0}, {0, 0, 0, 0, 0}, {0, -2, 0,
f1 - g1, 0}, {0, 0, 0, 0, 0}, {0, -2, 0, f1 - g1, 0}, {0, 0, 0, 0,
0}, {0, 0, 0, 0, 0}, {0, 0, 0, 0, 0}, {0, 0, 0, 0, 0}, {0, 0, 0, 0,
0}, {0, 0, 0, 0, 0}, {0, 0, 0, 0, 0}, {0, 0, 0, 0, 0}, {0, 0, 0, 0,
0}, {0, 0, 0, 0, 0}, {0, 0, 0, 0, 0}, {0, -2, 0, f1 - g1, 0}, {0, 0,
0, 0, 0}, {0, 0, 0, 0, 0}, {0, 0, 0, 0, 0}, {0, 0, 0, 0, 0}, {0, 0,
0, 0, 0}, {0, 0, 0, 0, 0}, {0, 0, 0, 0, 0}, {0, 0, 0, 0, 0}, {0, 0,
0, 0, 0}}

In[116]:= outB

Out[116]= {{45, 1, 1, f2, 1}, {81, -1, 2, g2, -1}, {211, -1, 3, g2,
1}, {220, 1, 4, g2, 1}, {237, -1, 5, g2, -1}, {139, -1, 6, g2,
1}, {115, -1, 7, f2, -1}, {165, 1, 8, g2, -1}, {349, -1, 9,
f2, -1}, {163, -1, 10, g2, -1}, {197, -1, 11, g2, -1}, {330, -1, 12,
g2, -1}, {323, -1, 13, g2, 1}, {172, -1, 14, g2, -1}, {274, 1, 15,
g2, 1}, {204, -1, 16, g2, 1}, {139, -1, 17, g2, 1}, {38, -1, 18,
g2, -1}, {269, 1, 19, g2, -1}, {84, -1, 20, g2, -1}, {294, -1, 21,
f2, -1}, {234, 1, 22, g2, -1}, {102, -1, 23, g2, -1}, {93, -1, 24,
g2, -1}, {172, 1, 25, g2, 1}, {262, 1, 26, g2, 1}, {273, 1, 27,
g2, -1}, {291, -1, 28, g2, -1}, {340, -1, 29, g2, 1}, {118, 1, 30,
g2, 1}}

[FrediFizzx]

Nope. You are doing the wrong process. That doesn't prove non-locality.
.

[gill1109]

Nope. You are doing the wrong process. That doesn't prove non-locality.

The simple proof of non-locality, for me, is that you violated Bell’s inequality (originally proven by Boole in the 1850’s)!

I would also prove it by random testing if only you (Fred) would give us a version which was written in R or Python, and allowed the user to specify the settings and set the seed. Then I would quickly find a sequence of inputs for Alice and Bob such that if I change Bob’s n’th input then Alice’s n’th output changes, even though the seed is the same and all the other inputs are the same; the first n - 1 outputs did not change. Alice’s n’th input did not change. But changing Bob’s n’th input changed Alice’s n’th output.

This would prove that the functions A and B which Joy wants Fred to supply simply do not exist.

Such an n can be found as follows. Find a seed and use some large N and random binary inputs so we get a big violation of CHSH. Now simply use the same seed and the same inputs, running the program just for the first n trials, and testing what happens if Alice’s or Bob’s last input is changed. This will certainly find an n which disproves locality. The search can be done automatically.

[jreed]

Nope. You are doing the wrong process. That doesn't prove non-locality.
.

I won't make any further comments on your program. You are in your own world where you are able to ignore facts that don't agree with your theory and invent incorrect facts that support it.

[FrediFizzx]

Nope. You are doing the wrong process. That doesn't prove non-locality.
.

I won't make any further comments on your program. You are in your own world where you are able to ignore facts that don't agree with your theory and invent incorrect facts that support it.

Sorry, but you need to point specifically to a process in the program.
.

[FrediFizzx]

Nope. You are doing the wrong process. That doesn't prove non-locality.

The simple proof of non-locality, for me, is that you violated Bell’s inequality (originally proven by Boole in the 1850’s)!

I would also prove it by random testing if only you (Fred) would give us a version which was written in R or Python, and allowed the user to specify the settings and set the seed. Then I would quickly find a sequence of inputs for Alice and Bob such that if I change Bob’s n’th input then Alice’s n’th output changes, even though the seed is the same and all the other inputs are the same; the first n - 1 outputs did not change. Alice’s n’th input did not change. But changing Bob’s n’th input changed Alice’s n’th output.

This would prove that the functions A and B which Joy wants Fred to supply simply do not exist.

Such an n can be found as follows. Find a seed and use some large N and random binary inputs so we get a big violation of CHSH. Now simply use the same seed and the same inputs, running the program just for the first n trials, and testing what happens if Alice’s or Bob’s last input is changed. This will certainly find an n which disproves locality. The search can be done automatically.

CHSH = 2.78024! Ok, I can try that but not fully understanding it. How do I change A or B's last input?
.