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

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: 1. Convert each $$\rm CNOT$$ using eq. (9) from here: 1. Try to optimize the resulting circuit.

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

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.

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).

• Wow, that's really cool! Jun 15 '21 at 18:28