spatial-computing 0.5.0__py3-none-any.whl

spatial/q/parser.py

@@ -0,0 +1,330 @@
+"""SPATIAL Q recursive-descent parser. AST nodes are tuples: (kind, ..., line).
+
+See docs/07_SPATIAL_Q_SPEC.md for the grammar.
+"""
+from __future__ import annotations
+
+from dataclasses import dataclass, field
+
+from .lexer import SQSyntaxError, Tok, lex
+
+GATES = {  # name -> (n_params, n_qubits)
+    "h": (0, 1), "x": (0, 1), "y": (0, 1), "z": (0, 1), "s": (0, 1), "sdg": (0, 1),
+    "t": (0, 1), "tdg": (0, 1), "sx": (0, 1),
+    "rx": (1, 1), "ry": (1, 1), "rz": (1, 1), "p": (1, 1),
+    "cx": (0, 2), "cz": (0, 2), "swap": (0, 2), "cp": (1, 2), "crz": (1, 2),
+    "ccx": (0, 3),
+}
+
+
+@dataclass
+class Kernel:
+    name: str
+    params: list[str]
+    body: list
+    line: int
+    ptypes: list = field(default_factory=list)     # per-parameter annotation; "qubit" marks a qubit argument
+
+
+@dataclass
+class TaskDef:
+    name: str
+    params: list[str]
+    target: str        # cpu | worker | any
+    body: list
+    line: int
+
+
+@dataclass
+class Program:
+    kernels: dict[str, Kernel] = field(default_factory=dict)
+    tasks: dict[str, TaskDef] = field(default_factory=dict)
+    main: list | None = None
+
+
+class Parser:
+    def __init__(self, src: str):
+        self.t = lex(src)
+        self.i = 0
+
+    # ---- token helpers
+    @property
+    def cur(self) -> Tok:
+        return self.t[self.i]
+
+    def err(self, msg: str):
+        raise SQSyntaxError(f"line {self.cur.line}:{self.cur.col}: {msg} (found {self.cur.val!r})")
+
+    def at(self, kind: str, val=None) -> bool:
+        return self.cur.kind == kind and (val is None or self.cur.val == val)
+
+    def eat(self, kind: str, val=None) -> Tok:
+        if not self.at(kind, val):
+            self.err(f"expected {val or kind}")
+        self.i += 1
+        return self.t[self.i - 1]
+
+    def opt(self, kind: str, val=None) -> bool:
+        if self.at(kind, val):
+            self.i += 1
+            return True
+        return False
+
+    # ---- declarations
+    def program(self) -> Program:
+        p = Program()
+        while not self.at("eof"):
+            if self.at("kw", "quantum"):
+                line = self.eat("kw").line
+                name = self.eat("id").val
+                params = self.params()
+                ptypes = self._ptypes
+                p.kernels[name] = Kernel(name, params, self.block(True), line, ptypes)
+            elif self.at("kw", "task"):
+                line = self.eat("kw").line
+                name = self.eat("id").val
+                params = self.params()
+                target = self.eat("id").val if self.opt("kw", "on") else "cpu"
+                if target not in ("cpu", "worker", "any"):
+                    self.err("task target must be cpu, worker or any")
+                p.tasks[name] = TaskDef(name, params, target, self.block(False), line)
+            elif self.at("kw", "main"):
+                self.eat("kw")
+                if p.main is not None:
+                    self.err("duplicate main")
+                p.main = self.block(False)
+            else:
+                self.err("expected 'quantum', 'task' or 'main'")
+        if p.main is None:
+            raise SQSyntaxError("program has no main block")
+        return p
+
+    def params(self) -> list[str]:
+        self.eat("op", "(")
+        out, types = [], []
+        while not self.at("op", ")"):
+            out.append(self.eat("id").val)
+            types.append(None)
+            if self.opt("op", ":"):      # annotation; `qubit` makes the parameter a qubit argument
+                if self.cur.kind not in ("id", "kw"):
+                    self.err("expected a type name")
+                types[-1] = self.cur.val
+                self.i += 1
+            if not self.opt("op", ","):
+                break
+        self.eat("op", ")")
+        self._ptypes = types
+        return out
+
+    def block(self, q: bool) -> list:
+        self.eat("op", "{")
+        out = []
+        while not self.at("op", "}"):
+            out.append(self.stmt(q))
+        self.eat("op", "}")
+        return out
+
+    # ---- statements
+    def stmt(self, q: bool):
+        c = self.cur
+        if c.kind == "kw":
+            if c.val == "qubit":
+                if not q:
+                    self.err("'qubit' is only allowed inside a quantum kernel")
+                self.eat("kw")
+                name = self.eat("id").val
+                self.eat("op", "[")
+                size = self.expr()
+                self.eat("op", "]")
+                self.eat("op", ";")
+                return ("qubit", name, size, c.line)
+            if c.val == "let":
+                self.eat("kw")
+                name = self.eat("id").val
+                self.eat("op", "=")
+                e = self.expr()
+                self.eat("op", ";")
+                return ("let", name, e, c.line)
+            if c.val == "for":
+                self.eat("kw")
+                var = self.eat("id").val
+                self.eat("kw", "in")
+                lo = self.expr()
+                self.eat("op", "..")
+                hi = self.expr()
+                return ("for", var, lo, hi, self.block(q), c.line)
+            if c.val == "while":
+                self.eat("kw")
+                cond = self.expr()
+                return ("while", cond, self.block(q), c.line)
+            if c.val == "if":
+                self.eat("kw")
+                cond = self.expr()
+                then = self.block(q)
+                els = self.block(q) if self.opt("kw", "else") else []
+                return ("if", cond, then, els, c.line)
+            if c.val == "return":
+                self.eat("kw")
+                e = self.expr()
+                self.eat("op", ";")
+                return ("return", e, c.line)
+            if c.val == "print":
+                self.eat("kw")
+                es = [self.expr()]
+                while self.opt("op", ","):
+                    es.append(self.expr())
+                self.eat("op", ";")
+                return ("print", es, c.line)
+            if c.val == "parallel":
+                if q:
+                    self.err("'parallel' is not allowed inside a quantum kernel")
+                self.eat("kw")
+                return ("parallel", self.block(False), c.line)
+            if c.val == "reset" and q:
+                self.eat("kw")
+                qa = self.qarg()
+                self.eat("op", ";")
+                return ("reset", qa, c.line)
+        if q and c.kind == "id" and c.val in GATES:
+            self.eat("id")
+            params = []
+            if self.opt("op", "("):
+                while not self.at("op", ")"):
+                    params.append(self.expr())
+                    if not self.opt("op", ","):
+                        break
+                self.eat("op", ")")
+            qargs = [self.qarg()]
+            while self.opt("op", ","):
+                qargs.append(self.qarg())
+            self.eat("op", ";")
+            np_, nq = GATES[c.val]
+            if len(params) != np_:
+                raise SQSyntaxError(f"line {c.line}: gate {c.val} takes {np_} parameter(s), got {len(params)}")
+            if len(qargs) != nq:
+                raise SQSyntaxError(f"line {c.line}: gate {c.val} acts on {nq} qubit(s), got {len(qargs)}")
+            return ("gate", c.val, params, qargs, c.line)
+        if q and c.kind == "id" and self.t[self.i + 1].kind == "op" and self.t[self.i + 1].val == "(":
+            self.eat("id")               # sub-kernel call: name(args...);
+            args = self.call_args()
+            self.eat("op", ";")
+            return ("kcall", c.val, args, c.line)
+        if c.kind == "id" and self.t[self.i + 1].kind == "op" and self.t[self.i + 1].val == "=":
+            name = self.eat("id").val
+            self.eat("op", "=")
+            e = self.expr()
+            self.eat("op", ";")
+            return ("assign", name, e, c.line)
+        e = self.expr()
+        self.eat("op", ";")
+        return ("expr", e, c.line)
+
+    def qarg(self):
+        name = self.eat("id").val
+        idx = None
+        if self.opt("op", "["):
+            idx = self.expr()
+            self.eat("op", "]")
+        return (name, idx)
+
+    # ---- expressions (precedence climbing)
+    _BIN = [("or",), ("and",), ("==", "!=", "<", "<=", ">", ">="), ("+", "-"), ("*", "/", "%")]
+
+    def expr(self, level: int = 0):
+        if level == len(self._BIN):
+            return self.unary()
+        left = self.expr(level + 1)
+        while self.cur.kind in ("op", "kw") and self.cur.val in self._BIN[level]:
+            op = self.cur.val
+            self.i += 1
+            left = ("bin", op, left, self.expr(level + 1))
+        return left
+
+    def unary(self):
+        if self.opt("op", "-"):
+            return ("neg", self.unary())
+        if self.opt("op", "!") or self.opt("kw", "not"):
+            return ("not", self.unary())
+        return self.postfix()
+
+    def postfix(self):
+        e = self.primary()
+        while self.opt("op", "["):
+            idx = self.expr()
+            self.eat("op", "]")
+            e = ("index", e, idx)
+        return e
+
+    def call_args(self) -> list:
+        self.eat("op", "(")
+        args = []
+        while not self.at("op", ")"):
+            args.append(self.expr())
+            if not self.opt("op", ","):
+                break
+        self.eat("op", ")")
+        return args
+
+    def primary(self):
+        c = self.cur
+        if c.kind == "num":
+            self.i += 1
+            return ("num", c.val)
+        if c.kind == "str":
+            self.i += 1
+            return ("str", c.val)
+        if c.kind == "kw":
+            if c.val in ("true", "false"):
+                self.i += 1
+                return ("num", c.val == "true")
+            if c.val == "measure":
+                self.i += 1
+                return ("measure", self.qarg(), c.line)
+            if c.val == "sample":
+                self.i += 1
+                name = self.eat("id").val
+                args = self.call_args()
+                shots = self.expr(3) if self.opt("kw", "shots") else ("num", 1024)
+                backend = self.eat("id").val if self.opt("kw", "on") else "auto"
+                return ("sample", name, args, shots, backend, c.line)
+            if c.val == "expect":
+                self.i += 1
+                pauli = self.eat("str").val
+                self.eat("kw", "of")
+                name = self.eat("id").val
+                args = self.call_args()
+                backend = self.eat("id").val if self.opt("kw", "on") else "auto"
+                return ("expect", pauli, name, args, backend, c.line)
+            if c.val == "workload":
+                self.i += 1
+                self.eat("op", "(")
+                wname = self.eat("str").val
+                kwargs = {}
+                while self.opt("op", ","):
+                    k = self.eat("id").val
+                    self.eat("op", "=")
+                    kwargs[k] = self.expr()
+                self.eat("op", ")")
+                return ("workload", wname, kwargs, c.line)
+        if c.kind == "id":
+            self.i += 1
+            if self.at("op", "("):
+                return ("call", c.val, self.call_args(), c.line)
+            return ("var", c.val, c.line)
+        if self.opt("op", "("):
+            e = self.expr()
+            self.eat("op", ")")
+            return e
+        if self.opt("op", "["):
+            items = []
+            while not self.at("op", "]"):
+                items.append(self.expr())
+                if not self.opt("op", ","):
+                    break
+            self.eat("op", "]")
+            return ("list", items)
+        self.err("expected an expression")
+
+
+def parse(src: str) -> Program:
+    return Parser(src).program()

spatial/q/qir.py

@@ -0,0 +1,128 @@
+"""QIR export for SQIR circuits (base and adaptive profiles).
+
+Gates outside the common QIS set are lowered first (exact up to a global phase):
+  sx -> rx(pi/2)      p(t) -> rz(t)
+  cp(t) a,b  -> rz(t/2) a; cx a,b; rz(-t/2) b; cx a,b; rz(t/2) b
+  crz(t) c,t -> rz(t/2) t; cx c,t; rz(-t/2) t; cx c,t
+Static circuits are exported in the base profile; circuits with mid-circuit measurement
+or feed-forward in the adaptive profile.
+"""
+from __future__ import annotations
+
+import math
+import struct
+
+from .ir import Circuit, Op
+
+_QIS = {"h": "h", "x": "x", "y": "y", "z": "z", "s": "s", "sdg": "s__adj", "t": "t", "tdg": "t__adj",
+        "rx": "rx", "ry": "ry", "rz": "rz", "cx": "cnot", "cz": "cz", "swap": "swap", "ccx": "ccx"}
+
+
+class QirExportError(Exception):
+    pass
+
+
+def lower(c: Circuit) -> Circuit:
+    """Rewrite the circuit with gates of the QIS set only (measure/reset/conditions kept)."""
+    out: list[Op] = []
+    for o in c.ops:
+        k = o.cond
+        if o.name in ("measure", "reset"):
+            out.append(o)
+        elif o.name == "sx":
+            out.append(Op("rx", o.qubits, (math.pi / 2,), cond=k))
+        elif o.name == "p":
+            out.append(Op("rz", o.qubits, o.params, cond=k))
+        elif o.name == "cp":
+            (t,), (a, b) = o.params, o.qubits
+            out += [Op("rz", (a,), (t / 2,), cond=k), Op("cx", (a, b), cond=k), Op("rz", (b,), (-t / 2,), cond=k),
+                    Op("cx", (a, b), cond=k), Op("rz", (b,), (t / 2,), cond=k)]
+        elif o.name == "crz":
+            (t,), (a, b) = o.params, o.qubits
+            out += [Op("rz", (b,), (t / 2,), cond=k), Op("cx", (a, b), cond=k), Op("rz", (b,), (-t / 2,), cond=k),
+                    Op("cx", (a, b), cond=k)]
+        elif o.name in _QIS:
+            out.append(o)
+        else:
+            raise QirExportError(f"gate {o.name} has no QIR lowering")
+    return Circuit(c.name, c.n_qubits, c.n_cbits, out)
+
+
+def _q(i: int) -> str:
+    return "ptr null" if i == 0 else f"ptr inttoptr (i64 {i} to ptr)"
+
+
+def _dbl(x: float) -> str:
+    return "double 0x" + struct.pack(">d", float(x)).hex().upper()     # exact IEEE-754 literal
+
+
+def to_qir(c: Circuit) -> str:
+    """LLVM IR text (opaque pointers). Static circuits use the QIR base profile; circuits with
+    mid-circuit measurement or feed-forward use the adaptive profile (results read back with
+    read_result and conditional branches). Every qubit is measured at the end."""
+    low = lower(c)
+    dynamic = any(o.name in ("measure", "reset") or o.cond for o in low.ops)
+    body, decls, tmp, blk = [], set(), 0, 0
+    n, m = c.n_qubits, c.n_cbits
+
+    def gate(o: Op) -> str:
+        if o.name == "measure":
+            decls.add("declare void @__quantum__qis__mz__body(ptr, ptr writeonly) #1")
+            return f"  call void @__quantum__qis__mz__body({_q(o.qubits[0])}, {_q(o.cbit)})"
+        if o.name == "reset":
+            decls.add("declare void @__quantum__qis__reset__body(ptr) #1")
+            return f"  call void @__quantum__qis__reset__body({_q(o.qubits[0])})"
+        fn = f"__quantum__qis__{_QIS[o.name]}__body"
+        decls.add(f"declare void @{fn}({', '.join(['double'] * len(o.params) + ['ptr'] * len(o.qubits))})")
+        return f"  call void @{fn}({', '.join([_dbl(p) for p in o.params] + [_q(q) for q in o.qubits])})"
+
+    i = 0
+    while i < len(low.ops):
+        o = low.ops[i]
+        if not o.cond:
+            body.append(gate(o))
+            i += 1
+            continue
+        j = i                                   # consecutive ops under the same condition share one branch
+        while j < len(low.ops) and low.ops[j].cond == o.cond:
+            j += 1
+        decls.add("declare i1 @__quantum__qis__read_result__body(ptr)")
+        acc = None
+        for bit, val in o.cond:
+            body.append(f"  %t{tmp} = call i1 @__quantum__qis__read_result__body({_q(bit)})")
+            cur = f"%t{tmp}"
+            tmp += 1
+            if val == 0:
+                body.append(f"  %t{tmp} = xor i1 {cur}, true")
+                cur = f"%t{tmp}"
+                tmp += 1
+            if acc is not None:
+                body.append(f"  %t{tmp} = and i1 {acc}, {cur}")
+                cur = f"%t{tmp}"
+                tmp += 1
+            acc = cur
+        body += [f"  br i1 {acc}, label %then{blk}, label %cont{blk}", f"then{blk}:"]
+        body += [gate(x) for x in low.ops[i:j]]
+        body += [f"  br label %cont{blk}", f"cont{blk}:"]
+        blk += 1
+        i = j
+    for q in range(n):                          # final read-out uses result ids after the mid-circuit ones
+        body.append(f"  call void @__quantum__qis__mz__body({_q(q)}, {_q(m + q)})")
+    body.append(f"  call void @__quantum__rt__array_record_output(i64 {n}, ptr null)")
+    for q in range(n):
+        body.append(f"  call void @__quantum__rt__result_record_output({_q(m + q)}, ptr null)")
+    decls |= {"declare void @__quantum__qis__mz__body(ptr, ptr writeonly) #1",
+              "declare void @__quantum__rt__array_record_output(i64, ptr)",
+              "declare void @__quantum__rt__result_record_output(ptr, ptr)"}
+    profile = "adaptive_profile" if dynamic else "base_profile"
+    return "\n".join([
+        f"; SPATIAL Q kernel '{c.name}' exported to QIR ({profile})",
+        "define void @main() #0 {", "entry:", *body, "  ret void", "}", "", *sorted(decls), "",
+        f'attributes #0 = {{ "entry_point" "output_labeling_schema" "qir_profiles"="{profile}" '
+        f'"required_num_qubits"="{n}" "required_num_results"="{m + n}" }}',
+        'attributes #1 = { "irreversible" }', "",
+        "!llvm.module.flags = !{!0, !1, !2, !3}",
+        '!0 = !{i32 1, !"qir_major_version", i32 1}',
+        '!1 = !{i32 7, !"qir_minor_version", i32 0}',
+        '!2 = !{i32 1, !"dynamic_qubit_management", i1 false}',
+        '!3 = !{i32 1, !"dynamic_result_management", i1 false}', ""])