Introdução a itensor (Manual do Maxima 5.44.0)

Próximo: Definições para itensor, Anterior: itensor, Acima: itensor [Conteúdo][Índice]

### 27.1, Introdução a itensor

Maxima implementa a manipulação de tensores simbólicos d dois tipos distintos: manipulação de componentes de tensores (pacote `ctensor`) e manipulação de tensores indiciais (pacote `itensor`).

Note bem: Por favor veja a nota sobre ’nova notação de tensor’ abaixo.

Manipulação de componentes de tensores significa que objectos do tipo tensor geométrico são representados como arrays ou matrizes. Operações com tensores tais com contração ou diferenciação covariante são realizadas sobre índices (que ocorrem exactamente duas vezes) repetidos com declarações `do`. Isto é, se executa explicitamente operações sobre as componentes apropriadas do tensor armazenadas em um array ou uma matriz.

Manipulação tensorial de índice é implementada através da representação de tensores como funções e suas covariantes, contravariantes e índices de derivação. Operações com tensores como contração ou diferenciação covariante são executadas através de manipulação dos índices em si mesmos em lugar das componentes para as quais eles correspondem.

Esses dois métodos aproximam-se do tratamento de processos diferenciais, algébricos e analíticos no contexto da geometria de Riemannian possuem várias vantagens e desvantagens as quais se revelam por si mesmas somente apesar da natureza particular e dificuldade dos problemas de utilizador. Todavia, se pode ter em mente as seguintes características das duas implementações:

As representações de tensores e de operações com tensores explicitamente em termos de seus componntes tornam o pacote `ctensor` fácil de usar. Especificação da métrica e o cálculo de tensores induzidos e invariantes é directo. Embora todas a capacidade de simplificação poderosa do Maxima está em manusear, uma métrica complexa com intrincada dependência funcional e de coordenadas pode facilmente conduzir a expressões cujo tamanho é excessivo e cuja estrutura está escondida. Adicionalmente, muitos cálculos envolvem expressões intermédias cujo crescimento fazem com que os programas terminem antes de serem completados. Através da experiência, um utilizador pode evitar muitas dessas dificuldade.

O motivo de caminhos especiais através dos quais tensores e operações de tensores são representados em termos de operações simbólicas sobre seus índices, expressões cujas representação de componentes podem ser não gerenciaveis da forma comum podem algumas vezes serem grandemente simplificadas através do uso das rotinas especiais para objectos simétricos em `itensor`. Nesse caminho a estrutura de uma expressão grande pode ser mais transparente. Por outro lado, o motivo da representação indicial especial em `itensor`, faz com que em alguns casos o utilizador possa encontrar dificuldade com a especificação da métrica, definição de função, e a avaliação de objectos "indexados" diferenciados.

#### 27.1.1, Nova notação d tensores

Até agora, o pacote `itensor` no Maxima tinha usado uma notação que algumas vezes conduzia a ordenação incorrecta de índices. Considere o seguinte, por exemplo:

    (%i2) imetric(g);
    (%o2)                                done
    (%i3) ishow(g([],[j,k])*g([],[i,l])*a([i,j],[]))$
                                     i l  j k
    (%t3)                           g    g    a
                                               i j
    (%i4) ishow(contract(%))$
                                          k l
    (%t4)                                a

O resultado está incorrecto a menos que ocorra ser `a` um tensor simétrico. A razão para isso é que embora `itensor` mantenha correctamente a ordem dentro do conjunto de índices covariantes e contravariantes, assim que um índice é incrementado ou decrementado, sua posição relativa para o outro conjunto de índices é perdida.

Para evitar esse problema, uma nova notação tem sido desenvolvida que mantém total compatibilidade com a notação existente e pode ser usada intercambiavelmente. Nessa notação, índices contravariantes são inseridos na posição apropriada na lista de índices covariantes, mas com um sinal de menos colocado antes. Funções como `contract` e `ishow` estão agora consciente dessa nova notação de índice e podem processar tensores apropriadamente.

Nessa nova notação, o exemplo anterior retorna um resultado correcto:

    (%i5) ishow(g([-j,-k],[])*g([-i,-l],[])*a([i,j],[]))$
                                     i l       j k
    (%t5)                           g    a    g
                                          i j
    (%i6) ishow(contract(%))$
                                          l k
    (%t6)                                a

Presentemente, o único código que faz uso dessa notação é a função `lc2kdt`. Através dessa notação, a função `lc2kdt` encontra com êxito resultados consistentes como a aplicação do tensor métrico para resolver os símbolos de Levi-Civita sem reordenar para índices numéricos.

Uma vez que esse código é um tipo novo, provavelmente contém erros. Enquanto esse tipo novo não tiver sido testado para garantir que ele não interrompe nada usando a "antiga" notação de tensor, existe uma considerável chance que "novos" tensores irão falhar em interoperar com certas funções ou recursos. Essas falhas serão corrigidas à medida que forem encontradas... até então, seja cuidadoso!

#### 27.1.2, Manipulação de tensores indiciais

o pacote de manipulação de tensores indiciais pode ser chamado através de `load(itensor)`. Demonstações estão também disponíveis: tente `demo(tensor)`. Em `itensor` um tensor é representado como um "objecto indexado" . Um "objecto indexado" é uma função de 3 grupos de índices os quais representam o covariante, o contravariante e o índice de derivação. Os índices covariantes são especificados através de uma lista com o primeiro argumento para o objecto indexado, e os índices contravariantes através de uma lista como segundo argumento. Se o objecto indexado carece de algum desses grupos de índices então a lista vazia `[]` é fornecida como o argumento correspondente. Dessa forma, `g([a,b],[c])` representa um objecto indexado chamado `g` o qual tem dois índices covariantes `(a,b)`, um índice contravariante (`c`) e não possui índices de derivação.

Os índices de derivação, se estiverem presente, são anexados ao final como argumentos adicionais para a função numérica representando o tensor. Eles podem ser explicitamente especificado pelo utilizador ou serem criados no processo de diferenciação com relação a alguma variável coordenada. Uma vez que diferenciação ordinária é comutativa, os índices de derivação são ordenados alfanumericamente, a menos que `iframe_flag` seja escolhida para `true`, indicando que um referencial métrico está a ser usado. Essa ordenação canónica torna possível para Maxima reconhecer que, por exemplo, `t([a],[b],i,j)` é o mesmo que `t([a],[b],j,i)`. Diferenciação de um objecto indexado com relação a alguma coordenada cujos índices não aparecem como um argumento para o objecto indexado podem normalmente retornar zero. Isso é porque Maxima pode não saber que o tensor representado através do objecto indexado possívelmente depende implicitamente da respectiva coordenada. Pela modificação da função existente no Maxima, `diff`, em `itensor`, Maxima sabe assumir que todos os objectos indexados dependem de qualquer variável de diferenciação a menos que seja declarado de outra forma. Isso torna possível para a convençào de somatório ser extendida para índices derivativos. Pode ser verificado que `itensor` não possui a compatibilidade de incrementar índices derivativos, e então eles são sempre tratados como covariantes.

As seguintes funções estão disponíveis no pacote tensor para manipulação de objectos. Actualmente, com relação às rotinas de simplificação, é assumido que objectos indexados não possuem por padrão propriedades simétricas. Isso pode ser modificado através da escolha da variável `allsym[false]` para `true`, o que irá resultar no tratamento de todos os objectos indexados completamente simétricos em suas listas de índices covariantes e simétricos em suas listas de índices contravariantes.

O pacote `itensor` geralmente trata tensores como objectos opacos. Equações tensoriais são manipuladas baseadas em regras algébricas, especificamente simetria e regras de contração. Adicionalmente, o pacote `itensor` não entende diferenciação covariante, curvatura, e torsão. Cálculos podem ser executados relativamente a um métrica de referenciais de movimento, dependendo da escolha para a variável `iframe_flag`.

Uma sessão demonstrativa abaixo mostra como chamar o pacote `itensor`, especificando o nome da métrica, e executando alguns cálculos simples.

    (%i1) load(itensor);
    (%o1)      /share/tensor/itensor.lisp
    (%i2) imetric(g);
    (%o2)                                done
    (%i3) components(g([i,j],[]),p([i,j],[])*e([],[]))$
    (%i4) ishow(g([k,l],[]))$
    (%t4)                               e p
                                           k l
    (%i5) ishow(diff(v([i],[]),t))$
    (%t5)                                  0
    (%i6) depends(v,t);
    (%o6)                               [v(t)]
    (%i7) ishow(diff(v([i],[]),t))$
                                        d
    (%t7)                               -- (v )
                                        dt   i
    (%i8) ishow(idiff(v([i],[]),j))$
    (%t8)                                v
                                          i,j
    (%i9) ishow(extdiff(v([i],[]),j))$
    (%t9)                             v    - v
                                       j,i    i,j
                                      -----------
                                           2
    (%i10) ishow(liediff(v,w([i],[])))$
                                   %3          %3
    (%t10)                        v   w     + v   w
                                       i,%3    ,i  %3
    (%i11) ishow(covdiff(v([i],[]),j))$
                                                  %4
    (%t11)                        v    - v   ichr2
                                   i,j    %4      i j
    (%i12) ishow(ev(%,ichr2))$
                   %4 %5
    (%t12) v    - g      v   (e p       + e   p     - e p       - e    p
            i,j           %4     j %5,i    ,i  j %5      i j,%5    ,%5  i j

                                                    + e p       + e   p    )/2
                                                         i %5,j    ,j  i %5
    (%i13) iframe_flag:true;
    (%o13)                               true
    (%i14) ishow(covdiff(v([i],[]),j))$
                                                 %6
    (%t14)                        v    - v   icc2
                                   i,j    %6     i j
    (%i15) ishow(ev(%,icc2))$
                                                 %6
    (%t15)                        v    - v   ifc2
                                   i,j    %6     i j
    (%i16) ishow(radcan(ev(%,ifc2,ifc1)))$
                 %6 %8                    %6 %8
    (%t16) - (ifg      v   ifb       + ifg      v   ifb       - 2 v
                        %6    j %8 i             %6    i j %8      i,j

                                                        %6 %8
                                                   - ifg      v   ifb      )/2
                                                               %6    %8 i j
    (%i17) ishow(canform(s([i,j],[])-s([j,i])))$
    (%t17)                            s    - s
                                       i j    j i
    (%i18) decsym(s,2,0,[sym(all)],[]);
    (%o18)                               done
    (%i19) ishow(canform(s([i,j],[])-s([j,i])))$
    (%t19)                                 0
    (%i20) ishow(canform(a([i,j],[])+a([j,i])))$
    (%t20)                            a    + a
                                       j i    i j
    (%i21) decsym(a,2,0,[anti(all)],[]);
    (%o21)                               done
    (%i22) ishow(canform(a([i,j],[])+a([j,i])))$
    (%t22)                                 0

Próximo: Definições para itensor, Anterior: itensor, Acima: itensor [Conteúdo][Índice]