6
$\begingroup$

I would like to know some circuit decomposition for an arbitrary controlled Pauli string rotation: \begin{equation} |0\rangle\langle 0| \otimes e^{i \theta (P_1\otimes...\otimes P_n)}+ |1\rangle\langle 1| \otimes I \end{equation} where $P_i$ are Pauli operators. What's a simple circuit decomposition for that?

$\endgroup$

2 Answers 2

8
$\begingroup$

This is nearly a built-in decomposition in cirq. Here's what happens when you decompose a Pauli product:

import cirq
a, b, c, d, e = cirq.LineQubit.range(5)

product = cirq.X(a) * cirq.X(b) * cirq.Y(c) * cirq.Y(d) * cirq.Z(e)

power = product**0.125
ops = cirq.decompose_once(power)
print(cirq.Circuit(ops).to_text_diagram(use_unicode_characters=False))

Which prints:

0: ---Y^-0.5---X---X---X---X---Z^(1/8)---X---X---X--------X--------Y^0.5---
               |   |   |   |             |   |   |        |
1: ---Y^-0.5---@---|---|---|-------------|---|---|--------@--------Y^0.5---
                   |   |   |             |   |   |
2: ---X^0.5--------@---|---|-------------|---|---@--------X^-0.5-----------
                       |   |             |   |
3: ---X^0.5------------@---|-------------|---@---X^-0.5--------------------
                           |             |
4: ---I--------------------@-------------@---I-----------------------------

It works by conjugating the Pauli product by single qubit gates to turn it into a product of Z observables, then conjugating by CNOTs to reduce that to a single Z observable, then phasing that single observable.

Anyways, the point is that the key operation in this entire thing is that one Z gate in the middle. Everything else is self-undoing conjugation. So...

C: ----------------------------@-------------------------------------------
                               |
0: ---Y^-0.5---X---X---X---X---Z^(1/8)---X---X---X--------X--------Y^0.5---
               |   |   |   |             |   |   |        |
1: ---Y^-0.5---@---|---|---|-------------|---|---|--------@--------Y^0.5---
                   |   |   |             |   |   |
2: ---X^0.5--------@---|---|-------------|---|---@--------X^-0.5-----------
                       |   |             |   |
3: ---X^0.5------------@---|-------------|---@---X^-0.5--------------------
                           |             |
4: ---I--------------------@-------------@---I-----------------------------

Controlling that one key gate controls the entire operation.

$\endgroup$
1
  • $\begingroup$ Thanks a lot Craig! $\endgroup$
    – Pablo
    Feb 16, 2022 at 16:25
1
$\begingroup$

This decomposition is now built into pytket.

As pointed out by the accepted answer, you can make a controlled Pauli string rotation (aka a controlled Pauli gadget) by only controlling on the central $Z$ rotation. This is way more efficent in terms of circuit complexity than naively controlling on the other operations.

Here's an example for $\theta=0.7$ and with the Pauli string $ Z \otimes Z \otimes Y \otimes X$.

enter image description here

More generally, there's a simple pattern for when you can do this. If the base gate $U$ in your controlled gate is of the form

$$ \begin{equation} U = V \, A \, V^\dagger, \end{equation} $$

then it is sufficent to only control on the central $A$ operation. You can see that the above circuit fits this conjugation pattern. I wrote a short blog post on this.

Here's the pytket code to generate the controlled Pauli operation shown above.

from pytket.pauli import Pauli
from pytket.circuit import PauliExpBox, QControlBox

zzyx_box = PauliExpBox([Pauli.Z, Pauli.Z, Pauli.Y, Pauli.X], 0.7)

# Controlled Pauli gadget with a single control.
controlled_pauli = QControlBox(zzyx_box, 1)
$\endgroup$

Your Answer

By clicking “Post Your Answer”, you agree to our terms of service and acknowledge you have read our privacy policy.

Not the answer you're looking for? Browse other questions tagged or ask your own question.