The benchmarking suite has no way to specify which qubits are used in the execution of a given circuit, i.e. one cannot define an initial_layout here:

https://github.com/SRI-International/QC-App-Oriented-Benchmarks/blob/5e1f68eed96d667b9bcc08d3b04b2004f4c04643/_common/qiskit/execute.py#L269

This is nice to have because, for example, in Fig. 11 of https://arxiv.org/abs/2110.03137 you look at dynamic Berstein-Vazirani on the Lagos system, but the 0-1 edge of the coupling map is actually not the best (it is also not the worst). On that machine the 3-5 edge is the best in terms of fidelity:

[3, 5] 0.7861328125
[2, 1] 0.77197265625
[5, 4] 0.7678222656250001
[5, 3] 0.7481689453125
[3, 1] 0.7360839843750001
[4, 5] 0.7303466796875
[0, 1] 0.7076416015625001
[1, 2] 0.665771484375
[6, 5] 0.64208984375
[1, 0] 0.6323242187500001
[1, 3] 0.6124267578125001
[5, 6] 0.5809326171875001

Hello Sir, I am finding problem in executing the vqe code. The error I am getting is below: I tried installing these packages but the error is still not resolved. Need your help.

Hi Tried, I tried running the below code from your Deush Josza algorithm:

"""
Deutsch-Jozsa Benchmark Program - Qiskit
"""

import sys
import time

import numpy as np
from qiskit import QuantumCircuit, QuantumRegister, ClassicalRegister

sys.path[1:1] = ["_common", "_common/qiskit"]
sys.path[1:1] = ["../../_common", "../../_common/qiskit"]
import execute as ex
import metrics as metrics

np.random.seed(0)

verbose = False

# saved circuits for display
QC_ = None
C_ORACLE_ = None
B_ORACLE_ = None


############### Circuit Definition

# Create a constant oracle, appending gates to given circuit
def constant_oracle(input_size, num_qubits):
    # Initialize first n qubits and single ancilla qubit
    qc = QuantumCircuit(num_qubits, name=f"Uf")

    output = np.random.randint(2)
    if output == 1:
        qc.x(input_size)

    global C_ORACLE_
    if C_ORACLE_ == None or num_qubits <= 6:
        if num_qubits < 9: C_ORACLE_ = qc

    return qc


# Create a balanced oracle.
# Perform CNOTs with each input qubit as a control and the output bit as the target.
# Vary the input states that give 0 or 1 by wrapping some of the controls in X-gates.
def balanced_oracle(input_size, num_qubits):
    # Initialize first n qubits and single ancilla qubit
    qc = QuantumCircuit(num_qubits, name=f"Uf")

    b_str = "10101010101010101010"  # permit input_string up to 20 chars
    for qubit in range(input_size):
        if b_str[qubit] == '1':
            qc.x(qubit)

    qc.barrier()

    for qubit in range(input_size):
        qc.cx(qubit, input_size)

    qc.barrier()

    for qubit in range(input_size):
        if b_str[qubit] == '1':
            qc.x(qubit)

    global B_ORACLE_
    if B_ORACLE_ == None or num_qubits <= 6:
        if num_qubits < 9: B_ORACLE_ = qc

    return qc


# Create benchmark circuit
def DeutschJozsa(num_qubits, type):
    # Size of input is one less than available qubits
    input_size = num_qubits - 1

    # allocate qubits
    qr = QuantumRegister(num_qubits);
    cr = ClassicalRegister(input_size);
    qc = QuantumCircuit(qr, cr, name="main")

    for qubit in range(input_size):
        qc.h(qubit)
    qc.x(input_size)
    qc.h(input_size)

    qc.barrier()

    # Add a constant or balanced oracle function
    if type == 0:
        Uf = constant_oracle(input_size, num_qubits)
    else:
        Uf = balanced_oracle(input_size, num_qubits)
    qc.append(Uf, qr)

    qc.barrier()

    for qubit in range(num_qubits):
        qc.h(qubit)

    # uncompute ancilla qubit, not necessary for algorithm
    qc.x(input_size)

    qc.barrier()

    for i in range(input_size):
        qc.measure(i, i)

    # save smaller circuit and oracle subcircuit example for display
    global QC_
    if QC_ == None or num_qubits <= 6:
        if num_qubits < 9: QC_ = qc

    # return a handle to the circuit
    return qc


############### Result Data Analysis

# Analyze and print measured results
# Expected result is always the type, so fidelity calc is simple
def analyze_and_print_result(qc, result, num_qubits, type, num_shots):
    # Size of input is one less than available qubits
    input_size = num_qubits - 1

    # obtain counts from the result object
    counts = result.get_counts(qc)
    if verbose: print(f"For type {type} measured: {counts}")

    # create the key that is expected to have all the measurements (for this circuit)
    if type == 0:
        key = '0' * input_size
    else:
        key = '1' * input_size

    # correct distribution is measuring the key 100% of the time
    correct_dist = {key: 1.0}

    # use our polarization fidelity rescaling
    fidelity = metrics.polarization_fidelity(counts, correct_dist)

    return counts, fidelity


################ Benchmark Loop

# Execute program with default parameters
def run(min_qubits=3, max_qubits=8, max_circuits=3, num_shots=100,
        backend_id='qasm_simulator', provider_backend=None,
        hub="ibm-q", group="open", project="main", exec_options=None):
    print("Deutsch-Jozsa Benchmark Program - Qiskit")

    # validate parameters (smallest circuit is 3 qubits)
    max_qubits = max(3, max_qubits)
    min_qubits = min(max(3, min_qubits), max_qubits)
    # print(f"min, max qubits = {min_qubits} {max_qubits}")

    # Initialize metrics module
    metrics.init_metrics()

    # Define custom result handler
    def execution_handler(qc, result, num_qubits, type, num_shots):

        # determine fidelity of result set
        num_qubits = int(num_qubits)
        counts, fidelity = analyze_and_print_result(qc, result, num_qubits, int(type), num_shots)
        metrics.store_metric(num_qubits, type, 'fidelity', fidelity)

    # Initialize execution module using the execution result handler above and specified backend_id
    ex.init_execution(execution_handler)
    ex.set_execution_target(backend_id, provider_backend=provider_backend,
                            hub=hub, group=group, project=project, exec_options=exec_options)

    # Execute Benchmark Program N times for multiple circuit sizes
    # Accumulate metrics asynchronously as circuits complete
    for num_qubits in range(min_qubits, max_qubits + 1):

        input_size = num_qubits - 1

        # determine number of circuits to execute for this group
        num_circuits = min(2, max_circuits)

        print(f"************\nExecuting [{num_circuits}] circuits with num_qubits = {num_qubits}")

        # loop over only 2 circuits
        for type in range(num_circuits):
            # create the circuit for given qubit size and secret string, store time metric
            ts = time.time()
            qc = DeutschJozsa(num_qubits, type)
            metrics.store_metric(num_qubits, type, 'create_time', time.time() - ts)

            # collapse the sub-circuit levels used in this benchmark (for qiskit)
            qc2 = qc.decompose()

            # submit circuit for execution on target (simulator, cloud simulator, or hardware)
            ex.submit_circuit(qc2, num_qubits, type, num_shots)

        # Wait for some active circuits to complete; report metrics when groups complete
        ex.throttle_execution(metrics.finalize_group)

    # Wait for all active circuits to complete; report metrics when groups complete
    ex.finalize_execution(metrics.finalize_group)

    # print a sample circuit
    print("Sample Circuit:");
    print(QC_ if QC_ != None else "  ... too large!")
    print("\nConstant Oracle 'Uf' =");
    print(C_ORACLE_ if C_ORACLE_ != None else " ... too large or not used!")
    print("\nBalanced Oracle 'Uf' =");
    print(B_ORACLE_ if B_ORACLE_ != None else " ... too large or not used!")

    # Plot metrics for all circuit sizes
    metrics.plot_metrics("Benchmark Results - Deutsch-Jozsa - Qiskit")


# if main, execute method
if __name__ == '__main__': run()

I am getting the below error:

C:\Users\manuc\Documents\Pytorch_Study_Workspace\Benchmark_dj\venv\Scripts\python.exe C:/Users/manuc/Documents/Pytorch_Study_Workspace/Benchmark_dj/main.py
Traceback (most recent call last):
  File "C:\Users\manuc\Documents\Pytorch_Study_Workspace\Benchmark_dj\main.py", line 219, in <module>
    if __name__ == '__main__': run()
  File "C:\Users\manuc\Documents\Pytorch_Study_Workspace\Benchmark_dj\main.py", line 161, in run
    metrics.init_metrics()
AttributeError: module 'metrics' has no attribute 'init_metrics'
Deutsch-Jozsa Benchmark Program - Qiskit

Process finished with exit code 1

Please guide me how to correct this Error?

In the paper https://arxiv.org/abs/2110.03137 it is said that the depth calculation for circuits is done using the basis set ['rx', 'ry', 'rz', 'cx']. However when looking at Fig 9 of the paper the reported depth does not match what the depth is when the circuit is decomposed to the indicated basis. Namely the routine just does a decompose

https://github.com/SRI-International/QC-App-Oriented-Benchmarks/blob/5e1f68eed96d667b9bcc08d3b04b2004f4c04643/quantum-fourier-transform/qiskit/qft_benchmark.py#L313

before passing on to execute that computes the depth of this decomposition:

https://github.com/SRI-International/QC-App-Oriented-Benchmarks/blob/5e1f68eed96d667b9bcc08d3b04b2004f4c04643/_common/qiskit/execute.py#L237

This does not decompose to the correct basis, and the circuits are much shorter than they should be. At 7 qubits, the decomposed depth is 31, which matches Fig 9., but the actual depth with the correct basis is 78. The same is true for the circuits that are swap mapped to the Casablanca system, where I get an avg depth of 117.

• Added function to metrics.py for computing the empirical probability distribution of cut sizes.
• Added function that plots the cactus plots
• Added an mplstyle file
• Rather than using mplstyle globally, using it with a context manager
• Restructuring in plot_metrics_optgaps to allow choosing which metrics to plot.

Hi, I tried running the hamiltonian-simulation code in the pycharm. I am getting the below error: The directory structure of my program looks as below: Please give suggestion on how to resolve this error?

When running some benchmarks, if the expected distribution is too small q_sum will be zero and result in a ZeroDivisionError error when calculating hellinger_fidelity_with_expected.

I wasn't sure on what the printed Error message should say. Please let me know if you have any suggestions.

Modify execute.py module for qiskit to allow multiple transpilations passes for the transpiler. This is useful because the transpiled circuit is found stochastically and it can vary in different runs of the transpiler. Running the transpiler multiple times and selecting the transpiled circuit with the lowest cx count can improve the fidelity of circuit ran with qiskit

Added custom theta initialization parameter custom_theta_init: dict[float]. To initialize custom angles, pass a dict of floats with the angle as key, e.g.

maxcut_benchmark.run(custom_theta_init={"beta": 0.5, "gamma": 0.5})

Slightly refactored code to initialize new thetas in main loop, this means we no longer need the method and rounds parameters in MaxCut since we always pass thetas_init.

Also, fixed title issue in optimality gap plot (was missing the f for the fstring).

• Added markdown headings above each benchmark cell for easier navigation.
• Deleted run magic commands because they were redundant and didn't allow user to specify any new arguments.

Get distribution of cut sizes for uniform random sampling. Changes to metrics.py. Next, will add a function for plotting empirical probability distribution of cut sizes, both for the QAOA output, and uniform random sampling.

use file in any module that is imported. This method allows one to import, for example, maxcut/qiskit/maxcut_benchmark.py from a location which is different from maxcut/qiskit/ directory. Previous way of adding system path did not work in this case.

In this PR, it's found that it's possible for the maxcut benchmark to produce expected distributions with norm=0. At line 139 of get_expectation, there is a step:

# scale to number of shots
        for k, v in counts.items():
            counts[k] = round(v * num_shots)

Correct me if I'm wrong, but this is used to compare the results against a discrete approximation to the theoretical distribution, possibly to not penalize a result list that does not contain any counts for bitstrings that have very small probability mass (so that you'd expect 0 appearances at the given shot count) and also just to peg an integer number of results for each bitstring as ideal. This means for the case you describe, the only way to run the problem instance throwing the error is to increase the number of shots until the discretized expected distribution has at least a single nonzero element. I worry this has its own issues, because a significant distortion between the original distribution and the discretized distribution causes a distortion in the actual fidelity calculation. You could conceivably be comparing the results to a discrete distribution with whacky finite-size effects that make it look very different from the distribution that an ideal quantum computer is pulling from. This should only happen when the theoretical distribution is very wide and mostly but not perfectly flat, (I think), but it's worth considering.

Just wanted to share these thoughts... I don't think we use this kind of step in other benchmarks? It seems odd that we'd calculate fidelity against discretized distributions for some benchmarks and continuous exact distributions for others. Maybe we should perform a check that something like this doesn't happen in maxcut_benchmark.py or pass the exact distribution even if the fidelity moderately underperforms at low shot counts?

The QED-C benchmarks, and paper, use the polarization fidelity as the comparison metric amongst applications and differing numbers of qubits. This is given by Eq.(2) of the paper (https://arxiv.org/abs/2110.03137). In the plots this fidelity is reported on the interval [0,1], e.g

-(1/2**N)/(1-1/2**N)

where N is the number of qubits. Therefore the range [0,1] is only valid in the large N limit. More importantly, this lower bound is qubit number specific. Therefore this fidelity cannot be used as a comparator across differing numbers of qubits, as done in the tests and paper.

The polarization fidelity should, for example, be shifted and rescaled so that the range [0,1] is valid across all numbers of qubits.

This PR adds an Amazon Braket implementation of the Amplitude Estimation benchmark.

Here are a couple notes about this implementation:

1. I found that Braket just doesn't support certain features natively, namely, adjoint circuits, multi-cnot gates, etc. (at least not obviously from the documentation), so I had to implement many of those functions by hand. It sounds like it might be useful to compile a general set of Braket utils useful across all benchmarks.

2. The main implementation is located in braket/ae_benchmark.py and the utilities mentioned in point 1 are located in braket/ae_utils.py.

3. I tried to keep the benchmark itself as uniform as possible with respect to the existing benchmarks with some small differences due to Braket's limitations.

• When generating Q, instead of returning cQ and Q, the function Q_Unitary returns the Q circuit object as well as the unitary matrix of Q which is later supplied to controlled_unitary() when creating the general circuit.
• I kept a vanilla python list of qubit numbers to use similar to QuantumRegister in Qiskit

Let me know if you have any questions! I'm not sure if there's any established workflow, so I just assumed based on the branches that I should PR into develop. Please let me know if there's a different established flow.