feat: add U and GPhase gates

src/braket/circuits/ascii_circuit_diagram.py

@@ -23,6 +23,7 @@
 from braket.circuits.instruction import Instruction
 from braket.circuits.noise import Noise
 from braket.circuits.result_type import ResultType
+from braket.registers.qubit import Qubit
 from braket.registers.qubit_set import QubitSet
 
 
@@ -84,6 +85,9 @@ def build_diagram(circuit: cir.Circuit) -> str:
         # Time on top and bottom
         lines.append(lines[0])
 
+        if circuit.global_phase:
+            lines.append(f"\nGlobal phase: {circuit.global_phase}")
+
         # Additional result types line on bottom
         if additional_result_types:
             lines.append(f"\nAdditional result types: {', '.join(additional_result_types)}")
@@ -115,8 +119,8 @@ def _ascii_group_items(
         groupings = []
         for item in items:
             # Can only print Gate and Noise operators for instructions at the moment
-            if isinstance(item, Instruction) and not isinstance(
-                item.operator, (Gate, Noise, CompilerDirective)
+            if isinstance(item, Instruction) and (
+                not isinstance(item.operator, (Gate, Noise, CompilerDirective))
             ):
                 continue
 
@@ -258,6 +262,10 @@ def _ascii_diagram_column(
                 else:
                     target_qubits = item.target
                 control_qubits = getattr(item, "control", QubitSet())
+                map_control_qubit_states = AsciiCircuitDiagram._build_map_control_qubits(
+                    item, control_qubits
+                )
+
                 target_and_control = target_qubits.union(control_qubits)
                 qubits = QubitSet(range(min(target_and_control), max(target_and_control) + 1))
 
@@ -288,7 +296,7 @@ def _ascii_diagram_column(
                         else ascii_symbols[item_qubit_index]
                     )
                 elif qubit in control_qubits:
-                    symbols[qubit] = "C"
+                    symbols[qubit] = "C" if map_control_qubit_states[qubit] else "N"
                 else:
                     symbols[qubit] = "|"
 
@@ -305,3 +313,15 @@ def _ascii_diagram_column(
                 symbols[qubit], fill="-", align="<", width=symbols_width + 1
             )
         return output
+
+    @staticmethod
+    def _build_map_control_qubits(item: Instruction, control_qubits: QubitSet) -> dict(Qubit, int):
+        control_state = getattr(item, "control_state", None)
+        if control_state is not None:
+            map_control_qubit_states = {
+                qubit: state for qubit, state in zip(control_qubits, control_state)
+            }
+        else:
+            map_control_qubit_states = {qubit: 1 for qubit in control_qubits}
+
+        return map_control_qubit_states

src/braket/circuits/basis_state.py

@@ -1,5 +1,5 @@
 from functools import singledispatch
-from typing import Optional, Union
+from typing import Any, Optional, Union
 
 import numpy as np
 
@@ -33,6 +33,35 @@ def __iter__(self):
     def __eq__(self, other):
         return self.state == other.state
 
+    def __str__(self):
+        return self.as_string
+
+    def __repr__(self):
+        return f'BasisState("{self.as_string}")'
+
+    def __getitem__(self, item):
+        return BasisState(self.state[item])
+
+    def index(self, value: Any) -> int:
+        return list(self.state).index(value)
+
+    def pop(self, index: Optional[int] = None) -> int:
+        """Removes and returns item at index.
+
+        Args:
+            index (Optional[int]): index of the object to remove (default last).
+
+        Returns:
+            int: removed item.
+        """
+        if index is None:
+            item = self.state[-1]
+            self.state = self.state[:-1]
+        else:
+            item = self.state[index]
+            self.state = self.state[:index] + self.state[index + 1 :]
+        return item
+
 
 BasisStateInput = Union[int, list[int], str, BasisState]
 

src/braket/circuits/braket_program_context.py

@@ -56,8 +56,15 @@ def is_builtin_gate(self, name: str) -> bool:
         user_defined_gate = self.is_user_defined_gate(name)
         return name in BRAKET_GATES and not user_defined_gate
 
-    def add_phase_instruction(self, target: tuple[int], phase_value: int) -> None:
-        raise NotImplementedError
+    def add_phase_instruction(self, target: tuple[int], phase_value: float) -> None:
+        """Add a global phase to the circuit.
+
+        Args:
+            target (tuple[int]): Unused
+            phase_value (float): The phase value to be applied
+        """
+        instruction = Instruction(BRAKET_GATES["gphase"](phase_value))
+        self._circuit.add_instruction(instruction)
 
     def add_gate_instruction(
         self, gate_name: str, target: tuple[int], *params, ctrl_modifiers: list[int], power: float

src/braket/circuits/circuit.py

@@ -156,6 +156,11 @@ def depth(self) -> int:
         """int: Get the circuit depth."""
         return self._moments.depth
 
+    @property
+    def global_phase(self) -> float:
+        """int: Get the circuit depth."""
+        return self._moments._global_phase
+
     @property
     def instructions(self) -> list[Instruction]:
         """Iterable[Instruction]: Get an `iterable` of instructions in the circuit."""
@@ -1196,6 +1201,9 @@ def _to_openqasm(
             ]
         )
 
+        if self.global_phase:
+            ir_instructions.append(f"gphase({self.global_phase});")
+
         if self.result_types:
             ir_instructions.extend(
                 [
@@ -1423,7 +1431,9 @@ def to_unitary(self) -> np.ndarray:
         qubits = self.qubits
         if not qubits:
             return np.zeros(0, dtype=complex)
-        return calculate_unitary_big_endian(self.instructions, qubits)
+        return calculate_unitary_big_endian(self.instructions, qubits) * np.exp(
+            1j * self.global_phase
+        )
 
     @property
     def qubits_frozen(self) -> bool:

src/braket/circuits/gate.py

@@ -198,7 +198,7 @@ def _to_openqasm(
 
         return (
             f"{inv_prefix}{power_prefix}{control_prefix}"
-            f"{self._qasm_name}{param_string} {', '.join(qubits)};"
+            f"{self._qasm_name}{param_string}{','.join([f' {qubit}' for qubit in qubits])};"
         )
 
     @property