Add Zeno diagnostic: identity vs X Zeno at high N

Identity Zeno holds at 91.2% at 14x T1. Gate errors cause
60% of X Zeno decline; measurement mechanism causes 40%.

README.md

@@ -640,6 +640,22 @@ At 3.47× T1 the delay-matched control reads 18.3%, approaching the thermal floo
 
 The delay-matched control reaches the thermal floor (~17%) by 3× T1 and remains there through 14× T1. Zeno excess-flip weighted fidelity declines at approximately 2.5 percentage points per doubling of N, consistent with logarithmic degradation. At 13.86× T1, the Zeno-protected qubit maintains 77% fidelity while the delay-matched control reads 16.8%.
 
+### Zeno Fidelity Decline Diagnostic
+
+**zeno_diagnostic/** — Identifies the source of fidelity decline observed at high N. The X gate Zeno protocol requires Ry rotation gates between each measurement; at N=1024 this amounts to 2048 rotations decomposed into ~5000 native gates. To determine whether the decline from 92% (N=32) to 77% (N=1024) originates from accumulated gate errors or from the measurement mechanism itself, we compare identity Zeno (repeated measurement with no rotations) against X Zeno (measurement with Ry rotations) at matched N values. Fifteen circuits were run at 4096 shots each on ibm_torino (job d6jjtl860irc7394k8rg, 55s QPU time, March 3 2026).
+
+**Results (excess-flip weighting, 4096 shots per circuit):**
+
+| N | ×T1 | Identity Zeno | X Zeno | Delay-matched | I − X |
+|---|-----|---------------|--------|---------------|-------|
+| 32 | 0.43 | 95.4% | 92.5% | 89.0% | +2.9pp |
+| 128 | 1.73 | 94.4% | 91.1% | 86.6% | +3.2pp |
+| 256 | 3.47 | 93.7% | 88.6% | 87.6% | +5.2pp |
+| 512 | 6.93 | 92.6% | 82.8% | 88.8% | +9.7pp |
+| 1024 | 13.86 | 91.2% | 82.3% | 87.3% | +8.9pp |
+
+Identity Zeno declines by 4.2 percentage points from N=32 to N=1024. X Zeno declines by 10.2 percentage points over the same range. The measurement mechanism accounts for roughly 40% of the total decline; accumulated Ry gate errors account for the remaining 60%. The Zeno projection mechanism itself remains effective at 91.2% fidelity after 1024 consecutive measurements spanning 14× T1.
+
 ---
 
 ## Data Format

zeno_diagnostic.py

@@ -0,0 +1,438 @@
+"""
+Zeno Diagnostic — Is the decline from gate errors or measurement mechanism?
+
+Identity Zeno (theta=0): just measure the qubit repeatedly, no rotations.
+If identity stays at 95% while X declined to 77% at N=1024,
+the decline is from accumulated Ry gate errors.
+If identity also declines, it's the measurement mechanism itself.
+"""
+
+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")
+
+
+@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_identity_zeno(n_meas):
+    """Zeno freeze: just measure |0> repeatedly. No rotations. Ideal = |0>."""
+    qr = QuantumRegister(1, 'q')
+    cr = ClassicalRegister(n_meas + 1, 'c')
+    qc = QuantumCircuit(qr, cr)
+
+    for k in range(n_meas):
+        qc.measure(0, k)
+
+    qc.measure(0, n_meas)
+    return qc
+
+
+def build_x_zeno(n_meas):
+    """Zeno drag 0->pi via N measurements, then undo. Ideal = |0>. (For comparison.)"""
+    theta = np.pi
+    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_delay_matched(n_meas, meas_duration_dt):
+    """Identity + delay = same wall-clock. Ideal = |0>."""
+    qc = QuantumCircuit(1, 1)
+    qc.delay(n_meas * meas_duration_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
+
+    # 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',
+    }
+
+
+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 DIAGNOSTIC — GATE ERRORS OR MEASUREMENT MECHANISM?")
+    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, error={meas_error:.4f}")
+    log(f"Qubit 0: T1={T1*1e6:.1f} us, T2={T2*1e6:.1f} us")
+
+    n_values = [32, 128, 256, 512, 1024]
+    shots = 4096
+
+    all_experiments = []
+
+    for n in n_values:
+        total_time_us = n * meas_duration_s * 1e6
+        t1_mult = n * meas_duration_s / T1
+
+        # Identity Zeno — no rotations
+        all_experiments.append(ExperimentConfig(
+            name=f"identity_zeno_N{n}",
+            circuit=build_identity_zeno(n),
+            category="identity_zeno",
+            params={'gate': 'I', 'theta': 0, 'n_meas': n,
+                    'total_time_us': total_time_us,
+                    'T1_multiple': t1_mult},
+        ))
+
+        # X Zeno — with rotations (for direct comparison)
+        all_experiments.append(ExperimentConfig(
+            name=f"x_zeno_N{n}",
+            circuit=build_x_zeno(n),
+            category="x_zeno",
+            params={'gate': 'X', 'theta': np.pi, 'n_meas': n,
+                    'total_time_us': total_time_us,
+                    'T1_multiple': t1_mult},
+        ))
+
+        # Delay-matched
+        all_experiments.append(ExperimentConfig(
+            name=f"delay_N{n}",
+            circuit=build_delay_matched(n, meas_duration_dt),
+            category="delay",
+            params={'gate': 'I', 'theta': 0, 'n_meas': n,
+                    'total_time_us': total_time_us,
+                    'T1_multiple': t1_mult},
+        ))
+
+    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_diagnostic',
+        'description': 'Diagnose Zeno fidelity decline: gate errors vs measurement mechanism',
+        '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,
+        '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_diagnostic' / 'zeno_diagnostic.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 ANSWER
+    # =========================================================================
+    print("\n" + "=" * 70)
+    print("DIAGNOSTIC: IDENTITY ZENO vs X ZENO vs DELAY")
+    print("=" * 70)
+
+    print(f"\n{'N':>5} | {'×T1':>5} | {'I Zeno(exc)':>11} | {'X Zeno(exc)':>11} | {'Delay':>7} | {'I-X gap':>7} | {'I flips':>10} | {'X flips':>10}")
+    print("-" * 90)
+
+    for n in n_values:
+        ik = f"identity_zeno_N{n}"
+        xk = f"x_zeno_N{n}"
+        dk = f"delay_N{n}"
+
+        if not all(k in results_data for k in [ik, xk, dk]):
+            continue
+
+        ia = results_data[ik]['analysis']
+        xa = results_data[xk]['analysis']
+        da = results_data[dk]['analysis']
+        t1m = results_data[ik]['params']['T1_multiple']
+
+        gap = ia['fidelity_excess'] - xa['fidelity_excess']
+
+        print(f"{n:5d} | {t1m:4.1f}x | {ia['fidelity_excess']:11.4f} | {xa['fidelity_excess']:11.4f} | "
+              f"{da['fidelity']:7.4f} | {gap:+7.4f} | {ia['mean_flips']:4.1f}±{ia['std_flips']:<4.1f} | "
+              f"{xa['mean_flips']:4.1f}±{xa['std_flips']:<4.1f}")
+
+    print(f"\n{'=' * 70}")
+    print("VERDICT")
+    print(f"{'=' * 70}")
+
+    # Compare decline rates
+    i_fids = []
+    x_fids = []
+    for n in n_values:
+        ik = f"identity_zeno_N{n}"
+        xk = f"x_zeno_N{n}"
+        if ik in results_data and xk in results_data:
+            i_fids.append(results_data[ik]['analysis']['fidelity_excess'])
+            x_fids.append(results_data[xk]['analysis']['fidelity_excess'])
+
+    i_decline = i_fids[0] - i_fids[-1]
+    x_decline = x_fids[0] - x_fids[-1]
+
+    print(f"\n  Identity Zeno decline (N={n_values[0]} to N={n_values[-1]}): {i_decline:+.4f}")
+    print(f"  X gate Zeno decline (N={n_values[0]} to N={n_values[-1]}):    {x_decline:+.4f}")
+    print(f"  Difference: {x_decline - i_decline:.4f}")
+
+    if i_decline < 0.05 and x_decline > 0.10:
+        print(f"\n  GATE ERRORS are the bottleneck.")
+        print(f"  Identity Zeno holds steady — the measurement mechanism works.")
+        print(f"  X Zeno declines — accumulated Ry rotation errors cause the drop.")
+        print(f"  Better gates would eliminate the decline.")
+    elif abs(i_decline - x_decline) < 0.05:
+        print(f"\n  MEASUREMENT MECHANISM is the bottleneck.")
+        print(f"  Both identity and X decline similarly.")
+        print(f"  The rotations aren't the problem — repeated measurement itself degrades fidelity.")
+    else:
+        print(f"\n  MIXED: both contribute.")
+        print(f"  Identity decline: {i_decline:.4f}")
+        print(f"  X decline: {x_decline:.4f}")
+        print(f"  Gate errors account for ~{(x_decline - i_decline)/x_decline*100:.0f}% of the decline.")
+
+    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)