qiskit_nature.second_q.mappers.qubit_mapper のソースコード

# This code is part of a Qiskit project.
#
# (C) Copyright IBM 2021, 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.

"""Qubit Mapper interface."""

from __future__ import annotations

from abc import ABC
from functools import lru_cache
from typing import TypeVar, Dict, Iterable, Generic, Generator

import numpy as np
from qiskit.quantum_info.operators import Pauli, SparsePauliOp
from qiskit_algorithms.list_or_dict import ListOrDict as ListOrDictType

from qiskit_nature import QiskitNatureError
from qiskit_nature.second_q.operators import SparseLabelOp

# pylint: disable=invalid-name
T = TypeVar("T")


class _ListOrDict(Dict, Iterable, Generic[T]):
    """The ListOrDict utility class.

    This is a utility which allows seamless iteration of a `list` or `dict` object.
    """

    def __init__(self, values: ListOrDictType | None = None):
        """
        Args:
            values: an optional object of `list` or `dict` type.
        """
        if isinstance(values, list):
            values = dict(enumerate(values))
        elif values is None:
            values = {}
        super().__init__(values)

    def __iter__(self) -> Generator[tuple[int | str, T], T, None]:
        """Return the generator-iterator method."""
        return self._generator()

    def _generator(self) -> Generator[tuple[int | str, T], T, None]:
        """Return generator method iterating the contents of this class.

        This generator yields the `(key, value)` pairs of the underlying dictionary. If this object
        was constructed from a list, the keys in this generator are simply the numeric indices.

        This generator also supports overriding the yielded value upon receiving any value other
        than `None` from a `send` [1] instruction.

        [1]: https://docs.python.org/3/reference/expressions.html#generator.send
        """
        for key, value in self.items():
            new_value = yield (key, value)
            if new_value is not None:
                self[key] = new_value

    @classmethod
    def wrap(cls, objects: dict | list | T) -> tuple[_ListOrDict, type]:
        """Wraps the provided objects into a ``_ListOrDict`` instance.

        Args:
            objects: a dict, list or single object instance to be wrapped.

        Returns:
            A tuple consisting of the constructed ``_ListOrDict`` and the original type that was
            wrapped.
        """
        wrapped_type = type(objects)

        if not issubclass(wrapped_type, (dict, list)):
            objects = [objects]

        wrapped_objects = cls(objects)

        return wrapped_objects, wrapped_type

    def unwrap(self, wrapped_type: type, *, suppress_none: bool = True) -> dict | Iterable | T:
        """Return the content of this class according to the initial type of the data before
        the creation of the ListOrDict object.

        Args:
            wrapped_type: Type of the data before the creation of the ListOrDict object.
            suppress_none: If None values should be suppressed from the output.

        Returns:
            Content of the current class instance as a list, a dictionary or a single element.
        """

        def _qubit_op_type_wrapper(qubit_op: SparsePauliOp | None):
            if qubit_op is None:
                return None
            return qubit_op

        if wrapped_type == list:
            if suppress_none:
                return [_qubit_op_type_wrapper(op) for _, op in iter(self) if op is not None]
            else:
                return [_qubit_op_type_wrapper(op) for _, op in iter(self)]
        if wrapped_type == dict:
            if suppress_none:
                return {key: _qubit_op_type_wrapper(op) for key, op in iter(self) if op is not None}
            else:
                return {key: _qubit_op_type_wrapper(op) for key, op in iter(self)}
        # only other case left is that it was a single operator to begin with:
        return _qubit_op_type_wrapper(list(iter(self))[0][1])


[ドキュメント]class QubitMapper(ABC): """The interface for implementing methods which map from a ``SparseLabelOp`` to a qubit operator in the form of a ``SparsePauliOp``. """ def _map_single( self, second_q_op: SparseLabelOp, *, register_length: int | None = None ) -> SparsePauliOp: """Maps a :class:`~qiskit_nature.second_q.operators.SparseLabelOp` to a ``SparsePauliOp``. Args: second_q_op: the ``SparseLabelOp`` to be mapped. register_length: when provided, this will be used to overwrite the ``register_length`` attribute of the operator being mapped. This is possible because the ``register_length`` is considered a lower bound in a ``SparseLabelOp``. Returns: The qubit operator corresponding to the problem-Hamiltonian in the qubit space. """ return self.mode_based_mapping(second_q_op, register_length=register_length)
[ドキュメント] def map( self, second_q_ops: SparseLabelOp | ListOrDictType[SparseLabelOp], *, register_length: int | None = None, ) -> SparsePauliOp | ListOrDictType[SparsePauliOp]: """Maps a second quantized operator or a list, dict of second quantized operators based on the current mapper. Args: second_q_ops: A second quantized operator, or list thereof. register_length: when provided, this will be used to overwrite the ``register_length`` attribute of the ``SparseLabelOp`` being mapped. This is possible because the ``register_length`` is considered a lower bound in a ``SparseLabelOp``. Returns: A qubit operator in the form of a ``SparsePauliOp``, or list (resp. dict) thereof if a list (resp. dict) of second quantized operators was supplied. """ wrapped_second_q_ops, wrapped_type = _ListOrDict.wrap(second_q_ops) qubit_ops: _ListOrDict = _ListOrDict() for name, second_q_op in iter(wrapped_second_q_ops): qubit_ops[name] = self._map_single(second_q_op, register_length=register_length) returned_ops = qubit_ops.unwrap(wrapped_type) # Note the output of the mapping will never be None for standard mappers other than the # TaperedQubitMapper. return returned_ops
[ドキュメント] @classmethod @lru_cache(maxsize=32) def pauli_table(cls, register_length: int) -> list[tuple[Pauli, Pauli]]: """Generates a Pauli-lookup table mapping from modes to pauli pairs. The generated table is processed by :meth:`.QubitMapper.sparse_pauli_operators`. Args: register_length: the register length for which to generate the table. Returns: A list of tuples in which the first and second Pauli operator the real and imaginary Pauli strings, respectively. """
[ドキュメント] @classmethod @lru_cache(maxsize=32) def sparse_pauli_operators( cls, register_length: int ) -> tuple[list[SparsePauliOp], list[SparsePauliOp]]: # pylint: disable=unused-argument """Generates the cached :class:`.SparsePauliOp` terms. This uses :meth:`.QubitMapper.pauli_table` to construct a list of operators used to translate the second-quantization symbols into qubit operators. Args: register_length: the register length for which to generate the operators. Returns: Two lists stored in a tuple, consisting of the creation and annihilation operators, applied on the individual modes. """ times_creation_op = [] times_annihilation_op = [] for paulis in cls.pauli_table(register_length): real_part = SparsePauliOp(paulis[0], coeffs=[0.5]) imag_part = SparsePauliOp(paulis[1], coeffs=[0.5j]) # The creation operator is given by 0.5*(X - 1j*Y) creation_op = real_part - imag_part times_creation_op.append(creation_op) # The annihilation operator is given by 0.5*(X + 1j*Y) annihilation_op = real_part + imag_part times_annihilation_op.append(annihilation_op) return (times_creation_op, times_annihilation_op)
[ドキュメント] @classmethod def mode_based_mapping( cls, second_q_op: SparseLabelOp, register_length: int | None = None, ) -> SparsePauliOp: # pylint: disable=unused-argument """Utility method to map a ``SparseLabelOp`` to a qubit operator using a pauli table. Args: second_q_op: the `SparseLabelOp` to be mapped. register_length: when provided, this will be used to overwrite the ``register_length`` attribute of the operator being mapped. This is possible because the ``register_length`` is considered a lower bound. Returns: The qubit operator corresponding to the problem-Hamiltonian in the qubit space. Raises: QiskitNatureError: If number length of pauli table does not match the number of operator modes, or if the operator has unexpected label content """ if register_length is None: register_length = second_q_op.register_length times_creation_op, times_annihilation_op = cls.sparse_pauli_operators(register_length) # make sure ret_op_list is not empty by including a zero op ret_op_list = [SparsePauliOp("I" * register_length, coeffs=[0])] for terms, coeff in second_q_op.terms(): # 1. Initialize an operator list with the identity scaled by the `coeff` ret_op = SparsePauliOp("I" * register_length, coeffs=np.array([coeff])) # Go through the label and replace the fermion operators by their qubit-equivalent, then # save the respective Pauli string in the pauli_str list. for term in terms: char = term[0] if char == "": break position = int(term[1]) if char == "+": ret_op = ret_op.compose(times_creation_op[position], front=True).simplify() elif char == "-": ret_op = ret_op.compose(times_annihilation_op[position], front=True).simplify() # catch any disallowed labels else: raise QiskitNatureError( f"FermionicOp label included '{char}'. Allowed characters: I, N, E, +, -" ) ret_op_list.append(ret_op) sparse_op = SparsePauliOp.sum(ret_op_list).simplify() return sparse_op