QCut 2.2.0__tar.gz → 2.3.0__tar.gz

{qcut-2.2.0 → qcut-2.3.0}/CHANGELOG.rst

@@ -2,6 +2,37 @@
 Changelog
 =========
 
+**Version 2.3.0**
+=================
+
+Remove Qiskit-Aer dependency
+----------------------------
+
+- :code:`run()` and :code:`run_cut_circuit()` no longer default to :code:`AerSimulator()`;
+  pass a backend or sampler. :code:`qiskit-aer` is no longer installed with QCut, so
+  install it separately to simulate.
+- :code:`transpile_subcircuits()` and :code:`transpile_experiments()` read a backend's
+  public :code:`target` rather than :code:`_target`, which Aer never fills in. Transpiling
+  for :code:`AerSimulator` works, and :code:`run_cut_circuit()` transpiles only for a
+  backend with a coupling map.
+
+Deduplicated experiment circuits
+--------------------------------
+
+- A run now submits each *distinct* experiment circuit once and shares its result with
+  every slot it fills.
+- :code:`shots` still means shots per circuit, so a run spends that many on each
+  distinct circuit and the total drops by the same factor. What the old total bought
+  was re-measuring circuits already measured. Sharing a sample between groups leaves the estimate unbiased,
+  since the groups are summed rather than multiplied.
+- :code:`estimate_run()` counts the circuits and shots that are actually submitted, so
+  it still matches the run exactly.
+- :code:`CutOptions(deduplicate=False)` restores one submission per slot.
+  :code:`CutExperiment.num_circuits` is unchanged: it still counts the circuits the
+  decomposition calls for.
+- Experiments whose wire cuts communicate are unaffected for now. Their first wave
+  already shares circuits between the groups that differ only in the label they answer.
+
 **Version 2.2.0**
 =================
 

{qcut-2.2.0 → qcut-2.3.0}/PKG-INFO

@@ -1,8 +1,8 @@
 Metadata-Version: 2.4
 Name: QCut
-Version: 2.2.0
+Version: 2.3.0
 Summary: QCut is a quantum circuit knitting package built on top of qiskit for performing gate cuts and resetless wire cuts allowing simulation of larger quantum circuits on smaller quantum devices or simulators at the cost of a circuit overhead.
-Author-email: Joonas Nivala <joonas.nivala@gmail.com>
+Author-email: Joonas Nivala <joonas.nivala@csc.fi>, FiQCI <servicedesk@csc.fi>
 License:                                  Apache License
                                    Version 2.0, January 2004
                                 http://www.apache.org/licenses/
@@ -205,10 +205,10 @@ License:                                  Apache License
            See the License for the specific language governing permissions and
            limitations under the License.
         
-Project-URL: homepage, https://github.com/JooNiv/QCut
-Project-URL: documentation, https://jooniv.github.io/QCut/
-Project-URL: repository, https://github.com/JooNiv/QCut.git
-Project-URL: changelog, https://github.com/JooNiv/QCut/blob/main/CHANGELOG.rst
+Project-URL: homepage, https://github.com/FiQCI/QCut
+Project-URL: documentation, https://fiqci.fi/QCut/
+Project-URL: repository, https://github.com/FiQCI/QCut.git
+Project-URL: changelog, https://github.com/FiQCI/QCut/blob/main/CHANGELOG.rst
 Classifier: Programming Language :: Python :: 3 :: Only
 Classifier: Programming Language :: Python :: 3.11
 Classifier: Programming Language :: Python :: 3.12
@@ -219,7 +219,6 @@ Description-Content-Type: text/markdown
 License-File: LICENSE
 Requires-Dist: qiskit<3.0,>=1.1
 Requires-Dist: numpy
-Requires-Dist: qiskit-aer<0.18
 Requires-Dist: pymetis==2025.2.2
 Provides-Extra: dev
 Requires-Dist: pytest; extra == "dev"
@@ -258,7 +257,7 @@ Dynamic: license-file
 
 # QCut
 
-![QCut Banner](docs/_static/images/logos/qcut-banner.png)
+<img src="docs/_static/images/diagram/qcut-diagram-left-logo.png" alt="QCut Diagram" width="1000">
 
 QCut is a quantum circuit knitting package built on top of qiskit for performing gate cuts and resetless wire cuts allowing simulation of larger quantum circuits on smaller quantum devices or simulators at the cost of a circuit overhead. QCut has been designed and tested to work with IQM's qpus, and the Finnish Quantum Computing Infrastructure ([FiQCI](https://fiqci.fi/)).
 
@@ -281,6 +280,8 @@ uv add QCut
 
 If using other than the default Qiskit version (newest) it is recommended to install Qiskit first before installing QCut.
 
+QCut does not install a simulator. The examples below run on [Qiskit Aer](https://github.com/Qiskit/qiskit-aer), which needs `uv pip install qiskit-aer`.
+
 **IQM hardware and fake backends:**
 
 ```bash
@@ -297,6 +298,7 @@ After installing you can simply import what you need:
 
 ```python
 from iqm.qiskit_iqm import IQMFakeAdonis
+
 backend = IQMFakeAdonis()
 ```
 
@@ -342,7 +344,10 @@ from qiskit import QuantumCircuit, transpile
 from qiskit.circuit.library import CXGate
 from qiskit.quantum_info import SparsePauliOp
 from qiskit_aer import AerSimulator
-from qiskit.primitives import StatevectorEstimator as Estimator, BackendEstimatorV2 as BackendEstimator
+from qiskit.primitives import (
+    StatevectorEstimator as Estimator,
+    BackendEstimatorV2 as BackendEstimator,
+)
 from iqm.qiskit_iqm import IQMFakeAdonis
 ```
 
@@ -352,11 +357,11 @@ from iqm.qiskit_iqm import IQMFakeAdonis
 circuit = QuantumCircuit(5)
 
 for qubit in range(5):
-    circuit.ry(0.4 + 0.3*qubit, qubit)
-circuit.cx(0,1)
-circuit.cx(1,2)
-circuit.cx(2,3)
-circuit.cx(3,4)
+    circuit.ry(0.4 + 0.3 * qubit, qubit)
+circuit.cx(0, 1)
+circuit.cx(1, 2)
+circuit.cx(2, 3)
+circuit.cx(3, 4)
 
 circuit.draw("mpl")
 ```
@@ -371,12 +376,12 @@ Note that here we don't insert any measurements. Measurements will be automatica
 marked_circuit = QuantumCircuit(5)
 
 for qubit in range(5):
-    marked_circuit.ry(0.4 + 0.3*qubit, qubit)
-marked_circuit.cx(0,1)
+    marked_circuit.ry(0.4 + 0.3 * qubit, qubit)
+marked_circuit.cx(0, 1)
 marked_circuit.append(**cutGate(CXGate(), 1, 2))
-marked_circuit.cx(2,3)
+marked_circuit.cx(2, 3)
 marked_circuit.append(cut(), [3])
-marked_circuit.cx(3,4)
+marked_circuit.cx(3, 4)
 
 marked_circuit.decompose(gates_to_decompose=["CutGate"]).draw("mpl")
 ```
@@ -527,8 +532,8 @@ finder's own options and how it chooses.
 Two helpers, `transpile_subcircuits()` and `transpile_experiments()` , differing in when they run:
 
 ```python
-fake = IQMFakeAdonis() #noisy
-sim = AerSimulator() #ideal
+fake = IQMFakeAdonis()  # noisy
+sim = AerSimulator()  # ideal
 ```
 
 `transpile_circuits()` does whichever of the two the thing it is given calls for. Each
@@ -570,12 +575,18 @@ The cost of an experiment run can be checked before submission:
 print(ck.estimate_run(cut_experiment, shots=4096, max_batch_size=40))
 ```
 
-`Experiment will run 144 circuits in 4 jobs with a total of 589824 shots. See the returned object for the breakdown.`
+`Experiment will run 31 circuits in 1 jobs with a total of 126976 shots. See the returned object for the breakdown.`
 
 ```python
-{'job1': JobEstimate(circuits=40, shots=4096), 'job2': JobEstimate(circuits=40, shots=4096), ...}
+{"job1": JobEstimate(circuits=31, shots=4096)}
 ```
 
+31 circuits, not the 144 the decomposition calls for: a subcircuit's experiment circuit
+depends only on the QPD terms of the cuts touching it and on the measurement setting
+over its own qubits, so most of them repeat. Each distinct one is submitted once and its
+result shared, which is where the saving comes from. `shots` still means shots per
+circuit. Pass `CutOptions(deduplicate=False)` to submit one circuit per slot instead.
+
 Exact for non-cummunicating runs. Runs whose wire cuts communicate get executed in waves so that
 each wave after the first spends its shots on what the one before it measured. For these jobs
 the circuit count is exact and job and shot counts are estimates.
@@ -604,8 +615,11 @@ Comparing against the exact and noisy expectation values of the original circuit
 
 ```python
 estimator = Estimator()
-exact_expvals = [e.data.evs for e in
-    estimator.run([(x) for x in zip([circuit] * len(observables), observables)]).result()
+exact_expvals = [
+    e.data.evs
+    for e in estimator.run(
+        [(x) for x in zip([circuit] * len(observables), observables)]
+    ).result()
 ]
 
 tr = transpile(circuit, backend=fake)
@@ -615,8 +629,11 @@ tr_obs_separate = [
 ]
 
 fake_estimator = BackendEstimator(backend=fake)
-exps = [e.data.evs for e in
-    fake_estimator.run([(x) for x in zip([tr] * len(tr_obs_separate), tr_obs_separate)]).result()
+exps = [
+    e.data.evs
+    for e in fake_estimator.run(
+        [(x) for x in zip([tr] * len(tr_obs_separate), tr_obs_separate)]
+    ).result()
 ]
 ```
 
@@ -682,19 +699,19 @@ for how the distribution is reconstructed.
 The result is a mapping, so it indexes and plots like a dict, and carries three views:
 
 ```python
-probs['00']                     # 0.8658
-probs.quasi_probabilities()     # the same values, as a plain dict
-probs.nearest_probabilities()   # closest true distribution, negatives projected away
-probs.counts()                  # scaled by the shots the experiment ran at
-probs.counts(shots=1000)        # or by any other shots
+probs["00"]  # 0.8658
+probs.quasi_probabilities()  # the same values, as a plain dict
+probs.nearest_probabilities()  # closest true distribution, negatives projected away
+probs.counts()  # scaled by the shots the experiment ran at
+probs.counts(shots=1000)  # or by any other shots
 ```
 
 The three dict views report, by default, the ten most likely bitstrings. Pass `top` for a different
 number, or `top=None` for all of them:
 
 ```python
-probs.quasi_probabilities(top=50)      # the fifty most likely
-probs.counts(shots=1000, top=None)     # the whole distribution, as before
+probs.quasi_probabilities(top=50)  # the fifty most likely
+probs.counts(shots=1000, top=None)  # the whole distribution, as before
 ```
 
 Note that :code:`counts()` sums to :code:`shots` only with :code:`top=None` and

{qcut-2.2.0 → qcut-2.3.0}/QCut/execution/backend_utility.py

@@ -8,7 +8,8 @@ import logging
 from collections import defaultdict
 
 from qiskit import QuantumCircuit, transpile
-from qiskit.circuit import Gate
+from qiskit.circuit import Gate, Instruction
+from qiskit.circuit.library import get_standard_gate_name_mapping
 from qiskit.transpiler import PassManager, Target
 
 from QCut.cutcircuit import CutCircuit, CutExperiment
@@ -96,11 +97,15 @@ def _add_block_gates(target, coupling_map, members: dict[str, list[str]]) -> set
     is free to hand the marker its qubits either way round. Qiskit can turn a ``cz`` the
     right way because it knows the gate is symmetric; a marker is opaque, so an
     unsupported orientation is a transpiler error rather than something it can fix.
+
+    Without a coupling map every pair is coupled, so the marker is declared global.
     """
-    loci = {}
-    for first, second in coupling_map.get_edges():
-        loci[(first, second)] = None
-        loci[(second, first)] = None
+    loci = None
+    if coupling_map is not None:
+        loci = {}
+        for first, second in coupling_map.get_edges():
+            loci[(first, second)] = None
+            loci[(second, first)] = None
     for name, group in members.items():
         target.add_instruction(
             Gate(num_qubits=len(group), name=name, params=[], label=name),
@@ -235,6 +240,40 @@ def _placeholder_gates(cut_circuit) -> dict[str, Gate]:
     return gates
 
 
+def _target_of(backend) -> Target:
+    """A backend's target, read through the public ``target``.
+
+    Raises:
+        QCutError: the backend has no target to transpile for.
+    """
+    target = getattr(backend, "target", None)
+    if target is None:
+        raise QCutError(
+            f"{backend} has no target to transpile for. Pass a backend that has one."
+        )
+    return target
+
+
+def _basis(target: Target) -> tuple[list[str], dict[str, Instruction]]:
+    """The operations a target names, and those of them qiskit would not recognise."""
+    standard = get_standard_gate_name_mapping()
+    names: set[str] = set()
+    custom: dict[str, Instruction] = {}
+    for operation in target.operations:
+        if not isinstance(operation, Instruction):
+            continue
+        names.add(operation.name)
+        if operation.name not in standard:
+            custom[operation.name] = operation
+    return sorted(names), custom
+
+
+def has_topology(backend) -> bool:
+    """Whether running on ``backend`` needs its circuits transpiled first."""
+    target = getattr(backend, "target", None)
+    return target is not None and target.build_coupling_map() is not None
+
+
 def _iqm_transpiler_for(backend):
     """Return IQM's transpiler if it is installed and ``backend`` is one of its own.
 
@@ -312,27 +351,16 @@ def transpile_subcircuits(
     # the multi-qubit operation it is rather than as unrelated single-qubit ones.
     spans, block_members = _block_spans(cut_circuit)
 
-    target = Target()
-
-    try:
-        basis_gates = list(
-            {
-                i[0].name
-                for i in backend._target.instructions
-                if isinstance(i[0].name, str)
-            }
-        )
-
-    except Exception as e:
-        raise ValueError(f"Error accessing backend target instructions: {e}")
-
-    target = target.from_configuration(
+    backend_target = _target_of(backend)
+    coupling_map = backend_target.build_coupling_map()
+    basis_gates, backend_gates = _basis(backend_target)
+    target = Target.from_configuration(
         num_qubits=backend.num_qubits,
-        coupling_map=backend._coupling_map,
+        coupling_map=coupling_map,
         basis_gates=basis_gates + list(custom_gates.keys()),
-        custom_name_mapping=custom_gates,
+        custom_name_mapping={**backend_gates, **custom_gates},
     )
-    block_names = _add_block_gates(target, backend._coupling_map, block_members)
+    block_names = _add_block_gates(target, coupling_map, block_members)
 
     # Fenced first: a placeholder is a single-qubit gate as far as the transpiler is
     # concerned, so without barriers it gets commuted past the others and the experiment
@@ -551,20 +579,17 @@ def transpile_circuits(
             for circuit in circuits
         ]
 
-    # A simulator has no target to build one from, and needs none: it takes the
-    # circuits as they are, so it is handed itself instead.
+    # An ideal simulator has no topology to build a target from, and needs none: it
+    # takes the circuits as they are, so it is handed itself instead.
     target = None
-    if getattr(backend, "_target", None) is not None:
-        target = Target().from_configuration(
+    if has_topology(backend):
+        backend_target = _target_of(backend)
+        basis_gates, backend_gates = _basis(backend_target)
+        target = Target.from_configuration(
             num_qubits=backend.num_qubits,
-            coupling_map=backend._coupling_map,
-            basis_gates=sorted(
-                {
-                    item[0].name
-                    for item in backend._target.instructions
-                    if isinstance(item[0].name, str)
-                }
-            ),
+            coupling_map=backend_target.build_coupling_map(),
+            basis_gates=basis_gates,
+            custom_name_mapping=backend_gates,
         )
 
     return [

{qcut-2.2.0 → qcut-2.3.0}/QCut/execution/circuit_knitting.py

@@ -17,12 +17,11 @@ from qiskit.circuit import (
 from qiskit.circuit.library import get_standard_gate_name_mapping
 from qiskit.converters import circuit_to_dag, dag_to_circuit
 from qiskit.primitives import BaseSamplerV2
-from qiskit_aer import AerSimulator
 
 from QCut.cutcircuit import CutCircuit, CutExperiment
 from QCut.cutting.circuit_preparation import get_locations_and_subcircuits
 from QCut.errors.qcuterror import QCutError
-from QCut.execution.backend_utility import transpile_subcircuits
+from QCut.execution.backend_utility import has_topology, transpile_subcircuits
 from QCut.execution.basis_transform import (
     _combine_pauli_ops,
     _get_obs_subcircuits,
@@ -56,7 +55,12 @@ from QCut.qpd.qpd_operations import (
     qpd_for_bundle,
     sample_qpd_combinations,
 )
-from QCut.utils.circuit_utils import _remove_obsm, _remove_obsm_2, compact_qpd_register
+from QCut.utils.circuit_utils import (
+    _remove_obsm,
+    _remove_obsm_2,
+    circuit_fingerprint,
+    compact_qpd_register,
+)
 
 logger: logging.Logger = logging.getLogger(__name__)
 
@@ -906,6 +910,13 @@ def _run_communicating(cut_experiment, shots, backend, max_batch_size, run_optio
     The budget is not divided evenly between the waves. Sharing makes a measuring shot
     worth more than a preparing one, so wave zero takes :data:`MEASURE_SHARE` of the run
     and the later waves divide the rest. The total is unchanged either way.
+
+    TODO: the waves after the first do not share circuits at all. ``_later_wave_jobs``
+    gives every group a job of its own, where :func:`_deduplicate` would collapse the
+    groups holding the same circuit as wave zero's ``plan.keys`` already does. It is not
+    the same change as the plain path's, because each group carries its own shot
+    allocation by then, so the shared job would have to run at their sum and be scaled
+    back per group.
     """
     plan = cut_experiment.plan
     results: list[list[dict[int, CircuitResult]]] = [
@@ -1049,6 +1060,83 @@ def _projected_wave_jobs(cut_experiment, wave: int, shots: int):
     ]
 
 
+#: One slot of an experiment: which group, which measurement setting, which subcircuit.
+Slot = tuple[int, int, int]
+
+
+def _runnable(cut_experiment) -> tuple[list, list]:
+    """Split an experiment's slots into the ones worth submitting and the ones not.
+
+    A QPD term that measures nothing on a subcircuit leaves a circuit with no
+    measurements at all. There is nothing to run, and its counts are known: every shot
+    reads zero. Those are filled in directly rather than submitted.
+
+    Returns:
+        The slots to submit, as ``(slot, circuit)``, and the empty ones, as
+        ``(slot, num_clbits)``. Both in group, setting, subcircuit order.
+    """
+    runnable: list[tuple[Slot, QuantumCircuit]] = []
+    empty: list[tuple[Slot, int]] = []
+    for group_idx, circuit_group in enumerate(cut_experiment.experiments):
+        for obs_idx, obs_group in enumerate(circuit_group):
+            for sub_idx, subcircuit in obs_group.items():
+                slot = (group_idx, obs_idx, sub_idx)
+                if _has_measurements(subcircuit):
+                    runnable.append((slot, subcircuit))
+                else:
+                    empty.append((slot, subcircuit.num_clbits))
+    return runnable, empty
+
+
+def _deduplicate(runnable: list, enabled: bool) -> list[tuple[list, QuantumCircuit]]:
+    """Group slots filled by the same circuit, so it is only submitted once.
+
+    A subcircuit's experiment circuit depends on the QPD terms of the cuts touching that
+    subcircuit and on the measurement setting restricted to its own qubits, neither of
+    which most of an experiment's groups change. The slot count grows exponentially in
+    the number of pieces and the distinct count linearly, so almost all of a large run
+    is the same handful of circuits submitted over and over.
+
+    The key carries the subcircuit index as well as the fingerprint. The estimator takes
+    one factor per subcircuit from each group and multiplies them, so two factors of a
+    single product sharing a sample would give ``E[X**2]`` where ``E[X]**2`` is meant.
+    Keying on the subcircuit makes that impossible, since a group holds each subcircuit
+    once. Sharing between groups is a different matter: groups are summed rather than
+    multiplied, so it leaves the estimate unbiased and moves only its variance.
+
+    Two subcircuits of a symmetric circuit really can produce identical experiment
+    circuits, so this is not a theoretical concern.
+
+    Returns:
+        ``(slots, circuit)`` per distinct circuit, in the order first seen, so two runs
+        of one experiment submit the same circuits in the same order.
+    """
+    if not enabled:
+        return [([slot], circuit) for slot, circuit in runnable]
+
+    cache: dict = {}
+    distinct: dict[tuple, tuple[list, QuantumCircuit]] = {}
+    for slot, circuit in runnable:
+        key = (slot[2], circuit_fingerprint(circuit, cache))
+        hit = distinct.get(key)
+        if hit is None:
+            distinct[key] = ([slot], circuit)
+        else:
+            hit[0].append(slot)
+    return list(distinct.values())
+
+
+def _submission(cut_experiment) -> tuple[list[tuple[list, QuantumCircuit]], list]:
+    """What a run of this experiment actually submits, and what it fills in itself."""
+    runnable, empty = _runnable(cut_experiment)
+    jobs = _deduplicate(runnable, cut_experiment.options.deduplicate)
+    if len(jobs) < len(runnable):
+        logger.info(
+            f"{len(runnable)} experiment circuits hold {len(jobs)} distinct ones"
+        )
+    return jobs, empty
+
+
 def estimate_run(
     cut_experiment: CutExperiment,
     shots: int = DEFAULT_SHOTS,
@@ -1079,18 +1167,14 @@ def estimate_run(
     cap = _backend_shot_cap(backend) if backend is not None else None
 
     if cut_experiment.plan is None:
-        runnable = [
-            circuit
-            for group in cut_experiment.experiments
-            for obs_group in group
-            for circuit in obs_group.values()
-            if _has_measurements(circuit)
-        ]
+        # Counted through the same pair the run uses, so an estimate cannot drift from
+        # what is submitted.
+        jobs, _empty = _submission(cut_experiment)
         return RunEstimate(
             _named(
                 [
-                    JobEstimate(len(runnable[start : start + max_batch_size]), shots)
-                    for start in range(0, len(runnable), max_batch_size)
+                    JobEstimate(len(jobs[start : start + max_batch_size]), shots)
+                    for start in range(0, len(jobs), max_batch_size)
                 ]
             ),
             exact=True,
@@ -1163,7 +1247,7 @@ def run_experiments(  # noqa: C901
 
     """
     if backend is None:
-        backend = AerSimulator()
+        raise QCutError("a backend or sampler to run the circuits on is needed")
 
     if cut_experiment.plan is not None:
         results = _run_communicating(
@@ -1172,26 +1256,19 @@ def run_experiments(  # noqa: C901
         return RawResult(results, shots, cut_experiment)
 
     results: list[list[dict[int, CircuitResult]]] = [
-        [{} for _ in group] for group in cut_experiment.experiments
+        # Seeded in subcircuit order, because the estimator reads a group's subcircuits
+        # back in the order these were filled, and deduplicated circuits fill them in
+        # the order they were submitted instead. The same reason _run_communicating
+        # seeds its own.
+        [{sub: CircuitResult({}) for sub in sorted(obs_group)} for obs_group in group]
+        for group in cut_experiment.experiments
     ]
 
-    runnable: list[tuple[tuple[int, int, int], QuantumCircuit]] = []
-    empty_locations: list[tuple[tuple[int, int, int], int]] = []
-    for group_idx, circuit_group in enumerate(cut_experiment.experiments):
-        for obs_idx, obs_group in enumerate(circuit_group):
-            for sub_idx, subcircuit in obs_group.items():
-                key = (group_idx, obs_idx, sub_idx)
-                if _has_measurements(subcircuit):
-                    runnable.append((key, subcircuit))
-                else:
-                    empty_locations.append((key, subcircuit.num_clbits))
+    jobs, empty_locations = _submission(cut_experiment)
 
-    num_batches = len(runnable) // max_batch_size + (
-        1 if len(runnable) % max_batch_size else 0
-    )
+    num_batches = len(jobs) // max_batch_size + (1 if len(jobs) % max_batch_size else 0)
     logger.info(
-        f"Running {len(runnable)} circuits on the"
-        f" backend {backend} with {shots} shots each"
+        f"Running {len(jobs)} circuits on the backend {backend} with {shots} shots each"
     )
     logger.info(
         "Circuits will be split into "
@@ -1200,8 +1277,8 @@ def run_experiments(  # noqa: C901
     )
     # Submitted before any is collected, so every batch queues at once.
     submitted = []
-    for start in range(0, len(runnable), max_batch_size):
-        batch = runnable[start : start + max_batch_size]
+    for start in range(0, len(jobs), max_batch_size):
+        batch = jobs[start : start + max_batch_size]
         job = _submit(
             backend,
             [circ for _, circ in batch],
@@ -1214,9 +1291,13 @@ def run_experiments(  # noqa: C901
 
     for job, batch in submitted:
         result = _result(job)
-        for index, (key, _circ) in enumerate(batch):
-            group_idx, obs_idx, sub_idx = key
-            results[group_idx][obs_idx][sub_idx] = CircuitResult(result, index)
+        for index, (slots, _circ) in enumerate(batch):
+            # One result object for the circuit, shared by every slot it fills. It is
+            # frozen and holds the job's result by reference, so there is nothing to
+            # copy and nothing that could be mutated through one slot.
+            circuit_result = CircuitResult(result, index)
+            for group_idx, obs_idx, sub_idx in slots:
+                results[group_idx][obs_idx][sub_idx] = circuit_result
 
     for (group_idx, obs_idx, sub_idx), num_clbits in empty_locations:
         results[group_idx][obs_idx][sub_idx] = CircuitResult(
@@ -1229,7 +1310,7 @@ def run_experiments(  # noqa: C901
 def run_cut_circuit(
     cut_circuit: CutCircuit,
     observables: ObservablesLike | None = None,
-    backend=AerSimulator(),
+    backend=None,
     max_batch_size: int = 100,
     options: CutOptions | None = None,
     shots: int = DEFAULT_SHOTS,
@@ -1243,7 +1324,9 @@ def run_cut_circuit(
             operations and cut locations
         observables: the observables to estimate, taken as qiskit's estimator takes
             them. See :func:`get_experiment_circuits`.
-        backend: backend to use for running experiment circuits (optional)
+        backend: backend or V2 sampler to run the experiment circuits on. A device
+            with a coupling map gets the subcircuits transpiled for it first. A
+            sampler is not transpiled for, so it must take the circuits as built.
         max_batch_size (int): maximum number of circuits submitted per backend.run
             call (optional)
         options (CutOptions): configuration, overriding what the CutCircuit carries
@@ -1269,16 +1352,13 @@ def run_cut_circuit(
     if options is not None:
         cut_circuit.options = options
 
-    if not isinstance(backend, AerSimulator):
-        transpiled_subcircuits = transpile_subcircuits(
-            cut_circuit, backend, optimization_level=3
-        )
+    if backend is None:
+        raise QCutError("a backend or sampler to run the circuits on is needed")
 
-        cut_experiment = get_experiment_circuits(
-            transpiled_subcircuits, observables, qubits
-        )
-    else:
-        cut_experiment = get_experiment_circuits(cut_circuit, observables, qubits)
+    if has_topology(backend):
+        cut_circuit = transpile_subcircuits(cut_circuit, backend, optimization_level=3)
+
+    cut_experiment = get_experiment_circuits(cut_circuit, observables, qubits)
 
     results = run_experiments(
         cut_experiment,
@@ -1297,7 +1377,7 @@ def run_cut_circuit(
 def run(
     circuit: QuantumCircuit,
     observables: ObservablesLike | None = None,
-    backend=AerSimulator(),
+    backend=None,
     max_batch_size: int = 100,
     options: CutOptions | None = None,
     shots: int = DEFAULT_SHOTS,
@@ -1310,7 +1390,9 @@ def run(
         circuit (QuantumCircuit): circuit with cut experiments
         observables: the observables to estimate, taken as qiskit's estimator takes
             them. See :func:`get_experiment_circuits`.
-        backend: backend to use for running experiment circuits (optional)
+        backend: backend or V2 sampler to run the experiment circuits on. A device
+            with a coupling map gets the subcircuits transpiled for it first. A
+            sampler is not transpiled for, so it must take the circuits as built.
         max_batch_size (int): maximum number of circuits submitted per backend.run
             call (optional)
         options (CutOptions): configuration for the run (optional)