map_edge_vertex_generators

map_edge_vertex_generators(operator, map_action, identity, compose=None)

Associer un opérateur de type à EdgeVertexOperator un autre type d'opérateur.

Il s'agit d'une fonction générique destinée à faciliter la mise en œuvre de nouveaux mappeurs pour les instances EdgeVertexOperator . En substance, il se contente de parcourir les termes de l'opérateur, en appliquant à EdgeAction chacun d'entre eux la fonction map_action fournie par l'utilisateur. Associé au générateur identity fourni par l'utilisateur, cela permet d'effectuer une mise en correspondance vers des types de sortie arbitraires.

Remarque

Le type de sortie doit T prendre en charge la multiplication par un scalaire via __mul__. Si compose=None elle doit également prendre en charge la composition de deux instances via __and__. SparseObservable ce n'est pas le cas, c'est pourquoi l'exemple ci-dessous le nomme explicitement compose() ; un type comportant un __and__ (tel que SparsePauliOp) peut s'appuyer sur la valeur par défaut.

Remarque

La cartographie présentée ci-dessous est une illustration délibérément simplifiée de cette fonction; elle ne remplace pas celle-ci edge_vertex_jordan_wigner(): elle ne prend en compte que les interactions entre voisins les plus proches et n'est ni parallélisée ni limitée en mémoire. Utilisez plutôt la fonction de la bibliothèque au lieu de copier celle-ci.

>>> from qiskit_fermions.mappers import map_edge_vertex_generators
>>> from qiskit_fermions.operators import EdgeAction, EdgeVertexOperator
>>> from qiskit.quantum_info import SparseObservable
>>>
>>> def jordan_wigner_nearest_neighbor(mode: EdgeAction) -> SparseObservable:
...     left, right = mode
...     if left == right:
...         return SparseObservable.from_sparse_list(
...             [("Z", [left], 1.0)], num_qubits=num_qubits
...         )
...     if abs(left - right) != 1:
...         raise NotImplementedError(
...             "This mapping only handles nearest neighbor interactions"
...         )
...     # The orientation must be compared rather than differenced: an edge operator is
...     # antisymmetric, so the sign depends on the index order while the string does not.
...     lo, hi = min(left, right), max(left, right)
...     coeff = -1.0 if left < right else 1.0
...     return SparseObservable.from_sparse_list(
...         [("YX", [lo, hi], coeff)], num_qubits=num_qubits
...     )
>>>
>>> num_qubits = 4
>>> def identity() -> SparseObservable:
...     return SparseObservable.identity(num_qubits)
>>>
>>> op = EdgeVertexOperator.from_dict({
...     ((0, 0),): 2.0,
...     ((0, 1),): 0.5,
...     ((1, 1), (1, 2)): 1.0,
... })
>>> qop = map_edge_vertex_generators(
...     op, jordan_wigner_nearest_neighbor, identity, compose=SparseObservable.compose
... )
>>> print(sorted(qop.simplify().to_sparse_list()))
[('XX', [1, 2], 1j), ('YX', [0, 1], (-0.5+0j)), ('Z', [0], (2+0j))]

Paramètres

operator (EdgeVertexOperator) – l'opérateur à mapper.
map_action (Callable[[tuple[int, int]], T]) – la fonction permettant de mapper un élément unique vers EdgeAction le type de sortie souhaité.
identity (Callable[[], T]) – la fonction permettant de générer l'instance de l'identité multiplicative du type de sortie.
compose (Callable[[T, T], T] | None) – une fonction facultative permettant de mettre en œuvre la logique de composition de deux instances de type de sortie. Si cette information n'est pas fournie, le système utilisera par défaut operator.and_().

Retours

L'opérateur mappé.

Type de retour

Cette page a-t-elle été utile ?

Signaler un bogue, une coquille ou proposer du contenu sur GitHub.