quantum-debugger 0.9.0__tar.gz → 0.9.1__tar.gz

{quantum_debugger-0.9.0 → quantum_debugger-0.9.1}/CHANGELOG.md

@@ -5,6 +5,21 @@ All notable changes to QuantumDebugger will be documented in this file.
 The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/),
 and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
+## [0.9.1]
+
+Theme: correctness patch for the depolarizing noise channel.
+
+### Fixed
+- **`DepolarizingNoise.get_kraus_operators()`** now implements the same channel as
+  `DepolarizingNoise.apply()` and the class docstring — the Pauli-error convention
+  `ρ → (1−p)ρ + (p/3)(XρX + YρY + ZρZ)`, giving `K₀ = √(1−p)·I` and `K₁₋₃ = √(p/3)·{X, Y, Z}`.
+  It previously used a `√(p/4)` weighting (the uniform `ρ → (1−p)ρ + pI/2` convention), which
+  agrees with `apply()` only under the substitution `p → 4p/3`. Because
+  `StochasticNoiseSampler` consumes the Kraus path, Monte-Carlo–sampled depolarizing noise was
+  silently `4/3×` too strong for a given `p`. The operators remain trace-preserving
+  (`Σ Kᵢ†Kᵢ = I`). Added channel-equivalence, trace-preservation, edge-case, and sampler
+  regression tests. (Present in 0.8.0 and 0.9.0; fixed here.)
+
 ## [0.9.0]
 
 Theme: quantum chemistry, many-body physics & advanced simulation. Fermionic systems

{quantum_debugger-0.9.0 → quantum_debugger-0.9.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: quantum-debugger
-Version: 0.9.0
+Version: 0.9.1
 Summary: A quantum simulation and debugging toolkit: state-vector, Clifford/stabilizer, and density-matrix (open-systems) engines, with a broad algorithm library, error correction under noise, quantum machine learning, GPU acceleration, and multi-framework support (Qiskit, PennyLane, Cirq, TensorFlow, PyTorch).
 Home-page: https://github.com/Raunakg2005/quantum-debugger
 Author: Raunak Kumar Gupta
@@ -86,6 +86,15 @@ Dynamic: summary
 
 A powerful Python library for quantum circuit debugging, state inspection, performance analysis, and quantum machine learning. From basic circuits to QML with one-line AutoML.
 
+## What's New in v0.9.1
+
+Correctness patch: **`DepolarizingNoise.get_kraus_operators()`** now implements the same
+channel as `apply()` and the class docstring — the Pauli-error convention
+`ρ → (1−p)ρ + (p/3)(XρX + YρY + ZρZ)` (`K₀ = √(1−p)·I`, `K₁₋₃ = √(p/3)·{X, Y, Z}`). The old
+`√(p/4)` weighting made `StochasticNoiseSampler`'s Monte-Carlo depolarizing noise `4/3×` too
+strong for a given `p`. Trace preservation is unchanged; channel-equivalence and sampler
+regression tests added. See [CHANGELOG.md](CHANGELOG.md).
+
 ## What's New in v0.9.0
 
 Quantum **chemistry, many-body physics & advanced simulation** — every routine verified
@@ -490,5 +499,5 @@ If you use quantum-debugger in your research, please cite:
 
 ---
 
-**Version:** 0.9.0 (latest on PyPI) · 0.8.0, 0.7.1 (previous)  
+**Version:** 0.9.1 (latest on PyPI) · 0.9.0, 0.8.0 (previous)  
 **Last Updated:** August 2026

{quantum_debugger-0.9.0 → quantum_debugger-0.9.1}/README.md

@@ -11,6 +11,15 @@
 
 A powerful Python library for quantum circuit debugging, state inspection, performance analysis, and quantum machine learning. From basic circuits to QML with one-line AutoML.
 
+## What's New in v0.9.1
+
+Correctness patch: **`DepolarizingNoise.get_kraus_operators()`** now implements the same
+channel as `apply()` and the class docstring — the Pauli-error convention
+`ρ → (1−p)ρ + (p/3)(XρX + YρY + ZρZ)` (`K₀ = √(1−p)·I`, `K₁₋₃ = √(p/3)·{X, Y, Z}`). The old
+`√(p/4)` weighting made `StochasticNoiseSampler`'s Monte-Carlo depolarizing noise `4/3×` too
+strong for a given `p`. Trace preservation is unchanged; channel-equivalence and sampler
+regression tests added. See [CHANGELOG.md](CHANGELOG.md).
+
 ## What's New in v0.9.0
 
 Quantum **chemistry, many-body physics & advanced simulation** — every routine verified
@@ -415,5 +424,5 @@ If you use quantum-debugger in your research, please cite:
 
 ---
 
-**Version:** 0.9.0 (latest on PyPI) · 0.8.0, 0.7.1 (previous)  
+**Version:** 0.9.1 (latest on PyPI) · 0.9.0, 0.8.0 (previous)  
 **Last Updated:** August 2026

{quantum_debugger-0.9.0 → quantum_debugger-0.9.1}/quantum_debugger/__init__.py

@@ -13,7 +13,7 @@ Features:
 - Hardware profile support
 """
 
-__version__ = "0.9.0"
+__version__ = "0.9.1"
 __author__ = "Raunak Kumar Gupta"
 __license__ = "MIT"
 

{quantum_debugger-0.9.0 → quantum_debugger-0.9.1}/quantum_debugger/noise/noise_models.py

@@ -114,16 +114,29 @@ class DepolarizingNoise(NoiseModel):
         """
         Get Kraus operators for stochastic sampling
 
+        These describe the same channel as apply(), which implements the
+        Pauli-error convention this class documents:
+
+            rho -> (1 - p) rho + (p/3) (X rho X + Y rho Y + Z rho Z)
+
+        so K0 = sqrt(1 - p) I and K1..K3 = sqrt(p/3) {X, Y, Z}.
+
+        The previous sqrt(p/4) form implemented a different convention,
+        rho -> (1 - p) rho + p I/2, which coincides with the above only at
+        4p/3.  StochasticNoiseSampler consumes this method, so the mismatch
+        made sampled noise 4/3 stronger than apply() produced for the same p.
+
         Returns:
             List of Kraus operators [K0, K1, K2, K3] for depolarizing channel
         """
         p = self.probability
 
-        # Kraus operators: K0 = √(1-3p/4)I, K1 = √(p/4)X, K2 = √(p/4)Y, K3 = √(p/4)Z
-        K0 = np.sqrt(1 - 3 * p / 4) * np.eye(2, dtype=complex)
-        K1 = np.sqrt(p / 4) * np.array([[0, 1], [1, 0]], dtype=complex)  # X
-        K2 = np.sqrt(p / 4) * np.array([[0, -1j], [1j, 0]], dtype=complex)  # Y
-        K3 = np.sqrt(p / 4) * np.array([[1, 0], [0, -1]], dtype=complex)  # Z
+        # K0 = √(1-p)I, K1 = √(p/3)X, K2 = √(p/3)Y, K3 = √(p/3)Z
+        # Completeness: (1-p)I + (p/3)(X² + Y² + Z²) = (1-p)I + pI = I
+        K0 = np.sqrt(1 - p) * np.eye(2, dtype=complex)
+        K1 = np.sqrt(p / 3) * np.array([[0, 1], [1, 0]], dtype=complex)  # X
+        K2 = np.sqrt(p / 3) * np.array([[0, -1j], [1j, 0]], dtype=complex)  # Y
+        K3 = np.sqrt(p / 3) * np.array([[1, 0], [0, -1]], dtype=complex)  # Z
 
         return [K0, K1, K2, K3]
 

{quantum_debugger-0.9.0 → quantum_debugger-0.9.1}/quantum_debugger.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: quantum-debugger
-Version: 0.9.0
+Version: 0.9.1
 Summary: A quantum simulation and debugging toolkit: state-vector, Clifford/stabilizer, and density-matrix (open-systems) engines, with a broad algorithm library, error correction under noise, quantum machine learning, GPU acceleration, and multi-framework support (Qiskit, PennyLane, Cirq, TensorFlow, PyTorch).
 Home-page: https://github.com/Raunakg2005/quantum-debugger
 Author: Raunak Kumar Gupta
@@ -86,6 +86,15 @@ Dynamic: summary
 
 A powerful Python library for quantum circuit debugging, state inspection, performance analysis, and quantum machine learning. From basic circuits to QML with one-line AutoML.
 
+## What's New in v0.9.1
+
+Correctness patch: **`DepolarizingNoise.get_kraus_operators()`** now implements the same
+channel as `apply()` and the class docstring — the Pauli-error convention
+`ρ → (1−p)ρ + (p/3)(XρX + YρY + ZρZ)` (`K₀ = √(1−p)·I`, `K₁₋₃ = √(p/3)·{X, Y, Z}`). The old
+`√(p/4)` weighting made `StochasticNoiseSampler`'s Monte-Carlo depolarizing noise `4/3×` too
+strong for a given `p`. Trace preservation is unchanged; channel-equivalence and sampler
+regression tests added. See [CHANGELOG.md](CHANGELOG.md).
+
 ## What's New in v0.9.0
 
 Quantum **chemistry, many-body physics & advanced simulation** — every routine verified
@@ -490,5 +499,5 @@ If you use quantum-debugger in your research, please cite:
 
 ---
 
-**Version:** 0.9.0 (latest on PyPI) · 0.8.0, 0.7.1 (previous)  
+**Version:** 0.9.1 (latest on PyPI) · 0.9.0, 0.8.0 (previous)  
 **Last Updated:** August 2026

{quantum_debugger-0.9.0 → quantum_debugger-0.9.1}/tests/unit/test_noise.py

@@ -124,3 +124,91 @@ def test_depolarizing_noise_bell_state():
     # Trace should be 1
     trace = np.trace(rho).real
     assert np.isclose(trace, 1.0)
+
+
+def _depolarizing_via_apply(p, psi):
+    """Channel output from DepolarizingNoise.apply()."""
+    state = QuantumState(1, state_vector=psi.copy(), use_density_matrix=True)
+    DepolarizingNoise(p).apply(state, [0])
+    return np.asarray(state.density_matrix)
+
+
+def _depolarizing_via_kraus(p, psi):
+    """Channel output from DepolarizingNoise.get_kraus_operators()."""
+    rho = np.outer(psi, psi.conj())
+    return sum(K @ rho @ K.conj().T for K in DepolarizingNoise(p).get_kraus_operators())
+
+
+def _probe_states():
+    rng = np.random.default_rng(0)
+    states = [
+        np.array([1, 0], complex),
+        np.array([0, 1], complex),
+        np.array([1, 1], complex) / np.sqrt(2),
+        np.array([1, -1], complex) / np.sqrt(2),
+        np.array([1, 1j], complex) / np.sqrt(2),
+        np.array([1, -1j], complex) / np.sqrt(2),
+    ]
+    for _ in range(3):
+        v = rng.normal(size=2) + 1j * rng.normal(size=2)
+        states.append(v / np.linalg.norm(v))
+    return states
+
+
+@pytest.mark.parametrize("p", [0.0, 0.05, 0.2, 1 / 3, 0.5, 0.9, 1.0])
+def test_depolarizing_kraus_matches_apply(p):
+    """get_kraus_operators() must describe the same channel as apply().
+
+    Both are public API.  They previously used different conventions --
+    apply() the Pauli-error form and the Kraus operators the uniform form --
+    which agree only under p -> 4p/3.
+    """
+    for psi in _probe_states():
+        assert np.allclose(
+            _depolarizing_via_apply(p, psi), _depolarizing_via_kraus(p, psi), atol=1e-12
+        )
+
+
+@pytest.mark.parametrize("p", [0.0, 0.05, 1 / 3, 0.6, 1.0])
+def test_depolarizing_kraus_is_trace_preserving(p):
+    """Completeness: (1-p)I + (p/3)(X^2 + Y^2 + Z^2) = I"""
+    kraus = DepolarizingNoise(p).get_kraus_operators()
+    total = sum(K.conj().T @ K for K in kraus)
+    assert np.allclose(total, np.eye(2), atol=1e-12)
+
+
+def test_depolarizing_kraus_edge_cases():
+    """p=0 leaves the state alone; p=1 is the full Pauli twirl."""
+    psi = np.array([1, 0], complex)
+    rho = np.outer(psi, psi.conj())
+    assert np.allclose(_depolarizing_via_kraus(0.0, psi), rho, atol=1e-12)
+
+    paulis = [
+        np.array([[0, 1], [1, 0]], complex),
+        np.array([[0, -1j], [1j, 0]], complex),
+        np.array([[1, 0], [0, -1]], complex),
+    ]
+    twirl = sum(P @ rho @ P.conj().T for P in paulis) / 3
+    assert np.allclose(_depolarizing_via_kraus(1.0, psi), twirl, atol=1e-12)
+
+
+def test_stochastic_sampler_matches_apply():
+    """Sampling Kraus operators must converge to the deterministic channel."""
+    from quantum_debugger.core.quantum_state import QuantumState as PureState
+    from quantum_debugger.noise.stochastic_sampler import StochasticNoiseSampler
+
+    np.random.seed(0)
+    p, shots = 0.3, 20000
+    psi = np.array([1, 0], complex)
+    target = _depolarizing_via_apply(p, psi)
+
+    sampler = StochasticNoiseSampler(DepolarizingNoise(p))
+    accumulated = np.zeros((2, 2), complex)
+    for _ in range(shots):
+        state = PureState(1, state_vector=psi.copy())
+        sampler.apply_stochastic_noise(state, None)
+        v = np.asarray(state.state_vector).reshape(-1)
+        accumulated += np.outer(v, v.conj())
+
+    # 3 sigma over 20k shots is about 0.01
+    assert np.abs(target - accumulated / shots).max() < 0.015