task_id stringlengths 17 19 | prompt stringlengths 122 728 | canonical_solution stringlengths 97 1.53k | test stringlengths 192 1.54k | entry_point stringlengths 3 50 | difficulty_scale stringclasses 3
values |
|---|---|---|---|---|---|
qiskitHumanEval/0 | Generate a Quantum Circuit for the given int 'n_qubits' and return it.
You must implement this using a function named `create_quantum_circuit` with the following arguments: n_qubits. | from qiskit import QuantumCircuit
def create_quantum_circuit(n_qubits):
return QuantumCircuit(n_qubits)
| from qiskit import QuantumCircuit
def check(candidate):
result = candidate(3)
assert isinstance(result, QuantumCircuit)
assert result.num_qubits == 3
check(create_quantum_circuit) | create_quantum_circuit | basic |
qiskitHumanEval/1 | Define a phi plus bell state using Qiskit, transpile the circuit using pass manager with optimization level as 1, run it using Qiskit Sampler with the Aer simulator as backend and return the counts dictionary.
You must implement this using a function named `run_bell_state_simulator` with no arguments. | from qiskit import QuantumCircuit
from qiskit_aer import AerSimulator
from qiskit_ibm_runtime import Sampler
from qiskit.transpiler.preset_passmanagers import generate_preset_pass_manager
def run_bell_state_simulator():
bell = QuantumCircuit(2)
bell.h(0)
bell.cx(0, 1)
bell.measure_all()
backend = A... | from qiskit import QuantumCircuit
from qiskit_aer import AerSimulator
from qiskit_ibm_runtime import Sampler
from qiskit.transpiler.preset_passmanagers import generate_preset_pass_manager
def check(candidate):
result = candidate()
assert isinstance(result, dict)
assert result.keys() == {"00", "11"}
asse... | run_bell_state_simulator | basic |
qiskitHumanEval/2 | Return a phi+ Bell statevector.
You must implement this using a function named `create_bell_statevector` with no arguments. | from qiskit.quantum_info import Statevector
from math import sqrt
def create_bell_statevector():
return (Statevector.from_label("00") + Statevector.from_label("11")) / sqrt(2)
| from qiskit.quantum_info import Statevector
from math import sqrt
def check(candidate):
result = candidate()
solution = (Statevector.from_label("00") + Statevector.from_label("11")) / sqrt(2)
assert result.equiv(solution)
check(create_bell_statevector) | create_bell_statevector | basic |
qiskitHumanEval/3 | Generate a QuantumCircuit for a 3 qubit GHZ State and measure it. If `drawing` is True, return both the circuit object and the Matplotlib drawing of the circuit, otherwise return just the circuit object.
You must implement this using a function named `create_ghz` with the following arguments: drawing. | from qiskit import QuantumCircuit
def create_ghz(drawing=False):
ghz = QuantumCircuit(3)
ghz.h(0)
ghz.cx(0, 1)
ghz.cx(0, 2)
ghz.measure_all()
if drawing:
return ghz, ghz.draw(output="mpl")
return ghz | from qiskit import QuantumCircuit
def check(candidate):
from qiskit.quantum_info import Statevector
import math
import matplotlib
def check_circuit(circuit):
assert circuit.data[-1].operation.name == "measure"
circuit.remove_final_measurements()
ghz_statevector = (
S... | create_ghz | basic |
qiskitHumanEval/4 | Write the function that converts the matrix [[0, 0, 0, 1],[0, 0, 1, 0],[1, 0, 0, 0],[0, 1, 0, 0]] into a unitary gate and apply it to a Quantum Circuit. Then return the circuit.
You must implement this using a function named `create_unitary_from_matrix` with no arguments. | from qiskit import QuantumCircuit
def create_unitary_from_matrix():
matrix = [[0, 0, 0, 1], [0, 0, 1, 0], [1, 0, 0, 0], [0, 1, 0, 0]]
circuit = QuantumCircuit(2)
circuit.unitary(matrix, [0, 1])
return circuit
| from qiskit import QuantumCircuit
def check(candidate):
from qiskit.quantum_info import Operator
matrix = [[0, 0, 0, 1], [0, 0, 1, 0], [1, 0, 0, 0], [0, 1, 0, 0]]
solution = QuantumCircuit(2)
solution.unitary(matrix, [0, 1])
assert Operator(solution).equiv(Operator(candidate()))
check(create_unitar... | create_unitary_from_matrix | basic |
qiskitHumanEval/5 | Return a QuantumCircuit that prepares the binary state 1.
You must implement this using a function named `create_state_prep` with no arguments. | from qiskit import QuantumCircuit
def create_state_prep():
qc = QuantumCircuit(2)
qc.prepare_state("01")
return qc
| from qiskit import QuantumCircuit
def check(candidate):
from qiskit.quantum_info import Statevector
candidate_circuit = candidate()
assert isinstance(candidate_circuit, QuantumCircuit)
candidate_sv = Statevector.from_instruction(candidate())
refrence_sv = Statevector.from_label("1".zfill(candidate_s... | create_state_prep | basic |
qiskitHumanEval/6 | Return a QuantumCircuit that prepares the state |1> on an n-qubit register.
You must implement this using a function named `create_state_prep` with the following arguments: num_qubits. | from qiskit import QuantumCircuit
def create_state_prep(num_qubits):
qc = QuantumCircuit(num_qubits)
qc.prepare_state(1)
return qc
| from qiskit import QuantumCircuit
def check(candidate):
from qiskit.quantum_info import Statevector
candidate_circuit = candidate(num_qubits=5)
assert isinstance(candidate_circuit, QuantumCircuit)
assert candidate_circuit.num_qubits == 5
candidate_sv = Statevector.from_instruction(candidate_circuit... | create_state_prep | basic |
qiskitHumanEval/7 | Generate a 1 qubit QuantumCircuit with a parametrized Rx gate with parameter "theta".
You must implement this using a function named `create_parametrized_gate` with no arguments. | from qiskit.circuit import QuantumCircuit, Parameter
def create_parametrized_gate():
theta = Parameter("theta")
quantum_circuit = QuantumCircuit(1)
quantum_circuit.rx(theta, 0)
return quantum_circuit
| from qiskit.circuit import QuantumCircuit, Parameter
def check(candidate):
circuit = candidate()
assert circuit.num_qubits == 1
assert circuit.data[0].operation.name == "rx"
assert circuit.data[0].operation.params[0].name == "theta"
check(create_parametrized_gate) | create_parametrized_gate | basic |
qiskitHumanEval/8 | Return a 1-qubit QuantumCircuit with a parametrized Rx gate and parameter "theta". If value is not None, return the circuit with value assigned to theta.
You must implement this using a function named `rx_gate` with the following arguments: value. | from qiskit.circuit import QuantumCircuit, Parameter
def rx_gate(value=None):
theta = Parameter("theta")
quantum_circuit = QuantumCircuit(1)
quantum_circuit.rx(theta, 0)
if value is not None:
return quantum_circuit.assign_parameters({theta: value})
return quantum_circuit
| from qiskit.circuit import QuantumCircuit, Parameter
def check(candidate):
from qiskit.quantum_info import Operator
import math
circuit = candidate()
assert circuit.num_qubits == 1
assert circuit.data[0].operation.name == "rx"
assert circuit.data[0].operation.params[0].name == "theta"
cand... | rx_gate | basic |
qiskitHumanEval/9 | Generate an EfficientSU2 circuit with 3 qubits, 1 reps and make insert_barriers true.
You must implement this using a function named `create_efficientSU2` with no arguments. | from qiskit.circuit.library import EfficientSU2
def create_efficientSU2():
circuit = EfficientSU2(num_qubits=3, reps=1, insert_barriers=True)
return circuit
| from qiskit.circuit.library import EfficientSU2
def check(candidate):
result = candidate()
solution = EfficientSU2(num_qubits=3, reps=1, insert_barriers=True)
assert isinstance(solution, EfficientSU2)
assert solution.reps == result.reps
assert solution.num_qubits == result.num_qubits
check(create_e... | create_efficientSU2 | basic |
qiskitHumanEval/10 | Create a Qiskit circuit with the following unitary [[0, 0, 0, 1], [0, 0, 1, 0], [0, 1, 0, 0], [1, 0, 0, 0]], consisting of only single-qubit gates and CX gates, then transpile the circuit using pass manager with optimization level as 1.
You must implement this using a function named `create_operator` with no arguments. | from qiskit.circuit import QuantumCircuit
from qiskit.quantum_info.operators import Operator
from qiskit.transpiler.preset_passmanagers import generate_preset_pass_manager
def create_operator():
XX = Operator([[0, 0, 0, 1], [0, 0, 1, 0], [0, 1, 0, 0], [1, 0, 0, 0]])
circ = QuantumCircuit(2, 2)
circ.append(... | from qiskit.circuit import QuantumCircuit
from qiskit.quantum_info.operators import Operator
from qiskit.transpiler.preset_passmanagers import generate_preset_pass_manager
def check(candidate):
result = candidate()
XX = Operator([[0, 0, 0, 1], [0, 0, 1, 0], [0, 1, 0, 0], [1, 0, 0, 0]])
assert XX.equiv(Opera... | create_operator | basic |
qiskitHumanEval/11 | Return the statevector from a circuit.
You must implement this using a function named `get_statevector` with the following arguments: circuit. | from qiskit import QuantumCircuit
from qiskit.quantum_info import Statevector
def get_statevector(circuit):
sv = Statevector.from_instruction(circuit)
return sv
| from qiskit import QuantumCircuit
from qiskit.quantum_info import Statevector
def check(candidate):
test_circuit = QuantumCircuit(2)
test_circuit.u(0.39702, 0.238798, 0.298374, 0)
test_circuit.cx(0, 1)
result = candidate(test_circuit)
assert isinstance(result, Statevector)
assert Statevector.fr... | get_statevector | basic |
qiskitHumanEval/12 | Get unitary matrix for a phi plus bell circuit and return it.
You must implement this using a function named `get_unitary` with no arguments. | from qiskit import QuantumCircuit
from qiskit.quantum_info import Operator
def get_unitary():
circ = QuantumCircuit(2)
circ.h(0)
circ.cx(0, 1)
return Operator.from_circuit(circ).to_matrix() | from qiskit import QuantumCircuit
from qiskit.quantum_info import Operator
def check(candidate):
result = candidate()
solution = QuantumCircuit(2)
solution.h(0)
solution.cx(0, 1)
assert Operator(solution).equiv(result)
check(get_unitary) | get_unitary | basic |
qiskitHumanEval/13 | Create a quantum circuit that carries out a custom single-qubit rotation gate (U gate) with angles theta, phi and lambda all equal to pi/2.
You must implement this using a function named `custom_rotation_gate` with no arguments. | from qiskit import QuantumCircuit
import numpy as np
def custom_rotation_gate():
circuit = QuantumCircuit(1)
circuit.u(np.pi / 2, np.pi / 2, np.pi / 2, 0)
return circuit
| from qiskit import QuantumCircuit
import numpy as np
def check(candidate):
from qiskit.quantum_info import Operator
result = candidate()
assert isinstance(result, QuantumCircuit)
solution = QuantumCircuit(1)
solution.u(np.pi / 2, np.pi / 2, np.pi / 2, 0)
assert Operator(solution).equiv(Operator... | custom_rotation_gate | basic |
qiskitHumanEval/14 | Run a phi plus Bell circuit using Qiskit Sampler with the Aer simulator as backend for 10 shots and return measurement results for each shots. To do so, transpile the circuit using a pass manager with optimization level as 1.
You must implement this using a function named `bell_each_shot` with no arguments. | from qiskit import QuantumCircuit
from qiskit_aer import AerSimulator
from qiskit_ibm_runtime import Sampler
from qiskit.transpiler.preset_passmanagers import generate_preset_pass_manager
def bell_each_shot():
bell = QuantumCircuit(2)
# Apply gates
bell.h(0)
bell.cx(0, 1)
bell.measure_all()
# ... | from qiskit import QuantumCircuit
from qiskit_aer import AerSimulator
from qiskit_ibm_runtime import Sampler
from qiskit.transpiler.preset_passmanagers import generate_preset_pass_manager
def check(candidate):
result = candidate()
assert isinstance(result, list)
assert len(result) > 0
assert set(result)... | bell_each_shot | basic |
qiskitHumanEval/15 | Transpile a bell circuit using pass manager with optimization level as 1, run it using Qiskit Sampler with the Aer simulator as backend and get the execution counts.
You must implement this using a function named `noisy_bell` with no arguments. | from qiskit_ibm_runtime.fake_provider import FakeBelemV2
from qiskit_ibm_runtime import Sampler
from qiskit_aer import AerSimulator
from qiskit import QuantumCircuit
from qiskit.transpiler.preset_passmanagers import generate_preset_pass_manager
def noisy_bell():
bell = QuantumCircuit(2)
bell.h(0)
bell.cx(0... | from qiskit_ibm_runtime.fake_provider import FakeBelemV2
from qiskit_ibm_runtime import Sampler
from qiskit_aer import AerSimulator
from qiskit import QuantumCircuit
from qiskit.transpiler.preset_passmanagers import generate_preset_pass_manager
def check(candidate):
result = candidate()
assert isinstance(result... | noisy_bell | basic |
qiskitHumanEval/16 | For the given Quantum Circuit, return the transpiled circuit for the Fake Cairo V2 backend using pass manager with optimization level as 1.
You must implement this using a function named `transpile_circuit` with the following arguments: circuit. | from qiskit_ibm_runtime.fake_provider import FakeCairoV2
from qiskit.transpiler import CouplingMap
from qiskit import QuantumCircuit
from qiskit.transpiler.preset_passmanagers import generate_preset_pass_manager
def transpile_circuit(circuit):
backend = FakeCairoV2()
coupling_map = CouplingMap(backend.configur... | from qiskit_ibm_runtime.fake_provider import FakeCairoV2
from qiskit.transpiler import CouplingMap
from qiskit import QuantumCircuit
from qiskit.transpiler.preset_passmanagers import generate_preset_pass_manager
def check(candidate):
backend = FakeCairoV2()
circuit = QuantumCircuit(4, 3)
circuit.cx([0, 1, 2... | transpile_circuit | basic |
qiskitHumanEval/17 | Unroll circuit for the gateset: CX, ID, RZ, SX, X, U.
You must implement this using a function named `unroll_circuit` with the following arguments: circuit. | from qiskit import QuantumCircuit
from qiskit.circuit.library.standard_gates.equivalence_library import StandardEquivalenceLibrary as std_eqlib
from qiskit.transpiler.passes import BasisTranslator
from qiskit.transpiler import PassManager
import numpy as np
def unroll_circuit(circuit):
pass_ = BasisTranslator(std_... | from qiskit import QuantumCircuit
from qiskit.circuit.library.standard_gates.equivalence_library import StandardEquivalenceLibrary as std_eqlib
from qiskit.transpiler.passes import BasisTranslator
from qiskit.transpiler import PassManager
import numpy as np
def check(candidate):
from qiskit.quantum_info import Oper... | unroll_circuit | basic |
qiskitHumanEval/18 | Transpile a 10-qubit GHZ circuit for the Fake Sydney V2 backend using pass manager with no optimization.
You must implement this using a function named `transpile_circuit_noopt` with no arguments. | from qiskit import QuantumCircuit
from qiskit_ibm_runtime.fake_provider import FakeSydneyV2
from qiskit.transpiler.preset_passmanagers import generate_preset_pass_manager
def transpile_circuit_noopt():
backend = FakeSydneyV2()
ghz = QuantumCircuit(10)
ghz.h(0)
ghz.cx(0, range(1, 10))
ghz.measure_al... | from qiskit import QuantumCircuit
from qiskit_ibm_runtime.fake_provider import FakeSydneyV2
from qiskit.transpiler.preset_passmanagers import generate_preset_pass_manager
def check(candidate):
result = candidate()
backend = FakeSydneyV2()
# Optimization level 0 should use trivial qubit mapping
# i.e. ci... | transpile_circuit_noopt | basic |
qiskitHumanEval/19 | Transpile and map an 11-qubit GHZ circuit for the Fake Toronto V2 backend using pass manager with maximum transpiler optimization.
You must implement this using a function named `transpile_circuit_maxopt` with no arguments. | from qiskit import QuantumCircuit
from qiskit_ibm_runtime.fake_provider import FakeTorontoV2
from qiskit.transpiler.preset_passmanagers import generate_preset_pass_manager
def transpile_circuit_maxopt():
backend = FakeTorontoV2()
ghz = QuantumCircuit(11, 11)
ghz.h(0)
ghz.cx(0, range(1, 11))
ghz.bar... | from qiskit import QuantumCircuit
from qiskit_ibm_runtime.fake_provider import FakeTorontoV2
from qiskit.transpiler.preset_passmanagers import generate_preset_pass_manager
def check(candidate):
result = candidate()
result.remove_final_measurements()
backend = FakeTorontoV2()
# Check initial layout is no... | transpile_circuit_maxopt | intermediate |
qiskitHumanEval/20 | Using a pass manager with optimization level as 1, transpile and map a three-qubit GHZ circuit for the Fake Perth backend using custom initial layout: [2,4,6].
You must implement this using a function named `transpile_ghz_customlayout` with no arguments. | from qiskit import QuantumCircuit
from qiskit_ibm_runtime.fake_provider import FakePerth
from qiskit.transpiler.preset_passmanagers import generate_preset_pass_manager
def transpile_ghz_customlayout():
backend = FakePerth()
ghz = QuantumCircuit(3)
ghz.h(0)
ghz.cx(0, [1, 2])
ghz.barrier()
pass_m... | from qiskit import QuantumCircuit
from qiskit_ibm_runtime.fake_provider import FakePerth
from qiskit.transpiler.preset_passmanagers import generate_preset_pass_manager
def check(candidate):
result = candidate()
result.remove_final_measurements()
backend = FakePerth()
assert result.num_qubits == backend.... | transpile_ghz_customlayout | intermediate |
qiskitHumanEval/21 | Using a pass manager with optimization level as 1 and dense layout method, transpile and map a bell circuit for the Fake Oslo backend.
You must implement this using a function named `transpile_circuit_dense` with no arguments. | from qiskit import QuantumCircuit
from qiskit_ibm_runtime.fake_provider import FakeOslo
from qiskit.transpiler.preset_passmanagers import generate_preset_pass_manager
def transpile_circuit_dense():
backend = FakeOslo()
bell = QuantumCircuit(2)
bell.h(0)
bell.cx(0, 1)
pass_manager = generate_preset_... | from qiskit import QuantumCircuit
from qiskit_ibm_runtime.fake_provider import FakeOslo
from qiskit.transpiler.preset_passmanagers import generate_preset_pass_manager
def check(candidate):
result = candidate()
backend = FakeOslo()
assert result.num_qubits == backend.num_qubits
check(transpile_circuit_dense... | transpile_circuit_dense | basic |
qiskitHumanEval/22 | Using a pass manager with optimization level as 1 and as-late-as-possible scheduling method, transpile and map a bell circuit for the Fake Auckland backend. Return the circuit.
You must implement this using a function named `transpile_circuit_alap` with no arguments. | from qiskit import QuantumCircuit
from qiskit_ibm_runtime.fake_provider import FakeAuckland
from qiskit.transpiler.preset_passmanagers import generate_preset_pass_manager
def transpile_circuit_alap():
backend = FakeAuckland()
bell = QuantumCircuit(2)
bell.h(0)
bell.cx(0, 1)
pass_manager = generate_... | from qiskit import QuantumCircuit
from qiskit_ibm_runtime.fake_provider import FakeAuckland
from qiskit.transpiler.preset_passmanagers import generate_preset_pass_manager
def check(candidate):
result = candidate()
backend = FakeAuckland()
assert result.num_qubits == backend.num_qubits
check(transpile_circu... | transpile_circuit_alap | basic |
qiskitHumanEval/23 | Create a constant oracle for use in a Deutsch-Jozsa experiment. The oracle takes two input bits (qubits 0 and 1) and writes to one output bit (qubit 2).
You must implement this using a function named `dj_constant_oracle` with no arguments. | from qiskit import QuantumCircuit
def dj_constant_oracle():
oracle = QuantumCircuit(3)
oracle.x(2)
return oracle
| from qiskit import QuantumCircuit
def check(candidate):
from qiskit.quantum_info import Operator
qc = QuantumCircuit(3)
constant_0_oracle = Operator(qc)
qc.x(2)
constant_1_oracle = Operator(qc)
result = Operator(candidate())
assert result.equiv(constant_0_oracle) or result.equiv(constant_1_... | dj_constant_oracle | basic |
qiskitHumanEval/24 | Given a Deutsch-Jozsa oracle in which the final qubit is the "output" qubit, return True if the oracle is constant or False otherwise.
You must implement this using a function named `dj_algorithm` with the following arguments: oracle. | from qiskit import QuantumCircuit
from qiskit.primitives import StatevectorSampler
from numpy import isclose
def dj_algorithm(oracle):
n = oracle.num_qubits
qc = QuantumCircuit(n, n - 1)
qc.x(n - 1)
qc.h(range(n))
qc.compose(oracle, inplace=True)
qc.h(range(n))
qc.measure(range(n - 1), rang... | from qiskit import QuantumCircuit
from qiskit.primitives import StatevectorSampler
from numpy import isclose
def check(candidate):
balanced = QuantumCircuit(5)
balanced.cx(3, 4)
assert candidate(balanced) == False
constant = QuantumCircuit(9)
constant.x(8)
assert candidate(constant) == True
che... | dj_algorithm | intermediate |
qiskitHumanEval/25 | Transpile a 7-qubit GHZ circuit using LookaheadSwap pass and the input custom coupling map.
You must implement this using a function named `passmanager_Lookahead` with the following arguments: coupling. | from qiskit import QuantumCircuit
from qiskit.transpiler import CouplingMap
from qiskit.transpiler.passes import LookaheadSwap
from qiskit.transpiler.passmanager import PassManager
def passmanager_Lookahead(coupling):
ghz = QuantumCircuit(7)
ghz.h(0)
ghz.cx(0, range(1, 7))
coupling_map = CouplingMap(co... | from qiskit import QuantumCircuit
from qiskit.transpiler import CouplingMap
from qiskit.transpiler.passes import LookaheadSwap
from qiskit.transpiler.passmanager import PassManager
def check(candidate):
from qiskit.quantum_info import Statevector
from qiskit.transpiler.passes import CheckMap
from qiskit.con... | passmanager_Lookahead | intermediate |
qiskitHumanEval/26 | Construct a DAG circuit for a 3-qubit Quantum Circuit with the bell state applied on qubit 0 and 1. Finally return the DAG Circuit object.
You must implement this using a function named `bell_dag` with no arguments. | from qiskit.dagcircuit import DAGCircuit
from qiskit import QuantumRegister, ClassicalRegister, QuantumCircuit
from qiskit.converters import circuit_to_dag
def bell_dag():
q = QuantumRegister(3, 'q')
c = ClassicalRegister(3, 'c')
circ = QuantumCircuit(q, c)
circ.h(q[0])
circ.cx(q[0], q[1])
circ... | from qiskit.dagcircuit import DAGCircuit
from qiskit import QuantumRegister, ClassicalRegister, QuantumCircuit
from qiskit.converters import circuit_to_dag
def check(candidate):
result = candidate()
assert type(result) == DAGCircuit
assert result.num_qubits() == 3
assert result.depth() == 3
assert d... | bell_dag | basic |
qiskitHumanEval/27 | Generate a DAG circuit for 3-qubit Quantum Circuit which consists of H gate on qubit 0 and CX gate on qubit 0 and 1. After converting the circuit to DAG, apply a Hadamard operation to the back of qubit 0 and return the DAGCircuit.
You must implement this using a function named `apply_op_back` with no arguments. | from qiskit.dagcircuit import DAGCircuit
from qiskit.converters import circuit_to_dag
from qiskit.circuit.library import HGate
from qiskit import QuantumRegister, ClassicalRegister, QuantumCircuit
def apply_op_back():
q = QuantumRegister(3, "q")
c = ClassicalRegister(3, "c")
circ = QuantumCircuit(q, c)
... | from qiskit.dagcircuit import DAGCircuit
from qiskit.converters import circuit_to_dag
from qiskit.circuit.library import HGate
from qiskit import QuantumRegister, ClassicalRegister, QuantumCircuit
def check(candidate):
from qiskit.quantum_info import Statevector
from qiskit.converters import dag_to_circuit
... | apply_op_back | intermediate |
qiskitHumanEval/28 | Prepare phi plus and phi minus bell states and visualize their results in a histogram and return the histogram.
You must implement this using a function named `visualize_bell_states` with no arguments. | from matplotlib.figure import Figure
from qiskit import QuantumCircuit
from qiskit_aer import AerSimulator
from qiskit_ibm_runtime import Sampler
from qiskit.visualization import plot_histogram
def visualize_bell_states():
phi_plus = QuantumCircuit(2)
phi_minus = QuantumCircuit(2)
phi_plus.h(0)
phi_plu... | from matplotlib.figure import Figure
from qiskit import QuantumCircuit
from qiskit_aer import AerSimulator
from qiskit_ibm_runtime import Sampler
from qiskit.visualization import plot_histogram
def check(candidate):
from matplotlib.patches import Rectangle
result = candidate()
assert isinstance(result, Figu... | visualize_bell_states | basic |
qiskitHumanEval/29 | Plot a circuit layout visualization for a transpiled bell circuit using a pass manager with optimization level as 1 for the Fake Athens V2 backend.
You must implement this using a function named `plot_circuit_layout_bell` with no arguments. | from matplotlib.figure import Figure
from qiskit.visualization import plot_circuit_layout
from qiskit import QuantumCircuit
from qiskit_ibm_runtime.fake_provider import FakeAthensV2
from qiskit.transpiler.preset_passmanagers import generate_preset_pass_manager
def plot_circuit_layout_bell():
backend = FakeAthensV2... | from matplotlib.figure import Figure
from qiskit.visualization import plot_circuit_layout
from qiskit import QuantumCircuit
from qiskit_ibm_runtime.fake_provider import FakeAthensV2
from qiskit.transpiler.preset_passmanagers import generate_preset_pass_manager
def check(candidate):
result = candidate()
assert t... | plot_circuit_layout_bell | intermediate |
qiskitHumanEval/30 | Plot a city_state for a bell circuit.
You must implement this using a function named `plot_circuit_layout_bell` with no arguments. | from qiskit import QuantumCircuit
from matplotlib.figure import Figure
from qiskit.visualization import plot_state_city
from qiskit.quantum_info import Statevector
def plot_circuit_layout_bell():
bell = QuantumCircuit(2)
bell.h(0)
bell.cx(0,1)
bell_state = Statevector(bell)
plot_state_city(bell_sta... | from qiskit import QuantumCircuit
from matplotlib.figure import Figure
from qiskit.visualization import plot_state_city
from qiskit.quantum_info import Statevector
def check(candidate):
result = candidate()
assert type(result) == Figure
assert len(result.axes) == 2
check(plot_circuit_layout_bell) | plot_circuit_layout_bell | basic |
qiskitHumanEval/31 | Run a Bell circuit on Qiskit Sampler and run the circuit on the Aer simulator with the seed set as 42. Return the resulting counts dictionary.
You must implement this using a function named `sampler_qiskit` with no arguments. | from typing import Dict
from qiskit import QuantumCircuit
from qiskit_aer import AerSimulator
from qiskit_ibm_runtime import Sampler
from qiskit_ibm_runtime.options import SamplerOptions
def sampler_qiskit():
qc = QuantumCircuit(2)
qc.h(0)
qc.cx(0,1)
qc.measure_all()
options = SamplerOptions()
... | from typing import Dict
from qiskit import QuantumCircuit
from qiskit_aer import AerSimulator
from qiskit_ibm_runtime import Sampler
from qiskit_ibm_runtime.options import SamplerOptions
def check(candidate):
result = candidate()
assert result == {"00": 521, "11": 503}
check(sampler_qiskit) | sampler_qiskit | intermediate |
qiskitHumanEval/32 | Run a Bell circuit on Qiskit Estimator and return expectation values for the bases II, XX, YY, ZZ.
You must implement this using a function named `estimator_qiskit` with no arguments. | from numpy import float64
from qiskit import QuantumCircuit
from qiskit_aer import AerSimulator
from qiskit_ibm_runtime import Estimator
from qiskit.quantum_info import SparsePauliOp
def estimator_qiskit():
observable = SparsePauliOp(["II","XX","YY","ZZ"], coeffs=[1, 1, -1, 1])
qc = QuantumCircuit(2)
qc.h(... | from numpy import float64
from qiskit import QuantumCircuit
from qiskit_aer import AerSimulator
from qiskit_ibm_runtime import Estimator
from qiskit.quantum_info import SparsePauliOp
def check(candidate):
result = candidate()
assert result == 4.0
check(estimator_qiskit) | estimator_qiskit | intermediate |
qiskitHumanEval/33 | Generate two random quantum circuits, each with 2 qubits and a depth of 2, using seed values of 0 and 1 respectively. Run the circuits using the Sampler on the Aer simulator with the seed set as 42 and return the counts for both circuits.
You must implement this using a function named `run_multiple_sampler` with no arg... | from typing import List
from qiskit.circuit.random import random_circuit
from qiskit_ibm_runtime import Sampler, SamplerOptions
from qiskit_aer import AerSimulator
def run_multiple_sampler():
circuits = (
random_circuit(2, 2, seed=0, measure=True).decompose(reps=1),
random_circuit(2, 2, seed=1, mea... | from typing import List
from qiskit.circuit.random import random_circuit
from qiskit_ibm_runtime import Sampler, SamplerOptions
from qiskit_aer import AerSimulator
def check(candidate):
result = candidate()
assert isinstance(result, list)
assert result == [{"01": 1024}, {"00": 552, "01": 472}]
check(run_mu... | run_multiple_sampler | intermediate |
qiskitHumanEval/34 | Generate all four Bell states and execute them on the FakeAlgiers backend using SamplerV2 with batch mode. Each Bell state circuit will be transpiled with an optimization level of 3, with the seed 123 for the transpiler.
Returns a dictionary where the keys are the Bell state names ['phi_plus', 'phi_minus', 'psi_plus', ... | from typing import Dict, Optional, Tuple
from qiskit_ibm_runtime import Batch, Sampler
from qiskit.primitives.primitive_job import PrimitiveJob
from qiskit_ibm_runtime.fake_provider import FakeAlgiers
from qiskit.transpiler import CouplingMap
from qiskit import QuantumCircuit
from qiskit.transpiler.preset_passmanagers ... | from typing import Dict, Optional, Tuple
from qiskit_ibm_runtime import Batch, Sampler
from qiskit.primitives.primitive_job import PrimitiveJob
from qiskit_ibm_runtime.fake_provider import FakeAlgiers
from qiskit.transpiler import CouplingMap
from qiskit import QuantumCircuit
from qiskit.transpiler.preset_passmanagers ... | run_jobs_on_batch | difficult |
qiskitHumanEval/35 | Run an EfficientSU2 circuit with 5 qubits, 2 repetitions, and pairwise entanglement on the FakeAuckland backend.
The circuit should be transpiled with an optimization level of 1 and a transpiler seed of 789. Use 1*Z_-1 observable to calculate the expectation value.
You must implement this using a function named `run_ci... | from qiskit.circuit.library import EfficientSU2
from qiskit.quantum_info import SparsePauliOp
from qiskit.transpiler import CouplingMap
import numpy as np
from qiskit_ibm_runtime import QiskitRuntimeService, Estimator, EstimatorOptions
from qiskit.primitives.primitive_job import PrimitiveJob
from qiskit_ibm_runtime.fak... | from qiskit.circuit.library import EfficientSU2
from qiskit.quantum_info import SparsePauliOp
from qiskit.transpiler import CouplingMap
import numpy as np
from qiskit_ibm_runtime import QiskitRuntimeService, Estimator, EstimatorOptions
from qiskit.primitives.primitive_job import PrimitiveJob
from qiskit_ibm_runtime.fak... | run_circuit_with_dd_trex | difficult |
qiskitHumanEval/36 | Write a function to design a Bernstein-Vazirani oracle from a bitstring and return it.
You must implement this using a function named `bv_function` with the following arguments: s. | from qiskit import QuantumCircuit
def bv_function(s):
n = len(s)
qc = QuantumCircuit(n + 1)
for index, bit in enumerate(reversed(s)):
if bit == "1":
qc.cx(index, n)
return qc
| from qiskit import QuantumCircuit
def check(candidate):
from qiskit.quantum_info.operators import Operator
s = "1111"
result = candidate(s)
assert isinstance(result, QuantumCircuit)
assert result.num_qubits == 5
solution = QuantumCircuit(5)
for i in range(4):
solution.cx(i, 4)
as... | bv_function | intermediate |
qiskitHumanEval/37 | Illustrate a Bernstein-Vazirani algorithm routine on Qiskit and run it using Qiskit Sampler with Aer simulator as backend for a string of 0s and 1s. Return the bit strings of the result and the result itself.
You must implement this using a function named `bv_algorithm` with the following arguments: s. | from qiskit import QuantumCircuit
from qiskit_aer import AerSimulator
from qiskit_ibm_runtime import Sampler
from qiskit.primitives.containers.primitive_result import PrimitiveResult
def bv_algorithm(s):
qc = QuantumCircuit(len(s) + 1)
for index, bit in enumerate(reversed(s)):
if bit == "1":
... | from qiskit import QuantumCircuit
from qiskit_aer import AerSimulator
from qiskit_ibm_runtime import Sampler
from qiskit.primitives.containers.primitive_result import PrimitiveResult
def check(candidate):
s = "1111"
result = candidate(s)
assert (type(result[0]) == list)
assert (len(result[0]) == result[... | bv_algorithm | intermediate |
qiskitHumanEval/38 | Build a 2-qubit Quantum Circuit composed by H gate in Quantum register 0, Controlled-RZ gate in quantum register 0 1 with given input theta value, H gate in quantum register 1 and Controlled-RY gate in quantum register 1 0 with given input theta value.
You must implement this using a function named `create_quantum_circ... | from qiskit import QuantumCircuit
def create_quantum_circuit_based_h0_crz01_h1_cry10(theta):
qc = QuantumCircuit(2)
qc.h(0)
qc.crz(theta,0,1)
qc.h(1)
qc.cry(theta,1,0)
return qc
| from qiskit import QuantumCircuit
def check(candidate):
from qiskit import QuantumRegister
from qiskit.circuit import CircuitInstruction
from math import pi
from qiskit.circuit.library import HGate, CRZGate, CRYGate
qr = QuantumRegister(2, name="q")
theta = pi/2
data = candidate(theta).data
... | create_quantum_circuit_based_h0_crz01_h1_cry10 | basic |
qiskitHumanEval/39 | Initialize a uniform superposition on n qubits and return statevector.
You must implement this using a function named `create_uniform_superposition` with the following arguments: n. | from qiskit import QuantumCircuit
from qiskit.quantum_info import Statevector
def create_uniform_superposition(n):
qc = QuantumCircuit(n)
qc.h(range(n))
return Statevector(qc)
| from qiskit import QuantumCircuit
from qiskit.quantum_info import Statevector
def check(candidate):
from qiskit.quantum_info import state_fidelity
from math import sqrt
assert round(state_fidelity(candidate(1), [1/sqrt(2)]*2),3)==1
assert round(state_fidelity(candidate(2), [0.5]*4),3)==1
assert roun... | create_uniform_superposition | basic |
qiskitHumanEval/40 | Initialize a non-trivial 3-qubit state for a given desired vector state and return counts after running it using Qiskit Sampler with the Aer simulator as backend and ser=t seed as 42.
You must implement this using a function named `init_random_3qubit` with the following arguments: desired_vector. | from qiskit import QuantumCircuit
from qiskit.quantum_info import Statevector
from qiskit_aer import AerSimulator
from qiskit_ibm_runtime import Sampler
from qiskit_ibm_runtime.options import SamplerOptions
def init_random_3qubit(desired_vector):
qc = QuantumCircuit(3)
qc.initialize(desired_vector, range(3))
... | from qiskit import QuantumCircuit
from qiskit.quantum_info import Statevector
from qiskit_aer import AerSimulator
from qiskit_ibm_runtime import Sampler
from qiskit_ibm_runtime.options import SamplerOptions
def check(candidate):
from math import sqrt
from qiskit.quantum_info import state_fidelity
desired_ve... | init_random_3qubit | basic |
qiskitHumanEval/41 | Compose XZ with a 3-qubit identity operator using the Operator and the Pauli 'YX' class in Qiskit. Return the operator instance.
You must implement this using a function named `compose_op` with no arguments. | from qiskit.quantum_info.operators import Operator, Pauli
import numpy as np
def compose_op():
op = Operator(np.eye(2 ** 3))
YX = Operator(Pauli('YX'))
op.compose(YX, qargs=[0, 2], front=True)
return op
| from qiskit.quantum_info.operators import Operator, Pauli
import numpy as np
def check(candidate):
result = candidate()
op = Operator(np.eye(2 ** 3))
YX = Operator(Pauli('YX'))
op.compose(YX, qargs=[0, 2], front=True)
assert(result == op)
check(compose_op) | compose_op | basic |
qiskitHumanEval/42 | Combine the following three operators XX YY ZZ as: 0.5 * (XX + YY - 3 * ZZ).
You must implement this using a function named `combine_op` with no arguments. | from qiskit.quantum_info.operators import Operator, Pauli
def combine_op():
XX = Operator(Pauli('XX'))
YY = Operator(Pauli('YY'))
ZZ = Operator(Pauli('ZZ'))
op = 0.5 * (XX + YY - 3 * ZZ)
return op
| from qiskit.quantum_info.operators import Operator, Pauli
def check(candidate):
result = candidate()
XX = Operator(Pauli('XX'))
YY = Operator(Pauli('YY'))
ZZ = Operator(Pauli('ZZ'))
op = 0.5 * (XX + YY - 3 * ZZ)
assert (result == op)
check(combine_op) | combine_op | basic |
qiskitHumanEval/43 | Instantiate a preset_passmanager using Qiskit using the least busy device available and optimzation level 3. Return the resulting passmanager instance.
You must implement this using a function named `generate_pass_manager_obj` with no arguments. | from qiskit.transpiler.preset_passmanagers import generate_preset_pass_manager
from qiskit_ibm_runtime import QiskitRuntimeService
from qiskit import QuantumCircuit
def generate_pass_manager_obj():
provider = QiskitRuntimeService()
backend = provider.least_busy()
pass_manager = generate_preset_pass_manager... | from qiskit.transpiler.preset_passmanagers import generate_preset_pass_manager
from qiskit_ibm_runtime import QiskitRuntimeService
from qiskit import QuantumCircuit
def check(candidate):
from qiskit.transpiler.passmanager import StagedPassManager
result = candidate()
assert(type(result) == StagedPassManager... | generate_pass_manager_obj | basic |
qiskitHumanEval/44 | Write an example using Qiskit that performs tensor operation on a 1-qubit quantum circuit with an X gate and a 2-qubit quantum circuit with a CRY gate, where the CRY gate has an angle of 0.2 radians and is controlled by qubit 0.
You must implement this using a function named `tensor_circuits` with no arguments. | from qiskit import QuantumCircuit
def tensor_circuits():
top = QuantumCircuit(1)
top.x(0)
bottom = QuantumCircuit(2)
bottom.cry(0.2, 0, 1)
tensored = bottom.tensor(top)
return tensored
| from qiskit import QuantumCircuit
def check(candidate):
from qiskit.quantum_info import Statevector
result = candidate()
top = QuantumCircuit(1)
top.x(0);
bottom = QuantumCircuit(2)
bottom.cry(0.2, 0, 1)
tensored = bottom.tensor(top)
assert Statevector.from_instruction(result).equiv(Stat... | tensor_circuits | basic |
qiskitHumanEval/45 | Generate a random clifford circuit using the input n_qubit as number of qubits.
You must implement this using a function named `get_random_clifford` with the following arguments: n_qubits. | from qiskit.quantum_info.random import random_clifford
def get_random_clifford(n_qubits):
return random_clifford(num_qubits=n_qubits)
| from qiskit.quantum_info.random import random_clifford
def check(candidate):
from qiskit.quantum_info import Clifford
result = candidate(3)
assert result.num_qubits == 3
assert isinstance(result, Clifford)
check(get_random_clifford) | get_random_clifford | basic |
qiskitHumanEval/46 | Generate a random linear function circuit using the input parameters n_qubits and seed, and the random_invertible_binary_matrix method.
You must implement this using a function named `get_random_linear_function` with the following arguments: n_qubits, seed. | from qiskit.circuit.library import LinearFunction
from qiskit.synthesis.linear.linear_matrix_utils import random_invertible_binary_matrix
def get_random_linear_function(n_qubits, seed):
return LinearFunction(random_invertible_binary_matrix(num_qubits=n_qubits, seed=seed))
| from qiskit.circuit.library import LinearFunction
from qiskit.synthesis.linear.linear_matrix_utils import random_invertible_binary_matrix
def check(candidate):
result = candidate(3,3)
assert result.num_qubits == 3
assert isinstance(result, LinearFunction)
check(get_random_linear_function) | get_random_linear_function | basic |
qiskitHumanEval/47 | Design a Quantum Circuit that simulates random coin flips for the given samples using Qiskit Sampler with the Aer simulator as backend and outputs the count of heads and tails in a dictionary. The heads should be stored in the dict as 'Heads' and tails as 'Tails'. For example
random_coin_flip(10) == {'Heads' : 5, 'Tail... | from qiskit import QuantumCircuit
from qiskit_aer import AerSimulator
from qiskit_ibm_runtime import Sampler
def random_coin_flip(samples):
circuit = QuantumCircuit(1,1)
circuit.h(0)
circuit.measure_all()
backend = AerSimulator()
sampler = Sampler(mode=backend)
result = sampler.run([circuit], s... | from qiskit import QuantumCircuit
from qiskit_aer import AerSimulator
from qiskit_ibm_runtime import Sampler
def check(candidate):
samples = 2000
result = candidate(samples)
assert result.keys() == {'Heads', 'Tails'}
assert round(result['Heads']/samples, 1) == 0.5
assert round(result['Tails']/sampl... | random_coin_flip | intermediate |
qiskitHumanEval/48 | Write a function that generates n number of random 8-bit unsigned integers using a Quantum Circuit and outputs a list of integers.
You must implement this using a function named `random_number_generator_unsigned_8bit` with the following arguments: n. | from qiskit import QuantumCircuit
from qiskit_aer import AerSimulator
from qiskit_ibm_runtime import Sampler
def random_number_generator_unsigned_8bit(n):
circuit = QuantumCircuit(8)
circuit.h(range(8))
circuit.measure_all()
backend = AerSimulator()
sampler = Sampler(mode=backend)
result = samp... | from qiskit import QuantumCircuit
from qiskit_aer import AerSimulator
from qiskit_ibm_runtime import Sampler
def check(candidate):
result = candidate(10)
assert isinstance(result, list)
assert len(result) == 10
for i in range(10):
assert result[i] >= 0 and result[i] < 256
check(random_number_ge... | random_number_generator_unsigned_8bit | intermediate |
qiskitHumanEval/49 | Return a simple Elitzur Vaidman bomb tester circuit.
You must implement this using a function named `simple_elitzur_vaidman` with no arguments. | from qiskit import QuantumCircuit
def simple_elitzur_vaidman():
circuit = QuantumCircuit(2)
circuit.h(0)
circuit.cx(0,1)
circuit.h(0)
return circuit
| from qiskit import QuantumCircuit
def check(candidate):
from qiskit.quantum_info import Statevector
result = candidate()
assert isinstance(result, QuantumCircuit)
assert result.num_qubits == 2
circuit = QuantumCircuit(2)
circuit.h(0)
circuit.cx(0,1)
circuit.h(0)
assert Statevector.fr... | simple_elitzur_vaidman | intermediate |
qiskitHumanEval/50 | Remove the gate in the input position for the given Quantum Circuit.
You must implement this using a function named `remove_gate_in_position` with the following arguments: circuit, position. | from qiskit import QuantumCircuit
def remove_gate_in_position(circuit, position):
del circuit.data[position]
return circuit
| from qiskit import QuantumCircuit
def check(candidate):
qc = QuantumCircuit(2)
qc.h(0)
qc.cx(0, 1)
qc.h(1)
qc.h(0)
expected_qc = QuantumCircuit(2)
expected_qc.cx(0, 1)
expected_qc.h(1)
expected_qc.h(0)
assert candidate(qc, 0)==expected_qc
check(remove_gate_in_position) | remove_gate_in_position | basic |
qiskitHumanEval/51 | Write a function to build a quantum teleportation circuit that takes a list of instructions as an argument to transfer the data from the sender to the receiver while taking advantage of dynamic circuits.
You must implement this using a function named `quantum_teleportation_circuit` with the following arguments: data. | from qiskit import QuantumRegister, ClassicalRegister, QuantumCircuit
from qiskit.circuit import Instruction
def quantum_teleportation_circuit(data):
sender = QuantumRegister(1, "sender")
receiver = QuantumRegister(1, "receiver")
ancillary = QuantumRegister(1, "ancillary")
c_sender = ClassicalRegister(... | from qiskit import QuantumRegister, ClassicalRegister, QuantumCircuit
from qiskit.circuit import Instruction
def check(candidate):
from qiskit.circuit.library import XGate, HGate
from qiskit_aer import AerSimulator
from qiskit_ibm_runtime import Sampler
from qiskit.result import marginal_distribution
... | quantum_teleportation_circuit | intermediate |
qiskitHumanEval/52 | Provide a quantum circuit that enables the transmission of two classical bits from the sender to the receiver through a single qubit of quantum communication, given that the sender and receiver have access to entangled qubits.
You must implement this using a function named `send_bits` with the following arguments: bits... | from qiskit import QuantumRegister, ClassicalRegister, QuantumCircuit
def send_bits(bitstring):
sender = QuantumRegister(1, "sender")
receiver = QuantumRegister(1, "receiver")
measure = ClassicalRegister(2, "measure")
circuit = QuantumCircuit(sender, receiver, measure)
# Prepare ebit used for super... | from qiskit import QuantumRegister, ClassicalRegister, QuantumCircuit
def check(candidate):
from qiskit_aer import AerSimulator
from qiskit_ibm_runtime import Sampler
result_1 = candidate("10")
backend = AerSimulator()
sampler = Sampler(mode=backend)
assert isinstance(result_1, QuantumCircuit)
... | send_bits | intermediate |
qiskitHumanEval/53 | Given two 8-bit integers a and b design a Quantum Circuit that acts as a classical XOR gate. Simulate the circuit using Qiskit Sampler with the Aer simulator as backend and return the counts of the result.
You must implement this using a function named `xor_gate` with the following arguments: a, b. | from qiskit_aer import AerSimulator
from qiskit_ibm_runtime import Sampler
from qiskit.circuit.library import XOR
def xor_gate(a, b):
circuit = XOR(8, a).compose(XOR(8, b))
circuit.measure_all()
backend = AerSimulator()
sampler = Sampler(mode=backend)
result = sampler.run([circuit.decompose()]).res... | from qiskit_aer import AerSimulator
from qiskit_ibm_runtime import Sampler
from qiskit.circuit.library import XOR
def check(candidate):
assert candidate(10, 20) == {"00011110": 1024}
assert candidate(61, 9) == {"00110100": 1024}
assert candidate(47, 8) == {"00100111": 1024}
check(xor_gate) | xor_gate | intermediate |
qiskitHumanEval/54 | Given two 3-bit integers a and b, design a quantum circuit that acts as a classical AND gate. Simulate the circuit on using Qiskit Sampler with the Aer simulator as backend and return the counts of the result.
You must implement this using a function named `and_gate` with the following arguments: a, b. | from qiskit import QuantumRegister, ClassicalRegister, QuantumCircuit
from qiskit_aer import AerSimulator
from qiskit_ibm_runtime import Sampler
def and_gate(a, b):
qr_a = QuantumRegister(3, "qr_a")
qr_b = QuantumRegister(3, "qr_b")
ancillary = QuantumRegister(3, "ancillary")
measure = ClassicalRegiste... | from qiskit import QuantumRegister, ClassicalRegister, QuantumCircuit
from qiskit_aer import AerSimulator
from qiskit_ibm_runtime import Sampler
def check(candidate):
assert candidate(1, 2) == {'000': 1024}
assert candidate(6, 7) == {'110': 1024}
assert candidate(3, 5) == {'001': 1024}
check(and_gate) | and_gate | intermediate |
qiskitHumanEval/55 | Given two 3-bit integers a and b, design a quantum circuit that acts as a classical OR gate. Simulate the circuit using Qiskit Sampler with the Aer simulator as backend and return the counts of the result.
You must implement this using a function named `or_gate` with the following arguments: a, b. | from qiskit import QuantumRegister, ClassicalRegister, QuantumCircuit
from qiskit_aer import AerSimulator
from qiskit_ibm_runtime import Sampler
def or_gate(a, b):
qr_a = QuantumRegister(3, "qr_a")
qr_b = QuantumRegister(3, "qr_b")
ancillary = QuantumRegister(3, "ancillary")
measure = ClassicalRegister... | from qiskit import QuantumRegister, ClassicalRegister, QuantumCircuit
from qiskit_aer import AerSimulator
from qiskit_ibm_runtime import Sampler
def check(candidate):
assert candidate(1, 2) == {"011": 1024}
assert candidate(6, 7) == {"111": 1024}
assert candidate(0, 5) == {"101": 1024}
check(or_gate) | or_gate | intermediate |
qiskitHumanEval/56 | Given two 8-bit integers, design a quantum circuit that acts as a classical NOT gate. Simulate the circuit Qiskit Sampler with the Aer simulator as backend and return the counts of the result.
You must implement this using a function named `not_gate` with the following arguments: a. | from qiskit import QuantumCircuit
from qiskit_aer import AerSimulator
from qiskit_ibm_runtime import Sampler
def not_gate(a):
circuit = QuantumCircuit(8)
a = format(a, "08b")
for i in range(8):
if a[7-i] == "0":
circuit.x(i)
circuit.measure_all()
backend = AerSimulator()
sam... | from qiskit import QuantumCircuit
from qiskit_aer import AerSimulator
from qiskit_ibm_runtime import Sampler
def check(candidate):
assert candidate(0) == {"11111111": 1024}
assert candidate(238) == {"00010001": 1024}
assert candidate(59) == {"11000100": 1024}
check(not_gate) | not_gate | intermediate |
qiskitHumanEval/57 | Design a SWAP gate using only CX gates.
You must implement this using a function named `create_swap_gate` with no arguments. | from qiskit import QuantumCircuit
def create_swap_gate():
circuit = QuantumCircuit(2)
circuit.cx(0,1)
circuit.cx(1,0)
circuit.cx(0,1)
return circuit
| from qiskit import QuantumCircuit
def check(candidate):
from qiskit.circuit.library import SwapGate
from qiskit.quantum_info.operators import Operator
result = candidate()
assert isinstance(result, QuantumCircuit)
assert result.num_qubits == 2
assert dict(result.count_ops()) == {'cx': 3}
ass... | create_swap_gate | intermediate |
qiskitHumanEval/58 | Design a CH gate using CX and RY gates.
You must implement this using a function named `create_ch_gate` with no arguments. | from qiskit import QuantumCircuit
from numpy import pi
def create_ch_gate():
circuit = QuantumCircuit(2)
circuit.ry(pi/4, 1)
circuit.cx(0,1)
circuit.ry(-pi/4, 1)
return circuit
| from qiskit import QuantumCircuit
from numpy import pi
def check(candidate):
from qiskit.circuit.library import CHGate
from qiskit.quantum_info.operators import Operator
result = candidate()
assert isinstance(result, QuantumCircuit)
assert result.num_qubits == 2
assert dict(result.count_ops()) =... | create_ch_gate | intermediate |
qiskitHumanEval/59 | Design a CZ gate using only H and CNOT gates and return the quantum circuit.
You must implement this using a function named `create_cz_gate` with no arguments. | from qiskit import QuantumCircuit
def create_cz_gate():
circuit = QuantumCircuit(2)
circuit.h(1)
circuit.cx(0,1)
circuit.h(1)
return circuit
| from qiskit import QuantumCircuit
def check(candidate):
from qiskit.circuit.library import CZGate
from qiskit.quantum_info.operators import Operator
result = candidate()
assert isinstance(result, QuantumCircuit)
assert result.num_qubits == 2
assert dict(result.count_ops()) == {'h': 2, 'cx': 1}
... | create_cz_gate | intermediate |
qiskitHumanEval/60 | Design a CY gate using only one CX gate and any other single qubit gates.
You must implement this using a function named `create_cy_gate` with no arguments. | from qiskit import QuantumCircuit
def create_cy_gate():
circuit = QuantumCircuit(2)
circuit.sdg(1)
circuit.cx(0,1)
circuit.s(1)
return circuit
| from qiskit import QuantumCircuit
def check(candidate):
from qiskit.circuit.library import CYGate
from qiskit.quantum_info.operators import Operator
result = candidate()
assert isinstance(result, QuantumCircuit)
assert result.num_qubits == 2
assert 'cx' in result.count_ops()
for gate in resu... | create_cy_gate | intermediate |
qiskitHumanEval/61 | Build a Quantum Circuit by first creating one Quantum Register and one Classical Register and then perform measurement on it.
You must implement this using a function named `create_quantum_circuit_with_one_qubit_and_measure` with no arguments. | from qiskit import QuantumRegister, QuantumCircuit, ClassicalRegister
def create_quantum_circuit_with_one_qubit_and_measure():
q = QuantumRegister(1, 'q')
c = ClassicalRegister(1, 'c')
qc = QuantumCircuit(q, c)
qc.measure(q, c)
return qc
| from qiskit import QuantumRegister, QuantumCircuit, ClassicalRegister
def check(candidate):
result = candidate()
assert result.depth() == 1
assert result.width() == 2
assert dict(result.count_ops()) == {'measure': 1}
check(create_quantum_circuit_with_one_qubit_and_measure) | create_quantum_circuit_with_one_qubit_and_measure | basic |
qiskitHumanEval/62 | Construct a BB84 protocol circuit for the sender, inputting both the states and the measured bases.
You must implement this using a function named `bb84_senders_circuit` with the following arguments: state, basis. | from qiskit import QuantumCircuit
def bb84_senders_circuit(state, basis):
num_qubits = len(state)
circuit = QuantumCircuit(num_qubits)
for i in range(len(basis)):
if state[i] == 1:
circuit.x(i)
if basis[i] == 1:
circuit.h(i)
return circuit
| from qiskit import QuantumCircuit
def check(candidate):
from qiskit.quantum_info import Statevector
from numpy.random import randint, seed
seed(12345)
qubits = 5
state = randint(2, size=qubits)
basis = randint(2, size=qubits)
result = candidate(state, basis)
assert isinstance(result, Qua... | bb84_senders_circuit | intermediate |
qiskitHumanEval/63 | Write a function to generate the key from the circuit and the sender's basis generated by the sender using BB84 protocol.
You must implement this using a function named `bb84_circuit_generate_key` with the following arguments: senders_basis, circuit. | from qiskit import QuantumCircuit
from qiskit_aer import AerSimulator
from qiskit_ibm_runtime import Sampler
from numpy.random import randint
def bb84_circuit_generate_key(senders_basis, circuit):
n = len(senders_basis)
receivers_basis = randint(2, size=n)
for i in range(n):
if receivers_basis[i]:
... | from qiskit import QuantumCircuit
from qiskit_aer import AerSimulator
from qiskit_ibm_runtime import Sampler
from numpy.random import randint
def check(candidate):
from numpy.random import seed
seed(12345)
basis = [1, 0, 0, 1, 1]
circuit = QuantumCircuit(5)
circuit.x([3, 4])
circuit.h([0, 3, 4])... | bb84_circuit_generate_key | difficult |
qiskitHumanEval/64 | Write a function that takes the bitstring 's' as the input and builds a Quantum Circuit such that the output when xor-ed with the input 's' is same as the 's'. When building the quantum circuit make sure the classical registers is named 'c'.
You must implement this using a function named `simons_algorithm` with the fol... | from qiskit import QuantumCircuit, QuantumRegister, ClassicalRegister
def simons_algorithm(s):
n = len(s)
s = s[::-1]
q_reg1 = QuantumRegister(n,"reg1")
q_reg2 = QuantumRegister(n,"reg2")
c_reg = ClassicalRegister(n, "c")
circuit = QuantumCircuit (q_reg1, q_reg2, c_reg)
circuit.h(q_reg1)
... | from qiskit import QuantumCircuit, QuantumRegister, ClassicalRegister
def check(candidate):
from qiskit_aer import AerSimulator
from qiskit_ibm_runtime import Sampler
result = candidate('1010')
assert isinstance(result, QuantumCircuit)
assert result.num_qubits == 8
def dpm2(vec1, vec2):
... | simons_algorithm | intermediate |
qiskitHumanEval/65 | Design a Quantum Fourier Transform circuit for n qubits using basic Quantum gates.
You must implement this using a function named `QFT` with the following arguments: n. | from qiskit import QuantumCircuit
from numpy import pi
def QFT(n):
circuit = QuantumCircuit(n)
def swap_registers(circuit, n):
for qubit in range(n//2):
circuit.swap(qubit, n-qubit-1)
return circuit
def qft_rotations(circuit, n):
"""Performs qft on the first n qubits in ... | from qiskit import QuantumCircuit
from numpy import pi
def check(candidate):
from qiskit.circuit.library import QFT as QiskitQFT
from qiskit.quantum_info.operators import Operator
result = candidate(3)
assert isinstance(result, QuantumCircuit)
assert result.num_qubits == 3
for gate in result.dat... | QFT | intermediate |
qiskitHumanEval/66 | Generate a Quantum Circuit for a W state and measure it.
You must implement this using a function named `w_state` with no arguments. | from qiskit import QuantumCircuit
from numpy import arccos, sqrt
def w_state():
circuit = QuantumCircuit(3)
circuit.ry(2*arccos(1/sqrt(3)), 0)
circuit.ch(0,1)
circuit.cx(1,2)
circuit.cx(0,1)
circuit.x(0)
circuit.measure_all()
return circuit
| from qiskit import QuantumCircuit
from numpy import arccos, sqrt
def check(candidate):
from qiskit_aer import AerSimulator
from qiskit.transpiler.preset_passmanagers import generate_preset_pass_manager
from qiskit_ibm_runtime import Sampler
result = candidate()
assert isinstance(result, QuantumCircu... | w_state | intermediate |
qiskitHumanEval/67 | Design a CHSH circuit that takes bits of Alice and Bob as input and return the Quantum Circuit after measuring.
You must implement this using a function named `chsh_circuit` with the following arguments: alice, bob. | from qiskit import QuantumCircuit
from numpy import pi
def chsh_circuit(alice, bob):
qc = QuantumCircuit(2, 2)
qc.h(0)
qc.cx(0, 1)
qc.barrier()
if alice == 0:
qc.ry(0, 0)
else:
qc.ry(-pi / 2, 0)
qc.measure(0, 0)
if bob == 0:
qc.ry(-pi / 4, 1)
else:
q... | from qiskit import QuantumCircuit
from numpy import pi
def check(candidate):
result = candidate(0,1)
assert isinstance(result, QuantumCircuit)
assert result.num_qubits == 2
assert result.width() == 4
assert result.depth() == 4
assert set({'ry': 2, 'measure': 2, 'h': 1, 'cx': 1}.items()).issubset... | chsh_circuit | intermediate |
qiskitHumanEval/68 | Design a Zeno Elitzur Vaidman Bomb Tester circuit which takes the boolean if the bomb is live and outputs the percentage of successful live bomb predictions, dud bomb predictions and bombs that detonated. Use 25 cycles to increase the efficiency of the circuit.
You must implement this using a function named `zeno_elitz... | from qiskit import QuantumCircuit
from qiskit_aer import AerSimulator
from qiskit_ibm_runtime import Sampler
from numpy import pi
def zeno_elitzur_vaidman_bomb_tester(bomb_live):
live_predictions = dud_predictions = detonations = 0
shots = 1024
cycles = 25
e = pi/cycles
measurements = cycles + 1 if... | from qiskit import QuantumCircuit
from qiskit_aer import AerSimulator
from qiskit_ibm_runtime import Sampler
from numpy import pi
import numpy as np
def check(candidate):
# Check output structure
result_live = candidate(True)
result_dud = candidate(False)
assert isinstance(result_live, tuple) and len(re... | zeno_elitzur_vaidman_bomb_tester | difficult |
qiskitHumanEval/69 | Build a Quantum Circuit composed by the gates H in Quantum register 0, Controlled-S gate in quantum register 0 1, H gate in quantum register 1 and Controlled-S dagger gate in quantum register 1 0.
You must implement this using a function named `create_quantum_circuit_based_h0_cs01_h1_csdg10` with no arguments. | from qiskit import QuantumCircuit
def create_quantum_circuit_based_h0_cs01_h1_csdg10():
qc = QuantumCircuit(2)
qc.h(0)
qc.cs(0,1)
qc.h(1)
qc.csdg(1,0)
return qc
| from qiskit import QuantumCircuit
def check(candidate):
result = candidate()
assert isinstance(result, QuantumCircuit)
assert result.num_qubits == 2
assert result.depth() == 4
assert dict(result.count_ops()) == {'h': 2, 'cs': 1, 'csdg': 1}
check(create_quantum_circuit_based_h0_cs01_h1_csdg10) | create_quantum_circuit_based_h0_cs01_h1_csdg10 | basic |
qiskitHumanEval/70 | Build a Quantum Circuit composed by the gates H in Quantum register 0, Controlled-SWAP gate, also known as the Fredkin gate in quantum register 0 1 2, H gate in quantum register 1 and Controlled-S dagger gate in quantum register 1 0.
You must implement this using a function named `create_quantum_circuit_based_h0_cswap0... | from qiskit import QuantumCircuit
def create_quantum_circuit_based_h0_cswap012_h1_csdg10():
qc = QuantumCircuit(3)
qc.h(0)
qc.cswap(0,1,2)
qc.h(1)
qc.csdg(1,0)
return qc
| from qiskit import QuantumCircuit
def check(candidate):
result = candidate()
assert isinstance(result, QuantumCircuit)
assert result.num_qubits == 3
assert result.depth() == 4
assert dict(result.count_ops()) == {"h": 2, "cswap": 1, "csdg": 1}
check(create_quantum_circuit_based_h0_cswap012_h1_csdg10... | create_quantum_circuit_based_h0_cswap012_h1_csdg10 | basic |
qiskitHumanEval/71 | Build a Quantum Circuit composed by the gates H in Quantum register 0, Controlled-√X gate in quantum register 0 1, and H gate in quantum register 1.
You must implement this using a function named `create_quantum_circuit_based_h0_csx01_h1` with no arguments. | from qiskit import QuantumCircuit
def create_quantum_circuit_based_h0_csx01_h1():
qc = QuantumCircuit(3)
qc.h(0)
qc.csx(0,1)
qc.h(1)
return qc
| from qiskit import QuantumCircuit
def check(candidate):
result = candidate()
assert isinstance(result, QuantumCircuit)
assert result.num_qubits == 3
assert result.depth() == 3
assert dict(result.count_ops()) == {"h": 2, "csx": 1}
check(create_quantum_circuit_based_h0_csx01_h1) | create_quantum_circuit_based_h0_csx01_h1 | basic |
qiskitHumanEval/72 | Apply `gate` to qubits with indices `qubits`, conditioned on all `condition_clbits` being 1.
You must implement this using a function named `gate_if_clbits` with the following arguments: circuit, gate, qubits, condition_clbits. | import contextlib
from qiskit import QuantumCircuit
from qiskit.circuit import Gate
def gate_if_clbits(circuit, gate, qubits, condition_clbits):
with contextlib.ExitStack() as stack:
for index in condition_clbits:
stack.enter_context(circuit.if_test((index, 1)))
circuit.append(gate, qub... | import contextlib
from qiskit import QuantumCircuit
from qiskit.circuit import Gate
def check(candidate):
from qiskit.circuit.library import CXGate
from qiskit_aer import AerSimulator
from qiskit_ibm_runtime import Sampler
qc = QuantumCircuit(2, 3)
qc.x(0)
candidate(qc, CXGate(), [0, 1], [0, 2])... | gate_if_clbits | intermediate |
qiskitHumanEval/73 | Add an X-basis measurement on qubit at index `qubit`, storing the result to classical bit `clbit`.
You must implement this using a function named `x_measurement` with the following arguments: circuit, qubit, clbit. | from qiskit import QuantumCircuit
def x_measurement(circuit, qubit, clbit):
circuit.h(qubit)
circuit.measure(qubit, clbit)
| from qiskit import QuantumCircuit
def check(candidate):
from qiskit.primitives import StatevectorSampler
qc = QuantumCircuit(3, 2)
qc.x(1)
qc.h(1)
candidate(qc, 1, 0)
result = StatevectorSampler().run([qc]).result()[0].data.c.get_counts()
assert result.get('01') == 1024
check(x_measurement... | x_measurement | basic |
qiskitHumanEval/74 | Split `circuit` at each barrier operation. Do not include barriers in the output circuits.
You must implement this using a function named `split_circuit_at_barriers` with the following arguments: circuit. | from qiskit import QuantumCircuit
from qiskit.circuit.library import Barrier
def split_circuit_at_barriers(circuit):
output = []
new_circuit = circuit.copy_empty_like()
for inst in circuit.data:
if isinstance(inst.operation, Barrier):
output.append(new_circuit)
new_circuit =... | from qiskit import QuantumCircuit
from qiskit.circuit.library import Barrier
def check(candidate):
qc = QuantumCircuit(3)
qc.x(0)
qc.barrier()
qc.cx(0, 1)
qc.h([0, 1])
qc.z(1)
qc.barrier()
qc.barrier()
qc.tdg(0)
circuits = candidate(qc)
assert len(circuits) == 4
for circ... | split_circuit_at_barriers | intermediate |
qiskitHumanEval/75 | Given a QuantumCircuit, sample it once and convert the measurement result to a list of bools, where the 0th bool is the result of the 0th classical bit.
You must implement this using a function named `circuit_to_bools` with the following arguments: circuit. | from qiskit import QuantumCircuit
from qiskit.primitives import StatevectorSampler
def circuit_to_bools(circuit):
result = StatevectorSampler().run([circuit], shots=1).result()[0].data.meas.get_counts()
measurement_int = int(list(result.keys())[0], 2)
output = []
for bit_index in range(circuit.num_clbi... | from qiskit import QuantumCircuit
from qiskit.primitives import StatevectorSampler
def check(candidate):
# 101
qc = QuantumCircuit(3)
qc.x([0, 2])
qc.measure_all()
assert candidate(qc) == [True, False, True]
# 00011
qc = QuantumCircuit(5)
qc.x([3, 4])
qc.measure_all()
assert can... | circuit_to_bools | intermediate |
qiskitHumanEval/76 | Return a transpiler pass that replaces all non-controlled Z-gates with H-X-H-gate sequences.
You must implement this using a function named `create_hxh_pass` with no arguments. | from qiskit import QuantumRegister
from qiskit.transpiler.basepasses import TransformationPass
from qiskit.dagcircuit import DAGCircuit
from qiskit.circuit.library import ZGate, HGate, XGate
def create_hxh_pass():
class HXHPass(TransformationPass):
def run(
self,
dag: DAGCircuit,
... | from qiskit import QuantumRegister
from qiskit.transpiler.basepasses import TransformationPass
from qiskit.dagcircuit import DAGCircuit
from qiskit.circuit.library import ZGate, HGate, XGate
def check(candidate):
from qiskit.transpiler import PassManager
from qiskit import QuantumCircuit
hxh_pass = candidat... | create_hxh_pass | intermediate |
qiskitHumanEval/77 | Given a distribution as a dictionary of the form { measurement: probability }, return a quantum circuit that produces that distribution.
You must implement this using a function named `circuit_from_probability_dist` with the following arguments: probability_dist. | import math
from qiskit import QuantumCircuit
def circuit_from_probability_dist(probability_dist):
num_qubits = math.ceil(math.log2(max(probability_dist.keys()) + 1)) or 1
amplitudes = []
for basis_state in range(2**num_qubits):
prob = probability_dist.get(basis_state, 0)
amplitudes.append(... | import math
from qiskit import QuantumCircuit
def check(candidate):
from qiskit.quantum_info import Statevector
def _check(input_dist):
circuit = candidate(input_dist)
# allow circuits with or without final measurements
circuit.remove_final_measurements()
probability_dist = State... | circuit_from_probability_dist | intermediate |
qiskitHumanEval/78 | Return an inverse quantum Fourier transform circuit without the swap gates.
You must implement this using a function named `qft_no_swaps` with the following arguments: num_qubits. | from qiskit import QuantumCircuit
from qiskit.circuit.library import QFT
def qft_no_swaps(num_qubits):
qft = QFT(num_qubits=num_qubits, do_swaps=False, inverse=True)
return qft
| from qiskit import QuantumCircuit
from qiskit.circuit.library import QFT
def check(candidate):
from qiskit.quantum_info import Operator
for num_qubits in [1, 3, 8]:
qft = QFT(num_qubits=num_qubits, do_swaps=False, inverse=True)
response = candidate(num_qubits)
assert Operator(qft) == Ope... | qft_no_swaps | intermediate |
qiskitHumanEval/79 | Return the total number of instructions in the circuit.
You must implement this using a function named `count_instructions` with the following arguments: circuit. | from qiskit import QuantumCircuit
def count_instructions(circuit):
return len(circuit.data)
| from qiskit import QuantumCircuit
def check(candidate):
qc = QuantumCircuit(4)
qc.x(0)
assert candidate(qc) == 1
qc.cx(0, [1, 2])
assert candidate(qc) == 3
qc.measure_all()
assert candidate(qc) == 8
check(count_instructions) | count_instructions | basic |
qiskitHumanEval/80 | Return the total number of unitary gates in the circuit.
You must implement this using a function named `count_gates` with the following arguments: circuit. | from qiskit import QuantumCircuit
from qiskit.circuit import Gate
def count_gates(circuit):
count = 0
for inst in circuit.data:
if isinstance(inst.operation, Gate):
count += 1
return count
| from qiskit import QuantumCircuit
from qiskit.circuit import Gate
def check(candidate):
qc = QuantumCircuit(4)
qc.reset(0)
qc.tdg(0)
assert candidate(qc) == 1
qc.cx(0, [1, 2])
assert candidate(qc) == 3
qc.measure_all()
assert candidate(qc) == 3
check(count_gates) | count_gates | basic |
qiskitHumanEval/81 | Generate a QASM 2 string representing a Phi plus Bell state quantum circuit. Then, convert this QASM 2 string into a Quantum Circuit object and return the resulting circuit.
You must implement this using a function named `convert_qasm_string_to_quantum_circuit` with no arguments. | from qiskit import QuantumCircuit
def convert_qasm_string_to_quantum_circuit():
qasm_string="""OPENQASM 2.0;
include "qelib1.inc";
qreg q[2];
creg c[2];
h q[0];
cx q[0],q[1];"""
qc = QuantumCircuit.from_qasm_str(qasm_string)
return qc
| from qiskit import QuantumCircuit
def check(candidate):
from qiskit.quantum_info import Statevector
from math import sqrt
data = candidate()
bell_state = (Statevector.from_label("11") + Statevector.from_label("00"))/sqrt(2)
assert Statevector.from_instruction(data) == bell_state
check(convert_qasm_... | convert_qasm_string_to_quantum_circuit | basic |
qiskitHumanEval/82 | Create a file containing the binary serialization of a Phi plus Bell state quantum circuit and write it as 'bell.qpy' in binary mode.
You must implement this using a function named `create_binary_serialization` with no arguments. | from qiskit import QuantumCircuit
from qiskit import qpy
def create_binary_serialization():
qc = QuantumCircuit(2, name='Bell', metadata={'test': True})
qc.h(0)
qc.cx(0, 1)
with open('bell.qpy', 'wb') as fd:
qpy.dump(qc, fd)
| from qiskit import QuantumCircuit
from qiskit import qpy
def check(candidate):
from qiskit.quantum_info import Statevector
from math import sqrt
candidate()
with open('bell.qpy', 'rb') as fd:
data = qpy.load(fd)[0]
bell_state = (Statevector.from_label("11") + Statevector.from_label("00"))/sq... | create_binary_serialization | basic |
qiskitHumanEval/83 | Construct a Phi plus Bell state quantum circuit, compute its Density Matrix and Concurrence, and return these results in a tuple in the same order.
You must implement this using a function named `calculate_bell_state_properties` with no arguments. | from qiskit import QuantumCircuit
from qiskit.quantum_info import DensityMatrix, concurrence
def calculate_bell_state_properties():
qc = QuantumCircuit(2, name='Bell')
qc.h(0)
qc.cx(0, 1)
rho = DensityMatrix.from_instruction(qc)
concur = concurrence(rho)
return rho, concur
| from qiskit import QuantumCircuit
from qiskit.quantum_info import DensityMatrix, concurrence
def check(candidate):
import numpy as np
DensityMatrix, concurrence = candidate()
assert round(concurrence,1) == 1
expected_rho = np.array([[0.5, 0, 0, 0.5], [0, 0, 0, 0], [0, 0, 0, 0], [0.5, 0, 0, 0.5]])
np... | calculate_bell_state_properties | basic |
qiskitHumanEval/84 | Create a 2-qubit quantum circuit where you define a custom 1-qubit unitary gate (e.g., U3) and apply it as a controlled gate with qubit 0 as control and qubit 1 as target. Return the final circuit.
You must implement this using a function named `controlled_custom_unitary_circuit` with no arguments. | from qiskit import QuantumCircuit
from qiskit.circuit.library import U3Gate
def controlled_custom_unitary_circuit():
qc = QuantumCircuit(2)
custom_gate = U3Gate(0.3, 0.2, 0.1).control()
qc.append(custom_gate, [0, 1])
return qc
| from qiskit import QuantumCircuit
from qiskit.circuit.library import U3Gate
def check(candidate):
qc = candidate()
assert isinstance(qc, QuantumCircuit)
assert qc.num_qubits == 2
assert any(instr[0].name.startswith('cu3') or 'u3' in instr[0].name for instr in qc.data)
check(controlled_custom_unitary_ci... | controlled_custom_unitary_circuit | basic |
qiskitHumanEval/85 | Given a QuantumCircuit, convert it into qasm2 string and return it.
You must implement this using a function named `convert_quantum_circuit_to_qasm_string` with the following arguments: circuit. | from qiskit import QuantumCircuit
import qiskit.qasm2
def convert_quantum_circuit_to_qasm_string(circuit):
qasm_str = qiskit.qasm2.dumps(circuit)
return qasm_str
| from qiskit import QuantumCircuit
import qiskit.qasm2
def check(candidate):
from qiskit.quantum_info import Statevector
qc = QuantumCircuit(2, 2)
qc.h(0)
qc.cx(0,1)
qasm_str = candidate(qc)
circuit = QuantumCircuit.from_qasm_str(qasm_str)
assert Statevector.from_instruction(circuit) == State... | convert_quantum_circuit_to_qasm_string | basic |
qiskitHumanEval/86 | Create a 5-qubit quantum circuit with a chain of CX gates and apply Qiskit's CollectLinearFunctions transpiler pass. Return two circuits:
1. One with no block width restriction.
2. One with a max_block_width of 3.
Use PassManager to apply the pass and return both circuits.
You must implement this using a function named... | from qiskit import QuantumCircuit
from qiskit.transpiler.passes import CollectLinearFunctions
from qiskit.transpiler import PassManager
def collect_linear_blocks_with_and_without_limit():
qc = QuantumCircuit(5)
qc.h(0)
qc.cx(0, 1)
qc.cx(1, 2)
qc.cx(2, 3)
qc.cx(3, 4)
pm_full = PassManager([C... | from qiskit import QuantumCircuit
from qiskit.transpiler.passes import CollectLinearFunctions
from qiskit.transpiler import PassManager
def check(candidate):
from qiskit.circuit.library import LinearFunction
full, limited = candidate()
full_linear_count = sum(1 for instr in full.data if isinstance(instr.ope... | collect_linear_blocks_with_and_without_limit | intermediate |
qiskitHumanEval/87 | Create a one-qubit quantum circuit, apply hadamard gate, then add a delay of 100 and then again apply hadamard gate and return the circuit.
You must implement this using a function named `quantum_circuit_with_delay` with no arguments. | from qiskit import QuantumCircuit
def quantum_circuit_with_delay():
qc = QuantumCircuit(1)
qc.h(0)
delay_duration = 100
qc.delay(delay_duration, 0, unit="dt")
qc.h(0)
return qc
| from qiskit import QuantumCircuit
def check(candidate):
from qiskit import QuantumRegister
from qiskit.circuit import CircuitInstruction
from qiskit.circuit.library import HGate
from qiskit.circuit import Delay
qr = QuantumRegister(1, name="q")
data = candidate().data
assert data[0]==Circuit... | quantum_circuit_with_delay | intermediate |
qiskitHumanEval/88 | Create a one-qubit quantum circuit, apply a Hadamard gate, and then measure it. Based on the classical output, use an IfElseOp operation: if the output is 1, append a one-qubit quantum circuit with a Z gate; if the output is 0, append a one-qubit quantum circuit with an X gate. Finally, add a measurement to the appende... | from qiskit import QuantumCircuit, ClassicalRegister, QuantumRegister
from qiskit.circuit import IfElseOp
def create_conditional_circuit():
qr = QuantumRegister(1, 'q')
cr = ClassicalRegister(1, 'c')
circuit = QuantumCircuit(qr, cr)
circuit.h(qr[0])
circuit.measure(qr[0], cr[0])
true_body = Qua... | from qiskit import QuantumCircuit, ClassicalRegister, QuantumRegister
from qiskit.circuit import IfElseOp
def check(candidate):
from qiskit import QuantumRegister
from qiskit.circuit import CircuitInstruction
from qiskit.circuit.library import HGate
from qiskit_aer import AerSimulator
from qiskit_ib... | create_conditional_circuit | intermediate |
qiskitHumanEval/89 | Construct a quantum circuit with a three-qubit controlled-Hadamard gate, using qubit 0 and qubit 1 as the control bits and qubit 2 as the target bit. Return the circuit.
You must implement this using a function named `create_controlled_hgate` with no arguments. | from qiskit.circuit.library import HGate
from qiskit import QuantumCircuit, QuantumRegister
def create_controlled_hgate():
qr = QuantumRegister(3)
qc = QuantumCircuit(qr)
c3h_gate = HGate().control(2)
qc.append(c3h_gate, qr)
return qc
| from qiskit.circuit.library import HGate
from qiskit import QuantumCircuit, QuantumRegister
def check(candidate):
from qiskit.quantum_info import Operator
solution_register = QuantumRegister(3)
solution_circuit = QuantumCircuit(solution_register)
c3h_gate = HGate().control(2)
solution_circuit.append... | create_controlled_hgate | basic |
qiskitHumanEval/90 | Create a custom 2-qubit gate with an X gate on qubit 0 and an H gate on qubit 1. Then, add two control qubits to this gate. Apply this controlled gate to a 4-qubit circuit, using qubits 0 and 3 as controls and qubits 1 and 2 as targets. Return the final circuit.
You must implement this using a function named `create_cu... | from qiskit import QuantumCircuit
def create_custom_controlled():
qc1 = QuantumCircuit(2)
qc1.x(0)
qc1.h(1)
custom = qc1.to_gate().control(2)
qc2 = QuantumCircuit(4)
qc2.append(custom, [0, 3, 1, 2])
return qc2
| from qiskit import QuantumCircuit
def check(candidate):
from qiskit.quantum_info import Operator
qc1 = QuantumCircuit(2)
qc1.x(0)
qc1.h(1)
custom = qc1.to_gate().control(2)
qc2 = QuantumCircuit(4)
qc2.append(custom, [0, 3, 1, 2])
candidate_circuit = candidate()
assert Operator(qc2).e... | create_custom_controlled | basic |
qiskitHumanEval/91 | Create a circuit that produces a phi plus bell state with name bell_instruction and convert it into a quantum instruction.
You must implement this using a function named `convert_circuit_to_instruction` with no arguments. | from qiskit import QuantumCircuit
from qiskit.converters import circuit_to_instruction
def convert_circuit_to_instruction():
circ = QuantumCircuit(2, 2, name="bell_instruction")
circ.h(0)
circ.cx(0,1)
circ.measure([0, 1], [0, 1])
instruction = circuit_to_instruction(circ)
return instruction
| from qiskit import QuantumCircuit
from qiskit.converters import circuit_to_instruction
def check(candidate):
instruction = candidate()
assert instruction.name == "bell_instruction"
assert instruction.num_qubits == 2
circ = QuantumCircuit(2, 2)
circ.h(0)
circ.cx(0,1)
circ.measure([0, 1], [0, ... | convert_circuit_to_instruction | basic |
qiskitHumanEval/92 | Construct a Phi plus Bell state quantum circuit, compute its stabilizer state, and return both the stabilizer state and a dictionary of the stabilizer state measurement probabilities.
You must implement this using a function named `calculate_stabilizer_state_info` with no arguments. | from qiskit import QuantumCircuit
from qiskit.quantum_info import StabilizerState
def calculate_stabilizer_state_info():
qc = QuantumCircuit(2)
qc.h(0)
qc.cx(0, 1)
stab = StabilizerState(qc)
probabilities_dict = stab.probabilities_dict()
return stab, probabilities_dict
| from qiskit import QuantumCircuit
from qiskit.quantum_info import StabilizerState
def check(candidate):
stab, probabilities_dict = candidate()
assert isinstance(stab, StabilizerState)
assert isinstance(probabilities_dict, dict)
assert probabilities_dict == {"00": 0.5, "11": 0.5}
qc = QuantumCircuit(... | calculate_stabilizer_state_info | basic |
qiskitHumanEval/93 | Create a random clifford circuit using the random_clifford function for a given n qubits with seed 1234 and synthesize it using synth_clifford_full method and return.
You must implement this using a function named `synthesize_clifford_circuit` with the following arguments: n_qubits. | from qiskit.synthesis import synth_clifford_full
from qiskit.quantum_info.random import random_clifford
def synthesize_clifford_circuit(n_qubits):
qc = random_clifford(n_qubits, seed=1234)
synthesized_qc = synth_clifford_full(qc)
return synthesized_qc
| from qiskit.synthesis import synth_clifford_full
from qiskit.quantum_info.random import random_clifford
def check(candidate):
from qiskit.quantum_info import Operator
n_qubits = 6
synthesized_qc = candidate(n_qubits)
qc = random_clifford(n_qubits)
synthesized_qc = synth_clifford_full(qc)
assert ... | synthesize_clifford_circuit | basic |
qiskitHumanEval/94 | Given a Quantum Circuit as the argument, convert it into qasm3 string and return it.
You must implement this using a function named `convert_quantum_circuit_to_qasm_string` with the following arguments: circuit. | from qiskit import QuantumCircuit
import qiskit.qasm3
def convert_quantum_circuit_to_qasm_string(circuit):
qasm_str = qiskit.qasm3.dumps(circuit)
return qasm_str
| from qiskit import QuantumCircuit
import qiskit.qasm3
def check(candidate):
from qiskit.quantum_info import Operator
qc = QuantumCircuit(2, 2)
qc.h(0)
qc.cx(0,1)
qasm_str = candidate(qc)
circuit = qiskit.qasm3.loads(qasm_str)
assert Operator(circuit).equiv(Operator(qc)), "Loaded QASM does no... | convert_quantum_circuit_to_qasm_string | basic |
qiskitHumanEval/95 | For a given Quantum Circuit remove all the barriers from it and return.
You must implement this using a function named `remove_barrier` with the following arguments: circuit. | from qiskit import QuantumCircuit
from qiskit.transpiler.passes import RemoveBarriers
def remove_barrier(circuit):
return RemoveBarriers()(circuit)
| from qiskit import QuantumCircuit
from qiskit.transpiler.passes import RemoveBarriers
def check(candidate):
from qiskit.quantum_info import Operator
circuit = QuantumCircuit(1)
circuit.h(0)
circuit.barrier()
circuit.x(0)
candidate_circuit = candidate(circuit)
for inst in candidate_circuit.da... | remove_barrier | basic |
qiskitHumanEval/96 | Create the phi+ Bell state, run it in the FakeKyoto backend and return the counts. Use seed 42 for the sampler.
You must implement this using a function named `bell_state_noisy` with no arguments. | from qiskit_ibm_runtime.fake_provider import FakeKyoto
from qiskit.circuit import QuantumCircuit
from qiskit_ibm_runtime import Sampler
from qiskit_ibm_runtime.options import SamplerOptions
from qiskit.transpiler.preset_passmanagers import generate_preset_pass_manager
def bell_state_noisy():
backend = FakeKyoto()
... | from qiskit_ibm_runtime.fake_provider import FakeKyoto
from qiskit.circuit import QuantumCircuit
from qiskit_ibm_runtime import Sampler
from qiskit_ibm_runtime.options import SamplerOptions
from qiskit.transpiler.preset_passmanagers import generate_preset_pass_manager
def check(candidate):
from qiskit.quantum_info ... | bell_state_noisy | basic |
qiskitHumanEval/97 | Return the two qubit connections for any input backend of type FakeBackendV2, IBMBackend.
You must implement this using a function named `two_qubit_conections` with the following arguments: backend. | from qiskit_ibm_runtime.fake_provider.fake_backend import FakeBackendV2
from qiskit_ibm_runtime import IBMBackend
from typing import Union
def two_qubit_conections(backend):
if isinstance(backend, FakeBackendV2):
return backend.coupling_map
return backend.configuration().coupling_map
| from qiskit_ibm_runtime.fake_provider.fake_backend import FakeBackendV2
from qiskit_ibm_runtime import IBMBackend
from typing import Union
def check(candidate):
from qiskit_ibm_runtime.fake_provider import FakeKyoto
from qiskit_ibm_runtime import QiskitRuntimeService
backend_v2 = FakeKyoto()
backend_ser... | two_qubit_conections | intermediate |
qiskitHumanEval/98 | Return the minimum readout error of any input backend of type FakeBackendV2, IBMBackend.
You must implement this using a function named `qubit_with_least_readout_error` with the following arguments: backend. | import numpy as np
from typing import Union
from qiskit_ibm_runtime.fake_provider.fake_backend import FakeBackendV2
from qiskit_ibm_runtime import IBMBackend
def qubit_with_least_readout_error(backend):
error_list = []
if issubclass(type(backend), FakeBackendV2):
for qubits in range(backend.num_qub... | import numpy as np
from typing import Union
from qiskit_ibm_runtime.fake_provider.fake_backend import FakeBackendV2
from qiskit_ibm_runtime import IBMBackend
def check(candidate):
from qiskit_ibm_runtime.fake_provider import FakeKyoto
from qiskit_ibm_runtime import QiskitRuntimeService
backend_v2 = FakeKyot... | qubit_with_least_readout_error | basic |
qiskitHumanEval/99 | Remove all the gates with unassigned parameters from the given circuit.
You must implement this using a function named `remove_unassigned_parameterized_gates` with the following arguments: circuit. | from qiskit.circuit import Parameter, QuantumCircuit
def remove_unassigned_parameterized_gates(circuit):
circuit_data = circuit.data.copy()
circuit_without_params = QuantumCircuit(circuit.num_qubits, circuit.num_clbits)
#for instr, qargs, cargs in circuit_data:
for instruction in circuit_data:
... | from qiskit.circuit import Parameter, QuantumCircuit
def check(candidate):
from qiskit.circuit.library import RXGate, RZGate
circ = QuantumCircuit(2)
theta = Parameter("θ")
circ.rx(0.1, 1)
circ.ry(theta, 1)
circ.rx(theta, 0)
circ.cp(theta, 0, 1)
circ.rz(0.4, 0)
circ_can = candidate(c... | remove_unassigned_parameterized_gates | basic |
End of preview. Expand in Data Studio
qiskit_humaneval_hard
qiskit_humaneval_hard is a dataset for evaluating LLM's at writing Qiskit code. It contains the same problems as in Qiskit/qiskit_humaneval but is not formatted as a completion exercise. Compared
with Qiskit/qiskit_humaneval the benchmark is more challenging as the LLM needs to decide which python modules to use for solving the problems.
Terms of use
- Terms of use: https://quantum.ibm.com/terms
- Privacy policy: https://quantum.ibm.com/terms/privacy
License
- Downloads last month
- 21