Introducción a itensor (Manual de Maxima 5.44.0)

Siguiente: Funciones y variables para itensor, Anterior: itensor, Subir: itensor [Índice general][Índice]

### 25.1 Introducción a itensor

Maxima implementa dos tipos diferentes de manipulación simbólica de tensores: la manipulación de componentes (paquete `ctensor`) y la manipulación indexada (paquete `itensor`).

Véase más abajo la nota sobre ’notación tensorial’.

La manipulación de componentes significa que los objetos geométricos tensoriales se representan como arreglos (arrays) o matrices. Operaciones tensoriales como la contracción o la diferenciación covariante se llevan a cabo sumando índices mudos con la sentencia `do`. Esto es, se realizan operaciones directamente con las componentes del tensor almacenadas en un arreglo o matriz.

La manipulación indexada de tensores se lleva a cabo mediante la representación de los tensores como funciones de sus índices covariantes, contravariantes y de derivadas. Operaciones tensoriales como la contracción o la diferenciación covariante se realizan manipulando directamente los índices, en lugar de sus componentes asociadas.

Estas dos técnicas para el tratamiento de los procesos diferenciales, algebraicos y analíticos en el contexto de la geometría riemanniana tienen varias ventajas y desventajas que surgen según la naturaleza y dificultad del problema que está abordando el usuario. Sin embargo, se deben tener presentes las siguientes características de estas dos técnicas:

La representación de los tensores y sus operaciones en términos de sus componentes facilita el uso de paquete `ctensor`. La especificación de la métrica y el cálculo de los tensores inducidos e invariantes es inmediato. Aunque toda la potencia de simplificación de Maxima se encuentra siempre a mano, una métrica compleja con dependencias funcionales y de coordenadas intrincada, puede conducir a expresiones de gran tamaño en las que la estructura interna quede oculta. Además, muchos cálculos requieren de expresiones intermedias que pueden provocar la detención súbita de los programas antes de que se termine el cálculo. Con la experiencia, el usuario podrá evitar muchas de estas dificultades.

Devido a la forma en que los tensores y sus operaciones se representan en términos de operaciones simbólicas con sus índices, expresiones que serían intratables en su representación por componentes pueden en ocasiones simplificarse notablemente utilizando las rutinas especiales para objetos simétricos del paquete `itensor`. De esta manera, la estructura de expresiones grandes puede hacerse más transparente. Por otro lado, debido a la forma especial de la representación indexada de tensores en `itensor`, en algunos casos el usuario encontrará dificultades con la especificación de la métrica o la definición de funciones.

El paquete `itensor` puede derivar respecto de una variable indexada, lo que permite utilizar el paquete cuando se haga uso del formalismo de lagrangiano y hamiltoniano. Puesto que es posible derivar un campo lagrangiano respecto de una variable de campo indexada, se puede hacer uso de Maxima para derivar las ecuaciones de Euler-Lagrange correspondientes en forma indexada. Estas ecuaciones pueden traducirse a componentes tensoriales (`ctensor`) con la función `ic_convert`, lo que permite resolver las ecuaciones de campo en cualquier sistema de coordenadas, o obtener las ecuaciones de movimiento en forma hamiltoniana. Véanse dos ejemplos en `einhil.dem` y `bradic.dem`; el primero utiliza la acción de Einstein-Hilbert para derivar el campo tensorial de Einstein en el caso homogéneo e isotrópico (ecuaciones de Friedmann), así como en el caso esferosimétrico estático (solución de Schwarzschild); el segundo demuestra cómo calcular las ecuaciones de Friedmann a partir de la acción de la teoría de la gravedad de Brans-Dicke, y también muestra cómo derivar el hamiltoniano asociado con la teoría del campo escalar.

#### 25.1.1 Notación tensorial

Hasta ahora, el paquete `itensor` de Maxima utilizaba una notación que algunas veces llevaba a una ordenación incorrecta de los índices. Por ejemplo:

    (%i2) imetric(g);
    (%o2)                                done
    (%i3) ishow(g([],[j,k])*g([],[i,l])*a([i,j],[]))$
                                     i l  j k
    (%t3)                           g    g    a
                                               i j
    (%i4) ishow(contract(%))$
                                          k l
    (%t4)                                a

Este resultado no es correcto a menos que `a` sea un tensor simétrico. La razón por la que esto ocurre es que aunque `itensor` mantenga correctamente el orden dentro del conjunto de índices covariantes y contravariantes, una vez un índice sea aumentado o disminuido, su posición relativa al otro conjunto de índices se pierde.

Para evitar este problema, se ha desarrollado una notación totalmente compatible con la anterior.En esta notación, los índices contravariantes se insertan en las posiciones correctas en la lista de índices covariantes, pero precedidos del signo negativo.

En esta notación, el ejemplo anterior da el resultado correcto:

    (%i5) ishow(g([-j,-k],[])*g([-i,-l],[])*a([i,j],[]))$
                                     i l       j k
    (%t5)                           g    a    g
                                          i j
    (%i6) ishow(contract(%))$
                                          l k
    (%t6)                                a

El único código que hace uso de esta notación es la función `lc2kdt`.

Devido a que este código es nuevo, puede contener errores.

#### 25.1.2 Manipulación indexada de tensores

El paquete `itensor` se carga haciendo `load(itensor)`. Para acceder a las demos se hará `demo(tensor)`.

En el paquete `itensor` un tensor se representa como un objeto indexado, esto es, como una función de tres grupos de índices: los covariantes, los contravariantes y los de derivadas. Los índices covariantes se especifican mediante una lista que será el primer argumento del objeto indexado, siendo los índices contravariantes otra lista que será el segundo argumento del mismo objeto indexado. Si al objeto indexado le falta cualquiera de estos grupos de índices, entonces se le asignará al argumento correspondiente la lista vacía `[]`. Así, `g([a,b],[c])` representa un objeto indexado llamado `g`, el cual tiene dos índices covariantes `(a,b)`, un índice contravariante (`c`) y no tiene índices de derivadas.

Los índices de derivadas, si están presentes, se añaden como argumentos adicionales a la función simbólica que representa al tensor. Se pueden especificar explícitamente por el usuario o pueden crearse durante el proceso de diferenciación respecto de alguna coordenada. Puesto que la diferenciación ordinaria es conmutativa, los índices de derivadas se ordenan alfanuméricamente, a menos que la variable `iframe_flag` valga `true`, indicando que se está utilizando una métrica del sistema de referencia. Esta ordenación canónica hace posible que Maxima reconozca, por ejemplo, que `t([a],[b],i,j)` es lo mismo que `t([a],[b],j,i)`. La diferenciación de un objeto indexado con respecto de alguna coordenada cuyo índice no aparece como argumento de dicho objeto indexado, dará como resultado cero. Esto se debe a que Maxima no sabe si el tensor representado por el objeto indexado depende implícitamente de la coordenada correspondiente. Modificando la función `diff` de Maxima en `itensor`, se da por hecho que todos los objetos indexados dependen de cualquier variable de diferenciación, a menos que se indique lo contrario. Esto hace posible que la convención sobre la sumación se extienda a los índices de derivadas. El paquete `itensor` trata a los índices de derivadas como covariantes.

Las siguientes funciones forman parte del paquete `itensor` para la manipulación indexada de vectores. En lo que respecta a las rutinas de simplificación, no se considera en general que los objetos indexados tengan propiedades simétricas. Esto puede cambiarse reasignando a la variable `allsym[false]` el valor `true`, con lo cual los objetos indexados se considerarán simétricos tanto respecto de sus índices covariantes como contravariantes.

En general, el paquete `itensor` trata a los tensores como objetos opacos. Las ecuaciones tensoriales se manipulan en base a reglas algebraicas, como la simetría y la contracción. Además, en el paquete `itensor` hay funciones para la diferenciación covariante, la curvatura y la torsión. Los cálculos se pueden realizar respecto de una métrica del sistema de referencia móvil, dependiendo de las asignaciones dadas a la variable `iframe_flag`.

La siguiente sesión de ejemplo demuestra cómo cargar el paquete `itensor`, especificar el nombre de la métrica y realizar algunos cálculos sencillos.

    (%i1) load(itensor);
    (%o1)      /share/tensor/itensor.lisp
    (%i2) imetric(g);
    (%o2)                                done
    (%i3) components(g([i,j],[]),p([i,j],[])*e([],[]))$
    (%i4) ishow(g([k,l],[]))$
    (%t4)                               e p
                                           k l
    (%i5) ishow(diff(v([i],[]),t))$
    (%t5)                                  0
    (%i6) depends(v,t);
    (%o6)                               [v(t)]
    (%i7) ishow(diff(v([i],[]),t))$
                                        d
    (%t7)                               -- (v )
                                        dt   i
    (%i8) ishow(idiff(v([i],[]),j))$
    (%t8)                                v
                                          i,j
    (%i9) ishow(extdiff(v([i],[]),j))$
    (%t9)                             v    - v
                                       j,i    i,j
                                      -----------
                                           2
    (%i10) ishow(liediff(v,w([i],[])))$
                                   %3          %3
    (%t10)                        v   w     + v   w
                                       i,%3    ,i  %3
    (%i11) ishow(covdiff(v([i],[]),j))$
                                                  %4
    (%t11)                        v    - v   ichr2
                                   i,j    %4      i j
    (%i12) ishow(ev(%,ichr2))$
                    %4 %5
    (%t12) v    - (g      v   (e p       + e   p     - e p       - e    p
            i,j            %4     j %5,i    ,i  j %5      i j,%5    ,%5  i j

                                             + e p       + e   p    ))/2
                                                  i %5,j    ,j  i %5
    (%i13) iframe_flag:true;
    (%o13)                               true
    (%i14) ishow(covdiff(v([i],[]),j))$
                                                 %6
    (%t14)                        v    - v   icc2
                                   i,j    %6     i j
    (%i15) ishow(ev(%,icc2))$
                                                 %6
    (%t15)                        v    - v   ifc2
                                   i,j    %6     i j
    (%i16) ishow(radcan(ev(%,ifc2,ifc1)))$
                 %6 %7                    %6 %7
    (%t16) - (ifg      v   ifb       + ifg      v   ifb       - 2 v
                        %6    j %7 i             %6    i j %7      i,j

                                                 %6 %7
                                            - ifg      v   ifb      )/2
                                                        %6    %7 i j
    (%i17) ishow(canform(s([i,j],[])-s([j,i])))$
    (%t17)                            s    - s
                                       i j    j i
    (%i18) decsym(s,2,0,[sym(all)],[]);
    (%o18)                               done
    (%i19) ishow(canform(s([i,j],[])-s([j,i])))$
    (%t19)                                 0
    (%i20) ishow(canform(a([i,j],[])+a([j,i])))$
    (%t20)                            a    + a
                                       j i    i j
    (%i21) decsym(a,2,0,[anti(all)],[]);
    (%o21)                               done
    (%i22) ishow(canform(a([i,j],[])+a([j,i])))$
    (%t22)                                 0

Siguiente: Funciones y variables para itensor, Anterior: itensor, Subir: itensor [Índice general][Índice]