Merge pull request #38 from ColibrITD-SAS/functional_tests_execution

Functional tests execution in ideal case

Author: hJaffaliColibritd

mpqp/execution/runner.py

@@ -1,7 +1,7 @@
 from __future__ import annotations
 
 from numbers import Complex
-from typing import Optional, Union
+from typing import Optional, Sequence, Union
 
 import numpy as np
 from sympy import Expr
@@ -20,6 +20,7 @@
 from mpqp.execution.providers.ibm import run_ibm, submit_ibmq
 from mpqp.execution.result import BatchResult, Result
 from mpqp.tools.errors import RemoteExecutionError
+from mpqp.tools.generics import OneOrMany
 
 
 @typechecked
@@ -147,7 +148,7 @@ def _run_single(
 @typechecked
 def run(
     circuit: QCircuit,
-    device: AvailableDevice | list[AvailableDevice],
+    device: OneOrMany[AvailableDevice],
     values: Optional[dict[Expr | str, Complex]] = None,
 ) -> Union[Result, BatchResult]:
     """Runs the circuit on the backend, or list of backend, provided in
@@ -198,7 +199,7 @@ def run(
     if values is None:
         values = {}
 
-    if isinstance(device, list):
+    if isinstance(device, Sequence):
         # Duplicate devices are removed
         set_device = list(set(device))
         if len(set_device) == 1:

mpqp/tools/generics.py

@@ -8,6 +8,7 @@
 from typeguard import typechecked
 
 T = TypeVar("T")
+OneOrMany = Union[T, Sequence[T]]
 ListOrSingle = Union[list[T], T]
 """Type alias for both elements of type ``T``, or list of elements of type ``T``."""
 ArbitraryNestedSequence = Union[Sequence["ArbitraryNestedSequence"], T]

mpqp/tools/maths.py

@@ -1,11 +1,15 @@
 from __future__ import annotations
 
+import math
+from functools import reduce
 from numbers import Complex, Real
 from typing import TYPE_CHECKING
 
 import numpy as np
 import numpy.typing as npt
 import sympy as sp
+from qiskit import quantum_info
+from scipy.linalg import inv, sqrtm
 from sympy import Expr, I, pi  # pyright: ignore[reportUnusedImport]
 from typeguard import typechecked
 
@@ -41,7 +45,7 @@ def normalize(v: npt.NDArray[np.complex64]) -> npt.NDArray[np.complex64]:
 
 @typechecked
 def matrix_eq(lhs: Matrix, rhs: Matrix) -> bool:
-    r"""Checks whether two matrix are element-wise equal, within a tolerance.
+    r"""Checks whether two matrix (including vectors) are element-wise equal, within a tolerance.
 
     For respectively each elements `a` and `b` of both inputs, we check this
     specific condition: `|a - b| \leq (atol + rtol * |b|)`.
@@ -182,3 +186,75 @@ def exp(angle: Expr | Complex) -> sp.Expr | complex:
         res = sp.exp(angle)
         assert isinstance(res, Expr)
         return res
+
+
+def rand_orthogonal_matrix_seed(size: int, seed: int) -> npt.NDArray[np.complex64]:
+    """Generate a random orthogonal matrix with a given seed.
+
+    Args:
+        size: Size (number of columns, or rows) of the squared matrix to generate.
+        seed: Seed used to control the random generation of the matrix.
+
+    Returns:
+        A random orthogonal Matrix.
+    """
+    # TODO: example
+    np.random.seed(seed)
+    m = np.random.rand(size, size)
+    return m.dot(inv(sqrtm(m.T.dot(m))))
+
+
+def rand_orthogonal_matrix(size: int) -> npt.NDArray[np.complex64]:
+    """Generate a random orthogonal matrix without a given seed"""
+    # TODO: to comment + examples
+    m = np.random.rand(size, size)
+    return m.dot(inv(sqrtm(m.T.dot(m))))
+
+
+def rand_clifford_matrix(nb_qubits: int) -> npt.NDArray[np.complex64]:
+    """Generate a random Clifford matrix"""
+    # TODO: to comment + examples
+    return quantum_info.random_clifford(
+        nb_qubits
+    ).to_matrix()  # pyright: ignore[reportReturnType]
+
+
+def rand_unitary_2x2_matrix() -> npt.NDArray[np.complex64]:
+    """Generate a random one-qubit unitary matrix"""
+    # TODO: to comment + examples
+    theta, phi, gamma = np.random.rand(3) * 2 * math.pi
+    c, s, eg, ep = (
+        np.cos(theta / 2),
+        np.sin(theta / 2),
+        np.exp(gamma * 1j),
+        np.exp(phi * 1j),
+    )
+    return np.array([[c, -eg * s], [eg * s, eg * ep * c]])
+
+
+def rand_product_local_unitaries(nb_qubits: int) -> npt.NDArray[np.complex64]:
+    """
+    Generate a random tensor product of unitary matrices
+
+    Args:
+        nb_qubits: Number of qubits on which the product of unitaries will act.
+    """
+    return reduce(
+        np.kron,
+        [rand_unitary_2x2_matrix() for _ in range(nb_qubits - 1)],
+        np.eye(1, dtype=np.complex64),
+    )
+
+
+def rand_hermitian_matrix(size: int) -> npt.NDArray[np.complex64]:
+    """Generate a random Hermitian matrix.
+
+    Args:
+        size: Size (number of columns, or rows) of the squared matrix to generate.
+
+    Returns:
+        A random orthogonal Matrix.
+    """
+    # TODO: examples
+    m = np.random.rand(size, size).astype(np.complex64)
+    return m + m.conjugate().transpose()

pytest.ini

@@ -14,4 +14,6 @@ filterwarnings =
     ignore:Setting metadata to None.*:DeprecationWarning
     ignore:divide by zero.*:RuntimeWarning
     ignore:The qiskit.extensions module is pending deprecation.*:PendingDeprecationWarning
-    ignore:Building a flow controller with keyword arguments is going to be deprecated.*:PendingDeprecationWarning
+    ignore:Building a flow controller with keyword arguments is going to be deprecated.*:PendingDeprecationWarning
+    ignore:.*OpenQASM language features that m.*
+    ignore:.*OpenQASMTranslationWarning.*