Add local folding to ZNE error mitigation

[josh146]

Requirements

The mitigate_with_zne function is modified to take a folding argument:

mitigate_with_zne(f, *, scale_factors: jax.Array, folding: str, deg)

where folding accepts a string corresponding to:

• global (current behaviour, global folding)

• random (local random folding)

• left (local folding from left)

• right (local folding from right)

• all (all gates folded locally)

For more details on how these options behave, see the mitiq documentation.

The mitigate_with_zne docstring should be adequately updated.

[vprusso]

Hi @josh146,

Thanks for putting this together. One point that may be relevant here is that fold_from_left and fold_from_right are deprecated within mitiq, so we may want to consider those options as out-of-scope.

As for supporting local folding, the following snippet may be helpful as this applies local folding without the need to invoke mitiq:

from functools import reduce

from qiskit import QuantumCircuit
from qiskit.converters import circuit_to_dag, dag_to_circuit

# Define a basic Qiskit quantum circuit, for example.
qc = QuantumCircuit(3)
qc.h(0)
qc.cx(0, 1)
qc.cx(0, 2)

# Altering impacts the number of folds to perform.
num_folds = 0

# Deconstruct the circuit into layers as represented by DAG.
dag = circuit_to_dag(qc)
circuit_layers = [dag_to_circuit(layer["graph"]) for layer in dag.layers()]

# Construct a new circuit based on the number of folds requested.
layers: list[QuantumCircuit] = []
for i, layer in enumerate(circuit_layers):
    layers.append(layer)
    for _ in range(num_folds):
        layers.append(layer.inverse())
        layers.append(layer)

# Combine the layers into one circuit.
combined_circuit = reduce(lambda x, y: x.compose(y), layers)
print(combined_circuit)

So, for instance, if num_folds=0, then this is just the original circuit:

     ┌───┐
q_0: ┤ H ├──■────■──
     └───┘┌─┴─┐  │
q_1: ─────┤ X ├──┼──
          └───┘┌─┴─┐
q_2: ──────────┤ X ├
               └───┘

However, if we bump this up to num_folds=1, then this generates the circuit with the expected number of folds:

     ┌───┐┌───┐┌───┐
q_0: ┤ H ├┤ H ├┤ H ├──■────■────■────■────■────■──
     └───┘└───┘└───┘┌─┴─┐┌─┴─┐┌─┴─┐  │    │    │
q_1: ───────────────┤ X ├┤ X ├┤ X ├──┼────┼────┼──
                    └───┘└───┘└───┘┌─┴─┐┌─┴─┐┌─┴─┐
q_2: ──────────────────────────────┤ X ├┤ X ├┤ X ├
                                   └───┘└───┘└───┘

It should be straightforward enough to take the above, turn it into a function, and add support options for global and random folding.

[nathanshammah]

Thanks @vprusso. Regarding the other options for folding, the layerwise folding is one alternative we could consider. This is related at the high level but different from layerwise Richardson extrapolation (LRE), from this paper (https://arxiv.org/abs/2402.04000) and recently approved in this RFC. Even if different from LRE, the fact that the concept of folding by layer has this other usage highlights how layer-based folding is an interesting way of thinking about mitigation.

[dime10]

While the transform could be implemented in Python, this would tie it to the frontend (in this case PennyLane). I remember one point of interest was to implement error mitigation independently of the frontend, which is why we started building the error mitigation dialect in MLIR.

[josh146]

Thanks for putting this together. One point that may be relevant here is that fold_from_left and fold_from_right are deprecated within mitiq, so we may want to consider those options as out-of-scope.

Good point @vprusso! I'll edit the original comment.

I remember one point of interest was to implement error mitigation independently of the frontend, which is why we started building the error mitigation dialect in MLIR.

Yep, the idea here is to extend the error mitigation dialect (mitiq dialect) we have in MLIR to support this folding :)