Quantinuum 공급자

Q#에서 함수를 MResetZ 사용하여 큐비트를 측정하고 다시 설정할 수 있습니다. 이 함수에 대한 자세한 내용은 Q# 설명서를 참조 MResetZ 하세요.

%%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) Entangling 게이트가 Quantinuum의 QIR 프로필을 통해 구현됩니다. 이를 사용하려면 QIR 프로필 서명과 일치하는 사용자 지정 내장 함수를 정의하고 작업 내에서 이 함수를 SU4Example 사용합니다.

회로가 일반 SU(4) Entangling 게이트와 함께 실행되도록 하려면 Quantinuum 스택에서 다음 옵션을 전달하세요.

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

이제 작업을 컴파일합니다.

from qdk import qsharp

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

Azure Quantum에 연결하고, 머신을 target 선택하고, 에뮬레이터에 대한 노이즈 매개 변수를 구성합니다.

from qdk.azure import Workspace

MyWorkspace = 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
from qdk.azure import Workspace

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 = 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
from qdk.azure import Workspace
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 = 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())