feature: Add delay and barrier for circuits

src/braket/circuits/gates.py

@@ -3847,6 +3847,77 @@ def pulse_gate(
 Gate.register_gate(PulseGate)
 
 
+class Barrier(Gate):
+    r"""Barrier gate."""
+
+    def __init__(self, qubit_count):
+        super().__init__(qubit_count=qubit_count, ascii_symbols=["||" for i in range(qubit_count)])
+
+    def bind_values(self, **kwargs) -> Any:
+        raise NotImplementedError
+
+    @property
+    def _qasm_name(self) -> str:
+        return "barrier"
+
+    def __hash__(self):
+        return hash((self.name, self.qubit_count))
+
+    @staticmethod
+    @circuit.subroutine(register=True)
+    def barrier(targets: QubitSetInput) -> Instruction:
+        r"""Barrier gate.
+
+        Args:
+            targets (QubitSetInput): Target qubit(s)
+
+        Examples:
+            >>> circ = Circuit().barrier(targets=[0, 1, 2])
+        """
+        return Instruction(Barrier(len(targets)), target=targets)
+
+
+Gate.register_gate(Barrier)
+
+
+class Delay(Gate):
+    r"""Delay gate. Applies delay in seconds."""
+
+    def __init__(self, qubit_count, duration):
+        super().__init__(
+            qubit_count=qubit_count,
+            ascii_symbols=[f"delay({duration})" for i in range(qubit_count)],
+        )
+        self.duration = duration
+
+    def bind_values(self, **kwargs) -> Any:
+        raise NotImplementedError
+
+    @property
+    def _qasm_name(self) -> str:
+        return f"delay[{self.duration}s]"
+
+    def __hash__(self):
+        return hash((self.name, self.qubit_count, self.duration))
+
+    @staticmethod
+    @circuit.subroutine(register=True)
+    def delay(targets: QubitSetInput, duration: float) -> Instruction:
+        r"""Delay gate. Applies delay in seconds.
+
+        Args:
+            targets (QubitSetInput): Target qubit(s)
+            duration (float): Delay (in seconds).
+
+        Examples:
+            >>> circ = Circuit().delay(targets=[0, 1, 2], duration=30e-9)
+        """
+        return Instruction(Delay(len(targets), duration), target=targets)
+
+
+Gate.register_gate(Delay)
+
+
 def format_complex(number: complex) -> str:
     """Format a complex number into <a> + <b>im to be consumed by the braket unitary pragma
 

test/unit_tests/braket/circuits/test_gates.py

@@ -15,6 +15,7 @@
 
 import numpy as np
 import pytest
+from pydantic.v1 import BaseModel, confloat
 
 import braket.ir.jaqcd as ir
 from braket.circuits import Circuit, FreeParameter, Gate, Instruction, QubitSet
@@ -39,6 +40,14 @@ class NoTarget:
     pass
 
 
+class Duration(BaseModel):
+    duration: confloat(ge=0)
+
+
+class NoMatrixGeneration:
+    pass
+
+
 class DoubleAngle:
     pass
 
@@ -68,6 +77,8 @@ class SingleNegControlModifier:
     (Gate.Ry, "ry", ir.Ry, [SingleTarget, Angle], {}),
     (Gate.Rz, "rz", ir.Rz, [SingleTarget, Angle], {}),
     (Gate.U, "u", None, [SingleTarget, TripleAngle], {}),
+    (Gate.Barrier, "barrier", None, [MultiTarget, NoMatrixGeneration], {}),
+    (Gate.Delay, "delay", None, [MultiTarget, Duration, NoMatrixGeneration], {}),
     (Gate.CNot, "cnot", ir.CNot, [SingleTarget, SingleControl], {}),
     (Gate.CV, "cv", ir.CV, [SingleTarget, SingleControl], {}),
     (Gate.CCNot, "ccnot", ir.CCNot, [SingleTarget, DoubleControl], {}),
@@ -170,6 +181,15 @@ def no_target_valid_input(**kwargs):
     return {}
 
 
+def no_matrix_valid_input(**kwargs):
+    qubit_count = 1
+
+    if kwargs.get("target", None) is not None:
+        qubit_count = len(kwargs.get("target"))
+
+    return {"qubit_count": qubit_count}
+
+
 def single_target_valid_input(**kwargs):
     return {"target": 2}
 
@@ -194,6 +214,10 @@ def triple_angle_valid_input(**kwargs):
     return {"angle_1": 0.123, "angle_2": 4.567, "angle_3": 8.910}
 
 
+def duration_valid_input(**kwargs):
+    return {"duration": 30.0}
+
+
 def single_control_valid_input(**kwargs):
     return {"control": 0}
 
@@ -225,6 +249,7 @@ def two_dimensional_matrix_valid_input(**kwargs):
 
 valid_ir_switcher = {
     "NoTarget": no_target_valid_input,
+    "NoMatrix": no_target_valid_input,
     "SingleTarget": single_target_valid_input,
     "DoubleTarget": double_target_valid_ir_input,
     "Angle": angle_valid_input,
@@ -235,6 +260,7 @@ def two_dimensional_matrix_valid_input(**kwargs):
     "DoubleControl": double_control_valid_ir_input,
     "MultiTarget": multi_target_valid_input,
     "TwoDimensionalMatrix": two_dimensional_matrix_valid_ir_input,
+    "Duration": duration_valid_input,
 }
 
 valid_subroutine_switcher = dict(
@@ -284,7 +310,14 @@ def create_valid_target_input(irsubclasses):
             control_state = list(single_neg_control_valid_input()["control_state"])
         elif subclass == DoubleControl:
             qubit_set = list(double_control_valid_ir_input().values()) + qubit_set
-        elif subclass not in (Angle, TwoDimensionalMatrix, DoubleAngle, TripleAngle):
+        elif subclass not in (
+            Angle,
+            Duration,
+            NoMatrixGeneration,
+            TwoDimensionalMatrix,
+            DoubleAngle,
+            TripleAngle,
+        ):
             raise ValueError("Invalid subclass")
     input = {"target": QubitSet(qubit_set)}
     input["control"] = QubitSet(control_qubit_set)
@@ -302,6 +335,10 @@ def create_valid_gate_class_input(irsubclasses, **kwargs):
         input.update(triple_angle_valid_input())
     if TwoDimensionalMatrix in irsubclasses:
         input.update(two_dimensional_matrix_valid_input(**kwargs))
+    if NoMatrixGeneration in irsubclasses:
+        input.update(no_matrix_valid_input(**kwargs))
+    if Duration in irsubclasses:
+        input.update(duration_valid_input(**kwargs))
     return input
 
 
@@ -326,12 +363,14 @@ def calculate_qubit_count(irsubclasses):
             qubit_count += 3
         elif subclass not in (
             NoTarget,
+            NoMatrixGeneration,
             Angle,
+            Duration,
             TwoDimensionalMatrix,
             DoubleAngle,
             TripleAngle,
         ):
-            raise ValueError("Invalid subclass")
+            raise ValueError(f"Invalid subclass: {subclass}")
     return qubit_count
 
 
@@ -408,6 +447,30 @@ def test_ir_gate_level(testclass, subroutine_name, irclass, irsubclasses, kwargs
             OpenQASMSerializationProperties(qubit_reference_type=QubitReferenceType.PHYSICAL),
             "h $4;",
         ),
+        (
+            Gate.Barrier(3),
+            [3, 4, 5],
+            OpenQASMSerializationProperties(qubit_reference_type=QubitReferenceType.VIRTUAL),
+            "barrier q[3], q[4], q[5];",
+        ),
+        (
+            Gate.Barrier(3),
+            [3, 4, 5],
+            OpenQASMSerializationProperties(qubit_reference_type=QubitReferenceType.PHYSICAL),
+            "barrier $3, $4, $5;",
+        ),
+        (
+            Gate.Delay(qubit_count=3, duration=30),
+            [3, 4, 5],
+            OpenQASMSerializationProperties(qubit_reference_type=QubitReferenceType.VIRTUAL),
+            "delay[30 s] q[3], q[4], q[5];",
+        ),
+        (
+            Gate.Delay(qubit_count=3, duration=30),
+            [3, 4, 5],
+            OpenQASMSerializationProperties(qubit_reference_type=QubitReferenceType.PHYSICAL),
+            "delay[30 s] $3, $4, $5;",
+        ),
         (
             Gate.Ry(angle=0.17),
             [4],
@@ -889,12 +952,10 @@ def test_ir_gate_level(testclass, subroutine_name, irclass, irsubclasses, kwargs
     ],
 )
 def test_gate_to_ir_openqasm(gate, target, serialization_properties, expected_ir):
-    assert (
-        gate.to_ir(
-            target, ir_type=IRType.OPENQASM, serialization_properties=serialization_properties
-        )
-        == expected_ir
+    actual_ir = gate.to_ir(
+        target, ir_type=IRType.OPENQASM, serialization_properties=serialization_properties
     )
+    assert actual_ir == expected_ir
 
 
 @pytest.mark.parametrize("testclass,subroutine_name,irclass,irsubclasses,kwargs", testdata)
@@ -979,19 +1040,21 @@ def test_angle_gphase_is_none():
 
 @pytest.mark.parametrize("testclass,subroutine_name,irclass,irsubclasses,kwargs", testdata)
 def test_gate_adjoint_expansion_correct(testclass, subroutine_name, irclass, irsubclasses, kwargs):
-    gate = testclass(**create_valid_gate_class_input(irsubclasses, **kwargs))
-    matrices = [elem.to_matrix() for elem in gate.adjoint()]
-    matrices.append(gate.to_matrix())
-    identity = np.eye(2**gate.qubit_count)
-    assert np.allclose(functools.reduce(lambda a, b: a @ b, matrices), identity)
+    if NoMatrixGeneration not in irsubclasses:
+        gate = testclass(**create_valid_gate_class_input(irsubclasses, **kwargs))
+        matrices = [elem.to_matrix() for elem in gate.adjoint()]
+        matrices.append(gate.to_matrix())
+        identity = np.eye(2**gate.qubit_count)
+        assert np.allclose(functools.reduce(lambda a, b: a @ b, matrices), identity)
 
 
 @pytest.mark.parametrize("testclass,subroutine_name,irclass,irsubclasses,kwargs", testdata)
 def test_gate_to_matrix(testclass, subroutine_name, irclass, irsubclasses, kwargs):
-    gate1 = testclass(**create_valid_gate_class_input(irsubclasses, **kwargs))
-    gate2 = testclass(**create_valid_gate_class_input(irsubclasses, **kwargs))
-    assert isinstance(gate1.to_matrix(), np.ndarray)
-    assert gate1.matrix_equivalence(gate2)
+    if NoMatrixGeneration not in irsubclasses:
+        gate1 = testclass(**create_valid_gate_class_input(irsubclasses, **kwargs))
+        gate2 = testclass(**create_valid_gate_class_input(irsubclasses, **kwargs))
+        assert isinstance(gate1.to_matrix(), np.ndarray)
+        assert gate1.matrix_equivalence(gate2)
 
 
 @pytest.mark.parametrize("testclass,subroutine_name,irclass,irsubclasses,kwargs", testdata)
@@ -1042,6 +1105,7 @@ def test_large_unitary():
 def test_bind_values(gate):
     double_angled = gate.__name__ in ["PRx"]
     triple_angled = gate.__name__ in ("MS", "U")
+    duration = gate.__name__ in ("Delay")
     num_params = 1
     if triple_angled:
         num_params = 3
@@ -1060,6 +1124,8 @@ def test_bind_values(gate):
     elif double_angled:
         for angle in new_gate.angle_1, new_gate.angle_2:
             assert isinstance(angle, float)
+    elif duration:
+        assert isinstance(new_gate.duration, float)
     else:
         assert isinstance(new_gate.angle, float)