Implement SpectralNormError

doc/releases/changelog-dev.md

@@ -126,10 +126,13 @@
 * A function called `apply_operation` has been added to the new `qutrit_mixed` module found in `qml.devices` that applies operations to device-compatible states.
   [(#5032)](https://github.com/PennyLaneAI/pennylane/pull/5032)
 
-* Added new error tracking and propagation functionality. 
+* Added new error tracking and propagation functionality.
   [(#5115)](https://github.com/PennyLaneAI/pennylane/pull/5115)
   [(#5121)](https://github.com/PennyLaneAI/pennylane/pull/5121)
 
+* Added new SpectralNormError class to the new error tracking functionality.
+  [(#5154)](https://github.com/PennyLaneAI/pennylane/pull/5154)
+
 
 <h3>Improvements 🛠</h3>
 
@@ -146,7 +149,7 @@
 * PennyLane can now use lightning provided VJPs by selecting `device_vjp=True` on the QNode.
   [(#4914)](https://github.com/PennyLaneAI/pennylane/pull/4914)
 
-* Remove queuing (`AnnotatedQueue`) from `qml.cut_circuit` and `qml.cut_circuit_mc` to improve performance 
+* Remove queuing (`AnnotatedQueue`) from `qml.cut_circuit` and `qml.cut_circuit_mc` to improve performance
   for large workflows.
   [(#5108)](https://github.com/PennyLaneAI/pennylane/pull/5108)
 
@@ -301,15 +304,15 @@
   To allow for packages to register multiple compilers with PennyLane,
   the `entry_points` convention under the designated group name
   `pennylane.compilers` has been modified.
-  
+
   Previously, compilers would register `qjit` (JIT decorator),
   `ops` (compiler-specific operations), and `context` (for tracing and
   program capture).
-  
+
   Now, compilers must register `compiler_name.qjit`, `compiler_name.ops`,
   and `compiler_name.context`, where `compiler_name` is replaced
   by the name of the provided compiler.
-  
+
   For more information, please see the
   [documentation on adding compilers](https://docs.pennylane.ai/en/stable/code/qml_compiler.html#adding-a-compiler).
 
@@ -339,10 +342,10 @@
   [(#5048)](https://github.com/PennyLaneAI/pennylane/pull/5048)
 
 * Controlled operators with a custom controlled version decomposes like how their
-  controlled counterpart decomposes, as opposed to decomposing into their controlled version.   
+  controlled counterpart decomposes, as opposed to decomposing into their controlled version.
   [(#5069)](https://github.com/PennyLaneAI/pennylane/pull/5069)
   [(#5125)](https://github.com/PennyLaneAI/pennylane/pull/5125/)
-  
+
   For example:
   ```
   >>> qml.ctrl(qml.RX(0.123, wires=1), control=0).decomposition()
@@ -478,16 +481,16 @@
 * `PauliSentence.wires` no longer imposes a false order.
   [(#5041)](https://github.com/PennyLaneAI/pennylane/pull/5041)
 
-* `qml.qchem.import_state` now applies the chemist-to-physicist 
+* `qml.qchem.import_state` now applies the chemist-to-physicist
   sign convention when initializing a PennyLane state vector from
-  classically pre-computed wavefunctions. That is, it interleaves 
+  classically pre-computed wavefunctions. That is, it interleaves
   spin-up/spin-down operators for the same spatial orbital index,
-  as standard in PennyLane (instead of commuting all spin-up 
-  operators to the left, as is standard in quantum chemistry). 
+  as standard in PennyLane (instead of commuting all spin-up
+  operators to the left, as is standard in quantum chemistry).
   [(#5114)](https://github.com/PennyLaneAI/pennylane/pull/5114)
 
 * Multi-wire controlled `CNOT` and `PhaseShift` can now be decomposed correctly.
-  [(#5125)](https://github.com/PennyLaneAI/pennylane/pull/5125/) 
+  [(#5125)](https://github.com/PennyLaneAI/pennylane/pull/5125/)
   [(#5148)](https://github.com/PennyLaneAI/pennylane/pull/5148)
 
 * `draw_mpl` no longer raises an error when drawing a circuit containing an adjoint of a controlled operation.
@@ -533,6 +536,7 @@ Astral Cai,
 Skylar Chan,
 Isaac De Vlugt,
 Diksha Dhawan,
+Amintor Dusko
 Lillian Frederiksen,
 Pietropaolo Frisoni,
 Eugenio Gigante,

pennylane/math/__init__.py

@@ -55,6 +55,7 @@
     matmul,
     multi_dispatch,
     norm,
+    svd,
     ones_like,
     scatter,
     scatter_element_add,

pennylane/math/multi_dispatch.py

@@ -870,6 +870,49 @@ def norm(tensor, like=None, **kwargs):
     return norm(tensor, **kwargs)
 
 
+@multi_dispatch(argnum=[0])
+def svd(tensor, like=None, **kwargs):
+    """Compute the singular value decomposition of a tensor in each interface.
+    For a matrix A, the singular value decomposition consist of three matrices U, S and Vh, such that:
+
+    .. math::
+
+        A = U . Diag(S) . Vh
+
+    Returns:
+        S, U, V: full decomposition (if compute_uv is True or None)
+        S: only the singular values (if compute_uv is False)
+
+    """
+    if like == "tensorflow":
+        from tensorflow.linalg import svd, adjoint
+
+        # Tensorflow results need some pos-processing to keep it similar to other frameworks.
+        if kwargs.get("compute_uv", True):
+            S, U, V = svd(tensor, **kwargs)
+            return U, S, adjoint(V)
+        return svd(tensor, **kwargs)
+
+    if like == "jax":
+        from jax.numpy.linalg import svd
+
+    elif like == "torch":
+        # Torch is deprecating torch.svd() in favor of torch.linalg.svd().
+        # The new UI is slightly different and breaks the logic for the multi dispatching.
+        # This small workaround restores the compute_uv control argument.
+        if kwargs.get("compute_uv", True) is False:
+            from torch.linalg import svdvals as svd
+        else:
+            from torch.linalg import svd
+        if kwargs.get("compute_uv", None) is not None:
+            kwargs.pop("compute_uv")
+
+    else:
+        from numpy.linalg import svd
+
+    return svd(tensor, **kwargs)
+
+
 def _flat_autograd_norm(tensor, **kwargs):  # pylint: disable=unused-argument
     """Helper function for computing the norm of an autograd tensor when the order or axes are not
     specified. This is used for differentiability."""

pennylane/resource/__init__.py

@@ -58,6 +58,7 @@
     :toctree: api
 
     ~AlgorithmicError
+    ~SpectralNormError
     ~ErrorOperation
 
 Resource Classes
@@ -123,4 +124,4 @@ def circuit(theta):
 from .second_quantization import DoubleFactorization
 from .measurement import estimate_error, estimate_shots
 from .specs import specs
-from .error import AlgorithmicError, ErrorOperation
+from .error import AlgorithmicError, ErrorOperation, SpectralNormError

pennylane/resource/error.py

@@ -16,7 +16,8 @@
 """
 from abc import ABC, abstractmethod
 
-from pennylane.operation import Operation
+from pennylane.operation import Operation, Operator, MatrixUndefinedError
+from pennylane import math as fn
 
 
 class AlgorithmicError(ABC):
@@ -77,3 +78,41 @@ def error(self) -> AlgorithmicError:
         Returns:
             AlgorithmicError: The error.
         """
+
+
+class SpectralNormError(AlgorithmicError):
+    """Class representing the spectral norm error.
+    The spectral norm error is defined as the distance (in spectral norm) between the true unitary we wish to apply and the approximate unitary that we actually apply.
+
+    Args:
+        error (float): The numerical value of the error
+
+    """
+
+    def combine(self, other: AlgorithmicError):
+        """A method to combine two spectral norm errors.
+
+        Args:
+            other (AlgorithmicError): The other instance of error being combined.
+
+        Returns:
+            AlgorithmicError: The total error after combination.
+        """
+        return self.__class__(self.error + other.error)
+
+    @staticmethod
+    def get_error(approximate_op: Operator, exact_op: Operator, **kwargs):
+        """A method to allow users to compute spectral norm error between two operators.
+
+        Args:
+            approximate_op (.Operator): The approximate operator.
+            exact_op (.Operator): The exact operator.
+
+        Returns:
+            float: The error between the exact operator and its
+            approximation.
+        """
+        if approximate_op.has_matrix and exact_op.has_matrix:
+            return fn.svd(exact_op.matrix() - approximate_op.matrix(), compute_uv=False)[0]
+
+        raise MatrixUndefinedError

tests/math/test_multi_dispatch.py

@@ -315,3 +315,86 @@ def test_autograd_norm_gradient(self, arr):
         grad = qml_grad(fn.norm)(arr)
         expected_grad = (norm**-1) * arr.conj()
         assert fn.allclose(grad, expected_grad)
+
+
+@pytest.mark.all_interfaces
+class TestSVD:
+    mat = [
+        [-0.00707107 + 0.0j, 1.00707107 + 0.0j],
+        [0.99292893 + 0.0j, -0.00707107 + 0.0j],
+    ]
+
+    mats_interface = (
+        (
+            onp.array(mat),
+            "numpy",
+        ),
+        (
+            torch.tensor(mat),
+            "torch",
+        ),
+        (
+            tf.Variable(mat),
+            "tensorflow",
+        ),
+        (
+            jnp.array(mat),
+            "jax",
+        ),
+    )
+
+    @pytest.mark.parametrize("mat, expected_intrf", mats_interface)
+    @pytest.mark.parametrize(
+        "expected_results",
+        [
+            (
+                [
+                    [
+                        [0.92388093 + 0.0j, -0.38268036 + 0.0j],
+                        [-0.38268048 + 0.0j, -0.9238808 + 0.0j],
+                    ],
+                    [1.0100001, 0.98999995],
+                    [[-0.3826802 + 0.0j, 0.9238809 + 0.0j], [-0.9238809 + 0.0j, -0.3826802 + 0.0j]],
+                ],
+            ),
+        ],
+    )
+    def test_svd_full(self, mat, expected_intrf, expected_results):
+        """Test that svd is correct and works for each interface. Asking for the full decomposition"""
+        results_svd = fn.svd(mat, compute_uv=True)
+        for n in range(len(expected_results)):
+            assert fn.get_interface(results_svd[n]) == expected_intrf
+        if expected_intrf == "tensorflow":
+            recovered_matrix = fn.matmul(
+                fn.matmul(
+                    results_svd[0],
+                    fn.diag(np.array(results_svd[1], dtype="complex128"), like=expected_intrf),
+                ),
+                results_svd[2],
+                like=expected_intrf,
+            )
+        else:
+            recovered_matrix = fn.matmul(
+                fn.matmul(
+                    results_svd[0],
+                    fn.diag(results_svd[1], like=expected_intrf),
+                ),
+                results_svd[2],
+                like=expected_intrf,
+            )
+
+        assert np.allclose(mat, recovered_matrix, rtol=1e-04)
+
+    @pytest.mark.parametrize("mat, expected_intrf", mats_interface)
+    @pytest.mark.parametrize(
+        "expected_results",
+        [
+            ([[1.0100001, 0.98999995]]),
+        ],
+    )
+    def test_svd_only_sv(self, mat, expected_intrf, expected_results):
+        """Test that svd is correct and works for each interface. Asking only for singular values."""
+        results_svd = fn.svd(mat, compute_uv=False)
+
+        assert np.allclose(results_svd, expected_results)
+        assert fn.get_interface(results_svd) == expected_intrf

tests/resource/test_error.py

@@ -15,9 +15,11 @@
 Test base AlgorithmicError class and its associated methods.
 """
 import pytest
+import numpy as np
 
 import pennylane as qml
-from pennylane.resource.error import AlgorithmicError, ErrorOperation
+from pennylane.resource.error import AlgorithmicError, SpectralNormError, ErrorOperation
+from pennylane.operation import Operation
 
 
 class SimpleError(AlgorithmicError):
@@ -82,6 +84,70 @@ def test_get_error(self):
         assert res == 0.5
 
 
+class TestSpectralNormError:
+    """Test methods for the SpectralNormError class"""
+
+    @pytest.mark.parametrize("err1", [0, 0.25, 0.75, 1.50, 2.50])
+    @pytest.mark.parametrize("err2", [0, 0.25, 0.75, 1.50, 2.50])
+    def test_combine(self, err1, err2):
+        """Test that combine works as expected"""
+        ErrorObj1 = SpectralNormError(err1)
+        ErrorObj2 = SpectralNormError(err2)
+
+        res = ErrorObj1.combine(ErrorObj2)
+        assert res.error == err1 + err2
+        assert isinstance(res, type(ErrorObj1))
+
+    @pytest.mark.parametrize(
+        "phi, expected",
+        [
+            [0, 2.0000000000000004],
+            [0.25, 1.9980522880732308],
+            [0.75, 1.9828661007943447],
+            [1.50, 1.9370988373785705],
+            [2.50, 1.8662406421959807],
+        ],
+    )
+    def test_get_error(self, phi, expected):
+        """Test that get_error works as expected"""
+        approx_op = qml.Hadamard(0)
+        exact_op = qml.RX(phi, 1)
+
+        res = SpectralNormError.get_error(approx_op, exact_op)
+        assert res == expected
+
+    @pytest.mark.parametrize(
+        "phi, expected",
+        [
+            [0, 1.311891347309272],
+            [0.25, 1.3182208123805488],
+            [0.75, 1.3772695464365001],
+            [1.50, 1.6078817482299055],
+            [2.50, 2.0506044587737255],
+        ],
+    )
+    def test_custom_operator(self, phi, expected):
+        """Test that get_error fails if the operator matrix is not defined"""
+
+        class DummyOp(Operation):  # pylint: disable=too-few-public-methods
+            def matrix(self):
+                return np.array([[0.5, 1.0], [1.2, 1.3]])
+
+        approx_op = DummyOp(1)
+        exact_op = qml.RX(phi, 1)
+
+        res = SpectralNormError.get_error(approx_op, exact_op)
+        assert res == expected
+
+    def test_no_operator_matrix_defined(self):
+        """Test that get_error fails if the operator matrix is not defined"""
+        approx_op = Operation
+        exact_op = qml.RX(0.1, 1)
+
+        with pytest.raises(qml.operation.MatrixUndefinedError):
+            SpectralNormError.get_error(approx_op, exact_op)
+
+
 class TestErrorOperation:  # pylint: disable=too-few-public-methods
     """Test the base ErrorOperation class."""