Merge pull request #212 from peachnuts/add_reset

Add reset

Author: edyounis

bqskit/ir/gates/__init__.py

@@ -112,6 +112,7 @@
 
     CircuitGate
     MeasurementPlaceholder
+    Reset
     BarrierPlaceholder
 
 .. rubric:: Gate Base Classes
@@ -146,11 +147,15 @@
 from bqskit.ir.gates.qubitgate import QubitGate
 from bqskit.ir.gates.quditgate import QuditGate
 from bqskit.ir.gates.qutritgate import QutritGate
+from bqskit.ir.gates.reset import Reset
 
 __all__ = composed_all + constant_all + parameterized_all
 __all__ += ['ComposedGate', 'ConstantGate']
 __all__ += ['QubitGate', 'QutritGate', 'QuditGate']
-__all__ += ['CircuitGate', 'MeasurementPlaceholder', 'BarrierPlaceholder']
+__all__ += [
+    'CircuitGate', 'MeasurementPlaceholder',
+    'Reset', 'BarrierPlaceholder',
+]
 __all__ += ['GeneralGate']
 
 # TODO: Implement the rest of the gates in:

bqskit/ir/gates/reset.py

@@ -0,0 +1,25 @@
+"""This module implements the Reset class."""
+from __future__ import annotations
+
+from bqskit.ir.gates.constantgate import ConstantGate
+from bqskit.qis.unitary.unitary import RealVector
+from bqskit.qis.unitary.unitarymatrix import UnitaryMatrix
+
+
+class Reset(ConstantGate):
+    """Pseudogate to reset/initialize the qudit to |0>."""
+
+    def __init__(self, radix: int = 2) -> None:
+        """
+        Construct a Reset.
+
+        Args:
+            radix (int): the dimension of the qudit. (Default: 2)
+        """
+        self._num_qudits = 1
+        self._qasm_name = 'reset'
+        self._radixes = tuple([radix])
+        self._num_params = 0
+
+    def get_unitary(self, params: RealVector = []) -> UnitaryMatrix:
+        raise RuntimeError('Cannot compute unitary for a reset.')

bqskit/ir/lang/qasm2/visitor.py

@@ -68,6 +68,7 @@
 from bqskit.ir.gates.parameterized.u1q import U1qGate
 from bqskit.ir.gates.parameterized.u2 import U2Gate
 from bqskit.ir.gates.parameterized.u3 import U3Gate
+from bqskit.ir.gates.reset import Reset
 from bqskit.ir.lang.language import LangException
 from bqskit.ir.lang.qasm2.parser import parse
 from bqskit.ir.location import CircuitLocation
@@ -169,7 +170,6 @@ def __init__(self) -> None:
         self.classical_regs: list[ClassicalReg] = []
         self.gate_def_parsing_obj: Any = None
         self.custom_gate_defs: dict[str, CustomGateDef] = {}
-        self.measurements: dict[int, tuple[str, int]] = {}
         self.fill_gate_defs()
 
     def get_circuit(self) -> Circuit:
@@ -180,12 +180,6 @@ def get_circuit(self) -> Circuit:
         circuit = Circuit(num_qubits)
         circuit.extend(self.op_list)
 
-        # Add measurements
-        if len(self.measurements) > 0:
-            cregs = cast(List[Tuple[str, int]], self.classical_regs)
-            mph = MeasurementPlaceholder(cregs, self.measurements)
-            circuit.append_gate(mph, list(self.measurements.keys()))
-
         return circuit
 
     def fill_gate_defs(self) -> None:
@@ -297,13 +291,6 @@ def gate(self, tree: lark.Tree) -> None:
         qlist = tree.children[-1]
         location = CircuitLocation(self.convert_qubit_ids_to_indices(qlist))
 
-        if any(q in self.measurements for q in location):
-            raise LangException(
-                'BQSKit currently does not support mid-circuit measurements.'
-                ' Unable to apply a gate on the same qubit where a measurement'
-                ' has been previously made.',
-            )
-
         # Parse gate object
         gate_name = str(tree.children[0])
         if gate_name in self.gate_defs:
@@ -591,10 +578,16 @@ def creg(self, tree: lark.Tree) -> None:
 
     def measure(self, tree: lark.Tree) -> None:
         """Measure statement node visitor."""
+        params: list[float] = []
+        measurements: dict[int, tuple[str, int]] = {}
         qubit_childs = tree.children[0].children
         class_childs = tree.children[1].children
         qubit_reg_name = str(qubit_childs[0])
         class_reg_name = str(class_childs[0])
+        cregs = cast(List[Tuple[str, int]], self.classical_regs)
+        qlist = tree.children[0]
+        location = CircuitLocation(self.convert_qubit_ids_to_indices(qlist))
+
         if not any(r.name == qubit_reg_name for r in self.qubit_regs):
             raise LangException(
                 f'Measuring undefined qubit register: {qubit_reg_name}',
@@ -605,7 +598,7 @@ def measure(self, tree: lark.Tree) -> None:
                 f'Measuring undefined classical register: {class_reg_name}',
             )
 
-        if len(qubit_childs) == 1 and len(class_childs) == 1:
+        if len(qubit_childs) == 1 and len(class_childs) == 1:  # for measure all
             for name, size in self.qubit_regs:
                 if qubit_reg_name == name:
                     qubit_size = size
@@ -625,34 +618,42 @@ def measure(self, tree: lark.Tree) -> None:
                 if name == qubit_reg_name:
                     break
                 outer_idx += size
-
             for i in range(qubit_size):
-                self.measurements[outer_idx + i] = (class_reg_name, i)
+                measurements[outer_idx + i] = (class_reg_name, i)
+            mph = MeasurementPlaceholder(cregs, measurements)
 
         elif len(qubit_childs) == 2 and len(class_childs) == 2:
+            # measure qubits to clbits
             qubit_index = int(qubit_childs[1])
             class_index = int(class_childs[1])
-
-            # Convert qubit_index to global index
-            outer_idx = 0
-            for name, size in self.qubit_regs:
-                if name == qubit_reg_name:
-                    qubit_index = outer_idx + qubit_index
-                    break
-                outer_idx += size
-
-            self.measurements[qubit_index] = (class_reg_name, class_index)
+            measurements[qubit_index] = (class_reg_name, class_index)
+            mph = MeasurementPlaceholder(cregs, measurements)
 
         else:
             raise LangException(
                 'Invalid measurement: either a single qubit is being measured '
                 'to a full classical register or a qubit register is being '
                 'measured to a single classical bit.',
             )
+        op = Operation(mph, location, params)
+        self.op_list.append(op)
 
     def reset(self, tree: lark.Tree) -> None:
-        """Reset statement node visitor."""
-        raise LangException('BQSKit currently does not support resets.')
+        """Reset node visitor."""
+        params: list[float] = []
+        qlist = tree.children[-1]
+        if len(qlist.children) == 2:
+            location = CircuitLocation(self.convert_qubit_ids_to_indices(qlist))
+            op = Operation(Reset(), location, params)
+            self.op_list.append(op)
+        else:
+            locations = [
+                CircuitLocation(i)
+                for i in range(self.qubit_regs[0][1])
+            ]
+            for location in locations:
+                op = Operation(Reset(), location, params)
+                self.op_list.append(op)
 
     def convert_qubit_ids_to_indices(self, qlist: lark.Tree) -> list[int]:
         if qlist.data == 'anylist':

bqskit/passes/partitioning/quick.py

@@ -8,6 +8,8 @@
 from bqskit.compiler.basepass import BasePass
 from bqskit.compiler.passdata import PassData
 from bqskit.ir.circuit import Circuit
+from bqskit.ir.gates import MeasurementPlaceholder
+from bqskit.ir.gates import Reset
 from bqskit.ir.gates.barrier import BarrierPlaceholder
 from bqskit.ir.gates.circuitgate import CircuitGate
 from bqskit.ir.location import CircuitLocation
@@ -117,8 +119,15 @@ def process_pending_bins() -> None:
                             merging = False
                             for p in partitioned_circuit.rear:
                                 op = partitioned_circuit[p]
-                                if isinstance(op.gate, BarrierPlaceholder):
-                                    # Don't merge through barriers
+                                if isinstance(
+                                    op.gate, (
+                                        BarrierPlaceholder,
+                                        MeasurementPlaceholder,
+                                        Reset,
+                                    ),
+                                ):
+                                    # Don't merge through barriers,
+                                    # measurement, or reset
                                     continue
                                 qudits = list(op.location)
 
@@ -179,7 +188,13 @@ def process_pending_bins() -> None:
             })
 
             # Barriers close all overlapping bins
-            if isinstance(op.gate, BarrierPlaceholder):
+            if isinstance(
+                op.gate, (
+                    BarrierPlaceholder,
+                    MeasurementPlaceholder,
+                    Reset,
+                ),
+            ):
                 for bin in overlapping_bins:
                     if close_bin_qudits(bin, location, cycle):
                         num_closed += 1
@@ -349,7 +364,11 @@ def can_accommodate(self, loc: CircuitLocation, block_size: int) -> bool:
 
 
 class BarrierBin(Bin):
-    """A special bin made to mark and preserve barrier location."""
+    """
+    A special bin made to mark and preserve barrier location.
+
+    For simplicity, the rest and measurement are treated as barrier as well.
+    """
 
     def __init__(
         self,

bqskit/passes/partitioning/single.py

@@ -4,6 +4,8 @@
 from bqskit.compiler.basepass import BasePass
 from bqskit.compiler.passdata import PassData
 from bqskit.ir.circuit import Circuit
+from bqskit.ir.gates import MeasurementPlaceholder
+from bqskit.ir.gates import Reset
 from bqskit.ir.gates.barrier import BarrierPlaceholder
 from bqskit.ir.region import CircuitRegion
 
@@ -31,7 +33,13 @@ async def run(self, circuit: Circuit, data: PassData) -> None:
                 op = circuit[c, q]
                 if (
                     op.num_qudits == 1
-                    and not isinstance(op.gate, BarrierPlaceholder)
+                    and not isinstance(
+                        op.gate, (
+                            BarrierPlaceholder,
+                            MeasurementPlaceholder,
+                            Reset,
+                        ),
+                    )
                 ):
                     if region_start is None:
                         region_start = c

tests/ir/lang/test_qasm_decode.py

@@ -15,6 +15,7 @@
 from bqskit.ir.gates.parameterized.u1q import U1qGate
 from bqskit.ir.gates.parameterized.u2 import U2Gate
 from bqskit.ir.gates.parameterized.u3 import U3Gate
+from bqskit.ir.gates.reset import Reset
 from bqskit.ir.lang.language import LangException
 from bqskit.ir.lang.qasm2 import OPENQASM2Language
 from bqskit.qis.unitary.unitarymatrix import UnitaryMatrix
@@ -296,6 +297,43 @@ def test_include_simple(self) -> None:
         assert circuit.get_unitary().get_distance_from(gate_unitary) < 1e-7
 
 
+class TestReset:
+    def test_reset_single_qubit(self) -> None:
+        input = """
+            OPENQASM 2.0;
+            qreg q[1];
+            reset q[0];
+        """
+        circuit = OPENQASM2Language().decode(input)
+        expected = Reset()
+        assert circuit[0, 0].gate == expected
+
+    def test_reset_register(self) -> None:
+        input = """
+            OPENQASM 2.0;
+            qreg q[2];
+            reset q;
+        """
+        circuit = OPENQASM2Language().decode(input)
+        expected = Reset()
+        assert circuit[0, 0].gate == expected
+        assert circuit[0, 1].gate == expected
+
+    def test_mid_reset(self) -> None:
+        input = """
+            OPENQASM 2.0;
+            qreg q[1];
+            u1(0.1) q[0];
+            reset q[0];
+            u1(0.1) q[0];
+        """
+        circuit = OPENQASM2Language().decode(input)
+        reset = Reset()
+        assert circuit[0, 0].gate == U1Gate()
+        assert circuit[1, 0].gate == reset
+        assert circuit[2, 0].gate == U1Gate()
+
+
 class TestMeasure:
     def test_measure_single_bit(self) -> None:
         input = """
@@ -308,6 +346,54 @@ def test_measure_single_bit(self) -> None:
         expected = MeasurementPlaceholder([('c', 1)], {0: ('c', 0)})
         assert circuit[0, 0].gate == expected
 
+    def test_mid_measure_single_bit(self) -> None:
+        input = """
+            OPENQASM 2.0;
+            qreg q[1];
+            creg c[1];
+            u1(0.1) q[0];
+            measure q[0] -> c[0];
+            u1(0.1) q[0];
+        """
+        circuit = OPENQASM2Language().decode(input)
+        measurements = {0: ('c', 0)}
+        measure = MeasurementPlaceholder([('c', 1)], measurements)
+        assert circuit[0, 0].gate == U1Gate()
+        assert circuit[1, 0].gate == measure
+        assert circuit[2, 0].gate == U1Gate()
+
+    def test_mid_measure_register_1(self) -> None:
+        input = """
+            OPENQASM 2.0;
+            qreg q[1];
+            creg c[1];
+            u1(0.1) q[0];
+            measure q -> c;
+            u1(0.1) q[0];
+        """
+        circuit = OPENQASM2Language().decode(input)
+        measurements = {0: ('c', 0)}
+        measure = MeasurementPlaceholder([('c', 1)], measurements)
+        assert circuit[0, 0].gate == U1Gate()
+        assert circuit[1, 0].gate == measure
+        assert circuit[2, 0].gate == U1Gate()
+
+    def test_mid_measure_register_2(self) -> None:
+        input = """
+            OPENQASM 2.0;
+            qreg q[2];
+            creg c[2];
+            u1(0.1) q[0];
+            measure q -> c;
+            u1(0.1) q[0];
+        """
+        circuit = OPENQASM2Language().decode(input)
+        measurements = {0: ('c', 0), 1: ('c', 1)}
+        measure = MeasurementPlaceholder([('c', 2)], measurements)
+        assert circuit[0, 0].gate == U1Gate()
+        assert circuit[1, 0].gate == measure
+        assert circuit[2, 0].gate == U1Gate()
+
     def test_measure_register_1(self) -> None:
         input = """
             OPENQASM 2.0;

tests/ir/lang/test_qasm_encode.py

@@ -2,6 +2,7 @@
 
 from bqskit.ir.circuit import Circuit
 from bqskit.ir.gates import CNOTGate
+from bqskit.ir.gates import Reset
 from bqskit.ir.gates import U3Gate
 from bqskit.ir.lang.qasm2 import OPENQASM2Language
 
@@ -41,3 +42,16 @@ def test_nested_circuitgate(self) -> None:
         qasm = OPENQASM2Language().encode(circuit)
         parsed_circuit = OPENQASM2Language().decode(qasm)
         assert parsed_circuit.get_unitary().get_distance_from(in_utry) < 1e-7
+
+    def test_reset(self) -> None:
+        circuit = Circuit(1)
+        circuit.append_gate(Reset(), 0)
+
+        qasm = OPENQASM2Language().encode(circuit)
+        expected = (
+            'OPENQASM 2.0;\n'
+            'include "qelib1.inc";\n'
+            'qreg q[1];\n'
+            'reset q[0];\n'
+        )
+        assert qasm == expected