{'fraction_non_alphanumeric': 0.02789946967950196, 'fraction_numerical': 0.00845438475136423, 'mean_word_length': 5.1060534960112625, 'pattern_counts': {'":': 0, '<': 0, '<?xml version=': 0, '>': 0, 'https://': 0, 'lorem ipsum': 0, 'www.': 0, 'xml': 0}, 'pii_count': 0, 'substrings_counts': 0, 'word_list_counts': {'cursed_substrings.json': 0, 'profanity_word_list.json': 0, 'sexual_word_list.json': 0, 'zh_pornsignals.json': 0}}
Comparison of Cloud-Based Ion Trap and Superconducting Quantum Computer Architectures

Quantum computing represents a radical departure from conventional approaches to information processing, offering the potential for solving problems that can never be approached classically. While large scale quantum computer hardware is still in development, several quantum computing systems have recently become available as commercial cloud services. We compare the performance of these systems on several simple quantum circuits and algorithms, and examine component performance in the context of each system's architecture.


INTRODUCTION
Quantum computing is a revolutionary form of information processing that is capable of solving some computational problems faster than conventional (classical) approaches [1,2]. Quantum information is represented by qubits, which can exist in superpositions of 0 and 1. Multiple qubits can be prepared in entangled states that generally possess an exponential number of superposed states, providing a quantum computer its power. Quantum algorithms can be expressed in terms of circuits involving universal discrete quantum gate operations that entangle qubits, akin to wiring transistors together to perform logic operations in classical computers.
Recently, gate-based quantum computers have become available as cloud computing services, hosted by IBM [3] and Amazon Web Services [4]. Two significantly different hardware types, ion traps and superconducting qubits, are featured on these cloud providers. Control over quantum circuits in each system is limited to certain quantum logic gate operations, and their qubits have significantly different architectures and error processes.
Here, we report the execution of several small quantum circuits and based on their performance, we investigate fundamental properties of these quantum systems such as qubit connectivity, gate noise and its accumulation, and State Preparation and Measurement (SPAM) error. Qubit noise, gate noise, and their accumulation is tested by performing increasing numbers of operations between two qubits. SPAM error is extracted by measuring qubits immediately after initialization in definite qubit states. Qubit connectivity is indirectly probed by implementing the Bernstein-Vazirani quantum algorithm [5] with various levels of circuit complexity.

QUANTUM COMPUTER SYSTEMS AND OPERATIONS
The physical architectures of these cloud based quantum computers fall into two categories: ion traps and superconductors. Both systems store information in a collection of qubits, with the two states |0 and |1 representing quantum states native to their particular hardware. The systems can express any quantum circuit in terms of a series of single-and two-qubit gate operations [6]. Our analysis focuses on the performance of two-qubit operations, as these typically dominate errors and facilitate communication between qubits.
Ion trap quantum computers store qubits in the internal states of individual electrically charged atoms (ions). The ions are laser cooled and confined with electric fields from nearby electrodes, forming a 1D crystal in free space and in a vacuum environment, as shown in Fig.  1 [7,8]. Quantum gates are accomplished by poking the ions with focused laser beams that affect a qubit statedependent force that modulates the Coulomb interaction between the ions and effectively "wires" together any pair of qubits [9]. The ion trap system we use, produced by IonQ, features "rotation" gates R(θ, φ) for single-qubit operations [1] and Ising (XX) gates for two-qubit entanglement, as described in Fig. 2 [10].
Superconducting quantum computer systems store qubits in Josephson junctions typically arrayed on a 2D lattice (see Fig. 1) and cooled to very low temperature [11]. Here, quantum gates are executed by running electrical currents through the device in a way that either changes the state of a single qubit or exploits the nonlinear interaction between adjoining qubits. The superconducting systems we use, produced by IBM and Rigetti, feature R(θ, φ) rotation gates for single-qubit operations. The IBM systems use cross-resonance (ZX) gates for two-qubit entanglement [12], and Rigetti systems use controlled-Z (CZ) gates for two-qubit entanglement operations [13]. The quantum computers we test each have a unique qubit layout or topology that forms a graph, whose vertices represent individual qubits and edges between vertices represent the ability to directly perform a two-qubit operation between the qubits. Connectivity characterizes how many distinct connections can be made between the vertices in the graph. When a two-qubit operation is performed between two qubits not directly connected, it must be decomposed into a series of SWAP (or other) operations involving intermediary qubits. The resultant increase in circuit complexity generally degrades performance for circuits that demand more connectivity than the system topology offers. Superconducting sys-tems generally have fewer connections because of the twodimensional wiring between nearest-neighbor Josephson junctions. On the other hand, ion trap quantum computers can be fully connected with direct gates available between any pair of qubits [14,15]. Fig. 3 plots the connectivity graphs of the machines we used. Quantum algorithms and circuits are typically expressed in terms of a universal standard gate set, such as the single-qubit Hadamard and T gate plus the twoqubit Controlled-NOT (CNOT) gate, shown in Fig. 4 [1]. Running algorithms and circuits on a quantum computer generally requires a compilation step, where the standard gates are converted to native gates. For instance, the Hadamard gate is expressed as two rotations H = R(π, 0)R(π/2, π/2) and the CNOT gate is expressed as CZ, XX, or ZX native gates with additional single qubit rotations [16].
Cloud quantum computing systems utilize transpilation, a heuristic process to simplify and optimize the circuits they run [17]. For example, if multiple consecutive rotation operations are performed on a single qubit, the transpiler reduces them to a single rotation. When qubits are stored in disparate energy levels, perfoming a singlequbit phase gate [1] can be replaced by a much simpler classical phase advance on the driving field for the next gate. Finally, operations with pure |0 or |1 inputs can be propagated classically, thus simplifying parts of the circuit. There are many other compilation and transpilation techniques on cloud servers that are not obvious to the user, and this can make it difficult to extract performance metrics of the native components.
Quantum algorithms and circuits typically have three stages: initialization, coherent quantum gate operation, and measurement. Below, we perform a series of experiments on the cloud quantum computers to analyze the performance of each of these steps.

STATE PREPARATION AND MEASUREMENT
We first examine the efficacy of state preparation and measurement (SPAM). We measure SPAM error by initializing a single qubit in either the |0 or |1 state, then immediately measuring the qubit. SPAM error is not expected to be symmetric, because the physical qubits occupy different energy levels and the detection process itself is not symmetric: one state generates a physical signal (an electrical current in the case of superconductors [11] and photonic counts in the case of trapped ions [8]) while the other state is a null signal. We observe that the superconducting systems have somewhat higher SPAM errors for the |1 state. We are unable to directly measure SPAM error for the |1 state on the IonQ computer, because for this trivial operation the transpiler simply complements the |0 measurement. However, this system is reported to have an average SPAM error (both states of all qubits) of 0.002 [18].  [18].

GATES
We characterize two-qubit gate quality by running simple circuits and measuring departures from the expected outputs. Fig. 5 shows an example circuit composed of a series of CNOT gates where we measure one of the output qubits. To bypass transpilation of the circuit, we surround the CNOT gates with X ≡ R(π, 0) and Y ≡ R(π, π/2) rotation operations, and the entire circuit is surrounded by Hadamard gates. The effects of the single qubit gates are expected to be much smaller than the two-qubit CNOT operations. For the IBM-Melbourne system, we observe a consistent decrease in performance with circuit depth, converging to a success rate of 0.5, which is expected from incoherent noise accumulation. The overall trend of circuit performance closely follows a Gaussian function with a characteristic 1/e degradation after approximately 28 CNOT gates. On IonQ and Rigetti systems, transpilation of the circuit prevents a similar test of two-qubit gate fidelity. We instead run successive SWAP operations between two qubits initialized in the |0 state, as shown in Fig. 7. Again, we circumvent the transpiler reduction of the circuit by surrounding the sequence of SWAP gates with Hadamard gates. The error due to these additional gates (as well as the SPAM error) is much lower than the twoqubit gate error and also constant for each circuit, while the error due to the SWAP operations accumulates and is readily observed.
We observe a general decrease in circuit performance with respect to the number of SWAP operations per- 7. Circuit for testing two-qubit gate error accumulation. The boxed portion of the circuit (a single SWAP) is repeated, to examine degradation in performance of larger circuits. formed. We expect the state probability to converge to 0.25, expected from incoherent noise accumulation. However, the observed decay does not follow an exponential law. Moreover, the probability in the Rigetti Aspen-8 system dropped to below 0.05 for the 11 and 12 SWAP operations, possibly indicating the presence of coherent or systematic errors. Extrapolation of success rates to 0 SWAP gates gives a rough estimate of constant (depth-independent) noise levels on each system. We use a linear regression model on the first 4 data points for each system, to approximate the relationship between performance and circuit depth for smaller circuits. For IonQ, this model yields an intercept of 0.999, with each set of three CNOT gates decreasing success probability by 0.0935. This intercept is not far from the SPAM error observed for IonQ in Ta optimal implementation of BV on this system would still only allow for three direct CNOT connections.
On BV-10, the IBM-Melbourne system shows a steep drop in performance beyond a Hamming weight of 1-2. This may be attributed to crosstalk errors, where noise from a qubit can influence adjacent qubits, resulting in lower overall success rate for any number of CNOT operations. Additionally, IBM-Melbourne's nearest-neighbor connectivity (Fig. 3b) only allows for a maximum of 3 direct connections to a single qubit, requiring additional (noisy) SWAP operations. The IonQ system shows a modest drop in performance with Hamming weight, but because of its full connectivity, this is consistent with simple accumulated gate errors.
It should be noted that the best classical success rate for successfully determining the hidden n-bit string is 1/2 n−1 ; because only one query of the BV oracle is allowed, the classical solution determines one bit of the string and guesses all the others. Thus, for BV-10, even a 1% success rate is better than the optimal classical solution.

OUTLOOK
While comparing circuit and algorithmic performance on these cloud quantum computer systems is straightforward, it is difficult to extract component performance or predict performance on other complex circuits. Our measurements show strong variations in circuit performance, possibly due to compiler/transpiler processes native to each system. For example, when comparing the twoqubit SWAP sequence of Fig. 7 vs. the BV-10 circuit in Fig. 10, the inferred two-qubit gate errors in each system differ significantly. This could be a result of each system's compiler or transpiler simplifying circuits in a different way. However, BV performance also depends critically on connectivity and crosstalk errors, which vary strongly between the systems.
A drawback in our analysis of these quantum computer cloud systems is a lack of information on aspects such as qubit assignment, compiler/transpiler methods, component drift rate, and time since last calibration. With significant time delay between submitting a circuit to the cloud and receiving a result, we cannot pinpoint the times at which calibrations occur, and how these errors influence our findings. We observe significant fluctuations in circuit performance between runs on all systems, and we suspect these systematic errors overwhelm any statistical errors. In the future, it will be interesting to run the same circuit over a wider range of time, which, along with access to detailed information on component performance, could control for such errors.