qiskit-aer 0.17.2__cp314-cp314-win_amd64.whl

qiskit_aer/primitives/sampler_v2.py

@@ -0,0 +1,256 @@
+# 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.
+
+"""
+Sampler V2 class.
+"""
+
+from __future__ import annotations
+
+import warnings
+from collections import defaultdict
+from dataclasses import dataclass, field
+from typing import Iterable
+
+import numpy as np
+from qiskit.primitives.backend_sampler_v2 import (
+    _analyze_circuit,
+    _MeasureInfo,
+    _memory_array,
+    _samples_to_packed_array,
+)
+from qiskit.primitives.base import BaseSamplerV2
+from qiskit.primitives.containers import (
+    BitArray,
+    DataBin,
+    PrimitiveResult,
+    SamplerPubLike,
+    SamplerPubResult,
+)
+from qiskit.primitives.containers.sampler_pub import SamplerPub
+from qiskit.primitives.primitive_job import PrimitiveJob
+from qiskit.result import Result
+
+from qiskit_aer import AerSimulator
+
+
+@dataclass
+class Options:
+    """Options for :class:`~.SamplerV2`."""
+
+    backend_options: dict = field(default_factory=dict)
+    """backend_options: Options passed to AerSimulator."""
+
+    run_options: dict = field(default_factory=dict)
+    """run_options: Options passed to run."""
+
+
+class SamplerV2(BaseSamplerV2):
+    """
+    Aer implementation of SamplerV2 class.
+
+    Each tuple of ``(circuit, <optional> parameter values, <optional> shots)``, called a sampler
+    primitive unified bloc (PUB), produces its own array-valued result. The :meth:`~run` method can
+    be given many pubs at once.
+
+    * ``backend_options``: Options passed to AerSimulator.
+      Default: {}.
+
+    * ``run_options``: Options passed to :meth:`AerSimulator.run`.
+      Default: {}.
+
+    """
+
+    def __init__(
+        self,
+        *,
+        default_shots: int = 1024,
+        seed: int | None = None,
+        options: dict | None = None,
+    ):
+        """
+        Args:
+            default_shots: The default shots for the sampler if not specified during run.
+            seed: The seed for random number generation.
+                If None, a random seeded default RNG will be used.
+            options:
+                the backend options (``backend_options``), and
+                the runtime options (``run_options``).
+
+        """
+        self._default_shots = default_shots
+        self._seed = seed
+
+        self._options = Options(**options) if options else Options()
+        self._backend = AerSimulator(**self.options.backend_options)
+
+    @classmethod
+    def from_backend(cls, backend, **options):
+        """make new sampler that uses external backend"""
+        sampler = cls(**options)
+        if isinstance(backend, AerSimulator):
+            sampler._backend = backend
+        else:
+            sampler._backend = AerSimulator.from_backend(backend)
+        return sampler
+
+    @property
+    def default_shots(self) -> int:
+        """Return the default shots"""
+        return self._default_shots
+
+    @property
+    def seed(self) -> int | None:
+        """Return the seed for random number generation."""
+        return self._seed
+
+    @property
+    def options(self) -> Options:
+        """Return the options"""
+        return self._options
+
+    def run(
+        self, pubs: Iterable[SamplerPubLike], *, shots: int | None = None
+    ) -> PrimitiveJob[PrimitiveResult[SamplerPubResult]]:
+        if shots is None:
+            shots = self._default_shots
+        coerced_pubs = [SamplerPub.coerce(pub, shots) for pub in pubs]
+        self._validate_pubs(coerced_pubs)
+        job = PrimitiveJob(self._run, coerced_pubs)
+        job._submit()
+        return job
+
+    def _validate_pubs(self, pubs: list[SamplerPub]):
+        for i, pub in enumerate(pubs):
+            if len(pub.circuit.cregs) == 0:
+                warnings.warn(
+                    f"The {i}-th pub's circuit has no output classical registers and so the result "
+                    "will be empty. Did you mean to add measurement instructions?",
+                    UserWarning,
+                )
+
+    def _run(self, pubs: list[SamplerPub]) -> PrimitiveResult[SamplerPubResult]:
+        pub_dict = defaultdict(list)
+        # consolidate pubs with the same number of shots
+        for i, pub in enumerate(pubs):
+            pub_dict[pub.shots].append(i)
+
+        results = [None] * len(pubs)
+        for shots, lst in pub_dict.items():
+            # run pubs with the same number of shots at once
+            pub_results = self._run_pubs([pubs[i] for i in lst], shots)
+            # reconstruct the result of pubs
+            for i, pub_result in zip(lst, pub_results):
+                results[i] = pub_result
+        return PrimitiveResult(results, metadata={"version": 2})
+
+    def _run_pubs(self, pubs: list[SamplerPub], shots: int) -> list[SamplerPubResult]:
+        """Compute results for pubs that all require the same value of ``shots``."""
+        circuits = [pub.circuit for pub in pubs]
+        parameter_binds = [_convert_parameter_bindings(pub) for pub in pubs]
+
+        # adjust run_options not to overwrite existings options
+        run_options = self.options.run_options.copy()
+        for key in ["shots", "parameter_binds", "memory"]:
+            if key in run_options:
+                del run_options[key]
+        if self._seed is not None and "seed_simulator" in run_options:
+            del run_options["seed_simulator"]
+
+        # run circuits
+        result = self._backend.run(
+            circuits,
+            shots=shots,
+            seed_simulator=self._seed,
+            parameter_binds=parameter_binds,
+            memory=True,
+            **run_options,
+        ).result()
+
+        result_memory = _prepare_memory(result)
+
+        # pack memory to an ndarray of uint8
+        results = []
+        start = 0
+        for pub in pubs:
+            meas_info, max_num_bytes = _analyze_circuit(pub.circuit)
+            p_v = pub.parameter_values
+            end = start + p_v.size
+            results.append(
+                self._postprocess_pub(
+                    result_memory[start:end],
+                    shots,
+                    p_v.shape,
+                    meas_info,
+                    max_num_bytes,
+                    pub.circuit.metadata,
+                    result.metadata,
+                )
+            )
+            start = end
+
+        return results
+
+    def _postprocess_pub(
+        self,
+        result_memory: list[list[str]],
+        shots: int,
+        shape: tuple[int, ...],
+        meas_info: list[_MeasureInfo],
+        max_num_bytes: int,
+        circuit_metadata: dict,
+        simulator_metadata: dict,
+    ) -> SamplerPubResult:
+        """Converts the memory data into an array of bit arrays with the shape of the pub."""
+        arrays = {
+            item.creg_name: np.zeros(shape + (shots, item.num_bytes), dtype=np.uint8)
+            for item in meas_info
+        }
+        memory_array = _memory_array(result_memory, max_num_bytes)
+
+        for samples, index in zip(memory_array, np.ndindex(*shape)):
+            for item in meas_info:
+                ary = _samples_to_packed_array(samples, item.num_bits, item.start)
+                arrays[item.creg_name][index] = ary
+
+        meas = {
+            item.creg_name: BitArray(arrays[item.creg_name], item.num_bits) for item in meas_info
+        }
+        return SamplerPubResult(
+            DataBin(**meas, shape=shape),
+            metadata={
+                "shots": shots,
+                "circuit_metadata": circuit_metadata,
+                "simulator_metadata": simulator_metadata,
+            },
+        )
+
+
+def _convert_parameter_bindings(pub: SamplerPub) -> dict:
+    circuit = pub.circuit
+    parameter_values = pub.parameter_values
+    parameter_binds = {}
+    param_array = parameter_values.as_array(circuit.parameters)
+    parameter_binds = {p: param_array[..., i].ravel() for i, p in enumerate(circuit.parameters)}
+    return parameter_binds
+
+
+def _prepare_memory(result: Result) -> list[list[str]]:
+    """There is no split of results due to max_experiments for Aer"""
+    lst = []
+    for exp in result.results:
+        if hasattr(exp.data, "memory") and exp.data.memory:
+            lst.append(exp.data.memory)
+        else:
+            # no measure in a circuit
+            lst.append(["0x0"] * exp.shots)
+    return lst

qiskit_aer/quantum_info/__init__.py

@@ -0,0 +1,32 @@
+# 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.
+
+"""
+=================================================
+Aer Quantum Info (:mod:`qiskit_aer.quantum_info`)
+=================================================
+
+.. currentmodule:: qiskit_aer.quantum_info
+
+States
+======
+
+.. autosummary::
+   :toctree: ../stubs/
+
+   AerStatevector
+   AerDensityMatrix
+
+"""
+
+from .states import AerStatevector
+from .states import AerDensityMatrix

qiskit_aer/quantum_info/states/__init__.py

@@ -0,0 +1,16 @@
+# 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.
+
+"""Aer Quantum States."""
+
+from .aer_statevector import AerStatevector
+from .aer_densitymatrix import AerDensityMatrix

qiskit_aer/quantum_info/states/aer_densitymatrix.py

@@ -0,0 +1,313 @@
+# This code is part of Qiskit.
+#
+# (C) Copyright IBM 2017, 2019, 2020, 2021, 2022, 2023.
+#
+# 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.
+
+"""
+DensityMatrix quantum state class.
+"""
+import copy
+import numpy as np
+
+from qiskit.circuit import QuantumCircuit, Instruction
+from qiskit.exceptions import QiskitError
+from qiskit.quantum_info.states import DensityMatrix
+from qiskit.quantum_info.operators.predicates import is_hermitian_matrix
+
+from qiskit_aer import AerSimulator
+from .aer_statevector import AerStatevector
+from .aer_state import AerState
+from ...backends.aerbackend import AerError
+from ...backends.backend_utils import BASIS_GATES
+
+
+class AerDensityMatrix(DensityMatrix):
+    """AerDensityMatrix class
+    This class inherits :class:`DensityMatrix`.
+    """
+
+    def __init__(self, data, dims=None, **configs):
+        """
+        Args:
+            data (np.array or list or Statevector or AerStatevector or DensityMatrix or
+                  AerDensityMatrix or QuantumCircuit or qiskit.circuit.Instruction):
+                Data from which the densitymatrix can be constructed. This can be either a complex
+                vector, another densitymatrix or statevector or a ``QuantumCircuit`` or
+                ``Instruction`` (``Operator`` is not supported in the current implementation).
+                If the data is a circuit or instruction, the densitymatrix is constructed by
+                assuming that all qubits are initialized to the zero state.
+            dims (int or tuple or list): Optional. The subsystem dimension of
+                                         the state (See additional information).
+            configs (kwargs): configurations of :class:`AerDensityMatrix`. `_aer_state` and `method`
+                are valid.
+
+        Raises:
+            AerError: if input data is not valid.
+        Additional Information:
+            The ``dims`` kwarg is used to ``AerDensityMatrix`` constructor.
+        """
+        if "_aer_state" in configs:
+            self._aer_state = configs.pop("_aer_state")
+        else:
+            if "method" not in configs:
+                configs["method"] = "density_matrix"
+            elif configs["method"] != "density_matrix":
+                method = configs["method"]
+                raise AerError(f"Method {method} is not supported")
+            if isinstance(data, (QuantumCircuit, Instruction)):
+                data, aer_state = AerDensityMatrix._from_instruction(data, None, configs)
+            elif isinstance(data, list):
+                data = self._from_1d_array(np.array(data, dtype=complex))
+                data, aer_state = AerDensityMatrix._from_ndarray(data, configs)
+            elif isinstance(data, np.ndarray):
+                data = self._from_1d_array(data)
+                data, aer_state = AerDensityMatrix._from_ndarray(data, configs)
+            elif isinstance(data, AerDensityMatrix):
+                aer_state = data._aer_state
+                if dims is None:
+                    dims = data._op_shape._dims_l
+                data = data._data.copy()
+            elif isinstance(data, DensityMatrix):
+                data, aer_state = AerDensityMatrix._from_ndarray(
+                    np.array(data.data, dtype=complex), configs
+                )
+            elif hasattr(data, "to_operator"):
+                # If the data object has a 'to_operator' attribute this is given
+                # higher preference than the 'to_matrix' method for initializing
+                # an Operator object.
+                op = data.to_operator()
+                data, aer_state = AerDensityMatrix._from_ndarray(op.data, configs)
+                if dims is None:
+                    dims = op.output_dims()
+            elif hasattr(data, "to_matrix"):
+                # If no 'to_operator' attribute exists we next look for a
+                # 'to_matrix' attribute to a matrix that will be cast into
+                # a complex numpy matrix.
+                data, aer_state = AerDensityMatrix._from_ndarray(
+                    np.asarray(data.to_matrix(), dtype=complex), configs
+                )
+            else:
+                raise AerError(f"Input data is not supported: type={data.__class__}, data={data}")
+
+            self._aer_state = aer_state
+
+        super().__init__(data, dims=dims)
+
+        self._result = None
+        self._configs = configs
+
+    def seed(self, value=None):
+        """Set the seed for the quantum state RNG."""
+        if value is None or isinstance(value, int):
+            self._aer_state.set_seed(value)
+        else:
+            raise AerError(f"This seed is not supported: type={value.__class__}, value={value}")
+
+    def _last_result(self):
+        if self._result is None:
+            self._result = self._aer_state.last_result()
+        return self._result
+
+    def metadata(self):
+        """Return result metadata of an operation that executed lastly."""
+        if self._last_result() is None:
+            raise AerError("AerState was not used and metadata does not exist.")
+        return self._last_result()["metadata"]
+
+    def __copy__(self):
+        return copy.deepcopy(self)
+
+    def __deepcopy__(self, _memo=None):
+        ret = AerDensityMatrix(self._data.copy(), **self._configs)
+        ret._op_shape = copy.deepcopy(self._op_shape)
+        ret._rng_generator = copy.deepcopy(self._rng_generator)
+        return ret
+
+    def conjugate(self):
+        return AerDensityMatrix(np.conj(self._data), dims=self.dims())
+
+    def tensor(self, other):
+        """Return the tensor product state self ⊗ other.
+        Args:
+            other (AerDensityMatrix): a quantum state object.
+        Returns:
+            AerDensityMatrix: the tensor product operator self ⊗ other.
+        Raises:
+            QiskitError: if other is not a quantum state.
+        """
+        if not isinstance(other, AerDensityMatrix):
+            other = AerDensityMatrix(other)
+        ret = copy.copy(self)
+        ret._data = np.kron(self._data, other._data)
+        ret._op_shape = self._op_shape.tensor(other._op_shape)
+        return ret
+
+    def expand(self, other):
+        """Return the tensor product state other ⊗ self.
+        Args:
+            other (AerDensityMatrix): a quantum state object.
+        Returns:
+            AerDensityMatrix: the tensor product state other ⊗ self.
+        Raises:
+            QiskitError: if other is not a quantum state.
+        """
+        if not isinstance(other, AerDensityMatrix):
+            other = AerDensityMatrix(other)
+        ret = copy.copy(self)
+        ret._data = np.kron(other._data, self._data)
+        ret._op_shape = self._op_shape.expand(other._op_shape)
+        return ret
+
+    def _add(self, other):
+        """Return the linear combination self + other.
+        Args:
+            other (AerDensityMatrix): a quantum state object.
+        Returns:
+            AerDensityMatrix: the linear combination self + other.
+        Raises:
+            QiskitError: if other is not a quantum state, or has
+                         incompatible dimensions.
+        """
+        if not isinstance(other, AerDensityMatrix):
+            other = AerDensityMatrix(other)
+        self._op_shape._validate_add(other._op_shape)
+        ret = copy.copy(self)
+        ret._data = self.data + other.data
+        return ret
+
+    def sample_memory(self, shots, qargs=None):
+        if qargs is None:
+            qubits = np.arange(self._aer_state.num_qubits)
+        else:
+            qubits = np.array(qargs)
+
+        self._aer_state.close()
+        self._aer_state.renew()
+        self._aer_state.initialize(self._data, copy=False)
+        samples = self._aer_state.sample_memory(qubits, shots)
+        self._data = self._aer_state.move_to_ndarray()
+        return samples
+
+    @staticmethod
+    def _from_1d_array(data):
+        # Convert statevector into a density matrix
+        ndim = data.ndim
+        shape = data.shape
+        if ndim == 2 and shape[0] == shape[1]:
+            pass  # We good
+        elif ndim == 1:
+            data = np.outer(data, np.conj(data))
+        elif ndim == 2 and shape[1] == 1:
+            data = np.reshape(data, shape[0])
+        else:
+            raise QiskitError("Invalid AerDensityMatrix input: not a square matrix.")
+        return data
+
+    @staticmethod
+    def _from_ndarray(init_data, configs):
+        aer_state = AerState(method="density_matrix")
+
+        options = AerSimulator._default_options()
+        for config_key, config_value in configs.items():
+            if options.get(config_key):
+                aer_state.configure(config_key, config_value)
+
+        if len(init_data) == 0:
+            raise AerError("initial data must be larger than 0")
+
+        num_qubits = int(np.log2(len(init_data)))
+
+        aer_state.allocate_qubits(num_qubits)
+        aer_state.initialize(data=init_data)
+
+        return aer_state.move_to_ndarray(), aer_state
+
+    @classmethod
+    def from_instruction(cls, instruction):
+        return AerDensityMatrix(instruction)
+
+    @staticmethod
+    def _from_instruction(inst, init_data, configs):
+        aer_state = AerState(method="density_matrix")
+
+        for config_key, config_value in configs.items():
+            aer_state.configure(config_key, config_value)
+
+        basis_gates = BASIS_GATES["density_matrix"]
+        custom_insts = ["reset", "kraus", "barrier"]
+
+        aer_state.allocate_qubits(inst.num_qubits)
+        num_qubits = inst.num_qubits
+
+        if init_data is not None:
+            aer_state.initialize(data=init_data, copy=True)
+        else:
+            aer_state.initialize()
+
+        if isinstance(inst, QuantumCircuit) and inst.global_phase != 0:
+            aer_state.apply_global_phase(inst.global_phase)
+
+        if isinstance(inst, QuantumCircuit):
+            AerStatevector._aer_evolve_circuit(
+                aer_state, inst, range(num_qubits), basis_gates, custom_insts
+            )
+        else:
+            AerStatevector._aer_evolve_instruction(
+                aer_state, inst, range(num_qubits), basis_gates, custom_insts
+            )
+
+        return aer_state.move_to_ndarray(), aer_state
+
+    def reset(self, qargs=None):
+        # Normally, DensityMatrix.reset returns DensityMatrix, which should
+        # be converted to AerDensityMatrix if necessary.
+        density_matrix = super().reset(qargs=qargs)
+        if isinstance(density_matrix, DensityMatrix):
+            density_matrix = AerDensityMatrix(density_matrix)
+        return density_matrix
+
+    @classmethod
+    def from_label(cls, label):
+        return AerDensityMatrix(AerStatevector.from_label(label))
+
+    @staticmethod
+    def from_int(i, dims):
+        size = np.prod(dims)
+        state = np.zeros((size, size), dtype=complex)
+        state[i, i] = 1.0
+        return AerDensityMatrix(state, dims=dims)
+
+    def to_statevector(self, atol=None, rtol=None):
+        """Return a statevector from a pure density matrix.
+        Args:
+            atol (float): Absolute tolerance for checking operation validity.
+            rtol (float): Relative tolerance for checking operation validity.
+        Returns:
+            AerStatevector: The pure density matrix's corresponding statevector.
+                Corresponds to the eigenvector of the only non-zero eigenvalue.
+        Raises:
+            QiskitError: if the state is not pure.
+        """
+        if atol is None:
+            atol = self.atol
+        if rtol is None:
+            rtol = self.rtol
+
+        if not is_hermitian_matrix(self.data, atol=atol, rtol=rtol):
+            raise QiskitError("Not a valid density matrix (non-hermitian).")
+
+        evals, evecs = np.linalg.eig(self.data)
+
+        nonzero_evals = evals[abs(evals) > atol]
+        if len(nonzero_evals) != 1 or not np.isclose(nonzero_evals[0], 1, atol=atol, rtol=rtol):
+            raise QiskitError("Density matrix is not a pure state")
+
+        psi = evecs[:, np.argmax(evals)]  # eigenvectors returned in columns.
+        return AerStatevector(psi)