Modelado de enredo cuántico en C #

A medida que el tema del enredo cuántico aparece cada vez más a menudo, quería profundizar un poco más. A juzgar por los comentarios sobre los artículos sobre enredo cuántico, esta información no me será útil solo. Bueno, teniendo en cuenta el hecho de que para la mayoría de nosotros, el código del programa es mucho más conveniente que cualquier alegoría, se decidió presentar mi entendimiento en forma de código.

Este artículo amplía el artículo de otro autor "Enredos cuánticos para tontos" (recomiendo leerlo, me ayudó mucho). En su artículo, indomit dio un ejemplo de un programa que demuestra claramente el problema de la teoría de los parámetros ocultos, pero no puede dar un ejemplo de un código para partículas en superposición. En este artículo, intentaremos simular 2 casos:

1. Cómo se comportarían las partículas enredadas en el determinismo, cuando el estado de las partículas se establece antes de la medición, simplemente no podemos medirlo sin introducir distorsiones (la teoría misma de los parámetros ocultos). Obtenemos los números y vemos la discrepancia con la práctica.
2. Escribiremos un modelo de partículas enredadas en superposición (el estado de las partículas no está definido antes de la medición). Intentemos asumir cómo se programa la partícula en el interior, es decir, ajustaremos su código a los datos obtenidos experimentalmente.

El artículo se basa en la explicación popular del fenómeno del enredo cuántico de Mermin:


Desafortunadamente, no hago física ni profesionalmente ni incluso a nivel amateur, no pretendo ser impecable. El objetivo principal del artículo es demostrar cómo hacer que un modelo sea comprensible para aquellos familiarizados con la programación. Si alguien está trabajando profesionalmente en este campo, en lugar de reprochar, intente escribir modelos de interacción más precisos basados ​​en mi artículo.

[Actualización] Explicación de la descripción de Mermin

Aunque han pasado varios meses desde la redacción del artículo y nadie volverá a leerlo, decidí hacer una aclaración para calmar mi conciencia.

Fui un poco más profundo y llegué a la conclusión de que la descripción según Mermin se simplifica enormemente y los intentos de vincularlo con experimentos físicos reales no tienen sentido .

Inicialmente, traté de vincular el artículo a un experimento real con polarización circular, y cometí un error al respecto. ARad intentó desarrollar un enlace con experimentos físicos reales, escribió sobre los errores cometidos e incluso propuso su propia versión del código (que tampoco corresponde a ningún experimento físico).

Para que el artículo tenga al menos algún sentido, se decidió eliminar todos los enlaces imaginarios a experimentos físicos reales y simplemente explicar la descripción de Mermin en el código y hacerlo más visual. Los experimentos reales son más complicados y para simularlos necesitas pasar mucho más tiempo.

En la primera versión del artículo, aceptamos que en el primer experimento (la posición de los sensores coincide), las partículas dan un resultado espejo, pero en la descripción original según Mermin, el resultado de la medición con la misma posición de los sensores siempre coincide. Esto está arreglado .

Además, agregaré una "explicación para una explicación" de este Mermin mismo, ya que no está escrito sin ambigüedades:

Es decir, deben acordar de antemano cuál de las respuestas, 0 o 1, da a la posición del interruptor, eligiendo para cada partícula una de las ocho funciones posibles, 000, 001, 010, 011, 100, 101, 110 y 111.

La frase "ocho funciones posibles" es ambigua. Se discuten ocho posibles variantes del impacto potencial de las partículas en el sensor. El sensor tiene tres posiciones (ver la descripción completa arriba). Si creemos que el estado de las dos partículas coincide y se establece de antemano, entonces podemos determinar de antemano qué respuesta (0 o 1) potencialmente recibiremos para cada una de las tres posiciones del interruptor (aunque podemos "medir" solo una de las tres opciones).

Seleccionar 000 o 111 dará como resultado una coincidencia del 100% de las lecturas del detector, independientemente de la posición de la perilla de sintonización.

Si las partículas pueden tomar un valor en el que potencialmente podemos recibir una respuesta de "1" para cualquier posición del interruptor (así como 0 para cualquier posición del interruptor), entonces el segundo experimento en estos casos dará una coincidencia del 100%. Para acercarse al 50%, estas opciones pueden excluirse.

Si los detectores implementan una de las seis funciones restantes, uno de los dígitos se extrae mediante un interruptor sintonizado al azar en 2/3 de los casos, y el otro con una probabilidad de 1/3.

Significa que en cada uno de los 6 triples (001, 010, 011, 100, 101, 110), solo dos de los tres dígitos coinciden (en la primera versión, dos de los tres son "0" y uno de los tres es "1" )

Para evaluar la probabilidad, compilamos una tabla para el primer caso 001 :

Posición del sensor 1	Posición del sensor 2	¿Las medidas coinciden?
1	1	+
1	2	+
1	3	-
2	1	+
2	2	+
2	3	-
3	1	-
3	2	-
3	3	+

Se puede ver que en cinco casos de nueve mediciones coinciden. La misma probabilidad será para cada una de estas seis opciones (después de todo, en cada una de ellas los dos números son iguales).

Medidas

En cada uno de los modelos (tanto deterministas como superposicionales), realizaremos dos experimentos con partículas enredadas correspondientes a la primera y segunda condiciones según Mermin:

1. Primero, coloque ambos sensores en la misma posición. En este caso, obtendremos resultados 100% idénticos (si el primer fotón pasa a través del polarizador, entonces el fotón asociado también pasa a través del polarizador en el mismo ángulo).
2. Luego estableceremos la posición de los sensores al azar.

Aquí está el código para el primer experimento:

var totalAttempts = 10000; //   var coincidenceCount = 0; //    for (int attemptNumber = 1; attemptNumber <= totalAttempts; attemptNumber++) { var entanglementParticles = new EntanglementParticles(); //     var position = GetRandomInteger(1, 3); //        //            int firstSensorPosition = position; int secondSensorPosition = position; bool firstValue = entanglementParticles.First.GetValue(firstSensorPosition); //         bool secondValue = entanglementParticles.Second.GetValue(secondSensorPosition); //         if (firstValue == secondValue) //     coincidenceCount ++; } Console.WriteLine(" №1: {0}%  ", (decimal)coincidenceCount / totalAttempts * 100); //   

Aquí está el código para el segundo experimento:

 var totalAttempts = 10000; //   var coincidenceCount = 0; //    for (int attemptNumber = 1; attemptNumber <= totalAttempts; attemptNumber++) { var entanglementParticles = new EntanglementParticles(); //     int firstSensorPosition = GetRandomInteger(1, 3); //      1 int secondSensorPosition = GetRandomInteger(1, 3); //      2 bool firstValue = entanglementParticles.First.GetValue(firstSensorPosition); //         bool secondValue = entanglementParticles.Second.GetValue(secondSensorPosition); //         if (firstValue == secondValue) //     coincidenceCount ++; } Console.WriteLine(" №2: {0}%  ", (decimal)coincidenceCount / totalAttempts * 100); 

Las mismas pruebas serán para todos los modelos de partículas, solo el código de partículas será diferente para los modelos deterministas y de superposición (más sobre esto a continuación).

Modelo determinista

Atencion ¡Vea ACTUALIZACIÓN al final del artículo!

Para aquellos que desean ejecutar el código de inmediato, esto se puede hacer desde el navegador: dotnetfiddle.net/N5Xg18

Entonces, según la explicación de Mermin, tenemos una partícula cuántica con 3 parámetros:

 //   ( , ) public class Particle { private bool _measured = false; public bool A { get; private set; } //       1 public bool B { get; private set; } //       2 public bool C { get; private set; } //       3 public Particle(bool a, bool b, bool c) { A = a; B = b; C = c; } //         ( 3 ). public bool GetValue(int sensorPosition) { if (_measured) throw new InvalidOperationException("    !"); _measured = true; switch (sensorPosition) { case 1: return A; case 2: return B; case 3: return C; default: throw new ArgumentOutOfRangeException(); } } } 

Como el modelo es determinista, todos los parámetros de la partícula se inicializan en el momento de su creación, es decir, directamente en el constructor. ¡La única condición es que la medición se permita solo una vez!

Siguiente Un par de partículas enredadas:

 //    public class EntanglementParticles { public Particle First { get; private set; } //   public Particle Second { get; private set; } //   //     (   ,         ) public EntanglementParticles() { //         bool a; bool b; bool c; do { a = GetRandomBoolean(); //     1 b = GetRandomBoolean(); //     2 c = GetRandomBoolean(); ; //     3 } while (a == b && b == c); //   000  111 (    ,       ) First = new Particle(a, b, c); Second = new Particle(a, b, c); //       } } 

Se puede ver que los valores de cada una de las partículas se establecen en el momento de crear un par de partículas enredadas, y los parámetros de la segunda partícula corresponden a los parámetros de la primera (sin esto no podemos pasar la primera prueba). Utilizamos números aleatorios, pero según el modelo, los parámetros dependen de factores en el momento del enredo (como resultado de la ruleta, depende de varios factores en el momento del desenrollado).

Código de ejemplo completo:


Puede iniciarlo desde el navegador (una vez más, el enlace: dotnetfiddle.net/N5Xg18 ).

Después del lanzamiento, estos son los resultados:

Experimento No. 1: 100% de los valores coincidieron
Experimento No. 2: 55.6700% de los valores coincidentes

La primera prueba aprobada, corresponde a lo que está sucediendo en la realidad. Pero el segundo no coincide, ¡ya que deberían obtener el 50%!

Como resultado, los físicos se vieron obligados a llegar a la conclusión de que la teoría de los parámetros ocultos es errónea. Y con ello, el principio de localidad se refuta y el principio de causalidad incluso se ha sacudido.

Modelo superposicional

Inmediatamente un enlace a un código de ejemplo, para los amantes de los detalles (se puede iniciar en un navegador): dotnetfiddle.net/Mb7JqU

Para explicar los resultados obtenidos durante los experimentos, fue necesario utilizar modelos más complejos. En los modelos modernos, el estado de los parámetros de partículas no se define antes de la medición, y las partículas enredadas tienen la capacidad de afectar instantáneamente (por encima de la velocidad de la luz) el estado del otro. Así es como se ve nuestro modelo de partículas ahora:

 //   public class Particle { private Particle _superluminalChannel; //         . private int? _measuredPosition; public bool? A { get; private set; } //       1 public bool? B { get; private set; } //       2 public bool? C { get; private set; } //       3 internal void CreateSuperluminalChannelWith(Particle particle) { _superluminalChannel = particle; } //         ( 3 ). public bool GetValue(int sensorPosition) { if (null != _measuredPosition) throw new InvalidOperationException("    !"); _measuredPosition = sensorPosition; if (null != _superluminalChannel._measuredPosition) //        { var measuredValue = _superluminalChannel.GetNakedValue(); //         (    ),   ,     . if (sensorPosition == _superluminalChannel._measuredPosition) return measuredValue; if (GetRandomInteger(1, 4) == 1) return measuredValue; return !measuredValue; } //  .        ,       -  . //   ! var value = GetRandomBoolean(); SetValue(sensorPosition, value); return value; } private bool GetNakedValue() //           ,    . { if (null == _measuredPosition) throw new InvalidOperationException(); switch (_measuredPosition.Value) { case 1: return A.Value; case 2: return B.Value; case 3: return C.Value; default: throw new InvalidOperationException(); } } private void SetValue(int position, bool value) { switch (position) { case 1: A = value; break; case 2: B = value; break; case 3: C = value; break; default: throw new ArgumentOutOfRangeException(); } } } 

Primero, los parámetros son anulables (pueden no importar) y no los establecemos en el constructor. En segundo lugar, el método CreateSuperluminalChannelWith para establecer el canal superligero entre partículas, es decir Ahora una partícula puede obtener el estado de otra al instante, independientemente de la distancia. Bueno, y lo más importante, ahora el estado de una partícula se establece solo en el momento de la medición (llamado método GetValue) y depende de si se midió otra partícula relacionada con ella.

El interior del método GetValue es pura especulación. Nadie sabe cómo está organizada la partícula en el interior, pero sabemos que funciona así: 100% de desajustes al medir el mismo parámetro y 50% de desajustes al medir parámetros en un orden aleatorio.

En mi versión del código, una partícula a través de un canal superluminal verifica si la medición se confunde con ella y actúa así:

1. Si el parámetro medido de otra partícula es el mismo que estamos tratando de medir, da el mismo valor.
2. Si el parámetro es diferente, en 1/4 de los casos da el mismo valor, y en 3/4 de los casos da el valor opuesto (ya que obtenemos 50/50).

Si no se realizó la medición, la partícula usa una aleatoriedad verdadera para establecer su valor, es decir, se viola una relación causal (el valor no existía antes de la medición y la medición en sí misma no determinó su valor).

Por cierto! Puede reescribir esta función de otra manera, pero para que los resultados de la prueba sean los mismos. De todos modos, nadie sabe cómo se organiza la partícula elemental y cómo se logra el 50% para la segunda prueba.

Un par de partículas enredadas se ha vuelto más fácil, ya que en el momento del enredo no se establecen valores (los valores aún no se han determinado):

 //    public class EntanglementParticles { public Particle First { get; private set; } //   public Particle Second { get; private set; } //   //     (  ,   ) public EntanglementParticles() { First = new Particle(); //   ,    Second = new Particle(); //   ,    //         First.CreateSuperluminalChannelWith(Second); Second.CreateSuperluminalChannelWith(First); } } 

Código de ejemplo completo:


Resultados:

Experimento No. 1: 100% de los valores coincidieron
Experimento No. 2: 49.7700% de los valores coincidieron

Ejecutar en el navegador: dotnetfiddle.net/Mb7JqU

Conclusiones

Me gustaría tener más interpretaciones disponibles, como las expresadas por Mermin. En base a esta interpretación, logré crear modelos visuales de teorías existentes e incluso presentar un modelo alternativo, y estos modelos no son alegóricos: puede ejecutarlos y ver cómo funcionan.

Desafortunadamente, no tengo los recursos de tiempo para un conocimiento más profundo de la física cuántica y espero que aquellos que saben puedan seguir mi ejemplo y dar modelos de trabajo más precisos.

ACTUALIZAR
La explicación de Mermin no tiene nada que ver con el diseño de detectores. Por mi propia iniciativa, agregué una explicación a A, B y C como una proyección del giro en los ejes X, Y y Z, respectivamente. Es decir, quería agregar un enlace a los fenómenos físicos en los comentarios al código para que no sea tan seco. Y me equivoqué en esto ...

El artículo se corrige y se eliminan todos los intentos vanos de vincular la explicación de Mermin con experimentos físicos reales.