Geekly articles weekly

Modellierung der Quantenverschränkung in C #

Da das Thema der Quantenverschränkung immer häufiger auftaucht, wollte ich etwas tiefer gehen. Nach den Kommentaren zu Artikeln über Quantenverschränkung zu urteilen, werden diese Informationen für mich allein nicht nützlich sein. Nun, unter Berücksichtigung der Tatsache, dass Programmcode für die meisten von uns viel praktischer ist als alle Allegorien, wurde beschlossen, mein Verständnis in Form von Code darzustellen.

Dieser Artikel erweitert den Artikel eines anderen Autors "Quantum Entanglement for Dummies" (ich empfehle ihn zu lesen, er hat mir sehr geholfen). In seinem Artikel gab indomit ein Beispiel für ein Programm, das das Problem der Theorie der verborgenen Parameter klar demonstriert, aber kein Beispiel für einen Code für Teilchen in Überlagerung geben konnte. In diesem Artikel werden wir versuchen, zwei Fälle zu simulieren:

  1. Wie sich verschränkte Teilchen im Determinismus verhalten würden, wenn der Zustand der Teilchen vor der Messung festgestellt wird, können wir ihn einfach nicht messen, ohne Verzerrungen einzuführen (die Theorie der verborgenen Parameter). Wir bekommen die Zahlen und sehen die Diskrepanz mit der Praxis.
  2. Wir werden ein Modell von verschränkten Partikeln in Überlagerung schreiben (der Zustand der Partikel wird vor der Messung nicht definiert). Nehmen wir an, wie das Partikel im Inneren programmiert ist, dh wir passen seinen Code an die experimentell erhaltenen Daten an.

Der Artikel basiert auf der populären Erklärung des Phänomens der Quantenverschränkung von Mermin:

Minins Paradoxon erklärt
Für den populären Bericht des Paradoxons schlägt D. Mermin vor, ein einfaches Gerät zu konstruieren [23]. Das Gerät sollte aus einem Partikelemitter und zwei Detektoren bestehen. Zu jedem von ihnen werden zwei identische Partikel emittiert. Nachdem der Detektor ein Partikel gefangen hat, gibt er eine binäre Antwort (0 oder 1), abhängig vom Partikel und seinem dreistelligen Abstimmschalter. Das Erkennen eines Partikelpaares sollte die gleichen Antworten geben:

  1. Immer wenn Detektoren auf die gleiche Weise konfiguriert werden.
  2. Laut Statistik in der Hälfte der Fälle, wenn sie zufällig konfiguriert werden.

Die erste Eigenschaft erfordert, dass alle Detektoren dieselbe Codierung verwenden. Die Schalterposition ist ∈ {1,2,3} ↦ Antwort ∈ {0,1} ohne zufälliges Element. Das heißt, sie müssen im Voraus vereinbaren, welche der Antworten 0 oder 1 auf die Schalterposition geben, und für jedes Partikel eine von acht möglichen Funktionen 000, 001, 010, 011, 100, 101, 110 und 111 auswählen. Die Auswahl von 000 oder 111 führt zu zu 100% Übereinstimmung der Messwerte der Detektoren, unabhängig von der Position des Steuerknopfs. Wenn die Detektoren eine der sechs verbleibenden Funktionen implementieren, wird in 2/3 der Fälle eine der Ziffern durch einen zufällig abgestimmten Schalter gezogen, die andere mit einer Wahrscheinlichkeit von 1/3. Die Wahrscheinlichkeit des Zusammentreffens der beiden Antworten beträgt (⅔) ² + (⅓) ² = 5/9. Unabhängig davon, um welchen Automatenalgorithmus es sich handelt, überschreitet die Korrelation zwangsläufig 50%, was die zweite Anforderung verletzt.

Da eine solche Maschine jedoch noch gebaut werden kann (z. B. durch Positionieren der Polarisatoren bei 120 ° wie in Böhms Experiment), kann es auch in versteckter Form keinen Determinismus (Parameter) geben. Stattdessen werden Antwortkorrelationen aufrechterhalten, indem Informationen schneller als bei der zweiten Messung von einem „gemessenen“ Partikel zu einem anderen übertragen werden.

Von hier genommen .

Leider mache ich weder beruflich noch auf Amateurebene Physik, ich gebe nicht vor, fehlerfrei zu sein. Das Hauptziel des Artikels ist es zu demonstrieren, wie ein Modell für diejenigen verständlich gemacht werden kann, die mit Programmierung vertraut sind. Wenn jemand professionell in diesem Bereich arbeitet, versuchen Sie, anstatt Vorwürfe zu machen, genauere Interaktionsmodelle zu schreiben, die auf meinem Artikel basieren.

[Update] Erläuterung der Beschreibung von Mermin


Obwohl seit dem Schreiben des Artikels mehrere Monate vergangen sind und niemand darauf zurückkommen wird, habe ich beschlossen, eine Klarstellung vorzunehmen, um mein Gewissen zu beruhigen.

Ich ging etwas tiefer und kam zu dem Schluss, dass die Beschreibung nach Mermin stark vereinfacht ist und Versuche, sie mit realen physikalischen Experimenten zu verknüpfen, bedeutungslos sind .

Anfangs habe ich versucht, den Artikel mit einem echten Experiment mit zirkularer Polarisation zu verknüpfen, und dabei habe ich einen Fehler gemacht. ARad versuchte, eine Bindung zu realen physikalischen Experimenten zu entwickeln, schrieb über die gemachten Fehler und schlug sogar eine eigene Version des Codes vor (die auch keinem physikalischen Experiment entspricht).

Damit der Artikel zumindest einen Sinn ergibt, wurde beschlossen, alle imaginären Verknüpfungen zu realen physikalischen Experimenten zu entfernen und einfach die Beschreibung von Mermin im Code zu erläutern und visueller zu gestalten. Echte Experimente sind komplizierter und um sie zu simulieren, müssen Sie viel mehr Zeit aufwenden.

In der ersten Version des Artikels haben wir akzeptiert, dass im ersten Experiment (die Position der Sensoren stimmt überein) die Partikel ein Spiegelergebnis ergeben, aber in der ursprünglichen Beschreibung nach Mermin stimmt das Messergebnis mit der gleichen Position der Sensoren immer überein. Dies ist behoben .

Zusätzlich werde ich eine "Erklärung für eine Erklärung" dieses Mermin selbst hinzufügen, da es nicht eindeutig geschrieben ist:

Das heißt, sie müssen im Voraus vereinbaren, welche der Antworten 0 oder 1 der Schalterposition geben, und für jedes Teilchen eine von acht möglichen Funktionen 000, 001, 010, 011, 100, 101, 110 und 111 auswählen.

Der Ausdruck "acht mögliche Funktionen" ist nicht eindeutig. Acht mögliche Varianten des möglichen Einflusses von Partikeln auf den Sensor werden diskutiert. Der Sensor hat drei Positionen (siehe die vollständige Beschreibung oben). Wenn wir glauben, dass der Zustand zweier Partikel übereinstimmt und im Voraus festgelegt wird, können wir im Voraus bestimmen, welche Antwort (0 oder 1) wir möglicherweise für jede der drei Positionen des Schalters erhalten (obwohl wir nur eine von drei Optionen „messen“ können).

Wenn Sie 000 oder 111 auswählen, stimmen die Detektorwerte unabhängig von der Position des Abstimmknopfs zu 100% überein.

Wenn Partikel einen Wert annehmen können, bei dem wir möglicherweise eine Antwort von „1“ für jede Schalterposition (sowie 0 für jede Schalterposition) erhalten können, ergibt das zweite Experiment in diesen Fällen eine 100% ige Übereinstimmung. Um sich 50% zu nähern, können diese Optionen ausgeschlossen werden.

Wenn die Detektoren eine der sechs verbleibenden Funktionen implementieren, wird in 2/3 der Fälle eine der Ziffern durch einen zufällig abgestimmten Schalter gezogen, die andere mit einer Wahrscheinlichkeit von 1/3.

Dies bedeutet, dass in jedem der 6 Tripel (001, 010, 011, 100, 101, 110) nur zwei der drei Ziffern übereinstimmen (in der ersten Version sind zwei der drei "0" und eine der drei "1"). )

Um die Wahrscheinlichkeit einzuschätzen, erstellen wir eine Tabelle für den ersten Fall 001 :

Sensorposition 1Sensorposition 2Stimmen die Maße überein?
11+
12+
13- -
21+
22+
23- -
31- -
32- -
33+

Es ist ersichtlich, dass in fünf Fällen von neun Messungen zusammenfallen. Die gleiche Wahrscheinlichkeit gilt für jede dieser sechs Optionen (schließlich sind in jeder von ihnen die beiden Zahlen gleich).

Messungen


In jedem der Modelle (sowohl deterministisch als auch überlagert) werden wir zwei Experimente mit verschränkten Partikeln durchführen, die den ersten und zweiten Bedingungen gemäß Mermin entsprechen:

  1. Stellen Sie zunächst beide Sensoren auf die gleiche Position. In diesem Fall erhalten wir 100% identische Ergebnisse (wenn das erste Photon den Polarisator passiert, passiert das zugehörige Photon auch den Polarisator im gleichen Winkel).
  2. Dann werden wir die Position der Sensoren zufällig einstellen.

Hier ist der Code für das erste Experiment:

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

Hier ist der Code für das zweite Experiment:

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

Die gleichen Tests werden für alle Partikelmodelle durchgeführt, nur der Partikelcode ist für das deterministische Modell und das Überlagerungsmodell unterschiedlich (mehr dazu weiter unten).

Deterministisches Modell


Achtung! Siehe UPDATE am Ende des Artikels!

Für diejenigen, die den Code sofort ausführen möchten, kann dies über den Browser erfolgen: dotnetfiddle.net/N5Xg18

Nach Minins Erklärung haben wir also ein Quantenteilchen mit drei Parametern:

 //   ( , ) 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(); } } }

Da das Modell deterministisch ist, werden alle Parameter des Partikels zum Zeitpunkt seiner Erstellung, dh direkt im Konstruktor, initialisiert. Die einzige Bedingung ist, dass die Messung nur einmal erlaubt ist!

Weiter. Ein Paar verwickelter Partikel:

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


Es ist ersichtlich, dass die Werte jedes der Partikel zum Zeitpunkt der Erzeugung eines Paares verschränkter Partikel eingestellt werden und die Parameter des zweiten Partikels den Parametern des ersten Partikels entsprechen (ohne dies können wir den ersten Test nicht bestehen). Wir verwenden Zufallszahlen, aber je nach Modell hängen die Parameter von den Faktoren zum Zeitpunkt des Verwickelns ab (aufgrund des Roulettes hängt dies von einer Reihe von Faktoren zum Zeitpunkt des Aufdrehens ab).

Vollständiger Beispielcode:

C # -Code des deterministischen Modells (fest)
 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); //          } }


Sie können es über den Browser starten (noch einmal den Link: dotnetfiddle.net/N5Xg18 ).

Nach dem Start sind dies die Ergebnisse:

Versuch Nr. 1: 100% der Werte stimmten überein
Versuch Nr. 2: 55.6700% der Werte stimmten überein

Der erste bestandene Test entspricht dem, was in der Realität passiert. Aber die zweite - passt nicht zusammen, da sie 50% bekommen sollten!

Infolgedessen mussten die Physiker zu dem Schluss kommen, dass die Theorie der verborgenen Parameter falsch ist. Und damit wird das Prinzip der Lokalität widerlegt und das Prinzip der Kausalität sogar erschüttert.

Überlagerungsmodell


Sofort ein Link zu einem Beispielcode für diejenigen, die Besonderheiten lieben (kann in einem Browser gestartet werden): dotnetfiddle.net/Mb7JqU

Um die während der Experimente erhaltenen Ergebnisse zu erklären, mussten komplexere Modelle verwendet werden. In modernen Modellen wird der Zustand der Partikelparameter vor der Messung nicht definiert, und verschränkte Partikel selbst können sich sofort (über die Lichtgeschwindigkeit hinaus) gegenseitig beeinflussen. So sieht unser Partikelmodell jetzt aus:

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

Erstens sind die Parameter nullbar (sie spielen möglicherweise keine Rolle) und wir setzen sie nicht im Konstruktor. Zweitens die CreateSuperluminalChannelWith-Methode zum Einstellen des Superlichtkanals zwischen Partikeln, d.h. Jetzt kann ein Teilchen unabhängig von der Entfernung sofort den Zustand eines anderen Teilchens erhalten. Nun, und vor allem, jetzt wird der Zustand eines Partikels erst zum Zeitpunkt der Messung (Aufruf der GetValue-Methode) festgestellt und hängt davon ab, ob ein anderes Partikel, das damit zusammenhängt, gemessen wurde.

Das Innere der GetValue-Methode ist reine Spekulation. Niemand weiß, wie das Partikel im Inneren angeordnet ist, aber wir wissen, dass es einfach so funktioniert: 100% Fehlanpassungen bei Messung desselben Parameters und 50% Fehlanpassungen bei Messung von Parametern in zufälliger Reihenfolge.

In meiner Version des Codes prüft ein Partikel durch einen überluminalen Kanal, ob die Messung damit verwechselt wird, und verhält sich wie folgt:

  1. Wenn der gemessene Parameter eines anderen Partikels derselbe ist, den wir messen möchten, ergibt sich der gleiche Wert.
  2. Wenn der Parameter unterschiedlich ist, gibt er in 1/4 der Fälle den gleichen Wert und in 3/4 der Fälle den entgegengesetzten Wert (da wir 50/50 erhalten).

Wenn die Messung nicht durchgeführt wurde, verwendet das Partikel eine echte Zufälligkeit, um seinen Wert festzulegen, dh ein Kausalzusammenhang wird verletzt (der Wert war vor der Messung nicht vorhanden und die Messung selbst hat seinen Wert nicht bestimmt).

Übrigens! Sie können diese Funktion auf andere Weise umschreiben, damit die Testergebnisse identisch sind. Trotzdem weiß niemand, wie das Elementarteilchen angeordnet ist und wie 50% für den zweiten Test erreicht werden.

Ein Paar verschränkter Partikel ist einfacher geworden, da zum Zeitpunkt der Verschränkung keine Werte festgelegt sind (Werte wurden noch nicht bestimmt):

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

Vollständiger Beispielcode:

Überlagerungsmodell in 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); //          } }


Ergebnisse:

Versuch Nr. 1: 100% der Werte stimmten überein
Versuch Nr. 2: 49,77700% der Werte stimmten überein

Führen Sie im Browser aus: dotnetfiddle.net/Mb7JqU

Schlussfolgerungen


Ich hätte gerne mehr Interpretationen, wie die von Mermin. Basierend auf dieser Interpretation habe ich es geschafft, visuelle Modelle bestehender Theorien zu erstellen und sogar ein alternatives Modell vorzuschlagen, und diese Modelle sind nicht allegorisch - Sie können sie ausführen und sehen, wie sie funktionieren.

Leider habe ich nicht die Zeitressourcen für ein tieferes Wissen über die Quantenphysik und ich hoffe, dass diejenigen, die es wissen, meinem Beispiel folgen und genauere Arbeitsmodelle geben können.

UPDATE
Minins Erklärung bezieht sich nicht auf das Design von Detektoren. Aus eigener Initiative fügte ich A, B und C eine Erklärung als Projektion des Spins auf die X-, Y- und Z-Achse hinzu. Das heißt, ich wollte in den Kommentaren zum Code eine Bindung zu physikalischen Phänomenen hinzufügen, damit er nicht so trocken wird. Und ich habe mich geirrt ...

Der Artikel wird korrigiert und alle vergeblichen Versuche, Minins Erklärung mit realen physikalischen Experimenten zu verknüpfen, werden gelöscht.

Source: https://habr.com/ru/post/de420611/

More articles:


All Articles