Remove list argument broadcasting and simplify transpile()

qiskit/providers/fake_provider/fake_1q.py

@@ -89,11 +89,3 @@ def __init__(self):
             general=[],
         )
         super().__init__(configuration)
-
-    def defaults(self):
-        """defaults == configuration"""
-        return self._configuration
-
-    def properties(self):
-        """properties == configuration"""
-        return self._configuration

qiskit/providers/fake_provider/fake_backend.py

@@ -474,6 +474,8 @@ def _setup_sim(self):
     def properties(self):
         """Return backend properties"""
         coupling_map = self.configuration().coupling_map
+        if coupling_map is None:
+            return None
         unique_qubits = list(set().union(*coupling_map))
 
         properties = {

qiskit/transpiler/passmanager_config.py

@@ -106,7 +106,7 @@ def __init__(
         self.hls_config = hls_config
 
     @classmethod
-    def from_backend(cls, backend, **pass_manager_options):
+    def from_backend(cls, backend, _skip_target=False, **pass_manager_options):
         """Construct a configuration based on a backend and user input.
 
         This method automatically gererates a PassManagerConfig object based on the backend's
@@ -128,7 +128,6 @@ def from_backend(cls, backend, **pass_manager_options):
             backend_version = 0
         if backend_version < 2:
             config = backend.configuration()
-
         if res.basis_gates is None:
             if backend_version < 2:
                 res.basis_gates = getattr(config, "basis_gates", None)
@@ -156,7 +155,7 @@ def from_backend(cls, backend, **pass_manager_options):
                 res.instruction_durations = backend.instruction_durations
         if res.backend_properties is None and backend_version < 2:
             res.backend_properties = backend.properties()
-        if res.target is None:
+        if res.target is None and not _skip_target:
             if backend_version >= 2:
                 res.target = backend.target
         if res.scheduling_method is None and hasattr(backend, "get_scheduling_stage_plugin"):

qiskit/transpiler/preset_passmanagers/__init__.py

@@ -92,6 +92,8 @@ def generate_preset_pass_manager(
     hls_config=None,
     init_method=None,
     optimization_method=None,
+    *,
+    _skip_target=False,
 ):
     """Generate a preset :class:`~.PassManager`
 
@@ -241,10 +243,10 @@ def generate_preset_pass_manager(
     }
 
     if backend is not None:
+        pm_options["_skip_target"] = _skip_target
         pm_config = PassManagerConfig.from_backend(backend, **pm_options)
     else:
         pm_config = PassManagerConfig(**pm_options)
-
     if optimization_level == 0:
         pm = level_0_pass_manager(pm_config)
     elif optimization_level == 1:

releasenotes/notes/remove-transpile-broadcast-1dfde28d508efa0d.yaml

@@ -0,0 +1,43 @@
+---
+upgrade:
+  - |
+    Support for passing in lists of argument values to the :func:`~.transpile`
+    function is removed. This functionality was deprecated as part of the
+    0.23.0 release and is now being removed. Removing this functionality was
+    necessary to greatly reduce the overhead for parallel execution for
+    transpiling multiple circuits at once. If you’re using this functionality
+    currently you can call :func:`~.transpile` multiple times instead. For
+    example if you were previously doing something like::
+
+        from qiskit.transpiler import CouplingMap
+        from qiskit import QuantumCircuit
+        from qiskit import transpile
+
+        qc = QuantumCircuit(2)
+        qc.h(0)
+        qc.cx(0, 1)
+        qc.measure_all()
+
+        cmaps = [CouplingMap.from_heavy_hex(d) for d in range(3, 15, 2)]
+        results = transpile([qc] * 6, coupling_map=cmaps)
+
+    instead you should now run something like::
+
+        from itertools import cycle
+
+        from qiskit.transpiler import CouplingMap
+        from qiskit import QuantumCircuit
+        from qiskit import transpile
+
+        qc = QuantumCircuit(2)
+        qc.h(0)
+        qc.cx(0, 1)
+        qc.measure_all()
+
+        cmaps = [CouplingMap.from_heavy_hex(d) for d in range(3, 15, 2)]
+        results = []
+        for qc, cmap in zip(cycle([qc]), cmaps):
+            results.append(transpile(qc, coupling_map=cmap))
+
+    You can also leverage :func:`~.parallel_map` or ``multiprocessing`` from
+    the Python standard library if you want to run this in parallel.

test/python/compiler/test_transpiler.py

@@ -635,7 +635,7 @@ def test_wrong_initial_layout(self):
             QuantumRegister(3, "q")[2],
         ]
 
-        with self.assertRaisesRegex(TranspilerError, "different numbers of qubits"):
+        with self.assertRaises(TranspilerError):
             transpile(qc, backend, initial_layout=bad_initial_layout)
 
     def test_parameterized_circuit_for_simulator(self):
@@ -2085,24 +2085,16 @@ def test_transpile_with_multiple_coupling_maps(self):
         cmap = CouplingMap.from_line(7)
         cmap.add_edge(0, 2)
 
-        with self.assertWarnsRegex(
-            DeprecationWarning, "Passing in a list of arguments for coupling_map is deprecated"
-        ):
+        with self.assertRaisesRegex(TranspilerError, "Only a single input coupling"):
             # Initial layout needed to prevent transpiler from relabeling
             # qubits to avoid doing the swap
-            tqc = transpile(
+            transpile(
                 [qc] * 2,
                 backend,
                 coupling_map=[backend.coupling_map, cmap],
                 initial_layout=(0, 1, 2),
             )
 
-        # Check that the two coupling maps were used. The default should
-        # require swapping (extra cx's) and the second one should not (just the
-        # original cx).
-        self.assertEqual(tqc[0].count_ops()["cx"], 4)
-        self.assertEqual(tqc[1].count_ops()["cx"], 1)
-
     @data(0, 1, 2, 3)
     def test_backend_and_custom_gate(self, opt_level):
         """Test transpile() with BackendV2, custom basis pulse gate."""

test/python/providers/test_backend_v2.py

@@ -21,8 +21,6 @@
 
 from qiskit.circuit import QuantumCircuit, ClassicalRegister, QuantumRegister
 from qiskit.compiler import transpile
-from qiskit.compiler.transpiler import _parse_inst_map
-from qiskit.pulse.instruction_schedule_map import InstructionScheduleMap
 from qiskit.test.base import QiskitTestCase
 from qiskit.providers.fake_provider import FakeMumbaiFractionalCX
 from qiskit.providers.fake_provider.fake_backend_v2 import (
@@ -178,11 +176,6 @@ def test_transpile_mumbai_target(self):
         expected.measure(qr[1], cr[1])
         self.assertEqual(expected, tqc)
 
-    def test_transpile_parse_inst_map(self):
-        """Test that transpiler._parse_inst_map() supports BackendV2."""
-        inst_map = _parse_inst_map(inst_map=None, backend=self.backend)
-        self.assertIsInstance(inst_map, InstructionScheduleMap)
-
     @data(0, 1, 2, 3, 4)
     def test_drive_channel(self, qubit):
         """Test getting drive channel with qubit index."""