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/0 | from qiskit import QuantumCircuit
def create_quantum_circuit(n_qubits):
""" Generate a Quantum Circuit for the given int 'n_qubits' and return it.
""" |
return QuantumCircuit(n_qubits)
| def check(candidate):
result = candidate(3)
assert isinstance(result, QuantumCircuit)
assert result.num_qubits == 3
| create_quantum_circuit | basic |
qiskitHumanEval/1 | 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():
""" Define a phi plus bell state using Qiskit, transpile the circuit using pass manager with opt... |
bell = QuantumCircuit(2)
bell.h(0)
bell.cx(0, 1)
bell.measure_all()
backend = AerSimulator()
pass_manager = generate_preset_pass_manager(optimization_level=1, backend=backend)
isa_circuit = pass_manager.run(bell)
sampler = Sampler(mode=backend)
result = sampler.run([isa_circuit], sh... | def check(candidate):
result = candidate()
assert isinstance(result, dict)
assert result.keys() == {"00", "11"}
assert 0.4 < (result["00"] / sum(result.values())) < 0.6
| run_bell_state_simulator | basic |
qiskitHumanEval/2 | from qiskit.quantum_info import Statevector
from math import sqrt
def create_bell_statevector() -> Statevector:
""" Return a phi+ Bell statevector.
""" |
return (Statevector.from_label("00") + Statevector.from_label("11")) / sqrt(2)
| def check(candidate):
result = candidate()
solution = (Statevector.from_label("00") + Statevector.from_label("11")) / sqrt(2)
assert result.equiv(solution)
| create_bell_statevector | basic |
qiskitHumanEval/3 | from qiskit import QuantumCircuit
def create_ghz(drawing=False):
""" 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.
""" |
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 | 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 = (
Statevector.from_label("000") + Sta... | create_ghz | basic |
qiskitHumanEval/4 | from qiskit import QuantumCircuit
def create_unitary_from_matrix():
""" 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.
""" |
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
| 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()))
| create_unitary_from_matrix | basic |
qiskitHumanEval/5 | from qiskit import QuantumCircuit
def create_state_prep():
""" Return a QuantumCircuit that prepares the binary state 1.
""" |
qc = QuantumCircuit(2)
qc.prepare_state("01")
return qc
| 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_sv.num_qubits))
assert candidat... | create_state_prep | basic |
qiskitHumanEval/6 | from qiskit import QuantumCircuit
def create_state_prep(num_qubits):
""" Return a QuantumCircuit that prepares the state |1> on an n-qubit register.
""" |
qc = QuantumCircuit(num_qubits)
qc.prepare_state(1)
return qc
| 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)
refrence_sv = Statevector.fr... | create_state_prep | basic |
qiskitHumanEval/7 | from qiskit.circuit import QuantumCircuit, Parameter
def create_parametrized_gate():
""" Generate a 1 qubit QuantumCircuit with a parametrized Rx gate with parameter "theta".
""" |
theta = Parameter("theta")
quantum_circuit = QuantumCircuit(1)
quantum_circuit.rx(theta, 0)
return quantum_circuit
| 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"
| create_parametrized_gate | basic |
qiskitHumanEval/8 | from qiskit.circuit import QuantumCircuit, Parameter
def rx_gate(value=None):
""" 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.
""" |
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
| 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"
candidate_circuit = candidate(value=math.pi * 3 / 4)
... | rx_gate | basic |
qiskitHumanEval/9 | from qiskit.circuit.library import EfficientSU2
def create_efficientSU2():
""" Generate an EfficientSU2 circuit with 3 qubits, 1 reps and make insert_barriers true.
""" |
circuit = EfficientSU2(num_qubits=3, reps=1, insert_barriers=True)
return circuit
| 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
| create_efficientSU2 | basic |
qiskitHumanEval/10 | 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() -> QuantumCircuit:
""" Create a Qiskit circuit with the following unitary [[0, 0, 0, 1], [0, 0, 1, 0], [0, 1, 0, 0], [1, 0... |
XX = Operator([[0, 0, 0, 1], [0, 0, 1, 0], [0, 1, 0, 0], [1, 0, 0, 0]])
circ = QuantumCircuit(2, 2)
circ.append(XX, [0, 1])
pass_manager = generate_preset_pass_manager(optimization_level=1, basis_gates=["u", "cx"])
return pass_manager.run(circ)
| 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(Operator(result))
for inst in result.data:
if inst.operation.num_qubits > 1:
assert inst.operation.name in ["cx", "barrier"]
| create_operator | basic |
qiskitHumanEval/11 | from qiskit import QuantumCircuit
from qiskit.quantum_info import Statevector
def get_statevector(circuit: QuantumCircuit) -> Statevector:
""" Return the statevector from a circuit.
""" |
sv = Statevector.from_instruction(circuit)
return sv
| 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.from_instruction(test_circuit).equiv(result)
| get_statevector | basic |
qiskitHumanEval/12 | from qiskit import QuantumCircuit
from qiskit.quantum_info import Operator
def get_unitary() -> Operator:
""" Get unitary matrix for a phi plus bell circuit and return it.
""" |
circ = QuantumCircuit(2)
circ.h(0)
circ.cx(0, 1)
return Operator.from_circuit(circ).to_matrix() | def check(candidate):
result = candidate()
solution = QuantumCircuit(2)
solution.h(0)
solution.cx(0, 1)
assert Operator(solution).equiv(result)
| get_unitary | basic |
qiskitHumanEval/13 | from qiskit import QuantumCircuit
import numpy as np
def custom_rotation_gate() -> QuantumCircuit:
""" 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.
""" |
circuit = QuantumCircuit(1)
circuit.u(np.pi / 2, np.pi / 2, np.pi / 2, 0)
return circuit
| 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(result))
| custom_rotation_gate | basic |
qiskitHumanEval/14 | 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() -> list[str]:
""" Run a phi plus Bell circuit using Qiskit Sampler with the Aer simulator as backend for 10... |
bell = QuantumCircuit(2)
# Apply gates
bell.h(0)
bell.cx(0, 1)
bell.measure_all()
# choose simulator backend
backend = AerSimulator()
# Transpile for simulator
pass_manager = generate_preset_pass_manager(optimization_level=1, backend=backend)
bell_circ = pass_manager.run(bell)
... | def check(candidate):
result = candidate()
assert isinstance(result, list)
assert len(result) > 0
assert set(result) == {"00", "11"}
| bell_each_shot | basic |
qiskitHumanEval/15 | 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():
""" Transpile a bell circuit using pass manager with ... |
bell = QuantumCircuit(2)
bell.h(0)
bell.cx(0, 1)
bell.measure_all()
device_backend = FakeBelemV2()
simulator = AerSimulator.from_backend(device_backend)
pass_manager = generate_preset_pass_manager(optimization_level=1, backend=simulator)
bell_circ = pass_manager.run(bell)
sampler = ... | def check(candidate):
result = candidate()
assert isinstance(result, dict)
assert (result["00"] + result["11"]) != sum(result.values())
| noisy_bell | basic |
qiskitHumanEval/16 | from qiskit_ibm_runtime.fake_provider import FakeCairoV2
from qiskit import QuantumCircuit
from qiskit.transpiler.preset_passmanagers import generate_preset_pass_manager
def transpile_circuit(circuit: QuantumCircuit) -> QuantumCircuit:
""" For the given Quantum Circuit, return the transpiled circuit for the Fake Ca... |
backend = FakeCairoV2()
pass_manager = generate_preset_pass_manager(optimization_level=1, backend=backend)
return pass_manager.run(circuit)
| def check(candidate):
backend = FakeCairoV2()
circuit = QuantumCircuit(4, 3)
circuit.cx([0, 1, 2, 3], [1, 2, 3, 0])
t_circuit = candidate(circuit)
assert t_circuit.num_qubits == backend.num_qubits
for inst in t_circuit.data:
assert inst.operation.name in backend.configuration().basis_gat... | transpile_circuit | basic |
qiskitHumanEval/17 | 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: QuantumCircuit) -> QuantumCir... |
pass_ = BasisTranslator(std_eqlib, ["cx", "id", "rz", "sx", "x", "u"])
pm = PassManager(pass_)
return pm.run(circuit)
| def check(candidate):
from qiskit.quantum_info import Operator
trial_circuit = QuantumCircuit(2)
trial_circuit.h(0)
trial_circuit.u(0.3, 0.1, 0.1, 1)
trial_circuit.cp(np.pi / 4, 0, 1)
trial_circuit.h(0)
output = candidate(trial_circuit)
assert Operator(output).equiv(Operator(trial_circui... | unroll_circuit | basic |
qiskitHumanEval/18 | 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() -> QuantumCircuit:
""" Transpile a 10-qubit GHZ circuit for the Fake Sydney V2 backend using pass manager with no o... |
backend = FakeSydneyV2()
ghz = QuantumCircuit(10)
ghz.h(0)
ghz.cx(0, range(1, 10))
ghz.measure_all()
pass_manager = generate_preset_pass_manager(optimization_level=0, backend=backend)
return pass_manager.run(ghz)
| def check(candidate):
result = candidate()
backend = FakeSydneyV2()
# Optimization level 0 should use trivial qubit mapping
# i.e. circuit qubit 'i' => device qubit 'i'.
# This is very unlikely with higher optimization levels
assert result.layout.initial_index_layout() == list(range(backend.num_... | transpile_circuit_noopt | basic |
qiskitHumanEval/19 | 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() -> QuantumCircuit:
""" Transpile and map an 11-qubit GHZ circuit for the Fake Toronto V2 backend using pass manag... |
backend = FakeTorontoV2()
ghz = QuantumCircuit(11, 11)
ghz.h(0)
ghz.cx(0, range(1, 11))
ghz.barrier()
pass_manager = generate_preset_pass_manager(optimization_level=3, backend=backend)
return pass_manager.run(ghz)
| def check(candidate):
result = candidate()
result.remove_final_measurements()
backend = FakeTorontoV2()
# Check initial layout is not the trivial layout (this is very unlikely
# if transpiled with optimization level 3)
assert result.layout.initial_index_layout() != list(range(backend.num_qubits)... | transpile_circuit_maxopt | intermediate |
qiskitHumanEval/20 | 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() -> QuantumCircuit:
""" Using a pass manager with optimization level as 1, transpile and map a three-qubit GHZ circu... |
backend = FakePerth()
ghz = QuantumCircuit(3)
ghz.h(0)
ghz.cx(0, [1, 2])
ghz.barrier()
pass_manager = generate_preset_pass_manager(optimization_level=1, backend=backend, initial_layout=[2, 4, 6])
return pass_manager.run(ghz)
| def check(candidate):
result = candidate()
result.remove_final_measurements()
backend = FakePerth()
assert result.num_qubits == backend.num_qubits
assert result.layout.initial_index_layout()[:3] == [2, 4, 6]
| transpile_ghz_customlayout | intermediate |
qiskitHumanEval/21 | 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() -> QuantumCircuit:
""" Using a pass manager with optimization level as 1 and dense layout method, transpile and map a b... |
backend = FakeOslo()
bell = QuantumCircuit(2)
bell.h(0)
bell.cx(0, 1)
pass_manager = generate_preset_pass_manager(optimization_level=1, backend=backend, layout_method="dense")
solution_circ = pass_manager.run(bell)
return solution_circ
| def check(candidate):
result = candidate()
backend = FakeOslo()
assert result.num_qubits == backend.num_qubits
| transpile_circuit_dense | basic |
qiskitHumanEval/22 | 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() -> QuantumCircuit:
""" Using a pass manager with optimization level as 1 and as-late-as-possible scheduling method, ... |
backend = FakeAuckland()
bell = QuantumCircuit(2)
bell.h(0)
bell.cx(0, 1)
pass_manager = generate_preset_pass_manager(optimization_level=1, backend=backend, scheduling_method="alap")
return pass_manager.run(bell)
| def check(candidate):
result = candidate()
backend = FakeAuckland()
assert result.num_qubits == backend.num_qubits
| transpile_circuit_alap | basic |
qiskitHumanEval/23 | from qiskit import QuantumCircuit
def dj_constant_oracle() -> QuantumCircuit:
""" 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).
""" |
oracle = QuantumCircuit(3)
oracle.x(2)
return oracle
| 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_oracle)
| dj_constant_oracle | basic |
qiskitHumanEval/24 | from qiskit import QuantumCircuit
from qiskit.primitives import StatevectorSampler
from numpy import isclose
def dj_algorithm(oracle: QuantumCircuit) -> bool:
""" Given a Deutsch-Jozsa oracle in which the final qubit is the "output" qubit, return True if the oracle is constant or False otherwise.
""" |
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), range(n - 1))
counts = StatevectorSampler().run([qc]).result()[0].data.c.get_counts()
return isclose(counts.get('00000000', 0), 102... | def check(candidate):
balanced = QuantumCircuit(5)
balanced.cx(3, 4)
assert candidate(balanced) == False
constant = QuantumCircuit(9)
constant.x(8)
assert candidate(constant) == True
| dj_algorithm | intermediate |
qiskitHumanEval/25 | 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) -> QuantumCircuit:
""" Transpile a 7-qubit GHZ circuit using LookaheadSwap pass and an input custom... |
ghz = QuantumCircuit(7)
ghz.h(0)
ghz.cx(0, range(1, 7))
coupling_map = CouplingMap(couplinglist=coupling)
ls = LookaheadSwap(coupling_map=coupling_map)
pass_manager = PassManager(ls)
lookahead_circ = pass_manager.run(ghz)
return lookahead_circ
| def check(candidate):
from qiskit.quantum_info import Statevector
from qiskit.transpiler.passes import CheckMap
from qiskit.converters import circuit_to_dag
coupling = [[0, 1], [1, 2], [2, 3], [3, 4], [4, 5], [5, 6]]
coupling_map = CouplingMap(couplinglist=coupling)
result = candidate(coupling)
... | passmanager_Lookahead | intermediate |
qiskitHumanEval/26 | from qiskit.dagcircuit import DAGCircuit
from qiskit import QuantumRegister, ClassicalRegister, QuantumCircuit
from qiskit.converters import circuit_to_dag
def bell_dag() -> DAGCircuit:
""" Construct a DAG circuit for a 3-qubit Quantum Circuit with the bell state applied on qubit 0 and 1. Finally return the DAG Cir... |
q = QuantumRegister(3, 'q')
c = ClassicalRegister(3, 'c')
circ = QuantumCircuit(q, c)
circ.h(q[0])
circ.cx(q[0], q[1])
circ.measure(q[0], c[0])
dag = circuit_to_dag(circ)
return dag
| def check(candidate):
result = candidate()
assert type(result) == DAGCircuit
assert result.num_qubits() == 3
assert result.depth() == 3
assert dict(result.count_ops()) == {'h': 1, 'cx': 1, 'measure':1}
| bell_dag | basic |
qiskitHumanEval/27 | 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() -> DAGCircuit:
""" Generate a DAG circuit for 3-qubit Quantum Circuit which consists of H gate on q... |
q = QuantumRegister(3, "q")
c = ClassicalRegister(3, "c")
circ = QuantumCircuit(q, c)
circ.h(q[0])
circ.cx(q[0], q[1])
dag = circuit_to_dag(circ)
dag.apply_operation_back(HGate(), qargs=[q[0]])
return dag
| def check(candidate):
from qiskit.quantum_info import Statevector
from qiskit.converters import dag_to_circuit
result = candidate()
assert type(result) == DAGCircuit
assert result.num_qubits() == 3
last_node = result.op_nodes()[-1]
assert last_node.name == "h"
assert len(result.descendan... | apply_op_back | intermediate |
qiskitHumanEval/28 | 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()->Figure:
""" Prepare phi plus and phi minus bell states and visualize their results in a histo... |
phi_plus = QuantumCircuit(2)
phi_minus = QuantumCircuit(2)
phi_plus.h(0)
phi_plus.cx(0,1)
phi_minus.x(0)
phi_minus.h(0)
phi_minus.cx(0,1)
phi_plus.measure_all()
phi_minus.measure_all()
backend = AerSimulator()
sampler = Sampler(mode=backend)
result_phi_plus = sampler.run... | def check(candidate):
from matplotlib.patches import Rectangle
result = candidate()
assert isinstance(result, Figure)
gca = result.gca()
assert {xlabel.get_text() for xlabel in gca.get_xticklabels()} == {"00", "11"}
objs = gca.findobj(Rectangle)
assert len(objs) >= 4
counts = [obj.get_he... | visualize_bell_states | basic |
qiskitHumanEval/29 | 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() -> Figure:
""" Plot a ci... |
backend = FakeAthensV2()
bell = QuantumCircuit(2)
bell.h(0)
bell.cx(0,1)
pass_manager = generate_preset_pass_manager(optimization_level=1, backend=backend)
brisbane_bell = pass_manager.run(bell)
return (plot_circuit_layout(brisbane_bell, backend))
| def check(candidate):
result = candidate()
assert type(result) == Figure
| plot_circuit_layout_bell | intermediate |
qiskitHumanEval/30 | 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() -> Figure:
""" Plot a city_state for a bell circuit.
""" |
bell = QuantumCircuit(2)
bell.h(0)
bell.cx(0,1)
bell_state = Statevector(bell)
plot_state_city(bell_state)
return plot_state_city(bell_state)
| def check(candidate):
result = candidate()
assert type(result) == Figure
assert len(result.axes) == 2
| plot_circuit_layout_bell | basic |
qiskitHumanEval/31 | 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() -> Dict:
""" Run a Bell circuit on Qiskit Sampler and run the circuit on the Aer simulator with the seed set... |
qc = QuantumCircuit(2)
qc.h(0)
qc.cx(0,1)
qc.measure_all()
options = SamplerOptions()
options.simulator.seed_simulator=42
sampler = Sampler(mode=AerSimulator(), options=options)
job = sampler.run([qc])
result = job.result()[0].data.meas.get_counts()
return result
| def check(candidate):
result = candidate()
assert result == {"00": 521, "11": 503}
| sampler_qiskit | intermediate |
qiskitHumanEval/32 | 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() -> float64:
""" Run a Bell circuit on Qiskit Estimator and return expectation values for the bases II, XX, YY,... |
observable = SparsePauliOp(["II","XX","YY","ZZ"], coeffs=[1, 1, -1, 1])
qc = QuantumCircuit(2)
qc.h(0)
qc.cx(0,1)
estimator = Estimator(mode=AerSimulator())
job = estimator.run([(qc, observable)])
result = job.result()[0].data.evs.item()
return result
| def check(candidate):
result = candidate()
assert result == 4.0
| estimator_qiskit | intermediate |
qiskitHumanEval/33 | 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() -> List:
""" Generate two random quantum circuits, each with 2 qubits and a depth of 2, using seed values of 0 and 1 respecti... |
circuits = (
random_circuit(2, 2, seed=0, measure=True).decompose(reps=1),
random_circuit(2, 2, seed=1, measure=True).decompose(reps=1),
)
options = SamplerOptions()
options.simulator.seed_simulator=42
sampler = Sampler(mode=AerSimulator(), options=options)
job = sampler.run(cir... | def check(candidate):
result = candidate()
assert isinstance(result, list)
assert result == [{"01": 1024}, {"00": 552, "01": 472}]
| run_multiple_sampler | intermediate |
qiskitHumanEval/34 | 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 FakeCairoV2
from qiskit import QuantumCircuit
from qiskit.transpiler.preset_passmanagers import generate_preset_pass_manager
def ru... |
def create_bell_circuit(state):
"Helper function to create bell state"
qc = QuantumCircuit(2)
qc.h(0)
qc.cx(0, 1)
if state == "phi_minus":
qc.z(0)
elif state == "psi_plus":
qc.x(1)
elif state == "psi_minus'":
qc.x(1)
... | def check(candidate):
from numpy import isclose
jobs = candidate()
reference_data = {
'phi_plus': {'00': 0.10, '11': 0.10},
'phi_minus': {'00': 0.10, '11': 0.10},
'psi_plus': {'01': 0.10, '10': 0.10},
'psi_minus': {'01': 0.001, '10': 0.002}
}
assert isinstance(jobs, d... | run_jobs_on_batch | difficult |
qiskitHumanEval/35 | from qiskit.circuit.library import EfficientSU2
from qiskit.quantum_info import SparsePauliOp
import numpy as np
from qiskit_ibm_runtime import QiskitRuntimeService, Estimator, EstimatorOptions
from qiskit.primitives.primitive_job import PrimitiveJob
from qiskit_ibm_runtime.fake_provider import FakeCairoV2
from qiskit.... |
n_qubits = 5
reps = 2
circuit = EfficientSU2(n_qubits, entanglement="pairwise", reps=reps)
observable = SparsePauliOp.from_sparse_list([("Z", [-1], 1.0)], num_qubits=n_qubits)
# Generate random parameters
rng = np.random.default_rng(1234)
params = rng.uniform(-np.pi, np.pi, size=circu... | def check(candidate):
from numpy import isclose
job = candidate()
assert isinstance(job, PrimitiveJob)
assert job.job_id() is not None
result = job.result()
assert isclose(result[0].data.evs.item(), 0.33, atol=0.06)
| run_circuit_with_dd_trex | difficult |
qiskitHumanEval/36 | from qiskit import QuantumCircuit
def bv_function(s: str) -> QuantumCircuit:
""" Write a function to design a Bernstein-Vazirani oracle from a bitstring and return it.
""" |
n = len(s)
qc = QuantumCircuit(n + 1)
for index, bit in enumerate(reversed(s)):
if bit == "1":
qc.cx(index, n)
return qc
| 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)
assert Operator(result).equiv(Operat... | bv_function | intermediate |
qiskitHumanEval/37 | 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: str) -> [list, PrimitiveResult]:
""" Illustrate a Bernstein-Vazirani algorithm routine on Qiskit and run it using... |
qc = QuantumCircuit(len(s) + 1)
for index, bit in enumerate(reversed(s)):
if bit == "1":
qc.cx(index, len(s))
qc.measure_all()
backend = AerSimulator()
sampler = Sampler(mode=backend)
result= sampler.run([qc], shots=1).result()
bitstrings = result[0].data.meas.get_bitstr... | def check(candidate):
s = "1111"
result = candidate(s)
assert (type(result[0]) == list)
assert (len(result[0]) == result[1][0].data.meas.num_shots)
assert (type(result[1]) == PrimitiveResult)
| bv_algorithm | intermediate |
qiskitHumanEval/38 | from qiskit import QuantumCircuit
def create_quantum_circuit_based_h0_crz01_h1_cry10(theta):
""" 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 ... |
qc = QuantumCircuit(2)
qc.h(0)
qc.crz(theta,0,1)
qc.h(1)
qc.cry(theta,1,0)
return qc
| 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
assert data[0]==CircuitInstruc... | create_quantum_circuit_based_h0_crz01_h1_cry10 | basic |
qiskitHumanEval/39 | from qiskit import QuantumCircuit
from qiskit.quantum_info import Statevector
def create_uniform_superposition(n: int) -> QuantumCircuit:
""" Initialize a uniform superposition on n qubits and return statevector.
""" |
qc = QuantumCircuit(n)
qc.h(range(n))
return Statevector(qc)
| 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 round(state_fidelity(candidate(3), [1/sqrt(8)]*8),3)==1
| create_uniform_superposition | basic |
qiskitHumanEval/40 | 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: [complex])-> dict:
""" Initialize a non-trivial 3-qubit state for a gi... |
qc = QuantumCircuit(3)
qc.initialize(desired_vector, range(3))
qc.measure_all()
backend = AerSimulator()
options = SamplerOptions()
options.simulator.seed_simulator=42
sampler = Sampler(mode=backend,options=options)
result = sampler.run([qc]).result()
return result[0].data.meas.get_... | def check(candidate):
from math import sqrt
from qiskit.quantum_info import state_fidelity
desired_vector = [0.25j, 1 /sqrt(8)+0j, 0.25+0.25j, 0, 0,1 / sqrt(8) * (1+2j), 0.25+0j, 0]
result = candidate(desired_vector)
assert isinstance(result, dict)
assert result == {"101": 665, "010": 118, "000"... | init_random_3qubit | basic |
qiskitHumanEval/41 | from qiskit.quantum_info.operators import Operator, Pauli
import numpy as np
def compose_op() -> Operator:
""" Compose XZ with a 3-qubit identity operator using the Operator and the Pauli 'YX' class in Qiskit. Return the operator instance.
""" |
op = Operator(np.eye(2 ** 3))
YX = Operator(Pauli('YX'))
op.compose(YX, qargs=[0, 2], front=True)
return op
| 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)
| compose_op | basic |
qiskitHumanEval/42 | from qiskit.quantum_info.operators import Operator, Pauli
def combine_op() -> Operator:
""" Combine the following three operators XX YY ZZ as: 0.5 * (XX + YY - 3 * ZZ).
""" |
XX = Operator(Pauli('XX'))
YY = Operator(Pauli('YY'))
ZZ = Operator(Pauli('ZZ'))
op = 0.5 * (XX + YY - 3 * ZZ)
return op
| 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)
| combine_op | basic |
qiskitHumanEval/43 | 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()-> QuantumCircuit:
""" Instantiate a preset_passmanager using Qiskit using the least busy device available and optimzati... |
provider = QiskitRuntimeService()
backend = provider.least_busy()
pass_manager = generate_preset_pass_manager(optimization_level=3, backend=backend)
return pass_manager
| def check(candidate):
from qiskit.transpiler.passmanager import StagedPassManager
result = candidate()
assert(type(result) == StagedPassManager)
| generate_pass_manager_obj | basic |
qiskitHumanEval/44 | from qiskit import QuantumCircuit
def tensor_circuits() -> QuantumCircuit:
""" 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.
""" |
top = QuantumCircuit(1)
top.x(0)
bottom = QuantumCircuit(2)
bottom.cry(0.2, 0, 1)
tensored = bottom.tensor(top)
return tensored
| 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(Statevector.from_instruction(tensored)... | tensor_circuits | basic |
qiskitHumanEval/45 | from qiskit.quantum_info.random import random_clifford
def get_random_clifford(n_qubits):
""" Generate a random clifford circuit using the input n_qubit as number of qubits.
""" |
return random_clifford(num_qubits=n_qubits)
| def check(candidate):
from qiskit.quantum_info import Clifford
result = candidate(3)
assert result.num_qubits == 3
assert isinstance(result, Clifford)
| get_random_clifford | basic |
qiskitHumanEval/46 | 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):
""" Generate a random linear function circuit using the input parameters n_qubits and seed, and the random_invertible_binary_matri... |
return LinearFunction(random_invertible_binary_matrix(num_qubits=n_qubits, seed=seed))
| def check(candidate):
result = candidate(3,3)
assert result.num_qubits == 3
assert isinstance(result, LinearFunction)
| get_random_linear_function | basic |
qiskitHumanEval/47 | from qiskit import QuantumCircuit
from qiskit_aer import AerSimulator
from qiskit_ibm_runtime import Sampler
def random_coin_flip(samples: int)->dict:
""" 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 h... |
circuit = QuantumCircuit(1,1)
circuit.h(0)
circuit.measure_all()
backend = AerSimulator()
sampler = Sampler(mode=backend)
result = sampler.run([circuit], shots=samples).result()
counts = result[0].data.meas.get_counts()
return {'Heads' : counts['0'], 'Tails': counts['1']}
| 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']/samples, 1) == 0.5
| random_coin_flip | intermediate |
qiskitHumanEval/48 | from qiskit import QuantumCircuit
from qiskit_aer import AerSimulator
from qiskit_ibm_runtime import Sampler
def random_number_generator_unsigned_8bit(n: int)->[int]:
""" Write a function that generates n number of random 8-bit unsigned integers using a Quantum Circuit and outputs a list of integers.
""" |
circuit = QuantumCircuit(8)
circuit.h(range(8))
circuit.measure_all()
backend = AerSimulator()
sampler = Sampler(mode=backend)
result = sampler.run([circuit], shots=n).result()
samples = result[0].data.meas.get_bitstrings()
return [int(sample, 2) for sample in samples]
| 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
| random_number_generator_unsigned_8bit | intermediate |
qiskitHumanEval/49 | from qiskit import QuantumCircuit
def simple_elitzur_vaidman()->QuantumCircuit:
""" Return a simple Elitzur Vaidman bomb tester circuit.
""" |
circuit = QuantumCircuit(2)
circuit.h(0)
circuit.cx(0,1)
circuit.h(0)
return circuit
| 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.from_instruction(result).equiv(State... | simple_elitzur_vaidman | intermediate |
qiskitHumanEval/50 | from qiskit import QuantumCircuit
def remove_gate_in_position(circuit: QuantumCircuit, position: int):
""" Remove the gate in the input position for the given Quantum Circuit.
""" |
del circuit.data[position]
return circuit
| 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
| remove_gate_in_position | basic |
qiskitHumanEval/51 | from qiskit import QuantumRegister, ClassicalRegister, QuantumCircuit
from qiskit.circuit import Instruction
def quantum_teleportation_circuit(data: [Instruction])->QuantumCircuit:
""" Write a function to build a quantum teleportation circuit that takes a list of instructions as an argument to transfer the data fro... |
sender = QuantumRegister(1, "sender")
receiver = QuantumRegister(1, "receiver")
ancillary = QuantumRegister(1, "ancillary")
c_sender = ClassicalRegister(1, "c_sender")
c_receiver = ClassicalRegister(1, "c_receiver")
c_ancillary = ClassicalRegister(1, "c_ancillary")
circuit = QuantumCircuit(... | 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
result_x = candidate([XGate()])
backend = AerSimulator()
sampler = Sampler(mode=backend)
assert... | quantum_teleportation_circuit | intermediate |
qiskitHumanEval/52 | from qiskit import QuantumRegister, ClassicalRegister, QuantumCircuit
def send_bits(bitstring: str)->QuantumCircuit:
""" 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 h... |
sender = QuantumRegister(1, "sender")
receiver = QuantumRegister(1, "receiver")
measure = ClassicalRegister(2, "measure")
circuit = QuantumCircuit(sender, receiver, measure)
# Prepare ebit used for superdense coding
circuit.h(sender)
circuit.cx(sender, receiver)
circuit.barrier()
# ... | 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)
assert result_1.num_qubits == 2
assert result_1.count_ops()["x"... | send_bits | intermediate |
qiskitHumanEval/53 | from qiskit_aer import AerSimulator
from qiskit_ibm_runtime import Sampler
from qiskit.circuit.library import XOR
def xor_gate(a: int, b: int)->dict:
""" 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 b... |
circuit = XOR(8, a).compose(XOR(8, b))
circuit.measure_all()
backend = AerSimulator()
sampler = Sampler(mode=backend)
result = sampler.run([circuit.decompose()]).result()
return result[0].data.meas.get_counts()
| def check(candidate):
assert candidate(10, 20) == {"00011110": 1024}
assert candidate(61, 9) == {"00110100": 1024}
assert candidate(47, 8) == {"00100111": 1024}
| xor_gate | intermediate |
qiskitHumanEval/54 | from qiskit import QuantumRegister, ClassicalRegister, QuantumCircuit
from qiskit_aer import AerSimulator
from qiskit_ibm_runtime import Sampler
def and_gate(a: int, b: int)->dict:
""" 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 ... |
qr_a = QuantumRegister(3, "qr_a")
qr_b = QuantumRegister(3, "qr_b")
ancillary = QuantumRegister(3, "ancillary")
measure = ClassicalRegister(3, "measure")
circuit = QuantumCircuit(qr_a, qr_b, ancillary, measure)
a = format(a, '03b')
b = format(b, '03b')
for i in range(3):
if a[2-... | def check(candidate):
assert candidate(1, 2) == {'000': 1024}
assert candidate(6, 7) == {'110': 1024}
assert candidate(3, 5) == {'001': 1024}
| and_gate | intermediate |
qiskitHumanEval/55 | from qiskit import QuantumRegister, ClassicalRegister, QuantumCircuit
from qiskit_aer import AerSimulator
from qiskit_ibm_runtime import Sampler
def or_gate(a: int, b: int)->dict:
""" Given two 3-bit integers a and b, design a quantum circuit that acts as a classical OR gate. Simulate the circuit using Qiskit Sampl... |
qr_a = QuantumRegister(3, "qr_a")
qr_b = QuantumRegister(3, "qr_b")
ancillary = QuantumRegister(3, "ancillary")
measure = ClassicalRegister(3, "measure")
circuit = QuantumCircuit(qr_a, qr_b, ancillary, measure)
a = format(a, '03b')
b = format(b, '03b')
for i in range(3):
if a[2-... | def check(candidate):
assert candidate(1, 2) == {"011": 1024}
assert candidate(6, 7) == {"111": 1024}
assert candidate(0, 5) == {"101": 1024}
| or_gate | intermediate |
qiskitHumanEval/56 | from qiskit import QuantumCircuit
from qiskit_aer import AerSimulator
from qiskit_ibm_runtime import Sampler
def not_gate(a: int)->dict:
""" 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 coun... |
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()
sampler = Sampler(mode=backend)
result = sampler.run([circuit]).result()
return result[0].data.meas.get_counts()
| def check(candidate):
assert candidate(0) == {"11111111": 1024}
assert candidate(238) == {"00010001": 1024}
assert candidate(59) == {"11000100": 1024}
| not_gate | intermediate |
qiskitHumanEval/57 | from qiskit import QuantumCircuit
def create_swap_gate()->QuantumCircuit:
""" Design a SWAP gate using only CX gates.
""" |
circuit = QuantumCircuit(2)
circuit.cx(0,1)
circuit.cx(1,0)
circuit.cx(0,1)
return circuit
| 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}
assert Operator(result) == Operator(S... | create_swap_gate | intermediate |
qiskitHumanEval/58 | from qiskit import QuantumCircuit
from numpy import pi
def create_ch_gate()->QuantumCircuit:
""" Design a CH gate using CX and RY gates.
""" |
circuit = QuantumCircuit(2)
circuit.ry(pi/4, 1)
circuit.cx(0,1)
circuit.ry(-pi/4, 1)
return circuit
| 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()) == {'ry': 2, 'cx': 1}
assert Operator(result) == Ope... | create_ch_gate | intermediate |
qiskitHumanEval/59 | from qiskit import QuantumCircuit
def create_cz_gate()->QuantumCircuit:
""" Design a CZ gate using only H and CNOT gates and return the quantum circuit.
""" |
circuit = QuantumCircuit(2)
circuit.h(1)
circuit.cx(0,1)
circuit.h(1)
return circuit
| 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}
assert Operator(result) == Oper... | create_cz_gate | intermediate |
qiskitHumanEval/60 | from qiskit import QuantumCircuit
def create_cy_gate()->QuantumCircuit:
""" Design a CY gate using only one CX gate and any other single qubit gates.
""" |
circuit = QuantumCircuit(2)
circuit.sdg(1)
circuit.cx(0,1)
circuit.s(1)
return circuit
| 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 result.data:
op = gate.operati... | create_cy_gate | intermediate |
qiskitHumanEval/61 | from qiskit import QuantumRegister, QuantumCircuit, ClassicalRegister
def create_quantum_circuit_with_one_qubit_and_measure():
""" Build a Quantum Circuit by first creating one Quantum Register and one Classical Register and then perform measurement on it.
""" |
q = QuantumRegister(1, 'q')
c = ClassicalRegister(1, 'c')
qc = QuantumCircuit(q, c)
qc.measure(q, c)
return qc
| def check(candidate):
result = candidate()
assert result.depth() == 1
assert result.width() == 2
assert dict(result.count_ops()) == {'measure': 1}
| create_quantum_circuit_with_one_qubit_and_measure | basic |
qiskitHumanEval/62 | from qiskit import QuantumCircuit
def bb84_senders_circuit(state: [int], basis: [int])->QuantumCircuit:
""" Construct a BB84 protocol circuit for the sender, inputting both the states and the measured bases.
""" |
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
| 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, QuantumCircuit)
assert result.num... | bb84_senders_circuit | intermediate |
qiskitHumanEval/63 | 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: [int], circuit: QuantumCircuit)->str:
""" Write a function to generate the key from the circuit and the sender's basis generated ... |
n = len(senders_basis)
receivers_basis = randint(2, size=n)
for i in range(n):
if receivers_basis[i]:
circuit.h(i)
circuit.measure_all()
backend = AerSimulator()
sampler = Sampler(mode=backend)
result = sampler.run([circuit.reverse_bits()], shots=1).result()
count= r... | 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])
result = candidate(basis, circuit)
assert result == "1"
| bb84_circuit_generate_key | difficult |
qiskitHumanEval/64 | from qiskit import QuantumCircuit, QuantumRegister, ClassicalRegister
def simons_algorithm(s: str)->QuantumCircuit:
""" 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 ma... |
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)
circuit.barrier()
circuit.cx(q_reg1, q_reg2)
if "1" in s:
i = s.find("1")
... | 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):
return sum(int(a) * int(b) for a, b in zip(vec1, vec2)) % 2
backen... | simons_algorithm | intermediate |
qiskitHumanEval/65 | from qiskit import QuantumCircuit
from numpy import pi
def QFT(n: int)->QuantumCircuit:
""" Design a Quantum Fourier Transform circuit for n qubits using basic Quantum gates.
""" |
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 circuit (without swaps)"""
if n == 0:
return ci... | 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.data:
op = gate.operation
assert op.num_qu... | QFT | intermediate |
qiskitHumanEval/66 | from qiskit import QuantumCircuit
from numpy import arccos, sqrt
def w_state()->QuantumCircuit:
""" Generate a Quantum Circuit for a W state and measure it.
""" |
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
| 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, QuantumCircuit)
assert result.num_qubits == 3
backend = AerSimulator(... | w_state | intermediate |
qiskitHumanEval/67 | from qiskit import QuantumCircuit
from numpy import pi
def chsh_circuit(alice: int, bob: int)->QuantumCircuit:
""" Design a CHSH circuit that takes bits of Alice and Bob as input and return the Quantum Circuit after measuring.
""" |
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:
qc.ry(pi / 4, 1)
qc.measure(1, 1)
return qc
| 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(set(result.count_ops().items()))
| chsh_circuit | intermediate |
qiskitHumanEval/68 | 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: bool)->(float, float, float):
""" Design a Zeno Elitzur Vaidman Bomb Tester circuit which takes the boolean if the bomb is live and output... |
live_predictions = dud_predictions = detonations = 0
shots = 1024
cycles = 25
e = pi/cycles
measurements = cycles + 1 if bomb_live else 1
circuit = QuantumCircuit(1, measurements)
for i in range(cycles):
circuit.ry(e, 0)
if bomb_live:
circuit.measure(0, i)
ci... | def check(candidate):
result = candidate(True)
assert isinstance(result, tuple) and len(result) == 3
assert result[0] >= 0.85 and result[1] <= 0.03 and result[2] <= 0.12
assert candidate(False) == (0.0, 1.0, 0.0)
| zeno_elitzur_vaidman_bomb_tester | difficult |
qiskitHumanEval/69 | from qiskit import QuantumCircuit
def create_quantum_circuit_based_h0_cs01_h1_csdg10():
""" 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.
""" |
qc = QuantumCircuit(2)
qc.h(0)
qc.cs(0,1)
qc.h(1)
qc.csdg(1,0)
return qc
| 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}
| create_quantum_circuit_based_h0_cs01_h1_csdg10 | basic |
qiskitHumanEval/70 | from qiskit import QuantumCircuit
def create_quantum_circuit_based_h0_cswap012_h1_csdg10():
""" 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 ... |
qc = QuantumCircuit(3)
qc.h(0)
qc.cswap(0,1,2)
qc.h(1)
qc.csdg(1,0)
return qc
| 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}
| create_quantum_circuit_based_h0_cswap012_h1_csdg10 | basic |
qiskitHumanEval/71 | from qiskit import QuantumCircuit
def create_quantum_circuit_based_h0_csx01_h1():
""" 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.
""" |
qc = QuantumCircuit(3)
qc.h(0)
qc.csx(0,1)
qc.h(1)
return qc
| 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}
| create_quantum_circuit_based_h0_csx01_h1 | basic |
qiskitHumanEval/72 | import contextlib
from qiskit import QuantumCircuit
from qiskit.circuit import Gate
def gate_if_clbits(
circuit: QuantumCircuit, gate: Gate, qubits: list[int], condition_clbits: list[int]
) -> None:
""" Apply `gate` to qubits with indices `qubits`, conditioned on all `condition_clbits` being 1.
""" |
with contextlib.ExitStack() as stack:
for index in condition_clbits:
stack.enter_context(circuit.if_test((index, 1)))
circuit.append(gate, qubits)
| 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])
qc.measure_all()
sampler = Sampler(mode=AerSimulator())
result = sample... | gate_if_clbits | intermediate |
qiskitHumanEval/73 | from qiskit import QuantumCircuit
def x_measurement(circuit: QuantumCircuit, qubit: int, clbit: int) -> None:
""" Add an X-basis measurement on qubit at index `qubit`, storing the result to classical bit `clbit`.
""" |
circuit.h(qubit)
circuit.measure(qubit, clbit)
| 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
| x_measurement | basic |
qiskitHumanEval/74 | from qiskit import QuantumCircuit
from qiskit.circuit.library import Barrier
def split_circuit_at_barriers(circuit: QuantumCircuit) -> list[QuantumCircuit]:
""" Split `circuit` at each barrier operation. Do not include barriers in the output circuits.
""" |
output = []
new_circuit = circuit.copy_empty_like()
for inst in circuit.data:
if isinstance(inst.operation, Barrier):
output.append(new_circuit)
new_circuit = circuit.copy_empty_like()
continue
new_circuit.data.append(inst)
output.append(new_circuit)
... | 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 circuit, expected_length in zip(circuits, [1, 4, 0, 1]):
assert len(circu... | split_circuit_at_barriers | intermediate |
qiskitHumanEval/75 | from qiskit import QuantumCircuit
from qiskit.primitives import StatevectorSampler
def circuit_to_bools(circuit: QuantumCircuit) -> list[bool]:
""" 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.
""" |
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_clbits):
# Use bit-masking to get bits from `int`
bit = bool(2 ** (bit_index) & measurement_int)
... | 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 candidate(qc) == [False] * 3 + [True] * 2
# 111011111
qc = QuantumCircuit(9)
... | circuit_to_bools | intermediate |
qiskitHumanEval/76 | 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() -> TransformationPass:
""" Return a transpiler pass that replaces all non-controlled Z-gates with H-X-H... |
class HXHPass(TransformationPass):
def run(
self,
dag: DAGCircuit,
) -> DAGCircuit:
for node in dag.op_nodes():
if not isinstance(node.op, ZGate):
continue
# Create HXH gate sequence
hxh_dag = DA... | def check(candidate):
from qiskit.transpiler import PassManager
from qiskit import QuantumCircuit
hxh_pass = candidate()
# Be lenient and accept both class and instance of class
if not isinstance(hxh_pass, TransformationPass):
hxh_pass = hxh_pass()
assert isinstance(hxh_pass, Transformat... | create_hxh_pass | intermediate |
qiskitHumanEval/77 | import math
from qiskit import QuantumCircuit
def circuit_from_probability_dist(probability_dist: dict[int, float]) -> QuantumCircuit:
""" Given a distribution as a dictionary of the form { measurement: probability }, return a quantum circuit that produces that distribution.
""" |
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(math.sqrt(prob))
qc = QuantumCircuit(num_qubits)
qc.prepare_state(amplitudes, range(num_qu... | 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 = Statevector(circuit).probabilities()
for ba... | circuit_from_probability_dist | intermediate |
qiskitHumanEval/78 | from qiskit import QuantumCircuit
from qiskit.circuit.library import QFT
def qft_no_swaps(num_qubits: int) -> QuantumCircuit:
""" Return an inverse quantum Fourier transform circuit without the swap gates.
""" |
qft = QFT(num_qubits=num_qubits, do_swaps=False, inverse=True)
return 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) == Operator(response)
| qft_no_swaps | intermediate |
qiskitHumanEval/79 | from qiskit import QuantumCircuit
def count_instructions(circuit: QuantumCircuit) -> int:
""" Return the total number of instructions in the circuit.
""" |
return len(circuit.data)
| 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
| count_instructions | basic |
qiskitHumanEval/80 | from qiskit import QuantumCircuit
from qiskit.circuit import Gate
def count_gates(circuit: QuantumCircuit) -> int:
""" Return the total number of unitary gates in the circuit.
""" |
count = 0
for inst in circuit.data:
if isinstance(inst.operation, Gate):
count += 1
return count
| 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
| count_gates | basic |
qiskitHumanEval/81 | from qiskit import QuantumCircuit
def convert_qasm_string_to_quantum_circuit() -> QuantumCircuit:
""" 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.
""" |
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
| 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
| convert_qasm_string_to_quantum_circuit | basic |
qiskitHumanEval/82 | from qiskit import QuantumCircuit
from qiskit import qpy
def create_binary_serialization():
""" Create a file containing the binary serialization of a Phi plus Bell state quantum circuit and write it as 'bell.qpy' in binary mode.
""" |
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)
| 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"))/sqrt(2)
assert Statevector.from_instruction(data) == be... | create_binary_serialization | basic |
qiskitHumanEval/83 | from qiskit import QuantumCircuit
from qiskit.quantum_info import DensityMatrix, concurrence
def calculate_bell_state_properties():
""" 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.
""" |
qc = QuantumCircuit(2, name='Bell')
qc.h(0)
qc.cx(0, 1)
rho = DensityMatrix.from_instruction(qc)
concur = concurrence(rho)
return rho, concur
| 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.testing.assert_array_almost_equal(DensityMatrix, expected_rho, decimal=5, err_msg='Density m... | calculate_bell_state_properties | basic |
qiskitHumanEval/84 | from qiskit import pulse
from qiskit_ibm_runtime.fake_provider import FakeBelemV2
from qiskit.pulse import DriveChannel, Gaussian
def define_gaussian_pulse_schedule():
""" Using Qiskit Pulse, create a Gaussian pulse schedule on drive channel 0 with a duration of 128 and name this schedule 'gaussian_pulse_schedule'.... |
backend = FakeBelemV2()
gaussian_pulse = Gaussian(duration=128, amp=0.1, sigma=16)
d0 = DriveChannel(0)
with pulse.build(backend=backend, name='gaussian_pulse_schedule') as gaussian_pulse_schedule:
pulse.play(gaussian_pulse, d0)
return gaussian_pulse_schedule
| def check(candidate):
gaussian_pulse_schedule = candidate()
assert gaussian_pulse_schedule.name == 'gaussian_pulse_schedule'
assert gaussian_pulse_schedule.duration == 128
| define_gaussian_pulse_schedule | intermediate |
qiskitHumanEval/85 | from qiskit import QuantumCircuit
import qiskit.qasm2
def convert_quantum_circuit_to_qasm_string(circuit: QuantumCircuit) -> str:
""" Given a QuantumCircuit, convert it into qasm2 string and return it.
""" |
qasm_str = qiskit.qasm2.dumps(circuit)
return qasm_str
| 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) == Statevector.from_instruction(qc)
| convert_quantum_circuit_to_qasm_string | basic |
qiskitHumanEval/86 | from qiskit import pulse
from qiskit_ibm_runtime.fake_provider import FakeBelemV2
from qiskit.pulse import DriveChannel, Constant, Play, Delay
def pulse_schedule_with_constant_and_delay():
""" Using Qiskit Pulse, create a schedule with a constant pulse on drive channel 0, featuring a duration of 160 and an amplitud... |
backend = FakeBelemV2()
constant_pulse = Constant(duration=160, amp=0.1)
drive_chan = DriveChannel(0)
with pulse.build(backend=backend, name="pulse_schedule_with_constant_and_delay") as pulse_sched:
pulse.play(constant_pulse, drive_chan)
pulse.delay(400, drive_chan)
pulse.play(c... | def check(candidate):
pulse_sched = candidate()
constant_pulses = 0
delays = 0
for _, inst in pulse_sched.instructions:
if isinstance(inst, Play):
if isinstance(inst.pulse, Constant):
constant_pulses += 1
elif isinstance(inst, Delay):
delays += 1
... | pulse_schedule_with_constant_and_delay | intermediate |
qiskitHumanEval/87 | from qiskit import QuantumCircuit
def quantum_circuit_with_delay():
""" 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.
""" |
qc = QuantumCircuit(1)
qc.h(0)
delay_duration = 100
qc.delay(delay_duration, 0, unit="dt")
qc.h(0)
return qc
| 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]==CircuitInstruction(HGate(), [qr[0]], [])
... | quantum_circuit_with_delay | intermediate |
qiskitHumanEval/88 | from qiskit import QuantumCircuit, ClassicalRegister, QuantumRegister
from qiskit.circuit import IfElseOp
def create_conditional_circuit():
""" 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-q... |
qr = QuantumRegister(1, 'q')
cr = ClassicalRegister(1, 'c')
circuit = QuantumCircuit(qr, cr)
circuit.h(qr[0])
circuit.measure(qr[0], cr[0])
true_body = QuantumCircuit(qr, cr)
true_body.z(qr[0])
false_body = QuantumCircuit(qr, cr)
false_body.x(qr[0])
if_else_gate = IfElseOp((cr, ... | 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_ibm_runtime import Sampler
qr = QuantumRegister(1, name="q")
circuit = candidate()
data = circui... | create_conditional_circuit | intermediate |
qiskitHumanEval/89 | from qiskit.circuit.library import HGate
from qiskit import QuantumCircuit, QuantumRegister
def create_controlled_hgate()->QuantumCircuit:
""" 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.
... |
qr = QuantumRegister(3)
qc = QuantumCircuit(qr)
c3h_gate = HGate().control(2)
qc.append(c3h_gate, qr)
return qc
| 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(c3h_gate, solution_register)
qc = candidate()
assert Operator(qc).equiv(solution_ci... | create_controlled_hgate | basic |
qiskitHumanEval/90 | from qiskit import QuantumCircuit
def create_custom_controlled()-> QuantumCircuit:
""" 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 t... |
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
| 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).equiv(candidate_circuit)
| create_custom_controlled | basic |
qiskitHumanEval/91 | from qiskit import QuantumCircuit
from qiskit.converters import circuit_to_instruction
def convert_circuit_to_instruction():
""" Create a circuit that produces a phi plus bell state with name bell_instruction and convert it into a quantum 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
| 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, 1])
assert instruction.definition == circ
| convert_circuit_to_instruction | basic |
qiskitHumanEval/92 | from qiskit import QuantumCircuit
from qiskit.quantum_info import StabilizerState
def calculate_stabilizer_state_info():
""" 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.
""" |
qc = QuantumCircuit(2)
qc.h(0)
qc.cx(0, 1)
stab = StabilizerState(qc)
probabilities_dict = stab.probabilities_dict()
return stab, probabilities_dict
| 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(2)
qc.h(0)
qc.cx(0, 1)
new_stab = StabilizerState(qc)
assert stab.... | calculate_stabilizer_state_info | basic |
qiskitHumanEval/93 | from qiskit.synthesis import synth_clifford_full
from qiskit.quantum_info.random import random_clifford
def synthesize_clifford_circuit(n_qubits:int):
""" 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 re... |
qc = random_clifford(n_qubits, seed=1234)
synthesized_qc = synth_clifford_full(qc)
return synthesized_qc
| 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 Operator(synthesized_qc) == Operator(qc)
| synthesize_clifford_circuit | basic |
qiskitHumanEval/94 | from qiskit import QuantumCircuit
import qiskit.qasm3
def convert_quantum_circuit_to_qasm_string(circuit: QuantumCircuit) -> str:
""" Given a Quantum Circuit as the argument, convert it into qasm3 string and return it.
""" |
qasm_str = qiskit.qasm3.dumps(circuit)
return qasm_str
| 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 not match circuit"
| convert_quantum_circuit_to_qasm_string | basic |
qiskitHumanEval/95 | from qiskit import QuantumCircuit
from qiskit.transpiler.passes import RemoveBarriers
def remove_barrier(circuit: QuantumCircuit):
""" For a given Quantum Circuit remove all the barriers from it and return.
""" |
return RemoveBarriers()(circuit)
| 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.data:
assert inst.operation.name != 'barrier'
assert Operator(circuit).equiv... | remove_barrier | basic |
qiskitHumanEval/96 | 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() -> dict:
""" Create the ... |
backend = FakeKyoto()
qc = QuantumCircuit(2)
qc.h(0)
qc.cx(0, 1)
qc.measure_all()
pass_manager = generate_preset_pass_manager(optimization_level=1, backend=backend)
isa_circuit = pass_manager.run(qc)
options = SamplerOptions()
options.simulator.seed_simulator=42
sampler = Sample... | def check(candidate):
from qiskit.quantum_info import hellinger_fidelity
counts_can = candidate()
backend = FakeKyoto()
qc = QuantumCircuit(2)
qc.h(0)
qc.cx(0, 1)
qc.measure_all()
pass_manager = generate_preset_pass_manager(optimization_level=1, backend=backend)
isa_circuit = pass_ma... | bell_state_noisy | basic |
qiskitHumanEval/97 | 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: Union[FakeBackendV2, IBMBackend]
) -> list:
""" Return the two qubit connections for any input backend of type FakeBackendV2, IBMBackend.
... |
if isinstance(backend, FakeBackendV2):
return backend.coupling_map
return backend.configuration().coupling_map
| def check(candidate):
from qiskit_ibm_runtime.fake_provider import FakeKyoto
from qiskit_ibm_runtime import QiskitRuntimeService
backend_v2 = FakeKyoto()
backend_ser = QiskitRuntimeService().least_busy()
connections_can_v2 = candidate(backend_v2)
connections_exp_v2 = backend_v2.coupling_map
... | two_qubit_conections | intermediate |
qiskitHumanEval/98 | 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: Union[IBMBackend, FakeBackendV2])-> float:
""" Return the minimum readout error of any input backend of type FakeB... |
error_list = []
if issubclass(type(backend), FakeBackendV2):
for qubits in range(backend.num_qubits):
error_list.append(backend.target["measure"][(qubits,)].error)
else:
for qubits in range(backend.configuration().num_qubits):
error_list.append(backend.properties... | def check(candidate):
from qiskit_ibm_runtime.fake_provider import FakeKyoto
from qiskit_ibm_runtime import QiskitRuntimeService
backend_v2 = FakeKyoto()
error_can_v2 = candidate(backend_v2)
error_list_v2 = []
for qubits in range(backend_v2.num_qubits):
error_list_v2.append(backend_v2.ta... | qubit_with_least_readout_error | basic |
qiskitHumanEval/99 | from qiskit.circuit import Parameter, QuantumCircuit
def remove_unassigned_parameterized_gates(circuit: QuantumCircuit) -> QuantumCircuit:
""" Remove all the gates with unassigned parameters from the given 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:
instr, qargs, cargs = instruction.operation, instruction.qubits, instruction.clbits
if not (... | 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(circ)
assert isinstance(circ_can, QuantumCircuit),... | remove_unassigned_parameterized_gates | basic |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.