@c /Atensor.texi/1.8/Mon Nov 21 00:19:56 2005//
@menu
* Introdução ao Pacote atensor::
* Definições para o Pacote atensor::
@end menu

@node Introdução ao Pacote atensor, Definições para o Pacote atensor, Pacote atensor, Pacote atensor
@section Introdução ao Pacote atensor

@code{atensor} é um pacote de manipulção de tensores algébricos.  Para usar @code{atensor},
digite @code{load(atensor)}, seguido por uma chamada à função 
@code{init_atensor}.

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

A compatibilidade de @code{atensor} pode ser demonstrada pela
definiçã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.:

@example
    i = v     j = v     k = v  .  v
         1         2         1    2
@end example

Embora o pacote @code{atensor} tenha uma definição
interna para a álgebra dos quaterniões, isso não foi usado nesse
exemplo, no qual nós nos esforçamos para construir a
tabela de multiplicação dos quaterniões como uma
matriz:

@example

(%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            ]
@end example

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

Desnecessário dizer, as funções @code{sf}, @code{af} e @code{av}
podem ser redefinidas.

Quando o pacote @code{atensor} é chamado, os seguintes sinalizadores são configurados:

@example
dotscrules:true;
dotdistrib:true;
dotexptsimp:false;
@end example

Se quiser experimentar com uma álgebra não associativa, pode
também considerar a configuração de @code{dotassoc}
para @code{false}.  Nesse caso, todavia, @code{atensimp} não stará
sempre habilitado a obter as simplificações desejadas.


@c end concepts atensor
@node Definições para o Pacote atensor,  , Introdução ao Pacote atensor, Pacote atensor

@section Definições para o Pacote atensor

@deffn {Função} init_atensor (@var{alg_type}, @var{opt_dims})
@deffnx {Função} init_atensor (@var{alg_type})

Inicializa o pacote @code{atensor} com o tipo especificado de álgebra.  @var{alg_type}
pode ser um dos seguintes:

@code{universal}: A álgebra universal tendo regras não comutativas.

@code{grassmann}: A álgebra de Grassman é definida pela relação de 
comutação @code{u.v+v.u=0}.

@code{clifford}: A álgebra de Clifford é definida pela relação
de comutação @code{u.v+v.u=-2*sf(u,v)} onde @code{sf} é a função
valor-escalar simétrico.  Para essa álgebra, @var{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 @var{opt_dims} são fornecidos, @code{atensor} irá configurar os
valores de @code{adim} e @code{aform} apropriadamente.  Caso contrário,
@code{adim} irá por padrão para 0 e @code{aform} não será definida.

@code{symmetric}: A álgebra simétrica é definida pela relação de 
comutação @code{u.v-v.u=0}.

@code{symplectic}: A álgebra simplética é definida pela relação de 
comutação @code{u.v-v.u=2*af(u,v)} onde @code{af} é uma função valor-escalar 
antisimétrica.  Para a álgebra simplética, @var{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 @var{opt_dims} são
fornecidos, @code{atensor} irá configurar os valores de @code{adim} e @code{aform}
apropriadamente.  Caso contrário, @code{adim} irá por padrão para 0 e @code{aform}
não será definida.

@code{lie_envelop}: O invólucro da álgebra de Lie é definido pela 
relação de comutação @code{u.v-v.u=2*av(u,v)} onde @code{av} é
uma função antisimétrica.

A função @code{init_atensor} também reconhece muitos tipos pré-definidos de 
álgebra:

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

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

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

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

@end deffn


@deffn {Função} atensimp (@var{expr})

Simplifica a expressão algébrica de tensores @var{expr} conforme as
regras configuradas por uma chamada a @code{init_atensor}.
Simplificações incluem aplicação
recursiva de relações comutativas e
resoluções de chamadas a @code{sf}, @code{af}, e
@code{av} onde for aplicável.  Uma salvaguarda é usada para garantir
que a função sempre termine, mesmo para expressões
complexas.

@end deffn

@deffn {Função} alg_type

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

@end deffn

@defvr {Variável} adim

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

@end defvr

@defvr {Variável} aform

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

@end defvr

@defvr {Variável} asymbol

O símbolo para bases vectoriais.

@end defvr

@deffn {Função} sf (@var{u}, @var{v})

É uma função escalar simétrica que é usada em
relações comutativas.  A implementação
padrão verifica se ambos os argumentos são bases vectoriais usando
@code{abasep} e se esse for o caso, substitui o valor correspondente da
matriz @code{aform}.

@end deffn

@deffn {Função} af (@var{u}, @var{v})

É uma função escalar antisimétrica que é usada em relações comutativas.
A implementação padrão verifica se ambos os argumentos são bases vectoriais
usando @code{abasep} e se esse for o caso, substitui o
valor correspondente da matriz @code{aform}.

@end deffn

@deffn {Função} av (@var{u}, @var{v})

É uma função antisimétrica que é usada em relações comutativas.
A implementação padrão verifica se ambos os argumentos são bases vectoriais
usando @code{abasep} e se esse for o caso, substitui o
valor correspondente da matriz @code{aform}.

Por exemplo:

@example
(%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
@end example

@end deffn


@deffn {Função} abasep (@var{v})

Verifica se esse argumento é uma base vectorial @code{atensor} .  

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

@end deffn

