qiskit-aer 0.17.2__cp314-cp314-win_amd64.whl

qiskit_aer/noise/noiseerror.py

@@ -0,0 +1,30 @@
+# This code is part of Qiskit.
+#
+# (C) Copyright IBM 2018, 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.
+
+"""
+Exception for errors raised by Aer noise module.
+"""
+
+from qiskit import QiskitError
+
+
+class NoiseError(QiskitError):
+    """Class for errors raised in qiskit_aer.noise package."""
+
+    def __init__(self, *message):
+        """Set the error message."""
+        super().__init__(*message)
+        self.message = " ".join(message)
+
+    def __str__(self):
+        """Return the message."""
+        return repr(self.message)

qiskit_aer/noise/passes/__init__.py

@@ -0,0 +1,18 @@
+# This code is part of Qiskit.
+#
+# (C) Copyright IBM 2021.
+#
+# 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.
+
+"""
+Passes for adding noises.
+"""
+
+from .local_noise_pass import LocalNoisePass
+from .relaxation_noise_pass import RelaxationNoisePass

qiskit_aer/noise/passes/local_noise_pass.py

@@ -0,0 +1,160 @@
+# This code is part of Qiskit.
+#
+# (C) Copyright IBM 2021.
+#
+# 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.
+"""
+Local noise addition pass.
+"""
+from typing import Optional, Union, Sequence, Callable, Iterable
+
+from qiskit.circuit import Instruction, QuantumCircuit
+from qiskit.dagcircuit import DAGCircuit
+from qiskit.converters import circuit_to_dag
+from qiskit.transpiler import TransformationPass
+from qiskit.transpiler.exceptions import TranspilerError
+from ..errors import QuantumError, ReadoutError
+
+InstructionLike = Union[Instruction, QuantumError, QuantumCircuit]
+
+
+class LocalNoisePass(TransformationPass):
+    """Transpiler pass to insert noise into a circuit.
+
+    The noise in this pass is defined by a noise function or callable with signature
+
+    .. code:: python
+
+            def func(
+                inst: Instruction,
+                qubits: Optional[List[int]] = None
+            ) -> InstructionLike:
+
+    For every instance of one of the reference instructions in a circuit the
+    supplied function is called on that instruction and the returned noise
+    is added to the circuit. This noise can depend on properties of the
+    instruction it is called on (for example parameters or duration) to
+    allow inserting parameterized noise models.
+
+    Several methods for adding the constructed errors to circuits are supported
+    and can be set by using the ``method`` kwarg. The supported methods are
+
+    * ``"append"``: add the return of the callable after the instruction.
+    * ``"prepend"``: add the return of the callable before the instruction.
+    * ``"replace"``: replace the instruction with the return of the callable.
+        If the return is None, the instruction will be removed.
+
+    """
+
+    def __init__(
+        self,
+        func: Callable[[Instruction, Sequence[int]], Optional[InstructionLike]],
+        op_types: Optional[Union[type, Iterable[type]]] = None,
+        method: str = "append",
+    ):
+        """Initialize noise pass.
+
+        Args:
+            func: noise function `func(inst, qubits) -> InstructionLike`.
+            op_types: Optional, single or list of instruction types to apply the
+                noise function to. If None the noise function will be
+                applied to all instructions in the circuit.
+            method: method for inserting noise. Allow methods are
+                'append', 'prepend', 'replace'.
+        Raises:
+            TranspilerError: if an invalid option is specified.
+        """
+        if method not in {"append", "prepend", "replace"}:
+            raise TranspilerError(
+                f'Invalid method: {method}, it must be "append", "prepend" or "replace"'
+            )
+        if isinstance(op_types, type):
+            op_types = (op_types,)
+        super().__init__()
+        self._func = func
+        self._ops = tuple(op_types) if op_types else tuple()
+        self._method = method
+        if not all(isinstance(op, type) for op in self._ops):
+            raise TranspilerError(
+                f"Invalid ops: '{op_types}', expecting single or list of operation types (or None)"
+            )
+
+    def run(self, dag: DAGCircuit) -> DAGCircuit:
+        """Run the LocalNoisePass pass on `dag`.
+        Args:
+            dag: DAG to be changed.
+        Returns:
+            A changed DAG.
+        Raises:
+            TranspilerError: if generated operation is not valid.
+        """
+        qubit_indices = {qubit: idx for idx, qubit in enumerate(dag.qubits)}
+        for node in dag.topological_op_nodes():
+            if self._ops and not isinstance(node.op, self._ops):
+                continue
+
+            qubits = [qubit_indices[q] for q in node.qargs]
+            new_op = self._func(node.op, qubits)
+
+            if new_op is None:
+                # Edge case where we are replacing a node with nothing (removing node)
+                if self._method == "replace":
+                    dag.remove_op_node(node)
+                continue
+
+            if isinstance(new_op, ReadoutError):
+                raise TranspilerError("Insertions of ReadoutError is not yet supported.")
+
+            # Initialize new node dag
+            new_dag = DAGCircuit()
+            new_dag.add_qubits(node.qargs)
+            new_dag.add_clbits(node.cargs)
+
+            # If appending re-apply original op node first
+            if self._method == "append":
+                new_dag.apply_operation_back(node.op, qargs=node.qargs, cargs=node.cargs)
+
+            # If the new op is not a QuantumCircuit or Instruction, attempt
+            # to conver to an Instruction
+            if not isinstance(new_op, (QuantumCircuit, Instruction)):
+                try:
+                    new_op = new_op.to_instruction()
+                except AttributeError as att_err:
+                    raise TranspilerError(
+                        "Function must return an object implementing 'to_instruction' method."
+                    ) from att_err
+
+            if new_op.num_clbits > 0:
+                raise TranspilerError("Noise must be an instruction without clbits.")
+
+            # Validate the instruction matches the number of qubits and clbits of the node
+            if new_op.num_qubits != len(node.qargs):
+                raise TranspilerError(
+                    f"Number of qubits of generated op {new_op.num_qubits} != "
+                    f"{len(node.qargs)} that of a reference op {node.name}"
+                )
+
+            # Add the noise op returned by the function
+            if isinstance(new_op, QuantumCircuit):
+                # If the new op is a quantum circuit, compose its DAG with the new dag
+                # so that it is unrolled rather than added as an opaque instruction
+                new_dag.compose(
+                    circuit_to_dag(new_op), qubits=list(node.qargs)
+                )  # never touch clbits
+            else:
+                # Otherwise append the instruction returned by the function
+                new_dag.apply_operation_back(new_op, qargs=node.qargs)  # never touch cargs
+
+            # If prepending reapply original op node last
+            if self._method == "prepend":
+                new_dag.apply_operation_back(node.op, qargs=node.qargs, cargs=node.cargs)
+
+            dag.substitute_node_with_dag(node, new_dag)
+
+        return dag

qiskit_aer/noise/passes/relaxation_noise_pass.py

@@ -0,0 +1,137 @@
+# This code is part of Qiskit.
+#
+# (C) Copyright IBM 2021.
+#
+# 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.
+"""
+Thermal relaxation noise pass.
+"""
+import warnings
+from typing import Optional, Union, Sequence, List
+
+import numpy as np
+
+from qiskit.circuit import Instruction, QuantumCircuit
+from qiskit.transpiler import Target
+from qiskit.utils.units import apply_prefix
+from .local_noise_pass import LocalNoisePass
+from ..errors.standard_errors import thermal_relaxation_error
+from ..noiseerror import NoiseError
+
+
+class RelaxationNoisePass(LocalNoisePass):
+    """Add duration dependent thermal relaxation noise after instructions."""
+
+    def __init__(
+        self,
+        t1s: List[float],
+        t2s: List[float],
+        dt: Optional[float] = None,
+        op_types: Optional[Union[type, Sequence[type]]] = None,
+        excited_state_populations: Optional[List[float]] = None,
+        target: Target = None,
+    ):
+        """Initialize RelaxationNoisePass.
+
+        Args:
+            t1s: List of T1 times in seconds for each qubit.
+            t2s: List of T2 times in seconds for each qubit.
+            dt: Backend sample time (resolution) in seconds. This is required
+                for converting dt-unit op durations to times in scheduled circuits.
+            op_types: Optional, the operation types to add relaxation to. If None
+                relaxation will be added to all operations.
+            excited_state_populations: Optional, list of excited state populations
+                for each qubit at thermal equilibrium. If not supplied or obtained
+                from the backend this will be set to 0 for each qubit.
+            target: Optional, target instance with instruction duration information.
+        """
+        self._t1s = np.asarray(t1s)
+        self._t2s = np.asarray(t2s)
+        if excited_state_populations is not None:
+            self._p1s = np.asarray(excited_state_populations)
+        else:
+            self._p1s = np.zeros(len(t1s))
+        self._dt = dt
+        self._target = target
+        super().__init__(self._thermal_relaxation_error, op_types=op_types, method="append")
+
+    def _thermal_relaxation_error(self, op: Instruction, qubits: Sequence[int]):
+        """Return thermal relaxation error on each operand qubit"""
+
+        duration = None
+
+        if self._target is not None:
+            if op.name == "delay":
+                duration = op.duration
+                if duration is not None:
+                    # Convert op duration to seconds
+                    if op.unit == "dt":
+                        if self._dt is None:
+                            raise NoiseError(
+                                "RelaxationNoisePass cannot apply noise to a 'dt' unit duration"
+                                " without a dt time set."
+                            )
+                        duration = op.duration * self._dt
+                    else:
+                        duration = apply_prefix(op.duration, op.unit)
+            else:
+                op_props = self._target.get(op.name)
+                if op_props is not None:
+                    inst_props = op_props.get(tuple(qubits))
+                    if inst_props is not None:
+                        # get duration in seconds
+                        duration = getattr(inst_props, "duration")
+        else:
+            try:
+                duration = op.duration
+                if duration is not None:
+                    # Convert op duration to seconds
+                    if op.unit == "dt":
+                        if self._dt is None:
+                            raise NoiseError(
+                                "RelaxationNoisePass cannot apply noise to a 'dt' unit duration"
+                                " without a dt time set."
+                            )
+                        duration = op.duration * self._dt
+                    else:
+                        duration = apply_prefix(op.duration, op.unit)
+
+            except AttributeError:
+                duration = None
+
+        if duration is None:
+            warnings.warn(
+                f"Instruction duration not found for {op.name}. RelaxationNoisePass ignores "
+                "instructions without duration. "
+                "To avoid this warning, provide the corresponding duration information via `target`.",
+                UserWarning,
+            )
+            return None
+
+        t1s = self._t1s[qubits]
+        t2s = self._t2s[qubits]
+        p1s = self._p1s[qubits]
+
+        # pylint: disable=invalid-name
+        if op.num_qubits == 1:
+            t1, t2, p1 = t1s[0], t2s[0], p1s[0]
+            if t1 == np.inf and t2 == np.inf:
+                return None
+            return thermal_relaxation_error(t1, t2, duration, p1)
+
+        # General multi-qubit case
+        noise = QuantumCircuit(op.num_qubits)
+        for qubit, (t1, t2, p1) in enumerate(zip(t1s, t2s, p1s)):
+            if t1 == np.inf and t2 == np.inf:
+                # No relaxation on this qubit
+                continue
+            error = thermal_relaxation_error(t1, t2, duration, p1)
+            noise.append(error.to_instruction(), [qubit])
+
+        return noise

qiskit_aer/primitives/__init__.py

@@ -0,0 +1,44 @@
+# 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.
+
+"""
+===================================================
+Primitives (:mod:`qiskit_aer.primitives`)
+===================================================
+
+.. currentmodule:: qiskit_aer.primitives
+
+This module is Aer implementation of primitives.
+See the docs https://quantum.cloud.ibm.com/docs/api/qiskit/primitives for general descriptions.
+
+
+Classes
+=======
+
+.. autosummary::
+    :toctree: ../stubs/
+
+    Sampler
+    Estimator
+    SamplerV2
+    EstimatorV2
+
+"""
+
+import qiskit
+
+from .estimator import Estimator
+from .sampler import Sampler
+
+if not qiskit.__version__.startswith("0."):
+    from .estimator_v2 import EstimatorV2
+    from .sampler_v2 import SamplerV2