Allow ParameterExpression values in TemplateOptimization pass

qiskit/circuit/exceptions.py

@@ -19,3 +19,9 @@ class CircuitError(QiskitError):
     """Base class for errors raised while processing a circuit."""
 
     pass
+
+
+class ParameterTypeError(TypeError):
+    """The type error throw by parameter if we try to cast to number unbind parameter."""
+
+    pass

qiskit/circuit/parameterexpression.py

@@ -19,7 +19,7 @@
 
 import numpy
 
-from qiskit.circuit.exceptions import CircuitError
+from qiskit.circuit.exceptions import CircuitError, ParameterTypeError
 
 try:
     import symengine
@@ -434,7 +434,7 @@ def __complex__(self):
             return complex(self._symbol_expr)
         # TypeError is for sympy, RuntimeError for symengine
         except (TypeError, RuntimeError) as exc:
-            raise TypeError(
+            raise ParameterTypeError(
                 "ParameterExpression with unbound parameters ({}) "
                 "cannot be cast to a complex.".format(self.parameters)
             ) from exc
@@ -444,7 +444,7 @@ def __float__(self):
             return float(self._symbol_expr)
         # TypeError is for sympy, RuntimeError for symengine
         except (TypeError, RuntimeError) as exc:
-            raise TypeError(
+            raise ParameterTypeError(
                 "ParameterExpression with unbound parameters ({}) "
                 "cannot be cast to a float.".format(self.parameters)
             ) from exc
@@ -532,6 +532,15 @@ def is_real(self):
                 return False
         return True
 
+    def to_simplify_expression(self):
+        """Return symbolic expression from sympy/symengine"""
+        if HAS_SYMENGINE:
+            return symengine.sympify(self._symbol_expr)
+        else:
+            from sympy import sympify
+
+            return sympify(self._symbol_expr)
+
 
 # Redefine the type so external imports get an evaluated reference; Sphinx needs this to understand
 # the type hints.

qiskit/dagcircuit/dagcircuit.py

@@ -215,6 +215,7 @@ def add_calibration(self, gate, qubits, schedule, params=None):
         Raises:
             Exception: if the gate is of type string and params is None.
         """
+
         if isinstance(gate, Gate):
             self._calibrations[gate.name][
                 (tuple(qubits), tuple(float(p) for p in gate.params))

qiskit/extensions/unitary.py

@@ -30,6 +30,7 @@
 from qiskit.quantum_info.synthesis.one_qubit_decompose import OneQubitEulerDecomposer
 from qiskit.quantum_info.synthesis.two_qubit_decompose import two_qubit_cnot_decompose
 from qiskit.extensions.exceptions import ExtensionError
+from qiskit.circuit.exceptions import ParameterTypeError
 
 _DECOMPOSER1Q = OneQubitEulerDecomposer("U3")
 
@@ -46,6 +47,7 @@ def __init__(self, data, label=None):
 
         Raises:
             ExtensionError: if input data is not an N-qubit unitary operator.
+            ParameterTypeError: if parameter is unbound so that type cannot be determined.
         """
         if hasattr(data, "to_matrix"):
             # If input is Gate subclass or some other class object that has
@@ -56,11 +58,19 @@ def __init__(self, data, label=None):
             # the object to an Operator so that we can extract the underlying
             # numpy matrix from `Operator.data`.
             data = data.to_operator().data
-        # Convert to numpy array in case not already an array
-        data = numpy.array(data, dtype=complex)
-        # Check input is unitary
-        if not is_unitary_matrix(data):
-            raise ExtensionError("Input matrix is not unitary.")
+
+        # Check if there is any unbound parameter in array
+        try:
+            # Convert to numpy array in case not already an array
+            data = numpy.array(data, dtype=complex)
+
+            # Check input is unitary
+            if not is_unitary_matrix(data):
+                raise ExtensionError("Input matrix is not unitary.")
+        except ParameterTypeError:
+            print("Type of unbound Parameter cannot be determined to ensure unitarity.")
+            pass
+
         # Check input is N-qubit matrix
         input_dim, output_dim = data.shape
         num_qubits = int(numpy.log2(input_dim))

qiskit/transpiler/passes/calibration/builders.py

@@ -25,6 +25,7 @@
 from qiskit.circuit.library.standard_gates import RZXGate
 from qiskit.dagcircuit import DAGCircuit
 from qiskit.exceptions import QiskitError
+from qiskit.transpiler.exceptions import TranspilerError
 from qiskit.pulse import (
     Play,
     Delay,
@@ -224,10 +225,18 @@ def get_calibration(self, node_op: CircuitInst, qubits: List) -> Union[Schedule,
             schedule: The calibration schedule for the RZXGate(theta).
 
         Raises:
-            QiskitError: if the control and target qubits cannot be identified or the backend
-                does not support cx between the qubits.
+            QiskitError: If the control and target
+                qubits cannot be identified, or the backend does not support cx between
+                the qubits.
+            TranspilerError: If all Parameters are not bound.
         """
-        theta = node_op.params[0]
+        try:
+            theta = float(node_op.params[0])
+        except TypeError as ex:
+            raise TranspilerError(
+                "This transpilation pass requires all Parameters to be bound and real."
+            ) from ex
+
         q1, q2 = qubits[0], qubits[1]
 
         if not self._inst_map.has("cx", qubits):

qiskit/transpiler/passes/optimization/template_matching/template_substitution.py

@@ -269,11 +269,6 @@ def _remove_impossible(self):
         list_predecessors = []
         remove_list = []
 
-        # First remove any scenarios that have parameters in the template.
-        for scenario in self.substitution_list:
-            if scenario.has_parameters():
-                remove_list.append(scenario)
-
         # Initialize predecessors for each group of matches.
         for scenario in self.substitution_list:
             predecessors = set()
@@ -500,39 +495,45 @@ def _attempt_bind(self, template_sublist, circuit_sublist):
             template_params += template_dag_dep.get_node(t_idx).op.params
 
         # Create the fake binding dict and check
-        equations, symbols, sol, fake_bind = [], set(), {}, {}
-        for t_idx, params in enumerate(template_params):
-            if isinstance(params, ParameterExpression):
-                equations.append(sym.Eq(parse_expr(str(params)), circuit_params[t_idx]))
-                for param in params.parameters:
-                    symbols.add(param)
-
-        if not symbols:
+        equations, circ_dict, temp_symbols, sol, fake_bind = [], {}, {}, {}, {}
+        for circuit_param, template_param in zip(circuit_params, template_params):
+            if isinstance(template_param, ParameterExpression):
+                if isinstance(circuit_param, ParameterExpression):
+                    circ_param_sym = circuit_param.to_simplify_expression()
+                else:
+                    circ_param_sym = parse_expr(str(circuit_param))
+                equations.append(sym.Eq(template_param.to_simplify_expression(), circ_param_sym))
+
+                for param in template_param.parameters:
+                    temp_symbols[param] = param.to_simplify_expression()
+
+                if isinstance(circuit_param, ParameterExpression):
+                    for param in circuit_param.parameters:
+                        circ_dict[param] = param.to_simplify_expression()
+
+        if not temp_symbols:
             return template_dag_dep
 
         # Check compatibility by solving the resulting equation
-        sym_sol = sym.solve(equations)
+        sym_sol = sym.solve(equations, set(temp_symbols.values()))
         for key in sym_sol:
             try:
-                sol[str(key)] = float(sym_sol[key])
+                sol[str(key)] = ParameterExpression(circ_dict, sym_sol[key])
             except TypeError:
                 return None
 
         if not sol:
             return None
 
-        for param in symbols:
-            fake_bind[param] = sol[str(param)]
+        for key in temp_symbols:
+            fake_bind[key] = sol[str(key)]
 
         for node in template_dag_dep.get_nodes():
             bound_params = []
-
             for param in node.op.params:
                 if isinstance(param, ParameterExpression):
-                    try:
-                        bound_params.append(float(param.bind(fake_bind)))
-                    except KeyError:
-                        return None
+                    for key in fake_bind:
+                        bound_params.append(param.assign(key, fake_bind[key]))
                 else:
                     bound_params.append(param)
 

releasenotes/notes/add-parameters-to-template-substitution-a1379cdbfcc10b5c.yaml

@@ -0,0 +1,78 @@
+---
+features:
+  - |
+    The :class:`.ParameterExpression` class is now allowed in the 
+    template optimization transpiler pass. An illustrative example 
+    of using :class:`.Parameter`\s is the following:
+
+    .. code-block:: 
+
+      from qiskit import QuantumCircuit, transpile, schedule
+      from qiskit.circuit import Parameter
+
+      from qiskit.transpiler import PassManager
+      from qiskit.transpiler.passes import TemplateOptimization
+
+      # New contributions to the template optimization
+      from qiskit.transpiler.passes.scheduling import RZXCalibrationBuilder, rzx_templates
+
+      from qiskit.test.mock import FakeCasablanca
+      backend = FakeCasablanca()
+
+      phi = Parameter('φ')
+
+      qc = QuantumCircuit(2)
+      qc.cx(0,1)
+      qc.p(2*phi, 1)
+      qc.cx(0,1)
+      print('Original circuit:')
+      print(qc)
+
+      pass_ = TemplateOptimization(**rzx_templates.rzx_templates(['zz2']))
+      qc_cz = PassManager(pass_).run(qc)
+      print('ZX based circuit:')
+      print(qc_cz)
+
+      # Add the calibrations
+      pass_ = RZXCalibrationBuilder(backend)
+      cal_qc = PassManager(pass_).run(qc_cz.bind_parameters({phi: 0.12}))
+
+      # Transpile to the backend basis gates
+      cal_qct = transpile(cal_qc, backend)
+      qct = transpile(qc.bind_parameters({phi: 0.12}), backend)
+
+      # Compare the schedule durations
+      print('Duration of schedule with the calibration:')
+      print(schedule(cal_qct, backend).duration)
+      print('Duration of standard with two CNOT gates:')
+      print(schedule(qct, backend).duration)
+
+    outputs
+
+    .. parsed-literal::
+
+      Original circuit:
+
+      q_0: ──■──────────────■──
+           ┌─┴─┐┌────────┐┌─┴─┐
+      q_1: ┤ X ├┤ P(2*φ) ├┤ X ├
+           └───┘└────────┘└───┘
+      ZX based circuit:
+      					 ┌─────────────┐            »
+      q_0: ────────────────────────────────────┤0            ├────────────»
+           ┌──────────┐┌──────────┐┌──────────┐│  Rzx(2.0*φ) │┌──────────┐»
+      q_1: ┤ Rz(-π/2) ├┤ Rx(-π/2) ├┤ Rz(-π/2) ├┤1            ├┤ Rx(-2*φ) ├»
+           └──────────┘└──────────┘└──────────┘└─────────────┘└──────────┘»
+      «                                                     
+      «q_0: ────────────────────────────────────────────────
+      «     ┌──────────┐┌──────────┐┌──────────┐┌──────────┐
+      «q_1: ┤ Rz(-π/2) ├┤ Rx(-π/2) ├┤ Rz(-π/2) ├┤ P(2.0*φ) ├
+      «     └──────────┘└──────────┘└──────────┘└──────────┘
+      Duration of schedule with the calibration:
+      1600
+      Duration of standard with two CNOT gates:
+      6848
+
+    Note that the :class:`.Parameter`\s/:class:`.ParameterExpression`\s 
+    must be bound before the :class:`.RZXCalibrationBuilder` can define 
+    calibrations for the :class:`.RZXGate`\ s.

test/python/transpiler/test_template_matching.py

@@ -24,6 +24,7 @@
 from qiskit.converters.circuit_to_dagdependency import circuit_to_dagdependency
 from qiskit.transpiler import PassManager
 from qiskit.transpiler.passes import TemplateOptimization
+from qiskit.transpiler.passes.calibration.rzx_templates import rzx_templates
 from qiskit.test import QiskitTestCase
 from qiskit.transpiler.exceptions import TranspilerError
 
@@ -353,9 +354,24 @@ def template():
         pass_ = TemplateOptimization(template_list=[template()])
         circuit_out = PassManager(pass_).run(circuit_in)
 
-        # This template will not fully match as long as gates with parameters do not
-        # commute with any other gates in the DAG dependency.
-        self.assertEqual(circuit_out.count_ops().get("cx", 0), 2)
+        self.assertEqual(circuit_out.count_ops().get("cx", 0), 0)
+
+    def test_unbound_parameters_in_rzx_template(self):
+        """
+        Test that rzx template ('zz2') functions correctly for a simple
+        circuit with an unbound ParameterExpression.
+        """
+
+        phi = Parameter("$\\phi$")
+        circuit_in = QuantumCircuit(2)
+        circuit_in.cx(0, 1)
+        circuit_in.p(2 * phi, 1)
+        circuit_in.cx(0, 1)
+
+        pass_ = TemplateOptimization(**rzx_templates(["zz2"]))
+        circuit_out = PassManager(pass_).run(circuit_in)
+
+        self.assertEqual(circuit_out.count_ops().get("cx", 0), 0)
 
 
 if __name__ == "__main__":