Einführung

Für die nicht kommutierbaren Operatoren $ X und Y $ gilt die folgende Lie-Trotter-Formel [^ name].

\exp(h(X+Y)) = \left( \exp(hX/n)\exp(hY/n) \right)^n + O\left(\frac{h^2}{n}\right)

Hier ist $ h $ die Zahl c und wird häufig als Zeitschritt bei der numerischen Berechnung verwendet, daher wird das Folgende als Zeitschritt bezeichnet. $ n $ ist die Zerlegungszahl. Der Zweck dieses Artikels besteht darin, diesen Abschaltfehler ordnungsgemäß zu bestätigen.

Die Quelle ist https://github.com/kaityo256/lie-trotter-sample Beim.

Hinzugefügt am 14. Juli 2017: Die Quelle wurde leicht modifiziert, sodass Sie auch eine quadratische symmetrische Zerlegung versuchen können. Einzelheiten finden Sie im folgenden Artikel Symmetrische Zerlegung zweiter Ordnung in der Lie-Trotter-Formel.

Erklärung, was das Skript tut

Betrachten Sie eine quadratische Matrix $ X $, $ Y $ der entsprechenden $ d $ -Dimension. Machen wir es zu einer symmetrischen Matrix, damit die Eigenwerte real sind. Berechnen Sie streng $ \ exp (h (X + Y)) $, $ \ exp (hX) $, $ \ exp (hY) $ usw. und berechnen Sie den Fehler mit der Lie-Trotter-Formel. Für den Fehler werde ich die Frobenius-Norm verwenden.

Machen Sie eine echte symmetrische Matrix

Erstellen Sie zunächst zufällig eine symmetrische Matrix mit der entsprechenden $ d $ -Dimension.

import numpy as np
import math
from scipy import linalg

d = 2
np.random.seed(1)
x1 = np.random.rand(d,d)
x2 = np.random.rand(d,d)
X = x1.dot(x1.T)
Y = x2.dot(x2.T)
Z = X + Y

Erstellen Sie eine entsprechend zufällige Matrix und setzen Sie das Produkt der Translokation auf $ X $ oder $ Y $. Auf diese Weise wird der Eigenwert real, weil er zu einer symmetrischen Matrix wird. Nehmen wir an, dass die Summe von $ X $ und $ Y $ $ Z $ ist.

Berechnung der Exponentialfunktion der Matrix

Erstellen Sie eine Funktion, die die Matrix im angegebenen Zeitintervall $ h $ auf die Schulter des Exponenten legt. Dazu zunächst diagonalisieren.

X = U_x \Lambda_x U_x^{-1}

Weil es einfach ist, eine Diagonalmatrix auf die Schulter einer Exponentialfunktion zu legen

\exp(h X) = U_x \exp(h \Lambda_x) U_x^{-1}

Kann berechnet werden als. Das in Python zu schreiben sieht so aus.

def calc_exp(X, h):
    rx, Ux = linalg.eigh(X)
    Ux_inv = linalg.inv(Ux)
    tx = np.diag(np.array([math.exp(h * i) for i in rx]))
    eX = Ux.dot(tx.dot(Ux_inv))
    return eX

Erklären Sie, was Sie tun

Rufen Sie linalg.eigh auf, weil es sich von einer symmetrischen Matrix ernährt
Setzen Sie den Eigenwertvektor in die Einschlussnotation der Liste auf die Schulter der Exponentialfunktion
Machen Sie eine Matrix mit numpy.diag
Rückgängig machen mit $ U_x $ oder $ U_x ^ {-1} $

Ich fühle mich so.

Angegebene Anzahl von Zerlegungen Trotter-Zerlegung

Es ist einfach, wenn die Exponentialfunktion der Matrix im angegebenen Zeitintervall berechnet werden kann. Beispiel: Im Fall von $ h $ in Zeitinkrementen und $ n $ in Zerlegungsnummer erstellen Sie zuerst $ \ exp (h X / n) $ und $ \ exp (h Y / n) $. Alles was Sie tun müssen, ist die Einheitsmatrix $ n $ mal zu multiplizieren.

    eX = calc_exp(X,h/n)
    eY = calc_exp(Y,h/n)
    S = np.diag(np.ones(d))
    eXeY = eX.dot(eY)
    for i in range(n):
        S = S.dot(eXeY)

Vergleichen Sie die so erstellte ungefähre Matrix $ S $ mit der strengen Auswertung $ \ exp (h Z) $. Vergleichen wir hier mit Frobenius Norm. Alles in allem sieht die Funktion so aus.

def trotter(X,Y,Z,h,n):
    eZ = calc_exp(Z,h)
    eX = calc_exp(X,h/n)
    eY = calc_exp(Y,h/n)
    S = np.diag(np.ones(d))
    eXeY = eX.dot(eY)
    for i in range(n):
        S = S.dot(eXeY)
    return linalg.norm(eZ - S)/linalg.norm(eZ)

Ergebnis

Im Fall von zwei Dimensionen untersuchen wir, was mit dem Cutoff-Fehler passiert, indem wir $ h $ und $ n $ ändern.

Erstens die $ h $ -Abhängigkeit des Kürzungsfehlers. Sei $ n $ 1,2,4 und bewerte den Cutoff-Fehler mit verschiedenen $ h $ -Werten für jeden.

Es ist ersichtlich, dass die $ h $ -Abhängigkeit des Fehlers $ (h ^ 2) $ ist, unabhängig vom Wert von $ n $. Größeres $ n $ reduziert den Fehler, der proportional zu $ 1 / n $ ist. Fixiere es auf $ h = 1.0 $ und bewerte den Cutoff-Fehler für verschiedene $ n $.

Es ist ersichtlich, dass der Fehler sicherlich $ O (1 / n) $ ist.

Zusammenfassung

Ich habe den Cutoff-Fehler der Traberzerlegung ausgewertet. Bisher wurde der Fall von $ n = 1 $ $ \ exp (h (A + B)) \ sim \ exp (hA) \ exp (hB) $ als "Zerlegung erster Ordnung" bezeichnet, daher ist der Fehler irgendwie $ O. Ich dachte, es wäre (h) $, aber jetzt weiß ich, dass es $ O (h ^ 2) $ ist, unabhängig vom Wert von $ n $.

[^ name]: Einige gruselige Onkel könnten kommen, um das Richtige über diesen offiziellen Namen zu sagen. Wenn der Operator begrenzt ist, wird die Lie-Formel, wenn sie nicht begrenzt ist, die Trotter-Formel und der Algorithmus, der den Pfad unter Verwendung dieses Pfads integriert, vorerst als Suzuki-Trotter-Zerlegung bezeichnet. Ich nenne es oft einfach Traber Demontage, aber ...

[PYTHON] Untersuchen Sie den Lie-Trotter-Formel-Cutoff-Fehler