Freeze fresh all-framework quantum circuits with phase gates, unseen angles and larger nonlocal stress holdouts

curriculum_v2/LICENSE.md

@@ -0,0 +1 @@
+Original generated circuits and numerical labels: CC BY 4.0, attributed to itsalissonsilva. Generator/rendering code: Apache-2.0. Framework implementations are not redistributed. Simulator versions and exact parity checks are recorded in manifest.json.

curriculum_v2/manifest.json

@@ -0,0 +1,21 @@
+{
+  "seed": 2026110101,
+  "rows_sha256": "e3e1e79a39f145c0eb1749ca28dd0ab07931eeac48bc9b5e45a281e425d2e348",
+  "renderer_source_sha256": "602ee257d443fd2457409b849823cfdbc566f3bbe11bc1fca7123abdac0fdfaf",
+  "versions": {
+    "numpy": "2.5.4",
+    "qiskit": "2.2.3",
+    "pennylane": "0.43.1",
+    "cirq": "1.6.1"
+  },
+  "groups": {
+    "train": 216,
+    "validation": 48,
+    "test_iid": 96,
+    "test_stress": 96
+  },
+  "rows": 1368,
+  "original_groups_excluded": 2000,
+  "scope": "Fresh follow-up, no original test circuits reused. All three frameworks occur in training. Held-out circuit groups and rotation angles; separate five/six-qubit long-range/deeper-circuit stress. Exact zero-input state fidelity only, not full process equivalence or novel quantum algorithms. Deterministic reference renderer is a perfect oracle on this structured task. Original framework-held-out negative result remains reported separately.",
+  "initial_generator_source_sha256": "5264ff94e7675c311bfda6bfe21511a56f2e28215d7b4242800212f90fd7740c"
+}

curriculum_v2/prepare_quantum_v2.py

@@ -0,0 +1,180 @@
+"""Fresh all-framework curriculum after the failed zero-shot-framework pilot.
+
+Keep the original framework-held-out result intact. This is a distinct follow-up
+with fresh circuit groups, all three training frameworks, and unseen size/topology
+and rotation-angle stress tests. Every target is executed in all three simulators.
+"""
+
+import hashlib
+import inspect
+import json
+import random
+import sys
+from pathlib import Path
+
+ROOT = Path(__file__).resolve().parent
+sys.path.insert(0, str(ROOT / "vendor_quantum"))
+import numpy as np
+import qiskit
+import cirq
+import pennylane as qml
+import pyarrow.parquet as pq
+
+
+def render(ops, n, framework):
+    if framework == "qiskit":
+        lines = [
+            "from qiskit import QuantumCircuit",
+            "from qiskit.quantum_info import Statevector",
+            f"circuit = QuantumCircuit({n})",
+        ]
+        for gate, qubits, angle in ops:
+            args = ([repr(angle)] if gate in ["ry", "rz"] else []) + [str(q) for q in qubits]
+            lines.append(f"circuit.{gate}({', '.join(args)})")
+        return "\n".join(lines + ["state = Statevector.from_instruction(circuit).data"])
+    if framework == "cirq":
+        lines = [
+            "import cirq",
+            "import numpy as np",
+            f"qubits = cirq.LineQubit.range({n})",
+            "circuit = cirq.Circuit()",
+        ]
+        for gate, qubits, angle in ops:
+            expr = (
+                f"cirq.{gate}({angle!r})"
+                if gate in ["ry", "rz"]
+                else {"h": "cirq.H", "x": "cirq.X", "z": "cirq.Z", "cx": "cirq.CNOT"}[gate]
+            )
+            lines.append(
+                f"circuit.append({expr}({', '.join('qubits[' + str(q) + ']' for q in qubits)}))"
+            )
+        return "\n".join(
+            lines
+            + [
+                "state = cirq.Simulator(dtype=np.complex128).simulate(circuit, qubit_order=list(reversed(qubits))).final_state_vector"
+            ]
+        )
+    lines = [
+        "import pennylane as qml",
+        f"device = qml.device('default.qubit', wires={list(reversed(range(n)))!r})",
+        "@qml.qnode(device)",
+        "def circuit():",
+    ]
+    names = {"h": "Hadamard", "x": "PauliX", "z": "PauliZ", "cx": "CNOT", "ry": "RY", "rz": "RZ"}
+    for gate, qubits, angle in ops:
+        lines.append(
+            f"    qml.{names[gate]}({repr(angle) + ', ' if gate in ['ry', 'rz'] else ''}wires={qubits!r})"
+        )
+    return "\n".join(lines + ["    return qml.state()", "state = circuit()"])
+
+
+def main():
+    source = ROOT / "build_exact_science.py"
+    code = render
+    old_groups = set()
+    for split in ["train", "validation", "test"]:
+        old_groups.update(
+            pq.read_table(
+                ROOT / f"datasets/quantum-circuit-specs-synthetic/data/{split}.parquet",
+                columns=["group_id"],
+            )
+            .column("group_id")
+            .to_pylist()
+        )
+    folder = ROOT / "models/QuantumCoder-9B/curriculum_v2"
+    folder.mkdir(parents=True, exist_ok=True)
+    rng = random.Random(2026110101)
+    seen = set()
+    rows = []
+    protocol = [("train", 216), ("validation", 48), ("test_iid", 96), ("test_stress", 96)]
+    for split, worlds in protocol:
+        produced = 0
+        while produced < worlds:
+            stress = split == "test_stress"
+            n = rng.choice([5, 6] if stress else [2, 3, 4])
+            angles = (
+                [0.17, 0.31, 0.67, 1.13, 1.71, 2.29]
+                if split == "train"
+                else [0.23, 0.83, 1.27, 2.07]
+                if split == "validation"
+                else [0.11, 0.53, 0.97, 1.91, 2.61]
+            )
+            operations = []
+            for _ in range(rng.randrange(16, 25) if stress else rng.randrange(6, 14)):
+                gate = rng.choice(["h", "x", "z", "ry", "rz", "cx"])
+                q = rng.randrange(n)
+                if gate == "cx":
+                    others = (
+                        [j for j in range(n) if abs(j - q) >= 2]
+                        if stress
+                        else [j for j in range(n) if abs(j - q) == 1]
+                    )
+                    qs = [q, rng.choice(others)]
+                else:
+                    qs = [q]
+                operations.append([gate, qs, rng.choice(angles) if gate in ["ry", "rz"] else 0.0])
+            if not {"h", "ry", "rz", "cx"}.issubset({op[0] for op in operations}):
+                continue
+            digest = hashlib.sha256(
+                json.dumps([n, operations], sort_keys=True).encode()
+            ).hexdigest()
+            if digest in seen or digest[:24] in old_groups:
+                continue
+            seen.add(digest)
+            programs = {f: code(operations, n, f) for f in ["qiskit", "pennylane", "cirq"]}
+            states = {}
+            # Only trusted renderer output is executed locally; no model output.
+            for framework, program in programs.items():
+                context = {}
+                exec(program, context)
+                states[framework] = np.asarray(context["state"], dtype=np.complex128)
+            reference = states["qiskit"]
+            assert abs(np.vdot(reference, reference).real - 1) < 1e-10
+            if np.max(abs(reference) ** 2) > 0.999:
+                continue
+            fidelities = {f: float(abs(np.vdot(reference, v)) ** 2) for f, v in states.items()}
+            assert min(fidelities.values()) > 1 - 1e-10
+            for framework in programs:
+                rows.append(
+                    dict(
+                        id=f"v2-{digest[:24]}-{framework}",
+                        group_id=digest,
+                        split=split,
+                        framework=framework,
+                        qubits=n,
+                        operations_json=json.dumps(operations),
+                        program=programs[framework],
+                        state_real=reference.real.tolist(),
+                        state_imag=reference.imag.tolist(),
+                        cross_framework_fidelity=fidelities[framework],
+                    )
+                )
+            produced += 1
+        print(json.dumps(dict(split=split, circuit_groups=worlds, examples=worlds * 3)), flush=True)
+    payload = json.dumps(rows, ensure_ascii=False, indent=2).encode()
+    (folder / "rows.json").write_bytes(payload)
+    (folder / "program_renderer.py").write_text(inspect.getsource(render), encoding="utf-8")
+    (folder / "prepare_quantum_v2.py").write_bytes(Path(__file__).read_bytes())
+    manifest = dict(
+        seed=2026110101,
+        rows_sha256=hashlib.sha256(payload).hexdigest(),
+        renderer_source_sha256=hashlib.sha256((folder/"program_renderer.py").read_bytes()).hexdigest(),
+        initial_generator_source_sha256=hashlib.sha256(source.read_bytes()).hexdigest(),
+        versions=dict(
+            numpy=np.__version__,
+            qiskit=qiskit.__version__,
+            pennylane=qml.__version__,
+            cirq=cirq.__version__,
+        ),
+        groups={s: n for s, n in protocol},
+        rows=len(rows),
+        original_groups_excluded=len(old_groups),
+        scope="Fresh follow-up, all 2000 original circuit groups excluded. All three frameworks occur in training. Includes phase RZ gates; circuits require H/RY/RZ/CX and exclude near-basis outputs. Held-out circuit groups and angles; separate five/six-qubit long-range/deeper stress. Exact zero-input state fidelity only, not full process equivalence or novel algorithm discovery. Deterministic renderer is a perfect structured-input oracle. Original framework-held-out negative result remains separate.",
+    )
+    (folder / "manifest.json").write_text(json.dumps(manifest, indent=2))
+    (folder/"LICENSE.md").write_text("Original generated circuits and numerical labels: CC BY 4.0, attributed to itsalissonsilva. Generator/rendering code: Apache-2.0. Framework implementations are not redistributed. Simulator versions and exact parity checks are recorded in manifest.json.\n",encoding="utf-8")
+    print(json.dumps(manifest), flush=True)
+
+
+if __name__ == "__main__":
+    main()

curriculum_v2/program_renderer.py

@@ -0,0 +1,45 @@
+def render(ops, n, framework):
+    if framework == "qiskit":
+        lines = [
+            "from qiskit import QuantumCircuit",
+            "from qiskit.quantum_info import Statevector",
+            f"circuit = QuantumCircuit({n})",
+        ]
+        for gate, qubits, angle in ops:
+            args = ([repr(angle)] if gate in ["ry", "rz"] else []) + [str(q) for q in qubits]
+            lines.append(f"circuit.{gate}({', '.join(args)})")
+        return "\n".join(lines + ["state = Statevector.from_instruction(circuit).data"])
+    if framework == "cirq":
+        lines = [
+            "import cirq",
+            "import numpy as np",
+            f"qubits = cirq.LineQubit.range({n})",
+            "circuit = cirq.Circuit()",
+        ]
+        for gate, qubits, angle in ops:
+            expr = (
+                f"cirq.{gate}({angle!r})"
+                if gate in ["ry", "rz"]
+                else {"h": "cirq.H", "x": "cirq.X", "z": "cirq.Z", "cx": "cirq.CNOT"}[gate]
+            )
+            lines.append(
+                f"circuit.append({expr}({', '.join('qubits[' + str(q) + ']' for q in qubits)}))"
+            )
+        return "\n".join(
+            lines
+            + [
+                "state = cirq.Simulator(dtype=np.complex128).simulate(circuit, qubit_order=list(reversed(qubits))).final_state_vector"
+            ]
+        )
+    lines = [
+        "import pennylane as qml",
+        f"device = qml.device('default.qubit', wires={list(reversed(range(n)))!r})",
+        "@qml.qnode(device)",
+        "def circuit():",
+    ]
+    names = {"h": "Hadamard", "x": "PauliX", "z": "PauliZ", "cx": "CNOT", "ry": "RY", "rz": "RZ"}
+    for gate, qubits, angle in ops:
+        lines.append(
+            f"    qml.{names[gate]}({repr(angle) + ', ' if gate in ['ry', 'rz'] else ''}wires={qubits!r})"
+        )
+    return "\n".join(lines + ["    return qml.state()", "state = circuit()"])