Fournisseur Quantinuum

Quantinuum donne accès à des systèmes à ions piégés offrant des qubits haute fidélité entièrement connectés et la possibilité d’effectuer des mesures à mi-circuit.

• Éditeur : Quantinuum
• ID du fournisseur : quantinuum

Targets

Les éléments suivants targets sont disponibles auprès de ce fournisseur :

Les targets de Quantinuum correspondent à un profil QIR Adaptive RI. Pour plus d’informations sur ce target profil et ses limitations, consultez Présentation des target types de profils dans Azure Quantum.

Tous les targets de Quantinuum supportent désormais les circuits hybrides intégrés. Pour plus d’informations sur l’envoi de travaux hybrides intégrés, consultez l’informatique hybride intégrée.

Vérificateurs de syntaxe

Nous recommandons aux utilisateurs d’utiliser d’abord un vérificateur de syntaxe pour valider leur code. Les vérificateurs de syntaxe vérifient la syntaxe appropriée, l'achèvement de la compilation, et la compatibilité avec les machines. Les vérificateurs de syntaxe utilisent le même compilateur que l’ordinateur quantique qu’ils target. Par exemple, le vérificateur de syntaxe H2-1 utilise le même compilateur que H2-1. La pile de compilation complète est exécutée, à l’exception des opérations quantiques réelles. Si le code se compile correctement, le vérificateur de syntaxe retourne un statut success et un résultat de toutes les valeurs à 0. Si le code ne se compile pas, le vérificateur de syntaxe retourne un état ayant échoué et fournit un message d’erreur pour aider les utilisateurs à déboguer leur syntaxe de circuit. Le vérificateur de syntaxe permet aux développeurs de valider leur code à tout moment, même lorsque les machines sont hors connexion.

• Type de tâche : Simulation
• Formats de données : honeywell.openqasm.v1, honeywell.qir.v1
• ID cible :
  • Vérificateur de syntaxe H2-1 : quantinuum.sim.h2-1sc
  • Vérificateur de syntaxe H2-2 : quantinuum.sim.h2-2sc
• Profil d’exécution cible : QIR Adaptive RI

L’utilisation des vérificateurs de syntaxe est gratuite.

Émulateur quantinuum (basé sur le cloud)

L’émulateur Quantinuum est disponible gratuitement sur la page Code avec Azure Quantum du site web Azure Quantum, où vous pouvez écrire du code Q# et envoyer vos travaux à l’émulateur Quantinuum sans compte Azure. L’émulateur Quantinuum est un émulateur quantique basé sur un vecteur d'état qui utilise un modèle de bruit physique réaliste et des paramètres d’erreur généralisés basés sur les performances typiques d’un ordinateur quantique de modèle système H2. La simulation quantique effectuée est la même que l’émulateur System Model H2 , mais la routine d’optimisation du circuit classique est réduite pour augmenter le débit. La prise en charge de l’informatique hybride intégrée est prévue pour une date ultérieure.

Émulateur du modèle de système H2

Après avoir validé la syntaxe de son code avec le vérificateur de syntaxe H2-1, les utilisateurs peuvent tirer parti de l’émulateur System Model H2 de Quantinuum, un outil d’émulation qui contient un modèle physique détaillé et un modèle de bruit réaliste du matériel H2 du modèle système réel. Vous trouverez plus d’informations sur le modèle de bruit dans la feuille de données produit de l’émulateur System Model H2 dans la page System Model H2. L’émulateur System Model H2 utilise une API identique pour la soumission de travaux comme le matériel System Model H2, facilitant une transition fluide de l'émulation au matériel. Pour optimiser la productivité et raccourcir le temps de développement, l’émulateur H2 est disponible même si le matériel est hors connexion.

• Type de tâche : Simulation
• Format de données : quantinuum.openqasm.v1
• ID cible :
  • Émulateur H2-1 : quantinuum.sim.h2-1e
  • H2-2 Emulator : quantinuum.sim.h2-2e
• Profil d’exécution cible : QIR Adaptive RI

L’utilisation de l’émulateur H2 du modèle système est proposée gratuitement avec un abonnement matériel. Pour plus de détails, consultez Tarifs Azure Quantum.

Modèle système H2

Le quantinuum System Model H2 génération d’ordinateurs quantiques, alimenté par Honeywell, est composé d’un appareil à couplage de charge quantique (QCCD) avec deux sections linéaires connectées et possède actuellement 1 machine, le H2-1. Vous trouverez plus d’informations dans la fiche technique produit du modèle Système H2 sur la page du modèle Système H2. Les utilisateurs sont encouragés à tester la compatibilité de leur code en envoyant des travaux à un vérificateur de syntaxe et à l’émulateur System Model H2 avant de les soumettre aux target machines.

Si un utilisateur envoie un travail à l’ordinateur H2-1 et que l’ordinateur H2-1 n’est pas disponible, le travail reste dans la file d’attente de cet ordinateur jusqu’à ce que l’ordinateur soit disponible.

Le matériel System Model H2 est mis à niveau en continu tout au long du cycle de vie du produit. Les utilisateurs ont accès au matériel le plus récent, le plus avancé et le plus performant qui soit.

• Type de tâche : Quantum Program
• Format de données : quantinuum.openqasm.v1
• ID cible :
  • H2-1 : quantinuum.qpu.h2-1
  • H2-2 : quantinuum.qpu.h2-2
• Profil d’exécution cible : QIR Adaptive RI

Spécifications techniques du modèle système H2

Vous trouverez des détails techniques pour le modèle système H2 dans les feuilles de données de produit de Quantinuum sur la page System Model H2 , ainsi que des liens vers la spécification Quantinuum et les référentiels de données de volume quantique et comment citer l’utilisation des systèmes Quantinuum.

Fonctionnalités supplémentaires

Des fonctionnalités supplémentaires disponibles via l’API Quantinuum sont répertoriées ici.

Les utilisateurs peuvent tirer parti de ces fonctionnalités supplémentaires via des fonctions de circuit ou des paramètres pass-through dans les fournisseurs Azure Quantum Q# et Qiskit.

Mesure et réinitialisation du circuit intermédiaire

La mesure et la réinitialisation du circuit intermédiaire (MCMR) permettent aux utilisateurs de mesurer les qubits au milieu d’un circuit et de les réinitialiser. Cela permet la fonctionnalité de correction des erreurs quantiques ainsi que la possibilité de réutiliser des qubits au sein du circuit.

En raison de la structure interne des qubits à ions piégés, une mesure à mi-circuit peut laisser le qubit dans un état non calculable. Toutes les mesures de circuit intermédiaire doivent être suivies d’une réinitialisation si le qubit doit être utilisé à nouveau dans ce circuit. Les exemples de code suivants illustrent cela.

Lorsqu’un sous-ensemble de qubits est mesuré au milieu du circuit, les informations classiques de ces mesures peuvent être utilisées pour conditionner les éléments futurs du circuit. Les exemples mettent également en évidence cette utilisation.

Pour plus d’informations sur MCMR dans les systèmes Quantinuum, consultez la page MCMR sur Quantinuum Docs.

%%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()

Portes ZZ à angle arbitraire

L’ensemble de portes natives de Quantinuum inclut des portes ZZ avec un angle arbitraire. Cela permet de réduire le nombre de portes à 2 qubits pour de nombreux algorithmes quantiques et séquences de portes. Pour plus d’informations sur les portes ZZ à angle arbitraire dans les systèmes Quantinuum, consultez la page Portes ZZ à angle paramétrable sur Quantinuum Docs.

%%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()

Porte d'intrication SU(4) générale

Le jeu de portes natif de Quantinuum comprend une porte d'enchevêtrement SU(4) générale. Notez que les circuits quantiques soumis au matériel sont rebasés sur la porte ZZ à enchevêtrement complet et sur la porte RZZ à angle arbitraire. Les circuits ne sont rebasés vers la porte d'intrication SU(4) générale que si les utilisateurs choisissent de le faire. Pour plus d’informations sur l’Entangler SU(4) Général dans les systèmes Quantinuum, consultez la page Portes d’angle paramétré SU(4) dans Quantinuum Docs.

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

from qdk import qsharp

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

from qdk.azure import Workspace

MyWorkspace = Workspace(
    resource_id = "",
    location = ""
)

MyTarget = MyWorkspace.get_targets("quantinuum.sim.h2-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()

Paramètres de bruit de l’émulateur

Les utilisateurs ont la possibilité d’expérimenter les paramètres de bruit des émulateurs Quantinuum. Seuls quelques-uns des paramètres de bruit disponibles sont mis en surbrillance ici, montrant comment passer les paramètres dans les fournisseurs Azure Quantum.

Pour plus d’informations sur l’ensemble complet des paramètres de bruit disponibles, consultez la page Émulateurs Quantinuum dans la documentation Quantinuum.

from qdk import qsharp
from qdk.azure import Workspace

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 = Workspace(
    resource_id = "",
    location = ""
)

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

# Update the parameter names desired
# Note: This is not the full set of options available. 
# For the full set, see the Quantinuum Emulators page
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.h2-1e")

# Update the parameter names desired
# Note: This is not the full set of options available. 
# For the full set, see the Quantinuum Emulator page
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" 
}

Compilation TKET dans la pile Quantinuum

Les circuits soumis aux systèmes Quantinuum Quantinuum, à l’exception des soumissions hybrides intégrées, sont exécutés automatiquement via des passes de compilation TKET pour le matériel Quantinuum. Cela permet aux circuits d’être automatiquement optimisés pour les systèmes Quantinuum et de s’exécuter plus efficacement.

Vous trouverez plus d’informations sur les passes de compilation spécifiques appliquées dans la pytket-quantinuum documentation, notamment dans la section pytket-quantinuum Passes de compilation.

Dans la pile logicielle Quantinuum, le niveau d’optimisation appliqué est défini avec le paramètre tket-opt-level. Le paramètre de compilation par défaut pour tous les circuits soumis aux systèmes Quantinuum est le niveau d’optimisation 2.

Les utilisateurs qui souhaitent expérimenter avec les passes de compilation TKET et voir les optimisations qui pourraient être appliquées à leurs circuits avant d’envoyer des travaux peuvent consulter le notebook Quantinuum_compile_without_api.ipynb dans le dossier pytket-quantinuum Exemples .

Pour désactiver la compilation TKET dans la pile, une autre option no-opt peut être définie sur True à l’intérieur de option_params. Par exemple : "no-opt": True.

Pour plus d’informations sur pytket, consultez les liens suivants :

• pytket
• pytket Manuel de l'utilisateur

from qdk import qsharp
from qdk.azure import Workspace
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 = Workspace(
    resource_id = "",
    location = ""
)

MyTarget = MyWorkspace.get_targets("quantinuum.sim.h2-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.h2-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())

Spécifications techniques

Vous trouverez des détails techniques pour le modèle de système H2 et les émulateurs du modèle de système H2 sur la page Guide de l’utilisateur matériel, en plus de la spécification Quantinuum, des référentiels de données de volume quantique et de Comment citer les systèmes Quantinuum.

Disponibilité cible

Les ordinateurs quantiques Quantinuum sont conçus pour être mis à niveau en continu, ce qui permet aux clients d’avoir accès aux dernières fonctionnalités matérielles à mesure que Quantinuum améliore les fidélités de porte, les erreurs de mémoire et la vitesse du système.

Le matériel Quantinuum passe par des périodes commerciales et des périodes de développement. Pendant les périodes commerciales, le matériel est disponible pour traiter des travaux par le biais d’un système de file d’attente. Pendant les périodes de développement, le matériel est hors connexion, car des mises à niveau sont appliquées.

Chaque mois, un calendrier est envoyé aux utilisateurs Quantinuum avec des informations sur les périodes commerciales et de développement. Si vous n’avez pas reçu ce calendrier, veuillez envoyer un e-mail à l’adresse QCsupport@quantinuum.com.

L’état d’un target indique sa capacité actuelle à traiter les tâches. Les états possibles d’un target élément sont les suivants :

• Disponible : target est en ligne, traitant les travaux soumis et acceptant de nouveaux.
• Détérioré : le target accepte des travaux, mais ne les traite pas actuellement.
• Non disponible : l’objet target est hors connexion et n’accepte pas de nouvelles soumissions de travaux.

Pour l’ordinateur targetsquantique Quantinuum, Disponible et détérioré correspondent aux périodes commerciales, tandis que Non disponible correspond aux périodes de développement où la machine est hors connexion pour les mises à niveau.

Les informations d’état actuelles peuvent être récupérées à partir de l’onglet Fournisseurs d’un espace de travail sur le portail Azure.

Pricing

Pour voir les plans de facturation de Quantinuum, visitez la page des tarifs Azure Quantum.

Limites et quotas

Les quotas de Quantinuum sont suivis sur la base de l’unité de crédit d’utilisation QPU, crédit Hardware Quantum (HQC), pour les travaux soumis aux ordinateurs quantiques Quantinuum et eHQC (HQC d’émulateur) pour les travaux soumis aux émulateurs.

Les crédits HQC et eHQC servent à calculer le coût d’exécution d’un travail, et ils sont calculés selon la formule suivante :

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

where:

• $N_{1q}$ est le nombre d’opérations à un qubit dans un circuit.
• $N_{2q}$ est le nombre d’opérations natives à deux qubit dans un circuit. La porte native est équivalente à CNOT jusqu’à plusieurs portes à un qubit.
• $N_{m}$ est le nombre d’opérations de préparation et de mesure (SPAM) de l’état dans un circuit, y compris la préparation de l’état implicite initial et toutes les mesures intermédiaires et finales et les réinitialisations d’état.
• $C$ est le nombre de captures.

Les quotas dépendent du plan sélectionné et peuvent être augmentés avec un ticket de support. Pour afficher vos limites et quotas actuels, accédez à la section Opérations et sélectionnez le panneau Quotas de votre espace de travail sur le portail Azure. Pour plus d’informations, consultez Quotas Azure Quantum.