dense-evolution 8.1.7__tar.gz → 8.1.9__tar.gz

{dense_evolution-8.1.7 → dense_evolution-8.1.9}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: dense-evolution
-Version: 8.1.7
+Version: 8.1.9
 Summary: Micro-optimized High-Performance NISQ Statevector Quantum Circuit Simulator (Hardware-Adaptive Integration of Native NumPy, CUDA-Accelerated CuPy, and Linear Kernel Fusion via JAX JIT/XLA Compilation)
 Author-email: Salvatore Pennacchio <jtatopenn@libero.it>
 License: Business Source License 1.1
@@ -63,10 +63,16 @@ Dynamic: license-file
 
 [![CI](https://github.com/tatopenn-cell/Dense-Evolution/actions/workflows/ci.yml/badge.svg)](https://github.com/tatopenn-cell/Dense-Evolution/actions/workflows/ci.yml)
 [![PyPI](https://img.shields.io/pypi/v/dense-evolution?style=flat-square&color=00e5ff)](https://pypi.org/project/dense-evolution/)
+[![PyPI Downloads](https://img.shields.io/pypi/dm/dense-evolution?style=flat-square&color=00e5ff)](https://pypi.org/project/dense-evolution/)
 [![Python](https://img.shields.io/badge/Python-3.9+-blue?style=flat-square&logo=python&logoColor=white)](https://www.python.org/)
 [![License](https://img.shields.io/badge/License-BSL_1.1-orange?style=flat-square)](LICENSE.md)
 [![Build](https://img.shields.io/badge/Build-Passing-00ff9d?style=flat-square)](https://github.com/tatopenn-cell/Dense-Evolution/actions)
 [![Cross-Validation CI](https://github.com/tatopenn-cell/Dense-Evolution-Ising-Tests/actions/workflows/ci.yml/badge.svg)](https://github.com/tatopenn-cell/Dense-Evolution-Ising-Tests/actions/workflows/ci.yml)
+[![Latest Release](https://img.shields.io/github/v/release/tatopenn-cell/Dense-Evolution?style=flat-square&color=blueviolet)](https://github.com/tatopenn-cell/Dense-Evolution/releases)
+[![Last Commit](https://img.shields.io/github/last-commit/tatopenn-cell/Dense-Evolution?style=flat-square)](https://github.com/tatopenn-cell/Dense-Evolution/commits/main)
+[![Issues](https://img.shields.io/github/issues/tatopenn-cell/Dense-Evolution?style=flat-square)](https://github.com/tatopenn-cell/Dense-Evolution/issues)
+[![Stars](https://img.shields.io/github/stars/tatopenn-cell/Dense-Evolution?style=flat-square&color=yellow)](https://github.com/tatopenn-cell/Dense-Evolution/stargazers)
+[![JAX](https://img.shields.io/badge/Backend-JAX_XLA-f9ab00?style=flat-square&logo=google&logoColor=white)](https://github.com/google/jax)
 
 ---
 
@@ -160,6 +166,9 @@ dense_evolution/
 ├── chunk.py        SafeMemoryGuard · MemoryChunker · CircuitChunker · Chunk (Anti-OOM)
 ├── simulator.py    DenseSVSimulator · run_parametric_batch_jit · vmap batch VQE
 └── dash.py         ipywidgets dashboard · VQE engine · QM/MM · MD simulation · 3D wavefunction
+
+ia_utils/
+└── vector_healing.py   median_healing · enhanced_dense_healing_hybrid (NaN/Inf-safe, lazy JAX import)
 ```
 
 **Data flow per run:**
@@ -185,6 +194,7 @@ dense_evolution/
 | **VQE + ADAM** | Hellmann-Feynman gradient · positional parameter injection into any OpenQASM 2.0 circuit |
 | **Anti-OOM Engine** | `SafeMemoryGuard` blocks execution before JAX raises `RESOURCE_EXHAUSTED` |
 | **Predictive Healing** | `healing.py` — Φ_AB alignment, dynamic vector, Σ-sync, `MemoryReflectionEngine` |
+| **Vector Sequence Healing** | `ia_utils/` — `median_healing`, `enhanced_dense_healing_hybrid` — NaN/Inf-safe, lazy JAX import |
 | **Backend Agnostic** | NumPy CPU · JAX XLA CPU/TPU · CuPy CUDA — runtime selection, zero code changes |
 | **Live Dashboard** | 8-panel ipywidgets telemetry: probability, VQE energy, entropy, purity, gradient, noise, θ-correction, Pearson heatmap |
 
@@ -240,6 +250,7 @@ sim = DenseSVSimulator(
 | Method | Description |
 |---|---|
 | `set_initial_state(state=None)` | Reset to `\|0⟩ⁿ` or inject custom statevector |
+| `run_circuit(circuit, transpile=True)` | Plain (non-JIT) gate execution — takes the tuple format below |
 | `run_circuit_jit_beast_mode(circuit)` | JIT-compiled gate execution — primary execution path |
 | `run_circuit_with_chunking(circuit, chunk_size=500)` | Chunked execution for long circuits |
 | `run_parametric_batch_jit(base_circuit, parameter_batch)` | `vmap` over parameter grid — returns full batch of statevectors |
@@ -258,16 +269,34 @@ circuit = parser.parse(qasm_str)   # → QASMCircuit
 valid, msg = parser.validate(circuit)
 ```
 
-`QASMCircuit` fields: `n_qubits`, `n_cbits`, `ops` (list of gate tuples).
+`QASMCircuit` fields: `n_qubits`, `n_cbits`, `ops` (list of gate dicts, e.g.
+`{'name': 'h', 'qubits': [0], 'params': []}`). Use `circuit.to_tuples()` to
+convert `ops` to the `(name, qubit0[, qubit1, ...][, param0, ...])` tuple
+format that `run_circuit` / `run_circuit_jit_beast_mode` expect — don't
+build that format by hand.
 
 ### `NoiseModel`
 
 ```python
 noise = NoiseModel()
-noise.apply(sv, model='depolarizing', p=0.01, n_qubits=4, rng=rng)
+noise.apply_to_sv(sv, n=4, model='depolarizing', p=0.01, rng=rng)
 desc  = NoiseModel.kraus_description('amplitude_damping')
 ```
 
+### End-to-end: parse → run → apply noise
+
+```python
+parser  = QASMParser()
+circuit = parser.parse(qasm_str)                  # → QASMCircuit
+sim     = DenseSVSimulator(n_qubits=circuit.n_qubits)
+sim.run_circuit(circuit.to_tuples())               # dicts -> tuples, then execute
+
+sv_noisy = NoiseModel().apply_to_sv(
+    sim.get_statevector(), n=circuit.n_qubits, model='depolarizing', p=0.01,
+    rng=np.random.default_rng(42),
+)
+```
+
 ### `Chunk` (Anti-OOM)
 
 ```python
@@ -283,6 +312,17 @@ sim.run_chunk(circuit, chunk_size_gates=500)
 
 Backward-compatibility aliases: `chunk1 = MemoryChunker`, `chunk2 = Chunk`, `Chunk2Incrociato = Chunk`.
 
+### `ia_utils.vector_healing`
+
+```python
+from ia_utils.vector_healing import median_healing, enhanced_dense_healing_hybrid
+
+healed, radius   = median_healing(vettori, radius_baseline=None)
+healed, metadata = enhanced_dense_healing_hybrid(vettori, radius_baseline=None, median_fallback_threshold=0.1)
+```
+
+See **IA Utils — Vector Sequence Healing** above for details.
+
 ---
 
 ## ▍ Gate Library
@@ -350,6 +390,42 @@ All core functions compiled via `@jax.jit`. Event history managed by `MemoryRefl
 
 ---
 
+## ▍ IA Utils — Vector Sequence Healing
+
+`ia_utils/vector_healing.py` — standalone module for cleaning sequences of vectors (e.g. hidden states / embeddings) that may contain `NaN` or `Inf` entries. Both functions preprocess the input (Inf → NaN → column-mean imputation) before healing, so corrupted values never propagate into the output.
+
+| Function | Approach | Returns |
+|---|---|---|
+| `median_healing(vettori, radius_baseline=None)` | `scipy.ndimage.median_filter`, dynamic radius `min(20, max(3, n // 3))` | `(healed: np.ndarray, radius: int)` |
+| `enhanced_dense_healing_hybrid(vettori, radius_baseline=None, median_fallback_threshold=0.1)` | Blends the `dense_evolution.healing` Φ-trigger logic with a median fallback, decided per-step | `(healed: np.ndarray, metadata: dict)` |
+
+`enhanced_dense_healing_hybrid` metadata:
+
+| Key | Type | Description |
+|---|---|---|
+| `fallback_triggered` | `bool` | `True` if the median fallback or dense blending fired at least once |
+| `adaptive_radius_used` | `int` | Baseline radius actually applied |
+| `reconstruction_error` | `float` | Mean norm of the correction applied vs. the sanitized input |
+
+```python
+import numpy as np
+from ia_utils.vector_healing import median_healing, enhanced_dense_healing_hybrid
+
+vettori = np.random.default_rng(0).normal(size=(50, 128))
+vettori[10, 3] = np.nan          # simulate a corrupted hidden state
+vettori[30, 7] = np.inf
+
+healed, radius = median_healing(vettori)
+
+healed_hybrid, meta = enhanced_dense_healing_hybrid(vettori)
+print(meta)
+# {'fallback_triggered': True, 'adaptive_radius_used': 16, 'reconstruction_error': 11.48}
+```
+
+`jax` is imported lazily inside `enhanced_dense_healing_hybrid` — `median_healing` and the module import itself work without the `[jax]` extra installed; only calling `enhanced_dense_healing_hybrid` requires it.
+
+---
+
 ## ▍ Anti-OOM Chunk Engine
 
 All operations parcellized dynamically using a 4-layer architectural shield.
@@ -468,6 +544,17 @@ All circuits stored as OpenQASM 2.0 strings in `QASM_LIBRARY`.
 
 ## ▍ Changelog
 
+### v8.1.9
+- **Fixed**: `ia_utils/vector_healing.py` — `enhanced_dense_healing_hybrid` had an unreachable third branch (a dense/blend fallback): the underlying `trigger` signal from `evaluate_phi_trigger` is strictly binary (0.0/1.0), so the branch could never execute. Collapsed to the genuine 2-state logic (pass-through vs. median fallback); runtime output is unchanged since the branch never ran.
+- **Fixed**: `dashboard_core.py` — `run_simulation` / `run_vqe_telemetry` mutated the process-wide JAX `jax_enable_x64` flag without ever restoring it, so running one float32 simulation silently downgraded numerical precision for unrelated code later in the same process (e.g. the Vector Healing page, which sets no precision of its own). Both now save/restore the flag around their own execution.
+- **Docs**: README's `NoiseModel` example called a nonexistent `.apply()` method with a wrong parameter name (`n_qubits` instead of `n`) — corrected to `apply_to_sv(sv, n=..., ...)`. Documented `QASMCircuit.to_tuples()` and `DenseSVSimulator.run_circuit`, which already existed and work correctly but were never mentioned in the README.
+
+### v8.1.8
+- **Fixed**: `parser.py` — controlled two-qubit gates (`cx`/`cy`/`cz`/`cp`/`crz`) parsed from QASM in the dashboard layer had control and target swapped relative to `compiler.py`'s documented `(gate, control, target)` contract, breaking entanglement for circuits run through the dashboard. The core `QASMCircuit.to_tuples()` path was already correct.
+- **Fixed**: `parser.py` — range syntax (`q[0:3]`) on single-qubit gates only applied to the first qubit in the range, silently dropping the rest. Now expands into one gate application per qubit, matching the parser's own documented contract.
+- **Fixed**: `from dense_evolution import Chunk` raised `ImportError` — `Chunk` is now re-exported from the package root. Added `get_probabilities()`/`get_statevector()` to `Chunk` for parity with `DenseSVSimulator`.
+- **Removed**: `dense_evolution/test2.py` and `stress_test.py` — byte-identical, assertion-free debug scripts that shipped inside every install with 0% test coverage. Their one real check (Kraus noise is genuinely stochastic across independent runs) is now a real regression test.
+
 ### v8.1.7
 - `ia_utils/` — new package: `median_healing`, `enhanced_dense_healing_hybrid` for vector sequence healing (NaN/Inf-safe)
 - `jax` import in `ia_utils.vector_healing` made lazy — importable without the `[jax]` extra

{dense_evolution-8.1.7 → dense_evolution-8.1.9}/README.md

@@ -18,10 +18,16 @@
 
 [![CI](https://github.com/tatopenn-cell/Dense-Evolution/actions/workflows/ci.yml/badge.svg)](https://github.com/tatopenn-cell/Dense-Evolution/actions/workflows/ci.yml)
 [![PyPI](https://img.shields.io/pypi/v/dense-evolution?style=flat-square&color=00e5ff)](https://pypi.org/project/dense-evolution/)
+[![PyPI Downloads](https://img.shields.io/pypi/dm/dense-evolution?style=flat-square&color=00e5ff)](https://pypi.org/project/dense-evolution/)
 [![Python](https://img.shields.io/badge/Python-3.9+-blue?style=flat-square&logo=python&logoColor=white)](https://www.python.org/)
 [![License](https://img.shields.io/badge/License-BSL_1.1-orange?style=flat-square)](LICENSE.md)
 [![Build](https://img.shields.io/badge/Build-Passing-00ff9d?style=flat-square)](https://github.com/tatopenn-cell/Dense-Evolution/actions)
 [![Cross-Validation CI](https://github.com/tatopenn-cell/Dense-Evolution-Ising-Tests/actions/workflows/ci.yml/badge.svg)](https://github.com/tatopenn-cell/Dense-Evolution-Ising-Tests/actions/workflows/ci.yml)
+[![Latest Release](https://img.shields.io/github/v/release/tatopenn-cell/Dense-Evolution?style=flat-square&color=blueviolet)](https://github.com/tatopenn-cell/Dense-Evolution/releases)
+[![Last Commit](https://img.shields.io/github/last-commit/tatopenn-cell/Dense-Evolution?style=flat-square)](https://github.com/tatopenn-cell/Dense-Evolution/commits/main)
+[![Issues](https://img.shields.io/github/issues/tatopenn-cell/Dense-Evolution?style=flat-square)](https://github.com/tatopenn-cell/Dense-Evolution/issues)
+[![Stars](https://img.shields.io/github/stars/tatopenn-cell/Dense-Evolution?style=flat-square&color=yellow)](https://github.com/tatopenn-cell/Dense-Evolution/stargazers)
+[![JAX](https://img.shields.io/badge/Backend-JAX_XLA-f9ab00?style=flat-square&logo=google&logoColor=white)](https://github.com/google/jax)
 
 ---
 
@@ -115,6 +121,9 @@ dense_evolution/
 ├── chunk.py        SafeMemoryGuard · MemoryChunker · CircuitChunker · Chunk (Anti-OOM)
 ├── simulator.py    DenseSVSimulator · run_parametric_batch_jit · vmap batch VQE
 └── dash.py         ipywidgets dashboard · VQE engine · QM/MM · MD simulation · 3D wavefunction
+
+ia_utils/
+└── vector_healing.py   median_healing · enhanced_dense_healing_hybrid (NaN/Inf-safe, lazy JAX import)
 ```
 
 **Data flow per run:**
@@ -140,6 +149,7 @@ dense_evolution/
 | **VQE + ADAM** | Hellmann-Feynman gradient · positional parameter injection into any OpenQASM 2.0 circuit |
 | **Anti-OOM Engine** | `SafeMemoryGuard` blocks execution before JAX raises `RESOURCE_EXHAUSTED` |
 | **Predictive Healing** | `healing.py` — Φ_AB alignment, dynamic vector, Σ-sync, `MemoryReflectionEngine` |
+| **Vector Sequence Healing** | `ia_utils/` — `median_healing`, `enhanced_dense_healing_hybrid` — NaN/Inf-safe, lazy JAX import |
 | **Backend Agnostic** | NumPy CPU · JAX XLA CPU/TPU · CuPy CUDA — runtime selection, zero code changes |
 | **Live Dashboard** | 8-panel ipywidgets telemetry: probability, VQE energy, entropy, purity, gradient, noise, θ-correction, Pearson heatmap |
 
@@ -195,6 +205,7 @@ sim = DenseSVSimulator(
 | Method | Description |
 |---|---|
 | `set_initial_state(state=None)` | Reset to `\|0⟩ⁿ` or inject custom statevector |
+| `run_circuit(circuit, transpile=True)` | Plain (non-JIT) gate execution — takes the tuple format below |
 | `run_circuit_jit_beast_mode(circuit)` | JIT-compiled gate execution — primary execution path |
 | `run_circuit_with_chunking(circuit, chunk_size=500)` | Chunked execution for long circuits |
 | `run_parametric_batch_jit(base_circuit, parameter_batch)` | `vmap` over parameter grid — returns full batch of statevectors |
@@ -213,16 +224,34 @@ circuit = parser.parse(qasm_str)   # → QASMCircuit
 valid, msg = parser.validate(circuit)
 ```
 
-`QASMCircuit` fields: `n_qubits`, `n_cbits`, `ops` (list of gate tuples).
+`QASMCircuit` fields: `n_qubits`, `n_cbits`, `ops` (list of gate dicts, e.g.
+`{'name': 'h', 'qubits': [0], 'params': []}`). Use `circuit.to_tuples()` to
+convert `ops` to the `(name, qubit0[, qubit1, ...][, param0, ...])` tuple
+format that `run_circuit` / `run_circuit_jit_beast_mode` expect — don't
+build that format by hand.
 
 ### `NoiseModel`
 
 ```python
 noise = NoiseModel()
-noise.apply(sv, model='depolarizing', p=0.01, n_qubits=4, rng=rng)
+noise.apply_to_sv(sv, n=4, model='depolarizing', p=0.01, rng=rng)
 desc  = NoiseModel.kraus_description('amplitude_damping')
 ```
 
+### End-to-end: parse → run → apply noise
+
+```python
+parser  = QASMParser()
+circuit = parser.parse(qasm_str)                  # → QASMCircuit
+sim     = DenseSVSimulator(n_qubits=circuit.n_qubits)
+sim.run_circuit(circuit.to_tuples())               # dicts -> tuples, then execute
+
+sv_noisy = NoiseModel().apply_to_sv(
+    sim.get_statevector(), n=circuit.n_qubits, model='depolarizing', p=0.01,
+    rng=np.random.default_rng(42),
+)
+```
+
 ### `Chunk` (Anti-OOM)
 
 ```python
@@ -238,6 +267,17 @@ sim.run_chunk(circuit, chunk_size_gates=500)
 
 Backward-compatibility aliases: `chunk1 = MemoryChunker`, `chunk2 = Chunk`, `Chunk2Incrociato = Chunk`.
 
+### `ia_utils.vector_healing`
+
+```python
+from ia_utils.vector_healing import median_healing, enhanced_dense_healing_hybrid
+
+healed, radius   = median_healing(vettori, radius_baseline=None)
+healed, metadata = enhanced_dense_healing_hybrid(vettori, radius_baseline=None, median_fallback_threshold=0.1)
+```
+
+See **IA Utils — Vector Sequence Healing** above for details.
+
 ---
 
 ## ▍ Gate Library
@@ -305,6 +345,42 @@ All core functions compiled via `@jax.jit`. Event history managed by `MemoryRefl
 
 ---
 
+## ▍ IA Utils — Vector Sequence Healing
+
+`ia_utils/vector_healing.py` — standalone module for cleaning sequences of vectors (e.g. hidden states / embeddings) that may contain `NaN` or `Inf` entries. Both functions preprocess the input (Inf → NaN → column-mean imputation) before healing, so corrupted values never propagate into the output.
+
+| Function | Approach | Returns |
+|---|---|---|
+| `median_healing(vettori, radius_baseline=None)` | `scipy.ndimage.median_filter`, dynamic radius `min(20, max(3, n // 3))` | `(healed: np.ndarray, radius: int)` |
+| `enhanced_dense_healing_hybrid(vettori, radius_baseline=None, median_fallback_threshold=0.1)` | Blends the `dense_evolution.healing` Φ-trigger logic with a median fallback, decided per-step | `(healed: np.ndarray, metadata: dict)` |
+
+`enhanced_dense_healing_hybrid` metadata:
+
+| Key | Type | Description |
+|---|---|---|
+| `fallback_triggered` | `bool` | `True` if the median fallback or dense blending fired at least once |
+| `adaptive_radius_used` | `int` | Baseline radius actually applied |
+| `reconstruction_error` | `float` | Mean norm of the correction applied vs. the sanitized input |
+
+```python
+import numpy as np
+from ia_utils.vector_healing import median_healing, enhanced_dense_healing_hybrid
+
+vettori = np.random.default_rng(0).normal(size=(50, 128))
+vettori[10, 3] = np.nan          # simulate a corrupted hidden state
+vettori[30, 7] = np.inf
+
+healed, radius = median_healing(vettori)
+
+healed_hybrid, meta = enhanced_dense_healing_hybrid(vettori)
+print(meta)
+# {'fallback_triggered': True, 'adaptive_radius_used': 16, 'reconstruction_error': 11.48}
+```
+
+`jax` is imported lazily inside `enhanced_dense_healing_hybrid` — `median_healing` and the module import itself work without the `[jax]` extra installed; only calling `enhanced_dense_healing_hybrid` requires it.
+
+---
+
 ## ▍ Anti-OOM Chunk Engine
 
 All operations parcellized dynamically using a 4-layer architectural shield.
@@ -423,6 +499,17 @@ All circuits stored as OpenQASM 2.0 strings in `QASM_LIBRARY`.
 
 ## ▍ Changelog
 
+### v8.1.9
+- **Fixed**: `ia_utils/vector_healing.py` — `enhanced_dense_healing_hybrid` had an unreachable third branch (a dense/blend fallback): the underlying `trigger` signal from `evaluate_phi_trigger` is strictly binary (0.0/1.0), so the branch could never execute. Collapsed to the genuine 2-state logic (pass-through vs. median fallback); runtime output is unchanged since the branch never ran.
+- **Fixed**: `dashboard_core.py` — `run_simulation` / `run_vqe_telemetry` mutated the process-wide JAX `jax_enable_x64` flag without ever restoring it, so running one float32 simulation silently downgraded numerical precision for unrelated code later in the same process (e.g. the Vector Healing page, which sets no precision of its own). Both now save/restore the flag around their own execution.
+- **Docs**: README's `NoiseModel` example called a nonexistent `.apply()` method with a wrong parameter name (`n_qubits` instead of `n`) — corrected to `apply_to_sv(sv, n=..., ...)`. Documented `QASMCircuit.to_tuples()` and `DenseSVSimulator.run_circuit`, which already existed and work correctly but were never mentioned in the README.
+
+### v8.1.8
+- **Fixed**: `parser.py` — controlled two-qubit gates (`cx`/`cy`/`cz`/`cp`/`crz`) parsed from QASM in the dashboard layer had control and target swapped relative to `compiler.py`'s documented `(gate, control, target)` contract, breaking entanglement for circuits run through the dashboard. The core `QASMCircuit.to_tuples()` path was already correct.
+- **Fixed**: `parser.py` — range syntax (`q[0:3]`) on single-qubit gates only applied to the first qubit in the range, silently dropping the rest. Now expands into one gate application per qubit, matching the parser's own documented contract.
+- **Fixed**: `from dense_evolution import Chunk` raised `ImportError` — `Chunk` is now re-exported from the package root. Added `get_probabilities()`/`get_statevector()` to `Chunk` for parity with `DenseSVSimulator`.
+- **Removed**: `dense_evolution/test2.py` and `stress_test.py` — byte-identical, assertion-free debug scripts that shipped inside every install with 0% test coverage. Their one real check (Kraus noise is genuinely stochastic across independent runs) is now a real regression test.
+
 ### v8.1.7
 - `ia_utils/` — new package: `median_healing`, `enhanced_dense_healing_hybrid` for vector sequence healing (NaN/Inf-safe)
 - `jax` import in `ia_utils.vector_healing` made lazy — importable without the `[jax]` extra

{dense_evolution-8.1.7 → dense_evolution-8.1.9}/dense_evolution/__init__.py

@@ -7,5 +7,6 @@ from .parser import QASMParser, QASMCircuit
 from .compiler import QuantumTranspiler
 from .registry import NoiseModel, QuantumHardwareRegistry
 from .gates import GATES, PARAMETRIC_GATES, GATE_IDS
+from .chunk import Chunk
 
-__version__ = "8.1.7"
+__version__ = "8.1.9"

{dense_evolution-8.1.7 → dense_evolution-8.1.9}/dense_evolution/chunk.py

@@ -334,6 +334,16 @@ class Chunk:
         """RAM used by the physical statevector in MB."""
         return self._inner_sim.memory_mb()
 
+    def get_probabilities(self):
+        """|amplitude|^2 for every basis state — forwards to the inner
+        DenseSVSimulator for parity with its own get_probabilities()."""
+        return self._inner_sim.get_probabilities()
+
+    def get_statevector(self):
+        """Full complex statevector — forwards to the inner DenseSVSimulator
+        for parity with its own get_statevector()."""
+        return self._inner_sim.get_statevector()
+
     # ── Public API ───────────────────────────────────────────────────────────
 
     def run_chunk(

{dense_evolution-8.1.7 → dense_evolution-8.1.9}/dense_evolution/healing.py

@@ -1,7 +1,7 @@
 import jax
 import jax.numpy as jnp
 import json
-from datetime import datetime
+from datetime import datetime, timezone
 from typing import Dict, Tuple, List, Any
 
 
@@ -104,7 +104,7 @@ class MemoryReflectionEngine:
 
     def record_event(self, event_type: str, value: float, description: str = ""):
         event = {
-            "timestamp": datetime.utcnow().isoformat(),
+            "timestamp": datetime.now(timezone.utc).isoformat(),
             "type": event_type,
             "value": float(value),
             "description": description

{dense_evolution-8.1.7 → dense_evolution-8.1.9}/dense_evolution/parser.py

@@ -93,6 +93,18 @@ class QASMParser:
         'ccx':     'ccx',
     }
 
+    # ── gate names that only ever take one qubit ─────────────────────
+    # Used to expand range syntax (q[0:3]) into one op per qubit instead
+    # of a single op with multiple qubits attached — see BUG FIX 3 note
+    # on parse(): the original fix resolved q[0:3] to the qubit list
+    # [0,1,2], but nothing expanded that list into separate applications
+    # for gates that are only ever single-qubit, so e.g. `h q[0:3]` ended
+    # up applying H to qubit 0 only, silently dropping qubits 1 and 2.
+    _SINGLE_QUBIT_GATES = frozenset((
+        'h', 'x', 'y', 'z', 's', 'sdg', 't', 'tdg', 'sx', 'id',
+        'rx', 'ry', 'rz', 'p', 'u1', 'u2', 'u3',
+    ))
+
     # ── statements to skip entirely ──────────────────────────────────
     # BUG FIX (original): 'gate ' had a trailing space making it miss
     # 'gate foo(...)' where the token is 'gate' followed by space.
@@ -211,11 +223,21 @@ class QASMParser:
             # ── gate application ─────────────────────────────────────
             op = self._parse_gate(instr, qubit_map)
             if op is not None:
-                ops.append(op)
-                # update n_qubits from seen qubit indices
-                # (handles circuits without explicit qreg declarations)
-                if op['qubits']:
-                    n_qubits = max(n_qubits, max(op['qubits']) + 1)
+                if op['name'] in self._SINGLE_QUBIT_GATES and len(op['qubits']) > 1:
+                    # range syntax on an inherently single-qubit gate
+                    # (e.g. `h q[0:3]`) — expand into one op per qubit.
+                    for q in op['qubits']:
+                        ops.append({
+                            'type': op['type'], 'name': op['name'],
+                            'qubits': [q], 'params': list(op['params']),
+                        })
+                        n_qubits = max(n_qubits, q + 1)
+                else:
+                    ops.append(op)
+                    # update n_qubits from seen qubit indices
+                    # (handles circuits without explicit qreg declarations)
+                    if op['qubits']:
+                        n_qubits = max(n_qubits, max(op['qubits']) + 1)
 
         return QASMCircuit(n_qubits, n_cbits, ops)
 
@@ -360,7 +382,7 @@ class QASMParser:
     def _resolve_qubits(self,
                          s:    str,
                          qmap: Dict[str, int]) -> List[int]:
-        """
+        r"""
         Resolve a comma-separated qubit argument string to absolute indices.
 
         Handles

{dense_evolution-8.1.7 → dense_evolution-8.1.9}/dense_evolution.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: dense-evolution
-Version: 8.1.7
+Version: 8.1.9
 Summary: Micro-optimized High-Performance NISQ Statevector Quantum Circuit Simulator (Hardware-Adaptive Integration of Native NumPy, CUDA-Accelerated CuPy, and Linear Kernel Fusion via JAX JIT/XLA Compilation)
 Author-email: Salvatore Pennacchio <jtatopenn@libero.it>
 License: Business Source License 1.1
@@ -63,10 +63,16 @@ Dynamic: license-file
 
 [![CI](https://github.com/tatopenn-cell/Dense-Evolution/actions/workflows/ci.yml/badge.svg)](https://github.com/tatopenn-cell/Dense-Evolution/actions/workflows/ci.yml)
 [![PyPI](https://img.shields.io/pypi/v/dense-evolution?style=flat-square&color=00e5ff)](https://pypi.org/project/dense-evolution/)
+[![PyPI Downloads](https://img.shields.io/pypi/dm/dense-evolution?style=flat-square&color=00e5ff)](https://pypi.org/project/dense-evolution/)
 [![Python](https://img.shields.io/badge/Python-3.9+-blue?style=flat-square&logo=python&logoColor=white)](https://www.python.org/)
 [![License](https://img.shields.io/badge/License-BSL_1.1-orange?style=flat-square)](LICENSE.md)
 [![Build](https://img.shields.io/badge/Build-Passing-00ff9d?style=flat-square)](https://github.com/tatopenn-cell/Dense-Evolution/actions)
 [![Cross-Validation CI](https://github.com/tatopenn-cell/Dense-Evolution-Ising-Tests/actions/workflows/ci.yml/badge.svg)](https://github.com/tatopenn-cell/Dense-Evolution-Ising-Tests/actions/workflows/ci.yml)
+[![Latest Release](https://img.shields.io/github/v/release/tatopenn-cell/Dense-Evolution?style=flat-square&color=blueviolet)](https://github.com/tatopenn-cell/Dense-Evolution/releases)
+[![Last Commit](https://img.shields.io/github/last-commit/tatopenn-cell/Dense-Evolution?style=flat-square)](https://github.com/tatopenn-cell/Dense-Evolution/commits/main)
+[![Issues](https://img.shields.io/github/issues/tatopenn-cell/Dense-Evolution?style=flat-square)](https://github.com/tatopenn-cell/Dense-Evolution/issues)
+[![Stars](https://img.shields.io/github/stars/tatopenn-cell/Dense-Evolution?style=flat-square&color=yellow)](https://github.com/tatopenn-cell/Dense-Evolution/stargazers)
+[![JAX](https://img.shields.io/badge/Backend-JAX_XLA-f9ab00?style=flat-square&logo=google&logoColor=white)](https://github.com/google/jax)
 
 ---
 
@@ -160,6 +166,9 @@ dense_evolution/
 ├── chunk.py        SafeMemoryGuard · MemoryChunker · CircuitChunker · Chunk (Anti-OOM)
 ├── simulator.py    DenseSVSimulator · run_parametric_batch_jit · vmap batch VQE
 └── dash.py         ipywidgets dashboard · VQE engine · QM/MM · MD simulation · 3D wavefunction
+
+ia_utils/
+└── vector_healing.py   median_healing · enhanced_dense_healing_hybrid (NaN/Inf-safe, lazy JAX import)
 ```
 
 **Data flow per run:**
@@ -185,6 +194,7 @@ dense_evolution/
 | **VQE + ADAM** | Hellmann-Feynman gradient · positional parameter injection into any OpenQASM 2.0 circuit |
 | **Anti-OOM Engine** | `SafeMemoryGuard` blocks execution before JAX raises `RESOURCE_EXHAUSTED` |
 | **Predictive Healing** | `healing.py` — Φ_AB alignment, dynamic vector, Σ-sync, `MemoryReflectionEngine` |
+| **Vector Sequence Healing** | `ia_utils/` — `median_healing`, `enhanced_dense_healing_hybrid` — NaN/Inf-safe, lazy JAX import |
 | **Backend Agnostic** | NumPy CPU · JAX XLA CPU/TPU · CuPy CUDA — runtime selection, zero code changes |
 | **Live Dashboard** | 8-panel ipywidgets telemetry: probability, VQE energy, entropy, purity, gradient, noise, θ-correction, Pearson heatmap |
 
@@ -240,6 +250,7 @@ sim = DenseSVSimulator(
 | Method | Description |
 |---|---|
 | `set_initial_state(state=None)` | Reset to `\|0⟩ⁿ` or inject custom statevector |
+| `run_circuit(circuit, transpile=True)` | Plain (non-JIT) gate execution — takes the tuple format below |
 | `run_circuit_jit_beast_mode(circuit)` | JIT-compiled gate execution — primary execution path |
 | `run_circuit_with_chunking(circuit, chunk_size=500)` | Chunked execution for long circuits |
 | `run_parametric_batch_jit(base_circuit, parameter_batch)` | `vmap` over parameter grid — returns full batch of statevectors |
@@ -258,16 +269,34 @@ circuit = parser.parse(qasm_str)   # → QASMCircuit
 valid, msg = parser.validate(circuit)
 ```
 
-`QASMCircuit` fields: `n_qubits`, `n_cbits`, `ops` (list of gate tuples).
+`QASMCircuit` fields: `n_qubits`, `n_cbits`, `ops` (list of gate dicts, e.g.
+`{'name': 'h', 'qubits': [0], 'params': []}`). Use `circuit.to_tuples()` to
+convert `ops` to the `(name, qubit0[, qubit1, ...][, param0, ...])` tuple
+format that `run_circuit` / `run_circuit_jit_beast_mode` expect — don't
+build that format by hand.
 
 ### `NoiseModel`
 
 ```python
 noise = NoiseModel()
-noise.apply(sv, model='depolarizing', p=0.01, n_qubits=4, rng=rng)
+noise.apply_to_sv(sv, n=4, model='depolarizing', p=0.01, rng=rng)
 desc  = NoiseModel.kraus_description('amplitude_damping')
 ```
 
+### End-to-end: parse → run → apply noise
+
+```python
+parser  = QASMParser()
+circuit = parser.parse(qasm_str)                  # → QASMCircuit
+sim     = DenseSVSimulator(n_qubits=circuit.n_qubits)
+sim.run_circuit(circuit.to_tuples())               # dicts -> tuples, then execute
+
+sv_noisy = NoiseModel().apply_to_sv(
+    sim.get_statevector(), n=circuit.n_qubits, model='depolarizing', p=0.01,
+    rng=np.random.default_rng(42),
+)
+```
+
 ### `Chunk` (Anti-OOM)
 
 ```python
@@ -283,6 +312,17 @@ sim.run_chunk(circuit, chunk_size_gates=500)
 
 Backward-compatibility aliases: `chunk1 = MemoryChunker`, `chunk2 = Chunk`, `Chunk2Incrociato = Chunk`.
 
+### `ia_utils.vector_healing`
+
+```python
+from ia_utils.vector_healing import median_healing, enhanced_dense_healing_hybrid
+
+healed, radius   = median_healing(vettori, radius_baseline=None)
+healed, metadata = enhanced_dense_healing_hybrid(vettori, radius_baseline=None, median_fallback_threshold=0.1)
+```
+
+See **IA Utils — Vector Sequence Healing** above for details.
+
 ---
 
 ## ▍ Gate Library
@@ -350,6 +390,42 @@ All core functions compiled via `@jax.jit`. Event history managed by `MemoryRefl
 
 ---
 
+## ▍ IA Utils — Vector Sequence Healing
+
+`ia_utils/vector_healing.py` — standalone module for cleaning sequences of vectors (e.g. hidden states / embeddings) that may contain `NaN` or `Inf` entries. Both functions preprocess the input (Inf → NaN → column-mean imputation) before healing, so corrupted values never propagate into the output.
+
+| Function | Approach | Returns |
+|---|---|---|
+| `median_healing(vettori, radius_baseline=None)` | `scipy.ndimage.median_filter`, dynamic radius `min(20, max(3, n // 3))` | `(healed: np.ndarray, radius: int)` |
+| `enhanced_dense_healing_hybrid(vettori, radius_baseline=None, median_fallback_threshold=0.1)` | Blends the `dense_evolution.healing` Φ-trigger logic with a median fallback, decided per-step | `(healed: np.ndarray, metadata: dict)` |
+
+`enhanced_dense_healing_hybrid` metadata:
+
+| Key | Type | Description |
+|---|---|---|
+| `fallback_triggered` | `bool` | `True` if the median fallback or dense blending fired at least once |
+| `adaptive_radius_used` | `int` | Baseline radius actually applied |
+| `reconstruction_error` | `float` | Mean norm of the correction applied vs. the sanitized input |
+
+```python
+import numpy as np
+from ia_utils.vector_healing import median_healing, enhanced_dense_healing_hybrid
+
+vettori = np.random.default_rng(0).normal(size=(50, 128))
+vettori[10, 3] = np.nan          # simulate a corrupted hidden state
+vettori[30, 7] = np.inf
+
+healed, radius = median_healing(vettori)
+
+healed_hybrid, meta = enhanced_dense_healing_hybrid(vettori)
+print(meta)
+# {'fallback_triggered': True, 'adaptive_radius_used': 16, 'reconstruction_error': 11.48}
+```
+
+`jax` is imported lazily inside `enhanced_dense_healing_hybrid` — `median_healing` and the module import itself work without the `[jax]` extra installed; only calling `enhanced_dense_healing_hybrid` requires it.
+
+---
+
 ## ▍ Anti-OOM Chunk Engine
 
 All operations parcellized dynamically using a 4-layer architectural shield.
@@ -468,6 +544,17 @@ All circuits stored as OpenQASM 2.0 strings in `QASM_LIBRARY`.
 
 ## ▍ Changelog
 
+### v8.1.9
+- **Fixed**: `ia_utils/vector_healing.py` — `enhanced_dense_healing_hybrid` had an unreachable third branch (a dense/blend fallback): the underlying `trigger` signal from `evaluate_phi_trigger` is strictly binary (0.0/1.0), so the branch could never execute. Collapsed to the genuine 2-state logic (pass-through vs. median fallback); runtime output is unchanged since the branch never ran.
+- **Fixed**: `dashboard_core.py` — `run_simulation` / `run_vqe_telemetry` mutated the process-wide JAX `jax_enable_x64` flag without ever restoring it, so running one float32 simulation silently downgraded numerical precision for unrelated code later in the same process (e.g. the Vector Healing page, which sets no precision of its own). Both now save/restore the flag around their own execution.
+- **Docs**: README's `NoiseModel` example called a nonexistent `.apply()` method with a wrong parameter name (`n_qubits` instead of `n`) — corrected to `apply_to_sv(sv, n=..., ...)`. Documented `QASMCircuit.to_tuples()` and `DenseSVSimulator.run_circuit`, which already existed and work correctly but were never mentioned in the README.
+
+### v8.1.8
+- **Fixed**: `parser.py` — controlled two-qubit gates (`cx`/`cy`/`cz`/`cp`/`crz`) parsed from QASM in the dashboard layer had control and target swapped relative to `compiler.py`'s documented `(gate, control, target)` contract, breaking entanglement for circuits run through the dashboard. The core `QASMCircuit.to_tuples()` path was already correct.
+- **Fixed**: `parser.py` — range syntax (`q[0:3]`) on single-qubit gates only applied to the first qubit in the range, silently dropping the rest. Now expands into one gate application per qubit, matching the parser's own documented contract.
+- **Fixed**: `from dense_evolution import Chunk` raised `ImportError` — `Chunk` is now re-exported from the package root. Added `get_probabilities()`/`get_statevector()` to `Chunk` for parity with `DenseSVSimulator`.
+- **Removed**: `dense_evolution/test2.py` and `stress_test.py` — byte-identical, assertion-free debug scripts that shipped inside every install with 0% test coverage. Their one real check (Kraus noise is genuinely stochastic across independent runs) is now a real regression test.
+
 ### v8.1.7
 - `ia_utils/` — new package: `median_healing`, `enhanced_dense_healing_hybrid` for vector sequence healing (NaN/Inf-safe)
 - `jax` import in `ia_utils.vector_healing` made lazy — importable without the `[jax]` extra

{dense_evolution-8.1.7 → dense_evolution-8.1.9}/dense_evolution.egg-info/SOURCES.txt

@@ -10,8 +10,6 @@ dense_evolution/healing.py
 dense_evolution/parser.py
 dense_evolution/registry.py
 dense_evolution/simulator.py
-dense_evolution/stress_test.py
-dense_evolution/test2.py
 dense_evolution.egg-info/PKG-INFO
 dense_evolution.egg-info/SOURCES.txt
 dense_evolution.egg-info/dependency_links.txt

{dense_evolution-8.1.7 → dense_evolution-8.1.9}/ia_utils/vector_healing.py

@@ -69,15 +69,20 @@ def enhanced_dense_healing_hybrid(
                                          Se `None`, il raggio viene calcolato dinamicamente
                                          come `min(20, max(3, n_tokens // 3))`.
                                          Defaults to None.
-        median_fallback_threshold (float): Soglia del trigger sotto la quale scatta il fallback
-                                           mediano. Defaults to 0.1.
+        median_fallback_threshold (float): Non più utilizzato dalla logica interna — `trigger`
+                                           (da `evaluate_phi_trigger`) è strettamente binario
+                                           (0.0 o 1.0 per design: ciclo aperto/dinamico → incluso,
+                                           ciclo chiuso/statico → escluso), quindi non esiste un
+                                           valore intermedio su cui questa soglia possa agire.
+                                           Mantenuto nella firma per compatibilità con i chiamanti
+                                           esistenti. Defaults to 0.1.
 
     Returns:
         tuple: Contiene:
             - np.ndarray: Vettori curati, della stessa shape dell'input.
             - dict: Metadati di telemetria contenenti:
-                    - 'fallback_triggered' (bool): `True` se il fallback mediano o il blending denso
-                                                   è stato applicato almeno una volta durante il healing.
+                    - 'fallback_triggered' (bool): `True` se il fallback mediano è stato applicato
+                                                   almeno una volta durante il healing.
                     - 'adaptive_radius_used' (int): Il raggio effettivamente calcolato e applicato.
                     - 'reconstruction_error' (float): La norma media di variazione (errore di ricostruzione)
                                                       introdotta rispetto ai vettori originali (potenzialmente corrotti).
@@ -86,7 +91,6 @@ def enhanced_dense_healing_hybrid(
     from dense_evolution.healing import (
         calculate_phi_ab,
         calculate_vettore_dinamico,
-        calculate_delta_preemp,
         evaluate_phi_trigger,
         GLOBAL_CONSTANTS,
     )
@@ -137,24 +141,14 @@ def enhanced_dense_healing_hybrid(
         E_B = jnp.linalg.norm(state_B)
 
         v_dinamic = calculate_vettore_dinamico(E_A, E_B, phi_ab)
-        delta_preemp = calculate_delta_preemp(E_A, E_B)
-        trigger, lambda_step, epsilon_dissip = evaluate_phi_trigger(v_dinamic)
-
-        healed_vector = processed_vettori[i]
+        trigger, _, _ = evaluate_phi_trigger(v_dinamic)
 
         if float(trigger) > GLOBAL_CONSTANTS['NON_STATIC_THRESHOLD_A']:
+            # trigger == 1.0: ciclo aperto/dinamico -> cambio genuino, si tiene il valore
             healed_vector = processed_vettori[i]
-        elif float(trigger) < median_fallback_threshold:
-            baseline_median = np.median(processed_vettori[lo:i], axis=0)
-            healed_vector = baseline_median
-            fallback_triggered_at_all = True
         else:
-            blend_factor = float(lambda_step)
-            if delta_preemp > GLOBAL_CONSTANTS['THRESHOLD_DELTA_PREEMP']:
-                blend_factor = min(1.0, blend_factor + GLOBAL_CONSTANTS['DAMPING_BOOST_ON_STASIS'])
-            else:
-                blend_factor = max(0.0, blend_factor - GLOBAL_CONSTANTS['DAMPING_BOOST_ON_STASIS'])
-            healed_vector = (1 - blend_factor) * processed_vettori[i] + blend_factor * baseline_mean
+            # trigger == 0.0: ciclo chiuso/statico -> rumore, si sostituisce con la mediana locale
+            healed_vector = np.median(processed_vettori[lo:i], axis=0)
             fallback_triggered_at_all = True
 
         out[i] = healed_vector

{dense_evolution-8.1.7 → dense_evolution-8.1.9}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "dense-evolution"
-version = "8.1.7"
+version = "8.1.9"
 description = "Micro-optimized High-Performance NISQ Statevector Quantum Circuit Simulator (Hardware-Adaptive Integration of Native NumPy, CUDA-Accelerated CuPy, and Linear Kernel Fusion via JAX JIT/XLA Compilation)"
 readme = "README.md"
 requires-python = ">=3.9"

dense_evolution-8.1.7/dense_evolution/stress_test.py

@@ -1,76 +0,0 @@
-import time
-import numpy as np
-from dense_evolution import DenseSVSimulator, QASMParser, QuantumTranspiler, NoiseModel
-
-print("====================================================")
-print("🔬 ADVANCED PRODUCTION STRESS-TEST: KRAUS & JIT SIMULATION")
-print("====================================================")
-
-try:
-    qasm_bench = """
-    OPENQASM 2.0;
-    include "qelib1.inc";
-    qreg q[6];
-    h q[0];
-    cx q[0], q[1];
-    cx q[1], q[2];
-    cx q[2], q[3];
-    cx q[3], q[4];
-    cx q[4], q[5];
-    rx(1.570796) q[0];
-    ry(0.785398) q[1];
-    rz(0.392699) q[2];
-    """
-    
-    print("1. Parsing e Transpilazione del circuito QASM...")
-    # Questo testa la corretta importazione e funzione di parser.py e compiler.py
-    parser = QASMParser()
-    circ = parser.parse(qasm_bench)
-    tuples = QuantumTranspiler.transpile(circ.to_tuples())
-    n_qubits = circ.n_qubits
-    print(f"✓ Parsing completato. Qubit: {n_qubits}, Gate transpilati: {len(tuples)}")
-
-    print("\n2. Validazione Core JIT in modalità ideale (simulator.py)...")
-    t0 = time.perf_counter()
-    sim_ideale = DenseSVSimulator(n_qubits)
-    sim_ideale.run_circuit_jit_beast_mode(tuples)
-    t_ideale = time.perf_counter() - t0
-    prob_ideale = sim_ideale.get_probabilities()
-    print(f"✓ Successo ideale in {t_ideale:.4f} s | Dimensione stato: {len(prob_ideale)}")
-
-    print("\n3. Validazione NoiseModel (registry.py): Canale stocastico Amplitude Damping...")
-    
-    # Run Noisy 1
-    t0 = time.perf_counter()
-    sim_noisy1 = DenseSVSimulator(n_qubits)
-    sim_noisy1.run_circuit_jit_beast_mode(tuples)
-    # Iniezione diretta del rumore Kraus sullo statevector compilato
-    sim_noisy1.sv = NoiseModel.apply_to_sv(sim_noisy1.sv, n_qubits, model='amplitude_damping', p=0.15)
-    prob_noisy1 = sim_noisy1.get_probabilities()
-    t_noisy1 = time.perf_counter() - t0
-    
-    # Run Noisy 2
-    sim_noisy2 = DenseSVSimulator(n_qubits)
-    sim_noisy2.run_circuit_jit_beast_mode(tuples)
-    sim_noisy2.sv = NoiseModel.apply_to_sv(sim_noisy2.sv, n_qubits, model='amplitude_damping', p=0.15)
-    prob_noisy2 = sim_noisy2.get_probabilities()
-    
-    print(f"✓ Successo noisy in {t_noisy1:.4f} s")
-
-    print("\n4. Analisi statistica delle fluttuazioni (Shot Noise Reale)...")
-    scostamento_stocastico = np.linalg.norm(prob_noisy1 - prob_noisy2)
-    scostamento_ideale = np.linalg.norm(prob_ideale - prob_noisy1)
-    
-    print(f"🔬 Distanza ideale-noisy: {scostamento_ideale:.6f}")
-    print(f"🔬 Fluttuazione quantistica indipendente (Shot Noise): {scostamento_stocastico:.6f}")
-
-    if scostamento_stocastico > 1e-12:
-        print("\n✅ TEST SUPERATO: Moduli collegati, PRNG JAX funzionante e rumore autenticamente non-deterministico!")
-    else:
-        print("\n❌ FALLIMENTO: Il rumore è ancora lineare o statico. Le due run hanno prodotto stati identici.")
-
-    print("====================================================")
-
-except Exception as e:
-    print(f"\n❌ CRASH DURANTE L'ELABORAZIONE HARDWARE: {str(e)}")
-    print("====================================================")

dense_evolution-8.1.7/dense_evolution/test2.py

@@ -1,76 +0,0 @@
-import time
-import numpy as np
-from dense_evolution import DenseSVSimulator, QASMParser, QuantumTranspiler, NoiseModel
-
-print("====================================================")
-print("TEST: KRAUS & JIT SIMULATION")
-print("====================================================")
-
-try:
-    qasm_bench = """
-    OPENQASM 2.0;
-    include "qelib1.inc";
-    qreg q[6];
-    h q[0];
-    cx q[0], q[1];
-    cx q[1], q[2];
-    cx q[2], q[3];
-    cx q[3], q[4];
-    cx q[4], q[5];
-    rx(1.570796) q[0];
-    ry(0.785398) q[1];
-    rz(0.392699) q[2];
-    """
-    
-    print("1. Parsing e Transpilazione del circuito QASM...")
-    # Questo testa la corretta importazione e funzione di parser.py e compiler.py
-    parser = QASMParser()
-    circ = parser.parse(qasm_bench)
-    tuples = QuantumTranspiler.transpile(circ.to_tuples())
-    n_qubits = circ.n_qubits
-    print(f"✓ Parsing completato. Qubit: {n_qubits}, Gate transpilati: {len(tuples)}")
-
-    print("\n2. Validazione Core JIT in modalità ideale (simulator.py)...")
-    t0 = time.perf_counter()
-    sim_ideale = DenseSVSimulator(n_qubits)
-    sim_ideale.run_circuit_jit_beast_mode(tuples)
-    t_ideale = time.perf_counter() - t0
-    prob_ideale = sim_ideale.get_probabilities()
-    print(f"✓ Successo ideale in {t_ideale:.4f} s | Dimensione stato: {len(prob_ideale)}")
-
-    print("\n3. Validazione NoiseModel (registry.py): Canale stocastico Amplitude Damping...")
-    
-    # Run Noisy 1
-    t0 = time.perf_counter()
-    sim_noisy1 = DenseSVSimulator(n_qubits)
-    sim_noisy1.run_circuit_jit_beast_mode(tuples)
-    # Iniezione diretta del rumore Kraus sullo statevector compilato
-    sim_noisy1.sv = NoiseModel.apply_to_sv(sim_noisy1.sv, n_qubits, model='amplitude_damping', p=0.15)
-    prob_noisy1 = sim_noisy1.get_probabilities()
-    t_noisy1 = time.perf_counter() - t0
-    
-    # Run Noisy 2
-    sim_noisy2 = DenseSVSimulator(n_qubits)
-    sim_noisy2.run_circuit_jit_beast_mode(tuples)
-    sim_noisy2.sv = NoiseModel.apply_to_sv(sim_noisy2.sv, n_qubits, model='amplitude_damping', p=0.15)
-    prob_noisy2 = sim_noisy2.get_probabilities()
-    
-    print(f"✓ Successo noisy in {t_noisy1:.4f} s")
-
-    print("\n4. Analisi statistica delle fluttuazioni (Shot Noise Reale)...")
-    scostamento_stocastico = np.linalg.norm(prob_noisy1 - prob_noisy2)
-    scostamento_ideale = np.linalg.norm(prob_ideale - prob_noisy1)
-    
-    print(f"🔬 Distanza ideale-noisy: {scostamento_ideale:.6f}")
-    print(f"🔬 Fluttuazione quantistica indipendente (Shot Noise): {scostamento_stocastico:.6f}")
-
-    if scostamento_stocastico > 1e-12:
-        print("\n✅ TEST SUPERATO: Moduli collegati, PRNG JAX funzionante e rumore autenticamente non-deterministico!")
-    else:
-        print("\n❌ FALLIMENTO: Il rumore è ancora lineare o statico. Le due run hanno prodotto stati identici.")
-
-    print("====================================================")
-
-except Exception as e:
-    print(f"\n❌ CRASH DURANTE L'ELABORAZIONE HARDWARE: {str(e)}")
-    print("====================================================")