Hibrid kvantum-számítási feladatok futtatása adaptív target profillal

A hibrid számítástechnika ötvözi a klasszikus és a kvantum-számítási folyamatokat az összetett problémák megoldásához.

A hibrid számítástechnikában a klasszikus kód vezérli a kvantumműveletek végrehajtását közép-áramköri mérések alapján, míg a fizikai qubitek aktívak maradnak. A gyakori programozási technikákat, például a beágyazott feltételes feltételeket, hurkokat és függvényhívásokat egyetlen kvantumprogramban használhatja összetett problémák futtatásához, csökkentve a szükséges lövések számát. A qubit újrafelhasználási technikákkal a nagyobb programok kisebb számú qubit használatával futtathatók a gépeken.

Ez a cikk bemutatja, hogyan küldhet be hibrid feladatokat az Azure Quantumba a QIR Adaptive RItarget profil használatával. Az Adaptív RI-profil target támogatja a közép-áramköri méréseket, a mérésalapú vezérlési folyamatot, a qubit alaphelyzetbe állítását és a klasszikus egész számszámítást.

Előfeltételek

• Egy Azure-fiók, aktív előfizetéssel. Ha nem rendelkezik Azure-fiókkal, regisztráljon ingyenesen, és regisztráljon használatalapú fizetéses előfizetésre.
• Egy Azure Quantum-munkaterület. További információ: Azure Quantum-munkaterület létrehozása.
• Ha önálló programokat szeretne küldeni Q# , a következő előfeltételekre van szüksége:
  • A Visual Studio Code telepítve van az Azure-bővítményselQuantum Development Kit.
  • Az Azure-bővítmény Quantum Development Kitlegújabb verziója.
• Ha python + Q# programokat szeretne küldeni, a következő előfeltételekre van szüksége:

  • Python-környezet, amelyen telepítve van a Python és a Pip .

  • Az Azure Quantum azure-quantum és a qsharp csomagok.

    pip install --upgrade azure-quantum qsharp
    

Támogatott targets

Hibrid kvantum-számítási feladatok futtatásához ki kell választania egy olyan kvantumszolgáltatót, amely támogatja az Adaptív RI-profilttarget.

Az Azure Quantum adaptív target profilja jelenleg a Quantinuumban targetstámogatott.

Adaptív RI-feladatok beküldése

A hibrid kvantum-számítási feladatok beküldéséhez konfigurálnia kell a profilt , ahol QIR Adaptive RIa target RI a " és Integer computations"qubit Reset.

A QIR Adaptive RItarget profil támogatja a közép-áramköri méréseket, a mérésalapú vezérlési folyamatot, a qubit alaphelyzetbe állítását és a klasszikus egész számszámítást.

Hibrid kvantumfeladatokat küldhet az Azure Quantum-nak önálló programokként vagy Python+ Q# programokkéntQ#. A hibrid kvantumfeladatok profiljának konfigurálásához target tekintse meg a következő szakaszokat.

Támogatott funkciók

Az alábbi táblázat a hibrid kvantum-számítástechnika és az Azure Quantum Quantinuum által támogatott funkcióit sorolja fel.

A QDK -specifikus visszajelzést nyújt target, ha Q# a nyelvi funkciók nem támogatottak a kiválasztott target. Ha a Q# program nem támogatott funkciókat tartalmaz hibrid kvantumfeladatok futtatásakor, a tervezéskor hibaüzenet jelenik meg. További információ: QIR wikilap.

A támogatott funkciók működés közbeni megtekintéséhez másolja a következő kódot egy Q# fájlba, és adja hozzá a következő kódrészleteket.

import Microsoft.Quantum.Measurement.*;
import Microsoft.Quantum.Math.*;
import Microsoft.Quantum.Convert.*;

operation Main() : Result {
    use (q0, q1) = (Qubit(), Qubit());
    H(q0);
    let r0 = MResetZ(q0);

    // Copy here the code snippets below to see the supported features 
    // in action.
    // Supported features include dynamic values, classically-bounded loops, 
    // arbitrary control flow, and mid-circuit measurement.

    r0
}

A Quantinuum támogatja a dinamikus logikai értékeket és egész számokat, ami azt jelenti, hogy a mérési eredményektől függő logikai értékek és egész számok. Vegye figyelembe, hogy r0 egy Result olyan típus, amely dinamikus bool- és egész számértékek létrehozásához használható.

        let dynamicBool = r0 != Zero; 
        let dynamicBool = ResultAsBool(r0); 
        let dynamicInt = dynamicBool ? 0 | 1; 

A Quantinuum támogatja a dinamikus logikai értékeket és az egész számokat, azonban más adattípusok, például a dupla értékek dinamikus értékeit nem támogatja. Másolja a következő kódot a dinamikus értékek korlátozásával kapcsolatos visszajelzések megtekintéséhez.

        let dynamicDouble = r0 == One ? 1. | 0.; // cannot use a dynamic double value
        let dynamicInt = r0 == One ? 1 | 0;
        let dynamicDouble = IntAsDouble(dynamicInt); // cannot use a dynamic double value
        let dynamicRoot = Sqrt(dynamicDouble); // cannot use a dynamic double value

Annak ellenére, hogy egyes adattípusok esetében a dinamikus értékek nem támogatottak, ezek az adattípusok továbbra is használhatók statikus értékekkel.

    let staticRoot = Sqrt(4.0);
    let staticBigInt = IntAsBigInt(2);

Bizonyos helyzetekben még a támogatott típus dinamikus értékei sem használhatók. A Quantinuum például nem támogatja a dinamikus tömböket, vagyis azokat a tömböket, amelyek mérete egy mérési eredménytől függ. A Quantinuum sem támogatja a dinamikusan kötött hurkokat. Másolja a következő kódot a dinamikus értékek korlátainak megtekintéséhez.

        let dynamicInt = r0 == Zero ? 2 | 4;
        let dynamicallySizedArray = [0, size = dynamicInt]; // cannot use a dynamically-sized array
        let staticallySizedArray = [0, size = 10];
        // Loops with a dynamic condition are not supported by Quantinuum.
        for _ in 0..dynamicInt {
            Rx(PI(), q1);
        }
        
        // Loops with a static condition are supported.
        let staticInt = 3;
        for _ in 0..staticInt {  
            Rx(PI(), q1);  
        }

A Quantinuum statikus és dinamikus feltételek használatával támogatja a vezérlési folyamatot, beleértve az if/else elágaztatást is. A dinamikus körülmények közötti elágaztatást a mérési eredmények alapján elágaztatásnak is nevezik.

        let dynamicInt = r0 == Zero ? 0 | 1; 
        if dynamicInt > 0 {
            X(q1);
        }
        let staticInt = 1;
        if staticInt > 5 {
            Y(q1);
        } else {
            Z(q1);
        }

A Quantinuum támogatja a klasszikus feltételekkel és kifejezésekkel if rendelkező hurkokat.

        for idx in 0..3 {
            if idx % 2 == 0 {
                Rx(ArcSin(1.), q0);
                Rz(IntAsDouble(idx) * PI(), q1)
            } else {
                Ry(ArcCos(-1.), q1);
                Rz(IntAsDouble(idx) * PI(), q1)
            }
        }

A Quantinuum támogatja a középköri mérést, vagyis a mérési eredmények alapján történő elágaztatást.

        if r0 == One {
            X(q1);
        }
        let r1 = MResetZ(q1);
        if r0 != r1 {
            let angle = PI() + PI() + PI()* Sin(PI()/2.0);
            Rxx(angle, q0, q1);
        } else {
            Rxx(PI() + PI() + 2.0 * PI() * Sin(PI()/2.0), q1, q0);
        }

Hibrid kvantum-számítási feladatok költségeinek becslése

A hibrid kvantum-számítási feladatok Quantinuum-hardveren való futtatásának költségeit úgy becsülheti meg, hogy először emulátoron futtatja.

Sikeres futtatás után az emulátoron:

1. Az Azure Quantum-munkaterületen válassza a Feladatkezelés lehetőséget.
2. Válassza ki a beküldött feladatot.
3. A Feladat részletei előugró ablakban válassza a Költségbecslés lehetőséget, hogy megtekintse, hány eHQCs (Quantinuum emulator credits) volt használatban. Ez a szám közvetlenül a feladat Quantinuum hardveren való futtatásához szükséges HQC-k (Quantinuum kvantum-kreditek) számára fordítható le.

Hibrid kvantum-számítástechnikai minták

A következő minták a kódminták adattárában Q#találhatók. Bemutatják a hibrid kvantum-számítástechnika jelenlegi funkciókészletét.

Három qubites ismétlési kód

Ez a minta bemutatja, hogyan hozhat létre három qubites ismétlési kódot , amely a bit tükrözési hibáinak észlelésére és javítására használható.

Integrált hibrid számítástechnikai funkciókat használ a hibajavítások számának megszámlálásához, miközben a logikai qubit-regiszter állapota koherens.

A kódmintát itt találja.

Iteratív fázisbecslés

Ez a mintaprogram egy iteratív fázisbecslést mutat be a .Q# Iteratív fázisbecsléssel számít ki egy belső terméket két, qubiten kódolt kétdimenziós vektor és egy target ancilla qubit között. Egy további vezérlő qubit is inicializálva van, amely az egyetlen, méréshez használt qubit.

A kapcsolatcsoport a qubit és target az ancilla qubit vektorpárjának kódolásával kezdődik. Ezután egy Oracle-operátort alkalmaz a teljes regiszterre, amelyet a vezérlő qubit szabályoz, amely $\ket +$ állapotban van beállítva. Az ellenőrzött Oracle-operátor létrehoz egy fázist a vezérlő qubit $\ket 1$ állapotában. Ez ezután olvasható egy H kapuval a vezérlő qubiten, hogy a fázis megfigyelhető legyen méréskor.

A kódmintát itt találja.

Kapcsolódó tartalom

• Ismerkedés a munkamenetekkel