emu-mps 1.2.4__py3-none-any.whl → 1.2.6__py3-none-any.whl

emu_mps/__init__.py

@@ -35,4 +35,4 @@ __all__ = [
     "SecondMomentOfEnergy",
 ]
 
-__version__ = "1.2.4"
+__version__ = "1.2.6"

emu_mps/hamiltonian.py

@@ -360,7 +360,6 @@ def make_H(
 
     nqubits = interaction_matrix.size(dim=1)
     middle = nqubits // 2
-
     interactions_to_keep = _get_interactions_to_keep(interaction_matrix)
 
     cores = [_first_factor(interactions_to_keep[0].item() != 0.0)]

emu_mps/mpo.py

@@ -6,10 +6,9 @@ import torch
 
 from emu_mps.algebra import add_factors, scale_factors, zip_right
 from emu_base.base_classes.operator import FullOp, QuditOp
-from emu_base import Operator, State
+from emu_base import Operator, State, DEVICE_COUNT
 from emu_mps.mps import MPS
 from emu_mps.utils import new_left_bath, assign_devices
-from emu_mps.constants import DEVICE_COUNT
 
 
 def _validate_operator_targets(operations: FullOp, nqubits: int) -> None:

emu_mps/mps.py

@@ -6,7 +6,7 @@ from typing import Any, List, Optional, Iterable
 
 import torch
 
-from emu_base import State
+from emu_base import State, DEVICE_COUNT
 from emu_mps import MPSConfig
 from emu_mps.algebra import add_factors, scale_factors
 from emu_mps.utils import (
@@ -16,7 +16,6 @@ from emu_mps.utils import (
     tensor_trace,
     n_operator,
 )
-from emu_mps.constants import DEVICE_COUNT
 
 
 class MPS(State):

emu_mps/mps_backend_impl.py

@@ -11,7 +11,7 @@ import torch
 import time
 from pulser import Sequence
 
-from emu_base import Results, State, PulserData
+from emu_base import Results, State, PulserData, DEVICE_COUNT
 from emu_base.math.brents_root_finding import BrentsRootFinder
 from emu_mps.hamiltonian import make_H, update_H
 from emu_mps.mpo import MPO
@@ -83,6 +83,12 @@ class MPSBackendImpl:
         )
         self.last_save_time = time.time()
 
+        if self.config.num_gpus_to_use > DEVICE_COUNT:
+            self.config.logger.warning(
+                f"Requested to use {self.config.num_gpus_to_use} GPU(s) "
+                f"but only {DEVICE_COUNT if DEVICE_COUNT > 0 else 'cpu'} available"
+            )
+
     @staticmethod
     def _get_autosave_filepath(autosave_prefix: str) -> pathlib.Path:
         return pathlib.Path(os.getcwd()) / (autosave_prefix + str(uuid.uuid1()) + ".dat")

emu_mps/mps_config.py

@@ -1,7 +1,6 @@
 from typing import Any
 
-from emu_base import BackendConfig, State
-from emu_mps.constants import DEVICE_COUNT
+from emu_base import BackendConfig, State, DEVICE_COUNT
 
 
 class MPSConfig(BackendConfig):

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-1.2.4.dist-info → emu_mps-1.2.6.dist-info}/METADATA

@@ -1,7 +1,10 @@
 Metadata-Version: 2.4
 Name: emu-mps
-Version: 1.2.4
+Version: 1.2.6
 Summary: Pasqal MPS based pulse emulator built on PyTorch
+Project-URL: Documentation, https://pasqal-io.github.io/emulators/
+Project-URL: Repository, https://github.com/pasqal-io/emulators
+Project-URL: Issues, https://github.com/pasqal-io/emulators/issues
 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)
         
@@ -22,78 +25,13 @@ 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.4
+Requires-Dist: emu-base==1.2.6
 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.
-
-## 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
+# Welcome to the Pasqal analog emulators
 
-- [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, ...)
+Welcome, and please see the [GitHub pages](https://pasqal-io.github.io/emulators/) for a landing page to this repo.

emu_mps-1.2.6.dist-info/RECORD

@@ -0,0 +1,17 @@
+emu_mps/__init__.py,sha256=KphiJUrBt3vjS0e2_tQejeB12X3YwqrEhxwfF1QRXQE,646
+emu_mps/algebra.py,sha256=ngPtTH-j2ZCBWoaJZXlkUyIlug7dY7Q92gzfnRlpPMA,5485
+emu_mps/hamiltonian.py,sha256=LcBs6CKBb643a1e9AAVtQoUfa4L_0dIhLOKecx5OOWs,15864
+emu_mps/mpo.py,sha256=H5vkJvz4AfXfnPbvgWznBWpMUO8LnGL3_NAP3IhxZzQ,8740
+emu_mps/mps.py,sha256=CcduX2BC4ArBwwF41w_FQCa6wqmynegQQC9zkK0EmgQ,17826
+emu_mps/mps_backend.py,sha256=6fVaq-D4xyicYRjGjhqMEieC7---90LpfpbV7ZD7zkQ,2192
+emu_mps/mps_backend_impl.py,sha256=Rp7WbT0Dto1G4ArqSLEzSHkJAuMIEZfUqUMP9Dyz31M,20838
+emu_mps/mps_config.py,sha256=ydKN0OOaWCBcNd9V-4CU5ZZ4w1FRT-bbKyZQD2WCaME,3317
+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.6.dist-info/METADATA,sha256=iUObGpVmQN3Y6GM_ScEFmFlY80htsWrIjo53ER2Flvw,3505
+emu_mps-1.2.6.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+emu_mps-1.2.6.dist-info/RECORD,,

emu_mps/constants.py

@@ -1,4 +0,0 @@
-import torch
-
-
-DEVICE_COUNT = torch.cuda.device_count()

emu_mps-1.2.4.dist-info/RECORD

@@ -1,15 +0,0 @@
-emu_mps/__init__.py,sha256=ou1n7ieIHlszqg9hBVYhvA8IBOpeduAWno3GC7X2dWE,646
-emu_mps/algebra.py,sha256=ngPtTH-j2ZCBWoaJZXlkUyIlug7dY7Q92gzfnRlpPMA,5485
-emu_mps/constants.py,sha256=41LYkKLUCz-oxPbd-j7nUDZuhIbUrnez6prT0uR0jcE,56
-emu_mps/hamiltonian.py,sha256=LALCdAQyYQgqFLVvtB9cHoUilT_7eU-6bAHRhu39lqM,15865
-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=XCrmIjV-ZzI0nTOoaIaM6RGtfo4WHoJakVtoqoTZ7zI,20556
-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-1.2.4.dist-info/METADATA,sha256=nAxhFZeRlvVOqTdfJ-szluFRpa0q8EwbmogczPni3kM,5465
-emu_mps-1.2.4.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
-emu_mps-1.2.4.dist-info/RECORD,,