MPF dynamiques

setup_dynamic_lse(trotter_steps, time, identity_factory, exact_evolver_factory, approx_evolver_factory, initial_state)

Renvoie le système d'équations linéaires pour le calcul des coefficients MPF dynamiques.

Cette fonction utilise l'algorithme DynamicMPF pour calculer les composantes de la matrice de Gram (LSE.A$M$ en [1] et [2] ) et du vecteur de recouvrement (LSE.b$L$ en [1] et [2] ) pour les paramètres d'évolution temporelle fournis.

Les éléments de la matrice de Gram, $M_{ij}$, et le vecteur de chevauchement, $L_i$, sont définis comme suit

où $\rho(t)$ est l'état exact de l'évolution temporelle au moment $t$ et $\rho_{k_i}(t)$ est l'état de l'évolution temporelle approximé à l'aide de $k_i$ étapes de Trotter.

Le calcul des coefficients MPF dynamiques (c'est-à-dire dépendant du temps) à partir de $M$ et $L$ revient à trouver une solution à l'équation LSE (de manière similaire à la façon dont les coefficients static MPF sont calculés) tout en appliquant la contrainte selon laquelle la somme de tous les coefficients doit être égale à 1 ( $\sum_i x_i = 1$ ), qui n'est pas appliquée dans le cadre de ce LSE (contrairement au cas statique). Les problèmes d'optimisation qui incluent cette contrainte supplémentaire sont documentés dans le module costs module. Celle suggérée par les [points 1] et [2] est la setup_frobenius_problem().

L'évaluation de chaque élément $M_{ij}$ et $L_i$ nécessite le calcul du chevauchement entre deux états d'évolution temporelle. L'algorithme DynamicMPF le fait au moyen de calculs de réseaux tensoriels, fournis par l'une des dépendances optionnelles. Les backends disponibles sont listés et expliqués plus en détail dans le module backends module.

Nous présentons ci-dessous un exemple utilisant le quimb_tebd backend. Nous expliquons brièvement chaque élément.

Tout d'abord, nous initialisons un simple hamiltonien d'Heisenberg que nous souhaitons faire évoluer dans le temps. Étant donné que nous utilisons un time-evolver basé sur la bibliothèque quimbnous initialisons également le hamiltonien à l'aide de cette bibliothèque.

>>> from quimb.tensor import ham_1d_heis
>>> num_qubits = 10
>>> hamil = ham_1d_heis(num_qubits, 0.8, 0.3, cyclic=False)

Ensuite, nous définissons le nombre de pas de Trotter pour constituer notre MPF, le temps d'évolution visé ainsi que l'état initial ( $\psi_{in}$ en [1] et $\psi_0$ en [2], resp.) par rapport à laquelle nous calculons le chevauchement entre les états d'évolution temporelle. Ici, nous utilisons simplement l'état Néel que nous construisons également à l'aide de quimb:

>>> trotter_steps = [3, 4]
>>> time = 0.9

>>> from quimb.tensor import MPS_neel_state
>>> initial_state = MPS_neel_state(num_qubits)

Puisque nous devons exécuter l'algorithme complet DynamicMPF pour calculer chaque élément de $M_{ij}$ et $L_i$, nous devons fournir des méthodes d'usine pour initialiser les arguments d'entrée des instances DynamicMPF instances. Pour ce faire, nous devons assurer trois fonctions. Pour les construire, nous utiliserons la fonction functools.partial() fonction.

>>> from functools import partial

Tout d'abord, nous avons besoin d'une fonction pour initialiser un état d'évolution temporelle vide (voir aussi DynamicMPF.evolution_state pour plus de détails). Cette fonction de construction ne peut pas prendre d'arguments positionnels ou de mots-clés et doit renvoyer un State objet.

>>> from qiskit_addon_mpf.backends.quimb_tebd import MPOState
>>> from quimb.tensor import MPO_identity
>>> identity_factory = lambda: MPOState(MPO_identity(num_qubits))

Les deuxième et troisième fonctions doivent construire les moteurs d'évolution temporelle des côtés gauche et droit (voir également DynamicMPF.lhs et DynamicMPF.rhs pour plus de détails). Ces fonctions doivent respecter les règles ExactEvolverFactory et ApproxEvolverFactory respectivement.

La fonction ExactEvolverFactory doit prendre un objet State comme seul argument positionnel et doit renvoyer un objet Evolver qui sera utilisé pour calculer la LHS des éléments de $L_i$ (c'est-à-dire qu'il doit produire l'état exact de l'évolution temporelle, $\rho(t)$ ).

Ici, nous approximons l'état temporel exact avec une formule de Suzuki-Trotter du quatrième ordre en utilisant un petit pas de temps de 0.05. Nous spécifions également certaines options de troncature quimb-pour limiter la dimension maximale des liaisons du réseau tensoriel sous-jacent ainsi que les valeurs singulières minimales des liaisons du réseau tensoriel divisé.

>>> from qiskit_addon_mpf.backends.quimb_tebd import TEBDEvolver
>>> exact_evolver_factory = partial(
...     TEBDEvolver,
...     H=hamil,
...     dt=0.05,
...     order=4,
...     split_opts={"max_bond": 10, "cutoff": 1e-5},
... )

La fonction ApproxEvolverFactory doit également prendre un objet State comme seul argument de position et, en outre, un mot-clé appelé dt pour spécifier le pas de temps de l'évolution temporelle. Il doit également renvoyer un objet Evolver qui produit les états d'évolution temporelle approximatifs, $\rho_{k_i}(t)$, où $k_i$ est déterminé par le pas de temps choisi, dt. En tant que telles, ces instances seront utilisées pour calculer le RHS de $L_i$ ainsi que les deux côtés des éléments de $M_{ij}$.

Nous utilisons ici une formule de Suzuki-Trotter du second ordre avec les mêmes paramètres de troncature que précédemment.

>>> approx_evolver_factory = partial(
...     TEBDEvolver,
...     H=hamil,
...     order=2,
...     split_opts={"max_bond": 10, "cutoff": 1e-5},
... )

Enfin, nous pouvons initialiser et exécuter la fonction setup_dynamic_lse() pour obtenir la fonction LSE décrite en haut de page.

>>> from qiskit_addon_mpf.dynamic import setup_dynamic_lse
>>> lse = setup_dynamic_lse(
...     trotter_steps,
...     time,
...     identity_factory,
...     exact_evolver_factory,
...     approx_evolver_factory,
...     initial_state,
... )
>>> print(lse.A)  
[[1.         0.99998513]
 [0.99998513 1.        ]]
>>> print(lse.b)  
[1.00001585 0.99998955]

Paramètres

• trotter_steps (list[int]) – la séquence de pas de trotteurs à utiliser.
• time (float) – le temps total d'évolution de la cible.
• identity_factory (IdentityStateFactory) – une fonction permettant de générer un objet State vide.
• exact_evolver_factory (ExactEvolverFactory) – une fonction pour initialiser l'instance Evolver qui produit l'état exact de l'évolution temporelle, $\rho(t)$.
• approx_evolver_factory (ApproxEvolverFactory) – une fonction pour initialiser l'instance Evolver qui produit l'état approximatif de l'évolution temporelle, $\rho_{k_i}(t)$, pour différentes valeurs de $k_i$ en fonction du pas de temps fourni, dt.
• initial_state (Any) – l'état initial ( $\psi_{in}$ ou $\psi_0$ ) par rapport auquel calculer les éléments $M_{ij}$ de LSE.A et $L_i$ de LSE.b. Le type de cet objet doit correspondre au réseau tensoriel choisi pour les arguments précédents.

Retours

Le LSE pour trouver les coefficients dynamiques de la MPF comme décrit ci-dessus.

Type de retour

LSE

Références

[1] : S. Zhuk et al, Physique. Rev. Research 6, 033309 (2024).

https://journals.aps.org/prresearch/abstract/10.1103/PhysRevResearch.6.033309

[2] : N. Robertson et al, arXiv:2407.17405v2 (2024).

https://arxiv.org/abs/2407.17405v2