Exécuter des travaux d’informatique quantique hybride avec un profil adaptatif target

L’informatique hybride combine des processus informatiques classiques et quantiques pour résoudre des problèmes complexes.

Dans l’informatique hybride, le code classique contrôle l’exécution d’opérations quantiques basées sur des mesures de circuit moyen tandis que les qubits physiques restent actifs. Vous pouvez utiliser des techniques de programmation courantes, telles que les conditions imbriquées, les boucles et les appels de fonction, dans un seul programme quantique pour exécuter des problèmes complexes, réduisant ainsi le nombre de captures nécessaires. Avec les techniques de réutilisation qubit, les programmes plus volumineux peuvent s’exécuter sur des machines à l’aide d’un plus petit nombre de qubits.

Cet article explique comment envoyer des travaux hybrides à Azure Quantum à l’aide du QIR Adaptive RItarget profil. Le profil RI target adaptatif offre la prise en charge des mesures intermédiaires, du flux de contrôle basé sur les mesures, de la réinitialisation de qubit et du calcul entier classique.

Prérequis

• Compte Azure avec un abonnement actif. Si vous n’avez pas de compte Azure, inscrivez-vous gratuitement et inscrivez-vous à un abonnement de paiement à l’utilisation.
• Un espace de travail Azure Quantum. Pour plus d’informations, consultez Créer un espace de travail Azure Quantum.
• Si vous souhaitez soumettre Q# des programmes autonomes, vous avez besoin des conditions préalables suivantes :
  • Visual Studio Code avec l’extension Azure Quantum Development Kit installée.
  • Dernière version de l’extension AzureQuantum Development Kit.
• Si vous souhaitez envoyer Python + Q# programmes, vous avez besoin des conditions préalables suivantes :

  • Un environnement Python avec Python et Pip installés.

  • Azure Quantum azure-quantum et qsharp packages.

    pip install --upgrade azure-quantum qsharp
    

Prise en charge de targets

Pour exécuter des travaux d’informatique quantique hybride, vous devez sélectionner un fournisseur quantique qui prend en charge le profil RI target adaptatif.

Actuellement, le profil adaptatif target dans Azure Quantum est pris en charge sur Quantinuumtargets.

Envoi de travaux ri adaptatifs

Pour soumettre des travaux d’informatique quantique hybride, vous devez configurer le target profil en tant que QIR Adaptive RI, où RI signifie «qubit Reset et Integer computations».

Le QIR Adaptive RItarget profil offre la prise en charge des mesures intermédiaires, du flux de contrôle basé sur les mesures, de la réinitialisation qubit et du calcul d’entier classique.

Vous pouvez soumettre des travaux quantiques hybrides à Azure Quantum en tant que Q# programmes autonomes ou Python + Q# programmes. Pour configurer le target profil pour les travaux quantiques hybrides, consultez les sections suivantes.

Fonctionnalités prises en charge

Le tableau suivant répertorie les fonctionnalités prises en charge pour l’informatique quantique hybride avec Quantinuum dans Azure Quantum.

Le QDK fournit targetdes commentaires spécifiques lorsque Q# les fonctionnalités de langage ne sont pas prises en charge pour l’élément sélectionné target. Si votre Q# programme contient des fonctionnalités non prises en charge lors de l’exécution de travaux quantiques hybrides, vous recevrez un message d’erreur au moment du design. Pour plus d’informations, consultez la page wiki QIR.

Pour afficher les fonctionnalités prises en charge en action, copiez le code suivant dans un Q# fichier et ajoutez les extraits de code suivants.

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
}

Quantinuum prend en charge les bools et entiers dynamiques, ce qui signifie des bools et des entiers qui dépendent des résultats de mesure. Notez qu’il r0 s’agit d’un Result type qui peut être utilisé pour générer des valeurs de bool et d’entier dynamiques.

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

Quantinuum prend en charge les bools et entiers dynamiques. Toutefois, il ne prend pas en charge les valeurs dynamiques pour d’autres types de données, tels que double. Copiez le code suivant pour voir les commentaires sur les limitations des valeurs dynamiques.

        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

Même si les valeurs dynamiques ne sont pas prises en charge pour certains types de données, ces types de données peuvent toujours être utilisés avec des valeurs statiques.

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

Même les valeurs dynamiques prises en charge ne peuvent pas être utilisées dans certaines situations. Par exemple, Quantinuum ne prend pas en charge les tableaux dynamiques, autrement dit, les tableaux dont la taille dépend d’un résultat de mesure. Quantinuum ne prend pas en charge les boucles délimitées dynamiquement non plus. Copiez le code suivant pour voir les limitations des valeurs dynamiques.

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

Quantinuum prend en charge le flux de contrôle, y compris if/else la branchement, à l’aide de conditions statiques et dynamiques. La branchement sur des conditions dynamiques est également appelé branchement basé sur les résultats de mesure.

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

Quantinuum prend en charge les boucles avec des conditions classiques et y compris if des expressions.

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

Quantinuum prend en charge la mesure du circuit moyen, c’est-à-dire la branche en fonction des résultats de mesure.

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

Estimation du coût d’un travail de calcul quantique hybride

Vous pouvez estimer le coût d’exécution d’un travail de calcul quantique hybride sur le matériel Quantinuum en l’exécutant d’abord sur un émulateur.

Après une exécution réussie sur l’émulateur :

1. Dans votre espace de travail Azure Quantum, sélectionnez Gestion des travaux.
2. Sélectionnez le travail que vous avez envoyé.
3. Dans la fenêtre contextuelle Détails du travail, sélectionnez Estimation du coût pour afficher le nombre de crédits d’émulateur de quantinuum (eHQCs) utilisés. Ce nombre se traduit directement par le nombre de HQC (crédits quantiques Quantinuum) nécessaires pour exécuter le travail sur le matériel Quantinuum.

Exemples d’informatique quantique hybride

Vous trouverez les exemples suivants dans le Q# référentiel d’exemples de code. Ils illustrent l’ensemble de fonctionnalités actuel pour l’informatique quantique hybride.

Code de répétition à trois qubits

Cet exemple montre comment créer un code de répétition à trois qubits qui peut être utilisé pour détecter et corriger les erreurs de retournement de bits.

Il tire parti des fonctionnalités de calcul hybride intégrées pour compter le nombre de fois où la correction des erreurs a été effectuée alors que l’état d’un registre qubit logique est cohérent.

Vous trouverez l’exemple de code ici.

Estimation de la phase itérative

Cet exemple de programme illustre une estimation de phase itérative dans Q#. Il utilise l’estimation de phase itérative pour calculer un produit interne entre deux vecteurs 2 dimensionnels encodés sur un target qubit et un qubit ancilla. Un qubit de contrôle supplémentaire est également initialisé, qui est le seul qubit utilisé pour la mesure.

Le circuit commence par encoder la paire de vecteurs sur le target qubit et le qubit ancilla. Il applique ensuite un opérateur Oracle à l’ensemble du registre, contrôlé sur le qubit de contrôle, qui est configuré dans l’état $\ket +$. L’opérateur Oracle contrôlé génère une phase sur l’état $\ket 1$ du qubit de contrôle. Cela peut ensuite être lu en appliquant une porte H au qubit de contrôle pour rendre la phase observable lors de la mesure.

Vous trouverez l’exemple de code ici.

Contenu connexe

• Prise en main des sessions