你当前正在访问 Microsoft Azure Global Edition 技术文档网站。如果需要访问由世纪互联运营的 Microsoft Azure 中国技术文档网站，请访问 https://docs.azure.cn。

集成混合计算

项目
01/13/2024

集成混合计算将经典和量子过程结合在一起，允许经典代码在物理量子比特保持活动状态的同时，根据中间线路测量来控制量子运算的执行。使用常见的编程技术（如嵌套条件、循环和函数调用），单个量子程序可以运行复杂的问题，从而减少所需的拍摄次数。使用量子比特重用技术，较大的程序可以在使用较少量子比特的计算机上运行。

重要

Visual Studio Code的现代 Quantum Development Kit (新式 QDK) 扩展以及本页示例中的其他组件（如 IQ# 内核、%azuremagic 命令或qsharp.azure模块）目前不支持集成混合量子计算。若要运行集成的混合作业，请使用 Microsoft Quantum Development Kit (经典 QDK) 。有关详细信息，请参阅继续在经典 QDK 中工作。

有关更多讨论，请参阅：

集成混合量子计算

已支持 targets

目前， Quantinuumtargets 支持 Azure Quantum 中的集成混合计算模型。

Quantinuum

支持的功能	备注
经典循环	仅限有界循环
任意控制流	使用 if/else 分支
中间线路测量	利用经典寄存器资源
量子位重用	不可用
实时经典计算	32 位无符号整数算术利用经典寄存器资源

入门

若要开始探索集成的混合编程，建议浏览本文中的示例，或浏览 Azure Quantum 门户的示例库中的 “混合量子计算 ”选项卡。

提交集成的混合作业

提交集成混合作业时，需要在指定 target后添加target功能参数。除此之外，Azure Quantum 上的集成混合程序与常规量子作业一样运行和管理。每个作业都有一个作业 ID，结果为单个直方图。

重要

我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 提交作业时，请添加 --target-capability 值为 AdaptiveExecution的参数。

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

在会话中提交集成的混合作业

可以使用和 Python 在会话Q#中合并多个集成的混合作业。提交会话时，添加 targetCapability 值为 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

有关详细信息，请参阅会话入门。

注意

尽管会话适用于所有量子计算硬件提供程序，但请注意，Quantinuum targets上当前支持集成的混合量子计算作业。

估算集成混合作业的成本

可以通过先在模拟器上运行 Quantinuum 硬件来估算在 Quantinuum 硬件上运行集成混合作业的成本。

在模拟器上成功运行后：

在 Azure Quantum 工作区中，选择“ 作业管理”。
选择提交的作业。
在“ 作业详细信息 ”弹出窗口中，选择“ 成本估算 ”以查看使用了多少 eHQC (Quantinuum 仿真器信用) 。此数字直接转换为在 Quantinuum 硬件上运行作业所需的 HQC 数 (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 订阅 ID、资源组和工作区名称。或者，可以在 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 订阅 ID、资源组和工作区名称。或者，可以在 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]

此示例代码由位于澳大利亚的毕马威量子团队成员编写，属于 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 (\表示 frac{\theta_1}{2}) \ket 0 + sin (\frac{\theta_1}{2}) \ket 1$，同样可以使用 $\theta_2$ 构造$c$。

应用于 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$$

注意

在 theta 上存在 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 生成特征相。此 oracle 的构造对于此示例中的演示并不重要，但它所应用的操作是

$$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{Controled }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$ 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 的术语 $\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;
}

计算内部积

最后，根据测量值计算内部积

$$\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 的对解。当输入为偶数函数余弦 (的变量时，上述任一值都生成相同的内部积值) 。

对于离散位精度之间的内部积解决方案，将根据内部积在离散位值之间的位置生成结果分布。

将以下操作添加到 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 订阅 ID、资源组和工作区名称。或者，可以在 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 需要支持 targetBasic Measurement Feedback的执行配置文件。

重要

在 Azure targets 上运行时，不建议将值Measurements增大到 3 以上，因为 eHQC 可能会显著增加。

可以使用查看作业的状态

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) 的输入参数非常适合使用少量镜头时的可见性。

后续步骤

分布式混合计算

Share via

集成混合计算

已支持 targets

Quantinuum

入门

提交集成的混合作业

我Q#

Python + Q#

Azure CLI

在会话中提交集成的混合作业

估算集成混合作业的成本

集成混合示例

先决条件

创建 VS Code 项目

创建 VS Code 项目

对三个量子比特使用迭代相位估计进行二维内部积计算

创建 VS Code 项目

编码向量

The Oracle

迭代

计算内部积

运行程序

模拟迭代相位估计

在 Azure Quantum 上运行 target

后续步骤

反馈

反馈

其他资源