ultraqse 1.0.0__py3-none-any.whl

qse/__init__.py

@@ -0,0 +1,74 @@
+"""
+QSE Framework — Von Neumann Entropy via Walsh-Hadamard transforms over GF(2).
+
+Quick start::
+
+    from qse import t14_Pb, vne_from_Pb, f2_rank
+
+    thetas = [0.8, 1.2]          # Rx rotation angles for A-qubits
+    pairs  = [(0, 0), (1, 0)]    # CNOT(ctrl=0,tgt=B0), CNOT(ctrl=1,tgt=B0)
+    NA, NB = 2, 1
+
+    Pb, _  = t14_Pb(thetas, pairs, NA, NB)
+    vne    = vne_from_Pb(Pb)
+
+Submodules:
+  core            — phi_dict, t14_Pb, t_universal, vne_from_Pb, renyi_entropy,
+                    f2_rank, t22_moment, newton_girard, build_M
+  states          — product_state, product_state_ry, exact_rho_B,
+                    exact_rho_B_mixed, vne_exact
+  gates           — apply_cnot, apply_fsim, apply_swap
+  gradients       — vne_gradient_rx
+  noise           — amplitude_damping_kraus, superop, noise_transfer_Pb,
+                    build_cnot_ad_transfer
+  random_circuits — gaussian_binom_2, expected_gf2_rank, enumerate_vne
+"""
+
+__version__ = "1.0.0"
+
+from qse.core import (
+    build_M,
+    phi_dict,
+    t14_Pb,
+    t_universal,
+    vne_from_Pb,
+    renyi_entropy,
+    f2_rank,
+    t22_moment,
+    newton_girard,
+)
+from qse.states import (
+    product_state,
+    product_state_ry,
+    exact_rho_B,
+    exact_rho_B_mixed,
+    vne_exact,
+)
+from qse.gates import apply_cnot, apply_fsim, apply_swap
+from qse.gradients import vne_gradient_rx
+from qse.noise import (
+    amplitude_damping_kraus,
+    superop,
+    noise_transfer_Pb,
+    build_cnot_ad_transfer,
+)
+from qse.random_circuits import gaussian_binom_2, expected_gf2_rank, enumerate_vne
+
+__all__ = [
+    # core
+    "build_M", "phi_dict", "t14_Pb", "t_universal",
+    "vne_from_Pb", "renyi_entropy", "f2_rank",
+    "t22_moment", "newton_girard",
+    # states
+    "product_state", "product_state_ry",
+    "exact_rho_B", "exact_rho_B_mixed", "vne_exact",
+    # gates
+    "apply_cnot", "apply_fsim", "apply_swap",
+    # gradients
+    "vne_gradient_rx",
+    # noise
+    "amplitude_damping_kraus", "superop", "noise_transfer_Pb",
+    "build_cnot_ad_transfer",
+    # random_circuits
+    "gaussian_binom_2", "expected_gf2_rank", "enumerate_vne",
+]

qse/core.py

@@ -0,0 +1,217 @@
+"""
+qse/core.py — Core QSE computations: WHT formula, GF(2) algebra, entropy.
+
+Key formulas:
+  T14:        P_b = (1/2^NB) sum_s (-1)^{b·s} Phi_M(s)
+  T-UNIVERSAL: P_b = sum_{x: Mx=b} rho_A[x,x]
+  VNE:        H(P) = -sum_b P_b log2(P_b)
+"""
+
+import numpy as np
+from math import cos, log2, sin
+
+# ── Building blocks ───────────────────────────────────────────────────────────
+
+def build_M(pairs, NA, NB):
+    """Build GF(2) connectivity matrix M ∈ F2^{NB×NA} from CNOT pairs.
+
+    pairs: list of (a, b) meaning CNOT(ctrl=a, tgt=b), a ∈ [0,NA), b ∈ [0,NB).
+    XOR for repeated pairs (mod-2 cancellation).
+    """
+    M = np.zeros((NB, NA), dtype=int)
+    for a, b in pairs:
+        M[b][a] ^= 1
+    return M
+
+
+def phi_dict(thetas, pairs, NA, NB):
+    """Phi_M(s) = prod_{i: (M^T s)_i = 1} cos(theta_i) for all s ∈ {0..2^NB-1}.
+
+    Returns: (phi dict {s: float}, M matrix)
+    """
+    M = build_M(pairs, NA, NB)
+    cos_t = [cos(t) for t in thetas]
+    phi = {}
+    for s in range(2**NB):
+        sv = np.array([(s >> j) & 1 for j in range(NB)])
+        MTs = np.mod(M.T @ sv, 2)
+        phi[s] = float(np.prod([cos_t[i] for i in range(NA) if MTs[i] == 1]))
+    return phi, M
+
+
+# ── T14: Walsh-Hadamard master theorem ───────────────────────────────────────
+
+def t14_Pb(thetas, pairs, NA, NB):
+    """T14: P_b = (1/2^NB) sum_s (-1)^{b·s} Phi_M(s).
+
+    Returns: (Pb dict {b: float}, phi dict {s: float})
+    """
+    phi, _ = phi_dict(thetas, pairs, NA, NB)
+    Pb = {}
+    for b in range(2**NB):
+        bv = np.array([(b >> j) & 1 for j in range(NB)])
+        Pb[b] = sum(
+            (-1) ** int(np.dot(bv, np.array([(s >> j) & 1 for j in range(NB)]) % 2))
+            * phi[s]
+            for s in range(2**NB)
+        ) / (2**NB)
+    return Pb, phi
+
+
+# ── T-UNIVERSAL: diagonal mixed input ────────────────────────────────────────
+
+def t_universal(rho_A, pairs, NA, NB):
+    """T-UNIVERSAL: P_b = sum_{x: Mx=b} rho_A[x,x].
+
+    Works for any diagonal (or full) density matrix rho_A.
+    """
+    M = build_M(pairs, NA, NB)
+    Pb = {}
+    for b in range(2**NB):
+        Pb[b] = 0.0
+        for x in range(2**NA):
+            bx = 0
+            for i in range(NA):
+                if (x >> i) & 1:
+                    for j in range(NB):
+                        if M[j][i]:
+                            bx ^= 1 << j
+            if bx == b:
+                Pb[b] += rho_A[x, x].real
+    return Pb
+
+
+# ── Entropy functions ─────────────────────────────────────────────────────────
+
+def vne_from_Pb(Pb):
+    """Von Neumann entropy H(P) = -sum_b P_b log2(P_b), clipped at 1e-14."""
+    return float(sum(-v * log2(max(v, 1e-14)) for v in Pb.values() if v > 1e-14))
+
+
+def renyi_entropy(Pb, alpha):
+    """S_alpha = (1/(1-alpha)) * log2(sum_b P_b^alpha). Returns VNE for alpha≈1."""
+    if abs(alpha - 1.0) < 1e-9:
+        return vne_from_Pb(Pb)
+    tr_rho_alpha = sum(max(v, 0) ** alpha for v in Pb.values())
+    return log2(max(tr_rho_alpha, 1e-300)) / (1 - alpha)
+
+
+# ── GF(2) rank ────────────────────────────────────────────────────────────────
+
+def f2_rank(pairs, NA, NB):
+    """Compute GF(2) rank of M via Gaussian elimination over F2."""
+    M = build_M(pairs, NA, NB)
+    mat = M.copy()
+    rank = 0
+    for col in range(NA):
+        pivot = next((r for r in range(rank, NB) if mat[r, col]), None)
+        if pivot is None:
+            continue
+        mat[[rank, pivot]] = mat[[pivot, rank]]
+        for row in range(NB):
+            if row != rank and mat[row, col]:
+                mat[row] = (mat[row] + mat[rank]) % 2
+        rank += 1
+    return rank
+
+
+# ── Moment theory ─────────────────────────────────────────────────────────────
+
+def t22_moment(thetas, pairs, NA, NB, alpha):
+    """T22: Tr(rho_B^alpha) = (1/2^{(alpha-1)*NB}) sum_{s1,...,s_{alpha-1}} prod Phi_M(s_i) * Phi_M(s1^...^s_{alpha-1})."""
+    from itertools import product as iproduct
+    phi, _ = phi_dict(thetas, pairs, NA, NB)
+    if alpha == 1:
+        return 1.0
+    total = 0.0
+    for combo in iproduct(range(2**NB), repeat=alpha - 1):
+        xor_all = 0
+        for c in combo:
+            xor_all ^= c
+        total += float(np.prod([phi[c] for c in combo])) * phi[xor_all]
+    return total / (2 ** ((alpha - 1) * NB))
+
+
+def newton_girard(moments):
+    """Recover eigenvalues from power-sum moments via Newton-Girard identities."""
+    n = len(moments)
+    e = [0.0] * (n + 1)
+    e[0] = 1.0
+    for k in range(1, n + 1):
+        total = sum(((-1) ** (i - 1)) * e[k - i] * moments[i - 1]
+                    for i in range(1, k + 1) if k - i <= n)
+        e[k] = total / k
+    coeffs = [(-1) ** k * e[k] for k in range(n + 1)]
+    return sorted(np.roots(coeffs).real, reverse=True)
+
+
+# ── Gradient computation (T-GRAD) ─────────────────────────────────────────────
+
+def vne_gradient_rx(thetas, pairs, NA, NB):
+    """Analytic gradient d(VNE)/d(theta_i) for Rx product state input via T14.
+
+    Derivation:
+      Phi_M(s) = prod_{j: (M^T s)_j=1} cos(theta_j)
+      d Phi_M(s)/d theta_i = -tan(theta_i) * Phi_M(s)  if (M^T s)_i = 1, else 0
+      d P_b / d theta_i  = (1/2^NB) sum_s (-1)^{b.s} * d Phi_M(s)/d theta_i
+      d VNE / d theta_i  = -sum_b (d P_b/d theta_i) * log2(P_b)
+      [normalization sum_b d P_b/d theta_i = 0 eliminates the -1/ln2 term]
+    """
+    phi, M = phi_dict(thetas, pairs, NA, NB)
+    Pb, _ = t14_Pb(thetas, pairs, NA, NB)
+    grad = []
+    for i in range(NA):
+        tan_i = sin(thetas[i]) / cos(thetas[i])
+        dPb = {}
+        for b in range(2**NB):
+            bv = np.array([(b >> j) & 1 for j in range(NB)])
+            val = 0.0
+            for s in range(2**NB):
+                sv = np.array([(s >> j) & 1 for j in range(NB)])
+                MTs = np.mod(M.T @ sv, 2)
+                if MTs[i] == 1:
+                    sign = (-1) ** int(np.dot(bv, sv) % 2)
+                    val += sign * (-tan_i * phi[s])
+            dPb[b] = val / (2**NB)
+        dvne = sum(-dPb[b] * log2(max(Pb[b], 1e-14)) for b in range(2**NB) if Pb[b] > 1e-14)
+        grad.append(dvne)
+    return grad
+
+
+# ── Renyi entropy derivative (T-RENYI-DERIV) ──────────────────────────────────
+
+def t_renyi_deriv(Pb):
+    """T-RENYI-DERIV: d(S_alpha)/d(alpha)|_{alpha=1} = -ln(2)/2 * Var[log2 P_b].
+
+    Measures convergence speed: positive = converging, negative = diverging.
+    """
+    import math
+    vne = vne_from_Pb(Pb)
+    second_moment = sum(v * log2(max(v, 1e-14))**2 for v in Pb.values() if v > 1e-14)
+    var_log = second_moment - vne**2
+    return -math.log(2) / 2.0 * var_log
+
+
+# ── Gaussian binomial coefficients ────────────────────────────────────────────
+
+def gaussian_binom_2(n, k):
+    """Gaussian binomial [n choose k]_2 over GF(2)."""
+    if k < 0 or k > n:
+        return 0
+    num = 1
+    for j in range(k):
+        num *= (2**n - 2**j)
+    den = 1
+    for j in range(k):
+        den *= (2**k - 2**j)
+    return num // den
+
+
+def expected_gf2_rank(NA, NB):
+    """E[rank] for NB×NA uniform-random GF(2) matrix via Gaussian binomial formula."""
+    total_matrices = 2 ** (NA * NB)
+    total = sum(
+        r * gaussian_binom_2(NB, r) * int(np.prod([2**NA - 2**j for j in range(r)]))
+        for r in range(1, min(NA, NB) + 1)
+    )
+    return total / total_matrices

qse/gates.py

@@ -0,0 +1,52 @@
+"""
+qse/gates.py — Quantum gate applications on statevectors.
+
+All gates operate on flat complex numpy arrays. Qubit index k = bit k of the
+integer index. A-qubits occupy bits 0..NA-1, B-qubits bits NA..NA+NB-1.
+"""
+
+import numpy as np
+from math import cos, sin
+
+
+def apply_cnot(amps, ctrl, tgt):
+    """Apply CNOT(ctrl, tgt) to statevector `amps` in-place (returns new array).
+
+    Flips bit `tgt` of each basis state where bit `ctrl` is 1.
+    """
+    new = np.zeros_like(amps)
+    for idx in range(len(amps)):
+        new[idx ^ (1 << tgt) if (idx >> ctrl) & 1 else idx] += amps[idx]
+    return new
+
+
+def apply_fsim(amps, q1, q2, alpha, phi):
+    """Apply fSim(alpha, phi) gate on qubits q1 and q2 of statevector.
+
+    fSim acts as:
+      |00⟩ → |00⟩
+      |01⟩ → cos(α)|01⟩ − i·sin(α)|10⟩
+      |10⟩ → cos(α)|10⟩ − i·sin(α)|01⟩
+      |11⟩ → e^{−iφ}|11⟩
+    """
+    new = amps.copy()
+    cos_a = cos(alpha)
+    sin_a = sin(alpha)
+    for idx in range(len(amps)):
+        b1 = (idx >> q1) & 1
+        b2 = (idx >> q2) & 1
+        if b1 == 1 and b2 == 1:
+            new[idx] = np.exp(-1j * phi) * amps[idx]
+        elif b1 == 0 and b2 == 1:
+            idx10 = idx ^ (1 << q1) ^ (1 << q2)
+            new[idx]   = cos_a * amps[idx]   - 1j * sin_a * amps[idx10]
+            new[idx10] = cos_a * amps[idx10] - 1j * sin_a * amps[idx]
+    return new
+
+
+def apply_swap(amps, q1, q2):
+    """Apply SWAP(q1, q2) via three CNOTs: CNOT(q1→q2), CNOT(q2→q1), CNOT(q1→q2)."""
+    amps = apply_cnot(amps, q1, q2)
+    amps = apply_cnot(amps, q2, q1)
+    amps = apply_cnot(amps, q1, q2)
+    return amps

qse/gradients.py

@@ -0,0 +1,46 @@
+"""
+qse/gradients.py — Analytic VNE gradients via T14.
+
+T-GRAD: d(VNE)/d(θ_i) closed form for Rx product-state inputs.
+
+Derivation:
+  Φ_M(s) = prod_{j: (M^T s)_j=1} cos(θ_j)
+  d Φ_M(s)/d θ_i = −tan(θ_i)·Φ_M(s)   if (M^T s)_i = 1, else 0
+  d P_b / d θ_i  = (1/2^NB) sum_s (−1)^{b·s} · d Φ_M(s)/d θ_i
+  d VNE / d θ_i  = −sum_b (d P_b/d θ_i) · log2(P_b)
+  (normalization sum_b d P_b/d θ_i = 0 eliminates the −1/ln2 term)
+"""
+
+import numpy as np
+from math import sin, cos, log2
+
+from qse.core import phi_dict, t14_Pb
+
+
+def vne_gradient_rx(thetas, pairs, NA, NB):
+    """Analytic gradient d(VNE)/d(θ_i) for Rx product-state input.
+
+    Returns a list of length NA with the gradient for each A-qubit angle.
+    """
+    phi, M = phi_dict(thetas, pairs, NA, NB)
+    Pb, _ = t14_Pb(thetas, pairs, NA, NB)
+    grad = []
+    for i in range(NA):
+        tan_i = sin(thetas[i]) / cos(thetas[i])
+        dPb = {}
+        for b in range(2**NB):
+            bv = np.array([(b >> j) & 1 for j in range(NB)])
+            val = 0.0
+            for s in range(2**NB):
+                sv = np.array([(s >> j) & 1 for j in range(NB)])
+                MTs = np.mod(M.T @ sv, 2)
+                if MTs[i] == 1:
+                    sign = (-1) ** int(np.dot(bv, sv) % 2)
+                    val += sign * (-tan_i * phi[s])
+            dPb[b] = val / (2**NB)
+        dvne = sum(
+            -dPb[b] * log2(max(Pb[b], 1e-14))
+            for b in range(2**NB) if Pb[b] > 1e-14
+        )
+        grad.append(dvne)
+    return grad

qse/noise.py

@@ -0,0 +1,61 @@
+"""
+qse/noise.py — Noise models for QSE circuits.
+
+T-NOISE: Amplitude damping transfer on P_b distribution.
+  After CNOT(ctrl=A, tgt=B) and amplitude-damping on B with rate γ:
+    P_0_noisy = P_0 + γ·P_1
+    P_1_noisy = (1−γ)·P_1
+  VNE of noisy B = H(P_0_noisy, P_1_noisy)
+
+S2 Transfer matrix: superoperator approach for iterated CNOT+AD cycles.
+"""
+
+import numpy as np
+from math import sqrt
+
+
+def amplitude_damping_kraus(gamma):
+    """Return Kraus operators [K0, K1] for amplitude damping with rate γ."""
+    K0 = np.array([[1, 0], [0, sqrt(1 - gamma)]], dtype=complex)
+    K1 = np.array([[0, sqrt(gamma)], [0, 0]], dtype=complex)
+    return [K0, K1]
+
+
+def superop(kraus_ops):
+    """Build superoperator S = sum_K K* ⊗ K for a set of Kraus operators.
+
+    Dimension: (d^2, d^2) where d is the operator dimension.
+    """
+    d = kraus_ops[0].shape[0]
+    S = np.zeros((d**2, d**2), dtype=complex)
+    for K in kraus_ops:
+        S += np.kron(K.conj(), K)
+    return S
+
+
+def noise_transfer_Pb(Pb, gamma):
+    """Apply amplitude-damping T_AD(γ) directly to a 1-qubit P_b distribution.
+
+    T-NOISE formula (NA=NB=1):
+      P_0 → P_0 + γ·P_1
+      P_1 → (1−γ)·P_1
+    """
+    P0 = Pb.get(0, 0.0)
+    P1 = Pb.get(1, 0.0)
+    return {0: P0 + gamma * P1, 1: (1 - gamma) * P1}
+
+
+def build_cnot_ad_transfer(gamma):
+    """Build the 16×16 transfer superoperator for one CNOT+AD_B+CNOT+AD_A cycle (NA=NB=1).
+
+    Returns T such that vec(ρ_k) = T^k @ vec(ρ_0).
+    """
+    K0, K1 = amplitude_damping_kraus(gamma)
+    CNOT = np.array([[1, 0, 0, 0],
+                     [0, 1, 0, 0],
+                     [0, 0, 0, 1],
+                     [0, 0, 1, 0]], dtype=complex)
+    S_cnot  = superop([CNOT])
+    S_AD_B  = superop([np.kron(np.eye(2), K0), np.kron(np.eye(2), K1)])
+    S_AD_A  = superop([np.kron(K0, np.eye(2)), np.kron(K1, np.eye(2))])
+    return S_AD_A @ S_cnot @ S_AD_B @ S_cnot

qse/random_circuits.py

@@ -0,0 +1,66 @@
+"""
+qse/random_circuits.py — Random circuit statistics via GF(2) matroid theory.
+
+T-RANDOM-VNE: E[VNE(θ=π/2)] = E[rank_GF2(M)] (Gaussian binomial formula).
+
+At θ=π/2, VNE = rank_GF2(M) exactly (T-OPT). Averaging over all 2^{NA·NB}
+binary matrices M gives the expected GF(2) rank via Gaussian binomial coefficients:
+
+  E[rank] = (1/2^{NA·NB}) sum_{r=1}^{min(NA,NB)} r · [NB choose r]_2 · prod_{j<r}(2^NA − 2^j)
+
+where [n choose k]_2 = prod_{j=0}^{k-1}(2^n − 2^j) / prod_{j=0}^{k-1}(2^k − 2^j)
+is the Gaussian binomial coefficient (count of k-dim subspaces of F2^n).
+"""
+
+from math import pi
+from functools import reduce
+import operator
+
+
+def gaussian_binom_2(n, k):
+    """[n choose k]_2 over GF(2): number of k-dim subspaces of F2^n.
+
+    Formula: prod_{j=0}^{k-1}(2^n − 2^j) / prod_{j=0}^{k-1}(2^k − 2^j)
+    Returns an exact integer.
+    """
+    if k < 0 or k > n:
+        return 0
+    num = reduce(operator.mul, (2**n - 2**j for j in range(k)), 1)
+    den = reduce(operator.mul, (2**k - 2**j for j in range(k)), 1)
+    return num // den
+
+
+def expected_gf2_rank(NA, NB):
+    """E[rank_GF2(M)] where M is a uniformly random NB×NA binary matrix.
+
+    Uses the Gaussian binomial formula for exact integer arithmetic.
+    """
+    total_matrices = 2 ** (NA * NB)
+    total = sum(
+        r * gaussian_binom_2(NB, r) * reduce(operator.mul, (2**NA - 2**j for j in range(r)), 1)
+        for r in range(1, min(NA, NB) + 1)
+    )
+    return total / total_matrices
+
+
+def enumerate_vne(NA, NB, thetas=None):
+    """Compute average VNE over all 2^{NA·NB} binary CNOT connectivity matrices.
+
+    thetas: list of NA angles; defaults to [π/2]*NA (T-OPT saturation).
+    Returns: (avg_vne, {matrix_index: vne} dict)
+    """
+    from qse.core import t14_Pb, vne_from_Pb
+    if thetas is None:
+        thetas = [pi / 2] * NA
+    vne_dict = {}
+    for bits in range(2 ** (NA * NB)):
+        pairs = [
+            (j, i)
+            for i in range(NB)
+            for j in range(NA)
+            if (bits >> (i * NA + j)) & 1
+        ]
+        Pb, _ = t14_Pb(thetas, pairs, NA, NB)
+        vne_dict[bits] = vne_from_Pb(Pb)
+    avg_vne = sum(vne_dict.values()) / len(vne_dict)
+    return avg_vne, vne_dict

qse/states.py

@@ -0,0 +1,94 @@
+"""
+qse/states.py — State preparation and exact statevector simulation.
+
+Conventions:
+  Rx(θ)|0⟩ = cos(θ/2)|0⟩ − i·sin(θ/2)|1⟩
+  Ry(θ)|0⟩ = cos(θ/2)|0⟩ −   sin(θ/2)|1⟩
+  Qubit layout: A-qubits = bits 0..NA-1, B-qubits = bits NA..NA+NB-1
+"""
+
+import numpy as np
+from math import cos, sin
+
+
+# ── State preparation ─────────────────────────────────────────────────────────
+
+def product_state(thetas):
+    """Build |ψ_A⟩ = ⊗_i Rx(θ_i)|0⟩ as a statevector.
+
+    thetas[0] is the least-significant qubit (bit 0).
+    """
+    psi = np.array([cos(thetas[-1] / 2), -1j * sin(thetas[-1] / 2)])
+    for i in range(len(thetas) - 2, -1, -1):
+        psi = np.kron(psi, np.array([cos(thetas[i] / 2), -1j * sin(thetas[i] / 2)]))
+    return psi
+
+
+def product_state_ry(thetas):
+    """Build |ψ_A⟩ = ⊗_i Ry(θ_i)|0⟩ as a statevector (no i factor vs Rx)."""
+    psi = np.array([cos(thetas[-1] / 2), -sin(thetas[-1] / 2)])
+    for i in range(len(thetas) - 2, -1, -1):
+        psi = np.kron(psi, np.array([cos(thetas[i] / 2), -sin(thetas[i] / 2)]))
+    return psi
+
+
+# ── Exact simulation ──────────────────────────────────────────────────────────
+
+def exact_rho_B(NA, NB, thetas_A, pairs, thetas_B=None):
+    """Compute ρ_B exactly via statevector simulation.
+
+    thetas_B=None → B initialized to |0…0⟩.
+    pairs: list of (a, b) meaning CNOT(ctrl=a, tgt=b).
+
+    Complexity: O(2^{NA+NB}) — scales to NA=12, NB=6 in ~8 ms.
+
+    Partial trace via reshape + matmul:
+      amps.reshape(2^NB, 2^NA) → ρ_B = A @ A†
+    Index layout: amps[a_bits | (b_bits << NA)], so the low NA bits
+    are A and the high NB bits are B — reshape groups B as rows, A as cols.
+    """
+    from qse.gates import apply_cnot
+    psi_A = product_state(thetas_A)
+    if thetas_B is not None:
+        psi_B = product_state(thetas_B)
+        psi = np.kron(psi_B, psi_A)
+    else:
+        psi_B0 = np.zeros(2**NB, dtype=complex)
+        psi_B0[0] = 1.0
+        psi = np.kron(psi_B0, psi_A)
+    amps = psi.copy()
+    for a_q, b_q in pairs:
+        amps = apply_cnot(amps, a_q, NA + b_q)
+    # Vectorized partial trace: reshape into (B_states, A_states), then ρ_B = A @ A†
+    A = amps.reshape(2**NB, 2**NA)
+    return A @ A.conj().T
+
+
+def exact_rho_B_mixed(NA, NB, rho_A_diag, pairs):
+    """Compute ρ_B for a diagonal mixed input ρ_A = diag(rho_A_diag).
+
+    rho_A_diag: array of length 2^NA summing to 1.
+    """
+    from qse.gates import apply_cnot
+    from qse.core import build_M
+    M = build_M(pairs, NA, NB)
+    rho_B = np.zeros((2**NB, 2**NB), dtype=complex)
+    for x, px in enumerate(rho_A_diag):
+        if abs(px) < 1e-15:
+            continue
+        bx = 0
+        for i in range(NA):
+            if (x >> i) & 1:
+                for j in range(NB):
+                    if M[j][i]:
+                        bx ^= 1 << j
+        rho_B[bx, bx] += px
+    return rho_B
+
+
+def vne_exact(NA, NB, thetas_A, pairs, thetas_B=None):
+    """Compute exact VNE of B by diagonalizing ρ_B."""
+    rho = exact_rho_B(NA, NB, thetas_A, pairs, thetas_B)
+    eigs = np.linalg.eigvalsh(rho).real
+    eigs = eigs[eigs > 1e-15]
+    return float(-np.sum(eigs * np.log2(eigs))) if len(eigs) else 0.0

ultraqse-1.0.0.dist-info/METADATA

@@ -0,0 +1,270 @@
+Metadata-Version: 2.4
+Name: ultraqse
+Version: 1.0.0
+Summary: Von Neumann Entropy of CNOT circuits via Walsh-Hadamard transforms over GF(2)
+Author-email: Ozgurooozer <ozigoca@gmail.com>
+License-Expression: MIT
+Project-URL: Repository, https://github.com/Ozgurooozer/ultraqse
+Keywords: quantum,entropy,von neumann,walsh hadamard,gf2,cnot,entanglement,quantum circuits
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Topic :: Scientific/Engineering :: Physics
+Classifier: Intended Audience :: Science/Research
+Classifier: Operating System :: OS Independent
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+Requires-Dist: numpy>=1.21
+
+# QSE Theorem Reference
+
+**Convention:** `Rx(θ)|0⟩ = cos(θ/2)|0⟩ − i·sin(θ/2)|1⟩`  
+**Ry convention:** `Ry(θ)|0⟩ = cos(θ/2)|0⟩ − sin(θ/2)|1⟩`  
+**Φ_M(s)** = ∏_{i: (M^T s)_i = 1} cos(θᵢ)  
+**M** ∈ F₂^{NB×NA}: M[b][a] = 1 iff CNOT(ctrl=a, tgt=b) is present  
+**Qubit layout:** A-qubits = bits 0..NA−1, B-qubits = bits NA..NA+NB−1  
+
+---
+
+## Core Theorems
+
+| ID | Name | Formula | max_err |
+|----|------|---------|---------|
+| **T14** | Walsh-Hadamard Master | `P_b = (1/2^NB) Σ_s (−1)^{b·s} Φ_M(s)`, `VNE = H({P_b})` | < 7e-16 |
+| **T-UNIVERSAL** | Diagonal Mixed Input | `P_b = Σ_{x: Mx=b} ρ_A[x,x]` (works for any diagonal ρ_A) | < 5e-16 |
+| **T-UNIVERSAL-GEN** | Nonlinear Gates | `P_b = Σ_{x: f(x)=b} |ψ[x]|²` | < 3e-16 |
+| **T16** | Phase Invariance | VNE depends only on {|cos(θᵢ/2)|²}, not on U(1) phases | < 7e-16 |
+
+---
+
+## Structural Theorems
+
+| ID | Name | Key Result | max_err |
+|----|------|-----------|---------|
+| **T17** | Blindness | VNE = 0 ↔ rank_F₂(M) = 0 | exact |
+| **T-RANK** | Rank Upper Bound | `VNE(B) ≤ rank_F₂(M)` | exact |
+| **T-OPT** | Rank Saturation | θ = π/2 ⟹ `VNE = rank_F₂(M)` exactly | exact |
+| **T-SUB** | Monotone Substructure | Adding CNOT → rank nondecreasing → VNE nondecreasing | exact |
+
+---
+
+## Gate Extensions
+
+| ID | Name | Key Result | max_err |
+|----|------|-----------|---------|
+| **T-BINIT** | B-Init Independence | T14 formula unchanged for any product-state B init (full-rank M) | < 7e-16 |
+| **CZ-T14** | CZ Equivalence | CZ + \|+⟩_A = CNOT + \|0⟩_A (same VNE) | < 6e-16 |
+| **T-fSim** | fSim Gate (NA=1) | λ± = (1 ± √D)/2, D = 1 − sin²(2α)sin⁴(θ/2); φ-invariant | < 2e-15 |
+| **T-FSIM-PRODUCT** | fSim Product Gates | NA independent fSim gates (qubit i ↔ B-qubit i): `VNE = Σᵢ H(λ±ᵢ)` | < 4e-14 |
+| **iSWAP** | Full iSWAP | iSWAP + Rx(θ)\|0⟩_B → product state → VNE = 0 | < 4e-16 |
+| **T-SWAP** | SWAP via 3 CNOTs | SWAP(A_a, B_b) via CNOT→CNOT→CNOT → VNE(B) = 0 | < 7e-16 |
+
+---
+
+## Symmetry & Invariance Theorems
+
+| ID | Name | Key Result | max_err |
+|----|------|-----------|---------|
+| **T-RY-EQ** | Ry = Rx Symmetry | VNE(Ry(θ) circuit) = VNE(Rx(θ) circuit) for same θ and M | < 8e-16 |
+| **T-MIRROR** | Schmidt Symmetry | VNE(A) = VNE(B) for any pure bipartite state \|Ψ⟩_AB | < 8e-16 |
+| **T-COHERENCE-DIAG** | Off-diagonal ρ_A Blindness | Off-diagonal ρ_A elements do not affect VNE(B); ρ_B always diagonal; VNE depends only on diag(ρ_A) | 0 |
+
+**T-COHERENCE-DIAG note:** This is a non-trivial result. Even if A is in a coherent superposition
+(off-diagonal ρ_A ≠ 0), the partial trace over A produces a strictly diagonal ρ_B, so
+the CNOT circuit acts as a classical channel at the level of B's entropy.
+
+---
+
+## Gradient Theorems
+
+| ID | Name | Formula | max_err |
+|----|------|---------|---------|
+| **T-GRAD** | Rx VNE Gradient | `d(VNE)/dθᵢ = −Σ_b (dP_b/dθᵢ)·log₂(P_b)` where `dP_b/dθᵢ = (1/2^NB) Σ_{s: (M^T s)_i=1} (−1)^{b·s}·(−tan θᵢ)·Φ_M(s)` | < 2e-10 (FD limit) |
+
+**T-GRAD note:** The 2e-10 error is the finite-difference floor, not an analytic error.
+The closed-form formula is exact; verification uses 4th-order central differences (h=1e-5).
+
+---
+
+## Information-Theoretic Theorems
+
+| ID | Name | Formula | max_err |
+|----|------|---------|---------|
+| **T-MUTUAL** | Mutual Information | `I(A;B) = 2·VNE(B)` for pure state | exact |
+| **T-MI** | MI Non-Negativity | `I(B₁;B₂) ≥ 0` | analytical |
+| **T-PAULI** | Pauli Representation | `Φ_M(s) = ⟨Z^{M^T s}⟩_A` (Pauli expectation value form) | exact |
+
+---
+
+## Dynamics
+
+| ID | Name | Key Result | max_err |
+|----|------|-----------|---------|
+| **T15A** | k-Layer Circuits | `M_eff = M₁ ⊕ M₂ ⊕ ... ⊕ Mₖ (mod 2)` | < 8e-16 |
+| **T18** | Period-2 | Even number of identical CNOT layers → M_eff = 0 → VNE = 0 | < 4e-16 |
+| **T-BIDIR** | Bidirectional Circuits | Alternating A→B and B→A CNOT layers reduce to T14(M_eff) | < 2e-15 |
+
+**T-BIDIR details:**
+
+For circuits with interleaved A→B layers (CNOTs ctrl=a, tgt=B_b) and B→A layers
+(CNOTs ctrl=B_b, tgt=a), the effective M matrix is:
+
+```
+M_eff[b, :] = M_raw[b, :] @ T_cum  (mod 2)
+```
+
+where T_cum ∈ F₂^{NA×NA} is the cumulative A-space shear transformation accumulated
+from all B→A CNOTs seen so far. Update rule after CNOT(ctrl=B_b, tgt=A_a):
+
+```
+T_cum[a, :] ^= M_eff[b_abs, :]   (row XOR, not matrix multiply)
+```
+
+**Invertibility condition:** T_cum must have full GF(2) rank (= NA). When T_cum is
+singular, multiple x-values map to the same A-state with different B-states, creating
+off-diagonal ρ_B elements (quantum coherences) that break the T14 assumption. The
+theorem applies only to circuits where T_cum remains invertible throughout.
+
+---
+
+## Noise Theorems
+
+| ID | Name | Formula | max_err |
+|----|------|---------|---------|
+| **T-NOISE** | Amplitude Damping | After AD_γ on B: `P₀ → P₀+γP₁`, `P₁ → (1−γ)P₁`; `VNE_noisy = H(P₀+γP₁, (1−γ)P₁)` | < 3e-16 |
+| **S2** | k-Round Transfer Matrix | `T = S_AD_A · S_CNOT · S_AD_B · S_CNOT` (16×16 superoperator); `vec(ρₖ) = Tᵏ·vec(ρ₀)` | < 7e-16 |
+
+---
+
+## Moment & Rényi Theory
+
+| ID | Name | Formula | max_err |
+|----|------|---------|---------|
+| **T22** | Rényi Moments | `Tr(ρᵅ) = (1/2^{(α−1)NB}) Σ_{s₁..s_{α−1}} ∏Φ_M(sᵢ)·Φ_M(⊕sᵢ)` | < 2e-15 |
+| **T29** | Newton-Girard Spectrum | Power-sum moments (T22) → Newton-Girard identities → all eigenvalues of ρ_B | < 7e-7 |
+| **T-RENYI-DERIV** | Rényi Derivative | `dS_α/dα\|_{α=1} = −(ln2/2)·Var_P[log₂ P_b]` where `Var_P = Σ_b P_b(log₂ P_b)² − VNE²` | < 4e-10 (4th-order FD) |
+| **T-RENYI-CONV** | Rényi→VNE Convergence | `S_α → VNE` as `α → 1` | 0 |
+
+**T-RENYI-DERIV note:** Derived by Taylor-expanding `log Tr(ρᵅ)` around α=1 using T22
+moments. The `(ln2/2)·Var` coefficient follows from the second cumulant of the log-probability
+distribution. Verified with 4th-order central differences (h=1e-3) to avoid FD floor.
+
+---
+
+## Random Circuit Statistics
+
+| ID | Name | Key Result | max_err |
+|----|------|-----------|---------|
+| **T-RANDOM-VNE** | Expected VNE = Expected GF(2) Rank | `E[VNE(θ=π/2)] = E[rank_GF₂(M)]` over uniform random M ∈ F₂^{NB×NA} | 0 |
+
+**Gaussian binomial formula:**
+
+```
+E[rank_GF₂(M)] = (1/2^{NA·NB}) · Σ_{r=1}^{min(NA,NB)} r · [NB choose r]₂ · ∏_{j<r}(2^NA − 2^j)
+
+[n choose k]₂ = ∏_{j=0}^{k-1}(2^n − 2^j) / ∏_{j=0}^{k-1}(2^k − 2^j)   (Gaussian binomial)
+```
+
+The formula is exact over integers (no floating-point error).
+
+---
+
+## Inter-Theorem Connections
+
+| ID | Connection | max_err |
+|----|-----------|---------|
+| **B1** | T22(α=2) = Parseval: `Σ P_b² = (1/2^NB) Σ Φ(s)²` | < 3e-16 |
+| **B2** | `Φ_M(s) = E_{x~P_A}[(−1)^{(M^T s)·x}]` — Walsh-Fourier characteristic function of P_A | < 5e-16 |
+| **B3** | T14 = α→1 limit of T22 Rényi hierarchy (T-RENYI-CONV) | analytical |
+| **B4** | T17+T-RANK+T-OPT+T-SUB = F₂ linear matroid rank structure | analytical |
+| **B5** | T22 = α-point Pauli correlation function (via T-PAULI) | analytical |
+| **B6** | VNE(θ) monotone in [0, rank_F₂(M)] for uniform θ ∈ [0, π/2] | 500/500 |
+| **B7** | T14 = H(f*(P_A)): VNE is Shannon entropy of the classical pushforward of P_A under M | < 4e-16 |
+
+---
+
+## Resolved Open Problems
+
+| ID | Problem | Resolution | Theorem |
+|----|---------|-----------|---------|
+| **O1** | Closed-form for bidirectional circuits | M_eff = M_raw·T_cum (GF(2)), invertible T_cum required | T-BIDIR |
+| **O2a** | T-fSim eigenvalue formula (NA=1) | D = 1 − sin²(2α)sin⁴(θ/2); φ-invariant | T-fSim |
+| **O2b** | T-fSim for NA > 1 | VNE additivity for independent fSim gates | T-FSIM-PRODUCT |
+| **O3** | Gradient d(VNE)/dθᵢ for Ry/Rz input | Ry gives same VNE as Rx (T-RY-EQ); Rx gradient in closed form (T-GRAD) | T-RY-EQ, T-GRAD |
+| **O4** | Rényi approximation error bound | dS_α/dα\|₁ = −(ln2/2)·Var_P[log₂ P_b] | T-RENYI-DERIV |
+| **O5** | Non-diagonal ρ_A extension | Off-diagonal ρ_A does not affect VNE; ρ_B always diagonal | T-COHERENCE-DIAG |
+| **O6** | Random circuit VNE via F₂ matroid counting | E[VNE] = E[rank_GF₂] via Gaussian binomial | T-RANDOM-VNE |
+
+---
+
+## Scaling & Performance
+
+Tested on NA=12, NB=6 (2^18 = 262,144 amplitudes):
+
+| Operation | Complexity | Measured |
+|-----------|-----------|---------|
+| `t14_Pb` (WHT formula) | O(2^{2NB}) | **12 ms** |
+| `vne_gradient_rx` | O(NA · 2^{2NB}) | **195 ms** |
+| `exact_rho_B` (vectorized) | O(2^{NA+NB} · 2^{NB}) | **8 ms** |
+| `exact_rho_B` (old O(n²) loop) | O(4^{NA+NB}) | ~hours |
+
+**Key insight:** T14 complexity depends only on NB (the B register size), not NA.
+Growing NA to 100+ costs nothing for the WHT formula — only the statevector
+simulation and gradient scale with NA.
+
+**Vectorized partial trace** (`exact_rho_B`):
+
+```python
+# Old: O(4^{NA+NB}) double loop — infeasible for NA > 6
+# New: O(2^{NA+NB}) reshape + matmul
+A = amps.reshape(2**NB, 2**NA)   # B-bits as rows, A-bits as cols
+rho_B = A @ A.conj().T           # traces out A exactly
+```
+
+Index layout: `amps[a_bits | (b_bits << NA)]` — low NA bits are A, high NB bits are B.
+Reshape naturally groups B as rows and A as columns, making the matmul correct.
+
+---
+
+## Package API (`qse/`)
+
+```python
+from qse import (
+    # Core — T14 machinery
+    build_M, phi_dict, t14_Pb, t_universal,
+    vne_from_Pb, renyi_entropy, f2_rank,
+    t22_moment, newton_girard,
+
+    # States — simulation ground truth
+    product_state, product_state_ry,
+    exact_rho_B, exact_rho_B_mixed, vne_exact,
+
+    # Gates — statevector operations
+    apply_cnot, apply_fsim, apply_swap,
+
+    # Gradients
+    vne_gradient_rx,
+
+    # Noise
+    amplitude_damping_kraus, superop,
+    noise_transfer_Pb, build_cnot_ad_transfer,
+
+    # Random circuits
+    gaussian_binom_2, expected_gf2_rank, enumerate_vne,
+)
+```
+
+---
+
+## Test Suite
+
+Run `python qse_tests.py` — **34/34 tests** pass at machine precision (max_err < 1e-8).
+
+| Phase | Tests | Notes |
+|-------|-------|-------|
+| Initial commit | 23/23 | Core + noise + moment theory |
+| Katman 0 (bug fixes) | 23/23 | T-fSim formula fix, T-BINIT full-rank check, T18 generalization |
+| Katman 1 (open problems) | 33/33 | O2b–O6 resolved; T-SWAP, T-MIRROR added |
+| Katman 2 (new theorems) | 34/34 | T-BIDIR (O1) completed |

ultraqse-1.0.0.dist-info/RECORD

@@ -0,0 +1,11 @@
+qse/__init__.py,sha256=mEmEMmkxNMPWoqR-KYRdEffBhaumxL8w0_mniY-yQzE,2115
+qse/core.py,sha256=hGrC-HGNsyJ1aZToSGr7Npbc0i8vlcFWTe15qSKU7C0,8119
+qse/gates.py,sha256=_8BXZI8TTQj1QdICEduU5-xBOXpvc7syQRz0NlhWAw0,1637
+qse/gradients.py,sha256=0592EsjBg2upgyfyYwu2MO1Kex8C1z6Ns27LIEgSU-I,1530
+qse/noise.py,sha256=tHzA0qUaERPbtN_37U4_FrPoJwqJRVffGcd6aaL524I,1905
+qse/random_circuits.py,sha256=fX_idUpDXj8Lbyl8noo4gGCVAPYjCkCoxuzPHfs5VIk,2208
+qse/states.py,sha256=6NSYa4F6lU-41NAqBmVPAbRNElyrcFHOeR9-YUZPf0g,3436
+ultraqse-1.0.0.dist-info/METADATA,sha256=HSisgHTmL9CGIYVzm8F_ujA_A99InT1pWumEzi71EZo,11588
+ultraqse-1.0.0.dist-info/WHEEL,sha256=aeYiig01lYGDzBgS8HxWXOg3uV61G9ijOsup-k9o1sk,91
+ultraqse-1.0.0.dist-info/top_level.txt,sha256=sOJCZwZSA9WnGrROtyLe42mcnC3sJZQj1BFwcxCk8Q4,4
+ultraqse-1.0.0.dist-info/RECORD,,

ultraqse-1.0.0.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (82.0.1)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

ultraqse-1.0.0.dist-info/top_level.txt

@@ -0,0 +1 @@
+qse