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

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

@@ -5,6 +5,202 @@ 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
+(Jordan-Wigner, Fermi-Hubbard, the Kitaev topological chain), ground- and
+excited-state solvers (chemistry-via-VQE with Pauli decomposition, imaginary-time
+cooling, Krylov/Lanczos, adiabatic evolution), finite-temperature physics (Gibbs
+states & thermodynamics), quantum dynamics (Trotter error scaling, Loschmidt echo &
+DQPTs, out-of-time-order correlators, entanglement growth), quantum chaos (level-
+spacing statistics), metrology (spin squeezing, mixed-state QFI), and the modern
+measurement/tensor-network toolkit (classical shadows, Schmidt decomposition & the
+area law). Every routine verified against a closed form or an independent
+computation. (Open systems, noise, and fault tolerance landed in 0.8.0.)
+
+### Added
+- **SSH topological insulator** (`algorithms.ssh_hamiltonian`) — the Su-Schrieffer-Heeger
+  chain with alternating hoppings `v, w`, the textbook 1D topological insulator; the
+  single-particle Hamiltonian is exactly diagonalized and verified to have a
+  chiral-symmetric spectrum.
+- **SSH winding number** (`algorithms.ssh_winding_number`) — the bulk `Z` invariant of the
+  chiral class BDI: `1` (topological) when `|w| > |v|`, `0` (trivial) otherwise.
+- **SSH edge modes** (`algorithms.ssh_zero_modes`, `ssh_edge_polarization`) — the
+  bulk-boundary correspondence made concrete: `2` protected zero-energy modes localized on
+  the ends in the topological phase, `0` in the trivial phase, verified against the exact
+  spectrum and eigenvectors.
+- **Ground-state fidelity** (`algorithms.ground_state_fidelity`) — the overlap
+  `|<psi(lambda)|psi(lambda+dlambda)>|` between neighbouring ground states, near 1 inside a
+  phase and dipping sharply at a quantum phase transition.
+- **Fidelity susceptibility** (`algorithms.fidelity_susceptibility`, `tfim_critical_field`)
+  — the intensive response `chi_F = 2(1-F)/dlambda^2` that peaks at a critical point;
+  verified to locate the transverse-field Ising transition, its finite-size peak drifting
+  toward the exact `h_c = 1` as the system grows.
+- **Connected correlation functions** (`algorithms.connected_correlation`) —
+  `<O_i O_j> - <O_i><O_j>`, the probe of correlations beyond mean field; verified `1` on a
+  GHZ state and `0` on a product state.
+- **Correlation length** (`algorithms.correlation_length`) — `xi` from the exponential
+  decay of the connected correlator; verified `0` for a product state and growing toward
+  criticality for the TFIM ground state.
+- **Static structure factor** (`algorithms.structure_factor`) — `S(k)` from the spatial
+  correlations, the Fourier probe of order; verified to Bragg-peak at `k=0` for a
+  ferromagnet and `k=pi` for an antiferromagnet.
+- **Entanglement negativity** (`algorithms.negativity`, `logarithmic_negativity`) — the
+  computable mixed-state entanglement measure from the partial transpose; verified
+  `E_N = 1` for a Bell pair, `0` for a product state.
+- **Peres-Horodecki (PPT) criterion** (`algorithms.partial_transpose`, `is_entangled_ppt`)
+  — the partial transpose and its negative-eigenvalue entanglement witness; verified to
+  reproduce the Werner-state entanglement threshold `p > 1/3`.
+- **Schmidt decomposition & the area law** (`algorithms.schmidt_decomposition`,
+  `truncation_fidelity`, `area_law_compressibility`) — the tensor-network bridge:
+  write any bipartite pure state as `sum lambda_i |i>_A|i>_B` via SVD. Verified that a
+  Bell pair gives two equal Schmidt values (1 bit), a product state rank 1, the values
+  are normalized and descending, and the Schmidt entropy matches the density-matrix
+  entanglement entropy exactly. The headline result: a gapped 1D ground state (TFIM)
+  keeps > 99% of its weight in a handful of Schmidt values (area law → compressible to
+  a low-bond-dimension MPS), while a random volume-law state has a flat spectrum that
+  refuses to compress — exactly why matrix product states work.
+- **Classical shadows** (`algorithms.collect_shadows`, `estimate_observable`,
+  `shadow_estimates`) — estimate many observables from few measurements
+  (Huang-Kueng-Preskill): measure each qubit in a random Pauli basis, build the
+  unbiased single-shot snapshot `prod_q (3|b_q><b_q| - I)`, and read off `<O> =
+  Tr(O rho_hat)` for *any* observable from the *same* dataset. Verified: Bell-pair
+  correlators (`<XX>=1`, `<YY>=-1`, `<ZZ>=1`, `<ZI>=0`) all recovered from one
+  collection, the error shrinks with shot count, `<I...I>=1` exactly per snapshot, and
+  a shadow set is reusable across observables — the cost set by observable locality,
+  not Hilbert-space dimension.
+- **Spin squeezing (one-axis twisting)** (`algorithms.one_axis_twisting`,
+  `best_squeezing`) — metrologically useful entanglement that beats the standard
+  quantum limit. Evolving a coherent spin state under `H = chi J_z^2` (Kitagawa-Ueda)
+  redistributes the transverse noise; the Wineland parameter `xi^2 = N min Var(J_perp)
+  / |<J>|^2` (minimum variance computed in closed form from the 2x2 covariance matrix)
+  drops below 1. Verified: `xi^2 = 1` exactly at zero twisting (the SQL), squeezing
+  reaches -2.9 to -4.5 dB, improves with atom number, and `1/xi^2` gives the
+  phase-sensitivity gain — the interferometric payoff of the entanglement.
+- **Kitaev chain (topological superconductor)** (`algorithms.kitaev_chain_hamiltonian`,
+  `kitaev_ground_degeneracy`) — the simplest model with Majorana edge modes, built on
+  the Jordan-Wigner operators: `-mu sum n_j - t sum hopping + Delta sum pairing`.
+  Verified the topological hallmarks — for `|mu| < 2t` the ground state is doubly
+  degenerate (splitting < 1e-9 at `mu = 0`) with the bulk gap staying open, while for
+  `|mu| > 2t` it is unique and gapped; the topological flag flips exactly at the
+  `|mu| = 2t` transition; fermion parity is conserved; and the ground-state splitting
+  decays *exponentially* with chain length (halving per site) — the localization of
+  the two Majorana modes at the chain ends, the nonlocal storage behind topological
+  qubits.
+- **Level-spacing statistics (quantum chaos)** (`algorithms.level_spacing_ratio`,
+  `goe_reference`, `poisson_reference`, `classify_spectrum`) — the symmetry-free
+  Oganesyan-Huse gap-ratio `<r>` that distinguishes integrable from chaotic spectra
+  without unfolding. Validated against both defining ensembles: Gaussian Orthogonal
+  Ensemble spectra give `<r> ~ 0.531` (Wigner-Dyson level repulsion) and uncorrelated
+  Poisson spectra give `~ 0.386`, with a rigid equally-spaced spectrum giving exactly
+  1. `classify_spectrum` labels a spectrum against these universal values.
+  Honestly documented: physical Hamiltonians only show the clean values within a
+  single symmetry sector (mixed sectors bias toward Poisson).
+- **Entanglement growth after a quench** (`algorithms.entanglement_growth`) — how
+  isolated systems thermalize: start in a product state, evolve under an entangling
+  Hamiltonian, and watch a subregion's entanglement entropy grow and saturate near
+  the volume-law value. Verified against the analytic two-qubit case (an `X x X`
+  quench of `|00>` gives exactly the binary entropy `h(sin^2(gt))`, reaching 1 bit at
+  a quarter period), and for larger TFIM/Heisenberg quenches the entropy starts at 0,
+  grows, saturates below its `min(|A|, n-|A|)` bound, and stays static for an energy
+  eigenstate.
+- **Out-of-time-order correlators (scrambling)** (`algorithms.otoc`,
+  `scrambling_time`) — the butterfly effect of quantum chaos: the growth of
+  `C(t) = <|[W(t), V]|^2>` as a local operator spreads across the lattice. Verified
+  the exact structure — `C(0) = 0` for spatially-separated operators (they commute),
+  `C(0) = 4` for anticommuting same-site operators, `C(t) >= 0` always, and the exact
+  identity `C(t) = 2(1 - Re F(t))` with the OTOC `F(0) = 1`. `scrambling_time` tracks
+  a perturbation from one edge to the other and finds when it arrives — the far qubit
+  lagging the near one, the operator light cone made quantitative.
+- **Loschmidt echo & dynamical quantum phase transitions**
+  (`algorithms.loschmidt_echo`, `rate_function`, `quench_dynamics`) — quench a state
+  under a Hamiltonian and track `L(t) = |<psi_0|e^{-iHt}|psi_0>|^2` and its rate
+  function `-ln L / N`, whose non-analytic cusps mark DQPTs. Verified: an eigenstate
+  never dephases (`L = 1`), a two-level superposition reproduces the analytic
+  `1 - sin^2(2θ) sin^2(Δt/2)` exactly, the rate function peaks precisely where the
+  echo dips, and at `θ = π/4` the echo hits zero — a genuine dynamical phase
+  transition where the evolved state becomes orthogonal to the start.
+- **Krylov subspace diagonalization (Lanczos)** (`algorithms.krylov_spectrum`,
+  `krylov_ground_energy`) — build a small subspace `span{|psi>, H|psi>, ...,
+  H^{m-1}|psi>}` and diagonalize `H` inside it. The Ritz values converge to the exact
+  extreme eigenvalues — ground energy to machine precision by `m = 8` on TFIM
+  (Fermi-Hubbard, Heisenberg too), and, unlike imaginary-time evolution, the lowest
+  Ritz values recover the low-lying *excited* states as well. Solved through a
+  thresholded generalized eigenproblem for stability against the near-parallel Krylov
+  vectors; Ritz values are provably bracketed by the exact spectrum.
+- **Adiabatic quantum computation** (`algorithms.adiabatic_evolution`) — the
+  alternative computing paradigm: start in the easy ground state of a driver
+  Hamiltonian and slowly interpolate `H(s) = (1-s)H_i + s H_f` to the problem
+  Hamiltonian, ending in *its* ground state. Verified across both regimes of the
+  adiabatic theorem: a slow sweep (T=50) reaches the target ground state at fidelity
+  > 0.99, a fast one (T=0.5) is left excited at < 0.5 (diabatic transition), fidelity
+  is monotone in the total time, and the minimum spectral gap along the path is
+  tracked — the quantity that sets how slow "slow enough" must be.
+- **Trotter error scaling** (`algorithms.trotter_unitary`,
+  `trotter_error_scaling`) — assemble the full Trotterized evolution operator and
+  measure how its error `|| U_trotter - exp(-iHt) ||` shrinks with the step count.
+  Verified against the theoretical rates: the first-order formula converges as
+  `~ t^2/n` (measured log-log slope -1.03) and the symmetric second-order Suzuki
+  formula as `~ t^3/n^2` (slope -2.02) on TFIM and Heisenberg Hamiltonians, with
+  second order strictly beating first at fixed step count — quantifying the accuracy
+  of Hamiltonian-simulation circuits.
+- **Imaginary-time evolution** (`algorithms.imaginary_time_evolution`) — cool any
+  state to a Hamiltonian's ground state via normalized `e^{-tau H}`, the engine
+  behind QITE and projector Monte Carlo — no optimizer, no local minima. Verified to
+  converge to the exact ground energy (Fermi-Hubbard, TFIM, Heisenberg) with the
+  energy decreasing monotonically and the converged state a true ground eigenstate.
+  Honestly bounded: because the ground component decays slowest, even a start made
+  orthogonal to the ground state still cools *to* it (its ~1e-16 residual overlap is
+  re-amplified) — so plain ITE targets the ground state, never an excited level.
+- **Gibbs states & quantum thermodynamics** (`algorithms.gibbs_state`,
+  `partition_function`, `thermal_properties`) — finite-temperature physics of any
+  Hamiltonian: `rho(beta) = e^{-beta H}/Z` and its thermodynamic potentials. Verified
+  the full set of identities — `beta -> 0` gives the maximally mixed `I/d` (entropy
+  `ln d`), `beta -> infinity` projects onto the ground state (entropy 0), the
+  Helmholtz free energy satisfies `F = -ln Z / beta = E - S/beta` exactly, entropy is
+  monotone in temperature, heat capacity is non-negative, and a single spin
+  reproduces the analytic `<H> = -tanh(beta)`, `Z = 2 cosh(beta)`. Applied to the
+  Fermi-Hubbard Hamiltonian, this gives its thermal state directly.
+- **Pauli decomposition + chemistry-via-VQE**
+  (`algorithms.pauli_decompose`) — decompose any Hermitian matrix into weighted
+  Pauli strings (`c_P = Tr(P H)/2^n`), the step that turns a dense molecular or
+  Fermi-Hubbard Hamiltonian into something a gate-based algorithm can run. Verified
+  to round-trip random Hermitian operators exactly and to preserve the full
+  spectrum; feeding the decomposed Fermi-Hubbard dimer (and a hopping chain) to the
+  existing VQE solver recovers the exact ground energy to ~1e-11 — the complete
+  fermion → qubit → variational-ground-state pipeline.
+- **Fermi-Hubbard model** (`algorithms.fermi_hubbard_hamiltonian`,
+  `hubbard_ground_energy`, `hubbard_dimer_energy`) — interacting electrons on a
+  lattice, built on the Jordan-Wigner operators: hopping `t` vs on-site repulsion
+  `U`, two spin-orbitals per site. Verified: the Hamiltonian conserves total and
+  per-spin particle number, and the exactly-solvable half-filled two-site dimer
+  reproduces the analytic ground energy `(U - sqrt(U^2 + 16t^2))/2` at every `U`,
+  interpolating from the non-interacting `-2t` (`U = 0`) to the Heisenberg
+  antiferromagnet `-4t^2/U` (large `U`) — the Mott physics in miniature.
+- **Jordan-Wigner transformation** (`algorithms.jw_annihilation`, `jw_creation`,
+  `jw_number`, `jw_total_number`, `hopping_hamiltonian`, `anticommutation_error`) —
+  the bridge from fermions to qubits that makes quantum chemistry simulable. Mode
+  `j` maps to `(prod_{k<j} Z_k) sigma_j^-`; verified that the operators satisfy the
+  fermionic algebra `{a_i, a_j} = 0`, `{a_i, a_j^dagger} = delta_ij` exactly, that
+  number operators are {0,1} projectors, that `(a^dagger)^2 = 0` (Pauli exclusion),
+  and that the tight-binding hopping Hamiltonian reproduces the exact band
+  `-2t cos(k)` (open chain and ring) while conserving particle number.
+
 ## [0.8.0]
 
 Theme: a comprehensive quantum-information-theory layer on the two simulation

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: quantum-debugger
-Version: 0.8.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,31 +86,33 @@ 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.8.0
+## What's New in v0.9.1
 
-A comprehensive **quantum-information-theory layer** on both simulation engines —
-every routine verified against a closed form or an independent computation:
+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).
 
-- **Density-matrix simulator** (`DensityMatrix`) — open quantum systems with Kraus
-  channels, Lindblad master-equation evolution, channel metrics (process / average
-  gate fidelity, Choi matrix, CPTP checks), **Stinespring dilation**, and **quantum
-  process tomography**.
-- **Fault tolerance & QEC** — the 5-qubit `[[5,1,3]]` perfect code, Steane `[[7,1,3]]`
-  with transversal gates, the `[[4,2,2]]` error-detecting code, magic-state injection,
-  the **Petz recovery map** for approximate QEC, and QEC run against continuous
-  (density-matrix) noise with CPTP syndrome recovery.
-- **Quantum networking** — BBPSSW / DEJMPS entanglement distillation, noisy
-  entanglement swapping, and repeater chains.
-- **Noise protection without QEC** — decoherence-free subspaces, spin echo, and the
-  quantum Zeno effect.
-- **Foundations & resource measures** — negativity, concurrence, discord, mutual
-  information, Horodecki nonlocality, contextuality (Mermin-Peres), geometric
-  (Pancharatnam-Berry) phase, uncertainty relations, weak values, Holevo bound,
-  channel capacity, state discrimination, no-cloning, stabilizer-Rényi magic, and
-  measurement-based computation.
-- **Clifford engine** — stabilizer entanglement entropy straight from the tableau
-  (`O(n^3)`, works on hundreds of qubits), plus a quantum multiplier and a
-  ripple-carry subtractor.
+## What's New in v0.9.0
+
+Quantum **chemistry, many-body physics & advanced simulation** — every routine verified
+against a closed form or an independent computation:
+
+- **Fermionic systems** — Jordan-Wigner transform, the Fermi-Hubbard model, and the
+  Kitaev topological chain (Majorana edge modes).
+- **Ground- & excited-state solvers** — chemistry via VQE with Pauli decomposition,
+  imaginary-time cooling, Krylov/Lanczos, and adiabatic evolution.
+- **Finite-temperature physics** — Gibbs states and thermodynamic quantities.
+- **Quantum dynamics** — Trotter error scaling, the Loschmidt echo & dynamical quantum
+  phase transitions, out-of-time-order correlators (scrambling), and entanglement growth.
+- **Quantum chaos** — level-spacing statistics (GOE vs Poisson).
+- **Metrology** — spin squeezing and mixed-state quantum Fisher information.
+- **Modern measurement & tensor-network toolkit** — classical shadows, Schmidt
+  decomposition, and the area law.
+
+(Open systems, noise, and fault tolerance shipped in v0.8.0.)
 
 See [CHANGELOG.md](CHANGELOG.md) for the full, itemized list.
 
@@ -128,7 +130,7 @@ A **second simulation engine** plus a large, verified quantum-algorithms library
 - **VQE** ground-state solver converges to machine precision on larger chains
   (BFGS optimizer).
 
-### Density-matrix engine (v0.8.0)
+### v0.8.0 — density-matrix engine & open systems
 - **Density-matrix simulator** (`DensityMatrix`) — open quantum systems with Kraus
   channels, Lindblad master-equation evolution, and channel metrics (process /
   average gate fidelity, Choi matrix, CPTP checks).
@@ -497,5 +499,5 @@ If you use quantum-debugger in your research, please cite:
 
 ---
 
-**Version:** 0.8.0 (latest on PyPI) · 0.7.1, 0.7.0 (previous)  
+**Version:** 0.9.1 (latest on PyPI) · 0.9.0, 0.8.0 (previous)  
 **Last Updated:** August 2026

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

@@ -11,31 +11,33 @@
 
 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.8.0
-
-A comprehensive **quantum-information-theory layer** on both simulation engines —
-every routine verified against a closed form or an independent computation:
-
-- **Density-matrix simulator** (`DensityMatrix`) — open quantum systems with Kraus
-  channels, Lindblad master-equation evolution, channel metrics (process / average
-  gate fidelity, Choi matrix, CPTP checks), **Stinespring dilation**, and **quantum
-  process tomography**.
-- **Fault tolerance & QEC** — the 5-qubit `[[5,1,3]]` perfect code, Steane `[[7,1,3]]`
-  with transversal gates, the `[[4,2,2]]` error-detecting code, magic-state injection,
-  the **Petz recovery map** for approximate QEC, and QEC run against continuous
-  (density-matrix) noise with CPTP syndrome recovery.
-- **Quantum networking** — BBPSSW / DEJMPS entanglement distillation, noisy
-  entanglement swapping, and repeater chains.
-- **Noise protection without QEC** — decoherence-free subspaces, spin echo, and the
-  quantum Zeno effect.
-- **Foundations & resource measures** — negativity, concurrence, discord, mutual
-  information, Horodecki nonlocality, contextuality (Mermin-Peres), geometric
-  (Pancharatnam-Berry) phase, uncertainty relations, weak values, Holevo bound,
-  channel capacity, state discrimination, no-cloning, stabilizer-Rényi magic, and
-  measurement-based computation.
-- **Clifford engine** — stabilizer entanglement entropy straight from the tableau
-  (`O(n^3)`, works on hundreds of qubits), plus a quantum multiplier and a
-  ripple-carry subtractor.
+## 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
+against a closed form or an independent computation:
+
+- **Fermionic systems** — Jordan-Wigner transform, the Fermi-Hubbard model, and the
+  Kitaev topological chain (Majorana edge modes).
+- **Ground- & excited-state solvers** — chemistry via VQE with Pauli decomposition,
+  imaginary-time cooling, Krylov/Lanczos, and adiabatic evolution.
+- **Finite-temperature physics** — Gibbs states and thermodynamic quantities.
+- **Quantum dynamics** — Trotter error scaling, the Loschmidt echo & dynamical quantum
+  phase transitions, out-of-time-order correlators (scrambling), and entanglement growth.
+- **Quantum chaos** — level-spacing statistics (GOE vs Poisson).
+- **Metrology** — spin squeezing and mixed-state quantum Fisher information.
+- **Modern measurement & tensor-network toolkit** — classical shadows, Schmidt
+  decomposition, and the area law.
+
+(Open systems, noise, and fault tolerance shipped in v0.8.0.)
 
 See [CHANGELOG.md](CHANGELOG.md) for the full, itemized list.
 
@@ -53,7 +55,7 @@ A **second simulation engine** plus a large, verified quantum-algorithms library
 - **VQE** ground-state solver converges to machine precision on larger chains
   (BFGS optimizer).
 
-### Density-matrix engine (v0.8.0)
+### v0.8.0 — density-matrix engine & open systems
 - **Density-matrix simulator** (`DensityMatrix`) — open quantum systems with Kraus
   channels, Lindblad master-equation evolution, and channel metrics (process /
   average gate fidelity, Choi matrix, CPTP checks).
@@ -422,5 +424,5 @@ If you use quantum-debugger in your research, please cite:
 
 ---
 
-**Version:** 0.8.0 (latest on PyPI) · 0.7.1, 0.7.0 (previous)  
+**Version:** 0.9.1 (latest on PyPI) · 0.9.0, 0.8.0 (previous)  
 **Last Updated:** August 2026

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

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

{quantum_debugger-0.8.0 → quantum_debugger-0.9.1}/quantum_debugger/algorithms/__init__.py

@@ -52,6 +52,9 @@ from .hamiltonian_simulation import (
     trotter_circuit,
     hamiltonian_matrix,
     pauli_term_matrix,
+    pauli_decompose,
+    trotter_unitary,
+    trotter_error_scaling,
 )
 from .decomposition import (
     zyz_decompose,
@@ -163,6 +166,71 @@ from .error_detection import (
 from .mbqc import cluster_pair, mbqc_rotation
 from .weak_values import weak_value, weak_measurement_shift, weak_value_demo
 from .petz import petz_recovery, petz_code_recovery
+from .jordan_wigner import (
+    jw_annihilation,
+    jw_creation,
+    jw_number,
+    jw_total_number,
+    hopping_hamiltonian,
+    anticommutation_error,
+)
+from .hubbard import (
+    fermi_hubbard_hamiltonian,
+    hubbard_ground_energy,
+    hubbard_dimer_energy,
+)
+from .thermal import (
+    gibbs_state,
+    partition_function,
+    thermal_properties,
+)
+from .imaginary_time import imaginary_time_evolution
+from .adiabatic import adiabatic_evolution
+from .krylov import krylov_spectrum, krylov_ground_energy
+from .loschmidt import loschmidt_echo, rate_function, quench_dynamics
+from .otoc import otoc, scrambling_time
+from .entanglement_growth import entanglement_growth
+from .level_statistics import (
+    level_spacing_ratio,
+    goe_reference,
+    poisson_reference,
+    classify_spectrum,
+)
+from .kitaev_chain import kitaev_chain_hamiltonian, kitaev_ground_degeneracy
+from .spin_squeezing import one_axis_twisting, best_squeezing
+from .classical_shadows import (
+    collect_shadows,
+    estimate_observable,
+    shadow_estimates,
+)
+from .schmidt import (
+    schmidt_decomposition,
+    truncation_fidelity,
+    area_law_compressibility,
+)
+from .ssh_model import (
+    ssh_hamiltonian,
+    ssh_winding_number,
+    ssh_zero_modes,
+    ssh_edge_polarization,
+)
+from .quantum_phase_transition import (
+    ground_state_fidelity,
+    fidelity_susceptibility,
+    tfim_critical_field,
+)
+from .many_body_correlations import (
+    connected_correlation,
+    correlation_length,
+    structure_factor,
+    expectation,
+)
+from .entanglement_negativity import (
+    partial_transpose,
+    negativity,
+    logarithmic_negativity,
+    is_entangled_ppt,
+)
 from .spectroscopy import unitary_eigenphase, hermitian_eigenvalue
 
 __all__ = [
@@ -213,6 +281,9 @@ __all__ = [
     "trotter_circuit",
     "hamiltonian_matrix",
     "pauli_term_matrix",
+    "pauli_decompose",
+    "trotter_unitary",
+    "trotter_error_scaling",
     # Gate decomposition
     "zyz_decompose",
     "abc_decomposition",
@@ -333,6 +404,61 @@ __all__ = [
     "weak_value_demo",
     "petz_recovery",
     "petz_code_recovery",
+    "jw_annihilation",
+    "jw_creation",
+    "jw_number",
+    "jw_total_number",
+    "hopping_hamiltonian",
+    "anticommutation_error",
+    "fermi_hubbard_hamiltonian",
+    "hubbard_ground_energy",
+    "hubbard_dimer_energy",
+    "gibbs_state",
+    "partition_function",
+    "thermal_properties",
+    "imaginary_time_evolution",
+    "adiabatic_evolution",
+    "krylov_spectrum",
+    "krylov_ground_energy",
+    "loschmidt_echo",
+    "rate_function",
+    "quench_dynamics",
+    "otoc",
+    "scrambling_time",
+    "entanglement_growth",
+    "level_spacing_ratio",
+    "goe_reference",
+    "poisson_reference",
+    "classify_spectrum",
+    "kitaev_chain_hamiltonian",
+    "kitaev_ground_degeneracy",
+    "one_axis_twisting",
+    "best_squeezing",
+    "collect_shadows",
+    "estimate_observable",
+    "shadow_estimates",
+    "schmidt_decomposition",
+    "truncation_fidelity",
+    "area_law_compressibility",
+    # SSH topological insulator
+    "ssh_hamiltonian",
+    "ssh_winding_number",
+    "ssh_zero_modes",
+    "ssh_edge_polarization",
+    # Quantum phase transitions (fidelity)
+    "ground_state_fidelity",
+    "fidelity_susceptibility",
+    "tfim_critical_field",
+    # Many-body correlations
+    "connected_correlation",
+    "correlation_length",
+    "structure_factor",
+    "expectation",
+    # Entanglement negativity
+    "partial_transpose",
+    "negativity",
+    "logarithmic_negativity",
+    "is_entangled_ppt",
     # Quantum spectroscopy
     "unitary_eigenphase",
     "hermitian_eigenvalue",

quantum_debugger-0.9.1/quantum_debugger/algorithms/adiabatic.py

@@ -0,0 +1,66 @@
+"""
+Adiabatic quantum computation & the adiabatic theorem
+
+An alternative to the circuit model: encode the answer in the ground state of a
+"problem" Hamiltonian ``H_final``, start in the easily-prepared ground state of a
+"driver" ``H_initial``, and slowly interpolate
+
+    H(s) = (1 - s) H_initial + s H_final,      s = t / T,   0 -> 1.
+
+The adiabatic theorem guarantees the system stays in the instantaneous ground state
+-- ending in the ground state of ``H_final`` -- provided the total time ``T`` is large
+compared to the inverse square of the minimum spectral gap along the path. Run too
+fast and the system is excited (a diabatic transition). This module evolves the state
+under the time-dependent Hamiltonian and measures the final ground-state fidelity,
+verifying both regimes.
+"""
+
+import numpy as np
+from scipy.linalg import expm
+
+
+def _ground_state(H):
+    _, vecs = np.linalg.eigh(H)
+    return vecs[:, 0].astype(complex)
+
+
+def adiabatic_evolution(
+    h_initial, h_final, total_time: float, steps: int = None
+) -> dict:
+    """
+    Prepare the ground state of ``h_initial``, sweep ``H(s) = (1-s) H_i + s H_f`` over
+    total time ``total_time``, and return how well the result matches the ground state
+    of ``h_final``.
+
+    ``steps`` defaults to ``max(50, 30 * total_time)`` (enough for the piecewise-constant
+    integrator to be accurate). Returns dict with:
+      * ``fidelity``        -- overlap-squared of the final state with the target ground state
+      * ``final_energy``    -- ``<H_final>`` of the final state
+      * ``target_energy``   -- exact ground energy of ``h_final``
+      * ``min_gap``         -- the minimum spectral gap of ``H(s)`` along the path
+      * ``adiabatic``       -- whether the run stayed near the ground state (fidelity > 0.9)
+    """
+    H_i = np.asarray(h_initial, dtype=complex)
+    H_f = np.asarray(h_final, dtype=complex)
+    if steps is None:
+        steps = max(50, int(30 * total_time))
+
+    psi = _ground_state(H_i)
+    dt = total_time / steps
+    min_gap = np.inf
+    for k in range(steps):
+        s = (k + 0.5) / steps
+        H_s = (1 - s) * H_i + s * H_f
+        ev = np.linalg.eigvalsh(H_s).real
+        min_gap = min(min_gap, ev[1] - ev[0])
+        psi = expm(-1j * H_s * dt) @ psi
+
+    target = _ground_state(H_f)
+    fidelity = float(abs(np.vdot(target, psi)) ** 2)
+    return {
+        "fidelity": fidelity,
+        "final_energy": float(np.real(psi.conj() @ H_f @ psi)),
+        "target_energy": float(np.linalg.eigvalsh(H_f).real.min()),
+        "min_gap": float(min_gap),
+        "adiabatic": fidelity > 0.9,
+    }

{quantum_debugger-0.8.0 → quantum_debugger-0.9.1}/quantum_debugger/algorithms/channel_capacity.py

@@ -82,8 +82,9 @@ def amplitude_damping_capacity(gamma: float) -> dict:
     def neg_ic(p):
         return -coherent_information(kraus, np.diag([1 - p, p]).astype(complex))
 
-    res = minimize_scalar(neg_ic, bounds=(1e-9, 1 - 1e-9), method="bounded",
-                          options={"xatol": 1e-10})
+    res = minimize_scalar(
+        neg_ic, bounds=(1e-9, 1 - 1e-9), method="bounded", options={"xatol": 1e-10}
+    )
     p_star = float(res.x)
     ic = -float(res.fun)
     capacity = max(0.0, ic)