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 :

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

Tous les circuits hybrides intégrés de targets Quantinuum prennent désormais en charge 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.

Pour commencer à utiliser le fournisseur Quantinuum sur Azure Quantum, consultez Prise en main de Q# et d’un notebook Azure Quantum.

Vérificateurs de syntaxe

Nous recommandons aux utilisateurs de commencer par valider leur code à l’aide de notre vérificateur de syntaxe. Il s’agit d’un outil qui permet de vérifier la syntaxe, l’achèvement de la compilation et la compatibilité de la machine. Les vérificateurs de syntaxe utilisent le même compilateur que l’ordinateur quantique qu’ils target. Par exemple, le vérificateur de syntaxe H1-1 utilise le même compilateur que H1-1. La pile de compilation complète est exécutée à l’exception des opérations quantiques réelles. Si le code se compile, le vérificateur de syntaxe retourne un success état et un résultat de toutes les 0. Si le code ne compile pas, le vérificateur de syntaxe retourne un état d’échec et donne l’erreur retournée 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
• Target ID:
  • Vérificateur de syntaxe H1-1 : quantinuum.sim.h1-1sc
  • Vérificateur de syntaxe H2-1 : quantinuum.sim.h2-1sc
• Target Profil d’exécution : QIR Adaptive RI

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

Émulateurs du modèle de système H1

Après avoir validé la syntaxe de leur code avec un vérificateur de syntaxe, les utilisateurs peuvent tirer parti des émulateurs System Model H1 de Quantinuum, des outils d’émulation qui contiennent un modèle physique détaillé et un modèle de bruit réaliste du matériel H1 du modèle système réel. Les modèles de bruit sont dérivés d’une caractérisation détaillée du matériel. Les émulateurs System Model H1 utilisent une API identique pour la soumission de travaux en tant que matériel System Model H1, ce qui permet une transition transparente de l’émulation au matériel. Pour optimiser la productivité et raccourcir le temps de développement, les émulateurs System Model H1 sont disponibles même si le matériel est hors connexion.

Vous trouverez plus d’informations dans la feuille de données produit de l’émulateur System Model H1 dans la page System Model H1.

• Type de tâche : Simulation
• Format de données : quantinuum.openqasm.v1
• Target ID:
  • H1-1 Emulator : quantinuum.sim.h1-1e
• Target Profil d’exécution : QIR Adaptive RI

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

Émulateur de série H (basé sur le cloud)

L’émulateur H-Series est disponible gratuitement sur la page Code avec Azure Quantum sur le site web Azure Quantum, où vous pouvez écrire du code Q# et envoyer vos travaux à l’émulateur Quantinuum H-Series sans compte Azure. L’émulateur de série H est un émulateur quantique basé sur un état qui utilise un modèle de bruit physique réaliste et des paramètres d’erreur généralisés en fonction des performances classiques d’un ordinateur quantique H1 de modèle système. La simulation quantique effectuée est la même que l’émulateur System Model H1, 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.

Modèle de système H1

La génération System Model H1 d’ordinateurs quantiques, alimenté par Honeywell, est composée d’un appareil à couplage de charge quantique (QCCD) avec une section linéaire et comprend actuellement une machine targets: le H1-1. Les utilisateurs sont encouragés à tester la compatibilité de leur code avec le H1-1 en envoyant des travaux à un vérificateur de syntaxe et à l’émulateur System Model H1 avant de les soumettre aux target machines.

La machine System Model H1 est mise à niveau en continu tout au long de son cycle de vie de produit. Les utilisateurs ont accès au matériel le plus récent, le plus avancé et le plus performant qui soit.

Vous trouverez plus d’informations dans la feuille de données produit Du modèle système H1 dans la page Modèle système H1 .

• Type de tâche : Quantum Program
• Format de données : honeywell.openqasm.v1, honeywell.qir.v1
• Target ID:
  • H1-1 : quantinuum.qpu.h1-1
• Target Profil d’exécution : QIR Adaptive RI

Émulateur H2 du modèle système

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 en tant que matériel System Model H2, ce qui permet une transition transparente 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
• Target ID:
  • Émulateur H2-1 : quantinuum.sim.h2-1e
• Target Profil d’exécution : 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 feuille de données produit Du modèle système H2 dans la page 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
• Target ID:
  • H2-1 : quantinuum.qpu.h2-1
• Target Profil d’exécution : QIR Adaptive RI

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

Vous trouverez des détails techniques pour le modèle système H1 et le modèle système H2 dans les feuilles de données produit de Quantinuum sur les pages System Model H1 et 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 de niveau interne des qubits d’ion piégés, une mesure de circuit intermédiaire peut laisser le qubit dans un état de non-calcul. 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 les feuilles de données de produit de la série H sur les pages System Model H1 et System Model H2 .

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

Angle arbitraire ZZ Gates

L’ensemble de portes natives de Quantinuum comprend des portes ZZ d’angle arbitraire. Cela est bénéfique pour 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 d’angle arbitraire dans les systèmes Quantinuum, consultez les feuilles de données de la série H sur les pages System Model H1 et System Model H2 .

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

Général SU(4) Entangling Gate

L’ensemble de portes natives de Quantinuum comprend une porte d’entrée générale SU(4). Notez que les circuits quantiques soumis au matériel sont redéployés à la porte ZZ entièrement enanglantée et à la porte RZZ d’angle arbitraire. Les circuits ne sont rebases qu’à la porte d’entrée générale SU(4) si les utilisateurs y optent. Pour plus d’informations sur les systèmes Entangler généraux (4) dans les systèmes Quantinuum, consultez les feuilles de données produit de la série H sur les pages System Model H1 et System Model H2 .

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

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 les feuilles de données produit de l’émulateur de série H sur les pages System Model H1 et System Model H2 .

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" 
}

Compilation TKET dans la pile de sérieS H

Les circuits soumis aux systèmes Quantinuum H-Series, à l’exception des soumissions hybrides intégrées, sont exécutés automatiquement via des passes de compilation TKET pour le matériel de série H. Cela permet aux circuits d’être automatiquement optimisés pour les systèmes de série H 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, en particulier dans la pytket-quantinuum section Passes de compilation.

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

Les utilisateurs qui souhaitent expérimenter la compilation TKET passent et voient quelles optimisations s’appliqueraient à leurs circuits avant d’envoyer des travaux peuvent voir le notebook Quantinuum_compile_without_api.ipynb dans lepytket-quantinuum dossier Exemples.

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

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

• pytket
• pytket Manuel

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

Spécifications techniques

Des détails techniques pour les émulateurs System Model H1 et H2 et System Model H1 et H2 sont disponibles dans les feuilles de données de produit de Quantinuum sur la page System Model H1 et 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.

Target Disponibilité

Les ordinateurs quantiques Quantinuum H-Series 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état indique sa capacité actuelle à traiter les travaux. Les états possibles d’un target élément sont les suivants :

• Disponible : il target s’agit de travaux en ligne, de traitement des travaux soumis et d’acceptation de nouveaux travaux.
• Détérioré : les target travaux acceptent, mais ne les traitent 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.

Vous pouvez récupérer des informations sur l’état actuel à partir de l’onglet Fournisseurs d’un espace de travail sur le portail Azure.

Tarification

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

Limites et quotas

Les quotas de Quantinuum sont suivis en fonction de l’unité de crédit d’utilisation du QPU, du crédit quantique H-System (HQC) pour les travaux soumis à des ordinateurs quantiques Quantinuum et des HQCs (eHQCs) 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 $$

où :

• $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 consulter vos limites et quotas actuels, accédez au panneau Crédits et quotas, puis sélectionnez l’onglet Quotas de votre espace de travail sur le portail Azure. Pour plus d’informations, consultez Quotas Azure Quantum.