Exponentiating Pauli matrices using trapped ion native gates (single-qubit rotations + XX, YY, ZZ)

Question

I'm wondering what are the known/good/standard ways of exponentiating Pauli terms (i.e. constructing circuits, which implement $\exp(i\alpha XIIZYI...)$) using gates supported by trapped ion quantum computers — single-qubit rotations and $\{XX,YY,ZZ\}$ gates.

One naïve/brute force approach would be to

1. Exponentiate using the single-qubit + $\rm{CNOT}$ technique:

   a. Rotate to $Z$ basis,

   b. Exponentiate using $\rm CNOT$s:

2. Convert each $\rm CNOT$ using eq. (9) from here:

3. Try to optimize the resulting circuit.

This approach is, quite obviously, very inefficient. Any suggestions what one could do instead?..

Answer 1

The following answer to this question was given by Dmitrii Maslov in a private conversation.

An improvement to the approach described in the original post can be made by noticing that the middle block of the circuit, containing two $CNOT$s and the $R_z$ rotation, is equivalent to the following circuit (which, in turn, is equivalent, up to a phase, to $\{Z_0^\alpha;Z_1^\alpha;CZ_{0,1}^{-2\alpha}\}$):

 ──■─────────────■──       ┌───────┐┌─────────┐          ┌─────────┐┌────────┐┌──────────┐         
 ┌─┴─┐┌───────┐┌─┴─┐   =   ┤ RZ(α) ├┤ RY(π/2) ├──────────┤0        ├┤ RX(-3) ├┤ RY(-π/2) ├─────────
 ┤ X ├┤ RZ(α) ├┤ X ├       ├───────┤├─────────┴┐┌───────┐│  RXX(α) │├────────┤├──────────┤┌───────┐
 └───┘└───────┘└───┘       ┤ RZ(α) ├┤ RY(-π/2) ├┤ RZ(π) ├┤1        ├┤ RX(-3) ├┤ RY(-π/2) ├┤ RZ(π) ├
                           └───────┘└──────────┘└───────┘└─────────┘└────────┘└──────────┘└───────┘

The advantage of this method is not not only in that it reduces the number of $XX$ gates by one. While all the $XX$ gates on the side have to be applied with the phase corresponding to the maximum entanglement (in order to reproduce $CNOT$s), the construction above only produces maximum entanglement in the worst case scenario.

NOTE: IN THE CIRCUIT ABOVE, I USED QISKIT CONVENTION FOR THE $XX$ GATE, I.E. MAXIMUM ENTANGLEMENT AT $\pi/2$. A MORE COMMON NOTATION IS HAVING MAXIMUM ENTANGLEMENT AT $\pi/4$, WHICH WOULD RESULT IN HAVING RXX(2α) IN THE MIDDLE.

Answer 2

First, you need a "compression step" that maps a two-qubit observable like ZZ into a single qubit observable like IZ. That's what this does:

That circuit maps ZZ on the left to Z_bottom on the right.

You can then chain this step together in order to reduce an arbitrarily large ZZZ...Z product into a single Z observable, phase that Z observable, and uncompress back. Here's a circuit that phases ZZZ...Z:

Note that, if you have better qubit connectivity (e.g. a grid or all-to-all), you can reduce the depth significantly by compressing in a different order. Also, as noted in another answer, the central three operations can be rewritten to use a single XX rotation (but by an arbitrary angle) instead of two.

Once you have the all-to-one compression it's pretty easy to make it work for any Pauli product observable you want. Use H to turn Xs into Zs, use sqrtX to turn Ys into Zs, and use a gate sequence that moves ZI to IZ to skip over qubits not in the product:

The above circuit sends Z_top on the left to Z_bottom on the right (and vice versa).