As superconducting qubits continue to advance technologically, the realization of quantum algorithms from theoretical abstraction to physical implementation requires knowledge of both quantum circuit construction as well as hardware limitations. In this study, we present results from experiments run on IBM’s 20-qubit “Poughkeepsie” architecture, with the goal of demonstrating various qubit qualities and challenges that arise in designing quantum algorithms. These include experimentally measuring *T*_{1} and *T*_{2} coherence times, gate fidelities, sequential CNOT gates, techniques for handling ancilla qubits, and finally CCNOT and QFT^{†} circuits implemented on several different qubit geometries. Our results demonstrate various techniques for improving quantum circuits, which must compensate for limited connectivity, either through the use of SWAP gates or additional ancilla qubits.

## I. INTRODUCTION

For as long as technology remains in the NISQ (noisy intermediate scale quantum) era^{1} of quantum computers, quantum algorithm design will need to compensate for noisy qubits. While algorithms such as Shor’s^{2} and Grover’s^{3} have proven mathematical speedups over the best known classical algorithms, they critically rely on demands from quantum computers such as qubit coherence times and gate fidelities, which to date have been unfeasible. Specifically for superconducting qubits, these various sources of noise^{4–7} inhibit the success of quantum algorithms, which in turn diminish or completely negate their potential for speedups. Even then, technological strides and new techniques for minimizing noise continue to develop,^{8–10} with the hope that someday soon we will reach full error-correcting^{11–13} quantum computers.

Due to the complex technological nature of quantum computers, the current standard model by which interested users can work with these machines is through remote access with various vendors.^{14–17} Analogous to high-level classical programming languages, these vendors offer quantum programming languages which grant the ability to users to execute quantum circuits, without necessarily knowing the full technical extent of how they are implemented via superconducting qubits. Consequently, this allows for an important separation of quantum software from hardware, opening up more opportunities for research efforts in the field of quantum algorithms.^{18,19} In the spirit of this new dawn of quantum programming, the findings in this study reflect the capabilities and limitations of this current model for quantum computer access, aiming to test the 20-qubit Poughkeepsie architecture through various experiments.

Each experiment in this study is motivated by different components, which are critical to the success of larger, more complex quantum algorithms. These include *T*_{1} and *T*_{2} coherence times,^{20–22} single and 2-qubit gate fidelities, and qubit connectivity. After testing these properties individually, we then study their combined effects through implementation of CCNOT and QFT^{†} circuits.^{23,24} Throughout these various experiments, we make a concentrated effort to distinguish between results that are simply technological benchmarks (coherence times, gate fidelity, etc.) and those that are more fundamental to algorithm design. Our findings demonstrate several challenges which must be factored into NISQ era algorithm design, adding to the growing population of studies that aim to benchmark IBM’s qubits,^{25–27} as well as test the limits of various algorithm implementations.^{28–32}

### A. Layout

The layout of this paper is as follows: In Sec. II, we investigate the *T*_{1} and *T*_{2} coherence times of various qubits. In Sec. III, we demonstrate CNOT gate fidelities across all 20 of IBM’s Poughkeepsie qubits, showing the extent to which a single CNOT operation can be reliably performed between distant qubits. Section IV contains no experimental results but lays the framework and motivation for the remainder of the study. In Secs. V and VI, we experimentally implement CCNOT and QFT^{†} circuits on various qubit geometries. Finally, Sec. VII summarizes the main results of the paper and their implications for future algorithm design.

## II. COHERENCE TIMES

In quantum computing, a qubit is a two-level system that can simultaneously occupy both the |0⟩ (ground) and |1⟩ (excited) states through superposition and is also sensitive to the relative phase between the two states. In practice, however, one must always be mindful of the potential for noise to cause qubits to deviate from their intended states. Contrary to their classical counterparts, current qubits have short timescales for which their quantum states are usable in any sort of calculation. These time frames are referred to as coherence times, quantified by the metrics *T*_{1} and *T*_{2}, representing timescales after which a qubit has likely lost its computational utility. Physically, these metrics correspond to a qubit’s interactions with a noisy environment, tracking the probability that a qubit’s excited state (*T*_{1}) or superposition state (*T*_{2}) is preserved, which both decay exponentially over time. The following equation shows the probability of a qubit resisting a decoherence collapse after an interval of time Δ*t*,

While working on IBM’s Poughkeepsie architecture, coherence times for both *T*_{1} and *T*_{2} ranged from lows of 30 *µ*s–40 *µ*s to highs of 100 *µ*s–120 *µ*s. In this section, we present experimental results aimed at verifying these coherence times through direct observation of decoherence over varying timescales. However, when working on these shared devices remotely, one must be mindful of the number of other users, which at certain times during the day can cause more competition for machine usage than other times. This in turn can be problematic for experiments which require data collection from numerous trials, such as the coherence experiments to come, as we found that qubit coherence times can fluctuate throughout a 24 h day. Thus, the results shown in Secs. II A and II B represent some of the best data obtained as a remote user, overcoming the challenge of shared device usage and ultimately demonstrating the coherence times of IBM’s qubits.

### A. T_{1} energy relaxation

The *T*_{1} metric corresponds to a spontaneous decay from the excited state (|1⟩) to the ground state (|0⟩). Just as classical computing is reliant on the long shelf life of bits, a critical ingredient for quantum circuits is how long a qubit can maintain the |1⟩ state. 2-qubit gates such as CNOT and control-*R*_{ϕ}, which make up the backbone of several critical quantum subroutines, are reliant on “control” qubits whereby the action of the 2-qubit gate is only performed if the control qubit is in the |1⟩ state. Thus, the impact of a spontaneous energy relaxation in the middle of an algorithm can vary depending on when, and on which qubit, the error occurs. If a key qubit to a circuit’s success were to unintentionally undergo a *T*_{1} collapse, it could spell the end of the algorithm. Conversely, as demonstrated in some of the later experiments, certain algorithms can still yield successful results despite one or more qubits undergoing spontaneous decays, provided the collapse happens after a qubit has served its purpose.

In order to experimentally demonstrate the decay shown in Eq. (1), a circuit, as shown Fig. 1, is used to verify the underlying *T*_{1} nature of IBM’s qubits. The circuit is designed such that the qubit is initially brought into the |1⟩ excited state via an *X* gate, followed by a desired amount of time Δ*t* whereby we anticipate an energy relaxation according to the exponential probability distribution.

While performing the experiment with the circuit shown in Fig. 1, which can be seen more explicitly in the Appendix, Fig. 29, various Δ*t* times were tested in order to reveal the full exponential decaying nature of the qubits. For each value of Δ*t*, the circuit was run 8000 times, the results of which were then used to compute an average percentage probability of decay. Once all experiments for a given qubit were completed, exponential regression fits were then performed to the data. The *T*_{1} values from these best fits are displayed alongside the plots shown in Fig. 2, as well as the reported *T*_{1} times by IBM for each qubit.

### B. T_{2} transverse relaxation

On comparison with *T*_{1}, which has a single well defined physical description, *T*_{2} coherence for qubits can take on several potential definitions. In this study, we present results based on two experiments, commonly referred to as “*T*_{2} Ramsey” and “*T*_{2} Echo.” The quantum circuits for each experiment are shown in Fig. 3. In both experiments, the qubit is initially brought into the 50-50 superposition state |+⟩ via a Hadamard gate, followed by various amounts of time Δ*t*, and finally a second Hadamard just before the measurement. During the time between Hadamard gates, the qubit is subject to spontaneous energy relaxation (*T*_{1}), as well as dephasing and frequency drifting, for a combined effect referred to as transverse relaxation.^{6}

Beginning with the Ramsey experiment, the theoretical final state after two sequential Hadamard gates (Δ*t* = 0) should return the qubit back to the ground state. However, when time is introduced in between these two *H* gates, the qubit becomes susceptible to *T*_{2} transverse relaxation. As illustrated in Fig. 4, the frequency drifting component of *T*_{2} relaxation causes the state of the qubit to process around the equatorial plane of the Bloch sphere,

Experimentally, this effect causes the second Hadamard gate to transform the qubit to a new final state based on the elapsed time, one which oscillates between |0⟩ and |1⟩ with the frequency of the drift. Second, the qubit is also subject to pure dephasing over time, represented by the growing shaded area in Fig. 4, where one gradually loses knowledge of the exact state of the qubit.^{33}

The frequency of the precessing state shown in Eq. (2) can be determined through the difference in energies of the two-level qubit system, *ω* = *E*_{1} − *E*_{0}. As a result, the probability of measuring the |0⟩ state in the Ramsey experiment as a function of time goes like cos^{2}(), which can be seen in Fig. 5,

In order to obtain data similar to those of the *T*_{1} experiment, suitable for an exponential best fit, one can counteract the drifting process of the qubit using the *T*_{2} Echo circuit. By splitting each time evolution (Δ*t*) into two equal halves and using an additional *X* gate, one can refocus the qubit back to the |+⟩ state just prior to the second Hadamard, guaranteeing a theoretical measurement of |0⟩. Visually, one can picture this process as the state of the qubit drifting along for some time Δ*t* (Fig. 4), becoming |Ψ(Δ*t*)⟩ [Eq. (2)], undergoing a reflection as a result of the *X* gate, and finally drifting once again of equal time back to its starting state.

Plotted below are the results obtained running the Ramsey and Echo experiments on various qubits on the Poughkeepsie architecture. Figure 5 shows a typical Ramsey experiment, whereby the probability of the final state oscillates between |0⟩ and |1⟩ as a function of time while simultaneously dampening into a fully decohered state as a result of dephasing. Figure 6 illustrates the Echo technique described earlier, showing the effect of using an *X* gate to let the quantum system naturally refocus the state of the qubit. Exponential best fits for the *T*_{2} Echo experiment are given, along with reported values from IBM.

## III. CHAINING CNOT GATES

When comparing quantum algorithms to classical competitors, claims of speedups often assume full connectivity between all qubits in the quantum system. By connectivity, we refer to the ability of two qubits to perform a 2-qubit operation. However, if one looks to the foreseeable future of qubit technologies, it is possible that a fully connected superconducting 20 or 50+ qubit device may be upward of a decade or more away. Thus, in order to compensate for lacking connectivity, quantum algorithms will need to be adapted to fit the various existing architectures.

In this section, we investigate the effectiveness of using CNOT gates (control-*X* gates) as a means of compensating for limited qubit connectivity. We study the reliability with which one can use a series of CNOT gates to invoke a control operation between distant qubits, which do not directly share a connection. Figure 7 shows an example of a length-3 chain (two intermediate qubits separating the control and the target), achieving a CNOT operation between qubits *A* and *B*.

In Fig. 7, qubits such as 1 and 2, which only serve an intermediate means for connecting *A* and *B*, are often referred to as ancilla qubits. Such qubits play a pivotal role in delivering the control operation between the distant computational qubits (*A* and *B*) and in principle are meant to have no direct impact on the success of the algorithm. In practice, however, this last point can be difficult to control as merely their incorporated presence in the quantum system can lead to new sources of error. Additionally, this problem can become compounding as certain algorithms may require the use of the same ancilla qubits several times, requiring proper handling of these qubits after each use.

### A. Delivering desired states

In testing the effectiveness of IBM’s 20-qubit device for implementing CNOT chains, the overall goal of each experiment is to measure both the starting and the final (control and target) qubits in the |1⟩ state. This is carried out by exciting the initial control qubit into the |1⟩ state with an *X* gate, followed by a series of CNOT gates along some path of ancilla qubits. For each path studied, we examine three circuits (Fig. 8), two such that the desired final state of the system contains all of the ancilla qubits in the |0⟩ state and one for |1⟩. The motivation for studying multiple variations of each chain circuit stems from whether or not a certain algorithm requires the ancilla qubits to be reset for future use, oftentimes determined by whether or not the control qubit contains superposition.

The left circuit in Fig. 8 is the simplest form of a CNOT chain, where the ideal final state of the system leaves each ancilla qubit in the |1⟩ state. More generally, this circuit represents the case where the ancilla qubit states are inconsequential. That is to say, the only desired effect is such that the distant control and target qubits are both in the |1⟩ state, completing the effect of the computational CNOT gate between them with no intended future use of the ancilla qubits. Conversely, circuits of the center and the right type are designed such that the desired final state of the system leaves each ancilla qubit back in the |0⟩ state, representing the case where one anticipates future use from these ancilla. For instances where one knows that the initial control qubit is purely in the |1⟩ state, the central circuit would be optimal due to the use of only single qubit gates for resetting the ancilla. However, for more general cases in which the control qubit may contain superposition, the additional CNOT gates are necessary for resetting.

### B. Experimental design

CNOT chain paths were designed for IBM’s 20-qubit Poughkeepsie architecture, and Fig. 9 illustrates the general layout for each experiment, showcasing the longest path of ancilla qubits tested for a single CNOT chain (touching all 20 qubits on the device). In addition to the maximum, all intermediate lengths were tested as well, keeping the control qubit fixed and moving the final target qubit along the path shown.

### C. Experimental results

Presented here are the results experimentally gathered for the various CNOT chain experiments, testing each of the circuit types illustrated in Fig. 8 across all four path orientations. In all of the coming results, we distinguish the measurement outcomes from each experiment into three categories based on the state of the control, target, and ancilla qubits. First, any measurement outcome yielding either the control or the target qubit in the |0⟩ state is considered a failure. Next, we separate cases where the CNOT chain successfully yields both the control and target qubits in the |1⟩ state into two groupings based on the final state of the ancilla qubits. The more lenient of the two metrics, which we call *f*_{1}, tracks the final state of only the control and target qubits, regardless of the ancilla qubits. Conversely, the second state fidelity metric, *f*_{2}, tracks the percentage of trials where *all* qubits in the system are found to be in their theoretically desired state of either |0⟩ or |1⟩.

In the equations shown above, the states |CT⟩ and |A⟩ represent the final measured states of the control and target and the intermediate ancilla qubits, respectively, on a computational basis. The state |A′⟩ represents the desired final state for the ancilla qubits, either |0⟩ or |1⟩, according to the circuit types laid out in Fig. 8. Using the metrics *f*_{1} and *f*_{2}, we present the first of the two experimental findings regarding CNOT chains in Fig. 11, demonstrating differences in fidelities as a consequence of the four path orientations shown in Figs. 9 and 10.

When comparing the plots in Fig. 11, it is clear that there are some noticeable differences in fidelity rates between the various paths, some as large as 10%–20% after length-10 chains. Interestingly, a closer look at the data reveals distinct drops at certain chain lengths, particularly for paths 2 (circles), 3 (diamonds), and 4 (squares). Upon further investigation into the location of each path’s drop in fidelity, we find that they all occur at qubit 7 (see Fig. 9), which was later confirmed to have the lowest *T*_{1} at the time of the experiments. Thus, these results demonstrate how the location of a single noisy qubit can lead to varying algorithmic success rates based on circuit configuration, which is a result that will be further demonstrated in later experiments. Next, we present CNOT chain results which showcase each of the circuit techniques in Fig. 8 and their effectiveness at controlling the final state of the ancilla.

The results shown in Fig. 12 represent average fidelities obtained from the four path orientations. Beginning with *f*_{1}, the data show that the presence of additional *X* gates for resetting ancilla qubits has no impact when compared to using no gates, demonstrated by the overlap of the circle and triangle plots. This agrees with what one would expect theoretically, given that the chain of CNOTs in both circuits are chronologically the same, therefore uninfluenced by any later gate operations on each ancilla qubit. Additionally, the total lengths of time for each circuit are nearly identical, only differing by a single *X* gate. Conversely, because of the way in which the additional CNOT gates are staggered in the third circuit type (squares), we see a decrease in *f*_{1} fidelity resulting from the fact that these extra gates ultimately delay the final measurement, effectively creating more time for decoherence errors on the control and target qubits.

Now turning to the results for each circuit’s *f*_{2} rates, the bottom plot in Fig. 12 demonstrates each circuit type’s ability to produce reliable ancilla states. Using the case of no gates as a baseline, the data show that the usage of *X* gates can lead to a drastic improvement while the use of CNOT gates has the opposite effect. When comparing the plots for *X* gates vs no gates, the data show a widening gap as a function of chain length. We can understand this trend as a result of *T*_{1} decays, which become more problematic as the number of ancilla increases (more opportunities for collapse), as well as circuit length (more time that each qubit must maintain its excited state). Conversely, the usage of additional *X* gates immediately after each CNOT resolves this problem by effectively minimizing the time each ancilla qubit is subject to *T*_{1} relaxation, regardless of chain length.

Finally, the results for the circuit type utilizing CNOT gates shows the worst *f*_{2} rates between the three. Conceptually, resetting the ancilla qubits in this way is plagued with several issues, the worst of which being increased circuit length. By requiring an entire second CNOT chain for resetting, ancilla qubits closer to the control must maintain their excited state for almost double that of the other two circuits. Additionally, the success of each ancilla being properly reset is conditioned on the one prior, which means that a single intermediate *T*_{1} relaxation is enough to disrupt the entire resetting process. Although this circuit type has been shown to be the worst in both *f*_{1} and *f*_{2} fidelities, it is important to note that amongst the three circuit types, it is the only one which can properly reset ancilla when the control qubit is in a superposition. Thus, despite the advantage in ancilla control achieved by using *X* gates, oftentimes, the requirement of superposition in algorithms forces the use of additional CNOT gates.

## IV. QUBIT GEOMETRY AND ALGORITHM DESIGN

Having now seen the extent to which a single CNOT operation can be reliably transmitted across ancilla qubits, the next question is how useful could such chains be for constructing larger circuits? With limited connectivity on future NISQ devices being the expected standard, near term quantum circuits will need to critically rely on ancilla qubits and various techniques for algorithm implementation. In this section, we present several qubit geometries and circuit implementations for which we present experimental results later (see Secs. V and VI).

### A. 3 qubit geometry

Despite lacking any set of three directly interconnected qubits, the Poughkeepsie architecture possesses numerous combinations of three linearly connected qubits, as shown in Fig. 13. Using qubits in this way to implement 3-qubit algorithms has the advantage of avoiding the need for any additional ancilla qubits but becomes problematic when 2-qubit gate operations are required between the outer two qubits. Compensating for this lacking connection requires additional 2-qubit gates through the central qubit, typically SWAP gates, which consequently increase circuit length and noise susceptibility.

When implementing 2-qubit gate operations between the two unconnected qubits shown in Fig. 13, the challenge lies in protecting the central qubit from additional noise while simultaneously ensuring that its quantum state is unaltered in the end. The standard approach for implementing a 2-qubit gate between qubits 1 and 3 shown in Fig. 13 would be to use SWAP gates, which effectively interchange the quantum state held on two qubits. Through the use of SWAP gates, the quantum states held on distant qubits can be swapped onto qubits which possess a direct connection, allowing for the 2-qubit gate operation to occur.

The circuits shown in Fig. 14 are those tested in the coming experiments. While not always optimal in circuit depth and gate count, each circuit is guaranteed to accomplish two things: (1) the successful implementation of the 2-qubit operation between the distant qubits and (2) the central qubit is always returned back to its initial quantum state. This second point comes at the cost of the second SWAP gate in each circuit, where notably this is where one typically looks to optimize when possible.

### B. 4 qubit geometry

If one wishes to avoid interchanging any computational qubits in order to compensate for missing connections, such as with the 3-qubit geometry, then one is forced to increase the size of the quantum system through the introduction of ancilla qubits. Figure 15 illustrates one such solution using a single central ancilla qubit to supply all 2-qubit gate operations between the surrounding three computational qubits.

The 4-qubit geometry shown in Fig. 15 represents an alternative to the problem of the 3-qubit geometry discussed earlier, using a single ancilla in order to avoid any additional SWAP gates on the computational qubits. However, using a single ancilla for all 2-qubit gates requires that the state of the ancilla be properly reset after each usage in order to ensure the success of future gate operations. Figure 16 shows two examples for resetting the ancilla qubit when implementing a CNOT gate between computational qubits, where the choice for resetting depends on the presence of superposition on the control qubit.

When comparing the 3 and 4-qubit geometries, the question is whether or not the additional ancilla qubit aids or hinders algorithmic success. By requiring all 2-qubit gate operations traverse through a single qubit, a heavy burden is placed on the 4-qubit geometry’s ancilla in terms of proper state manipulation and minimizing noise. A similar burden is placed on the central qubit in the 3-qubit geometry, leading one to expect that a majority of algorithmic success is tied to these central qubits’ coherence properties and gate fidelities.

### C. 6 qubit geometries

As the final qubit geometry size tested in this study, we present here two 6-qubit geometries, shown in Fig. 17, as well as their possible locations on the Poughkeepsie chip, shown in Fig. 18. The two 6-qubit geometries shown are motivated by the respective strengths and weaknesses anticipated of the 3 and 4-qubit geometries already mentioned. Specifically, the left circuit in Fig. 17 (“3 chain”) contains the same connectivity between the three computational qubits as the 3-qubit geometry, sharing the advantage of having two-out-of-three direct connections. Conversely, the right geometry (“1 chain”) uses one ancilla for all 2-qubit gate operations just as with the 4-qubit geometry but avoids the issue of repeated single ancilla use by using a different ancilla between each computational qubit. While not expected to outperform the other two configurations, the two geometries put forth in Fig. 17 are designed to provide additional insight into the role of using ancilla in implementing algorithms over more sparse architectures.

## V. CCNOT EXPERIMENTAL RESULTS

For the progression of quantum computing, the importance of the CCNOT (control-control-*X* gate) operation, also known as a Toffoli gate, cannot be understated as numerous quantum algorithms critically rely on its usage. This includes algorithms which rely on oracles such as Grover’s,^{3} modular multiplication like Shor’s,^{35} higher order control operators for quantum phase estimation (QPE),^{36} or creating entanglement through mixing operators like in the QAOA (quantum approximate optimization algorithm),^{37} just to name a few. Unlike previous operations studied up to this point, however, the CCNOT gate is better thought of as a quantum circuit, consisting of several single and 2-qubit geometries, as shown in Fig. 19.

In order to implement the quantum circuit outlined in Fig. 19, one necessary condition is that the three qubits be interconnected, requiring CNOT gates between the target and control qubits, as well as the two controls. As already mentioned, however, such connectivity does not exist on IBM’s 20-qubit Poughkeepsie architecture, which means the circuit must be adapted to fit the various qubit geometries laid out in Sec. IV.

### A. 3 qubit results

In testing the CCNOT circuit using three linearly connected qubits, there are two unique configurations for which one can implement the control and target qubits. Specifically, one can have the target qubit be either an outer (referred to as “CCT”) or a central (“CTC”) qubit. Due to the design of the CCNOT circuit, which requires exactly two CNOT gates between all three qubits, both configurations result in the same circuit depth and gate count when using SWAP gates to supplement the missing outer connection. In total, the Poughkeepsie architecture possesses 32 possible 3-qubit combinations, all of which were tested using both configurations, and the results are shown in Fig. 20. In each trial, the control and target qubits are prepared in the |1⟩ and |0⟩ states, respectively, before passing through the CCNOT circuit. Just as with the CNOT chain experiments, we are interested in the fidelity of the final measured state, where the target and both control qubits are all found to be in the |1⟩ state,

Figure 20 shows the fidelity rates found across the 96 tested CCNOT circuit implementations (three unique locations for the target qubit per each of the 32 total combinations). As illustrated by the colors and numerical values, it is clear that no single combination of qubits or orientation is dominant in producing the best CCNOT fidelity. While certain combinations produced worse fidelities as a result of noisier qubits, the data suggest that on average, one can expect a successful CCNOT gate implementation on the order of 50%–60%, with only a select few noisy qubits reducing these values to around 25%–40%.

### B. 4 and 6 qubit results

When analyzing the results for the 4 and 6-qubit geometry implementations of the CCNOT circuit, the addition of ancilla qubits requires the tracking of the *f*_{2} metric in addition to *f*_{1}. The interest is once again in how well each qubit configuration can reliably reset their respective ancilla qubits back to the |0⟩ state through the use of either *X* or CNOT gates,

Beginning with the 4-qubit geometry, two cases for handling the resetting of the ancilla qubit were tested, corresponding to the two implementations shown in Fig. 16. For each implementation, all six possible 4-qubit combinations on the Poughkeepsie architecture (see Fig. 21) were experimentally tested, setting each of the three outer qubits as the target. The average results for each qubit combination are shown in Fig. 22.

When looking at the results shown in Fig. 22, it is clear that the use of *X* gates for resetting the central ancilla qubit produces noticeably higher fidelities, both for *f*_{1} and *f*_{2}. This is in agreement with the CNOT chain results from earlier (Fig. 12), once again highlighting the cost in ancilla control when forced to implement CNOT gates to account for superposition. If we now compare these results to those of Fig. 20, we find that the fidelities between the 3- and 4-qubit geometries using *X* gates are comparable, with a slight edge going to the 3-qubit geometry. The closeness of the two results suggests that the use of an ancilla qubit, instead of SWAP gates through a computational qubit, is a viable approach for CCNOT algorithm design. However, this viability is lost when superpositions must be accounted for, which are handled automatically by SWAP gates for the 3-qubit geometry but require CNOT gates for the 4-qubit geometry.

Proceeding now to the 6-qubit geometries, Fig. 23 shows the full results for the two implementations illustrated in Fig. 17, once again separated into the metrics *f*_{1} and *f*_{2}. Overall, the data show that the “3 chain” circuit implementation yields comparable fidelity rates to the 4-qubit configurations using *X* gates. However, the use of a single ancilla between each computational qubit shows a dramatic decrease.

When comparing the two circuit designs, which only differ in the manner in which the ancilla qubits are distributed, it is important to note that both circuit implementations use the same total number of CNOT and *X* gates, producing near identical circuit depths. Additionally, in both cases, each ancilla qubit is called upon exactly twice, followed immediately by *X* or CNOT gates for resetting back to the |0⟩ state. These consistencies suggest that the results shown in Fig. 23 are then attributable to the *way* in which the CNOT gates are distributed throughout the circuits.

More specifically, if we return to the results of the CNOT chain experiment, as well as focus on the fidelities found for chains of 1 and 3 ancilla qubits, we can approximate the average *f*_{1} fidelities to be 0.9 and 0.85. If we now compare the way in which each circuit requires CNOT chains in order to supplement missing connections, we find that the “3 chain” configuration only needs two successful chains, while the “1 chain” configuration is reliant on six. Using our example approximate fidelities, this means that we would expect the probability of success from each circuit to be (0.9)^{6} and (0.85)^{2}, respectively, heavily favoring the “3 chain” circuit design. Thus, in determining how best to arrange computational and ancilla qubits for algorithm design, the results shown above suggest that grouping computational qubits closer together, in favor of fewer but longer ancilla chains, will lead to better algorithmic success.

## VI. QUANTUM FOURIER TRANSFORMATION

Having just seen the varying degrees to which the Poughkeepsie architecture can handle CCNOT circuits, we now turn to another critical subroutine for quantum computing, the quantum Fourier transformation (QFT). In this section, we present experimental results which demonstrate the reliability with which one can successfully perform a 3-qubit QFT using the various qubit geometries outlined earlier. At its core, the QFT is the quantum equivalent to the discrete Fourier transformation, applied to a quantum state. The power of the QFT lies in its ability to apply up to 2^{N} unique phases across the various components of a quantum state, where *N* is the number of qubits. The core element necessary for any successful QFT is the control-*R*_{ϕ} gate, which applies an arbitrary phase to a target qubit’s |1⟩ state, conditional on a control qubit,

Just like the CCNOT circuit, the QFT requires full connectivity between all qubits. The standard quantum circuit for a 3-qubit QFT is shown in Fig. 24 (technically a QFT^{†} circuit, which we discuss in the coming section), which we adapt accordingly for the various qubit geometries. When physically implementing these 3-qubit QFTs, note that the true gate count for each control-*R*_{ϕ} gate includes additional CNOT and *R*_{ϕ} gates. As a result, the circuit depth and total gate count for the 3-qubit QFT turns out to be comparable to those of the CCNOT circuit, which in turn will provide some insight when comparing the success rates between the two.

### A. Testing QFT^{†} with phase estimation

In order to isolate and benchmark the success of the QFT^{†} circuit in Fig. 24 in a way similar to the previous sections, one ideally needs an experiment where the effect of the QFT^{†} produces a single desirable final state. However, unlike the CCNOT operation whose effect is directly observable by means of the target qubit, the QFT^{†} is a more versatile quantum operation whose effect ranges widely based on the state of the qubits it is applied to. To this end, we quantify the fidelity of our QFT^{†} implementations in a manner analogous to the quantum phase estimation (QPE) algorithm,^{36,38} where the effect of the final QFT^{†} leaves all of the qubits in a final state containing no superposition. By creating very particular superposition states just prior to the QFT^{†} operation, we are guaranteed to have theoretical |0⟩ and |1⟩ final states for the computational qubits, with which we can then use to compute fidelities *f*_{1} and *f*_{2}.

Quantum phase estimation is a quantum algorithm which uses a control-U operation, along with one of its eigenstates |*μ*⟩, in order to detect some unknown eigenphase *e*^{iθ}. An example QPE is shown in the top circuit of Fig. 25. Creating such a circuit is typically very challenging as both the implementation of arbitrary control-U operators and their eigenstates require clever circuit design. For the purpose of our QFT benchmarking, however, we apply the core idea of the QPE in a much simpler form, effectively achieving the states resulting from the control-U operations acting on |*μ*⟩ with only *R*_{ϕ} gates, illustrated by the bottom circuit in Fig. 25.

By using single qubit rotation gates to initialize the computational qubits, we are able to prepare quantum states just prior to the QFT^{†} with high fidelities, minimizing any additional noise not caused by the QFT^{†} circuit. Additionally, the use of *R*_{ϕ} gates allows for the creation of a wider range of states than typically achievable through the use of control-U gates, which we in turn use for further insight into the viability of the QFT^{†} circuit in later experiments.

### B. Perfect phase detection

For the case of a 3-qubit QFT^{†}, there are exactly eight choices for *ϕ* such that the bottom circuit in Fig. 25 will result in a final state containing no superposition. These eight values of *ϕ* span an even distribution from 0 to $7\pi 4$, corresponding to the eight unique quantum states from |000⟩ to |111⟩. These eight states will serve as the desired final measurements for determining fidelities,

In the QFT^{†} fidelity results to come, the highest fidelity rates from experiments 21–23 were used to determine which qubits to experimentally test. Specifically, the top three qubit combinations for each geometry which yielded the highest fidelities were tested and then averaged together. For the 3-qubit geometries, the top three qubit combinations for both control-target orientations were tested. For the 6-qubit geometries, only the “3 chain” orientation was tested (preliminary results showed once again a significant decrease in fidelity rates for the “1 chain” orientation). Finally, because the QFT^{†} circuit is always acting on a superposition state of the computational qubits, both the 4 and 6-qubit geometries require CNOT gates for resetting ancilla qubits.

Beginning with *f*_{1}, the results shown in Fig. 26 reveal that the 4-qubit geometry leads to the overall highest QFT^{†} fidelities across all eight phases. In addition to the high *f*_{1} rates, the accompanying high *f*_{2} values suggest that one could also reliably perform further gate operations after the QFT^{†}. Behind the 4-qubit geometry, we find that the 3- and 6-qubit geometries produced fidelities of the order of 55%–65% and 30%–40%, respectively.

Based on the results from the CCNOT experiments, the higher fidelity rates of the 4-qubit geometry may come as a surprise at first glance. However, in analyzing the two top performing geometries and their circuit implementations, the key to the 4-qubit geometry’s success lies in the ordering of the control phase gates. Specifically, the $\u2212\pi 2$ and $\u2212\pi 4$ control-*R*_{ϕ} gates which happen in succession, originating from the same computational qubit, allow for a slight optimization in the 4-qubit circuit.

As illustrated in Fig. 27, the difference in implementation between the 3- and the 4-qubit geometries boils down to the extra CNOT gates necessary to compensate for each configuration’s lacking connectivity. While the 3-qubit geometry requires two SWAP gates, for a combined total of six additional CNOT gates, the 4-qubit geometry only requires four. Typically, each control gate would require two CNOTs for resetting, but since two of them originate from the same computational qubit with no gates in between, there is no need to reset the ancilla qubit back down to the |0⟩ state after the first $\u2212\pi 2$ gate. Thus, the results shown in Fig. 27 demonstrate that an ancilla qubit can potentially be used to optimize circuit depth and consequently improve algorithm success.

In addition to the qubit geometry discrepancies, a second interesting result emerging from the data reveals an alternating pattern in fidelities between phases. This pattern is present across all three qubit geometries, suggesting that this phenomenon is inherently linked to QPE itself. One possible explanation for this trend could be in the complexity of the quantum state just prior to the QFT^{†} circuit. Specifically, the superposition states created from the even integer cases of $\pi 4$ contain at most four unique phases, namely, $18$, $\u221218$, $i8$, and $\u2212i8$, across the eight computational basis states. Conversely, the odd integer cases contain four additional phases, $\xb11\xb1i4$, producing superposition states where each basis state has a unique phase. Since these quantum states have more relative phases between the eight computational basis states, it is possible that they are more sensitive to noise and errors, leading to lower fidelity rates after the QFT^{†} circuit.

### C. Continuous phase detection

Following from the data trends revealed in Sec. VI B, we now present experimental results which are motivated by a more realistic usage of the QPE Algorithm. Specifically, we present results which extend the data shown in Fig. 26, testing for intermediate values of *ϕ*, ultimately attempting to detect phases which do not match up perfectly with one of the 2^{N} basis states created from the number of qubits being used. Detecting these “non-perfect” phases comes with an inherent probability of failure, even for a noiseless quantum computer, as the resulting final states from the QFT^{†} now contain superposition. Consequently, one expects lower fidelities in regions of *ϕ* between the 2^{N} perfect phases, with the lowest points being exactly halfway between each perfect phase (∼40% for a noiseless 3-qubit QPE). Figure 28 confirms this trend, illustrating fidelity swings of nearly 50% for changes in *ϕ* as little as $\pi 16$.

The *f*_{1} rates illustrated in Fig. 28 are in agreement with those found in the previous experiment, showing fidelities on the order of 60%–75% around the eight perfect phases. Additionally, we once again see the alternating peaks in success between the odd and even integers of $\pi 4$, now extended to the nearby regions of *ϕ* as well.

When comparing the data from Fig. 28 to what one would expect from a noiseless quantum computer, the quantity of interest here is the way in which noise affects the full range of phase values. Specifically, since the anticipated results have fewer than 100% theoretical fidelities, one might anticipate the manner in which noise impacts these fidelities in one of two ways. Supposing one finds a 75% fidelity for the perfect phases, would the presence of noise cause intermediate values of *ϕ* to similarly yield 75% of their theoretical maxima or simply result in a flat 25% reduction across the board (down to lows of fully decohered states)? The results from Fig. 28 confirm the impact of noise to be of the former case, showing that on average, the measured *f*_{1} rates for both geometries across the full range of *ϕ* are around 60%–75% of their theoretical values. In terms of NISQ era algorithm design, this means that quantum algorithms which may rely on low probabilities are still viable, whereas noise of the latter case would be far more detrimental.

## VII. CONCLUSIONS

The experimental results in this paper have showcased various qualities of IBM’s 20-qubit Poughkeepsie architecture. In analyzing these results, it is important to keep in context the steadily improving technology of quantum computers, specifically superconducting qubits in this case. In the coming years, it is reasonable to expect quantities such as *T*_{1} and *T*_{2} coherence times and gate fidelities to continually improve. In anticipation of better qubits, however, the results from this study demonstrate inherent properties in algorithm design which go beyond qubit quality.

In testing the CNOT chains across all 20 qubits, the difference in fidelity rates between using *X* gates vs CNOT gates for resetting ancilla qubits was very pronounced. This in turn demonstrates the potential for improving algorithm design when working with qubit geometries of limited connectivity, where knowledge of where and when qubits contain superposition in a circuit can be used to optimize ancilla qubit resetting. Additionally, the study of the various qubit geometries and their performance in implementing the CCNOT and QFT^{†} operations further showcased the challenges of circuit design with limited connectivity. When determining the best geometry of computational and ancilla qubits for implementing an algorithm, our results demonstrated pros and cons of various configurations, ultimately showing that for certain circuits, ancilla qubits can be used to potentially reduce total gate counts.

## DATA AVAILABILITY

The data that support the findings of this study are available from the corresponding author upon reasonable request.

## ACKNOWLEDGMENTS

The authors gratefully acknowledge support from the National Research Council Associateship Program, Award No. FA9550-18-D-0002. Special thanks to Dan Campbell for his numerous insightful talks throughout this project. The authors would also like to thank the IBM Quantum Experience team and all of their support. Any opinions, findings, conclusions, or recommendations expressed in this material are those of the author(s) and do not necessarily reflect the views of the AFRL.