Quantengrundlagen mit Q#Quantum basics with Q#

In dieser Schnellstartanleitung wird veranschaulicht, wie Sie ein Q#-Programm schreiben, mit dem Qubits bearbeitet und gemessen werden können. Darüber hinaus werden die Auswirkungen der Überlagerung und Verschränkung dargestellt.In this Quickstart, we show you how to write a Q# program that manipulates and measures qubits and demonstrates the effects of superposition and entanglement. Es wird beschrieben, wie Sie das QDK installieren und das Programm erstellen und mit einem Quantensimulator ausführen.This guides you on installing the QDK, building the program and executing that program on a quantum simulator.

Sie schreiben eine Anwendung mit dem Namen „Bell“, um die Quantenverschränkung zu veranschaulichen.You will write an application called Bell to demonstrate quantum entanglement. Der Name „Bell“ bezieht sich auf die Bell-Zustände. Hierbei handelt es sich um spezifische Quantenzustände von zwei Qubits, die zum Darstellen der einfachsten Beispiele für Überlagerungen und Quantenverschränkungen verwendet werden.The name Bell is in reference to Bell states, which are specific quantum states of two qubits that are used to represent the simplest examples of superposition and quantum entanglement.

VoraussetzungenPre-requisites

Führen Sie zunächst diese Schritte aus, wenn Sie bereit zum Codieren sind:If you are ready to start coding, follow these steps before proceeding:

  • Installieren Sie das Quantum Development Kit in Ihrer bevorzugten Sprache und EntwicklungsumgebungInstall the Quantum Development Kit using your preferred language and development environment
  • Wenn das QDK bereits installiert ist, vergewissern Sie sich, dass es auf die neueste Version geupdated wurdeIf you already have the QDK installed, make sure you have updated to the latest version

Sie können den Vorgang auch ohne Installation des QDK durchführen, indem Sie sich die Übersichten zur Q#-Programmiersprache und die wichtigsten Konzepte des Quantencomputings ansehen.You can also follow along with the narrative without installing the QDK, reviewing the overviews of the Q# programming language and the first concepts of quantum computing.

Veranschaulichen des Qubit-Verhaltens mit Q#Demonstrating qubit behavior with Q#

Denken Sie an unsere einfache Qubit-Definition zurück.Recall our simple definition of a qubit. Klassische Bits enthalten einen einzelnen binären Wert (0 oder 1). Der Zustand eines Qubits kann dagegen eine Superposition sein (also 0 und 1 gleichzeitig).Where classical bits hold a single binary value such as a 0 or 1, the state of a qubit can be in a superposition of 0 and 1 simultaneously. Vom Konzept her können Sie sich ein Qubit als eine Richtung im Raum vorstellen (auch als Vektor bezeichnet).Conceptually, a qubit can be thought of as a direction in space (also known as a vector). Ein Qubit kann eine beliebige der möglichen Richtungen aufweisen.A qubit can be in any of the possible directions. Die beiden klassischen Zustände sind die beiden Richtungen, die für die einhundertprozentige Chance einer Messung von 0 und die einhundertprozentige Chance einer Messung von 1 stehen.The two classical states are the two directions; representing 100% chance of measuring 0 and 100% chance of measuring 1. Diese Darstellung wird formal durch die Bloch-Kugel visualisiert.This representation is also more formally visualized by the bloch sphere.

Mit dem Messvorgang wird ein binäres Ergebnis erzeugt und ein Qubit-Zustand geändert.The act of measurement produces a binary result and changes a qubit state. Bei der Messung wird ein binärer Wert erzeugt (0 oder 1).Measurement produces a binary value, either 0 or 1. Das Qubit geht von einem Überlagerungszustand (beliebige Richtung) in einen der klassischen Zustände über.The qubit goes from being in superposition (any direction) to one of the classical states. Danach führt die Wiederholung der gleichen Messung ohne Eingriff zu demselben binären Ergebnis.Thereafter, repeating the same measurement without any intervening operations produces the same binary result.

Mehrere Qubits können verschränkt sein.Multiple qubits can be entangled. Bei der Messung eines verschränkten Qubits wird unsere Kenntnis des Zustands der anderen Qubits ebenfalls aktualisiert.When we make a measurement of one entangled qubit, our knowledge of the state of the other(s) is updated as well.

Nun können wir veranschaulichen, wie dieses Verhalten von Q# ausgedrückt wird.Now, we're ready to demonstrate how Q# expresses this behavior. Sie beginnen mit dem einfachsten möglichen Programm und erweitern es anschließend, um die Quantenüberlagerung und -verschränkung zu demonstrieren.You start with the simplest program possible and build it up to demonstrate quantum superposition and quantum entanglement.

EinrichtenSetup

Anwendungen, die mit dem Quantum Development Kit von Microsoft entwickelt wurden, bestehen aus zwei Teilen:Applications developed with Microsoft's Quantum Development Kit consist of two parts:

  1. Einem oder mehreren Quantenalgorithmen, die mithilfe der Quantenprogrammiersprache Q# implementiert wurden.One or more quantum algorithms, implemented using the Q# quantum programming language.
  2. Einem Hostprogramm, das in einer Programmiersprache wie Python oder C# implementiert wurde, das als Haupteinstiegspunkt dient und Q#-Vorgänge aufruft, um einen Quantenalgorithmus auszuführen.A host program, implemented in a programming language like Python or C# that serves as the main entry point and invokes Q# operations to execute a quantum algorithm.
  1. Wählen Sie einen Speicherort für Ihre Anwendung ausChoose a location for your application

  2. Erstellen Sie eine Datei namens Bell.qs.Create a file called Bell.qs. Diese Datei enthält Ihren Q #-Code.This file will contain your Q# code.

  3. Erstellen Sie eine Datei namens host.py.Create a file called host.py. Diese Datei enthält Ihren Python-Hostcode.This file will contain your Python host code.

Schreiben einer Q#-OperationWrite a Q# operation

Unser Ziel ist die Festlegung eines spezifischen Quantenzustands für zwei Qubits. Hiermit soll demonstriert werden, wie Sie mit Q# bei Qubits vorgehen, um den Zustand zu ändern und die Auswirkungen von Überlagerung und Verschränkung zu veranschaulichen.Our goal is to prepare two qubits in a specific quantum state, demonstrating how to operate on qubits with Q# to change their state and demonstrate the effects of superposition and entanglement. Wir bauen dies Stück für Stück auf, um Zustände, Vorgänge und Messungen von Qubits zu demonstrieren.We will build this up piece by piece to demonstrate qubit states, operations, and measurement.

Übersicht: Im ersten unten aufgeführten Code wird gezeigt, wie Sie in Q# mit Qubits arbeiten.Overview: In the first code below, we show you how to work with qubits in Q#. Wir verwenden die beiden Vorgänge M und X, um den Zustand eines Qubits zu transformieren.We’ll introduce two operations, M and X that transform the state of a qubit.

In diesem Codeausschnitt wird der Vorgang Set definiert, für den als Parameter ein Qubit verwendet wird, sowie ein weiterer Parameter desired, mit dem der gewünschte Zustand für das Qubit dargestellt wird.In this code snippet, an operation Set is defined that takes as a parameter a qubit and another parameter, desired, representing the state that we would like the qubit to be in. Der Vorgang Set führt eine Messung für das Qubit durch, indem der Vorgang M verwendet wird.The operation Set performs a measurement on the qubit using the operation M. In Q# wird für eine Qubit-Messung immer entweder Zero oder One zurückgegeben.In Q#, a qubit measurement always returns either Zero or One. Wenn die Messung einen Wert zurückgibt, der nicht einem gewünschten Wert entspricht, wird das Qubit von „Set“ umgekehrt. Der Vorgang X wird ausgeführt, mit dem der Qubit-Zustand in einen neuen Zustand geändert wird, bei dem die Wahrscheinlichkeiten, dass für eine Messung Zero und One zurückgegeben wird, umgekehrt sind.If the measurement returns a value not equal to a desired value, Set “flips” the qubit; that is, it executes an X operation, which changes the qubit state to a new state in which the probabilities of a measurement returning Zero and One are reversed. Zur Veranschaulichung der Auswirkungen des Vorgangs Set wird dann der Vorgang TestBellState hinzugefügt.To demonstrate the effect of the Set operation, a TestBellState operation is then added. Für diesen Vorgang wird Zero oder One als Eingabe verwendet, und der Vorgang Set wird einige Male mit dieser Eingabe aufgerufen. Es wird gezählt, wie oft bei der Messung des Qubits Zero und wie oft One zurückgegeben wird.This operation takes as input a Zero or One, and calls the Set operation some number of times with that input, and counts the number of times that Zero was returned from the measurement of the qubit and the number of times that One was returned. Bei der ersten Simulation des Vorgangs TestBellState erwarten wir natürlich, dass in der Ausgabe für alle Messungen des Qubits mit Zero als Parametereingabe Zero und für alle Messungen eines Qubits mit One als Parametereingabe One zurückgegeben wird.Of course, in this first simulation of the TestBellState operation, we expect that the output will show that all measurements of the qubit set with Zero as the parameter input will return Zero, and all measurements of a qubit set with One as the parameter input will return One. Später fügen wir TestBellState Code hinzu, um die Überlagerung und Verschränkung zu demonstrieren.Further on, we’ll add code to TestBellState to demonstrating superposition and entanglement.

Q#-OperationscodeQ# operation code

  1. Ersetzen Sie den Inhalt der Datei „Bell.qs“ durch den folgenden Code:Replace the contents of the Bell.qs file with the following code:

    namespace Quantum.Bell {
        open Microsoft.Quantum.Intrinsic;
        open Microsoft.Quantum.Canon;
    
        operation Set(desired : Result, q1 : Qubit) : Unit {
            if (desired != M(q1)) {
                X(q1);
            }
        }
    }
    

    Dieser Vorgang kann jetzt aufgerufen werden, um ein Qubit auf einen klassischen Zustand festzulegen, indem entweder immer Zero oder immer One zurückgegeben wird.This operation may now be called to set a qubit to a classical state, either returning Zero 100% of the time or returning One 100% of the time. Zero und One sind Konstanten, die die beiden einzigen möglichen Ergebnisse der Messung eines Qubits darstellen.Zero and One are constants that represent the only two possible results of a measurement of a qubit.

    Mit dem Vorgang Set wird das Qubit gemessen.The operation Set measures the qubit. Falls sich das Qubit im gewünschten Zustand befindet, wird es von Set unverändert gelassen. Andernfalls ändern wir den Qubit-Zustand in den gewünschten Zustand, indem wir den Vorgang X ausführen.If the qubit is in the state we want, Set leaves it alone; otherwise, by executing the X operation, we change the qubit state to the desired state.

Informationen zu Q#-VorgängenAbout Q# operations

Ein Q#-Vorgang ist eine Quantenunterroutine.A Q# operation is a quantum subroutine. Dies bedeutet, dass es sich um eine aufrufbare Routine handelt, die Quantenvorgänge enthält.That is, it is a callable routine that contains quantum operations.

Die Argumente für eine Operation werden als Tupel angegeben, in Klammern eingeschlossen.The arguments to an operation are specified as a tuple, within parentheses.

Der Rückgabetyp der Operation wird nach einem Doppelpunkt angegeben.The return type of the operation is specified after a colon. In diesem Fall hat die Operation Set keinen Rückgabewert, daher ist sie als Unit zurückgebend markiert.In this case, the Set operation has no return, so it is marked as returning Unit. Dies ist die Q#-Entsprechung von unit in F#, das in etwa analog zu void in C# und einem leeren Tupel (Tuple[()]) in Python ist.This is the Q# equivalent of unit in F#, which is roughly analogous to void in C#, and an empty tuple (Tuple[()]) in Python.

Sie haben in Ihrem ersten Q#-Vorgang zwei Quantenvorgänge verwendet:You have used two quantum operations in your first Q# operation:

  • Den Vorgang M, mit dem der Zustand des Qubits gemessen wirdThe M operation, which measures the state of the qubit
  • Den Vorgang X, mit dem der Zustand eines Qubits umgekehrt wirdThe X operation, which flips the state of a qubit

Mit einem Quantenvorgang wird der Zustand eines Qubits transformiert.A quantum operation transforms the state of a qubit. Analog zu klassischen Logikgattern wird anstelle von Vorgängen auch von Quantengattern gesprochen.Sometime people talk about quantum gates instead of operations, in analogy to classical logic gates. Diese Bezeichnung stammt aus den Anfängen des Quantencomputings, als Algorithmen lediglich ein theoretisches Konstrukt waren und in Form von Diagrammen visualisiert wurden – ähnlich wie bei einem Schaltplan im Bereich des klassischen Computings.This is rooted in the early days of quantum computing when algorithms were merely a theoretical construct and visualized as diagrams similarly to circuit diagrams in classical computing.

Hinzufügen von Q#-TestcodeAdd Q# test code

  1. Fügen Sie der Bell.qs-Datei die folgende Operation hinzu, innerhalb des Namespaces, nach dem Ende der Set-Operation:Add the following operation to the Bell.qs file, inside the namespace, after the end of the Set operation:

    operation TestBellState(count : Int, initial : Result) : (Int, Int) {
    
        mutable numOnes = 0;
        using (qubit = Qubit()) {
    
            for (test in 1..count) {
                Set(initial, qubit);
                let res = M(qubit);
    
                // Count the number of ones we saw:
                if (res == One) {
                    set numOnes += 1;
                }
            }
            Set(Zero, qubit);
        }
    
        // Return number of times we saw a |0> and number of times we saw a |1>
        return (count-numOnes, numOnes);
    }
    

    Diese Operation (TestBellState) iteriert count Iterationen lang in einer Schleife, legt einen angegebenen initial-Wert für ein Qubit fest, und misst (M) dann das Ergebnis.This operation (TestBellState) will loop for count iterations, set a specified initial value on a qubit and then measure (M) the result. Sie führt eine Statistik zur Anzahl der gemessenen Nullen und Einsen und gibt diese an den Aufrufer zurück.It will gather statistics on how many zeros and ones we've measured and return them to the caller. Sie führt eine weitere erforderliche Operation aus.It performs one other necessary operation. Sie setzt das Qubit auf einen bekannten Zustand (Zero) zurück, bevor sie es zurückgibt, was es anderen ermöglicht, dieses Qubit in einem bekannten Zustand zuzuweisen.It resets the qubit to a known state (Zero) before returning it allowing others to allocate this qubit in a known state. Dies ist aufgrund der using-Anweisung erforderlich.This is required by the using statement.

Informationen zu Variablen in Q#About variables in Q#

Standardmäßig sind Variablen in Q# unveränderlich; ihr Wert kann nach der Bindung nicht geändert werden.By default, variables in Q# are immutable; their value may not be changed after they are bound. Das let-Schlüsselwort wird verwendet, um die Bindung einer unveränderlichen Variable anzugeben.The let keyword is used to indicate the binding of an immutable variable. Operationsargumente sind immer unveränderlich.Operation arguments are always immutable.

Wenn Sie eine Variable benötigen, deren Wert geändert werden kann, wie etwa numOnes im Beispiel, können Sie die Variable mit dem Schlüsselwort mutable deklarieren.If you need a variable whose value can change, such as numOnes in the example, you can declare the variable with the mutable keyword. Der Wert einer veränderlichen Variable kann mithilfe einer set-Anweisung geändert werden.A mutable variable's value may be changed using a set statement.

In beiden Fällen wird der Typ einer Variablen vom Compiler abgeleitet.In both cases, the type of a variable is inferred by the compiler. Q# erfordert keine Typanmerkungen für Variablen.Q# doesn't require any type annotations for variables.

Informationen zu using-Anweisungen in Q#About using statements in Q#

Die using-Anweisung ist eine weitere Besonderheit in Q#.The using statement is also special to Q#. Sie wird verwendet, um Qubits für die Verwendung in einem Codeblock zuzuweisen.It is used to allocate qubits for use in a block of code. In Q# werden alle Qubits dynamisch zugewiesen und freigegeben, sie stellen also keine festen Ressourcen dar, die für die gesamte Lebensdauer eines komplexen Algorithmus vorhanden sind.In Q#, all qubits are dynamically allocated and released, rather than being fixed resources that are there for the entire lifetime of a complex algorithm. Eine using-Anweisung weist eine Reihe Qubits am Anfang zu und gibt diese Qubits am Ende des Blocks wieder frei.A using statement allocates a set of qubits at the start, and releases those qubits at the end of the block.

Erstellen des HostanwendungscodesCreate the host application code

  1. Öffnen Sie die Datei host.py, und fügen Sie den folgenden Code hinzu:Open the host.py file and add the following code:

    import qsharp
    
    from qsharp import Result
    from Quantum.Bell import TestBellState
    
    initials = (Result.Zero, Result.One)
    
    for i in initials:
      res = TestBellState.simulate(count=1000, initial=i)
      (num_zeros, num_ones) = res
      print(f'Init:{i: <4} 0s={num_zeros: <4} 1s={num_ones: <4}')
    

Informationen zum HostanwendungscodeAbout the host application code

Die Python-Hostanwendung weist drei Teile auf:The Python host application has three parts:

  • Berechnen aller Argumente, die für den Quantenalgorithmus erforderlich sind.Compute any arguments required for the quantum algorithm. Im Beispiel ist count auf 1000 festgelegt, und initial ist der Anfangswert des Qubits.In the example, count is fixed at a 1000 and initial is the initial value of the qubit.
  • Ausführen des Quantenalgorithmus durch Aufrufen der simulate()-Methode der importierten Q#-Operation.Run the quantum algorithm by calling the simulate() method of the imported Q# operation.
  • Verarbeiten des Ergebnisses der Operation.Process the result of the operation. Im Beispiel empfängt res das Ergebnis der Operation.In the example, res receives the result of the operation. Hier ist das Ergebnis ein Tupel der Anzahl von Nullen (num_zeros) und der Anzahl von Einsen (num_ones), die vom Simulator gemessen wurden.Here the result is a tuple of the number of zeros (num_zeros) and number of ones (num_ones) measured by the simulator. Wir dekonstruieren das Tupel, um die zwei Felder zu erhalten, und geben die Ergebnisse aus.We deconstruct the tuple to get the two fields, and print the results.

Erstellen und AusführenBuild and run

  1. Führen Sie den folgenden Befehl an Ihrem Terminal aus:Run the following command at your terminal:

    python host.py
    

    Dieser Befehl führt die Hostanwendung aus, die die Q#-Operation simuliert.This command runs the host application, which simulates the Q# operation.

Dies sollten die Ergebnisse sein:The results should be:

Init:0    0s=1000 1s=0   
Init:1    0s=0    1s=1000

Vorbereiten von ÜberlagerungPrepare superposition

Übersicht Wir sehen uns nun an, wie in Q# die Überlagerung von Qubits erzielt wird.Overview Now let’s look at how Q# expresses ways to put qubits in superposition. Sie wissen bereits, dass der Zustand eines Qubits den Überlagerungswert 0 und 1 aufweisen kann.Recall that the state of a qubit can be in a superposition of 0 and 1. Wir verwenden den Vorgang Hadamard, um dies zu erreichen.We’ll use the Hadamard operation to accomplish this. Wenn das Qubit einen der klassischen Zustände aufweist (bei dem für eine Messung immer Zero oder immer One zurückgegeben wird), versetzt der Vorgang Hadamard bzw. H das Qubit in einen Zustand, in dem für eine Messung des Qubits in 50 % der Fälle Zero und in 50 % der Fälle One zurückgegeben wird.If the qubit is in either of the classical states (where a measurement returns Zero always or One always), then the Hadamard or H operation will put the qubit in a state where a measurement of the qubit will return Zero 50% of the time and return One 50% of the time. Sie können sich das Qubit als Mischung von Zero und One vorstellen.Conceputually, the qubit can be thought of as halfway between the Zero and One. Wenn wir nun den Vorgang TestBellState simulieren, sehen wir nach der Messung, dass ungefähr mit der gleichen Häufigkeit Zero und One als Ergebnis zurückgegeben wird.Now, when we simulate the TestBellState operation, we will see the results will return roughly an equal number of Zero and One after measurement.

Zuerst versuchen wir, das Qubit umzukehren (wenn das Qubit den Zustand Zero aufweist, wird in One umgekehrt (bzw. andersherum)).First we'll just try to flip the qubit (if the qubit is in Zero state will flip to One and vice versa). Dies wird dadurch erreicht, dass wir den Vorgang X durchführen, bevor die Messung in TestBellState erfolgt:This is accomplished by performing an X operation before we measure it in TestBellState:

X(qubit);
let res = M(qubit);

Jetzt sind die Ergebnisse (nach dem Drücken von F5) umgekehrt:Now the results (after pressing F5) are reversed:

Init:Zero 0s=0    1s=1000
Init:One  0s=1000 1s=0

Aber alles, was wir bisher gesehen haben, ist klassisch.However, everything we've seen so far is classical. Rufen wir mal ein Quantenergebnis ab.Let's get a quantum result. Hierfür müssen wir lediglich den Vorgang X in der vorherigen Ausführung durch den Vorgang H (Hadamard-Vorgang) ersetzen.All we need to do is replace the X operation in the previous run with an H or Hadamard operation. Statt das Qubit ganz von 0 in 1 umzukehren, kehren wir es nur halb um.Instead of flipping the qubit all the way from 0 to 1, we will only flip it halfway. Die ersetzten Zeilen in TestBellState sehen jetzt so aus:The replaced lines in TestBellState now look like:

H(qubit);
let res = M(qubit);

Jetzt werden die Ergebnisse interessanter:Now the results get more interesting:

Init:Zero 0s=484  1s=516
Init:One  0s=522  1s=478

Jedes Mal, wenn wir messen, fragen wir nach einem klassischen Wert, aber das Qubit befindet sich auf halbem Weg zwischen 0 und 1, also erhalten wir (statistisch) die Hälfte der Zeit 0 und die Hälfte der Zeit 1.Every time we measure, we ask for a classical value, but the qubit is halfway between 0 and 1, so we get (statistically) 0 half the time and 1 half the time. Dies wird als Überlagerung bezeichnet und gibt uns unseren ersten echten Einblick in einen Quantenzustand.This is known as superposition and gives us our first real view into a quantum state.

Vorbereiten von VerschränkungPrepare entanglement

Übersicht: Als Nächstes sehen wir uns an, wie Qubits in Q# verschränkt werden.Overview: Now let’s look at how Q# expresses ways to entangle qubits. Zuerst legen wir das erste Qubit auf den Anfangszustand fest und verwenden dann den Vorgang H, um die Überlagerung zu erzielen.First, we set the first qubit to the initial state and then use the H operation to put it into superposition. Vor dem Messen des ersten Qubits verwenden wir den neuen Vorgang CNOT. Diese Abkürzung steht für „Controlled-Not“.Then, before we measure the first qubit, we use a new operation (CNOT), which stands for Controlled-Not. Das Ergebnis der Ausführung dieses Vorgangs für zwei Qubits ist, dass das zweite Qubit umgekehrt wird, wenn das erste Qubit One ist.The result of executing this operation on two qubits is to flip the second qubit if the first qubit is One. Die beiden Qubits sind nun verschränkt.Now, the two qubits are entangled. Unsere Statistiken für das erste Qubit haben sich nicht geändert (50:50-Wahrscheinlichkeit für Zero oder One nach der Messung), aber wenn wir jetzt das zweite Qubit messen, erhalten wir immer das gleiche Ergebnis wie bei der Messung des ersten Qubits.Our statistics for the first qubit haven't changed (50-50 chance of a Zero or a One after measurement), but now when we measure the second qubit, it is always the same as what we measured for the first qubit. Unser CNOT hat die zwei Qubits verschränkt, sodass was immer mit dem einen von ihnen geschieht, auch mit dem anderen geschieht.Our CNOT has entangled the two qubits, so that whatever happens to one of them, happens to the other. Wenn Sie die Messungen umkehrten (das zweite Qubit vor dem ersten messen), würde das Gleiche passieren.If you reversed the measurements (did the second qubit before the first), the same thing would happen. Die erste Messung wäre zufällig, und die zweite wäre im Gleichschritt mit dem, was bei der ersten herausgefunden wurde.The first measurement would be random and the second would be in lock step with whatever was discovered for the first.

Im ersten Schritt müssen wir dazu in TestBellState 2 Qubits anstelle von einem zuweisen:The first thing we'll need to do is allocate 2 qubits instead of one in TestBellState:

using ((q0, q1) = (Qubit(), Qubit())) {

Dies ermöglicht es uns, einen neuen Vorgang (CNOT) hinzuzufügen, bevor wir in TestBellState die Messung (M) durchführen:This will allow us to add a new operation (CNOT) before we measure (M) in TestBellState:

Set(initial, q0);
Set(Zero, q1);

H(q0);
CNOT(q0, q1);
let res = M(q0);

Wir haben eine weitere Set-Operation hinzugefügt, um das erste Qubit zu initialisieren, um sicherzustellen, dass es sich anfangs immer im Zero-Zustand befindet.We've added another Set operation to initialize the first qubit to make sure that it's always in the Zero state when we start.

Wir müssen außerdem das zweite Qubit zurücksetzen, bevor wir es freigeben.We also need to reset the second qubit before releasing it.

Set(Zero, q0);
Set(Zero, q1);

Die vollständige Routine sieht jetzt so aus:The full routine now looks like this:

    operation TestBellState(count : Int, initial : Result) : (Int, Int) {

        mutable numOnes = 0;
        using ((q0, q1) = (Qubit(), Qubit())) {
            for (test in 1..count) {
                Set (initial, q0);
                Set (Zero, q1);

                H(q0);
                CNOT(q0,q1);
                let res = M(q0);

                // Count the number of ones we saw:
                if (res == One) {
                    set numOnes += 1;
                }
            }
            
            Set(Zero, q0);
            Set(Zero, q1);
        }

        // Return number of times we saw a |0> and number of times we saw a |1>
        return (count-numOnes, numOnes);
    }

Wenn wir dies ausführen, erhalten wir exakt das gleiche 50-50-Ergebnis, das wir zuvor erhalten haben.If we run this, we'll get exactly the same 50-50 result we got before. Woran wir interessiert sind, ist aber die Reaktion des zweiten Qubits auf die Messung des ersten.However, what we're interested in is how the second qubit reacts to the first being measured. Wir fügen diese Statistik mit einer neuen Version der TestBellState-Operation hinzu:We'll add this statistic with a new version of the TestBellState operation:

    operation TestBellState(count : Int, initial : Result) : (Int, Int, Int) {
        mutable numOnes = 0;
        mutable agree = 0;
        using ((q0, q1) = (Qubit(), Qubit())) {
            for (test in 1..count) {
                Set(initial, q0);
                Set(Zero, q1);

                H(q0);
                CNOT(q0, q1);
                let res = M(q0);

                if (M(q1) == res) {
                    set agree += 1;
                }

                // Count the number of ones we saw:
                if (res == One) {
                    set numOnes += 1;
                }
            }
            
            Set(Zero, q0);
            Set(Zero, q1);
        }

        // Return number of times we saw a |0> and number of times we saw a |1>
        return (count-numOnes, numOnes, agree);
    }

Der neue Rückgabewert (agree) hält fest, wenn die Messung des ersten Qubits mit der Messung des zweiten Qubits übereinstimmt.The new return value (agree) keeps track of every time the measurement from the first qubit matches the measurement of the second qubit. Außerdem müssen wir die Hostanwendung entsprechend aktualisieren:We also have to update the host application accordingly:

import qsharp

from qsharp import Result
from Quantum.Bell import TestBellState

initials = {Result.Zero, Result.One} 

for i in initials:
    res = TestBellState.simulate(count=1000, initial=i)
    (num_zeros, num_ones, agree) = res
    print(f'Init:{i: <4} 0s={num_zeros: <4} 1s={num_ones: <4} agree={agree: <4}')

Bei einer erneuten Ausführung erhalten wir jetzt etwas ziemlich Erstaunliches:Now when we run, we get something pretty amazing:

Init:Zero 0s=499  1s=501  agree=1000
Init:One  0s=490  1s=510  agree=1000

Wie in der Übersicht beschrieben, haben sich unsere Statistiken für das erste Qubit nicht geändert (50:50-Wahrscheinlichkeit für 0 oder 1), aber wenn wir jetzt das zweite Qubit messen, erhalten wir immer das gleiche Ergebnis wie bei der Messung des ersten Qubits, weil sie verschränkt sind.As stated in the overview, our statistics for the first qubit haven't changed (50-50 chance of a 0 or a 1), but now when we measure the second qubit, it is always the same as what we measured for the first qubit, because they are entangled!

Herzlichen Glückwunsch, Sie haben Ihr erstes Quantenprogramm geschrieben!Congratulations, you've written your first quantum program!

Wie geht es weiter?What's next?

In der Schnellstartanleitung zur Grover-Suche wird veranschaulicht, wie Sie die Grover-Suche erstellen und ausführen. Dies ist einer der beliebtesten Algorithmen des Quantencomputings und ein schönes Beispiel für ein Q#-Programm, das zum Lösen echter Probleme im Bereich des Quantencomputings eingesetzt werden kann.The QuickStart Grover’s search shows you how to build and run Grover search, one of the most popular quantum computing algorithms and offers a nice example of a Q# program that can be used to solve real problems with quantum computing.

Der Artikel zum Einstieg in das Quantum Development Kit enthält Informationen zu weiteren Möglichkeiten, wie Sie Q# und die Quantenprogrammierung erlernen können.Get Started with the Quantum Development Kit recommends more ways to learn Q# and quantum programming.