Add multi-axis validation, weakness tests, interval experiment

zeno_multiaxis.py: 48-circuit experiment across qubits, angles,
schedules, DD hybrids, two-qubit. Sinusoidal schedule +1.2-4.7pp
over uniform. Adaptive N scales with angle. DD in gaps +5pp.

tests/test_weaknesses.py: W1-W6 systematic stress tests.
zeno_interval.py: inter-measurement gap sweep.

README.md

@@ -371,13 +371,15 @@ Based on the comprehensive experimental data presented in this section, we can n
 
 | Application | Recommended Strategy | Rationale |
 |-------------|----------------------|-----------|
-| Maximum data extraction | Exponential weighting | +92% effective yield vs hard PS |
-| Position-sensitive | Position-aware weighting | Penalizes early flips more |
-| VQE/QAOA estimation | Exponential or soft k≤2 | Best balance of fidelity and yield |
-| Quick benchmarking | Soft k≤2 | 90%+ yield, 96%+ fidelity |
+| Maximum data extraction | Soft k≤2 | 90%+ yield, 96%+ fidelity, no tuning required |
+| Position-sensitive | Position-aware thresholding | Rejects pos-0 multi-flip trajectories, keeps the rest |
+| VQE/QAOA estimation | Soft k≤2 | Best balance of fidelity and yield (see W5 weakness test) |
+| Quick benchmarking | Soft k≤1 | 88% yield, 96.5% fidelity |
 | Maximum fidelity | Hard k=0 | Highest per-shot fidelity (but wasteful) |
 
-Hard post-selection is never optimal. In all eleven circuits tested across multiple experiments, at least one alternative strategy outperformed hard post-selection on effective yield while maintaining comparable fidelity. For most applications, exponential weighting with formula w = exp(-n_flips) provides the best combination of simplicity and performance: it is easy to implement, requires no calibration or fitting, and extracts 92% more effective signal than hard post-selection from the same quantum data. The only scenario where hard post-selection remains appropriate is when maximum per-shot fidelity is required regardless of throughput cost—a rare requirement in practical quantum computing where shot budgets are typically the limiting resource.
+Hard post-selection is never optimal. In all eleven circuits tested across multiple experiments, at least one alternative strategy outperformed hard post-selection on effective yield while maintaining comparable fidelity.
+
+**Note on exponential weighting**: Earlier versions of this document recommended `w = exp(−n_flips)` as the best general strategy. Weakness test W5 showed this is suboptimal: soft k≤2 thresholding achieves 90.1% effective yield vs. 74.7% for exponential weighting on the same data. The exponential function assigns weight 0.37 to one-flip trajectories that have 96.5% fidelity — penalizing them far more than their quality warrants. Soft thresholds that accept low-flip trajectories at full weight extract more signal. Exponential weighting remains useful for composition analysis (where it eliminates the composition penalty, as shown in the Gate Composition section) but is not recommended as the default strategy for single-gate analysis.
 
 ---
 
@@ -675,6 +677,101 @@ The X Zeno protocol loses its advantage over delay-matched controls at just 5μs
 
 Identity Zeno tells a different story. With no rotations to corrupt, the pure measurement-based freeze declines only 6 percentage points across the entire sweep — from 95.4% at gap=0 to 89.4% at gap=100μs. Even when the inter-measurement interval approaches T1, the projective measurement still partially resets the decoherence clock. The measurement mechanism is robust; the gate operations between measurements are the fragile component.
 
+### Weakness Tests
+
+**tests/weakness_tests.json** — Systematic stress-testing of six identified methodological weaknesses in the dataset's claims. Three tests run offline against existing data (zero QPU cost); three run new hardware experiments on ibm_torino (51 circuits, 4096 shots each, job d6jkidm33pjc73dm3upg, 56s QPU, March 3 2026). The test script is at `tests/test_weaknesses.py`.
+
+**W1: Single-qubit generalization.** The original gate comparison experiments all used qubit 0, which has an unusually high measurement error rate (11.6%) compared to the chip median. To test whether the Zeno advantage generalizes, we ran identical Zeno vs. standard comparisons on 5 qubits spanning the full quality range: Q0 (T1=115μs, meas_err=11.6%), Q37 (T1=60μs, meas_err=1.0%), Q85 (T1=3.6μs, meas_err=4.6%), Q95 (T1=174μs, meas_err=2.7%), and Q131 (T1=333μs, meas_err=1.8%).
+
+| Qubit | T1 (μs) | Meas Err | Std I | Zeno I | Std X | Zeno X | Zeno−Std I | Zeno−Std X |
+|-------|---------|----------|-------|--------|-------|--------|------------|------------|
+| Q0 | 115.2 | 11.6% | 90.2% | 94.7% | 89.8% | 88.6% | +4.5pp | −1.2pp |
+| Q37 | 59.9 | 1.0% | 100.0% | 100.0% | 100.0% | 97.6% | −0.0pp | −2.4pp |
+| Q85 | 3.6 | 4.6% | 98.2% | 98.9% | 98.6% | 96.4% | +0.7pp | −2.2pp |
+| Q95 | 174.3 | 2.7% | 99.4% | 99.8% | 98.9% | 96.7% | +0.5pp | −2.1pp |
+| Q131 | 332.5 | 1.8% | 99.4% | 99.7% | 99.5% | 96.9% | +0.2pp | −2.6pp |
+
+**Result: FAIL.** Zeno improves identity gate fidelity on all qubits (+0.2 to +4.5pp), but *hurts* X gate fidelity on every qubit tested (−1.2 to −2.6pp). The original dataset's Q0 results flatter Zeno because Q0 has the highest measurement error on the chip — more errors to filter means more post-selection benefit. On low-error qubits where standard gates already achieve 99–100% fidelity, Zeno's overhead (extra Ry gates, mid-circuit measurements) introduces more errors than post-selection removes. The Zeno gate improvement claim is qubit-dependent and should not be generalized from Q0 alone.
+
+**W2: Measurement error independence.** The excess-flip weighting scheme assumes measurement errors are independent Bernoulli events. We tested this assumption against identity Zeno data (N=32, 4096 shots) where there are no Ry rotations — any observed flips are purely from measurement backaction.
+
+- **Transition autocorrelation**: Lag-1 autocorrelation of transition events (0→1 or 1→0) is +0.41 (t=53.8, p≈10⁻¹⁷⁸). Transitions cluster rather than occurring independently.
+- **Binomial goodness-of-fit**: Chi-squared = 15,323 (p≈0). Observed 958 zero-flip shots vs. 75 expected under Binomial(32, 0.116). Measurement backaction creates long runs of correlated outcomes.
+- **Monotonicity**: Fidelity decreases monotonically with flip count through k=7 (96.9% → 36.4%), but 4 violations occur at k≥8 where bin sizes are <10 shots. The monotonic regime (k=0 through k=7, covering 98.3% of all shots) validates flip-count-based weighting for practical purposes despite the independence violation.
+
+**Result: FAIL on statistical assumptions, PASS on practical utility.** The Binomial independence model is wrong — backaction creates correlated flip runs. But flip count remains a monotonically decreasing predictor of fidelity across the range that matters (0–7 flips, 98% of data). The excess-flip weighting formula works in practice even though its theoretical justification is incorrect.
+
+**W3: Zero-noise extrapolation comparison.** The original error mitigation comparison tested only dynamical decoupling and gate twirling. We added ZNE (zero-noise extrapolation) via unitary folding at 1×, 3×, 5×, and 7× noise levels, with Richardson extrapolation to zero noise.
+
+| Gate | Standard | ZNE (linear) | ZNE (quadratic) | Zeno (excess-flip) | Zeno (hard PS) |
+|------|----------|-------------|-----------------|-------------------|---------------|
+| I | 89.8% | 89.9% | 89.6% | 94.7% | 95.6% |
+| X | 89.3% | 88.9% | 88.5% | 88.6% | 94.9% |
+
+**Result: MIXED.** ZNE provides negligible improvement on this hardware (identity: +0.1pp, X: −0.4pp over standard). The noise model may be too non-Markovian for Richardson extrapolation to help. Zeno hard PS beats ZNE on per-shot fidelity for both gates. On effective yield at 100% utilization, ZNE (89.9%) and Zeno excess-flip (88.6%) are comparable for X gate. Zeno wins on identity (94.7% vs 89.9%). Neither method dominates the other across all metrics.
+
+**W4: VQE fidelity constancy.** The VQE bias correction formula `z_corrected = z_measured / (2f − 1)` assumes constant fidelity f across all rotation angles. We extracted per-theta hard-PS fidelity from the VQE data:
+
+| θ/π | Hard-PS Fidelity |
+|-----|-----------------|
+| 0.000 | 100.0% |
+| 0.125 | 89.5% |
+| 0.250 | 82.8% |
+| 0.375 | 67.9% |
+| 0.500 | 55.6% |
+| 0.625 | 36.5% |
+| 0.750 | 19.6% |
+| 0.875 | 4.8% |
+| 1.000 | 8.0% |
+
+**Result: FAIL.** Fidelity ranges from 4.8% to 100% — a 95pp spread. The constant-fidelity assumption is catastrophically wrong. The VQE correction formula divides by (2f−1), and when f drops below 50% the correction factor flips sign. Per-theta calibration reduces RMSE from 18.99 to 1.25 — a 93.4% improvement. The published VQE RMSE numbers (0.101 for "calibrated") used eigenstate calibration which partially mitigates this, but the bias correction discussion in the README should be updated to note that per-theta fidelity variation is extreme.
+
+**W5: ML model vs. simple heuristics.** The README recommends exponential weighting `w = exp(−n_flips)` as the best strategy. We compared 8 strategies on x_freeze_n8 trajectory data (4096 trajectories):
+
+| Strategy | Fidelity | Utilization | Effective Yield |
+|----------|----------|-------------|-----------------|
+| Hard (k=0) | 96.8% | 68.8% | 66.6% |
+| Soft (k≤1) | 96.5% | 90.7% | 87.6% |
+| Soft (k≤2) | 96.3% | 93.5% | 90.1% |
+| exp(−k) | 96.6% | 77.3% | 74.7% |
+| Excess-flip | 96.6% | 77.5% | 74.9% |
+| Early-penalty | 96.6% | 79.2% | 76.5% |
+| Pos0-aware | 96.4% | 92.0% | 88.7% |
+| Uniform | 91.2% | 100.0% | 91.2% |
+
+**Result: exp(−k) is suboptimal.** Soft k≤2 (90.1% yield) beats exp(−k) (74.7% yield) by 15pp. Position-aware thresholding (88.7%) also beats exp(−k). The exponential weighting penalizes 1-flip trajectories too aggressively — assigning them weight 0.37 when they have 96.5% fidelity. Soft thresholds that accept these trajectories at full weight extract far more signal. The recommended strategy table should be updated: soft k≤2 for most applications, not exponential weighting.
+
+**W6: Computation between measurements.** The inter-measurement gap experiment showed X Zeno loses its advantage at 5μs of idle delay. But idle delay is not computation — real algorithms perform gate operations between measurements. We tested Zeno with 0, 1, 2, and 4 identity-equivalent gate pairs (Ry(ε)Ry(−ε), ε=0.01) interleaved between each measurement step:
+
+| Work gates | Zeno (excess-flip) | Zeno (hard PS) | Depth-matched | Standard | Zeno−Standard |
+|------------|-------------------|---------------|---------------|----------|--------------|
+| 0 | 93.1% | 96.1% | 88.8% | 89.0% | +4.1pp |
+| 1 | 91.9% | 95.4% | 88.2% | 89.0% | +2.8pp |
+| 2 | 91.4% | 93.8% | 88.1% | 89.0% | +2.4pp |
+| 4 | 91.8% | 95.5% | 87.8% | 89.0% | +2.7pp |
+
+**Result: REFUTED.** The Zeno advantage survives interleaved computation. With 4 gate pairs between each measurement (32 extra gates total), Zeno still beats standard by +2.7pp and beats depth-matched by +3.9pp. The advantage decays 33% from the zero-work baseline but does not vanish. The idle-gap experiment measured decoherence during idle time, not the effect of active computation. Gate-based work between measurements preserves coherence (the gates keep the qubit driven) while idle gaps allow T1/T2 decay.
+
+### Multi-Axis Validation
+
+**results/zeno_multiaxis/zeno_multiaxis.json** — 48 circuits testing Zeno dragging across qubits, rotation angles, measurement counts, measurement schedules, and idle gap mitigation. Single Batch on ibm_torino, 4096 shots each, job d6jl6lkgmsgc73bv7ia0, 55s QPU, March 3 2026. Script: `zeno_multiaxis.py`.
+
+**Multi-qubit gate comparison (18 circuits).** Repeats the gate comparison on Q37 (1.0% meas err), Q95 (2.7%), Q131 (1.8%), replacing Q0 (11.6%). Zeno improves identity gate fidelity on 2/3 qubits (+0.1 to +1.1pp). Zeno hurts X gate fidelity on all 3 (−4.1 to −6.9pp). Confirms W1: the gate comparison advantage depends on qubit measurement error rate.
+
+**Adaptive-N (8 circuits).** N=4 and N=8 produce identical fidelity at θ=π/8 (99.5%). At θ=π, N=16 reaches 97.9% vs 93.2% at N=8. Optimal N scales with rotation angle.
+
+**Sinusoidal measurement schedule (6 circuits).** θ_k = θ·sin²(kπ/2N) vs uniform θ_k = kθ/N, three angles, N=8. The sinusoidal schedule produces higher soft k≤2 fidelity at every angle: +1.2pp at π/2, +2.1pp at 3π/4, +4.7pp at π.
+
+| θ | Uniform k≤2 | Sinusoidal k≤2 | Difference |
+|---------|-------------|----------------|------------|
+| π/2 | 97.6% | 98.9% | +1.2pp |
+| 3π/4 | 96.0% | 98.1% | +2.1pp |
+| π | 92.0% | 96.7% | +4.7pp |
+
+**Zeno-DD hybrid (4 circuits).** Hahn echo DD in 10μs inter-measurement gaps recovers +5.0pp fidelity over bare gaps for X Zeno (81.5% → 86.6%). Identity Zeno is unaffected by gaps (99.9%).
+
+**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.
+
 ---
 
 ## Data Format
@@ -739,8 +836,8 @@ Full calibration data for all 133 qubits is embedded in `results/zeno_megabatch/
 
 - **Shots per circuit**: 2048–4096 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 experiment
-- **Temporal window**: January experiments completed within 24 hours (single calibration epoch); measurement duration experiment 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
+- **Temporal window**: January experiments completed within 24 hours (single calibration epoch); measurement duration and weakness test experiments conducted March 3, 2026
 
 ---
 

tests/test_weaknesses.py

@@ -0,0 +1,1427 @@
+"""
+Test All Six Identified Weaknesses — Single Script, Single Batch
+
+OFFLINE (zero QPU cost):
+  W2: Measurement error independence assumption in excess-flip weighting
+  W4: VQE bias correction assumes constant fidelity across theta
+  W5: ML model vs simple heuristic marginal improvement
+
+HARDWARE (one Batch submission, ~51 circuits, ~25s QPU):
+  W1: Single-qubit, single-backend generalization — test 5 diverse qubits
+  W3: Incomplete error mitigation comparison — add ZNE
+  W6: Practical gap — computation between measurements kills advantage
+"""
+
+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 scipy import stats as sp_stats
+
+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"
+TESTS_DIR = DATA_DIR / "tests"
+TESTS_DIR.mkdir(exist_ok=True)
+
+
+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}
+
+
+# =============================================================================
+# SHARED CIRCUIT BUILDERS
+# =============================================================================
+
+def build_standard(theta, qubit=0, n_qubits=1):
+    """Standard: Ry(theta) Ry(-theta) measure. Ideal = |0>."""
+    qc = QuantumCircuit(n_qubits, 1)
+    qc.ry(theta, qubit)
+    qc.ry(-theta, qubit)
+    qc.measure(qubit, 0)
+    return qc
+
+
+def build_zeno(theta, n_meas, qubit=0, n_qubits=1):
+    """Zeno drag 0->theta via N measurements, then undo. Ideal = |0>."""
+    qr = QuantumRegister(n_qubits, '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, qubit)
+        qc.measure(qubit, k - 1)
+        qc.ry(theta_k, qubit)
+    qc.ry(-theta, qubit)
+    qc.measure(qubit, n_meas)
+    return qc
+
+
+def build_delay_matched(theta, n_meas, meas_duration_dt, qubit=0, n_qubits=1):
+    """Standard gate + idle delay = same wall-clock as Zeno."""
+    qc = QuantumCircuit(n_qubits, 1)
+    qc.ry(theta, qubit)
+    qc.delay(n_meas * meas_duration_dt, qubit, unit='dt')
+    qc.ry(-theta, qubit)
+    qc.measure(qubit, 0)
+    return qc
+
+
+def build_zne_folded(theta, n_folds, qubit=0, n_qubits=1):
+    """ZNE circuit: Ry(theta)[Ry(-theta)Ry(theta)]^n_folds then Ry(-theta) measure.
+
+    n_folds=0: standard circuit (depth 1 pair)
+    n_folds=1: 3x noise (depth 3 pairs)
+    n_folds=2: 5x noise (depth 5 pairs)
+    """
+    qc = QuantumCircuit(n_qubits, 1)
+    qc.ry(theta, qubit)
+    for _ in range(n_folds):
+        qc.ry(-theta, qubit)
+        qc.ry(theta, qubit)
+    qc.ry(-theta, qubit)
+    qc.measure(qubit, 0)
+    return qc
+
+
+def build_zeno_with_work(theta, n_meas, work_gates, qubit=0, n_qubits=1):
+    """Zeno drag with 'work' gates (identity-equivalent) between measurements.
+
+    Simulates practical use: computation happens between Zeno measurements.
+    work_gates: number of Ry(eps)Ry(-eps) pairs inserted between each step.
+    Net effect is identity, but adds gate noise and wall-clock time.
+    """
+    eps = 0.01  # tiny rotation — effectively identity but real gates
+    qr = QuantumRegister(n_qubits, '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, qubit)
+        qc.measure(qubit, k - 1)
+        qc.ry(theta_k, qubit)
+        # Insert "work" between measurements
+        if k < n_meas:
+            for _ in range(work_gates):
+                qc.ry(eps, qubit)
+                qc.ry(-eps, qubit)
+
+    qc.ry(-theta, qubit)
+    qc.measure(qubit, n_meas)
+    return qc
+
+
+def build_depth_matched_work(theta, n_meas, work_gates, qubit=0, n_qubits=1):
+    """Same gate structure as zeno_with_work but no measurements."""
+    eps = 0.01
+    qc = QuantumCircuit(n_qubits, 1)
+    qc.ry(theta, qubit)
+    for k in range(1, n_meas + 1):
+        theta_k = k * theta / n_meas
+        qc.ry(-theta_k, qubit)
+        qc.barrier()  # placeholder for measurement
+        qc.ry(theta_k, qubit)
+        if k < n_meas:
+            for _ in range(work_gates):
+                qc.ry(eps, qubit)
+                qc.ry(-eps, qubit)
+    qc.ry(-theta, qubit)
+    qc.measure(qubit, 0)
+    return qc
+
+
+# =============================================================================
+# SHARED ANALYSIS
+# =============================================================================
+
+def analyze_standard(bitstrings):
+    total = len(bitstrings)
+    zeros = sum(1 for b in bitstrings if b[-1] == '0')
+    return {'total': total, 'fidelity': zeros / total, 'type': 'standard'}
+
+
+def analyze_zeno(bitstrings, n_meas, p_meas):
+    """Full Zeno analysis with multiple weighting schemes."""
+    total = len(bitstrings)
+    successful = 0
+    correct_given_success = 0
+    flip_bins = {}
+
+    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 flip_bins:
+            flip_bins[n_flips] = {'total': 0, 'correct': 0}
+        flip_bins[n_flips]['total'] += 1
+        if final == '0':
+            flip_bins[n_flips]['correct'] += 1
+
+        if n_flips == 0:
+            successful += 1
+            if final == '0':
+                correct_given_success += 1
+
+    success_rate = successful / total if total > 0 else 0
+    fidelity_hard = correct_given_success / successful if successful > 0 else 0
+    expected_meas_flips = n_meas * p_meas
+
+    # exp(-k)
+    w1_c, w1_t = 0, 0
+    for nf, data in flip_bins.items():
+        w = np.exp(-nf)
+        w1_c += w * data['correct']
+        w1_t += w * data['total']
+    fid_exp_k = w1_c / w1_t if w1_t > 0 else 0
+
+    # Excess-flip
+    w3_c, w3_t = 0, 0
+    for nf, data in flip_bins.items():
+        excess = max(0, nf - expected_meas_flips)
+        w = np.exp(-excess)
+        w3_c += w * data['correct']
+        w3_t += w * data['total']
+    fid_excess = w3_c / w3_t if w3_t > 0 else 0
+
+    # Likelihood ratio
+    w4_c, w4_t = 0, 0
+    for nf, data in flip_bins.items():
+        if nf <= n_meas:
+            p_target = comb(n_meas, nf, exact=True) * (p_meas ** nf) * ((1 - p_meas) ** (n_meas - nf))
+            p_random = comb(n_meas, nf, exact=True) * (0.5 ** n_meas)
+            w = min(p_target / p_random, 1e10) if p_random > 0 else 0
+        else:
+            w = 0
+        w4_c += w * data['correct']
+        w4_t += w * data['total']
+    fid_likelihood = w4_c / w4_t if w4_t > 0 else 0
+
+    all_flips = []
+    for nf, data in flip_bins.items():
+        all_flips.extend([nf] * data['total'])
+    mean_flips = np.mean(all_flips) if all_flips else 0
+    std_flips = np.std(all_flips) if all_flips else 0
+
+    return {
+        'total': total,
+        'successful': successful,
+        'success_rate': success_rate,
+        'fidelity_hard_ps': fidelity_hard,
+        'fidelity_exp_k': fid_exp_k,
+        'fidelity_excess': fid_excess,
+        'fidelity_likelihood': fid_likelihood,
+        'expected_meas_flips': expected_meas_flips,
+        'mean_flips': mean_flips,
+        'std_flips': std_flips,
+        'flip_distribution': {str(k): v for k, v in sorted(flip_bins.items())},
+        'type': 'zeno',
+    }
+
+
+# =============================================================================
+# OFFLINE TEST W2: Measurement Error Independence
+# =============================================================================
+
+def test_w2_measurement_independence():
+    """Test whether excess-flip weighting's independence assumption holds.
+
+    Key insight: raw outcome correlations are HIGH in identity Zeno because
+    measurement backaction is projective — a single measurement error physically
+    flips the qubit, and it stays flipped until another error flips it back.
+    This is NOT a violation of the independence assumption.
+
+    The correct test is on TRANSITIONS (0->1 or 1->0 events), not raw outcomes.
+    Each transition is a separate physical event (measurement error or T1 decay).
+    If transitions are independent, the excess-flip model is justified.
+
+    Three sub-tests:
+      2a: Transition rate analysis — are transitions (not raw flips) independent?
+      2b: Flip count vs Binomial — does the distribution match?
+      2c: Does flip count predict fidelity monotonically? (functional test)
+    """
+    print("\n" + "=" * 70)
+    print("W2: MEASUREMENT ERROR INDEPENDENCE TEST")
+    print("=" * 70)
+
+    results = {}
+
+    # Load diagnostic data (has explicit identity Zeno)
+    diag_path = RESULTS_DIR / 'zeno_diagnostic' / 'zeno_diagnostic.json'
+    hn = json.load(open(RESULTS_DIR / 'zeno_high_n_sweep' / 'zeno_high_n_sweep.json'))
+    p_meas = hn['hardware_timing']['measurement_error']
+
+    if diag_path.exists():
+        diag = json.load(open(diag_path))
+    else:
+        diag = None
+
+    # Get identity Zeno bitstrings
+    if diag is not None and 'identity_zeno_N32' in diag['results']:
+        entry = diag['results']['identity_zeno_N32']
+        bitstrings = entry.get('raw_bitstrings', [])
+        n_meas = entry.get('params', {}).get('n_meas', 32)
+        source = "identity_zeno_N32 (diagnostic)"
+    else:
+        entry = hn['results'].get('zeno_X_N32', {})
+        bitstrings = entry.get('raw_bitstrings', [])
+        n_meas = entry.get('params', {}).get('n_meas', 32)
+        source = "zeno_X_N32 (fallback — expect structured correlations)"
+
+    print(f"\n  Data source: {source}")
+    print(f"  Bitstrings: {len(bitstrings)}, N={n_meas}")
+
+    # --- Test 2a: Transition analysis ---
+    print("\n--- 2a: Transition rate analysis ---")
+    print("  Raw outcomes are correlated by design (backaction is projective).")
+    print("  Testing TRANSITIONS (0->1, 1->0) for independence instead.")
+
+    if len(bitstrings) >= 50:
+        n_pos = min(n_meas, 32)
+        transition_counts = []
+        run_lengths = []  # lengths of consecutive-same-value runs
+
+        for bs in bitstrings:
+            if len(bs) < n_meas + 1:
+                continue
+            intermediate = bs[1:n_meas + 1]
+            seq = [int(intermediate[i] == '1') for i in range(n_pos)]
+
+            # Count transitions (value changes between adjacent positions)
+            transitions = sum(1 for i in range(len(seq) - 1) if seq[i] != seq[i + 1])
+            transition_counts.append(transitions)
+
+            # Compute run lengths
+            current_run = 1
+            for i in range(1, len(seq)):
+                if seq[i] == seq[i - 1]:
+                    current_run += 1
+                else:
+                    run_lengths.append(current_run)
+                    current_run = 1
+            run_lengths.append(current_run)
+
+        n_shots = len(transition_counts)
+        mean_transitions = np.mean(transition_counts)
+        std_transitions = np.std(transition_counts)
+        mean_run = np.mean(run_lengths)
+
+        # Under independent Bernoulli(p) outcomes, expected transitions = (N-1)*2*p*(1-p)
+        expected_transitions = (n_pos - 1) * 2 * p_meas * (1 - p_meas)
+        # Under correlated (backaction) model, transitions are much rarer
+        # because a flip persists until the next error event
+
+        # If backaction dominates: expected transitions ~ 2 * N * p_backaction
+        # where p_backaction is the rate of actual state-change events
+        # Mean run length under independence = 1 / (2*p*(1-p)) ~ 4.9 for p=0.12
+        # Mean run length under backaction = 1 / p_transition (much longer)
+
+        print(f"  Shots analyzed:          {n_shots}")
+        print(f"  Mean transitions/shot:   {mean_transitions:.2f}")
+        print(f"  Expected (independent):  {expected_transitions:.2f}")
+        print(f"  Ratio (obs/expected):    {mean_transitions/expected_transitions:.3f}")
+        print(f"  Mean run length:         {mean_run:.2f}")
+        print(f"  Expected run (indep):    {1/(2*p_meas*(1-p_meas)):.2f}")
+
+        # Now test: are transitions themselves independent?
+        # Build binary transition sequence and test pairwise correlation
+        trans_adj_phis = []
+        for bs in bitstrings[:500]:
+            if len(bs) < n_meas + 1:
+                continue
+            intermediate = bs[1:n_meas + 1]
+            seq = [int(intermediate[i] == '1') for i in range(n_pos)]
+            trans_seq = [1 if seq[i] != seq[i + 1] else 0 for i in range(len(seq) - 1)]
+
+            if len(trans_seq) >= 4:
+                ts = np.array(trans_seq, dtype=float)
+                if ts.std() > 0:
+                    ac = np.corrcoef(ts[:-1], ts[1:])[0, 1]
+                    if not np.isnan(ac):
+                        trans_adj_phis.append(ac)
+
+        if trans_adj_phis:
+            mean_trans_ac = np.mean(trans_adj_phis)
+            t_stat, p_val = sp_stats.ttest_1samp(trans_adj_phis, 0)
+
+            print(f"\n  Transition-sequence lag-1 autocorrelation:")
+            print(f"    Mean: {mean_trans_ac:+.4f}")
+            print(f"    t={t_stat:.2f}, p={p_val:.6f}")
+
+            if abs(mean_trans_ac) > 0.1 and p_val < 0.01:
+                verdict_2a = "FAIL: Transitions themselves are correlated. Error events cluster."
+            elif abs(mean_trans_ac) > 0.05 and p_val < 0.05:
+                verdict_2a = "WEAK: Mild transition correlation. Excess-flip may slightly misweight."
+            else:
+                verdict_2a = "PASS: Transitions are uncorrelated. Each error event is independent."
+
+            print(f"\n  VERDICT: {verdict_2a}")
+
+            results['w2a_transition_analysis'] = {
+                'n_shots': n_shots,
+                'mean_transitions': float(mean_transitions),
+                'expected_transitions': float(expected_transitions),
+                'transition_ratio': float(mean_transitions / expected_transitions),
+                'mean_run_length': float(mean_run),
+                'transition_autocorrelation': float(mean_trans_ac),
+                't_stat': float(t_stat),
+                'p_value': float(p_val),
+                'verdict': verdict_2a,
+            }
+
+    # --- Test 2b: Flip count distribution vs Binomial ---
+    print("\n--- 2b: Flip count distribution ---")
+
+    if diag is not None:
+        id_entry = diag['results'].get('identity_zeno_N32', {})
+        id_analysis = id_entry.get('analysis', {})
+        flip_dist = id_analysis.get('flip_distribution', {})
+        id_n_meas = id_entry.get('params', {}).get('n_meas', 32)
+        id_p_meas = diag['hardware_timing']['measurement_error']
+    else:
+        flip_dist = {}
+        id_n_meas = 0
+        id_p_meas = p_meas
+
+    if flip_dist and id_n_meas > 0:
+        observed_counts = {}
+        total_shots = 0
+        for k_str, v in flip_dist.items():
+            k = int(k_str)
+            count = v['total']
+            observed_counts[k] = count
+            total_shots += count
+
+        # Expected binomial distribution
+        max_k = max(observed_counts.keys())
+        observed = []
+        expected = []
+        labels = []
+        for k in range(max_k + 1):
+            obs = observed_counts.get(k, 0)
+            exp = total_shots * sp_stats.binom.pmf(k, id_n_meas, id_p_meas)
+            if exp >= 5:
+                observed.append(obs)
+                expected.append(exp)
+                labels.append(k)
+
+        if len(observed) >= 3:
+            # Normalize expected to match observed total (required by scipy)
+            obs_arr = np.array(observed, dtype=float)
+            exp_arr = np.array(expected, dtype=float)
+            exp_arr = exp_arr * obs_arr.sum() / exp_arr.sum()
+
+            chi2, p_value = sp_stats.chisquare(obs_arr, exp_arr)
+
+            print(f"  Identity Zeno N={id_n_meas}, p_meas={id_p_meas:.4f}")
+            print(f"  Total shots: {total_shots}")
+            print(f"  Bins tested: {len(observed)} (k={labels[0]}..{labels[-1]})")
+            print(f"  Chi-squared: {chi2:.2f}")
+            print(f"  p-value:     {p_value:.6f}")
+            print(f"  Expected mean flips: {id_n_meas * id_p_meas:.1f}")
+            print(f"  Observed mean flips: {id_analysis.get('mean_flips', 0):.1f}")
+
+            # Also print observed vs expected for each bin
+            print(f"\n  {'k':>3} | {'Observed':>8} | {'Expected':>8} | {'Ratio':>6}")
+            print(f"  " + "-" * 35)
+            for k, o, e in zip(labels, obs_arr, exp_arr):
+                print(f"  {k:3d} | {o:8.0f} | {e:8.1f} | {o/e:6.2f}")
+
+            if p_value < 0.001:
+                verdict_2b = "FAIL: Flip counts deviate from Binomial. Backaction creates correlated runs."
+            elif p_value < 0.05:
+                verdict_2b = "WEAK: Marginal deviation (p<0.05). Mild departure from independence."
+            else:
+                verdict_2b = "PASS: Flip counts consistent with Binomial."
+
+            print(f"\n  VERDICT: {verdict_2b}")
+
+            results['w2b_binomial_gof'] = {
+                'n_meas': id_n_meas,
+                'p_meas': float(id_p_meas),
+                'total_shots': total_shots,
+                'chi2': float(chi2),
+                'p_value': float(p_value),
+                'bins_tested': len(observed),
+                'verdict': verdict_2b,
+            }
+    else:
+        print("  No identity Zeno data available. Skipping.")
+
+    # --- Test 2c: Does flip count monotonically predict fidelity? ---
+    print("\n--- 2c: Flip-count-to-fidelity monotonicity ---")
+    print("  If excess-flip weighting is valid, more flips => lower fidelity,")
+    print("  regardless of whether flips are independent or correlated.")
+
+    if diag is not None and 'identity_zeno_N32' in diag['results']:
+        id_analysis = diag['results']['identity_zeno_N32']['analysis']
+        flip_dist = id_analysis.get('flip_distribution', {})
+
+        fid_by_flips = []
+        print(f"\n  {'Flips':>5} | {'Shots':>5} | {'Correct':>7} | {'Fidelity':>8}")
+        print(f"  " + "-" * 35)
+        for k in sorted(int(x) for x in flip_dist.keys()):
+            v = flip_dist[str(k)]
+            fid = v['correct'] / v['total'] if v['total'] > 0 else 0
+            if v['total'] >= 10:
+                fid_by_flips.append((k, fid))
+            print(f"  {k:5d} | {v['total']:5d} | {v['correct']:7d} | {fid:8.4f}")
+
+        # Check monotonicity
+        if len(fid_by_flips) >= 3:
+            fids_only = [f for _, f in fid_by_flips]
+            violations = sum(1 for i in range(len(fids_only) - 1)
+                           if fids_only[i + 1] > fids_only[i] + 0.02)
+
+            if violations == 0:
+                verdict_2c = "PASS: Fidelity decreases monotonically with flip count. Weighting is justified."
+            elif violations <= 1:
+                verdict_2c = "PASS: Nearly monotonic (1 minor violation). Weighting is reasonable."
+            else:
+                verdict_2c = f"FAIL: {violations} monotonicity violations. Flip count is a poor fidelity predictor."
+
+            print(f"\n  Monotonicity violations: {violations}")
+            print(f"  VERDICT: {verdict_2c}")
+
+            results['w2c_monotonicity'] = {
+                'fidelity_by_flips': [(k, float(f)) for k, f in fid_by_flips],
+                'violations': violations,
+                'verdict': verdict_2c,
+            }
+
+    return results
+
+
+# =============================================================================
+# OFFLINE TEST W4: VQE Bias Correction Assumes Constant Fidelity
+# =============================================================================
+
+def test_w4_vqe_fidelity_constancy():
+    """Test whether fidelity is constant across theta for the VQE correction.
+
+    The correction z_corrected = z_measured / (2f - 1) assumes f is constant.
+    We check: does the fidelity measured per-theta vary significantly?
+    If so, a per-theta calibration would be more accurate.
+    """
+    print("\n" + "=" * 70)
+    print("W4: VQE FIDELITY CONSTANCY TEST")
+    print("=" * 70)
+
+    results = {}
+    vqe_path = RESULTS_DIR / 'vqe_trajectory_validation' / 'vqe_trajectory_validation.json'
+    if not vqe_path.exists():
+        print("  VQE data not found. Skipping.")
+        return results
+
+    vqe = json.load(open(vqe_path))
+    n_meas = vqe['n_meas']
+    shots = vqe['shots']
+
+    # Extract per-theta fidelity from Zeno circuits
+    theta_fidelities = []
+    theta_values = []
+
+    for key, entry in vqe['results'].items():
+        if entry.get('type') != 'zeno':
+            continue
+        theta = entry['theta']
+        bitstrings = entry.get('bitstrings', [])
+        if not bitstrings:
+            continue
+
+        # Compute hard-PS fidelity at this theta
+        # For Zeno circuits: fidelity = P(correct final | successful trajectory)
+        # "correct" depends on what the target state is at this theta
+        # The VQE measures <Z>, so the circuit prepares Ry(theta)|0> then measures
+        # Actually the Zeno does drag + undo, so target is always |0>
+        # fidelity = P(0 | successful)
+        successful = 0
+        correct = 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 == 0:
+                successful += 1
+                if final == '0':
+                    correct += 1
+
+        if successful > 10:
+            fid = correct / successful
+            theta_fidelities.append(fid)
+            theta_values.append(theta)
+
+    if len(theta_fidelities) < 3:
+        print("  Insufficient per-theta data points.")
+        return results
+
+    thetas = np.array(theta_values)
+    fids = np.array(theta_fidelities)
+    mean_fid = np.mean(fids)
+    std_fid = np.std(fids)
+    spread = np.max(fids) - np.min(fids)
+
+    print(f"\n  Per-theta hard-PS fidelity (N={n_meas}, {shots} shots):")
+    print(f"  {'theta/pi':>8} | {'Fidelity':>8}")
+    print(f"  " + "-" * 20)
+    for t, f in zip(thetas, fids):
+        print(f"  {t/np.pi:8.3f} | {f:8.4f}")
+
+    print(f"\n  Mean fidelity:  {mean_fid:.4f}")
+    print(f"  Std fidelity:   {std_fid:.4f}")
+    print(f"  Spread (max-min): {spread:.4f}")
+
+    # Chi-squared test: are all fidelities consistent with a single value?
+    # Under null hypothesis (constant f), each fidelity is binomial
+    # Use Cochran's Q or simpler: test if variance exceeds binomial expectation
+    expected_var = mean_fid * (1 - mean_fid) / shots  # variance of single estimate
+    observed_var = np.var(fids, ddof=1)
+    F_ratio = observed_var / expected_var if expected_var > 0 else 0
+
+    print(f"\n  Expected variance (binomial): {expected_var:.6f}")
+    print(f"  Observed variance:            {observed_var:.6f}")
+    print(f"  F-ratio (obs/exp):            {F_ratio:.2f}")
+
+    # Also: what RMSE improvement would per-theta calibration give?
+    # Recompute VQE estimates with per-theta fidelity vs global fidelity
+    print("\n  --- Impact on VQE RMSE ---")
+
+    global_errors = []
+    pertheta_errors = []
+
+    for i, (key, entry) in enumerate(
+        [(k, v) for k, v in vqe['results'].items() if v.get('type') == 'zeno']
+    ):
+        theta = entry['theta']
+        true_z = entry['true_z']
+        estimates = entry.get('estimates', {})
+        hard_est = estimates.get('hard_ps', 0)
+
+        # Global correction
+        if abs(2 * mean_fid - 1) > 0.01:
+            global_corrected = hard_est / (2 * mean_fid - 1)
+        else:
+            global_corrected = hard_est
+
+        # Per-theta correction
+        if i < len(fids) and abs(2 * fids[i] - 1) > 0.01:
+            pertheta_corrected = hard_est / (2 * fids[i] - 1)
+        else:
+            pertheta_corrected = hard_est
+
+        global_errors.append((global_corrected - true_z) ** 2)
+        pertheta_errors.append((pertheta_corrected - true_z) ** 2)
+
+    if global_errors:
+        global_rmse = np.sqrt(np.mean(global_errors))
+        pertheta_rmse = np.sqrt(np.mean(pertheta_errors))
+        improvement = (global_rmse - pertheta_rmse) / global_rmse * 100
+
+        print(f"  Global-fidelity RMSE:    {global_rmse:.4f}")
+        print(f"  Per-theta-fidelity RMSE: {pertheta_rmse:.4f}")
+        print(f"  Improvement:             {improvement:+.1f}%")
+
+    if spread < 0.03:
+        verdict = "PASS: Fidelity variation < 3pp across theta. Constant assumption is reasonable."
+    elif spread < 0.08:
+        verdict = "WEAK: Fidelity varies 3-8pp. Constant assumption introduces mild bias."
+    else:
+        verdict = "FAIL: Fidelity varies >8pp. Per-theta calibration needed."
+
+    print(f"\n  VERDICT: {verdict}")
+
+    results['w4_fidelity_constancy'] = {
+        'n_thetas': len(theta_fidelities),
+        'mean_fidelity': float(mean_fid),
+        'std_fidelity': float(std_fid),
+        'spread': float(spread),
+        'F_ratio': float(F_ratio),
+        'global_rmse': float(global_rmse) if global_errors else None,
+        'pertheta_rmse': float(pertheta_rmse) if pertheta_errors else None,
+        'verdict': verdict,
+    }
+
+    return results
+
+
+# =============================================================================
+# OFFLINE TEST W5: ML Model vs Simple Heuristics
+# =============================================================================
+
+def test_w5_ml_vs_heuristics():
+    """Test whether the ML model meaningfully outperforms simple heuristics.
+
+    Load trajectory_estimation bitstrings. Apply:
+    1. Hard post-selection (k=0)
+    2. Soft k<=1
+    3. Soft k<=2
+    4. exp(-k)
+    5. Excess-flip exp(-max(0, k-Np))
+    6. Simple early-flip penalty: exp(-2 * early_flips - 0.5 * late_flips)
+
+    Compare effective yields. If #6 matches ML within 2pp, the complexity
+    of ML is unjustified.
+    """
+    print("\n" + "=" * 70)
+    print("W5: ML vs SIMPLE HEURISTICS")
+    print("=" * 70)
+
+    results = {}
+    traj_path = RESULTS_DIR / 'trajectory_estimation' / 'trajectory_estimation.json'
+    if not traj_path.exists():
+        print("  Trajectory estimation data not found. Skipping.")
+        return results
+
+    traj = json.load(open(traj_path))
+
+    # Find x_freeze_n8 — the cleanest test case
+    target_key = None
+    for key in (traj.get('data', {}) if isinstance(traj.get('data'), dict) else {}):
+        if 'x_freeze' in key and 'n8' in key:
+            target_key = key
+            break
+
+    if target_key is None:
+        # Try alternate structure
+        for key in traj.get('results', traj.get('data', {})):
+            if 'x_freeze' in key and 'n8' in key:
+                target_key = key
+                break
+
+    if target_key is None:
+        print("  x_freeze_n8 data not found. Trying drag_n8.")
+        for key in (traj.get('data', {}) if isinstance(traj.get('data'), dict) else {}):
+            if 'drag' in key and 'n8' in key:
+                target_key = key
+                break
+
+    data_container = traj.get('data', traj.get('results', {}))
+    if target_key is None or target_key not in data_container:
+        print("  No suitable trajectory data found. Skipping.")
+        return results
+
+    entry = data_container[target_key]
+    bitstrings = entry.get('bitstrings', entry.get('raw_bitstrings', []))
+    n_meas = 8
+
+    if len(bitstrings) < 100:
+        print(f"  Only {len(bitstrings)} bitstrings. Need >= 100. Skipping.")
+        return results
+
+    print(f"\n  Dataset: {target_key}, {len(bitstrings)} trajectories, N={n_meas}")
+
+    # Parse all trajectories
+    parsed = []
+    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')
+        flip_positions = [i for i, b in enumerate(intermediate) if b == '1']
+        correct = 1 if final == '0' else 0
+
+        early_flips = sum(1 for p in flip_positions if p < n_meas // 2)
+        late_flips = n_flips - early_flips
+        has_pos0 = 1 if 0 in flip_positions else 0
+
+        parsed.append({
+            'n_flips': n_flips,
+            'flip_positions': flip_positions,
+            'correct': correct,
+            'early_flips': early_flips,
+            'late_flips': late_flips,
+            'has_pos0': has_pos0,
+        })
+
+    # Define weighting strategies
+    strategies = {
+        'hard_k0': lambda s: 1.0 if s['n_flips'] == 0 else 0.0,
+        'soft_k1': lambda s: 1.0 if s['n_flips'] <= 1 else 0.0,
+        'soft_k2': lambda s: 1.0 if s['n_flips'] <= 2 else 0.0,
+        'exp_k': lambda s: np.exp(-s['n_flips']),
+        'excess_flip': lambda s: np.exp(-max(0, s['n_flips'] - n_meas * 0.003)),
+        'early_penalty': lambda s: (
+            np.exp(-2.0 * s['early_flips'] - 0.3 * s['late_flips'])
+            if s['n_flips'] > 0 else 1.0
+        ),
+        'pos0_aware': lambda s: (
+            0.0 if (s['has_pos0'] and s['n_flips'] > 1)
+            else (0.5 if s['has_pos0'] else (1.0 if s['n_flips'] <= 2 else 0.3))
+        ),
+        'uniform': lambda s: 1.0,
+    }
+
+    print(f"\n  {'Strategy':>16} | {'Fidelity':>8} | {'Utilization':>11} | {'Eff Yield':>9}")
+    print(f"  " + "-" * 55)
+
+    strategy_results = {}
+    for name, weight_fn in strategies.items():
+        w_correct = 0
+        w_total = 0
+        for s in parsed:
+            w = weight_fn(s)
+            w_correct += w * s['correct']
+            w_total += w
+
+        fidelity = w_correct / w_total if w_total > 0 else 0
+        utilization = w_total / len(parsed) if parsed else 0
+        eff_yield = fidelity * utilization
+
+        strategy_results[name] = {
+            'fidelity': float(fidelity),
+            'utilization': float(utilization),
+            'effective_yield': float(eff_yield),
+        }
+
+        print(f"  {name:>16} | {fidelity:8.4f} | {utilization:11.4f} | {eff_yield:9.4f}")
+
+    # Compare: is the gap between best simple heuristic and exp_k significant?
+    simple_yields = [v['effective_yield'] for k, v in strategy_results.items()
+                     if k in ('early_penalty', 'pos0_aware', 'soft_k2')]
+    best_simple = max(simple_yields) if simple_yields else 0
+    exp_yield = strategy_results.get('exp_k', {}).get('effective_yield', 0)
+    gap = exp_yield - best_simple
+
+    print(f"\n  Best simple heuristic yield:  {best_simple:.4f}")
+    print(f"  exp(-k) yield:               {exp_yield:.4f}")
+    print(f"  Gap:                         {gap:+.4f}")
+
+    if abs(gap) < 0.02:
+        verdict = "CONFIRMED: Simple heuristics match exp(-k) within 2pp. ML adds complexity without meaningful gain."
+    elif gap > 0.02:
+        verdict = f"PARTIAL: exp(-k) beats best simple heuristic by {gap:.1%}. But position-aware heuristics close the gap."
+    else:
+        verdict = "REFUTED: Simple heuristic actually beats exp(-k). Position awareness helps."
+
+    print(f"\n  VERDICT: {verdict}")
+
+    results['w5_ml_vs_heuristics'] = {
+        'n_trajectories': len(parsed),
+        'strategies': strategy_results,
+        'best_simple_yield': float(best_simple),
+        'exp_k_yield': float(exp_yield),
+        'gap': float(gap),
+        'verdict': verdict,
+    }
+
+    return results
+
+
+# =============================================================================
+# HARDWARE TESTS — Circuit builders for W1, W3, W6
+# =============================================================================
+
+@dataclass
+class ExperimentConfig:
+    name: str
+    circuit: QuantumCircuit
+    category: str
+    weakness: str
+    params: dict
+
+
+def build_hardware_experiments(backend):
+    """Build all circuits for weaknesses 1, 3, 6 in one list."""
+    dt = backend.dt
+    target = backend.target
+    meas_duration_dt = int(target['measure'][(0,)].duration / dt)
+    meas_error = target['measure'][(0,)].error
+
+    # Collect qubit properties for W1 qubit selection
+    qubit_t1 = {}
+    qubit_meas_err = {}
+    for qi in range(min(backend.num_qubits, 133)):
+        try:
+            props = backend.qubit_properties(qi)
+            qubit_t1[qi] = props.t1
+            mp = target['measure'][(qi,)]
+            qubit_meas_err[qi] = mp.error
+        except Exception:
+            pass
+
+    # Select 5 diverse qubits for W1: best T1, worst T1, median T1, plus
+    # lowest meas error, highest meas error
+    if len(qubit_t1) >= 5:
+        sorted_by_t1 = sorted(qubit_t1.items(), key=lambda x: x[1])
+        # Filter out qubits with absurdly high measurement error (>30%)
+        valid_qubits = [(q, t) for q, t in sorted_by_t1 if qubit_meas_err.get(q, 1) < 0.30]
+        if len(valid_qubits) < 5:
+            valid_qubits = sorted_by_t1
+
+        best_t1_q = valid_qubits[-1][0]
+        worst_t1_q = valid_qubits[0][0]
+        median_t1_q = valid_qubits[len(valid_qubits) // 2][0]
+
+        sorted_by_merr = sorted(qubit_meas_err.items(), key=lambda x: x[1])
+        valid_merr = [(q, e) for q, e in sorted_by_merr if q in qubit_t1]
+        low_merr_q = valid_merr[0][0]
+        high_merr_q = valid_merr[-1][0] if valid_merr[-1][1] < 0.30 else valid_merr[-2][0]
+
+        # Deduplicate — ensure 5 distinct qubits
+        w1_qubits = list(dict.fromkeys([
+            0,  # always include qubit 0 for baseline comparison
+            best_t1_q,
+            worst_t1_q,
+            median_t1_q,
+            low_merr_q,
+            high_merr_q,
+        ]))[:5]
+    else:
+        w1_qubits = [0]
+
+    experiments = []
+    theta_X = np.pi
+    theta_I = 0.0
+    n_meas = 8
+    shots = 4096
+
+    # =========================================================================
+    # W1: Multi-qubit generalization
+    # =========================================================================
+    for qi in w1_qubits:
+        qi_t1 = qubit_t1.get(qi, 0)
+        qi_merr = qubit_meas_err.get(qi, 0)
+        qi_meas_dt = int(target['measure'][(qi,)].duration / dt) if (qi,) in target['measure'] else meas_duration_dt
+
+        for gate_name, theta in [('I', theta_I), ('X', theta_X)]:
+            # Standard
+            experiments.append(ExperimentConfig(
+                name=f"w1_q{qi}_{gate_name}_standard",
+                circuit=build_standard(theta, qubit=qi, n_qubits=max(w1_qubits) + 1),
+                category="standard",
+                weakness="W1",
+                params={'qubit': qi, 'gate': gate_name, 'theta': theta,
+                        'T1_us': qi_t1 * 1e6, 'meas_error': qi_merr},
+            ))
+            # Zeno
+            experiments.append(ExperimentConfig(
+                name=f"w1_q{qi}_{gate_name}_zeno",
+                circuit=build_zeno(theta, n_meas, qubit=qi, n_qubits=max(w1_qubits) + 1),
+                category="zeno",
+                weakness="W1",
+                params={'qubit': qi, 'gate': gate_name, 'theta': theta,
+                        'n_meas': n_meas, 'T1_us': qi_t1 * 1e6,
+                        'meas_error': qi_merr},
+            ))
+            # Delay-matched
+            experiments.append(ExperimentConfig(
+                name=f"w1_q{qi}_{gate_name}_delay",
+                circuit=build_delay_matched(theta, n_meas, qi_meas_dt, qubit=qi,
+                                            n_qubits=max(w1_qubits) + 1),
+                category="delay_matched",
+                weakness="W1",
+                params={'qubit': qi, 'gate': gate_name, 'theta': theta,
+                        'n_meas': n_meas, 'T1_us': qi_t1 * 1e6,
+                        'meas_error': qi_merr},
+            ))
+
+    # =========================================================================
+    # W3: Zero-noise extrapolation comparison
+    # =========================================================================
+    for gate_name, theta in [('I', theta_I), ('X', theta_X)]:
+        for n_folds in [0, 1, 2, 3]:
+            noise_level = 2 * n_folds + 1
+            experiments.append(ExperimentConfig(
+                name=f"w3_{gate_name}_zne_{noise_level}x",
+                circuit=build_zne_folded(theta, n_folds),
+                category="zne",
+                weakness="W3",
+                params={'gate': gate_name, 'theta': theta,
+                        'n_folds': n_folds, 'noise_level': noise_level},
+            ))
+
+    # =========================================================================
+    # W6: Computation between measurements
+    # =========================================================================
+    theta_test = np.pi / 2  # Ry(pi/2) — midpoint, not trivial
+
+    for work_gates in [0, 1, 2, 4]:
+        # Zeno with interleaved work
+        experiments.append(ExperimentConfig(
+            name=f"w6_zeno_work{work_gates}",
+            circuit=build_zeno_with_work(theta_test, n_meas, work_gates),
+            category="zeno_work",
+            weakness="W6",
+            params={'gate': 'Ry_pi2', 'theta': theta_test,
+                    'n_meas': n_meas, 'work_gates': work_gates},
+        ))
+
+        # Depth-matched (same gates, no measurements)
+        experiments.append(ExperimentConfig(
+            name=f"w6_depth_work{work_gates}",
+            circuit=build_depth_matched_work(theta_test, n_meas, work_gates),
+            category="depth_work",
+            weakness="W6",
+            params={'gate': 'Ry_pi2', 'theta': theta_test,
+                    'n_meas': n_meas, 'work_gates': work_gates},
+        ))
+
+        # Delay-matched (same wall-clock, idle)
+        total_gates = n_meas * (2 + 2 * work_gates)  # Ry pairs per step
+        extra_dt = work_gates * 2 * int(32e-9 / dt) * (n_meas - 1)  # gate time in dt
+        delay_dt = n_meas * meas_duration_dt + extra_dt
+        experiments.append(ExperimentConfig(
+            name=f"w6_delay_work{work_gates}",
+            circuit=build_delay_matched(theta_test, n_meas, meas_duration_dt + extra_dt // n_meas),
+            category="delay_work",
+            weakness="W6",
+            params={'gate': 'Ry_pi2', 'theta': theta_test,
+                    'n_meas': n_meas, 'work_gates': work_gates},
+        ))
+
+    # Standard baseline for W6
+    experiments.append(ExperimentConfig(
+        name="w6_standard",
+        circuit=build_standard(theta_test),
+        category="standard",
+        weakness="W6",
+        params={'gate': 'Ry_pi2', 'theta': theta_test},
+    ))
+
+    log(f"W1 qubits selected: {w1_qubits}")
+    for qi in w1_qubits:
+        log(f"  Q{qi}: T1={qubit_t1.get(qi,0)*1e6:.1f}us, meas_err={qubit_meas_err.get(qi,0):.4f}", 1)
+
+    return experiments, {
+        'w1_qubits': w1_qubits,
+        'qubit_properties': {
+            str(qi): {'T1_us': qubit_t1.get(qi, 0) * 1e6,
+                      'meas_error': qubit_meas_err.get(qi, 0)}
+            for qi in w1_qubits
+        },
+        'meas_duration_dt': meas_duration_dt,
+        'meas_error_q0': meas_error,
+        'dt_ns': dt * 1e9,
+    }
+
+
+# =============================================================================
+# HARDWARE ANALYSIS
+# =============================================================================
+
+def analyze_hardware_results(experiments, result, hw_meta):
+    """Analyze all hardware results and produce verdicts for W1, W3, W6."""
+    results_data = {}
+
+    for i, exp in enumerate(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())
+
+        p_meas = exp.params.get('meas_error', hw_meta['meas_error_q0'])
+
+        if 'zeno' in exp.category:
+            analysis = analyze_zeno(bitstrings, exp.params.get('n_meas', 8), p_meas)
+        else:
+            analysis = analyze_standard(bitstrings)
+
+        results_data[exp.name] = {
+            'category': exp.category,
+            'weakness': exp.weakness,
+            'params': {k: (float(v) if isinstance(v, (np.floating, float)) else v)
+                       for k, v in exp.params.items()},
+            'analysis': analysis,
+        }
+
+    # =========================================================================
+    # W1 VERDICT
+    # =========================================================================
+    print("\n" + "=" * 70)
+    print("W1: MULTI-QUBIT GENERALIZATION")
+    print("=" * 70)
+
+    w1_qubits = hw_meta['w1_qubits']
+
+    print(f"\n  {'Qubit':>5} | {'T1(us)':>6} | {'MeasErr':>7} | {'Std I':>6} | {'Zeno I':>7} | "
+          f"{'Std X':>6} | {'Zeno X':>7} | {'Zeno-Std I':>10} | {'Zeno-Std X':>10}")
+    print("  " + "-" * 95)
+
+    improvements_I = []
+    improvements_X = []
+
+    for qi in w1_qubits:
+        std_I = results_data.get(f'w1_q{qi}_I_standard', {}).get('analysis', {}).get('fidelity', 0)
+        zeno_I = results_data.get(f'w1_q{qi}_I_zeno', {}).get('analysis', {}).get('fidelity_excess', 0)
+        std_X = results_data.get(f'w1_q{qi}_X_standard', {}).get('analysis', {}).get('fidelity', 0)
+        zeno_X = results_data.get(f'w1_q{qi}_X_zeno', {}).get('analysis', {}).get('fidelity_excess', 0)
+
+        t1 = hw_meta['qubit_properties'][str(qi)]['T1_us']
+        merr = hw_meta['qubit_properties'][str(qi)]['meas_error']
+
+        imp_I = zeno_I - std_I
+        imp_X = zeno_X - std_X
+        improvements_I.append(imp_I)
+        improvements_X.append(imp_X)
+
+        print(f"  Q{qi:>3} | {t1:6.1f} | {merr:7.4f} | {std_I:6.4f} | {zeno_I:7.4f} | "
+              f"{std_X:6.4f} | {zeno_X:7.4f} | {imp_I:+10.4f} | {imp_X:+10.4f}")
+
+    mean_imp_I = np.mean(improvements_I) if improvements_I else 0
+    mean_imp_X = np.mean(improvements_X) if improvements_X else 0
+    std_imp_I = np.std(improvements_I) if improvements_I else 0
+    std_imp_X = np.std(improvements_X) if improvements_X else 0
+    all_positive_I = all(i > 0 for i in improvements_I)
+    all_positive_X = all(i > 0 for i in improvements_X)
+    any_negative = any(i < -0.02 for i in improvements_I + improvements_X)
+
+    print(f"\n  Mean Zeno improvement (I): {mean_imp_I:+.4f} +/- {std_imp_I:.4f}")
+    print(f"  Mean Zeno improvement (X): {mean_imp_X:+.4f} +/- {std_imp_X:.4f}")
+    print(f"  All positive (I): {all_positive_I}, All positive (X): {all_positive_X}")
+
+    if all_positive_I and all_positive_X:
+        w1_verdict = "PASS: Zeno advantage holds across all tested qubits. Single-qubit concern mitigated."
+    elif any_negative:
+        w1_verdict = "FAIL: Some qubits show Zeno DISADVANTAGE. Results are qubit-dependent."
+    else:
+        w1_verdict = "PARTIAL: Zeno advantage inconsistent across qubits. Qubit selection matters."
+
+    print(f"\n  VERDICT: {w1_verdict}")
+
+    # =========================================================================
+    # W3 VERDICT
+    # =========================================================================
+    print("\n" + "=" * 70)
+    print("W3: ZERO-NOISE EXTRAPOLATION COMPARISON")
+    print("=" * 70)
+
+    for gate_name in ['I', 'X']:
+        print(f"\n  --- {gate_name} gate ---")
+        noise_levels = []
+        fidelities = []
+
+        for n_folds in [0, 1, 2, 3]:
+            noise_level = 2 * n_folds + 1
+            key = f"w3_{gate_name}_zne_{noise_level}x"
+            fid = results_data.get(key, {}).get('analysis', {}).get('fidelity', 0)
+            noise_levels.append(noise_level)
+            fidelities.append(fid)
+            print(f"    {noise_level}x noise: fidelity = {fid:.4f}")
+
+        # Richardson extrapolation to 0x noise using linear fit on first 3 points
+        if len(fidelities) >= 3:
+            # Linear extrapolation from 1x and 3x
+            f1 = fidelities[0]  # 1x
+            f3 = fidelities[1]  # 3x
+            zne_linear = (3 * f1 - f3) / 2
+
+            # Quadratic extrapolation from 1x, 3x, 5x
+            f5 = fidelities[2]  # 5x
+            # Lagrange interpolation at x=0
+            zne_quad = (15 * f1 - 10 * f3 + 3 * f5) / 8
+
+            print(f"    ZNE (linear):    {zne_linear:.4f}")
+            print(f"    ZNE (quadratic): {zne_quad:.4f}")
+
+            # Compare against Zeno result from existing data
+            # For identity: ideal=1.0; for X: ideal=1.0 (we measure P(0) after undo)
+            print(f"    Ideal:           1.0000")
+
+            # Get existing Zeno result for this gate
+            zeno_key = f"w1_q0_{gate_name}_zeno"
+            zeno_fid = results_data.get(zeno_key, {}).get('analysis', {}).get('fidelity_excess', 0)
+            zeno_hard = results_data.get(zeno_key, {}).get('analysis', {}).get('fidelity_hard_ps', 0)
+            zeno_sr = results_data.get(zeno_key, {}).get('analysis', {}).get('success_rate', 0)
+
+            if zeno_fid > 0:
+                zeno_yield = zeno_fid * (1.0 - (1.0 - zeno_sr))
+                # ZNE uses all shots (100% utilization)
+                print(f"    Zeno (excess-flip): {zeno_fid:.4f} (success rate: {zeno_sr:.4f})")
+                print(f"    Zeno (hard PS):     {zeno_hard:.4f}")
+
+                best_zne = max(zne_linear, zne_quad)
+                best_zne = min(best_zne, 1.0)  # cap at 1
+
+                print(f"\n    ZNE best:  {best_zne:.4f} (100% utilization, yield={best_zne:.4f})")
+                print(f"    Zeno best: {zeno_fid:.4f} (utilization varies)")
+
+    # Overall W3 verdict based on comparison
+    w3_results = {}
+    for gate_name in ['I', 'X']:
+        fids = []
+        for n_folds in [0, 1, 2, 3]:
+            key = f"w3_{gate_name}_zne_{2*n_folds+1}x"
+            fids.append(results_data.get(key, {}).get('analysis', {}).get('fidelity', 0))
+
+        if len(fids) >= 3:
+            zne_lin = (3 * fids[0] - fids[1]) / 2
+            zne_quad = (15 * fids[0] - 10 * fids[1] + 3 * fids[2]) / 8
+            w3_results[gate_name] = {
+                'raw_fidelities': fids,
+                'zne_linear': float(min(zne_lin, 1.0)),
+                'zne_quadratic': float(min(zne_quad, 1.0)),
+            }
+
+    zne_best = max(
+        max(r.get('zne_linear', 0), r.get('zne_quadratic', 0))
+        for r in w3_results.values()
+    ) if w3_results else 0
+
+    zeno_q0_X = results_data.get('w1_q0_X_zeno', {}).get('analysis', {}).get('fidelity_excess', 0)
+
+    if zne_best > zeno_q0_X + 0.02:
+        w3_verdict = f"CONFIRMED: ZNE ({zne_best:.4f}) beats Zeno ({zeno_q0_X:.4f}) at 100% utilization."
+    elif abs(zne_best - zeno_q0_X) < 0.02:
+        w3_verdict = f"MIXED: ZNE ({zne_best:.4f}) and Zeno ({zeno_q0_X:.4f}) are comparable."
+    else:
+        w3_verdict = f"REFUTED: Zeno ({zeno_q0_X:.4f}) beats ZNE ({zne_best:.4f}) even at full utilization."
+
+    print(f"\n  VERDICT: {w3_verdict}")
+
+    # =========================================================================
+    # W6 VERDICT
+    # =========================================================================
+    print("\n" + "=" * 70)
+    print("W6: COMPUTATION BETWEEN MEASUREMENTS")
+    print("=" * 70)
+
+    std_fid = results_data.get('w6_standard', {}).get('analysis', {}).get('fidelity', 0)
+    print(f"\n  Standard Ry(pi/2): {std_fid:.4f}")
+
+    print(f"\n  {'Work gates':>10} | {'Zeno(excess)':>12} | {'Zeno(hard)':>10} | "
+          f"{'Depth-matched':>13} | {'Delay':>6} | {'Zeno-Std':>8} | {'Zeno-Depth':>10}")
+    print("  " + "-" * 85)
+
+    zeno_advantages = []
+    for work_gates in [0, 1, 2, 4]:
+        zk = f"w6_zeno_work{work_gates}"
+        dk = f"w6_depth_work{work_gates}"
+        dlk = f"w6_delay_work{work_gates}"
+
+        za = results_data.get(zk, {}).get('analysis', {})
+        da = results_data.get(dk, {}).get('analysis', {})
+        dla = results_data.get(dlk, {}).get('analysis', {})
+
+        z_excess = za.get('fidelity_excess', 0)
+        z_hard = za.get('fidelity_hard_ps', 0)
+        d_fid = da.get('fidelity', 0)
+        dl_fid = dla.get('fidelity', 0)
+
+        adv_vs_std = z_excess - std_fid
+        adv_vs_depth = z_excess - d_fid
+        zeno_advantages.append(adv_vs_std)
+
+        print(f"  {work_gates:>10} | {z_excess:12.4f} | {z_hard:10.4f} | "
+              f"{d_fid:13.4f} | {dl_fid:6.4f} | {adv_vs_std:+8.4f} | {adv_vs_depth:+10.4f}")
+
+    # How fast does advantage decay with work?
+    if len(zeno_advantages) >= 2:
+        adv_0 = zeno_advantages[0]  # 0 work gates
+        adv_4 = zeno_advantages[-1]  # 4 work gates
+        decay = adv_0 - adv_4
+
+        print(f"\n  Advantage at 0 work gates:  {adv_0:+.4f}")
+        print(f"  Advantage at 4 work gates:  {adv_4:+.4f}")
+        print(f"  Decay:                      {decay:.4f}")
+
+        if adv_4 < -0.01:
+            w6_verdict = "CONFIRMED: Zeno advantage vanishes with interleaved computation. Practical utility limited."
+        elif adv_4 < adv_0 * 0.5:
+            w6_verdict = "PARTIAL: Advantage decays >50% with 4 gate pairs. Degrades with practical workloads."
+        else:
+            w6_verdict = "REFUTED: Advantage survives interleaved computation. Practical use viable."
+    else:
+        w6_verdict = "INCONCLUSIVE: Insufficient data."
+
+    print(f"\n  VERDICT: {w6_verdict}")
+
+    return results_data, {
+        'W1': {'verdict': w1_verdict, 'improvements_I': [float(x) for x in improvements_I],
+               'improvements_X': [float(x) for x in improvements_X]},
+        'W3': {'verdict': w3_verdict, **w3_results},
+        'W6': {'verdict': w6_verdict, 'advantages': [float(x) for x in zeno_advantages]},
+    }
+
+
+# =============================================================================
+# MAIN
+# =============================================================================
+
+def main():
+    print("=" * 70)
+    print("WEAKNESS TESTS — ALL SIX")
+    print("=" * 70)
+
+    all_results = {}
+
+    # -----------------------------------------------------------------
+    # PHASE 1: OFFLINE TESTS (zero QPU cost)
+    # -----------------------------------------------------------------
+    print("\n\n" + "#" * 70)
+    print("# PHASE 1: OFFLINE TESTS (zero QPU cost)")
+    print("#" * 70)
+
+    w2_results = test_w2_measurement_independence()
+    all_results['W2'] = w2_results
+
+    w4_results = test_w4_vqe_fidelity_constancy()
+    all_results['W4'] = w4_results
+
+    w5_results = test_w5_ml_vs_heuristics()
+    all_results['W5'] = w5_results
+
+    # -----------------------------------------------------------------
+    # PHASE 2: HARDWARE TESTS (single Batch)
+    # -----------------------------------------------------------------
+    print("\n\n" + "#" * 70)
+    print("# PHASE 2: HARDWARE TESTS (single Batch job)")
+    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("Less than 30s remaining. Skipping hardware tests.")
+        # Save offline results only
+        outfile = TESTS_DIR / 'weakness_tests.json'
+        with open(outfile, 'w') as f:
+            json.dump(all_results, f, indent=2, default=str)
+        log(f"Saved offline results: {outfile}")
+        return
+
+    backend = service.backend("ibm_torino")
+    log(f"Backend: {backend.name} ({backend.num_qubits}q)")
+
+    experiments, hw_meta = build_hardware_experiments(backend)
+    log(f"Total circuits: {len(experiments)}")
+
+    # Transpile
+    log("Transpiling...")
+    pm = generate_preset_pass_manager(backend=backend, optimization_level=1)
+
+    transpiled = []
+    valid_experiments = []
+
+    for exp in experiments:
+        try:
+            tc = pm.run(exp.circuit)
+            transpiled.append(tc)
+            valid_experiments.append(exp)
+        except Exception as e:
+            log(f"ERROR transpiling {exp.name}: {e}")
+
+    log(f"Transpiled: {len(transpiled)}/{len(experiments)}")
+
+    if not transpiled:
+        log("No circuits transpiled successfully. Aborting hardware tests.")
+        return
+
+    depths = [tc.depth() for tc in transpiled]
+    log(f"Depths: min={min(depths)}, max={max(depths)}, median={sorted(depths)[len(depths)//2]}")
+
+    # Submit single batch
+    log("Submitting batch...")
+    start_time = datetime.now(timezone.utc)
+    shots = 4096
+
+    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"Done. Wall time: {wall_time:.1f}s, QPU: {job.usage() or 0}s")
+
+    result = job.result()
+
+    hw_results, hw_verdicts = analyze_hardware_results(valid_experiments, result, hw_meta)
+
+    all_results['W1'] = hw_verdicts['W1']
+    all_results['W3'] = hw_verdicts['W3']
+    all_results['W6'] = hw_verdicts['W6']
+    all_results['hardware_meta'] = {
+        **hw_meta,
+        'job_id': job.job_id(),
+        'usage_seconds': job.usage() or 0,
+        'wall_time_seconds': wall_time,
+        'n_circuits': len(transpiled),
+        'shots': shots,
+        'timestamp': start_time.isoformat(),
+    }
+
+    # -----------------------------------------------------------------
+    # SAVE & SUMMARY
+    # -----------------------------------------------------------------
+    outfile = TESTS_DIR / 'weakness_tests.json'
+    with open(outfile, 'w') as f:
+        json.dump(all_results, f, indent=2, default=str)
+    log(f"Saved: {outfile}")
+
+    print("\n\n" + "=" * 70)
+    print("SUMMARY OF ALL SIX WEAKNESS TESTS")
+    print("=" * 70)
+
+    for w_id in ['W1', 'W2', 'W3', 'W4', 'W5', 'W6']:
+        w = all_results.get(w_id, {})
+        verdict = w.get('verdict', 'N/A')
+        if isinstance(w, dict) and 'verdict' not in w:
+            # Multi-sub-test — collect verdicts
+            sub_verdicts = [v.get('verdict', '') for k, v in w.items() if isinstance(v, dict) and 'verdict' in v]
+            verdict = ' | '.join(sub_verdicts) if sub_verdicts else 'N/A'
+        print(f"\n  {w_id}: {verdict}")
+
+    usage_after = check_usage(service)
+    log(f"\nUsage after: {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)

tests/weakness_tests.json

@@ -0,0 +1,258 @@
+{
+  "W2": {
+    "w2a_transition_analysis": {
+      "n_shots": 500,
+      "mean_transitions": 2.692,
+      "expected_transitions": 6.344517230987549,
+      "transition_ratio": 0.4243033633594498,
+      "mean_run_length": 8.66738894907909,
+      "transition_autocorrelation": 0.4119721980294112,
+      "t_stat": 53.762899612456586,
+      "p_value": 1.3474201297243222e-178,
+      "verdict": "FAIL: Transitions themselves are correlated. Error events cluster."
+    },
+    "w2b_binomial_gof": {
+      "n_meas": 32,
+      "p_meas": 0.11572265625,
+      "total_shots": 4096,
+      "chi2": 15323.0839652716,
+      "p_value": 0.0,
+      "bins_tested": 11,
+      "verdict": "FAIL: Flip counts deviate from Binomial. Backaction creates correlated runs."
+    },
+    "w2c_monotonicity": {
+      "fidelity_by_flips": [
+        [
+          0,
+          0.9686847599164927
+        ],
+        [
+          1,
+          0.9555382215288611
+        ],
+        [
+          2,
+          0.9526952695269527
+        ],
+        [
+          3,
+          0.9392523364485982
+        ],
+        [
+          4,
+          0.8947368421052632
+        ],
+        [
+          5,
+          0.8113207547169812
+        ],
+        [
+          6,
+          0.7333333333333333
+        ],
+        [
+          7,
+          0.36363636363636365
+        ],
+        [
+          8,
+          0.5
+        ],
+        [
+          12,
+          0.4
+        ],
+        [
+          17,
+          0.6666666666666666
+        ],
+        [
+          24,
+          0.3333333333333333
+        ],
+        [
+          25,
+          0.35714285714285715
+        ],
+        [
+          26,
+          0.2727272727272727
+        ],
+        [
+          27,
+          0.20833333333333334
+        ],
+        [
+          28,
+          0.16666666666666666
+        ],
+        [
+          29,
+          0.2857142857142857
+        ],
+        [
+          30,
+          0.14705882352941177
+        ],
+        [
+          31,
+          0.07407407407407407
+        ]
+      ],
+      "violations": 4,
+      "verdict": "FAIL: 4 monotonicity violations. Flip count is a poor fidelity predictor."
+    }
+  },
+  "W4": {
+    "w4_fidelity_constancy": {
+      "n_thetas": 9,
+      "mean_fidelity": 0.5163154410848451,
+      "std_fidelity": 0.3394285161934174,
+      "spread": 0.9516129032258065,
+      "F_ratio": 1062.9229626856127,
+      "global_rmse": 18.986229211309393,
+      "pertheta_rmse": 1.2521720627384025,
+      "verdict": "FAIL: Fidelity varies >8pp. Per-theta calibration needed."
+    }
+  },
+  "W5": {
+    "w5_ml_vs_heuristics": {
+      "n_trajectories": 4096,
+      "strategies": {
+        "hard_k0": {
+          "fidelity": 0.9680624556422995,
+          "utilization": 0.68798828125,
+          "effective_yield": 0.666015625
+        },
+        "soft_k1": {
+          "fidelity": 0.9652852529601722,
+          "utilization": 0.9072265625,
+          "effective_yield": 0.875732421875
+        },
+        "soft_k2": {
+          "fidelity": 0.9634369287020109,
+          "utilization": 0.934814453125,
+          "effective_yield": 0.900634765625
+        },
+        "exp_k": {
+          "fidelity": 0.9663760786147975,
+          "utilization": 0.7726615289055263,
+          "effective_yield": 0.7466816184002365
+        },
+        "excess_flip": {
+          "fidelity": 0.966339701762272,
+          "utilization": 0.7747182690079382,
+          "effective_yield": 0.7486410210229146
+        },
+        "early_penalty": {
+          "fidelity": 0.9662011359170656,
+          "utilization": 0.7917104068840887,
+          "effective_yield": 0.7649514944487686
+        },
+        "pos0_aware": {
+          "fidelity": 0.964131156245851,
+          "utilization": 0.9195556640625009,
+          "effective_yield": 0.8865722656250004
+        },
+        "uniform": {
+          "fidelity": 0.912109375,
+          "utilization": 1.0,
+          "effective_yield": 0.912109375
+        }
+      },
+      "best_simple_yield": 0.900634765625,
+      "exp_k_yield": 0.7466816184002365,
+      "gap": -0.1539531472247635,
+      "verdict": "REFUTED: Simple heuristic actually beats exp(-k). Position awareness helps."
+    }
+  },
+  "W1": {
+    "verdict": "FAIL: Some qubits show Zeno DISADVANTAGE. Results are qubit-dependent.",
+    "improvements_I": [
+      0.0452231252327957,
+      0.0022516596077793993,
+      0.007394570319754101,
+      0.0046508063074586214,
+      -9.731657901379531e-05
+    ],
+    "improvements_X": [
+      -0.011832915012489065,
+      -0.025856505263611496,
+      -0.022231385683244342,
+      -0.021130844386844427,
+      -0.023924039129208152
+    ]
+  },
+  "W3": {
+    "verdict": "MIXED: ZNE (0.8989) and Zeno (0.8859) are comparable.",
+    "I": {
+      "raw_fidelities": [
+        0.898193359375,
+        0.896728515625,
+        0.88623046875,
+        0.890869140625
+      ],
+      "zne_linear": 0.89892578125,
+      "zne_quadratic": 0.895538330078125
+    },
+    "X": {
+      "raw_fidelities": [
+        0.893310546875,
+        0.90185546875,
+        0.899169921875,
+        0.906494140625
+      ],
+      "zne_linear": 0.8890380859375,
+      "zne_quadratic": 0.88482666015625
+    }
+  },
+  "W6": {
+    "verdict": "REFUTED: Advantage survives interleaved computation. Practical use viable.",
+    "advantages": [
+      0.041001923381343786,
+      0.028494706439102346,
+      0.024268913015265237,
+      0.027480862169691034
+    ]
+  },
+  "hardware_meta": {
+    "w1_qubits": [
+      0,
+      131,
+      85,
+      95,
+      37
+    ],
+    "qubit_properties": {
+      "0": {
+        "T1_us": 115.2263264704152,
+        "meas_error": 0.11572265625
+      },
+      "131": {
+        "T1_us": 332.54033018370484,
+        "meas_error": 0.017578125
+      },
+      "85": {
+        "T1_us": 3.5656842137414944,
+        "meas_error": 0.045654296875
+      },
+      "95": {
+        "T1_us": 174.3273204280589,
+        "meas_error": 0.026611328125
+      },
+      "37": {
+        "T1_us": 59.919350992670644,
+        "meas_error": 0.010009765625
+      }
+    },
+    "meas_duration_dt": 390,
+    "meas_error_q0": 0.11572265625,
+    "dt_ns": 4.0,
+    "job_id": "d6jkidm33pjc73dm3upg",
+    "usage_seconds": 56,
+    "wall_time_seconds": 282.760999,
+    "n_circuits": 51,
+    "shots": 4096,
+    "timestamp": "2026-03-03T20:48:48.416591+00:00"
+  }
+}

zeno_interval.py

@@ -0,0 +1,455 @@
+"""
+Zeno Interval — Vary the inter-measurement gap.
+
+N=32 fixed. Insert deliberate delays of 0, 5, 10, 20, 50, 100μs between
+each measurement. At 100μs the gap approaches T1 — Zeno protection
+should collapse. Maps the phase boundary between Zeno-protected and
+unprotected thermalization.
+
+Theory predicts: fidelity depends on the ratio of measurement rate to
+decoherence rate. When inter-measurement interval << T1, Zeno wins.
+When interval ≈ T1, the qubit thermalizes between measurements and
+Zeno can't help.
+"""
+
+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")
+N_MEAS = 32
+
+
+@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}
+
+
+def build_zeno_with_gap(theta, n_meas, gap_dt):
+    """Zeno drag with deliberate delay between each measurement."""
+    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 gap_dt > 0 and k < n_meas:
+            qc.delay(gap_dt, 0, unit='dt')
+
+    qc.ry(-theta, 0)
+    qc.measure(0, n_meas)
+    return qc
+
+
+def build_identity_zeno_with_gap(n_meas, gap_dt):
+    """Identity Zeno with deliberate delay between each measurement."""
+    qr = QuantumRegister(1, 'q')
+    cr = ClassicalRegister(n_meas + 1, 'c')
+    qc = QuantumCircuit(qr, cr)
+
+    for k in range(n_meas):
+        qc.measure(0, k)
+        if gap_dt > 0 and k < n_meas - 1:
+            qc.delay(gap_dt, 0, unit='dt')
+
+    qc.measure(0, n_meas)
+    return qc
+
+
+def build_delay_total(total_delay_dt):
+    """Pure delay for same total circuit time. Ideal = |0>."""
+    qc = QuantumCircuit(1, 1)
+    if total_delay_dt > 0:
+        qc.delay(total_delay_dt, 0, unit='dt')
+    qc.measure(0, 0)
+    return qc
+
+
+def analyze_zeno(bitstrings, n_meas, p_meas):
+    total = len(bitstrings)
+    successful = 0
+    correct_given_success = 0
+    flip_bins = {}
+
+    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 flip_bins:
+            flip_bins[n_flips] = {'total': 0, 'correct': 0}
+        flip_bins[n_flips]['total'] += 1
+        if final == '0':
+            flip_bins[n_flips]['correct'] += 1
+
+        if n_flips == 0:
+            successful += 1
+            if final == '0':
+                correct_given_success += 1
+
+    success_rate = successful / total if total > 0 else 0
+    fidelity_hard = correct_given_success / successful if successful > 0 else 0
+
+    expected_meas_flips = n_meas * p_meas
+
+    # Excess-flip weighting
+    w_c, w_t = 0, 0
+    for nf, data in flip_bins.items():
+        excess = max(0, nf - expected_meas_flips)
+        w = np.exp(-excess)
+        w_c += w * data['correct']
+        w_t += w * data['total']
+    fid_excess = w_c / w_t if w_t > 0 else 0
+
+    # Likelihood ratio
+    wl_c, wl_t = 0, 0
+    for nf, data in flip_bins.items():
+        if nf <= n_meas:
+            p_target = comb(n_meas, nf, exact=True) * (p_meas ** nf) * ((1 - p_meas) ** (n_meas - nf))
+            p_random = comb(n_meas, nf, exact=True) * (0.5 ** n_meas)
+            w = min(p_target / p_random, 1e10) if p_random > 0 else 0
+        else:
+            w = 0
+        wl_c += w * data['correct']
+        wl_t += w * data['total']
+    fid_likelihood = wl_c / wl_t if wl_t > 0 else 0
+
+    all_flips = []
+    for nf, data in flip_bins.items():
+        all_flips.extend([nf] * data['total'])
+    mean_flips = np.mean(all_flips) if all_flips else 0
+    std_flips = np.std(all_flips) if all_flips else 0
+
+    return {
+        'total': total,
+        'successful': successful,
+        'success_rate': success_rate,
+        'fidelity_hard_ps': fidelity_hard,
+        'fidelity_excess': fid_excess,
+        'fidelity_likelihood': fid_likelihood,
+        'expected_meas_flips': expected_meas_flips,
+        'mean_flips': mean_flips,
+        'std_flips': std_flips,
+        'flip_distribution': {str(k): v for k, v in sorted(flip_bins.items())},
+        'type': 'zeno',
+    }
+
+
+def analyze_standard(bitstrings):
+    total = len(bitstrings)
+    zeros = sum(1 for b in bitstrings if b[-1] == '0')
+    return {'total': total, 'fidelity': zeros / total, 'type': 'standard'}
+
+
+def main():
+    print("=" * 70)
+    print("ZENO INTERVAL — VARY INTER-MEASUREMENT GAP")
+    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("Less than 30s remaining. Aborting.")
+        return
+
+    backend = service.backend("ibm_torino")
+    log(f"Backend: {backend.name} ({backend.num_qubits}q)")
+
+    dt = backend.dt
+    target_obj = backend.target
+    meas_props = target_obj['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), error={meas_error:.4f}")
+    log(f"Qubit 0: T1={T1*1e6:.1f} us, T2={T2*1e6:.1f} us")
+    log(f"dt = {dt*1e9:.1f} ns")
+
+    # Gap values in microseconds
+    gap_us_values = [0, 5, 10, 20, 50, 100]
+    theta = np.pi
+    shots = 4096
+
+    print(f"\nN = {N_MEAS} fixed")
+    print(f"\nExperiment plan:")
+    print(f"{'Gap(us)':>7} | {'Interval(us)':>12} | {'Interval/T1':>11} | {'Total(us)':>9} | {'Total/T1':>8}")
+    print("-" * 55)
+    for gap_us in gap_us_values:
+        interval = meas_duration_s * 1e6 + gap_us
+        total = N_MEAS * interval
+        print(f"{gap_us:7.0f} | {interval:12.1f} | {interval / (T1*1e6):11.3f} | {total:9.1f} | {total / (T1*1e6):8.2f}")
+
+    all_experiments = []
+
+    for gap_us in gap_us_values:
+        gap_s = gap_us * 1e-6
+        gap_dt = int(gap_s / dt)
+        interval_us = meas_duration_s * 1e6 + gap_us
+        total_time_us = N_MEAS * interval_us
+
+        # X Zeno with gap
+        all_experiments.append(ExperimentConfig(
+            name=f"x_zeno_gap{gap_us}",
+            circuit=build_zeno_with_gap(theta, N_MEAS, gap_dt),
+            category="x_zeno",
+            params={'gate': 'X', 'theta': theta, 'n_meas': N_MEAS,
+                    'gap_us': gap_us, 'gap_dt': gap_dt,
+                    'interval_us': interval_us,
+                    'interval_over_T1': interval_us / (T1 * 1e6),
+                    'total_time_us': total_time_us,
+                    'T1_multiple': total_time_us / (T1 * 1e6)},
+        ))
+
+        # Identity Zeno with gap
+        all_experiments.append(ExperimentConfig(
+            name=f"identity_zeno_gap{gap_us}",
+            circuit=build_identity_zeno_with_gap(N_MEAS, gap_dt),
+            category="identity_zeno",
+            params={'gate': 'I', 'theta': 0, 'n_meas': N_MEAS,
+                    'gap_us': gap_us, 'gap_dt': gap_dt,
+                    'interval_us': interval_us,
+                    'interval_over_T1': interval_us / (T1 * 1e6),
+                    'total_time_us': total_time_us,
+                    'T1_multiple': total_time_us / (T1 * 1e6)},
+        ))
+
+        # Delay-matched (same total time, no measurements)
+        total_delay_dt = int(total_time_us * 1e-6 / dt)
+        all_experiments.append(ExperimentConfig(
+            name=f"delay_gap{gap_us}",
+            circuit=build_delay_total(total_delay_dt),
+            category="delay",
+            params={'gate': 'I', 'theta': 0, 'n_meas': 0,
+                    'gap_us': gap_us,
+                    'total_time_us': total_time_us,
+                    'T1_multiple': total_time_us / (T1 * 1e6)},
+        ))
+
+    log(f"Total experiments: {len(all_experiments)}")
+
+    log("Transpiling...")
+    pm = generate_preset_pass_manager(backend=backend, optimization_level=1)
+
+    transpiled = []
+    for exp in all_experiments:
+        try:
+            tc = pm.run(exp.circuit)
+            transpiled.append(tc)
+        except Exception as e:
+            log(f"ERROR transpiling {exp.name}: {e}")
+            transpiled.append(None)
+
+    valid_indices = [i for i, tc in enumerate(transpiled) if tc is not None]
+    valid_transpiled = [transpiled[i] for i in valid_indices]
+    valid_experiments = [all_experiments[i] for i in valid_indices]
+
+    log(f"Transpiled: {len(valid_transpiled)}/{len(all_experiments)}")
+
+    depths = [tc.depth() for tc in valid_transpiled]
+    log(f"Depths: min={min(depths)}, max={max(depths)}")
+
+    for i, exp in enumerate(valid_experiments):
+        exp.params['transpiled_depth'] = depths[i]
+
+    log("Submitting batch...")
+    start_time = datetime.now(timezone.utc)
+
+    with Batch(backend=backend) as batch:
+        sampler = SamplerV2(mode=batch)
+        job = sampler.run(valid_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"Done. Wall time: {wall_time:.1f}s, QPU: {job.usage() or 0}s")
+
+    result = job.result()
+    metrics = job.metrics()
+    results_data = {}
+
+    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())
+
+        if 'zeno' in exp.category:
+            analysis = analyze_zeno(bitstrings, exp.params['n_meas'], meas_error)
+        else:
+            analysis = analyze_standard(bitstrings)
+
+        results_data[exp.name] = {
+            'category': exp.category,
+            'params': {k: (float(v) if isinstance(v, (np.floating, float)) else v)
+                       for k, v in exp.params.items()},
+            'analysis': analysis,
+            'raw_bitstrings': bitstrings[:500],
+        }
+
+    # Save
+    output = {
+        'experiment': 'zeno_interval',
+        'description': 'Vary inter-measurement gap to map the Zeno protection phase boundary',
+        'timestamp': start_time.isoformat(),
+        'backend': backend.name,
+        'shots': shots,
+        'n_meas': N_MEAS,
+        'job_id': job.job_id(),
+        'usage_seconds': job.usage() or 0,
+        'wall_time_seconds': wall_time,
+        'metrics': metrics,
+        'hardware_timing': {
+            'dt_ns': dt * 1e9,
+            'measurement_duration_us': meas_duration_s * 1e6,
+            'measurement_duration_dt': meas_duration_dt,
+            'measurement_error': meas_error,
+            'qubit_0_T1_us': T1 * 1e6,
+            'qubit_0_T2_us': T2 * 1e6,
+        },
+        'results': results_data,
+    }
+
+    outfile = DATA_DIR / 'results' / 'zeno_interval' / 'zeno_interval.json'
+    outfile.parent.mkdir(exist_ok=True)
+    with open(outfile, 'w') as f:
+        json.dump(output, f, indent=2, default=str)
+    log(f"Saved: {outfile}")
+
+    # =========================================================================
+    # THE PHASE BOUNDARY
+    # =========================================================================
+    print("\n" + "=" * 70)
+    print("ZENO PHASE BOUNDARY — INTER-MEASUREMENT INTERVAL")
+    print("=" * 70)
+
+    print(f"\nN = {N_MEAS}, Qubit 0 T1 = {T1*1e6:.1f} us")
+
+    print(f"\n{'Gap(us)':>7} | {'Interval':>8} | {'Int/T1':>6} | {'X Zeno':>7} | {'I Zeno':>7} | "
+          f"{'Delay':>7} | {'X-Delay':>7} | {'Total':>7} | {'×T1':>5}")
+    print("-" * 85)
+
+    for gap_us in gap_us_values:
+        xk = f"x_zeno_gap{gap_us}"
+        ik = f"identity_zeno_gap{gap_us}"
+        dk = f"delay_gap{gap_us}"
+
+        if not all(k in results_data for k in [xk, ik, dk]):
+            continue
+
+        xa = results_data[xk]['analysis']
+        ia = results_data[ik]['analysis']
+        da = results_data[dk]['analysis']
+        xp = results_data[xk]['params']
+
+        gap_xd = xa['fidelity_excess'] - da['fidelity']
+
+        print(f"{gap_us:7.0f} | {xp['interval_us']:6.1f}us | {xp['interval_over_T1']:6.3f} | "
+              f"{xa['fidelity_excess']:7.4f} | {ia['fidelity_excess']:7.4f} | "
+              f"{da['fidelity']:7.4f} | {gap_xd:+7.4f} | {xp['total_time_us']:5.0f}us | {xp['T1_multiple']:4.1f}x")
+
+    # Find crossover
+    print(f"\n{'=' * 70}")
+    print("ANALYSIS")
+    print(f"{'=' * 70}")
+
+    prev_gap = None
+    prev_advantage = None
+    for gap_us in gap_us_values:
+        xk = f"x_zeno_gap{gap_us}"
+        dk = f"delay_gap{gap_us}"
+        if xk in results_data and dk in results_data:
+            adv = results_data[xk]['analysis']['fidelity_excess'] - results_data[dk]['analysis']['fidelity']
+            if prev_advantage is not None and adv <= 0 and prev_advantage > 0:
+                print(f"\n  Zeno advantage crosses zero between gap={prev_gap}us and gap={gap_us}us")
+            prev_gap = gap_us
+            prev_advantage = adv
+
+    # Compare 0 gap vs 100 gap
+    x0 = results_data.get('x_zeno_gap0', {}).get('analysis', {}).get('fidelity_excess', 0)
+    x100 = results_data.get('x_zeno_gap100', {}).get('analysis', {}).get('fidelity_excess', 0)
+    i0 = results_data.get('identity_zeno_gap0', {}).get('analysis', {}).get('fidelity_excess', 0)
+    i100 = results_data.get('identity_zeno_gap100', {}).get('analysis', {}).get('fidelity_excess', 0)
+
+    print(f"\n  X Zeno:  gap=0 → {x0:.4f},  gap=100μs → {x100:.4f},  decline: {x0-x100:.4f}")
+    print(f"  I Zeno:  gap=0 → {i0:.4f},  gap=100μs → {i100:.4f},  decline: {i0-i100:.4f}")
+
+    usage_after = check_usage(service)
+    log(f"\nUsage: {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)

zeno_multiaxis.py

@@ -0,0 +1,1141 @@
+"""
+Zeno Multi-Axis Validation
+
+Six-section experiment testing Zeno dragging across qubits, rotation
+angles, measurement schedules, and idle gap mitigation strategies.
+
+48 circuits, single Batch submission.
+
+Section A: Corrected multi-qubit gate comparison (W1 fix) — 18 circuits
+Section B: Per-theta VQE calibration (W4 fix) — 10 circuits
+Section C: Adaptive-N Zeno (new) — 8 circuits
+Section D: Non-uniform STZ schedule (new) — 6 circuits
+Section E: Zeno-DD hybrid (new) — 4 circuits
+Section F: Two-qubit soft weighting (new) — 2 circuits
+
+Primary metric: soft k<=2 effective yield.
+Budget: ~175s QPU remaining. Target: ~20-25s QPU.
+Safety: abort if <30s remaining; reduced mode (A+B only) if 30-50s.
+"""
+
+import json
+import sys
+from datetime import datetime, timezone
+from dataclasses import dataclass, field
+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_multiaxis"
+
+
+@dataclass
+class ExperimentConfig:
+    name: str
+    circuit: QuantumCircuit
+    category: str
+    section: str
+    params: dict
+    target_qubits: list = field(default_factory=lambda: [0])
+
+
+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_standard(theta):
+    """Standard: Ry(theta) Ry(-theta) measure. Ideal = |0>."""
+    qc = QuantumCircuit(1, 1)
+    qc.ry(theta, 0)
+    qc.ry(-theta, 0)
+    qc.measure(0, 0)
+    return qc
+
+
+def build_vqe_standard(theta):
+    """VQE prep: Ry(theta)|0>, measure Z. No undo."""
+    qc = QuantumCircuit(1, 1)
+    qc.ry(theta, 0)
+    qc.measure(0, 0)
+    return qc
+
+
+def build_zeno(theta, n_meas):
+    """Zeno drag 0->theta via N measurements, then undo. Ideal = |0>."""
+    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)
+    qc.ry(-theta, 0)
+    qc.measure(0, n_meas)
+    return qc
+
+
+def build_zeno_stz(theta, n_meas):
+    """Zeno drag with sinusoidal (STZ) schedule: theta_k = theta * sin^2(k*pi/2N).
+
+    Concentrates measurement steps near Bloch sphere poles (slow start/end,
+    fast middle). Lewalle et al. (PRX Quantum 2024) showed this is optimal.
+    """
+    qr = QuantumRegister(1, 'q')
+    cr = ClassicalRegister(n_meas + 1, 'c')
+    qc = QuantumCircuit(qr, cr)
+    for k in range(1, n_meas + 1):
+        theta_k = theta * np.sin(k * np.pi / (2 * n_meas)) ** 2
+        qc.ry(-theta_k, 0)
+        qc.measure(0, k - 1)
+        qc.ry(theta_k, 0)
+    qc.ry(-theta, 0)
+    qc.measure(0, n_meas)
+    return qc
+
+
+def build_delay_matched(theta, n_meas, meas_duration_dt):
+    """Standard gate + idle delay = same wall-clock as Zeno. Ideal = |0>."""
+    qc = QuantumCircuit(1, 1)
+    qc.ry(theta, 0)
+    qc.delay(n_meas * meas_duration_dt, 0, unit='dt')
+    qc.ry(-theta, 0)
+    qc.measure(0, 0)
+    return qc
+
+
+def build_delay_total(total_delay_dt):
+    """Pure delay then measure. Ideal = |0>."""
+    qc = QuantumCircuit(1, 1)
+    if total_delay_dt > 0:
+        qc.delay(total_delay_dt, 0, unit='dt')
+    qc.measure(0, 0)
+    return qc
+
+
+def build_zeno_bare_gap(theta, n_meas, gap_dt):
+    """Zeno drag with bare idle delay between measurements."""
+    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 gap_dt > 0 and k < n_meas:
+            qc.delay(gap_dt, 0, unit='dt')
+    qc.ry(-theta, 0)
+    qc.measure(0, n_meas)
+    return qc
+
+
+def build_zeno_dd_gap(theta, n_meas, gap_dt):
+    """Zeno drag with Hahn echo DD (delay/2 - X - delay/2) in gaps.
+
+    The X-X echo refocuses low-frequency dephasing noise during idle gaps.
+    Net unitary of DD sequence is identity (X^2 = I).
+    """
+    qr = QuantumRegister(1, 'q')
+    cr = ClassicalRegister(n_meas + 1, 'c')
+    qc = QuantumCircuit(qr, cr)
+    half_gap = gap_dt // 2
+    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 gap_dt > 0 and k < n_meas:
+            qc.delay(half_gap, 0, unit='dt')
+            qc.x(0)
+            qc.delay(gap_dt - half_gap, 0, unit='dt')
+            qc.x(0)
+    qc.ry(-theta, 0)
+    qc.measure(0, n_meas)
+    return qc
+
+
+def build_identity_zeno_bare_gap(n_meas, gap_dt):
+    """Identity Zeno (no rotation) with bare gap between measurements."""
+    qr = QuantumRegister(1, 'q')
+    cr = ClassicalRegister(n_meas + 1, 'c')
+    qc = QuantumCircuit(qr, cr)
+    for k in range(n_meas):
+        qc.measure(0, k)
+        if gap_dt > 0 and k < n_meas - 1:
+            qc.delay(gap_dt, 0, unit='dt')
+    qc.measure(0, n_meas)
+    return qc
+
+
+def build_cnot_standard():
+    """Standard: X(q0), CX round-trip, X(q0), measure both. Ideal = |00>."""
+    qc = QuantumCircuit(2, 2)
+    qc.x(0)
+    qc.cx(0, 1)
+    qc.cx(0, 1)
+    qc.x(0)
+    qc.measure([0, 1], [0, 1])
+    return qc
+
+
+def build_cnot_zeno(n_meas):
+    """Zeno drag q0 to |1>, CX round-trip, undo drag, measure both.
+
+    Intermediate measurements on q0 track drag quality.
+    Ideal = |00>.
+    """
+    theta = np.pi
+    qr = QuantumRegister(2, 'q')
+    cr = ClassicalRegister(n_meas + 2, 'c')
+    qc = QuantumCircuit(qr, cr)
+    # Zeno drag q0 from |0> to |1>
+    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)
+    # CX round-trip (q0=|1> flips q1, then flips back)
+    qc.cx(0, 1)
+    qc.cx(0, 1)
+    # Undo the drag
+    qc.ry(-theta, 0)
+    # Final measurements
+    qc.measure(0, n_meas)
+    qc.measure(1, n_meas + 1)
+    return qc
+
+
+# =============================================================================
+# ANALYSIS
+# =============================================================================
+
+def analyze_zeno(bitstrings, n_meas, p_meas):
+    """Full Zeno analysis with soft k<=2 as primary metric."""
+    total = len(bitstrings)
+    successful = 0
+    correct_given_success = 0
+    flip_bins = {}
+
+    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 flip_bins:
+            flip_bins[n_flips] = {'total': 0, 'correct': 0}
+        flip_bins[n_flips]['total'] += 1
+        if final == '0':
+            flip_bins[n_flips]['correct'] += 1
+
+        if n_flips == 0:
+            successful += 1
+            if final == '0':
+                correct_given_success += 1
+
+    success_rate = successful / total if total > 0 else 0
+    fidelity_hard = correct_given_success / successful if successful > 0 else 0
+    expected_meas_flips = n_meas * p_meas
+
+    # Soft k<=2 (PRIMARY METRIC)
+    sk2_c, sk2_t = 0, 0
+    for nf, data in flip_bins.items():
+        if nf <= 2:
+            sk2_c += data['correct']
+            sk2_t += data['total']
+    fidelity_soft_k2 = sk2_c / sk2_t if sk2_t > 0 else 0
+    utilization_k2 = sk2_t / total if total > 0 else 0
+    effective_yield_k2 = sk2_c / total if total > 0 else 0
+
+    # Excess-flip
+    w3_c, w3_t = 0, 0
+    for nf, data in flip_bins.items():
+        excess = max(0, nf - expected_meas_flips)
+        w = np.exp(-excess)
+        w3_c += w * data['correct']
+        w3_t += w * data['total']
+    fid_excess = w3_c / w3_t if w3_t > 0 else 0
+
+    # Likelihood ratio
+    w4_c, w4_t = 0, 0
+    for nf, data in flip_bins.items():
+        if nf <= n_meas:
+            p_target = comb(n_meas, nf, exact=True) * (p_meas ** nf) * ((1 - p_meas) ** (n_meas - nf))
+            p_random = comb(n_meas, nf, exact=True) * (0.5 ** n_meas)
+            w = min(p_target / p_random, 1e10) if p_random > 0 else 0
+        else:
+            w = 0
+        w4_c += w * data['correct']
+        w4_t += w * data['total']
+    fid_likelihood = w4_c / w4_t if w4_t > 0 else 0
+
+    all_flips = []
+    for nf, data in flip_bins.items():
+        all_flips.extend([nf] * data['total'])
+    mean_flips = float(np.mean(all_flips)) if all_flips else 0
+    std_flips = float(np.std(all_flips)) if all_flips else 0
+
+    return {
+        'total': total,
+        'successful': successful,
+        'success_rate': success_rate,
+        'fidelity_hard_ps': fidelity_hard,
+        'fidelity_soft_k2': fidelity_soft_k2,
+        'utilization_k2': utilization_k2,
+        'effective_yield_k2': effective_yield_k2,
+        'fidelity_excess': fid_excess,
+        'fidelity_likelihood': fid_likelihood,
+        'expected_meas_flips': expected_meas_flips,
+        'mean_flips': mean_flips,
+        'std_flips': std_flips,
+        'flip_distribution': {str(k): v for k, v in sorted(flip_bins.items())},
+        'type': 'zeno',
+    }
+
+
+def analyze_standard(bitstrings):
+    total = len(bitstrings)
+    zeros = sum(1 for b in bitstrings if b[-1] == '0')
+    return {'total': total, 'fidelity': zeros / total if total > 0 else 0, 'type': 'standard'}
+
+
+def analyze_vqe(bitstrings, theta):
+    """Analyze VQE standard circuit: P(0) -> z_raw."""
+    total = len(bitstrings)
+    p0 = sum(1 for bs in bitstrings if bs[-1] == '0') / total if total > 0 else 0.5
+    z_raw = 2 * p0 - 1
+    true_z = float(np.cos(theta))
+    return {
+        'total': total,
+        'p0': p0,
+        'z_raw': z_raw,
+        'true_z': true_z,
+        'error': z_raw - true_z,
+        'type': 'vqe_standard',
+    }
+
+
+def analyze_two_qubit_zeno(bitstrings, n_meas, p_meas):
+    """Analyze 2-qubit Zeno: intermediate on q0, final on both. Target = |00>."""
+    total = len(bitstrings)
+    flip_bins = {}
+
+    for bs in bitstrings:
+        if len(bs) < n_meas + 2:
+            continue
+        final_q1 = bs[0]
+        final_q0 = bs[1]
+        intermediate = bs[2:n_meas + 2]
+        n_flips = sum(1 for b in intermediate if b == '1')
+        correct = 1 if (final_q0 == '0' and final_q1 == '0') else 0
+
+        if n_flips not in flip_bins:
+            flip_bins[n_flips] = {'total': 0, 'correct': 0}
+        flip_bins[n_flips]['total'] += 1
+        flip_bins[n_flips]['correct'] += correct
+
+    # Soft k<=2
+    sk2_c, sk2_t = 0, 0
+    for nf, data in flip_bins.items():
+        if nf <= 2:
+            sk2_c += data['correct']
+            sk2_t += data['total']
+    fidelity_soft_k2 = sk2_c / sk2_t if sk2_t > 0 else 0
+
+    # Hard PS
+    hard_data = flip_bins.get(0, {'total': 0, 'correct': 0})
+    fidelity_hard = hard_data['correct'] / hard_data['total'] if hard_data['total'] > 0 else 0
+
+    # Raw (unweighted)
+    raw_correct = sum(d['correct'] for d in flip_bins.values())
+    fidelity_raw = raw_correct / total if total > 0 else 0
+
+    return {
+        'total': total,
+        'fidelity_soft_k2': fidelity_soft_k2,
+        'fidelity_hard_ps': fidelity_hard,
+        'fidelity_raw': fidelity_raw,
+        'soft_k2_shots': sk2_t,
+        'hard_ps_shots': hard_data['total'],
+        'flip_distribution': {str(k): v for k, v in sorted(flip_bins.items())},
+        'type': 'two_qubit_zeno',
+    }
+
+
+def analyze_two_qubit_standard(bitstrings):
+    """Analyze standard 2-qubit circuit. Target = |00>."""
+    total = len(bitstrings)
+    correct = sum(1 for bs in bitstrings if all(b == '0' for b in bs))
+    return {
+        'total': total,
+        'fidelity': correct / total if total > 0 else 0,
+        'type': 'two_qubit_standard',
+    }
+
+
+# =============================================================================
+# MAIN
+# =============================================================================
+
+def main():
+    print("=" * 70)
+    print("ZENO MULTI-AXIS VALIDATION — DEFINITIVE EXPERIMENT")
+    print("=" * 70)
+
+    service = QiskitRuntimeService(channel="ibm_cloud", instance="claude")
+
+    usage_before = check_usage(service)
+    log(f"Usage: {usage_before['total']:.1f}s / 600s ({usage_before['percentage']:.1f}%)")
+    log(f"Remaining: {usage_before['remaining']:.1f}s")
+
+    if usage_before['remaining'] < 30:
+        log("Less than 30s remaining. Aborting.")
+        return
+
+    reduced_mode = usage_before['remaining'] < 50
+    if reduced_mode:
+        log("30-50s remaining — REDUCED mode (Sections A+B only, 28 circuits)")
+
+    backend = service.backend("ibm_torino")
+    log(f"Backend: {backend.name} ({backend.num_qubits}q)")
+
+    # Hardware properties
+    dt = backend.dt
+    hw_target = backend.target
+    shots = 4096
+
+    # Target qubits for Section A: low measurement error qubits
+    # Q37 (1.0%), Q95 (2.7%), Q131 (1.8%) — replaces Q0 (11.6%)
+    section_a_qubits = [37, 95, 131]
+    qubit_info = {}
+    for qi in section_a_qubits:
+        try:
+            props = backend.qubit_properties(qi)
+            mp = hw_target['measure'][(qi,)]
+            qubit_info[qi] = {
+                'T1_us': props.t1 * 1e6,
+                'T2_us': props.t2 * 1e6,
+                'meas_error': mp.error,
+                'meas_duration_dt': int(mp.duration / dt),
+            }
+        except Exception as e:
+            log(f"WARNING: Could not get properties for Q{qi}: {e}")
+
+    if 37 not in qubit_info:
+        log("FATAL: Q37 properties unavailable. Cannot proceed.")
+        return
+
+    q37 = qubit_info[37]
+    meas_err_37 = q37['meas_error']
+    meas_dt_37 = q37['meas_duration_dt']
+
+    for qi, info in sorted(qubit_info.items()):
+        log(f"Q{qi}: T1={info['T1_us']:.1f}us, T2={info['T2_us']:.1f}us, "
+            f"meas_err={info['meas_error']:.4f}", 1)
+
+    # Find CX neighbor for Q37 (Section F)
+    cx_neighbor = None
+    if not reduced_mode:
+        try:
+            cm = backend.coupling_map
+            # Get neighbors from coupling map edges
+            neighbors = list(set(
+                [j for (i, j) in cm.get_edges() if i == 37] +
+                [i for (i, j) in cm.get_edges() if j == 37]
+            ))
+            if neighbors:
+                best_neighbor = None
+                best_err = 1.0
+                for n in neighbors:
+                    try:
+                        nerr = hw_target['measure'][(n,)].error
+                        if nerr < best_err:
+                            best_err = nerr
+                            best_neighbor = n
+                    except Exception:
+                        pass
+                cx_neighbor = best_neighbor
+                if cx_neighbor is not None:
+                    log(f"Section F: CX pair Q37-Q{cx_neighbor} "
+                        f"(neighbor meas_err={best_err:.4f})")
+                else:
+                    log("Section F: No valid CX neighbor found. Skipping.")
+            else:
+                log("Section F: Q37 has no coupling map neighbors. Skipping.")
+        except Exception as e:
+            log(f"Section F: Could not query coupling map: {e}")
+
+    # =========================================================================
+    # BUILD ALL EXPERIMENTS
+    # =========================================================================
+    all_experiments = []
+    n_meas_default = 8
+
+    # --- SECTION A: Corrected Multi-Qubit Gate Comparison (18 circuits) ---
+    log("Building Section A: Multi-qubit gate comparison...")
+    for qi in section_a_qubits:
+        if qi not in qubit_info:
+            continue
+        info = qubit_info[qi]
+        for gate_name, theta in [('I', 0.0), ('X', np.pi)]:
+            # Standard
+            all_experiments.append(ExperimentConfig(
+                name=f"a_q{qi}_{gate_name}_standard",
+                circuit=build_standard(theta),
+                category="standard",
+                section="A",
+                params={'qubit': qi, 'gate': gate_name, 'theta': theta,
+                        'T1_us': info['T1_us'], 'meas_error': info['meas_error']},
+                target_qubits=[qi],
+            ))
+            # Zeno N=8
+            all_experiments.append(ExperimentConfig(
+                name=f"a_q{qi}_{gate_name}_zeno",
+                circuit=build_zeno(theta, n_meas_default),
+                category="zeno",
+                section="A",
+                params={'qubit': qi, 'gate': gate_name, 'theta': theta,
+                        'n_meas': n_meas_default,
+                        'T1_us': info['T1_us'], 'meas_error': info['meas_error']},
+                target_qubits=[qi],
+            ))
+            # Delay-matched
+            all_experiments.append(ExperimentConfig(
+                name=f"a_q{qi}_{gate_name}_delay",
+                circuit=build_delay_matched(theta, n_meas_default,
+                                            info['meas_duration_dt']),
+                category="delay_matched",
+                section="A",
+                params={'qubit': qi, 'gate': gate_name, 'theta': theta,
+                        'n_meas': n_meas_default,
+                        'T1_us': info['T1_us'], 'meas_error': info['meas_error']},
+                target_qubits=[qi],
+            ))
+
+    # --- SECTION B: Per-Theta VQE Calibration (10 circuits) ---
+    log("Building Section B: Per-theta VQE calibration...")
+    vqe_thetas = [0.2, 0.8, 1.5, 2.4, np.pi]
+    for theta in vqe_thetas:
+        theta_label = f"{theta:.2f}".replace('.', 'p')
+        # Standard VQE (just Ry, no undo)
+        all_experiments.append(ExperimentConfig(
+            name=f"b_vqe_std_t{theta_label}",
+            circuit=build_vqe_standard(theta),
+            category="vqe_standard",
+            section="B",
+            params={'theta': theta, 'true_z': float(np.cos(theta))},
+            target_qubits=[37],
+        ))
+        # Zeno calibration (drag + undo, gives f(theta))
+        all_experiments.append(ExperimentConfig(
+            name=f"b_vqe_zeno_t{theta_label}",
+            circuit=build_zeno(theta, n_meas_default),
+            category="zeno",
+            section="B",
+            params={'theta': theta, 'n_meas': n_meas_default,
+                    'meas_error': meas_err_37},
+            target_qubits=[37],
+        ))
+
+    if not reduced_mode:
+        # --- SECTION C: Adaptive-N (8 circuits) ---
+        log("Building Section C: Adaptive-N Zeno...")
+        adaptive_configs = [
+            (np.pi / 8, [4, 8]),
+            (np.pi / 2, [4, 8, 12]),
+            (np.pi, [8, 12, 16]),
+        ]
+        for theta, n_values in adaptive_configs:
+            theta_label = f"{theta/np.pi:.3f}pi".replace('.', 'p')
+            for n in n_values:
+                all_experiments.append(ExperimentConfig(
+                    name=f"c_t{theta_label}_n{n}",
+                    circuit=build_zeno(theta, n),
+                    category="zeno",
+                    section="C",
+                    params={'theta': theta, 'n_meas': n,
+                            'meas_error': meas_err_37},
+                    target_qubits=[37],
+                ))
+
+        # --- SECTION D: Non-Uniform Schedule / STZ (6 circuits) ---
+        log("Building Section D: STZ non-uniform schedule...")
+        stz_thetas = [np.pi / 2, 3 * np.pi / 4, np.pi]
+        for theta in stz_thetas:
+            theta_label = f"{theta/np.pi:.3f}pi".replace('.', 'p')
+            # Uniform (standard Zeno)
+            all_experiments.append(ExperimentConfig(
+                name=f"d_uniform_t{theta_label}",
+                circuit=build_zeno(theta, n_meas_default),
+                category="zeno_uniform",
+                section="D",
+                params={'theta': theta, 'n_meas': n_meas_default,
+                        'schedule': 'uniform', 'meas_error': meas_err_37},
+                target_qubits=[37],
+            ))
+            # Sinusoidal (STZ)
+            all_experiments.append(ExperimentConfig(
+                name=f"d_stz_t{theta_label}",
+                circuit=build_zeno_stz(theta, n_meas_default),
+                category="zeno_stz",
+                section="D",
+                params={'theta': theta, 'n_meas': n_meas_default,
+                        'schedule': 'sinusoidal', 'meas_error': meas_err_37},
+                target_qubits=[37],
+            ))
+
+        # --- SECTION E: Zeno-DD Hybrid (4 circuits) ---
+        log("Building Section E: Zeno-DD hybrid...")
+        gap_us = 10
+        gap_s = gap_us * 1e-6
+        gap_dt = int(gap_s / dt)
+        theta_E = np.pi  # X gate
+
+        # 1. X Zeno + bare gap
+        all_experiments.append(ExperimentConfig(
+            name="e_x_zeno_bare_gap",
+            circuit=build_zeno_bare_gap(theta_E, n_meas_default, gap_dt),
+            category="zeno_bare_gap",
+            section="E",
+            params={'theta': theta_E, 'n_meas': n_meas_default,
+                    'gap_us': gap_us, 'gap_dt': gap_dt,
+                    'meas_error': meas_err_37},
+            target_qubits=[37],
+        ))
+        # 2. X Zeno + DD echo in gap
+        all_experiments.append(ExperimentConfig(
+            name="e_x_zeno_dd_gap",
+            circuit=build_zeno_dd_gap(theta_E, n_meas_default, gap_dt),
+            category="zeno_dd_gap",
+            section="E",
+            params={'theta': theta_E, 'n_meas': n_meas_default,
+                    'gap_us': gap_us, 'gap_dt': gap_dt,
+                    'meas_error': meas_err_37},
+            target_qubits=[37],
+        ))
+        # 3. Delay-matched baseline (same total time)
+        total_delay_e = (n_meas_default * meas_dt_37
+                         + (n_meas_default - 1) * gap_dt)
+        all_experiments.append(ExperimentConfig(
+            name="e_delay_matched",
+            circuit=build_delay_total(total_delay_e),
+            category="delay_matched",
+            section="E",
+            params={'theta': 0.0, 'total_delay_dt': total_delay_e,
+                    'gap_us': gap_us},
+            target_qubits=[37],
+        ))
+        # 4. Identity Zeno + bare gap (control)
+        all_experiments.append(ExperimentConfig(
+            name="e_identity_zeno_bare_gap",
+            circuit=build_identity_zeno_bare_gap(n_meas_default, gap_dt),
+            category="identity_zeno_bare_gap",
+            section="E",
+            params={'theta': 0.0, 'n_meas': n_meas_default,
+                    'gap_us': gap_us, 'gap_dt': gap_dt,
+                    'meas_error': meas_err_37},
+            target_qubits=[37],
+        ))
+
+        # --- SECTION F: Two-Qubit Zeno with Soft Weighting (2 circuits) ---
+        if cx_neighbor is not None:
+            log(f"Building Section F: Two-qubit Zeno on Q37-Q{cx_neighbor}...")
+            # Standard CNOT round-trip
+            all_experiments.append(ExperimentConfig(
+                name="f_cnot_standard",
+                circuit=build_cnot_standard(),
+                category="two_qubit_standard",
+                section="F",
+                params={'control': 37, 'target_qubit': cx_neighbor},
+                target_qubits=[37, cx_neighbor],
+            ))
+            # Zeno CNOT round-trip
+            all_experiments.append(ExperimentConfig(
+                name="f_cnot_zeno",
+                circuit=build_cnot_zeno(n_meas_default),
+                category="two_qubit_zeno",
+                section="F",
+                params={'control': 37, 'target_qubit': cx_neighbor,
+                        'n_meas': n_meas_default,
+                        'meas_error': meas_err_37},
+                target_qubits=[37, cx_neighbor],
+            ))
+
+    section_counts = {}
+    for exp in all_experiments:
+        section_counts[exp.section] = section_counts.get(exp.section, 0) + 1
+    for s, c in sorted(section_counts.items()):
+        log(f"Section {s}: {c} circuits", 1)
+    log(f"Total circuits: {len(all_experiments)}")
+
+    # =========================================================================
+    # TRANSPILE (with per-qubit initial_layout)
+    # =========================================================================
+    log("Transpiling...")
+    pm_cache = {}
+    transpiled = []
+    valid_experiments = []
+
+    for exp in all_experiments:
+        layout_key = tuple(exp.target_qubits)
+        if layout_key not in pm_cache:
+            pm_cache[layout_key] = generate_preset_pass_manager(
+                backend=backend,
+                optimization_level=1,
+                initial_layout=list(layout_key),
+            )
+        try:
+            tc = pm_cache[layout_key].run(exp.circuit)
+            transpiled.append(tc)
+            valid_experiments.append(exp)
+        except Exception as e:
+            log(f"ERROR transpiling {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"Done. Wall time: {wall_time:.1f}s, QPU: {job.usage() or 0}s")
+
+    # =========================================================================
+    # PARSE RESULTS
+    # =========================================================================
+    result = job.result()
+    metrics = job.metrics()
+    results_data = {}
+
+    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())
+
+        p_meas = exp.params.get('meas_error', meas_err_37)
+        n_meas = exp.params.get('n_meas', 0)
+
+        if exp.category == 'two_qubit_zeno':
+            analysis = analyze_two_qubit_zeno(bitstrings, n_meas, p_meas)
+        elif exp.category == 'two_qubit_standard':
+            analysis = analyze_two_qubit_standard(bitstrings)
+        elif exp.category == 'vqe_standard':
+            analysis = analyze_vqe(bitstrings, exp.params['theta'])
+        elif 'zeno' in exp.category:
+            analysis = analyze_zeno(bitstrings, n_meas, p_meas)
+        else:
+            analysis = analyze_standard(bitstrings)
+
+        results_data[exp.name] = {
+            'section': exp.section,
+            'category': exp.category,
+            'params': {k: (float(v) if isinstance(v, (np.floating, float)) else v)
+                       for k, v in exp.params.items()},
+            'analysis': analysis,
+            'raw_bitstrings': bitstrings,  # all 4096, not truncated
+        }
+
+    # =========================================================================
+    # SECTION A ANALYSIS
+    # =========================================================================
+    print("\n" + "=" * 70)
+    print("SECTION A: CORRECTED MULTI-QUBIT GATE COMPARISON (W1 fix)")
+    print("=" * 70)
+
+    print(f"\n  {'Qubit':>5} | {'MeasErr':>7} | {'Gate':>4} | {'Standard':>8} | "
+          f"{'Zeno k2':>8} | {'Delay':>7} | {'Z-Std':>7} | {'Z-Delay':>7}")
+    print("  " + "-" * 70)
+
+    a_improvements_I = []
+    a_improvements_X = []
+
+    for qi in section_a_qubits:
+        if qi not in qubit_info:
+            continue
+        for gate_name in ['I', 'X']:
+            std_key = f"a_q{qi}_{gate_name}_standard"
+            zen_key = f"a_q{qi}_{gate_name}_zeno"
+            del_key = f"a_q{qi}_{gate_name}_delay"
+
+            std_fid = results_data.get(std_key, {}).get('analysis', {}).get('fidelity', 0)
+            zen_k2 = results_data.get(zen_key, {}).get('analysis', {}).get('fidelity_soft_k2', 0)
+            del_fid = results_data.get(del_key, {}).get('analysis', {}).get('fidelity', 0)
+            merr = qubit_info[qi]['meas_error']
+
+            imp = zen_k2 - std_fid
+            if gate_name == 'I':
+                a_improvements_I.append(imp)
+            else:
+                a_improvements_X.append(imp)
+
+            print(f"  Q{qi:>3} | {merr:7.4f} | {gate_name:>4} | {std_fid:8.4f} | "
+                  f"{zen_k2:8.4f} | {del_fid:7.4f} | {imp:+7.4f} | "
+                  f"{zen_k2-del_fid:+7.4f}")
+
+    i_wins = sum(1 for x in a_improvements_I if x > 0)
+    x_wins = sum(1 for x in a_improvements_X if x > 0)
+    n_qubits_tested = len([q for q in section_a_qubits if q in qubit_info])
+    print(f"\n  I gate: Zeno improvement on {i_wins}/{n_qubits_tested} qubits")
+    print(f"  X gate: Zeno improvement on {x_wins}/{n_qubits_tested} qubits")
+
+    # =========================================================================
+    # SECTION B ANALYSIS
+    # =========================================================================
+    print("\n" + "=" * 70)
+    print("SECTION B: PER-THETA VQE CALIBRATION (W4 fix)")
+    print("=" * 70)
+
+    print(f"\n  {'theta':>7} | {'cos(t)':>7} | {'z_raw':>7} | {'f(t) k2':>8} | "
+          f"{'err_std':>8} | {'err_glob':>8} | {'err_per':>8}")
+    print("  " + "-" * 70)
+
+    z_raws = []
+    fidelities_b = []
+    true_zs = []
+
+    for theta in vqe_thetas:
+        theta_label = f"{theta:.2f}".replace('.', 'p')
+        std_key = f"b_vqe_std_t{theta_label}"
+        zen_key = f"b_vqe_zeno_t{theta_label}"
+
+        vqe_a = results_data.get(std_key, {}).get('analysis', {})
+        zen_a = results_data.get(zen_key, {}).get('analysis', {})
+
+        z_raw = vqe_a.get('z_raw', 0)
+        true_z = float(np.cos(theta))
+        f_theta = zen_a.get('fidelity_soft_k2', 0.5)
+
+        z_raws.append(z_raw)
+        fidelities_b.append(f_theta)
+        true_zs.append(true_z)
+
+    f_global = np.mean(fidelities_b) if fidelities_b else 0.5
+
+    std_errors_sq = []
+    glob_errors_sq = []
+    per_errors_sq = []
+
+    for i, theta in enumerate(vqe_thetas):
+        z_raw = z_raws[i]
+        f_theta = fidelities_b[i]
+        true_z = true_zs[i]
+
+        err_std = z_raw - true_z
+
+        denom_glob = 2 * f_global - 1
+        z_glob = z_raw / denom_glob if abs(denom_glob) > 0.01 else z_raw
+        z_glob = max(-1.0, min(1.0, z_glob))
+        err_glob = z_glob - true_z
+
+        denom_per = 2 * f_theta - 1
+        z_per = z_raw / denom_per if abs(denom_per) > 0.01 else z_raw
+        z_per = max(-1.0, min(1.0, z_per))
+        err_per = z_per - true_z
+
+        std_errors_sq.append(err_std ** 2)
+        glob_errors_sq.append(err_glob ** 2)
+        per_errors_sq.append(err_per ** 2)
+
+        print(f"  {theta:7.3f} | {true_z:+7.4f} | {z_raw:+7.4f} | {f_theta:8.4f} | "
+              f"{err_std:+8.4f} | {err_glob:+8.4f} | {err_per:+8.4f}")
+
+    rmse_std = float(np.sqrt(np.mean(std_errors_sq))) if std_errors_sq else 0
+    rmse_glob = float(np.sqrt(np.mean(glob_errors_sq))) if glob_errors_sq else 0
+    rmse_per = float(np.sqrt(np.mean(per_errors_sq))) if per_errors_sq else 0
+
+    print(f"\n  RMSE standard:   {rmse_std:.4f}")
+    print(f"  RMSE global-f:   {rmse_glob:.4f} (f_global={f_global:.4f})")
+    print(f"  RMSE per-theta:  {rmse_per:.4f}")
+
+    if rmse_per < rmse_glob < rmse_std:
+        print("  RESULT: per-theta < global < standard")
+    elif rmse_per < rmse_std:
+        print("  RESULT: per-theta improves over standard")
+    else:
+        print("  RESULT: correction does not improve RMSE — honest result")
+
+    if not reduced_mode:
+        # =================================================================
+        # SECTION C ANALYSIS
+        # =================================================================
+        print("\n" + "=" * 70)
+        print("SECTION C: ADAPTIVE-N ZENO")
+        print("=" * 70)
+
+        print(f"\n  {'theta':>8} | {'N':>3} | {'k2 fid':>7} | {'k2 yield':>8} | "
+              f"{'hard PS':>7} | {'success':>7} | {'excess':>7}")
+        print("  " + "-" * 65)
+
+        for theta, n_values in adaptive_configs:
+            for n in n_values:
+                theta_label = f"{theta/np.pi:.3f}pi".replace('.', 'p')
+                key = f"c_t{theta_label}_n{n}"
+                a = results_data.get(key, {}).get('analysis', {})
+
+                fk2 = a.get('fidelity_soft_k2', 0)
+                yk2 = a.get('effective_yield_k2', 0)
+                fh = a.get('fidelity_hard_ps', 0)
+                sr = a.get('success_rate', 0)
+                fe = a.get('fidelity_excess', 0)
+
+                print(f"  {theta/np.pi:6.3f}pi | {n:3d} | {fk2:7.4f} | {yk2:8.4f} | "
+                      f"{fh:7.4f} | {sr*100:6.1f}% | {fe:7.4f}")
+            print()
+
+        # Check: does N=4 suffice for small angles?
+        pi8_n4 = results_data.get(
+            f"c_t{(np.pi/8/np.pi):.3f}pi_n4".replace('.', 'p'), {}
+        ).get('analysis', {}).get('fidelity_soft_k2', 0)
+        pi8_n8 = results_data.get(
+            f"c_t{(np.pi/8/np.pi):.3f}pi_n8".replace('.', 'p'), {}
+        ).get('analysis', {}).get('fidelity_soft_k2', 0)
+        if pi8_n4 > 0 and pi8_n8 > 0:
+            diff = pi8_n8 - pi8_n4
+            print(f"  pi/8: N=4 vs N=8 fidelity gap: {diff:+.4f}")
+            if abs(diff) < 0.02:
+                print("  -> N=4 suffices for small angles (2x shallower)")
+            else:
+                print("  -> N=8 still meaningfully better")
+
+        # =================================================================
+        # SECTION D ANALYSIS
+        # =================================================================
+        print("\n" + "=" * 70)
+        print("SECTION D: NON-UNIFORM SCHEDULE (STZ)")
+        print("=" * 70)
+
+        print(f"\n  {'theta':>8} | {'Schedule':>10} | {'k2 fid':>7} | "
+              f"{'k2 yield':>8} | {'excess':>7} | {'diff':>7}")
+        print("  " + "-" * 60)
+
+        d_diffs = []
+        for theta in stz_thetas:
+            theta_label = f"{theta/np.pi:.3f}pi".replace('.', 'p')
+            uni_key = f"d_uniform_t{theta_label}"
+            stz_key = f"d_stz_t{theta_label}"
+
+            uni_a = results_data.get(uni_key, {}).get('analysis', {})
+            stz_a = results_data.get(stz_key, {}).get('analysis', {})
+
+            uni_k2 = uni_a.get('fidelity_soft_k2', 0)
+            stz_k2 = stz_a.get('fidelity_soft_k2', 0)
+            uni_y = uni_a.get('effective_yield_k2', 0)
+            stz_y = stz_a.get('effective_yield_k2', 0)
+            uni_e = uni_a.get('fidelity_excess', 0)
+            stz_e = stz_a.get('fidelity_excess', 0)
+            diff_pp = (stz_k2 - uni_k2) * 100
+            d_diffs.append(abs(stz_k2 - uni_k2))
+
+            print(f"  {theta/np.pi:6.3f}pi | {'uniform':>10} | {uni_k2:7.4f} | "
+                  f"{uni_y:8.4f} | {uni_e:7.4f} |")
+            print(f"  {'':>8} | {'sinusoidal':>10} | {stz_k2:7.4f} | "
+                  f"{stz_y:8.4f} | {stz_e:7.4f} | {diff_pp:+6.1f}pp")
+
+        any_gt_half = any(d > 0.005 for d in d_diffs)
+        print(f"\n  >0.5pp difference for any angle: {any_gt_half}")
+
+        # =================================================================
+        # SECTION E ANALYSIS
+        # =================================================================
+        print("\n" + "=" * 70)
+        print("SECTION E: ZENO-DD HYBRID")
+        print("=" * 70)
+
+        e_configs = [
+            ("X Zeno + bare gap", "e_x_zeno_bare_gap", True),
+            ("X Zeno + DD echo",  "e_x_zeno_dd_gap",   True),
+            ("Delay-matched",     "e_delay_matched",    False),
+            ("I Zeno + bare gap", "e_identity_zeno_bare_gap", True),
+        ]
+
+        print(f"\n  {'Variant':>22} | {'k2 fid':>7} | {'k2 yield':>8} | "
+              f"{'excess':>7} | {'fidelity':>8}")
+        print("  " + "-" * 60)
+
+        for label, key, is_zeno in e_configs:
+            a = results_data.get(key, {}).get('analysis', {})
+            if is_zeno:
+                fk2 = a.get('fidelity_soft_k2', 0)
+                yk2 = a.get('effective_yield_k2', 0)
+                fe = a.get('fidelity_excess', 0)
+                print(f"  {label:>22} | {fk2:7.4f} | {yk2:8.4f} | "
+                      f"{fe:7.4f} | {'---':>8}")
+            else:
+                fid = a.get('fidelity', 0)
+                print(f"  {label:>22} | {'---':>7} | {'---':>8} | "
+                      f"{'---':>7} | {fid:8.4f}")
+
+        bare_k2 = (results_data.get("e_x_zeno_bare_gap", {})
+                    .get('analysis', {}).get('fidelity_soft_k2', 0))
+        dd_k2 = (results_data.get("e_x_zeno_dd_gap", {})
+                  .get('analysis', {}).get('fidelity_soft_k2', 0))
+        print(f"\n  DD improvement over bare gap: {(dd_k2 - bare_k2)*100:+.1f}pp")
+
+        # =================================================================
+        # SECTION F ANALYSIS
+        # =================================================================
+        if cx_neighbor is not None and 'f_cnot_standard' in results_data:
+            print("\n" + "=" * 70)
+            print(f"SECTION F: TWO-QUBIT ZENO (Q37-Q{cx_neighbor})")
+            print("=" * 70)
+
+            std_f = results_data['f_cnot_standard']['analysis']
+            zen_f = results_data.get('f_cnot_zeno', {}).get('analysis', {})
+
+            std_fid = std_f.get('fidelity', 0)
+            zen_k2 = zen_f.get('fidelity_soft_k2', 0)
+            zen_hard = zen_f.get('fidelity_hard_ps', 0)
+            zen_raw = zen_f.get('fidelity_raw', 0)
+
+            print(f"\n  Standard CNOT round-trip: {std_fid:.4f}")
+            print(f"  Zeno CNOT (hard PS):     {zen_hard:.4f} "
+                  f"({zen_f.get('hard_ps_shots', 0)} shots)")
+            print(f"  Zeno CNOT (soft k<=2):   {zen_k2:.4f} "
+                  f"({zen_f.get('soft_k2_shots', 0)} shots)")
+            print(f"  Zeno CNOT (raw):         {zen_raw:.4f}")
+            print(f"  Improvement (k2-std):    {zen_k2 - std_fid:+.4f}")
+
+    # =========================================================================
+    # SAVE
+    # =========================================================================
+    output = {
+        'experiment': 'zeno_multiaxis',
+        'description': (
+            'Definitive experiment: corrects W1-W6 weakness failures and tests '
+            'adaptive-N, STZ scheduling, DD hybrids, soft-weighted two-qubit '
+            'operations. Primary metric: soft k<=2 effective yield.'
+        ),
+        'timestamp': start_time.isoformat(),
+        'backend': backend.name,
+        'shots': shots,
+        'job_id': job.job_id(),
+        'usage_seconds': job.usage() or 0,
+        'wall_time_seconds': wall_time,
+        'metrics': metrics,
+        'reduced_mode': reduced_mode,
+        'hardware': {
+            'dt_ns': dt * 1e9,
+            'qubit_info': {str(k): v for k, v in qubit_info.items()},
+            'cx_neighbor': cx_neighbor,
+        },
+        'sections': {},
+        'results': results_data,
+    }
+
+    # Section-level summaries
+    for section_id in ['A', 'B', 'C', 'D', 'E', 'F']:
+        section_results = {k: v for k, v in results_data.items()
+                          if v['section'] == section_id}
+        if section_results:
+            output['sections'][section_id] = {
+                'n_circuits': len(section_results),
+                'circuit_names': list(section_results.keys()),
+            }
+
+    # VQE RMSE summary
+    output['sections'].setdefault('B', {}).update({
+        'rmse_standard': rmse_std,
+        'rmse_global': rmse_glob,
+        'rmse_pertheta': rmse_per,
+        'f_global': float(f_global),
+    })
+
+    RESULTS_DIR.mkdir(parents=True, exist_ok=True)
+    outfile = RESULTS_DIR / 'zeno_multiaxis.json'
+    with open(outfile, 'w') as f:
+        json.dump(output, f, indent=2, default=str)
+    log(f"Saved: {outfile}")
+
+    # =========================================================================
+    # SUMMARY
+    # =========================================================================
+    print("\n" + "=" * 70)
+    print("SUMMARY")
+    print("=" * 70)
+
+    print(f"\n  Total circuits: {len(valid_experiments)}")
+    print(f"  QPU time: {job.usage() or 0}s")
+    print(f"  Wall time: {wall_time:.1f}s")
+    for s, c in sorted(section_counts.items()):
+        print(f"  Section {s}: {c} circuits")
+
+    usage_after = check_usage(service)
+    log(f"\nUsage: {usage_after['total']:.1f}s / 600s "
+        f"({usage_after['percentage']:.1f}%)")
+    log(f"Remaining: {usage_after['remaining']:.1f}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)