bloqade-circuit 0.4.1__tar.gz → 0.4.2__tar.gz

{bloqade_circuit-0.4.1 → bloqade_circuit-0.4.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: bloqade-circuit
-Version: 0.4.1
+Version: 0.4.2
 Summary: The software development toolkit for neutral atom arrays.
 Author-email: Roger-luo <rluo@quera.com>, kaihsin <khwu@quera.com>, weinbe58 <pweinberg@quera.com>, johnzl-777 <jlong@quera.com>
 License-File: LICENSE

{bloqade_circuit-0.4.1 → bloqade_circuit-0.4.2}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "bloqade-circuit"
-version = "0.4.1"
+version = "0.4.2"
 description = "The software development toolkit for neutral atom arrays."
 readme = "README.md"
 authors = [

{bloqade_circuit-0.4.1 → bloqade_circuit-0.4.2}/src/bloqade/qasm2/parse/lowering.py

@@ -2,9 +2,9 @@ from typing import Any
 from dataclasses import field, dataclass
 
 from kirin import ir, types, lowering
-from kirin.dialects import cf, func, ilist
+from kirin.dialects import cf, scf, func, ilist
 
-from bloqade.qasm2.types import CRegType, QRegType
+from bloqade.qasm2.types import CRegType, QRegType, QubitType
 from bloqade.qasm2.dialects import uop, core, expr, glob, noise, parallel
 
 from . import ast
@@ -101,6 +101,13 @@ class QASM2(lowering.LoweringABC[ast.Node]):
     def lower_global(
         self, state: lowering.State[ast.Node], node: ast.Node
     ) -> lowering.LoweringABC.Result:
+        if isinstance(node, ast.Name):
+            # NOTE: might be a lookup for a gate function invoke
+            try:
+                return lowering.LoweringABC.Result(state.current_frame.globals[node.id])
+            except KeyError:
+                pass
+
         raise lowering.BuildError("Global variables are not supported in QASM 2.0")
 
     def visit_MainProgram(self, state: lowering.State[ast.Node], node: ast.MainProgram):
@@ -171,7 +178,6 @@ class QASM2(lowering.LoweringABC[ast.Node]):
     def visit_Reset(self, state: lowering.State[ast.Node], node: ast.Reset):
         state.current_frame.push(core.Reset(qarg=state.lower(node.qarg).expect_one()))
 
-    # TODO: clean this up? copied from cf dialect with a small modification
     def visit_IfStmt(self, state: lowering.State[ast.Node], node: ast.IfStmt):
         cond_stmt = core.CRegEq(
             lhs=state.lower(node.cond.lhs).expect_one(),
@@ -179,84 +185,23 @@ class QASM2(lowering.LoweringABC[ast.Node]):
         )
         cond = state.current_frame.push(cond_stmt).result
         frame = state.current_frame
-        before_block = frame.curr_block
 
-        with state.frame(node.body, region=frame.curr_region) as if_frame:
+        with state.frame(node.body) as if_frame:
             true_cond = if_frame.entr_block.args.append_from(types.Bool, cond.name)
             if cond.name:
                 if_frame.defs[cond.name] = true_cond
 
+            # NOTE: pass in definitions from outer scope (usually just for the qreg)
+            if_frame.defs.update(frame.defs)
+
             if_frame.exhaust()
-            self.branch_next_if_not_terminated(if_frame)
 
-        with state.frame([], region=frame.curr_region) as else_frame:
-            true_cond = else_frame.entr_block.args.append_from(types.Bool, cond.name)
-            if cond.name:
-                else_frame.defs[cond.name] = true_cond
-            else_frame.exhaust()
-            self.branch_next_if_not_terminated(else_frame)
-
-        with state.frame(frame.stream.split(), region=frame.curr_region) as after_frame:
-            after_frame.defs.update(frame.defs)
-            phi: set[str] = set()
-            for name in if_frame.defs.keys():
-                if frame.get(name):
-                    phi.add(name)
-                elif name in else_frame.defs:
-                    phi.add(name)
-
-            for name in else_frame.defs.keys():
-                if frame.get(name):  # not defined in if_frame
-                    phi.add(name)
-
-            for name in phi:
-                after_frame.defs[name] = after_frame.entr_block.args.append_from(
-                    types.Any, name
-                )
+            # NOTE: qasm2 can never yield anything from if
+            if_frame.push(scf.Yield())
 
-            after_frame.exhaust()
-            self.branch_next_if_not_terminated(after_frame)
-            after_frame.next_block.stmts.append(
-                cf.Branch(arguments=(), successor=frame.next_block)
-            )
+            then_body = if_frame.curr_region
 
-        if_args = []
-        for name in phi:
-            if value := if_frame.get(name):
-                if_args.append(value)
-            else:
-                raise lowering.BuildError(f"undefined variable {name} in if branch")
-
-        else_args = []
-        for name in phi:
-            if value := else_frame.get(name):
-                else_args.append(value)
-            else:
-                raise lowering.BuildError(f"undefined variable {name} in else branch")
-
-        if_frame.next_block.stmts.append(
-            cf.Branch(
-                arguments=tuple(if_args),
-                successor=after_frame.entr_block,
-            )
-        )
-        else_frame.next_block.stmts.append(
-            cf.Branch(
-                arguments=tuple(else_args),
-                successor=after_frame.entr_block,
-            )
-        )
-        before_block.stmts.append(
-            cf.ConditionalBranch(
-                cond=cond,
-                then_arguments=(cond,),
-                then_successor=if_frame.entr_block,
-                else_arguments=(cond,),
-                else_successor=else_frame.entr_block,
-            )
-        )
-        frame.defs.update(after_frame.defs)
-        frame.jump_next_block()
+        state.current_frame.push(scf.IfElse(cond, then_body=then_body))
 
     def branch_next_if_not_terminated(self, frame: lowering.Frame):
         """Branch to the next block if the current block is not terminated.
@@ -430,7 +375,56 @@ class QASM2(lowering.LoweringABC[ast.Node]):
             raise lowering.BuildError(f"Include {node.filename} not found")
 
     def visit_Gate(self, state: lowering.State[ast.Node], node: ast.Gate):
-        raise NotImplementedError("Gate lowering not supported")
+        arg_names = node.cparams + node.qparams
+        arg_types = [types.Float for _ in node.cparams] + [
+            QubitType for _ in node.qparams
+        ]
+
+        with state.frame(
+            stmts=node.body,
+            finalize_next=False,
+        ) as body_frame:
+            # NOTE: insert _self as arg
+            body_frame.curr_block.args.append_from(
+                types.Generic(
+                    ir.Method, types.Tuple.where(tuple(arg_types)), types.NoneType
+                ),
+                name=node.name + "_self",
+            )
+
+            for arg_type, arg_name in zip(arg_types, arg_names):
+                # NOTE: append args as block arguments
+                block_arg = body_frame.curr_block.args.append_from(
+                    arg_type, name=arg_name
+                )
+
+                # NOTE: add arguments as definitions to frame
+                body_frame.defs[arg_name] = block_arg
+
+            body_frame.exhaust()
+
+            # NOTE: append none as return value
+            return_val = func.ConstantNone()
+            body_frame.push(return_val)
+            body_frame.push(func.Return(return_val))
+
+            body = body_frame.curr_region
+
+        gate_func = expr.GateFunction(
+            sym_name=node.name,
+            signature=func.Signature(inputs=tuple(arg_types), output=types.NoneType),
+            body=body,
+        )
+
+        mt = ir.Method(
+            mod=None,
+            py_func=None,
+            sym_name=node.name,
+            dialects=self.dialects,
+            arg_names=[*node.cparams, *node.qparams],
+            code=gate_func,
+        )
+        state.current_frame.globals[node.name] = mt
 
     def visit_Instruction(self, state: lowering.State[ast.Node], node: ast.Instruction):
         params = [state.lower(param).expect_one() for param in node.params]

{bloqade_circuit-0.4.1 → bloqade_circuit-0.4.2}/test/pyqrack/squin/test_noise.py

@@ -137,7 +137,7 @@ def test_pp_error():
     zero_avg /= len(result)
 
     # should be approximately 10% since that is the bit flip error probability in the kernel above
-    assert 0.05 < zero_avg < 0.25
+    assert 0.0 < zero_avg < 0.25
 
 
 def test_depolarize():

bloqade_circuit-0.4.2/test/qasm2/test_lowering.py

@@ -0,0 +1,165 @@
+import math
+import pathlib
+import tempfile
+import textwrap
+
+from kirin import ir, types
+from kirin.dialects import func
+
+from bloqade import qasm2
+from bloqade.qasm2.parse.lowering import QASM2
+
+lines = textwrap.dedent(
+    """
+OPENQASM 2.0;
+
+qreg q[2];
+creg c[2];
+
+h q[0];
+CX q[0], q[1];
+barrier q[0], q[1];
+CX q[0], q[1];
+rx(pi/2) q[0];
+"""
+)
+
+
+def test_run_lowering():
+    ast = qasm2.parse.loads(lines)
+    code = QASM2(qasm2.main).run(ast)
+    code.print()
+
+
+def test_loadfile():
+
+    with tempfile.TemporaryDirectory() as tmp_dir:
+        with open(f"{tmp_dir}/test.qasm", "w") as f:
+            f.write(lines)
+
+        file = pathlib.Path(f"{tmp_dir}/test.qasm")
+        qasm2.loadfile(file)
+
+
+def test_negative_lowering():
+
+    mwe = """
+    OPENQASM 2.0;
+    include "qelib1.inc";
+    qreg q[1];
+    rz(-0.2) q[0];
+    """
+
+    entry = qasm2.loads(mwe)
+
+    body = ir.Region(
+        ir.Block(
+            [
+                (size := qasm2.expr.ConstInt(value=1)),
+                (qreg := qasm2.core.QRegNew(n_qubits=size.result)),
+                (phi := qasm2.expr.ConstFloat(value=0.2)),
+                (theta := qasm2.expr.Neg(phi.result)),
+                (idx := qasm2.expr.ConstInt(value=0)),
+                (qubit := qasm2.core.QRegGet(qreg.result, idx.result)),
+                (qasm2.uop.RZ(qubit.result, theta.result)),
+                (none := func.ConstantNone()),
+                (func.Return(none.result)),
+            ]
+        )
+    )
+
+    code = func.Function(
+        sym_name="main",
+        signature=func.Signature((), types.NoneType),
+        body=body,
+    )
+
+    code.print()
+    entry.print()
+
+    assert entry.code.is_structurally_equal(code)
+
+
+def test_gate():
+    qasm2_prog = textwrap.dedent(
+        """
+        OPENQASM 2.0;
+        include "qelib1.inc";
+        qreg q[2];
+        gate custom_gate q1, q2 {
+            cx q1, q2;
+        }
+        h q[0];
+        custom_gate q[0], q[1];
+        """
+    )
+
+    main = qasm2.loads(qasm2_prog, compactify=False)
+
+    main.print()
+
+    from bloqade.pyqrack import StackMemorySimulator
+
+    target = StackMemorySimulator(min_qubits=2)
+    ket = target.state_vector(main)
+
+    assert ket[1] == ket[2] == 0
+    assert math.isclose(abs(ket[0]) ** 2, 0.5, abs_tol=1e-6)
+    assert math.isclose(abs(ket[3]) ** 2, 0.5, abs_tol=1e-6)
+
+
+def test_gate_with_params():
+    qasm2_prog = textwrap.dedent(
+        """
+        OPENQASM 2.0;
+        include "qelib1.inc";
+        qreg q[2];
+        h q[1];
+        gate custom_gate(theta) q1, q2 {
+            u(theta, 0, 0) q1;
+            cx q1, q2;
+        }
+        h q[1];
+        custom_gate(1.5707963267948966) q[0], q[1];
+        """
+    )
+
+    main = qasm2.loads(qasm2_prog, compactify=False)
+
+    main.print()
+
+    from bloqade.pyqrack import StackMemorySimulator
+
+    target = StackMemorySimulator(min_qubits=2)
+    ket = target.state_vector(main)
+
+    assert ket[1] == ket[2] == 0
+    assert math.isclose(abs(ket[0]) ** 2, 0.5, abs_tol=1e-6)
+    assert math.isclose(abs(ket[3]) ** 2, 0.5, abs_tol=1e-6)
+
+
+def test_if_lowering():
+
+    qasm2_prog = textwrap.dedent(
+        """
+        OPENQASM 2.0;
+        include "qelib1.inc";
+        qreg q[1];
+        creg c[1];
+        if(c == 1) x q[0];
+        """
+    )
+
+    main = qasm2.loads(qasm2_prog)
+
+    main.print()
+
+    @qasm2.main
+    def main2():
+        q = qasm2.qreg(1)
+        c = qasm2.creg(1)
+
+        if c == 1:
+            qasm2.x(q[0])
+
+    main2.print()

{bloqade_circuit-0.4.1 → bloqade_circuit-0.4.2}/uv.lock

@@ -96,7 +96,7 @@ wheels = [
 
 [[package]]
 name = "bloqade-circuit"
-version = "0.4.1"
+version = "0.4.2"
 source = { editable = "." }
 dependencies = [
     { name = "kirin-toolchain" },

bloqade_circuit-0.4.1/test/qasm2/test_lowering.py

@@ -1,79 +0,0 @@
-import pathlib
-import tempfile
-import textwrap
-
-from kirin import ir, types
-from kirin.dialects import func
-
-from bloqade import qasm2
-from bloqade.qasm2.parse.lowering import QASM2
-
-lines = textwrap.dedent(
-    """
-OPENQASM 2.0;
-
-qreg q[2];
-creg c[2];
-
-h q[0];
-CX q[0], q[1];
-barrier q[0], q[1];
-CX q[0], q[1];
-rx(pi/2) q[0];
-"""
-)
-
-
-def test_run_lowering():
-    ast = qasm2.parse.loads(lines)
-    code = QASM2(qasm2.main).run(ast)
-    code.print()
-
-
-def test_loadfile():
-
-    with tempfile.TemporaryDirectory() as tmp_dir:
-        with open(f"{tmp_dir}/test.qasm", "w") as f:
-            f.write(lines)
-
-        file = pathlib.Path(f"{tmp_dir}/test.qasm")
-        qasm2.loadfile(file)
-
-
-def test_negative_lowering():
-
-    mwe = """
-    OPENQASM 2.0;
-    include "qelib1.inc";
-    qreg q[1];
-    rz(-0.2) q[0];
-    """
-
-    entry = qasm2.loads(mwe)
-
-    body = ir.Region(
-        ir.Block(
-            [
-                (size := qasm2.expr.ConstInt(value=1)),
-                (qreg := qasm2.core.QRegNew(n_qubits=size.result)),
-                (phi := qasm2.expr.ConstFloat(value=0.2)),
-                (theta := qasm2.expr.Neg(phi.result)),
-                (idx := qasm2.expr.ConstInt(value=0)),
-                (qubit := qasm2.core.QRegGet(qreg.result, idx.result)),
-                (qasm2.uop.RZ(qubit.result, theta.result)),
-                (none := func.ConstantNone()),
-                (func.Return(none.result)),
-            ]
-        )
-    )
-
-    code = func.Function(
-        sym_name="main",
-        signature=func.Signature((), types.NoneType),
-        body=body,
-    )
-
-    code.print()
-    entry.print()
-
-    assert entry.code.is_structurally_equal(code)