task_id stringlengths 17 19 | prompt stringlengths 129 898 | canonical_solution stringlengths 30 1.05k | test stringlengths 72 1.05k | entry_point stringlengths 3 50 | difficulty_scale stringclasses 3
values |
|---|---|---|---|---|---|
qiskitHumanEval/100 | from qiskit.transpiler.passes import SolovayKitaev
from qiskit.transpiler import PassManager
from qiskit.circuit import QuantumCircuit
def sol_kit_decomp(circuit: QuantumCircuit) -> QuantumCircuit:
""" Create a pass manager to decompose the single qubit gates into gates of the dense subset ['t', 'tdg', 'h'] in the ... |
pm = PassManager([SolovayKitaev()])
circ_dec = pm.run(circuit)
return circ_dec
| def check(candidate):
import numpy as np
from qiskit.circuit.library import EfficientSU2
from qiskit.quantum_info import Operator
circ = EfficientSU2(3).decompose()
circ = circ.assign_parameters(np.random.random(circ.num_parameters))
circ_can = candidate(circ)
op_or = Operator(circ)
op_c... | sol_kit_decomp | basic |
qiskitHumanEval/101 | from qiskit_ibm_runtime.fake_provider import FakeKyoto
from qiskit.circuit.library import GraphState
import networkx as nx
from qiskit.circuit import QuantumCircuit
def get_graph_state() -> QuantumCircuit:
""" Return the circuit for the graph state of the coupling map of the Fake Kyoto backend. Hint: Use the networ... |
backend = FakeKyoto()
coupling_map = backend.coupling_map
G = nx.Graph()
G.add_edges_from(coupling_map)
adj_matrix = nx.adjacency_matrix(G).todense()
gr_state_circ = GraphState(adjacency_matrix=adj_matrix)
return gr_state_circ
| def check(candidate):
from collections import OrderedDict
from qiskit.transpiler.passes import UnitarySynthesis
from qiskit.transpiler import PassManager
gr_state_circ_can = candidate()
assert isinstance(gr_state_circ_can, QuantumCircuit)
gr_state_circ_exp_ops = OrderedDict([("cz", 144), ("h", 1... | get_graph_state | intermediate |
qiskitHumanEval/102 | from qiskit.circuit import QuantumCircuit
from qiskit_ibm_runtime.fake_provider import FakeKyoto, FakeKyiv, FakeAuckland
from qiskit.transpiler.preset_passmanagers import generate_preset_pass_manager
def backend_with_least_instructions() -> str:
""" Transpile the circuit for the phi plus bell state for FakeKyoto, F... |
qc = QuantumCircuit(2)
qc.h(0)
qc.cx(0, 1)
backends = [FakeKyiv(), FakeKyoto(), FakeAuckland()]
qc_isa_num_intruc = {}
for backend in backends:
pm = generate_preset_pass_manager(optimization_level=0, backend=backend)
qc_isa_num_intruc[backend.name] = len(pm.run(qc).data)
ret... | def check(candidate):
backend_can = candidate()
assert backend_can in "fake_auckland" or "auckland" in backend_can
| backend_with_least_instructions | basic |
qiskitHumanEval/103 | import importlib
import inspect
from qiskit_ibm_runtime.fake_provider import fake_backend
def fake_providers_v2_with_ecr() -> list:
""" Return the list of names of all the fake providers of type FakeBackendV2 which contains ecr gates in its available operations.
""" |
fake_provider_module = importlib.import_module("qiskit_ibm_runtime.fake_provider")
fake_providers = {}
for name, obj in inspect.getmembers(fake_provider_module):
if inspect.isclass(obj) and issubclass(obj, fake_backend.FakeBackendV2):
fake_providers[name] = obj
fake_providers_ecr = ... | def check(candidate):
providers_can = candidate()
providers_exp = [
"FakeCusco",
"FakeKawasaki",
"FakeKyiv",
"FakeKyoto",
"FakeOsaka",
"FakePeekskill",
"FakeQuebec",
"FakeSherbrooke",
"FakeBrisbane",
"FakeCairoV2",
]
for pro... | fake_providers_v2_with_ecr | basic |
qiskitHumanEval/104 | from qiskit_ibm_runtime.fake_provider import FakeOsaka, FakeSherbrooke, FakeBrisbane
from qiskit.transpiler.preset_passmanagers import generate_preset_pass_manager
from qiskit.circuit.library import QFT
def backend_with_lowest_complexity():
""" Transpile the 4-qubit QFT circuit using preset passmanager with optimiz... |
qc = QFT(4)
backends = [FakeOsaka(), FakeSherbrooke(), FakeBrisbane()]
complexity_dict = {}
for backend in backends:
pm = generate_preset_pass_manager(
optimization_level=3, seed_transpiler=1234, backend=backend
)
data = pm.run(qc).data
complexity = 0
... | def check(candidate):
complexity_can = candidate()
complexity_exp = 211
assert complexity_can == complexity_exp
| backend_with_lowest_complexity | intermediate |
qiskitHumanEval/105 | from qiskit import QuantumCircuit
from qiskit.quantum_info import CNOTDihedral
def initialize_cnot_dihedral() -> CNOTDihedral:
""" Initialize a CNOTDihedral element from a QuantumCircuit consist of 2-qubits with cx gate on qubit 0 and 1 and t gate on qubit 0 and return.
""" |
circ = QuantumCircuit(2)
# Apply gates
circ.cx(0, 1)
circ.t(0)
elem = CNOTDihedral(circ)
return elem
| def check(candidate):
result = candidate()
assert isinstance(result, CNOTDihedral), f'Expected result to be CNOTDihedral, but got {type(result)}'
assert result.linear.tolist() == [[1, 0], [1, 1]]
assert str(result.poly) == "0 + x_0"
assert result.shift.tolist() == [0, 0]
| initialize_cnot_dihedral | basic |
qiskitHumanEval/106 | from qiskit import QuantumCircuit
from qiskit.quantum_info import CNOTDihedral
def compose_cnot_dihedral() -> CNOTDihedral:
""" Create two Quantum Circuits of 2 qubits. First quantum circuit should have a cx gate on qubits 0 and 1 and a T gate on qubit 0. The second one is the same but with an additional X gate on ... |
circ1 = QuantumCircuit(2)
# Apply gates
circ1.cx(0, 1)
circ1.t(0)
elem1 = CNOTDihedral(circ1)
circ2 = circ1.copy()
circ2.x(1)
elem2 = CNOTDihedral(circ2)
composed_elem = elem1.compose(elem2)
return composed_elem
| def check(candidate):
result = candidate()
assert isinstance(result, CNOTDihedral), f'Expected result to be CNOTDihedral, but got {type(result)}'
assert result.linear.tolist() == [[1, 0], [0, 1]]
assert str(result.poly) == "0 + 2*x_0"
assert list(result.shift) == [0, 1]
| compose_cnot_dihedral | intermediate |
qiskitHumanEval/107 | from qiskit.quantum_info import ScalarOp
def compose_scalar_ops() -> ScalarOp:
""" Create two ScalarOp objects with dimension 2 and coefficient 2, compose them together, and return the resulting ScalarOp.
""" |
op1 = ScalarOp(2, 2)
op2 = ScalarOp(2, 2)
composed_op = op1.compose(op2)
return composed_op
| def check(candidate):
result = candidate()
assert isinstance(result, ScalarOp), f'Expected result to be ScalarOp, but got {type(result)}'
assert result.coeff == 4
assert result.input_dims() == (2,)
| compose_scalar_ops | basic |
qiskitHumanEval/108 | from qiskit.quantum_info import Choi
import numpy as np
def initialize_adjoint_and_compose(data1: np.ndarray, data2: np.ndarray) -> (Choi, Choi, Choi):
""" Initialize Choi matrices for the given data1 and data2 as inputs. Compute data1 adjoint, and then return the data1 Choi matrix, its adjoint and the composed cho... |
choi1 = Choi(data1)
choi2 = Choi(data2)
adjoint_choi1 = choi1.adjoint()
composed_choi = choi1.compose(choi2)
return choi1, adjoint_choi1, composed_choi
| def check(candidate):
data = np.eye(4)
choi, adjoint_choi, composed_choi = candidate(data, data)
assert isinstance(choi, Choi), f'Expected choi to be Choi, but got {type(choi)}'
assert choi.dim == (2, 2), f'Expected dimensions to be (2, 2), but got {choi.dim}'
assert isinstance(adjoint_choi, Choi), ... | initialize_adjoint_and_compose | basic |
qiskitHumanEval/109 | from qiskit.circuit import QuantumCircuit, Parameter
def circuit()-> QuantumCircuit:
""" Create a parameterized quantum circuit using minimum resources whose statevector output cover the equatorial plane of the surface of the bloch sphere.
""" |
qc = QuantumCircuit(1)
qc.h(0)
theta = Parameter('th')
qc.rz(theta,0)
return qc
| def check(candidate):
import numpy as np
from qiskit.quantum_info import Statevector
def statevector_to_bloch_angles(state_vector):
alpha = state_vector[0]
beta = state_vector[1]
norm = np.sqrt(np.abs(alpha)**2 + np.abs(beta)**2)
alpha = alpha / norm
beta = beta / nor... | circuit | intermediate |
qiskitHumanEval/110 | from qiskit import QuantumCircuit
from qiskit.quantum_info import random_clifford, Operator
def equivalent_clifford_circuit(circuit: QuantumCircuit,n: int)->list:
""" Given a clifford circuit return a list of n random clifford circuits which are equivalent to the given circuit up to a relative and absolute toleranc... |
op_or = Operator(circuit)
num_qubits = circuit.num_qubits
qc_list = []
counter = 0
while counter< n:
qc = random_clifford(num_qubits).to_circuit()
op_qc = Operator(qc)
if op_qc.equiv(op_or, rtol = 0.4, atol = 0.4) == True:
counter += 1
qc_list.append(... | def check(candidate):
from qiskit.quantum_info import Clifford
qc_comp = random_clifford(5).to_circuit()
op_comp = Operator(qc_comp)
can_circ_list = candidate(qc_comp, 10)
for item in can_circ_list:
assert Operator(item).equiv(op_comp, rtol = 0.4, atol = 0.4)
try:
Cliffor... | equivalent_clifford_circuit | intermediate |
qiskitHumanEval/111 | from qiskit.circuit import QuantumCircuit, Parameter
def circuit():
""" Return an ansatz to create a quantum dataset of pure states distributed equally across the bloch sphere. Use minimum number of gates in the ansatz.
""" |
qc = QuantumCircuit(1)
p1 = Parameter("p1")
p2 = Parameter("p2")
qc.rx(p1,0)
qc.ry(p2,0)
return qc
| def check(candidate):
assert candidate().num_parameters >= 2 , "The circuit doesn't cover the bloch sphere."
assert candidate().num_parameters <= 5 , "The circuit is too long"
| circuit | intermediate |
qiskitHumanEval/112 | from qiskit.quantum_info import Operator
from qiskit.circuit.library import PauliEvolutionGate
from qiskit.synthesis import LieTrotter
from qiskit import QuantumCircuit
from qiskit.quantum_info import Pauli, SparsePauliOp
def create_product_formula_circuit(pauli_strings: list, times: list, order: int, reps: int) -> Qua... |
qc = QuantumCircuit(len(pauli_strings[0]))
synthesizer = LieTrotter(reps=reps)
for pauli_string, time in zip(pauli_strings, times):
pauli = Pauli(pauli_string)
hamiltonian = SparsePauliOp(pauli)
evolution_gate = PauliEvolutionGate(hamiltonian, time)
synthesized_circuit = syn... | def check(candidate):
pauli_strings = ["X", "Y", "Z"]
times = [1.0, 2.0, 3.0]
order = 2
reps = 1
def create_solution_circuit(pauli_strings, times, order, reps):
qc = QuantumCircuit(len(pauli_strings[0]))
synthesizer = LieTrotter(reps=reps)
for pauli_string, time in zip(pauli... | create_product_formula_circuit | intermediate |
qiskitHumanEval/113 | from qiskit import QuantumCircuit
from qiskit.transpiler import PassManager, PropertySet
from qiskit.transpiler.passes import RemoveBarriers
def calculate_depth_after_barrier_removal(qc: QuantumCircuit) -> PropertySet:
""" Remove barriers from the given quantum circuit and calculate the depth before and after remov... |
property_set = PropertySet()
property_set["depth_before"] = qc.depth()
property_set["width"] = qc.width()
pass_manager = PassManager(RemoveBarriers())
optimized_qc = pass_manager.run(qc)
property_set['depth_after'] = optimized_qc.depth()
return property_set
| def check(candidate):
qc = QuantumCircuit(3)
qc.h(0)
qc.barrier()
qc.cx(0, 1)
qc.barrier()
qc.cx(1, 2)
qc.measure_all()
property_set = candidate(qc)
assert property_set["depth_before"] == qc.depth(), "'depth_before' should match the original circuit depth"
assert proper... | calculate_depth_after_barrier_removal | intermediate |
qiskitHumanEval/114 | from qiskit.transpiler import CouplingMap
def create_and_modify_coupling_map() -> CouplingMap:
""" Create a CouplingMap with a specific coupling list, then modify it by adding an edge and a physical qubit.
The initial coupling list is [[0, 1], [1, 2], [2, 3], [3, 4], [4, 5]].
Add an edge (5, 6), and add a p... |
coupling_list = [[0, 1], [1, 2], [2, 3], [3, 4], [4, 5]]
cmap = CouplingMap(couplinglist=coupling_list)
cmap.add_edge(5, 6)
cmap.add_physical_qubit(7)
return cmap
| def check(candidate):
cmap = candidate()
edges = set(cmap.get_edges())
assert edges == { (0, 1), (1, 2), (2, 3), (3, 4), (4, 5), (5,6) }
assert len(cmap.physical_qubits) == 8
| create_and_modify_coupling_map | intermediate |
qiskitHumanEval/115 | from qiskit.transpiler import Target, InstructionProperties
from qiskit.circuit.library import UGate, CXGate
from qiskit.circuit import Parameter
def create_target() -> Target:
""" Create a Target object for a 2-qubit system and add UGate and CXGate instructions with specific properties.
- Add UGate for both qu... |
gmap = Target()
theta, phi, lam = [Parameter(p) for p in ("theta", "phi", "lambda")]
u_props = {
(0,): InstructionProperties(duration=5.23e-8, error=0.00038115),
(1,): InstructionProperties(duration=4.52e-8, error=0.00032115),
}
gmap.add_instruction(UGate(theta, phi, lam), u_props)
... | def check(candidate):
target = candidate()
assert isinstance(target, Target)
instructions = target.instructions
u_gate_instructions = [inst for inst in instructions if inst[0].name == "u"]
cx_gate_instructions = [inst for inst in instructions if inst[0].name == 'cx']
assert len(u_gate_instruct... | create_target | intermediate |
qiskitHumanEval/116 | from qiskit.circuit.library import PauliEvolutionGate
from qiskit.synthesis import MatrixExponential
from qiskit import QuantumCircuit
from qiskit.quantum_info import Pauli, Operator
import numpy as np
def synthesize_evolution_gate(pauli_string: str, time: float) -> QuantumCircuit:
""" Synthesize an evolution gate ... |
pauli = Pauli(pauli_string)
evolution_gate = PauliEvolutionGate(pauli, time)
synthesizer = MatrixExponential()
qc = synthesizer.synthesize(evolution_gate)
return qc
| def check(candidate):
pauli_string = "X"
time = 1.0
qc = candidate(pauli_string, time)
assert isinstance(qc, QuantumCircuit), "The function should return a QuantumCircuit"
assert qc.size() > 0, "The circuit should not be empty"
ideal_solution = QuantumCircuit(1)
ideal_solution.rx(2... | synthesize_evolution_gate | intermediate |
qiskitHumanEval/117 | from qiskit.synthesis import TwoQubitBasisDecomposer
from qiskit.quantum_info import Operator, random_unitary
from qiskit.circuit.library import CXGate
from qiskit import QuantumCircuit
import numpy as np
def decompose_unitary(unitary: Operator) -> QuantumCircuit:
""" Decompose a 4x4 unitary using the TwoQubitBasis... |
decomposer = TwoQubitBasisDecomposer(CXGate())
return decomposer(unitary)
| def check(candidate):
unitary = random_unitary(4)
try:
qc = candidate(unitary)
assert isinstance(qc, QuantumCircuit)
assert qc.num_qubits == 2
assert qc.size() > 0
cx_count = sum(1 for inst in qc.data if inst.operation.name == "cx")
assert cx_count > 0
except... | decompose_unitary | intermediate |
qiskitHumanEval/118 | from qiskit import QuantumCircuit
from qiskit.circuit.library import C3SXGate
def create_c3sx_circuit() -> QuantumCircuit:
""" Create a QuantumCircuit with a C3SXGate applied to the first four qubits.
""" |
qc = QuantumCircuit(4)
c3sx_gate = C3SXGate()
qc.append(c3sx_gate, [0, 1, 2, 3])
return qc
| def check(candidate):
qc = candidate()
assert isinstance(qc, QuantumCircuit)
c3sx_instructions = [inst for inst in qc.data if isinstance(inst.operation, C3SXGate)]
assert len(c3sx_instructions) == 1
assert c3sx_instructions[0].qubits == tuple([qc.qubits[i] for i in range(4)])
| create_c3sx_circuit | intermediate |
qiskitHumanEval/119 | from qiskit.circuit.library import CDKMRippleCarryAdder
from qiskit import QuantumCircuit
from qiskit.quantum_info import Operator
def create_ripple_carry_adder_circuit(num_state_qubits: int, kind: str) -> QuantumCircuit:
""" Create a QuantumCircuit with a CDKMRippleCarryAdder applied to the qubits.
The kind of... |
adder = CDKMRippleCarryAdder(num_state_qubits, kind)
qc = QuantumCircuit(adder.num_qubits)
qc.append(adder.to_instruction(), range(adder.num_qubits))
return qc
| def check(candidate):
qc_full = candidate(3, "full")
assert isinstance(qc_full, QuantumCircuit), "The function should return a QuantumCircuit"
op_full = Operator(qc_full)
expected_full = Operator(CDKMRippleCarryAdder(3, "full"))
assert op_full.equiv(expected_full), "The circuit does not match t... | create_ripple_carry_adder_circuit | intermediate |
qiskitHumanEval/120 | from qiskit.circuit.library import Diagonal
from qiskit import QuantumCircuit
from qiskit.quantum_info import Operator
def create_diagonal_circuit(diag: list) -> QuantumCircuit:
""" Create a QuantumCircuit with a Diagonal gate applied to the qubits.
The diagonal elements are provided in the list 'diag'.
""" |
diagonal_gate = Diagonal(diag)
qc = QuantumCircuit(diagonal_gate.num_qubits)
qc.append(diagonal_gate.to_instruction(), range(diagonal_gate.num_qubits))
return qc
| def check(candidate):
diag = [1, 1j, -1, -1j]
qc = candidate(diag)
assert isinstance(qc, QuantumCircuit), "The function should return a QuantumCircuit"
op_circuit = Operator(qc)
expected_diagonal = Diagonal(diag)
op_expected = Operator(expected_diagonal)
assert op_circuit.equi... | create_diagonal_circuit | intermediate |
qiskitHumanEval/121 | from qiskit import QuantumCircuit, QuantumRegister, ClassicalRegister
def conditional_two_qubit_circuit():
""" Create a quantum circuit with one qubit and two classical bits. The qubit's operation depends on its measurement outcome: if it measures to 1 (|1> state), it flips the qubit's state back to |0> using an X ... |
qr = QuantumRegister(1)
cr = ClassicalRegister(2, 'c')
qc = QuantumCircuit(qr, cr)
qc.h(qr[0])
qc.measure(qr[0], cr[0])
with qc.if_test((cr[0], 1)):
qc.x(qr[0])
qc.measure(qr[0], cr[1])
return qc
| def check(candidate):
from qiskit_aer import AerSimulator
from qiskit_ibm_runtime import Sampler
from qiskit_ibm_runtime.options import SamplerOptions
qc = candidate()
assert isinstance(qc, QuantumCircuit)
assert qc.num_qubits == 1
assert qc.num_clbits == 2
ops = dict(qc.count_ops())
... | conditional_two_qubit_circuit | basic |
qiskitHumanEval/122 | from qiskit.circuit.library import EfficientSU2
from qiskit_ibm_transpiler.transpiler_service import TranspilerService
def ai_transpiling(num_qubits):
""" Generate an EfficientSU2 circuit with the given number of qubits, 1 reps and make entanglement circular.
Then use the Qiskit Transpiler service with the AI ... |
circuit = EfficientSU2(num_qubits, entanglement="circular", reps=1)
transpiler_ai_true = TranspilerService(
backend_name="ibm_brisbane",
ai=True,
optimization_level=3
)
transpiled_circuit = transpiler_ai_true.run(circuit)
return transpiled_circuit
| def check(candidate):
import qiskit
num_qubits = 3
backend_name = "ibm_brisbane"
ai_flag = True
optimization_level = 3
og_circuit = EfficientSU2(num_qubits, entanglement="circular", reps=1)
gen_transpiled_circuit = candidate(num_qubits)
assert isinstance(gen_transpiled_circuit, qiskit.ci... | ai_transpiling | basic |
qiskitHumanEval/123 | from qiskit.visualization import plot_error_map
from qiskit_ibm_runtime.fake_provider import FakeBelemV2
def backend_error_map():
""" Instantiate a FakeBelemV2 backend and return the plot of its error_map.
""" |
backend = FakeBelemV2()
return plot_error_map(backend)
| def check(candidate):
from matplotlib.figure import Figure
result = candidate()
assert type(result) == Figure
assert len(result.axes) == 5
assert result.get_suptitle() == "fake_belem Error Map"
| backend_error_map | basic |
qiskitHumanEval/124 | from qiskit_ibm_runtime.fake_provider import FakeCairoV2
from qiskit_aer.noise import NoiseModel
def gen_noise_model():
""" Generate a noise model from the Fake Cairo V2 backend.
""" |
backend = FakeCairoV2()
noise_model = NoiseModel.from_backend(backend)
return noise_model
| def check(candidate):
backend = FakeCairoV2()
expected_nm = NoiseModel.from_backend(backend)
noise_model = candidate()
assert type(noise_model) == NoiseModel
assert noise_model == expected_nm
| gen_noise_model | basic |
qiskitHumanEval/125 | from qiskit.converters import circuit_to_gate
def circ_to_gate(circ):
""" Given a QuantumCircuit, convert it into a gate equivalent to the action of the input circuit and return it.
""" |
circ_gate = circuit_to_gate(circ)
return circ_gate
| def check(candidate):
from qiskit import QuantumCircuit, QuantumRegister
from qiskit.circuit.gate import Gate
from qiskit.quantum_info import Operator
from qiskit.circuit.library import ZGate
q = QuantumRegister(3, "q")
circ = QuantumCircuit(q)
circ.h(q[0])
circ.cx(q[0], q[1])
custom... | circ_to_gate | basic |
qiskitHumanEval/126 | from qiskit.circuit.library import HGate
from qiskit.quantum_info import Operator, process_fidelity
import numpy as np
def calculate_phase_difference_fidelity():
""" Create two quantum operators using Hadamard gate that differ only by a global phase. Calculate the process fidelity between these two operators and re... |
op_a = Operator(HGate())
op_b = np.exp(1j * 0.5) * Operator(HGate())
fidelity = process_fidelity(op_a, op_b)
return fidelity
| def check(candidate):
result = candidate()
assert isinstance(result, float)
assert abs(result - 1.0) < 1e-6
| calculate_phase_difference_fidelity | basic |
qiskitHumanEval/127 | from qiskit.circuit.random import random_circuit
from qiskit import QuantumCircuit
def random_circuit_depth():
""" Using qiskit's random_circuit function, generate a circuit with 4 qubits and a depth of 3 that measures all qubits at the end. Use the seed value 17 and return the generated circuit.
""" |
circuit = random_circuit(4, 3, measure=True, seed = 17)
return circuit
| def check(candidate):
result = candidate()
qc = random_circuit(4, 3, measure=True, seed = 17)
assert type(result) == QuantumCircuit
assert result == qc
| random_circuit_depth | basic |
qiskitHumanEval/128 | from qiskit.circuit import QuantumCircuit, QuantumRegister, ClassicalRegister
from qiskit.circuit.classical import expr
def conditional_quantum_circuit():
""" Create a quantum circuit with 4 qubits and 4 classical bits. Apply Hadamard gates to the first three qubits, measure them with three classical registers,
... |
qr = QuantumRegister(4, "q")
cr = ClassicalRegister(4, "c")
circ = QuantumCircuit(qr, cr)
circ.h(qr[0:3])
circ.measure(qr[0:3], cr[0:3])
_condition = expr.bit_xor(expr.bit_xor(cr[0], cr[1]), cr[2])
with circ.if_test(_condition):
circ.x(qr[3])
circ.measure(qr[3], cr[3])
r... | def check(candidate):
from qiskit_aer import AerSimulator
from qiskit_ibm_runtime import Sampler, SamplerOptions
from qiskit_ibm_runtime.options import SamplerOptions
circ_res = candidate()
assert type(circ_res) == QuantumCircuit
assert circ_res.num_qubits == 4
assert circ_res.num_clbits ==... | conditional_quantum_circuit | basic |
qiskitHumanEval/129 | from qiskit_ibm_runtime import QiskitRuntimeService
def find_highest_rz_error_rate(backend_name):
""" Given the name of a quantum backend, retrieve the properties of the specified backend and identify the qubit pair with the highest error rate among its RZ gates.
Return this qubit pair along with the correspon... |
service = QiskitRuntimeService(channel="ibm_quantum")
backend = service.backend(backend_name)
backend_properties = backend.properties()
try:
rz_props = backend_properties.gate_property("rz")
except:
return None
qubit_pair = max(rz_props, key=lambda x: rz_props[x]["gate_error"]... | def check(candidate):
service = QiskitRuntimeService(channel="ibm_quantum")
backend = service.least_busy(filters=lambda b : ("rz" in b.basis_gates))
max_rz_error_pair, max_rz_error_rate = candidate(backend.name)
assert isinstance(max_rz_error_pair, (tuple, list))
assert len(max_rz_error_pair) =... | find_highest_rz_error_rate | intermediate |
qiskitHumanEval/130 | from qiskit.circuit import QuantumCircuit
def inv_circuit(n):
""" Create a quantum circuit with 'n' qubits. Apply Hadamard gates to the second and third qubits.
Then apply CNOT gates between the second and fourth qubits, and between the third and fifth qubits.
Finally give the inverse of the quantum circuit... |
qc = QuantumCircuit(n)
for i in range(2):
qc.h(i+1)
for i in range(2):
qc.cx(i+1, i+2+1)
return qc.inverse()
| def check(candidate):
n = 5
qc_inv = candidate(n)
expected_qc = QuantumCircuit(n)
for i in range(2):
expected_qc.h(i+1)
for i in range(2):
expected_qc.cx(i+1, i+2+1)
expected_qc_inv = expected_qc.inverse()
assert qc_inv, QuantumCircuit
assert qc_inv == expected_qc... | inv_circuit | basic |
qiskitHumanEval/131 | from qiskit_ibm_runtime.fake_provider import FakeCairoV2
def backend_info(backend_name):
""" Given the fake backend name, retrieve information about the backend's number of qubits, coupling map, and supported instructions using the Qiskit Runtime Fake Provider,
and create a dictionary containing the info. The ... |
backend = FakeCairoV2()
config = backend.configuration()
dict_result = {"num_qubits": config.num_qubits, "coupling_map": config.coupling_map, "supported_instructions": config.supported_instructions}
return dict_result
| def check(candidate):
backend = FakeCairoV2()
binfo_dict = candidate(backend.name)
backend_config = backend.configuration()
assert isinstance(binfo_dict, dict)
assert binfo_dict["num_qubits"] == backend_config.num_qubits
assert binfo_dict["coupling_map"] == backend_config.coupling_map
assert... | backend_info | basic |
qiskitHumanEval/132 | from qiskit.circuit.random import random_circuit
from qiskit.transpiler.preset_passmanagers import generate_preset_pass_manager
from qiskit_ibm_runtime import Batch, Sampler
from qiskit_ibm_runtime.fake_provider import FakeManilaV2
def run_batched_random_circuits():
""" Generate 6 random quantum circuits, each with... |
fake_manila = FakeManilaV2()
pm = generate_preset_pass_manager(backend=fake_manila, optimization_level=1, seed_transpiler = 1)
circuits = [pm.run(random_circuit(3, 2, measure=True, seed=17)) for _ in range(6)]
batch_size = 3
partitions = [circuits[i : i + batch_size] for i in range(0, len(circuits)... | def check(candidate):
result = candidate()
assert isinstance(result, list)
assert len(result) == 2
for counts in result:
assert isinstance(counts, dict)
assert counts == {"110": 423, "100": 474, "000": 58, "010": 52, "101": 8, "111": 8, "011": 1}
| run_batched_random_circuits | basic |
qiskitHumanEval/133 | import datetime
from qiskit_ibm_runtime import QiskitRuntimeService
def find_recent_jobs():
""" Find and return jobs submitted in the last three months using QiskitRuntimeService.
""" |
three_months_ago = datetime.datetime.now() - datetime.timedelta(days=90)
service = QiskitRuntimeService()
jobs_in_last_three_months = service.jobs(created_after=three_months_ago)
return jobs_in_last_three_months
| def check(candidate):
result = candidate()
assert isinstance(result, list)
for job in result:
assert hasattr(job, "job_id")
assert hasattr(job, "creation_date")
assert job.creation_date.replace(tzinfo=None) >= (datetime.datetime.now() - datetime.timedelta(days=90)).replace(tzinfo=Non... | find_recent_jobs | basic |
qiskitHumanEval/134 | from qiskit_ibm_runtime import QiskitRuntimeService
def backend_info():
""" Using the QiskitRuntimeService, retrieve the backends that meet the following criteria: they are real quantum devices, they are operational, and they have a
minimum of 20 qubits. Then, return a list of dictionaries, each containing the... |
service = QiskitRuntimeService()
backends = service.backends(simulator=False, operational=True, min_num_qubits=20)
backend_info = []
for b in backends:
backend_info.append({"backend_name": b.name, "num_qubits": b.num_qubits, "instructions": b.operation_names})
sorted_backend_info = ... | def check(candidate):
result = candidate()
assert isinstance(result, list)
service = QiskitRuntimeService()
backends = service.backends(simulator=False, operational=True, min_num_qubits=20)
backend_info = []
for b in backends:
backend_info.append({"backend_name": b.name, "num_qubits... | backend_info | basic |
qiskitHumanEval/135 | from qiskit_aer.noise import NoiseModel, ReadoutError
def noise_model_with_readouterror():
""" Construct a noise model with specific readout error properties for different qubits. For qubit 0, a readout of 1 has a 20% probability
of being erroneously read as 0, and a readout of 0 has a 30% probability of being... |
noise_model = NoiseModel()
p0given1_other = 0.03
p1given0_other = 0.02
readout_error_other = ReadoutError(
[
[1 - p1given0_other, p1given0_other],
[p0given1_other, 1 - p0given1_other],
]
)
noise_model.add_all_qubit_readout_error(readout_error_other)
... | def check(candidate):
result = candidate()
assert isinstance(result, NoiseModel), "Result should be a NoiseModel instance"
global_error = result.to_dict()["errors"][0]['probabilities']
assert global_error == [[0.98, 0.02], [0.03, 0.97]]
qubit0_error = result.to_dict()["errors"][1]
... | noise_model_with_readouterror | intermediate |
qiskitHumanEval/136 | from qiskit.quantum_info import entropy, random_density_matrix, DensityMatrix
def pure_states(ε):
""" Return a list of ten density matrices which are pure up to a tolerance of ε.
""" |
entropy_list = []
while len(entropy_list) <= 9:
density_matrix = random_density_matrix(dims = 2)
if entropy(density_matrix) < ε:
entropy_list.append(density_matrix)
return entropy_list
| def check(candidate):
tol = 0.01
list_can = candidate(tol)
assert len(list_can) == 10," Length of the list is not 10"
for _, item in enumerate(list_can):
assert isinstance(item, DensityMatrix), "The list doesn't contain density matrices"
assert entropy(item) < tol, "Entropy of density ma... | pure_states | intermediate |
qiskitHumanEval/137 | from qiskit.quantum_info import random_density_matrix, entanglement_of_formation
def entanglement_dataset(ε):
""" Return a dataset of density matrices whose 2-qubit entanglement of formation is within given tolerance.
""" |
entanglement_data = []
while len(entanglement_data) <= 9:
density_matrix = random_density_matrix(dims = 4)
if entanglement_of_formation(density_matrix)>=ε:
entanglement_data.append(density_matrix)
return entanglement_data
| def check(candidate):
from qiskit.quantum_info import DensityMatrix
tol = 0.1
can_list = candidate(tol)
assert len(can_list) == 10, "Length of list is not 10"
for _, item in enumerate(can_list):
assert isinstance(item, DensityMatrix), "The list doesn't contain density matrices"
asser... | entanglement_dataset | intermediate |
qiskitHumanEval/138 | from qiskit.quantum_info import mutual_information, random_density_matrix
def mutual_information_dataset(ε):
""" Return a list of density matrices whose mutual information is greater than the given tolerance.
""" |
mutual_information_list = []
while len(mutual_information_list)<= 9:
density_matrix = random_density_matrix(dims = 4)
if mutual_information(density_matrix) >= ε:
mutual_information_list.append(density_matrix)
return mutual_information_list
| def check(candidate):
from qiskit.quantum_info import DensityMatrix
tol = 0.5
can_list = candidate(tol)
assert len(can_list) == 10, "Length of the list is not 10"
for _,item in enumerate(can_list):
assert isinstance(item, DensityMatrix), "The list doesn't contain density matrices"
as... | mutual_information_dataset | intermediate |
qiskitHumanEval/139 | from qiskit.quantum_info import schmidt_decomposition
def schmidt_test(data, qargs_B):
""" Return the schmidt decomposition coefficients and the subsystem vectors for the given density matrix and partition.
""" |
return schmidt_decomposition(data, qargs_B)
| def check(candidate):
from qiskit.quantum_info import random_statevector
rs = random_statevector(dims = 16)
qargs = [0,1]
schmidt_decomp = candidate(rs, qargs)
for _, item in enumerate(schmidt_decomp):
assert item[0]>=0, "Schmidt coefficients must be real"
assert item[1].dims() == (2... | schmidt_test | basic |
qiskitHumanEval/140 | from qiskit.quantum_info import shannon_entropy
import numpy as np
def shannon_entropy_data(ε):
""" Return a list of ten probability vectors each of length 16 whose shannon entropy is greater than a given value.
""" |
shannon_data = []
while len(shannon_data) <= 9:
rand_prob = np.random.randn(16)
if shannon_entropy(rand_prob) >= ε:
shannon_data.append(rand_prob)
return shannon_data
| def check(candidate):
tol = 1
can_list = candidate(tol)
assert len(can_list) == 10, " The length of the list is not 10"
for _, item in enumerate(can_list):
assert shannon_entropy(item)>= tol, "Shannon entropy not greater than given value"
assert len(item) == 16, "The length of the probab... | shannon_entropy_data | basic |
qiskitHumanEval/141 | from qiskit.quantum_info import anti_commutator, SparsePauliOp
from qiskit.quantum_info import random_pauli
import numpy as np
def anticommutators(pauli: SparsePauliOp):
""" Return a list of ten anticommutators for the given pauli.
""" |
def is_multiple_of_identity(matrix):
identity_matrix = np.eye(matrix.shape[0])
scalar = matrix[0,0]
return np.allclose(matrix, scalar*identity_matrix)
num_qubits = pauli.num_qubits
anticommutator_list = []
while len(anticommutator_list) <= 9:
random_pauli_value = SparseP... | def check(candidate):
def is_multiple_of_identity(matrix):
if matrix.shape[0] != matrix.shape[1]:
return False # Not a square matrix
identity_matrix = np.eye(matrix.shape[0])
scalar = matrix[0,0]
return np.allclose(matrix, scalar*identity_matrix)
test_pauli = SparseP... | anticommutators | intermediate |
qiskitHumanEval/142 | from qiskit.quantum_info import random_density_matrix, purity, DensityMatrix
import numpy as np
def purity_dataset():
""" Return a list of 10 single qubit density matrices whose purity is greater than 0.5.
""" |
purity_dataset_list = []
while len(purity_dataset_list)<=9:
rand_density_matrix = random_density_matrix(dims=2)
if np.abs(purity(rand_density_matrix))>=0.5:
purity_dataset_list.append(rand_density_matrix)
return purity_dataset_list
| def check(candidate):
can_list = candidate()
assert len(can_list) == 10, "Number of density matrices is not 10"
for _, item in enumerate(can_list):
assert isinstance(item, DensityMatrix)
assert np.abs(purity(item))>=0.5, "Purity of the denisty matrices is not less than 0.5"
| purity_dataset | intermediate |
qiskitHumanEval/143 | from qiskit.quantum_info import random_statevector, state_fidelity, Statevector
def fidelity_dataset():
""" Return a list of ten pairs of one qubit state vectors whose state fidelity is greater than 0.9.
""" |
fidelity_dataset_list = []
while len(fidelity_dataset_list)<=9:
sv_1 = random_statevector(2)
sv_2 = random_statevector(2)
if state_fidelity(sv_1, sv_2) >= 0.9:
fidelity_dataset_list.append((sv_1,sv_2))
return fidelity_dataset_list
| def check(candidate):
can_list = candidate()
assert len(can_list) == 10, "Length of returned list is not 10"
for _, item in enumerate(can_list):
assert isinstance(item[0], Statevector)
assert isinstance(item[1], Statevector)
assert(state_fidelity(item[0], item[1]))>=0.9, "State fidel... | fidelity_dataset | intermediate |
qiskitHumanEval/144 | from qiskit.quantum_info import random_density_matrix, concurrence, DensityMatrix
def concurrence_dataset():
""" Return a list of 10 density matrices whose concurrence is 0.
""" |
concurrence_dataset_list = []
while len(concurrence_dataset_list) <= 9:
rand_mat = random_density_matrix(dims = 4)
if concurrence(rand_mat) == 0:
concurrence_dataset_list.append(rand_mat)
return concurrence_dataset_list
| def check(candidate):
can_mat_list = candidate()
assert len(can_mat_list) == 10, "The list doesn't contain 10 elements"
for _, item in enumerate(can_mat_list):
assert isinstance(item, DensityMatrix)
assert concurrence(item) == 0, "The concurrence of the density matrix is not 0"
| concurrence_dataset | intermediate |
qiskitHumanEval/145 | from qiskit.circuit.library import QFT
from qiskit import QuantumCircuit
from qiskit.quantum_info import Operator
def qft_inverse(n: int):
""" Return the inverse qft circuit for n qubits.
""" |
return QFT(num_qubits=n, approximation_degree=0, inverse=True)
| def check(candidate):
candidate_circ = candidate(5)
assert isinstance(candidate_circ,QuantumCircuit), "Returned circuit is not a quantum circuit"
candidate_op = Operator(candidate_circ)
test_circ = QFT(5, approximation_degree=0, inverse=True)
test_op = Operator(test_circ)
assert test_op.equiv(ca... | qft_inverse | intermediate |
qiskitHumanEval/146 | from qiskit.transpiler import PassManager, StagedPassManager
from qiskit_ibm_runtime import QiskitRuntimeService
from qiskit.transpiler.passes.layout.trivial_layout import TrivialLayout
def trivial_layout() -> StagedPassManager:
""" Generate Qiskit code that sets up a StagedPassManager with a trivial layout using P... |
pm_opt = StagedPassManager()
pm_opt.layout = PassManager()
backend = QiskitRuntimeService().least_busy()
cm = backend.coupling_map
pm_opt.layout += TrivialLayout(cm)
return pm_opt
| def check(candidate):
pm_opt = candidate()
assert isinstance(pm_opt.layout._tasks[0][0], TrivialLayout)
| trivial_layout | basic |
qiskitHumanEval/147 | from qiskit import QuantumCircuit
from qiskit.circuit.library import YGate
def mcy(qc: QuantumCircuit) -> QuantumCircuit:
""" Add a multi-controlled-Y operation to qubit 4, controlled by qubits 0-3.
""" |
mcy_gate = YGate().control(num_ctrl_qubits=4)
qc.append(mcy_gate, range(5))
return qc
| from qiskit.quantum_info import Operator
def check(candidate):
expected = QuantumCircuit(6)
expected.h([0, 4, 5])
mcy_gate = YGate().control(num_ctrl_qubits=4)
expected.append(mcy_gate, range(5))
solution = QuantumCircuit(6)
solution.h([0, 4, 5])
solution = candidate(solution)
assert O... | mcy | intermediate |
qiskitHumanEval/148 | from qiskit import QuantumCircuit
from qiskit.transpiler.passes import BasicSwap
from qiskit.converters import circuit_to_dag, dag_to_circuit
from qiskit_ibm_runtime import IBMBackend
def swap_map(qc: QuantumCircuit, backend: IBMBackend) -> QuantumCircuit:
""" Add SWAPs to route `qc` for the `backend` object's coup... |
swap_pass = BasicSwap(coupling_map=backend.coupling_map)
dag = circuit_to_dag(qc)
mapped_dag = swap_pass.run(dag)
return dag_to_circuit(mapped_dag)
| def check(candidate):
from qiskit_ibm_runtime.fake_provider import FakeKyiv
from qiskit.circuit.random import random_circuit
from qiskit.transpiler.passes import CheckMap
backend = FakeKyiv()
for _ in range(3):
qc = random_circuit(5,5)
original_ops = qc.count_ops()
original_o... | swap_map | intermediate |
qiskitHumanEval/149 | from statistics import mode
from qiskit.primitives import BitArray
def most_common_result(bits: BitArray) -> str:
""" Return the most common result as a string of `1`s and `0`s.
""" |
return mode(bits.get_bitstrings())
| def check(candidate):
test_inputs = [
{"001": 50, "101": 3},
{"1": 1},
{"01101": 302, "10010": 10, "101": 209},
]
for counts in test_inputs:
bit_array = BitArray.from_counts(counts)
expected = max(counts.items(), key=lambda x: x[1])[0]
assert candidate(bit_arr... | most_common_result | intermediate |
qiskitHumanEval/150 | from qiskit import QuantumCircuit
from numpy import pi
def for_loop_circuit(qc: QuantumCircuit, n: int) -> QuantumCircuit:
""" Add a sub-circuit to the quantum circuit `qc` that applies a series of operations for `n` iterations using the `for_loop`.
In each iteration `i`, perform the following:
1. Apply a ... |
with qc.for_loop(range(n)) as i:
qc.ry(pi/n*i, 0)
qc.h(0)
qc.cx(0, 1)
qc.measure(0, 0)
qc.break_loop().c_if(0, 1)
return qc
| def check(candidate):
from qiskit.circuit.library import RYGate, HGate, CXGate, Measure
from qiskit.circuit import BreakLoopOp, CircuitInstruction
qc = QuantumCircuit(2,1)
solution = candidate(qc, 2)
assert len(solution.data) > 0, "Circuit should have operations added"
op = solution.d... | for_loop_circuit | difficult |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.