統合ハイブリッドコンピューティング

[アーティクル]
12/07/2023

統合ハイブリッドコンピューティングでは、従来のプロセスと量子プロセスがまとめられ、物理量子ビットが存続している間に、中間回路の測定に基づいて量子操作の実行を従来のコードで制御できます。入れ子になった条件、ループ、関数呼び出しなどの一般的なプログラミング手法を使用すると、1 つの量子プログラムで複雑な問題が発生し、必要なショットの数が減る可能性があります。量子ビット再利用手法を使用すると、より少ない数の量子ビットを使用するマシンで大規模なプログラムを実行できます。

重要

統合ハイブリッド量子コンピューティングは、Visual Studio Code の Modern Quantum Development Kit (Modern QDK) 拡張機能と、このページの例の他のコンポーネント (IQ# カーネル、マジックコマンドqsharp.azure、%azureモジュールなど) では現在サポートされていません。統合ハイブリッドジョブを実行するには、Microsoft Quantum Development Kit (クラシック QDK) を使用します。詳細については、「従来の QDK で作業を続行する」を参照してください。

詳細については、以下を参照してください。

統合ハイブリッド量子コンピューティング

targets をサポートするようになりました

現在、Azure Quantum の統合ハイブリッドコンピューティングモデルは Quantinuumtargets でサポートされています。

Quantinuum

サポートされている機能	メモ
従来のループ	境界付きループのみ
任意の制御フロー	if/else 分岐の使用
中間回路測定	従来のレジスタリソースを利用します
量子ビットの再利用	該当なし
リアルタイムの従来のコンピューティング	32 ビット符号なし整数算術従来のレジスタリソースを利用します

作業の開始

統合ハイブリッドプログラミングの調査を開始するには、この記事のサンプルを確認するか、Azure Quantum ポータルのサンプルギャラリーにある [ハイブリッド量子コンピューティング ] タブを確認することをお勧めします。

統合ハイブリッドジョブの送信

統合ハイブリッドジョブを送信する場合は、を指定した後に target capability パラメーターを追加する target必要があります。それ以外に、Azure Quantum 上の統合ハイブリッドプログラムは、通常の量子ジョブと同様に実行および管理されます。各ジョブには 1 つのジョブ ID があり、結果は 1 つのヒストグラムです。

重要

私Q#

Jupyter Notebookで IQ# カーネルを使用する場合は、%azure を使用します。target-capability magic コマンドと AdaptiveExecution パラメーター。

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

Python + Q#

qsharp Python パッケージを使用する場合は、パラメーターと共に qsharp.azure.target_capability 関数をAdaptiveExecution使用します。

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

Azure CLI

Azure CLI を使用してジョブを送信する場合は、値 AdaptiveExecutionを指定して --target-capability パラメーターを追加します。

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

セッション内での統合ハイブリッドジョブの送信

と Python を使用して、セッション内で複数の統合ハイブリッドジョブを Q# 組み合わせることができます。セッションを送信するときに、値 AdaptiveExecutionを指定してtargetCapability入力パラメーターを追加します。

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

詳細については、「セッションの概要」を参照してください。

注意

セッションはすべての量子コンピューティングハードウェアプロバイダーで使用できますが、統合ハイブリッド量子コンピューティングジョブが Quantinuum targetsで現在サポートされていることに注意してください。

統合ハイブリッドジョブのコストの見積もり

最初にエミュレーターで実行することで、Quantinuum ハードウェアで統合ハイブリッドジョブを実行するコストを見積もることができます。

エミュレーターで正常に実行された後:

Azure Quantum ワークスペースで、[ ジョブ管理] を選択します。
送信したジョブを選択します。
[ ジョブの詳細 ] ポップアップで、[ コスト見積もり ] を選択して、使用された eHQC (Quantinuum エミュレータークレジット) の数を表示します。この数は、Quantinuum ハードウェアでジョブを実行するために必要な HQC (Quantinuum 量子クレジット) の数に直接変換されます。

Cost estimation (コスト見積もり)

注意

Quantinuum は回線全体の登録を解除し、条件付きで実行されているかどうかに関係なく、すべてのコードパスのコストを計算します。

統合ハイブリッドサンプル

次のサンプルは、統合ハイブリッドコンピューティングの現在の機能セットを示しています。

絡み合った GHZ 状態を確認する
3 量子ビットの繰り返し
反復的な位相推定

前提条件

Azure Quantum を初めて使用する場合は、量子ハードウェアに対してサンプルを実行するための Azure サブスクリプションと Azure Quantum ワークスペースが必要です。詳細については、「Azure Quantum ワークスペースを作成する」を参照してください。
VS Code とローカル Quantum Development Kit 環境での設定。詳細については、「を設定する Quantum Development Kit」を参照してください。
VS Code に最新バージョンの Quantum Development Kit (0.27.258160) があることを確認します。
- VS Code で Ctrl + Shift + X を 選択し、"Microsoft Quantum Development Kit" を検索します。

この記事のサンプルは、Visual Studio (VS) コードで実行するように設定されており、組み込みの Azure コマンドラインインターフェイス (CLI) を使用してジョブを Azure Quantum に送信します。これらのサンプルとその他のサンプルのJupyter Notebookバージョンを実行するには、Azure portal ワークスペースにログインし、サンプルギャラリーの [ハイブリッド量子コンピューティング] タブからサンプルを表示します。クラウドでノートブックを実行するか、ダウンロードしてローカルで実行できます。

統合ハイブリッドプログラムに関する問題のトラブルシューティングについては、「統合ハイブリッドのトラブルシューティング」を参照してください。

このサンプルでは、量子コンピューティングバックエンドによって完全に処理された、同じプログラムで従来の命令と量子命令をブレンドする方法について説明します。

このサンプルに関する注意すべき機能:

ループと量子ビットの測定は、量子ビットが一貫している間に発生します。
このルーチンは、従来のコンピューティング操作と量子コンピューティング操作を組み合わせたものです。
QPU (FPGA など) の横で実行されている特殊なハイパフォーマンスハードウェアのプログラミングを学習する必要はありません。
ハイブリッド機能を統合せずに同等のプログラムを実行するには、すべての中間測定結果を返し、データに対して後処理を実行する必要があります。

VS Code プロジェクトを作成する

VS Code で、CheckGHZ という名前の新しいQ#スタンドアロンコンソールアプリケーションプロジェクトを作成します。
1. [コマンドパレット>Q#の表示>] を選択します。新しいプロジェクト>の作成スタンドアロンコンソールアプリケーション

CheckGHZ.csproj の構成を次のように置き換えます。

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

Program.qs のコードを次のように置き換えます。

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

VS Code のターミナルウィンドウから Azure Quantum ワークスペースに接続し、既定のリソースを設定します。
```
az login
```
注意

az quantum workspace list を実行して、ログイン後にターミナルウィンドウに Azure サブスクリプション ID、リソースグループ、ワークスペース名を一覧表示できます。または、Azure Quantum ワークスペースの [概要] ページのAzure portalで確認することもできます。
```
az account set --subscription <MySubscriptionID>

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

ジョブを送信し、結果を表示します。この実行では、約 10.65 eHQC (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]

GHZ 出力

このサンプルでは、ビットフリップエラーの検出と修正に使用できる 3 量子ビット繰り返しコードを作成する方法を示します。

統合ハイブリッドコンピューティング機能を利用して、論理量子ビットレジスタの状態が一貫性がある間にエラー修正が実行された回数をカウントします。

VS Code プロジェクトを作成する

VS Code で、ThreeQubit という名前の新しいQ#スタンドアロンコンソールアプリケーションプロジェクトを作成します。
1. [コマンドパレットの>Q#表示>: 新しいプロジェクト>の作成] スタンドアロンコンソールアプリケーションの選択

ThreeQubit.csproj の構成を次のように置き換えます。

<Project Sdk="Microsoft.Quantum.Sdk/0.27.258160">

  <PropertyGroup>
    <OutputType>Exe</OutputType>
    <TargetFramework>net6.0</TargetFramework>
    <ExecutionTarget>quantinuum</ExecutionTarget>
    <TargetCapability>AdaptiveExecution</TargetCapability>
  </PropertyGroup>

</Project>

Program.qs のコードを次のように置き換えます。

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

VS Code のターミナルウィンドウから、Azure Quantum ワークスペースに接続し、既定のリソースを設定します。
```
az login
```
注意

az quantum workspace list を実行して、ログイン後にターミナルウィンドウに Azure サブスクリプション ID、リソースグループ、ワークスペース名を一覧表示できます。または、Azure Quantum ワークスペースの [概要] ページのAzure portalで確認することもできます。
```
az account set --subscription <MySubscriptionID>

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

ジョブを送信し、結果を表示します。この実行では、約 11.31 eHQC (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]

このサンプルコードは、オーストラリアの KPMG Quantum チームのメンバーによって作成され、MIT ライセンスに該当します。これは、境界ループ、実行時の従来の関数呼び出し、入れ子になった条件 if ステートメント、中間回路測定、量子ビット再利用の拡張機能 Basic Measurement Feedbacktargets を示し、利用することを目的としています。

3 量子ビットでの反復位相推定を使用した 2 次元内部積計算

このサンプルプログラムでは、内 Q#の反復位相推定を示します。反復位相推定を使用して、量子ビットと補助量子ビットで target エンコードされた 2 つの 2 次元ベクトル間の内部積を計算します。追加の制御量子ビットも初期化されます。これは、測定に使用される唯一の量子ビットになります。

回路は、量子ビットと補助量子ビット上 target のベクトルのペアをエンコードすることによって始まります。次に、Oracle 演算子をレジスタ全体に適用し、$\ket +$ 状態で設定される制御量子ビットを制御します。制御された Oracle 演算子は、制御量子ビットの $\ket 1$ 状態でフェーズを生成します。これを読み取るために、制御量子ビットに H ゲートを適用して、測定時に位相を観測できるようにします。

VS Code プロジェクトを作成する

VS Code で、IPE という名前の新しいQ#スタンドアロンコンソールアプリケーションプロジェクトを作成します。
1. [コマンドパレットの>Q#表示>: 新しいプロジェクト>の作成] スタンドアロンコンソールアプリケーションの選択

IPE.csproj の構成を次のように置き換えます。

<Project Sdk="Microsoft.Quantum.Sdk/0.27.253010">

  <PropertyGroup>
    <OutputType>Exe</OutputType>
    <TargetFramework>net6.0</TargetFramework>
    <ExecutionTarget>quantinuum.sim.h1-1e</ExecutionTarget>
  </PropertyGroup>

</Project>

Program.qs のコードを次のように置き換えます。

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


}

エンコードベクター

ベクトル v と c は、量子ビットと ancilla 量子ビットに target エンコードされます。ベクター $v = (cos(\frac{\theta_1}{2}),sin(\frac{\theta_1}{2}))$ は量子状態 $\ket v = cos(\frac{\theta_1}{2})\ket 0 + sin(\frac{\theta_1}{2})\ket 1$, 同様に、$c$ は $\theta_2$ を使用して構築できます。

$\ket 0$ 状態の量子ビットに適用される target Y 回転:

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

注意

ここで、2 の係数が θ に存在します。 $\ket 0$ 上の$RY(2\pi)$ ゲートのアプリケーションは、状態 $-\ket 0$ を与え、ベクター $(-1,0)$ をエンコードします。このフェーズはグローバルフェーズとは見なできず、レジスタ全体が絡み合うので削除されます。

量子ビットと補助量子ビットの target レジスタは次のようになります。

$$\ket \Psi = \ket {\Psi_\text{Target qubit}}\ket {\Psi_\text{Ancilla qubit}}$$

作成する状態は量子ビット上 target にあり、補助量子ビットは

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

また、フォームを受け取ります

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

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

oracle G は、量子ビットと補助量子ビットでエンコードされた状態で固有位相を target 生成するように構築する必要があります。このオラクルの構築は、この例のデモでは重要ではありませんが、適用される操作は次のようになります。

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

ここで、内部積 $\braket {v|c}$ はフェーズ $\phi$ 内に含まれており、これは [0,1] の間にバインドされています。その状態 $\ket{\Psi_\text{Control Qubit}} = \ket +$ で始まる制御量子ビットに対して制御が適用された場合

$$\begin{aligned} \text{Control }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{aligned}$$

制御量子ビットに、内部積 $\braket {v|c}$ に関連するフェーズが含まれるようになりました

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

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

反復

次に、回路の反復部分について。 n 個の測定値の場合、位相はバイナリ値 $\phi$ として表すことができます。また、$2^n$ オラクルを適用すると、位相の n 番目の二項点が観測可能になります (単純な二項乗算と剰余 $2\pi$ を使用)。制御量子ビットの値は読み取り可能で、次のイテレーションで使用するために従来のレジスタと量子ビットリセットに配置できます。次のイテレーションでは、$2^{n-1}$ oracle が適用され、n 番目の測定値に依存する制御量子ビットのフェーズが修正されます。制御量子ビットの状態は、

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

ここで、$\phi = 0.\phi_0\phi_1\phi_2\phi_3$...

$2^n$ 制御されたオラクルを適用すると、制御量子ビットの状態が与えられます

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

フェーズに $\phi_n$ より深い用語がないことを考慮してください (つまり、用語 $\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 $$

これで、値 $\phi_n$ は、H ゲートと Z 軸に沿って投影された測定で観察できます。制御量子ビットをリセットし、oracle $2^{n-1}$ 回を適用する

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

$\phi_n$ の前の測定値を使用すると、追加のバイナリポイントを回転させることができます

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

このプロセスは、ビット精度 n を繰り返し適用して、フェーズ $0.\phi_0\phi_1\phi_2...\phi_{n}$ を取得します。現在、実行時に操作できるのは整数のみであるため、値はバイナリ値として格納$x = \phi_0\phi_1\phi_2...\phi_{n}$ です。

読み取りではどちらのベクトルも何も示されず、それらの間の内部積のみが伝わるので、量子ビットとアンシラ量子ビットのtarget状態はプロセス全体で同じ状態のままです。

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

内部積を計算する

最後に、測定値から内部積を計算します

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

ここで、$x = \phi_0\phi_1\phi_2...\phi_{n}$ です。コサイン関数内の分母は、元の値 $\phi$ に一致するようにバイナリポイントをシフトすることです。

注意

-1 または 1 ではない内部積の場合、解は $2^{n-1}$ の値差とペアになっています。たとえば、n=3 の測定値の場合、測定されたビット値 2 のペアソリューションも 6 になります。これらの値のいずれかが、偶数関数コサインへの変数として入力されると、内部積の同じ値を生成します (この例では内部積が 0 になります)。

離散ビット精度間の内部積解の場合、離散ビット値の間の内部積の位置に基づいて結果の分布が生成されます。

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

プログラムの実行

これで、プログラムをテストできます。まず、シミュレーション操作を使用してプログラムをローカルで実行し、次に Azure Quantum に接続してハードウェア targetに対して実行します。

反復位相推定のシミュレーション

Q# プログラムでは、を @EntryPoint() 使用して、プログラムの実行を開始する場所をコンパイラに指示する必要があります。次のコードを Programs.qs に追加して、操作でプログラムを SimulateInnerProduct() 開始します。このバージョンの内部製品操作では、出力がターミナルに表示される double の操作など、追加情報が出力されます。

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

プログラムを実行するには、VS Code でターミナルウィンドウを開き、

    dotnet run

Azure Quantum での実行 target

ハードウェアtargetに対してを実行するには、操作を次HardwareInnerProduct()のSimulateInnerProduct()操作に置き換えます。

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

次に、Azure Quantum ワークスペースに接続し、既定のリソースを設定します。

az login

注意

az quantum workspace list を実行して、ログイン後にターミナルウィンドウに Azure サブスクリプション ID、リソースグループ、ワークスペース名を一覧表示できます。または、Azure Quantum ワークスペースの [概要] ページのAzure portalで確認することもできます。

az account set --subscription <MySubscriptionID>

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

次のパラメーターを使用してジョブを送信します。

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

注意

指定した target には、を target サポートする実行プロファイルが必要です Basic Measurement Feedback。

重要

eHQC が大幅に増加する可能性があるため、Azure targets で実行する場合は、のMeasurements値を 3 より大きくすることはお勧めしません。

を使用してジョブの状態を表示できます。

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

[job-id] を表示されたジョブ ID に置き換えます。結果は、母集団が多数を持つ状態の解を示しています。整数の結果からの最終的な内部積は、$\braket {v|c} = -cos(2\pi x / 2^n)$ で計算できます。ここで、n はジョブで指定された測定値の数です。

注意

1 つのソリューション状態 (-1 または 1 の内部積) のみを持つ入力パラメーターを選択することは、ショットの数が少ない場合の可視性に最適です。

次の手順

分散ハイブリッドコンピューティング

Share via

統合ハイブリッドコンピューティング

targets をサポートするようになりました

Quantinuum

作業の開始

統合ハイブリッドジョブの送信

私Q#

Python + Q#

Azure CLI

セッション内での統合ハイブリッドジョブの送信

統合ハイブリッドジョブのコストの見積もり

統合ハイブリッドサンプル

前提条件

VS Code プロジェクトを作成する

VS Code プロジェクトを作成する

3 量子ビットでの反復位相推定を使用した 2 次元内部積計算

VS Code プロジェクトを作成する

エンコードベクター

The Oracle

反復

内部積を計算する

プログラムの実行

反復位相推定のシミュレーション

Azure Quantum での実行 target

次の手順

フィードバック

フィードバック

その他のリソース

Share via

統合ハイブリッド コンピューティング

targets をサポートするようになりました

Quantinuum

作業の開始

統合ハイブリッド ジョブの送信

私Q#

Python + Q#

Azure CLI

セッション内での統合ハイブリッド ジョブの送信

統合ハイブリッド ジョブのコストの見積もり

統合ハイブリッド サンプル

前提条件

VS Code プロジェクトを作成する

次の手順

フィードバック

フィードバック

その他のリソース

統合ハイブリッドコンピューティング

統合ハイブリッドジョブの送信

セッション内での統合ハイブリッドジョブの送信

統合ハイブリッドジョブのコストの見積もり

統合ハイブリッドサンプル