Noise Scaling for LRE

docs/source/apidoc.md

@@ -87,6 +87,13 @@ See Ref. {cite}`Czarnik_2021_Quantum` for more details on these methods.
    :members:
 ```
 
+### Layerwise Richardson Extrapolation
+
+```{eval-rst}
+.. automodule:: mitiq.lre.multivariate_scaling.layerwise_folding
+   :members:
+```
+
 ### Pauli Twirling
 
 ```{eval-rst}
@@ -116,6 +123,7 @@ See Ref. {cite}`Czarnik_2021_Quantum` for more details on these methods.
    :members:
 ```
 
+
 #### Learning-based PEC
 
 ```{eval-rst}

docs/source/refs.bib

@@ -731,6 +731,16 @@ @misc{Russo_2022_Testing
   year      = {2022},
   copyright = {arXiv.org perpetual, non-exclusive license},
 }
+
+@misc{Russo_2024_LRE,
+      title={Quantum error mitigation by layerwise Richardson extrapolation}, 
+      author={Vincent Russo and Andrea Mari},
+      year={2024},
+      eprint={2402.04000},
+      archivePrefix={arXiv},
+      primaryClass={quant-ph}
+}
+
 # Letter S
 
 @article{Sagastizabal_2019_PRA,

mitiq/interface/conversions.py

@@ -6,6 +6,7 @@
 """Functions for converting to/from Mitiq's internal circuit representation."""
 
 from functools import wraps
+from itertools import chain
 from typing import Any, Callable, Dict, Iterable, Optional, Tuple, cast
 
 import cirq
@@ -317,6 +318,12 @@ def new_function(circuit: QPROGRAM, *args: Any, **kwargs: Any) -> QPROGRAM:
             )
             out_circuits = [out_circuit]
 
+        # for the case when the circuit modifier returns a list of circuits
+        # flatten the list of lists into a list
+        if isinstance(out_circuits[0], list):
+            new_out_circuits = list(chain(*out_circuits))
+            out_circuits = new_out_circuits
+
         circuits_to_return = []
         for out_circuit in out_circuits:
             # Post atomic conversion
@@ -379,9 +386,13 @@ def new_function(circuit: QPROGRAM, *args: Any, **kwargs: Any) -> QPROGRAM:
                     out_circuit.measure(q, c)
             circuits_to_return.append(out_circuit)
 
-        if not one_to_many:
-            assert len(circuits_to_return) == 1
-            return circuits_to_return[0]
+        try:
+            if not one_to_many:
+                assert len(circuits_to_return) == 1
+                return circuits_to_return[0]
+        except AssertionError:
+            # for the case when the circuit modifier returns a list of circuits
+            assert len(out_circuits) == len(circuits_to_return)
 
         return circuits_to_return
 

mitiq/lre/__init__.py

@@ -0,0 +1,8 @@
+# Copyright (C) Unitary Fund
+#
+# This source code is licensed under the GPL license (v3) found in the
+# LICENSE file in the root directory of this source tree.
+
+"""Methods for scaling noise in circuits by layers and using multivariate extrapolation."""
+
+from mitiq.lre.multivariate_scaling.layerwise_folding import multivariate_layer_scaling

mitiq/lre/multivariate_scaling/layerwise_folding.py

@@ -0,0 +1,214 @@
+# Copyright (C) Unitary Fund
+#
+# This source code is licensed under the GPL license (v3) found in the
+# LICENSE file in the root directory of this source tree.
+
+"""Functions for layerwise folding of input circuits to allow for multivariate
+extrapolation as defined in :cite:`Russo_2024_LRE`.
+"""
+
+import itertools
+from copy import deepcopy
+from typing import Any, Callable, List, Optional, Tuple
+
+import numpy as np
+from cirq import Circuit
+
+from mitiq import QPROGRAM
+from mitiq.interface import accept_qprogram_and_validate
+from mitiq.utils import _append_measurements, _pop_measurements
+from mitiq.zne.scaling import fold_gates_at_random
+from mitiq.zne.scaling.folding import _check_foldable
+
+
+def _get_num_layers_without_measurements(input_circuit: Circuit) -> int:
+    """Checks if the circuit has non-terminal measurements and returns the
+    number of layers in the input circuit without the terminal measurements.
+
+        Args:
+            input_circuit: Circuit of interest
+
+        Raises:
+            UnfoldableCircuitError:
+                * If the circuit has intermediate measurements
+                * If the circuit has non-unitary channels which are not
+                    terminal measurements
+
+        Returns:
+            num_layers: the number of layers in the input circuit without the
+                terminal measurements
+    """
+
+    _check_foldable(input_circuit)
+    circuit = deepcopy(input_circuit)
+    _pop_measurements(circuit)
+    return len(circuit)
+
+
+def _get_chunks(
+    input_circuit: Circuit, num_chunks: Optional[int] = None
+) -> List[Circuit]:
+    """Splits a circuit into approximately equal chunks.
+
+    Adapted from:
+    https://stackoverflow.com/questions/2130016/splitting-a-list-into-n-parts-of-approximately-equal-length
+
+        Args:
+            input_circuit: Circuit of interest
+            num_chunks: Number of desired approximately equal chunks
+                * when num_chunks == num_layers, the original circuit is
+                    returned
+                * when num_chunks == 1, the entire circuit is chunked into 1
+                    layer
+
+
+        Returns:
+            split_circuit: Circuit of interest split into approximately equal
+                chunks
+    """
+    num_layers = _get_num_layers_without_measurements(input_circuit)
+    if num_chunks is None:
+        num_chunks = num_layers
+
+    if num_chunks == 0:
+        raise ValueError(
+            "Number of chunks should be greater than or equal to 1."
+        )
+
+    if num_chunks > num_layers:
+        raise ValueError(
+            f"Number of chunks {num_chunks} cannot be greater than the number"
+            f" of layers {num_layers}."
+        )
+
+    k, m = divmod(num_layers, num_chunks)
+    return [
+        input_circuit[i * k + min(i, m) : (i + 1) * k + min(i + 1, m)]
+        for i in range(num_chunks)
+    ]
+
+
+def _get_scale_factor_vectors(
+    input_circuit: Circuit,
+    degree: int,
+    fold_multiplier: int,
+    num_chunks: Optional[int] = None,
+) -> List[Tuple[Any, ...]]:
+    """Returns the patterned scale factor vectors required for multivariate
+    extrapolation.
+
+        Args:
+            input_circuit: Circuit to be scaled
+            degree: Degree of the multivariate polynomial
+            num_chunks: Number of desired approximately equal chunks
+            fold_multiplier: Scaling gap required by unitary folding
+
+        Returns:
+            scale_factor_vectors: Multiple variations of scale factors for each
+                layer in the input circuit
+    """
+
+    circuit_chunks = _get_chunks(input_circuit, num_chunks)
+    num_layers = len(circuit_chunks)
+
+    # Find the exponents of all the monomial terms required for the folding
+    # pattern
+    pattern_full = []
+    for i in range(degree + 1):
+        for j in itertools.combinations_with_replacement(range(num_layers), i):
+            pattern = np.zeros(num_layers, dtype=int)
+            # Get the monomial terms in graded lexicographic order.
+            for index in j:
+                pattern[index] += 1
+            # Use the fold multiplier on the folding pattern to determine which
+            # layers will be scaled.
+            pattern_full.append(tuple(fold_multiplier * pattern))
+
+    # Get the scale factor vectors.
+    # The layers are scaled as 2n+1 due to unitary folding.
+    return [
+        tuple(2 * num_folds + 1 for num_folds in pattern)
+        for pattern in pattern_full
+    ]
+
+
+@accept_qprogram_and_validate
+def multivariate_layer_scaling(
+    input_circuit: Circuit,
+    degree: int,
+    fold_multiplier: int,
+    num_chunks: Optional[int] = None,
+    folding_method: Callable[
+        [QPROGRAM, float], QPROGRAM
+    ] = fold_gates_at_random,
+) -> List[Circuit]:
+    r"""
+    Defines the noise scaling function required for Layerwise Richardson
+    Extrapolation as defined in :cite:`Russo_2024_LRE`.
+
+    Note that this method only works for the multivariate extrapolation
+    methods. It does not allows a user to choose which layers in the input
+    circuit will be scaled.
+
+    .. seealso::
+
+        If you would prefer to choose the layers for unitary
+        folding, use :func:`mitiq.zne.scaling.layer_scaling.get_layer_folding`
+        instead.
+
+    Args:
+        input_circuit: Circuit to be scaled
+        degree: Degree of the multivariate polynomial
+        fold_multiplier: Scaling gap required by unitary folding
+        num_chunks: Number of desired approximately equal chunks. When the
+            number of chunks is the same as the layers in the input circuit,
+            the input circuit is unchanged.
+        folding_method: Unitary folding method. Default is
+            :func:`fold_gates_at_random`
+
+    Returns:
+        Multiple folded variations of the input circuit
+
+    Raises:
+        ValueError:
+            When the degree for the multinomial is not greater than or
+                equal to 1.
+        ValueError:
+            When the fold multiplier to scale the circuit is greater than or
+                equal to 1.
+        ValueError:
+            When the number of chunks for a large circuit is 0.
+        ValueError:
+            When the number of chunks in a circuit is greater than the number
+                of layers in the input circuit.
+
+    """
+    if degree < 1:
+        raise ValueError(
+            "Multinomial degree must be greater than or equal to 1."
+        )
+    if fold_multiplier < 1:
+        raise ValueError("Fold multiplier must be greater than or equal to 1.")
+    circuit_copy = deepcopy(input_circuit)
+    terminal_measurements = _pop_measurements(circuit_copy)
+
+    scaling_pattern = _get_scale_factor_vectors(
+        circuit_copy, degree, fold_multiplier, num_chunks
+    )
+
+    chunks = _get_chunks(circuit_copy, num_chunks)
+
+    multiple_folded_circuits = []
+    for scale_factor_vector in scaling_pattern:
+        folded_circuit = Circuit()
+        for chunk, scale_factor in zip(chunks, scale_factor_vector):
+            if scale_factor == 1:
+                folded_circuit += chunk
+            else:
+                chunks_circ = Circuit(chunk)
+                folded_chunk_circ = folding_method(chunks_circ, scale_factor)
+                folded_circuit += folded_chunk_circ
+        _append_measurements(folded_circuit, terminal_measurements)
+        multiple_folded_circuits.append((folded_circuit))
+
+    return multiple_folded_circuits