Updating names and minor bug fixes. (#46)

* rename circuit to place

* Fixing issue with interpreter

* updating name for rewrite rule

* renaming modules

* Renaming a rewrite

* testing compiler pipeline with measurement

* fixing demo

* fixing dialect name

Author: weinbe58

demo/ghz_moves_demo.py

@@ -6,7 +6,7 @@
 from bloqade.lanes import visualize
 from bloqade.lanes.arch.gemini import logical
 from bloqade.lanes.heuristics import fixed
-from bloqade.lanes.upstream import CircuitToMove, NativeToCircuit
+from bloqade.lanes.upstream import NativeToPlace, PlaceToMove
 
 
 @squin.kernel(typeinfer=True, fold=True)
@@ -44,8 +44,8 @@ def compile_and_visualize(mt: ir.Method, interactive=True):
     # Compile to move dialect
 
     mt = SquinToNative().emit(mt)
-    mt = NativeToCircuit().emit(mt)
-    mt = CircuitToMove(
+    mt = NativeToPlace().emit(mt)
+    mt = PlaceToMove(
         fixed.LogicalLayoutHeuristic(),
         fixed.LogicalPlacementStrategy(),
         fixed.LogicalMoveScheduler(),

demo/pipeline_demo.py

@@ -1,46 +1,38 @@
+from bloqade.gemini.dialects import logical as gemini_logical
 from bloqade.native.upstream import SquinToNative
-from kirin.dialects import ilist
 
 from bloqade import qubit, squin
-from bloqade.lanes.arch.gemini.logical import SpecializeGemini
 from bloqade.lanes.heuristics import fixed
-from bloqade.lanes.upstream import CircuitToMove, NativeToCircuit
+from bloqade.lanes.upstream import NativeToPlace, PlaceToMove
 
+kernel = squin.kernel.add(gemini_logical.dialect)
+kernel.run_pass = squin.kernel.run_pass
 
-@squin.kernel(typeinfer=True, fold=True)
-def log_depth_ghz():
+
+@kernel(typeinfer=True, fold=True)
+def ghz_optimal():
     size = 10
-    q0 = qubit.new()
-    squin.h(q0)
-    reg = ilist.IList([q0])
-    for i in range(size):
-        current = len(reg)
-        missing = size - current
-        if missing > current:
-            num_alloc = current
-        else:
-            num_alloc = missing
+    qs = qubit.qalloc(size)
+    squin.h(qs[0])
+    squin.cx(qs[0], qs[1])
+    squin.broadcast.cx(qs[:2], qs[2:4])
+    squin.cx(qs[3], qs[4])
+    squin.broadcast.cx(qs[:5], qs[5:])
 
-        if num_alloc > 0:
-            new_qubits = qubit.qalloc(num_alloc)
-            squin.broadcast.cx(reg[-num_alloc:], new_qubits)
-            reg = reg + new_qubits
+    return gemini_logical.terminal_measure(qs)
 
 
-log_depth_ghz.print()
+ghz_optimal.print()
 
-log_depth_ghz = SquinToNative().emit(log_depth_ghz)
-log_depth_ghz.print()
+ghz_optimal = SquinToNative().emit(ghz_optimal)
+ghz_optimal.print()
 
-log_depth_ghz = NativeToCircuit().emit(log_depth_ghz)
-log_depth_ghz.print()
+ghz_optimal = NativeToPlace().emit(ghz_optimal)
+ghz_optimal.print()
 
-log_depth_ghz = CircuitToMove(
+ghz_optimal = PlaceToMove(
     fixed.LogicalLayoutHeuristic(),
     fixed.LogicalPlacementStrategy(),
     fixed.LogicalMoveScheduler(),
-).emit(log_depth_ghz)
-log_depth_ghz.print()
-
-out = SpecializeGemini().emit(log_depth_ghz)
-out.print()
+).emit(ghz_optimal)
+ghz_optimal.print()

src/bloqade/lanes/analysis/placement/analysis.py

@@ -40,6 +40,13 @@ def sq_placements(
     ) -> AtomState:
         pass
 
+    def measure_placements(
+        self,
+        state: AtomState,
+        qubits: tuple[int, ...],
+    ) -> AtomState:
+        return state
+
 
 @dataclass
 class PlacementAnalysis(Forward[AtomState]):

src/bloqade/lanes/dialects/circuit.py src/bloqade/lanes/dialects/place.pysrc/bloqade/lanes/dialects/circuit.py renamed to src/bloqade/lanes/dialects/place.py

@@ -10,7 +10,7 @@
 from bloqade.lanes.analysis.placement import AtomState, ConcreteState, PlacementAnalysis
 from bloqade.lanes.types import StateType
 
-dialect = ir.Dialect(name="lanes.circuit")
+dialect = ir.Dialect(name="lanes.place")
 
 
 @statement(init=False)
@@ -96,13 +96,13 @@ def __init__(self, final_state: ir.SSAValue, *classical_results: ir.SSAValue):
 
 
 @statement(dialect=dialect)
-class StaticCircuit(ir.Statement):
+class StaticPlacement(ir.Statement):
     """This statement represents A static circuit to be executed on the hardware.
 
     The body region contains the low-level instructions to be executed.
     The inputs are the squin qubits to be used in the execution.
 
-    The region always terminates with an ExitRegion statement, which provides the
+    The region always terminates with an Yield statement, which provides the
     the measurement results for the qubits depending on which low-level code was executed.
     """
 
@@ -176,26 +176,43 @@ def impl_single_qubit_gate(
     def impl_yield(
         self, _interp: PlacementAnalysis, frame: ForwardFrame[AtomState], stmt: Yield
     ):
-        return interp.YieldValue((frame.get(stmt.final_state),))
+        return interp.YieldValue(frame.get_values(stmt.args))
 
-    @interp.impl(StaticCircuit)
+    @interp.impl(StaticPlacement)
     def impl_static_circuit(
         self,
         _interp: PlacementAnalysis,
         frame: ForwardFrame[AtomState],
-        stmt: StaticCircuit,
+        stmt: StaticPlacement,
     ):
         initial_state = _interp.get_inintial_state(stmt.qubits)
 
-        final_state = _interp.frame_call_region(frame, stmt, stmt.body, initial_state)
+        frame_call_result = _interp.frame_call_region(
+            frame, stmt, stmt.body, initial_state
+        )
 
-        ret = (AtomState.bottom(),) * len(stmt.results)
+        match frame_call_result:
+            case (ConcreteState() as final_state, *ret):
+                for qid, qubit in enumerate(stmt.qubits):
+                    _interp.move_count[qubit] += final_state.move_count[qid]
 
-        if isinstance(final_state, ConcreteState):
-            for qid, qubit in enumerate(stmt.qubits):
-                _interp.move_count[qubit] += final_state.move_count[qid]
+                return tuple(ret)
+            case _:
+                raise interp.InterpreterError(
+                    "StaticPlacement body did not return a ConcreteState"
+                )
 
-        return ret
+    @interp.impl(EndMeasure)
+    def end_measure(
+        self,
+        _interp: PlacementAnalysis,
+        frame: ForwardFrame[AtomState],
+        stmt: EndMeasure,
+    ):
+        new_state = _interp.placement_strategy.measure_placements(
+            frame.get(stmt.state_before), stmt.qubits
+        )
+        return (new_state,) + (EmptyLattice.bottom(),) * len(stmt.qubits)
 
 
 @dialect.register(key="circuit.layout")
@@ -212,12 +229,12 @@ def cz(
 
         return ()
 
-    @interp.impl(StaticCircuit)
+    @interp.impl(StaticPlacement)
     def static_circuit(
         self,
         _interp: LayoutAnalysis,
         frame: ForwardFrame[EmptyLattice],
-        stmt: StaticCircuit,
+        stmt: StaticPlacement,
     ):
         initial_addresses = tuple(
             _interp.address_entries[qubit] for qubit in stmt.qubits

src/bloqade/lanes/heuristics/fixed.py

@@ -15,7 +15,7 @@
     SiteLaneAddress,
     WordLaneAddress,
 )
-from bloqade.lanes.rewrite.circuit2move import MoveSchedulerABC
+from bloqade.lanes.rewrite.place2move import MoveSchedulerABC
 
 
 @dataclass

…/bloqade/lanes/rewrite/native2circuit.py src/bloqade/lanes/rewrite/native2place.pysrc/bloqade/lanes/rewrite/native2circuit.py renamed to src/bloqade/lanes/rewrite/native2place.py src/bloqade/lanes/rewrite/native2circuit.py renamed to src/bloqade/lanes/rewrite/native2place.py

@@ -7,14 +7,14 @@
 from kirin.dialects import ilist
 from kirin.rewrite import abc
 
-from bloqade.lanes.dialects import circuit
+from bloqade.lanes.dialects import place
 from bloqade.lanes.types import StateType
 
 
 @dataclass
-class RewriteLowLevelCircuit(abc.RewriteRule):
+class RewritePlaceOperations(abc.RewriteRule):
     """
-    Rewrite rule to convert native operations to placement operations.
+    Rewrite rule to convert native operations to place operations.
     This is a placeholder for the actual implementation.
     """
 
@@ -33,18 +33,18 @@ def prep_region(self) -> tuple[ir.Region, ir.Block, ir.SSAValue]:
 
     def construct_execute(
         self,
-        quantum_stmt: circuit.QuantumStmt,
+        quantum_stmt: place.QuantumStmt,
         *,
         qubits: tuple[ir.SSAValue, ...],
         body: ir.Region,
         block: ir.Block,
-    ) -> circuit.StaticCircuit:
+    ) -> place.StaticPlacement:
         block.stmts.append(quantum_stmt)
         block.stmts.append(
-            circuit.Yield(quantum_stmt.state_after, *quantum_stmt.results[1:])
+            place.Yield(quantum_stmt.state_after, *quantum_stmt.results[1:])
         )
 
-        return circuit.StaticCircuit(qubits=qubits, body=body)
+        return place.StaticPlacement(qubits=qubits, body=body)
 
     def rewrite_TerminalLogicalMeasurement(
         self, node: gemini_stmts.TerminalLogicalMeasurement
@@ -54,7 +54,7 @@ def rewrite_TerminalLogicalMeasurement(
 
         inputs = args_list.values
         body, block, entry_state = self.prep_region()
-        gate_stmt = circuit.EndMeasure(
+        gate_stmt = place.EndMeasure(
             entry_state,
             qubits=tuple(range(len(inputs))),
         )
@@ -63,7 +63,7 @@ def rewrite_TerminalLogicalMeasurement(
         )
         new_node.insert_before(node)
         node.replace_by(
-            circuit.ConvertToPhysicalMeasurements(
+            place.ConvertToPhysicalMeasurements(
                 tuple(new_node.results),
             )
         )
@@ -85,7 +85,7 @@ def rewrite_CZ(self, node: gate.CZ) -> abc.RewriteResult:
         n_controls = len(controls)
 
         body, block, entry_state = self.prep_region()
-        stmt = circuit.CZ(
+        stmt = place.CZ(
             entry_state,
             controls=all_qubits[:n_controls],
             targets=all_qubits[n_controls:],
@@ -106,7 +106,7 @@ def rewrite_R(self, node: gate.R) -> abc.RewriteResult:
         inputs = args_list.values
 
         body, block, entry_state = self.prep_region()
-        gate_stmt = circuit.R(
+        gate_stmt = place.R(
             entry_state,
             qubits=tuple(range(len(inputs))),
             axis_angle=node.axis_angle,
@@ -127,7 +127,7 @@ def rewrite_Rz(self, node: gate.Rz) -> abc.RewriteResult:
         body = ir.Region(block := ir.Block())
         entry_state = block.args.append_from(StateType, name="entry_state")
 
-        gate_stmt = circuit.Rz(
+        gate_stmt = place.Rz(
             entry_state,
             qubits=tuple(range(len(inputs))),
             rotation_angle=node.rotation_angle,
@@ -158,11 +158,11 @@ class MergePlacementRegions(abc.RewriteRule):
     def remap_qubits(
         self,
         curr_state: ir.SSAValue,
-        node: circuit.R | circuit.Rz | circuit.CZ | circuit.EndMeasure,
+        node: place.R | place.Rz | place.CZ | place.EndMeasure,
         input_map: dict[int, int],
     ):
-        if isinstance(node, circuit.CZ):
-            return circuit.CZ(
+        if isinstance(node, place.CZ):
+            return place.CZ(
                 curr_state,
                 targets=tuple(input_map[i] for i in node.targets),
                 controls=tuple(input_map[i] for i in node.controls),
@@ -178,8 +178,8 @@ def remap_qubits(
 
     def rewrite_Statement(self, node: ir.Statement) -> abc.RewriteResult:
         if not (
-            isinstance(node, circuit.StaticCircuit)
-            and isinstance(next_node := node.next_stmt, circuit.StaticCircuit)
+            isinstance(node, place.StaticPlacement)
+            and isinstance(next_node := node.next_stmt, place.StaticPlacement)
         ):
             return abc.RewriteResult()
 
@@ -199,16 +199,14 @@ def rewrite_Statement(self, node: ir.Statement) -> abc.RewriteResult:
         new_block = new_body.blocks[0]
 
         curr_yield = new_block.last_stmt
-        assert isinstance(curr_yield, circuit.Yield)
+        assert isinstance(curr_yield, place.Yield)
 
         curr_state = curr_yield.final_state
         current_yields = list(curr_yield.classical_results)
         curr_yield.delete()
 
         for stmt in next_node.body.blocks[0].stmts:
-            if isinstance(
-                stmt, (circuit.R, circuit.Rz, circuit.CZ, circuit.EndMeasure)
-            ):
+            if isinstance(stmt, (place.R, place.Rz, place.CZ, place.EndMeasure)):
                 remapped_stmt = self.remap_qubits(curr_state, stmt, new_input_map)
                 curr_state = remapped_stmt.results[0]
                 new_block.stmts.append(remapped_stmt)
@@ -218,14 +216,14 @@ def rewrite_Statement(self, node: ir.Statement) -> abc.RewriteResult:
                     old_result.replace_by(new_result)
                     current_yields.append(new_result)
 
-        new_yield = circuit.Yield(
+        new_yield = place.Yield(
             curr_state,
             *current_yields,
         )
         new_block.stmts.append(new_yield)
 
         # create the new static circuit
-        new_static_circuit = circuit.StaticCircuit(
+        new_static_circuit = place.StaticPlacement(
             new_qubits,
             new_body,
         )