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 ativadas quando a funcedilhaão init_atensor é chamada.

A compatibilidade de atensor pode ser demonstrada pela definicedilhaão da álgebra de quatérnios como uma álgera-Clifford Cl(0,2) com dois vetores fundamentais.  As três unidades quaterniônicas imaginárias fundamentais são então os dois vetores 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 quatérnios, isso não foi usado nesse exemplo, no qual nós nos esforcedilhaamos para construir a tabela de multiplicacedilhaão dos quatérnios 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 vetoriais 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 você deseja experimentar com uma álgebra não associativa, você 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.

Funcedilhaões e Variáveis Definidas 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 quatérnios.  A chamada init_atensor(quaternion) é equivalente a init_atensor(clifford,0,0,2).

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

     dirac implementa a álgebra de Dirac-spinors como a Clifford-álgebra 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
     Valor padrão: 0

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

 -- Variável: aform

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

 -- Variável: asymbol
     Valor padrão: v

     O símbolo para bases vetoriais.

 -- 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 vetoriais 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 vetoriais 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 vetoriais 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 vetorial 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.