整合式混合式運算

發行項
03/14/2024

整合式混合式運算會將傳統和量子程式結合在一起，讓傳統程式代碼能夠根據中間電路測量來控制量子作業的執行，同時實體量子位仍保持運作。使用常見的程式設計技術，例如巢狀條件、迴圈和函數調用，單一量子程式可以執行複雜的問題，以減少所需的快照數目。使用量子位重複使用技術，較大的程式可以在使用較少量子位的計算機上執行。

重要

Visual Studio Code 的新式 (新Quantum Development Kit式 QDK) 擴充功能目前不支援整合式混合式量子運算，以及此頁面範例中的其他元件，例如 IQ# 核心、%azuremagic 命令或qsharp.azure模組。若要執行整合式混合式作業，請使用 Microsoft Quantum Development Kit (傳統 QDK) 。如需詳細資訊，請參閱繼續在傳統 QDK 中工作。

如需更多討論，請參閱：

整合式混合式量子運算

已支援 targets

Azure Quantum 中的整合式混合式運算模型目前支援 Quantinuumtargets。

Quantinuum

支援的功能	備註
傳統迴圈	僅限系結迴圈
任意控制流程	使用 if/else 分支
中間電路測量	利用傳統快取器資源
量子位重複使用	N/A
即時傳統計算	32 位無符號整數算術利用傳統快取器資源

開始使用

若要開始探索整合式混合式程序設計，建議您逐步流覽本文中的範例，或探索 Azure Quantum 入口網站範例庫中的 混合式量子運算 索引卷標。

提交整合式混合式作業

提交整合式混合式作業時，您必須在指定 target之後新增target功能參數。除此之外，Azure Quantum 上的整合式混合式程式會執行和管理，就像一般量子作業一樣。每個作業都有單一作業標識符，結果為單一直方圖。

重要

我Q#

在 Jupyter Notebook 中使用 IQ# 核心時，請使用 %azure。target-capability magic 命令搭配 AdaptiveExecution 參數。

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

Python + Q#

使用 qsharp Python 套件時，請搭配 AdaptiveExecution 參數使用 qsharp.azure.target_capability 函式。

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 量子點數 (Quantinuum 量子點數) ，這些數量需要在 Quantinuum 硬體上執行作業。

成本估計

注意

Quantinuum 會取消註冊整個線路，並計算所有程式代碼路徑的成本，不論這些路徑是否有條件地執行。

整合式混合式範例

下列範例示範整合式混合式運算的目前功能集。

確認糾纏 GHZ 狀態
三量子位重複
迭代相位估算法

必要條件

如果您不熟悉 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) Code 上執行，並使用內建的 Azure 命令行介面 (CLI) 將作業提交至 Azure Quantum。若要執行這些和其他範例的 Jupyter Notebook 版本，請登入您的 Azure 入口網站工作區，並從範例資源庫中的 [混合式量子運算] 索引卷標檢視範例。您可以在雲端中執行筆記本，或下載筆記本並在本機執行。

若要針對整合式混合式程序的問題進行疑難解答，請參閱針對整合式混合式進行疑難解答。

在此範例中，您將探索如何在相同程式中混合傳統和量子指令，這些指令全都由量子運算後端完整處理。

要注意此範例的功能：

當量子位維持一致時，就會發生迴圈和量子位測量。
例程會混合傳統和量子計算作業。
您不需要瞭解如何針對 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 訂用帳戶標識碼、資源群組和工作區名稱。或者，您可以在 Azure Quantum 工作區的 [概觀] 頁面上的 [Azure 入口網站中找到它們。
```
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 訂用帳戶標識碼、資源群組和工作區名稱。或者，您可以在 Azure Quantum 工作區的 [概觀] 頁面上的 [Azure 入口網站中找到它們。
```
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 授權。其目標是示範擴充的功能 Basic Measurement Feedbacktargets ，並利用限定迴圈、運行時間的傳統函式呼叫、巢狀條件式 if 語句、中間電路測量和量子位重複使用。

三個量子位上使用反覆階段估計的二維內部產品計算

此範例程式示範內的 Q#反覆階段估計。它會使用反覆階段估計來計算在量子位和輔助量子位上 target 編碼的兩維向量之間的內部乘積。也會初始化額外的控制量子位，這是用於測量的唯一量子位。

線路的開頭是編碼量子位和輔助量子位上的 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 會編碼至 target 量子位和輔助量子位。向量 $v = (cos (\frac{\theta_1}{2}) ，sin (\frac{\theta_1}{2}) ) $ 可以透過量子狀態 $\ket v = cos (\cos 來表示 frac{\theta_1}) \ket 0 + sin (\frac{\theta_1}{2}{2}) \ket 1$，同樣地$c$ 可以使用 $\theta_2$ 來建構。

套用至 target $\ket 0$ 狀態之量子位的 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+\frac{1}{2} (\ket{0}{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 編碼的狀態上產生 eigenphase。此 Oracle 的建構對此範例中的示範並不重要，但套用的作業為

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

其中內部產品 $\存盤 {v|c}$ 包含在介於 [0,1] 之間的階段 $\phi$ 內。在控件量子位上套用控制時，從該狀態 $\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{aligned}$$

現在，控制量子位包含與內部產品 $\columnt {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$ Oracle 會透過簡單的二進位乘法，讓階段的第 n 個二進位點成為可觀察 (，以及模數 $2\pi$) 。控件量子位的值可以是讀取、放在傳統緩存器中，以及用於下一個反覆專案的量子位重設。下一個反覆專案會套用 $2^{n-1}$ oracles，修正相依於第 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$ 個受控制的 Oracle 會提供控制量子位的狀態

$$ 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$ (ie、terms $\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 $$

現在可以使用 H 閘道和 Z 軸上的度量投影來觀察 $\phi_n$ 值。重設控制量子位並套用 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;
}

計算內部產品

最後，從測量值計算內部乘積

$$\) $$ {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 的解決方案。當輸入做為偶數函數餘弦 (的變數輸入時，這兩個值都會產生與內部乘積相同的內部乘積) 。

針對離散位精確度之間的內部產品解決方案，將會根據內部產品位於離散位值之間的位置來產生結果分佈。

將下列作業新增至 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() 作業啟動程式。這個版本的內部產品作業會輸出其他資訊，包括操作終端機中顯示輸出的雙精度浮點數。

@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執行，請將 SimulateInnerProduct() 作業取代為下列 HardwareInnerProduct() 作業：

//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 訂用帳戶標識碼、資源群組和工作區名稱。或者，您可以在 Azure Quantum 工作區的 [概觀] 頁面上的 [Azure 入口網站中找到它們。

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的執行設定檔。

重要

不建議在 Azure targets 上執行時增加超過 3 的值Measurements，因為 eHQC 可以大幅增加。

您可以使用檢視作業的狀態

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

將 [job-id] 取代為顯示的作業標識碼。結果會顯示具有多數母體之狀態的解決方案。整數結果的最後一個內部乘積可由 $\braket {v|c} = -cos (2\pi x / 2^n) $計算，其中 n 是作業中指定的度量數目。

注意

選取只有一個解決方案狀態的輸入參數 (內部產品 -1 或 1 個) 適合使用低數目的螢幕快照時可見度。

下一步

分散式混合式運算

Share via

整合式混合式運算

已支援 targets

Quantinuum

開始使用

提交整合式混合式作業

我Q#

Python + Q#

Azure CLI

提交會話內的整合式混合式作業

估計整合式混合式作業的成本

整合式混合式範例

必要條件

建立 VS Code 專案

建立 VS Code 專案

三個量子位上使用反覆階段估計的二維內部產品計算

建立 VS Code 專案

編碼向量

The Oracle

反覆運算

計算內部產品

執行程式

模擬反覆階段估計

在 Azure Quantum 上執行 target

下一步

意見反應

意見反應

其他資源