Qiskit/qiskit_humaneval huggingface dataset:
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
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,
    and conditionally apply an X gate to the fourth qubit based on the XOR of the three classical bits. Finally, measure the fourth qubit into another classical register.
    """
    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])

    return circ


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 == 4
    assert any(instr.operation.name == "if_else" and instr.operation.num_qubits == 1 and instr.operation.num_clbits == 3 for instr in circ_res.data)
    
    sim = AerSimulator()
    options = SamplerOptions()
    options.simulator.seed_simulator=17
    sampler = Sampler(mode=sim, options=options)
    counts = sampler.run([circ_res], shots=1024).result()[0].data.c.get_counts()
    for outcome, _ in counts.items():
        qubit_states = outcome[::-1]
        q3_state = int(qubit_states[3])
        q0 = int(qubit_states[0])
        q1 = int(qubit_states[1])
        q2 = int(qubit_states[2])
        expected_q3_state = (q0 ^ q1 ^ q2)
        assert q3_state == expected_q3_state
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 corresponding error rate as a tuple. If the backend doesn't support the RZ gate, return None.
    """
    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"][0])
    max_rz_error = rz_props[qubit_pair]["gate_error"][0]
    return (qubit_pair, max_rz_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) == 1
    assert all(isinstance(qubit, int) for qubit in max_rz_error_pair)
    assert max_rz_error_rate >= 0 and max_rz_error_rate <= 1

    backend_properties = backend.properties()
    rz_props = backend_properties.gate_property("rz")
    expected_max_rz_error_pair = max(rz_props, key=lambda x: rz_props[x]["gate_error"][0])
    expected_max_rz_error_rate = rz_props[expected_max_rz_error_pair]["gate_error"][0]
    assert (expected_max_rz_error_pair, expected_max_rz_error_rate) == (max_rz_error_pair, max_rz_error_rate)
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
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 dictionary must have the following keys: 'num_qubits' (the number of qubits), 'coupling_map' 
    (the coupling map of the backend), and 'supported_instructions' (the supported instructions of the backend).
    """
    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 binfo_dict["supported_instructions"] == backend_config.supported_instructions
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 3 qubits, depth of 2 and measure set to True; using the random_circuit Qiskit function, with seed 17. Then use a 
    preset pass manager to optimize these circuits with an optimization level of 1, the backend for the pass manager should be FakeManilaV2, and set the seed value 
    to 1. Partition these optimized circuits into batches of 3 circuits each, and execute these batches using Qiskit Runtime's Batch mode, and return a list containing 
    the measurement outcome for each batch. For the execution of each batch set the seed to 42 for the sampler primitive.
    """
    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), batch_size)]
    sampler_options = {"simulator": {"seed_simulator": 42}}
    with Batch(backend=fake_manila):
        sampler = Sampler(mode=fake_manila, options=sampler_options)
        results = []
        for partition in partitions:
            job = sampler.run(partition)
            results.append(job.result()[0].data.c.get_counts())
    return results


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}
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=None)
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 backend's name, number of qubits, and the list of supported instruction names.
    Ensure that the list of dictionaries is sorted by the backend name.
    """
    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 = sorted(backend_info, key=lambda x: x["backend_name"])
    return 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": b.num_qubits, "instructions": b.operation_names})        
    sorted_backend_info_expected = sorted(backend_info, key=lambda x: x["backend_name"])
    assert sorted_backend_info_expected == result
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 erroneously read as 1. For all other qubits, a readout of 1 has a 3% 
    probability of being erroneously read as 0, and a readout of 0 has a 2% probability of being erroneously read as 1.
    """
    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)

    p0given1_q0 = 0.2
    p1given0_q0 = 0.3
    readout_error_q0 = ReadoutError(
        [
            [1 - p1given0_q0, p1given0_q0],
            [p0given1_q0, 1 - p0given1_q0],
        ]
    )
    noise_model.add_readout_error(readout_error_q0, [0])

    return noise_model


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]
    assert qubit0_error["gate_qubits"][0][0] == 0
    assert qubit0_error["probabilities"] == [[0.7, 0.3], [0.2, 0.8]]
    
    assert len(result.to_dict()["errors"]) == 2
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 matrix is not within tolerance"
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"
        assert entanglement_of_formation(item) >= tol , " The entanglement of formation is not within tolerance"
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"
        assert mutual_information(item) >= tol, "The mutual information is not above given value"
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,2), "The dimension of the first subsystem doesn't match"
        assert item[2].dims() == (2,2), "The dimension of the second subsystem doesn't match"
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 probability vector is not 16"
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 = SparsePauliOp(random_pauli(num_qubits))
        anti_commutator_value = anti_commutator(pauli, random_pauli_value)
        if is_multiple_of_identity(anti_commutator_value.to_matrix()):
            anticommutator_list.append(random_pauli_value)
    return anticommutator_list


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 = SparsePauliOp(["XI"])
    can_anticommutators = candidate(test_pauli)
    assert len(can_anticommutators) == 10, "The number of anticommutators is not 10"
    for _,item in enumerate(can_anticommutators):
        assert is_multiple_of_identity(anti_commutator(item, test_pauli).to_matrix()), "The operator doesn't anticommute with the given pauli operator"
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"
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 fidelity of the returned pairs is less than 0.9"
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"
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(candidate_op), "The circuit doesn't match with the inverse QFT circuit"
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 PassManager for the least busy backend available.
    """
    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)
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 Operator(solution) == Operator(expected)
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 coupling map, but don't transform any gates.
    """
    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_ops.pop("swap", None)

        mapped_qc = candidate(qc, backend)

        check_map = CheckMap(coupling_map=backend.coupling_map)
        dag = circuit_to_dag(mapped_qc)
        check_map.run(dag)
        assert check_map.property_set["is_swap_mapped"]

        mapped_ops = mapped_qc.count_ops()
        mapped_ops.pop("swap", None)

        # We convert to set for comparison to ignore dictionary ordering
        assert set(original_ops.items()) == set(mapped_ops.items())
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_array) == expected