C # में मॉडलिंग क्वांटम उलझाव

जैसा कि क्वांटम उलझाव का विषय अधिक से अधिक बार सामने आता है, मैं थोड़ा गहराई में जाना चाहता था। क्वांटम उलझाव पर लेखों पर टिप्पणियों को देखते हुए, यह जानकारी मेरे लिए अकेले उपयोगी नहीं होगी। खैर, इस तथ्य को ध्यान में रखते हुए कि हम में से अधिकांश के लिए, प्रोग्राम कोड किसी भी रूपक की तुलना में बहुत अधिक सुविधाजनक है, कोड के रूप में मेरी समझ को पेश करने का निर्णय लिया गया था।

यह लेख एक अन्य लेखक के लेख "ड्यूमिनीज़ के लिए क्वांटम एंटैंग्लमेंट" (मैं इसे पढ़ने की सलाह देता हूं, इससे मुझे बहुत मदद मिली)। अपने लेख में, इंडोमिट ने एक कार्यक्रम का उदाहरण दिया जो छिपे हुए मापदंडों के सिद्धांत की समस्या को स्पष्ट रूप से प्रदर्शित करता है, लेकिन सुपरपोज़िशन में कणों के लिए एक कोड का उदाहरण नहीं दे सकता है। इस लेख में, हम 2 मामलों का अनुकरण करने का प्रयास करेंगे:

1. उलझे हुए कण कैसे नियतावाद में व्यवहार करते हैं, जब माप से पहले कणों की स्थिति स्थापित की जाती है, तो हम केवल इसे विकृतियों (छिपे हुए मापदंडों के बहुत सिद्धांत) को पेश किए बिना नहीं माप सकते हैं। हम संख्या प्राप्त करते हैं और अभ्यास के साथ विसंगति देखते हैं।
2. हम सुपरपोज़िशन में उलझे हुए कणों का एक मॉडल लिखेंगे (माप से पहले कणों की स्थिति को परिभाषित नहीं किया गया है)। आइए यह मानने का प्रयास करें कि कण को ​​अंदर कैसे क्रमादेशित किया जाता है, अर्थात् हम इसके कोड को प्रयोगात्मक रूप से प्राप्त आंकड़ों के लिए फिट करेंगे।

लेख मरमिन से क्वांटम उलझाव की घटना के लोकप्रिय विवरण पर आधारित है:


दुर्भाग्य से, मैं भौतिकी या तो पेशेवर या शौकिया स्तर पर भी नहीं करता, मैं दोषपूर्ण होने का नाटक नहीं करता। लेख का मुख्य लक्ष्य यह प्रदर्शित करना है कि प्रोग्रामिंग से परिचित लोगों के लिए एक मॉडल को कैसे समझा जा सकता है। यदि कोई पेशेवर रूप से इस क्षेत्र में काम कर रहा है, तो उसके बदले में, मेरे लेख के आधार पर अधिक सटीक इंटरैक्शन मॉडल लिखने का प्रयास करें।

[अद्यतन] Mermin के विवरण की व्याख्या

यद्यपि लेख के लेखन में कई महीने बीत चुके हैं और कोई भी इसे वापस नहीं करेगा, मैंने अपनी अंतरात्मा को शांत करने के लिए एक स्पष्टीकरण देने का फैसला किया।

मैं थोड़ा गहरा गया और इस निष्कर्ष पर पहुंचा कि मर्मिन के अनुसार विवरण बहुत सरल है और इसे वास्तविक भौतिक प्रयोगों से जोड़ने का प्रयास निरर्थक है ।

प्रारंभ में, मैंने लेख को परिपत्र ध्रुवीकरण के साथ एक वास्तविक प्रयोग से जोड़ने की कोशिश की, और मैंने इसमें एक गलती की। एआरएड ने वास्तविक शारीरिक प्रयोगों के लिए एक बंधन विकसित करने की कोशिश की, जो गलतियों के बारे में लिखा, और यहां तक कि कोड के अपने स्वयं के संस्करण का प्रस्ताव दिया (जो किसी भी भौतिक प्रयोग के अनुरूप नहीं है)।

कम से कम कुछ समझ बनाने के लिए लेख के लिए, वास्तविक भौतिक प्रयोगों के लिए सभी काल्पनिक लिंक को हटाने और कोड में Mermin के विवरण की व्याख्या करने और इसे अधिक दृश्य बनाने का निर्णय लिया गया। वास्तविक प्रयोग अधिक जटिल होते हैं और उन्हें अनुकरण करने के लिए आपको अधिक समय बिताने की आवश्यकता होती है।

लेख के पहले संस्करण में, हमने स्वीकार किया कि पहले प्रयोग में (सेंसर की स्थिति मेल खाती है), कण एक दर्पण परिणाम देते हैं, लेकिन Mermin के अनुसार मूल विवरण में, सेंसर की उसी स्थिति के साथ माप परिणाम हमेशा मेल खाता है। यह तय है ।

इसके अलावा, मैं खुद इस मर्मिन के "स्पष्टीकरण के लिए स्पष्टीकरण" जोड़ूंगा, क्योंकि यह स्पष्ट रूप से नहीं लिखा गया है:

यही है, उन्हें अग्रिम में सहमत होना चाहिए कि कौन सी प्रतिक्रियाएं, 0 या 1, स्विच स्थिति को दें, प्रत्येक कण को ​​आठ संभावित कार्यों, 000, 001, 010, 011, 100, 101, 110 और 111 में से एक के लिए चुनना।

वाक्यांश "आठ संभावित कार्य" अस्पष्ट है। सेंसर पर कणों के संभावित प्रभाव के आठ संभावित वेरिएंट पर चर्चा की जाती है। सेंसर में तीन स्थिति हैं (ऊपर पूर्ण विवरण देखें)। यदि हम मानते हैं कि दो कणों की स्थिति मेल खाती है और पहले से निर्धारित है, तो हम अग्रिम में निर्धारित कर सकते हैं कि हम किस प्रतिक्रिया (0 या 1) को संभवतः स्विच के तीन पदों में से प्रत्येक के लिए प्राप्त करेंगे (हालांकि हम "केवल तीन विकल्पों में से एक को माप सकते हैं")।

ट्यूनिंग घुंडी की स्थिति की परवाह किए बिना 000 या 111 का चयन डिटेक्टर रीडिंग के 100% मैच में होगा।

यदि कण किसी ऐसे मूल्य पर ले जा सकते हैं जिस पर हम संभावित रूप से किसी भी स्विच स्थिति के लिए "1" की प्रतिक्रिया प्राप्त कर सकते हैं (साथ ही किसी भी स्विच स्थिति के लिए), तो इन मामलों में दूसरा प्रयोग 100% संयोग देगा। 50% तक पहुंचने के लिए, इन विकल्पों को बाहर रखा जा सकता है।

यदि डिटेक्टर छह शेष कार्यों में से एक को कार्यान्वित करते हैं, तो अंकों में से एक को 1/3 मामलों की संभावना वाले 2/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); 

एक ही परीक्षण सभी कण मॉडल के लिए होगा, केवल कण कोड नियतात्मक और सुपरपोजिशन मॉडल के लिए अलग होगा (अधिक से अधिक नीचे)।

नियतात्मक मॉडल

चेतावनी! लेख के अंत में अद्यतन देखें!

जो लोग तुरंत कोड चलाना चाहते हैं, उनके लिए यह ब्राउज़र से किया जा सकता है: 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); //       } } 

यह देखा जा सकता है कि प्रत्येक कणों के मूल्यों को उलझे हुए कणों की एक जोड़ी बनाने के क्षण में सेट किया जाता है, और दूसरे कण के पैरामीटर पहले के मापदंडों के अनुरूप होते हैं (इसके बिना हम पहला परीक्षण पास नहीं कर सकते हैं)। हम यादृच्छिक संख्याओं का उपयोग करते हैं, लेकिन मॉडल के अनुसार, पैरामीटर टंग्लिंग के समय कारकों पर निर्भर करते हैं (रूले के परिणामस्वरूप, यह असंबद्ध के समय कई कारकों पर निर्भर करता है)।

पूर्ण उदाहरण कोड:


आप इसे ब्राउज़र से शुरू कर सकते हैं (एक बार फिर लिंक: 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(); } } } 

सबसे पहले, पैरामीटर अशक्त हैं (वे मायने नहीं रख सकते हैं) और हम उन्हें कंस्ट्रक्टर में सेट नहीं करते हैं। दूसरे, कणों के बीच सुपरलाइट चैनल सेट करने के लिए CreateSuperluminalChannelWith विधि, अर्थात। अब एक कण दूरी की परवाह किए बिना तुरंत दूसरे का राज्य प्राप्त कर सकता है। खैर, और सबसे महत्वपूर्ण बात, अब एक कण की स्थिति केवल माप के समय (गेटवैल्यू पद्धति को कॉल करने) पर स्थापित होती है और इस पर निर्भर करती है कि क्या इससे संबंधित एक और कण मापा गया था।

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

पूर्ण उदाहरण कोड:


परिणाम:

प्रयोग नंबर 1: 100% मूल्यों का संयोग हुआ
प्रयोग नंबर 2: 49.7700% मूल्यों का संयोग हुआ

ब्राउज़र में चलाएं: dotnetfiddle.net/Mb7JqU

निष्कर्ष

मुझे उपलब्ध अधिक व्याख्याएं पसंद हैं, जैसे कि मर्मिन द्वारा व्यक्त की गई। इस व्याख्या के आधार पर, मैं मौजूदा सिद्धांतों के दृश्य मॉडल बनाने में कामयाब रहा और यहां तक ​​कि एक वैकल्पिक मॉडल भी सामने रखा, और ये मॉडल अलौकिक नहीं हैं - आप उन्हें चला सकते हैं और देख सकते हैं कि वे कैसे काम करते हैं।

दुर्भाग्य से, मेरे पास क्वांटम भौतिकी के गहन ज्ञान के लिए समय के संसाधन नहीं हैं और मुझे आशा है कि जो लोग जानते हैं वे मेरे उदाहरण का अनुसरण कर सकते हैं और अधिक सटीक काम करने वाले मॉडल दे सकते हैं।

अद्यतन
Mermin की व्याख्या डिटेक्टरों के डिजाइन के बारे में कुछ भी नहीं है। अपनी पहल पर, मैंने क्रमशः एक्स, वाई और जेड अक्ष पर स्पिन के प्रक्षेपण के रूप में ए, बी और सी के स्पष्टीकरण को जोड़ा। यही है, मैं कोड में टिप्पणियों में भौतिक घटनाओं के लिए एक बंधन जोड़ना चाहता था ताकि यह इतना सूखा न हो। और मैं इस में गलत था ...

लेख को ठीक किया गया है और सभी व्यर्थ के प्रयासों को वास्तविक भौतिक प्रयोगों से Mermin की व्याख्या से जोड़ने का प्रयास किया जाता है।