Qiskit/qiskit_humaneval huggingface dataset:
from qiskit_ibm_runtime.fake_provider import FakeOsaka, FakeSherbrooke, FakeBrisbane
from qiskit.transpiler.preset_passmanagers import generate_preset_pass_manager
from qiskit.circuit.library import QFT
def backend_with_lowest_complexity():
    """ Transpile the 4-qubit QFT circuit using preset passmanager with optimization level 3 and seed transpiler = 1234 in FakeOsaka, FakeSherbrooke and FakeBrisbane. Compute the cost of the instructions by penalizing the two qubit gate with a cost of 5, rz gates with a cost 1 and other gates with a cost 2 and return the value of the highest cost among these backends.
    """
    qc = QFT(4)
    backends = [FakeOsaka(), FakeSherbrooke(), FakeBrisbane()]
    complexity_dict = {}
    for backend in backends:
        pm = generate_preset_pass_manager(
            optimization_level=3, seed_transpiler=1234, backend=backend
        )
        data = pm.run(qc).data
        complexity = 0
        for instruc in data:
            if instruc.operation.num_qubits == 2:
                complexity += 5
            elif instruc.operation.name == "rz":
                complexity += 1
            else:
                complexity += 2
        complexity_dict[backend.name] = complexity
    return complexity_dict[max(complexity_dict, key=complexity_dict.get)]


def check(candidate):
    complexity_can = candidate()
    complexity_exp = 211
    assert complexity_can == complexity_exp
from qiskit import QuantumCircuit
from qiskit.quantum_info import CNOTDihedral
def initialize_cnot_dihedral() -> CNOTDihedral:
    """ Initialize a CNOTDihedral element from a QuantumCircuit consist of 2-qubits with cx gate on qubit 0 and 1 and t gate on qubit 0 and return.
    """
    circ = QuantumCircuit(2)
    # Apply gates
    circ.cx(0, 1)
    circ.t(0)
    elem = CNOTDihedral(circ)

    return elem


def check(candidate):
    result = candidate()
    assert isinstance(result, CNOTDihedral), f'Expected result to be CNOTDihedral, but got {type(result)}'
    assert result.linear.tolist() == [[1, 0], [1, 1]]
    assert str(result.poly) == "0 + x_0"
    assert result.shift.tolist() == [0, 0]
from qiskit import QuantumCircuit
from qiskit.quantum_info import CNOTDihedral
def compose_cnot_dihedral() -> CNOTDihedral:
    """ Create two Quantum Circuits of 2 qubits. First quantum circuit should have a cx gate on qubits 0 and 1 and a T gate on qubit 0. The second one is the same but with an additional X gate on qubit 1. Convert the two quantum circuits into CNOTDihedral elements and return the composed circuit.
    """
    circ1 = QuantumCircuit(2)
    # Apply gates
    circ1.cx(0, 1)
    circ1.t(0)
    elem1 = CNOTDihedral(circ1)
    circ2 = circ1.copy()
    circ2.x(1)
    elem2 = CNOTDihedral(circ2)
    composed_elem = elem1.compose(elem2)
    return composed_elem


def check(candidate):
    result = candidate()
    assert isinstance(result, CNOTDihedral), f'Expected result to be CNOTDihedral, but got {type(result)}'
    assert result.linear.tolist() == [[1, 0], [0, 1]]
    assert str(result.poly) == "0 + 2*x_0"
    assert list(result.shift) == [0, 1]
from qiskit.quantum_info import ScalarOp
def compose_scalar_ops() -> ScalarOp:
    """ Create two ScalarOp objects with dimension 2 and coefficient 2, compose them together, and return the resulting ScalarOp.
    """
    op1 = ScalarOp(2, 2)
    op2 = ScalarOp(2, 2)
    composed_op = op1.compose(op2)
    return composed_op


def check(candidate):
    result = candidate()
    assert isinstance(result, ScalarOp), f'Expected result to be ScalarOp, but got {type(result)}'
    assert result.coeff == 4
    assert result.input_dims() == (2,)
from qiskit.quantum_info import Choi
import numpy as np
def initialize_adjoint_and_compose(data1: np.ndarray, data2: np.ndarray) -> (Choi, Choi, Choi):
    """ Initialize Choi matrices for the given data1 and data2 as inputs. Compute data1 adjoint, and then return the data1 Choi matrix, its adjoint and the composed choi matrices in order.
    """
    choi1 = Choi(data1)
    choi2 = Choi(data2)
    adjoint_choi1 = choi1.adjoint()
    composed_choi = choi1.compose(choi2)
    return choi1, adjoint_choi1, composed_choi


def check(candidate):
    data = np.eye(4)
    choi, adjoint_choi, composed_choi = candidate(data, data)
    assert isinstance(choi, Choi), f'Expected choi to be Choi, but got {type(choi)}'
    assert choi.dim == (2, 2), f'Expected dimensions to be (2, 2), but got {choi.dim}'
    assert isinstance(adjoint_choi, Choi), f'Expected adjoint_choi to be Choi, but got {type(adjoint_choi)}'
    assert isinstance(composed_choi, Choi), f'Expected composed_choi to be Choi, but got {type(composed_choi)}'
    expected_adjoint_data = data.conj().T
    assert np.allclose(adjoint_choi.data, expected_adjoint_data), f'Expected adjoint data to be {expected_adjoint_data}, but got {adjoint_choi.data}'
from qiskit.circuit import QuantumCircuit, Parameter
def circuit()-> QuantumCircuit:
    """ Create a parameterized quantum circuit using minimum resources whose statevector output cover the equatorial plane of the surface of the bloch sphere.
    """
    qc = QuantumCircuit(1)
    qc.h(0)
    theta = Parameter('th')
    qc.rz(theta,0)
    return qc
    

def check(candidate):
    import numpy as np
    from qiskit.quantum_info import Statevector
    def statevector_to_bloch_angles(state_vector):
        alpha = state_vector[0]
        beta = state_vector[1]
        norm = np.sqrt(np.abs(alpha)**2 + np.abs(beta)**2)
        alpha = alpha / norm
        beta = beta / norm
        theta = 2 * np.arccos(np.abs(alpha))
        phi = np.angle(beta) - np.angle(alpha)
        phi = (phi + 2 * np.pi) % (2 * np.pi)
        return theta, phi
    error = 0.000001
    for i in range(1000):
        qc = candidate()
        num_params = qc.num_parameters
        qc.assign_parameters(np.random.randn(num_params), inplace=True)
        sv = Statevector(qc)
        theta, phi = statevector_to_bloch_angles(sv)
        assert np.pi/2 - error <= theta <= np.pi/2 + error
from qiskit import QuantumCircuit
from qiskit.quantum_info import random_clifford, Operator
def equivalent_clifford_circuit(circuit: QuantumCircuit,n: int)->list:
    """ Given a clifford circuit return a list of n random clifford circuits which are equivalent to the given circuit up to a relative and absolute tolerance of 0.4.
    """
    op_or = Operator(circuit)
    num_qubits = circuit.num_qubits
    qc_list = []
    counter = 0
    while counter< n:
        qc = random_clifford(num_qubits).to_circuit()
        op_qc = Operator(qc)
        if op_qc.equiv(op_or, rtol = 0.4, atol = 0.4) == True:
            counter += 1
            qc_list.append(qc)
    return qc_list


def check(candidate):
    from qiskit.quantum_info import Clifford
    qc_comp = random_clifford(5).to_circuit()
    op_comp = Operator(qc_comp)
    can_circ_list = candidate(qc_comp, 10)
    for item in can_circ_list:
        assert Operator(item).equiv(op_comp, rtol = 0.4, atol = 0.4)
        try:
            Clifford(item)
        except Exception as err:
            raise AssertionError("The circuit is not a Clifford circuit.") from err
from qiskit.circuit import QuantumCircuit, Parameter
def circuit():
    """ Return an ansatz to create a quantum dataset of pure states distributed equally across the bloch sphere. Use minimum number of gates in the ansatz.
    """
    qc = QuantumCircuit(1)
    p1 = Parameter("p1")
    p2 = Parameter("p2")
    qc.rx(p1,0)
    qc.ry(p2,0)
    return qc


def check(candidate):
    assert candidate().num_parameters >= 2 , "The circuit doesn't cover the bloch sphere."
    assert candidate().num_parameters <= 5 , "The circuit is too long"
from qiskit.quantum_info import Operator
from qiskit.circuit.library import PauliEvolutionGate
from qiskit.synthesis import LieTrotter
from qiskit import QuantumCircuit
from qiskit.quantum_info import Pauli, SparsePauliOp
def create_product_formula_circuit(pauli_strings: list, times: list, order: int, reps: int) -> QuantumCircuit:
    """ Create a quantum circuit using LieTrotter for a list of Pauli strings and times. Each Pauli string is associated with a corresponding time in the 'times' list. The function should return the resulting QuantumCircuit.
    """
    qc = QuantumCircuit(len(pauli_strings[0]))
    synthesizer = LieTrotter(reps=reps)
    for pauli_string, time in zip(pauli_strings, times):
        pauli = Pauli(pauli_string)
        hamiltonian = SparsePauliOp(pauli)
        evolution_gate = PauliEvolutionGate(hamiltonian, time)
        synthesized_circuit = synthesizer.synthesize(evolution_gate)
        qc.append(synthesized_circuit.to_gate(), range(len(pauli_string)))
    return qc


def check(candidate):
    pauli_strings = ["X", "Y", "Z"]
    times = [1.0, 2.0, 3.0]
    order = 2
    reps = 1

    def create_solution_circuit(pauli_strings, times, order, reps):
        qc = QuantumCircuit(len(pauli_strings[0]))
        synthesizer = LieTrotter(reps=reps)
        for pauli_string, time in zip(pauli_strings, times):
            pauli = Pauli(pauli_string)
            hamiltonian = SparsePauliOp(pauli)
            evolution_gate = PauliEvolutionGate(hamiltonian, time)
            synthesized_circuit = synthesizer.synthesize(evolution_gate)
            qc.append(synthesized_circuit.to_gate(), range(len(pauli_string)))
        return qc

    solution_circuit = create_solution_circuit(pauli_strings, times, order, reps)
    candidate_circuit = candidate(pauli_strings, times, order, reps)

    assert Operator(solution_circuit) == Operator(candidate_circuit), "The candidate circuit does not match the expected solution."
    assert isinstance(candidate_circuit, QuantumCircuit), "The returned object is not a QuantumCircuit."
from qiskit import QuantumCircuit
from qiskit.transpiler import PassManager, PropertySet
from qiskit.transpiler.passes import RemoveBarriers
def calculate_depth_after_barrier_removal(qc: QuantumCircuit) -> PropertySet:
    """ Remove barriers from the given quantum circuit and calculate the depth before and after removal.
    Return a PropertySet with 'depth_before', 'depth_after', and 'width' properties.
    The function should only remove barriers and not perform any other optimizations.
    """
    property_set = PropertySet()
    property_set["depth_before"] = qc.depth()
    property_set["width"] = qc.width()
    
    pass_manager = PassManager(RemoveBarriers())
    optimized_qc = pass_manager.run(qc)
    
    property_set['depth_after'] = optimized_qc.depth()
    
    return property_set


def check(candidate):
    qc = QuantumCircuit(3)
    qc.h(0)
    qc.barrier()
    qc.cx(0, 1)
    qc.barrier()
    qc.cx(1, 2)
    qc.measure_all()
    
    property_set = candidate(qc)
    
    assert property_set["depth_before"] == qc.depth(), "'depth_before' should match the original circuit depth"
    assert property_set["width"] == qc.width(), "'width' should match the circuit width"
    optimized_qc = PassManager(RemoveBarriers()).run(qc)
    assert property_set["depth_after"] == optimized_qc.depth(), "'depth_after' should match the depth of a barrier-free circuit"
from qiskit.transpiler import CouplingMap
def create_and_modify_coupling_map() -> CouplingMap:
    """ Create a CouplingMap with a specific coupling list, then modify it by adding an edge and a physical qubit.
    The initial coupling list is [[0, 1], [1, 2], [2, 3], [3, 4], [4, 5]].
    Add an edge (5, 6), and add a physical qubit "7".
    """
    coupling_list = [[0, 1], [1, 2], [2, 3], [3, 4], [4, 5]]
    cmap = CouplingMap(couplinglist=coupling_list)
    cmap.add_edge(5, 6)
    cmap.add_physical_qubit(7)
    return cmap


def check(candidate):
    cmap = candidate()
    edges = set(cmap.get_edges())
    assert edges == { (0, 1), (1, 2), (2, 3), (3, 4), (4, 5), (5,6) }
    assert len(cmap.physical_qubits) == 8
from qiskit.transpiler import Target, InstructionProperties
from qiskit.circuit.library import UGate, CXGate
from qiskit.circuit import Parameter
def create_target() -> Target:
    """ Create a Target object for a 2-qubit system and add UGate and CXGate instructions with specific properties.
    - Add UGate for both qubits (0 and 1) with parameters 'theta', 'phi', and 'lambda'.
    - Add CXGate for qubit pairs (0,1) and (1,0).
    - All instructions should have nonzero 'duration' and 'error' properties set.
    """
    gmap = Target()
    theta, phi, lam = [Parameter(p) for p in ("theta", "phi", "lambda")]
    u_props = {
        (0,): InstructionProperties(duration=5.23e-8, error=0.00038115),
        (1,): InstructionProperties(duration=4.52e-8, error=0.00032115),
    }
    gmap.add_instruction(UGate(theta, phi, lam), u_props)
    cx_props = {
        (0,1): InstructionProperties(duration=5.23e-7, error=0.00098115),
        (1,0): InstructionProperties(duration=4.52e-7, error=0.00132115),
    }
    gmap.add_instruction(CXGate(), cx_props)
    return gmap


def check(candidate):
    target = candidate()
    assert isinstance(target, Target)

    instructions = target.instructions
    u_gate_instructions = [inst for inst in instructions if inst[0].name == "u"]
    cx_gate_instructions = [inst for inst in instructions if inst[0].name == 'cx']

    assert len(u_gate_instructions) == 2
    assert len(cx_gate_instructions) == 2

    for inst in u_gate_instructions + cx_gate_instructions:
        props = target[inst[0].name][inst[1]]
        assert isinstance(props, InstructionProperties)
        assert props.duration > 0
        assert props.error >= 0

    assert set(inst[1] for inst in u_gate_instructions) == {(0,), (1,)}
    assert set(inst[1] for inst in cx_gate_instructions) == {(0, 1), (1, 0)}
from qiskit.circuit.library import PauliEvolutionGate
from qiskit.synthesis import MatrixExponential
from qiskit import QuantumCircuit
from qiskit.quantum_info import Pauli, Operator
import numpy as np
def synthesize_evolution_gate(pauli_string: str, time: float) -> QuantumCircuit:
    """ Synthesize an evolution gate using MatrixExponential for a given Pauli string and time.
    The Pauli string can be any combination of 'I', 'X', 'Y', and 'Z'.
    Return the resulting QuantumCircuit.
    """
    pauli = Pauli(pauli_string)
    evolution_gate = PauliEvolutionGate(pauli, time)
    synthesizer = MatrixExponential()
    qc = synthesizer.synthesize(evolution_gate)
    return qc


def check(candidate):
    pauli_string = "X"
    time = 1.0
    
    qc = candidate(pauli_string, time)
    assert isinstance(qc, QuantumCircuit), "The function should return a QuantumCircuit"
    assert qc.size() > 0, "The circuit should not be empty"
    
    ideal_solution = QuantumCircuit(1)
    ideal_solution.rx(2 * time, 0)
    
    assert np.allclose(Operator(qc), Operator(ideal_solution)), "The synthesized circuit does not match the expected evolution"
from qiskit.synthesis import TwoQubitBasisDecomposer
from qiskit.quantum_info import Operator, random_unitary
from qiskit.circuit.library import CXGate
from qiskit import QuantumCircuit
import numpy as np
def decompose_unitary(unitary: Operator) -> QuantumCircuit:
    """ Decompose a 4x4 unitary using the TwoQubitBasisDecomposer with CXGate as the basis gate.
    Return the resulting QuantumCircuit.
    """
    decomposer = TwoQubitBasisDecomposer(CXGate())
    return decomposer(unitary)


def check(candidate):
    unitary = random_unitary(4)
    try:
        qc = candidate(unitary)
        assert isinstance(qc, QuantumCircuit)
        assert qc.num_qubits == 2
        assert qc.size() > 0

        cx_count = sum(1 for inst in qc.data if inst.operation.name == "cx")
        assert cx_count > 0
    except (ValueError, np.linalg.LinAlgError) as e:
        raise e
from qiskit import QuantumCircuit
from qiskit.circuit.library import C3SXGate
def create_c3sx_circuit() -> QuantumCircuit:
    """ Create a QuantumCircuit with a C3SXGate applied to the first four qubits.
    """
    qc = QuantumCircuit(4)
    c3sx_gate = C3SXGate()
    qc.append(c3sx_gate, [0, 1, 2, 3])
    return qc


def check(candidate):
    qc = candidate()
    assert isinstance(qc, QuantumCircuit)
    
    c3sx_instructions = [inst for inst in qc.data if isinstance(inst.operation, C3SXGate)]
    assert len(c3sx_instructions) == 1
    
    assert c3sx_instructions[0].qubits == tuple([qc.qubits[i] for i in range(4)])
from qiskit.circuit.library import CDKMRippleCarryAdder
from qiskit import QuantumCircuit
from qiskit.quantum_info import Operator
def create_ripple_carry_adder_circuit(num_state_qubits: int, kind: str) -> QuantumCircuit:
    """ Create a QuantumCircuit with a CDKMRippleCarryAdder applied to the qubits.
    The kind of adder can be 'full', 'half', or 'fixed'.
    """
    adder = CDKMRippleCarryAdder(num_state_qubits, kind)
    qc = QuantumCircuit(adder.num_qubits)
    qc.append(adder.to_instruction(), range(adder.num_qubits))
    return qc


def check(candidate):
    qc_full = candidate(3, "full")
    assert isinstance(qc_full, QuantumCircuit), "The function should return a QuantumCircuit"
    
    op_full = Operator(qc_full)
    expected_full = Operator(CDKMRippleCarryAdder(3, "full"))
    assert op_full.equiv(expected_full), "The circuit does not match the expected CDKMRippleCarryAdder for full kind"
    qc_fixed = candidate(3, "fixed")
    assert isinstance(qc_fixed, QuantumCircuit), "The function should return a QuantumCircuit"
    
    op_fixed = Operator(qc_fixed)
    expected_fixed = Operator(CDKMRippleCarryAdder(3, "fixed"))
    assert op_fixed.equiv(expected_fixed), "The circuit does not match the expected CDKMRippleCarryAdder for fixed kind"
from qiskit.circuit.library import Diagonal
from qiskit import QuantumCircuit
from qiskit.quantum_info import Operator
def create_diagonal_circuit(diag: list) -> QuantumCircuit:
    """ Create a QuantumCircuit with a Diagonal gate applied to the qubits.
    The diagonal elements are provided in the list 'diag'.
    """
    diagonal_gate = Diagonal(diag)
    qc = QuantumCircuit(diagonal_gate.num_qubits)
    qc.append(diagonal_gate.to_instruction(), range(diagonal_gate.num_qubits))
    return qc


def check(candidate):
    diag = [1, 1j, -1, -1j]
    qc = candidate(diag)
    assert isinstance(qc, QuantumCircuit), "The function should return a QuantumCircuit"
    
    op_circuit = Operator(qc)
    
    expected_diagonal = Diagonal(diag)
    op_expected = Operator(expected_diagonal)
    
    assert op_circuit.equiv(op_expected), "The circuit does not match the expected Diagonal gate"
from qiskit import QuantumCircuit, QuantumRegister, ClassicalRegister
def conditional_two_qubit_circuit():
    """ Create a quantum circuit with one qubit and two classical bits. The qubit's operation depends on its measurement outcome: if it measures to 1 (|1> state), it flips the qubit's state back to |0> using an X gate. The qubit's initial state is randomized using a Hadamard gate. When building the quantum circuit make sure the classical registers is named 'c'.
    """
    qr = QuantumRegister(1)
    cr = ClassicalRegister(2, 'c')
    qc = QuantumCircuit(qr, cr)

    qc.h(qr[0])
    qc.measure(qr[0], cr[0])
    with qc.if_test((cr[0], 1)):
        qc.x(qr[0])
    qc.measure(qr[0], cr[1])
    return qc


def check(candidate):
    from qiskit_aer import AerSimulator
    from qiskit_ibm_runtime import Sampler
    from qiskit_ibm_runtime.options import SamplerOptions
    qc = candidate()
    assert isinstance(qc, QuantumCircuit)
    assert qc.num_qubits == 1
    assert qc.num_clbits == 2
    ops = dict(qc.count_ops())
    assert "h" in ops and "if_else" in ops
    backend = AerSimulator()
    options = SamplerOptions()
    options.simulator.seed_simulator=42
    sampler = Sampler(mode=backend, options=options)
    result = sampler.run([qc]).result()
    counts = result[0].data.c.get_counts()
    assert "10" not in counts and "11" not in counts
from qiskit.circuit.library import EfficientSU2
from qiskit_ibm_transpiler.transpiler_service import TranspilerService
def ai_transpiling(num_qubits):
    """ Generate an EfficientSU2 circuit with the given number of qubits, 1 reps and make entanglement circular. 
    Then use the Qiskit Transpiler service with the AI flag turned on, use the ibm_brisbane backend and an optimization level of 3 and transpile the generated circuit.
    """
    circuit = EfficientSU2(num_qubits, entanglement="circular", reps=1)
    transpiler_ai_true = TranspilerService(
        backend_name="ibm_brisbane",
        ai=True,
        optimization_level=3
    )

    transpiled_circuit = transpiler_ai_true.run(circuit)
    return transpiled_circuit


def check(candidate):
    import qiskit
    num_qubits = 3
    backend_name = "ibm_brisbane"
    ai_flag = True
    optimization_level = 3
    og_circuit = EfficientSU2(num_qubits, entanglement="circular", reps=1)
    gen_transpiled_circuit = candidate(num_qubits)
    assert isinstance(gen_transpiled_circuit, qiskit.circuit.QuantumCircuit)
    transpiler_service = TranspilerService(
        backend_name=backend_name,
        ai=ai_flag,
        optimization_level=optimization_level
    )

    expected_transpiled_circuit = transpiler_service.run(og_circuit)

    # We can add the following check once we have the random_state/seed feature in the transpiler service
    # assert gen_transpiled_circuit == expected_transpiled_circuit
from qiskit.visualization import plot_error_map
from qiskit_ibm_runtime.fake_provider import FakeBelemV2
def backend_error_map():
    """ Instantiate a FakeBelemV2 backend and return the plot of its error_map.
    """
    backend = FakeBelemV2()
    return plot_error_map(backend)


def check(candidate):
    from matplotlib.figure import Figure
    result = candidate()
    assert type(result) == Figure
    assert len(result.axes) == 5
    assert result.get_suptitle() == "fake_belem Error Map"
from qiskit_ibm_runtime.fake_provider import FakeCairoV2
from qiskit_aer.noise import NoiseModel
def gen_noise_model():
    """ Generate a noise model from the Fake Cairo V2 backend.
    """
    backend = FakeCairoV2()
    noise_model = NoiseModel.from_backend(backend)
    return noise_model


def check(candidate):
    backend = FakeCairoV2()
    expected_nm = NoiseModel.from_backend(backend)
    noise_model = candidate()
    assert type(noise_model) == NoiseModel
    assert noise_model == expected_nm
from qiskit.converters import circuit_to_gate
def circ_to_gate(circ):
    """ Given a QuantumCircuit, convert it into a gate equivalent to the action of the input circuit and return it.
    """
    circ_gate = circuit_to_gate(circ)
    return circ_gate


def check(candidate):
    from qiskit import QuantumCircuit, QuantumRegister
    from qiskit.circuit.gate import Gate
    from qiskit.quantum_info import Operator
    from qiskit.circuit.library import ZGate
    q = QuantumRegister(3, "q")
    circ = QuantumCircuit(q)
    circ.h(q[0])
    circ.cx(q[0], q[1])
    custom_gate = candidate(circ)
    assert type(custom_gate) == Gate
    assert custom_gate.num_qubits == 3
    assert custom_gate.num_clbits == 0

    q = QuantumRegister(1, "q")
    circ = QuantumCircuit(q)
    circ.h(q)
    circ.x(q)
    circ.h(q)
    hxh_gate = circ_to_gate(circ)
    hxh_op = Operator(hxh_gate)
    z_op = Operator(ZGate())
    assert hxh_op.equiv(z_op)
from qiskit.circuit.library import HGate
from qiskit.quantum_info import Operator, process_fidelity
import numpy as np
def calculate_phase_difference_fidelity():
    """ Create two quantum operators using Hadamard gate that differ only by a global phase. Calculate the process fidelity between these two operators and return the process fidelity value.
    """
    op_a = Operator(HGate())
    op_b = np.exp(1j * 0.5) * Operator(HGate())
    
    fidelity = process_fidelity(op_a, op_b)
    
    return fidelity


def check(candidate):
    result = candidate()
    assert isinstance(result, float)
    assert abs(result - 1.0) < 1e-6