Inputs can be provided from python to QASM 3.0 programs

doc/releases/changelog-dev.md

@@ -4,6 +4,13 @@
 
 <h3>New features since last release</h3>
 
+<h4>OpenQASM 🤝 PennyLane</h4>
+
+* More functionality within :func:`qml.from_qasm3` has been added, which converts more complex OpenQASM 3.0 circuits 
+  into quantum functions that can be subsequently loaded into QNodes and executed. For more details, 
+  please consult the documentation for :func:`qml.from_qasm3`.
+  [(#7651)](https://github.com/PennyLaneAI/pennylane/pull/7651)
+
 <h3>Improvements 🛠</h3>
 
 <h3>Breaking changes 💔</h3>

pennylane/io/io.py

@@ -843,14 +843,14 @@ def from_quil_file(quil_filename: str):
     return plugin_converter(quil_filename)
 
 
-def from_qasm3(quantum_circuit: str, wire_map: dict = None):
+def from_qasm3(quantum_circuit: str, wire_map: dict = None, **kwargs):
     """
     Converts an OpenQASM 3.0 circuit into a quantum function that can be used within a QNode.
 
     .. note::
         The following OpenQASM 3.0 gates are not supported: sdg, tdg, cu. Built-in mathematical functions and
         constants, custom gates, and pulses are not yet supported. The remaining standard library gates,
-        subroutines, variables, control flow, measurements and ``end`` statements are all supported.
+        subroutines, variables, control flow, measurements, inputs and ``end`` statements are all supported.
 
         In order to use this function, ``openqasm3`` and ``'openqasm3[parser]'`` must be installed in the user's
         environment. Please consult the `OpenQASM installation instructions <https://pypi.org/project/openqasm3>`__
@@ -939,6 +939,6 @@ def my_circuit():
         ) from e
 
     def interpret_function():
-        QasmInterpreter().interpret(ast, context={"name": "global", "wire_map": wire_map})
+        QasmInterpreter().interpret(ast, context={"name": "global", "wire_map": wire_map}, **kwargs)
 
     return interpret_function

pennylane/io/qasm_interpreter.py

@@ -396,6 +396,13 @@ class QasmInterpreter:
     visitor function on each node.
     """
 
+    def __init__(self):
+        """
+        Initializes the QASM interpreter.
+        """
+        self.inputs = {}
+        self.found_inputs = []
+
     @functools.singledispatchmethod
     def visit(self, node: QASMNode, context: Context, aliasing: bool = False):
         """
@@ -427,18 +434,23 @@ def visit_list(self, node_list: list, context: Context):
         for sub_node in node_list:
             self.visit(sub_node, context)
 
-    def interpret(self, node: QASMNode, context: dict):
+    def interpret(self, node: QASMNode, context: dict, **inputs):
         """
         Entry point for visiting the QASMNodes of a parsed OpenQASM 3.0 program.
 
         Args:
             node (QASMNode): The top-most QASMNode.
-            context (Context): The initial context populated with the name of the program (the outermost scope).
+            context (dict): The initial context populated with the name of the program (the outermost scope).
+            inputs (dict): Additional inputs to the OpenQASM 3.0 program.
+
+        Raises:
+            ValueError: If the wrong parameters are provided in **inputs.
 
         Returns:
             dict: The context updated after the compilation of all nodes by the visitor.
         """
         context = Context(context)
+        self.inputs = inputs
 
         # begin recursive descent traversal
         try:
@@ -450,6 +462,12 @@ def interpret(self, node: QASMNode, context: dict):
                         self.visit(item, context)
         except EndProgram:
             pass
+
+        if len(self.found_inputs) != len(inputs):
+            raise ValueError(
+                f"Got the wrong input parameters {list(inputs.keys())} to QASM, expecting {self.found_inputs}."
+            )
+
         return context
 
     @visit.register(ast.QuantumMeasurement)
@@ -805,6 +823,26 @@ def _index_into_var(
             f"Array index does not evaluate to a single RangeDefinition or Literal at line {node.span.start_line}."
         )
 
+    @visit.register(ast.IODeclaration)
+    def visit_io_declaration(self, node: ast.IODeclaration, context: Context):
+        """
+        Registers an input declaration (outputs to come in a future PR).
+
+        Args:
+            node (IODeclaration): The IODeclaration QASMNode.
+            context (Context): the current context.
+        """
+        name = _resolve_name(node.identifier)
+        self.found_inputs.append(name)
+        if name in self.inputs:
+            context.vars[name] = Variable(
+                node.type.__class__.__name__, self.inputs[name], -1, node.span.start_line, True
+            )
+        else:
+            raise ValueError(
+                f"Missing input {name}. Please pass {name} as a keyword argument to from_qasm3."
+            )
+
     @visit.register(ast.EndStatement)
     def visit_end_statement(self, node: ast.EndStatement, context: Context):
         """

tests/io/qasm_interpreter/test_interpreter.py

@@ -59,6 +59,66 @@
     pass
 
 
+@pytest.mark.external
+class TestIO:
+
+    def test_wrong_input(self):
+        ast = parse(
+            """
+            input float theta;
+            qubit q;
+            rx(theta) q;
+            """
+        )
+
+        with pytest.raises(
+            ValueError,
+            match=escape(
+                "Got the wrong input parameters ['theta', 'phi'] to QASM, expecting ['theta']."
+            ),
+        ):
+            QasmInterpreter().interpret(
+                ast, context={"name": "wrong-input", "wire_map": None}, theta=0.2, phi=0.1
+            )
+
+    def test_missing_input(self):
+        ast = parse(
+            """
+            input float theta;
+            qubit q;
+            rx(theta) q;
+            """
+        )
+
+        with pytest.raises(
+            ValueError,
+            match="Missing input theta. Please pass theta as a keyword argument to from_qasm3.",
+        ):
+            QasmInterpreter().interpret(ast, context={"name": "missing-input", "wire_map": None})
+
+    def test_input(self):
+        ast = parse(
+            """
+            input float theta;
+            qubit q;
+            rx(theta) q;
+            """
+        )
+
+        with queuing.AnnotatedQueue() as q:
+            QasmInterpreter().interpret(
+                ast, context={"name": "inputs", "wire_map": None}, theta=0.1
+            )
+            QasmInterpreter().interpret(
+                ast, context={"name": "inputs", "wire_map": None}, theta=0.2
+            )
+
+        assert q.queue == [
+            RX(0.1, "q"),
+            RX(0.2, "q"),
+        ]
+
+
 @pytest.mark.external
 class TestMeasurementReset: