Informatique hybride intégrée

L’informatique hybride intégrée réunit les processus classiques et quantiques, ce qui permet au code classique de contrôler l’exécution d’opérations quantiques basées sur des mesures de circuit intermédiaire pendant que les qubits physiques restent actifs. À l’aide de techniques de programmation courantes, telles que les conditions imbriquées, les boucles et les appels de fonction, un seul programme quantique peut exécuter des problèmes complexes, ce qui réduit le nombre de captures nécessaires. À l’aide des techniques de réutilisation des qubits, les programmes plus volumineux peuvent s’exécuter sur des machines utilisant un plus petit nombre de qubits.

Important

L’informatique quantique hybride intégrée n’est actuellement pas prise en charge par l’extension QDK moderne Quantum Development Kit pour Visual Studio Code, ainsi que d’autres composants dans les exemples de cette page, tels que le noyau IQ# , la %azure commande magic ou le qsharp.azure module. Pour exécuter des travaux hybrides intégrés, utilisez microsoft Quantum Development Kit (QDK classique). Pour plus d’informations, consultez Continuer à travailler dans le QDK classique.

Pour plus d’informations, consultez :

• Granade & Weibe, « Using Random Walks for Iterative Phase Estimation ».
• Lubinski, et al., « Advancing Hybrid Quantum–Classic Computation with Real-Time Execution »

Prise en charge de targets

Actuellement, le modèle informatique hybride intégré dans Azure Quantum est pris en charge sur Quantinuumtargets.

Quantinuum

Fonctionnalité prise en charge	Notes
Boucles classiques	Boucles limitées uniquement
Flux de contrôle arbitraire	Utilisation de la branche if/else
Mesure du circuit intermédiaire	Utilise les ressources de registre classiques
Réutilisation des qubits	N/A
Calcul classique en temps réel	Arithmétique d’entier non signé 32 bits Utilise les ressources de registre classiques

Prise en main

Pour commencer à explorer la programmation hybride intégrée, nous vous suggérons de parcourir les exemples de cet article ou d’explorer l’onglet Informatique quantique hybride dans la galerie Exemples du portail Azure Quantum.

Envoi de travaux hybrides intégrés

Lors de l’envoi d’un travail hybride intégré, vous devez ajouter un target paramètre de fonctionnalité après avoir spécifié le target. En outre, les programmes hybrides intégrés sur Azure Quantum sont exécutés et gérés comme des travaux quantiques réguliers. Chaque travail a un ID de travail unique et le résultat est un seul histogramme.

Important

L’informatique quantique hybride intégrée n’est actuellement pas prise en charge par l’extension QDK moderne Quantum Development Kit pour Visual Studio Code, ainsi que d’autres composants dans les exemples de cette page, tels que le noyau IQ# , la %azure commande magic ou le qsharp.azure module. Pour exécuter des travaux hybrides intégrés, utilisez microsoft Quantum Development Kit (QDK classique). Pour plus d’informations, consultez Continuer à travailler dans le QDK classique.

JeQ#

Lorsque vous utilisez le noyau IQ# dans un Jupyter Notebook, utilisez %azure.target-capability magic command with the AdaptiveExecution parameter.

%azure.target quantinuum.sim.h1-1e
%azure.target-capability AdaptiveExecution

Python + Q#

Lorsque vous utilisez le package Python qsharp , utilisez la qsharp.azure.target_capability fonction avec le AdaptiveExecution paramètre .

qsharp.azure.target("quantinuum.sim.h1-1e")
qsharp.azure.target_capability("AdaptiveExecution")

Azure CLI

Lorsque vous utilisez Azure CLI pour envoyer un travail, ajoutez le --target-capability paramètre avec la valeur AdaptiveExecution.

az quantum job submit \
    --target-capability AdaptiveExecution \
    --target-id quantinuum.sim.h1-1e \
    --job-name IterativePhaseEstimation \
    --shots 100 \
    --output table

Envoi de travaux hybrides intégrés dans une session

Vous pouvez combiner plusieurs travaux hybrides intégrés au sein d’une session à l’aide de Q# et de Python. Lors de l’envoi d’une session, ajoutez le targetCapability paramètre d’entrée avec la valeur AdaptiveExecution.

with target.open_session(name="Q# session") as session:
    target.submit(input_data=QuantumOperation, name="Job 1", input_params={"count":100, "targetCapability":"AdaptiveExecution"}) # First job submission
    target.submit(input_data=QuantumOperation, name="Job 2", input_params={"count":200, "targetCapability":"AdaptiveExecution"}) # Second job submission
    target.submit(input_data=QuantumOperation, name="Job 3", input_params={"count":300, "targetCapability":"AdaptiveExecution"}) # Third job submission

Pour plus d’informations, consultez Prise en main des sessions.

Notes

Bien que les sessions soient disponibles pour tous les fournisseurs de matériel d’informatique quantique, notez que les travaux d’informatique quantique hybride intégrés sont actuellement pris en charge sur Quantinuum targets.

Estimation du coût d’un travail hybride intégré

Vous pouvez estimer le coût d’exécution d’un travail hybride intégré sur du 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 des coûts pour afficher le nombre d’eHQC (crédits de l’émulateur Quantinuum) qui ont été 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.

Notes

Quantinuum déroule l’intégralité du circuit et calcule le coût sur tous les chemins de code, qu’ils soient exécutés de manière conditionnelle ou non.

Exemples hybrides intégrés

Les exemples suivants illustrent l’ensemble de fonctionnalités actuelles pour l’informatique hybride intégrée.

• Vérifier un état GHZ enchevêtré
• Répétition à trois qubits
• Estimation de la phase itérative

Prérequis

• Si vous débutez avec Azure Quantum, vous aurez besoin d’un abonnement Azure et d’un espace de travail Azure Quantum pour exécuter les exemples sur du matériel quantique. Pour plus d’informations, consultez Créer un espace de travail Azure Quantum.
• VS Code et la Quantum Development Kit configuration dans votre environnement local. Pour plus d’informations, consultez Configurer le Quantum Development Kit.
• Vérifiez que VS Code dispose de la dernière version de ( Quantum Development Kit 0.27.258160).
  • Dans VS Code, sélectionnez Ctrl + Maj + X et recherchez « Microsoft Quantum Development Kit».

Les exemples de cet article sont configurés pour s’exécuter sur Visual Studio (VS) Code et utiliser l’interface de ligne de commande (CLI) Azure intégrée pour envoyer le travail à Azure Quantum. Pour exécuter la version Jupyter Notebook de ces exemples et d’autres, connectez-vous à votre espace de travail Portail Azure et affichez les exemples à partir de l’onglet Informatique quantique hybride dans la galerie Exemples. Vous pouvez exécuter le notebook dans le cloud ou le télécharger et l’exécuter localement.

Pour résoudre les problèmes liés aux programmes hybrides intégrés, consultez Résolution des problèmes d’hybride intégré.

Vérifier l’état GHZ

Dans cet exemple, vous allez découvrir comment fusionner des instructions classiques et quantiques dans le même programme, toutes entièrement traitées par le back-end d’informatique quantique.

Fonctionnalités à noter à propos de cet exemple :

• Les mesures de boucle et de qubit se produisent alors que les qubits restent cohérents.
• La routine combine des opérations de calcul classiques et quantiques.
• Vous n’avez pas besoin d’apprendre à programmer du matériel hautes performances spécialisé s’exécutant à côté du QPU (par exemple, fpga).
• L’exécution d’un programme équivalent sans les fonctionnalités hybrides intégrées nécessite de retourner chaque résultat de mesure intermédiaire, puis d’exécuter le post-traitement sur les données.

Créer un projet VS Code

1. Dans VS Code, créez un projet d’application Q# console autonome nommé CheckGHZ.

   1. Sélectionner Afficher > la palette >Q#de commandes : Créer une application console autonome de projet >

2. Remplacez la configuration dans CheckGHZ.csproj par ce qui suit :

   <Project Sdk="Microsoft.Quantum.Sdk/0.27.258160">
     <PropertyGroup>
       <OutputType>Exe</OutputType>
       <TargetFramework>net6.0</TargetFramework>
       <ExecutionTarget>quantinuum</ExecutionTarget>
       <TargetCapability>AdaptiveExecution</TargetCapability>
     </PropertyGroup>
   </Project>
   

3. Remplacez le code dans Program.qs par ce qui suit :

   namespace Microsoft.Quantum.Samples {
   
       open Microsoft.Quantum.Measurement;
       open Microsoft.Quantum.Intrinsic;
   
       /// # Summary
       /// Counts the number of times measurements of a prepared GHZ state did not match the expected correlations.
       @EntryPoint() // The EntryPoint attribute is used to mark that this operation is where a quantum program will start running.
       operation CheckGHZ() : Int {
           use q = Qubit[3];
           mutable mismatch = 0;
           for _ in 1..10 {
               // Prepare the GHZ state.
               H(q[0]);
               CNOT(q[0], q[1]);
               CNOT(q[1], q[2]);
   
               // Measures and resets the 3 qubits
               let (r0, r1, r2) = (MResetZ(q[0]), MResetZ(q[1]), MResetZ(q[2]));
   
               // Adjusts classical value based on qubit measurement results
               if not (r0 == r1 and r1 == r2) {
                   set mismatch += 1;
               }
           }
           return mismatch;
       }
   }
   

4. À partir d’une fenêtre de terminal dans VS Code, connectez-vous à votre espace de travail Azure Quantum et définissez les ressources par défaut.

   az login
   

   Notes

   Votre ID d’abonnement Azure, votre groupe de ressources et votre nom d’espace de travail peuvent être répertoriés dans la fenêtre du terminal après vous être connecté en exécutant az quantum workspace list. Vous pouvez également les trouver dans le Portail Azure sur la page Vue d’ensemble de votre espace de travail Azure Quantum.

   az account set --subscription <MySubscriptionID>
   
   az quantum workspace set --resource-group <MyResourceGroup> --workspace <MyWorkspace> --location <MyLocation>
   

5. Envoyez le travail et affichez les résultats. Cette exécution utilise environ 10,65 eHQC (unités de facturation de l’émulateur Quantinuum)

   az quantum job submit \
     --target-id quantinuum.sim.h1-1e \
     --job-name CheckGHZ \
     --target-capability AdaptiveExecution \
     --shots 50
   

   az quantum job output \
     -o table \
     --job-id [job-id]
   

Code de répétition à trois qubits

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

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

Créer un projet VS Code

1. Dans VS Code, créez un projet Q# d’application console autonome nommé ThreeQubit.

   1. Sélectionner Afficher > la palette de commandes >Q#: Créer une application console autonome de projet >

2. Remplacez la configuration dans ThreeQubit.csproj par ce qui suit :

   <Project Sdk="Microsoft.Quantum.Sdk/0.27.258160">
   
     <PropertyGroup>
       <OutputType>Exe</OutputType>
       <TargetFramework>net6.0</TargetFramework>
       <ExecutionTarget>quantinuum</ExecutionTarget>
       <TargetCapability>AdaptiveExecution</TargetCapability>
     </PropertyGroup>
   
   </Project>
   

3. Remplacez le code dans Program.qs par ce qui suit :

   namespace Microsoft.Quantum.Samples {
   
       open Microsoft.Quantum.Intrinsic;
       open Microsoft.Quantum.Math;
       open Microsoft.Quantum.Measurement;
   
       @EntryPoint()
       operation ThreeQubitRepetitionCode() : (Bool, Int) {
           // Use two qubit registers, one for encoding and an auxiliary one for syndrome measurements.
           use encodedRegister = Qubit[3];
           use auxiliaryRegister = Qubit[2];
   
           // Initialize the first qubit in the register to a |-〉 state.
           H(encodedRegister[0]);
           Z(encodedRegister[0]);
   
           // Apply several unitary operations to the encoded qubits performing bit flip detection and correction between
           // each application.
           mutable bitFlipCount = 0;
           within {
               // The 3 qubit register is used as a repetition code.
               Encode(encodedRegister);
           }
           apply {
               let iterations = 5;
               for _ in 1 .. iterations {
                   // Apply a sequence of rotations to the encoded register that effectively perform an identity operation.
                   ApplyRotationalIdentity(encodedRegister);
   
                   // Measure the bit flip error syndrome, revert the bit flip if needed, and increase the count if a bit flip occurred.
                   let (parity01, parity12) = MeasureBitFlipSyndrome(encodedRegister, auxiliaryRegister);
                   let bitFlipReverted = RevertBitFlip(encodedRegister, parity01, parity12);
                   if (bitFlipReverted) {
                       set bitFlipCount += 1;
                   }
               }
           }
   
           // Transform the qubit to the |1〉 state and measure it in the computational basis.
           H(encodedRegister[0]);
           let result = MResetZ(encodedRegister[0]) == One;
           ResetAll(encodedRegister);
   
           // The output of the program is a boolean-integer tuple where the boolean represents whether the qubit
           // measurement result was the expected one and the integer represents the number of times bit flips occurred
           // throughout the program.
           return (result, bitFlipCount);
       }
   
       operation ApplyRotationalIdentity(register : Qubit[]) : Unit is Adj
       {
           // This operation implements an identity operation using rotations about the x-axis.
           // The Rx operation has a period of $2\pi$ (given that it is not possible to measure the difference between
           // states $|\\psi〉$ and $-|\\psi〉$). Using it to apply 4 $\frac{\pi}{2}$ rotations about the x-axis, effectively
           // leaves the qubit register in its original state.
           let theta = PI() * 0.5;
           for i in 1 .. 4 {
               for qubit in register
               {
                   Rx(theta, qubit);
               }
           }
       }
   
       operation RevertBitFlip(register : Qubit[], parity01 : Result, parity12 : Result) : Bool
       {
           if (parity01 == One and parity12 == Zero) {
               X(register[0]);
           }
           elif (parity01 == One and parity12 == One) {
               X(register[1]);
           }
           elif (parity01 == Zero and parity12 == One) {
               X(register[2]);
           }
   
           return parity01 == One or parity12 == One;
       }
   
       operation Encode(register : Qubit[]) : Unit is Adj
       {
           CNOT(register[0], register[1]);
           CNOT(register[0], register[2]);
       }
   
       operation MeasureBitFlipSyndrome(encodedRegister : Qubit[], auxiliaryRegister : Qubit[]) : (Result, Result)
       {
           // Measure the bit flip syndrome by checking the parities between qubits 0 and 1, and between qubits 1 and 2.
           ResetAll(auxiliaryRegister);
           CNOT(encodedRegister[0], auxiliaryRegister[0]);
           CNOT(encodedRegister[1], auxiliaryRegister[0]);
           CNOT(encodedRegister[1], auxiliaryRegister[1]);
           CNOT(encodedRegister[2], auxiliaryRegister[1]);
           let parity01 = MResetZ(auxiliaryRegister[0]);
           let parity12 = MResetZ(auxiliaryRegister[1]);
           return (parity01, parity12);
       }
   }
   

4. À partir d’une fenêtre de terminal dans VS Code, connectez-vous à votre espace de travail Azure Quantum et définissez les ressources par défaut.

   az login
   

   Notes

   Votre ID d’abonnement Azure, votre groupe de ressources et votre nom d’espace de travail peuvent être répertoriés dans la fenêtre du terminal après la connexion en exécutant az quantum workspace list. Vous pouvez également les trouver dans le Portail Azure de la page Vue d’ensemble de votre espace de travail Azure Quantum.

   az account set --subscription <MySubscriptionID>
   
   az quantum workspace set --resource-group <MyResourceGroup> --workspace <MyWorkspace> --location <MyLocation>
   

5. Envoyez le travail et affichez les résultats. Cette exécution utilise environ 11,31 eHQCs (unités de facturation de l’émulateur Quantinuum)

   az quantum job submit \
       --target-id quantinuum.sim.h1-1e \
       --job-name ErrorCorrection \
       --target-capability AdaptiveExecution \
       --shots 50
   

   az quantum job output \
       -o table \
       --job-id [job-id]
   

Estimation de la phase itérative

Cet exemple de code a été écrit par des membres de l’équipe KPMG Quantum en Australie et est soumis à une licence MIT. Il vise à démontrer des fonctionnalités étendues de boucles limitées, des appels de fonctions classiques au moment de Basic Measurement Feedbacktargets l’exécution, des instructions conditionnelles imbriquées si, des mesures de circuit intermédiaire et la réutilisation des qubits.

Calcul du produit interne à deux dimensions à l’aide d’une estimation de phase itérative sur trois qubits

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 dimensions encodés sur un target qubit et un qubit ancilla. Un qubit de contrôle supplémentaire est également initialisé, qui sera le seul qubit utilisé pour la mesure.

Le circuit commence par l’encodage de 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é hors du 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.

Créer un projet VS Code

1. Dans VS Code, créez un projet Q# d’application console autonome nommé IPE.

   1. Sélectionner Afficher > la palette de commandes >Q#: Créer une application console autonome de projet >

2. Remplacez la configuration dans IPE.csproj par les éléments suivants :

   <Project Sdk="Microsoft.Quantum.Sdk/0.27.253010">
   
     <PropertyGroup>
       <OutputType>Exe</OutputType>
       <TargetFramework>net6.0</TargetFramework>
       <ExecutionTarget>quantinuum.sim.h1-1e</ExecutionTarget>
     </PropertyGroup>
   
   </Project>
   

3. Remplacez le code dans Program.qs par ce qui suit :

   namespace IPE {
   
       //IMPORT LIBRARIES
       open Microsoft.Quantum.Intrinsic;
       open Microsoft.Quantum.Math;
       open Microsoft.Quantum.Arrays;
       open Microsoft.Quantum.Measurement;
       open Microsoft.Quantum.Convert;
   
   
       // additional code added here
   
   
   }
   

Vecteurs d’encodage

Les vecteurs v et c doivent être encodés sur le target qubit et le qubit ancilla. Le vecteur $v = (cos(\frac{\theta_1}{2}),sin(\frac{\theta_1}{2}))$ peut être représenté par l’état quantique $\ket v = cos(\frac{\theta_1}{2})\ket 0 + sin(\frac{\theta_1}{2})\ket 1$, de même, $c$ peut être construit à l’aide de $\theta_2$.

Rotation Y appliquée à un target qubit à l’état $\ket 0$ :

$$RY(\theta)\ket 0 = e^{iY\theta/2}\ket 0 = cos(\frac{\theta}{2})\ket 0 + sin(\frac{\theta}{2})\ket 1$$

Notes

Un facteur de 2 est présent ici sur ntta. Une application d’une porte $RY(2\pi)$ sur $\ket 0$ donne l’état $-\ket 0$ et encoderait le vecteur $(-1,0)$. Cette phase ne peut pas être considérée comme une phase globale et est supprimée car l’ensemble du registre sera enchevêtré.

Le registre du target qubit et du qubit ancilla est

$$\ket \Psi = \ket {\Psi_\text{Qubit cible}}\ket {\Psi_\text{Ancilla qubit}}$$

L’état à créer est sur le target qubit et le qubit ancilla est

$$\ket{\Psi}=\frac{1}{\sqrt{2}}(\ket{v}\ket{+}+\ket{c}\ket{-}),$$

qui prend également la forme

$$\ket{\Psi} = \frac{1}{2}(\ket{v}+\ket{c})\ket{0}+\frac{1}{2}(\ket{v}-\ket{c})\ket{1}.$$

Ajoutez l’opération suivante au fichier Program.qs .

//This is state preparation operator A for encoding the 2D vector
operation StateInitialisation(TargetReg : Qubit, AncilReg : Qubit, theta_1 : Double, theta_2 : Double) : Unit is Adj + Ctl {
    H(AncilReg);

    // Arbitray controlled rotation based on theta. This is vector v.
    Controlled R([AncilReg], (PauliY, theta_1, TargetReg));

    // X gate on ancilla to change from |+> to |->
    X(AncilReg);

    // Arbitray controlled rotation based on theta. This is vector c.
    Controlled R([AncilReg], (PauliY, theta_2, TargetReg));
    X(AncilReg);
    H(AncilReg);
}

The Oracle

Un oracle G doit être construit de telle sorte qu’il génère une phase propre sur l’état encodé sur le target qubit et le qubit ancilla. La construction de cet oracle n’a aucune importance pour la démonstration dans cet exemple, mais l’opération qu’il applique est

$$G\ket \Psi = e^{2\pi i\phi} \ket \Psi.$$

où le produit interne $\braket {v|c}$ est contenu dans la phase $\phi$, qui est liée entre [0,1]. En cas d’application contrôlée sur le qubit de contrôle qui commence dans cet état $\ket{\Psi_\text{Control Qubit}} = \ket +$

$$\begin{aligned} \text{Controlled }G \ket{\Psi_\text{Control Qubit}} \ket \Psi & = \frac {1}{\sqrt{2}} (\ket 0 \ket \Psi + e^{2\pi i\phi}\ket 1 \ket \Psi )\ & =\frac {1}{\sqrt{2}} (\ket 0 + e^{2\pi i\phi}\ket 1) \ket \Psi \end{aligné}$$

Maintenant, le qubit de contrôle contient la phase qui concerne le produit interne $\braket {v|c}$

$$\ket{\Psi_\text{Control Qubit}} = \frac {1}{\sqrt{2}} (\ket 0 + e^{2\pi i\phi}\ket 1)$$

Ajoutez l’opération suivante au fichier Program.qs .

operation GOracle(TargetReg : Qubit, AncilReg : Qubit, theta_1 : Double, theta_2 : Double) : Unit is Adj + Ctl {
    Z(AncilReg);
        within {
            Adjoint StateInitialisation(TargetReg, AncilReg, theta_1, theta_2);

            // Apply X gates individually here as currently ApplyAll is not Adj + Ctl
            X(AncilReg);
            X(TargetReg);
        }
        apply {
            Controlled Z([AncilReg],TargetReg);
        }
    }

Itération

Maintenant pour la partie itérative du circuit. Pour n mesures, considérez que la phase peut être représentée sous la forme d’une valeur binaire $\phi$, et que l’application d’oracles $2^n$ rend observable le nième point binaire de la phase (par multiplication binaire simple, et module $2\pi$). La valeur du qubit de contrôle peut être lue, placée dans un registre classique et la réinitialisation du qubit pour une utilisation dans l’itération suivante. L’itération suivante applique $2^{n-1}$ oracles, en corrigeant la phase sur le qubit de contrôle en fonction de la nième mesure. L’état sur le qubit de contrôle peut être représenté comme

$$ \ket {\Psi_{\text{Control Qubit}}} = \ket 0 + e^{2\pi i\phi}\ket 1 $$

où $\phi = 0.\phi_0\phi_1\phi_2\phi_3$...

L’application d’oracles contrôlés $2^n$ donne l’état sur le qubit de contrôle

$$ G^{2^n}\ket {\Psi_{\text{Control Qubit}}} = \ket 0 + e^{2\pi i 0.\phi_n\phi_{n+1}\phi_{n+2}\phi_{n+3}...} \ket 1 $$

Considérez que la phase n’a pas de termes plus profonds que $\phi_n$ (c’est-à-dire, termes $\phi_{n+1},\phi_{n+2}, \text{etc}$)

$$ G^{2^n}\ket {\Psi_{\text{Control Qubit}}} = \ket 0 + e^{2\pi i 0.\phi_n}\ket 1 $$

À présent, la valeur $\phi_n$ peut être observée avec une porte H et une mesure projetant le long de l’axe Z. Réinitialisation du qubit de contrôle et application de l’oracle $2^{n-1}$ fois

$$ G^{2^{n-1}}\ket {\Psi_{\text{Control Qubit}}} = \ket 0 + e^{2\pi i 0.\phi_{n-1}\phi_n}\ket 1 $$

À l’aide de la valeur mesurée précédente pour $\phi_n$, le point binaire supplémentaire peut être pivoté vers l’extérieur

$$ RZ(-2\pi \times 0.0\phi_n)G^{n-1}\ket {\Psi_{\text{Control Qubit}}} = \ket 0 + e^{2\pi i 0.\phi_{n-1}}\ket 1 $$

Ce processus est appliqué de manière itérative pour une précision de bits n pour obtenir la phase $0.\phi_0\phi_1\phi_2...\phi_{n}$. La valeur est stockée en tant que valeur binaire $x = \phi_0\phi_1\phi_2...\phi_{n}$, car seuls les entiers peuvent être manipulés au moment de l’exécution.

Comme la lecture ne dit rien des deux vecteurs, seul le produit interne entre eux, les états sur le qubit et le target qubit ancilla restent dans le même état tout au long du processus !

Ajoutez l’opération suivante au fichier Program.qs .

operation IterativePhaseEstimation(TargetReg : Qubit, AncilReg : Qubit, theta_1 : Double, theta_2 : Double, Measurements : Int) : Int{
    use ControlReg = Qubit();
    mutable MeasureControlReg = [Zero, size = Measurements];
    mutable bitValue = 0;

    //Apply to initialise state, this is defined by the angles theta_1 and theta_2
    StateInitialisation(TargetReg, AncilReg, theta_1, theta_2);
    for index in 0 .. Measurements - 1{
        H(ControlReg);

        //Don't apply rotation on first set of oracles
        if index > 0 {

            //Loop through previous results
            for index2 in 0 .. index - 1{
                if MeasureControlReg[Measurements - 1 - index2] == One{
                    let angle = -IntAsDouble(2^(index2))*PI()/(2.0^IntAsDouble(index));

                    //Rotate control qubit dependent on previous measurements and number of measurements
                    R(PauliZ, angle, ControlReg);
                }
            }
        }
        let powerIndex = (1 <<< (Measurements - 1 - index));

        //Apply a number of oracles equal to 2^index, where index is the number or measurements left
        for _ in 1 .. powerIndex{
                Controlled GOracle([ControlReg],(TargetReg, AncilReg, theta_1, theta_2));
            }
        H(ControlReg);

        //Make a measurement mid circuit
        set MeasureControlReg w/= (Measurements - 1 - index) <- MResetZ(ControlReg);
        if MeasureControlReg[Measurements - 1 - index] == One{

            //Assign bitValue based on previous measurement
            set bitValue += 2^(index);

        }
    }
    return bitValue;
}

Calculer le produit interne

Enfin, calculez le produit interne à partir de la valeur mesurée

$$\braket {v|c} = -cos(2\pi x / 2^n)$$

where $x = \phi_0\phi_1\phi_2...\phi_{n}$. Le dénominateur dans la fonction cosinus consiste à déplacer le point binaire pour qu’il corresponde à la valeur d’origine $\phi$.

Notes

Pour les produits internes qui ne sont pas -1 ou 1, les solutions sont associées à une différence de valeur de $2^{n-1}$. Par exemple, pour n=3 mesures, la valeur de bit mesurée de 2 aurait également une solution de paire de 6. L’une ou l’autre de ces valeurs produit la même valeur du produit interne lors de l’entrée en tant que variable dans la fonction égale cosinus (résultant en un produit interne de 0 dans cet exemple).

Pour les solutions de produit interne entre la précision de bits discrets, une distribution des résultats est générée en fonction de l’emplacement où le produit interne se trouve entre la valeur de bit discret.

Ajoutez l’opération suivante au fichier Program.qs .

function CalculateInnerProduct(Results : Int, theta_1 : Double, theta_2 : Double, Measurements : Int): Unit{
    let DoubleVal = PI() * IntAsDouble(Results) / IntAsDouble(2 ^ (Measurements-1));

    //Convert to the final inner product
    let InnerProductValue = -Cos(DoubleVal);
    Message("The Bit Value measured is:");
    Message($"{Results}");
    Message("The Inner Product is:");
    Message($"{InnerProductValue}");
    Message("The True Inner Product is:");
    Message($"{Cos(theta_1/2.0)*Cos(theta_2/2.0)+Sin(theta_1/2.0)*Sin(theta_2/2.0)}");
}

Exécuter le programme

Vous pouvez maintenant tester le programme. Tout d’abord, vous allez exécuter le programme à l’aide d’une opération de simulation localement, puis vous vous connecterez à Azure Quantum et l’exécuterez sur un matériel target.

Simulation de l’estimation de phase itérative

Q# les programmes nécessitent un @EntryPoint() pour indiquer au compilateur où commencer l’exécution du programme. Ajoutez le code suivant à Programs.qs pour démarrer le programme avec l’opération SimulateInnerProduct() . Cette version de l’opération de produit interne génère des informations supplémentaires, notamment la manipulation des doubles dont la sortie est affichée dans le terminal.

@EntryPoint()

//Operation for calculating the inner product on local simulators
operation SimulateInnerProduct() : Unit{

    //This operation will output additional classical calculations
    let (Results, theta_1, theta_2, Measurements) = InnerProduct();
    CalculateInnerProduct(Results, theta_1, theta_2, Measurements);
}

operation InnerProduct() : (Int, Double, Double, Int){

    //Specify the angles for inner product
    let theta_1 = 0.0;
    let theta_2 = 0.0;
    let Measurements = 3;

    //Create target register
    use TargetReg = Qubit();

    //Create ancilla register
    use AncilReg = Qubit();

    //This runs iterative phase estimation
    let Results = IterativePhaseEstimation(TargetReg, AncilReg, theta_1, theta_2, Measurements);
    Reset(TargetReg);
    Reset(AncilReg);
    return (Results, theta_1, theta_2, Measurements);
}

Pour exécuter le programme, ouvrez une fenêtre de terminal dans VS Code et exécutez

    dotnet run

S’exécutant sur azure Quantum target

Pour exécuter sur un matériel target, remplacez l’opération SimulateInnerProduct() par l’opération suivante HardwareInnerProduct() :

//Operation for calculating the inner product on hardware or emulators
operation HardwareInnerProduct() : Int{
    let (Results,_,_,_) = InnerProduct();
    return Results;
}

Ensuite, connectez-vous à votre espace de travail Azure Quantum et définissez les ressources par défaut.

az login

Notes

Votre ID d’abonnement Azure, votre groupe de ressources et votre nom d’espace de travail peuvent être répertoriés dans la fenêtre du terminal après la connexion en exécutant az quantum workspace list. Vous pouvez également les trouver dans le Portail Azure de la page Vue d’ensemble de votre espace de travail Azure Quantum.

az account set --subscription <MySubscriptionID>

az quantum workspace set --resource-group <MyResourceGroup> --workspace <MyWorkspace> --location <MyLocation>

Soumettez le travail avec les paramètres suivants :

az quantum job submit \
    --target-id quantinuum.sim.h1-1e \
    --target-capability AdaptiveExecution \
    --shots 50 \
    --job-name IterativePhaseEstimation

Notes

Le spécifié target nécessite un profil d’exécution target qui prend en charge Basic Measurement Feedback.

Important

Il n’est pas recommandé d’augmenter la valeur au-delà de 3 lors de Measurements l’exécution sur Azuretargets, car les eHQCs peuvent augmenter considérablement.

Vous pouvez afficher les status du travail avec

az quantum job output \
    -o table \
    --job-id [job-id]

remplacement de [job-id] par l’ID de travail affiché. Les résultats montrent une solution à l’état avec la population majoritaire. Le produit interne final des résultats entiers peut être calculé par $\braket {v|c} = -cos(2\pi x / 2^n)$, où n est le nombre de mesures spécifiées dans le travail.

Notes

La sélection de paramètres d’entrée qui n’ont qu’un seul état de solution (produits internes de -1 ou 1) est idéale pour la visibilité lors de l’utilisation d’un faible nombre de captures.

Étapes suivantes

Informatique hybride distribuée