qcoder 0.1.0a0__py3-none-any.whl

qcoder/tools/runners/quantum_rings/v12/mirror.py

@@ -0,0 +1,459 @@
+#!/usr/bin/env python3
+"""
+qcoder.tools.mirror
+
+Mirror runner:
+- Builds mirror QASM (U then U†) using qcoder.core.qasm2.mirror_build
+- Loads mirror circuit in QuantumRingsLib
+- Runs with measurements
+- Computes mirror "success probability": P(measuring all-zeros) from counts
+- Records wall time + peak RSS (external sampler)
+- Records SDK-native metrics best-effort:
+    - result.get_fidelity()            (semantics TBD; logged for analysis)
+    - result.get_peakmemorysize(0)     (signature requires an int)
+    - result.get_memory()
+
+Why counts-based mirror?
+- Venkat says get_amplitude is not a published API; do not use.
+- Counts-based "return-to-zero probability" is a standard mirror-style metric.
+
+NOTE:
+- This is NOT guaranteed to correlate perfectly with forward-distribution fidelity,
+  but it is at least well-defined and doesn’t rely on unpublished amplitude APIs.
+"""
+
+from qcoder.tools import qr_dll_bootstrap
+
+qr_dll_bootstrap.bootstrap()
+
+import argparse
+import datetime as _dt
+import hashlib
+import importlib.metadata as _imd
+import json
+import os
+import platform
+import re
+import subprocess
+import sys
+import time
+from typing import Any, Dict, List, Optional, Tuple
+
+import psutil
+
+from QuantumRingsLib import QuantumRingsProvider, QuantumCircuit, job_monitor
+
+from qcoder.core.qasm2.mirror_build import build_mirror_qasm, UnsupportedQasm
+from qcoder.core.qasm2.adjoint_eligibility import classify_mirror_eligibility
+
+
+# -----------------------------
+# Helpers
+# -----------------------------
+
+def die(msg: str, code: int = 1) -> None:
+    print(f"[fatal] {msg}", file=sys.stderr, flush=True)
+    sys.exit(code)
+
+def sha256_file(path: str) -> str:
+    h = hashlib.sha256()
+    with open(path, "rb") as f:
+        while True:
+            b = f.read(1 << 20)
+            if not b:
+                break
+            h.update(b)
+    return h.hexdigest()
+
+def resolve_backend_id(provider: QuantumRingsProvider, backend_arg: str, precision: str) -> str:
+    """
+    Accept friendly names (Scarlet/Amber/Serin or CPU/GPU/Both) OR raw backend ids.
+    """
+    if not backend_arg:
+        return "scarlet_quantum_rings"
+
+    b = backend_arg.strip()
+    if "_" in b or b.endswith("_quantum_rings"):
+        return b
+
+    key = b.lower()
+    if key in ("scarlet", "cpu"):
+        candidates = ["scarlet_quantum_rings", "scarlet"]
+    elif key in ("amber", "gpu"):
+        candidates = ["amber_quantum_rings", "amber"]
+    elif key in ("serin", "both", "hybrid"):
+        candidates = ["serin_quantum_rings", "serin"]
+    else:
+        candidates = [b]
+
+    last_err = None
+    for cid in candidates:
+        try:
+            _ = provider.get_backend(cid, precision=precision)
+            return cid
+        except Exception as e:
+            last_err = e
+    die(f"Could not resolve backend '{backend_arg}'. Tried: {candidates}. Last error: {last_err}")
+    return b  # unreachable
+
+def default_json_out(qasm_path: str, backend_id: str, precision: str, threshold: int, shots: int, out_dir: str) -> str:
+    base = os.path.splitext(os.path.basename(qasm_path))[0]
+    fname = f"{base}__MIRROR__{backend_id}__{precision}__thr{threshold}__shots{shots}.json"
+    return os.path.join(out_dir, fname)
+
+def try_nvidia_smi() -> Optional[Dict[str, Any]]:
+    try:
+        cmd = [
+            "nvidia-smi",
+            "--query-gpu=name,driver_version,memory.total",
+            "--format=csv,noheader,nounits",
+        ]
+        p = subprocess.run(cmd, capture_output=True, text=True, check=False)
+        if p.returncode != 0:
+            return None
+        line = (p.stdout.strip().splitlines() or [""])[0].strip()
+        if not line:
+            return None
+        parts = [x.strip() for x in line.split(",")]
+        if len(parts) >= 3:
+            return {
+                "gpu_name": parts[0],
+                "driver_version": parts[1],
+                "gpu_memory_total_mb": float(parts[2]) if parts[2].replace(".", "", 1).isdigit() else parts[2],
+            }
+        return {"raw": line}
+    except Exception:
+        return None
+
+def start_peak_rss_sampler(interval_s: float = 0.05):
+    import threading
+    import time as _time
+    import os as _os
+
+    proc = psutil.Process(_os.getpid())
+    peak = {"rss": 0}
+    running = {"on": True}
+
+    def _loop():
+        while running["on"]:
+            try:
+                rss = proc.memory_info().rss
+                if rss > peak["rss"]:
+                    peak["rss"] = rss
+            except Exception:
+                pass
+            _time.sleep(interval_s)
+
+    th = threading.Thread(target=_loop, daemon=True)
+    th.start()
+    return running, th, peak
+
+def stop_peak_rss_sampler(running, th):
+    running["on"] = False
+    th.join(timeout=1.0)
+
+def get_dist_version(names: List[str]) -> Optional[str]:
+    for n in names:
+        try:
+            return _imd.version(n)
+        except Exception:
+            pass
+    return None
+
+def safe_call_noarg(result: Any, name: str):
+    if not hasattr(result, name):
+        return None, "missing"
+    try:
+        return getattr(result, name)(), None
+    except Exception as e:
+        return None, repr(e)
+
+def safe_call_1arg(result: Any, name: str, arg0: int):
+    if not hasattr(result, name):
+        return None, "missing"
+    try:
+        return getattr(result, name)(arg0), None
+    except Exception as e:
+        return None, repr(e)
+
+def jsonable_value(x: Any) -> Any:
+    if x is None:
+        return None
+    if isinstance(x, (str, int, float, bool)):
+        return x
+    return repr(x)
+
+def normalize_counts_keys(counts: Dict[Any, Any]) -> Dict[str, int]:
+    out: Dict[str, int] = {}
+    for k, v in counts.items():
+        ks = str(k).replace(" ", "")
+        out[ks] = int(v)
+    return out
+
+_MEASURE_LINE_RE = re.compile(r"^\s*measure\s+.*?;\s*$", flags=re.M | re.I)
+_CREG_DECL_RE   = re.compile(r"^\s*creg\s+.*?;\s*$", flags=re.M | re.I)
+
+def strip_measures_and_cregs(qasm: str) -> str:
+    """
+    Make QASM unitary-ish by removing creg declarations and measure lines.
+    This is required for qc.inverse() to work reliably.
+    """
+    q = _MEASURE_LINE_RE.sub("", qasm)
+    q = _CREG_DECL_RE.sub("", q)
+    return q
+
+
+
+# -----------------------------
+# Main
+# -----------------------------
+
+def main() -> None:
+    ap = argparse.ArgumentParser(description="QR12 mirror runner: mirror QASM + counts-based return-to-zero probability.")
+    ap.add_argument("qasm", help="Path to original QASM2 file (U)")
+    ap.add_argument("--backend", default="Scarlet", help="Scarlet|Amber|Serin (or CPU/GPU/Both) OR backend id")
+    ap.add_argument("--precision", choices=["single", "double"], default="single")
+    ap.add_argument("--threshold", type=int, default=128)
+    ap.add_argument("--shots", type=int, default=1024,
+                    help="Shots for mirror counts. (Unlike amplitude-based mirror, you usually want >1.)")
+    ap.add_argument("--json-out", default=None)
+    ap.add_argument("--out-dir", default="runs")
+    ap.add_argument("--save-mirror-qasm", default=None, help="Optional: save generated mirror QASM for debugging")
+    ap.add_argument("--topk", type=int, default=20, help="Store top-K outcomes in the JSON")
+    ap.add_argument(
+        "--mirror-mode",
+        choices=["qasm_counts", "sdk_inverse_fidelity"],
+        default="qasm_counts",
+        help="qasm_counts: build mirror via qcoder.core.qasm2.mirror_build + measurements + p_return_zero. "
+             "sdk_inverse_fidelity: build mirror via qc.inverse()+append and use result.get_fidelity()."
+    )
+
+    args = ap.parse_args()
+
+    print("===== QR12 Mirror Runner =====", flush=True)
+
+    os.makedirs(args.out_dir, exist_ok=True)
+
+    sdk_pkg = "quantumrings-cuda13x"
+    sdk_ver = get_dist_version([sdk_pkg, "quantumrings_cuda13x", "QuantumRingsLib"])
+    print(f"[env] sdk_pkg={sdk_pkg} sdk_version={sdk_ver} python={sys.version.split()[0]}", flush=True)
+
+    # Provider first (important for entitlement context)
+    provider = QuantumRingsProvider()
+    backend_id = resolve_backend_id(provider, args.backend, args.precision)
+    backend = provider.get_backend(backend_id, precision=args.precision)
+    print("[backend]", backend, flush=True)
+
+    # Read original QASM
+    with open(args.qasm, "r", encoding="utf-8", errors="replace") as f:
+        orig_text = f.read()
+    eligibility, eligibility_reason = classify_mirror_eligibility(orig_text)
+    if eligibility != "ok":
+        die(f"Mirror eligibility={eligibility}: {eligibility_reason}", code=2)
+
+    # ---- Build mirror circuit (two modes) ----
+    qc_mirror = None
+    n_qubits = None
+    mirror_qasm = None  # only set in qasm_counts
+
+    if args.mirror_mode == "sdk_inverse_fidelity":
+        # Venkat-style: unitary circuit -> inverse -> append
+        unitary_qasm = strip_measures_and_cregs(orig_text)
+        try:
+            qc_u = QuantumCircuit.from_qasm_str(unitary_qasm)
+        except Exception as e:
+            die(f"Unitary QASM failed to load for sdk_inverse_fidelity: {e}", code=3)
+
+        try:
+            qc_inv = qc_u.inverse()
+            qc_u.append(qc_inv)
+        except Exception as e:
+            die(f"qc.inverse()/append failed in sdk_inverse_fidelity: {e}", code=4)
+
+        qc_mirror = qc_u
+        try:
+            n_qubits = int(qc_mirror.num_qubits)
+        except Exception:
+            n_qubits = None
+
+        # Venkat-like run kwargs (keep simple)
+        run_kwargs = dict(
+            shots=int(args.shots),
+            mode="async",
+            quiet=True,
+            performance="custom",
+            threshold=int(args.threshold),
+        )
+
+    else:
+        # Existing method: QASM mirror + measurements + counts-based p_return_zero
+        try:
+            mirror_qasm, n_qubits = build_mirror_qasm(orig_text, drop_barriers=True)
+        except UnsupportedQasm as e:
+            die(f"Unsupported QASM for mirror inversion: {e}", code=2)
+
+        if args.save_mirror_qasm:
+            os.makedirs(os.path.dirname(args.save_mirror_qasm) or ".", exist_ok=True)
+            with open(args.save_mirror_qasm, "w", encoding="utf-8") as f:
+                f.write(mirror_qasm)
+            print(f"[ok] wrote mirror QASM: {args.save_mirror_qasm}", flush=True)
+
+        try:
+            qc_mirror = QuantumCircuit.from_qasm_str(mirror_qasm)
+        except Exception as e:
+            die(f"Mirror QASM failed to load in SDK: {e}", code=3)
+
+        run_kwargs = dict(
+            shots=int(args.shots),
+            mode="sync",
+            generate_amplitude=False,
+            quiet=True,
+            performance="custom",
+            threshold=int(args.threshold),
+            transfer_to_cpu=True,
+            max_threads=5,
+        )
+
+
+    print(f"[run] backend_id={backend_id} precision={args.precision} thr={args.threshold} shots={args.shots}", flush=True)
+
+    running, th, peak = start_peak_rss_sampler(0.05)
+    t_submit = time.perf_counter()
+
+    job = backend.run(qc_mirror, **run_kwargs)
+    job_monitor(job, quiet=True)
+    result = job.result()
+
+    t_done = time.perf_counter()
+    stop_peak_rss_sampler(running, th)
+
+    run_wall_s = t_done - t_submit
+    peak_rss_bytes = int(peak["rss"])
+
+    # Mirror metrics
+    p_zero = None
+    shots_from_counts = 0
+    items = []
+    top_items = []
+
+    zero_key = None
+    try:
+        if n_qubits is not None:
+            zero_key = "0" * int(n_qubits)
+    except Exception:
+        zero_key = None
+
+    if args.mirror_mode == "qasm_counts":
+        counts_raw = result.get_counts()
+        if not isinstance(counts_raw, dict):
+            die(f"result.get_counts() returned unexpected type: {type(counts_raw)}")
+
+        counts = normalize_counts_keys(counts_raw)
+        shots_from_counts = sum(counts.values()) if counts else 0
+
+        if n_qubits is not None:
+            zero_key = "0" * int(n_qubits)
+            p_zero = (counts.get(zero_key, 0) / shots_from_counts) if shots_from_counts else None
+
+        items = sorted(counts.items(), key=lambda kv: (-kv[1], kv[0]))
+        topk = max(1, int(args.topk))
+        top_items = items[:topk]
+    else:
+        # sdk_inverse_fidelity: no measurements, so no counts-based p_return_zero
+        pass
+
+
+    # SDK-native metrics (best-effort)
+    sdk_metrics: Dict[str, Any] = {"errors": {}}
+
+    gf, gf_err = safe_call_noarg(result, "get_fidelity")
+    if gf_err:
+        sdk_metrics["errors"]["get_fidelity"] = gf_err
+    sdk_metrics["get_fidelity"] = jsonable_value(gf)
+
+    # IMPORTANT: signature requires one int arg
+    gpm0, gpm0_err = safe_call_1arg(result, "get_peakmemorysize", 0)
+    if gpm0_err:
+        sdk_metrics["errors"]["get_peakmemorysize(0)"] = gpm0_err
+    sdk_metrics["get_peakmemorysize_0"] = jsonable_value(gpm0)
+
+    memx, memx_err = safe_call_noarg(result, "get_memory")
+    if memx_err:
+        sdk_metrics["errors"]["get_memory"] = memx_err
+    sdk_metrics["get_memory"] = jsonable_value(memx)
+
+    # Output path
+    if args.json_out:
+        out_path = args.json_out
+    else:
+        out_path = default_json_out(args.qasm, backend_id, args.precision, int(args.threshold), int(args.shots), args.out_dir)
+    os.makedirs(os.path.dirname(out_path) or ".", exist_ok=True)
+
+    gpu_info = try_nvidia_smi()
+
+    payload: Dict[str, Any] = {
+        "meta": {
+            "created_utc": _dt.datetime.now(_dt.timezone.utc).replace(microsecond=0).isoformat(),
+            "original_qasm_file": os.path.basename(args.qasm),
+            "original_qasm_path": os.path.abspath(args.qasm),
+            "original_qasm_sha256": sha256_file(args.qasm),
+            "n_qubits": int(n_qubits),
+            "backend": str(args.backend),
+            "backend_id": backend_id,
+            "backend_repr": str(backend),
+            "precision": args.precision,
+            "threshold": int(args.threshold),
+            "shots": int(args.shots),
+            "mode": args.mirror_mode,
+            "sdk_pkg": sdk_pkg,
+            "sdk_version": sdk_ver,
+        },
+        "sdk": {
+            **run_kwargs
+        },
+        "system": {
+            "hostname": platform.node(),
+            "platform": platform.platform(),
+            "python": sys.version.split()[0],
+            "cpu_count": os.cpu_count(),
+            "gpu": gpu_info,
+        },
+        "timing_s": {
+            "run_wall_s": float(run_wall_s),
+        },
+        "memory": {
+            "peak_rss_bytes": int(peak_rss_bytes),
+            "peak_rss_mb": float(peak_rss_bytes) / (1024.0 * 1024.0),
+        },
+        "sdk_metrics": sdk_metrics,
+        "mirror_metrics": {
+            "shots_from_counts": int(shots_from_counts),
+            "p_return_zero": None if p_zero is None else float(p_zero),
+            "return_zero_bitstring": zero_key,
+            "unique_outcomes": int(len(items)),
+            "top": [{"bitstring": b, "count": int(c)} for b, c in top_items],
+        },
+    }
+
+    with open(out_path, "w", encoding="utf-8") as f:
+        json.dump(payload, f, indent=2, sort_keys=True)
+
+    print(f"[ok] wrote JSON: {out_path}", flush=True)
+    print(f"[mirror] p_return_zero={p_zero}  unique_outcomes={len(items)}", flush=True)
+    print(f"[timing] run_wall_s={run_wall_s:.3f}  [mem] peak_rss_mb={payload['memory']['peak_rss_mb']:.1f}", flush=True)
+    print(f"[sdk] get_fidelity={sdk_metrics.get('get_fidelity')} get_peakmemorysize_0={sdk_metrics.get('get_peakmemorysize_0')}", flush=True)
+    if sdk_metrics.get("errors"):
+        print(f"[sdk] errors={sdk_metrics['errors']}", flush=True)
+    print("===== done =====", flush=True)
+
+
+if __name__ == "__main__":
+    try:
+        main()
+    except SystemExit:
+        raise
+    except Exception as e:
+        import traceback
+        traceback.print_exc()
+        die(f"Unhandled exception: {e}")
+