[ < ] | [ > ] |  | [ << ] | [ Up ] | [ >> ] |  |  |  |  | [Top] | [Contents] | [Index] | [ ? ]

# 29. Pacote atensor

[ < ] | [ > ] |  | [ << ] | [ Up ] | [ >> ] |  |  |  |  | [Top] | [Contents] | [Index] | [ ? ]

## 29.1 Introdução ao Pacote atensor

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

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

A compatibilidade de `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.:

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

Embora o pacote `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:

    (%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 avaliaçã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 funçõ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 configuração de `dotassoc` para `false`. Nesse caso, todavia, `atensimp` não stará sempre habilitado a obter as simplificações desejadas.

[ < ] | [ > ] |  | [ << ] | [ Up ] | [ >> ] |  |  |  |  | [Top] | [Contents] | [Index] | [ ? ]

## 29.2 Definições para o Pacote atensor

Função: init_atensor (alg_type, opt_dims)
Funçã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 relação de comutação `u.v+v.u=0`.

  `clifford`: A álgebra de Clifford é definida pela relação de comutação `u.v+v.u=-2*sf(u,v)` onde `sf` é a funçã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 relação de comutação `u.v-v.u=0`.

  `symplectic`: A álgebra simplética é definida pela relação de comutação `u.v-v.u=2*af(u,v)` onde `af` é uma funçã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 relação de comutação `u.v-v.u=2*av(u,v)` onde `av` é uma função antisimétrica.

  A funçã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)`.

Função: atensimp (expr)

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

Funçã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.

Função: sf (u, 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 `abasep` e se esse for o caso, substitui o valor correspondente da matriz `aform`.

Função: af (u, 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 `abasep` e se esse for o caso, substitui o valor correspondente da matriz `aform`.

Função: av (u, 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 `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

Funçã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`.

[ << ] | [ >> ] |  |  |  |  |  | [Top] | [Contents] | [Index] | [ ? ]

This document was generated by U-Cygwin\ASSI on noviembre, 12 2017 using texi2html 1.76.