dense-evolution 8.3.0__tar.gz → 8.3.1__tar.gz

{dense_evolution-8.3.0 → dense_evolution-8.3.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: dense-evolution
-Version: 8.3.0
+Version: 8.3.1
 Summary: High-performance quantum simulation toolkit -- Statevector/MPS engines with JIT compilation, noise modeling, VQE, QEC, quantum chemistry, and agent-native tooling
 Author-email: Salvatore Pennacchio <jtatopenn@libero.it>
 License: Business Source License 1.1
@@ -300,9 +300,11 @@ sim.run_chunk(circuit.to_tuples(), chunk_size_gates=500)
 
 - **JIT-fused statevector engine.** No Kronecker-product overhead — stride-sliced linear kernel fusion compiled through JAX XLA, real GPU/TPU dispatch with no code change. [Simulator](https://tatopenn-cell.github.io/Dense-Evolution/api/simulator/) · [MPS backend](https://tatopenn-cell.github.io/Dense-Evolution/api/mps/) for low-entanglement circuits at scale.
 - **Anti-OOM `Chunk` engine.** Circuits too large for one array, split dynamically and sized off the real compute device's own free memory — with disk-backed overflow past even that ceiling. [Chunk guide](https://tatopenn-cell.github.io/Dense-Evolution/api/chunk/).
-- **Real noise, real mitigation.** Stochastic Kraus channels, real-device noise imported from Qiskit backends, and Zero-Noise Extrapolation to correct for it. [Noise](https://tatopenn-cell.github.io/Dense-Evolution/api/noise/) · [Mitigation](https://tatopenn-cell.github.io/Dense-Evolution/api/mitigation/) · [what noise/mitigation/healing each mean](https://tatopenn-cell.github.io/Dense-Evolution/concepts/).
+- **Real noise, real mitigation.** Stochastic Kraus channels, real-device noise imported from Qiskit backends, and Zero-Noise Extrapolation, with the shot budget split optimally across noise factors and a single-qubit Bloch-vector variant that always returns a valid state, to correct for it. [Noise](https://tatopenn-cell.github.io/Dense-Evolution/api/noise/) · [Mitigation](https://tatopenn-cell.github.io/Dense-Evolution/api/mitigation/) · [what noise/mitigation/healing each mean](https://tatopenn-cell.github.io/Dense-Evolution/concepts/).
 - **Differentiable VQE, from scratch.** `circuit_to_energy_fn` is the same JAX-differentiable engine real molecular VQE runs on — real Hartree-Fock Hamiltonians, UCCSD/hardware-efficient ansätze, Adam optimization. [Autodiff](https://tatopenn-cell.github.io/Dense-Evolution/api/autodiff/).
 - **libcint integrals on Windows, macOS and Linux.** `pip install dense-evolution` ships libcint compiled for each system: the full two-electron tensor of ethanol in 6-31G* in 0.32 s. [native_hf](https://tatopenn-cell.github.io/Dense-Evolution/api/native_hf/).
+- **Reversible arithmetic.** Register adders, subtraction, comparisons and modular arithmetic up to modular exponentiation, applied as exact basis permutations and checked against the Vedral, Cuccaro, Draper and Beauregard circuits. [Arithmetic](https://tatopenn-cell.github.io/Dense-Evolution/api/arithmetic/).
+- **Postselection.** Keep the branch where a qubit is found in `|0>`, `|1>`, `|±>` or `|±i>`, with its probability. [Postselection](https://tatopenn-cell.github.io/Dense-Evolution/api/postselect/).
 - **OpenQASM 2.0/3.0, both directions.** A real parser, plus Qiskit/PennyLane interop bridges. [QASM Parser](https://tatopenn-cell.github.io/Dense-Evolution/api/parser/) · [Interop](https://tatopenn-cell.github.io/Dense-Evolution/api/interop/).
 - **Code-agnostic QEC decoding**, Majorana/Jordan-Wigner fermion mapping, from-scratch Hartree-Fock for elements outside PennyLane's own basis set, a traversable-wormhole-inspired teleportation protocol, and real QM/MM region partitioning (ring-safe BFS, Diffuse2Seg-derived relevance propagation) — see the [full API reference](https://tatopenn-cell.github.io/Dense-Evolution/api/) for all of it.
 

{dense_evolution-8.3.0 → dense_evolution-8.3.1}/README.md

@@ -200,9 +200,11 @@ sim.run_chunk(circuit.to_tuples(), chunk_size_gates=500)
 
 - **JIT-fused statevector engine.** No Kronecker-product overhead — stride-sliced linear kernel fusion compiled through JAX XLA, real GPU/TPU dispatch with no code change. [Simulator](https://tatopenn-cell.github.io/Dense-Evolution/api/simulator/) · [MPS backend](https://tatopenn-cell.github.io/Dense-Evolution/api/mps/) for low-entanglement circuits at scale.
 - **Anti-OOM `Chunk` engine.** Circuits too large for one array, split dynamically and sized off the real compute device's own free memory — with disk-backed overflow past even that ceiling. [Chunk guide](https://tatopenn-cell.github.io/Dense-Evolution/api/chunk/).
-- **Real noise, real mitigation.** Stochastic Kraus channels, real-device noise imported from Qiskit backends, and Zero-Noise Extrapolation to correct for it. [Noise](https://tatopenn-cell.github.io/Dense-Evolution/api/noise/) · [Mitigation](https://tatopenn-cell.github.io/Dense-Evolution/api/mitigation/) · [what noise/mitigation/healing each mean](https://tatopenn-cell.github.io/Dense-Evolution/concepts/).
+- **Real noise, real mitigation.** Stochastic Kraus channels, real-device noise imported from Qiskit backends, and Zero-Noise Extrapolation, with the shot budget split optimally across noise factors and a single-qubit Bloch-vector variant that always returns a valid state, to correct for it. [Noise](https://tatopenn-cell.github.io/Dense-Evolution/api/noise/) · [Mitigation](https://tatopenn-cell.github.io/Dense-Evolution/api/mitigation/) · [what noise/mitigation/healing each mean](https://tatopenn-cell.github.io/Dense-Evolution/concepts/).
 - **Differentiable VQE, from scratch.** `circuit_to_energy_fn` is the same JAX-differentiable engine real molecular VQE runs on — real Hartree-Fock Hamiltonians, UCCSD/hardware-efficient ansätze, Adam optimization. [Autodiff](https://tatopenn-cell.github.io/Dense-Evolution/api/autodiff/).
 - **libcint integrals on Windows, macOS and Linux.** `pip install dense-evolution` ships libcint compiled for each system: the full two-electron tensor of ethanol in 6-31G* in 0.32 s. [native_hf](https://tatopenn-cell.github.io/Dense-Evolution/api/native_hf/).
+- **Reversible arithmetic.** Register adders, subtraction, comparisons and modular arithmetic up to modular exponentiation, applied as exact basis permutations and checked against the Vedral, Cuccaro, Draper and Beauregard circuits. [Arithmetic](https://tatopenn-cell.github.io/Dense-Evolution/api/arithmetic/).
+- **Postselection.** Keep the branch where a qubit is found in `|0>`, `|1>`, `|±>` or `|±i>`, with its probability. [Postselection](https://tatopenn-cell.github.io/Dense-Evolution/api/postselect/).
 - **OpenQASM 2.0/3.0, both directions.** A real parser, plus Qiskit/PennyLane interop bridges. [QASM Parser](https://tatopenn-cell.github.io/Dense-Evolution/api/parser/) · [Interop](https://tatopenn-cell.github.io/Dense-Evolution/api/interop/).
 - **Code-agnostic QEC decoding**, Majorana/Jordan-Wigner fermion mapping, from-scratch Hartree-Fock for elements outside PennyLane's own basis set, a traversable-wormhole-inspired teleportation protocol, and real QM/MM region partitioning (ring-safe BFS, Diffuse2Seg-derived relevance propagation) — see the [full API reference](https://tatopenn-cell.github.io/Dense-Evolution/api/) for all of it.
 

{dense_evolution-8.3.0 → dense_evolution-8.3.1}/dense_evolution/__init__.py

@@ -31,7 +31,7 @@ from .backends.mps import MPSSimulator
 from .mitigation.zne import (richardson_extrapolate, richardson_amplification_factor,
                           zero_noise_extrapolation, polynomial_extrapolate,
                           bounded_exponential_extrapolate,
-                          project_to_physical, uhlmann_fidelity, zne_density_matrix,
+                          project_to_physical, bloch_zne, bloch_zne_jit, uhlmann_fidelity, zne_density_matrix,
                           jsd_predictive_zne_density_matrix,
                           coherence_predictive_zne_density_matrix,
                           classically_augmented_zne_phaseflip,
@@ -45,6 +45,12 @@ from .physics.observables import (pauli_expectation, pauli_sum_expectation, paul
 from .physics.states import ghz_state
 from .utils.measurement import sample_counts, statevector_fidelity
 from .circuits.qft import qft
+from .circuits.arithmetic import (
+    add_registers, subtract_registers, add_constant,
+    compare_registers, compare_constant,
+    add_registers_mod, add_constant_mod, multiply_add_mod, multiply_mod, power_mod,
+)
+from .circuits.postselect import postselect
 from .circuits.random_circuit import random_circuit
 from .utils.drawing import draw_circuit
 from .solvers.harrison_tb import (ELEMENTS as HARRISON_ELEMENTS, ETA as HARRISON_ETA,
@@ -62,7 +68,7 @@ from .physics.qec import (pauli_commutes, compute_syndrome, erasure_aware_decode
                    peeling_decode, union_find_decode, matching_erasure_decode,
                            estimate_edge_probabilities_from_detection_events)
 
-__version__ = "8.3.0"
+__version__ = "8.3.1"
 
 __all__ = [
     "__version__",
@@ -75,6 +81,10 @@ __all__ = [
     "NoiseModel", "NoiseSpec", "QuantumHardwareRegistry",
     "GATES", "PARAMETRIC_GATES", "GATE_IDS",
     "entangling_layer", "qft",
+    "add_registers", "subtract_registers", "add_constant",
+    "compare_registers", "compare_constant",
+    "add_registers_mod", "add_constant_mod", "multiply_add_mod", "multiply_mod", "power_mod",
+    "postselect",
     "pauli_rotation_ops", "trotter_evolve_ops", "continuous_pulse_evolve",
     "continuous_dissipative_evolve",
     "find_excitations", "single_excitation_ops", "double_excitation_ops",
@@ -91,7 +101,7 @@ __all__ = [
     "richardson_extrapolate", "richardson_amplification_factor",
     "zero_noise_extrapolation", "polynomial_extrapolate",
     "bounded_exponential_extrapolate",
-    "project_to_physical", "uhlmann_fidelity", "zne_density_matrix",
+    "project_to_physical", "bloch_zne", "bloch_zne_jit", "uhlmann_fidelity", "zne_density_matrix",
     "jsd_predictive_zne_density_matrix", "coherence_predictive_zne_density_matrix",
     "classically_augmented_zne_phaseflip",
     "global_depolarizing_channel", "amplitude_damping_channel", "phaseflip_channel_exact",

{dense_evolution-8.3.0 → dense_evolution-8.3.1}/dense_evolution/circuits/__init__.py

@@ -5,6 +5,12 @@ from .compiler import QuantumTranspiler
 from .registry import HAS_JAX, NoiseModel, NoiseSpec, QuantumHardwareRegistry
 from .topology import entangling_layer, VALID_PATTERNS
 from .qft import qft
+from .arithmetic import (
+    add_registers, subtract_registers, add_constant,
+    compare_registers, compare_constant,
+    add_registers_mod, add_constant_mod, multiply_add_mod, multiply_mod, power_mod,
+)
+from .postselect import postselect
 from .random_circuit import random_circuit
 from .trotter import pauli_rotation_ops, trotter_evolve_ops
 
@@ -15,6 +21,10 @@ __all__ = [
     "HAS_JAX", "NoiseModel", "NoiseSpec", "QuantumHardwareRegistry",
     "entangling_layer", "VALID_PATTERNS",
     "qft",
+    "add_registers", "subtract_registers", "add_constant",
+    "compare_registers", "compare_constant",
+    "add_registers_mod", "add_constant_mod", "multiply_add_mod", "multiply_mod", "power_mod",
+    "postselect",
     "random_circuit",
     "pauli_rotation_ops", "trotter_evolve_ops",
 ]

dense_evolution-8.3.1/dense_evolution/circuits/arithmetic.py

@@ -0,0 +1,241 @@
+"""
+Reversible arithmetic on qubit registers, applied to a statevector.
+
+Every operation here is a bijection f on computational basis states, so its
+unitary is the permutation U|x> = |f(x)> (Vedral, Barenco, Ekert,
+quant-ph/9511018, Sect. II, Eqs. 2-3). It is applied directly as an index
+permutation of the statevector, which is exact and costs one gather over the
+2^n amplitudes. The gate-level circuits from the papers (Cuccaro et al.
+quant-ph/0410184 ripple-carry adder, Draper quant-ph/0008033 transform
+adder) are the references the tests compare against.
+
+A register is a list of qubit indices, least significant bit first. Qubit 0
+is the most significant bit of the statevector index, as everywhere in the
+engine.
+"""
+import numpy as np
+
+from ..config import ensure_x64
+from .registry import HAS_JAX
+
+if HAS_JAX:
+    import jax.numpy as jnp
+    xp = jnp
+else:
+    xp = np
+
+__all__ = ['add_registers', 'subtract_registers', 'add_constant',
+           'compare_registers', 'compare_constant',
+           'add_registers_mod', 'add_constant_mod', 'multiply_add_mod',
+           'multiply_mod', 'power_mod']
+
+_COMPARISONS = {
+    '<': np.less, '>': np.greater, '<=': np.less_equal,
+    '>=': np.greater_equal, '==': np.equal, '!=': np.not_equal,
+}
+
+
+def _register_values(n_qubits, register):
+    idx = np.arange(2 ** n_qubits)
+    value = np.zeros_like(idx)
+    for k, q in enumerate(register):
+        value |= ((idx >> (n_qubits - 1 - q)) & 1) << k
+    return idx, value
+
+
+def _with_register(n_qubits, idx, register, value):
+    out = idx.copy()
+    for k, q in enumerate(register):
+        shift = n_qubits - 1 - q
+        out = (out & ~(1 << shift)) | (((value >> k) & 1) << shift)
+    return out
+
+
+def _check(n_qubits, *registers):
+    used = [q for r in registers for q in r]
+    if len(set(used)) != len(used):
+        raise ValueError("registers must not share qubits")
+    if any(q < 0 or q >= n_qubits for q in used):
+        raise ValueError(f"qubit index out of range for {n_qubits} qubits")
+    if any(len(r) == 0 for r in registers):
+        raise ValueError("registers must not be empty")
+
+
+def _permute(sv, target):
+    if xp is np:
+        sv = np.asarray(sv)
+        out = np.zeros_like(sv)
+        out[target] = sv
+        return out
+    ensure_x64()
+    sv = xp.asarray(sv)
+    return xp.zeros_like(sv).at[target].set(sv)
+
+
+def add_registers(sv, n_qubits, a, b):
+    """
+    |a, b> -> |a, (a + b) mod 2^len(b)>.
+
+    With len(b) = len(a) + 1 the sum never overflows (Vedral et al.,
+    Sect. III.A, Eq. 9); with len(b) = len(a) it is addition modulo 2^n
+    (Cuccaro et al., Sect. 4.1).
+    """
+    _check(n_qubits, a, b)
+    idx, va = _register_values(n_qubits, a)
+    _, vb = _register_values(n_qubits, b)
+    target = _with_register(n_qubits, idx, b, (va + vb) % (1 << len(b)))
+    return _permute(sv, target)
+
+
+def subtract_registers(sv, n_qubits, a, b):
+    """
+    |a, b> -> |a, (b - a) mod 2^len(b)>, the inverse of add_registers.
+
+    If b < a the result is 2^len(b) - (a - b) and, with len(b) = len(a) + 1,
+    its most significant qubit is 1 (Vedral et al., Sect. III.A).
+    """
+    _check(n_qubits, a, b)
+    idx, va = _register_values(n_qubits, a)
+    _, vb = _register_values(n_qubits, b)
+    target = _with_register(n_qubits, idx, b, (vb - va) % (1 << len(b)))
+    return _permute(sv, target)
+
+
+def add_constant(sv, n_qubits, b, c):
+    """
+    |b> -> |(b + c) mod 2^len(b)> for a classical integer c.
+
+    c = 1 is increment, c = -1 decrement. Same operation as Draper's
+    transform adder with classical addend (Sect. 5) and Beauregard's
+    phiADD(c) (quant-ph/0205095, Sect. 2.1).
+    """
+    _check(n_qubits, b)
+    idx, vb = _register_values(n_qubits, b)
+    target = _with_register(n_qubits, idx, b, (vb + int(c)) % (1 << len(b)))
+    return _permute(sv, target)
+
+
+def _flip_if(n_qubits, idx, out, condition):
+    return idx ^ (condition.astype(idx.dtype) << (n_qubits - 1 - out))
+
+
+def _comparison(op):
+    if op not in _COMPARISONS:
+        raise ValueError(f"op must be one of {sorted(_COMPARISONS)}, got {op!r}")
+    return _COMPARISONS[op]
+
+
+def compare_registers(sv, n_qubits, a, b, out, op='<'):
+    """
+    |a, b, z> -> |a, b, z XOR [a op b]>, inputs unchanged.
+
+    op = '<' is the comparator of Cuccaro et al. (Sect. 4.3): the high bit of
+    a - b, which is 1 if and only if a < b. The other comparisons follow by
+    swapping the operands and negating the output qubit.
+    """
+    _check(n_qubits, a, b, [out])
+    idx, va = _register_values(n_qubits, a)
+    _, vb = _register_values(n_qubits, b)
+    return _permute(sv, _flip_if(n_qubits, idx, out, _comparison(op)(va, vb)))
+
+
+def compare_constant(sv, n_qubits, b, c, out, op='<'):
+    """
+    |b, z> -> |b, z XOR [b op c]> for a classical integer c.
+
+    op = '<' is the most significant qubit after the reverse phiADD(c) of
+    Beauregard (quant-ph/0205095, Sect. 2.1, Fig. 4).
+    """
+    _check(n_qubits, b, [out])
+    idx, vb = _register_values(n_qubits, b)
+    return _permute(sv, _flip_if(n_qubits, idx, out, _comparison(op)(vb, int(c))))
+
+
+def _active(n_qubits, idx, controls):
+    on = np.ones(idx.shape, dtype=bool)
+    for q in controls:
+        on &= ((idx >> (n_qubits - 1 - q)) & 1).astype(bool)
+    return on
+
+
+def _check_modulus(N, *registers):
+    if N < 1 or any(N > (1 << len(r)) for r in registers):
+        raise ValueError(f"modulus N={N} must be >= 1 and fit in the register")
+
+
+def add_registers_mod(sv, n_qubits, a, b, N):
+    """
+    |a, b> -> |a, (a + b) mod N> for 0 <= a, b < N (Vedral et al., Sect. III.B,
+    Eq. 10). Basis states with a >= N or b >= N are left unchanged, which
+    keeps the map a permutation.
+    """
+    _check(n_qubits, a, b)
+    _check_modulus(N, a, b)
+    idx, va = _register_values(n_qubits, a)
+    _, vb = _register_values(n_qubits, b)
+    ok = (va < N) & (vb < N)
+    return _permute(sv, _with_register(n_qubits, idx, b, np.where(ok, (va + vb) % N, vb)))
+
+
+def add_constant_mod(sv, n_qubits, b, c, N, controls=()):
+    """
+    |b> -> |(b + c) mod N> for 0 <= b < N, applied only where every control
+    qubit is 1: the doubly controlled phiADD(c)MOD(N) of Beauregard
+    (quant-ph/0205095, Sect. 2.2, Fig. 5). Basis states with b >= N are left
+    unchanged.
+    """
+    _check(n_qubits, b, *([list(controls)] if controls else []))
+    _check_modulus(N, b)
+    idx, vb = _register_values(n_qubits, b)
+    ok = _active(n_qubits, idx, controls) & (vb < N)
+    return _permute(sv, _with_register(n_qubits, idx, b, np.where(ok, (vb + int(c)) % N, vb)))
+
+
+def multiply_add_mod(sv, n_qubits, x, b, a, N, controls=()):
+    """
+    |x, b> -> |x, (b + a*x) mod N> for 0 <= b < N, applied only where every
+    control qubit is 1: CMULT(a)MOD(N) of Beauregard (Sect. 2.3, Fig. 6),
+    built in the paper from n controlled modular additions of 2^i*a mod N
+    (Vedral et al., Sect. III.C). Basis states with b >= N are left unchanged.
+    """
+    _check(n_qubits, x, b, *([list(controls)] if controls else []))
+    _check_modulus(N, b)
+    idx, vx = _register_values(n_qubits, x)
+    _, vb = _register_values(n_qubits, b)
+    ok = _active(n_qubits, idx, controls) & (vb < N)
+    new = (vb + (int(a) % N) * (vx % N)) % N
+    return _permute(sv, _with_register(n_qubits, idx, b, np.where(ok, new, vb)))
+
+
+def multiply_mod(sv, n_qubits, x, a, N, controls=()):
+    """
+    |x> -> |a*x mod N> in place for 0 <= x < N and gcd(a, N) = 1, applied only
+    where every control qubit is 1 (Vedral et al., Sect. II, Eqs. 4-6;
+    Beauregard, Sect. 2.3, Fig. 7). With N = 2^len(x) and odd a this is plain
+    multiplication modulo 2^n. Basis states with x >= N are left unchanged.
+    """
+    _check(n_qubits, x, *([list(controls)] if controls else []))
+    _check_modulus(N, x)
+    if np.gcd(int(a), N) != 1:
+        raise ValueError(f"a={a} and N={N} must be coprime for an in-place multiplication")
+    idx, vx = _register_values(n_qubits, x)
+    ok = _active(n_qubits, idx, controls) & (vx < N)
+    return _permute(sv, _with_register(n_qubits, idx, x, np.where(ok, (int(a) * vx) % N, vx)))
+
+
+def power_mod(sv, n_qubits, x, y, a, N):
+    """
+    |x, y> -> |x, y * a^x mod N> for 0 <= y < N and gcd(a, N) = 1. With y = 1
+    this is the modular exponentiation |x, 1> -> |x, a^x mod N> of Shor's
+    algorithm (Vedral et al., Eq. 1 and Sect. III.D). Basis states with
+    y >= N are left unchanged.
+    """
+    _check(n_qubits, x, y)
+    _check_modulus(N, y)
+    if np.gcd(int(a), N) != 1:
+        raise ValueError(f"a={a} and N={N} must be coprime")
+    idx, vx = _register_values(n_qubits, x)
+    _, vy = _register_values(n_qubits, y)
+    powers = np.array([pow(int(a), int(e), N) for e in range(1 << len(x))])
+    ok = vy < N
+    return _permute(sv, _with_register(n_qubits, idx, y, np.where(ok, (vy * powers[vx]) % N, vy)))

{dense_evolution-8.3.0 → dense_evolution-8.3.1}/dense_evolution/circuits/parser.py

@@ -260,12 +260,9 @@ class QASMParser:
         - `for` loops with unresolvable bounds, and all `if`/`while`/`def`
           blocks (no static execution — would need runtime classical bit
           state), are simply removed, leaving the rest of the source intact.
-        - `gate` definitions are removed too — their body uses the gate's
-          own formal parameter names, not real qubit indices, so it can't
-          be executed directly; a later call site referencing that gate
-          name still falls through as an unrecognized gate (silent no-op,
-          same as any other unknown gate name elsewhere in this codebase),
-          but no longer corrupts the qubit/statement that follows it.
+        - `gate` definitions never reach this loop: parse() lifts them out
+          first with _extract_gate_definitions and expands every call site
+          into the definition's body (_expand_gate_call).
 
         Runs as a search/replace loop rather than recursion: after an outer
         block is unrolled, any inner (nested) blocks are duplicated as raw
@@ -303,6 +300,70 @@ class QASMParser:
             s = s[:m.start()] + replacement + s[close_brace + 1:]
         return s
 
+    _RE_GATE_DEF = re.compile(r'\bgate\s+([a-zA-Z_]\w*)\s*(?:\(([^)]*)\))?\s*([^{]*)\{')
+
+    def _extract_gate_definitions(self, s: str) -> Tuple[str, Dict]:
+        """
+        Remove every `gate NAME(params) args { body }` definition from the
+        source and return it with a table NAME -> (params, args, body).
+
+        OpenQASM 2.0 defines new gates as a body of earlier gates acting on
+        formal arguments; exporters such as qiskit.qasm2.dumps write
+        composite and arithmetic circuits this way (e.g. gate_MAJ inside
+        CDKMRippleCarryAdder), so call sites must be expanded, not dropped.
+        """
+        defs: Dict[str, Tuple[List[str], List[str], str]] = {}
+        while True:
+            m = self._RE_GATE_DEF.search(s)
+            if not m:
+                return s, defs
+            close = self._find_matching_brace(s, m.end() - 1)
+            if close is None:
+                return s, defs
+            params = [p.strip() for p in (m.group(2) or '').split(',') if p.strip()]
+            args = [a.strip() for a in m.group(3).split(',') if a.strip()]
+            defs[m.group(1).lower()] = (params, args, s[m.end():close])
+            s = s[:m.start()] + s[close + 1:]
+
+    def _expand_gate_call(self, instr: str, defs: Dict, depth: int = 0) -> List[str]:
+        """
+        Replace a call to a user-defined gate by its body, with formal
+        arguments and parameters substituted, recursively for nested
+        definitions. Anything else is returned unchanged.
+        """
+        instr = re.sub(r'\s+', ' ', instr).strip()
+        head = re.split(r'[\s(]', instr, 1)[0].lower()
+        if head not in defs:
+            return [instr]
+        if depth > 64:
+            raise ValueError(f"gate definitions nested too deeply at '{head}'")
+        params, args, body = defs[head]
+        rest = instr[len(head):].strip()
+        actual_params: List[str] = []
+        if rest.startswith('('):
+            depth_p, close = 0, -1
+            for i, ch in enumerate(rest):
+                depth_p += (ch == '(') - (ch == ')')
+                if depth_p == 0:
+                    close = i
+                    break
+            actual_params = [t.strip() for t in self._split_params(rest[1:close])]
+            rest = rest[close + 1:]
+        actual_args = [a.strip() for a in rest.split(',') if a.strip()]
+        if len(actual_args) != len(args) or len(actual_params) != len(params):
+            raise ValueError(f"gate '{head}' expects {len(params)} parameters and "
+                             f"{len(args)} qubits, got '{instr}'")
+        table = dict(zip(args, actual_args))
+        table.update({p: f'({v})' for p, v in zip(params, actual_params)})
+        if table:
+            names = re.compile(r'\b(' + '|'.join(re.escape(k) for k in table) + r')\b')
+            body = names.sub(lambda mm: table[mm.group(1)], body)
+        out: List[str] = []
+        for st in body.split(';'):
+            if st.strip():
+                out.extend(self._expand_gate_call(st, defs, depth + 1))
+        return out
+
     def parse(self, qasm_str: str) -> QASMCircuit:
         """
         Parse an OpenQASM 2.0 or 3.0 string into a QASMCircuit.
@@ -337,10 +398,12 @@ class QASMParser:
         # Must run before the ';'-split below: brace-delimited blocks are
         # not single ';'-terminated statements, and left alone they corrupt
         # whatever real statement follows them on the same line.
+        cleaned, gate_defs = self._extract_gate_definitions(cleaned)
         cleaned = self._process_block_constructs(cleaned)
 
         # ── split into statements ─────────────────────────────────────
         statements = [s.strip() for s in cleaned.split(';') if s.strip()]
+        statements = [e for st in statements for e in self._expand_gate_call(st, gate_defs)]
 
         for instr in statements:
             # collapse internal whitespace runs to a single space

dense_evolution-8.3.1/dense_evolution/circuits/postselect.py

@@ -0,0 +1,59 @@
+"""
+Postselection: keep only the branch of the state in which a qubit is found in a
+chosen state, then renormalise.
+
+This is the operation in the definition of PostBQP (Aaronson,
+quant-ph/0412187, Definition 1): the computation is conditioned on a
+measurement outcome that has nonzero probability. It is not unitary, so it is
+applied to the statevector directly, as the projector |psi><psi| on the
+qubit followed by renormalisation, and the success probability is returned
+with the new state.
+"""
+import numpy as np
+
+from ..config import ensure_x64
+from .registry import HAS_JAX
+
+if HAS_JAX:
+    import jax.numpy as jnp
+    xp = jnp
+else:
+    xp = np
+
+__all__ = ['postselect', 'POSTSELECT_STATES']
+
+_R = 1 / np.sqrt(2)
+POSTSELECT_STATES = {
+    '0': np.array([1, 0], dtype=np.complex128),
+    '1': np.array([0, 1], dtype=np.complex128),
+    '+': np.array([_R, _R], dtype=np.complex128),
+    '-': np.array([_R, -_R], dtype=np.complex128),
+    '+i': np.array([_R, 1j * _R], dtype=np.complex128),
+    '-i': np.array([_R, -1j * _R], dtype=np.complex128),
+}
+
+
+def postselect(sv, n_qubits, qubit, state='1'):
+    """
+    Project `qubit` onto `state` and renormalise.
+
+    `state` is one of '0', '1', '+', '-', '+i', '-i'. Returns
+    `(new_sv, probability)`, where `probability` is the chance of that outcome
+    before postselection. Raises ValueError if the probability is zero, since
+    postselection is only defined for outcomes that can occur (Aaronson,
+    Definition 1, condition (i)).
+    """
+    if state not in POSTSELECT_STATES:
+        raise ValueError(f"state must be one of {list(POSTSELECT_STATES)}, got {state!r}")
+    if not 0 <= qubit < n_qubits:
+        raise ValueError(f"qubit index out of range for {n_qubits} qubits")
+    if HAS_JAX:
+        ensure_x64()
+    psi = xp.asarray(POSTSELECT_STATES[state])
+    t = xp.asarray(sv).reshape(2 ** qubit, 2, 2 ** (n_qubits - qubit - 1))
+    overlap = xp.einsum('j,ijk->ik', xp.conj(psi), t)
+    probability = float(xp.sum(xp.abs(overlap) ** 2))
+    if probability <= 1e-15:
+        raise ValueError(f"outcome {state!r} on qubit {qubit} has zero probability")
+    projected = xp.einsum('j,ik->ijk', psi, overlap).reshape(-1)
+    return projected / np.sqrt(probability), probability

{dense_evolution-8.3.0 → dense_evolution-8.3.1}/dense_evolution/config.py

@@ -19,6 +19,8 @@ QuantumHardwareRegistry.__init__, circuit_to_energy_fn); set_precision()
 is the public opt-out for a caller who wants to choose precision
 explicitly, before constructing anything, and have that choice stick.
 """
+import functools
+
 import jax
 
 _explicit = False
@@ -47,3 +49,14 @@ def ensure_x64() -> None:
     precision -- never at import time."""
     if not _explicit:
         jax.config.update("jax_enable_x64", True)
+
+
+def with_x64(fn):
+    """Wrap `fn` so ensure_x64() runs before every call -- for public entry
+    points that build JAX arrays from user input, which JAX would otherwise
+    silently truncate to complex64/float32 if nothing else enabled x64 first."""
+    @functools.wraps(fn)
+    def wrapper(*args, **kwargs):
+        ensure_x64()
+        return fn(*args, **kwargs)
+    return wrapper

{dense_evolution-8.3.0 → dense_evolution-8.3.1}/dense_evolution/mitigation/__init__.py

@@ -8,10 +8,10 @@ snapshots (magic_entropy_shadows), a multi-qubit per-state magic monotone
 that module's own docstring for the distinction), and the classical
 Kullback-Leibler divergence over probability distributions (kl_divergence)."""
 from .zne import (
-    richardson_extrapolate, richardson_amplification_factor,
+    richardson_extrapolate, richardson_amplification_factor, zne_shot_allocation,
     zero_noise_extrapolation, polynomial_extrapolate,
     bounded_exponential_extrapolate,
-    project_to_physical, uhlmann_fidelity, zne_density_matrix,
+    project_to_physical, bloch_zne, bloch_zne_jit, uhlmann_fidelity, zne_density_matrix,
     jsd_predictive_zne_density_matrix,
     coherence_predictive_zne_density_matrix,
     classically_augmented_zne_phaseflip,
@@ -33,10 +33,10 @@ from .magic_entropy_shadows import (
 from .kl_divergence import kl_divergence, kl_divergence_jit
 
 __all__ = [
-    "richardson_extrapolate", "richardson_amplification_factor",
+    "richardson_extrapolate", "richardson_amplification_factor", "zne_shot_allocation",
     "zero_noise_extrapolation", "polynomial_extrapolate",
     "bounded_exponential_extrapolate",
-    "project_to_physical", "uhlmann_fidelity", "zne_density_matrix",
+    "project_to_physical", "bloch_zne", "bloch_zne_jit", "uhlmann_fidelity", "zne_density_matrix",
     "jsd_predictive_zne_density_matrix",
     "coherence_predictive_zne_density_matrix",
     "classically_augmented_zne_phaseflip",

{dense_evolution-8.3.0 → dense_evolution-8.3.1}/dense_evolution/mitigation/kl_divergence.py

@@ -41,6 +41,7 @@ Additive, not a replacement for the already-validated healing pipeline.
 """
 import jax
 import jax.numpy as jnp
+from ..config import with_x64
 
 __all__ = ["kl_divergence", "kl_divergence_jit"]
 
@@ -69,6 +70,7 @@ def _kl_divergence_core(p: jnp.ndarray, q: jnp.ndarray) -> jnp.ndarray:
     return jnp.where(is_support_violation, jnp.inf, finite_result)
 
 
+@with_x64
 def kl_divergence(p: jnp.ndarray, q: jnp.ndarray) -> float:
     """Classical Kullback-Leibler divergence D_KL(p||q), in bits.
 
@@ -88,6 +90,6 @@ def kl_divergence(p: jnp.ndarray, q: jnp.ndarray) -> float:
     return float(_kl_divergence_core(p, q))
 
 
-kl_divergence_jit = jax.jit(_kl_divergence_core)
+kl_divergence_jit = with_x64(jax.jit(_kl_divergence_core))
 """`jax.jit`-compiled entry point for `kl_divergence`. `p`/`q` must already
 be `float64` arrays. Returns a jnp scalar, not a Python `float`."""

{dense_evolution-8.3.0 → dense_evolution-8.3.1}/dense_evolution/mitigation/magic_entropy.py

@@ -45,6 +45,7 @@ import functools
 import jax
 import jax.numpy as jnp
 import numpy as np
+from ..config import with_x64
 
 __all__ = ["magic_entropy", "magic_entropy_jit"]
 
@@ -130,6 +131,7 @@ def _magic_entropy_core(rho: jnp.ndarray, eps: float = 1e-12) -> jnp.ndarray:
     return -jnp.sum(safe_ev * jnp.log2(safe_ev))
 
 
+@with_x64
 def magic_entropy(rho: jnp.ndarray) -> float:
     """Magic entropy of a single-qubit density matrix `rho` (2x2), in bits
     (log2) -- NOTE this differs from
@@ -157,7 +159,7 @@ def magic_entropy(rho: jnp.ndarray) -> float:
     return float(_magic_entropy_core(rho))
 
 
-magic_entropy_jit = jax.jit(_magic_entropy_core)
+magic_entropy_jit = with_x64(jax.jit(_magic_entropy_core))
 """`jax.jit`-compiled entry point for `magic_entropy`. `rho` must already
 be `complex128`. Returns a jnp scalar, not a Python `float` -- call
 `float(...)` yourself if you need one outside a jitted context."""

{dense_evolution-8.3.0 → dense_evolution-8.3.1}/dense_evolution/mitigation/magic_entropy_shadows.py

@@ -36,6 +36,7 @@ import jax.numpy as jnp
 import numpy as np
 
 from .magic_entropy import _key_unitary_k3
+from ..config import with_x64
 
 __all__ = [
     "sample_classical_shadow", "magic_entropy_from_shadows",
@@ -56,6 +57,7 @@ def _basis_u() -> jnp.ndarray:
     return jnp.stack([h, h @ sdag, jnp.eye(2, dtype=jnp.complex128)])
 
 
+@with_x64
 def sample_classical_shadow(rho: jnp.ndarray, n_snapshots: int, seed: int = 0) -> jnp.ndarray:
     """Simulates the real single-qubit random-Pauli classical-shadow
     measurement protocol against a known `rho` (2x2, pure or mixed): for
@@ -149,6 +151,7 @@ def _median_of_means(values: np.ndarray, n_groups: int) -> float:
     return float(np.median(group_means))
 
 
+@with_x64
 def magic_entropy_from_shadows(shadow_snapshots: jnp.ndarray, n_groups: int = 20) -> float:
     """Estimates `magic_entropy(rho)` from classical shadow snapshots of
     `rho` (from `sample_classical_shadow`, or real hardware measurement
@@ -208,6 +211,7 @@ _FIT_C = 11.751
 _FIT_P = 0.546
 
 
+@with_x64
 def approx_shadow_std(n_snapshots: int) -> float:
     """Rough approximate standard deviation (bits) of
     `magic_entropy_from_shadows`'s estimate at a given snapshot count,
@@ -225,6 +229,7 @@ def approx_shadow_std(n_snapshots: int) -> float:
     return _FIT_C / float(n_snapshots) ** _FIT_P
 
 
+@with_x64
 def fit_shadow_sample_complexity(rho: jnp.ndarray, exact_value: float, n_snapshots_list, n_trials: int, seed_base: int = 0):
     """Empirically measures `magic_entropy_from_shadows`'s standard
     deviation across `n_trials` independent shadow samplings at each