Dynamische MPFs

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

Rückgabe des linearen Gleichungssystems zur Berechnung der dynamischen MPF-Koeffizienten.

Diese Funktion verwendet den DynamicMPF algorithmus zur Berechnung der Komponenten der Gram-Matrix (LSE.A, $M$ in [1] und [2] ) und den Überlappungsvektor (LSE.b, $L$ in [1] und [2] ) für die angegebenen Zeit-Evolutionsparameter.

Die Elemente der Gram-Matrix $M_{ij}$ und des Überlappungsvektors $L_i$ sind definiert als

wobei $\rho(t)$ der exakte Zeitentwicklungszustand zum Zeitpunkt $t$ und $\rho_{k_i}(t)$ der durch $k_i$ Trotter-Schritte approximierte Zeitentwicklungszustand ist.

Die Berechnung der dynamischen (d.h. zeitabhängigen) MPF-Koeffizienten aus $M$ und $L$ läuft darauf hinaus, eine Lösung für die Frage LSE (ähnlich wie bei der Berechnung der static MPF-Koeffizienten berechnet werden), wobei die Bedingung gilt, dass alle Koeffizienten die Summe 1 ergeben müssen ( $\sum_i x_i = 1$ ), was im Rahmen dieser LSE (anders als im statischen Fall) nicht der Fall ist. Optimierungsprobleme, die diese zusätzliche Randbedingung enthalten, sind im costs modul dokumentiert. Die von [1] und [2] vorgeschlagene Variante ist die setup_frobenius_problem().

Die Auswertung jedes Elements $M_{ij}$ und $L_i$ erfordert die Berechnung der Überlappung zwischen zwei Zeitentwicklungszuständen. Der DynamicMPF algorithmus tut dies mit Hilfe von Tensornetzberechnungen, die durch eine der optionalen Abhängigkeiten bereitgestellt werden. Die verfügbaren Backends werden im Modul backends modul.

Im Folgenden finden Sie ein Beispiel, das das quimb_tebd backend. Wir erläutern kurz jedes Element.

Zunächst initialisieren wir einen einfachen Heisenberg-Hamiltonschen, den wir zeitlich entwickeln möchten. Da wir einen Zeit-Evolver verwenden, der auf quimbverwenden, initialisieren wir auch den Hamiltonian mit dieser Bibliothek.

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

Als Nächstes definieren wir die Anzahl der Trotter-Schritte, aus denen sich unser MPF zusammensetzt, die angestrebte Entwicklungszeit sowie den Ausgangszustand ( $\psi_{in}$ in [1] bzw. $\psi_0$ in [2] ) in Bezug auf die wir die Überlappung zwischen den Zeitentwicklungszuständen berechnen. Hier verwenden wir einfach den Néel-Zustand, den wir auch mit quimb:

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

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

Da wir den gesamten DynamicMPF algorithmus ausführen müssen, um jedes Element von $M_{ij}$ und $L_i$ zu berechnen, müssen wir Factory-Methoden für die Initialisierung der Eingangsargumente der DynamicMPF instanzen bereitstellen. Zu diesem Zweck müssen wir drei Funktionen bereitstellen. Um diese zu konstruieren, werden wir die functools.partial() funktion.

>>> from functools import partial

Zunächst benötigen wir eine Funktion, um einen leeren Zeitentwicklungszustand zu initialisieren (siehe auch DynamicMPF.evolution_state für weitere Details). Diese Konstruktorfunktion darf keine Positions- oder Schlüsselwortargumente annehmen und muss ein State objekt zurückgeben.

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

Die zweite und die dritte Funktion müssen die linke und die rechte Seite der Zeitentwicklungsmaschine konstruieren (siehe auch DynamicMPF.lhs und DynamicMPF.rhs für weitere Einzelheiten). Diese Funktionen sollten auf die ExactEvolverFactory und ApproxEvolverFactory protokollen folgen.

Die Funktion ExactEvolverFactory funktion sollte ein State objekt als ihr einziges Positionsargument nehmen und ein Evolver objekt zurückgeben, das für die Berechnung der LHS der Elemente von $L_i$ verwendet wird (d. h. sie sollte den exakten Zeitentwicklungszustand erzeugen, $\rho(t)$ ).

Hier approximieren wir den exakten zeitlich entwickelten Zustand mit einer Suzuki-Trotter-Formel vierter Ordnung mit einem kleinen Zeitschritt von 0.05. Wir spezifizieren auch einige quimb-spezifische Trunkierungsoptionen, um die maximale Bindungsdimension des zugrundeliegenden Tensornetzwerks sowie die minimalen Singulärwerte der gespaltenen Tensornetzwerkbindungen zu begrenzen.

>>> 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},
... )

Die Funktion ApproxEvolverFactory funktion sollte ebenfalls ein State objekt als einziges Positionsargument und zusätzlich ein Schlüsselwortargument namens dt , um den Zeitschritt der Zeitentwicklung anzugeben. Es sollte auch ein Evolver objekt zurückgeben, das die approximativen Zeitentwicklungszustände, $\rho_{k_i}(t)$, erzeugt, wobei $k_i$ durch den gewählten Zeitschritt, dt, bestimmt wird. Daher werden diese Instanzen für die Berechnung der RHS von $L_i$ sowie für beide Seiten der Elemente von $M_{ij}$ verwendet.

Hier verwenden wir eine Suzuki-Trotter-Formel zweiter Ordnung mit den gleichen Trunkierungseinstellungen wie zuvor.

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

Schließlich können wir die Funktion initialisieren und ausführen setup_dynamic_lse() funktion initialisieren und ausführen, um die LSE wie oben beschrieben.

>>> 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]

Parameter

• trotter_steps (list[int]) – die Reihenfolge der zu verwendenden Trabschritte.
• time (float) – die gesamte Zielentwicklungszeit.
• identity_factory (IdentityStateFactory) – eine Funktion zur Erzeugung eines leeren State objekt zu erzeugen.
• exact_evolver_factory (ExactEvolverFactory) – eine Funktion zur Initialisierung der Evolver instanz, die den exakten Zeitentwicklungszustand erzeugt, $\rho(t)$.
• approx_evolver_factory (ApproxEvolverFactory) – eine Funktion zur Initialisierung der Evolver instanz, die den ungefähren Zeitentwicklungszustand, $\rho_{k_i}(t)$, für verschiedene Werte von $k_i$ in Abhängigkeit von dem angegebenen Zeitschritt, dt, erzeugt.
• initial_state (Any) – den Ausgangszustand ( $\psi_{in}$ oder $\psi_0$ ), in Bezug auf den die Elemente $M_{ij}$ von LSE.A und $L_i$ von LSE.b. Der Typ dieses Objekts muss mit dem für die vorherigen Argumente gewählten Tensornetzwerk-Backend übereinstimmen.

Rückgabe

Die LSE um die dynamischen MPF-Koeffizienten wie oben beschrieben zu ermitteln.

Rückgabetyp

LSE

Referenzen

[1] : S. Zhuk et al, Phys. Rev. Forschung 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