[ < ] | [ > ] |  | [ << ] | [ Up ] | [ >> ] |  |  |  |  | [Top] | [Contents] | [Índice] | [ ? ]

# 29. Pacote atensor

[ < ] | [ > ] |  | [ << ] | [ Up ] | [ >> ] |  |  |  |  | [Top] | [Contents] | [Índice] | [ ? ]

## 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 ativadas quando a função `init_atensor` é chamada.

A compatibilidade de `atensor` pode ser demonstrada pela definiçã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 definição interna para a álgebra dos quatérnios, isso não foi usado nesse exemplo, no qual nós nos esforçamos para construir a tabela de multiplicaçã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 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 você deseja experimentar com uma álgebra não associativa, você 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] | [Índice] | [ ? ]

## 29.2 Funções e Variáveis Definidas 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 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)`.

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

  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.

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

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

[ << ] | [ >> ] |  |  |  |  |  | [Top] | [Contents] | [Índice] | [ ? ]

This document was generated by Viktor T. Toth on Setembro, 27 2018 using texi2html 1.76.