feature: add barrier instruction

src/braket/circuits/circuit.py

@@ -729,6 +729,29 @@ def add_verbatim_box(
             self._has_compiler_directives = True
         return self
 
+    def barrier(self, target: QubitSetInput | None = None) -> Circuit:
+        """Add a barrier compiler directive to the circuit.
+
+        Args:
+            target (QubitSetInput | None): Target qubits for the barrier.
+            If None, applies to all qubits in the circuit.
+
+        Returns:
+            Circuit: self
+
+        Examples:
+            >>> circ = Circuit().h(0).barrier([0, 1]).cnot(0, 1)
+            >>> circ = Circuit().h(0).h(1).barrier()  # barrier on all qubits
+        """
+        target_qubits = self.qubits if target is None else QubitSet(target)
+
+        if target_qubits:
+            self.add_instruction(
+                Instruction(compiler_directives.Barrier(list(target_qubits)), target=target_qubits)
+            )
+            self._has_compiler_directives = True
+        return self
+
     def _add_measure(self, target_qubits: QubitSetInput) -> None:
         """Adds a measure instruction to the the circuit
 

src/braket/circuits/compiler_directives.py

@@ -16,6 +16,8 @@
 import braket.ir.jaqcd as ir
 
 from braket.circuits.compiler_directive import CompilerDirective
+from braket.circuits.serialization import IRType, SerializationProperties
+from braket.registers.qubit_set import QubitSet
 
 
 class StartVerbatimBox(CompilerDirective):
@@ -60,3 +62,39 @@ def _to_jaqcd(self, *args, **kwargs) -> Any:
 
     def _to_openqasm(self) -> str:
         return "}"
+
+
+class Barrier(CompilerDirective):
+    r"""Barrier compiler directive."""
+
+    def __init__(self, qubit_indices: list[int]):
+        super().__init__(["||"])
+        self._qubit_indices = qubit_indices
+
+    @property
+    def qubit_indices(self) -> list[int]:
+        return self._qubit_indices
+
+    @property
+    def qubit_count(self) -> int:
+        return len(self._qubit_indices)
+
+    def _to_jaqcd(self) -> Any:
+        raise NotImplementedError("Barrier is not supported in JAQCD")
+
+    def to_ir(
+        self,
+        target: QubitSet | None,
+        ir_type: IRType,
+        serialization_properties: SerializationProperties | None = None,
+        **kwargs,
+    ) -> Any:
+        if ir_type.name == "OPENQASM":
+            if target:
+                qubits = ", ".join(serialization_properties.format_target(int(q)) for q in target)
+                return f"barrier {qubits};"
+            return "barrier;"
+        return super().to_ir(target, ir_type, serialization_properties, **kwargs)
+
+    def _to_openqasm(self) -> str:
+        return "barrier"

src/braket/circuits/moments.py

@@ -174,8 +174,12 @@ def add(self, instructions: Iterable[Instruction] | Instruction, noise_index: in
     def _add(self, instruction: Instruction, noise_index: int = 0) -> None:
         operator = instruction.operator
         if isinstance(operator, CompilerDirective):
-            time = self._update_qubit_times(self._qubits)
-            self._moments[MomentsKey(time, None, MomentType.COMPILER_DIRECTIVE, 0)] = instruction
+            qubit_range = instruction.target.union(instruction.control or QubitSet())
+            time = self._update_qubit_times(qubit_range or self._qubits)
+            self._moments[MomentsKey(time, qubit_range, MomentType.COMPILER_DIRECTIVE, 0)] = (
+                instruction
+            )
+            self._qubits.update(qubit_range)
             self._depth = time + 1
             self._time_all_qubits = time
         elif isinstance(operator, Noise):

src/braket/circuits/text_diagram_builders/ascii_circuit_diagram.py

@@ -70,6 +70,19 @@ def _duplicate_time_at_bottom(cls, lines: str) -> None:
         # duplicate times after an empty line
         lines.append(lines[0])
 
+    @classmethod
+    def _get_compiler_directive_symbols(
+        cls, item: Instruction, circuit_qubits: QubitSet
+    ) -> list[str]:
+        """Get symbols for compiler directives, handling barriers specially."""
+        if item.operator.name == "Barrier":
+            return item.ascii_symbols
+        ascii_symbol = item.ascii_symbols[0]
+        marker = "*" * len(ascii_symbol)
+        num_after = len(circuit_qubits) - 1
+        after = ["|"] * (num_after - 1) + ([marker] if num_after else [])
+        return [ascii_symbol, *after]
+
     @classmethod
     def _create_diagram_column(
         cls,
@@ -102,11 +115,7 @@ def _create_diagram_column(
                 control_qubits = QubitSet()
                 target_and_control = target_qubits.union(control_qubits)
                 qubits = circuit_qubits
-                ascii_symbol = item.ascii_symbols[0]
-                marker = "*" * len(ascii_symbol)
-                num_after = len(circuit_qubits) - 1
-                after = ["|"] * (num_after - 1) + ([marker] if num_after else [])
-                ascii_symbols = [ascii_symbol, *after]
+                ascii_symbols = cls._get_compiler_directive_symbols(item, circuit_qubits)
             elif (
                 isinstance(item, Instruction)
                 and isinstance(item.operator, Gate)
@@ -135,9 +144,9 @@ def _create_diagram_column(
                 # Determine if the qubit is part of the item or in the middle of a
                 # multi qubit item.
                 if qubit in target_qubits:
-                    item_qubit_index = [  # noqa: RUF015
+                    item_qubit_index = next(
                         index for index, q in enumerate(target_qubits) if q == qubit
-                    ][0]
+                    )
                     power_string = (
                         f"^{power}"
                         if (
@@ -150,10 +159,19 @@ def _create_diagram_column(
                         )
                         else ""
                     )
+                    idx = (
+                        0
+                        if (
+                            isinstance(item, Instruction)
+                            and isinstance(item.operator, CompilerDirective)
+                            and item.operator.name == "Barrier"
+                        )
+                        else item_qubit_index
+                    )
                     symbols[qubit] = (
-                        f"({ascii_symbols[item_qubit_index]}{power_string})"
+                        f"({ascii_symbols[idx]}{power_string})"
                         if power_string
-                        else ascii_symbols[item_qubit_index]
+                        else ascii_symbols[idx]
                     )
                 elif qubit in control_qubits:
                     symbols[qubit] = "C" if map_control_qubit_states[qubit] else "N"

src/braket/circuits/text_diagram_builders/unicode_circuit_diagram.py

@@ -209,12 +209,12 @@ def _draw_symbol(
         """
         top = ""
         bottom = ""
-        if symbol in {"C", "N", "SWAP"}:
+        if symbol in {"C", "N", "SWAP", "||"}:
             if connection in {"above", "both"}:
                 top = _fill_symbol(cls._vertical_delimiter(), " ")
             if connection in {"below", "both"}:
                 bottom = _fill_symbol(cls._vertical_delimiter(), " ")
-            new_symbol = {"C": "●", "N": "◯", "SWAP": "x"}
+            new_symbol = {"C": "●", "N": "◯", "SWAP": "x", "||": "▒"}
             # replace SWAP by x
             # the size of the moment remains as if there was a box with 4 characters inside
             symbol = _fill_symbol(new_symbol[symbol], cls._qubit_line_character())

test/unit_tests/braket/circuits/test_ascii_circuit_diagram.py

@@ -956,3 +956,33 @@ def test_measure_with_readout_noise():
         "T  : |0|    1    |2|",
     )
     _assert_correct_diagram(circ, expected)
+
+
+def test_barrier_circuit_visualization_without_other_gates():
+    circ = Circuit().barrier(target=[0, 100])
+    expected = (
+        "T    : |0 |",
+        "           ",
+        "q0   : -||-",
+        "        |  ",
+        "q100 : -||-",
+        "",
+        "T    : |0 |",
+    )
+    _assert_correct_diagram(circ, expected)
+
+
+def test_barrier_circuit_visualization_with_other_gates():
+    circ = Circuit().x(0).barrier(target=[0, 100]).h(3)
+    expected = (
+        "T    : |0|1 |2|",
+        "               ",
+        "q0   : -X-||---",
+        "          |    ",
+        "q3   : ---||-H-",
+        "          |    ",
+        "q100 : ---||---",
+        "",
+        "T    : |0|1 |2|",
+    )
+    _assert_correct_diagram(circ, expected)

test/unit_tests/braket/circuits/test_circuit.py

@@ -3589,3 +3589,50 @@ def test_from_ir_round_trip_transformation_with_targeted_measurements():
 
     assert Circuit.from_ir(ir) == Circuit.from_ir(circuit.to_ir("OPENQASM"))
     assert circuit.to_ir("OPENQASM") == Circuit.from_ir(ir).to_ir("OPENQASM")
+
+
+def test_barrier_specific_qubits():
+    circ = Circuit().barrier([0, 1, 2])
+    assert len(circ.instructions) == 1
+    instr = circ.instructions[0]
+    assert isinstance(instr.operator, compiler_directives.Barrier)
+    assert instr.target == QubitSet([0, 1, 2])
+    assert instr.operator.qubit_indices == [0, 1, 2]
+    assert circ.qubits_frozen is True
+
+
+def test_barrier_all_qubits():
+    circ = Circuit().h(0).h(1).barrier()
+    assert len(circ.instructions) == 3
+    barrier_instr = circ.instructions[2]
+    assert isinstance(barrier_instr.operator, compiler_directives.Barrier)
+    assert barrier_instr.target == QubitSet([0, 1])
+
+
+def test_barrier_empty_circuit():
+    circ = Circuit().barrier()
+    assert len(circ.instructions) == 0  # No barrier added to empty circuit
+
+
+def test_barrier_none_target():
+    circ = Circuit().h(0).h(2).barrier(None)
+    barrier_instr = circ.instructions[2]
+    assert barrier_instr.target == QubitSet([0, 2])
+
+
+def test_barrier_openqasm_export_specific_qubits():
+    circ = Circuit().h(0).barrier([0, 1]).cnot(0, 1)
+    qasm = circ.to_ir(IRType.OPENQASM).source
+    assert "barrier q[0], q[1];" in qasm
+
+
+def test_barrier_openqasm_export_all_qubits():
+    circ = Circuit().h(0).h(1).barrier().cnot(0, 1)
+    qasm = circ.to_ir(IRType.OPENQASM).source
+    assert "barrier q[0], q[1];" in qasm
+
+
+def test_barrier_jaqcd_export_fails():
+    circ = Circuit().h(0).barrier([0, 1])
+    with pytest.raises(NotImplementedError, match="Barrier is not supported in JAQCD"):
+        circ.to_ir(IRType.JAQCD)

test/unit_tests/braket/circuits/test_compiler_directives.py

@@ -17,6 +17,7 @@
 from braket.circuits import compiler_directives
 from braket.circuits.compiler_directive import CompilerDirective
 from braket.circuits.serialization import IRType
+from braket.circuits.serialization import OpenQASMSerializationProperties, QubitReferenceType
 
 
 @pytest.mark.parametrize(
@@ -49,3 +50,22 @@ def test_verbatim(testclass, irclass, openqasm_str, counterpart):
     assert directive is not op
     assert directive != CompilerDirective(ascii_symbols=["foo"])
     assert directive != "not a directive"
+
+
+def test_barrier():
+    barrier = compiler_directives.Barrier([0, 1, 2])
+    assert barrier.qubit_indices == [0, 1, 2]
+    assert barrier.qubit_count == 3
+    assert barrier.ascii_symbols == ("||",)
+    assert barrier._to_openqasm() == "barrier"
+    assert repr(barrier) == "Barrier"
+
+    with pytest.raises(NotImplementedError, match="Barrier is not supported in JAQCD"):
+        barrier._to_jaqcd()
+
+    props = OpenQASMSerializationProperties(qubit_reference_type=QubitReferenceType.VIRTUAL)
+    result = barrier.to_ir([0, 1, 2], IRType.OPENQASM, props)
+    assert result == "barrier q[0], q[1], q[2];"
+
+    result = barrier.to_ir([], IRType.OPENQASM, props)
+    assert result == "barrier;"

test/unit_tests/braket/circuits/test_unicode_circuit_diagram.py

@@ -1119,3 +1119,36 @@ def test_measure_with_readout_noise():
         "T  : │  0  │        1        │  2  │",
     )
     _assert_correct_diagram(circ, expected)
+
+
+def test_barrier_circuit_visualization_without_other_gates():
+    circ = Circuit().barrier(target=[0, 100])
+    expected = (
+        "T    : │  0   │",
+        "               ",
+        "q0   : ───▒────",
+        "          │    ",
+        "          │    ",
+        "q100 : ───▒────",
+        "               ",
+        "T    : │  0   │",
+    )
+    _assert_correct_diagram(circ, expected)
+
+
+def test_barrier_circuit_visualization_with_other_gates():
+    circ = Circuit().x(0).barrier(target=[0, 100]).h(3)
+    expected = (
+        "T    : │  0  │  1   │  2  │",
+        "        ┌───┐              ",
+        "q0   : ─┤ X ├───▒──────────",
+        "        └───┘   │          ",
+        "                │    ┌───┐ ",
+        "q3   : ─────────▒────┤ H ├─",
+        "                │    └───┘ ",
+        "                │          ",
+        "q100 : ─────────▒──────────",
+        "                           ",
+        "T    : │  0  │  1   │  2  │",
+    )
+    _assert_correct_diagram(circ, expected)