Tensornetzwerk-Renormalisierungsgruppe

Mathematica-Implementierung. Definieren Sie die Tensor-Trace-Funktion:

tTr[Ts_,s_]:=Activate@TensorContract[Inactive[TensorProduct]@@Ts,s];

Die Tensorspur kann einfach implementiert werden, indem die Liste der Tensoren angegeben wird und die Beinpaare kontrahiert werden sollen. Die Beine werden nach den Befehlen der Tensoren indiziert. Der folgende Code verwendet beispielsweise die 3-Bein-Tensoren$A$Und$B$und kontrahiere die Beine$(3,4)$um den 4-Bein-Tensor zu bilden$X$.

A = RandomReal[1, {2, 2, 2}];
B = RandomReal[1, {2, 2, 2}];
X = tTr[{A, B}, {{3, 4}}];

Um die tTrFunktion korrekt zu verwenden, muss man verstehen, wie die Einstein-Notation übersetzt wird$A_{ijm}\;B_{mkl}$zur Tensor-Netzwerk-Sprache. Die Regel ist ganz einfach, hängen Sie einfach an jeden Index in der Einstein-Notation durch den Beinindex 1,2,3 ... von links nach rechts. Zum Beispiel kann man umschreiben$A_{ijm}\;B_{mkl}$als$A_{(i1)(j2)(m3)}\;\;B_{(m4)(k5)(l6)}\;\;$, dann wissen wir es$(m3)$Und$(m4)$sind Beine, die zusammengezogen werden müssen, also müssen wir sagen, tTrdass wir die Beine paaren sollen$(3,4)$. Nach der Tensorspur erhalten wir einen 4-Bein-Tensor$X_{ijkl}=A_{ijm}\;B_{mkl}$.

Dann den Tensor spalten$X_{ijkl}=C_{lin}\;D_{jkn}$, müssen wir die Beine gruppieren$li$Und$jk$Erste. Um uns zu helfen, die Leg-Indizes zu finden, schreiben wir$X$als$X_{(i1)(j2)(k3)(l4)}\;\;$, dann wissen wir, dass die Beine$li$sind eigentlich Beine$(4,1)$und die Beine$jk$sind eigentlich Beine$(2,3)$, damit wir die Beine gruppieren und die SVD by durchführen können

{U, S, V} = SingularValueDecomposition@Flatten[X, {{4, 1}, {2, 3}}];

Also Beine$li$werde gehen$U$und die Beine$jk$werde gehen$V$Jetzt. Wir müssen den Singularwert in die linken und rechten Einheitsmatrizen aufnehmen, dies kann durch erfolgen

V = V.Sqrt[S];
U = U.Sqrt[S];

Für den Tensor RG möchten Sie in diesem Schritt möglicherweise die Dimension der inneren Beine einschränken. Zum Beispiel können Sie das tun

V = V[[;; d]];
U = U[[;; d]];

Wo$d$sollte die Bindungsdimension sein, die Sie zuvor angegeben haben. Aber wir werden diese Kürzung vorerst nicht durchführen. Schließlich formen wir die Matrizen um$U$Und$V$in 3-Bein-Tensoren$C$Und$D$von

C = ArrayReshape[U, {2, 2, 4}];
D = ArrayReshape[V, {2, 2, 4}];

Damit haben wir die neuen Tensoren erhalten$C$Und$D$. Um zu überprüfen, ob dies die richtige Antwort ist, können wir die Tensoren zusammenziehen$C$Und$D$. Durch das Umschreiben$C_{(l1)(i2)(n3)}\;\;D_{(j4)(k5)(n6)}\;\;$, wir wissen, dass wir dieses Mal die Beine anspannen müssen$(3,6)$, also sagen wir das zutTr

Y = tTr[{C, D}, {{3, 6}}];

Jetzt haben wir einen 4-Bein-Tensor erhalten$Y_{lijk}=C_{lin}\;D_{jkn}$. Wir hätten sollen$Y_{lijk}=X_{ijkl}$. Aber wir können Mathematica nicht direkt bitten, zu prüfen, ob Y == X, weil die beiden Tensoren jetzt unterschiedliche Beinordnungen haben. Um die Beine neu anzuordnen, können wir die verallgemeinerte Transponierung verwenden. Aber wir müssen Mathematica die Leg-Mapping-Regeln mitteilen. So finden Sie die Mapping-Regeln aus$Y$Zu$X$, wir können schreiben$Y_{(l1)(i2)(j3)(k4)}\;\;\to X_{(i1)(j2)(k3)(l4)}\;\;$, also haben wir die Zuordnung für jedes Bein als festgelegt$l:(l1)\to(l4)$,$i:(i2)\to(i1)$,$j:(j3)\to(j2)$,$k:(k4)\to(k3)$. Wir müssen die Namen nicht behalten$i,j,k,l$, können wir die Zuordnung einfach schreiben als$(1,2,3,4)\to(4,1,2,3)$. Wir müssen Mathematica nicht einmal die linke Seite der Abbildung mitteilen, da die linke Seite per Definition immer wie 1,2,3... geordnet sein muss , also müssen wir Mathematica nur mitteilen den Tensor zu transponieren$Y$von$(4,1,2,3)$, dann vergleiche das Ergebnis mit dem Tensor$X$.

Transpose[Y, {4, 1, 2, 3}] == X

Das Ergebnis ist Truetrotzdem$A$Und$B$werden zufällig generiert. Wir wissen also, dass das ganze Verfahren funktioniert.

Zusammenfassend lässt sich sagen, dass wir Tensoroperationen in Mathematica sehr einfach realisieren können. Die folgenden vier Funktionen decken im Grunde alle unsere Bedürfnisse ab:

• tTr: Tensor-Trace durchführen (Tensor-Netzwerkkontraktion),
• Transpose: Tensorbeine neu anordnen,
• Flatten: Spannbeine gruppieren,
• ArrayReshape: Trennen Sie die Tensorbeine (tatsächlich kann es verwendet werden, um den Tensor in jede gewünschte Form umzuformen).

Mit dem von bereitgestellten SVD-Solver können Sie auf diesen vier Funktionen ein Tensor-RG-Paket aufbauen SingularValueDecomposition.