Support "input" modifier in QASM3 parser (#7997)

Added reserved keywords: 'input', 'float', and 'angle'. Wrote test cases
for the new keywords. Input parameters become sympy.Symbols in the
parsed qasm.

Fixes #7933

---------

Co-authored-by: Michael Hucka <mhucka@caltech.edu>
Co-authored-by: Michael Hucka <mhucka@google.com>
Co-authored-by: Pavol Juhas <juhas@google.com>

Author: 3 people

cirq-core/cirq/contrib/qasm_import/_lexer.py

@@ -37,6 +37,9 @@ def __init__(self):
         'gate': 'GATE',
         'if': 'IF',
         'pi': 'PI',
+        'input': 'INPUT',
+        'float': 'FLOAT',
+        'angle': 'ANGLE',
     }
 
     tokens = [

cirq-core/cirq/contrib/qasm_import/_parser.py

@@ -37,7 +37,13 @@ class Qasm:
     """Qasm stores the final result of the Qasm parsing."""
 
     def __init__(
-        self, supported_format: bool, qelib1_include: bool, qregs: dict, cregs: dict, c: Circuit
+        self,
+        supported_format: bool,
+        qelib1_include: bool,
+        qregs: dict,
+        cregs: dict,
+        input_params: dict[str, str],
+        circuit: Circuit,
     ):
         """Initializes Qasm.
 
@@ -53,7 +59,8 @@ def __init__(
         self.supportedFormat = supported_format
         self.qregs = qregs
         self.cregs = cregs
-        self.circuit = c
+        self.circuit = circuit
+        self.input_params = input_params
 
 
 def _generate_op_qubits(args: list[list[ops.Qid]], lineno: int) -> list[list[ops.Qid]]:
@@ -187,24 +194,34 @@ def __init__(self) -> None:
         Attributes:
             gate_set: The gates available to use in the circuit, including those from
                 libraries, and user-defined ones.
+            circuit: A Cirq Circuit object.
+            qregs: Quantum registers.
+            cregs: Classical registers.
             in_custom_gate_scope: This is set to True when the parser is in the middle
                 of parsing a custom gate definition.
             custom_gate_scoped_params: The params declared within the current custom
                 gate definition. Empty if not in custom gate scope.
             custom_gate_scoped_qubits: The qubits declared within the current custom
                 gate definition. Empty if not in custom gate scope.
+            input_params: The input parameters mapped from name to type.
+            qelibinc: Boolean indicating whether the Quantum Experience standard header
+                is present or not.
+            supported_format: Boolean indicating whether the format is supported.
+            format_version: The OpenQASM version string.
         """
         self.parser = yacc.yacc(module=self, debug=False, write_tables=False)
         self.circuit = Circuit()
         self.qregs: dict[str, int] = {}
         self.cregs: dict[str, int] = {}
         self.gate_set: dict[str, CustomGate | QasmGateStatement] = {**self.basic_gates}
-        self.in_custom_gate_scope = False
+        self.in_custom_gate_scope: bool = False
         self.custom_gate_scoped_params: set[str] = set()
         self.custom_gate_scoped_qubits: dict[str, ops.Qid] = {}
-        self.qelibinc = False
+        self.input_params: dict[str, str] = {}
+        self.qelibinc: bool = False
         self.lexer = QasmLexer()
-        self.supported_format = False
+        self.supported_format: bool = False
+        self.format_version: str = ""
         self.parsedQasm: Qasm | None = None
         self.qubits: dict[str, ops.Qid] = {}
         self.functions = {
@@ -810,7 +827,14 @@ def p_start(self, p):
     def p_qasm_format_only(self, p):
         """qasm : format"""
         self.supported_format = True
-        p[0] = Qasm(self.supported_format, self.qelibinc, self.qregs, self.cregs, self.circuit)
+        p[0] = Qasm(
+            self.supported_format,
+            self.qelibinc,
+            self.qregs,
+            self.cregs,
+            self.input_params,
+            self.circuit,
+        )
 
     def p_qasm_no_format_specified_error(self, p):
         """qasm : QELIBINC
@@ -823,31 +847,49 @@ def p_qasm_include(self, p):
         """qasm : qasm QELIBINC"""
         self.qelibinc = True
         self.gate_set |= self.qelib_gates
-        p[0] = Qasm(self.supported_format, self.qelibinc, self.qregs, self.cregs, self.circuit)
+        p[0] = Qasm(
+            self.supported_format,
+            self.qelibinc,
+            self.qregs,
+            self.cregs,
+            self.input_params,
+            self.circuit,
+        )
 
     def p_qasm_include_stdgates(self, p):
         """qasm : qasm STDGATESINC"""
         self.qelibinc = True
         self.gate_set |= self.qelib_gates
-        p[0] = Qasm(self.supported_format, self.qelibinc, self.qregs, self.cregs, self.circuit)
+        p[0] = Qasm(
+            self.supported_format,
+            self.qelibinc,
+            self.qregs,
+            self.cregs,
+            self.input_params,
+            self.circuit,
+        )
 
     def p_qasm_circuit(self, p):
         """qasm : qasm circuit"""
-        p[0] = Qasm(self.supported_format, self.qelibinc, self.qregs, self.cregs, p[2])
+        p[0] = Qasm(
+            self.supported_format, self.qelibinc, self.qregs, self.cregs, self.input_params, p[2]
+        )
 
     def p_format(self, p):
         """format : FORMAT_SPEC"""
         if p[1] not in ["2.0", "3.0"]:
             raise QasmException(
-                f"Unsupported OpenQASM version: {p[1]}, "
-                "only 2.0 and 3.0 are supported currently by Cirq"
+                f"Unsupported OpenQASM version: {p[1]}. "
+                "Only 2.0 and 3.0 are supported currently by Cirq"
             )
+        self.format_version = p[1]
 
     # circuit : new_reg circuit
     #         | gate_op circuit
     #         | measurement circuit
     #         | reset circuit
     #         | if circuit
+    #         | input_decl circuit
     #         | empty
 
     def p_circuit_reg(self, p):
@@ -862,6 +904,10 @@ def p_circuit_gate_or_measurement_or_if(self, p):
         self.circuit.append(p[2])
         p[0] = self.circuit
 
+    def p_circuit_input_decl(self, p):
+        """circuit : input_decl circuit"""
+        p[0] = self.circuit
+
     def p_circuit_empty(self, p):
         """circuit : empty"""
         p[0] = self.circuit
@@ -891,7 +937,7 @@ def p_new_reg(self, p):
             else:
                 # QUBIT '[' NATURAL_NUMBER ']' ID ';'
                 name, length = p[5], p[3]
-        if name in self.qregs.keys() or name in self.cregs.keys():
+        if name in self.qregs or name in self.cregs or name in self.input_params:
             raise QasmException(f"{name} is already defined at line {p.lineno(2)}")
         if length == 0:
             raise QasmException(f"Illegal, zero-length register '{name}' at line {p.lineno(4)}")
@@ -934,6 +980,34 @@ def p_params_single(self, p):
         """params : expr"""
         p[0] = [p[1]]
 
+    # input declarations (OpenQASM 3.0 only)
+    # input_decl : INPUT input_type '[' NATURAL_NUMBER ']' ID ';'
+
+    def p_input_type(self, p):
+        """input_type : FLOAT
+        | ANGLE
+        """
+        p[0] = p[1]
+
+    def p_input_decl(self, p):
+        """input_decl : INPUT input_type '[' NATURAL_NUMBER ']' ID ';'"""
+        if self.format_version != "3.0":
+            raise QasmException(
+                f"'input' modifier at line {p.lineno(1)} is only supported in OpenQASM 3.0"
+            )
+        # INPUT input_type '[' NATURAL_NUMBER ']' ID ';'
+        bit_width = p[4]
+        if bit_width == 0:
+            raise QasmException(
+                f"Illegal bit width of zero for input '{p[6]}' at line {p.lineno(4)}"
+            )
+        input_type = f"{p[2]}[{bit_width}]"
+        name = p[6]
+        if name in self.input_params or name in self.qregs or name in self.cregs:
+            raise QasmException(f"{name} is already defined at line {p.lineno(6)}")
+        self.input_params[name] = input_type
+        p[0] = (name, input_type)
+
     # expr : term
     #            | ID
     #            | func '(' expression ')'
@@ -946,10 +1020,11 @@ def p_expr_term(self, p):
 
     def p_expr_identifier(self, p):
         """expr : ID"""
-        if not self.in_custom_gate_scope:
-            raise QasmException(f"Parameter '{p[1]}' in line {p.lineno(1)} not supported")
-        if p[1] not in self.custom_gate_scoped_params:
-            raise QasmException(f"Undefined parameter '{p[1]}' in line {p.lineno(1)}'")
+        if p[1] not in self.input_params:
+            if not self.in_custom_gate_scope:
+                raise QasmException(f"Parameter '{p[1]}' in line {p.lineno(1)} not supported")
+            if p[1] not in self.custom_gate_scoped_params:
+                raise QasmException(f"Undefined parameter '{p[1]}' in line {p.lineno(1)}'")
         p[0] = sympy.Symbol(p[1])
 
     def p_expr_parens(self, p):

cirq-core/cirq/contrib/qasm_import/_parser_test.py

@@ -2437,3 +2437,91 @@ def test_all_qelib_gates_unitary_equivalence(
     U_import = cirq.unitary(imported)
     assert np.allclose(U_import, U_native, atol=1e-8)
     assert parsed_qasm.qregs == {'q': num_args}
+
+
+@pytest.mark.parametrize('input_type', ['angle', 'float'])
+def test_input_basic(input_type: str) -> None:
+    qasm = f"""
+        OPENQASM 3.0;
+        qreg q[1];
+        input {input_type}[64] theta;
+        U(theta, 0, 0) q[0];
+    """
+    parsed_qasm = QasmParser().parse(qasm)
+
+    assert parsed_qasm.input_params == {'theta': f'{input_type}[64]'}
+
+    theta = sympy.Symbol('theta')
+    q_0 = cirq.NamedQubit('q_0')
+    expected_circuit = Circuit(QasmUGate(theta / np.pi, 0, 0).on(q_0))
+    ct.assert_same_circuits(parsed_qasm.circuit, expected_circuit)
+
+
+def test_input_two_params() -> None:
+    qasm = """
+        OPENQASM 3.0;
+        qreg q[1];
+        input angle[64] theta;
+        input float[64] phi;
+        U(theta, phi, 0) q[0];
+    """
+    parsed_qasm = QasmParser().parse(qasm)
+
+    assert parsed_qasm.input_params == {'theta': 'angle[64]', 'phi': 'float[64]'}
+
+    theta = sympy.Symbol('theta')
+    phi = sympy.Symbol('phi')
+    q_0 = cirq.NamedQubit('q_0')
+    expected_circuit = Circuit(QasmUGate(theta / np.pi, phi / np.pi, 0).on(q_0))
+    ct.assert_same_circuits(parsed_qasm.circuit, expected_circuit)
+
+
+def test_input_not_allowed_in_qasm2() -> None:
+    qasm = """
+        OPENQASM 2.0;
+        qreg q[1];
+        input float[64] n;
+    """
+    with pytest.raises(
+        QasmException, match="'input' modifier at line 4 is only supported in OpenQASM 3.0"
+    ):
+        QasmParser().parse(qasm)
+
+
+@pytest.mark.parametrize(
+    'first_decl,second_decl,name',
+    [
+        ('input float[32] theta;', 'input angle[32] theta;', 'theta'),
+        ('qreg q[1];', 'input float[32] q;', 'q'),
+        ('creg c[1];', 'input float[32] c;', 'c'),
+        ('input float[32] q;', 'qreg q[1];', 'q'),
+    ],
+)
+def test_input_duplicate_identifier_error(first_decl: str, second_decl: str, name: str) -> None:
+    qasm = f"""
+        OPENQASM 3.0;
+        {first_decl}
+        {second_decl}
+    """
+    with pytest.raises(QasmException, match=f"{name} is already defined"):
+        QasmParser().parse(qasm)
+
+
+def test_input_zero_bit_width_error() -> None:
+    qasm = """
+        OPENQASM 3.0;
+        qreg q[1];
+        input float[0] theta;
+    """
+    with pytest.raises(QasmException, match="Illegal bit width of zero for input 'theta'"):
+        QasmParser().parse(qasm)
+
+
+def test_input_invalid_type_error() -> None:
+    qasm = """
+        OPENQASM 3.0;
+        qreg q[1];
+        input badtype theta;
+    """
+    with pytest.raises(QasmException, match="Syntax error"):
+        QasmParser().parse(qasm)