doc/info/es/Atensor.es.texi

   1 @c English version 2011-03-14
   2 @menu
   3 * Introducción a atensor::
   4 * Funciones y variables para atensor::
   5 @end menu
   6
   7 @node Introducción a atensor, Funciones y variables para atensor, atensor, atensor
   8 @section Introducción a atensor
   9
  10 El paquete @code{atensor} contiene funciones para la manipulación algebraica de tensores. Para hacer uso de @code{atensor} es necesario cargarlo en memoria haciendo @code{load("atensor")}, seguido de una llamada a la función  @code{init_atensor}.
  11
  12 La parte más importante de @code{atensor} es una batería de reglas de simplificación para el producto no conmutativo ("@code{.}"). El paquete @code{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 @code{init_atensor}.
  13
  14 Las capacidades de @code{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:
  15
  16 @example
  17     i = v     j = v     k = v  . v
  18          1         2         1    2
  19 @end example
  20
  21 Aunque el paquete @code{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:
  22
  23 @example
  24
  25 (%i1) load("atensor");
  26 (%o1)       /share/tensor/atensor.mac
  27 (%i2) init_atensor(clifford,0,0,2);
  28 (%o2)                                done
  29 (%i3) atensimp(v[1].v[1]);
  30 (%o3)                                 - 1
  31 (%i4) atensimp((v[1].v[2]).(v[1].v[2]));
  32 (%o4)                                 - 1
  33 (%i5) q:zeromatrix(4,4);
  34                                 [ 0  0  0  0 ]
  35                                 [            ]
  36                                 [ 0  0  0  0 ]
  37 (%o5)                           [            ]
  38                                 [ 0  0  0  0 ]
  39                                 [            ]
  40                                 [ 0  0  0  0 ]
  41 (%i6) q[1,1]:1;
  42 (%o6)                                  1
  43 (%i7) for i thru adim do q[1,i+1]:q[i+1,1]:v[i];
  44 (%o7)                                done
  45 (%i8) q[1,4]:q[4,1]:v[1].v[2];
  46 (%o8)                               v  . v
  47                                      1    2
  48 (%i9) for i from 2 thru 4 do for j from 2 thru 4 do
  49       q[i,j]:atensimp(q[i,1].q[1,j]);
  50 (%o9)                                done
  51 (%i10) q;
  52 @group
  53                    [    1        v         v      v  . v  ]
  54                    [              1         2      1    2 ]
  55                    [                                      ]
  56                    [   v         - 1     v  . v    - v    ]
  57                    [    1                 1    2      2   ]
  58 (%o10)             [                                      ]
  59                    [   v      - v  . v     - 1      v     ]
  60                    [    2        1    2              1    ]
  61                    [                                      ]
  62                    [ v  . v      v        - v       - 1   ]
  63                    [  1    2      2          1            ]
  64 @end group
  65 @end example
  66
  67 El paquete @code{atensor} reconoce como vectores de la base símbolos indexados, donde el símbolo es el almacenado en  @code{asymbol} y el índice va desde 1 hasta @code{adim}. Para símbolos indexados, y sólo para ellos, se evalúan las formas bilineales @code{sf}, @code{af} y @code{av}. La evaluación sustituye el valor de @code{aform[i,j]} en lugar de @code{fun(v[i],v[j])}, donde @code{v} representa el valor de @code{asymbol} y @code{fun} es  @code{af} o @code{sf}; o sustituye @code{v[aform[i,j]]} en lugar de @code{av(v[i],v[j])}.
  68
  69 Huelga decir que las funciones @code{sf}, @code{af} y @code{av} pueden volver a definirse.
  70
  71 Cuando se carga el paquete @code{atensor} se hacen las siguientes asignaciones de variables:
  72
  73 @example
  74 dotscrules:true;
  75 dotdistrib:true;
  76 dotexptsimp:false;
  77 @end example
  78
  79 Si se quiere experimentar con una álgebra no asociativa, también se puede igualar la variable  @code{dotassoc} a @code{false}. En tal caso, sin embargo, @code{atensimp} no será siempre capaz de realizar las simplificaciones deseadas.
  80
  81
  82 @c end concepts atensor
  83 @node Funciones y variables para atensor,  , Introducción a atensor, atensor
  84
  85 @section Funciones y variables para atensor
  86
  87 @deffn {Función} init_atensor (@var{alg_type}, @var{opt_dims})
  88 @deffnx {Función} init_atensor (@var{alg_type})
  89
  90 Inicializa el paquete @code{atensor} con el tipo de álgebra especificado, @var{alg_type}, que puede ser una de las siguientes:
  91
  92 @code{universal}: El álgebra universal no tiene reglas de conmutación.
  93
  94 @code{grassmann}: El álgebra de Grassman se define mediante la relación de conmutación @code{u.v+v.u=0}.
  95
  96 @code{clifford}: El álgebra de Clifford se define mediante la regla de conmutación  @code{u.v+v.u=-2*sf(u,v)} donde  @code{sf} es una función escalar simétrica. Para esta álgebra,  @var{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 @var{opt_dims}, @code{atensor} configurará los valores de @code{adim} y @code{aform} de forma apropiada. En otro caso, @code{adim} tomará por defecto el valor 0 y @code{aform} no se definirá.
  97
  98 @code{symmetric}: El álgebra simétrica se define mediante la regla de conmutación @code{u.v-v.u=0}.
  99
 100 @code{symplectic}: El álgebra simpléctica se define mediante la regla de conmutación @code{u.v-v.u=2*af(u,v)}, donde @code{af} es una función escalar antisimétrica. Para el álgebra simpléctica, @var{opt_dims} puede contener hasta dos enteros no negativos, que representan las dimensiones no degeneradas y degeneradas, respectivamente. Si se suministran los valores de @var{opt_dims}, @code{atensor} configurará los valores de @code{adim} y @code{aform} de forma apropiada. En otro caso, @code{adim} tomará por defecto el valor 0 y @code{aform} no se definirá.
 101
 102 @code{lie_envelop}: El álgebra de la envolvente de Lie se define mediante la regla de conmutación @code{u.v-v.u=2*av(u,v)}, donde @code{av} es una función antisimétrica.
 103
 104 La función @code{init_atensor} también reconoce algunos tipos de álgebras predefinidas:
 105
 106 @code{complex} implementa el álgebra de números complejos como un álgebra de Clifford Cl(0,1). La llamada  @code{init_atensor(complex)} equivale a @code{init_atensor(clifford,0,0,1)}.
 107
 108 @code{quaternion} implementa el álgebra de cuaterniones. La llamada @code{init_atensor(quaternion)} equivale a
 109 @code{init_atensor(clifford,0,0,2)}.
 110
 111 @code{pauli} implementa el álgebra de Pauli como un álgebra de Clifford Cl(3,0). La llamada @code{init_atensor(pauli)} equivale a @code{init_atensor(clifford,3)}.
 112
 113 @code{dirac} implementa el álgebra de Dirac como un álgebra de Clifford Cl(3,1). La llamada @code{init_atensor(dirac)} equivale a @code{init_atensor(clifford,3,0,1)}.
 114
 115 @end deffn
 116
 117
 118 @deffn {Función} atensimp (@var{expr})
 119
 120 Simplifica la expresión algebraica de un tensor  @var{expr} de acuerdo con las reglas configuradas mediante una llamada a  @code{init_atensor}. La simplificación incluye la aplicación recursiva de las reglas de conmutación y llamadas a @code{sf}, @code{af} y @code{av} siempre que sea posible. Se utiliza un algoritmo que asegure que la función termina siempre, incluso en el caso de expresiones complejas.
 121
 122 @end deffn
 123
 124 @deffn {Función} alg_type
 125
 126 Tipo de álgebra. Valores válidos son @code{universal}, @code{grassmann},
 127 @code{clifford}, @code{symmetric}, @code{symplectic} y @code{lie_envelop}.
 128
 129 @end deffn
 130
 131 @defvr {Variable} adim
 132 Valor por defecto: 0
 133
 134 La dimensión del álgebra. El paquete @code{atensor} utiliza el valor de @code{adim} para determinar si un objeto indexado es un vector válido para la base. Véase @code{abasep}.
 135
 136 @end defvr
 137
 138 @defvr {Variable} aform
 139 Valor por defecto: @code{ident(3)}
 140
 141 Valores por defecto para las formas bilineales  @code{sf}, @code{af} y @code{av}. El valor por defecto es la matriz identidad @code{ident(3)}.
 142
 143 @end defvr
 144
 145 @defvr {Variable} asymbol
 146 Valor por defecto: @code{v}
 147
 148 Símbolo para los vectores base.
 149
 150 @end defvr
 151
 152 @deffn {Función} sf (@var{u}, @var{v})
 153
 154 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  @code{abasep} y en tal caso sustituye el valor correspondiente de la matriz  @code{aform}.
 155
 156 @end deffn
 157
 158 @deffn {Función} af (@var{u}, @var{v})
 159
 160 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  @code{abasep} y en tal caso sustituye el valor correspondiente de la matriz  @code{aform}.
 161
 162 @end deffn
 163
 164 @deffn {Función} av (@var{u}, @var{v})
 165
 166 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  @code{abasep} y en tal caso sustituye el valor correspondiente de la matriz  @code{aform}.
 167
 168 Ejemplo:
 169
 170 @example
 171 (%i1) load("atensor");
 172 (%o1)       /share/tensor/atensor.mac
 173 (%i2) adim:3;
 174 (%o2)                                  3
 175 (%i3) aform:matrix([0,3,-2],[-3,0,1],[2,-1,0]);
 176                                [  0    3   - 2 ]
 177                                [               ]
 178 (%o3)                          [ - 3   0    1  ]
 179                                [               ]
 180                                [  2   - 1   0  ]
 181 (%i4) asymbol:x;
 182 (%o4)                                  x
 183 (%i5) av(x[1],x[2]);
 184 (%o5)                                 x
 185                                        3
 186 @end example
 187
 188 @end deffn
 189
 190
 191 @deffn {Función} abasep (@var{v})
 192
 193 Analiza si su argumento es un vector base en @code{atensor}. Esto es, si se trata de un símbolo indexado, siendo el símbolo el mismo que el valor de @code{asymbol} y si el índice tiene un valor numérico entre 1 y @code{adim}.
 194
 195 @end deffn
 196