Introducedilhaão ao Pacote atensor
==================================

atensor é um pacote de manipulcedilhaão de tensores algébricos.  Para usar atensor, digite load(atensor), seguido por uma chamada à funcedilhaão init_atensor.

A essência de atensor é um conjunto de regras de simplificacedilhaão para o operador de produto (ponto) não comutativo (".").  atensor reconhece muitos tipos de álgebra; as regras de simplificacedilhaão correspondentes são activadas quando a funcedilhaão init_atensor é chamada.

A compatibilidade de atensor pode ser demonstrada pela definicedilhaão da álgebra de quaterniões como uma álgebra de Clifford Cl(0,2) com dois vectores fundamentais.  As três unidades quaterniónicas imaginárias fundamentais são então os dois vectores base e seu produto, i.e.:

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

Embora o pacote atensor tenha uma definicedilhaão interna para a álgebra dos quaterniões, isso não foi usado nesse exemplo, no qual nós nos esforcedilhaamos para construir a tabela de multiplicacedilhaão dos quaterniões como uma 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            ]

atensor reconhece como bases vectoriais símbolos indexados, onde o símbolo é aquele armazenado em asymbol e o iíndice está entre 1 e adim. Para símbolos indexado, e somente para símbolos indexados, as formas bilineares sf, af, e av são avaliadas.  A avaliacedilhaão substitui os valores  de aform[i,j] em lugar de fun(v[i],v[j]) onde v representa o valor de asymbol e fun é ainda af ou sf; ou, isso substitui v[aform[i,j]] em lugar de av(v[i],v[j]).

Desnecessário dizer, as funcedilhaões sf, af e av podem ser redefinidas.

Quando o pacote atensor é chamado, os seguintes sinalizadores são configurados:

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

Se quiser experimentar com uma álgebra não associativa, pode também considerar a configuracedilhaão de dotassoc para false.  Nesse caso, todavia, atensimp não stará sempre habilitado a obter as simplificacedilhaões desejadas.

Definicedilhaões para o Pacote atensor
======================================

 -- Funcedilhaão: init_atensor (ALG_TYPE, OPT_DIMS)
 -- Funcedilhaão: init_atensor (ALG_TYPE)

     Inicializa o pacote atensor com o tipo especificado de álgebra.  ALG_TYPE pode ser um dos seguintes:

     universal: A álgebra universal tendo regras não comutativas.

     grassmann: A álgebra de Grassman é definida pela relacedilhaão de comutacedilhaão u.v+v.u=0.

     clifford: A álgebra de Clifford é definida pela relacedilhaão de comutacedilhaão u.v+v.u=-2*sf(u,v) onde sf é a funcedilhaão valor-escalar simétrico.  Para essa álgebra, OPT_DIMS pode ser acima de três inteiros não negativos, representando o número de dimensões positivas, dimensões degeneradas, e dimensões negativas da álgebra, respectivamente.  Se quaisquer valores OPT_DIMS são fornecidos, atensor irá configurar os valores de adim e aform apropriadamente.  Caso contrário, adim irá por padrão para 0 e aform não será definida.

     symmetric: A álgebra simétrica é definida pela relacedilhaão de comutacedilhaão u.v-v.u=0.

     symplectic: A álgebra simplética é definida pela relacedilhaão de comutacedilhaão u.v-v.u=2*af(u,v) onde af é uma funcedilhaão valor-escalar antisimétrica.  Para a álgebra simplética, OPT_DIMS pode mais de dois inteiros não negativos, representando a dimensão não degenerada e e a dimensão degenerada, respectivamente.  Se quaisquer valores OPT_DIMS são fornecidos, atensor irá configurar os valores de adim e aform apropriadamente.  Caso contrário, adim irá por padrão para 0 e aform não será definida.

     lie_envelop: O invólucro da álgebra de Lie é definido pela relacedilhaão de comutacedilhaão u.v-v.u=2*av(u,v) onde av é uma funcedilhaão antisimétrica.

     A funcedilhaão init_atensor também reconhece muitos tipos pré-definidos de álgebra:

     complex implementa a álgebra de números complexos como a álgebra de Clifford Cl(0,1).  A chamada init_atensor(complex) é equivalente a init_atensor(clifford,0,0,1).

     quaternion implementa a álgebra de quaterniões.  A chamada init_atensor(quaternion) é equivalente a init_atensor(clifford,0,0,2).

     pauli implementa a álgebra de spinores de Pauli como a álgebra de Clifford Cl(3,0).  Uma chamada a init_atensor(pauli) é equivalente a init_atensor(clifford,3).

     dirac implementa a álgebra de spinores de Dirac como a álgebra de Clifford Cl(3,1).  Uma chamada a init_atensor(dirac) é equivalente a init_atensor(clifford,3,0,1).

 -- Funcedilhaão: atensimp (EXPR)

     Simplifica a expressão algébrica de tensores EXPR conforme as regras configuradas por uma chamada a init_atensor. Simplificacedilhaões incluem aplicacedilhaão recursiva de relacedilhaões comutativas e resolucedilhaões de chamadas a sf, af, e av onde for aplicável.  Uma salvaguarda é usada para garantir que a funcedilhaão sempre termine, mesmo para expressões complexas.

 -- Funcedilhaão: alg_type

     O tipo de álgebra.  Valores válidos sáo universal, grassmann, clifford, symmetric, symplectic e lie_envelop.

 -- Variável: adim

     A dimensionalidade da álgebra.  atensor usa o valor de adim para determinar se um objecto indexado é uma base vectorial válida. Veja abasep.

 -- Variável: aform

     Valor por omissão para as formas bilineares sf, af, e av.  O padrão é a matriz identidade ident(3).

 -- Variável: asymbol

     O símbolo para bases vectoriais.

 -- Funcedilhaão: sf (U, V)

     É uma funcedilhaão escalar simétrica que é usada em relacedilhaões comutativas.  A implementacedilhaão padrão verifica se ambos os argumentos são bases vectoriais usando abasep e se esse for o caso, substitui o valor correspondente da matriz aform.

 -- Funcedilhaão: af (U, V)

     É uma funcedilhaão escalar antisimétrica que é usada em relacedilhaões comutativas. A implementacedilhaão padrão verifica se ambos os argumentos são bases vectoriais usando abasep e se esse for o caso, substitui o valor correspondente da matriz aform.

 -- Funcedilhaão: av (U, V)

     É uma funcedilhaão antisimétrica que é usada em relacedilhaões comutativas. A implementacedilhaão padrão verifica se ambos os argumentos são bases vectoriais usando abasep e se esse for o caso, substitui o valor correspondente da matriz aform.

     Por exemplo:

          (%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

 -- Funcedilhaão: abasep (V)

     Verifica se esse argumento é uma base vectorial atensor .

     E será, se ele for um símbolo indexado, com o símbolo sendo o mesmo que o valor de asymbol, e o índice tiver o mesmo valor numérico entre 1 e adim.