Upload 3 files

quread/exporters.py

@@ -1,21 +1,94 @@
 from __future__ import annotations
-from typing import List, Dict, Any
+import math
+import re
+from typing import List, Dict, Any, Tuple
 
 Op = Dict[str, Any]
 
+_ROT_GATE_RE = re.compile(r"^(R[XYZ])\((.+)\)$", re.IGNORECASE)
+
+
+def _parse_angle(value: Any) -> float:
+    if isinstance(value, (int, float)):
+        return float(value)
+
+    s = str(value).strip().lower().replace(" ", "")
+    if s in ("π", "pi"):
+        return float(math.pi)
+    if s in ("π/2", "pi/2"):
+        return float(math.pi / 2.0)
+    return float(s)
+
+
+def _fmt_theta(theta: float) -> str:
+    return f"{float(theta):.15g}"
+
+
+def _canonical_single_gate(op: Op) -> Tuple[str, float | None]:
+    gate_raw = str(op.get("gate", "")).strip()
+    if not gate_raw:
+        raise ValueError("Single-qubit op is missing gate name.")
+
+    aliases = {
+        "S†": "SDG",
+        "SDG": "SDG",
+        "T†": "TDG",
+        "TDG": "TDG",
+        "√X": "SQRTX",
+        "SX": "SQRTX",
+        "√Z": "SQRTZ",
+        "SZ": "SQRTZ",
+        "I†": "I",
+        "IDG": "I",
+        "ID": "I",
+    }
+
+    g_upper = gate_raw.upper()
+    if g_upper in aliases:
+        return aliases[g_upper], None
+
+    rot = _ROT_GATE_RE.match(gate_raw)
+    if rot:
+        return rot.group(1).upper(), _parse_angle(rot.group(2))
+
+    if g_upper in ("RX", "RY", "RZ"):
+        if "theta" not in op:
+            raise ValueError(f"{g_upper} is missing theta in op history.")
+        return g_upper, _parse_angle(op["theta"])
+
+    if g_upper in ("I", "H", "X", "Y", "Z", "S", "T", "SQRTX", "SQRTZ"):
+        return g_upper, None
+
+    raise ValueError(f"Unsupported gate in history: {gate_raw}")
+
+
 def to_openqasm2(ops: List[Op], n_qubits: int) -> str:
     lines = ["OPENQASM 2.0;", 'include "qelib1.inc";', f"qreg q[{n_qubits}];", f"creg c[{n_qubits}];", ""]
+    gate_map = {
+        "I": "id",
+        "H": "h",
+        "X": "x",
+        "Y": "y",
+        "Z": "z",
+        "S": "s",
+        "SDG": "sdg",
+        "T": "t",
+        "TDG": "tdg",
+    }
     for op in ops:
         t = op.get("type")
         if t == "single":
-            g = op["gate"].lower()
-            q = op["target"]
-            if op["gate"] in ("RX","RY","RZ"):
-                theta = op["theta"]
-                g = op["gate"].lower()
-                lines.append(f"{g}({theta}) q[{q}];")
+            g, theta = _canonical_single_gate(op)
+            q = int(op["target"])
+            if g in ("RX", "RY", "RZ"):
+                lines.append(f"{g.lower()}({_fmt_theta(theta)}) q[{q}];")
+            elif g == "SQRTX":
+                # Equivalent up to global phase, more portable than sx in some parsers.
+                lines.append(f"rx({_fmt_theta(math.pi / 2.0)}) q[{q}];")
+            elif g == "SQRTZ":
+                lines.append(f"s q[{q}];")
             else:
-                lines.append(f"{g} q[{q}];")
+                lines.append(f"{gate_map[g]} q[{q}];")
         elif t == "cnot":
             lines.append(f"cx q[{op['control']}],q[{op['target']}];")
         elif t == "measure":
@@ -31,15 +104,30 @@ def to_qiskit(ops: List[Op], n_qubits: int) -> str:
         f"qc = QuantumCircuit({n_qubits}, {n_qubits})",
         ""
     ]
+    gate_map = {
+        "I": "id",
+        "H": "h",
+        "X": "x",
+        "Y": "y",
+        "Z": "z",
+        "S": "s",
+        "SDG": "sdg",
+        "T": "t",
+        "TDG": "tdg",
+    }
     for op in ops:
         t = op.get("type")
         if t == "single":
-            g = op["gate"]
-            q = op["target"]
-            if g in ("RX","RY","RZ"):
-                lines.append(f"qc.{g.lower()}({op['theta']}, {q})")
+            g, theta = _canonical_single_gate(op)
+            q = int(op["target"])
+            if g in ("RX", "RY", "RZ"):
+                lines.append(f"qc.{g.lower()}({_fmt_theta(theta)}, {q})")
+            elif g == "SQRTX":
+                lines.append(f"qc.sx({q})")
+            elif g == "SQRTZ":
+                lines.append(f"qc.s({q})")
             else:
-                lines.append(f"qc.{g.lower()}({q})")
+                lines.append(f"qc.{gate_map[g]}({q})")
         elif t == "cnot":
             lines.append(f"qc.cx({op['control']}, {op['target']})")
         elif t == "measure":
@@ -57,23 +145,33 @@ def to_cirq(ops: List[Op], n_qubits: int) -> str:
         "circuit = cirq.Circuit()",
         ""
     ]
+    gate_expr = {
+        "I": "cirq.I",
+        "H": "cirq.H",
+        "X": "cirq.X",
+        "Y": "cirq.Y",
+        "Z": "cirq.Z",
+        "S": "cirq.S",
+        "SDG": "(cirq.S**-1)",
+        "T": "cirq.T",
+        "TDG": "(cirq.T**-1)",
+        "SQRTX": "(cirq.X**0.5)",
+        "SQRTZ": "(cirq.Z**0.5)",
+    }
     for op in ops:
         t = op.get("type")
         if t == "single":
-            g = op["gate"]
-            qu = op["target"]
-            if g in ("RX","RY","RZ"):
-                theta = op["theta"]
-                # Cirq uses radians in exponent form
+            g, theta = _canonical_single_gate(op)
+            qu = int(op["target"])
+            if g in ("RX", "RY", "RZ"):
                 if g == "RX":
-                    lines.append(f"circuit.append(cirq.rx({theta}).on(q[{qu}]))")
+                    lines.append(f"circuit.append(cirq.rx({_fmt_theta(theta)}).on(q[{qu}]))")
                 elif g == "RY":
-                    lines.append(f"circuit.append(cirq.ry({theta}).on(q[{qu}]))")
+                    lines.append(f"circuit.append(cirq.ry({_fmt_theta(theta)}).on(q[{qu}]))")
                 else:
-                    lines.append(f"circuit.append(cirq.rz({theta}).on(q[{qu}]))")
+                    lines.append(f"circuit.append(cirq.rz({_fmt_theta(theta)}).on(q[{qu}]))")
             else:
-                map_ = {"H":"H","X":"X","Y":"Y","Z":"Z","S":"S","T":"T","I":"I"}
-                lines.append(f"circuit.append(cirq.{map_[g]}.on(q[{qu}]))")
+                lines.append(f"circuit.append({gate_expr[g]}.on(q[{qu}]))")
         elif t == "cnot":
             lines.append(f"circuit.append(cirq.CNOT(q[{op['control']}], q[{op['target']}]))")
         elif t == "measure":
@@ -169,4 +267,4 @@ def csv_to_skill(csv_text: str, n_qubits: int | None = None) -> str:
     out.append("; )")
     out.append("")
 
-    return "\n".join(out) + "\n"    
+    return "\n".join(out) + "\n"    

quread/heatmap.py

@@ -3,12 +3,15 @@ from __future__ import annotations
 
 import csv
 import io
+import logging
 from dataclasses import dataclass
-from typing import Dict, List, Optional, Tuple
+from typing import Dict, List, Optional, Tuple, Any
 
 import numpy as np
 import matplotlib.pyplot as plt
 
+logger = logging.getLogger(__name__)
+
 
 @dataclass
 class HeatmapConfig:
@@ -32,23 +35,53 @@ def _default_qubit_coords(n_qubits: int, rows: int, cols: int) -> Dict[int, Tupl
     return m
 
 
-def _parse_history_rows(csv_text: str) -> List[dict]:
+def _parse_history_rows(csv_text: str) -> Tuple[List[dict], int]:
     """
     Expects the CSV you generate in Task 2A:
       step,gate,target,control,theta
     """
+    def _to_int_or_none(v: Any) -> Optional[int]:
+        s = str(v).strip()
+        if s == "":
+            return None
+        try:
+            return int(s)
+        except Exception:
+            return None
+
     f = io.StringIO(csv_text or "")
     reader = csv.DictReader(f)
-    rows = []
+    rows: List[dict] = []
+    skipped = 0
     for r in reader:
+        gate = (r.get("gate") or "").strip()
+        target_raw = r.get("target", "")
+        control_raw = r.get("control", "")
+        target = _to_int_or_none(target_raw)
+        control = _to_int_or_none(control_raw)
+        step = _to_int_or_none(r.get("step", ""))
+
+        malformed = False
+        if not gate:
+            malformed = True
+        if str(target_raw).strip() != "" and target is None:
+            malformed = True
+        if str(control_raw).strip() != "" and control is None:
+            malformed = True
+
+        if malformed:
+            skipped += 1
+            continue
+
         rows.append({
-            "step": int(r.get("step", "0") or 0),
-            "gate": (r.get("gate") or "").strip(),
-            "target": r.get("target", "").strip(),
-            "control": r.get("control", "").strip(),
+            "step": 0 if step is None else step,
+            "gate": gate,
+            "target": target,
+            "control": control,
             "theta": (r.get("theta") or "").strip(),
         })
-    return rows
+
+    return rows, skipped
 
 
 def make_activity_heatmap(
@@ -70,21 +103,19 @@ def make_activity_heatmap(
     # count per qubit
     counts = np.zeros((n_qubits,), dtype=float)
 
-    rows = _parse_history_rows(csv_text)
+    rows, skipped = _parse_history_rows(csv_text)
     for r in rows:
         gate = r["gate"].upper()
 
         # target
-        if r["target"] != "":
-            t = int(r["target"])
-            if 0 <= t < n_qubits:
-                counts[t] += 1.0
+        t = r["target"]
+        if t is not None and 0 <= t < n_qubits:
+            counts[t] += 1.0
 
         # control for CNOT
-        if gate == "CNOT" and r["control"] != "":
-            c = int(r["control"])
-            if 0 <= c < n_qubits:
-                counts[c] += 1.0
+        c = r["control"]
+        if gate == "CNOT" and c is not None and 0 <= c < n_qubits:
+            counts[c] += 1.0
 
     # place into chip grid
     for q, (rr, cc) in coords.items():
@@ -99,6 +130,19 @@ def make_activity_heatmap(
     ax.set_ylabel("Chip row")
     fig.colorbar(im, ax=ax, fraction=0.046, pad=0.04)
 
+    if skipped:
+        logger.warning("Skipped %d malformed CSV rows while building heatmap.", skipped)
+        ax.text(
+            0.01,
+            1.02,
+            f"Skipped {skipped} malformed CSV row(s)",
+            transform=ax.transAxes,
+            fontsize=8,
+            color="#b91c1c",
+            ha="left",
+            va="bottom",
+        )
+
     # annotate qubit ids on mapped cells
     for q, (rr, cc) in coords.items():
         if 0 <= rr < cfg.rows and 0 <= cc < cfg.cols:
@@ -107,4 +151,4 @@ def make_activity_heatmap(
     ax.set_xticks(range(cfg.cols))
     ax.set_yticks(range(cfg.rows))
     fig.tight_layout()
-    return fig
+    return fig

quread/llm_explain_openai.py

@@ -3,7 +3,12 @@ from typing import Any, Dict, List, Optional, Tuple
 import os
 from openai import OpenAI
 
-client = OpenAI(api_key=os.getenv("OPENAI_API_KEY"))
+
+def _build_client() -> OpenAI:
+    api_key = os.getenv("OPENAI_API_KEY")
+    if not api_key:
+        raise RuntimeError("OPENAI_API_KEY is not set.")
+    return OpenAI(api_key=api_key)
 
 
 def explain_with_gpt4o(
@@ -69,11 +74,18 @@ Shots: {shots}
 Answer:
 """
 
-    response = client.chat.completions.create(
-        model="gpt-4o",
-        messages=[{"role": "user", "content": prompt}],
-        temperature=0.2,
-        max_tokens=800,
-    )
-
-    return response.choices[0].message.content.strip()
+    try:
+        client = _build_client()
+        response = client.chat.completions.create(
+            model="gpt-4o",
+            messages=[{"role": "user", "content": prompt}],
+            temperature=0.2,
+            max_tokens=800,
+        )
+    except Exception as exc:
+        raise RuntimeError(f"OpenAI request failed ({type(exc).__name__}).") from exc
+
+    content = response.choices[0].message.content
+    if not content:
+        raise RuntimeError("OpenAI returned an empty explanation.")
+    return content.strip()