Oefening: verstrengeling gebruiken om te teleporteren met Q#
In de vorige les hebt u de stappen van het kwantumteleportatieprotocol gecontroleerd. Nu is het uw beurt om Alice en Bob te helpen met hun kwantumteleportatieexperiment.
In deze les maakt u een kwantumteleportatieprogramma waarin Q# het kwantumteleportatieprotocol wordt gebruikt om de status van een qubit van Alice naar Bob te verzenden.
Een kwantumteleportatieprogramma maken in Q#
- Open Visual Studio Code.
- Selecteer Nieuw > tekstbestand bestand en sla het op als Main.qs.
- Selecteer Weergave -> Opdrachtpalet en typQ#: Stel het Azure Quantum QIR-profiel target in. Druk op Enter.
- Selecteer Q#: Onbeperkt.
De vereiste bibliotheken importeren
Eerst moet u de vereiste bibliotheken importeren om de Q# bewerkingen en functies te kunnen gebruiken. Kopieer en plak de volgende code in uw Main.qs-bestand .
import Microsoft.Quantum.Diagnostics.*; // Aka Std.Diagnostics.*;
import Microsoft.Quantum.Intrinsic.*; // Aka Std.Intrinsic.*;
import Microsoft.Quantum.Measurement.*; // Aka Std.Measurement.*;
Teleport
De bewerking definiëren
Eerst moet u de Teleport
bewerking definiëren waarmee het kwantumteleportatieprotocol wordt geïmplementeerd. De bewerking gebruikt twee qubits als invoer: de message
qubit die de kwantumstatus bevat die moet worden geteld en de bob
qubit die de status ontvangt.
operation Teleport(message : Qubit, bob : Qubit) : Unit {
// Allocate an alice qubit.
use alice = Qubit();
// Create some entanglement that we can use to send our message.
H(alice);
CNOT(alice, bob);
// Encode the message into the entangled pair.
CNOT(message, alice);
H(message);
// Measure the qubits to extract the classical data we need to decode
// the message by applying the corrections on the bob qubit
// accordingly.
if M(message) == One {
Z(bob);
}
if M(alice) == One {
X(bob);
}
// Reset alice qubit before releasing.
Reset(alice);
}
Laten we de Teleport
bewerking opsplitsen:
De bewerking maakt gebruik van de
alice
qubit en maakt verstrengeling tussenalice
enbob
qubits. Demessage
qubit wordt vervolgens verstrengeld met dealice
qubit, dus de twee qubits zijn verstrengeld met debob
qubit en demessage
qubit wordt gecodeerd.Vervolgens moet
alice
u meten enmessage
qubits in de belbasis. Hoe kunt u een meting in de belbasis uitdrukken?Q# Dat is niet mogelijk. Of in ieder geval niet rechtstreeks. In Q# u hebt deM
bewerking, die een meting uitvoert in de $Z-basis$ of rekenkundige basis. Als u deM
bewerking dus correct wilt gebruiken, moet u de belstatussen omzetten in de rekenkundige basistoestanden. U kunt dit doen door eenH
bewerking toe te passen op demessage
qubit. In de volgende tabel ziet u de correspondentie tussen de beltoestanden en de rekenkundige basistoestanden.Klokstatus Berekeningsbasisstatus $\ket{\phi^+}$ $\ket{00}$ $\ket{\phi^-}$ $\ket{01}$ $\ket{\psi^+}$ $\ket{10}$ $\ket{\psi^-}$ $\ket{11}$ Tip
Een goede oefening is om de gelijkwaardigheid van de Bell-toestanden en de rekenbasistoestanden te controleren nadat de Hadamard-bewerking is toegepast op de eerste qubit. Succes!
Ten slotte controleren de
if
instructies de meetresultaten en passen ze dienovereenkomstig correcties toe op debob
qubit. Als demessage
qubit wordt gemetenOne
, past u de Z-poort toe op debob
qubit. Als dealice
qubit ook inOne
u wordt gemeten, past u de X-poort toe op debob
qubit.
SetToPlus
De en SetToMinus
bewerkingen definiëren
Als u qubits in verschillende toestanden wilt teleporteren, zoals |0⟩, |1⟩, |+⟩ en |−⟩, moet u de geïnitialiseerde statussen definiëren. U hebt al de Teleport
bewerking om de qubit te teleporteren, maar u moet de qubit in de juiste status voorbereiden voordat u deze teleporteert.
U moet nog twee bewerkingen SetToPlus
definiëren en SetToMinus
een qubit instellen in status |0⟩ respectievelijk op |+⟩ en |−⟩.
/// Sets a qubit in state |0⟩ to |+⟩.
operation SetToPlus(q : Qubit) : Unit is Adj + Ctl {
H(q);
}
/// Sets a qubit in state |0⟩ to |−⟩.
operation SetToMinus(q : Qubit) : Unit is Adj + Ctl {
X(q);
H(q);
}
Main
De bewerking definiëren
Elk Q# programma moet een Main
bewerking hebben die fungeert als het toegangspunt voor het programma. De Main
bewerking voert het teleportatieprotocol uit voor verschillende kwantumstatussen,$\ket{{0}$ , $\ket{1}$$\ket{+}$ en $\ket{-}$.
Laten we de Main
bewerking opsplitsen:
- Met de bewerking worden twee qubits
message
enbob
. - Hiermee definieert u een lijst met tuples die de kwantumstatus bevatten, de initialisatiebewerking die nodig is om de qubit in een dergelijke toestand te initialiseren en de basis voor de teleportatie. De initialisatiebewerkingen zijn
I
voor $\ket{0}$,X
voor $\ket{1}$+SetToPlus
$\ket{}$enSetToMinus
voor .$\ket{-}$ DeSetToPlus
enSetToMinus
bewerkingen worden gedefinieerd in de vorige stappen. - De bewerking doorloopt de lijst met tuples en initialiseert de
message
qubit in de bijbehorende status en gebruiktDumpMachine
om de status weer te geven. Vervolgens wordt de status van demessage
qubit naar debob
qubit geteld met behulp van deTeleport
bewerking die in de vorige stappen is gedefinieerd. - Na het teleporteren van de status meet de bewerking de
bob
qubit in de bijbehorende basis en stelt de qubits opnieuw in om door te gaan met het teleporteren van meer berichten. - Ten slotte retourneert de bewerking de meetresultaten voor elke teleportatie.
operation Main() : Result[] {
// Allocate the message and bob qubits.
use (message, bob) = (Qubit(), Qubit());
// Use the `Teleport` operation to send different quantum states.
let stateInitializerBasisTuples = [
("|0〉", I, PauliZ),
("|1〉", X, PauliZ),
("|+〉", SetToPlus, PauliX),
("|-〉", SetToMinus, PauliX)
];
mutable results = [];
for (state, initializer, basis) in stateInitializerBasisTuples {
// Initialize the message and show its state using the `DumpMachine`
// function.
initializer(message);
Message($"Teleporting state {state}");
DumpMachine();
// Teleport the message and show the quantum state after
// teleportation.
Teleport(message, bob);
Message($"Received state {state}");
DumpMachine();
// Measure bob in the corresponding basis and reset the qubits to
// continue teleporting more messages.
let result = Measure([basis], [bob]);
set results += [result];
ResetAll([message, bob]);
}
return results;
}
Het programma uitvoeren
Uw kwantumteleportatieprogramma is klaar. U kunt het programma uitvoeren om te zien hoe kwantumteleportatie werkt voor verschillende kwantumstatussen. Het programma initialiseert de message
qubit in verschillende statussen en teleporteert de status naar de bob
qubit.
De volgende code bevat de Teleport
bewerking, de SetToPlus
en SetToMinus
bewerkingen en de Main
bewerking waarmee het teleportatieprotocol voor verschillende kwantumstatussen wordt uitgevoerd.
Het bestand Main.qs moet er als volgt uitzien:
/// This Q# program implements quantum teleportation. import Microsoft.Quantum.Diagnostics.*; import Microsoft.Quantum.Intrinsic.*; import Microsoft.Quantum.Measurement.*; operation Main() : Result[] { // Allocate the message and bob qubits. use (message, bob) = (Qubit(), Qubit()); // Use the `Teleport` operation to send different quantum states. let stateInitializerBasisTuples = [ ("|0〉", I, PauliZ), ("|1〉", X, PauliZ), ("|+〉", SetToPlus, PauliX), ("|-〉", SetToMinus, PauliX) ]; mutable results = []; for (state, initializer, basis) in stateInitializerBasisTuples { // Initialize the message and show its state using the `DumpMachine` // function. initializer(message); Message($"Teleporting state {state}"); DumpMachine(); // Teleport the message and show the quantum state after // teleportation. Teleport(message, bob); Message($"Received state {state}"); DumpMachine(); // Measure bob in the corresponding basis and reset the qubits to // continue teleporting more messages. let result = Measure([basis], [bob]); set results += [result]; ResetAll([message, bob]); } return results; } /// # Summary /// Sends the state of one qubit to a bob qubit by using teleportation. /// /// Notice that after calling Teleport, the state of `message` is collapsed. /// /// # Input /// ## message /// A qubit whose state we wish to send. /// ## bob /// A qubit initially in the |0〉 state that we want to send /// the state of message to. operation Teleport(message : Qubit, bob : Qubit) : Unit { // Allocate an alice qubit. use alice = Qubit(); // Create some entanglement that we can use to send our message. H(alice); CNOT(alice, bob); // Encode the message into the entangled pair. CNOT(message, alice); H(message); // Measure the qubits to extract the classical data we need to decode // the message by applying the corrections on the bob qubit // accordingly. if M(message) == One { Z(bob); } if M(alice) == One { X(bob); } // Reset alice qubit before releasing. Reset(alice); } /// # Summary /// Sets a qubit in state |0⟩ to |+⟩. operation SetToPlus(q : Qubit) : Unit is Adj + Ctl { H(q); } /// # Summary /// Sets a qubit in state |0⟩ to |−⟩. operation SetToMinus(q : Qubit) : Unit is Adj + Ctl { X(q); H(q); }
Als u uw programma wilt uitvoeren op de ingebouwde simulator, klikt u op Uitvoeren boven de bewerking of drukt u op
Main
. Uw uitvoer wordt weergegeven in de console voor foutopsporing.Controleer of de ontvangen statussen overeenkomen met de teleporterende statussen. Voorbeeld:
Teleporting state |0〉 DumpMachine: Basis | Amplitude | Probability | Phase ----------------------------------------------- |00⟩ | 1.0000+0.0000𝑖 | 100.0000% | 0.0000 Received state |0〉
Gefeliciteerd! U kunt de status van de qubit van Alice teleporteren naar de qubit van Bob met behulp van het kwantumteleportatieprotocol. Allemaal dankzij kwantumverstrengeling!
In de volgende les test u uw kennis van kwantumteleportatie en verstrengeling.