qcoder 0.1.0a0__py3-none-any.whl

qcoder/tools/generate_corpus.py

@@ -0,0 +1,491 @@
+from __future__ import annotations
+
+import argparse
+import json
+from dataclasses import dataclass
+from pathlib import Path
+from typing import Any
+
+
+SYNTH_FAMILIES = (
+    "span_sweep",
+    "entangling_depth",
+    "graph_topology",
+    "temporal_variants",
+    "pair_reuse",
+)
+ALGO_FAMILIES = (
+    "ghz",
+    "qft",
+    "grover_like",
+    "qaoa_like",
+    "trotter_like",
+)
+ALL_FAMILIES = SYNTH_FAMILIES + ALGO_FAMILIES
+
+WIDTH_PRESETS: dict[str, list[int]] = {
+    "fast": [8, 12, 16, 20, 24],
+    "mid": [32, 48, 64, 80],
+    "large": [96, 128, 160, 200],
+}
+
+
+@dataclass(frozen=True)
+class CircuitSpec:
+    source: str
+    family: str
+    subfamily: str
+    width: int
+    nominal_depth_target: int
+    span_regime: str | None = None
+    graph_type: str | None = None
+    temporal_variant: str | None = None
+    pair_reuse_regime: str | None = None
+    generator_params: dict[str, Any] | None = None
+    body_lines: tuple[str, ...] = ()
+
+
+def _qasm_header(width: int) -> list[str]:
+    return [
+        "OPENQASM 2.0;",
+        'include "qelib1.inc";',
+        f"qreg q[{int(width)}];",
+        f"creg c[{int(width)}];",
+    ]
+
+
+def _qasm_footer_measurements(width: int) -> list[str]:
+    return [f"measure q[{i}] -> c[{i}];" for i in range(int(width))]
+
+
+def _name_from_spec(spec: CircuitSpec) -> str:
+    parts = [spec.family, f"w{spec.width:03d}", f"d{spec.nominal_depth_target:03d}"]
+    if spec.subfamily:
+        parts.append(spec.subfamily)
+    if spec.span_regime:
+        parts.append(f"span_{spec.span_regime}")
+    if spec.graph_type:
+        parts.append(f"graph_{spec.graph_type}")
+    if spec.temporal_variant:
+        parts.append(f"tvar_{spec.temporal_variant}")
+    if spec.pair_reuse_regime:
+        parts.append(f"reuse_{spec.pair_reuse_regime}")
+    return "__".join(parts) + ".qasm"
+
+
+def _edge_pairs_for_graph(width: int, graph_type: str) -> list[tuple[int, int]]:
+    if width < 2:
+        return []
+    if graph_type == "chain":
+        return [(i, i + 1) for i in range(width - 1)]
+    if graph_type == "ring":
+        return [(i, i + 1) for i in range(width - 1)] + [(width - 1, 0)]
+    if graph_type == "star":
+        return [(0, i) for i in range(1, width)]
+    if graph_type == "sparse_random_like":
+        pairs: set[tuple[int, int]] = set()
+        for i in range(width):
+            j = (i * 7 + 3) % width
+            if i == j:
+                continue
+            a, b = (i, j) if i < j else (j, i)
+            pairs.add((a, b))
+        return sorted(pairs)
+    # clustered
+    half = max(1, width // 2)
+    left = list(range(0, half))
+    right = list(range(half, width))
+    pairs: list[tuple[int, int]] = []
+    for group in (left, right):
+        for i in range(0, len(group) - 1, 2):
+            pairs.append((group[i], group[i + 1]))
+    if left and right:
+        pairs.append((left[-1], right[0]))
+    return pairs
+
+
+def _emit_pairs_rounds(pairs: list[tuple[int, int]], rounds: int) -> list[str]:
+    out: list[str] = []
+    if not pairs:
+        return out
+    for r in range(max(1, int(rounds))):
+        # deterministic parity staggering for lighter layering.
+        for idx, (a, b) in enumerate(pairs):
+            if (idx + r) % 2 == 0:
+                out.append(f"cx q[{a}],q[{b}];")
+    return out
+
+
+def _build_span_sweep(widths: list[int]) -> list[CircuitSpec]:
+    specs: list[CircuitSpec] = []
+    for w in widths:
+        regimes = [
+            ("short", 1),
+            ("mid", max(2, w // 4)),
+            ("long", max(2, w // 2)),
+        ]
+        depth_modes = [("shallow", max(4, w // 2)), ("medium", max(8, w))]
+        for depth_name, d in depth_modes:
+            for span_name, span in regimes:
+                span = min(span, max(1, w - 1))
+                pairs = [(i, i + span) for i in range(0, w - span)]
+                body = _emit_pairs_rounds(pairs, max(1, d // max(1, len(pairs))))
+                specs.append(
+                    CircuitSpec(
+                        source="synthetic_diagnostics",
+                        family="span_sweep",
+                        subfamily=depth_name,
+                        width=w,
+                        nominal_depth_target=d,
+                        span_regime=span_name,
+                        generator_params={"interaction_span": span, "depth_mode": depth_name},
+                        body_lines=tuple(body),
+                    )
+                )
+    return specs
+
+
+def _build_entangling_depth(widths: list[int]) -> list[CircuitSpec]:
+    specs: list[CircuitSpec] = []
+    for w in widths:
+        layer_options = [4, 8] if w <= 24 else ([8, 16] if w <= 80 else [12])
+        for layers in layer_options:
+            body: list[str] = []
+            for _ in range(layers):
+                for start in (0, 1):
+                    for i in range(start, w - 1, 2):
+                        body.append(f"cx q[{i}],q[{i+1}];")
+            specs.append(
+                CircuitSpec(
+                    source="synthetic_diagnostics",
+                    family="entangling_depth",
+                    subfamily="brickwork",
+                    width=w,
+                    nominal_depth_target=layers,
+                    graph_type="brickwork",
+                    generator_params={"entangling_layers": layers},
+                    body_lines=tuple(body),
+                )
+            )
+    return specs
+
+
+def _build_graph_topology(widths: list[int]) -> list[CircuitSpec]:
+    specs: list[CircuitSpec] = []
+    for w in widths:
+        for g in ("chain", "ring", "star", "sparse_random_like", "clustered"):
+            pairs = _edge_pairs_for_graph(w, g)
+            d = max(6, min(24, w // 2))
+            body = _emit_pairs_rounds(pairs, max(1, d // 2))
+            specs.append(
+                CircuitSpec(
+                    source="synthetic_diagnostics",
+                    family="graph_topology",
+                    subfamily=g,
+                    width=w,
+                    nominal_depth_target=d,
+                    graph_type=g,
+                    generator_params={"graph_type": g, "n_pairs": len(pairs)},
+                    body_lines=tuple(body),
+                )
+            )
+    return specs
+
+
+def _build_temporal_variants(widths: list[int]) -> list[CircuitSpec]:
+    specs: list[CircuitSpec] = []
+    for w in widths:
+        short_pairs = [(i, i + 1) for i in range(0, w - 1, 2)]
+        long_span = min(max(2, w // 2), max(1, w - 1))
+        long_pairs = [(i, i + long_span) for i in range(0, w - long_span, 2)]
+        d = max(8, min(32, w))
+        blocks = max(2, d // 4)
+        for variant in ("early", "late", "interleaved"):
+            body: list[str] = []
+            for blk in range(blocks):
+                if variant == "early":
+                    use_long = blk < (blocks // 2)
+                elif variant == "late":
+                    use_long = blk >= (blocks // 2)
+                else:
+                    use_long = (blk % 2 == 0)
+                body.extend(_emit_pairs_rounds(long_pairs if use_long else short_pairs, 1))
+            specs.append(
+                CircuitSpec(
+                    source="synthetic_diagnostics",
+                    family="temporal_variants",
+                    subfamily="same_totals",
+                    width=w,
+                    nominal_depth_target=d,
+                    temporal_variant=variant,
+                    generator_params={"variant": variant, "blocks": blocks},
+                    body_lines=tuple(body),
+                )
+            )
+    return specs
+
+
+def _build_pair_reuse(widths: list[int]) -> list[CircuitSpec]:
+    specs: list[CircuitSpec] = []
+    for w in widths:
+        d = max(10, min(40, w))
+        many_pairs = _edge_pairs_for_graph(w, "ring") or _edge_pairs_for_graph(w, "chain")
+        concentrated = many_pairs[:2] if len(many_pairs) >= 2 else many_pairs
+        for regime in ("spread", "concentrated"):
+            body: list[str] = []
+            if regime == "spread":
+                pairs = many_pairs
+                for r in range(max(1, d // 2)):
+                    a, b = pairs[r % len(pairs)]
+                    body.append(f"cx q[{a}],q[{b}];")
+            else:
+                pairs = concentrated
+                for r in range(max(1, d // 2)):
+                    a, b = pairs[r % len(pairs)]
+                    body.append(f"cx q[{a}],q[{b}];")
+                    if r % 4 == 0 and many_pairs:
+                        u, v = many_pairs[(r // 4) % len(many_pairs)]
+                        body.append(f"cx q[{u}],q[{v}];")
+            specs.append(
+                CircuitSpec(
+                    source="synthetic_diagnostics",
+                    family="pair_reuse",
+                    subfamily="controlled_mass",
+                    width=w,
+                    nominal_depth_target=d,
+                    pair_reuse_regime=regime,
+                    generator_params={"regime": regime, "base_pairs": len(pairs)},
+                    body_lines=tuple(body),
+                )
+            )
+    return specs
+
+
+def _build_algo_families(widths: list[int]) -> list[CircuitSpec]:
+    specs: list[CircuitSpec] = []
+    for w in widths:
+        # ghz
+        ghz_body = [f"h q[0];"] + [f"cx q[{i}],q[{i+1}];" for i in range(0, w - 1)]
+        specs.append(
+            CircuitSpec(
+                source="algorithms_generated",
+                family="ghz",
+                subfamily="chain",
+                width=w,
+                nominal_depth_target=max(2, w),
+                generator_params={"style": "chain_ghz"},
+                body_lines=tuple(ghz_body),
+            )
+        )
+
+        # qft (minimal canonical form)
+        qft_body: list[str] = []
+        for i in range(w):
+            qft_body.append(f"h q[{i}];")
+            max_j = min(w, i + 4)
+            for j in range(i + 1, max_j):
+                denom = 2 ** (j - i)
+                qft_body.append(f"cu1(pi/{denom}) q[{j}],q[{i}];")
+        specs.append(
+            CircuitSpec(
+                source="algorithms_generated",
+                family="qft",
+                subfamily="truncated_phase",
+                width=w,
+                nominal_depth_target=max(4, w),
+                generator_params={"phase_span_limit": 3},
+                body_lines=tuple(qft_body),
+            )
+        )
+
+        # grover_like
+        grover_body = [f"h q[{i}];" for i in range(w)]
+        for _ in range(2):
+            grover_body += [f"x q[{i}];" for i in range(w)]
+            if w >= 2:
+                grover_body += [f"cz q[{i}],q[{i+1}];" for i in range(w - 1)]
+            grover_body += [f"h q[{i}];" for i in range(w)]
+        specs.append(
+            CircuitSpec(
+                source="algorithms_generated",
+                family="grover_like",
+                subfamily="2_iter",
+                width=w,
+                nominal_depth_target=max(6, w // 2),
+                generator_params={"iterations": 2},
+                body_lines=tuple(grover_body),
+            )
+        )
+
+        # qaoa_like
+        qaoa_body = [f"h q[{i}];" for i in range(w)]
+        for _ in range(2):
+            for i in range(w - 1):
+                qaoa_body.append(f"cx q[{i}],q[{i+1}];")
+                qaoa_body.append(f"rz(pi/8) q[{i+1}];")
+                qaoa_body.append(f"cx q[{i}],q[{i+1}];")
+            for i in range(w):
+                qaoa_body.append(f"rx(pi/6) q[{i}];")
+        specs.append(
+            CircuitSpec(
+                source="algorithms_generated",
+                family="qaoa_like",
+                subfamily="p2_chain",
+                width=w,
+                nominal_depth_target=max(8, w),
+                generator_params={"p_layers": 2},
+                body_lines=tuple(qaoa_body),
+            )
+        )
+
+        # trotter_like
+        trotter_body: list[str] = []
+        for _ in range(3):
+            for i in range(w):
+                trotter_body.append(f"rx(pi/9) q[{i}];")
+            for i in range(w - 1):
+                trotter_body.append(f"cx q[{i}],q[{i+1}];")
+                trotter_body.append(f"rz(pi/7) q[{i+1}];")
+                trotter_body.append(f"cx q[{i}],q[{i+1}];")
+        specs.append(
+            CircuitSpec(
+                source="algorithms_generated",
+                family="trotter_like",
+                subfamily="nn_chain_3step",
+                width=w,
+                nominal_depth_target=max(8, w),
+                generator_params={"steps": 3},
+                body_lines=tuple(trotter_body),
+            )
+        )
+    return specs
+
+
+def _selected_widths(width_preset: str) -> list[int]:
+    if width_preset == "all":
+        return WIDTH_PRESETS["fast"] + WIDTH_PRESETS["mid"] + WIDTH_PRESETS["large"]
+    if width_preset in WIDTH_PRESETS:
+        return list(WIDTH_PRESETS[width_preset])
+    raise ValueError(f"unknown width preset: {width_preset}")
+
+
+def _build_specs(selected_families: set[str], width_preset: str) -> list[CircuitSpec]:
+    widths = _selected_widths(width_preset)
+    specs: list[CircuitSpec] = []
+    if "span_sweep" in selected_families:
+        specs.extend(_build_span_sweep(widths))
+    if "entangling_depth" in selected_families:
+        specs.extend(_build_entangling_depth(widths))
+    if "graph_topology" in selected_families:
+        specs.extend(_build_graph_topology(widths))
+    if "temporal_variants" in selected_families:
+        specs.extend(_build_temporal_variants(widths))
+    if "pair_reuse" in selected_families:
+        specs.extend(_build_pair_reuse(widths))
+    algo_widths = [w for w in widths if w <= 80] + [96, 128]
+    algo_widths = sorted(set(algo_widths))
+    if selected_families.intersection(ALGO_FAMILIES):
+        # Build once then filter to keep deterministic ordering.
+        for spec in _build_algo_families(algo_widths):
+            if spec.family in selected_families:
+                specs.append(spec)
+    return specs
+
+
+def generate_corpus(
+    *,
+    output_root: str | Path = "circuits",
+    families: list[str] | None = None,
+    width_preset: str = "all",
+    overwrite: bool = False,
+    manifest_path: str | Path | None = None,
+) -> list[dict[str, Any]]:
+    selected = set(families or ALL_FAMILIES)
+    unknown = sorted(selected.difference(ALL_FAMILIES))
+    if unknown:
+        raise ValueError(f"unknown families: {', '.join(unknown)}")
+
+    root = Path(output_root)
+    specs = _build_specs(selected, width_preset)
+    rows: list[dict[str, Any]] = []
+    for spec in specs:
+        rel_dir = Path(spec.source) / spec.family
+        out_dir = root / rel_dir
+        out_dir.mkdir(parents=True, exist_ok=True)
+        fname = _name_from_spec(spec)
+        out_path = out_dir / fname
+        if out_path.exists() and not overwrite:
+            raise FileExistsError(f"file exists (use --overwrite): {out_path}")
+        qasm_lines = (
+            _qasm_header(spec.width)
+            + list(spec.body_lines)
+            + _qasm_footer_measurements(spec.width)
+        )
+        out_path.write_text("\n".join(qasm_lines) + "\n", encoding="utf-8")
+
+        row = {
+            "circuit_path": str(out_path),
+            "source": spec.source,
+            "family": spec.family,
+            "subfamily": spec.subfamily,
+            "width": spec.width,
+            "nominal_depth_target": spec.nominal_depth_target,
+            "span_regime": spec.span_regime,
+            "graph_type": spec.graph_type,
+            "temporal_variant": spec.temporal_variant,
+            "pair_reuse_regime": spec.pair_reuse_regime,
+            "generator_params": spec.generator_params or {},
+        }
+        rows.append(row)
+
+    rows.sort(key=lambda r: r["circuit_path"])
+    mpath = Path(manifest_path) if manifest_path else (root / "generated_corpus_manifest.jsonl")
+    mpath.parent.mkdir(parents=True, exist_ok=True)
+    with mpath.open("w", encoding="utf-8") as f:
+        for row in rows:
+            f.write(json.dumps(row, sort_keys=True) + "\n")
+    return rows
+
+
+def main(argv: list[str] | None = None) -> int:
+    ap = argparse.ArgumentParser(description="Generate synthetic and algorithmic QASM corpus with manifest.")
+    ap.add_argument("--output-root", default="circuits", help="Root directory for generated circuit folders.")
+    ap.add_argument(
+        "--families",
+        nargs="+",
+        default=list(ALL_FAMILIES),
+        help="Families to generate.",
+    )
+    ap.add_argument(
+        "--width-preset",
+        choices=("fast", "mid", "large", "all"),
+        default="all",
+        help="Width preset band.",
+    )
+    ap.add_argument("--manifest-path", default=None, help="Optional explicit manifest JSONL path.")
+    ap.add_argument("--overwrite", action="store_true", help="Overwrite existing generated files.")
+    ap.add_argument("--list-families", action="store_true", help="Print available families and exit.")
+    args = ap.parse_args(argv)
+
+    if args.list_families:
+        print("\n".join(ALL_FAMILIES))
+        return 0
+
+    rows = generate_corpus(
+        output_root=args.output_root,
+        families=args.families,
+        width_preset=args.width_preset,
+        overwrite=bool(args.overwrite),
+        manifest_path=args.manifest_path,
+    )
+    print(f"[ok] generated {len(rows)} circuits")
+    print(f"[ok] root: {args.output_root}")
+    print(
+        f"[ok] manifest: {args.manifest_path if args.manifest_path else str(Path(args.output_root) / 'generated_corpus_manifest.jsonl')}"
+    )
+    print("[todo] external benchmark import hook is intentionally deferred (future extension point).")
+    return 0
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())

qcoder/tools/harness.py

@@ -0,0 +1,15 @@
+#!/usr/bin/env python3
+"""
+qcoder.tools.harness — entrypoint that delegates to Quantum Rings v12 harness.
+"""
+from qcoder.tools.runners.quantum_rings.v12.harness import main, die
+
+if __name__ == "__main__":
+    try:
+        main()
+    except SystemExit:
+        raise
+    except Exception as e:
+        import traceback
+        traceback.print_exc()
+        die(f"Unhandled exception: {e}")