Quantinuum-szolgáltató

A Quantinuum nagy megbízhatóságú, teljes mértékben csatlakoztatott qubitekkel rendelkező, csapdába esett ionrendszerekhez biztosít hozzáférést, valamint képes a középső áramkörök mérésére.

• Kiadó: Quantinuum
• Szolgáltató azonosítója: quantinuum

Célok

A következő targets lehetőségek érhetők el a szolgáltatótól:

A Quantinuum egy targets profilnak QIR Adaptive RI felel meg. A profilról és annak korlátairól target további információt az Azure Quantum profiltípusainak ismertetése target című témakörben talál.

A Quantinuum összes tagja támogatja az targets integrált hibrid áramköröket. Az integrált hibrid feladatok beküldésével kapcsolatos további információkért lásd: Integrált hibrid számítástechnika.

A Quantinuum-szolgáltató Azure Quantumon való használatának megkezdéséhez tekintse meg a Q# használatának első lépéseit és egy Azure Quantum-jegyzetfüzetet.

Szintaxis-ellenőrzők

Javasoljuk, hogy a felhasználók először szintaxis-ellenőrzővel érvényesítsék a kódjukat. Ez az eszköz ellenőrzi a megfelelő szintaxist, a fordítás befejezését és a gép kompatibilitását. A szintaxis-ellenőrzők ugyanazt a fordítót használják, mint a kvantumszámítógép.target A H1-1 szintaxis ellenőrzője például ugyanazt a fordítót használja, mint a H1-1. A teljes összeállítási verem végrehajtása a tényleges kvantumműveletek kivételével történik. Ha a kód lefordítva van, a szintaxis-ellenőrző az állapotot és az összes 0-s eredményt adja vissza success . Ha a kód nem áll össze, a szintaxis-ellenőrző sikertelen állapotot ad vissza, és visszaadja a hibát, hogy segítsen a felhasználóknak a kapcsolatcsoport szintaxisának hibakeresésében. A szintaxis-ellenőrzők lehetővé teszik a fejlesztők számára, hogy bármikor érvényesítsék a kódjukat, még akkor is, ha a gépek offline állapotban vannak.

• Feladat típusa: Simulation
• Adatformátumok: honeywell.openqasm.v1, honeywell.qir.v1
• Célazonosító:
  • H1-1 Szintaxis ellenőrző: quantinuum.sim.h1-1sc
  • H2-1 szintaxis-ellenőrző: quantinuum.sim.h2-1sc
  • H2-2 szintaxis ellenőrző: quantinuum.sim.h2-2sc
• Célvégrehajtási profil: QIR Adaptive RI

A szintaxis-ellenőrzők használata ingyenesen érhető el.

H1 rendszermodell emulátorai

Miután a kód szintaxisát szintaxis-ellenőrzővel ellenőrizte, a felhasználók kihasználhatják a Quantinuum H1 rendszermodelljének emulátorait, az emulációs eszközöket, amelyek részletes fizikai modellt és valós zajmodellt tartalmaznak a tényleges H1 rendszermodell hardverén. A zajmodellek a hardver részletes jellemzéséből származnak. A H1 rendszermodell emulátorai egy azonos API-t használnak a feladatküldéshez, mint a System Model H1 hardver, így zökkenőmentes átmenetet tesz lehetővé az emulációról a hardverre. A hatékonyság maximalizálása és a fejlesztési idő lerövidítése érdekében a H1 rendszermodell emulátorai akkor is elérhetők, ha a hardver offline állapotban van.

További információt a H1 rendszermodell emulátor termékadatlapján talál a rendszermodell H1 oldalán.

• Feladat típusa: Simulation
• Adatformátum: quantinuum.openqasm.v1
• Célazonosító:
  • H1-1 Emulátor: quantinuum.sim.h1-1e
• Célvégrehajtási profil: QIR Adaptive RI

A H1 rendszermodell emulátor használata hardveres előfizetéssel ingyenesen érhető el. További részletekért tekintse meg az Azure Quantum díjszabását.

Quantinuum Emulator (felhőalapú)

A Quantinuum Emulator ingyenesen elérhető az Azure Quantum webhelyén található Code és az Azure Quantum oldalán, ahol Q#-kódot írhat, és azure-fiók nélkül küldheti el feladatait a Quantinuum Emulatorba. A Quantinuum Emulator egy statevector-alapú kvantumemulátor, amely egy valós fizikai zajmodellt és általános hibaparamétereket használ a H1 kvantumszámítógépektipikus teljesítménye alapján. A végrehajtott kvantumszimuláció megegyezik a H1-es rendszermodell emulátorával , de a klasszikus áramkör-optimalizálási rutin csökkenti az átviteli sebesség növelését. Az integrált hibrid számítástechnika támogatása a jövőben várható.

H1 rendszermodell

A Honeywell által üzemeltetett kvantumszámítógépek H1 rendszermodellje egy kvantumköltség-összekapcsolt eszközből (QCCD) áll, amely egy lineáris szakaszt tartalmaz, és jelenleg egy gépet targetstartalmaz: a H1-1-et. A felhasználóknak javasoljuk, hogy teszteljék a kód kompatibilitását a H1-1-zel, ha feladatokat küldenek a szintaxis-ellenőrzőnek és a H1 Emulator rendszermodellnek, mielőtt elküldenék őket a target gépekre.

A system model H1 gép folyamatosan frissül a termék életciklusa során. A felhasználók hozzáférhetnek az elérhető legkorszerűbb, fejlett és képes hardverekhez.

További információt a H1 rendszermodell H1 termékadatlapján talál a rendszermodell H1 oldalán.

• Feladat típusa: Quantum Program
• Adatformátum: honeywell.openqasm.v1, honeywell.qir.v1
• Célazonosító:
  • H1-1: quantinuum.qpu.h1-1
• Célvégrehajtási profil: QIR Adaptive RI

H2 Emulátor rendszermodell

Miután ellenőrizte a kód szintaxisát a H2-1 szintaxis-ellenőrzővel, a felhasználók kihasználhatják a Quantinuum H2 Emulator rendszermodelljének előnyeit, amely részletes fizikai modellt és valós zajmodellt tartalmaz a tényleges H2 rendszermodell hardveréhez. A zajmodellről további információt a H2 rendszermodell emulátor termékadatlapján talál a rendszermodell H2 oldalán. A System Model H2 Emulator egy azonos API-t használ a feladatküldéshez, mint a System Model H2 hardver, így zökkenőmentes átmenetet tesz lehetővé az emulációról a hardverre. A hatékonyság maximalizálása és a fejlesztési idő lerövidítése érdekében a H2 Emulator akkor is elérhető, ha a hardver offline állapotban van.

• Feladat típusa: Simulation
• Adatformátum: quantinuum.openqasm.v1
• Célazonosító:
  • H2-1 Emulátor: quantinuum.sim.h2-1e
  • H2-2 Emulátor: quantinuum.sim.h2-2e
• Célvégrehajtási profil: QIR Adaptive RI

A H2 Emulator rendszermodell használata hardveres előfizetéssel ingyenesen érhető el. További részletekért tekintse meg az Azure Quantum díjszabását.

H2 rendszermodell

A Quantinuum system model H2 generációs kvantumszámítógépek, Powered by Honeywell, áll a Quantum charge-coupled eszköz (QCCD) két csatlakoztatott lineáris szakasz, és jelenleg 1 gép, a H2-1. További információt a H2 rendszermodell H2 termékadatlapján talál a Rendszermodell H2 oldalán. A felhasználókat arra ösztönzik, hogy teszteljék a kód kompatibilitását úgy, hogy feladatokat küldenek egy szintaxis-ellenőrzőnek és a H2 Emulátor rendszermodellnek, mielőtt elküldenék őket a target gépekre.

Ha egy felhasználó beküld egy feladatot a H2-1 gépre, és a H2-1 gép nem érhető el, a feladat a gép várólistáján marad, amíg el nem válik a gép.

A H2 rendszermodell hardvere folyamatosan frissül a termék életciklusa során. A felhasználók hozzáférhetnek az elérhető legkorszerűbb, fejlett és képes hardverekhez.

• Feladat típusa: Quantum Program
• Adatformátum: quantinuum.openqasm.v1
• Célazonosító:
  • H2-1: quantinuum.qpu.h2-1
  • H2-2: quantinuum.qpu.h2-2
• Célvégrehajtási profil: QIR Adaptive RI

H1 és H2 rendszermodell műszaki specifikációi

A H1 rendszermodell és a H2 rendszermodell műszaki részletei megtalálhatók a Quantinuum termékadatlapjaiban a H1 rendszermodell és a rendszermodell H2 oldalán, valamint a Quantinuum specifikációjára és a kvantumkötet-adattárakra mutató hivatkozásokon, valamint a Quantinuum-rendszerek használatára vonatkozó hivatkozásokon.

További képességek

A Quantinuum API-val elérhető további képességeket itt találja.

A felhasználók az Azure Quantum Q# és a Qiskit-szolgáltatók kapcsolatcsoportfüggvényeivel vagy átmenő paramétereivel kihasználhatják ezeket a további képességeket.

Közép áramkör mérése és alaphelyzetbe állítása

A középső kapcsolatcsoport mérése és alaphelyzetbe állítása (MCMR) lehetővé teszi a felhasználók számára a qubitek mérését a kapcsolatcsoport közepén, és alaphelyzetbe állíthatják őket. Ez lehetővé teszi a kvantumhibák kijavítását, valamint a qubitek újrahasználatát a kapcsolatcsoporton belül.

A csapdába esett ion qubitek belső szintje miatt a középső áramköri mérés nem számítási állapotban hagyhatja a qubitet. Minden közép áramköri mérést alaphelyzetbe kell állítani, ha a qubitet ismét használni kell az adott kapcsolatcsoportban. Ezt az alábbi példakódok szemléltetik.

Ha a qubitek egy részhalmazát a kapcsolatcsoport közepén mérik, az ezekből a mérésekből származó klasszikus információk felhasználhatók a kapcsolatcsoport jövőbeli elemeinek konfigurálására. A példák ezt a használatot is kiemelik.

A Quantinuum-rendszerek MCMR-ével kapcsolatos információkért tekintse meg a Quantinuum-rendszerek termékadatlapjait a H1 rendszermodell és H2 rendszermodell lapon.

%%qsharp
import Std.Measurement.*;

operation ContinueComputationAfterReset() : Result[] {
    // Set up circuit with 2 qubits
    use qubits = Qubit[2];

    // Perform Bell Test
    H(qubits[0]);
    CNOT(qubits[0], qubits[1]);

    // Measure Qubit 1 and reset it
    let res1 = MResetZ(qubits[1]);

    // Continue additional computation, conditioned on qubits[1] measurement outcome
    if res1 == One {
         X(qubits[0]);
    }
    CNOT(qubits[0], qubits[1]);

    // Measure qubits and return results
    let res2 = Measure([PauliZ, PauliZ], qubits);
    return [res1, res2];
}

from qiskit import QuantumRegister, ClassicalRegister, QuantumCircuit

# Set up quantum circuit
q = QuantumRegister(2)
c = ClassicalRegister(2)
circuit = QuantumCircuit(q, c)
circuit.name = "MCMR Example with Conditional Logic"

# Perform Bell Test
circuit.h(q[0])
circuit.cx(q[0], q[1])

# Measure and reset Qubit 1
circuit.measure(q[1], c[1])
circuit.reset(q[1])

# Continue additional computation, conditioned on Qubit 1's measurement outcome
circuit.x(q[0]).c_if(c, 1)
circuit.cx(q[0], q[1])

# Measure all qubits
circuit.measure(q, c)

# Print out the circuit
circuit.draw()

Tetszőleges szögű ZZ-kapuk

A Quantinuum natív kapukészlete tetszőleges szögű ZZ-kapukat tartalmaz. Ez hasznos a 2 qubites kapuk számának csökkentéséhez számos kvantum-algoritmus és kapuütemezés esetében. A Quantinuum-rendszerek tetszőleges szögű ZZ-kapuiról a Quantinuum-rendszerek termékadatlapjait a H1 rendszermodell H1 és H2 rendszermodell lapon talál.

%%qsharp
import Std.Intrinsic.*;
import Std.Measurement.*;
import Std.Arrays.*;

operation ArbitraryAngleZZExample(theta : Double) : Result[] {
    
    // Set up circuit with 2 qubits
    use qubits = Qubit[2];

    // Create array for measurement results
    mutable resultArray = [Zero, size = 2];

    H(qubits[0]);
    Rz(theta, qubits[0]);
    Rz(theta, qubits[1]);
    X(qubits[1]);

    // Add Arbitrary Angle ZZ gate
    Rzz(theta, qubits[0], qubits[1]);  

    // Measure qubits and return results
    for i in IndexRange(qubits) {
        resultArray w/= i <- M(qubits[i]);  
    }
    
    return resultArray;
}

from qiskit import QuantumCircuit

theta = 0.25

# Set up quantum circuit
circuit = QuantumCircuit(2, 2)
circuit.name = "Arbitrary Angle ZZ Gate Example"

circuit.h(0)
circuit.rz(theta, 0)
circuit.rz(theta, 1)
circuit.x(1)

# Add arbitrary angle ZZ gate
circuit.rzz(theta, 0, 1)

circuit.measure_all()

Általános SU(4) Összecsukó kapu

A Quantinuum natív kapukészlete egy általános SU(4) összecsukható kaput tartalmaz. Vegye figyelembe, hogy a hardverhez küldött kvantum áramköröket a rendszer újra a teljesen összefonódott ZZ-kapura és az tetszőleges szögű RZZ-kapura iktálja. A kapcsolatcsoportok csak akkor kerülnek át az általános SU(4) összecsukható kapura, ha a felhasználók ezt engedélyezik. A Quantinuum-rendszerek általános SU(4) entanglerével kapcsolatos információkért tekintse meg a Quantinuum-rendszerek termékadatlapjait a H1 rendszermodell H1 és H2 rendszermodell oldalán.

%%qsharp
import Std.Math.*;

operation __quantum__qis__rxxyyzz__body(a1 : Double, a2 : Double, a3 : Double, q1 : Qubit, q2 : Qubit) : Unit {
    body intrinsic;
}

operation SU4Example() : Result[] {
    use qs = Qubit[2];
    
    // Add SU(4) gate
    __quantum__qis__rxxyyzz__body(PI(), PI(), PI(), qs[0], qs[1]);
    
    MResetEachZ(qs)
}

MyProgram = qsharp.compile("GenerateRandomBit()")

MyWorkspace = azure.quantum.Workspace(
    resource_id = "",
    location = ""
)

MyTarget = MyWorkspace.get_targets("quantinuum.sim.h1-1e")

# Update TKET optimization level desired
option_params = {
    "nativetq": `Rxxyyzz`,
    "noreduce": True
}

job = MyTarget.submit(MyProgram, "Submit a program with SU(4) gate", shots = 10, input_params = option_params)
job.get_results()

Emulátor zajparaméterei

A felhasználók kísérleteznek a Quantinuum emulátorok zajparamétereivel. Itt a rendelkezésre álló zajparaméterek közül csak néhány van kiemelve , amely bemutatja, hogyan haladhat át a paramétereken az Azure Quantum-szolgáltatókban.

A rendelkezésre álló zajparaméterek teljes készletéről további információt a Quantinuum emulator termék adatlapján talál a H1 rendszermodell H1 és H2 rendszermodell lapon.

import qsharp
import azure.quantum
qsharp.init(target_profile=qsharp.TargetProfile.Base)

%%qsharp
import Std.Measurement.*;
import Std.Arrays.*;
import Std.Convert.*;

operation GenerateRandomBit() : Result {
    use target = Qubit();

    // Apply an H-gate and measure.
    H(target);
    return M(target);
}

MyProgram = qsharp.compile("GenerateRandomBit()")

MyWorkspace = azure.quantum.Workspace(
    resource_id = "",
    location = ""
)

MyTarget = MyWorkspace.get_targets("quantinuum.sim.h1-1e")

# Update the parameter names desired
# Note: This is not the full set of options available. 
# For the full set, see the System Model H1 Emulator Product Data Sheet
option_params = {
    "error-params": {
        "p1": 4e-5,
        "p2": 3e-3,
        "p_meas": [3e-3, 3e-3],
        "p_init": 4e-5,
        "p_crosstalk_meas": 1e-5,
        "p_crosstalk_init": 3e-5,
        "p1_emission_ratio": 6e-6,
        "p2_emission_ratio": 2e-4
    }
}

job = MyTarget.submit(MyProgram, "Experiment with Emulator Noise Parameters", 
                      shots = 10, 
                      input_params = option_params)
job.get_results()

option_params = {
    "error-model": False 
}

option_params = {
    "simulator": "stabilizer" 
}

# Specify the emulator backend target to submit to
backend = provider.get_backend("quantinuum.sim.1e")

# Update the parameter names desired
# Note: This is not the full set of options available. 
# For the full set, see the System Model H1 Emulator Product Data Sheet
option_params = {
    "error-params": {
        "p1": 4e-5,
        "p2": 3e-3,
        "p_meas": [3e-3, 3e-3],
        "p_init": 4e-5,
        "p_crosstalk_meas": 1e-5,
        "p_crosstalk_init": 3e-5,
        "p1_emission_ratio": 6e-6,
        "p2_emission_ratio": 2e-4
    }
}
backend.options.update_options(**option_params)

# Submit the job
job = backend.run(circuit, shots=100)
print("Job id:", job.id())

option_params = {
    "error-model": False 
}

option_params = {
    "simulator": "stabilizer" 
}

TKET-összeállítás a Quantinuum Stackben

A Quantinuum Quantinuum-rendszereknek küldött áramkörök automatikusan átfutnak a Quantinuum-hardverek TKET fordító iterációin, az integrált hibrid beküldésekkivételével . Így a kapcsolatcsoportok automatikusan optimalizálhatók a Quantinuum-rendszerekhez, és hatékonyabban futtathatók.

Az alkalmazott fordítási bérletekkel kapcsolatos további információk a pytket-quantinuum dokumentációban találhatók, különösen a pytket-quantinuum Fordítási passzok szakaszban.

A Quantinuum szoftververemben az alkalmazott optimalizálási szint a tket-opt-level paraméterrel van beállítva. A Quantinuum-rendszereknek küldött összes kapcsolatcsoport alapértelmezett összeállítási beállítása a 2. optimalizálási szint.

Azok a felhasználók, akik kísérletezni szeretnének a TKET-fordítási feladatokkal, és megnézik, hogy milyen optimalizálások vonatkoznak a kapcsolatcsoportjaikra, mielőtt bármilyen feladatot elküldenének, megtekinthetik a Quantinuum_compile_without_api.ipynb jegyzetfüzetet a pytket-quantinuum Példák mappában.

Ha ki szeretné kapcsolni a TKET-fordítást a veremben, egy másik lehetőség no-optbe van állítva True belülre option_params. Például: "no-opt": True.

További információkért pytketlásd az alábbi hivatkozásokat:

• pytket
• pytket Felhasználói kézikönyv

import qsharp
import azure.quantum
qsharp.init(target_profile=qsharp.TargetProfile.Base)

%%qsharp
import Std.Measurement.*;
import Std.Arrays.*;
import Std.Convert.*;

operation GenerateRandomBit() : Result {
    use target = Qubit();

    // Apply an H-gate and measure.
    H(target);
    return M(target);
}

MyProgram = qsharp.compile("GenerateRandomBit()")

MyWorkspace = azure.quantum.Workspace(
    resource_id = "",
    location = ""
)

MyTarget = MyWorkspace.get_targets("quantinuum.sim.h1-1e")

# Update TKET optimization level desired
option_params = {
    "tket-opt-level": 1
}

job = MyTarget.submit(MyProgram, "Experiment with TKET Compilation", shots = 10, input_params = option_params)
job.get_results()

# Specify the backend target to submit to
backend = provider.get_backend("quantinuum.sim.h1-1e")

# Update TKET optimization level desired
option_params = {
    "tket-opt-level": 1
}
backend.options.update_options(**option_params)

# Submit the job
job = backend.run(circuit, shots=100)
print("Job id:", job.id())

Műszaki specifikációk

A H1 és H2 rendszermodell, valamint a H1 és H2 rendszermodell emulátorainak műszaki részletei megtalálhatók a Quantinuum termékadatlapjaiban a H1 rendszermodell és a H2 rendszermodell oldalán, valamint a Quantinuum specifikációjára és a kvantumkötet-adattárakra mutató hivatkozásokon, valamint a Quantinuum-rendszerek használatára vonatkozó hivatkozásokon.

A cél elérhetősége

A Quantinuum kvantumszámítógépeket úgy tervezték, hogy folyamatosan frissüljenek, ami lehetővé teszi az ügyfelek számára a legújabb hardveres képességek elérését, mivel a Quantinuum folyamatosan javítja a kapuk hűségét, a memóriahibákat és a rendszer sebességét.

A Quantinuum hardverciklusai kereskedelmi időszakokon és fejlesztési időszakokon keresztül. Kereskedelmi időszakokban a hardver elérhető a feladatok várólistás rendszeren keresztüli feldolgozásához. A fejlesztési időszakokban a hardver offline állapotban van a frissítések alkalmazásakor.

Minden hónapban egy naptárt küldünk a Quantinuum felhasználóinak a kereskedelmi és fejlesztési időszakokra vonatkozó információkkal. Ha nem kapta meg ezt a naptárt, kérjük, küldjön e-mailt QCsupport@quantinuum.com.

Az targetállapot azt jelzi, hogy jelenleg képes feldolgozni a feladatokat. A lehetséges állapotok a target következők lehetnek:

• Elérhető: Az target online állapot, a beküldött feladatok feldolgozása és az újak elfogadása.
• Csökkentett: A target feladatokat elfogadja, de jelenleg nem dolgozza fel őket.
• Nem érhető el: A target kapcsolat nélküli állapotú, nem fogadja el az új feladatbeküldéseket.

A Quantinuum kvantumszámítógép targetsesetében az Elérhető és a Csökkentett érték kereskedelmi időszakoknak felel meg, míg a Nem érhető el azoknak a fejlesztési időszakoknak, amikor a gép offline állapotban van a frissítésekhez.

Az aktuális állapotinformációk lekérhetők az Azure Portalon található munkaterület Szolgáltatók lapjáról.

Díjszabás

A Quantinuum számlázási terveinek megtekintéséhez látogasson el az Azure Quantum díjszabására.

Korlátozások és kvóták

A Quantinuum kvótáit a QPU használatának kreditegysége alapján követjük nyomon: hardveres kvantumhitel (HQC)a Quantinuum kvantumszámítógépeire küldött feladatok esetében, és emulátor HQC-k (eHQC-k) az emulátoroknak küldött feladatokhoz.

A HQC-k és az eHQC-k a feladatok futtatásának költségeinek kiszámítására szolgálnak, és a számításuk a következő képlet alapján történik:

$$ HQC = 5 + C(N_{1q} + 10 N_{2q} + 5 N_m)/5000 $$

ahol:

• $N_{1q}$ egy kapcsolatcsoport egy qubites műveleteinek száma.
• $N_{2q}$ a kapcsolatcsoport natív két qubites műveleteinek száma. A natív kapu több egy qubites kapuval egyenértékű a CNOT-nak.
• $N_{m}$ az állapot-előkészítési és -mérési (SPAM) műveletek száma egy kapcsolatcsoportban, beleértve a kezdeti implicit állapot-előkészítést, valamint az esetleges köztes és végső méréseket és állapot-visszaállításokat.
• $C$ a lövések száma.

A kvóták a tervválasztáson alapulnak, és támogatási jegyekkel növelhetők. Az aktuális korlátok és kvóták megtekintéséhez lépjen a Kreditek és kvóták panelre, és válassza a munkaterület Kvóták lapját az Azure Portalon. További információ: Azure Quantum-kvóták.