Моделируем квантовую запутанность на C#

C#Popular science
Поскольку тема квантовой запутанности всплывает все чаще, захотелось немного углубиться. Судя по комментариям к статьям о квантовой запутанности, не мне одному будет полезна данная информация. Ну и, с учетом того что для большинства из нас программный код гораздо удобнее всяких аллегорий – решено было представить мое понимание в виде кода.

Данная статья расширяет статью другого автора «Квантовая запутанность для чайников» (рекомендую к прочтению, она мне очень помогла). В своей статье indomit привел пример программы, которая наглядно демонстрирует проблему теории скрытых параметров, но не смог привести пример кода для частиц в суперпозиции. В данной же статье мы попытаемся смоделировать 2 случая:

  1. Как бы вели себя запутанные частицы при детерминизме, когда состояние частиц установлено до измерения, просто мы его не можем измерить без внесения искажений (та самая теория скрытых параметров). Получим числа и увидим расхождение с практикой.
  2. Напишем модель запутанных частиц, находящихся в суперпозиции (состояние частиц не определено до измерения). Попробуем предположить, как частица запрограммирована внутри, то есть подгоним ее код под данные, которые получены экспериментально.

За основу статьи взято популярное объяснение феномена квантовой запутанности от Мермина:

Объяснение парадокса по Мермину
Для популярного донесения парадокса Д. Мермин предлагает сконструировать простое устройство[23]. Устройство должно состоять из излучателя частиц и двух детекторов. Две одинаковые частицы испускаются к каждому из них. Поймав частицу, детектор даёт двоичный ответ (0 или 1), зависящий от частицы и своего трёхпозиционного переключателя настройки. Детектирование пары частиц должно дать одинаковые ответы:

  1. Всякий раз, когда детекторы настроены одинаково.
  2. По статистике в половине случаев, когда они настроены случайным образом.

Первое свойство требует, чтобы все детекторы использовали одну и ту же кодировку позиция переключателя ∈ {1,2,3} ↦ отклик ∈ {0,1}, без какого бы то ни было элемента случайности. То есть они должны заранее сговориться какой из откликов, 0 или 1, давать на позицию переключателя, выбрав для каждой частицы одну из восьми возможных функций, 000, 001, 010, 011, 100, 101, 110 и 111. Выбор 000 или 111 приведёт к 100 % совпадению показаний детекторов вне зависимости от положения ручки настройки. Если же детекторы реализуют одну из шести оставшихся функций, одна из цифр вытягивается случайно настроенным переключателем в 2/3 случаев, другая — с вероятностью 1/3. Вероятность совпадения двух ответов при этом составит (⅔)² + (⅓)² = 5/9. Так что каков бы ни был алгоритм автомата, корреляция неизбежно превышает 50 %, нарушая второе требование.

Но поскольку такую машину всё-таки соорудить можно (например, располагая позиции поляризаторов под 120° как в опыте Бома), то никакого детерминизма (параметров) не может быть даже в скрытой форме. Вместо этого корреляции откликов поддерживаются за счёт передачи информации от одной «измеренной» частицы к другой быстрее, чем произойдёт второе измерение.

Взято отсюда.

К сожалению, я не занимаюсь физикой ни профессионально ни даже на уровне любителя, на безошибочность не претендую. Главная цель статьи – продемонстрировать как сделать понятную для знакомых с программированием модель. Если кто-то профессионально работает в данной области, то вместо того, чтобы упрекать — попробуйте написать более точные модели взаимодействий по мотивам моей статьи.

[Update] Поясниние к описанию Мермина


Хотя с момента написания статьи прошло несколько месяцев и никто к ней возвращаться не будет, для успокоения совести решил внести уточнение.

Немного углубился и пришел к выводу, что описание по Мермину сильно упрощено и попытки привязать его к реальным физическим экспериментам бессмысленны.

Изначально я попытался привязать статью к реальному эксперименту с круговой поляризацией и в этом ошибся. ARad попытался развить привязку к реальным физическим экспериментам, написал о допущенных ошибках и даже предложил свою версию кода (которая тоже не соответствует ни одному физическому эксперименту).

Чтобы статья имела хоть какой-то смысл, было решено убрать все мнимые привязки к реальным физическим экспериментам и просто пояснить в коде описание Мермина, сделать его более наглядным. Реальные эксперименты сложнее и для их моделирования нужно потратить значительно больше времени.

В первой версии статьи мы приняли что в первом эксперименте (положение датчиков совпадает) частицы дают зеркальный результат, но в оригинальном описании по Мермину результат измерения при одинаковом положении датчиков всегда совпадает. Это исправлено.

Дополнительно добавлю «пояснение на пояснение» этого самого Мермина, так как написано не однозначно:

То есть они должны заранее сговориться какой из откликов, 0 или 1, давать на позицию переключателя, выбрав для каждой частицы одну из восьми возможных функций, 000, 001, 010, 011, 100, 101, 110 и 111.

Фраза «восьми возможных функций» не однозначна. Говорится о восьми возможных вариантах потенциального воздействия частиц на датчик. Положений у датчика три (см. полное описание выше). Если мы считаем, что состояние двух частиц совпадает и установлено заранее, то мы можем и заранее определить какой отклик (0 или 1) потенциально получим для каждой из трех позиций переключателя (хотя «измерить» можем лишь один из трех вариантов).

Выбор 000 или 111 приведёт к 100 % совпадению показаний детекторов вне зависимости от положения ручки настройки.

Если частицы могут принимать значение, при котором потенциально получим отклик «1» при любом положении переключателя (равно как и 0, при любом положении переключателя) — то второй эксперимент в этих случаях даст 100% совпадений. Для приближения к 50% эти варианты можно исключить.

Если же детекторы реализуют одну из шести оставшихся функций, одна из цифр вытягивается случайно настроенным переключателем в 2/3 случаев, другая — с вероятностью 1/3.

Имеется в виду, что в каждой из 6 троек (001, 010, 011, 100, 101, 110) — только две цифры из трех совпадают (в первом варианте две из трех — «0», и одна из трех — «1»).

Для оценки вероятности составим таблицу для первого случая 001:

Положение датчика 1 Положение датчика 2 Совпадут ли измерения
1 1 +
1 2 +
1 3 -
2 1 +
2 2 +
2 3 -
3 1 -
3 2 -
3 3 +

Видно что в пяти случаях из девяти измерения совпадут. Такая же вероятность будет для каждого из этих шести вариантов (ведь в каждом из них две цифры одинаковые).

Измерения


В каждой из моделей (и в детерминистической, и в суперпозиционной) будем проводить с запутанными частицами два эксперимента, соответствующие первому и второму условию по Мермину:

  1. Сначала установим оба датчика в одинаковую позицию. В этом случае будем получать 100% одинаковые результаты (если первый фотон проходит через поляризатор, то связанный с ним тоже проходит через поляризатор под таким же углом).
  2. Затем будем устанавливать позицию датчиков случайным образом.

Вот код первого эксперимента:

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); // все совпали

Вот код второго эксперимента:

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);

Для всех моделей частиц будут одни и те же тесты, только код частиц будут отличаться для детерминистической и суперпозиционной моделей (об этом ниже).

Детерминистическая модель


Внимание! См. UPDATE в конце статьи!

Для желающих сразу запустить код, это можно сделать из браузера: dotnetfiddle.net/N5Xg18

Итак, согласно объяснению Мермина, у нас есть квантовая частица с 3 параметрами:

// Элементарная частица (к примеру, фотон)
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();
        }
    }
}

Поскольку модель детерминистическая — все параметры частицы инициализированы в момент ее создания, то есть прямо в конструкторе. Единственное условие — измерение разрешено только один раз!

Далее. Пара запутанных частиц:

// Пара запутанных частиц
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); // Значение первой и второй частицы совпадают
    }
}


Видно, что значения каждой из частиц устанавливаются в момент создания пары запутанных частиц, причем параметры второй частицы соответствуют параметрам первой (без этого не сможем пройти первый тест). Мы используем случайные числа, но согласно модели, параметры зависят от факторов в момент запутывания (как результат рулетки зависит от ряда факторов в момент раскручивания).

Полный код примера:

Код C# детерминистической модели (исправлено)
using System;

public class Program
{
    private static readonly Random Random = new Random();

    // Элементарная частица
	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();
			}
		}
	}

    // Пара запутанных частиц
    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); // Значение первой и второй частицы совпадают
        }
    }


    public static void Main(string[] args)
    {
        Experiment1();
        Experiment2();
    }

    private static void Experiment1()
    {
        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); // все совпали
	}

    private static void Experiment2()
    {
        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);
    }


    private static bool GetRandomBoolean()
    {
        return GetRandomInteger(0, 1) == 1;
    }


    private static int GetRandomInteger(int from, int to)
    {
        return Random.Next(from, to + 1); // нам удобнее указывать с какого числа по какое включительно
    }
}


Запустить можно из браузера (еще раз ссылка: dotnetfiddle.net/N5Xg18).

После запуска вот такие результаты:

Эксперимент №1: 100% значений совпало
Эксперимент №2: 55.6700% значений совпало

Первый тест пройден, соответствует происходящему в реальности. А вот второй — не соответствует, так как должны получить 50%!

В результате физики были вынуждены прийти к тому, что теория скрытых параметров ошибочна. А вместе с ней опровергнут принцип локальности и даже пошатнулся принцип причинности.

Суперпозиционная модель


Сразу ссылка на код примера, для любящих конкретику (можно запустить в браузере): dotnetfiddle.net/Mb7JqU

Чтобы объяснить полученные в ходе экспериментов результаты, пришлось использовать более сложные модели. В современных моделях состояние параметров частицы до измерения не определено, а сами запутанные частицы имеют возможность мгновенно (сверх скорости света) влиять на состояние друг друга. Вот как теперь выглядит наша модель элементарной частицы:

// Элементарная частица
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();
        }
    }
}

Во-первых, параметры стали Nullable (могут не иметь значения) и в конструкторе мы их не устанавливаем. Во-вторых, появился метод CreateSuperluminalChannelWith для установки сверхсветового канала между частицами, т.е. теперь одна частица может получить состояние другой мгновенно, не взирая на расстояние. Ну и, главное, теперь состояние частицы устанавливается лишь в момент измерения (вызов метода GetValue) и зависит от того, было ли произведено измерение другой, связанной с ней, частицы.

Внутренность метода GetValue — чистое предположение. Как внутри устроена частица — никто не знает, но мы знаем, что работает она именно так: 100% несовпадений в случае измерения одинакового параметра и 50% несовпадений при измерении параметров в случайном порядке.

В моей версии кода частица по сверхсветовому каналу проверяет произведено ли измерение запутанной с ней и действует так:

  1. Если измеренный параметр другой частицы тот же, что мы пытаемся замерять — выдает одинаковое значение.
  2. Если параметр другой, то в 1/4 случаев выдает одинаковое значение, а в 3/4 случаев выдает противоположное значение (так как раз получим 50/50).

В случае, если измерение не производилось — частица использует истинный рандом для установки своего значения, то есть происходит нарушение причинно-следственной связи (значение не существовало до измерения и само измерение не определило его значение).

Кстати! Вы можете переписать эту функцию иным образом, но чтобы результаты тестов были такими же. Все равно никто не знает как устроена элементарная частица и как достигается 50% для второго теста.

Пара запутанных частиц стала проще, так как в момент запутывания никаких значений не устанавливается (значения еще не определены):

// Пара запутанных частиц
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#
using System;

public class Program
{
    private static readonly Random Random = new Random();

    // Элементарная частица
    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();
            }
        }
    }

    // Пара запутанных частиц
    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);
        }
    }


    public static void Main(string[] args)
    {
        Experiment1();
        Experiment2();
    }

    private static void Experiment1()
    {
        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); // все совпали
	}

    private static void Experiment2()
    {
        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);
    }

    private static bool GetRandomBoolean()
    {
        return GetRandomInteger(0, 1) == 1;
    }


    private static int GetRandomInteger(int from, int to)
    {
        return Random.Next(from, to + 1); // нам удобнее указывать с какого числа по какое включительно
    }
}


Результаты:

Эксперимент №1: 100% значений совпало
Эксперимент №2: 49.7700% значений совпало

Запустить в браузере: dotnetfiddle.net/Mb7JqU

Выводы


Хотелось бы побольше доступных толкований, наподобие тех, что высказал Мермин. На основе этого толкования мне удалось создать наглядные модели существующих теорий и даже выдвинуть альтернативную модель и эти модели не аллегорические — их можно запустить и посмотреть как они работают.

К сожалению, не имею временных ресурсов для более глубокого познания квантовой физики и надеюсь что знающие смогут последовать моему примеру и привести более точные работающие модели.

UPDATE
В объяснении Мермина ничего нет про устройство детекторов. Я же, по своей инициативе, добавил пояснение к A, В и С как проекция спина на ось X, Y и Z соответственно. То есть мне захотелось в комментариях к коду добавить привязку к физическим явлениям, дабы не было так сухо. И в этом я ошибся…

Статья исправлена и все тщетные попытки привязать объяснение Мермина к реальным физическим экспериментам удалены.
Tags:квантовая запутанностьквантовая сцепленностьнеравенство белла
Hubs: C# Popular science
+11
7.3k 52
Comments 81
C# разработчик
from 70,000 to 165,000 ₽ЭЛКОМ+Москва
.NET C# Software Engineer
from 3,500 to 4,000 $Hand2NoteRemote job
Программист C#
from 90,000 to 140,000 ₽Группа ЧТПЗЧелябинскRemote job
C# разработчик
from 130,000 to 200,000 ₽deeplayНовосибирскRemote job
Middle Backend developer (C#)
from 60,000 ₽Email SoldiersRemote job