qiskit 1.4.2__cp39-abi3-macosx_11_0_arm64.whl → 2.0.0__cp39-abi3-macosx_11_0_arm64.whl

qiskit/compiler/scheduler.py

@@ -1,109 +0,0 @@
-# This code is part of Qiskit.
-#
-# (C) Copyright IBM 2019.
-#
-# This code is licensed under the Apache License, Version 2.0. You may
-# obtain a copy of this license in the LICENSE.txt file in the root directory
-# of this source tree or at http://www.apache.org/licenses/LICENSE-2.0.
-#
-# Any modifications or derivative works of this code must retain this
-# copyright notice, and modified files need to carry a notice indicating
-# that they have been altered from the originals.
-
-"""
-Convenience entry point into pulse scheduling, requiring only a circuit and a backend. For more
-control over pulse scheduling, look at `qiskit.scheduler.schedule_circuit`.
-"""
-import logging
-
-from time import time
-from typing import List, Optional, Union
-
-from qiskit.circuit.quantumcircuit import QuantumCircuit
-from qiskit.exceptions import QiskitError
-from qiskit.pulse import InstructionScheduleMap, Schedule
-from qiskit.providers.backend import Backend
-from qiskit.scheduler.config import ScheduleConfig
-from qiskit.scheduler.schedule_circuit import schedule_circuit
-from qiskit.utils.parallel import parallel_map
-from qiskit.utils.deprecate_pulse import deprecate_pulse_dependency
-
-logger = logging.getLogger(__name__)
-
-
-def _log_schedule_time(start_time, end_time):
-    log_msg = f"Total Scheduling Time - {((end_time - start_time) * 1000):.5f} (ms)"
-    logger.info(log_msg)
-
-
-@deprecate_pulse_dependency(moving_to_dynamics=True)
-def schedule(
-    circuits: Union[QuantumCircuit, List[QuantumCircuit]],
-    backend: Optional[Backend] = None,
-    inst_map: Optional[InstructionScheduleMap] = None,
-    meas_map: Optional[List[List[int]]] = None,
-    dt: Optional[float] = None,
-    method: Optional[Union[str, List[str]]] = None,
-) -> Union[Schedule, List[Schedule]]:
-    """
-    Schedule a circuit to a pulse ``Schedule``, using the backend, according to any specified
-    methods. Supported methods are documented in :py:mod:`qiskit.scheduler.schedule_circuit`.
-
-    Args:
-        circuits: The quantum circuit or circuits to translate
-        backend: A backend instance, which contains hardware-specific data required for scheduling
-        inst_map: Mapping of circuit operations to pulse schedules. If ``None``, defaults to the
-                  ``backend``\'s ``instruction_schedule_map``
-        meas_map: List of sets of qubits that must be measured together. If ``None``, defaults to
-                  the ``backend``\'s ``meas_map``
-        dt: The output sample rate of backend control electronics. For scheduled circuits
-            which contain time information, dt is required. If not provided, it will be
-            obtained from the backend configuration
-        method: Optionally specify a particular scheduling method
-
-    Returns:
-        A pulse ``Schedule`` that implements the input circuit
-
-    Raises:
-        QiskitError: If ``inst_map`` and ``meas_map`` are not passed and ``backend`` is not passed
-    """
-    arg_circuits_list = isinstance(circuits, list)
-    start_time = time()
-    if backend and getattr(backend, "version", 0) > 1:
-        if inst_map is None:
-            inst_map = backend.instruction_schedule_map
-        if meas_map is None:
-            meas_map = backend.meas_map
-        if dt is None:
-            dt = backend.dt
-    else:
-        if inst_map is None:
-            if backend is None:
-                raise QiskitError(
-                    "Must supply either a backend or InstructionScheduleMap for scheduling passes."
-                )
-            defaults = backend.defaults()
-            if defaults is None:
-                raise QiskitError(
-                    "The backend defaults are unavailable. The backend may not support pulse."
-                )
-            inst_map = defaults.instruction_schedule_map
-        if meas_map is None:
-            if backend is None:
-                raise QiskitError(
-                    "Must supply either a backend or a meas_map for scheduling passes."
-                )
-            meas_map = backend.configuration().meas_map
-        if dt is None:
-            if backend is not None:
-                dt = backend.configuration().dt
-
-    schedule_config = ScheduleConfig(inst_map=inst_map, meas_map=meas_map, dt=dt)
-    circuits = circuits if isinstance(circuits, list) else [circuits]
-    schedules = parallel_map(schedule_circuit, circuits, (schedule_config, method, backend))
-    end_time = time()
-    _log_schedule_time(start_time, end_time)
-    if arg_circuits_list:
-        return schedules
-    else:
-        return schedules[0]

qiskit/compiler/sequencer.py

@@ -1,71 +0,0 @@
-# This code is part of Qiskit.
-#
-# (C) Copyright IBM 2020.
-#
-# This code is licensed under the Apache License, Version 2.0. You may
-# obtain a copy of this license in the LICENSE.txt file in the root directory
-# of this source tree or at http://www.apache.org/licenses/LICENSE-2.0.
-#
-# Any modifications or derivative works of this code must retain this
-# copyright notice, and modified files need to carry a notice indicating
-# that they have been altered from the originals.
-
-"""
-Mapping a scheduled ``QuantumCircuit`` to a pulse ``Schedule``.
-"""
-from typing import List, Optional, Union
-
-from qiskit.circuit.quantumcircuit import QuantumCircuit
-from qiskit.exceptions import QiskitError
-from qiskit.providers.backend import Backend
-from qiskit.pulse import InstructionScheduleMap, Schedule
-from qiskit.scheduler import ScheduleConfig
-from qiskit.scheduler.sequence import sequence as _sequence
-from qiskit.utils.deprecate_pulse import deprecate_pulse_dependency
-
-
-@deprecate_pulse_dependency(moving_to_dynamics=True)
-def sequence(
-    scheduled_circuits: Union[QuantumCircuit, List[QuantumCircuit]],
-    backend: Optional[Backend] = None,
-    inst_map: Optional[InstructionScheduleMap] = None,
-    meas_map: Optional[List[List[int]]] = None,
-    dt: Optional[float] = None,
-) -> Union[Schedule, List[Schedule]]:
-    """
-    Schedule a scheduled circuit to a pulse ``Schedule``, using the backend.
-
-    Args:
-        scheduled_circuits: Scheduled circuit(s) to be translated
-        backend: A backend instance, which contains hardware-specific data required for scheduling
-        inst_map: Mapping of circuit operations to pulse schedules. If ``None``, defaults to the
-                  ``backend``\'s ``instruction_schedule_map``
-        meas_map: List of sets of qubits that must be measured together. If ``None``, defaults to
-                  the ``backend``\'s ``meas_map``
-        dt: The output sample rate of backend control electronics. For scheduled circuits
-            which contain time information, dt is required. If not provided, it will be
-            obtained from the backend configuration
-
-    Returns:
-        A pulse ``Schedule`` that implements the input circuit
-
-    Raises:
-        QiskitError: If ``inst_map`` and ``meas_map`` are not passed and ``backend`` is not passed
-    """
-    if inst_map is None:
-        if backend is None:
-            raise QiskitError("Must supply either a backend or inst_map for sequencing.")
-        inst_map = backend.defaults().instruction_schedule_map
-    if meas_map is None:
-        if backend is None:
-            raise QiskitError("Must supply either a backend or a meas_map for sequencing.")
-        meas_map = backend.configuration().meas_map
-    if dt is None:
-        if backend is None:
-            raise QiskitError("Must supply either a backend or a dt for sequencing.")
-        dt = backend.configuration().dt
-
-    schedule_config = ScheduleConfig(inst_map=inst_map, meas_map=meas_map, dt=dt)
-    circuits = scheduled_circuits if isinstance(scheduled_circuits, list) else [scheduled_circuits]
-    schedules = [_sequence(circuit, schedule_config) for circuit in circuits]
-    return schedules[0] if len(schedules) == 1 else schedules

qiskit/primitives/backend_estimator.py

@@ -1,486 +0,0 @@
-# This code is part of Qiskit.
-#
-# (C) Copyright IBM 2022.
-#
-# This code is licensed under the Apache License, Version 2.0. You may
-# obtain a copy of this license in the LICENSE.txt file in the root directory
-# of this source tree or at http://www.apache.org/licenses/LICENSE-2.0.
-#
-# Any modifications or derivative works of this code must retain this
-# copyright notice, and modified files need to carry a notice indicating
-# that they have been altered from the originals.
-
-"""Estimator V1 implementation for an arbitrary Backend object."""
-
-from __future__ import annotations
-
-from collections.abc import Sequence
-from itertools import accumulate
-
-import numpy as np
-
-from qiskit.circuit import ClassicalRegister, QuantumCircuit, QuantumRegister
-from qiskit.compiler import transpile
-from qiskit.exceptions import QiskitError
-from qiskit.providers import BackendV1, BackendV2, Options
-from qiskit.quantum_info import Pauli, PauliList
-from qiskit.quantum_info.operators.base_operator import BaseOperator
-from qiskit.result import Counts, Result
-from qiskit.transpiler import CouplingMap, PassManager
-from qiskit.transpiler.passes import (
-    ApplyLayout,
-    EnlargeWithAncilla,
-    FullAncillaAllocation,
-    Optimize1qGatesDecomposition,
-    SetLayout,
-)
-from qiskit.utils.deprecation import deprecate_func
-
-from .base import BaseEstimator, EstimatorResult
-from .primitive_job import PrimitiveJob
-from .utils import _circuit_key, _observable_key, init_observable
-
-
-def _run_circuits(
-    circuits: QuantumCircuit | list[QuantumCircuit],
-    backend: BackendV1 | BackendV2,
-    clear_metadata: bool = True,
-    **run_options,
-) -> tuple[list[Result], list[dict]]:
-    """Remove metadata of circuits and run the circuits on a backend.
-    Args:
-        circuits: The circuits
-        backend: The backend
-        clear_metadata: Clear circuit metadata before passing to backend.run if
-            True.
-        **run_options: run_options
-    Returns:
-        The result and the metadata of the circuits
-    """
-    if isinstance(circuits, QuantumCircuit):
-        circuits = [circuits]
-    metadata = []
-    for circ in circuits:
-        metadata.append(circ.metadata)
-        if clear_metadata:
-            circ.metadata = {}
-    if isinstance(backend, BackendV1):
-        max_circuits = getattr(backend.configuration(), "max_experiments", None)
-    elif isinstance(backend, BackendV2):
-        max_circuits = backend.max_circuits
-    else:
-        raise RuntimeError("Backend version not supported")
-    if max_circuits:
-        jobs = [
-            backend.run(circuits[pos : pos + max_circuits], **run_options)
-            for pos in range(0, len(circuits), max_circuits)
-        ]
-        result = [x.result() for x in jobs]
-    else:
-        result = [backend.run(circuits, **run_options).result()]
-    return result, metadata
-
-
-def _prepare_counts(results: list[Result]):
-    counts = []
-    for res in results:
-        count = res.get_counts()
-        if not isinstance(count, list):
-            count = [count]
-        counts.extend(count)
-    return counts
-
-
-class BackendEstimator(BaseEstimator[PrimitiveJob[EstimatorResult]]):
-    """Evaluates expectation value using Pauli rotation gates.
-
-    The :class:`~.BackendEstimator` class is a generic implementation of the
-    :class:`~.BaseEstimator` (V1) interface that is used to wrap a :class:`~.BackendV2`
-    (or :class:`~.BackendV1`) object in the :class:`~.BaseEstimator` V1 API. It
-    facilitates using backends that do not provide a native
-    :class:`~.BaseEstimator` V1 implementation in places that work with
-    :class:`~.BaseEstimator` V1.
-    However, if you're using a provider that has a native implementation of
-    :class:`~.BaseEstimatorV1` ( :class:`~.BaseEstimator`) or
-    :class:`~.BaseEstimatorV2`, it is a better
-    choice to leverage that native implementation as it will likely include
-    additional optimizations and be a more efficient implementation.
-    The generic nature of this class precludes doing any provider- or
-    backend-specific optimizations.
-    """
-
-    @deprecate_func(
-        since="1.2",
-        additional_msg="All implementations of the `BaseEstimatorV1` interface "
-        "have been deprecated in favor of their V2 counterparts. "
-        "The V2 alternative for the `BackendEstimator` class is `BackendEstimatorV2`.",
-    )
-    def __init__(
-        self,
-        backend: BackendV1 | BackendV2,
-        options: dict | None = None,
-        abelian_grouping: bool = True,
-        bound_pass_manager: PassManager | None = None,
-        skip_transpilation: bool = False,
-    ):
-        """Initialize a new BackendEstimator (V1) instance
-
-        Args:
-            backend: (required) the backend to run the primitive on
-            options: Default options.
-            abelian_grouping: Whether the observable should be grouped into
-                commuting
-            bound_pass_manager: An optional pass manager to run after
-                parameter binding.
-            skip_transpilation: If this is set to True the internal compilation
-                of the input circuits is skipped and the circuit objects
-                will be directly executed when this object is called.
-        """
-        super().__init__(options=options)
-        self._circuits = []
-        self._parameters = []
-        self._observables = []
-
-        self._abelian_grouping = abelian_grouping
-
-        self._backend = backend
-
-        self._transpile_options = Options()
-        self._bound_pass_manager = bound_pass_manager
-
-        self._preprocessed_circuits: list[tuple[QuantumCircuit, list[QuantumCircuit]]] | None = None
-        self._transpiled_circuits: list[QuantumCircuit] | None = None
-
-        self._grouping = list(zip(range(len(self._circuits)), range(len(self._observables))))
-        self._skip_transpilation = skip_transpilation
-
-        self._circuit_ids = {}
-        self._observable_ids = {}
-
-    @property
-    def transpile_options(self) -> Options:
-        """Return the transpiler options for transpiling the circuits."""
-        return self._transpile_options
-
-    def set_transpile_options(self, **fields):
-        """Set the transpiler options for transpiler.
-        Args:
-            **fields: The fields to update the options
-        """
-        self._transpiled_circuits = None
-        self._transpile_options.update_options(**fields)
-
-    @property
-    def preprocessed_circuits(
-        self,
-    ) -> list[tuple[QuantumCircuit, list[QuantumCircuit]]]:
-        """
-        Transpiled quantum circuits produced by preprocessing
-        Returns:
-            List of the transpiled quantum circuit
-        """
-        self._preprocessed_circuits = self._preprocessing()
-        return self._preprocessed_circuits
-
-    @property
-    def transpiled_circuits(self) -> list[QuantumCircuit]:
-        """
-        Transpiled quantum circuits.
-        Returns:
-            List of the transpiled quantum circuit
-        Raises:
-            QiskitError: if the instance has been closed.
-        """
-        self._transpile()
-        return self._transpiled_circuits
-
-    @property
-    def backend(self) -> BackendV1 | BackendV2:
-        """
-        Returns:
-            The backend which this estimator object based on
-        """
-        return self._backend
-
-    def _transpile(self):
-        """Split Transpile"""
-        self._transpiled_circuits = []
-        for common_circuit, diff_circuits in self.preprocessed_circuits:
-            # 1. transpile a common circuit
-            if self._skip_transpilation:
-                transpiled_circuit = common_circuit.copy()
-                final_index_layout = list(range(common_circuit.num_qubits))
-            else:
-                transpiled_circuit = transpile(  # pylint:disable=unexpected-keyword-arg
-                    common_circuit, self.backend, **self.transpile_options.__dict__
-                )
-                if transpiled_circuit.layout is not None:
-                    final_index_layout = transpiled_circuit.layout.final_index_layout()
-                else:
-                    final_index_layout = list(range(transpiled_circuit.num_qubits))
-
-            # 2. transpile diff circuits
-            passmanager = _passmanager_for_measurement_circuits(final_index_layout, self.backend)
-            diff_circuits = passmanager.run(diff_circuits)
-            # 3. combine
-            transpiled_circuits = []
-            for diff_circuit in diff_circuits:
-                transpiled_circuit_copy = transpiled_circuit.copy()
-                # diff_circuit is supposed to have a classical register whose name is different from
-                # those of the transpiled_circuit
-                clbits = diff_circuit.cregs[0]
-                for creg in transpiled_circuit_copy.cregs:
-                    if clbits.name == creg.name:
-                        raise QiskitError(
-                            "Classical register for measurements conflict with those of the input "
-                            f"circuit: {clbits}. "
-                            "Recommended to avoid register names starting with '__'."
-                        )
-                transpiled_circuit_copy.add_register(clbits)
-                transpiled_circuit_copy.compose(diff_circuit, clbits=clbits, inplace=True)
-                transpiled_circuit_copy.metadata = diff_circuit.metadata
-                transpiled_circuits.append(transpiled_circuit_copy)
-            self._transpiled_circuits += transpiled_circuits
-
-    def _call(
-        self,
-        circuits: Sequence[int],
-        observables: Sequence[int],
-        parameter_values: Sequence[Sequence[float]],
-        **run_options,
-    ) -> EstimatorResult:
-
-        # Transpile
-        self._grouping = list(zip(circuits, observables))
-        transpiled_circuits = self.transpiled_circuits
-        num_observables = [len(m) for (_, m) in self.preprocessed_circuits]
-        accum = [0] + list(accumulate(num_observables))
-
-        # Bind parameters
-        parameter_dicts = [
-            dict(zip(self._parameters[i], value)) for i, value in zip(circuits, parameter_values)
-        ]
-        bound_circuits = [
-            (
-                transpiled_circuits[circuit_index]
-                if len(p) == 0
-                else transpiled_circuits[circuit_index].assign_parameters(p)
-            )
-            for i, (p, n) in enumerate(zip(parameter_dicts, num_observables))
-            for circuit_index in range(accum[i], accum[i] + n)
-        ]
-        bound_circuits = self._bound_pass_manager_run(bound_circuits)
-
-        # Run
-        result, metadata = _run_circuits(bound_circuits, self._backend, **run_options)
-
-        return self._postprocessing(result, accum, metadata)
-
-    def _run(
-        self,
-        circuits: tuple[QuantumCircuit, ...],
-        observables: tuple[BaseOperator, ...],
-        parameter_values: tuple[tuple[float, ...], ...],
-        **run_options,
-    ):
-        circuit_indices = []
-        for circuit in circuits:
-            index = self._circuit_ids.get(_circuit_key(circuit))
-            if index is not None:
-                circuit_indices.append(index)
-            else:
-                circuit_indices.append(len(self._circuits))
-                self._circuit_ids[_circuit_key(circuit)] = len(self._circuits)
-                self._circuits.append(circuit)
-                self._parameters.append(circuit.parameters)
-        observable_indices = []
-        for observable in observables:
-            observable = init_observable(observable)
-            index = self._observable_ids.get(_observable_key(observable))
-            if index is not None:
-                observable_indices.append(index)
-            else:
-                observable_indices.append(len(self._observables))
-                self._observable_ids[_observable_key(observable)] = len(self._observables)
-                self._observables.append(observable)
-        job = PrimitiveJob(
-            self._call, circuit_indices, observable_indices, parameter_values, **run_options
-        )
-        job._submit()
-        return job
-
-    @staticmethod
-    def _measurement_circuit(num_qubits: int, pauli: Pauli):
-        # Note: if pauli is I for all qubits, this function generates a circuit to measure only
-        # the first qubit.
-        # Although such an operator can be optimized out by interpreting it as a constant (1),
-        # this optimization requires changes in various methods. So it is left as future work.
-        qubit_indices = np.arange(pauli.num_qubits)[pauli.z | pauli.x]
-        if not np.any(qubit_indices):
-            qubit_indices = [0]
-        meas_circuit = QuantumCircuit(
-            QuantumRegister(num_qubits, "q"), ClassicalRegister(len(qubit_indices), f"__c_{pauli}")
-        )
-        for clbit, i in enumerate(qubit_indices):
-            if pauli.x[i]:
-                if pauli.z[i]:
-                    meas_circuit.sdg(i)
-                meas_circuit.h(i)
-            meas_circuit.measure(i, clbit)
-        return meas_circuit, qubit_indices
-
-    def _preprocessing(self) -> list[tuple[QuantumCircuit, list[QuantumCircuit]]]:
-        """
-        Preprocessing for evaluation of expectation value using pauli rotation gates.
-        """
-        preprocessed_circuits = []
-        for group in self._grouping:
-            circuit = self._circuits[group[0]]
-            observable = self._observables[group[1]]
-            diff_circuits: list[QuantumCircuit] = []
-            if self._abelian_grouping:
-                for obs in observable.group_commuting(qubit_wise=True):
-                    basis = Pauli(
-                        (np.logical_or.reduce(obs.paulis.z), np.logical_or.reduce(obs.paulis.x))
-                    )
-                    meas_circuit, indices = self._measurement_circuit(circuit.num_qubits, basis)
-                    paulis = PauliList.from_symplectic(
-                        obs.paulis.z[:, indices],
-                        obs.paulis.x[:, indices],
-                        obs.paulis.phase,
-                    )
-                    meas_circuit.metadata = {
-                        "paulis": paulis,
-                        "coeffs": np.real_if_close(obs.coeffs),
-                    }
-                    diff_circuits.append(meas_circuit)
-            else:
-                for basis, obs in zip(observable.paulis, observable):
-                    meas_circuit, indices = self._measurement_circuit(circuit.num_qubits, basis)
-                    paulis = PauliList.from_symplectic(
-                        obs.paulis.z[:, indices],
-                        obs.paulis.x[:, indices],
-                        obs.paulis.phase,
-                    )
-                    meas_circuit.metadata = {
-                        "paulis": paulis,
-                        "coeffs": np.real_if_close(obs.coeffs),
-                    }
-                    diff_circuits.append(meas_circuit)
-
-            preprocessed_circuits.append((circuit.copy(), diff_circuits))
-        return preprocessed_circuits
-
-    def _postprocessing(
-        self, result: list[Result], accum: list[int], metadata: list[dict]
-    ) -> EstimatorResult:
-        """
-        Postprocessing for evaluation of expectation value using pauli rotation gates.
-        """
-        counts = _prepare_counts(result)
-        expval_list = []
-        var_list = []
-        shots_list = []
-
-        for i, j in zip(accum, accum[1:]):
-
-            combined_expval = 0.0
-            combined_var = 0.0
-
-            for k in range(i, j):
-                meta = metadata[k]
-                paulis = meta["paulis"]
-                coeffs = meta["coeffs"]
-
-                count = counts[k]
-
-                expvals, variances = _pauli_expval_with_variance(count, paulis)
-
-                # Accumulate
-                combined_expval += np.dot(expvals, coeffs)
-                combined_var += np.dot(variances, coeffs**2)
-
-            expval_list.append(combined_expval)
-            var_list.append(combined_var)
-            shots_list.append(sum(counts[i].values()))
-
-        metadata = [{"variance": var, "shots": shots} for var, shots in zip(var_list, shots_list)]
-
-        return EstimatorResult(np.real_if_close(expval_list), metadata)
-
-    def _bound_pass_manager_run(self, circuits):
-        if self._bound_pass_manager is None:
-            return circuits
-        else:
-            output = self._bound_pass_manager.run(circuits)
-            if not isinstance(output, list):
-                output = [output]
-            return output
-
-
-def _paulis2inds(paulis: PauliList) -> list[int]:
-    """Convert PauliList to diagonal integers.
-    These are integer representations of the binary string with a
-    1 where there are Paulis, and 0 where there are identities.
-    """
-    # Treat Z, X, Y the same
-    nonid = paulis.z | paulis.x
-
-    # bits are packed into uint8 in little endian
-    # e.g., i-th bit corresponds to coefficient 2^i
-    packed_vals = np.packbits(nonid, axis=1, bitorder="little")
-    power_uint8 = 1 << (8 * np.arange(packed_vals.shape[1], dtype=object))
-    inds = packed_vals @ power_uint8
-    return inds.tolist()
-
-
-def _parity(integer: int) -> int:
-    """Return the parity of an integer"""
-    return bin(integer).count("1") % 2
-
-
-def _pauli_expval_with_variance(counts: Counts, paulis: PauliList) -> tuple[np.ndarray, np.ndarray]:
-    """Return array of expval and variance pairs for input Paulis.
-    Note: All non-identity Pauli's are treated as Z-paulis, assuming
-    that basis rotations have been applied to convert them to the
-    diagonal basis.
-    """
-    # Diag indices
-    size = len(paulis)
-    diag_inds = _paulis2inds(paulis)
-
-    expvals = np.zeros(size, dtype=float)
-    denom = 0  # Total shots for counts dict
-    for bin_outcome, freq in counts.items():
-        split_outcome = bin_outcome.split(" ", 1)[0] if " " in bin_outcome else bin_outcome
-        outcome = int(split_outcome, 2)
-        denom += freq
-        for k in range(size):
-            coeff = (-1) ** _parity(diag_inds[k] & outcome)
-            expvals[k] += freq * coeff
-
-    # Divide by total shots
-    expvals /= denom
-
-    # Compute variance
-    variances = 1 - expvals**2
-    return expvals, variances
-
-
-def _passmanager_for_measurement_circuits(layout, backend) -> PassManager:
-    passmanager = PassManager([SetLayout(layout)])
-    if isinstance(backend, BackendV2):
-        opt1q = Optimize1qGatesDecomposition(target=backend.target)
-    else:
-        opt1q = Optimize1qGatesDecomposition(basis=backend.configuration().basis_gates)
-    passmanager.append(opt1q)
-    if isinstance(backend, BackendV2) and isinstance(backend.coupling_map, CouplingMap):
-        coupling_map = backend.coupling_map
-        passmanager.append(FullAncillaAllocation(coupling_map))
-        passmanager.append(EnlargeWithAncilla())
-    elif isinstance(backend, BackendV1) and backend.configuration().coupling_map is not None:
-        coupling_map = CouplingMap(backend.configuration().coupling_map)
-        passmanager.append(FullAncillaAllocation(coupling_map))
-        passmanager.append(EnlargeWithAncilla())
-    passmanager.append(ApplyLayout())
-    return passmanager