emu-mps 1.2.3__py3-none-any.whl → 1.2.5__py3-none-any.whl

emu_mps/optimatrix/__init__.py

@@ -0,0 +1,9 @@
+from .optimiser import minimize_bandwidth
+from .permutations import permute_list, permute_matrix, invert_permutation
+
+__all__ = [
+    "minimize_bandwidth",
+    "permute_list",
+    "permute_matrix",
+    "invert_permutation",
+]

emu_mps/optimatrix/optimiser.py

@@ -0,0 +1,234 @@
+from scipy.sparse import csr_matrix
+from scipy.sparse.csgraph import reverse_cuthill_mckee
+import numpy as np
+from emu_mps.optimatrix.permutations import permute_matrix, permute_list
+import itertools
+
+
+def is_symmetric(mat: np.ndarray) -> bool:
+    if mat.shape[0] != mat.shape[1]:
+        return False
+    if not np.allclose(mat, mat.T, atol=1e-8):
+        return False
+
+    return True
+
+
+def matrix_bandwidth(mat: np.ndarray) -> float:
+    """matrix_bandwidth(matrix: np.ndarray) -> float
+
+    Computes bandwidth as max weighted distance between columns of
+    a square matrix as `max (abs(matrix[i, j] * (j - i))`.
+
+             abs(j-i)
+          |<--------->|
+        (i,i)       (i,j)
+          |           |
+    | *   .   .   .   .   . |
+    | .   *   .   .   a   . |
+    | .   .   *   .   .   . |
+    | .   .   .   *   .   . |
+    | .   .   .   .   *   . |
+    | .   .   .   .   .   * |
+
+    Distance from the main diagonal `[i,i]` and element `m[i,j]` along row is
+    `abs(j-i)` and therefore the weighted distance is `abs(matrix[i, j] * (j - i))`
+
+    Parameters
+    -------
+    matrix :
+        square matrix nxn
+
+    Returns
+    -------
+        bandwidth of the input matrix
+
+    Example:
+    -------
+    >>> matrix = np.array([
+    ...    [  1, -17, 2.4],
+    ...    [  9,   1, -10],
+    ...    [-15,  20,   1],])
+    >>> matrix_bandwidth(matrix) # 30.0 because abs(-15 * (2-0) == 30)
+    30.0
+    """
+
+    bandwidth = max(abs(el * (index[0] - index[1])) for index, el in np.ndenumerate(mat))
+    return float(bandwidth)
+
+
+def minimize_bandwidth_above_threshold(mat: np.ndarray, threshold: float) -> np.ndarray:
+    """
+    minimize_bandwidth_above_threshold(matrix, trunc) -> permutation_lists
+
+    Finds a permutation list that minimizes a bandwidth of a symmetric matrix `A = A.T`
+    using the reverse Cuthill-Mckee algorithm from `scipy.sparse.csgraph.reverse_cuthill_mckee`.
+    Matrix elements below a threshold `m[i,j] < threshold` are considered as 0.
+
+    Parameters
+    -------
+    matrix :
+        symmetric square matrix
+    threshold :
+        matrix elements `m[i,j] < threshold` are considered as 0
+
+    Returns
+    -------
+        permutation list that minimizes matrix bandwidth for a given threshold
+
+    Example:
+    -------
+    >>> matrix = np.array([
+    ...    [1, 2, 3],
+    ...    [2, 5, 6],
+    ...    [3, 6, 9]])
+    >>> threshold = 3
+    >>> minimize_bandwidth_above_threshold(matrix, threshold)
+    array([1, 2, 0], dtype=int32)
+    """
+
+    matrix_truncated = mat.copy()
+    matrix_truncated[mat < threshold] = 0
+    rcm_permutation = reverse_cuthill_mckee(
+        csr_matrix(matrix_truncated), symmetric_mode=True
+    )
+    return np.array(rcm_permutation)
+
+
+def minimize_bandwidth_global(mat: np.ndarray) -> list[int]:
+    """
+    minimize_bandwidth_global(matrix) -> list
+
+    Does one optimisation step towards finding
+    a permutation of a matrix that minimizes matrix bandwidth.
+
+    Parameters
+    -------
+    matrix :
+        symmetric square matrix
+
+    Returns
+    -------
+        permutation order that minimizes matrix bandwidth
+
+    Example:
+    -------
+    >>> matrix = np.array([
+    ...    [1, 2, 3],
+    ...    [2, 5, 6],
+    ...    [3, 6, 9]])
+    >>> minimize_bandwidth_global(matrix)
+    [2, 1, 0]
+    """
+    mat_amplitude = np.max(np.abs(mat))
+    # Search from 1.0 to 0.1 doesn't change result
+    permutations = (
+        minimize_bandwidth_above_threshold(mat, trunc * mat_amplitude)
+        for trunc in np.arange(start=0.1, stop=1.0, step=0.01)
+    )
+
+    opt_permutation = min(
+        permutations, key=lambda perm: matrix_bandwidth(permute_matrix(mat, list(perm)))
+    )
+    return list(opt_permutation)  # opt_permutation is np.ndarray
+
+
+def minimize_bandwidth_impl(
+    matrix: np.ndarray, initial_perm: list[int]
+) -> tuple[list[int], float]:
+    """
+    minimize_bandwidth_impl(matrix, initial_perm) -> list
+
+    Applies initial_perm to a matrix and
+    finds the permutation list for a symmetric matrix that iteratively minimizes matrix bandwidth.
+
+    Parameters
+    -------
+    matrix :
+        symmetric square matrix
+    initial_perm: list of integers
+
+
+    Returns
+    -------
+        permutation order that minimizes matrix bandwidth
+
+    Example:
+    -------
+    Periodic 1D chain
+    >>> matrix = np.array([
+    ...    [0, 1, 0, 0, 1],
+    ...    [1, 0, 1, 0, 0],
+    ...    [0, 1, 0, 1, 0],
+    ...    [0, 0, 1, 0, 1],
+    ...    [1, 0, 0, 1, 0]])
+    >>> id_perm = list(range(matrix.shape[0]))
+    >>> minimize_bandwidth_impl(matrix, id_perm) # [3, 2, 4, 1, 0] does zig-zag
+    ([3, 2, 4, 1, 0], 2.0)
+
+    Simple 1D chain. Cannot be optimised further
+    >>> matrix = np.array([
+    ...    [0, 1, 0, 0, 0],
+    ...    [1, 0, 1, 0, 0],
+    ...    [0, 1, 0, 1, 0],
+    ...    [0, 0, 1, 0, 1],
+    ...    [0, 0, 0, 1, 0]])
+    >>> id_perm = list(range(matrix.shape[0]))
+    >>> minimize_bandwidth_impl(matrix, id_perm)
+    ([0, 1, 2, 3, 4], 1.0)
+    """
+    if initial_perm != list(range(matrix.shape[0])):
+        matrix = permute_matrix(matrix, initial_perm)
+    bandwidth = matrix_bandwidth(matrix)
+    acc_permutation = initial_perm
+
+    for counter in range(101):
+        if counter == 100:
+            raise (
+                NotImplementedError(
+                    "The algorithm takes too many steps, " "probably not converging."
+                )
+            )
+
+        optimal_perm = minimize_bandwidth_global(matrix)
+        test_mat = permute_matrix(matrix, optimal_perm)
+        new_bandwidth = matrix_bandwidth(test_mat)
+
+        if bandwidth <= new_bandwidth:
+            break
+
+        matrix = test_mat
+        acc_permutation = permute_list(acc_permutation, optimal_perm)
+        bandwidth = new_bandwidth
+
+    return acc_permutation, bandwidth
+
+
+def minimize_bandwidth(input_matrix: np.ndarray, samples: int = 100) -> list[int]:
+    assert is_symmetric(input_matrix), "Input matrix is not symmetric"
+    input_mat = abs(input_matrix)
+    # We are interested in strength of the interaction, not sign
+
+    L = input_mat.shape[0]
+    rnd_permutations = itertools.chain(
+        [list(range(L))],  # First element is always the identity list
+        (np.random.permutation(L).tolist() for _ in range(samples)),
+    )
+
+    opt_permutations_and_opt_bandwidth = (
+        minimize_bandwidth_impl(input_mat, rnd_perm) for rnd_perm in rnd_permutations
+    )
+
+    best_perm, best_bandwidth = min(
+        opt_permutations_and_opt_bandwidth,
+        key=lambda perm_and_bandwidth: perm_and_bandwidth[1],
+    )
+
+    assert best_bandwidth <= matrix_bandwidth(input_matrix), "Matrix is not optimised"
+    return best_perm
+
+
+if __name__ == "__main__":
+    import doctest
+
+    doctest.testmod()

emu_mps/optimatrix/permutations.py

@@ -0,0 +1,94 @@
+import numpy as np
+
+
+def permute_list(input_list: list, permutation: list[int]) -> list:
+    """
+    Permutes the input list according to the given permutation.
+
+    Parameters
+    -------
+    input_list :
+        A list to permute.
+    permutation :
+        A list of indices representing the new order.
+
+    Returns
+    -------
+        The permuted list.
+
+    Example
+    -------
+    >>> permute_list(['a', 'b', 'c'], [2, 0, 1])
+    ['c', 'a', 'b']
+    """
+
+    permuted_list = [None] * len(input_list)
+    for i, p in enumerate(permutation):
+        permuted_list[i] = input_list[p]
+    return permuted_list
+
+
+def invert_permutation(permutation: list[int]) -> list[int]:
+    """
+    invert_permutation(permutation) -> inv_permutation
+
+    Inverts the input permutation list.
+
+    Parameters
+    -------
+    permutation :
+        A list of indices representing the order
+
+    Returns
+    -------
+        permutation list inverse to the input list
+
+    Example:
+    -------
+    >>> invert_permutation([2, 0, 1])
+    [1, 2, 0]
+    """
+
+    inv_perm = np.empty_like(permutation)
+    inv_perm[permutation] = np.arange(len(permutation))
+    return list(inv_perm)
+
+
+def permute_matrix(mat: np.ndarray, permutation: list[int]) -> np.ndarray:
+    """
+    permute_matrix(matrix, permutation_list) -> permuted_matrix
+
+    Simultaneously permutes columns and rows according to a permutation list.
+
+    Parameters
+    -------
+    matrix :
+        square matrix nxn
+    permutation :
+        permutation list
+
+    Returns
+    -------
+        matrix with permuted columns and rows
+
+    Example:
+    -------
+    >>> matrix = np.array([
+    ...    [1, 2, 3],
+    ...    [4, 5, 6],
+    ...    [7, 8, 9]])
+    >>> permutation = [1, 0, 2]
+    >>> permute_matrix(matrix, permutation)
+    array([[5, 4, 6],
+           [2, 1, 3],
+           [8, 7, 9]])
+    """
+
+    perm = np.array(permutation)
+    return mat[perm, :][:, perm]
+
+
+if __name__ == "__main__":
+    import doctest
+
+    doctest.testmod()

emu_mps/tdvp.py

@@ -3,6 +3,7 @@ import torch
 from emu_base import krylov_exp
 from emu_mps import MPS, MPO
 from emu_mps.utils import split_tensor
+from emu_mps.mps_config import MPSConfig
 
 
 def new_right_bath(
@@ -10,7 +11,8 @@ def new_right_bath(
 ) -> torch.Tensor:
     bath = torch.tensordot(state, bath, ([2], [2]))
     bath = torch.tensordot(op.to(bath.device), bath, ([2, 3], [1, 3]))
-    return torch.tensordot(state.conj(), bath, ([1, 2], [1, 3]))
+    bath = torch.tensordot(state.conj(), bath, ([1, 2], [1, 3]))
+    return bath
 
 
 """
@@ -79,27 +81,6 @@ def apply_effective_Hamiltonian(
 _TIME_CONVERSION_COEFF = 0.001  # Omega and delta are given in rad/ms, dt in ns
 
 
-class EvolveConfig:
-    def __init__(
-        self,
-        *,
-        exp_tolerance: float,
-        norm_tolerance: float,
-        max_krylov_dim: int,
-        is_hermitian: bool,
-        max_error: float,
-        max_rank: int
-    ) -> None:
-        self.exp_tolerance = exp_tolerance
-        self.norm_tolerance = norm_tolerance
-        self.max_krylov_dim = max_krylov_dim
-        self.is_hermitian = is_hermitian
-        self.max_error = (
-            max_error  # FIXME: max_error and max_rank are irrelevant for evolve_single
-        )
-        self.max_rank = max_rank
-
-
 def evolve_pair(
     *,
     state_factors: list[torch.Tensor],
@@ -107,7 +88,8 @@ def evolve_pair(
     ham_factors: list[torch.Tensor],
     dt: float,
     orth_center_right: bool,
-    config: EvolveConfig
+    is_hermitian: bool,
+    config: MPSConfig,
 ) -> tuple[torch.Tensor, torch.Tensor]:
     """
     Time evolution of a pair of tensors of a tensor train using baths and truncated SVD.
@@ -154,16 +136,16 @@ def evolve_pair(
     evol = krylov_exp(
         op,
         combined_state_factors,
-        exp_tolerance=config.exp_tolerance,
-        norm_tolerance=config.norm_tolerance,
+        exp_tolerance=config.precision * config.extra_krylov_tolerance,
+        norm_tolerance=config.precision * config.extra_krylov_tolerance,
         max_krylov_dim=config.max_krylov_dim,
-        is_hermitian=config.is_hermitian,
+        is_hermitian=is_hermitian,
     ).reshape(left_bond_dim * 2, 2 * right_bond_dim)
 
     l, r = split_tensor(
         evol,
-        max_error=config.max_error,
-        max_rank=config.max_rank,
+        max_error=config.precision,
+        max_rank=config.max_bond_dim,
         orth_center_right=orth_center_right,
     )
 
@@ -178,7 +160,8 @@ def evolve_single(
     baths: tuple[torch.Tensor, torch.Tensor],
     ham_factor: torch.Tensor,
     dt: float,
-    config: EvolveConfig
+    is_hermitian: bool,
+    config: MPSConfig,
 ) -> torch.Tensor:
     """
     Time evolution of a single tensor of a tensor train using baths.
@@ -202,8 +185,8 @@ def evolve_single(
     return krylov_exp(
         op,
         state_factor,
-        exp_tolerance=config.exp_tolerance,
-        norm_tolerance=config.norm_tolerance,
+        exp_tolerance=config.precision * config.extra_krylov_tolerance,
+        norm_tolerance=config.precision * config.extra_krylov_tolerance,
         max_krylov_dim=config.max_krylov_dim,
-        is_hermitian=config.is_hermitian,
+        is_hermitian=is_hermitian,
     )

emu_mps/utils.py

@@ -3,7 +3,7 @@ import torch
 import random
 from collections import Counter
 
-DEVICE_COUNT = torch.cuda.device_count()
+from emu_mps import MPSConfig
 
 
 def new_left_bath(
@@ -12,15 +12,16 @@ def new_left_bath(
     # this order is more efficient than contracting the op first in general
     bath = torch.tensordot(bath, state.conj(), ([0], [0]))
     bath = torch.tensordot(bath, op.to(bath.device), ([0, 2], [0, 1]))
-    return torch.tensordot(bath, state, ([0, 2], [0, 1]))
+    bath = torch.tensordot(bath, state, ([0, 2], [0, 1]))
+    return bath
 
 
 def _determine_cutoff_index(d: torch.Tensor, max_error: float) -> int:
     assert max_error > 0
     squared_max_error = max_error * max_error
-    acc = 0
+    acc = 0.0
     for i in range(d.shape[0]):
-        acc += d[i]
+        acc += d[i].item()
         if acc > squared_max_error:
             return i
     return 0  # type: ignore[no-any-return]
@@ -60,9 +61,8 @@ def split_tensor(
 
 
 def truncate_impl(
-    factors: list[torch.tensor],
-    max_error: float = 1e-5,
-    max_rank: int = 1024,
+    factors: list[torch.Tensor],
+    config: MPSConfig,
 ) -> None:
     """
     Eigenvalues-based truncation of a matrix product.
@@ -78,8 +78,8 @@ def truncate_impl(
 
         l, r = split_tensor(
             factors[i].reshape(factor_shape[0], -1),
-            max_error=max_error,
-            max_rank=max_rank,
+            max_error=config.precision,
+            max_rank=config.max_bond_dim,
             orth_center_right=False,
         )
 
@@ -241,7 +241,7 @@ def apply_measurement_errors(
     return result
 
 
-n_operator = torch.tensor(
+n_operator: torch.Tensor = torch.tensor(
     [
         [0, 0],
         [0, 1],

emu_mps-1.2.5.dist-info/METADATA

@@ -0,0 +1,101 @@
+Metadata-Version: 2.4
+Name: emu-mps
+Version: 1.2.5
+Summary: Pasqal MPS based pulse emulator built on PyTorch
+Author-email: Anton Quelle <anton.quelle@pasqal.com>, Mauro Mendizabal <mauro.mendizabal-pico@pasqal.com>, Stefano Grava <stefano.grava@pasqal.com>, Pablo Le Henaff <pablo.le-henaff@pasqal.com>
+License: PASQAL OPEN-SOURCE SOFTWARE LICENSE AGREEMENT (MIT-derived)
+        
+        The author of the License is:
+          Pasqal, a Société par Actions Simplifiée (Simplified Joint Stock Company) registered under number 849 441 522 at the Registre du commerce et des sociétés (Trade and Companies Register) of Evry – France, headquartered at 7 rue Leonard de Vinci – 91300 – Massy – France, duly represented by its Président, M. Georges-Olivier REYMOND,
+        
+        Hereafter referred to as « the Licensor »
+        
+        - Permission is hereby granted, free of charge, to any person obtaining a copy of this software (the “Licensee”) and associated documentation files (the “Software”), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
+        The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software. The Software is “as is”, without warranty of any kind, express or implied, including but not limited to the warranties of merchantability, fitness for a particular purpose and non-infringement. In no event shall the authors or copyright holders be liable for any claim, damages or other liability, whether in an action of contract, tort or otherwise arising from, out of or in connection with the Software or the use or other dealings in the Software.
+        
+        - If use of the Software leads to the necessary use of any patent of the Licensor and/or any of its Affiliates (defined as a company owned or controlled by the Licensor), the Licensee is granted a royalty-free license, in any country where such patent is in force, to use the object of such patent; or use the process covered by such patent,
+        
+        - Such a patent license is granted for internal research or academic use of the Licensee's, which includes use by employees and students of the Licensee, acting on behalf of the Licensee, for research purposes only.
+        
+        - The License is governed by the laws of France. Any dispute relating to the License, notably its execution, performance and/or termination shall be brought to, heard and tried by the Tribunal Judiciaire de Paris, regardless of the rules of jurisdiction in the matter.
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: Implementation :: CPython
+Classifier: Programming Language :: Python :: Implementation :: PyPy
+Requires-Python: >=3.10
+Requires-Dist: emu-base==1.2.5
+Description-Content-Type: text/markdown
+
+<div align="center">
+  <img src="docs/logos/LogoTaglineSoftGreen.svg">
+
+  # Emu-MPS
+</div>
+
+**Emu-mps** is a backend for the [Pulser low-level Quantum Programming toolkit](https://pulser.readthedocs.io) that lets you run Quantum Algorithms on a simulated device, using GPU acceleration if available. More in depth, emu-mps is designed to **emu**late the dynamics of programmable arrays of neutral atoms, with matrix product states (**mps**). While benchmarking is incomplete as of this writing, early results suggest that this design makes emu-mps faster and more memory-efficient than previous generations of quantum emulators at running simulations with large numbers of qubits.
+
+As of this writing, Emu-MPS is provided for Linux and macOS but will not work under Windows.
+
+## Installation
+
+**Warning:** installing emu-mps will update pulser-core
+
+### Using `hatch`, `uv` or any pyproject-compatible Python manager
+
+To add `emu-mps` to your project, edit your `pyproject.toml` to add the line
+
+```toml
+  "emu-mps"
+```
+
+to the list of `dependencies`.
+
+
+### Using `pip` or `pipx`
+To install the `pipy` package using `pip` or `pipx`
+
+1. Create a `venv` if that's not done yet
+
+```sh
+$ python -m venv venv
+
+```
+
+2. Enter the venv
+
+If you're running Unix:
+
+```sh
+$ . venv/bin/activate
+```
+
+If you're running Windows:
+
+```sh
+C:\> /path/to/new/virtual/environment/Scripts/activate
+```
+
+3. Install the package
+
+```sh
+$ pip install emu-mps
+# or
+$ pipx install emu-mps
+```
+
+
+Join us on [Slack](https://pasqalworkspace.slack.com/archives/C07MUV5K7EU) or by [e-mail](mailto:emulation@pasqal.com) to give us feedback about how you plan to use Emu-MPS or if you require specific feature-upgrades.
+
+## Usage
+
+For the time being, the easiest way to learn how to use this package is to look
+at the [examples](examples/emu_mps_examples) and [notebooks](https://pasqal-io.github.io/emulators/latest/).
+
+See also the [full documentation](https://github.com/pasqal-io/emulators/blob/main/docs/index.md) for
+the API, information about contributing, benchmarks, etc.
+
+
+## Getting in touch
+
+- [Pasqal Community Portal](https://community.pasqal.com/) (forums, chat, tutorials, examples, code library).
+- [GitHub Repository](https://github.com/pasqal-io/quantum-evolution-kernel) (source code, issue tracker).
+- [Professional Support](https://www.pasqal.com/contact-us/) (if you need tech support, custom licenses, a variant of this library optimized for your workload, your own QPU, remote access to a QPU, ...)

emu_mps-1.2.5.dist-info/RECORD

@@ -0,0 +1,18 @@
+emu_mps/__init__.py,sha256=EdVngqaa6GtyXmEP2aK3BfTHjYLBJSN3wR0CvltS9NQ,646
+emu_mps/algebra.py,sha256=ngPtTH-j2ZCBWoaJZXlkUyIlug7dY7Q92gzfnRlpPMA,5485
+emu_mps/constants.py,sha256=41LYkKLUCz-oxPbd-j7nUDZuhIbUrnez6prT0uR0jcE,56
+emu_mps/hamiltonian.py,sha256=LcBs6CKBb643a1e9AAVtQoUfa4L_0dIhLOKecx5OOWs,15864
+emu_mps/mpo.py,sha256=7y6q0UIfyX9igQknqtgt6nymuVcgjHlH3-Qv7N7uOZE,8769
+emu_mps/mps.py,sha256=OjG_caqPOioCdOt-bFUkOf2xuNGnKzj0LaMc3EJCHi4,17855
+emu_mps/mps_backend.py,sha256=6fVaq-D4xyicYRjGjhqMEieC7---90LpfpbV7ZD7zkQ,2192
+emu_mps/mps_backend_impl.py,sha256=HKDqUakqSs1THeeEZP5MFZaUyALnaIhrlsZTQ0Qp4qU,20867
+emu_mps/mps_config.py,sha256=MxahrPDaOpfdB6SLG1610iDUOuLR04IaCjKQRk99ICY,3346
+emu_mps/noise.py,sha256=h4X2EFjoC_Ok0gZ8I9wN77RANXaVehTBbjkcbY_GAmY,784
+emu_mps/tdvp.py,sha256=TH4CcBNczRURXYGPXndWKDs0jWXz_x9ozM961uGiSOw,5711
+emu_mps/utils.py,sha256=n9BcpuIz4Kl6EYlATaK8TKsyF-T7FTwbBo6KSAQYzl8,8066
+emu_mps/optimatrix/__init__.py,sha256=lHWYNeThHp57ZrwTwXd0p8bNvcCv0w_AZ31iCWflBUo,226
+emu_mps/optimatrix/optimiser.py,sha256=cVMdm2r_4OpbthcQuFMrJ9rNR9WEJRga9c_lHrJFkhw,6687
+emu_mps/optimatrix/permutations.py,sha256=JRXGont8B4QgbkV9CzrA0w7uzLgBrmZ1J9aa0G52hPo,1979
+emu_mps-1.2.5.dist-info/METADATA,sha256=bOtqQKZZ6ZkK9C6aV4puIipHUm5v1G9-tQrUftkIw0M,5559
+emu_mps-1.2.5.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+emu_mps-1.2.5.dist-info/RECORD,,