Add order parameter to backend.calculate_norm

doc/source/api-reference/qibo.rst

@@ -655,7 +655,7 @@ Parametric ZX interaction (RZX)
     :member-order: bysource
 
 Parametric XX-YY interaction (RXXYY)
-""""""""""""""""""""""""""""""""""
+""""""""""""""""""""""""""""""""""""
 
 .. autoclass:: qibo.gates.RXXYY
     :members:

src/qibo/backends/abstract.py

@@ -326,13 +326,29 @@ def entanglement_entropy(self, rho):  # pragma: no cover
         raise_error(NotImplementedError)
 
     @abc.abstractmethod
-    def calculate_norm(self, state):  # pragma: no cover
-        """Calculate norm of a state vector."""
+    def calculate_norm(self, state, order=2):  # pragma: no cover
+        """Calculate norm of a state vector.
+
+        For specifications on possible values of the parameter ``order``
+        for the ``tensorflow`` backend, please refer to
+        `tensorflow.norm <https://www.tensorflow.org/api_docs/python/tf/norm>`_.
+        For all other backends, please refer to
+        `numpy.linalg.norm <https://numpy.org/doc/stable/reference/generated/numpy.linalg.norm.html>`_.
+        """
         raise_error(NotImplementedError)
 
     @abc.abstractmethod
-    def calculate_norm_density_matrix(self, state):  # pragma: no cover
-        """Calculate norm (trace) of a density matrix."""
+    def calculate_norm_density_matrix(self, state, order="nuc"):  # pragma: no cover
+        """Calculate norm (trace) of a density matrix.
+
+        If ``order="nuc"``, it returns the nuclear norm os ``state``,
+        assuming ``state`` is Hermitian. For specifications on the other
+        possible values of the parameter ``order`` for the ``tensorflow`` backend,
+        please refer to
+        `tensorflow.norm <https://www.tensorflow.org/api_docs/python/tf/norm>`_.
+        For all other backends, please refer to
+        `numpy.linalg.norm <https://numpy.org/doc/stable/reference/generated/numpy.linalg.norm.html>`_.
+        """
         raise_error(NotImplementedError)
 
     @abc.abstractmethod

src/qibo/backends/numpy.py

@@ -673,13 +673,13 @@ def entanglement_entropy(self, rho):
         entropy = self.np.sum(masked_eigvals * spectrum) / self.np.log(2.0)
         return entropy, spectrum
 
-    def calculate_norm(self, state):
+    def calculate_norm(self, state, order=2):
         state = self.cast(state)
-        return self.np.sqrt(self.np.sum(self.np.abs(state) ** 2))
+        return self.np.linalg.norm(state, ord=order)
 
-    def calculate_norm_density_matrix(self, state):
+    def calculate_norm_density_matrix(self, state, order="nuc"):
         state = self.cast(state)
-        return self.np.trace(state)
+        return self.np.linalg.norm(state, ord=order)
 
     def calculate_overlap(self, state1, state2):
         state1 = self.cast(state1)

src/qibo/backends/tensorflow.py

@@ -306,6 +306,16 @@ def entanglement_entropy(self, rho):
         entropy = self.np.sum(masked_eigvals * spectrum) / self.np.log(2.0)
         return entropy, spectrum
 
+    def calculate_norm(self, state, order=2):
+        state = self.cast(state)
+        return self.tf.norm(state, ord=order)
+
+    def calculate_norm_density_matrix(self, state, order="nuc"):
+        state = self.cast(state)
+        if order == "nuc":
+            return self.np.trace(state)
+        return self.tf.norm(state, ord=order)
+
     def calculate_eigenvalues(self, matrix, k=6):
         return self.tf.linalg.eigvalsh(matrix)
 

tests/test_callbacks.py

@@ -7,6 +7,7 @@
 # Absolute testing tolerance for the cases of zero entanglement entropy
 from qibo.config import PRECISION_TOL
 from qibo.models import AdiabaticEvolution, Circuit
+from qibo.quantum_info.random_ensembles import random_density_matrix, random_statevector
 
 
 def test_abstract_callback_properties():
@@ -324,17 +325,18 @@ def test_state_callback(backend, density_matrix, copy):
     backend.assert_allclose(statec[1], target_state1)
 
 
+@pytest.mark.parametrize("seed", list(range(1, 5 + 1)))
 @pytest.mark.parametrize("density_matrix", [False, True])
-def test_norm(backend, density_matrix):
+def test_norm(backend, density_matrix, seed):
     norm = callbacks.Norm()
     if density_matrix:
         norm.nqubits = 1
-        state = np.random.random((2, 2)) + 1j * np.random.random((2, 2))
+        state = random_density_matrix(2**norm.nqubits, seed=seed, backend=backend)
         target_norm = np.trace(state)
         final_norm = norm.apply_density_matrix(backend, state)
     else:
         norm.nqubits = 2
-        state = np.random.random(4) + 1j * np.random.random(4)
+        state = random_statevector(2**norm.nqubits, seed=seed, backend=backend)
         target_norm = np.sqrt((np.abs(state) ** 2).sum())
         final_norm = norm.apply(backend, state)