dense-evolution 8.1.78__tar.gz → 8.1.80__tar.gz

{dense_evolution-8.1.78 → dense_evolution-8.1.80}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: dense-evolution
-Version: 8.1.78
+Version: 8.1.80
 Summary: High-performance quantum simulation toolkit -- Statevector/MPS engines with JIT compilation, noise modeling, VQE, QEC, quantum chemistry, and agent-native tooling
 Author-email: Salvatore Pennacchio <jtatopenn@libero.it>
 License: Business Source License 1.1
@@ -38,6 +38,7 @@ Provides-Extra: dashboard
 Requires-Dist: streamlit>=1.30.0; extra == "dashboard"
 Requires-Dist: qiskit>=1.0.0; extra == "dashboard"
 Requires-Dist: pylatexenc>=2.10; extra == "dashboard"
+Requires-Dist: plotly>=5.0.0; extra == "dashboard"
 Provides-Extra: qiskit
 Requires-Dist: qiskit>=1.0.0; extra == "qiskit"
 Provides-Extra: pennylane
@@ -64,6 +65,7 @@ Requires-Dist: cupy-cuda12x>=12.0.0; extra == "full"
 Requires-Dist: streamlit>=1.30.0; extra == "full"
 Requires-Dist: qiskit>=1.0.0; extra == "full"
 Requires-Dist: pylatexenc>=2.10; extra == "full"
+Requires-Dist: plotly>=5.0.0; extra == "full"
 Requires-Dist: pennylane>=0.35.0; extra == "full"
 Requires-Dist: basis_set_exchange>=0.9; extra == "full"
 Requires-Dist: fastapi>=0.110.0; extra == "full"
@@ -82,6 +84,7 @@ Requires-Dist: mkdocs-include-markdown-plugin>=6.0.0; extra == "docs"
 Requires-Dist: ruff>=0.4.0; extra == "docs"
 Requires-Dist: pennylane>=0.35.0; extra == "docs"
 Requires-Dist: basis_set_exchange>=0.9; extra == "docs"
+Requires-Dist: plotly>=5.0.0; extra == "docs"
 Dynamic: license-file
 
 <p align="center">
@@ -335,7 +338,7 @@ If Dense-Evolution is useful in academic work, please cite it via the metadata i
 Archived on [Zenodo](https://zenodo.org/):
 
 - **Concept DOI** (always resolves to the latest version): [10.5281/zenodo.21855643](https://doi.org/10.5281/zenodo.21855643)
-- **This release (v8.1.74)**: [10.5281/zenodo.22669081](https://doi.org/10.5281/zenodo.22669081)
+- **This release (v8.1.78)**: [10.5281/zenodo.22706039](https://doi.org/10.5281/zenodo.22706039)
 
 ---
 

{dense_evolution-8.1.78 → dense_evolution-8.1.80}/README.md

@@ -249,7 +249,7 @@ If Dense-Evolution is useful in academic work, please cite it via the metadata i
 Archived on [Zenodo](https://zenodo.org/):
 
 - **Concept DOI** (always resolves to the latest version): [10.5281/zenodo.21855643](https://doi.org/10.5281/zenodo.21855643)
-- **This release (v8.1.74)**: [10.5281/zenodo.22669081](https://doi.org/10.5281/zenodo.22669081)
+- **This release (v8.1.78)**: [10.5281/zenodo.22706039](https://doi.org/10.5281/zenodo.22706039)
 
 ---
 

{dense_evolution-8.1.78 → dense_evolution-8.1.80}/dense_evolution/__init__.py

@@ -57,7 +57,7 @@ from .physics.qec import (pauli_commutes, compute_syndrome, erasure_aware_decode
                            blind_minimum_weight_decode, decode_with_erasure_fallback,
                            counts_in_intervals_dimension, nearest_coset_decode)
 
-__version__ = "8.1.78"
+__version__ = "8.1.80"
 
 __all__ = [
     "__version__",

{dense_evolution-8.1.78 → dense_evolution-8.1.80}/dense_evolution/backends/chunk/_engine_imports.py

@@ -10,11 +10,13 @@ import numpy as np
 try:
     from simulator import DenseSVSimulator
     from compiler import QuantumTranspiler  # pragma: no cover
+    from circuits.compiler import _gate_1q_matrix  # pragma: no cover
     from gates import GATE_IDS  # pragma: no cover
 except ModuleNotFoundError:
     try:
         from dense_evolution.simulator import DenseSVSimulator
         from dense_evolution.compiler import QuantumTranspiler
+        from dense_evolution.circuits.compiler import _gate_1q_matrix
         from dense_evolution.gates import GATE_IDS
     except ModuleNotFoundError:  # pragma: no cover
         class DenseSVSimulator:  # type: ignore[no-redef]
@@ -28,10 +30,28 @@ except ModuleNotFoundError:
             def memory_mb(self) -> float:
                 return (self.dim * np.dtype(self.dtype).itemsize) / 1_000_000
 
+            def _unavailable(self, name):
+                raise NotImplementedError(
+                    f"DenseSVSimulator stub: {name}() is not implemented here -- this "
+                    "class only exists because the real dense_evolution/JAX modules "
+                    "were not importable in this deployment (see this module's own "
+                    "comment above); it is not a working simulator."
+                )
+
+            def get_probabilities(self): self._unavailable("get_probabilities")
+            def get_statevector(self): self._unavailable("get_statevector")
+            def apply_gate_1q(self, gate, q1): self._unavailable("apply_gate_1q")
+            def apply_gate_2q(self, gate, q1, q2): self._unavailable("apply_gate_2q")
+
         class QuantumTranspiler:  # type: ignore[no-redef]
             @staticmethod
             def transpile(circuit): return circuit
 
+        def _gate_1q_matrix(g_id, param, dtype):  # type: ignore[no-redef]
+            raise NotImplementedError(
+                "_gate_1q_matrix stub: real dense_evolution/JAX not importable in this deployment"
+            )
+
         GATE_IDS: dict = {}
 
-__all__ = ["DenseSVSimulator", "QuantumTranspiler", "GATE_IDS"]
+__all__ = ["DenseSVSimulator", "QuantumTranspiler", "GATE_IDS", "_gate_1q_matrix"]

{dense_evolution-8.1.78 → dense_evolution-8.1.80}/dense_evolution/backends/chunk/disk_overflow.py

@@ -48,13 +48,17 @@ class LocalPhase:
 
 
 class ConditionalPhase:
-    """A single 2-qubit gate with ctrl chunk-select (q1 < m), tgt local
-    (q2 >= m) -- applied to each chunk independently, conditioned on
-    that chunk's own absolute index (see _case_2q_ctrl_chunk_tgt_local)."""
-    __slots__ = ("op",)
+    """A maximal run of consecutive 2-qubit gates with ctrl chunk-select
+    (q1 < m), tgt local (q2 >= m) -- applied to each chunk independently,
+    each op conditioned on that chunk's own absolute index (see
+    _case_2q_ctrl_chunk_tgt_local). Batched the same way LocalPhase is
+    (was: strictly one gate per phase object, so consecutive
+    ConditionalPhase-eligible gates did one full disk load/save cycle per
+    chunk PER GATE instead of once for the whole run -- prog.txt point 5b)."""
+    __slots__ = ("ops",)
 
-    def __init__(self, op):
-        self.op = op  # single (g_id, q1, q2, param)
+    def __init__(self, ops):
+        self.ops = ops  # list of (g_id, q1, q2, param) python tuples
 
 
 class MixPhase:
@@ -78,30 +82,41 @@ def partition_ops_into_phases(compiled_ops, m: int):
     rows = np.asarray(compiled_ops)
     phases = []
     pending_local = []
+    pending_conditional = []
 
-    def flush():
+    def flush_local():
         if pending_local:
             phases.append(LocalPhase(list(pending_local)))
             pending_local.clear()
 
+    def flush_conditional():
+        if pending_conditional:
+            phases.append(ConditionalPhase(list(pending_conditional)))
+            pending_conditional.clear()
+
     for row in rows:
         g_id, q1, q2, param = int(row[0]), int(row[1]), int(row[2]), float(row[3])
         is_2q = g_id >= 20
         if not is_2q:
             if q1 < m:
-                flush()
+                flush_local()
+                flush_conditional()
                 phases.append(MixPhase((g_id, q1, q2, param), q1))
             else:
+                flush_conditional()
                 pending_local.append((g_id, q1, q2, param))
         elif q1 < m and q2 >= m:
-            flush()
-            phases.append(ConditionalPhase((g_id, q1, q2, param)))
+            flush_local()
+            pending_conditional.append((g_id, q1, q2, param))
         elif q2 < m:
-            flush()
+            flush_local()
+            flush_conditional()
             phases.append(MixPhase((g_id, q1, q2, param), q2))
         else:
+            flush_conditional()
             pending_local.append((g_id, q1, q2, param))
-    flush()
+    flush_local()
+    flush_conditional()
     return phases
 
 
@@ -122,16 +137,17 @@ def _run_local_phase_on_chunk(chunk_arr, ops, m: int, k: int):
     return c[0]
 
 
-def _run_conditional_phase_on_chunk(chunk_arr, op, chunk_index: int, m: int, k: int):
-    """A single ConditionalPhase gate, applied to one chunk whose real
+def _run_conditional_phase_on_chunk(chunk_arr, ops, chunk_index: int, m: int, k: int):
+    """A run of ConditionalPhase gates, applied to one chunk whose real
     absolute index is `chunk_index` (needed for the ctrl-bit decision;
-    see _case_2q_ctrl_chunk_tgt_local's own docstring)."""
-    g_id, q1, q2, param = op
+    see _case_2q_ctrl_chunk_tgt_local's own docstring). Same load-once/
+    apply-all/save-once shape as _run_local_phase_on_chunk."""
     dtype = chunk_arr.dtype
-    _, _, _, _, u00, u01, u10, u11 = _gate_matrix_elements(g_id, param, dtype)
     c = chunk_arr[None, :]
     idxc = jnp.array([chunk_index], dtype=jnp.int32)
-    c = _case_2q_ctrl_chunk_tgt_local(c, u00, u01, u10, u11, q1, q2, m, k, idxc)
+    for g_id, q1, q2, param in ops:
+        _, _, _, _, u00, u01, u10, u11 = _gate_matrix_elements(g_id, param, dtype)
+        c = _case_2q_ctrl_chunk_tgt_local(c, u00, u01, u10, u11, q1, q2, m, k, idxc)
     return c[0]
 
 
@@ -197,7 +213,7 @@ def run_disk_overflow_circuit(chunk_paths, compiled_ops, m: int, k: int):
         elif isinstance(phase, ConditionalPhase):
             for i, path in enumerate(chunk_paths):
                 arr = jnp.asarray(np.load(path))
-                arr = _run_conditional_phase_on_chunk(arr, phase.op, i, m, k)
+                arr = _run_conditional_phase_on_chunk(arr, phase.ops, i, m, k)
                 np.save(path, np.asarray(arr))
 
         elif isinstance(phase, MixPhase):

{dense_evolution-8.1.78 → dense_evolution-8.1.80}/dense_evolution/backends/chunk/guard.py

@@ -74,6 +74,27 @@ class SafeMemoryGuard:
     """
 
     _WARN_MULTIPLIER = 2.0
+    # Below this, check_allocation's own margin-after-allocation math
+    # reduces to "is ambient free RAM currently below threshold_pct?",
+    # independent of required_mb -- for a request this small that's not
+    # protecting against anything, since real machines don't run out of
+    # memory over a request this size regardless of ambient load. Sized
+    # to comfortably cover a dense statevector up to 24 qubits at
+    # complex128 (2**24 * 16 bytes = 268.4 MB) with a real margin -- the
+    # same 24-qubit figure dashboard_core.system_limits already treats as
+    # MPS's own RAM-independent ceiling, and well inside the 16-27 qubit
+    # range dense_evolution.chunk.get_dynamic_chunk considers safe on any
+    # machine (27 qubits / 2 GB is that function's own practical ceiling
+    # for a single dense block). An 8 GB minimum-spec machine can always
+    # absorb an allocation this size without real risk, even while
+    # running low on RAM from unrelated processes. A 2-qubit statevector
+    # (64 bytes) used to be refused on a machine sitting at 8% free RAM
+    # from unrelated processes, which was not a real anti-OOM save, just
+    # a false positive from a threshold designed for actual multi-GB
+    # allocations. Only bypasses when available_mb is itself comfortably
+    # above this floor too (see check_allocation below) -- a machine
+    # truly down to its last few hundred MB still gets the real check.
+    _NEGLIGIBLE_MB = 512.0
 
     def __init__(self, threshold_pct: float = 0.15, gc_before_check: bool = True):
         if not 0.0 < threshold_pct < 1.0:
@@ -134,7 +155,10 @@ class SafeMemoryGuard:
         if self.gc_before_check:
             gc.collect()
 
-        s   = self.status()
+        s = self.status()
+        if required_mb < self._NEGLIGIBLE_MB and s["available_mb"] > self._NEGLIGIBLE_MB:
+            return
+
         tag = f"[{context}] " if context else ""
         available_after_mb = s["available_mb"] - required_mb
         free_frac_after = available_after_mb / self._total_mb if self._total_mb > 0 else 0.0

{dense_evolution-8.1.78 → dense_evolution-8.1.80}/dense_evolution/backends/chunk/kernels.py

@@ -4,7 +4,7 @@ from typing import List
 import jax
 import jax.numpy as jnp
 
-from ._engine_imports import QuantumTranspiler, GATE_IDS
+from ._engine_imports import QuantumTranspiler, GATE_IDS, _gate_1q_matrix
 
 __all__ = [
     "_build_multi_chunk_step", "_build_multi_chunk_runner",
@@ -44,45 +44,17 @@ def _gate_matrix_elements(g_id, param, dtype):
     be traced (the in-RAM scan) or concrete Python/jnp scalars (a single
     known gate in a phase); jax.lax.switch works identically either way.
 
-    Table is a copy of compiler.py's _apply_gate_fast_step / (this
-    module's own step() before this extraction) -- must stay in sync
-    with both, most notably index 14 (GPhase(alpha) = e^{i*alpha} * I)."""
-    inv2         = jnp.asarray(1.0 / jnp.sqrt(2.0), dtype=dtype)
+    The 1-qubit table itself lives in compiler.py's _gate_1q_matrix now
+    (was: an independent hand-copied switch here, with a "must stay in
+    sync" comment -- prog.txt point 2); only the 2-qubit controlled-U
+    table below is local to this module."""
     half_p       = param * jnp.float64(0.5)
-    cos_p        = jnp.cos(half_p).astype(dtype)
-    sin_p        = jnp.sin(half_p).astype(dtype)
     exp_pos      = jnp.exp(1j * param).astype(dtype)
-    exp_ph4      = jnp.exp(1j * jnp.pi / 4.0).astype(dtype)
-    exp_mh4      = jnp.exp(-1j * jnp.pi / 4.0).astype(dtype)
     exp_pos_half = jnp.exp(1j * half_p).astype(dtype)
     exp_neg_half = jnp.exp(-1j * half_p).astype(dtype)
 
     g_id = jnp.asarray(g_id).astype(jnp.int32)
-    safe_gid = jnp.clip(g_id, 0, 14)
-    g_1q = jax.lax.switch(
-        safe_gid,
-        [
-            lambda _: jnp.eye(2, dtype=dtype),
-            lambda _: jnp.array([[inv2, inv2], [inv2, -inv2]], dtype=dtype),
-            lambda _: jnp.array([[0.0 + 0j, 1.0 + 0j], [1.0 + 0j, 0.0 + 0j]], dtype=dtype),
-            lambda _: jnp.array([[0.0 + 0j, -1j], [1j, 0.0 + 0j]], dtype=dtype),
-            lambda _: jnp.array([[1.0 + 0j, 0.0 + 0j], [0.0 + 0j, -1.0 + 0j]], dtype=dtype),
-            lambda _: jnp.array([[1.0 + 0j, 0.0 + 0j], [0.0 + 0j, 1j]], dtype=dtype),
-            lambda _: jnp.array([[1.0 + 0j, 0.0 + 0j], [0.0 + 0j, -1j]], dtype=dtype),
-            lambda _: jnp.array([[1.0 + 0j, 0.0 + 0j], [0.0 + 0j, exp_ph4]], dtype=dtype),
-            lambda _: jnp.array([[1.0 + 0j, 0.0 + 0j], [0.0 + 0j, exp_mh4]], dtype=dtype),
-            lambda _: jnp.array([[cos_p, -1j * sin_p], [-1j * sin_p, cos_p]], dtype=dtype),
-            lambda _: jnp.array([[cos_p, -sin_p], [sin_p, cos_p]], dtype=dtype),
-            lambda _: jnp.array([[jnp.exp(-1j * half_p), 0.0 + 0j], [0.0 + 0j, jnp.exp(1j * half_p)]], dtype=dtype),
-            lambda _: jnp.array([[1.0 + 0j, 0.0 + 0j], [0.0 + 0j, exp_pos]], dtype=dtype),
-            lambda _: jnp.array([[0.5 + 0.5j, 0.5 - 0.5j], [0.5 - 0.5j, 0.5 + 0.5j]], dtype=dtype),
-            # 14  GPhase(alpha) = e^{i*alpha} * I -- see compiler.py's
-            # _apply_gate_fast_step index 14 for the derivation; this
-            # table must stay in sync with that one (see comment above).
-            lambda _: jnp.array([[exp_pos, 0.0 + 0j], [0.0 + 0j, exp_pos]], dtype=dtype),
-        ],
-        operand=None,
-    )
+    g_1q = _gate_1q_matrix(g_id, param, dtype)
 
     # Controlled-U submatrix for the 5 two-qubit gate types (mat[2:,2:]
     # of each gate's full 4x4 form — same values _apply_gate_multi's
@@ -319,59 +291,10 @@ def _build_distributed_chunk_step(num_chunks: int, m: int, k: int, axis_name: st
 
         my_id = jax.lax.axis_index(axis_name).astype(jnp.int32)
 
-        inv2         = jnp.asarray(1.0 / jnp.sqrt(2.0), dtype=dtype)
-        half_p       = param * jnp.float64(0.5)
-        cos_p        = jnp.cos(half_p).astype(dtype)
-        sin_p        = jnp.sin(half_p).astype(dtype)
-        exp_pos      = jnp.exp(1j * param).astype(dtype)
-        exp_ph4      = jnp.exp(1j * jnp.pi / 4.0).astype(dtype)
-        exp_mh4      = jnp.exp(-1j * jnp.pi / 4.0).astype(dtype)
-        exp_pos_half = jnp.exp(1j * half_p).astype(dtype)
-        exp_neg_half = jnp.exp(-1j * half_p).astype(dtype)
-
-        safe_gid = jnp.clip(g_id, 0, 14)
-        g_1q = jax.lax.switch(
-            safe_gid,
-            [
-                lambda _: jnp.eye(2, dtype=dtype),
-                lambda _: jnp.array([[inv2, inv2], [inv2, -inv2]], dtype=dtype),
-                lambda _: jnp.array([[0.0 + 0j, 1.0 + 0j], [1.0 + 0j, 0.0 + 0j]], dtype=dtype),
-                lambda _: jnp.array([[0.0 + 0j, -1j], [1j, 0.0 + 0j]], dtype=dtype),
-                lambda _: jnp.array([[1.0 + 0j, 0.0 + 0j], [0.0 + 0j, -1.0 + 0j]], dtype=dtype),
-                lambda _: jnp.array([[1.0 + 0j, 0.0 + 0j], [0.0 + 0j, 1j]], dtype=dtype),
-                lambda _: jnp.array([[1.0 + 0j, 0.0 + 0j], [0.0 + 0j, -1j]], dtype=dtype),
-                lambda _: jnp.array([[1.0 + 0j, 0.0 + 0j], [0.0 + 0j, exp_ph4]], dtype=dtype),
-                lambda _: jnp.array([[1.0 + 0j, 0.0 + 0j], [0.0 + 0j, exp_mh4]], dtype=dtype),
-                lambda _: jnp.array([[cos_p, -1j * sin_p], [-1j * sin_p, cos_p]], dtype=dtype),
-                lambda _: jnp.array([[cos_p, -sin_p], [sin_p, cos_p]], dtype=dtype),
-                lambda _: jnp.array([[jnp.exp(-1j * half_p), 0.0 + 0j], [0.0 + 0j, jnp.exp(1j * half_p)]], dtype=dtype),
-                lambda _: jnp.array([[1.0 + 0j, 0.0 + 0j], [0.0 + 0j, exp_pos]], dtype=dtype),
-                lambda _: jnp.array([[0.5 + 0.5j, 0.5 - 0.5j], [0.5 - 0.5j, 0.5 + 0.5j]], dtype=dtype),
-                # 14  GPhase(alpha) = e^{i*alpha} * I -- must stay in sync
-                # with _apply_gate_fast_step (compiler.py) and the
-                # non-distributed copy of this table above.
-                lambda _: jnp.array([[exp_pos, 0.0 + 0j], [0.0 + 0j, exp_pos]], dtype=dtype),
-            ],
-            operand=None,
-        )
-
-        two_q_idx = jnp.where(g_id == 20, 0,
-                    jnp.where(g_id == 21, 1,
-                    jnp.where(g_id == 22, 2,
-                    jnp.where(g_id == 24, 3, 4))))
-        U = jax.lax.switch(
-            two_q_idx,
-            [
-                lambda _: jnp.array([[0.0 + 0j, 1.0 + 0j], [1.0 + 0j, 0.0 + 0j]], dtype=dtype),
-                lambda _: jnp.array([[1.0 + 0j, 0.0 + 0j], [0.0 + 0j, -1.0 + 0j]], dtype=dtype),
-                lambda _: jnp.array([[1.0 + 0j, 0.0 + 0j], [0.0 + 0j, exp_pos]], dtype=dtype),
-                lambda _: jnp.array([[0.0 + 0j, -1j], [1j, 0.0 + 0j]], dtype=dtype),
-                lambda _: jnp.array([[exp_neg_half, 0.0 + 0j], [0.0 + 0j, exp_pos_half]], dtype=dtype),
-            ],
-            operand=None,
-        )
-        g00, g01, g10, g11 = g_1q[0, 0], g_1q[0, 1], g_1q[1, 0], g_1q[1, 1]
-        u00, u01, u10, u11 = U[0, 0], U[0, 1], U[1, 0], U[1, 1]
+        # Same table _build_multi_chunk_step uses (was: an independent
+        # hand-copied switch here -- prog.txt point 2, "must stay in
+        # sync" comment on both sides).
+        g00, g01, g10, g11, u00, u01, u10, u11 = _gate_matrix_elements(g_id, param, dtype)
 
         is_2q    = g_id >= 20
         q1_chunk = q1 < m

{dense_evolution-8.1.78 → dense_evolution-8.1.80}/dense_evolution/backends/mps.py

@@ -51,6 +51,7 @@ complementary.
 """
 
 import dataclasses
+import heapq
 import warnings
 from functools import partial
 from typing import List, Optional, Tuple
@@ -1161,7 +1162,7 @@ class MPSSimulator:
     # candidate as a whole regardless of backend.
     def _sample_bitstring(self, rng: np.random.Generator) -> List[int]:
         bits = []
-        state = jnp.ones(1, dtype=complex)
+        state = jnp.ones(1, dtype=self.gammas[0].dtype)
         for i in range(self.n):
             g = self.gammas[i]
             lam = self.lambdas[i + 1] if i < self.n - 1 else jnp.ones(g.shape[2])
@@ -1214,8 +1215,15 @@ class MPSSimulator:
                     new_vec = jnp.einsum("l,lr->r", vec_p, gamma[:, bit, :]) * lam
                     weight = float(jnp.sum(jnp.abs(new_vec) ** 2))
                     candidates.append(((idx_p << 1) | bit, new_vec, weight))
-            candidates.sort(key=lambda c: c[2], reverse=True)
-            paths = [(idx, vec) for idx, vec, _ in candidates[:k]]
+            # heapq.nlargest instead of a full sort-then-slice (prog.txt
+            # point 5e): only the top k by weight are ever used below, and
+            # this avoids materializing/sorting the full candidates list
+            # when len(candidates) >> k. Final probability order is
+            # re-derived from scratch at the end of this function anyway
+            # (`order = np.argsort(-probabilities)`), so which of two
+            # equal-weight candidates heapq happens to prefer over sort's
+            # stable order has no effect on the result.
+            paths = [(idx, vec) for idx, vec, _ in heapq.nlargest(k, candidates, key=lambda c: c[2])]
 
         indices = np.array([p[0] for p in paths])
         amplitudes = np.array([