Add support for QASM 3.0 qubit registers

doc/releases/changelog-dev.md

@@ -50,12 +50,13 @@
 <h4>OpenQASM-PennyLane interoperability</h4>
 
 * The :func:`qml.from_qasm3` function can now convert OpenQASM 3.0 circuits that contain
-  subroutines, constants, all remaining stdlib gates, and built-in mathematical functions.
+  subroutines, constants, all remaining stdlib gates, qubit registers, and built-in mathematical functions.
   [(#7651)](https://github.com/PennyLaneAI/pennylane/pull/7651)
   [(#7653)](https://github.com/PennyLaneAI/pennylane/pull/7653)
   [(#7676)](https://github.com/PennyLaneAI/pennylane/pull/7676)
   [(#7679)](https://github.com/PennyLaneAI/pennylane/pull/7679)
   [(#7677)](https://github.com/PennyLaneAI/pennylane/pull/7677)
+  [(#7767)](https://github.com/PennyLaneAI/pennylane/pull/7767)
   [(#7690)](https://github.com/PennyLaneAI/pennylane/pull/7690)
 
 <h4>Other improvements</h4>

pennylane/io/io.py

@@ -979,8 +979,8 @@ def from_qasm3(quantum_circuit: str, wire_map: dict = None):
     Converts an OpenQASM 3.0 circuit into a quantum function that can be used within a QNode.
 
     .. note::
-        The standard library gates, built-in mathematical functions and constants, subroutines, variables,
-        control flow, measurements, inputs, outputs, custom gates and ``end`` statements are all supported.
+        The standard library gates, qubit registers, built-in mathematical functions and constants, subroutines,
+        variables, control flow, measurements, inputs, outputs, custom gates and ``end`` statements are all supported.
         Pulses are not yet supported.
 
         In order to use this function, ``openqasm3`` and ``'openqasm3[parser]'`` must be installed in the user's

pennylane/io/qasm_interpreter.py

@@ -277,6 +277,8 @@ def __init__(self, context: dict):
             context["aliases"] = {}
         if "wires" not in context:
             context["wires"] = []
+        if "registers" not in context:
+            context["registers"] = {}
         if "scopes" not in context:
             context["scopes"] = {"subroutines": {}, "custom_gates": {}}
         if "wire_map" not in context or context["wire_map"] is None:
@@ -300,6 +302,7 @@ def init_custom_gate_scope(self, node: ast.QuantumGateDefinition):
                 "params": [_resolve_name(param) for param in node.arguments]
                 + [_resolve_name(qubit) for qubit in node.qubits],
                 "wires": copy.deepcopy(self.wires),
+                "registers": copy.deepcopy(self.registers),
                 "name": node.name.name,
                 # we want subroutines declared in the global scope to be available
                 "scopes": {
@@ -323,6 +326,7 @@ def init_subroutine_scope(self, node: ast.SubroutineDefinition):
                 "vars": {k: v for k, v in self.vars.items() if v.constant},  # same namespace
                 "wire_map": {},
                 "wires": copy.deepcopy(self.wires),
+                "registers": copy.deepcopy(self.registers),
                 "name": node.name.name,
                 # we want subroutines declared in the global scope to be available
                 "scopes": {
@@ -354,6 +358,8 @@ def retrieve_variable(self, name: str):
             if res.val is not None:
                 return res
             raise ValueError(f"Attempt to reference uninitialized parameter {name}!")
+        if name in self.registers:
+            return self.registers[name]
         if name in self.wires:
             return name
         if name in self.aliases:
@@ -393,7 +399,7 @@ def require_wires(self, wires: list):
         Raises:
             NameError: If the context is missing a wire.
         """
-        missing_wires = set(wires) - set(self.wires)
+        missing_wires = set(wires) - (set(self.wires + list(self.registers)))
         if len(missing_wires) > 0:
             raise NameError(
                 f"Attempt to reference wire(s): {missing_wires} that have not been declared in {self.name}"
@@ -596,8 +602,11 @@ def visit_quantum_measurement_statement(
             node (QuantumMeasurementStatement): the quantum measurement statement to register.
             context (Context): the current context.
         """
-        wire = self.visit(node.measure.qubit, context)
-        res = measure(context.wire_map.get(wire, wire))
+        wires = self.visit(node.measure.qubit, context)
+        if isinstance(wires, list):
+            res = [measure(context.wire_map.get(wire, wire)) for wire in wires]
+        else:
+            res = measure(context.wire_map.get(wires, wires))
         if node.target is not None:
             name = _resolve_name(node.target)  # str or Identifier
             context.vars[name].val = res
@@ -829,8 +838,33 @@ def visit_quantum_reset(self, node: QASMNode, context: dict):
             node (QASMNode): the quantum reset node.
             context (dict): the current context.
         """
-        wire = self.visit(node.qubits, context)
-        measure(context.wire_map.get(wire, wire), reset=True)
+        wires = self.visit(node.qubits, context)
+        if isinstance(wires, list):
+            for wire in wires:
+                measure(context.wire_map.get(wire, wire), reset=True)
+        else:
+            measure(context.wire_map.get(wires, wires), reset=True)
+
+    @staticmethod
+    def _bind_quantum_parameter(param, evald_arg, inner_context, context):
+        """
+        Binds a quantum parameter in a subroutine or custom gate context.
+
+        Args:
+            param (str): the name of the quantum parameter to bind.
+            evald_arg (str): the name of the qubit.
+            inner_context (Context): the custom gate or subroutine context.
+            context (Context): the outer context.
+        """
+        reg = False
+        if evald_arg in context.registers:
+            reg = True
+            del inner_context.wires[inner_context.wires.index(param)]
+            inner_context.registers[param] = context.registers[evald_arg]
+        elif evald_arg in context.wire_map:
+            evald_arg = context.wire_map[evald_arg]
+        if param != evald_arg and not reg:
+            inner_context.wire_map[param] = evald_arg
 
     def execute_custom_gate(self, node: ast.QuantumGate, context: Context):
         """
@@ -853,10 +887,7 @@ def execute_custom_gate(self, node: ast.QuantumGate, context: Context):
                     evald_arg.__class__.__name__, evald_arg, None, node.span.start_line, False
                 )
             else:
-                if evald_arg in context.wire_map:
-                    evald_arg = context.wire_map[evald_arg]
-                if param != evald_arg:
-                    gate_context.wire_map[param] = evald_arg
+                self._bind_quantum_parameter(param, evald_arg, gate_context, context)
 
         # execute the subroutine
         self.visit(gate_context.body, gate_context)
@@ -885,13 +916,20 @@ def _execute_function(self, name: str, node: FunctionCall, context: Context):
         func_context.context["return"] = None
 
         # bind subroutine arguments
-        evald_args = [self.visit(raw_arg, context) for raw_arg in node.arguments]
+        evald_args = [
+            # visit will resolve a qubit name to itself, but a register name to a list of its member qubits,
+            # we don't want to dereference yet... to behave consistently with execute_custom_gate
+            (
+                _resolve_name(raw_arg)
+                if isinstance(raw_arg, (str, ast.Identifier))
+                and _resolve_name(raw_arg) in context.registers
+                else self.visit(raw_arg, context)
+            )
+            for raw_arg in node.arguments
+        ]
         for evald_arg, param in list(zip(evald_args, func_context.params)):
             if isinstance(evald_arg, str):  # this would indicate a quantum parameter
-                if evald_arg in context.wire_map:
-                    evald_arg = context.wire_map[evald_arg]
-                if evald_arg != param:
-                    func_context.wire_map[param] = evald_arg
+                self._bind_quantum_parameter(param, evald_arg, func_context, context)
             else:
                 func_context.vars[param] = Variable(
                     evald_arg.__class__.__name__,
@@ -1043,11 +1081,13 @@ def visit_qubit_declaration(self, node: ast.QubitDeclaration, context: Context):
         Raises:
             TypeError: if it is a qubit register declaration.
         """
-        if node.size is not None:
-            raise TypeError(
-                "Qubit registers are not yet supported, please declare each qubit individually."
-            )
-        context.wires.append(node.qubit.name)
+        if node.size is not None and isinstance(self.visit(node.size, context), int):
+            context.registers[node.qubit.name] = []
+            for i in range(self.visit(node.size, context)):
+                context.wires.append(f"{node.qubit.name}[{i}]")
+                context.registers[node.qubit.name].append(f"{node.qubit.name}[{i}]")
+        else:
+            context.wires.append(node.qubit.name)
 
     @visit.register(ast.ClassicalAssignment)
     def visit_classical_assignment(self, node: ast.ClassicalAssignment, context: Context):
@@ -1281,15 +1321,43 @@ def _gate_setup_helper(self, node: ast.QuantumGate, gates_dict: dict, context: C
         gate = gates_dict[node.name.name.upper()]
 
         # setup wires
-        wires = [_resolve_name(node.qubits[q]) for q in range(len(node.qubits))]
-
-        context.require_wires(wires)
+        wires = []
+        require_wires = []
+        for qubit in node.qubits:
+            if (not hasattr(qubit, "indices")) or qubit.indices is None:
+                # we are dealing with a wire label directly
+                wire = _resolve_name(qubit)
+                # require the qubit to have been declared
+                require_wires.append(wire)
+                # resolve any wire relabelling (mapping pennylane wires to qasm wires, or renaming between func contexts)
+                wires.append(context.wire_map[wire] if wire in context.wire_map else wire)
+            elif len(qubit.indices) == 1 and len(qubit.indices[0]) == 1:
+                # we are dealing with an index into a register
+                register = _resolve_name(qubit)
+                # required the register to have been declared
+                require_wires.append(register)
+                # evaluate the register to a list of the qubits that compose it
+                reg_var = context.retrieve_variable(register)
+                # evaluate the index into the register to a literal
+                index = self.visit(qubit.indices[0][0], context)
+                # check that the index is not out of bounds
+                if index < len(reg_var):
+                    # index into the register and return the wire acted on
+                    wires.append(reg_var[index])
+                else:
+                    raise IndexError(
+                        f"Index {index} into register {register} of length {len(reg_var)} out of bounds on line {node.span.start_line}."
+                    )
+            else:
+                raise (
+                    NotImplementedError(
+                        "Only a single Expression or Index is supported for indexing into registers."
+                    )
+                )
 
-        resolved_wires = list(
-            map(lambda wire: context.wire_map[wire] if wire in context.wire_map else wire, wires)
-        )
+        context.require_wires(require_wires)
 
-        return gate, args, resolved_wires
+        return gate, args, wires
 
     def apply_modifier(
         self, mod: ast.QuantumGate, previous: Operator, context: Context, wires: list

tests/io/qasm_interpreter/complex_subroutines.qasm

@@ -1,5 +1,6 @@
 qubit q0;
 qubit anc;
+qubit[2] p;
 
 def second(qubit q) {
     h q;
@@ -20,4 +21,10 @@ def third(qubit q, float a) {
     rx(a) q;
 }
 
+def fourth(qubit[2] p) {
+    x p[0];
+    y p[1];
+}
+
 third(q0, 0.1);
+fourth(p);

tests/io/qasm_interpreter/custom_gates.qasm

@@ -1,5 +1,6 @@
 qubit q0;
 qubit q1;
+qubit[2] p;
 
 const float pi = 3.14159;
 
@@ -17,4 +18,11 @@ gate custom_two(θ) c, d
     x d;
 }
 
+gate custom_three f
+{
+    x f[0];
+    y f[1];
+}
+
 custom_two(pi) q1, q0;
+custom_three p;

tests/io/qasm_interpreter/nested_renaming.qasm

@@ -1,4 +1,4 @@
-qubit q0;
+qubit[1] q;
 
 def f3(qubit q2) {
     h q2;
@@ -14,4 +14,22 @@ def f1(qubit q1) {
     f2(q1);
 }
 
-f1(q0);
+f1(q[0]);
+
+qubit[2] p;
+
+def l3(qubit[2] p2) {
+    h p2[1];
+}
+
+def l2(qubit[2] p2) {
+    x p2[0];
+    l3(p2);
+}
+
+def l1(qubit[2] p1) {
+    y p1[1];
+    l2(p1);
+}
+
+l1(p);

tests/io/qasm_interpreter/resets.qasm

@@ -1,10 +1,9 @@
-qubit q;
-reset q;
+qubit[10] q;
 
-def reset_and_measure(qubit p) -> bit {
-  bit b = "0";
-  reset p;
-  measure p -> b;
+def reset_and_measure(qubit[10] q) -> bit {
+  bit b = "0000000000";
+  reset q;
+  measure q -> b;
   return b;
 }