Kvantum-kapcsolatcsoport-diagramok vizualizációja a következővel: Q#

Cikk
06/21/2024

A kvantum-kapcsolatcsoportok diagramjai a kvantumműveletek vizuális ábrázolása. A qubitek kvantumprogramon keresztüli áramlását mutatják, beleértve a kapukat és a rajtuk alkalmazott méréseket is.

Ebben a cikkben megtudhatja, hogyan jelenítheti meg a kvantumalgoritmusokat kvantumkörök diagramjaival a Visual Studio Code vagy a Jupyter Notebook használatával.

A kvantumkörök diagramkonvenciáival kapcsolatos további információkért lásd a kvantumkörök konvencióit.

Előfeltételek

VS Code

A Visual Studio Code legújabb verziója, vagy nyissa meg a VS Code-ot a weben.
Az Azure Quantum Development Kit bővítmény legújabb verziója.
A legújabb Azure Quantum qsharp - és azure-quantum Python-csomagok.
```
python -m pip install --upgrade qsharp azure-quantum
```

Jupyter notebook

A Visual Studio Code legújabb verziója, vagy nyissa meg a VS Code-ot a weben.
VS Code az Azure Quantum Development Kit, Python és Jupyter bővítményekkel.
A legújabb Azure Quantum qsharp és qsharp-widgets csomagok, valamint a ipykernel csomag.
```
python -m pip install --upgrade qsharp qsharp-widgets ipykernel
```

Kvantum-kapcsolatcsoportok a Visual Studio Code-tal

Az alábbi lépéseket követve vizualizálhatja a Visual Studio Code-ban futó programok kvantum-kapcsolatcsoportjait Q# . A kvantumkörök diagramkonvenciáival kapcsolatos további információkért lásd a kvantumkörök konvencióit.

Program kapcsolatcsoportdiagramjainak Q# megtekintése

Nyisson meg egy Q# fájlt a Visual Studio Code-ban, vagy töltse be az egyik kvantummintát.
A program kvantum-kapcsolatcsoportjának megjelenítéséhez válassza a Q# Nézet –> Parancskatalógus lehetőséget, és írja be aQ# "kapcsolatcsoport" kifejezést, amelynek a következőt kell választania: Kapcsolatcsoport megjelenítése lehetőség. Az alábbi @EntryPoint()parancsok listájából a Circuit (Kapcsolatcsoport) elemre is kattinthat.
A kapcsolatcsoport megjelenik a Q# kapcsolatcsoport ablakában. Az alábbi kapcsolatcsoport például egy olyan műveletnek felel meg, amely egy qubitet helyez egy szuperpozícióba, majd méri azt. A kapcsolatcsoportdiagram egy qubitregisztrációs adatbázist mutat be, amelyet a rendszer a(z) |0⟩ állapotba inicializált. Ezután egy H hadamard kaput alkalmazunk a qubitre, majd egy mérési művelettel, amelyet egy mérőszimbólum jelöl.

Kapcsolatcsoportdiagramok megtekintése műveletekhez

Egyetlen Q# művelethez vizualizálhatja a kvantum áramkört. Ehhez kattintson a műveletdeklaráció fölött megjelenő kódlencse Kapcsolatcsoport gombjára.

Képernyőkép a Visual Studio Code-ról, amely bemutatja, hogyan jelenítheti meg a kapcsolatcsoportokat a Q# kapcsolatcsoportok panelen a program hibakeresése után.

Kapcsolatcsoportdiagramok megtekintése hibakereséskor

A program hibakeresésekor Q# a kvantum-kapcsolatcsoportot a program aktuális állapota alapján jelenítheti meg.

Válassza a Hibakeresés gombot az alábbi @EntryPoint()kódlencse-parancsok listájából.
A bal oldali Futtatás és hibakeresés nézetben bontsa ki a Quantum Circuit szakaszt a Változók panelen, hogy a programon végiglépkedve jelenítse meg a kapcsolatcsoportot.
A kód végigfuttatásával különböző pontok töréspontjait állíthatja be a kapcsolatcsoport frissítésének megtekintéséhez a program futtatásakor.
Az aktuális kvantum-kapcsolatcsoport megjelenik a Q# Kapcsolatcsoport panelen. Ez a kapcsolatcsoportdiagram a szimulátor aktuális állapotát, vagyis az aktuális végrehajtási pontig alkalmazott kapukat jelöli.

Kvantum-kapcsolatcsoportok Jupyter notebookokkal

A Jupyter notebookokban a csomag használatával vizualizálhatja a qsharp-widgets kvantum áramköröket. Ez a csomag egy widgetet biztosít, amely SVG-képként jeleníti meg a kvantumkörök diagramjait.

A Visual Studio Code-ban válassza a Parancspaletta megtekintése > lehetőséget, majd a Létrehozás: Új Jupyter-jegyzetfüzet lehetőséget.
A jegyzetfüzet első cellájában futtassa az alábbi kódot a Q# modul importálásához.
```
import qsharp
```
Adjon hozzá egy új cellát , és írja be a Q# kódot. Az alábbi kód például előkészít egy Bell-állapotot.
```
%%qsharp

// Prepare a Bell State.
use register = Qubit[2];
H(register[0]);
CNOT(register[0], register[1]);
```
A függvény használatával dump_circuit() megjeleníthet egy kvantum áramkört a program aktuális állapota alapján. A kapcsolatcsoportdiagramon például két qubit-regiszter látható, amelyek inicializálása |0⟩ állapotba van inicializálva. Ezután egy H hadamard kaput alkalmazunk az első qubitre. Ezt követően a rendszer egy CNOT-kaput alkalmaz az első qubit mint vezérlő használatával, amely pontként jelenik meg, a második qubit pedig targetX-ként.
```
qsharp.dump_circuit()
```
```
q_0    ── H ──── ● ──
q_1    ───────── X ──
```
A csomag használatával SVG-rendszerképként vizualizálhatja a qsharp-widgets kvantum áramköröket. Ebben az esetben a CNOT-kapu a két qubitet összekötő vonalként jelenik meg, a vezérlő qubiten egy ponttal és egy körülírt kereszttel a target qubiten. További információ: Kvantum-kapcsolatcsoportok konvenciók.
```
from qsharp_widgets import Circuit

Circuit(qsharp.dump_circuit())
```

Bejegyzéskifejezés kapcsolatcsoportdiagramjainak megtekintése

Bármely programhoz létrehozhat kapcsolatcsoportdiagramot egy belépési kifejezéssel, ha argumentumként meghívja qsharp.circuit() és átadja a belépési kifejezést.

Adjon hozzá például egy új cellát, és másolja a következő kódot, amely előkészíti a GHZ-állapotot.

%%qsharp

open Microsoft.Quantum.Diagnostics;
open Microsoft.Quantum.Measurement;

operation GHZSample(n: Int) : Result[] {
    use qs = Qubit[n];

    H(qs[0]);
    ApplyToEach(CNOT(qs[0], _), qs[1...]);

    let results = MeasureEachZ(qs);
    ResetAll(qs);
    return results;
}

Adjon hozzá egy új cellát, és futtassa az alábbi kódot a kapcsolatcsoport megjelenítéséhez. Például készítsen elő egy GHZ-állapotot 3 qubittel.
```
Circuit(qsharp.circuit("GHZSample(3)"))
```

Kapcsolatcsoportdiagramok megtekintése qubitekkel végzett műveletekhez

Létrehozhat kapcsolatcsoportdiagramokat minden olyan művelethez, amely qubiteket vagy qubittömböket vesz igénybe. Az ábrán annyi vezeték látható, amennyi bemeneti qubit, valamint a műveleten belül lefoglalt további qubitek. Amikor a művelet qubittömböt (Qubit[])vesz igénybe, a kapcsolatcsoport a tömböt 2 qubit regisztereként jeleníti meg.

Adjon hozzá egy új cellát, és másolja a következő példát. Ez a kód előkészíti a macska állapotát.

%%qsharp

operation PrepareCatState(register : Qubit[]) : Unit {
    H(register[0]);
    ApplyToEach(CNOT(register[0], _), register[1...]);
}

Adjon hozzá egy új cellát, és futtassa a következő kódot a művelet kapcsolatcsoportjának vizualizációjához PrepareCatState .
```
Circuit(qsharp.circuit(operation="PrepareCatState"))
```

Kapcsolatcsoportdiagramokat befolyásoló feltételek

A kvantum áramkörök vizualizációja során az alábbi feltételek befolyásolhatják a kapcsolatcsoportdiagram vizualizációját.

Dinamikus kapcsolatcsoportok

A kapcsolatcsoportdiagramok úgy jönnek létre, hogy végrehajtják az összes klasszikus logikát egy Q# programban, és nyomon követik a lefoglalt qubiteket vagy az alkalmazott kapukat. A hurkok és a feltételes elemek mindaddig támogatottak, amíg csak a klasszikus értékekkel foglalkoznak.

A qubitmérési eredményeket használó hurkokat és feltételes kifejezéseket tartalmazó programok azonban trükkösebbek a kapcsolatcsoportdiagramok ábrázolásához. Például egy olyan kifejezés, mint a következő

if (M(q) == One) {
   X(q)
}

nem jeleníthető meg egyszerű áramköri diagrammal, mivel a kapuk mérési eredményhez vannak kapcsolva. Az ilyen kapcsolatcsoportokat dinamikus kapcsolatcsoportnak nevezzük.

A kapcsolatcsoportdiagramok dinamikus áramkörökhöz hozhatók létre a program kvantumszimulátorban való futtatásával és a kapuk alkalmazásuk szerinti nyomon követésével. Ezt nyomkövetési módnak nevezzük, mivel a qubitek és a kapuk a szimuláció végrehajtása során lesznek nyomon követve.

A nyomkövetési áramkörök hátránya, hogy csak a mérési eredményeket és az ebből eredő kapualkalmazásokat rögzítik egyetlen szimulációhoz. A fenti példában, ha a mérési eredmény az Zero, akkor nem látja a kaput X a diagramon. A szimuláció egy másik futtatása kissé eltérő kapcsolatcsoportot mutathat.

Célprofil

A jelenleg kijelölt target profil befolyásolja a kapcsolatcsoportdiagramok létrehozásának módját. A célprofilok a hardver képességeinek target és a kvantumprogramra vonatkozó korlátozásoknak a megadására szolgálnak.

Ha a target profil korlátlan vagy QIR adaptív RI értékre van állítva, a kapcsolatcsoportdiagramok a programban meghívott Q# kvantumműveleteket mutatják be. Ha a target profil QIR-alapra van állítva, az áramköri diagramok azokat a kvantumműveleteket mutatják be, amelyeket hardveren futtatnának, ha a program ezzel target a profillal lett elküldve az Azure Quantumnak.

Feljegyzés

A VS Code-ban a profil kiválasztásához válassza a target Nézet –> Parancskatalógus lehetőséget, majd válassza Q#az Azure Quantum QIR-profiltarget beállítása lehetőséget. A legördülő listából vagy unrestricted a legördülő listából is választhat.QIR baseQIR Adaptive RI
A profil Pythonban való target kiválasztásához hívja meg vagy qsharp.init(target_profile=qsharp.TargetProfile.Unrestricted)qsharp.init(target_profile=qsharp.TargetProfile.Adaptive_RI).qsharp.init(target_profile=qsharp.TargetProfile.Base)

Pontosabban a kapubontásokat alkalmazzák, amelyek az eredményként kapott áramkört kompatibilissé teszik a target hardver képességeivel. Ezek ugyanazok a felbontások, amelyeket a kódlétrehozás és az Azure Quantumba való beküldés során alkalmaznának.

Vegyük például a következő Q# programot, amely egy qubitet és egy qubittömböt mér.

namespace Sample {
    open Microsoft.Quantum.Measurement;

    @EntryPoint()
    operation Main() : (Result, Result[]) {
        // The `M` operation performs a measurement of a single qubit in the
        // computational basis, also known as the Pauli Z basis.
        use q = Qubit();
        let result = M(q);
        Reset(q);

        // The `MeasureEachZ` operation measures each qubit in an array in the
        // computational basis and returns an array of `Result` values.
        use qs = Qubit[2];
        let results = MeasureEachZ(qs);

        return (result, results);
    }
}

Ha target a profil korlátlan vagy QIR adaptív RI értékre van állítva, a kapcsolatcsoporton megjelenített kapuk pontosan megfelelnek a programban meghívott Q# kvantumműveleteknek.
Ha a target profil QIR-alap, a kapcsolatcsoport másként néz ki. Mivel az alapprofil targets nem teszi lehetővé a qubit újrahasználatát a mérés után, a mérés most már egy összefonódott qubiten történik. Mivel Reset a művelet nem támogatott kapu az alapprofilban, a rendszer elveti. Az eredményként kapott kapcsolatcsoport megegyezik azzal, amit a hardveren futtatna, ha ezt a programot ezzel target a profillal küldi el az Azure Quantumnak.

Megosztás a következőn keresztül: