Teleportálás létrehozása Q#

9 perc

Most a te sorod, hogy segíts Alice-nek és Bobnak a kvantum teleportációs kísérletükkel! Létre fog hozni egy kvantum teleportációs programot, amely Q# a kvantum teleportálási protokollt használja egy qubit állapotának alice-ből Bobnak való elküldéséhez.

Kvantum teleportálási program létrehozása a következőben: Q#

Nyissa meg a Visual Studio Code-ot.
Válassza az Új szövegfájl fájlja > lehetőséget, és mentse a fájlkéntTeleportation.qs.
Válassza a Nézet – Parancskatalógus lehetőséget, és írja beQ# az Azure Quantum QIR-profilttarget.> Nyomja le az Enter billentyűt.
Válassza a Q#következőt: Korlátlan.

A művelet definiálása `Teleport`

Először meg kell határoznia a Teleport kvantum teleportációs protokollt implementáló műveletet. A művelet bemenetként két qubitet vesz igénybe: a message teleportálni kívánt kvantumállapotot tartalmazó qubitet és az bob állapotot fogadó qubitet.

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

Bontsuk le a Teleport műveletet:

A művelet a qubitet alice használja, és összefonódást hoz létre a qubitek és bob a qubitek közöttalice. A message qubit ezután összefonódik a alice qubittel, így a két qubit össze van fonva a bob qubittel, és a message kódolt.
Ezután meg kell mérnie és message qubiteket kell mérnie alice a Bell alapján. Hogyan fejezhet ki egy mérést a Bell alapján Q#? Ez nem kezelhető. Vagy legalábbis nem közvetlenül. Ebben Q# az esetben a M művelet Z-alapon vagy számítási alapon végez méréseket$$. A művelet helyes használatához M át kell alakítania a Bell-állapotokat számítási alapállapotokká. Ezt úgy teheti meg, hogy egy H műveletet alkalmaz a message qubitre. Az alábbi táblázat a Bell-állapotok és a számítási alapállapotok közötti megfeleltetéseket mutatja be.

Harang állapota Számítási alapállapot

$\ket{\phi^+}$ $\ket{00}$

$\ket{\phi^-}$ $\ket{01}$

$\ket{\psi^+}$ $\ket{10}$

$\ket{\psi^-}$ $\ket{11}$

Tipp.

Jó gyakorlat a Bell-állapotok és a számítási alapállapotok egyenértékűségének ellenőrzése a Hadamard-művelet első qubitre való alkalmazása után. Sok sikert!
Végül az if utasítások ellenőrzik a mérési eredményeket, és ennek megfelelően korrekciókat alkalmaznak a bob qubitre. Ha a message qubit mérése Onefolyamatban van, alkalmazza a Z kaput a bob qubitre. Ha a alice qubitet is méri One , alkalmazza az X kaput a bob qubitre.

Harang állapota	Számítási alapállapot
$\ket{\phi^+}$	$\ket{00}$
$\ket{\phi^-}$	$\ket{01}$
$\ket{\psi^+}$	$\ket{10}$
$\ket{\psi^-}$	$\ket{11}$

A műveletek és `SetToMinus` a műveletek `SetToPlus` meghatározása

Ha különböző állapotokban szeretne qubiteket teleportálni, például |0⟩, |1⟩, |+⟩ és |−⟩, meg kell határoznia az inicializált állapotokat. Már rendelkezik a Teleport qubit teleportálására vonatkozó művelettel, de a teleportálás előtt a qubitet a megfelelő állapotban kell előkészítenie.

További két műveletet kell definiálnia, SetToPlus és SetToMinusa qubit 0 állapotban |való beállításához ⟩ a |+⟩ és |a −⟩ értékre.

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

A program futtatása

A kvantum teleportálási program készen áll! A programot futtatva megnézheti, hogyan működik a kvantum teleportálás a különböző kvantumállapotokban. A program inicializálja a message qubitet különböző állapotokban, és teleportálja az állapotot a bob qubitbe.

Az alábbi kód tartalmazza a Teleport különböző kvantumállapotok teleportálási protokollját futtató műveletet SetToPlus , valamint SetToMinus azokat a Main műveleteket, amelyek a teleportálási protokollt futtatják.

Másolja és illessze be a következő kódot a Teleportation.qs fájlba.

/// This Q# program implements quantum teleportation.
namespace Teleportation {
    open Microsoft.Quantum.Diagnostics;
    open Microsoft.Quantum.Intrinsic;
    open Microsoft.Quantum.Measurement;

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

Ha helyileg szeretné futtatni a programot a beépített szimulátoron, kattintson a Futtatás gombra az alábbi @EntryPoint()parancsok listájából, vagy nyomja le a Ctrl+F5 billentyűkombinációt. A kimenet megjelenik a hibakeresési konzolon.

Ellenőrizze, hogy a fogadott állapotok megegyeznek-e a teleportálási állapotokkal. Példa:

Teleporting state |0〉

DumpMachine:

 Basis | Amplitude      | Probability | Phase
 -----------------------------------------------
  |00⟩ |  1.0000+0.0000𝑖 |   100.0000% |   0.0000

Received state |0〉

Folytatás

Teleportálás létrehozása Q#

Kvantum teleportálási program létrehozása a következőben: Q#

A művelet definiálása Teleport

A műveletek és SetToMinus a műveletek SetToPlus meghatározása

A program futtatása

Visszajelzés

A művelet definiálása `Teleport`

A műveletek és `SetToMinus` a műveletek `SetToPlus` meghatározása