générateurs_de_problèmes

qiskit_addon_utils.problem_generators

Méthodes d'utilité pour la génération de problèmes.

generate_xyz_hamiltonian

generate_xyz_hamiltonian(coupling, *, coupling_constants=(1.0, 1.0, 1.0), ext_magnetic_field=(0.0, 0.0, 0.0), pauli_order_strategy=PauliOrderStrategy.ColorThenInteraction, coloring=None)

GitHub

Générer un opérateur de qubit tenant compte de la connectivité et représentant un modèle quantique de type XYZ.

Cette fonction met en œuvre l'hamiltonien suivant :

\hat{H} = \sum_{(j,k)\in E} (J_{x} \sigma_j^{x} \sigma_{k}^{x} + J_{y} \sigma_j^{y} \sigma_{k}^{y} + J_{z} \sigma_j^{z} \sigma_{k}^{z}) + \sum_{j\in V} (h_{x} \sigma_j^{x} + h_{y} \sigma_j^{y} + h_{z} \sigma_j^{z})

Où G(V,E) est le graphique de la carte coupling fournie.

Remarque

Un facteur $-\frac{1}{2}$ est souvent inclus en dehors de la somme de cette équation. Ce facteur n'est pas appliqué en interne, il doit donc être pris en compte dans les entrées coupling_constants et ext_magnetic_field .

>>> from qiskit.transpiler import CouplingMap
>>> from qiskit_addon_utils.problem_generators import generate_xyz_hamiltonian

>>> coupling_map = CouplingMap.from_line(10)
>>> hamiltonian = generate_xyz_hamiltonian(
...     coupling_map,
...     coupling_constants=(0.4, 0.4, 0.0),
...     ext_magnetic_field=(0.0, 0.0, 0.6),
... )
>>> print(hamiltonian)
SparsePauliOp(['IIIIIIIXXI', 'IIIIIIIYYI', 'IIIIIXXIII', 'IIIIIYYIII',
               'IIIXXIIIII', 'IIIYYIIIII', 'IXXIIIIIII', 'IYYIIIIIII',
               'IIIIIIIIXX', 'IIIIIIIIYY', 'IIIIIIXXII', 'IIIIIIYYII',
               'IIIIXXIIII', 'IIIIYYIIII', 'IIXXIIIIII', 'IIYYIIIIII',
               'XXIIIIIIII', 'YYIIIIIIII', 'IIIIIIIIIZ', 'IIIIIIIIZI',
               'IIIIIIIZII', 'IIIIIIZIII', 'IIIIIZIIII', 'IIIIZIIIII',
               'IIIZIIIIII', 'IIZIIIIIII', 'IZIIIIIIII', 'ZIIIIIIIII'],
            coeffs=[0.4+0.j, 0.4+0.j, 0.4+0.j, 0.4+0.j, 0.4+0.j, 0.4+0.j, 0.4+0.j, 0.4+0.j,
                    0.4+0.j, 0.4+0.j, 0.4+0.j, 0.4+0.j, 0.4+0.j, 0.4+0.j, 0.4+0.j, 0.4+0.j,
                    0.4+0.j, 0.4+0.j, 0.6+0.j, 0.6+0.j, 0.6+0.j, 0.6+0.j, 0.6+0.j, 0.6+0.j,
                    0.6+0.j, 0.6+0.j, 0.6+0.j, 0.6+0.j])

Paramètres

coupling (CouplingMap |PyGraph |PyDiGraph) – Le sous-graphe de qubits sur lequel il faut faire correspondre l'hamiltonien. La direction des arêtes du graphique sera ignorée et les arêtes parallèles seront traitées comme une seule arête lors de la génération de l'opérateur.
coupling_constants (Sequence[float]) – Les constantes de couplage à valeur réelle, $J_i$ , dans chaque axe cartésien.
ext_magnetic_field (Sequence[float]) – Les coefficients, $h_i$ , représentant un champ magnétique le long de chaque axe cartésien.
pauli_order_strategy (PauliOrderStrategy) – Indique la stratégie d'itération dans laquelle les termes de Pauli seront générés. Voir PauliOrderStrategy pour plus de détails.
coloring (dict[tuple[int, int], int] | None) – Un dictionnaire optionnel codant la coloration du graphe utilisée pour trier les termes hamiltoniens. Ce dictionnaire associe les étiquettes des bords (sous la forme de paires d'entiers) à des valeurs de couleur (entiers simples). Les termes d'interaction hamiltonienne seront ajoutés en augmentant la valeur de la couleur. Dans chaque couleur, les arêtes sont triées, ce qui ne change rien physiquement mais facilite la lecture des résultats.

Retours

Un opérateur qubit décrivant un modèle quantique de type XYZ. Le i-ème qubit de l'opérateur correspond au nœud d'indice i sur la carte de couplage.

Augmentations

ValueError - Les constantes de couplage doivent être spécifiées par une séquence de valeurs à virgule flottante ( length-3 ).
ValueError - Le champ magnétique externe doit être spécifié par une séquence de valeurs à virgule flottante ( length-3 ).

Type de retour

SparsePauliOp

generate_time_evolution_circuit

generate_time_evolution_circuit(operator, *, synthesis=None, time=1.0)

GitHub

Modéliser l'évolution temporelle d'un opérateur.

>>> from qiskit.quantum_info import SparsePauliOp
>>> from qiskit.synthesis import SuzukiTrotter
>>> from qiskit.transpiler import CouplingMap
>>> from qiskit_addon_utils.problem_generators import (
...     PauliOrderStrategy,
...     generate_xyz_hamiltonian,
...     generate_time_evolution_circuit,
... )

>>> coupling_map = CouplingMap.from_line(6)
>>> hamiltonian = generate_xyz_hamiltonian(
...     coupling_map,
...     coupling_constants=(0.4, 0.4, 0.0),
...     ext_magnetic_field=(0.0, 0.0, 0.6),
...     pauli_order_strategy=PauliOrderStrategy.InteractionThenColorZigZag,
... )

>>> circ = generate_time_evolution_circuit(
...     hamiltonian, synthesis=SuzukiTrotter(order=2, reps=2), time=2.0
... )
>>> _ = circ.draw("mpl", fold=-1)

Paramètres

operator (SparsePauliOp) – L'opérateur pour lequel il faut modéliser l'évolution temporelle.
synthesis (EvolutionSynthesis | None) – Une stratégie de synthèse. Si None, la synthèse par défaut est la formule du produit de Lie-Trotter avec une seule répétition.
time (float) – Le temps d'évolution.

Retours

A QuantumCircuit mettant en œuvre un opérateur évolué dans le temps.

Type de retour

QuantumCircuit

PauliOrderStrategy

class PauliOrderStrategy(value)

GitHub

Bases : Enum

Énumération de différents ordres de Pauli.

Lors de la construction d'un hamiltonien sur un ensemble coloré d'arêtes, les termes de Pauli générés peuvent être ordonnés de différentes manières. Cet ordre des termes dans l'hamiltonien est préservé au cours de son évolution temporelle et a donc un impact direct sur le circuit quantique qui en résulte.

ColorThenInteraction

Valeur par défaut : 1

Cette stratégie passe d'abord en revue toutes les arêtes (triées par leur valeur de couleur), puis les interactions (triées comme suit : X, Y, Z).

InteractionThenColor

Valeur par défaut : 2

Cette stratégie est l'inverse de ColorThenInteraction. Il itère d'abord les interactions (triées comme suit : X, Y, Z), puis toutes les arêtes (triées en fonction de leur valeur de couleur).

InteractionThenColorZigZag

Valeur par défaut : 3

Cette stratégie est similaire à celle de InteractionThenColor . Cependant, il alterne l'itération des bords en incrémentant et en décrémentant les valeurs de couleur lorsqu'il passe d'une interaction à l'autre. Par exemple, si seules les interactions X et Y sont incluses et que trois valeurs de couleur sont utilisées ({1, 2, 3}), on obtiendra l'ordre suivant : ["X on 1", "X on 2", "X on 3", "Y on 3", "Y on 2", "Y on 1"].

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

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