Merge branch 'main' into john/fix-incorrect-squin-address-lattice

Author: johnzl-777

src/bloqade/pyqrack/__init__.py

@@ -14,5 +14,5 @@
 
 # NOTE: The following import is for registering the method tables
 from .noise import native as native
-from .qasm2 import uop as uop, core as core, parallel as parallel
+from .qasm2 import uop as uop, core as core, glob as glob, parallel as parallel
 from .target import PyQrack as PyQrack

src/bloqade/pyqrack/qasm2/core.py

@@ -14,7 +14,6 @@
 
 @core.dialect.register(key="pyqrack")
 class PyQrackMethods(interp.MethodTable):
-
     @interp.impl(core.QRegNew)
     def qreg_new(
         self, interp: PyQrackInterpreter, frame: interp.Frame, stmt: core.QRegNew

src/bloqade/pyqrack/qasm2/glob.py

@@ -0,0 +1,26 @@
+from typing import Any
+
+from kirin import interp
+from kirin.dialects import ilist
+
+from bloqade.pyqrack.reg import PyQrackReg
+from bloqade.pyqrack.base import PyQrackInterpreter
+from bloqade.qasm2.dialects import glob
+
+
+@glob.dialect.register(key="pyqrack")
+class PyQrackMethods(interp.MethodTable):
+    @interp.impl(glob.UGate)
+    def ugate(self, interp: PyQrackInterpreter, frame: interp.Frame, stmt: glob.UGate):
+        registers: ilist.IList[PyQrackReg, Any] = frame.get(stmt.registers)
+        theta, phi, lam = (
+            frame.get(stmt.theta),
+            frame.get(stmt.phi),
+            frame.get(stmt.lam),
+        )
+
+        for qreg in registers:
+            for qarg in qreg:
+                if qarg.is_active():
+                    interp.memory.sim_reg.u(qarg.addr, theta, phi, lam)
+        return ()

src/bloqade/pyqrack/reg.py

@@ -33,7 +33,7 @@ class CBitRef:
     pos: int
     """The position of this bit in the classical register."""
 
-    def set_value(self, value: bool):
+    def set_value(self, value: Measurement):
         self.ref[self.pos] = value
 
     def get_value(self):
@@ -46,7 +46,7 @@ class QubitState(enum.Enum):
 
 
 @dataclass(frozen=True)
-class PyQrackReg(QReg):
+class PyQrackReg(QReg):  # TODO: clean up implementation with list base class
     """Simulation runtime value of a quantum register."""
 
     size: int
@@ -72,6 +72,8 @@ def drop(self, pos: int):
         self.qubit_state[pos] = QubitState.Lost
 
     def __getitem__(self, pos: int):
+        if not 0 <= pos < self.size:
+            raise IndexError("Qubit index out of bounds of register.")
         return PyQrackQubit(self, pos)
 
 

src/bloqade/qasm2/glob.py

@@ -11,7 +11,7 @@
 
 @wraps(glob.UGate)
 def u(
-    theta: float, phi: float, lam: float, registers: ilist.IList[QReg, Any] | list
+    registers: ilist.IList[QReg, Any] | list, theta: float, phi: float, lam: float
 ) -> None:
     """Apply a U gate to all qubits in the input registers.
 

src/bloqade/qasm2/parse/lowering.py

@@ -1,3 +1,5 @@
+import os
+import pathlib
 from typing import Any
 from dataclasses import field, dataclass
 
@@ -17,6 +19,118 @@ class QASM2(lowering.LoweringABC[ast.Node]):
     hint_show_lineno: bool = field(default=True, kw_only=True)
     stacktrace: bool = field(default=True, kw_only=True)
 
+    def loads(
+        self,
+        source: str,
+        kernel_name: str,
+        *,
+        returns: str | None = None,
+        globals: dict[str, Any] | None = None,
+        file: str | None = None,
+        lineno_offset: int = 0,
+        col_offset: int = 0,
+        compactify: bool = True,
+    ) -> ir.Method:
+        from ..parse import loads
+
+        # TODO: add source info
+        stmt = loads(source)
+
+        state = lowering.State(
+            self,
+            file=file,
+            lineno_offset=lineno_offset,
+            col_offset=col_offset,
+        )
+        with state.frame(
+            [stmt],
+            globals=globals,
+        ) as frame:
+            try:
+                self.visit(state, stmt)
+                # append return statement with the return values
+                if returns is not None:
+                    return_value = frame.get(returns)
+                    if return_value is None:
+                        raise lowering.BuildError(f"Cannot find return value {returns}")
+                else:
+                    return_value = func.ConstantNone()
+
+                return_node = frame.push(func.Return(value_or_stmt=return_value))
+
+            except lowering.BuildError as e:
+                hint = state.error_hint(
+                    e,
+                    max_lines=self.max_lines,
+                    indent=self.hint_indent,
+                    show_lineno=self.hint_show_lineno,
+                )
+                if self.stacktrace:
+                    raise Exception(
+                        f"{e.args[0]}\n\n{hint}",
+                        *e.args[1:],
+                    ) from e
+                else:
+                    e.args = (hint,)
+                    raise e
+
+            region = frame.curr_region
+
+        if compactify:
+            from kirin.rewrite import Walk, CFGCompactify
+
+            Walk(CFGCompactify()).rewrite(region)
+
+        code = func.Function(
+            sym_name=kernel_name,
+            signature=func.Signature((), return_node.value.type),
+            body=region,
+        )
+
+        return ir.Method(
+            mod=None,
+            py_func=None,
+            sym_name=kernel_name,
+            arg_names=[],
+            dialects=self.dialects,
+            code=code,
+        )
+
+    def loadfile(
+        self,
+        file: str | pathlib.Path,
+        *,
+        kernel_name: str | None = None,
+        returns: str | None = None,
+        globals: dict[str, Any] | None = None,
+        lineno_offset: int = 0,
+        col_offset: int = 0,
+        compactify: bool = True,
+    ) -> ir.Method:
+        if isinstance(file, str):
+            file = pathlib.Path(*os.path.split(file))
+
+        if not file.is_file() or not file.name.endswith(".qasm"):
+            raise ValueError("File must be a .qasm file")
+
+        kernel_name = (
+            file.name.replace(".qasm", "") if kernel_name is None else kernel_name
+        )
+
+        with file.open("r") as f:
+            source = f.read()
+
+        return self.loads(
+            source,
+            kernel_name,
+            returns=returns,
+            globals=globals,
+            file=str(file),
+            lineno_offset=lineno_offset,
+            col_offset=col_offset,
+            compactify=compactify,
+        )
+
     def run(
         self,
         stmt: ast.Node,
@@ -85,6 +199,9 @@ def lower_literal(self, state: lowering.State[ast.Node], value) -> ir.SSAValue:
             stmt = expr.ConstInt(value=value)
         elif isinstance(value, float):
             stmt = expr.ConstFloat(value=value)
+        else:
+            raise lowering.BuildError(f"Unsupported literal type {type(value)}")
+
         state.current_frame.push(stmt)
         return stmt.result
 

src/bloqade/qasm2/rewrite/native_gates.py

@@ -279,7 +279,7 @@ def rewrite_cu3(self, node: uop.CU3) -> result.RewriteResult:
         lam = self._get_const_value(node.lam)
         phi = self._get_const_value(node.phi)
 
-        if not all((theta, phi, lam)):
+        if theta is None or lam is None or phi is None:
             return result.RewriteResult()
 
         # cirq.ControlledGate(u3(theta, lambda phi))

src/bloqade/squin/analysis/nsites/analysis.py

@@ -15,9 +15,7 @@ class NSitesAnalysis(Forward[Sites]):
     keys = ["op.nsites"]
     lattice = Sites
 
-    # Take a page from const prop in Kirin,
-    # I can get the data I want from the SizedTrait
-    # and go from there
+    # Take a page from how constprop works in Kirin
 
     ## This gets called before the registry look up
     def eval_stmt(self, frame: ForwardFrame, stmt: ir.Statement):
@@ -37,7 +35,7 @@ def eval_stmt(self, frame: ForwardFrame, stmt: ir.Statement):
     # For when no implementation is found for the statement
     def eval_stmt_fallback(
         self, frame: ForwardFrame[Sites], stmt: ir.Statement
-    ) -> tuple[Sites, ...]:  # some form of Shape will go back into the frame
+    ) -> tuple[Sites, ...]:  # some form of Sites will go back into the frame
         return tuple(
             (
                 self.lattice.top()

test/pyqrack/test_target.py

@@ -38,3 +38,77 @@ def ghz():
     assert math.isclose(out[0].real, val, abs_tol=abs_tol)
     assert math.isclose(out[-1].real, val, abs_tol=abs_tol)
     assert all(math.isclose(ele.real, 0.0, abs_tol=abs_tol) for ele in out[1:-1])
+
+
+def test_target_glob():
+    @qasm2.extended
+    def global_h():
+        q = qasm2.qreg(3)
+
+        # rotate around Y by pi/2, i.e. perform a hadamard
+        qasm2.glob.u([q], math.pi / 2.0, 0, 0)
+
+        return q
+
+    target = PyQrack(3)
+    q = target.run(global_h)
+
+    assert isinstance(q, reg.PyQrackReg)
+
+    out = q.sim_reg.out_ket()
+
+    # remove global phase introduced by pyqrack
+    phase = out[0] / abs(out[0])
+    out = [ele / phase for ele in out]
+
+    for element in out:
+        assert math.isclose(element.real, 1 / math.sqrt(8), abs_tol=2.2e-7)
+        assert math.isclose(element.imag, 0, abs_tol=2.2e-7)
+
+    @qasm2.extended
+    def multiple_registers():
+        q1 = qasm2.qreg(2)
+        q2 = qasm2.qreg(2)
+        q3 = qasm2.qreg(2)
+
+        # hadamard on first register
+        qasm2.glob.u(
+            [q1],
+            math.pi / 2.0,
+            0,
+            0,
+        )
+
+        # apply hadamard to the other two
+        qasm2.glob.u(
+            [q2, q3],
+            math.pi / 2.0,
+            0,
+            0,
+        )
+
+        # rotate all of them back down
+        qasm2.glob.u(
+            [q1, q2, q3],
+            -math.pi / 2.0,
+            0,
+            0,
+        )
+
+        return q1
+
+    target = PyQrack(6)
+    q1 = target.run(multiple_registers)
+
+    assert isinstance(q1, reg.PyQrackReg)
+
+    out = q1.sim_reg.out_ket()
+
+    assert out[0] == 1
+    for i in range(1, len(out)):
+        assert out[i] == 0
+
+    assert True
+
+
+test_target_glob()

test/qasm2/passes/test_heuristic_noise.py

@@ -265,7 +265,7 @@ def test_global_noise():
     def test_method():
         q0 = qasm2.qreg(1)
         q1 = qasm2.qreg(1)
-        glob.UGate([q0, q1], 0.1, 0.2, 0.3)
+        qasm2.glob.u([q0, q1], 0.1, 0.2, 0.3)
 
     px = 0.01
     py = 0.01