spatial-computing 0.5.0__py3-none-any.whl

spatial/q/codegen.py

@@ -0,0 +1,153 @@
+"""Compiles the CLASSICAL part of a SPATIAL Q program (main + tasks) to Python source, which
+CPython then compiles to bytecode. Quantum kernels keep going through the SQIR compiler;
+this replaces the tree-walking interpreter for control flow and arithmetic.
+
+Semantics are the interpreter's: same dispatch (`sample`, `expect`, `workload`, tasks,
+`parallel`), same integer-preserving division, same errors for undeclared assignment.
+`compile_program()` returns the generated source so it can be inspected or cached.
+"""
+from __future__ import annotations
+
+from .compiler import CONSTS, FUNCS, div
+from .parser import Program
+
+
+class SQCodegenError(Exception):
+    pass
+
+
+_BIN = {"and": "and", "or": "or", "==": "==", "!=": "!=", "<": "<", "<=": "<=", ">": ">", ">=": ">=",
+        "+": "+", "-": "-", "*": "*", "%": "%"}
+
+
+class _Gen:
+    def __init__(self, prog: Program):
+        self.p = prog
+        self.lines: list[str] = []
+
+    def emit(self, depth: int, s: str):
+        self.lines.append("    " * depth + s)
+
+    def expr(self, e, scope: set, target: str) -> str:
+        k = e[0]
+        if k == "num":
+            return repr(e[1])
+        if k == "str":
+            return repr(e[1])
+        if k == "var":
+            if e[1] in scope:
+                return "v_" + e[1]
+            if e[1] in CONSTS:
+                return repr(CONSTS[e[1]])
+            raise SQCodegenError(f"line {e[2]}: unknown name '{e[1]}'")
+        if k == "neg":
+            return f"(-{self.expr(e[1], scope, target)})"
+        if k == "not":
+            return f"(not {self.expr(e[1], scope, target)})"
+        if k == "list":
+            return "[" + ", ".join(self.expr(x, scope, target) for x in e[1]) + "]"
+        if k == "index":
+            return f"{self.expr(e[1], scope, target)}[{self.expr(e[2], scope, target)}]"
+        if k == "bin":
+            a, b = self.expr(e[2], scope, target), self.expr(e[3], scope, target)
+            return f"_div({a}, {b})" if e[1] == "/" else f"({a} {_BIN[e[1]]} {b})"
+        if k == "call":
+            args = ", ".join(self.expr(a, scope, target) for a in e[2])
+            if e[1] in self.p.tasks:
+                return f"t_{e[1]}({args})"
+            if e[1] in FUNCS:
+                return f"_F[{e[1]!r}]({args})"
+            if e[1] in self.p.kernels:
+                raise SQCodegenError(f"line {e[3]}: quantum kernel '{e[1]}' must be used with 'sample' or 'expect'")
+            raise SQCodegenError(f"line {e[3]}: unknown function '{e[1]}'")
+        if k == "sample":
+            args = ", ".join(self.expr(a, scope, target) for a in e[2])
+            return f"_rt._sample({e[1]!r}, [{args}], int({self.expr(e[3], scope, target)}), {e[4]!r})"
+        if k == "expect":
+            args = ", ".join(self.expr(a, scope, target) for a in e[3])
+            return f"_rt._expect({e[1]!r}, {e[2]!r}, [{args}], {e[4]!r})"
+        if k == "workload":
+            kw = ", ".join(f"{kk!r}: {self.expr(v, scope, target)}" for kk, v in e[2].items())
+            return f"_rt._workload({e[1]!r}, {{{kw}}}, {target!r})"
+        if k == "measure":
+            raise SQCodegenError(f"line {e[2]}: 'measure' is only valid inside a quantum kernel")
+        raise SQCodegenError(f"cannot compile expression {k}")
+
+    def block(self, stmts, scope: set, depth: int, target: str):
+        if not stmts:
+            self.emit(depth, "pass")
+        for s in stmts:
+            k = s[0]
+            if k == "let":
+                rhs = self.expr(s[2], scope, target)
+                scope.add(s[1])
+                self.emit(depth, f"v_{s[1]} = {rhs}")
+            elif k == "assign":
+                if s[1] not in scope:
+                    raise SQCodegenError(f"line {s[3]}: assignment to undeclared variable '{s[1]}'")
+                self.emit(depth, f"v_{s[1]} = {self.expr(s[2], scope, target)}")
+            elif k == "print":
+                self.emit(depth, f"_rt.out({', '.join(self.expr(x, scope, target) for x in s[1])})")
+            elif k == "for":
+                lo, hi = self.expr(s[2], scope, target), self.expr(s[3], scope, target)
+                scope.add(s[1])
+                self.emit(depth, f"for v_{s[1]} in range({lo}, {hi}):")
+                self.block(s[4], scope, depth + 1, target)
+            elif k == "while":
+                self.emit(depth, f"while {self.expr(s[1], scope, target)}:")
+                self.block(s[2], scope, depth + 1, target)
+            elif k == "if":
+                self.emit(depth, f"if {self.expr(s[1], scope, target)}:")
+                self.block(s[2], scope, depth + 1, target)
+                if s[3]:
+                    self.emit(depth, "else:")
+                    self.block(s[3], scope, depth + 1, target)
+            elif k == "return":
+                self.emit(depth, f"return {self.expr(s[1], scope, target)}")
+            elif k == "expr":
+                self.emit(depth, self.expr(s[1], scope, target))
+            elif k == "parallel":
+                lets = [x for x in s[1] if x[0] in ("let", "assign")]
+                if len(lets) != len(s[1]):
+                    raise SQCodegenError(f"line {s[2]}: a parallel block may only contain let/assignment statements")
+                thunks = ", ".join(f"lambda: {self.expr(x[2], scope, target)}" for x in lets)
+                names = ", ".join(f"v_{x[1]}" for x in lets)
+                for x in lets:
+                    scope.add(x[1])
+                self.emit(depth, f"{names}{',' if len(lets) == 1 else ''} = _par([{thunks}])")
+            else:
+                raise SQCodegenError(f"line {s[-1]}: statement '{k}' not allowed here")
+
+    def program(self) -> str:
+        for t in self.p.tasks.values():
+            self.emit(0, f"def t_{t.name}({', '.join('v_' + a for a in t.params)}):")
+            self.block(t.body, set(t.params), 1, t.target)
+            self.emit(0, "")
+        self.emit(0, "def _main():")
+        scope: set = set()
+        self.block(self.p.main, scope, 1, "cpu")
+        self.emit(1, "return {k[2:]: v for k, v in locals().items() if k.startswith('v_')}")
+        return "\n".join(self.lines) + "\n"
+
+
+def compile_program(prog: Program) -> str:
+    """Python source for the classical part of `prog`."""
+    return _Gen(prog).program()
+
+
+def run_compiled(rt) -> dict:
+    """Execute a Runtime's program through the compiled classical path. Returns main's variables."""
+    import time
+    from concurrent.futures import ThreadPoolExecutor
+
+    def _par(thunks):
+        t0 = time.perf_counter()
+        with ThreadPoolExecutor(len(thunks)) as ex:
+            out = [f.result() for f in [ex.submit(t) for t in thunks]]
+        rt.trace.append({"op": "parallel", "branches": len(thunks), "wall_s": time.perf_counter() - t0})
+        return out
+
+    src = compile_program(rt.p)
+    ns = {"_rt": rt, "_F": FUNCS, "_div": div, "_par": _par}
+    exec(compile(src, "<spatialq-compiled>", "exec"), ns)      # source generated by this module, never user-supplied Python
+    return ns["_main"]()

spatial/q/compiler.py

@@ -0,0 +1,276 @@
+"""SPATIAL Q compiler: kernel AST + classical arguments -> SQIR Circuit, then optimisation.
+
+Kernels are specialised at call time (like a JIT): classical expressions and loops are
+evaluated at compile time; measurement results are run-time values that may only be used
+as `if` conditions (feed-forward).
+"""
+from __future__ import annotations
+
+import math
+from dataclasses import dataclass
+
+from .ir import Circuit, Op
+from .parser import GATES, Kernel
+
+
+class SQCompileError(Exception):
+    pass
+
+
+@dataclass(frozen=True)
+class MeasRef:
+    """Run-time measurement outcome (classical bit index, expected value)."""
+    cbit: int
+    value: int = 1
+
+
+CONSTS = {"pi": math.pi, "tau": math.tau, "e": math.e}
+FUNCS = {"sin": math.sin, "cos": math.cos, "sqrt": math.sqrt, "abs": abs, "min": min, "max": max,
+         "floor": math.floor, "acos": math.acos, "asin": math.asin, "exp": math.exp, "log": math.log,
+         "len": len, "float": float, "int": int, "pow": pow}
+
+
+def div(a, b):
+    """`/` keeps integers when the division is exact (so `n / 2` can index or size things)."""
+    if isinstance(a, int) and isinstance(b, int) and not isinstance(a, bool) and b != 0 and a % b == 0:
+        return a // b
+    return a / b
+
+
+def eval_const(e, env: dict):
+    """Evaluate a classical expression (shared with the runtime for pure expressions)."""
+    k = e[0]
+    if k in ("num", "str"):
+        return e[1]
+    if k == "var":
+        if e[1] in env:
+            return env[e[1]]
+        if e[1] in CONSTS:
+            return CONSTS[e[1]]
+        raise SQCompileError(f"line {e[2]}: unknown name '{e[1]}'")
+    if k == "neg":
+        return -eval_const(e[1], env)
+    if k == "not":
+        v = eval_const(e[1], env)
+        return MeasRef(v.cbit, 1 - v.value) if isinstance(v, MeasRef) else (not v)
+    if k == "list":
+        return [eval_const(x, env) for x in e[1]]
+    if k == "index":
+        return eval_const(e[1], env)[eval_const(e[2], env)]
+    if k == "bin":
+        op = e[1]
+        a = eval_const(e[2], env)
+        if op == "and":
+            return a and eval_const(e[3], env)
+        if op == "or":
+            return a or eval_const(e[3], env)
+        b = eval_const(e[3], env)
+        return {"+": lambda: a + b, "-": lambda: a - b, "*": lambda: a * b, "/": lambda: div(a, b),
+                "%": lambda: a % b, "==": lambda: a == b, "!=": lambda: a != b, "<": lambda: a < b,
+                "<=": lambda: a <= b, ">": lambda: a > b, ">=": lambda: a >= b}[op]()
+    if k == "call" and e[1] in FUNCS:
+        return FUNCS[e[1]](*[eval_const(a, env) for a in e[2]])
+    raise SQCompileError(f"expression kind '{k}' is not allowed here")
+
+
+MAX_CALL_DEPTH = 32
+
+
+class KernelCompiler:
+    def __init__(self, kernel: Kernel, args: list, kernels: dict | None = None):
+        if any(t == "qubit" for t in kernel.ptypes):
+            raise SQCompileError(f"kernel {kernel.name} takes qubit parameters: it can only be called from another kernel")
+        if len(args) != len(kernel.params):
+            raise SQCompileError(f"kernel {kernel.name} expects {len(kernel.params)} argument(s), got {len(args)}")
+        self.k = kernel
+        self.kernels = kernels or {}
+        self.env = dict(zip(kernel.params, args))
+        self.regs: dict[str, list[int]] = {}          # register name -> qubit indices
+        self.c = Circuit(kernel.name)
+        self.cond: tuple[tuple[int, int], ...] = ()
+        self.depth = 0
+
+    def _qubits_from_expr(self, e, line) -> list[int]:
+        if e[0] == "var":
+            return self.qubits((e[1], None), line)
+        if e[0] == "index" and e[1][0] == "var":
+            return self.qubits((e[1][1], e[2]), line)
+        raise SQCompileError(f"line {line}: a qubit argument must be a register or a register element")
+
+    def _call(self, name: str, args: list, line: int):
+        """Inline a sub-kernel: its gates are appended to this circuit on the qubits passed in."""
+        callee = self.kernels.get(name)
+        if callee is None:
+            raise SQCompileError(f"line {line}: unknown kernel '{name}'")
+        if len(args) != len(callee.params):
+            raise SQCompileError(f"line {line}: kernel {name} expects {len(callee.params)} argument(s), got {len(args)}")
+        if self.depth >= MAX_CALL_DEPTH:
+            raise SQCompileError(f"line {line}: kernel calls nested deeper than {MAX_CALL_DEPTH} (recursion?)")
+        child = object.__new__(KernelCompiler)
+        child.k, child.kernels, child.c, child.cond, child.depth = callee, self.kernels, self.c, self.cond, self.depth + 1
+        child.env, child.regs = {}, {}
+        ptypes = callee.ptypes or [None] * len(callee.params)
+        for pname, ptype, a in zip(callee.params, ptypes, args):
+            if ptype == "qubit":
+                child.regs[pname] = self._qubits_from_expr(a, line)
+            else:
+                child.env[pname] = eval_const(a, self.env)
+        child.body(callee.body)
+
+    def qubits(self, qa, line) -> list[int]:
+        name, idx = qa
+        if name not in self.regs:
+            raise SQCompileError(f"line {line}: unknown qubit register '{name}'")
+        qs = self.regs[name]
+        size = len(qs)
+        if idx is None:
+            return list(qs)
+        i = eval_const(idx, self.env)
+        if not isinstance(i, int) or not 0 <= i < size:
+            raise SQCompileError(f"line {line}: index {i!r} out of range for {name}[{size}]")
+        return [qs[i]]
+
+    def one(self, qa, line) -> int:
+        qs = self.qubits(qa, line)
+        if len(qs) != 1:
+            raise SQCompileError(f"line {line}: a single qubit is required here (use {qa[0]}[i])")
+        return qs[0]
+
+    def body(self, stmts):
+        for s in stmts:
+            kind = s[0]
+            if kind == "qubit":
+                size = eval_const(s[2], self.env)
+                if not isinstance(size, int) or size < 1:
+                    raise SQCompileError(f"line {s[3]}: register size must be a positive integer")
+                self.regs[s[1]] = list(range(self.c.n_qubits, self.c.n_qubits + size))
+                self.c.n_qubits += size
+            elif kind == "kcall":
+                self._call(s[1], s[2], s[3])
+            elif kind == "gate":
+                _, name, params, qargs, line = s
+                ps = tuple(float(eval_const(p, self.env)) for p in params)
+                if GATES[name][1] == 1 and qargs[0][1] is None:      # broadcast: `h q;`
+                    for q in self.qubits(qargs[0], line):
+                        self.c.ops.append(Op(name, (q,), ps, cond=self.cond))
+                else:
+                    qs = tuple(self.one(qa, line) for qa in qargs)
+                    if len(set(qs)) != len(qs):
+                        raise SQCompileError(f"line {line}: gate {name} applied twice to the same qubit")
+                    self.c.ops.append(Op(name, qs, ps, cond=self.cond))
+            elif kind == "reset":
+                for q in self.qubits(s[1], s[2]):
+                    self.c.ops.append(Op("reset", (q,), cond=self.cond))
+            elif kind in ("let", "assign"):
+                e = s[2]
+                if e[0] == "measure":
+                    q = self.one(e[1], e[2])
+                    self.c.ops.append(Op("measure", (q,), cbit=self.c.n_cbits, cond=self.cond))
+                    self.env[s[1]] = MeasRef(self.c.n_cbits)
+                    self.c.n_cbits += 1
+                else:
+                    self.env[s[1]] = eval_const(e, self.env)
+            elif kind == "for":
+                lo, hi = eval_const(s[2], self.env), eval_const(s[3], self.env)
+                for i in range(lo, hi):
+                    self.env[s[1]] = i
+                    self.body(s[4])
+            elif kind == "if":
+                c = eval_const(s[1], self.env)
+                if isinstance(c, MeasRef):
+                    saved = self.cond
+                    self.cond = saved + ((c.cbit, c.value),)
+                    self.body(s[2])
+                    self.cond = saved + ((c.cbit, 1 - c.value),)
+                    self.body(s[3])
+                    self.cond = saved
+                else:
+                    self.body(s[2] if c else s[3])
+            elif kind == "expr" and s[1][0] == "measure":
+                q = self.one(s[1][1], s[1][2])
+                self.c.ops.append(Op("measure", (q,), cbit=self.c.n_cbits, cond=self.cond))
+                self.c.n_cbits += 1
+            else:
+                raise SQCompileError(f"line {s[-1]}: statement '{kind}' is not allowed in a quantum kernel")
+
+    def compile(self) -> Circuit:
+        self.body(self.k.body)
+        if self.c.n_qubits == 0:
+            raise SQCompileError(f"kernel {self.k.name} declares no qubits")
+        return self.c
+
+
+# ------------------------------------------------------------------ optimiser
+_SELF_INVERSE = {"h", "x", "y", "z", "cx", "cz", "swap", "ccx"}
+_INVERSE_PAIR = {("s", "sdg"), ("sdg", "s"), ("t", "tdg"), ("tdg", "t")}
+_ROT = {"rx", "ry", "rz", "p", "cp", "crz"}
+_SYMMETRIC = {"cz", "swap", "cp"}
+
+
+def _key(o: Op):
+    return tuple(sorted(o.qubits)) if o.name in _SYMMETRIC else o.qubits
+
+
+def optimize(c: Circuit) -> tuple[Circuit, dict]:
+    """Peephole passes to a fixed point: cancel adjacent inverse pairs, merge same-axis
+    rotations, drop identity rotations. 'Adjacent' = no other op touches those qubits in
+    between. Measurements, resets and conditional ops are barriers."""
+    ops = list(c.ops)
+    before = len(ops)
+    passes = 0
+    changed = True
+    while changed:
+        changed = False
+        passes += 1
+        out: list[Op | None] = []
+        last: dict[int, int] = {}          # qubit -> index in `out` of the last op touching it
+        for o in ops:
+            barrier = o.name in ("measure", "reset") or bool(o.cond)
+            prev_i = None
+            if not barrier:
+                idxs = {last.get(q) for q in o.qubits}
+                if len(idxs) == 1 and None not in idxs:
+                    prev_i = idxs.pop()
+            prev = out[prev_i] if prev_i is not None else None
+            if prev is not None and not prev.cond and prev.name not in ("measure", "reset") \
+                    and _key(prev) == _key(o) and len(prev.qubits) == len(o.qubits):
+                if (prev.name == o.name and o.name in _SELF_INVERSE) or (prev.name, o.name) in _INVERSE_PAIR:
+                    out[prev_i] = None
+                    for q in o.qubits:
+                        last.pop(q, None)
+                    # restore `last` for these qubits from earlier ops
+                    for j in range(prev_i - 1, -1, -1):
+                        if out[j] is not None:
+                            for q in out[j].qubits:
+                                if q in o.qubits and q not in last:
+                                    last[q] = j
+                    changed = True
+                    continue
+                if prev.name == o.name and o.name in _ROT:
+                    out[prev_i] = Op(o.name, prev.qubits, (prev.params[0] + o.params[0],))
+                    changed = True
+                    continue
+            out.append(o)
+            for q in o.qubits:
+                last[q] = len(out) - 1
+        ops = []
+        for o in out:
+            if o is None:
+                continue
+            if o.name in _ROT and not o.cond:
+                period = 2 * math.pi if o.name in ("p", "cp") else 4 * math.pi
+                a = math.fmod(o.params[0], period)
+                if abs(a) < 1e-12 or abs(abs(a) - period) < 1e-12:
+                    changed = True
+                    continue
+            ops.append(o)
+    oc = Circuit(c.name, c.n_qubits, c.n_cbits, ops)
+    return oc, {"ops_before": before, "ops_after": len(ops), "passes": passes}
+
+
+def compile_kernel(kernel: Kernel, args: list, opt: bool = True, kernels: dict | None = None) -> tuple[Circuit, dict]:
+    """`kernels` is the program's kernel table, needed when the kernel calls sub-kernels."""
+    c = KernelCompiler(kernel, args, kernels).compile()
+    if opt:
+        return optimize(c)
+    return c, {"ops_before": len(c.ops), "ops_after": len(c.ops), "passes": 0}

spatial/q/ir.py

@@ -0,0 +1,121 @@
+"""SQIR — SPATIAL Q Intermediate Representation (quantum part).
+
+A Circuit is a flat list of Ops on numbered qubits and classical bits, plus a
+ResourceEstimate that the orchestrator uses to pick a backend. Serialisable to
+JSON (`to_json`) and to OpenQASM 3 (`to_qasm3`), the interoperability target.
+"""
+from __future__ import annotations
+
+import json
+from dataclasses import dataclass, field
+
+
+@dataclass(frozen=True)
+class Op:
+    name: str                       # gate name | "measure" | "reset"
+    qubits: tuple[int, ...]
+    params: tuple[float, ...] = ()
+    cbit: int | None = None         # target classical bit for "measure"
+    cond: tuple[tuple[int, int], ...] = ()   # all (cbit, value) pairs must hold
+
+
+@dataclass
+class ResourceEstimate:
+    qubits: int
+    ops: int
+    two_qubit_ops: int
+    depth: int
+    mid_circuit_measurements: int
+    statevector_bytes: int          # 16 * 2^n: RAM needed by an exact state-vector simulation
+    dynamic: bool                   # needs feed-forward (conditional ops)
+
+    def to_dict(self) -> dict:
+        return self.__dict__.copy()
+
+
+@dataclass
+class Circuit:
+    name: str
+    n_qubits: int = 0
+    n_cbits: int = 0
+    ops: list[Op] = field(default_factory=list)
+
+    def estimate(self) -> ResourceEstimate:
+        level = [0] * max(self.n_qubits, 1)
+        two = mid = 0
+        dyn = False
+        for o in self.ops:
+            d = max(level[q] for q in o.qubits) + 1
+            for q in o.qubits:
+                level[q] = d
+            if len(o.qubits) >= 2:
+                two += 1
+            if o.name == "measure":
+                mid += 1
+            if o.cond:
+                dyn = True
+        return ResourceEstimate(self.n_qubits, len(self.ops), two, max(level) if self.ops else 0,
+                                mid, 16 * (1 << self.n_qubits), dyn)
+
+    def to_json(self) -> str:
+        return json.dumps({
+            "sqir": "0.1", "name": self.name, "qubits": self.n_qubits, "cbits": self.n_cbits,
+            "ops": [{"g": o.name, "q": list(o.qubits), **({"p": list(o.params)} if o.params else {}),
+                     **({"c": o.cbit} if o.cbit is not None else {}),
+                     **({"if": [list(c) for c in o.cond]} if o.cond else {})} for o in self.ops],
+            "resources": self.estimate().to_dict()}, indent=1)
+
+    @staticmethod
+    def from_json(text: str) -> "Circuit":
+        d = json.loads(text)
+        c = Circuit(d["name"], d["qubits"], d["cbits"])
+        for o in d["ops"]:
+            c.ops.append(Op(o["g"], tuple(o["q"]), tuple(o.get("p", ())), o.get("c"),
+                            tuple(tuple(x) for x in o.get("if", ()))))
+        return c
+
+    def to_qasm2(self) -> str:
+        """OpenQASM 2.0 text for STATIC circuits (the dialect Cirq, PennyLane and older tools import).
+        Gates missing from qelib1.inc are rewritten: p -> u1, cp -> cu1."""
+        if any(o.name in ("measure", "reset") or o.cond for o in self.ops):
+            raise ValueError("OpenQASM 2 export supports static circuits only; use to_qasm3()")
+        ren = {"p": "u1", "cp": "cu1"}
+        L = ["OPENQASM 2.0;", 'include "qelib1.inc";', f"qreg q[{self.n_qubits}];", f"creg c[{self.n_qubits}];"]
+        for o in self.ops:
+            p = "(" + ",".join(repr(float(x)) for x in o.params) + ")" if o.params else ""
+            L.append(f"{ren.get(o.name, o.name)}{p} " + ",".join(f"q[{q}]" for q in o.qubits) + ";")
+        L.append("measure q -> c;")
+        return "\n".join(L) + "\n"
+
+    def shot_cost(self, shots: int, usd_per_shot: float = 0.0, usd_per_task: float = 0.0,
+                  usd_per_second: float = 0.0, seconds_per_shot: float = 0.0) -> dict:
+        """Cost of running this circuit on a provider, from PRICES THE CALLER SUPPLIES.
+        No provider price is built in: tariffs differ and change; an invented default would be a lie."""
+        if not (usd_per_shot or usd_per_task or usd_per_second):
+            raise ValueError("no price given: pass the provider's usd_per_shot, usd_per_task or usd_per_second")
+        usd = usd_per_task + shots * usd_per_shot + shots * seconds_per_shot * usd_per_second
+        return {"shots": shots, "usd": usd, "usd_per_shot_effective": usd / shots,
+                "inputs": {"usd_per_shot": usd_per_shot, "usd_per_task": usd_per_task,
+                           "usd_per_second": usd_per_second, "seconds_per_shot": seconds_per_shot}}
+
+    def to_qasm3(self) -> str:
+        """OpenQASM 3 text. A final `c = measure q;` reads out every qubit."""
+        L = ["OPENQASM 3.0;", 'include "stdgates.inc";', f"qubit[{self.n_qubits}] q;"]
+        if self.n_cbits:
+            L.append(f"bit[{self.n_cbits}] m;")
+        L.append(f"bit[{self.n_qubits}] c;")
+        for o in self.ops:
+            qs = ", ".join(f"q[{q}]" for q in o.qubits)
+            if o.name == "measure":
+                s = f"m[{o.cbit}] = measure {qs};"
+            elif o.name == "reset":
+                s = f"reset {qs};"
+            else:
+                p = "(" + ", ".join(repr(float(x)) for x in o.params) + ")" if o.params else ""
+                s = f"{o.name}{p} {qs};"
+            if o.cond:
+                cond = " && ".join(f"m[{b}] == {v}" for b, v in o.cond)
+                s = f"if ({cond}) {{ {s} }}"
+            L.append(s)
+        L.append("c = measure q;")
+        return "\n".join(L) + "\n"

spatial/q/lexer.py

@@ -0,0 +1,61 @@
+"""SPATIAL Q lexer."""
+from __future__ import annotations
+
+import re
+from dataclasses import dataclass
+
+KEYWORDS = {
+    "quantum", "task", "main", "on", "qubit", "let", "for", "in", "while", "if", "else",
+    "return", "print", "parallel", "measure", "reset", "sample", "shots", "expect", "of",
+    "workload", "true", "false", "and", "or", "not",
+}
+
+_TOKEN = re.compile(r"""
+    (?P<ws>[ \t\r]+|//[^\n]*)
+  | (?P<nl>\n)
+  | (?P<num>\d+\.(?!\.)\d*(?:[eE][-+]?\d+)?|\d+[eE][-+]?\d+|\.\d+|\d+)
+  | (?P<str>"[^"\n]*")
+  | (?P<id>[A-Za-z_][A-Za-z0-9_]*)
+  | (?P<op>->|\.\.|==|!=|<=|>=|[-+*/%<>=(){}\[\],;:!])
+""", re.X)
+
+
+@dataclass
+class Tok:
+    kind: str     # num | str | id | kw | op | eof
+    val: object
+    line: int
+    col: int
+
+
+class SQSyntaxError(SyntaxError):
+    pass
+
+
+def lex(src: str) -> list[Tok]:
+    out, pos, line, line_start = [], 0, 1, 0
+    while pos < len(src):
+        m = _TOKEN.match(src, pos)
+        if not m:
+            raise SQSyntaxError(f"line {line}:{pos - line_start + 1}: unexpected character {src[pos]!r}")
+        kind = m.lastgroup
+        text = m.group()
+        col = pos - line_start + 1
+        pos = m.end()
+        if kind == "ws":
+            continue
+        if kind == "nl":
+            line += 1
+            line_start = pos
+            continue
+        if kind == "num":
+            is_float = any(c in text for c in ".eE")
+            out.append(Tok("num", float(text) if is_float else int(text), line, col))
+        elif kind == "str":
+            out.append(Tok("str", text[1:-1], line, col))
+        elif kind == "id":
+            out.append(Tok("kw" if text in KEYWORDS else "id", text, line, col))
+        else:
+            out.append(Tok("op", text, line, col))
+    out.append(Tok("eof", None, line, 0))
+    return out