Introducción a atensor
======================

El paquete atensor contiene funciones para la manipulación algebraica de tensores. Para hacer uso de atensor es necesario cargarlo en memoria haciendo load(atensor), seguido de una llamada a la función  init_atensor.

La parte más importante de atensor es una batería de reglas de simplificación para el producto no conmutativo ("."). El paquete atensor reconoce algunos tipos de álgebras; las correspondientes reglas de simplificación se activan tan pronto como se hace una llamada a la función init_atensor.

Las capacidades de atensor se pueden demostrar definiendo el álgebra de cuaterniones como un álgebra de Clifford Cl(0,2) con una base de dos vectores. Las tres unidades imaginarias son los dos vectores de la base junto con su producto:

         i = v     j = v     k = v  . v
              1         2         1    2

Aunque el paquete atensor incluye su propia definición para el álgebra de cuaterniones, no se utiliza en el siguiente ejemplo, en el cual se construye la tabla de multiplicación como una matriz:

     (%i1) load(atensor);
     (%o1)       /share/tensor/atensor.mac
     (%i2) init_atensor(clifford,0,0,2);
     (%o2)                                done
     (%i3) atensimp(v[1].v[1]);
     (%o3)                                 - 1
     (%i4) atensimp((v[1].v[2]).(v[1].v[2]));
     (%o4)                                 - 1
     (%i5) q:zeromatrix(4,4);
                                     [ 0  0  0  0 ]
                                     [            ]
                                     [ 0  0  0  0 ]
     (%o5)                           [            ]
                                     [ 0  0  0  0 ]
                                     [            ]
                                     [ 0  0  0  0 ]
     (%i6) q[1,1]:1;
     (%o6)                                  1
     (%i7) for i thru adim do q[1,i+1]:q[i+1,1]:v[i];
     (%o7)                                done
     (%i8) q[1,4]:q[4,1]:v[1].v[2];
     (%o8)                               v  . v
                                          1    2
     (%i9) for i from 2 thru 4 do for j from 2 thru 4 do
           q[i,j]:atensimp(q[i,1].q[1,j]);
     (%o9)                                done
     (%i10) q;
                        [    1        v         v      v  . v  ]
                        [              1         2      1    2 ]
                        [                                      ]
                        [   v         - 1     v  . v    - v    ]
                        [    1                 1    2      2   ]
     (%o10)             [                                      ]
                        [   v      - v  . v     - 1      v     ]
                        [    2        1    2              1    ]
                        [                                      ]
                        [ v  . v      v        - v       - 1   ]
                        [  1    2      2          1            ]

El paquete atensor reconoce como vectores de la base símbolos indexados, donde el símbolo es el almacenado en  asymbol y el índice va desde 1 hasta adim. Para símbolos indexados, y sólo para ellos, se evalúan las formas bilineales sf, af y av. La evaluación sustituye el valor de aform[i,j] en lugar de fun(v[i],v[j]), donde v representa el valor de asymbol y fun es  af o sf; o sustituye v[aform[i,j]] en lugar de av(v[i],v[j]).

Huelga decir que las funciones sf, af y av pueden volver a definirse.

Cuando se carga el paquete atensor se hacen las siguientes asignaciones de variables:

     dotscrules:true;
     dotdistrib:true;
     dotexptsimp:false;

Si se quiere experimentar con una álgebra no asociativa, también se puede igualar la variable  dotassoc a false. En tal caso, sin embargo, atensimp no será siempre capaz de realizar las simplificaciones deseadas.

Funciones y variables para atensor
==================================

 -- Función: init_atensor (ALG_TYPE, OPT_DIMS)
 -- Función: init_atensor (ALG_TYPE)

     Inicializa el paquete atensor con el tipo de álgebra especificado, ALG_TYPE, que puede ser una de las siguientes:

     universal: El álgebra universal no tiene reglas de conmutación.

     grassmann: El álgebra de Grassman se define mediante la relación de conmutación u.v+v.u=0.

     clifford: El álgebra de Clifford se define mediante la regla de conmutación  u.v+v.u=-2*sf(u,v) donde  sf es una función escalar simétrica. Para esta álgebra,  OPT_DIMS puede contener hasta tres enteros no negativos, que representan el número de dimensiones positivas, degeneradas y negativas, respectivamente, de esta álgebra. Si se suministran los valores de OPT_DIMS, atensor configurará los valores de adim y aform de forma apropiada. En otro caso, adim tomará por defecto el valor 0 y aform no se definirá.

     symmetric: El álgebra simétrica se define mediante la regla de conmutación u.v-v.u=0.

     symplectic: El álgebra simpléctica se define mediante la regla de conmutación u.v-v.u=2*af(u,v), donde af es una función escalar antisimétrica. Para el álgebra simpléctica, OPT_DIMS puede contener hasta dos enteros no negativos, que representan las dimensiones no degeneradas y degeneradas, respectivamente. Si se suministran los valores de OPT_DIMS, atensor configurará los valores de adim y aform de forma apropiada. En otro caso, adim tomará por defecto el valor 0 y aform no se definirá.

     lie_envelop: El álgebra de la envolvente de Lie se define mediante la regla de conmutación u.v-v.u=2*av(u,v), donde av es una función antisimétrica.

     La función init_atensor también reconoce algunos tipos de álgebras predefinidas:

     complex implementa el álgebra de números complejos como un álgebra de Clifford Cl(0,1). La llamada  init_atensor(complex) equivale a init_atensor(clifford,0,0,1).

     quaternion implementa el álgebra de cuaterniones. La llamada init_atensor(quaternion) equivale a init_atensor(clifford,0,0,2).

     pauli implementa el álgebra de Pauli como un álgebra de Clifford Cl(3,0). La llamada init_atensor(pauli) equivale a init_atensor(clifford,3).

     dirac implementa el álgebra de Dirac como un álgebra de Clifford Cl(3,1). La llamada init_atensor(dirac) equivale a init_atensor(clifford,3,0,1).

 -- Función: atensimp (EXPR)

     Simplifica la expresión algebraica de un tensor  EXPR de acuerdo con las reglas configuradas mediante una llamada a  init_atensor. La simplificación incluye la aplicación recursiva de las reglas de conmutación y llamadas a sf, af y av siempre que sea posible. Se utiliza un algoritmo que asegure que la función termina siempre, incluso en el caso de expresiones complejas.

 -- Función: alg_type

     Tipo de álgebra. Valores válidos son universal, grassmann, clifford, symmetric, symplectic y lie_envelop.

 -- Variable: adim
     Valor por defecto: 0

     La dimensión del álgebra. El paquete atensor utiliza el valor de adim para determinar si un objeto indexado es un vector válido para la base. Véase abasep.

 -- Variable: aform
     Valor por defecto: ident(3)

     Valores por defecto para las formas bilineales  sf, af y av. El valor por defecto es la matriz identidad ident(3).

 -- Variable: asymbol
     Valor por defecto: v

     Símbolo para los vectores base.

 -- Función: sf (U, V)

     Una función escalar simétrica que se utiliza en relaciones de conmutación. La implementación por defecto analiza si los dos argumentos son vectores base mediante  abasep y en tal caso sustituye el valor correspondiente de la matriz  aform.

 -- Función: af (U, V)

     Una función escalar antisimétrica que se utiliza en relaciones de conmutación. La implementación por defecto analiza si los dos argumentos son vectores base mediante  abasep y en tal caso sustituye el valor correspondiente de la matriz  aform.

 -- Función: av (U, V)

     Una función antisimétrica que se utiliza en relaciones de conmutación. La implementación por defecto analiza si los dos argumentos son vectores base mediante  abasep y en tal caso sustituye el valor correspondiente de la matriz  aform.

     Ejemplo:

          (%i1) load(atensor);
          (%o1)       /share/tensor/atensor.mac
          (%i2) adim:3;
          (%o2)                                  3
          (%i3) aform:matrix([0,3,-2],[-3,0,1],[2,-1,0]);
                                         [  0    3   - 2 ]
                                         [               ]
          (%o3)                          [ - 3   0    1  ]
                                         [               ]
                                         [  2   - 1   0  ]
          (%i4) asymbol:x;
          (%o4)                                  x
          (%i5) av(x[1],x[2]);
          (%o5)                                 x
                                                 3

 -- Función: abasep (V)

     Analiza si su argumento es un vector base en atensor. Esto es, si se trata de un símbolo indexado, siendo el símbolo el mismo que el valor de asymbol y si el índice tiene un valor numérico entre 1 y adim.