doc/info/pt_BR/Atensor.texi

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