Grupo de renormalización de la red de tensores

Implementación de Mathematica. Defina la función de traza del tensor:

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

La traza del tensor se puede implementar simplemente especificando la lista de tensores y los pares de patas deben contraerse. Las patas se indexan siguiendo las órdenes de los tensores. Por ejemplo, el siguiente código toma los tensores de 3 patas$A$y$B$y contraer las piernas$(3,4)$para formar el tensor de 4 patas$X$.

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

Para usar la tTrfunción correctamente, uno necesita entender cómo traducir la notación de Einstein$A_{ijm}\;B_{mkl}$al lenguaje de red de tensores. La regla es bastante simple, simplemente adjunte a cada índice en la notación de Einstein por el índice de la pierna 1,2,3... de izquierda a derecha. Por ejemplo, uno puede reescribir$A_{ijm}\;B_{mkl}$como$A_{(i1)(j2)(m3)}\;\;B_{(m4)(k5)(l6)}\;\;$, entonces sabemos$(m3)$y$(m4)$son piernas que se van a contraer, así que tenemos que decirles tTrque emparejen las piernas$(3,4)$. Después de la traza del tensor, obtenemos un tensor de 4 patas$X_{ijkl}=A_{ijm}\;B_{mkl}$.

Entonces para dividir el tensor$X_{ijkl}=C_{lin}\;D_{jkn}$, tenemos que agrupar las piernas$li$y$jk$primero. Para ayudarnos a encontrar los índices de las piernas, escribimos$X$como$X_{(i1)(j2)(k3)(l4)}\;\;$, entonces sabemos que las piernas$li$en realidad son piernas$(4,1)$y las piernas$jk$en realidad son piernas$(2,3)$, por lo que podemos agrupar las piernas y realizar el SVD por

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

Entonces piernas$li$ir a$U$y las piernas$jk$ir a$V$ahora. Necesitamos absorber el valor singular en las matrices unitarias izquierda y derecha, esto se puede hacer mediante

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

Para el tensor RG, es posible que desee restringir la dimensión de las patas internas en este paso. Por ejemplo, puede hacer

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

dónde$d$debe ser la dimensión de enlace que especificó anteriormente. Pero no haremos este truncamiento por ahora. Finalmente, remodelamos las matrices.$U$y$V$en tensores de 3 patas$C$y$D$por

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

Así hemos obtenido los nuevos tensores$C$y$D$. Para verificar que esta es la respuesta correcta, podemos contraer los tensores$C$y$D$. Por la reescritura$C_{(l1)(i2)(n3)}\;\;D_{(j4)(k5)(n6)}\;\;$, sabemos que esta vez necesitamos contraer las piernas$(3,6)$, así que le decimos eso atTr

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

Ahora hemos obtenido un tensor de 4 patas$Y_{lijk}=C_{lin}\;D_{jkn}$. Nosotros deberíamos tener$Y_{lijk}=X_{ijkl}$. Pero no podemos pedirle directamente a Mathematica que verifique si Y == X, porque los dos tensores ahora tienen diferentes ordenaciones de piernas. Para reorganizar las piernas, podemos usar la transposición generalizada. Pero necesitamos decirle a Mathematica las reglas de mapeo de piernas. Para encontrar las reglas de mapeo de$Y$a$X$, podemos escribir$Y_{(l1)(i2)(j3)(k4)}\;\;\to X_{(i1)(j2)(k3)(l4)}\;\;$, por lo que hemos establecido el mapeo para cada pierna como$l:(l1)\to(l4)$,$i:(i2)\to(i1)$,$j:(j3)\to(j2)$,$k:(k4)\to(k3)$. No necesitamos mantener los nombres.$i,j,k,l$, podemos simplemente escribir el mapeo como$(1,2,3,4)\to(4,1,2,3)$. Ni siquiera necesitamos decirle a Mathematica el lado izquierdo del mapeo, porque por definición, el lado izquierdo siempre debe estar ordenado como 1,2,3..., entonces solo necesitamos decirle a Mathematica transponer el tensor$Y$por$(4,1,2,3)$, luego compare el resultado con el tensor$X$.

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

El resultado es Truea pesar de eso$A$y$B$se generan aleatoriamente. Entonces sabemos que todo el procedimiento funciona.

En conclusión, podemos realizar operaciones tensoriales en Mathematica muy fácilmente. Las siguientes cuatro funciones cubren básicamente todas nuestras necesidades:

• tTr: realizar seguimiento de tensor (contracción de red de tensor),
• Transpose: reorganizar las patas del tensor,
• Flatten: agrupar patas tensoras,
• ArrayReshape: dividir las patas del tensor (en realidad, se puede usar para remodelar el tensor en cualquier forma que desee).

Puede crear un paquete RG de tensor sobre estas cuatro funciones con el solucionador SVD proporcionado por SingularValueDecomposition.