Add an efficient circuit synthesis for a special pattern `exp(-it (IZZ + ZZI + ZZZ))`

What should we add?

[1] proposed an efficient way to synthesize the following special pattern of two-body terms (IZZ and ZZI) and three-body term (ZZZ) (Fig. 2 [1]). It can halve the number of two-qubit gates (8 to 4). This pattern is useful to handle QAOA with cubic terms as [1] did.

It would be nice if Qiskit can handle this special pattern of synthesis.

Target (coeffs can be arbitrary)

     ┌────────────────────────────────┐
q_0: ┤0                               ├
     │                                │
q_1: ┤1 exp(-it (IZZ + ZZI + ZZZ))(x) ├
     │                                │
q_2: ┤2                               ├
     └────────────────────────────────┘
# PauliEvolutionGate(SparsePauliOp(["IZZ", "ZZI", "ZZZ"], coeffs=[1, 2, 3]), x)

Qiskit optimization_level=3

                                                        ┌───┐┌───────────┐┌───┐
q_0: ──■─────────────────■──────────────────────────────┤ X ├┤ Rz(6.0*x) ├┤ X ├─────
     ┌─┴─┐┌───────────┐┌─┴─┐                       ┌───┐└─┬─┘└───────────┘└─┬─┘┌───┐
q_1: ┤ X ├┤ Rz(2.0*x) ├┤ X ├──■─────────────────■──┤ X ├──■─────────────────■──┤ X ├
     └───┘└───────────┘└───┘┌─┴─┐┌───────────┐┌─┴─┐└─┬─┘                       └─┬─┘
q_2: ───────────────────────┤ X ├┤ Rz(4.0*x) ├┤ X ├──■───────────────────────────■──
                            └───┘└───────────┘└───┘
OrderedDict({'cx': 8, 'rz': 3})

Proposed circuit by [1]

q_0: ──■───────────────────────────────────■────────────────────
     ┌─┴─┐┌───────────┐┌───┐┌───────────┐┌─┴─┐┌───────────┐┌───┐
q_1: ┤ X ├┤ Rz(2.0*x) ├┤ X ├┤ Rz(6.0*x) ├┤ X ├┤ Rz(4.0*x) ├┤ X ├
     └───┘└───────────┘└─┬─┘└───────────┘└───┘└───────────┘└─┬─┘
q_2: ────────────────────■───────────────────────────────────■──
OrderedDict({'cx': 4, 'rz': 3})

Reference [1] Pelofske, E., Bärtschi, A., & Eidenbenz, S. (2024). Short-depth QAOA circuits and quantum annealing on higher-order ising models. Npj Quantum Information, 10(1), 30. https://doi.org/10.1038/s41534-024-00825-w

Script to reproduce

from qiskit import QuantumCircuit, generate_preset_pass_manager
from qiskit.circuit import Parameter
from qiskit.circuit.library import PauliEvolutionGate
from qiskit.quantum_info import SparsePauliOp

# PauliEvolutionGate
qc = QuantumCircuit(3)
x = Parameter("x")
op = SparsePauliOp(["IZZ", "ZZI", "ZZZ"], coeffs=[1, 2, 3])
evo = PauliEvolutionGate(op, x)
qc.append(evo, qargs=qc.qregs[0])
print("PauliEvolutionGate")
print(qc)
print("PauliEvolutionGate + decompose")
print(qc.decompose())
pm = generate_preset_pass_manager(optimization_level=3, basis_gates=["cx", "rz"])
qc = pm.run(qc)
print("PauliEvolutionGate + optimization_level=3")
print(qc)

# Hand-optimized
qc2 = QuantumCircuit(3)
qc2.rzz(2.0 * x, 0, 1)
# RZZZ(6 * x, 0, 1, 2)
qc2.cx(0, 1)
qc2.rzz(6.0 * x, 2, 1)
qc2.cx(0, 1)
#
qc2.rzz(4.0 * x, 2, 1)
print("Hand-optimized")
print(qc2)

print("Hand-optimization + optimization_level=3")
qc3 = pm.run(qc2)
print(qc3)

To address the issue of efficiently synthesizing the special pattern exp(-it (IZZ + ZZI + ZZZ)) in Qiskit, we can create a custom synthesis method for the PauliEvolutionGate. This method will specifically handle the given pattern and optimize the circuit to use fewer two-qubit gates, as proposed in the reference. Here's a step-by-step plan to implement this:

Modifications and Additions

Extend PauliEvolutionGate to Support Custom Synthesis:
- Implement a new synthesis method that recognizes the specific pattern of IZZ, ZZI, and ZZZ and applies the optimized circuit structure.
Add Custom Synthesis Strategy:
- Create a new synthesis strategy class (e.g., SpecialPatternSynthesis) that implements the optimized circuit for this special pattern.
Integrate the Custom Synthesis into PauliEvolutionGate:
- Modify the PauliEvolutionGate to use this custom synthesis strategy when the operator matches the specific pattern.

Code Implementation

1. Extend `PauliEvolutionGate` in `pauli_evolution.py`

Add a method to detect the special pattern and apply the optimized synthesis.

class PauliEvolutionGate(Gate):
    # Existing code...

    def _define(self):
        """Unroll, where the default synthesis is matrix based."""
        if self._is_special_pattern():
            self.definition = self._special_pattern_synthesis()
        else:
            self.definition = self.synthesis.synthesize(self)

    def _is_special_pattern(self):
        """Check if the operator matches the special pattern IZZ, ZZI, ZZZ."""
        if isinstance(self.operator, SparsePauliOp):
            labels = self.operator.paulis.to_labels()
            return set(labels) == {"IZZ", "ZZI", "ZZZ"}
        return False

    def _special_pattern_synthesis(self):
        """Synthesize the special pattern using the optimized circuit."""
        from qiskit.circuit import QuantumCircuit

        qc = QuantumCircuit(self.num_qubits)
        x = self.time

        # Optimized pattern synthesis
        qc.cx(0, 1)
        qc.rz(2.0 * x, 1)
        qc.cx(1, 2)
        qc.rz(6.0 * x, 2)
        qc.cx(0, 1)
        qc.rz(4.0 * x, 2)
        qc.cx(1, 2)

        return qc

2. Create a New Synthesis Strategy (Optional)

If you want to make this more modular and reusable, you could define a separate class for the synthesis strategy. However, for simplicity, the above inline method in PauliEvolutionGate suffices for now.

Testing and Validation

Unit Tests: Add unit tests to ensure that the PauliEvolutionGate correctly identifies the special pattern and applies the optimized circuit.
Benchmarking: Compare the gate counts and execution time of the optimized synthesis against the default synthesis to validate the efficiency improvements.

By implementing the above changes, Qiskit will be able to handle the special pattern exp(-it (IZZ + ZZI + ZZZ)) efficiently, reducing the number of two-qubit gates as proposed in the referenced paper.

pdhoolia / qiskit