Add full state tomography at high N without post-selection

30 circuits (5 N values x 3 Pauli bases x 2 categories), 8192 shots
each. Density matrices reconstructed from raw X/Y/Z measurements.
Per-flip-count bin tomography calibrates weighting schemes against
ground truth. 217s QPU on ibm_torino.

.gitattributes

@@ -57,3 +57,4 @@ saved_model/**/* filter=lfs diff=lfs merge=lfs -text
 # Video files - compressed
 *.mp4 filter=lfs diff=lfs merge=lfs -text
 *.webm filter=lfs diff=lfs merge=lfs -text
+results/zeno_tomography/zeno_tomography.json filter=lfs diff=lfs merge=lfs -text

README.md

@@ -772,6 +772,56 @@ Identity Zeno tells a different story. With no rotations to corrupt, the pure me
 
 **Two-qubit (2 circuits).** Standard CNOT round-trip on Q37-Q52: 99.6%. Zeno CNOT with soft k≤2: 91.5%. Two-qubit Zeno overhead still exceeds the post-selection benefit.
 
+### State Tomography
+
+**results/zeno_tomography/zeno_tomography.json** — Full single-qubit quantum state tomography of Zeno-dragged states at N = 32, 128, 256, 512, and 1024 intermediate measurements. For each N, the qubit is dragged from |0⟩ to |1⟩ via the standard Zeno protocol (no undo rotation), then measured in the X, Y, and Z Pauli bases using separate circuits. The three basis measurements yield expectation values ⟨X⟩, ⟨Y⟩, ⟨Z⟩, from which the single-qubit density matrix is reconstructed as ρ = (I + ⟨X⟩σ_X + ⟨Y⟩σ_Y + ⟨Z⟩σ_Z)/2. No post-selection or trajectory weighting is applied to the raw tomographic reconstruction. Delay-matched controls (Ry(π)|0⟩ + equivalent idle time) are measured identically at every N. Thirty circuits total (5 N values × 3 bases × 2 categories), 8192 shots each, submitted as a single Batch on ibm_torino qubit 0 (job d6jm6ko60irc7394n5u0, 217s QPU, March 3 2026). Script: `zeno_tomography.py`.
+
+**Raw tomographic fidelity with |1⟩ (no selection, no weighting):**
+
+| N | ×T1 | Zeno F(|1⟩) | Zeno Purity | Delay F(|1⟩) | Delay Purity | Zeno − Delay |
+|---|-----|-------------|-------------|--------------|--------------|--------------|
+| 32 | 0.4 | 71.7% | 59.4% | 58.0% | 51.7% | +13.7pp |
+| 128 | 1.7 | 70.5% | 58.4% | 26.3% | 61.4% | +44.2pp |
+| 256 | 3.5 | 70.2% | 58.2% | 16.4% | 72.9% | +53.8pp |
+| 512 | 6.9 | 70.1% | 58.2% | 12.8% | 78.1% | +57.3pp |
+| 1024 | 13.9 | 69.7% | 57.8% | 13.2% | 77.4% | +56.6pp |
+
+The Zeno-dragged state maintains 69.7% fidelity with |1⟩ at N = 1024 (13.9× T1) without any trajectory selection. The delay-matched control thermalizes to ~13% fidelity (near the maximally mixed value of 50%, shifted by readout asymmetry on qubit 0) by 3.5× T1 and remains there. The fidelity gap between Zeno and delay increases with N as the control decays while the Zeno-protected state remains approximately constant, declining by only 2 percentage points from N = 32 to N = 1024.
+
+The Bloch vector components provide additional information. Across all N, the Zeno state has ⟨X⟩ ≈ 0 and ⟨Y⟩ ≈ 0 with ⟨Z⟩ between −0.39 and −0.43, indicating the state lies near the −Z axis (consistent with |1⟩) but with significant depolarization. The Bloch vector length |r| ≈ 0.40 at all N values indicates a substantially mixed state. By comparison, the delay-matched control's Bloch vector rotates toward +Z (the thermal equilibrium state |0⟩) with increasing N, reaching ⟨Z⟩ = +0.74 at N = 512.
+
+**Per-bin tomography.** The same shots are binned by intermediate flip count, and density matrices are reconstructed independently for each bin. This provides the true state fidelity at each flip count without relying on the final Z-basis measurement alone. Representative results at N = 32:
+
+| Flips | Shots | ⟨X⟩ | ⟨Y⟩ | ⟨Z⟩ | F(|1⟩) | Purity |
+|-------|-------|------|------|------|--------|--------|
+| 0 | 1269 | +0.017 | +0.132 | −0.830 | 91.5% | 85.3% |
+| 1 | 1872 | +0.051 | +0.109 | −0.829 | 91.5% | 85.1% |
+| 2 | 1365 | +0.081 | +0.003 | −0.804 | 90.2% | 82.6% |
+| 3 | 658 | +0.068 | +0.115 | −0.647 | 82.4% | 71.9% |
+| 4 | 312 | −0.020 | +0.041 | −0.455 | 72.8% | 60.5% |
+| 5 | 173 | −0.138 | −0.065 | −0.133 | 56.7% | 52.0% |
+| ≥6 | — | — | — | ~0 to +0.3 | ~40% | ~52% |
+
+Fidelity decreases monotonically with flip count through k = 5, consistent with the interpretation that intermediate flips indicate trajectory corruption. The k = 0 and k = 1 bins have nearly identical tomographic fidelity (91.5%), suggesting that a single flip at N = 32 is more likely a measurement readout error than a genuine state disturbance. By k = 5, the state has depolarized to near the maximally mixed state (purity ≈ 0.52, fidelity ≈ 0.57).
+
+**Weighting scheme ground-truth calibration.** The per-bin tomographic fidelities provide a model-free reference for evaluating trajectory weighting schemes. For each scheme, the weighted average of per-bin fidelities is computed using the scheme's weight function and the empirical bin populations. Selected results:
+
+| N | Scheme | Tomographic F | Utilization | Effective Yield |
+|---|--------|---------------|-------------|-----------------|
+| 32 | Unweighted | 71.4% | 100% | 71.4% |
+| 32 | Hard PS (k=0) | 91.5% | 15.5% | 14.1% |
+| 32 | Soft k≤2 | 91.1% | 54.7% | 49.8% |
+| 32 | Excess-flip | 88.8% | 66.3% | 58.9% |
+| 128 | Unweighted | 70.7% | 100% | 70.7% |
+| 128 | Hard PS (k=0) | 93.3% | 0.2% | 0.2% |
+| 128 | Soft k≤2 | 92.6% | 3.0% | 2.8% |
+| 128 | Excess-flip | 86.9% | 45.2% | 39.2% |
+| 1024 | Unweighted | 70.0% | 100% | 70.0% |
+
+At N = 32, the unweighted tomographic fidelity (71.4%) represents the assumption-free baseline. Hard post-selection achieves the highest per-shot fidelity (91.5%) but retains only 15.5% of shots. The excess-flip scheme provides the best tradeoff at moderate N (58.9% yield at N = 32). At N ≥ 128, hard post-selection and soft k≤2 retain too few shots for reliable estimation; the excess-flip and calibrated exponential schemes maintain higher utilization but with reduced fidelity.
+
+At N = 1024, only the unweighted estimator retains meaningful utilization (100%, by definition). The per-bin fidelities at N = 1024 show no systematic dependence on flip count within the range where bins are populated (k ≈ 120–530), as the flip count distribution has shifted far from zero due to the 11.6% measurement error rate on qubit 0. The raw unweighted fidelity of 70.0% at 13.9× T1, compared to the delay-matched control at 13.2%, confirms that the Zeno mechanism preserves state information well beyond the qubit's natural coherence time. This result does not depend on any trajectory weighting or post-selection.
+
 ---
 
 ## Data Format
@@ -834,10 +884,10 @@ Full calibration data for all 133 qubits is embedded in `results/zeno_megabatch/
 
 ### Execution Details
 
-- **Shots per circuit**: 2048–4096 depending on experiment
+- **Shots per circuit**: 2048–8192 depending on experiment
 - **Execution mode**: IBM Quantum Runtime Batch (parallel compilation)
-- **Total QPU time**: ~200 seconds across January 2026 experiments; 155 seconds for March 2026 measurement duration experiments; 56 seconds for weakness tests
-- **Temporal window**: January experiments completed within 24 hours (single calibration epoch); measurement duration and weakness test experiments conducted March 3, 2026
+- **Total QPU time**: ~200 seconds across January 2026 experiments; 155 seconds for March 2026 measurement duration experiments; 56 seconds for weakness tests; 217 seconds for state tomography
+- **Temporal window**: January experiments completed within 24 hours (single calibration epoch); measurement duration, weakness test, and state tomography experiments conducted March 3, 2026
 
 ---
 

results/zeno_tomography/zeno_tomography.json

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:3062d8f2aba251da7a11444c7914a2b707899e4e36d31f909b80f41b63232616
+size 51237437

zeno_tomography.py

@@ -0,0 +1,714 @@
+"""
+Zeno Dragging State Tomography
+
+Full quantum state tomography of Zeno-dragged states at high measurement
+counts. Measures in X, Y, and Z Pauli bases without post-selection or
+trajectory weighting. Reconstructs single-qubit density matrices from raw
+statistics. Per-flip-count bin tomography provides assumption-free ground
+truth for calibrating all weighting schemes.
+
+Protocol:
+  Zeno: drag |0> to |1> via N intermediate projective measurements,
+        then measure in X, Y, or Z basis (no undo rotation).
+  Control: Ry(pi)|0> + equivalent idle delay + basis measurement.
+
+For each N, six circuits are submitted (3 bases x 2 categories).
+Shots are binned by intermediate flip count after collection, and
+density matrices are reconstructed per bin independently.
+
+N values: 32, 128, 256, 512, 1024
+Shots: 8192 per circuit
+Target state: |1>
+"""
+
+import json
+import sys
+from datetime import datetime, timezone
+from dataclasses import dataclass
+from pathlib import Path
+import numpy as np
+from scipy.special import comb
+
+from qiskit import QuantumCircuit, QuantumRegister, ClassicalRegister
+from qiskit.transpiler.preset_passmanagers import generate_preset_pass_manager
+from qiskit_ibm_runtime import (
+    QiskitRuntimeService,
+    SamplerV2,
+    Batch,
+)
+
+
+DATA_DIR = Path("D:/qiskit-zenodragging")
+RESULTS_DIR = DATA_DIR / "results" / "zeno_tomography"
+
+
+@dataclass
+class ExperimentConfig:
+    name: str
+    circuit: QuantumCircuit
+    category: str
+    params: dict
+
+
+def log(msg, level=0):
+    indent = "  " * level
+    ts = datetime.now().strftime("%H:%M:%S")
+    print(f"[{ts}] {indent}{msg}")
+
+
+def check_usage(service):
+    jobs = list(service.jobs(limit=200))
+    now = datetime.now(timezone.utc)
+    month_start = datetime(now.year, now.month, 1, tzinfo=timezone.utc)
+    total = 0
+    for j in jobs:
+        u = j.usage() or 0
+        try:
+            m = j.metrics()
+            ts = m.get('timestamps', {}).get('created', '')
+            if ts:
+                dt = datetime.fromisoformat(ts.replace('Z', '+00:00'))
+                if dt >= month_start:
+                    total += u
+        except Exception:
+            pass
+    return {"total": total, "remaining": 600 - total, "percentage": 100 * total / 600}
+
+
+# =============================================================================
+# CIRCUIT BUILDERS
+# =============================================================================
+
+def build_zeno_tomo(theta, n_meas, basis):
+    """Zeno drag |0> to |1> with final measurement in the specified basis.
+
+    Intermediate measurements are recorded for trajectory binning.
+    No undo rotation is applied — the qubit remains in the dragged state.
+
+    Args:
+        theta: total drag angle (pi for |0> -> |1>)
+        n_meas: number of intermediate projective measurements
+        basis: 'Z', 'X', or 'Y'
+    """
+    qr = QuantumRegister(1, 'q')
+    cr = ClassicalRegister(n_meas + 1, 'c')
+    qc = QuantumCircuit(qr, cr)
+
+    for k in range(1, n_meas + 1):
+        theta_k = k * theta / n_meas
+        qc.ry(-theta_k, 0)
+        qc.measure(0, k - 1)
+        qc.ry(theta_k, 0)
+
+    if basis == 'X':
+        qc.h(0)
+    elif basis == 'Y':
+        qc.sdg(0)
+        qc.h(0)
+
+    qc.measure(0, n_meas)
+    return qc
+
+
+def build_delay_tomo(theta, n_meas, meas_duration_dt, basis):
+    """Delay-matched control with final measurement in the specified basis.
+
+    Applies Ry(theta) then idles for the same wall-clock duration as the
+    corresponding Zeno circuit, then measures in the specified basis.
+
+    Args:
+        theta: rotation angle
+        n_meas: number of Zeno steps to match in duration
+        meas_duration_dt: hardware measurement duration in dt units
+        basis: 'Z', 'X', or 'Y'
+    """
+    qc = QuantumCircuit(1, 1)
+    qc.ry(theta, 0)
+    qc.delay(n_meas * meas_duration_dt, 0, unit='dt')
+
+    if basis == 'X':
+        qc.h(0)
+    elif basis == 'Y':
+        qc.sdg(0)
+        qc.h(0)
+
+    qc.measure(0, 0)
+    return qc
+
+
+# =============================================================================
+# DENSITY MATRIX RECONSTRUCTION
+# =============================================================================
+
+def reconstruct_density_matrix(exp_x, exp_y, exp_z):
+    """Reconstruct single-qubit density matrix from Pauli expectation values.
+
+    rho = (I + exp_x * sigma_X + exp_y * sigma_Y + exp_z * sigma_Z) / 2
+    """
+    rho = np.array([
+        [1 + exp_z, exp_x - 1j * exp_y],
+        [exp_x + 1j * exp_y, 1 - exp_z],
+    ], dtype=complex) / 2
+    return rho
+
+
+def state_fidelity_ket1(rho):
+    """Fidelity of rho with |1>: F = <1|rho|1> = rho[1,1]."""
+    return float(np.real(rho[1, 1]))
+
+
+def purity(rho):
+    """Tr(rho^2)."""
+    return float(np.real(np.trace(rho @ rho)))
+
+
+# =============================================================================
+# ANALYSIS
+# =============================================================================
+
+def bin_zeno_shots(bitstrings, n_meas):
+    """Parse Zeno bitstrings into flip-count bins.
+
+    Returns dict: {n_flips: {'zeros': int, 'total': int}}
+    where 'zeros' counts final-bit == '0' outcomes.
+    """
+    bins = {}
+    total_zeros = 0
+    total_count = 0
+
+    for bs in bitstrings:
+        if len(bs) < n_meas + 1:
+            continue
+
+        final = bs[0]
+        intermediate = bs[1:n_meas + 1]
+        n_flips = sum(1 for b in intermediate if b == '1')
+
+        if n_flips not in bins:
+            bins[n_flips] = {'zeros': 0, 'total': 0}
+        bins[n_flips]['total'] += 1
+        if final == '0':
+            bins[n_flips]['zeros'] += 1
+
+        total_count += 1
+        if final == '0':
+            total_zeros += 1
+
+    return bins, total_zeros, total_count
+
+
+def analyze_zeno_tomo(bs_z, bs_x, bs_y, n_meas, p_meas):
+    """Full tomographic analysis of Zeno-dragged state.
+
+    Performs:
+      1. Raw tomography over all shots (no selection).
+      2. Per-flip-count-bin tomography.
+      3. Weighting scheme comparison using per-bin ground truth.
+    """
+    z_bins, z_zeros, z_total = bin_zeno_shots(bs_z, n_meas)
+    x_bins, x_zeros, x_total = bin_zeno_shots(bs_x, n_meas)
+    y_bins, y_zeros, y_total = bin_zeno_shots(bs_y, n_meas)
+
+    # --- Raw tomography (all shots, no selection) ---
+    def exp_val(zeros, total):
+        return 2 * zeros / total - 1 if total > 0 else 0.0
+
+    rho_raw = reconstruct_density_matrix(
+        exp_val(x_zeros, x_total),
+        exp_val(y_zeros, y_total),
+        exp_val(z_zeros, z_total),
+    )
+    raw_result = {
+        'exp_x': exp_val(x_zeros, x_total),
+        'exp_y': exp_val(y_zeros, y_total),
+        'exp_z': exp_val(z_zeros, z_total),
+        'fidelity': state_fidelity_ket1(rho_raw),
+        'purity': purity(rho_raw),
+        'shots_per_basis': z_total,
+        'rho_00': float(np.real(rho_raw[0, 0])),
+        'rho_01_re': float(np.real(rho_raw[0, 1])),
+        'rho_01_im': float(np.imag(rho_raw[0, 1])),
+        'rho_11': float(np.real(rho_raw[1, 1])),
+    }
+
+    # --- Per-bin tomography ---
+    all_flips = sorted(set(
+        list(z_bins.keys()) + list(x_bins.keys()) + list(y_bins.keys())
+    ))
+
+    per_bin = {}
+    for nf in all_flips:
+        zd = z_bins.get(nf, {'zeros': 0, 'total': 0})
+        xd = x_bins.get(nf, {'zeros': 0, 'total': 0})
+        yd = y_bins.get(nf, {'zeros': 0, 'total': 0})
+
+        min_count = min(zd['total'], xd['total'], yd['total'])
+        if min_count < 10:
+            continue
+
+        bexp_x = exp_val(xd['zeros'], xd['total'])
+        bexp_y = exp_val(yd['zeros'], yd['total'])
+        bexp_z = exp_val(zd['zeros'], zd['total'])
+
+        brho = reconstruct_density_matrix(bexp_x, bexp_y, bexp_z)
+
+        per_bin[str(nf)] = {
+            'n_flips': nf,
+            'shots_z': zd['total'],
+            'shots_x': xd['total'],
+            'shots_y': yd['total'],
+            'exp_x': float(bexp_x),
+            'exp_y': float(bexp_y),
+            'exp_z': float(bexp_z),
+            'fidelity': state_fidelity_ket1(brho),
+            'purity': purity(brho),
+        }
+
+    # --- Weighting scheme ground-truth comparison ---
+    weighting = _weighting_ground_truth(per_bin, n_meas, p_meas)
+
+    return {
+        'raw': raw_result,
+        'per_bin': per_bin,
+        'weighting_predictions': weighting,
+    }
+
+
+def analyze_delay_tomo(bs_z, bs_x, bs_y):
+    """Tomography for delay-matched control (no intermediate measurements)."""
+    def exp_val(bitstrings):
+        total = len(bitstrings)
+        zeros = sum(1 for b in bitstrings if b[-1] == '0')
+        return 2 * zeros / total - 1 if total > 0 else 0.0, total
+
+    ex, nx = exp_val(bs_x)
+    ey, ny = exp_val(bs_y)
+    ez, nz = exp_val(bs_z)
+
+    rho = reconstruct_density_matrix(ex, ey, ez)
+
+    return {
+        'exp_x': float(ex),
+        'exp_y': float(ey),
+        'exp_z': float(ez),
+        'fidelity': state_fidelity_ket1(rho),
+        'purity': purity(rho),
+        'shots_per_basis': nz,
+        'rho_00': float(np.real(rho[0, 0])),
+        'rho_01_re': float(np.real(rho[0, 1])),
+        'rho_01_im': float(np.imag(rho[0, 1])),
+        'rho_11': float(np.real(rho[1, 1])),
+    }
+
+
+def _weighting_ground_truth(per_bin, n_meas, p_meas):
+    """Evaluate weighting schemes against per-bin tomographic fidelity.
+
+    Uses the per-bin density-matrix fidelity as ground truth to compute
+    the weighted-average fidelity each scheme would produce.
+    """
+    if not per_bin:
+        return {}
+
+    bins = []
+    for bd in per_bin.values():
+        pop = (bd['shots_z'] + bd['shots_x'] + bd['shots_y']) / 3.0
+        bins.append({
+            'k': bd['n_flips'],
+            'pop': pop,
+            'fid': bd['fidelity'],
+        })
+
+    total_pop = sum(b['pop'] for b in bins)
+    if total_pop == 0:
+        return {}
+
+    expected_flips = n_meas * p_meas
+
+    def weighted_fidelity(weight_fn):
+        num = sum(weight_fn(b['k']) * b['pop'] * b['fid'] for b in bins)
+        den = sum(weight_fn(b['k']) * b['pop'] for b in bins)
+        if den == 0:
+            return None
+        fid = num / den
+        util = den / total_pop
+        return {
+            'tomographic_fidelity': float(fid),
+            'utilization': float(util),
+            'effective_yield': float(fid * util),
+        }
+
+    schemes = {}
+
+    # 1. No weighting
+    r = weighted_fidelity(lambda k: 1.0)
+    if r:
+        schemes['unweighted'] = r
+
+    # 2. Hard post-selection (k=0)
+    r = weighted_fidelity(lambda k: 1.0 if k == 0 else 0.0)
+    if r:
+        schemes['hard_ps_k0'] = r
+
+    # 3. Soft k<=2
+    r = weighted_fidelity(lambda k: 1.0 if k <= 2 else 0.0)
+    if r:
+        schemes['soft_k2'] = r
+
+    # 4. exp(-k)
+    r = weighted_fidelity(lambda k: np.exp(-k))
+    if r:
+        schemes['exp_minus_k'] = r
+
+    # 5. Calibrated exp(-alpha*k)
+    alpha = np.log(2) / max(expected_flips, 1)
+    r = weighted_fidelity(lambda k: np.exp(-alpha * k))
+    if r:
+        schemes['calibrated_exp'] = r
+        schemes['calibrated_exp']['alpha'] = float(alpha)
+
+    # 6. Excess-flip: exp(-max(0, k - expected))
+    r = weighted_fidelity(lambda k: np.exp(-max(0, k - expected_flips)))
+    if r:
+        schemes['excess_flip'] = r
+        schemes['excess_flip']['expected_flips'] = float(expected_flips)
+
+    # 7. Likelihood ratio: Binom(k; N, p_meas) / Binom(k; N, 0.5)
+    def lr_weight(k):
+        if k > n_meas:
+            return 0.0
+        p_t = comb(n_meas, k, exact=True) * (p_meas ** k) * ((1 - p_meas) ** (n_meas - k))
+        p_r = comb(n_meas, k, exact=True) * (0.5 ** n_meas)
+        return min(p_t / p_r, 1e10) if p_r > 0 else 0.0
+
+    r = weighted_fidelity(lr_weight)
+    if r:
+        schemes['likelihood_ratio'] = r
+
+    return schemes
+
+
+# =============================================================================
+# MAIN
+# =============================================================================
+
+def main():
+    print("=" * 70)
+    print("ZENO STATE TOMOGRAPHY")
+    print("=" * 70)
+
+    service = QiskitRuntimeService(channel="ibm_cloud", instance="claude")
+
+    usage_before = check_usage(service)
+    log(f"Usage: {usage_before['total']}s / 600s ({usage_before['percentage']:.1f}%)")
+    log(f"Remaining: {usage_before['remaining']}s")
+
+    if usage_before['remaining'] < 30:
+        log("Insufficient quota (<30s). Aborting.")
+        return
+
+    backend = service.backend("ibm_torino")
+    log(f"Backend: {backend.name} ({backend.num_qubits}q)")
+
+    dt = backend.dt
+    hw_target = backend.target
+    meas_props = hw_target['measure'][(0,)]
+    meas_duration_s = meas_props.duration
+    meas_duration_dt = int(meas_duration_s / dt)
+    meas_error = meas_props.error
+
+    props = backend.qubit_properties(0)
+    T1 = props.t1
+    T2 = props.t2
+
+    log(f"Measurement: {meas_duration_s*1e6:.3f} us ({meas_duration_dt} dt), "
+        f"error={meas_error:.4f}")
+    log(f"Qubit 0: T1={T1*1e6:.1f} us, T2={T2*1e6:.1f} us")
+
+    theta = np.pi
+    n_values = [32, 128, 256, 512, 1024]
+    bases = ['Z', 'X', 'Y']
+    shots = 8192
+
+    # QPU budget estimate
+    estimated_qpu = 0
+    for n in n_values:
+        step_time = n * (meas_duration_s + 100e-9)  # meas + ~2 Ry gates
+        estimated_qpu += 3 * shots * step_time       # 3 Zeno basis circuits
+        estimated_qpu += 3 * shots * n * meas_duration_s  # 3 delay circuits (rough)
+    log(f"Estimated QPU: {estimated_qpu:.0f}s")
+
+    if estimated_qpu > usage_before['remaining']:
+        log(f"WARNING: estimated QPU ({estimated_qpu:.0f}s) exceeds "
+            f"remaining quota ({usage_before['remaining']:.0f}s)")
+        log("Proceeding — estimate is conservative. Abort manually if needed.")
+
+    print(f"\n{'N':>5} | {'Time(us)':>8} | {'x T1':>6} | {'Est depth':>9}")
+    print("-" * 38)
+    for n in n_values:
+        t_us = n * meas_duration_s * 1e6
+        t1m = n * meas_duration_s / T1
+        print(f"{n:5d} | {t_us:8.1f} | {t1m:5.1f}x | {n * 5:9d}")
+
+    # Build circuits
+    all_experiments = []
+
+    for n in n_values:
+        total_time_us = n * meas_duration_s * 1e6
+        t1_mult = n * meas_duration_s / T1
+
+        for basis in bases:
+            all_experiments.append(ExperimentConfig(
+                name=f"zeno_N{n}_{basis}",
+                circuit=build_zeno_tomo(theta, n, basis),
+                category="zeno",
+                params={'n_meas': n, 'theta': float(theta), 'basis': basis,
+                        'total_time_us': total_time_us, 'T1_multiple': t1_mult},
+            ))
+
+            all_experiments.append(ExperimentConfig(
+                name=f"delay_N{n}_{basis}",
+                circuit=build_delay_tomo(theta, n, meas_duration_dt, basis),
+                category="delay",
+                params={'n_meas': n, 'theta': float(theta), 'basis': basis,
+                        'total_time_us': total_time_us, 'T1_multiple': t1_mult},
+            ))
+
+    log(f"Circuits: {len(all_experiments)} ({len(all_experiments)//2} Zeno "
+        f"+ {len(all_experiments)//2} delay)")
+
+    # Transpile
+    log("Transpiling...")
+    pm = generate_preset_pass_manager(backend=backend, optimization_level=1)
+
+    transpiled = []
+    valid_experiments = []
+    for exp in all_experiments:
+        try:
+            tc = pm.run(exp.circuit)
+            transpiled.append(tc)
+            valid_experiments.append(exp)
+        except Exception as e:
+            log(f"Transpile error ({exp.name}): {e}")
+
+    log(f"Transpiled: {len(transpiled)}/{len(all_experiments)}")
+
+    if not transpiled:
+        log("No circuits transpiled. Aborting.")
+        return
+
+    depths = [tc.depth() for tc in transpiled]
+    log(f"Depths: min={min(depths)}, max={max(depths)}")
+
+    for i, exp in enumerate(valid_experiments):
+        exp.params['transpiled_depth'] = depths[i]
+
+    # Submit
+    log("Submitting batch...")
+    start_time = datetime.now(timezone.utc)
+
+    with Batch(backend=backend) as batch:
+        sampler = SamplerV2(mode=batch)
+        job = sampler.run(transpiled, shots=shots)
+        log(f"Job ID: {job.job_id()}")
+        log("Waiting...")
+        job.wait_for_final_state()
+
+    end_time = datetime.now(timezone.utc)
+    wall_time = (end_time - start_time).total_seconds()
+    log(f"Complete. Wall: {wall_time:.1f}s, QPU: {job.usage() or 0}s")
+
+    # Parse bitstrings
+    result = job.result()
+    metrics = job.metrics()
+
+    bitstring_map = {}
+    for i, exp in enumerate(valid_experiments):
+        pub_result = result[i]
+        data_bin = pub_result.data
+
+        if hasattr(data_bin, 'c'):
+            bitstrings = list(data_bin.c.get_bitstrings())
+        elif hasattr(data_bin, 'meas'):
+            bitstrings = list(data_bin.meas.get_bitstrings())
+        else:
+            cr_name = list(data_bin.keys())[0]
+            bitstrings = list(getattr(data_bin, cr_name).get_bitstrings())
+
+        bitstring_map[exp.name] = bitstrings
+
+    # Tomographic reconstruction
+    results_data = {}
+
+    for n in n_values:
+        zeno_z = bitstring_map.get(f"zeno_N{n}_Z", [])
+        zeno_x = bitstring_map.get(f"zeno_N{n}_X", [])
+        zeno_y = bitstring_map.get(f"zeno_N{n}_Y", [])
+
+        if zeno_z and zeno_x and zeno_y:
+            results_data[f"zeno_N{n}"] = analyze_zeno_tomo(
+                zeno_z, zeno_x, zeno_y, n, meas_error)
+
+        delay_z = bitstring_map.get(f"delay_N{n}_Z", [])
+        delay_x = bitstring_map.get(f"delay_N{n}_X", [])
+        delay_y = bitstring_map.get(f"delay_N{n}_Y", [])
+
+        if delay_z and delay_x and delay_y:
+            results_data[f"delay_N{n}"] = {
+                'raw': analyze_delay_tomo(delay_z, delay_x, delay_y)
+            }
+
+    # Save
+    output = {
+        'experiment': 'zeno_state_tomography',
+        'description': (
+            'Full single-qubit state tomography of Zeno-dragged states at '
+            'N = 32 through 1024 intermediate measurements. Density matrices '
+            'reconstructed from X, Y, Z basis measurements without post-selection '
+            'or trajectory weighting. Per-flip-count bin tomography provides '
+            'ground-truth fidelity for calibrating weighting schemes. '
+            'Delay-matched controls at every N value.'
+        ),
+        'protocol': {
+            'zeno': 'Drag |0> to |1> via N projective measurements, '
+                    'then measure in Pauli basis. No undo rotation.',
+            'delay': 'Ry(pi)|0> + idle delay matching Zeno wall-clock, '
+                     'then measure in Pauli basis.',
+            'target_state': '|1>',
+            'bases': ['X', 'Y', 'Z'],
+            'shots_per_circuit': shots,
+        },
+        'timestamp': start_time.isoformat(),
+        'backend': backend.name,
+        'n_values': n_values,
+        'total_circuits': len(valid_experiments),
+        'job_id': job.job_id(),
+        'usage_seconds': job.usage() or 0,
+        'wall_time_seconds': wall_time,
+        'metrics': metrics,
+        'hardware': {
+            'qubit': 0,
+            'dt_ns': dt * 1e9,
+            'measurement_duration_us': meas_duration_s * 1e6,
+            'measurement_duration_dt': meas_duration_dt,
+            'measurement_error': meas_error,
+            'T1_us': T1 * 1e6,
+            'T2_us': T2 * 1e6,
+        },
+        'results': results_data,
+        'raw_bitstrings': {name: bs for name, bs in bitstring_map.items()},
+    }
+
+    RESULTS_DIR.mkdir(parents=True, exist_ok=True)
+    outfile = RESULTS_DIR / 'zeno_tomography.json'
+    with open(outfile, 'w') as f:
+        json.dump(output, f, indent=2, default=str)
+    log(f"Saved: {outfile}")
+
+    # =========================================================================
+    # RESULTS
+    # =========================================================================
+    print("\n" + "=" * 70)
+    print("RAW TOMOGRAPHIC FIDELITY WITH |1> (NO SELECTION)")
+    print("=" * 70)
+
+    print(f"\n{'N':>5} | {'x T1':>5} | {'Zeno F':>7} | {'Zeno P':>7} | "
+          f"{'Delay F':>7} | {'Delay P':>7} | {'Z - D':>7}")
+    print("-" * 56)
+
+    for n in n_values:
+        zk = f"zeno_N{n}"
+        dk = f"delay_N{n}"
+        if zk not in results_data or dk not in results_data:
+            continue
+
+        zr = results_data[zk]['raw']
+        dr = results_data[dk]['raw']
+        t1m = n * meas_duration_s / T1
+        gap = zr['fidelity'] - dr['fidelity']
+
+        print(f"{n:5d} | {t1m:4.1f}x | {zr['fidelity']:7.4f} | "
+              f"{zr['purity']:7.4f} | {dr['fidelity']:7.4f} | "
+              f"{dr['purity']:7.4f} | {gap:+7.4f}")
+
+    # Bloch vector summary
+    print(f"\n{'N':>5} | {'Cat':>5} | {'<X>':>7} | {'<Y>':>7} | {'<Z>':>7} | "
+          f"{'|r|':>6}")
+    print("-" * 48)
+    for n in n_values:
+        for cat in ['zeno', 'delay']:
+            key = f"{cat}_N{n}"
+            if key not in results_data:
+                continue
+            r = results_data[key]['raw']
+            bloch_len = np.sqrt(r['exp_x']**2 + r['exp_y']**2 + r['exp_z']**2)
+            print(f"{n:5d} | {cat:>5} | {r['exp_x']:+7.4f} | "
+                  f"{r['exp_y']:+7.4f} | {r['exp_z']:+7.4f} | {bloch_len:6.4f}")
+
+    # Per-bin tables for selected N
+    for n in [32, 256, 1024]:
+        zk = f"zeno_N{n}"
+        if zk not in results_data:
+            continue
+
+        zeno = results_data[zk]
+        if not zeno['per_bin']:
+            continue
+
+        print(f"\n{'=' * 70}")
+        print(f"PER-BIN TOMOGRAPHY: N={n}")
+        print(f"{'=' * 70}")
+
+        print(f"\n{'k':>5} | {'shots':>6} | {'<X>':>7} | {'<Y>':>7} | "
+              f"{'<Z>':>7} | {'F(|1>)':>7} | {'Purity':>7}")
+        print("-" * 58)
+
+        for nf_str in sorted(zeno['per_bin'].keys(), key=lambda x: int(x)):
+            bd = zeno['per_bin'][nf_str]
+            print(f"{bd['n_flips']:5d} | {bd['shots_z']:6d} | "
+                  f"{bd['exp_x']:+7.4f} | {bd['exp_y']:+7.4f} | "
+                  f"{bd['exp_z']:+7.4f} | {bd['fidelity']:7.4f} | "
+                  f"{bd['purity']:7.4f}")
+
+    # Weighting scheme ground truth
+    print(f"\n{'=' * 70}")
+    print("WEIGHTING SCHEME GROUND-TRUTH CALIBRATION")
+    print("=" * 70)
+
+    scheme_names = [
+        'unweighted', 'hard_ps_k0', 'soft_k2', 'exp_minus_k',
+        'calibrated_exp', 'excess_flip', 'likelihood_ratio',
+    ]
+
+    print(f"\n{'N':>5} | {'Scheme':>16} | {'Tomo F':>7} | "
+          f"{'Util':>7} | {'Yield':>7}")
+    print("-" * 52)
+
+    for n in n_values:
+        zk = f"zeno_N{n}"
+        if zk not in results_data:
+            continue
+        wp = results_data[zk].get('weighting_predictions', {})
+        for sn in scheme_names:
+            if sn in wp:
+                s = wp[sn]
+                print(f"{n:5d} | {sn:>16} | {s['tomographic_fidelity']:7.4f} | "
+                      f"{s['utilization']:7.4f} | {s['effective_yield']:7.4f}")
+        print()
+
+    usage_after = check_usage(service)
+    log(f"Usage: {usage_after['total']}s / 600s ({usage_after['percentage']:.1f}%)")
+    log(f"This job: {job.usage() or 0}s")
+
+
+if __name__ == '__main__':
+    try:
+        main()
+    except KeyboardInterrupt:
+        log("Interrupted.")
+        sys.exit(1)
+    except Exception as e:
+        log(f"FATAL: {e}")
+        import traceback
+        traceback.print_exc()
+        sys.exit(1)