added 162 characters in body
Source Link
Craig Gidney
  • 18k
  • 1
  • 11
  • 56

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:

enter image description here

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:

enter image description here

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 swap gates instead of the compressiona gate sequence that moves ZI to IZ to skip over qubits not in the product:

enter image description here

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

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:

enter image description here

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:

enter image description here

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 swap gates instead of the compression sequence to skip over qubits not in the product.

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:

enter image description here

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:

enter image description here

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:

enter image description here

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

Source Link
Craig Gidney
  • 18k
  • 1
  • 11
  • 56

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:

enter image description here

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:

enter image description here

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 swap gates instead of the compression sequence to skip over qubits not in the product.