A real EPR-Bohm scenario

[minkwe]

The sign(a.e) and the sign(b.e) are wrong as I mentioned previously for A and B functions.

I don't agree that they are wrong. (b.e) is the projection of the particle "e" vector along the polarizer "b" vector. The sign of that projection determines which of the detectors the particle will go toward (D+ or D-) corresponding to (+1, -1) for the figure I posted above. The absolute value of the magnitude of that projection is used so select the states.

That is what

A(a; e, s) = +sign(cos(a*e)) if |a.e| > f(s), 0 otherwise
B(b; e, s) = -sign(cos(b*e)) if |b.e| > f(s), 0 otherwise

means. Remember that "a" and "b" are polarizer orientations freely chosen by Alice and Bob. Why are you introducing another "pol" in addition to "a" and "b"? See the diagram above. I still do not understand what you are trying to do, sorry.

[FrediFizzx]

The sign(a.e) and the sign(b.e) are wrong as I mentioned previously for A and B functions.

I don't agree that they are wrong. (b.e) is the projection of the particle "e" vector along the polarizer "b" vector. The sign of that projection determines which of the detectors the particle will go toward (D+ or D-) corresponding to (+1, -1) for the figure I posted above. The absolute value of the magnitude of that projection is used so select the states.

That is what

A(a; e, s) = +sign(cos(a*e)) if |a.e| > f(s), 0 otherwise
B(b; e, s) = -sign(cos(b*e)) if |b.e| > f(s), 0 otherwise

means. Remember that "a" and "b" are polarizer orientations freely chosen by Alice and Bob. Why are you introducing another "pol" in addition to "a" and "b"? See the diagram above. I still do not understand what you are trying to do, sorry.

I am not sure exactly what you mean by "projection". Mathematically you seem to be saying that the cos(b - e) = cos(d) = ??? what mathematically? I guess you mean that sign(cos(d)) = +/-1 is the polarizer action already. And that works in R with fixed angles but does not work in Mathematica with random angles. But I don't think that is really what is going on because the other way works for both random angles and fixed angles.

You don't have to have the sign of the "projection" determining polarizer action. The sign(cos(angle*pol)) works for both where "angle" is a or b. IOW, the polarizer function has just been separated out and is now just relying on abs(angle - e) < pi if it is + or - 1.
.

[Joy Christian]

***
Fred, Michel,

What I find mathematically and historically interesting in this new simulation are the following lines:

Code: Select all

p = function(u,v){colSums(u*v)} # polarizer function of Bell

q = function(u,v,s){ifelse(abs(p(u,v)) > f, cos(Angles), 0)}

g = function(u,v,s){p(u,v)*q(u,v,s)}   # cf. http://rpubs.com/jjc/84238

A = +sign(p(a,e))*sign(q(a,e,s))  # Alice's results A(a, e, s) = +/-1


Note that A is a function of sign(p) x sign(q). If we set f = 0 in q, then the function A reduces to just sign(p), which was the function originally proposed by Bell in 1964. So, not surprisingly, the strong correlations are contained entirely in sign(q), which has been factored out from the original A function used in this simulation.

This may have nothing to do with what Fred is suggesting, but I find it interesting that Bell's original model can be factored out in this manner as a linear background.

***

[FrediFizzx]

***
Fred, Michel,

What I find mathematically and historically interesting in this new simulation are the following lines:

Code: Select all

p = function(u,v){colSums(u*v)} # polarizer function of Bell

q = function(u,v,s){ifelse(abs(p(u,v)) > f, cos(Angles), 0)}

g = function(u,v,s){p(u,v)*q(u,v,s)}   # cf. http://rpubs.com/jjc/84238

A = +sign(p(a,e))*sign(q(a,e,s))  # Alice's results A(a, e, s) = +/-1


Note that A is a function of sign(p) x sign(q). If we set f = 0 in q, then the function A reduces to just sign(p), which was the function originally proposed by Bell in 1964. So, not surprisingly, the strong correlations are contained entirely in sign(q), which has been factored out from the original A function used in this simulation.

This may have nothing to do with what Fred is suggesting, but I find it interesting that Bell's original model can be factored out in this manner as a linear background.

***

I find that interesting also but I am trying to figure out why it doesn't work with random angles and the other way does work with abs(angle - e) < pi for both random angles and fixed angles. It remains a dang mystery.
.

[minkwe]

I am not sure exactly what you mean by "projection". Mathematically you seem to be saying that the cos(b - e) = cos(d) = ???

"a" and "e" are both unit vectors, the dot product "a.b" is the magnitude of the projection of "a" on "b" or "b" on "a" which is equivalent to the cosine of the angle between the two vectors. The sign of that projection will be positive if both vectors are in the same hemicircle on their common plane, and negative otherwise. When +ve, the detector D+ fires. When -ve, the detector D- fires. The projection will be +1 if both vectors are pointing in the same direction and -1 if they are pointing in opposite directions. In between, it will take values from -1 to +1 according to the cosine of the angle between them.

There is no subtracting of angles involved, unless you are working in flatland, which is not a good approximation as we found out way back when.

[minkwe]

***
Fred, Michel,

What I find mathematically and historically interesting in this new simulation are the following lines:

Code: Select all

p = function(u,v){colSums(u*v)} # polarizer function of Bell

q = function(u,v,s){ifelse(abs(p(u,v)) > f, cos(Angles), 0)}

g = function(u,v,s){p(u,v)*q(u,v,s)}   # cf. http://rpubs.com/jjc/84238

A = +sign(p(a,e))*sign(q(a,e,s))  # Alice's results A(a, e, s) = +/-1


Note that A is a function of sign(p) x sign(q). If we set f = 0 in q, then the function A reduces to just sign(p), which was the function originally proposed by Bell in 1964. So, not surprisingly, the strong correlations are contained entirely in sign(q), which has been factored out from the original A function used in this simulation.

This may have nothing to do with what Fred is suggesting, but I find it interesting that Bell's original model can be factored out in this manner as a linear background.

***

Joy,
Now I understand what you mean. In my framework code, your factorization will be equivalent to:

Code: Select all

def particle_detector(info):
    particle, setting = info
    a = ga.ang2Vec3d(theta=setting, phi=numpy.pi/2)
    z = particle[-1]    # represents which arm we are on, left or right
    f = particle[0]
    particle[0] = 0; particle[-1] = 0 # zero out scalar and tri-vector parts

    # read particle e is just the vector part
    e = ga.MultiVector(ga.layout, value=particle)

    pol = (a*e).value[0]
    q = z*max(abs(pol) - f, 0)
    out = numpy.sign(pol)*numpy.sign(q)
    return [0, setting,out]



Producing exactly the same result as before. Note that as I explained to Fred earlier, there is more information in the dot product "a.e" than the sign of it. The sign of the dot product gives you the background Bell triangle wave, and the magnitude of the dot product combined with the state selection rules gives you the remainder.

[FrediFizzx]

I am not sure exactly what you mean by "projection". Mathematically you seem to be saying that the cos(b - e) = cos(d) = ???

"a" and "e" are both unit vectors, the dot product "a.b" is the magnitude of the projection of "a" on "b" or "b" on "a" which is equivalent to the cosine of the angle between the two vectors. The sign of that projection will be positive if both vectors are in the same hemicircle on their common plane, and negative otherwise. When +ve, the detector D+ fires. When -ve, the detector D- fires. The projection will be +1 if both vectors are pointing in the same direction and -1 if they are pointing in opposite directions. In between, it will take values from -1 to +1 according to the cosine of the angle between them.

There is no subtracting of angles involved, unless you are working in flatland, which is not a good approximation as we found out way back when.

OK, that is why abs(angle - e) < pi works for producing the + or - 1 for the polarizer action. And it works for both random and fixed angles. So why doesn't the "sign" method work for random angles? It seems like it should according to your explanation but it doesn't. IOW, separating the polarizers out, changed something regarding the "sign" method.
.

[minkwe]

See my previous post Fred. Unless you mean something different that Joy, the code in my previous post is exactly equivalent and produces the same results.

[FrediFizzx]

See my previous post Fred. Unless you mean something different that Joy, the code in my previous post is exactly equivalent and produces the same results.

Not sure what you mean by "same results". Are you saying that the "sign" method is now working with random angles?

[FrediFizzx]

See my previous post Fred. Unless you mean something different that Joy, the code in my previous post is exactly equivalent and produces the same results.

Not sure what you mean by "same results". Are you saying that the "sign" method is now working with random angles?

Sorry, took a better look at the code. I don't think what you are doing is exactly the same as what Joy is doing. But that could just be not fully understanding the Python code. Joy's q-function returns cos(angle) or 0 not cos(angle - e) or 0.

[minkwe]

See my previous post Fred. Unless you mean something different that Joy, the code in my previous post is exactly equivalent and produces the same results.

Not sure what you mean by "same results". Are you saying that the "sign" method is now working with random angles?

What I had presented was that the following expressions did not work:

- f(s) = -1 + (2/sqrt(1 + ((3 * s)/pi)))
- A(a; e, s) = +sign(a.e) * { sign(a.X) if |a.e| > f(s), 0 otherwise} and
- B(b; e, s) = -sign(b.e) * { sign(b.X) if |b.e| > f(s), 0 otherwise},
- where X is the vector (1,0,0)

but the following worked:

f(s) = -1 + (2/sqrt(1 + ((3 * s)/pi)))
- A(a; e, s) = +sign(a.e) if |a.e| > f(s), 0 otherwise
- B(b; e, s) = -sign(b.e) if |b.e| > f(s), 0 otherwise

What I'm saying now is that the following also works and is exactly equivalent to the previous one which also worked

f(s) = -1 + (2/sqrt(1 + ((3 * s)/pi)))
- A(a; e, s) = +sign(a.e)*sign(max(|a.e| - f(s), 0))
- B(b; e, s) = -sign(b.e)*sign(max(|b.e| - f(s), 0))

This latest one is my own understanding of what Joy is doing in his latest R-snippet.


Let me explain my python code line by line:

pol = (a*e).value[0]
# pol is the cosine of the angle between "a" and "e", ie the dot product.

q = z*max(abs(pol) - f, 0)
# if the absolute value of the angle between "a" and "e" is greeter than f, q will be z otherwise q will be zero
# z = +1 for Alice and -1 for Bob

out = numpy.sign(pol)*numpy.sign(q)
# self explanatory


Does it make sense to you now.

[minkwe]

Sorry, took a better look at the code. I don't think what you are doing is exactly the same as what Joy is doing. But that could just be not fully understanding the Python code. Joy's q-function returns cos(angle) or 0 not cos(angle - e) or 0.

Hmm? why does Joy have cos(Angles) in

Code: Select all

q = function(u,v,s){ifelse(abs(p(u,v)) > f, cos(Angles), 0)}

What is "Angles" doing there?

[FrediFizzx]

Sorry, took a better look at the code. I don't think what you are doing is exactly the same as what Joy is doing. But that could just be not fully understanding the Python code. Joy's q-function returns cos(angle) or 0 not cos(angle - e) or 0.

Hmm? why does Joy have cos(Angles) in

Code: Select all

q = function(u,v,s){ifelse(abs(p(u,v)) > f, cos(Angles), 0)}

What is "Angles" doing there?

Joy's q-function is returning cos(a) or 0 and cos(b) or 0 for each iteration. We think that is how it should be with the polarizer action separated out. And it works. It also works in Mathematica when using my polarizer action scheme with abs(angle - e) < pi, pol = 1, else pol = -1. It does not work in Mathematica with Joy's polarizer scheme of sign(cos(angle - e)).

However, from your previous explanation I am now confused about the cos(angle - e) thing.

q = z*max(abs(pol) - f, 0)
# if the absolute value of the angle between "a" and "e" is greeter than f, q will be z otherwise q will be zero
# z = +1 for Alice and -1 for Bob

I don't understand how it is returning "z".
q = z*max(abs(cos(angle - e)) - f, 0)
.

[Joy Christian]

Hmm? why does Joy have cos(Angles) in

Code: Select all

q = function(u,v,s){ifelse(abs(p(u,v)) > f, cos(Angles), 0)}

What is "Angles" doing there?

If you replace cos(Angles) with p(u,v), or cos(u,v), then it doesn't work in R. "Angles" are angles that the vectors "e" make with respect to the x-axis.

***

[ajw]

Speaking about a real EPR-Bohm scenario, does any of you have ideas of how to use quaternions or other multivectors (constrained by S3) for an event by event simulation? I know at least in Python there are libraries for this. The currently discussed simulations are the R3 flatlanders versions of Joy's model, and therefore have the if/else then 0 at the polarizer stage, which limits the proving value of the model.
(maybe this post belongs in a new thread)

[minkwe]

Joy's q-function is returning cos(a) or 0 and cos(b) or 0 for each iteration. We think that is how it should be with the polarizer action separated out. And it works. It also works in Mathematica when using my polarizer action scheme with abs(angle - e) < pi, pol = 1, else pol = -1. It does not work in Mathematica with Joy's polarizer scheme of sign(cos(angle - e)).

It doesn't look right to me. Angles is an array of angles not a single angle it is not correct to be calculating it like that. You are subtracting a single angle from an array of angles. It doesn't make sense to me.

I don't understand how it is returning "z".
q = z*max(abs(cos(angle - e)) - f, 0)

I'm not doing any angle subtractions in my code. What are you trying to do physically with the angle subtraction?

[minkwe]

Speaking about a real EPR-Bohm scenario, does any of you have ideas of how to use quaternions or other multivectors (constrained by S3) for an event by event simulation? I know at least in Python there are libraries for this. The currently discussed simulations are the R3 flatlanders versions of Joy's model, and therefore have the if/else then 0 at the polarizer stage, which limits the proving value of the model.
(maybe this post belongs in a new thread)

ajw, my code is using geometric algebra with Cl(0,3) through out. It is a simple tweak to change the algebra to some other layout. Like I mentioned, I can easily test any model by simply defining the two functions so I welcome any suggestions. All I need are:

1) Source: How are the particle pairs represented, and what information should they contain
2) Station: What are the steps involved to produce the detection events (+1, -1) and what other side-effects are caused by the detection (eg, time delays, memory, etc if relevant to the model)

The framework can handle all those.

[FrediFizzx]

Joy's q-function is returning cos(a) or 0 and cos(b) or 0 for each iteration. We think that is how it should be with the polarizer action separated out. And it works. It also works in Mathematica when using my polarizer action scheme with abs(angle - e) < pi, pol = 1, else pol = -1. It does not work in Mathematica with Joy's polarizer scheme of sign(cos(angle - e)).

It doesn't look right to me. Angles is an array of angles not a single angle it is not correct to be calculating it like that. You are subtracting a single angle from an array of angles. It doesn't make sense to me.

It is my understanding that the iterations step through the Angles array one at a time. IOW, the first iteration is cos(0) for a and cos(0) for b. The last iteration is cos(2pi) for a and cos(2pi) for b. But cos(angle) also works in Mathematica with random angles.

I don't understand how it is returning "z".
q = z*max(abs(cos(angle - e)) - f, 0)

I'm not doing any angle subtractions in my code. What are you trying to do physically with the angle subtraction?

What is this then?

pol = (a*e).value[0]
# pol is the cosine of the angle between "a" and "e", ie the dot product.

That is cos(a - e). Don't your vectors have an angle relationship to a lab frame?
.

[minkwe]

"a*e" is the dot product between the setting "a" and the particle vector "e". on Alice's side and "b*e" on bobs side. In 2D flatland it will be the same as cos(a-e). But this is not the same thing as the cos(Angles) I see in the R code. If what you are interested in is actually "a*e" and "b*e", then why not use those directly in the q function, rather than cos(Angles)?

The R-code at http://rpubs.com/jjc/84238 appears to do it correctly

Code: Select all

function(u,v,s){ifelse(abs(colSums(u*v)) > f, colSums(u*v), 0)}

This is exactly equivalent to my code, which works. However,

Code: Select all

function(u,v,s){ifelse(abs(colSums(u*v)) > f, cos(Angles), 0)}

does not seem correct, and I'm surprised that the code even runs. If it works, it is probably due to some strange side-effect not because it is correct. If you want to do the angle between the X-axis and the setting, you should define the x-axis, and do the dot-product for each iteration, like

Code: Select all

function(u,v,s){ifelse(abs(colSums(u*v)) > f, colSums(u*x), 0)}

or something. But I've done that in python and it does not work.

[FrediFizzx]

"a*e" is the dot product between the setting "a" and the particle vector "e". on Alice's side and "b*e" on bobs side. In 2D flatland it will be the same as cos(a-e). But this is not the same thing as the cos(Angles) I see in the R code. If what you are interested in is actually "a*e" and "b*e", then why not use those directly in the q function, rather than cos(Angles)?

I know it is not the same thing. I don't want or need it to be the same thing since the simulations work. The point being that a.e and b.e only are involved in determining the polarizer action and complete state selection. The only real question that I have here is why does Joy's polarizer action, sign(cos(angle - e)) work for fixed angles (vectors) in R but does not work for random angles (vectors). So I am still trying to decipher if your Python code is actually verifying the R code. You never answered my question about returning "z". I still don't understand that.