Quantinuum 供应商

在 Q# 中， MResetZ 函数可用于测量量子比特并重置它。 有关此函数的详细信息，请参阅 MResetZ Q# 文档中的信息。

%%qsharp
import Std.Measurement.*;

operation ContinueComputationAfterReset() : Result[] {
    // Set up circuit with 2 qubits
    use qubits = Qubit[2];

    // Perform Bell Test
    H(qubits[0]);
    CNOT(qubits[0], qubits[1]);

    // Measure Qubit 1 and reset it
    let res1 = MResetZ(qubits[1]);

    // Continue additional computation, conditioned on qubits[1] measurement outcome
    if res1 == One {
         X(qubits[0]);
    }
    CNOT(qubits[0], qubits[1]);

    // Measure qubits and return results
    let res2 = Measure([PauliZ, PauliZ], qubits);
    return [res1, res2];
}

在 Qiskit 中，量子比特进行显式测量和重置。 可以使用在门之后的 c_if 函数指定条件操作。

from qiskit import QuantumRegister, ClassicalRegister, QuantumCircuit

# Set up quantum circuit
q = QuantumRegister(2)
c = ClassicalRegister(2)
circuit = QuantumCircuit(q, c)
circuit.name = "MCMR Example with Conditional Logic"

# Perform Bell Test
circuit.h(q[0])
circuit.cx(q[0], q[1])

# Measure and reset Qubit 1
circuit.measure(q[1], c[1])
circuit.reset(q[1])

# Continue additional computation, conditioned on Qubit 1's measurement outcome
circuit.x(q[0]).c_if(c, 1)
circuit.cx(q[0], q[1])

# Measure all qubits
circuit.measure(q, c)

# Print out the circuit
circuit.draw()

在 Q# 中，任意角度 ZZ 门通过 Rzz 操作实现。

%%qsharp
import Std.Intrinsic.*;
import Std.Measurement.*;
import Std.Arrays.*;

operation ArbitraryAngleZZExample(theta : Double) : Result[] {
    
    // Set up circuit with 2 qubits
    use qubits = Qubit[2];

    // Create array for measurement results
    mutable resultArray = [Zero, size = 2];

    H(qubits[0]);
    Rz(theta, qubits[0]);
    Rz(theta, qubits[1]);
    X(qubits[1]);

    // Add Arbitrary Angle ZZ gate
    Rzz(theta, qubits[0], qubits[1]);  

    // Measure qubits and return results
    for i in IndexRange(qubits) {
        resultArray w/= i <- M(qubits[i]);  
    }
    
    return resultArray;
}

在 Qiskit 中，任意角度 ZZ 门是通过 rzz 方法实现的。

from qiskit import QuantumCircuit

theta = 0.25

# Set up quantum circuit
circuit = QuantumCircuit(2, 2)
circuit.name = "Arbitrary Angle ZZ Gate Example"

circuit.h(0)
circuit.rz(theta, 0)
circuit.rz(theta, 1)
circuit.x(1)

# Add arbitrary angle ZZ gate
circuit.rzz(theta, 0, 1)

circuit.measure_all()

在 Q# 中，通用 SU(4) 纠缠门通过 Quantinuum 的 QIR 配置文件实现。 要使用此功能，请定义一个与 QIR 配置文件签名匹配的自定义内部函数，并在 SU4Example 操作中使用该函数。

若要确保电路使用 General SU(4) Entangling 运行，请在 Quantinuum Stack 中传递以下选项：

• nativetq: Rxxyyzz 以防止重置到其他本地门。
• noreduce: True 以避免其他编译器优化（可选）。

%%qsharp
import Std.Math.*;

operation __quantum__qis__rxxyyzz__body(a1 : Double, a2 : Double, a3 : Double, q1 : Qubit, q2 : Qubit) : Unit {
    body intrinsic;
}

operation SU4Example() : Result[] {
    use qs = Qubit[2];
    
    // Add SU(4) gate
    __quantum__qis__rxxyyzz__body(PI(), PI(), PI(), qs[0], qs[1]);
    
    MResetEachZ(qs)
}

现在编译该操作：

MyProgram = qsharp.compile("GenerateRandomBit()")

连接到 Azure Quantum，选择 target 计算机，并为模拟器配置噪音参数：

MyWorkspace = azure.quantum.Workspace(
    resource_id = "",
    location = ""
)

MyTarget = MyWorkspace.get_targets("quantinuum.sim.h2-1e")

# Update TKET optimization level desired
option_params = {
    "nativetq": `Rxxyyzz`,
    "noreduce": True
}

提交作业时传递 noreduce 选项：

job = MyTarget.submit(MyProgram, "Submit a program with SU(4) gate", shots = 10, input_params = option_params)
job.get_results()

首先，导入所需的包并初始化基本配置文件。

from qdk import qsharp, azure

qsharp.init(target_profile=qsharp.TargetProfile.Base)

接下来，定义函数。

%%qsharp
import Std.Measurement.*;
import Std.Arrays.*;
import Std.Convert.*;

operation GenerateRandomBit() : Result {
    use target = Qubit();

    // Apply an H-gate and measure.
    H(target);
    return M(target);
}

并编译操作：

MyProgram = qsharp.compile("GenerateRandomBit()")

连接到 Azure Quantum，选择 target 计算机，并为模拟器配置噪音参数：

MyWorkspace = azure.Workspace(
    resource_id = "",
    location = ""
)

MyTarget = MyWorkspace.get_targets("quantinuum.sim.h2-1e")

# Update the parameter names desired
# Note: This is not the full set of options available. 
# For the full set, see the Quantinuum Emulators page
option_params = {
    "error-params": {
        "p1": 4e-5,
        "p2": 3e-3,
        "p_meas": [3e-3, 3e-3],
        "p_init": 4e-5,
        "p_crosstalk_meas": 1e-5,
        "p_crosstalk_init": 3e-5,
        "p1_emission_ratio": 6e-6,
        "p2_emission_ratio": 2e-4
    }
}

提交作业时传递仿真器噪声选项：

job = MyTarget.submit(MyProgram, "Experiment with Emulator Noise Parameters", 
                      shots = 10, 
                      input_params = option_params)
job.get_results()

若要关闭仿真器噪音模型，请将 error-model 选项设置为 False。 默认情况下，这设置为 True。

option_params = {
    "error-model": False 
}

若要使用稳定器模拟器，请将 simulator 选项设置为 stabilizer。 默认情况下，这设置为 state-vector。

option_params = {
    "simulator": "stabilizer" 
}

# Specify the emulator backend target to submit to
backend = provider.get_backend("quantinuum.sim.h2-1e")

# Update the parameter names desired
# Note: This is not the full set of options available. 
# For the full set, see the Quantinuum Emulator page
option_params = {
    "error-params": {
        "p1": 4e-5,
        "p2": 3e-3,
        "p_meas": [3e-3, 3e-3],
        "p_init": 4e-5,
        "p_crosstalk_meas": 1e-5,
        "p_crosstalk_init": 3e-5,
        "p1_emission_ratio": 6e-6,
        "p2_emission_ratio": 2e-4
    }
}
backend.options.update_options(**option_params)

# Submit the job
job = backend.run(circuit, shots=100)
print("Job id:", job.id())

若要关闭仿真器噪音模型，请将 error-model 选项设置为 False。 默认情况下，这设置为 True。

option_params = {
    "error-model": False 
}

若要使用稳定器模拟器，请将 simulator 选项设置为 stabilizer。 默认情况下，这设置为 state-vector。

option_params = {
    "simulator": "stabilizer" 
}

首先，导入所需的包并初始化基本配置文件。

from qdk import qsharp
import azure.quantum
qsharp.init(target_profile=qsharp.TargetProfile.Base)

接下来，定义函数。

%%qsharp
import Std.Measurement.*;
import Std.Arrays.*;
import Std.Convert.*;

operation GenerateRandomBit() : Result {
    use target = Qubit();

    // Apply an H-gate and measure.
    H(target);
    return M(target);
}

并编译操作：

MyProgram = qsharp.compile("GenerateRandomBit()")

连接到 Azure Quantum，选择 target 计算机，并为模拟器配置噪音参数：

MyWorkspace = azure.quantum.Workspace(
    resource_id = "",
    location = ""
)

MyTarget = MyWorkspace.get_targets("quantinuum.sim.h2-1e")

# Update TKET optimization level desired
option_params = {
    "tket-opt-level": 1
}

提交作业时输入优化参数：

job = MyTarget.submit(MyProgram, "Experiment with TKET Compilation", shots = 10, input_params = option_params)
job.get_results()

# Specify the backend target to submit to
backend = provider.get_backend("quantinuum.sim.h2-1e")

# Update TKET optimization level desired
option_params = {
    "tket-opt-level": 1
}
backend.options.update_options(**option_params)

# Submit the job
job = backend.run(circuit, shots=100)
print("Job id:", job.id())