Partager via

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

Cibles

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

Nom de la cible ID de la cible Nombre de qubits Descriptif
Vérificateur de syntaxe H1-1 quantinuum.sim.h1-1sc 20 qubits Utilisez cette option pour valider les programmes quantiques par rapport au compilateur H1-1 avant de les soumettre à du matériel ou des émulateurs sur la plateforme de Quantinuum. Gratuit.
Vérificateur de syntaxe H2-1 quantinuum.sim.h2-1sc 56 qubits Utilisez-le pour valider les programmes quantiques par rapport au compilateur H2-1 avant de les soumettre à du matériel ou des émulateurs sur la plateforme de Quantinuum. Gratuit.
Vérificateur de syntaxe H2-2 quantinuum.sim.h2-2sc 56 qubits Utilisez cette option pour valider les programmes quantiques par rapport au compilateur H2-2 avant de les soumettre à du matériel ou des émulateurs sur la plateforme de Quantinuum. Gratuit.
Émulateur H1-1 quantinuum.sim.h1-1e 20 qubits Utilise un modèle physique réaliste et un modèle de bruit de H1-1.
Émulateur H2-1 quantinuum.sim.h2-1e 56/32 qubits Utilise un modèle physique réaliste et un modèle de bruit de H2-1. La simulation à 56 qubits n’est disponible que comme simulation du stabilisateur
Émulateur H2-2 quantinuum.sim.h2-2e 56/32 qubits Utilise un modèle physique réaliste et un modèle de bruit H2-2. La simulation à 56 qubits n’est disponible que comme simulation du stabilisateur
H1-1 quantinuum.qpu.h1-1 20 qubits Appareil d’ion piégé H1-1 de Quantinuum.
H2-1 quantinuum.qpu.h2-1 56 qubits Quantinuum H2-1 appareil à ions piégés.
H2-2 quantinuum.qpu.h2-1 56 qubits Appareil d’ion piégé H2-2 de Quantinuum.

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.

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

Conseil

Les travaux quantiques soumis dans le cadre d'une session ont un accès exclusif au matériel Quantinuum tant que vous mettez les travaux en file d'attente à moins d'une minute les uns des autres. Après cela, tout travail est accepté et géré avec la logique de mise en file d’attente et de hiérarchisation standard. Pour plus d’informations, consultez les sessions dans 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 la même capacité calcul 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 est compilé, le vérificateur syntaxique renvoie un statut success et un résultat de tous les 0. Si le code ne se compile pas, le vérificateur syntaxique renvoie un état d'échec et donne l'erreur renvoyée pour aider les utilisateurs à déboguer la syntaxe de leur 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 H1-1 : quantinuum.sim.h1-1sc
    • 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.

É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 la même API pour la soumission de travaux que le matériel System Model H1, permettant une transition fluide 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 sur la page System Model H1.

  • Type de tâche : Simulation
  • Format de données : quantinuum.openqasm.v1
  • ID cible :
    • H1-1 Emulator : quantinuum.sim.h1-1e
  • Profil d’exécution cible : 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 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 état vecteur qui utilise un modèle réaliste de bruit physique et des paramètres d'erreur généralisés basés sur les performances typiques d’un ordinateur quantique System Model H1. 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 fiche technique du produit du modèle système H1 sur la page Modèle système H1.

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

É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 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.

Capacité Descriptif
Mesure et réinitialisation à mi-circuit (MCMR) Mesurer les qubits au milieu d’un circuit et les réutiliser
Portes ZZ à angle arbitraire Effectuer directement des rotations de portes à angle arbitraire de 2 qubits
Porte d'intrication SU(4) générale Effectuer directement des rotations de portes à angle arbitraire de 2 qubits
Paramètres de bruit de l’émulateur Expérimenter avec les paramètres de bruit utilisés dans les émulateurs Quantinuum
Optimisations TKET dans la pile Quantinuum Expérimentez avec l'activation de différents niveaux d'optimisations TKET dans la pile Quantinuum.

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 les fiches produit des systèmes Quantinuum sur les pages Modèle de système H1 et Modèle de système H2.

Dans Q#, la MResetZ fonction peut être utilisée à la fois pour mesurer un qubit et la réinitialiser. Pour plus d’informations sur cette fonction, consultez MResetZ dans la documentation Q#.

%%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];
}

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 les fiches techniques des produits des systèmes Quantinuum sur les pages du modèle de système H1 et du modèle de système H2 .

Dans Q#, la porte ZZ d’angle arbitraire est implémentée avec l’opération Rzz .

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

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 le General SU(4) Entangler dans les systèmes Quantinuum, consultez les fiches de données produit sur les pages consacrées au Modèle de système H1 et au Modèle de système H2.

Dans Q#, la porte d'intrication générale SU(4) est implémentée via le profil QIR de Quantinuum. Pour l’utiliser, définissez une fonction avec une intrinsèque personnalisée correspondant à la signature de profil QIR et utilisez cette fonction dans l’opération SU4Example .

Pour vous assurer que le circuit s’exécute avec la porte d'intrication SU(4) générale, passez les options suivantes dans la pile Quantinuum :

  • nativetq: Rxxyyzz afin d'éviter le rebasage vers d'autres portes natives.
  • noreduce: True pour éviter d’autres optimisations du compilateur (facultatives).
%%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)
}

Compilez maintenant l’opération :

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

Connectez-vous à Azure Quantum, sélectionnez la target machine et configurez les paramètres de bruit pour l’émulateur :

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
}

Indiquez l'option noreduce lorsque vous soumettez le travail :

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 fiches produit de l’émulateur Quantinuum sur les pages Modèle de système H1 et Modèle de système H2.

Tout d’abord, importez les packages requis et lancez le profil de base :

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

Ensuite, définissez la fonction.

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

et compilez l'opération :

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

Connectez-vous à Azure Quantum, sélectionnez la target machine et configurez les paramètres de bruit pour l’émulateur :

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

Transmettez les options de bruit de l’émulateur lors de l’envoi du travail :

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

Pour désactiver le modèle de bruit de l’émulateur, définissez l’option error-model sur False. Par défaut, elle est définie sur True.

option_params = {
    "error-model": False 
}

Pour utiliser l'émulateur de stabilisateur, définissez l'option simulator sur stabilizer. Par défaut, elle est définie sur state-vector.

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 la compilation TKET et voir quelles optimisations s’appliqueraient à leurs circuits avant d'envoyer des travaux, peuvent consulter le notebook Quantinuum_compile_without_api.ipynb dans le dossier .

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 :

Tout d’abord, importez les packages requis et lancez le profil de base :

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

Ensuite, définissez la fonction.

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

et compilez l'opération :

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

Connectez-vous à Azure Quantum, sélectionnez la target machine et configurez les paramètres de bruit pour l’émulateur :

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
}

Introduisez l'option d'optimisation lors de la soumission du travail :

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

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.

Disponibilité visée

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 : Le target est en ligne, traite les travaux soumis et accepte de nouveaux travaux.
  • Dégradé : 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.

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 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 $$

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.

Remarque

Le coût total en HQC inclut toutes les portes et mesures à travers toutes les branches conditionnelles ou flux de contrôle. Cela peut avoir un impact plus élevé sur les travaux hybrides intégrés.

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.