### wai-quantum 0.6.3: the wide stabilizer tableau, matrix product states at any angle, and fewer passes for the state vector, noisy shots and sparse Pauli sums

Every pinned digest is unchanged, and the state vector and the sparse-Pauli engine give the
same bits as before.

- **`quantum_tableau`** (new feature, in `full`): Clifford circuits on up to 32768 qubits.
  The Aaronson–Gottesman tableau is packed qubit by qubit, with 32-bit qubit indices, so a
  gate costs a few word operations per 64 rows.
  - **Outcomes:** `Tableau::support` computes the affine subspace the computational-basis
    outcomes are uniform over, by Gaussian elimination on the stabilizers with their signs
    tracked. A `Sampler` then draws each shot as a random combination of its basis,
    projected onto the measured qubits.
  - **Expectation values:** `Tableau::expectation` gives the exact ±1/0 of a Pauli string,
    from the destabilizers.
- **`quantum_mpsim`** (new feature, in `full`): matrix-product-state simulation of circuits
  with any angles, on up to 4096 qubits.
  - The chain is kept in mixed-canonical form, the center moved by QR. A gate on distant
    qubits is routed by swaps.
  - A two-qubit gate is a two-site update. It keeps the leading eigenvectors `U` of `M·M†`
    and makes `U†·M` the new center, so no singular value is divided by. A matrix taller
    than wide is first factored `M = Q·R`. The update is truncated to the bond dimension and
    a cutoff.
  - The eigensolver is new in `linalg`: Householder reflections to a real tridiagonal form,
    then QL with implicit shifts, in a fixed order with only `+ − × ÷ √`. Shares below 10⁻¹²
    of an update's weight are its rounding and are always dropped. An update that loses
    under 10⁻¹³ of its weight is not counted as a truncation.
  - Every truncation is reported: the bonds used, the summed discarded weight, and the
    fidelity estimate `Π(1 − εᵢ)`.
  - Readouts: amplitudes, Pauli expectation values by transfer matrices, and shots by
    sequential conditional sampling.
  - **Measured:**
    - With nothing truncated, every amplitude and expectation agrees with the dense state
      vector to 1e-10, and sampled frequencies match the probabilities. Under truncation,
      the estimate tracks the true fidelity.
    - On a 16-core desktop processor, on nearest-neighbour brickworks, against the crate's
      one-sided Jacobi split: 500 qubits at depth 10 take 0.75 s against 3.1 s, and depth
      20 at bond 64 takes 8.1 s against 35.9 s.
    - At depth 20 the estimate reports what truncation cost: 0.0426 at bond 64 and 0.4712
      at bond 128, the same under both splits.
- **Measured** on a random Clifford circuit of 10n gates at 10,000 qubits: the gates in
  49 ms, the outcome subspace in 353 ms, 1000 full-width shots in 154 ms, one expectation
  value in 27 ms. Over 40 random circuits on up to 10 qubits, the outcome set and its
  uniform probabilities match the dense state vector's, as do 800 Pauli expectation values.
- **Tiled state-vector passes** (`quantum_sv`). `StateVector::run` now groups consecutive
  gates into passes, as a `Schedule` sets (`run_scheduled`; `Schedule::UNTILED` gives a pass
  per gate). Each tile holds the amplitudes that agree on every bit outside the pass's local
  bits. A tile is copied into a buffer the size of a core's cache, every gate of the pass is
  applied to it there, and it is copied back.
  - A pass's dense gates act on its local bits. Diagonal gates may act on any bit.
  - Gates keep their order, and each amplitude goes through the same expressions as before,
    so the schedule never changes a bit. A test holds tiled and untiled states equal bit for
    bit at several tile and run sizes, at one thread and many.
  - A gate of three or more qubits on the top qubits used to fall back to one thread; it now
    runs in tiles. Gates on two or more qubits whose lowest stride allows it update eight
    groups side by side.
  - **Measured** on a 16-core desktop processor, 26 qubits, double precision:
    - a depth-20 brickwork of random rotations and fSim gates: 5.2 s → 2.3 s at fusion width 2;
    - a QFT: 2.9 s → 1.6 s at width 3;
    - a QAOA circuit: 2.9 s → 0.95 s.
- **Branching trajectories** (`quantum_noisy::branching_trajectories`). The shots of a noisy
  circuit have the law of independent trajectories, but shots that took the same errors
  share one state.
  - At each noise event a group splits as independent shots would. The number that err is
    binomial (drawn by geometric gaps, so the cost is the number of errors, not of shots),
    and each erring shot chooses its Pauli uniformly. A damping event's jumps are binomial
    in the group's own jump probability. The error-free prefix and the error-free majority
    therefore run once.
  - The largest branch carries on in place. Other branches run first in copies while fewer
    than a stated number of states are alive; past that, a branch waits and is replayed.
    Estimates, counts and histories depend on neither the thread count nor the state limit.
  - **Checked:** expectations land within four standard errors of the exact density matrix
    for three seeds, and counts with readout flips follow the exact distribution.
  - **Measured**, 18 qubits and 300 shots of a brickwork circuit, against independent
    trajectories: 28 times faster at two-qubit error 10⁻³, 5.6 times at 5·10⁻³, and 1.9
    times at 2·10⁻² with damping.
- **The sparse-Pauli engine on a worker pool** (`quantum_spd`). A large sum is updated by
  workers started once per run, each taking pieces of the table as it frees up.
  - A run of consecutive Clifford gates is applied in one pass, each term through the gates
    in order.
  - A rotation's new terms have distinct strings, so each existing coefficient receives at
    most one addition. The rest are appended in table order, and dropped magnitudes are
    summed in table order.
  - The thread count therefore changes the time and never a bit: a test compares one, two,
    three and eight threads bit for bit. `expectation_threaded` takes an explicit count.
  - **Measured:** the 127-qubit kicked-Ising run (20 steps, threshold 10⁻⁴, 2.2 million terms
    at its peak) takes 9.4 s, against 49 s on one thread, with the same value.

- **The tensor-engine member's kernel compiles for a device.**
  - **The kernel compiled for the simulator only.** The helper
    (`quantum_fabric/tensor_engine_helper.py`) defined its kernel inside `main()` and
    imported the kernel toolchain there. The simulator runs the kernel as Python, so it found
    the names. Compiling for a device traces the kernel's source and looks its names up in
    the kernel's module, so it found none and refused the first request (`failed to resolve
    name`). On a device every test of the member failed at that request. The kernel now sits
    at module level. `main()` still imports the toolchain after the target is chosen, but
    binds it as module globals.
  - **The compiler is found beside the interpreter.** Compiling for a device runs the
    toolchain's compiler from `PATH`, and the interpreter the member is given need not be on
    it. The helper now puts that interpreter's directory first on `PATH` for a device target.
  - **Checked** off the device with the toolchain's own compiler: the kernel now compiles
    for the device target. Execution there needs the device's runtime. The simulator path is
    unchanged.

