dense-evolution 8.0.0__py3-none-any.whl

dense_evolution.py

@@ -0,0 +1,1445 @@
+import subprocess, sys, os
+import importlib
+import numpy as np
+from numpy import linalg as LA
+import scipy.linalg
+import matplotlib
+import matplotlib.pyplot as plt
+import matplotlib.gridspec as gridspec
+from matplotlib.patches import FancyArrowPatch, Rectangle, Circle, FancyBboxPatch
+from matplotlib.colors import LinearSegmentedColormap, Normalize
+from matplotlib.cm import ScalarMappable
+import matplotlib.ticker as ticker
+from IPython.display import display, HTML, clear_output
+import time, re, io, warnings, hashlib, json, copy, psutil, platform
+from datetime import datetime
+from typing import List, Dict, Optional, Tuple
+from dataclasses import dataclass, field
+from enum import Enum
+import pandas as pd
+
+warnings.filterwarnings('ignore')
+
+# ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+# CELLA 1: Hardware Detection & Configuration
+# ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+
+def install(pkg):
+    subprocess.check_call([sys.executable, '-m', 'pip', 'install', '-q', pkg])
+
+# GPU Support (Optional)
+try:
+    import cupy as cp
+    HAS_CUPY = True
+    print('✅ CuPy disponibile — GPU acceleration attiva')
+except:
+    HAS_CUPY = False
+    print('ℹ️  CuPy non disponibile — usando NumPy CPU')
+
+# JAX Support (Optional with NumPy fallback)
+try:
+    import jax
+    import jax.numpy as jnp
+    HAS_JAX = True
+    print('✅ JAX disponibile (JIT optimization attivo)')
+except:
+    HAS_JAX = False
+    jnp = None  # Fallback: will use NumPy instead
+    print('ℹ️  JAX non disponibile — fallback NumPy attivo')
+
+# Hardware detection
+ram_total = psutil.virtual_memory().total / (1024**3)
+ram_avail = psutil.virtual_memory().available / (1024**3)
+print(f'\n⌨️  Sistema: {platform.processor()}')
+print(f'💾  RAM Totale: {ram_total:.1f} GB  |  Disponibile: {ram_avail:.1f} GB')
+
+# Automatic qubit limits based on RAM
+if ram_total >= 50:
+    MAX_DENSE_QUBITS = 28
+    print(f'🚀  High-RAM runtime → Dense SV fino a 28 qubit')
+elif ram_total >= 12:
+    MAX_DENSE_QUBITS = 24
+    print(f'✅  Standard runtime → Dense SV fino a 24 qubit')
+else:
+    MAX_DENSE_QUBITS = 20
+    print(f'⚠️  RAM limitata → Dense SV fino a 20 qubit')
+
+# GPU detection
+try:
+    gpu_info = subprocess.check_output(['nvidia-smi', '--query-gpu=name,memory.total',
+                                         '--format=csv,noheader'], text=True).strip()
+    print(f'🎮  GPU: {gpu_info}')
+    HAS_GPU = True
+except:
+    HAS_GPU = False
+    print('ℹ️  Nessuna GPU NVIDIA rilevata')
+
+print(f'\n📊  Configurazione: MAX_DENSE={MAX_DENSE_QUBITS}q | JAX={HAS_JAX} | GPU={HAS_GPU}')
+
+# ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+# CELLA 2: Matplotlib Professional Styling
+# ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+
+plt.style.use('dark_background')
+DARK_BG   = '#010409'
+PANEL_BG  = '#0d1117'
+PANEL_BG2 = '#161b22'
+BORDER    = '#21262d'
+ACC_G     = '#00ff9d'
+ACC_B     = '#00c8ff'
+ACC_O     = '#ff6b35'
+ACC_P     = '#b400ff'
+ACC_TEAL  = '#00ffff'
+ACC_PINK  = '#ff007f'
+WARN      = '#ffd700'
+DANGER    = '#ff4444'
+MUTED     = '#7d8590'
+TEXT      = '#e6edf3'
+
+matplotlib.rcParams.update({
+    'figure.facecolor': DARK_BG,
+    'axes.facecolor': PANEL_BG,
+    'axes.edgecolor': BORDER,
+    'axes.labelcolor': MUTED,
+    'axes.titlecolor': TEXT,
+    'text.color': TEXT,
+    'xtick.color': MUTED,
+    'ytick.color': MUTED,
+    'grid.color': BORDER,
+    'grid.alpha': 0.5,
+    'font.family': 'monospace',
+    'font.size': 9,
+    'figure.dpi': 130,
+    'savefig.dpi': 200,
+})
+
+print('✅ Matplotlib tema dark professionale configurato')
+
+# ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+# CELLA 3: Gate Matrices & Operators
+# ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+
+INV2 = 1.0 / np.sqrt(2.0)
+
+GATES = {
+    'h':    INV2 * np.array([[1,1],[1,-1]], dtype=complex),
+    'x':    np.array([[0,1],[1,0]], dtype=complex),
+    'y':    np.array([[0,-1j],[1j,0]], dtype=complex),
+    'z':    np.array([[1,0],[0,-1]], dtype=complex),
+    's':    np.array([[1,0],[0,1j]], dtype=complex),
+    'sdg':  np.array([[1,0],[0,-1j]], dtype=complex),
+    't':    np.array([[1,0],[0,np.exp(1j*np.pi/4)]], dtype=complex),
+    'tdg':  np.array([[1,0],[0,np.exp(-1j*np.pi/4)]], dtype=complex),
+    'sx':   0.5*np.array([[1+1j,1-1j],[1-1j,1+1j]], dtype=complex),
+    'id':   np.eye(2, dtype=complex),
+    'cx':   np.array([[1,0,0,0],[0,1,0,0],[0,0,0,1],[0,0,1,0]], dtype=complex),
+    'cz':   np.array([[1,0,0,0],[0,1,0,0],[0,0,1,0],[0,0,0,-1]], dtype=complex),
+    'cy':   np.array([[1,0,0,0],[0,1,0,0],[0,0,0,-1j],[0,0,1j,0]], dtype=complex),
+    'swap': np.array([[1,0,0,0],[0,0,1,0],[0,1,0,0],[0,0,0,1]], dtype=complex),
+    'iswap':np.array([[1,0,0,0],[0,0,1j,0],[0,1j,0,0],[0,0,0,1]], dtype=complex),
+    'ecr':  INV2 * np.array([[0,0,1,1j],[0,0,1j,1],[1,-1j,0,0],[-1j,1,0,0]], dtype=complex),
+    'ccx':  np.array([[1,0,0,0,0,0,0,0],
+                       [0,1,0,0,0,0,0,0],
+                       [0,0,1,0,0,0,0,0],
+                       [0,0,0,1,0,0,0,0],
+                       [0,0,0,0,1,0,0,0],
+                       [0,0,0,0,0,1,0,0],
+                       [0,0,0,0,0,0,0,1],
+                       [0,0,0,0,0,0,1,0]], dtype=complex)
+}
+
+# ┌─────────────────────────────────────────────────────────────────┐
+# │ FIX #1: PARAMETRIC GATES WITH NUMPY FALLBACK (JAX-OPTIONAL)    │
+# └─────────────────────────────────────────────────────────────────┘
+def _build_parametric_gates(use_jax: bool = HAS_JAX):
+    """
+    Builds parametric gate functions with automatic fallback to NumPy if JAX unavailable.
+    Returns a dictionary of gate factories.
+    """
+    if use_jax and HAS_JAX:
+        # JAX version with JIT optimization potential
+        def rx_gate(theta: float):
+            c, s = jnp.cos(theta/2), jnp.sin(theta/2)
+            return jnp.array([[c, -1j*s], [-1j*s, c]], dtype=complex)
+
+        def ry_gate(theta: float):
+            c, s = jnp.cos(theta/2), jnp.sin(theta/2)
+            return jnp.array([[c, -s], [s, c]], dtype=complex)
+
+        def rz_gate(theta: float):
+            return jnp.array([[jnp.exp(-1j*theta/2), 0],
+                             [0, jnp.exp(1j*theta/2)]], dtype=complex)
+
+        def u3_gate(theta: float, phi: float, lam: float):
+            c, s = jnp.cos(theta/2), jnp.sin(theta/2)
+            return jnp.array(
+                [[c, -jnp.exp(1j*lam)*s],
+                 [jnp.exp(1j*phi)*s, jnp.exp(1j*(phi+lam))*c]]
+            , dtype=complex)
+
+        def p_gate(lam: float):
+            return jnp.array([[1, 0], [0, jnp.exp(1j*lam)]], dtype=complex)
+
+        def cp_gate(lam: float):
+            return jnp.array([[1,0,0,0],[0,1,0,0],[0,0,1,0],[0,0,0,jnp.exp(1j*lam)]], dtype=complex)
+
+        def crz_gate(theta: float):
+            return jnp.array([[1,0,0,0],[0,1,0,0],
+                             [0,0,jnp.exp(-1j*theta/2),0],
+                             [0,0,0,jnp.exp(1j*theta/2)]], dtype=complex)
+    else:
+        # NumPy version (fallback or primary when JAX unavailable)
+        def rx_gate(theta: float):
+            c, s = np.cos(theta/2), np.sin(theta/2)
+            return np.array([[c, -1j*s], [-1j*s, c]], dtype=complex)
+
+        def ry_gate(theta: float):
+            c, s = np.cos(theta/2), np.sin(theta/2)
+            return np.array([[c, -s], [s, c]], dtype=complex)
+
+        def rz_gate(theta: float):
+            return np.array([[np.exp(-1j*theta/2), 0],
+                            [0, np.exp(1j*theta/2)]], dtype=complex)
+
+        def u3_gate(theta: float, phi: float, lam: float):
+            c, s = np.cos(theta/2), np.sin(theta/2)
+            return np.array(
+                [[c, -np.exp(1j*lam)*s],
+                 [np.exp(1j*phi)*s, np.exp(1j*(phi+lam))*c]]
+            , dtype=complex)
+
+        def p_gate(lam: float):
+            return np.array([[1, 0], [0, np.exp(1j*lam)]], dtype=complex)
+
+        def cp_gate(lam: float):
+            return np.array([[1,0,0,0],[0,1,0,0],[0,0,1,0],[0,0,0,np.exp(1j*lam)]], dtype=complex)
+
+        def crz_gate(theta: float):
+            return np.array([[1,0,0,0],[0,1,0,0],
+                            [0,0,np.exp(-1j*theta/2),0],
+                            [0,0,0,np.exp(1j*theta/2)]], dtype=complex)
+
+    return {
+        'rx': rx_gate, 'ry': ry_gate, 'rz': rz_gate,
+        'u3': u3_gate, 'u2': lambda p,l: u3_gate(np.pi/2,p,l),
+        'u1': lambda l: p_gate(l), 'p': p_gate,
+        'cp': cp_gate, 'crz': crz_gate,
+    }
+
+PARAMETRIC_GATES = _build_parametric_gates(use_jax=HAS_JAX)
+
+print('✅ Gate library caricata (Parametric gates: JAX-safe with NumPy fallback)')
+print(f'   Gate 1q: {list(GATES.keys())[:6]}...')
+print(f'   Parametrici: {list(PARAMETRIC_GATES.keys())}')
+
+# ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+# CELLA 4: JAX JIT Compilation (Optional)
+# ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+
+if HAS_JAX:
+    def _jax_apply_gate_1q_einsum_impl(sv_array, gate_array, n_qubits, qubit_idx):
+        n, q = int(n_qubits), int(qubit_idx)
+        sv_nd = sv_array.reshape([2] * n)
+        sv_moved = jnp.moveaxis(sv_nd, q, -1)
+        flat_shape = (1 << (n - 1), 2)
+        result_moved = jnp.dot(sv_moved.reshape(flat_shape), gate_array.T)
+        result_nd = result_moved.reshape([2] * n)
+        return jnp.moveaxis(result_nd, -1, q).ravel()
+
+    jax_apply_gate_1q_einsum = jax.jit(_jax_apply_gate_1q_einsum_impl, static_argnums=(2, 3))
+
+    def _jax_apply_gate_2q_einsum_impl(sv_array, gate_array, n_qubits, q1, q2):
+        n = int(n_qubits)
+        sv_nd = sv_array.reshape([2] * n)
+        sv_moved = jnp.moveaxis(sv_nd, (q1, q2), (-2, -1))
+        flat_shape = (1 << (n - 2), 4)
+        gate_2d = gate_array.reshape(4, 4)
+        result_moved = jnp.dot(sv_moved.reshape(flat_shape), gate_2d.T)
+        result_nd = result_moved.reshape([2] * n)
+        return jnp.moveaxis(result_nd, (-2, -1), (q1, q2)).ravel()
+
+    jax_apply_gate_2q_einsum = jax.jit(_jax_apply_gate_2q_einsum_impl, static_argnums=(2, 3, 4))
+    print("💎 JAX JIT compilation attiva per gate 1q e 2q")
+else:
+    jax_apply_gate_1q_einsum = None
+    jax_apply_gate_2q_einsum = None
+    print("ℹ️  JAX JIT non disponibile — fallback NumPy ottimizzato")
+
+# ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+# CELLA 5: DenseSVSimulator Core Engine
+# ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+
+class DenseSVSimulator:
+    """
+    Professional quantum circuit simulator using dense statevector representation.
+
+    Features:
+    - NumPy/CuPy/JAX backend with automatic selection
+    - 1q and 2q gate support via micro-optimized back-axis dot parallelization
+    - Optional JAX JIT compilation
+    - Vectorized stride-slicing measurement and collapse
+    - Noise model integration (Kraus operators via stochastic trajectories)
+
+    Endianness: MSB-first (bit 0 = qubit n-1, bit n-1 = qubit 0)
+    """
+
+    def __init__(self, n_qubits: int, use_gpu: bool = True, use_float32: bool = False):
+        self.n = n_qubits
+        self.dim = 2**n_qubits
+        self.use_gpu = use_gpu and HAS_CUPY
+        self.dtype = np.complex64 if use_float32 else np.complex128
+
+        if self.use_gpu:
+            import cupy as cp
+            self.xp = cp
+            print(f'🎮 DenseSV: CuPy GPU | n={n_qubits} | dim={self.dim:,}')
+        elif HAS_JAX:
+            self.xp = jnp
+            dtype_str = 'float32' if use_float32 else 'float64'
+            print(f'⚡ DenseSV: JAX CPU/TPU | n={n_qubits} | dim={self.dim:,} | {dtype_str}')
+        else:
+            self.xp = np
+            dtype_str = 'float32' if use_float32 else 'float64'
+            print(f'⌨️  DenseSV: NumPy CPU | n={n_qubits} | dim={self.dim:,} | {dtype_str}')
+
+        # Initialize |00...0⟩
+        self.sv = self.xp.zeros(self.dim, dtype=self.dtype)
+        if self.xp is jnp:
+            self.sv = self.sv.at[0].set(1.0)
+        else:
+            self.sv[0] = 1.0
+
+        ram_mb = (self.dim * (8 if use_float32 else 16)) / (1024**2)
+        print(f'   RAM allocata: {ram_mb:.1f} MB')
+        if ram_mb > 1000:
+            print(f'   ⚠️  >1GB: Richiede architettura Full Vector ottimizzata a basso livello')
+
+    def set_initial_state(self, state_vector: Optional[np.ndarray] = None):
+        """Set initial state vector or reset to |0...0⟩"""
+        xp = self.xp
+        if state_vector is None:
+            self.sv = xp.zeros(self.dim, dtype=self.dtype)
+            if xp is jnp:
+                self.sv = self.sv.at[0].set(1.0)
+            else:
+                self.sv[0] = 1.0
+        else:
+            if len(state_vector) != self.dim:
+                raise ValueError(f"State vector must have length 2^n ({self.dim})")
+            self.sv = xp.asarray(state_vector, dtype=self.dtype)
+            self.normalize()
+
+    def apply_gate_1q(self, gate: np.ndarray, qubit: int):
+        """Apply single-qubit gate with MSB convention"""
+        if not 0 <= qubit < self.n:
+            raise ValueError(f"Qubit index {qubit} out of bounds for {self.n} qubits")
+        self._apply_gate_fast(gate, qubit)
+
+    def _apply_gate_fast(self, gate: np.ndarray, qubit: int):
+        """Vectorized O(2^n) 1q gate application using back-axis dot product"""
+        xp = self.xp
+        g = xp.asarray(gate, dtype=self.dtype)
+
+        if HAS_JAX and xp is jnp and jax_apply_gate_1q_einsum is not None:
+            self.sv = jax_apply_gate_1q_einsum(self.sv, g, self.n, qubit)
+        else:
+            # Micro-ottimizzazione: Spostamento dell'asse all'ultimo posto ed esecuzione dot parallelo
+            sv_nd = self.sv.reshape([2] * self.n)
+            sv_moved = xp.moveaxis(sv_nd, qubit, -1)
+            flat_shape = (1 << (self.n - 1), 2)
+            result_moved = xp.dot(sv_moved.reshape(flat_shape), g.T)
+            result_nd = result_moved.reshape([2] * self.n)
+            self.sv = xp.moveaxis(result_nd, -1, qubit).ravel()
+
+    def apply_gate_2q(self, gate: np.ndarray, q1: int, q2: int):
+        """Apply 2-qubit gate (4x4 or 2x2x2x2 tensor) with MSB convention"""
+        xp = self.xp
+        if not (0 <= q1 < self.n and 0 <= q2 < self.n and q1 != q2):
+            raise ValueError(f"Invalid qubit indices ({q1}, {q2})")
+
+        g_2d = xp.asarray(gate, dtype=self.dtype).reshape(4, 4)
+
+        if HAS_JAX and xp is jnp and jax_apply_gate_2q_einsum is not None:
+            self.sv = jax_apply_gate_2q_einsum(self.sv, g_2d, self.n, q1, q2)
+        else:
+            # Soluzione migliore: eliminazione stringhe e contrazione via vettorializzazione BLAS posteriore
+            sv_nd = self.sv.reshape([2] * self.n)
+            sv_moved = xp.moveaxis(sv_nd, (q1, q2), (-2, -1))
+            flat_shape = (1 << (self.n - 2), 4)
+            result_moved = xp.dot(sv_moved.reshape(flat_shape), g_2d.T)
+            result_nd = result_moved.reshape([2] * self.n)
+            self.sv = xp.moveaxis(result_nd, (-2, -1), (q1, q2)).ravel()
+
+    def apply_cx(self, ctrl: int, tgt: int):
+        """Controlled-X (CNOT) gate - bit-mask based (No massive index allocation)"""
+        xp = self.xp
+        if not (0 <= ctrl < self.n and 0 <= tgt < self.n and ctrl != tgt):
+            raise ValueError(f"Invalid control ({ctrl}) or target ({tgt})")
+
+        if xp is jnp:
+            # Ramo JAX: Sfrutta il motore a 2 qubit nativo per non rompere la compilazione tracciata
+            cx_mat = xp.array([[1,0,0,0],[0,1,0,0],[0,0,0,1],[0,0,1,0]], dtype=self.dtype)
+            self.apply_gate_2q(cx_mat, ctrl, tgt)
+        else:
+            # Ramo NumPy/CuPy: Ottimizzazione chirurgica della memoria in-place sulla CPU/GPU
+            c_stride = 1 << (self.n - 1 - ctrl)
+            t_stride = 1 << (self.n - 1 - tgt)
+            step = 2 * max(c_stride, t_stride)
+            inner_step = 2 * min(c_stride, t_stride)
+
+            for i in range(0, self.dim, step):
+                for j in range(0, max(c_stride, t_stride), inner_step):
+                    base_idx = i + j + c_stride
+                    idx_0 = base_idx
+                    idx_1 = base_idx + t_stride
+
+                    # Swap dei blocchi contigui senza creare array intermedi condizionali
+                    tmp = self.sv[idx_0 : idx_0 + min(c_stride, t_stride)].copy()
+                    self.sv[idx_0 : idx_0 + min(c_stride, t_stride)] = self.sv[idx_1 : idx_1 + min(c_stride, t_stride)]
+                    self.sv[idx_1 : idx_1 + min(c_stride, t_stride)] = tmp
+
+    def apply_cz(self, ctrl: int, tgt: int):
+        """Controlled-Z gate - Micro-optimized stride slicing"""
+        xp = self.xp
+        if not (0 <= ctrl < self.n and 0 <= tgt < self.n and ctrl != tgt):
+            raise ValueError(f"Invalid indices ({ctrl}, {tgt})")
+
+        if xp is jnp:
+            cz_mat = xp.array([[1,0,0,0],[0,1,0,0],[0,0,1,0],[0,0,0,-1]], dtype=self.dtype)
+            self.apply_gate_2q(cz_mat, ctrl, tgt)
+        else:
+            c_stride = 1 << (self.n - 1 - ctrl)
+            t_stride = 1 << (self.n - 1 - tgt)
+            step = 2 * max(c_stride, t_stride)
+            inner_step = 2 * min(c_stride, t_stride)
+
+            # Inversione di segno diretta sui blocchi mirati dove sia il controllo che il target sono a 1
+            for i in range(0, self.dim, step):
+                for j in range(0, max(c_stride, t_stride), inner_step):
+                    idx = i + j + c_stride + t_stride
+                    self.sv[idx : idx + min(c_stride, t_stride)] *= -1
+
+    def normalize(self):
+        """Normalize statevector to unit norm in-place"""
+        norm = self.xp.linalg.norm(self.sv)
+        if norm > 1e-12:
+            if self.xp is jnp:
+                self.sv = self.sv / norm
+            else:
+                self.sv /= norm
+
+    def get_probabilities(self) -> np.ndarray:
+        """Compute |ψ|² for each basis state"""
+        probs = self.xp.abs(self.sv)**2
+        if self.use_gpu:
+            return probs.get()
+        return np.array(probs, dtype=np.float64)
+
+    def get_statevector(self) -> np.ndarray:
+        """Return statevector as NumPy array"""
+        sv = self.sv
+        if self.xp is jnp:
+            return np.array(sv)
+        if self.use_gpu:
+            return sv.get()
+        return np.array(sv)
+
+# ┌─────────────────────────────────────────────────────────────────┐
+    # │ FIX #2: VECTORIZED MEASURE (Stride Slicing — No Index Masks)    │
+    # └─────────────────────────────────────────────────────────────────┘
+    def measure(self, qubit_idx: int) -> int:
+        """
+        Measure a single qubit and collapse statevector.
+        FIXED: Uses micro-optimized stride-slicing without memory allocation.
+        """
+        if not 0 <= qubit_idx < self.n:
+            raise ValueError(f"Qubit {qubit_idx} out of bounds")
+
+        xp = self.xp
+
+        # Calcolo dell'indice fisico specchiato per la convenzione MSB
+        phys_q = self.n - 1 - qubit_idx
+        stride = 1 << phys_q
+
+        if xp is jnp:
+            # Ramo JAX: Calcolo conforme al tracciamento statico dei tensori con fette esatte
+            probs = self.xp.abs(self.sv)**2
+            sv_shape = [2] * self.n
+            sv_nd = probs.reshape(sv_shape)
+            prob_0 = float(jnp.sum(jnp.moveaxis(sv_nd, phys_q, 0)[0]))
+            prob_1 = float(jnp.sum(jnp.moveaxis(sv_nd, phys_q, 0)[1]))
+        else:
+            # Ramo NumPy/CuPy Ultra-Performante: Somma a salti in memoria (Zero allocazione)
+            sv_reshaped = self.sv.reshape(-1, 2, stride)
+            prob_0 = float(xp.sum(xp.abs(sv_reshaped[:, 0, :])**2))
+            prob_1 = float(xp.sum(xp.abs(sv_reshaped[:, 1, :])**2))
+
+        # Normalizzazione delle probabilità estratte
+        total = prob_0 + prob_1
+        if total > 1e-12:
+            prob_0 /= total
+            prob_1 /= total
+
+        # Campionamento dell'esito della misura
+        result = int(np.random.choice([0, 1], p=[prob_0, prob_1]))
+
+        # Collasso della funzione d'onda in-place (Zero allocazione di maschere giganti)
+        if xp is jnp:
+            sv_shape = [2] * self.n
+            sv_nd = self.sv.reshape(sv_shape)
+            moved_sv = jnp.moveaxis(sv_nd, phys_q, 0)
+            moved_sv = moved_sv.at[1 if result == 0 else 0].set(0.0)
+            self.sv = jnp.moveaxis(moved_sv, 0, phys_q).ravel()
+        else:
+            # Slicing chirurgico nativo: azzera metà del vettore direttamente sulla matrice di vista
+            sv_reshaped[:, 1 if result == 0 else 0, :] = 0.0
+
+        self.normalize()
+        return result
+
+    def memory_mb(self) -> float:
+        """Estimate RAM usage in MB"""
+        elem_size = 8 if self.dtype == np.complex64 else 16
+        return self.dim * elem_size / 1e6
+
+# ┌─────────────────────────────────────────────────────────────────┐
+# │ PARAMETRIC GATE INJECTION (VERSIONE INTEGRALE DA REPOSITORY)    │
+# └─────────────────────────────────────────────────────────────────┘
+
+def patch_dense_parametric(cls):
+    """Inject all parametric standard OpenQASM 2.0 methods into DenseSVSimulator"""
+
+    def apply_rx(self, qubit: int, theta: float):
+        gate = PARAMETRIC_GATES['rx'](theta)
+        self.apply_gate_1q(gate, qubit)
+
+    def apply_ry(self, qubit: int, theta: float):
+        gate = PARAMETRIC_GATES['ry'](theta)
+        self.apply_gate_1q(gate, qubit)
+
+    def apply_rz(self, qubit: int, theta: float):
+        gate = PARAMETRIC_GATES['rz'](theta)
+        self.apply_gate_1q(gate, qubit)
+
+    def apply_u3(self, qubit: int, theta: float, phi: float, lam: float):
+        gate = PARAMETRIC_GATES['u3'](theta, phi, lam)
+        self.apply_gate_1q(gate, qubit)
+
+    def apply_u2(self, qubit: int, phi: float, lam: float):
+        gate = PARAMETRIC_GATES['u2'](phi, lam)
+        self.apply_gate_1q(gate, qubit)
+
+    def apply_u1(self, qubit: int, lam: float):
+        gate = PARAMETRIC_GATES['u1'](lam)
+        self.apply_gate_1q(gate, qubit)
+
+    def apply_p(self, qubit: int, lam: float):
+        gate = PARAMETRIC_GATES['p'](lam)
+        self.apply_gate_1q(gate, qubit)
+
+    def apply_cp(self, ctrl: int, tgt: int, lam: float):
+        gate = PARAMETRIC_GATES['cp'](lam)
+        self.apply_gate_2q(gate, ctrl, tgt)
+
+    def apply_crz(self, ctrl: int, tgt: int, theta: float):
+        gate = PARAMETRIC_GATES['crz'](theta)
+        self.apply_gate_2q(gate, ctrl, tgt)
+
+    # Iniezione di tutta la suite senza eccezioni o esclusioni
+    cls.apply_rx = apply_rx
+    cls.apply_ry = apply_ry
+    cls.apply_rz = apply_rz
+    cls.apply_u3 = apply_u3
+    cls.apply_u2 = apply_u2
+    cls.apply_u1 = apply_u1
+    cls.apply_p = apply_p
+    cls.apply_cp = apply_cp
+    cls.apply_crz = apply_crz
+
+    print("✅ All parametric methods (including u1/u2) injected into DenseSVSimulator")
+
+patch_dense_parametric(DenseSVSimulator)
+
+import numpy as np
+from typing import Optional, List, Dict
+import time
+
+# ═══════════════════════════════════════════════════════════════════════════════
+# CELLA 6: Modelli di rumore con operatori Kraus (VERSIONE INTEGRALE JAX FIXED)
+# ═══════════════════════════════════════════════════════════════════════════════
+# [PROPRIETARY ALGORITHM - (c) 2026 Salvatore Pennacchio - Licensed under EUPL-1.2]
+
+try:
+    import jax
+    import jax.numpy as jnp
+    HAS_JAX = True
+except ImportError:
+    HAS_JAX = False
+
+class NoiseModel:
+    """
+    5 modelli fisici di decoerenza con operatori Kraus.
+    Ottimizzato per agire in-place su NumPy/CuPy e funzionalmente su JAX XLA.
+    """
+
+    MODELS = ['ideal', 'depolarizing', 'bitflip', 'phaseflip', 'amplitude_damping', 'combined']
+
+    @staticmethod
+    def apply_to_sv(sv: np.ndarray, n: int, model: str, p: float,
+                    rng: Optional[np.random.Generator] = None, qubits: Optional[List[int]] = None,
+                    jax_key: Optional[any] = None) -> np.ndarray:
+        """
+        Applica il rumore stocastico al vettore di stato tramite traiettorie quantistiche (quantum jumps).
+
+        Args:
+            sv: Vettore di stato (np.ndarray o jnp.ndarray)
+            n: Numero totale di qubit nel registro
+            model: Stringa identificativa del modello di rumore
+            p: Probabilità di errore / parametro di damping
+            rng: Generatore di numeri casuali NumPy (usato solo per backend NumPy/CuPy)
+            qubits: Lista di qubit su cui applicare il rumore (default: tutti)
+            jax_key: jax.random.PRNGKey obbligatoria per garantire la stochastiticità sotto JAX JIT
+        """
+        if model == 'ideal' or p <= 0:
+            return sv
+
+        is_jax_array = HAS_JAX and isinstance(sv, jnp.ndarray)
+        xp = jnp if is_jax_array else np
+
+        target_qubits = qubits if qubits else list(range(n))
+        dim = len(sv)
+        sv_local = sv  # JAX array immutabile, le operazioni .at restituiranno nuove istanze
+
+        # Fallback del generatore NumPy per compatibilità retroattiva NumPy/CuPy
+        if not is_jax_array and rng is None:
+            rng = np.random.default_rng(int(time.time()))
+
+        # Inizializzazione della chiave funzionale di JAX per evitare il tracing ghost
+        if is_jax_array:
+            if jax_key is None:
+                jax_key = jax.random.PRNGKey(int(time.time() * 1000))
+            current_key = jax_key
+
+        for q in target_qubits:
+            step = 1 << q
+            indices = xp.arange(dim)
+            mask_0 = (indices & step) == 0
+            idx_0 = xp.where(mask_0)[0]
+            idx_1 = idx_0 | step
+            len_idx = len(idx_0)
+
+            # --- GENERAZIONE DEL VETTORE CASUALE AGNOSTIC BACKEND ---
+            if is_jax_array:
+                current_key, subkey = jax.random.split(current_key)
+                r_vec = jax.random.uniform(subkey, shape=(len_idx,), minval=0.0, maxval=1.0)
+            else:
+                r_vec = rng.random(len_idx)
+
+            # --- APPLICAZIONE MODELLI DI RUMORE ---
+            if model == 'depolarizing':
+                mask_x = r_vec < p/3
+                mask_z = (r_vec >= p/3) & (r_vec < 2*p/3)
+                mask_y = (r_vec >= 2*p/3) & (r_vec < p)
+
+                if is_jax_array:
+                    # Inversione di ampiezza X-Gate (JAX Immutabile via indici booleani fissi)
+                    temp_sv_x = sv_local[idx_0[mask_x]]
+                    sv_local = sv_local.at[idx_0[mask_x]].set(sv_local[idx_1[mask_x]])
+                    sv_local = sv_local.at[idx_1[mask_x]].set(temp_sv_x)
+
+                    # Inversione di fase Z-Gate (JAX Immutabile)
+                    sv_local = sv_local.at[idx_1[mask_z]].multiply(-1)
+
+                    # Rotazione complessa Y-Gate (JAX Immutabile)
+                    temp_sv_y0 = sv_local[idx_0[mask_y]]
+                    sv_local = sv_local.at[idx_0[mask_y]].set(-1j * sv_local[idx_1[mask_y]])
+                    sv_local = sv_local.at[idx_1[mask_y]].set(1j * temp_sv_y0)
+                else:
+                    # Inversione di ampiezza X-Gate (NumPy standard in-place mutabile)
+                    temp_sv_x = sv_local[idx_0[mask_x]].copy()
+                    sv_local[idx_0[mask_x]] = sv_local[idx_1[mask_x]]
+                    sv_local[idx_1[mask_x]] = temp_sv_x
+
+                    sv_local[idx_1[mask_z]] *= -1
+
+                    # Rotazione complessa Y-Gate (NumPy Mutabile)
+                    temp_sv_y0 = sv_local[idx_0[mask_y]].copy()
+                    sv_local[idx_0[mask_y]] = -1j * sv_local[idx_1[mask_y]]
+                    sv_local[idx_1[mask_y]] = 1j * temp_sv_y0
+
+            elif model == 'bitflip':
+                mask_flip = r_vec < p
+                if is_jax_array:
+                    temp_sv_flip = sv_local[idx_0[mask_flip]]
+                    sv_local = sv_local.at[idx_0[mask_flip]].set(sv_local[idx_1[mask_flip]])
+                    sv_local = sv_local.at[idx_1[mask_flip]].set(temp_sv_flip)
+                else:
+                    temp_sv_flip = sv_local[idx_0[mask_flip]].copy()
+                    sv_local[idx_0[mask_flip]] = sv_local[idx_1[mask_flip]]
+                    sv_local[idx_1[mask_flip]] = temp_sv_flip
+
+            elif model == 'phaseflip':
+                mask_flip = r_vec < p
+                if is_jax_array:
+                    sv_local = sv_local.at[idx_1[mask_flip]].multiply(-1)
+                else:
+                    sv_local[idx_1[mask_flip]] *= -1
+
+            elif model == 'amplitude_damping':
+                gamma = p
+                if is_jax_array:
+                    sv_local = sv_local.at[idx_1].multiply(xp.sqrt(1 - gamma))
+                    mask_decay = r_vec < gamma
+                    sv_local = sv_local.at[idx_0[mask_decay]].add(sv_local[idx_1[mask_decay]])
+                    sv_local = sv_local.at[idx_1[mask_decay]].set(0)
+                else:
+                    sv_local[idx_1] *= np.sqrt(1 - gamma)
+                    mask_decay = r_vec < gamma
+                    sv_local[idx_0[mask_decay]] += sv_local[idx_1[mask_decay]]
+                    sv_local[idx_1[mask_decay]] = 0
+
+            elif model == 'combined':
+                mask_x = r_vec < p*0.2
+                mask_z = (r_vec >= p*0.2) & (r_vec < p*0.4)
+                mask_y = (r_vec >= p*0.4) & (r_vec < p*0.6)
+
+                if is_jax_array:
+                    temp_sv_x = sv_local[idx_0[mask_x]]
+                    sv_local = sv_local.at[idx_0[mask_x]].set(sv_local[idx_1[mask_x]])
+                    sv_local = sv_local.at[idx_1[mask_x]].set(temp_sv_x)
+
+                    sv_local = sv_local.at[idx_1[mask_z]].multiply(-1)
+
+                    temp_sv_y0 = sv_local[idx_0[mask_y]]
+                    sv_local = sv_local.at[idx_0[mask_y]].set(-1j * sv_local[idx_1[mask_y]])
+                    sv_local = sv_local.at[idx_1[mask_y]].set(1j * temp_sv_y0)
+
+                    sv_local = sv_local.at[idx_1].multiply(xp.sqrt(1 - p*0.3))
+                else:
+                    temp_sv_x = sv_local[idx_0[mask_x]].copy()
+                    sv_local[idx_0[mask_x]] = sv_local[idx_1[mask_x]]
+                    sv_local[idx_1[mask_x]] = temp_sv_x
+
+                    sv_local[idx_1[mask_z]] *= -1
+
+                    temp_sv_y0 = sv_local[idx_0[mask_y]].copy()
+                    sv_local[idx_0[mask_y]] = -1j * sv_local[idx_1[mask_y]]
+                    sv_local[idx_1[mask_y]] = 1j * temp_sv_y0
+
+                    sv_local[idx_1] *= np.sqrt(1 - p*0.3)
+
+        # Rinormalizzazione di traiettoria protetta
+        norm = xp.linalg.norm(sv_local)
+        return sv_local / (norm + 1e-15)
+
+    @staticmethod
+    def kraus_description(model: str) -> Dict:
+        desc = {
+            'ideal':             {'kraus': 1, 'formula': 'K\u2080=I',  'physical': 'Nessun rumore'},
+            'depolarizing':      {'kraus': 4, 'formula': 'K\u2080=\u221a(1-p)I, K\u2081=\u221a(p/3)X, K\u2082=\u221a(p/3)Y, K\u2083=\u221a(p/3)Z', 'physical': 'Errore isotropo'},
+            'bitflip':           {'kraus': 2, 'formula': 'K\u2080=\u221a(1-p)I, K\u2081=\u221ap\u00b7X', 'physical': 'Flip di qubit \u03c3_x'},
+            'phaseflip':         {'kraus': 2, 'formula': 'K\u2080=\u221a(1-p)I, K\u2081=\u221ap\u00b7Z', 'physical': 'Dephasing puro'},
+            'amplitude_damping': {'kraus': 2, 'formula': 'K\u2080=diag(1,\u221a(1-\u03b3)), K\u2081=[[0,\u221a\u03b3],[0,0]]', 'physical': 'Decadimento T\u2081 (relassazione)'},
+            'combined':          {'kraus': 6, 'formula': 'Dep(p*0.4) + AmpDamp(p*0.3)', 'physical': 'Worst-case NISQ'},
+        }
+        return desc.get(model, desc['ideal'])
+
+print("✅ NoiseModel aggiornato (EUPL-1.2): Pieno supporto stocastico runtime JAX JIT sigillato!")
+
+# ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+# CELLA 7: OpenQASM 2.0 Parser & Transpiler
+# ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+
+@dataclass
+class QASMCircuit:
+    n_qubits: int = 0
+    n_cbits: int = 0
+    ops: List[Dict[str, any]] = field(default_factory=list)
+
+
+class QASMParser:
+    """Parse OpenQASM 2.0 circuits - Production Grade GitHub Standard"""
+
+    # Pre-compilazione delle espressioni regolari per eliminare l'overhead di parsing a runtime
+    _REG_QUBIT = re.compile(r'\[(\d+)\]')
+    _ALIAS_MAP = {'cu1': 'cp', 'u1': 'p', 'toffoli': 'ccx', 'fredkin': 'cswap'}
+    _MATH_ENV  = {'__builtins__': {}, 'np': np, 'pi': np.pi, 'sin': np.sin,
+                  'cos': np.cos, 'sqrt': np.sqrt, 'exp': np.exp}
+
+    def parse(self, qasm_str: str) -> QASMCircuit:
+        n_qubits, n_cbits, ops = 0, 0, []
+
+        # Rimozione dei commenti in un unico passaggio lineare
+        clean = []
+        for raw in qasm_str.split('\n'):
+            line = raw.split('//')[0].strip()
+            if line:
+                clean.append(line)
+
+        # Tokenizzazione efficiente basata su delimitatore di istruzione standard ';'
+        for instr in "".join(clean).split(';'):
+            instr = instr.strip()
+            if not instr or any(instr.startswith(t) for t in ('OPENQASM', 'include', 'barrier')):
+                continue
+
+            if instr.startswith('qreg'):
+                m = self._REG_QUBIT.search(instr)
+                if m:
+                    n_qubits = int(m.group(1))
+                continue
+
+            if instr.startswith('creg'):
+                m = self._REG_QUBIT.search(instr)
+                if m:
+                    n_cbits = int(m.group(1))
+                continue
+
+            if instr.startswith('measure'):
+                continue
+
+            parts = instr.split()
+            if not parts:
+                continue
+
+            gate_raw = parts[0]
+            gate_name = gate_raw.split('(')[0].lower()
+            gate_name = self._ALIAS_MAP.get(gate_name, gate_name)
+
+            # Estrazione e risoluzione matematica deterministica dei parametri angolari delle porte
+            params: List[float] = []
+            if '(' in gate_raw:
+                try:
+                    inner = gate_raw[gate_raw.index('(') + 1 : gate_raw.index(')')]
+                    for tok in inner.split(','):
+                        tok = tok.strip()
+                        if tok:
+                            params.append(float(eval(tok, self._MATH_ENV)))
+                except Exception:
+                    params.append(0.0)
+
+            # Estrazione simultanea di tutti i qubit target coinvolti dall'istruzione
+            qubit_indices = [int(x) for x in self._REG_QUBIT.findall(" ".join(parts[1:]))]
+
+            if qubit_indices:
+                ops.append({'type': 'gate', 'name': gate_name,
+                            'qubits': qubit_indices, 'params': params})
+
+        return QASMCircuit(n_qubits, n_cbits, ops)
+
+    def validate(self, circ: QASMCircuit) -> Tuple[bool, str]:
+        if circ.n_qubits <= 0:
+            return False, "n_qubits deve essere > 0."
+        if not circ.ops:
+            return False, "Nessuna operazione rilevata nel circuito quantistico."
+        return True, ""
+
+
+class QuantumTranspiler:
+    """Decompose multi-qubit gates into 1q and 2q execution primitives"""
+
+    @staticmethod
+    def decompose_toffoli(c1: int, c2: int, t: int) -> List[Tuple]:
+        """Barenco et al. decomposition optimized for Full-Vector mapping (6 CNOT gates)"""
+        return [
+            ('h',   t),
+            ('cx',  c2, t), ('tdg', t),
+            ('cx',  c1, t), ('t',   t),
+            ('cx',  c2, t), ('tdg', t),
+            ('cx',  c1, t),
+            ('t',   c2), ('t',   t),
+            ('cx',  c1, c2), ('h', t),
+            ('t',   c1), ('tdg', c2),
+            ('cx',  c1, c2),
+        ]
+
+    @staticmethod
+    def decompose_swap(q1: int, q2: int) -> List[Tuple]:
+        """Decompose SWAP into core CNOT sequence compatible with hardware strides"""
+        return [('cx', q1, q2), ('cx', q2, q1), ('cx', q1, q2)]
+
+    @staticmethod
+    def transpile(circuit: List[Tuple]) -> List[Tuple]:
+        """Unroll high-level structures into native operational primitives"""
+        out = []
+        for cmd in circuit:
+            name = cmd[0].lower()
+            if name == 'ccx':
+                out.extend(QuantumTranspiler.decompose_toffoli(*cmd[1:]))
+            elif name == 'swap':
+                out.extend(QuantumTranspiler.decompose_swap(*cmd[1:]))
+            else:
+                out.append(cmd)
+        return out
+
+
+print("✅ QASMParser and QuantumTranspiler loaded (Optimized regex & clean primitives)")
+
+# ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+# CELLA 8: Circuit Execution (MSB-aware Engine Core - CORRETTA)
+# ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+
+def run_circuit(self, circuit: List[Tuple], transpile: bool = True):
+    """
+    Execute circuit with automatic endianness correction.
+    FIXED: Prevents index double-flipping for multi-qubit gates.
+    """
+    target = QuantumTranspiler.transpile(circuit) if transpile else circuit
+    is_dense = hasattr(self, 'sv')
+
+    for cmd in target:
+        gate_name = cmd[0].lower()
+        args = cmd[1:]
+
+        mat = None
+        if gate_name in GATES:
+            mat = GATES[gate_name]
+        elif gate_name in PARAMETRIC_GATES:
+            try:
+                mat = PARAMETRIC_GATES[gate_name](*[a for a in args if isinstance(a, (float, int)) and not isinstance(a, bool)])
+                args = tuple([a for a in args if isinstance(a, int) and not isinstance(a, bool)])
+            except Exception:
+                pass
+
+        if mat is None:
+            method = getattr(self, f'apply_{gate_name}', None)
+            if method is None and gate_name == 'measure':
+                method = getattr(self, 'measure', None)
+
+            if method:
+                method(*args)
+            else:
+                raise ValueError(f"Porta quantistica o istruzione '{gate_name}' non riconosciuta.")
+            continue
+
+        mat = np.asarray(mat)
+        if mat.ndim == 2 and mat.shape == (2, 2):
+            # Pass logical qubit index directly. apply_gate_1q handles internal mapping.
+            self.apply_gate_1q(mat, args[0])
+        elif mat.ndim == 2 and mat.shape == (4, 4):
+            # Pass logical qubit indices directly. apply_gate_2q handles internal mapping.
+            self.apply_gate_2q(mat, args[0], args[1])
+        elif mat.ndim == 4:
+            # Pass logical qubit indices directly. apply_gate_2q handles internal mapping.
+            self.apply_gate_2q(mat.reshape(4, 4), args[0], args[1])
+
+DenseSVSimulator.run_circuit = run_circuit
+print("✅ run_circuit patchato con successo: allineamento indici MSB stabilizzato!")
+
+# ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+# CORE COMPILATION ENGINE (KERNEL FUSION LINEARE AD ALLOCAZIONE ZERO)
+# ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+
+import time
+import numpy as np
+from typing import List, Tuple
+
+try:
+    import jax
+    import jax.numpy as jnp
+    HAS_JAX = True
+    # Abilita i 64-bit nativi in JAX per evitare overflow degli indici oltre i 24 qubit
+    jax.config.update("jax_enable_x64", True)
+except ImportError:
+    HAS_JAX = False
+
+# Mappatura stazionaria ottimizzata (0-11 per 1Q, 20-21 per 2Q)
+GATE_IDS = {
+    'id': 0, 'h': 1, 'x': 2, 'y': 3, 'z': 4, 's': 5, 'sdg': 6, 't': 7, 'tdg': 8,
+    'rx': 9, 'ry': 10, 'rz': 11, 'cx': 20, 'cz': 21
+}
+
+if HAS_JAX:
+    @jax.jit
+    def _apply_gate_fast_step(sv, operation):
+       
+        g_id, q1, q2, param = operation
+        dim = sv.shape[0]
+
+        inv2 = 1.0 / jnp.sqrt(2.0)
+        cos_p = jnp.cos(param / 2.0)
+        sin_p = jnp.sin(param / 2.0)
+
+        # Clamping protettivo dell'indice virtuale per evitare errori Out-of-Bounds in XLA
+        safe_gid = jnp.where(g_id <= 11, g_id, 0).astype(jnp.int32)
+
+        g_1q = jax.lax.switch(
+            safe_gid,
+            [
+                lambda _: jnp.eye(2, dtype=jnp.complex128),                                     # 0: id
+                lambda _: inv2 * jnp.array([[1.0, 1.0], [1.0, -1.0]], dtype=jnp.complex128),      # 1: h
+                lambda _: jnp.array([[0.0, 1.0], [1.0, 0.0]], dtype=jnp.complex128),            # 2: x
+                lambda _: jnp.array([[0.0, -1j], [1j, 0.0]], dtype=jnp.complex128),            # 3: y
+                lambda _: jnp.array([[1.0, 0.0], [0.0, -1.0]], dtype=jnp.complex128),           # 4: z
+                lambda _: jnp.array([[1.0, 0.0], [0.0, 1j]], dtype=jnp.complex128),             # 5: s
+                lambda _: jnp.array([[1.0, 0.0], [0.0, -1j]], dtype=jnp.complex128),            # 6: sdg
+                lambda _: jnp.array([[1.0, 0.0], [0.0, jnp.exp(1j * jnp.pi / 4)]], dtype=jnp.complex128),  # 7: t
+                lambda _: jnp.array([[1.0, 0.0], [0.0, jnp.exp(-1j * jnp.pi / 4)]], dtype=jnp.complex128), # 8: tdg
+                lambda _: jnp.array([[cos_p, -1j * sin_p], [-1j * sin_p, cos_p]], dtype=jnp.complex128), # 9: rx
+                lambda _: jnp.array([[cos_p, -sin_p], [sin_p, cos_p]], dtype=jnp.complex128),            # 10: ry
+                lambda _: jnp.array([[jnp.exp(-1j * param / 2.0), 0.0], [0.0, jnp.exp(1j * param / 2.0)]], dtype=jnp.complex128) # 11: rz
+            ],
+            operand=None
+        )
+
+        # 1-QUBIT: APPLICAZIONE LINEARE MATRICE-SPAZZATA (Zero .reshape, Zero indici, Norma protetta)
+        def do_1q(_sv):
+            t_bit = q1.astype(jnp.int64)
+            stride = 1 << t_bit
+
+            # Generazione implicita delle maschere di canale a 1D contigua ammessa da XLA
+            # Isola gli stati accoppiati specchiati proiettando direttamente il vettore originale
+            idx_full = jnp.arange(dim, dtype=jnp.int64)
+            mask_0 = (idx_full & stride) == 0
+
+            # Troviamo i puntatori specchiati esatti per ciascuna cella di memoria
+            idx_0 = jnp.where(mask_0, idx_full, idx_full ^ stride)
+            idx_1 = idx_0 | stride
+
+            # Estrazione sicura dei coefficienti scalari complessi per evitare conflitti di broadcasting
+            g00, g01, g10, g11 = g_1q[0, 0], g_1q[0, 1], g_1q[1, 0], g_1q[1, 1]
+
+            # Calcolo simultaneo della superposizione lineare lungo i registri della CPU
+            new_sv0 = g00 * _sv[idx_0] + g01 * _sv[idx_1]
+            new_sv1 = g10 * _sv[idx_0] + g11 * _sv[idx_1]
+
+            # Ri-assemblaggio lineare continuo (Costo di allocazione scratchpad = 0)
+            return jnp.where(mask_0, new_sv0, new_sv1)
+
+        # 2-QUBIT: APPLICAZIONE LINEARE CONTROLLATA (Zero .reshape, Zero indici, Anti-OOM a 24 Qubit)
+        def do_2q(_sv):
+            ctrl = q1.astype(jnp.int64)
+            trgt = q2.astype(jnp.int64)
+
+            idx_full = jnp.arange(dim, dtype=jnp.int64)
+            ctrl_active = (idx_full & (1 << ctrl)) != 0
+            trgt_active = (idx_full & (1 << trgt)) != 0
+
+            # Caso CX: Inversione del bit target tramite operatore XOR lineare specchiato
+            cx_sv = _sv[idx_full ^ (1 << trgt)]
+            # Caso CZ: Inversione di fase condizionale sullo stato eccitato comune |11>
+            cz_sv = jnp.where(trgt_active, -_sv, _sv)
+
+            # Selezione condizionale fusa del bersaglio mutato
+            target_sv = jax.lax.cond(g_id == 20, lambda _: cx_sv, lambda _: cz_sv, operand=None)
+
+            # Restituisce il vettore modificato solo nei canali attivi, preservando intatto il resto
+            return jnp.where(ctrl_active, target_sv, _sv)
+
+        # Configurazione del tracciatore statico ed esecuzione dei rami fusi
+        exec_1q = g_id <= 11
+        new_sv = jax.lax.cond(exec_1q, do_1q, do_2q, sv)
+        return new_sv, None
+
+    @jax.jit
+    def _compile_and_run_circuit_jit(state_vector, compiled_ops):
+        """Pipeline lineare fusa in XLA tramite scansione nativa hardware"""
+        final_sv, _ = jax.lax.scan(_apply_gate_fast_step, state_vector, compiled_ops)
+        return final_sv
+
+    print("💎 CORE COMPILER SIGILLATO V4 (ULTRA): Rimossi definitivamente i reshape dinamici. Struttura JIT stabile ed esatta!")
+
+# ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+# CORE COMPILATION ENGINE (KERNEL FUSION LINEARE AD ALLOCAZIONE ZERO)
+# ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+if HAS_JAX:
+    @jax.jit
+    def _apply_gate_fast_step(sv, operation):
+        g_id, q1, q2, param = operation
+        dim = sv.shape[0]
+        inv2 = 1.0 / jnp.sqrt(2.0)
+        cos_p = jnp.cos(param / 2.0)
+        sin_p = jnp.sin(param / 2.0)
+        safe_gid = jnp.where(g_id <= 11, g_id, 0).astype(jnp.int32)
+
+        g_1q = jax.lax.switch(
+            safe_gid,
+            [
+                lambda _: jnp.eye(2, dtype=jnp.complex128),
+                lambda _: inv2 * jnp.array([[1.0, 1.0], [1.0, -1.0]], dtype=jnp.complex128),
+                lambda _: jnp.array([[0.0, 1.0], [1.0, 0.0]], dtype=jnp.complex128),
+                lambda _: jnp.array([[0.0, -1j], [1j, 0.0]], dtype=jnp.complex128),
+                lambda _: jnp.array([[1.0, 0.0], [0.0, -1.0]], dtype=jnp.complex128),
+                lambda _: jnp.array([[1.0, 0.0], [0.0, 1j]], dtype=jnp.complex128),
+                lambda _: jnp.array([[1.0, 0.0], [0.0, -1j]], dtype=jnp.complex128),
+                lambda _: jnp.array([[1.0, 0.0], [0.0, jnp.exp(1j * jnp.pi / 4)]], dtype=jnp.complex128),
+                lambda _: jnp.array([[1.0, 0.0], [0.0, jnp.exp(-1j * jnp.pi / 4)]], dtype=jnp.complex128),
+                lambda _: jnp.array([[cos_p, -1j * sin_p], [-1j * sin_p, cos_p]], dtype=jnp.complex128),
+                lambda _: jnp.array([[cos_p, -sin_p], [sin_p, cos_p]], dtype=jnp.complex128),
+                lambda _: jnp.array([[jnp.exp(-1j * param / 2.0), 0.0], [0.0, jnp.exp(1j * param / 2.0)]], dtype=jnp.complex128)
+            ],
+            operand=None
+        )
+
+        def do_1q(_sv):
+            t_bit = q1.astype(jnp.int64)
+            stride = 1 << t_bit
+            idx_full = jnp.arange(dim, dtype=jnp.int64)
+            mask_0 = (idx_full & stride) == 0
+            idx_0 = jnp.where(mask_0, idx_full, idx_full ^ stride)
+            idx_1 = idx_0 | stride
+            g00, g01, g10, g11 = g_1q[0, 0], g_1q[0, 1], g_1q[1, 0], g_1q[1, 1]
+            new_sv0 = g00 * _sv[idx_0] + g01 * _sv[idx_1]
+            new_sv1 = g10 * _sv[idx_0] + g11 * _sv[idx_1]
+            return jnp.where(mask_0, new_sv0, new_sv1)
+
+        def do_2q(_sv):
+            ctrl = q1.astype(jnp.int64)
+            trgt = q2.astype(jnp.int64)
+            idx_full = jnp.arange(dim, dtype=jnp.int64)
+            ctrl_active = (idx_full & (1 << ctrl)) != 0
+            trgt_active = (idx_full & (1 << trgt)) != 0
+            cx_sv = _sv[idx_full ^ (1 << trgt)]
+            cz_sv = jnp.where(trgt_active, -_sv, _sv)
+            target_sv = jax.lax.cond(g_id == 20, lambda _: cx_sv, lambda _: cz_sv, operand=None)
+            return jnp.where(ctrl_active, target_sv, _sv)
+
+        exec_1q = g_id <= 11
+        new_sv = jax.lax.cond(exec_1q, do_1q, do_2q, sv)
+        return new_sv, None
+
+    @jax.jit
+    def _compile_and_run_circuit_jit(state_vector, compiled_ops):
+        final_sv, _ = jax.lax.scan(_apply_gate_fast_step, state_vector, compiled_ops)
+        return final_sv
+
+    print("💎 CORE COMPILER PATCHATO V4: Struttura 1D lineare stabilizzata a norma fissa.")
+
+
+# ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+# INTERFACCIA: run_circuit_jit_beast_mode (Mappatura Riallineata V2)
+# ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+
+def run_circuit_jit_beast_mode(self, circuit: List[Tuple]):
+   
+    if not (HAS_JAX and self.xp is jnp):
+        print("⚠️ JAX non attivo o istanza non JAX. Esecuzione via run_circuit standard...")
+        return self.run_circuit(circuit, transpile=True)
+
+    # Scomposizione preliminare delle macro-porte (Toffoli, SWAP) nelle primitive compatibili
+    target = QuantumTranspiler.transpile(circuit)
+
+    compiled_list = []
+    for cmd in target:
+        g_name = cmd[0].lower()
+        args = cmd[1:]
+
+        if g_name in GATE_IDS:
+            g_id = GATE_IDS[g_name]
+
+            # Smistamento in base alla firma della porta nella nuova mappa stazionaria
+            if g_name in ['rx', 'ry', 'rz']:
+                # Struttura gate parametrico standard: (name, qubit, theta)
+                q1 = float(args[0])
+                q2 = 0.0
+                param = float(args[1])
+            elif g_name in ['cx', 'cz']:
+                # Struttura gate a due qubit standard: (name, control, target)
+                q1 = float(args[0])
+                q2 = float(args[1])
+                param = 0.0
+            else:
+                # Struttura gate fissa a un qubit standard: (name, qubit)
+                q1 = float(args[0])
+                q2 = 0.0
+                param = 0.0
+
+            compiled_list.append([float(g_id), q1, q2, param])
+
+    if not compiled_list:
+        return
+
+    # Generazione della matrice di operazioni numeriche coerente [N_porte, 4] in float64
+    compiled_ops = jnp.array(compiled_list, dtype=jnp.float64)
+
+    # Invocazione della pipeline fusa XLA ad alte prestazioni
+    self.sv = _compile_and_run_circuit_jit(self.sv, compiled_ops)
+
+
+# Iniezione dell'interfaccia corretta e ripulita nella classe del simulatore
+DenseSVSimulator.run_circuit_jit_beast_mode = run_circuit_jit_beast_mode
+print("💎 INTERFACCIA RIALLINEATA: 'run_circuit_jit_beast_mode' agganciata con successo a DenseSVSimulator!")
+
+# ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+# AGGANCIO RUNTIME MANCANTI: measure & memory_mb
+# ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+
+def measure(self, qubit_idx: int) -> int:
+    
+    if not 0 <= qubit_idx < self.n:
+        raise ValueError(f"Qubit {qubit_idx} out of bounds")
+
+    xp = self.xp
+
+    # Calcolo dell'indice fisico specchiato per la convenzione MSB
+    phys_q = self.n - 1 - qubit_idx
+    stride = 1 << phys_q
+
+    if xp is jnp:
+        # Ramo JAX: Calcolo conforme al tracciamento statico dei tensori
+        probs = self.xp.abs(self.sv)**2
+        sv_shape = [2] * self.n
+        sv_nd = probs.reshape(sv_shape)
+        prob_0 = float(jnp.sum(jnp.moveaxis(sv_nd, phys_q, 0)[0]))
+        prob_1 = float(jnp.sum(jnp.moveaxis(sv_nd, phys_q, 0)[1]))
+    else:
+        # Ramo NumPy/CuPy Ultra-Performante: Somma a salti in memoria (Zero allocazione)
+        sv_reshaped = self.sv.reshape(-1, 2, stride)
+        prob_0 = float(xp.sum(xp.abs(sv_reshaped[:, 0, :])**2))
+        prob_1 = float(xp.sum(xp.abs(sv_reshaped[:, 1, :])**2))
+
+    # Normalizzazione delle probabilità estratte
+    total = prob_0 + prob_1
+    if total > 1e-12:
+        prob_0 /= total
+        prob_1 /= total
+
+    # Campionamento dell'esito della misura
+    result = int(np.random.choice([0, 1], p=[prob_0, prob_1]))
+
+    # Collasso della funzione d'onda in-place (Zero allocazione di maschere giganti)
+    if xp is jnp:
+        sv_shape = [2] * self.n
+        sv_nd = self.sv.reshape(sv_shape)
+        moved_sv = jnp.moveaxis(sv_nd, phys_q, 0)
+        moved_sv = moved_sv.at[1 if result == 0 else 0].set(0.0)
+        self.sv = jnp.moveaxis(moved_sv, 0, phys_q).ravel()
+    else:
+        # Slicing chirurgico nativo: azzera metà del vettore direttamente sulla matrice di vista
+        sv_reshaped = self.sv.reshape(-1, 2, stride)
+        sv_reshaped[:, 1 if result == 0 else 0, :] = 0.0
+
+    self.normalize()
+    return result
+
+def memory_mb(self) -> float:
+    """Estimate RAM usage in MB"""
+    elem_size = 8 if self.dtype == np.complex64 else 16
+    return self.dim * elem_size / 1e6
+
+# Forza l'iniezione e l'ancoraggio dei due metodi nella classe principale
+DenseSVSimulator.measure = measure
+DenseSVSimulator.memory_mb = memory_mb
+
+print("🚀 Metodi 'measure' e 'memory_mb' agganciati ed iniettati con successo in DenseSVSimulator!")
+
+import random # Import the standard random module
+
+def measure(self, qubit_idx: int) -> int:
+    
+    if not 0 <= qubit_idx < self.n:
+        raise ValueError(f"Qubit {qubit_idx} out of bounds")
+
+    xp = self.xp
+    phys_q = self.n - 1 - qubit_idx
+    stride = 1 << phys_q
+
+    if xp is jnp:
+        # Ramo JAX: Calcolo esatto estraendo gli indici ffetivi dell'asse tensoriale spostato
+        probs = self.xp.abs(self.sv)**2
+        sv_shape = [2] * self.n
+        sv_nd = probs.reshape(sv_shape)
+        moved_probs = jnp.moveaxis(sv_nd, phys_q, 0)
+        prob_0 = float(jnp.sum(moved_probs[0]))
+        prob_1 = float(jnp.sum(moved_probs[1]))
+    else:
+        # Ramo NumPy/CuPy Stride Slicing
+        sv_reshaped = self.sv.reshape(-1, 2, stride)
+        prob_0 = float(xp.sum(xp.abs(sv_reshaped[:, 0, :])**2))
+        prob_1 = float(xp.sum(xp.abs(sv_reshaped[:, 1, :])**2))
+
+    total = prob_0 + prob_1
+    if total > 1e-12:
+        prob_0 /= total
+        prob_1 /= total
+
+    # Campionamento dell'esito della misura
+    result = int(np.random.choice([0, 1], p=[prob_0, prob_1]))
+
+    if xp is jnp:
+        sv_shape = [2] * self.n
+        sv_nd = self.sv.reshape(sv_shape)
+        moved_sv = jnp.moveaxis(sv_nd, phys_q, 0)
+        # FIX: Correctly zero out the unmeasured component (1 if result is 0, 0 if result is 1)
+        moved_sv = moved_sv.at[1 - result].set(0.0)
+        self.sv = jnp.moveaxis(moved_sv, 0, phys_q).ravel()
+    else:
+        sv_reshaped = self.sv.reshape(-1, 2, stride)
+        sv_reshaped[:, 1 if result == 0 else 0, :] = 0.0
+
+    self.normalize()
+    return result
+
+
+def apply_cx(self, ctrl: int, tgt: int):
+    """CNOT gate - Corregge l'allineamento degli assi fisici per JAX ed evita il double-flipping."""
+    xp = self.xp
+    if not (0 <= ctrl < self.n and 0 <= tgt < self.n and ctrl != tgt):
+        raise ValueError(f"Invalid control ({ctrl}) or target ({tgt})")
+
+    if xp is jnp:
+        # Pass logical qubit indices directly to apply_gate_2q as it handles internal mapping for JAX.
+        cx_mat = xp.array([[1,0,0,0],[0,1,0,0],[0,0,0,1],[0,0,1,0]], dtype=self.dtype)
+        self.apply_gate_2q(cx_mat, ctrl, tgt)
+    else:
+        # Ramo NumPy/CuPy Stride Slicing classico in-place
+        c_stride = 1 << (self.n - 1 - ctrl)
+        t_stride = 1 << (self.n - 1 - tgt)
+        step = 2 * max(c_stride, t_stride)
+        inner_step = 2 * min(c_stride, t_stride)
+
+        for i in range(0, self.dim, step):
+            for j in range(0, max(c_stride, t_stride), inner_step):
+                base_idx = i + j + c_stride
+                idx_0 = base_idx
+                idx_1 = base_idx + t_stride
+                tmp = self.sv[idx_0 : idx_0 + min(c_stride, t_stride)].copy()
+                self.sv[idx_0 : idx_0 + min(c_stride, t_stride)] = self.sv[idx_1 : idx_1 + min(c_stride, t_stride)]
+                self.sv[idx_1 : idx_1 + min(c_stride, t_stride)] = tmp
+
+
+def apply_cz(self, ctrl: int, tgt: int):
+    """Controlled-Z gate - Corregge l'allineamento degli assi fisici per JAX."""
+    xp = self.xp
+    if not (0 <= ctrl < self.n and 0 <= tgt < self.n and ctrl != tgt):
+        raise ValueError(f"Invalid indices ({ctrl}, {tgt})")
+
+    if xp is jnp:
+        # Pass logical qubit indices directly to apply_gate_2q as it handles internal mapping for JAX.
+        cz_mat = xp.array([[1,0,0,0],[0,1,0,0],[0,0,1,0],[0,0,0,-1]], dtype=self.dtype)
+        self.apply_gate_2q(cz_mat, ctrl, tgt)
+    else:
+        c_stride = 1 << (self.n - 1 - ctrl)
+        t_stride = 1 << (self.n - 1 - tgt)
+        step = 2 * max(c_stride, t_stride)
+        inner_step = 2 * min(c_stride, t_stride)
+
+        for i in range(0, self.dim, step):
+            for j in range(0, max(c_stride, t_stride), inner_step):
+                idx = i + j + c_stride + t_stride
+                self.sv[idx : idx + min(c_stride, t_stride)] *= -1
+
+
+# Iniezione strutturata finale
+DenseSVSimulator.measure = measure
+DenseSVSimulator.apply_cx = apply_cx
+DenseSVSimulator.apply_cz = apply_cz
+
+print("💎 ENGINE CORE RIALLINEATO PERFETTAMENTE: Tutti i canali JAX e NumPy sono stabili!")
+
+DenseSVSimulator.measure = measure
+DenseSVSimulator.apply_cx = apply_cx
+DenseSVSimulator.apply_cz = apply_cz
+
+print("💎 ENGINE CORE RIALLINEATO PERFETTAMENTE: Tutti i canali JAX e NumPy sono stabili!")
+
+import numpy as np
+
+def run_circuit_with_chunking(self, circuit: list, chunk_size: int = 500, transpile: bool = True):
+    """
+    Esegue circuiti quantistici di profondità estrema frammentandoli in sotto-blocchi.
+    Previene la saturazione della cache JIT di JAX e azzera l'overhead sui circuiti NISQ.
+    """
+    # 1. Transpilazione preliminare facoltativa delle macro-porte
+    target_circuit = QuantumTranspiler.transpile(circuit) if transpile else circuit
+    total_gates = len(target_circuit)
+
+    if total_gates <= chunk_size:
+        try:
+            self.run_circuit_jit_beast_mode(target_circuit)
+        except Exception:
+            self.run_circuit(target_circuit)
+        return
+
+    print(f"⚙️ Circuit Chunking Attivo: {total_gates} gate totali divisi in blocchi da {chunk_size}...")
+
+    # 2. Suddivisione lineare del circuito in chunk protetti
+    for i in range(0, total_gates, chunk_size):
+        chunk = target_circuit[i : i + chunk_size]
+
+        try:
+            self.run_circuit_jit_beast_mode(chunk)
+        except Exception:
+            self.run_circuit(chunk)
+
+        # Forza JAX a sincronizzare e scaricare i buffer temporanei della CPU/TPU
+        if self.xp.__name__ == 'jax.numpy':
+            self.sv.block_until_ready()
+
+    print(f"✅ Esecuzione completata con successo tramite {int(np.ceil(total_gates/chunk_size))} Chunk geometrici.")
+
+# Iniezione del metodo enterprise corretto nella classe principale
+DenseSVSimulator.run_circuit_with_chunking = run_circuit_with_chunking
+
+import jax
+import jax.numpy as jnp
+import numpy as np
+import time
+
+def run_parametric_batch_jit(self, base_circuit: list, parameter_batch: np.ndarray) -> jnp.ndarray:
+    
+    if not HAS_JAX or self.xp is not jnp:
+        raise RuntimeError("JAX deve essere il backend attivo per usare run_parametric_batch_jit.")
+
+    # Decomposizione preliminare delle macro-porte (Toffoli, SWAP) tramite il tuo Transpiler
+    target_circuit = QuantumTranspiler.transpile(base_circuit)
+
+    # Mappiamo il circuito secondo lo standard numerico della tua CELLA 8
+    compiled_list = []
+    for cmd in target_circuit:
+        g_name = cmd[0].lower()
+        args = cmd[1:]
+
+        if g_name in GATE_IDS:
+            g_id = GATE_IDS[g_name]
+            if g_name in ['rx', 'ry', 'rz', 'p']:
+                # Memorizziamo una flag numerica (-1) per identificare la posizione del parametro dinamico
+                compiled_list.append([float(g_id), float(args[0]), 0.0, -1.0])
+            elif g_name in ['cx', 'cz']:
+                compiled_list.append([float(g_id), float(args[0]), float(args[1]), 0.0])
+            else:
+                compiled_list.append([float(g_id), float(args[0]), 0.0, 0.0])
+
+    compiled_ops_template = jnp.array(compiled_list, dtype=jnp.float64)
+    n_qubits = self.n
+    dim = self.dim
+
+    # Definizione della funzione da vettorializzare per la singola istanza del batch
+    def simulate_single_instance(single_params):
+        # Inizializzazione dello stato |00...0> conforme alla tua CELLA 5
+        local_sv = jnp.zeros(dim, dtype=jnp.complex128).at[0].set(1.0)
+
+        # Ricostruiamo la matrice delle operazioni sostituendo i parametri dinamici del batch
+        # Trova dove abbiamo messo la flag -1.0 e inserisce il parametro reale
+        def patch_ops(carry, op):
+            g_id, q1, q2, p_val = op
+            param_idx = carry[0]
+
+            # Se p_val == -1.0, prendiamo il parametro corrente dal batch e incrementiamo l'indice
+            final_p = jax.lax.cond(p_val == -1.0, lambda _: single_params[param_idx], lambda _: p_val, operand=None)
+            next_idx = jax.lax.cond(p_val == -1.0, lambda _: param_idx + 1, lambda _: param_idx, operand=None)
+
+            return (next_idx,), jnp.array([g_id, q1, q2, final_p], dtype=jnp.float64)
+
+        _, patched_ops = jax.lax.scan(patch_ops, (0,), compiled_ops_template)
+
+        # Chiamata diretta al tuo motore fuso XLA nativo (Cella 7 del tuo notebook)
+        return _compile_and_run_circuit_jit(local_sv, patched_ops)
+
+    print(f"🚀 VMAP COMPILER: Parallelizzazione inter-circuito attiva per {len(parameter_batch)} istanze...")
+
+    # Applichiamo vmap sul super-grafo fuso
+    vmap_sim = jax.vmap(simulate_single_instance, in_axes=(0,))
+    jitted_vmap = jax.jit(vmap_sim)
+
+    t0 = time.perf_counter()
+    res = jitted_vmap(jnp.asarray(parameter_batch, dtype=jnp.float64))
+    res.block_until_ready()
+    print(f"✅ Batch completato in {time.perf_counter() - t0:.4f} secondi!")
+    return res
+
+# Iniettiamo il metodo nel tuo simulatore originale
+DenseSVSimulator.run_parametric_batch_jit = run_parametric_batch_jit
+print("💎 BATCH ENGINE AGGANGIATO: Pieno supporto QML & VQE attivo sul tuo core!")
+
+
+