Transpile parallel experiment sub circuits (#680)

* Update ParallelExperiment to transpile sub experimetns

Parallel Experiment will now transpile sub experiments according to their individual transpile options before combining them. The combined circuits will then be transpiled again according to any options set in the parallel experiment transpile options.

* recursively set composite exp transpile options

Update CompositeExperiment.set_transpile_options to recursively set transpile options for each of the component experiments so that these options are not ignored for batch experiments.

Author: chriseclectic

qiskit_experiments/framework/composite/composite_experiment.py

@@ -69,6 +69,12 @@ def __init__(
     def circuits(self):
         pass
 
+    def set_transpile_options(self, **fields):
+        super().set_transpile_options(**fields)
+        # Recursively set transpile options of component experiments
+        for exp in self._experiments:
+            exp.set_transpile_options(**fields)
+
     @property
     def num_experiments(self):
         """Return the number of sub experiments"""

qiskit_experiments/framework/composite/parallel_experiment.py

@@ -16,6 +16,7 @@
 
 from qiskit import QuantumCircuit, ClassicalRegister
 from qiskit.providers.backend import Backend
+from qiskit_experiments.exceptions import QiskitError
 from .composite_experiment import CompositeExperiment, BaseExperiment
 from .composite_analysis import CompositeAnalysis
 
@@ -63,20 +64,27 @@ def circuits(self):
 
         sub_circuits = []
         sub_qubits = []
+        sub_maps = []
         sub_size = []
         num_qubits = 0
 
         # Generate data for combination
-        for expr in self._experiments:
+        for sub_exp in self._experiments:
+
+            # Generate transpiled subcircuits
+            circuits = sub_exp._transpiled_circuits()
+
             # Add subcircuits
-            circs = expr.circuits()
-            sub_circuits.append(circs)
-            sub_size.append(len(circs))
+            sub_circuits.append(circuits)
+            sub_size.append(len(circuits))
 
-            # Add sub qubits
-            qubits = list(range(num_qubits, num_qubits + expr.num_qubits))
+            # Sub experiment logical qubits in the combined circuits full qubits
+            qubits = list(range(num_qubits, num_qubits + sub_exp.num_qubits))
             sub_qubits.append(qubits)
-            num_qubits += expr.num_qubits
+            # Construct mapping for the sub-experiments logical qubits to physical qubits
+            # in the full combined circuits
+            sub_maps.append({q: qubits[i] for i, q in enumerate(sub_exp.physical_qubits)})
+            num_qubits += sub_exp.num_qubits
 
         # Generate empty joint circuits
         num_circuits = max(sub_size)
@@ -97,9 +105,37 @@ def circuits(self):
                     sub_circ = sub_circuits[exp_idx][circ_idx]
                     num_clbits = circuit.num_clbits
                     qubits = sub_qubits[exp_idx]
+                    qargs_map = sub_maps[exp_idx]
                     clbits = list(range(num_clbits, num_clbits + sub_circ.num_clbits))
                     circuit.add_register(ClassicalRegister(sub_circ.num_clbits))
-                    circuit.append(sub_circ, qubits, clbits)
+
+                    # Apply transpiled subcircuit
+                    # Note that this assumes the circuit was not expanded to use
+                    # any qubits outside the specified physical qubits
+                    for inst, qargs, cargs in sub_circ.data:
+                        try:
+                            mapped_qargs = [
+                                circuit.qubits[qargs_map[sub_circ.find_bit(i).index]] for i in qargs
+                            ]
+                        except KeyError as ex:
+                            # Instruction is outside physical qubits for the component
+                            # experiment.
+                            # This could legitimately happen if the subcircuit was
+                            # explicitly scheduled during transpilation which would
+                            # insert delays on all auxillary device qubits.
+                            # We skip delay instructions to allow for this.
+                            if inst.name == "delay":
+                                continue
+                            raise QiskitError(
+                                "Component experiment has been transpiled outside of the "
+                                "allowed physical qubits for that component. Check the "
+                                "experiment is valid on the backends coupling map."
+                            ) from ex
+                        mapped_cargs = [
+                            circuit.clbits[clbits[sub_circ.find_bit(i).index]] for i in cargs
+                        ]
+                        circuit._append(inst, mapped_qargs, mapped_cargs)
+
                     # Add subcircuit metadata
                     circuit.metadata["composite_index"].append(exp_idx)
                     circuit.metadata["composite_metadata"].append(sub_circ.metadata)
@@ -114,6 +150,6 @@ def circuits(self):
                             )
 
             # Add joint circuit to returned list
-            joint_circuits.append(circuit.decompose())
+            joint_circuits.append(circuit)
 
         return joint_circuits

releasenotes/notes/batch-transpile-b3c5e739d2eead63.yaml

@@ -0,0 +1,18 @@
+---
+upgrade:
+  - |
+    The component experiment circuits of :class:`.ParallelExperiment` and
+    :class:`.BatchExperiment` are now explicitly transpiled using the
+    respective component experiments
+    :meth:`~.BaseExperiment.transpile_options` before being combined into
+    the composite circuits returned by the :class:`.BaseExperiment.circuits`
+    method. 
+
+    Any transpile options set directly on the :class:`.ParallelExperiment`
+    or :class:`.BatchExperiment` will also be applied as a transpile option
+    to each component experiment.
+  - |
+    The circuits returned by the :meth:`.ParallelExperiment.circuits` method
+    of parallel circuits will now always be the combined circuits circuits
+    of the transpiled circuits of the individual component experiments
+    transpiled with that experiments transpile options.

releasenotes/notes/composite-exp-transpile-e37c257ba007ff40.yaml

@@ -191,6 +191,42 @@ def test_t1_low_quality(self):
         result = res[1]
         self.assertEqual(result.quality, "bad")
 
+    def test_t1_parallel_exp_transpile(self):
+        """Test parallel transpile options for T1 experiment"""
+        num_qubits = 5
+        instruction_durations = []
+        for i in range(num_qubits):
+            instruction_durations += [
+                ("rx", [i], (i + 1) * 10, "ns"),
+                ("measure", [i], (i + 1) * 1000, "ns"),
+            ]
+        coupling_map = [[i - 1, i] for i in range(1, num_qubits)]
+        basis_gates = ["rx", "delay"]
+
+        exp1 = T1(1, delays=[50e-9, 100e-9, 160e-9])
+        exp2 = T1(3, delays=[40e-9, 80e-9, 190e-9])
+        parexp = ParallelExperiment([exp1, exp2])
+        parexp.set_transpile_options(
+            basis_gates=basis_gates,
+            instruction_durations=instruction_durations,
+            coupling_map=coupling_map,
+            scheduling_method="alap",
+        )
+
+        circs = parexp.circuits()
+        for circ in circs:
+            self.assertEqual(circ.num_qubits, 2)
+            op_counts = circ.count_ops()
+            self.assertEqual(op_counts.get("rx"), 2)
+            self.assertEqual(op_counts.get("delay"), 2)
+
+        tcircs = parexp._transpiled_circuits()
+        for circ in tcircs:
+            self.assertEqual(circ.num_qubits, num_qubits)
+            op_counts = circ.count_ops()
+            self.assertEqual(op_counts.get("rx"), 2)
+            self.assertGreater(op_counts.get("delay"), num_qubits - 1)
+
     def test_experiment_config(self):
         """Test converting to and from config works"""
         exp = T1(0, [1, 2, 3, 4, 5])