doc/info/pt/Atensor.texi

   1 @c /Atensor.texi/1.8/Mon Nov 21 00:19:56 2005//
   2 @menu
   3 * Introdução ao Pacote atensor::
   4 * Definições para o Pacote atensor::
   5 @end menu
   6
   7 @node Introdução ao Pacote atensor, Definições para o Pacote atensor, Pacote atensor, Pacote atensor
   8 @section Introdução ao Pacote atensor
   9
  10 @code{atensor} é um pacote de manipulção de tensores algébricos.  Para usar @code{atensor},
  11 digite @code{load(atensor)}, seguido por uma chamada à função
  12 @code{init_atensor}.
  13
  14 A essência de @code{atensor} é um conjunto de regras de simplificação para o operador
  15 de produto (ponto) não comutativo ("@code{.}").  @code{atensor} reconhece
  16 muitos tipos de álgebra; as regras de simplificação correspondentes são activadas quando
  17 a função @code{init_atensor} é chamada.
  18
  19 A compatibilidade de @code{atensor} pode ser demonstrada pela
  20 definição da álgebra de quaterniões como uma
  21 álgebra de Clifford Cl(0,2) com dois vectores fundamentais.  As três
  22 unidades quaterniónicas imaginárias fundamentais são então os
  23 dois vectores base e seu produto, i.e.:
  24
  25 @example
  26     i = v     j = v     k = v  .  v
  27          1         2         1    2
  28 @end example
  29
  30 Embora o pacote @code{atensor} tenha uma definição
  31 interna para a álgebra dos quaterniões, isso não foi usado nesse
  32 exemplo, no qual nós nos esforçamos para construir a
  33 tabela de multiplicação dos quaterniões como uma
  34 matriz:
  35
  36 @example
  37
  38 (%i1) load(atensor);
  39 (%o1)       /share/tensor/atensor.mac
  40 (%i2) init_atensor(clifford,0,0,2);
  41 (%o2)                                done
  42 (%i3) atensimp(v[1].v[1]);
  43 (%o3)                                 - 1
  44 (%i4) atensimp((v[1].v[2]).(v[1].v[2]));
  45 (%o4)                                 - 1
  46 (%i5) q:zeromatrix(4,4);
  47                                 [ 0  0  0  0 ]
  48                                 [            ]
  49                                 [ 0  0  0  0 ]
  50 (%o5)                           [            ]
  51                                 [ 0  0  0  0 ]
  52                                 [            ]
  53                                 [ 0  0  0  0 ]
  54 (%i6) q[1,1]:1;
  55 (%o6)                                  1
  56 (%i7) for i thru adim do q[1,i+1]:q[i+1,1]:v[i];
  57 (%o7)                                done
  58 (%i8) q[1,4]:q[4,1]:v[1].v[2];
  59 (%o8)                               v  .  v
  60                                      1    2
  61 (%i9) for i from 2 thru 4 do for j from 2 thru 4 do
  62       q[i,j]:atensimp(q[i,1].q[1,j]);
  63 (%o9)                                done
  64 (%i10) q;
  65                    [    1        v         v      v  .  v  ]
  66                    [              1         2      1    2 ]
  67                    [                                      ]
  68                    [   v         - 1     v  .  v    - v    ]
  69                    [    1                 1    2      2   ]
  70 (%o10)             [                                      ]
  71                    [   v      - v  .  v     - 1      v     ]
  72                    [    2        1    2              1    ]
  73                    [                                      ]
  74                    [ v  .  v      v        - v       - 1   ]
  75                    [  1    2      2          1            ]
  76 @end example
  77
  78 @code{atensor} reconhece como bases vectoriais símbolos indexados, onde o símbolo
  79 é aquele armazenado em @code{asymbol} e o iíndice está entre 1 e @code{adim}.
  80 Para símbolos indexado, e somente para símbolos indexados, as formas bilineares
  81 @code{sf}, @code{af}, e @code{av} são avaliadas.  A avaliação
  82 substitui os valores  de @code{aform[i,j]} em lugar de @code{fun(v[i],v[j])}
  83 onde @code{v} representa o valor de @code{asymbol} e @code{fun} é
  84 ainda @code{af} ou @code{sf}; ou, isso substitui @code{v[aform[i,j]]}
  85 em lugar de @code{av(v[i],v[j])}.
  86
  87 Desnecessário dizer, as funções @code{sf}, @code{af} e @code{av}
  88 podem ser redefinidas.
  89
  90 Quando o pacote @code{atensor} é chamado, os seguintes sinalizadores são configurados:
  91
  92 @example
  93 dotscrules:true;
  94 dotdistrib:true;
  95 dotexptsimp:false;
  96 @end example
  97
  98 Se quiser experimentar com uma álgebra não associativa, pode
  99 também considerar a configuração de @code{dotassoc}
 100 para @code{false}.  Nesse caso, todavia, @code{atensimp} não stará
 101 sempre habilitado a obter as simplificações desejadas.
 102
 103
 104 @c end concepts atensor
 105 @node Definições para o Pacote atensor,  , Introdução ao Pacote atensor, Pacote atensor
 106
 107 @section Definições para o Pacote atensor
 108
 109 @deffn {Função} init_atensor (@var{alg_type}, @var{opt_dims})
 110 @deffnx {Função} init_atensor (@var{alg_type})
 111
 112 Inicializa o pacote @code{atensor} com o tipo especificado de álgebra.  @var{alg_type}
 113 pode ser um dos seguintes:
 114
 115 @code{universal}: A álgebra universal tendo regras não comutativas.
 116
 117 @code{grassmann}: A álgebra de Grassman é definida pela relação de
 118 comutação @code{u.v+v.u=0}.
 119
 120 @code{clifford}: A álgebra de Clifford é definida pela relação
 121 de comutação @code{u.v+v.u=-2*sf(u,v)} onde @code{sf} é a função
 122 valor-escalar simétrico.  Para essa álgebra, @var{opt_dims} pode ser acima de três
 123 inteiros não negativos, representando o número de dimensões positivas,
 124 dimensões degeneradas, e dimensões negativas da álgebra, respectivamente.  Se
 125 quaisquer valores @var{opt_dims} são fornecidos, @code{atensor} irá configurar os
 126 valores de @code{adim} e @code{aform} apropriadamente.  Caso contrário,
 127 @code{adim} irá por padrão para 0 e @code{aform} não será definida.
 128
 129 @code{symmetric}: A álgebra simétrica é definida pela relação de
 130 comutação @code{u.v-v.u=0}.
 131
 132 @code{symplectic}: A álgebra simplética é definida pela relação de
 133 comutação @code{u.v-v.u=2*af(u,v)} onde @code{af} é uma função valor-escalar
 134 antisimétrica.  Para a álgebra simplética, @var{opt_dims} pode
 135 mais de dois inteiros não negativos, representando a dimensão não degenerada e
 136 e a dimensão degenerada, respectivamente.  Se quaisquer valores @var{opt_dims} são
 137 fornecidos, @code{atensor} irá configurar os valores de @code{adim} e @code{aform}
 138 apropriadamente.  Caso contrário, @code{adim} irá por padrão para 0 e @code{aform}
 139 não será definida.
 140
 141 @code{lie_envelop}: O invólucro da álgebra de Lie é definido pela
 142 relação de comutação @code{u.v-v.u=2*av(u,v)} onde @code{av} é
 143 uma função antisimétrica.
 144
 145 A função @code{init_atensor} também reconhece muitos tipos pré-definidos de
 146 álgebra:
 147
 148 @code{complex} implementa a álgebra de números complexos como a
 149 álgebra de Clifford Cl(0,1).  A chamada @code{init_atensor(complex)} é
 150 equivalente a @code{init_atensor(clifford,0,0,1)}.
 151
 152 @code{quaternion} implementa a álgebra de quaterniões.  A chamada
 153 @code{init_atensor(quaternion)} é equivalente a
 154 @code{init_atensor(clifford,0,0,2)}.
 155
 156 @code{pauli} implementa a álgebra de spinores de Pauli como a
 157 álgebra de Clifford Cl(3,0).  Uma chamada a @code{init_atensor(pauli)}
 158 é equivalente a @code{init_atensor(clifford,3)}.
 159
 160 @code{dirac} implementa a álgebra de spinores de Dirac como a
 161 álgebra de Clifford Cl(3,1).  Uma chamada a @code{init_atensor(dirac)}
 162 é equivalente a @code{init_atensor(clifford,3,0,1)}.
 163
 164 @end deffn
 165
 166
 167 @deffn {Função} atensimp (@var{expr})
 168
 169 Simplifica a expressão algébrica de tensores @var{expr} conforme as
 170 regras configuradas por uma chamada a @code{init_atensor}.
 171 Simplificações incluem aplicação
 172 recursiva de relações comutativas e
 173 resoluções de chamadas a @code{sf}, @code{af}, e
 174 @code{av} onde for aplicável.  Uma salvaguarda é usada para garantir
 175 que a função sempre termine, mesmo para expressões
 176 complexas.
 177
 178 @end deffn
 179
 180 @deffn {Função} alg_type
 181
 182 O tipo de álgebra.  Valores válidos sáo @code{universal}, @code{grassmann},
 183 @code{clifford}, @code{symmetric}, @code{symplectic} e @code{lie_envelop}.
 184
 185 @end deffn
 186
 187 @defvr {Variável} adim
 188
 189 A dimensionalidade da álgebra.  @code{atensor} usa o valor de @code{adim}
 190 para determinar se um objecto indexado é uma base vectorial válida. Veja @code{abasep}.
 191
 192 @end defvr
 193
 194 @defvr {Variável} aform
 195
 196 Valor por omissão para as formas bilineares @code{sf}, @code{af}, e
 197 @code{av}.  O padrão é a matriz identidade @code{ident(3)}.
 198
 199 @end defvr
 200
 201 @defvr {Variável} asymbol
 202
 203 O símbolo para bases vectoriais.
 204
 205 @end defvr
 206
 207 @deffn {Função} sf (@var{u}, @var{v})
 208
 209 É uma função escalar simétrica que é usada em
 210 relações comutativas.  A implementação
 211 padrão verifica se ambos os argumentos são bases vectoriais usando
 212 @code{abasep} e se esse for o caso, substitui o valor correspondente da
 213 matriz @code{aform}.
 214
 215 @end deffn
 216
 217 @deffn {Função} af (@var{u}, @var{v})
 218
 219 É uma função escalar antisimétrica que é usada em relações comutativas.
 220 A implementação padrão verifica se ambos os argumentos são bases vectoriais
 221 usando @code{abasep} e se esse for o caso, substitui o
 222 valor correspondente da matriz @code{aform}.
 223
 224 @end deffn
 225
 226 @deffn {Função} av (@var{u}, @var{v})
 227
 228 É uma função antisimétrica que é usada em relações comutativas.
 229 A implementação padrão verifica se ambos os argumentos são bases vectoriais
 230 usando @code{abasep} e se esse for o caso, substitui o
 231 valor correspondente da matriz @code{aform}.
 232
 233 Por exemplo:
 234
 235 @example
 236 (%i1) load(atensor);
 237 (%o1)       /share/tensor/atensor.mac
 238 (%i2) adim:3;
 239 (%o2)                                  3
 240 (%i3) aform:matrix([0,3,-2],[-3,0,1],[2,-1,0]);
 241                                [  0    3   - 2 ]
 242                                [               ]
 243 (%o3)                          [ - 3   0    1  ]
 244                                [               ]
 245                                [  2   - 1   0  ]
 246 (%i4) asymbol:x;
 247 (%o4)                                  x
 248 (%i5) av(x[1],x[2]);
 249 (%o5)                                 x
 250                                        3
 251 @end example
 252
 253 @end deffn
 254
 255
 256 @deffn {Função} abasep (@var{v})
 257
 258 Verifica se esse argumento é uma base vectorial @code{atensor} .
 259
 260 E será, se ele for
 261 um símbolo indexado, com o símbolo sendo o mesmo que o valor de
 262 @code{asymbol}, e o índice tiver o mesmo valor numérico entre 1
 263 e @code{adim}.
 264
 265 @end deffn
 266