Software-Hardware Co-Optimization for Computational Chemistry on Superconducting Quantum Processors

The central building blocks of chemistry simulation circuits are Pauli string operators. An $n$-qubit Pauli string $P$ is an array $P=G_{n-1}G_{n-2}\dots G_{0}$ where $G_{i}\in\{I,X,Y,Z\}$ for the $i$th qubit and $0\leq i<n$. $X$, $Y$, $Z$ are the three Pauli operators and $I$ is the identity operator.

Time evolution: In quantum physics, the time evolution of a system is determined by the system Hamiltonian $H$, and the unitary that represents this time evolution is $exp(i\theta H)$ where $\theta$ is a parameter to represent time. Usually, we do not directly implement $exp(i\theta H)$ in a quantum circuit since it is hard to directly synthesize $exp(i\theta H)$ into basic single-qubit and two-qubit gates efficiently. Instead, we first decompose $H$ into a weighted sum of Pauli strings, i.e., $H=\sum_{j}w_{j}P_{j}$ where $P_{j}$ is a Pauli string and $w_{j}\in\mathbb{R}$ is its weight. The time evolution of Pauli strings $exp(i\theta P_{i})$ can be easily synthesized.

Pauli string simulation circuit: We introduce the synthesis of Pauli string simulation circuits with the examples in Figure 2. Suppose the Pauli string is $XIYZ$ on four qubits and the time parameter is $\theta$. The circuit in Figure 2 (a) shows the synthesis result. The first layer consists of some single-qubit gates. The rule is that if the operator on one qubit is $X$ (e.g., q3), then we apply an $H$ (Hadamard) gate. If the operator on one qubit is $Y$ (e.g., q1), then we apply a $Y$ gate. If it is $I$ (e.g., q2) or $Z$ (e.g., q0), no single-qubit gate is required. After applying the single-qubit gates, several CNOT gates will connect all qubits whose corresponding operators are not $I$ in the Pauli string. In this example, the CNOT gates connect q0, q1, q3 because the operator on q2 is $I$. We can first connect q0 and q1 and then connect q1 and q3, as shown in Figure 2. Then, a rotation gate is applied to rotate angle $2\theta$ along the $Z$ axis on the last qubit in the CNOT connections (i.e., q3). Finally, the CNOT gates and single-qubit gates are applied again in the reverse order. In summary, the Pauli string will determine the outermost single-qubit gates and the CNOT gates. The parameter will only affect the rotation angle of $Z$-rotation gate in the middle.

Flexible synthesis: The most expensive components for executing a Pauli string simulation circuit on a near-term superconducting quantum processor are the CNOT gates before and after the middle rotation gate. Across various qubit technologies today, (non-local) CNOT gates have an order of magnitude larger latency and error compared to (local) single-qubit gates. During the synthesis of a Pauli string simulation circuit, there is flexibility in the pattern of CNOT gates used. For example, the three circuits in Figure 2 (b)(c)(d) show three equivalent synthesis result variants of $exp(i\theta ZZZZ)$. The requirement of the CNOT gates is that they must be connected in a tree structure and the CNOT gates are then applied from the leaves to the root (the center rotation gate is applied on the root qubit). The tree structures of the three variants are shown below the corresponding circuit examples. Each qubit is a node and the CNOT gates are represented by directed edges connecting the nodes. We leverage this flexibility to guide our hardware architecture design and compiler optimizations.

We use the example in Figure 3 to briefly introduce the basics of VQE algorithm for chemistry simulation. We recommend [44] for further details.

The widely-used UCCSD (Unitary Coupled Cluster Singles and Doubles), a chemistry-inspired ansatz [47, 48], is the ‘standard’ ansatz for variational chemistry simulation. The terms in a UCCSD ansatz are similar to those in the Hamilto-nian of a chemical system. Therefore, it is expected that tuning the parameters in UCCSD can make a ‘good’ guess about the ground state. A UCCSD ansatz of $n$ qubit has $O(n^{4})$ parameters and each parameter corresponds to some Pauli strings. When implementing UCCSD in a circuit, it becomes a series of Pauli string simulation circuits with parameters, as shown in the middle of Figure 3. Implementing a UCCSD ansatz is very expensive on a superconducting quantum processor due to its large number of parameters and CNOT gates in the synthesized circuit. Our techniques will tailor the ansatz, architecture, and compiler for each other to significantly reduce the cost.

In a VQE simulation, the final observable, which is the Hamiltonian of the target chemical system, is an array of weighted Pauli strings. The UCCSD ansatz itself is also an array of Pauli string simulation circuits with their corresponding parameters (one parameter can be shared by multiple Pauli strings). We first estimate how likely the parameter tuning of each Pauli string in the ansatz can affect the final measurement and then assemble the results to estimate the importance of each parameter. The pseudo code of this importance estimation is in Algorithm 1. For a given Pauli string (denoted by $P_{a}$) in the ansatz, we compare it with each Pauli string  (denoted by $P_{H}$) in the Hamiltonian. We explain the Pauli string comparison method with an example of $P_{a}$ and $P_{H}$ shown on the left of Figure 4. For the two Pauli operators on the same qubit $q_{s}$ in the two Pauli strings being compared, we have the following three cases that will make $P_{a}$ less likely to affect the measurement result of $P_{H}$:

1. 1.

   If the Pauli operator in the $P_{a}$ is ‘$I$’ (e.g., q3), then this Pauli string simulation circuit will not apply any gate on $q_{s}$ (as shown in Figure 2 (a)) and this will make $P_{a}$ less likely to affect the measurement result of $P_{H}$.

2. 2.

   If the Pauli operator in the $P_{H}$ is ‘$I$’ (e.g., q2), then when measuring this Pauli string simulation circuit in the Hamiltonian, the measurement result on this qubit $q_{s}$ will be always be $1$ and will never be changed with respect to the parameter. This makes $P_{H}$ less sensitive to parameter tuning in $P_{a}$.

3. 3.

   If the two Pauli operators on $q_{s}$ are the same (e.g., q1), then the effect of changing the parameter in $P_{a}$ will be reduced on the measurement results of $P_{H}$. Figure 5 is a geometrical explanation. The state vector of a single qubit can be considered as a unit vector on the Bloch sphere in a three-dimensional Euclidean vector space (Figure 5 (a)). $X,Y,Z$ can represent three orthogonal axes. When applying $exp(-i\theta P)$ ($P\in\{X,Y,Z\}$) on a state vector $\ket{\psi}$, the state vector on the Bloch sphere will rotate around the corresponding axis. For example, in Figure 5 (b), the state is rotating around the $X$-axis after $exp(-i\theta X)$ is applied on it. Such rotation will not change the result when we project the state $\ket{\psi}$ onto the same axis, and therefore will not change the measurement result when the observable is $X$.

The only case left is when the two Pauli operators on $q_{s}$ are the different (e.g., q0). In this case, changing the parameter is very likely to affect the measurement result because rotation along one axis can change the projection onto another axis. For example, in Figure 5 (b), the projection result on the $Y$ axis is changed after a rotation along the $X$-axis is applied.

Suppose the number of qubits on which the Pauli operators satisfy any of the three conditions above is $d$ and we have $d=3$ in this example. How likely tuning the parameter of $P_{a}$ will affect the measurement result of $P_{H}$ is estimated to be the absolute value of the weight of $P_{H}$ multiplied by an exponential decaying term $2^{-d}$. We repeat this process for all $P_{H}$s in the Hamiltonian and obtain a score of $P_{a}$ in the ansatz. After we obtain the scores of each Pauli string in the ansatz, the importance of each parameter equals the sum of the scores of all that parameter’s corresponding Pauli strings (note that one parameter can be shared among multiple Pauli strings). For example, the importance of $\theta_{1}$ in the example ansatz on the right of Figure 4 is the sum of the scores of the first two Pauli strings ($IIIIXY$ and $IIIIYX$). The importance of the rest parameters can be calculated similarly. The time complexity of our ansatz compression algorithm is $O(n\#(P_{a})\#(P_{H}))$ where $\#(P_{a})$ and $\#(P_{H})$ are the numbers of $P_{a}$s and $P_{H}$s, respectively, and $n$ is the number of qubits.

After the importance of each parameter is determined, we can construct the new ansatz and achieve the three objectives mentioned above. First, since a small size with fewer parameters and Pauli string simulation circuits is expected, we will select only part of the parameters and Pauli string simulation circuits from the original UCCSD. The size of the constructed ansatz can be determined by a given compression ratio. Second, simulation accuracy is also desired. Therefore, we will select those components that are estimated to be more important than the remaining components. Changing the parameters in these important components is expected to have a large impact on the final simulated energy. Thus, a lower simulated ground state energy, which will be closer to the true ground state energy, is more likely to be achieved. For a given compression ratio $\alpha$, if the total number of parameters in the original UCCSD is $K$, then we will select the top $\left\lceil{\alpha K}\right\rceil$ parameters and employ their corresponding Pauli string simulation circuits. Third, we will make the constructed ansatz hardware friendly by putting the Pauli strings in an importance-decreasing order. Such an order will reduce the overhead when mapping to the target hardware by the compiler because this approach can improve qubit locality in the generated ansatz as explained in the next paragraph.

Improving locality: The term qubit locality (similar to data locality in classical computing) in this paper is that the CNOT gates are applied more frequently on some logical qubits in a period of time. In quantum chemistry simulation, each qubit represents an orbital but the wavefunction of the electrons is not uniformly distributed on all orbitals. Different orbitals represent the states with different energies and the electrons are more likely to occupy low energy orbitals because the energy minimum represents a stable ground state. Therefore, those Pauli string simulation circuits that involve low-energy orbitals are more important because changing their parameters will affect the occupancy of the low-energy orbitals. In our ansatz construction, those Pauli string simulation circuits at the beginning of the program mostly include the qubits representing low-energy orbitals. And these qubits will be frequently involved in the CNOT gates in these Pauli string simulation circuits. This creates gate locality in our constructed ansatz, which makes it easier to be synthesized and mapped later in our compilation.

The output of our ansatz compression algorithm is a sequence of Pauli strings and their parameters, rather than a typical quantum circuit. Later in Section V, we will have a customized compilation flow to compile the Pauli string sequence into an executable quantum circuit.

As introduced in Section II-A, the CNOT gates in the Pauli string simulation circuits form a tree structure. Therefore, if the physical qubits are connected in a tree, we can match them to the CNOT gates in the chemistry simulation program. Based on this observation, we propose an X-Tree superconducting quantum processor architecture after considering the design objective and physical constraints mentioned above.

X-Tree architecture construction: An X-Tree architecture starts from a root qubit. Then more qubits are placed and connected. The key is that the coupling graph formed by the connection is always a tree and there is no circle in the connections. Figure 6 shows several examples of X-Tree architecture with different numbers of qubits. We may connect four qubits to the root qubit and obtain the XTree5Q (5-qubit) architecture. We can add three more qubits to one leaf qubit of XTree5Q to obtain XTree8Q. Similarly, we can have XTree17Q and XTree26Q architectures by adding more physical qubits. The first generation of IBM’s cloud-access quantum computers were compatible with the XTree5Q architecture, but they have since diverged. Next, we explain why X-Tree architecture can satisfy our three design objectives.

Fewer connections: The proposed X-Tree architecture is highly simplified and has only the smallest number of connections ($N-1$ connections for $N$ qubits) to connect all qubits because the coupling graph of an X-Tree architecture is a tree. As our device yield rate simulations will show, this judicious lowering of connections results in higher yield rate in this architecture compared to conventional 2D-grid architectures (which roughly have $2N$ connections for $N$ qubits). Similarly, gate crosstalk errors will be significantly reduced too.

High performance and programmability: We expect the X-Tree architecture to support variational chemistry simulation applications with low mapping overhead since the physical qubit connections naturally fit the logical qubits’ CNOT gate connections (both of them are trees). We also expect programmability since the X-Tree architecture is not tailored to specific any gate-level VQE circuit instances. Instead, our design is inspired by the properties of Pauli string, a high-level algorithm feature, without any assumptions about the simulated system. However, the physical connection tree is not identical to the CNOT gate connection trees since there are different Pauli strings on different qubits for different simulation programs. Compiler optimizations are still required to deploy the chemistry simulation program onto the X-Tree architecture, which will be explained in the next section.

Since the program is not converted to gates yet, our initial qubit layout algorithm will directly analyze the high-level program and provide an initial qubit layout. This is possible because our proposed X-Tree architecture has different physical qubit levels. For example, in the XTree17Q architecture in Figure 6, the center (root) qubit has level $0$ as it is on average closer to all other qubits. The four qubits surrounding the root have level $1$, and the leaves have level $2$. Similarly, we can also discover different priorities for different logical qubits in a chemistry simulation program. The states represented by some orbitals are closer to the true ground state of the electrons, thus the logical qubits corresponding to these orbitals will appear in more Pauli string simulation circuits and will participate in more CNOT gates (as discussed in Section III-B). We place these logical qubits on lower-level physical qubits, ensuring that they can reach other qubits with shorter paths.

Our hierarchical initial layout algorithm is based on such heterogeneity of the logical and physical qubits. The pseudocode is in Algorithm 2 and we explain the algorithm with the example in Figure 7. We first determine which qubits appear in more Pauli strings. A matrix will record the number of instances when qubit $i$ and $j$ appear in the same Pauli string (the first loop). Then we can know which qubits connect to other qubits more by taking summation in one dimension. Finally, we sort the logical qubits by their connectivity requirements and place them on the X-Tree architecture from level $0$ outwards. In Figure 7, we put q0, which appears in all Pauli strings, on the level 0 root and put q1, q2, q3, q4 in the four level 1 physical qubits. In case of multiple available spots, we attach to a parent qubit which shares the largest number of common Pauli strings with the logical qubit to be allocated (the parent is already allocated a physical spot because it is in a lower level). In the example in Figure 7, q5 has been assigned level $2$ as it participates in only one Pauli string. Of the qubits it shares a Pauli string with, q3 is one level up and so chosen as q5’s parent.

After the initial qubit mapping is determined, we need to synthesize the Pauli string simulation circuits into concrete circuits and resolve all the CNOT gate dependency issues caused by the limited on-chip qubit connection. We propose a Merge-to-Root algorithm to synthesize the simulation circuits and determine how to insert SWAPs for remapping qubits. For each Pauli string simulation circuit, the two layers of the single-qubit gates at the beginning and the end are fixed. We only need to synthesize two CNOT trees and the center rotation gate as introduced in Section II-A. The pseudocode is in Algorithm 3 and we explain it with the example in Figure 8.

Suppose we need to compile the simulation of Pauli string on four logical qubits, q0, q1, q2, and q3. Their current mapping on an X-Tree architecture is shown on the top left of Figure 8. Our merge-to-root compilation starts from the outermost physical qubits. We can find that q0, q2, and q3 are currently mapped onto level 2 physical qubits. We check the parent qubits (at level 1) of these outermost qubits. If a parent qubit is holding a logical qubit in the simulation circuit, e.g., the parent qubit of q3 is the one q1 is mapped onto, then we can synthesize a CNOT between these two qubits. If not, we will find one qubit in the current level and swap it to this parent qubit. For example, the parent qubit of q0 and q2 is not in the Pauli string. We first select one of them and SWAP it to the parent qubit. We will select the qubit that will appear more times in the follow-up Pauli strings. Suppose we move q2 to the parent physical qubit. We can now synthesize a CNOT between q0 and q2. The procedure above synthesizes all CNOTs that are between level 2 and 1 with just one SWAP overhead. It will be repeated from the outer levels to the inner levels until the last qubit. For level 1 qubits (q1 and q2 in this example), we can move q1 and then synthesize the last CNOT between q2 and q1. This synthesis of the left CNOT tree is now completed with only two SWAPs in total. The center rotation gate can then be applied on q1. The right CNOT tree can be synthesized similarly in a reversed order from the inner levels to the outer levels. The time complexity of our compiler optimization algorithm is $O(n\#(P_{a}))$ where $n$ is the number of qubits and $\#(P_{a})$ is the number of Pauli strings in the ansatz.

Comparing with traditional compilation: The lower half of Figure 8 also shows the compilation results of the left CNOT tree from traditional compilation flow. The left CNOT tree will first be synthesized into three CNOT gates. Then a mapping algorithm will try to move the qubits to satisfy the dependencies of the three CNOT gates. In this example, we first move q1 by two SWAP gates to execute the first two CNOT gates. We then move q2 by three SWAP gates to execute the last CNOT gate. The total overhead is five SWAPs, which is much higher than that of our Merge-to-Root compilation. The key is that, comparing with traditional compilation, Merge-to-Root will synthesize entirely different CNOTs adapted to the current mapping and the architecture.

Benchmarks: We select nine molecules of various sizes and geometrical structures. The names of the molecules and the information of their simulation circuits using the original full UCCSD ansatz are listed in Table I. Note that ‘# of Pauli’ means the number of Pauli strings.

Metric: The simulation accuracy is measured by the simulated ground state energy of the target molecule. We adopt atomic units that are more convenient for computational chemistry. The energy unit is Hartree ($1\ \text{Hartree}\approx 4.36\times 10^{-18}\ \text{Joules}$). The bond length unit is Angstrom ($1\ \text{Angstrom}=10^{-10}\ \text{meter}$). The convergence speed is indicated by the number of iterations in the parameter optimization (outer loop in Figure 3). A smaller number of iterations means that the simulation converges faster. Compiler optimizations are evaluated by the gate count in the post-compilation circuit, a widely used metric in previous studies [50, 51, 52]. A more effective compiler optimization will result in a lower gate count in the post-compilation circuit. The CNOT count is of particular interest owing to the much higher error rate and longer latency compared to single-qubit gates.

Implementation: We implement the proposed optimizations based on IBM’s Qiskit [36] and perform experiments with classical simulators in Qiskit. The Hamiltonian of the simulated molecule is generated by PySCF [45] with STO-3G orbitals [53] and Jordan-Wigner encoding [54]. We freeze the core electrons and only simulate the interaction of the outermost electrons. We use the default UCCSD ansatz from Qiskit Aqua library (version 0.8.0). The parameters are optimized using the Sequential Least Squares Programming [55] solver. The noise-free simulations are performed with Qiskit Aer statevector simulator and the noisy simulations are performed with Qiksit Aer qasm simulator (version 0.6.0). For the hardware yield rate, we adopt the yield simulation method and qubit frequency allocation algorithm in [56]. All experiments are performed on a MacBook Pro with 2.8 GHz Quad-Core Intel Core i7 CPU and 16GB 2133MHz LPDDR3 memory.

Baseline: The software baseline is the original UCCSD ansatz [8], denoted by ‘Orig. UCCSD’. The true ground state energies for reference, denoted by ‘Ground State’, are obtained by directly calculating the eigenvalue of the Hamiltonian of the target system. The hardware baseline is IBM’s 17-qubit device (Grid17Q) with a 2D grid connection [32] (shown on the left of Figure 11) for a fair comparison with our 17-qubit X-Tree device (XTree17Q) employing the same number of qubits. The compiler baseline is SABRE [52] (SAB), a state-of-the-art general-purpose mapping algorithm in Qiskit.

Configurations: We apply the parameter compression method in Section III with five compression ratios: 10%, 30%, 50%, 70%, 90%. They are denoted by ‘10% Param.’ to ‘90% Param.’ We also generated ansatzes by randomly selecting 50% parameters (denoted by ‘Rand. 50%’).

Figure 9 shows the simulation accuracy and the convergence speed of our compressed ansatz. The results of $\rm H_{2}$ is omitted since its circuit is small with only three parameters. There are three parts in Figure 9. The X-axes represent the bond lengths of the simulated molecules. The Y-axes represent the simulated energy, simulated energy difference, and the number of iterations steps as labeled on the left of Figure 9. The top part shows simulated energies at different bond lengths. The simulation results of the compressed ansatzes are close to that of the full UCCSD and the true ground states. The more parameters we keep, the more accurate simulation we can obtain. To better understand the amount of accuracy loss, the middle part of Figure 9 shows the energy difference between different experiment configurations and their corresponding true ground states. For example, the energy differences for ‘50% Param.’ are usually only at the level of about $0.05\%$.

Effective parameter selection: We show the effectiveness of our parameter selection method by comparing the ansatzes generated by our compression method with those constructed by randomly selected parameters. For the ansatzes with 50% randomly selected parameters, we generate five different random parameter selections for each molecule at each simulated bond length. The simulation result distribution of ‘Rand. 50%’ is demonstrated by the mean and standard deviation of the simulated energies. It can be observed that the ‘50% Param.’ ansatzes generated by our optimization outperform the ‘Rand. 50%’ with better accuracy and the simulated energies are closer to the true ground state energies. The accuracy of ‘Rand. 50%’ is similar to that of ‘30% Param.’, which means that our optimization can select 30% of parameters but achieve the same level of accuracy from randomly selecting 50% of the parameters. This comparison proves that our ansatz compression algorithm is very effective. The execution time of our ansatz compression is negligible compared with the VQE execution itself. For example, it requires several minutes to compress the ansatz for $\rm CH_{4}$ while it takes over ten CPU hours to simulate $\rm CH_{4}$ with VQE at one bond length.

Convergence speedup: The bottom part of Figure 9 shows the number of iterations to converge. The compressed ansatzes with fewer parameters can converge much faster with smaller numbers of parameter optimization steps. The numbers of parameter optimization steps are reduced by $14.3\times$, $4.8\times$, $2.5\times$, $1.6\times$, and $1.1\times$ on average for the five parameter compression ratios of 10% to 90%, respectively.

There is also a subtle implication in computation reliability when the computation concludes faster. Quantum computers are calibrated to reduce gate errors. After a few hours, the physical properties of the system drift causing the calibration to become stale. At current experimental speeds, a full VQE experiment can easily take hours to converge, which makes these speedups a boost to reliability as well.

We study the effect of hardware noise on $\rm LiH$ and $\rm NaH$ as case studies. Our simulation adopts a depolarizing error model with realistic CNOT error rates of 0.0001 [57]. Figure 10 shows the simulation results. Similar to Figure 9, the first, second, and third rows are the overall simulated energies, energy differences, and number of iterations, respectively. We observe that our compressed VQE can still demonstrate the correct landscapes of the molecule energy under different bond lengths. We can also observe interesting trade-offs between parameter pruning and accuracy in noisy regimes. For $\rm LiH$, the error first decreases from ‘10% Param.’ to ‘50% Param.’ due to the increasing parameters. After that, the error does not change significantly from ‘50% Param.’ to ‘90% Param.’ because the effect of more parameters is masked by the increasing gate error. ‘50% Param.’ is a sweet spot for LiH. For $\rm NaH$, the balance is different. The error first increases from ‘10% Param.’ to ‘30% Param.’ and then drops from ‘30% Param.’ to ‘90% Param.’ This suggests that we should either select ‘10% Param.’ or ‘90% Param’. Such trade-offs depend on the molecule Hamiltonian, the bond length configuration, hardware noise strength, and maybe other factors. A comprehensive research into these trade-offs is left as future work.

We evaluate our hardware design by comparing the XTree17Q architecture with baseline Grid17Q. Both of them have 17 physical qubits. Figure 11 shows the yield rates of XTree17Q and Grid17Q for various fabrication precision parameters from 0.2 GHz to 0.6 GHz. The yield rate of the XTree17Q architecture is about $8\times$ higher than that of the Grid17Q architecture. This is because Grid17Q has 24 connections while XTree17Q only employs 16 connections.

Table II shows the mapping overhead (i.e., the number of additional CNOT gates) of our Merge-to-Root (MtR) compilation (including our initial layout algorithm) vs. the baseline compilation (SAB) on XTree17Q and Grid17Q architectures.

We first compare MtR on XTree17Q vs. SAB on XTree17Q. The sparse connectivity of XTree17Q makes the mapping overhead very high for the general-purpose SAB compiler. The number of additional CNOTs is about $177\%$ of the CNOT count of the original circuits. This is even worse for larger benchmarks. For $\rm CH_{4}$, the number of additional CNOTs for SAB is about $288\%$ of the original CNOT count. However, our MtR compilation incurs dramatically smaller overhead. For all tested benchmarks, the number of additional CNOTs is on average $1.4\%$ of the original CNOT count. Therefore, our MtR compilation reduces the mapping overhead to only about $\bf 1\%$ of the overhead from the state-of-the-art compilation.

The SAB compiler still cannot compete with our co-designed approach even if it targets a much denser architecture. Grid17Q employs more connections, of course at the cost of $8\times$ lower yield rate compared to our XTree17Q. However, even then the CNOT overhead for MtR on XTree17Q is only about $2.3\%$ of SAB on Grid17Q in most cases.

Locality improvement: Analysis of mapping overheads shows that our ansatz construction improves gate locality. At 10% ansatz compression ratio, MtR on XTree17Q does not require any additional CNOTs most of the time. We also observe that this mapping overhead jumps much faster from 70% to 90% compared to other gaps. For example, the mapping overhead increases from 70% to 90% is about $2.9\times$ that of 50% to 70%, while the original CNOT count increment from 70% to 90% is only about $0.47\times$ that of 50% to 70%. This is because our ansatz construction will first select Pauli string simulation circuits with more gate locality so that they can be synthesized and mapped to XTree17Q efficiently. But at compression ratios close to 1 (i.e. little compression), Pauli string simulation circuits with poor locality will also be included in the ansatz, which makes the mapping overhead grow faster.

The major component in the VQE circuit is the parameterized ansatz. UCCSD [8] is the “standard” chemistry-inspired ansatz, but has a large size. There have been several optimizations to reduce its size [19, 20, 21, 22, 23, 24], but without considering specific hardware mapping overheads. At the other extreme, “hardware-efficient” ansatzes [11] have been proposed which only employ gates that are easy to implement on the underlying hardware. However, these ansatzes are unlikely to support large molecules since they do not consider any information about the chemical system to be simulated [25, 44]. Alternatively, several ansatz selection techniques rely on classical simulation of the molecule, and it is unclear how they scale to super-classical regimes [17, 62]. In contrast, the algorithm optimization proposed in this paper exploits information about the target system through Pauli string comparison, and can maintain simulation accuracy as well as reduce hardware mapping overhead, and does not require classical simulation.

Additionally, there is prior work on optimizing the number of measurements required to evaluate the energy [63, 64, 65, 66, 67]. This type of optimization reduces the number of iterations of the inner loop in Figure 3 and is orthogonal to our techniques which reduce the number of iterations in the outer loop as well as the size of the circuit itself. These optimizations can be employed together with our techniques.

A large body of work exists on mapping quantum circuits to hardware [42, 52, 50, 68, 69]. These algorithms are invoked after a quantum circuit is already synthesized and are general-purpose with little assumption regarding the input programs or the underlying hardware architectures.

High-level semantics have recently been considered in compiler optimizations. Cowtan et al. recently proposed a method for compiling UCC ansatzes by partitioning Pauli strings into sets, but not considering the underlying architecture [70]. An architecture-aware synthesis for phase-polynomial quantum circuits was proposed in [71].

In contrast, this paper uses the Pauli string simulation circuit to devise a new compilation flow based not only on the chemistry simulation domain knowledge but also on the underlying architecture. Starting from a Pauli string IR, it achieves unprecedented mapping overhead reduction by combining synthesis and mapping in a single pass.

An application-specific quantum architecture was proposed by Wilhelm et al. for a specific Fermi-Hubbard model simulation, based on a superconducting planar architecture [72, 73]. Recently, an end-to-end design flow has also been proposed to generate optimized superconducting quantum processor architectures for different individual quantum programs [56]. These architectures are circuit-specific rather than domain-specific, as they exploit low-level gate patterns but not high-level domain knowledge and do not generalize to families of circuits. For trapped ion technology, [74] provided a forward-looking overview of co-designing trapped ion machines. Murali et al. also proposed a toolflow to evaluate the architecture design of trapped ion quantum computers over a benchmark suite [75]. Our architecture design, which integrates the algorithm-level domain knowledge, is a concrete optimized design with compiler support to accommodate various variational quantum chemistry programs with different simulation targets.