using System;

​

// Линейная поляризация запутанных фотонов

public class Program

{

    private static readonly Random Random = new Random();

​

    // Элементарная частица (к примеру, фотон) со скрытым параметром

    public class HPParticle

    {

        private readonly double _angle;

        private bool _measured = false;

        public HPParticle(double angle)

        {

            _angle = angle;

        }

​

        // Получаем значение с учетом позиции переключателя на датчике (всего 3 позиции).

        public bool GetValue(int sensorPosition)

        {

            if (_measured)

                throw new InvalidOperationException("Измерить можно только один раз!");

            _measured = true;

​

            return IsDetectedBySensor(sensorPosition, _angle);

        }

​

        private static bool IsDetectedBySensor(int sensorPosition, double angle) =>

            Random.NextDouble() < ComputeProbability(angle - Math.PI * 2 / 3 * sensorPosition);

​

        // Вероятность равна cos^2(θ) http://www.all-fizika.com/article/index.php?id_article=1962

        // смотрите также закон Малюса

        private static double ComputeProbability(double angle) =>

            Math.Pow(Math.Cos(angle), 2);

    }

​

    // Пара частиц с связанными скрытыми параметрами

    public class EntanglementHPParticles

    {

        public HPParticle First { get; private set; } // Первая частица

        public HPParticle Second { get; private set; } // Вторая частица

​

        // Создание пары запутанных частиц (пока верим в детерминизм, считаем что с каждая частица уже имеет установленное значение)

        public EntanglementHPParticles()

        {

            var angle1 = 2 * Math.PI * Random.NextDouble(); // угол поляризации первой частицы (случайное значение)

            var angle2 = angle1 + Math.PI / 2; // поляризация второй частицы перпендикулярно первой (сдвиг 90 градусов)

​

            First = new HPParticle(angle1);

            Second = new HPParticle(angle2);

        }

    }

​

    // Элементарная частица (к примеру, фотон) с редукцией (коллапсом) волновой функции

    public class WFCParticle

    {

        private WFCParticle _entangledParticle;

        private double? _angle;

        private bool _measured = false;

        public WFCParticle(WFCParticle entangledParticle)

        {

            _entangledParticle = entangledParticle;

            if (entangledParticle != null)

                entangledParticle._entangledParticle = this;

        }

        // Получаем значение с учетом позиции переключателя на датчике (всего 3 позиции).

        public bool GetValue(int sensorPosition)

        {

            if (_measured)

                throw new InvalidOperationException("Измерить можно только один раз!");

            _measured = true;

            var sensorAngle = Math.PI * 2 / 3 * sensorPosition;

            if (!_angle.HasValue)

                _angle = 2 * Math.PI * Random.NextDouble(); // угол поляризации (случайное значение)

            var result = IsDetectedBySensor(sensorAngle, _angle.Value);

            if (result)

                _angle = sensorAngle; // угол поляризации становится как у сенсора

            else

                _angle = sensorAngle + Math.PI / 2; // угол поляризации становится ортогонален сенсору

            // Редукция (коллапс) волновой функции

            if (_entangledParticle != null)

            {

                _entangledParticle._angle = _angle + Math.PI / 2; // угол поляризации ортогонален нашему

                _entangledParticle._entangledParticle = null;

                _entangledParticle = null;

            }

​

            return result;

        }

​

        private static bool IsDetectedBySensor(double sensorAngle, double angle) =>

            Random.NextDouble() < ComputeProbability(angle - sensorAngle);

​

        // Вероятность равна cos^2(θ) http://www.all-fizika.com/article/index.php?id_article=1962

        // смотрите также закон Малюса

        private static double ComputeProbability(double angle) =>

            Math.Pow(Math.Cos(angle), 2);

    }

​

    // Пара запутанных частиц 

    public class EntanglementWFCParticles

    {

        public WFCParticle First { get; private set; } // Первая частица

        public WFCParticle Second { get; private set; } // Вторая частица

​

        // Создание пары запутанных частиц (пока верим в детерминизм, считаем что с каждая частица уже имеет установленное значение)

        public EntanglementWFCParticles()

        {

            First = new WFCParticle(null);

            Second = new WFCParticle(First);

        }

    }

​

    public static void Main(string[] args)

    {

        Experiment1();

        Experiment2();

        Experiment3();

        Experiment4();

    }

​

    private static void Experiment1()

    {

        var totalAttempts = 10000; // всего измерений

        var disparityCount = 0; // сколько значений не совпало

​

        for (int attemptNumber = 1; attemptNumber <= totalAttempts; attemptNumber++)

        {

            var entanglementParticles = new EntanglementHPParticles(); // Зарождение пары запутанных частиц

​

            int firstSensorPosition = 1; // Первый датчик устанавливаем в позицию 1

            int secondSensorPosition = 1; // Второй датчик устанавливаем в позицию 1

​

            bool firstValue = entanglementParticles.First.GetValue(firstSensorPosition); // Значение первой частицы с учетом позиции первого датчика

            bool secondValue = entanglementParticles.Second.GetValue(secondSensorPosition); // Значение второй частицы с учетом позиции второго датчика

​

            if (firstValue != secondValue) // подсчет количества не совпавших значений

                disparityCount++;

        }

​

        Console.WriteLine("Эксперимент №1: {0}% значений не совпало", (double)disparityCount / totalAttempts * 100);

    }

​

    private static void Experiment2()

    {

        var totalAttempts = 10000; // всего измерений

        var disparityCount = 0; // сколько значений не совпало

​

        for (int attemptNumber = 1; attemptNumber <= totalAttempts; attemptNumber++)

        {

            var entanglementParticles = new EntanglementWFCParticles(); // Зарождение пары запутанных частиц

​

            int firstSensorPosition = 1; // Первый датчик устанавливаем в позицию 1

            int secondSensorPosition = 1; // Второй датчик устанавливаем в позицию 1

​

            bool firstValue = entanglementParticles.First.GetValue(firstSensorPosition); // Значение первой частицы с учетом позиции первого датчика

            bool secondValue = entanglementParticles.Second.GetValue(secondSensorPosition); // Значение второй частицы с учетом позиции второго датчика

​

            if (firstValue != secondValue) // подсчет количества не совпавших значений

                disparityCount++;

        }

​

        Console.WriteLine("Эксперимент №2: {0}% значений не совпало", (double)disparityCount / totalAttempts * 100);

    }

​

    private static void Experiment3()

    {

        var totalAttempts = 10000; // всего измерений

        var disparityCount = 0; // сколько значений не совпало

​

        for (int attemptNumber = 1; attemptNumber <= totalAttempts; attemptNumber++)

        {

            var entanglementParticles = new EntanglementHPParticles(); // Зарождение пары запутанных частиц

​

            int firstSensorPosition = Random.Next(0, 3); // Случайным образом устанавливаем позицию датчика 1

            int secondSensorPosition = Random.Next(0, 3); // Случайным образом устанавливаем позицию датчика 2

​

            bool firstValue = entanglementParticles.First.GetValue(firstSensorPosition); // Значение первой частицы с учетом позиции первого датчика

            bool secondValue = entanglementParticles.Second.GetValue(secondSensorPosition); // Значение второй частицы с учетом позиции второго датчика

​

            if (firstValue != secondValue) // подсчет количества не совпавших значений

                disparityCount++;

        }

​

        Console.WriteLine("Эксперимент №3: {0}% значений не совпало", (double)disparityCount / totalAttempts * 100);

    }

​

    private static void Experiment4()

    {

        var totalAttempts = 10000; // всего измерений

        var disparityCount = 0; // сколько значений не совпало

​

        for (int attemptNumber = 1; attemptNumber <= totalAttempts; attemptNumber++)

        {

            var entanglementParticles = new EntanglementWFCParticles(); // Зарождение пары запутанных частиц

​

            int firstSensorPosition = Random.Next(0, 3); // Случайным образом устанавливаем позицию датчика 1

            int secondSensorPosition = Random.Next(0, 3); // Случайным образом устанавливаем позицию датчика 2

​

            bool firstValue = entanglementParticles.First.GetValue(firstSensorPosition); // Значение первой частицы с учетом позиции первого датчика

            bool secondValue = entanglementParticles.Second.GetValue(secondSensorPosition); // Значение второй частицы с учетом позиции второго датчика

​

            if (firstValue != secondValue) // подсчет количества не совпавших значений

                disparityCount++;

        }

​

        Console.WriteLine("Эксперимент №4: {0}% значений не совпало", (double)disparityCount / totalAttempts * 100);

    }

}