Introducedilhaão a itensor
==========================

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

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

Manipulacedilhaão de componentes de tensores significa que objetos do tipo tensor geométrico são representados como arrays ou matrizes. Operacedilhaões com tensores tais com contracedilhaão ou diferenciacedilhaão covariante são realizadas sobre índices (que ocorrem exatamente duas vezes) repetidos com declaracedilhaões do. Isto é, se executa explicitamente operacedilhaões sobre as componentes apropriadas do tensor armazenadas em um array ou uma matriz.

Manipulacedilhaão tensorial de índice é implementada através da representacedilhaão de tensores como funcedilhaões e suas covariantes, contravariantes e índices de derivacedilhaão. Operacedilhaões com tensores como contracedilhaão ou diferenciacedilhaão covariante são executadas através de manipulacedilhaã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 usuário.  Todavia, se pode ter em mente as seguintes características das duas implementacedilhaões:

As representacedilhaões de tensores e de operacedilhaões com tensores explicitamente em termos de seus componntes tornam o pacote ctensor fácil de usar. Especificacedilhaão da métrica e o cálculo de tensores induzidos e invariantes é direto. Embora todas a capacidade de simplificacedilhaã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 intermediárias cujo crescimento fazem com que os programas terminem antes de serem completados. Através da experiência, um usuário pode evitar muitas dessas dificuldade.

O motivo de caminhos especiais através dos quais tensores e operacedilhaões de tensores são representados em termos de operacedilhaões simbólicas sobre seus índices, expressões cujas representacedilhaã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 objetos simétricos em itensor. Nesse caminho a estrutura de uma expressão grande pode ser mais transparente. Por outro lado, o motivo da representacedilhaão indicial especial em itensor, faz com que em alguns casos o usuário possa encontrar dificuldade com a especificacedilhaão da métrica, definicedilhaão de funcedilhaão, e a avaliacedilhaão de objetos "indexados" diferenciados.

Nova notacedilhaão d tensores
-----------------------------

Até agora, o pacote itensor no Maxima tinha usado uma notacedilhaão que algumas vezes conduzia a ordenacedilhaão incorreta 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á incorreto a menos que ocorra ser a um tensor simétrico. A razão para isso é que embora itensor mantenha corretamente a ordem dentro do conjunto de índices covariantes e contravariantes, assim que um índice é incrementado ou decrementado, sua posicedilhaão relativa para o outro conjunto de índices é perdida.

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

Nessa nova notacedilhaão, o exemplo anterior retorna um resultado correto:

     (%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 notacedilhaão é a funcedilhaão lc2kdt. Através dessa notacedilhaão, a funcedilhaão lc2kdt encontra com êxito resultados consistentes como a aplicacedilhaã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" notacedilhaão de tensor, existe uma considerável chance que "novos" tensores irão falhar em interoperar com certas funcedilhaões ou recursos. Essas falhas serão corrigidas à medida que forem encontradas... até então, seja cuidadoso!

Manipulacedilhaão de tensores indiciais
---------------------------------------

o pacote de manipulacedilhaão de tensores indiciais pode ser chamado através de load(itensor). Demonstacedilhaões estão também disponíveis: tente demo(tensor). Em itensor um tensor é representado como um "objeto indexado" .  Um "objeto indexado" é uma funcedilhaão de 3 grupos de índices os quais representam o covariante, o contravariante e o índice de derivacedilhaão.  Os índices covariantes são especificados através de uma lista com o primeiro argumento para o objeto indexado, e os índices contravariantes através de uma lista como segundo argumento. Se o objeto 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 objeto indexado chamado g o qual tem dois índices covariantes (a,b), um índice contravariante (c) e não possui índices de derivacedilhaão.

Os índices de derivacedilhaão, se estiverem presente, são anexados ao final como argumentos adicionais para a funcedilhaão numérica representando o tensor. Eles podem ser explicitamente especificado pelo usuário ou serem criados no processo de diferenciacedilhaão com relacedilhaão a alguma variável coordenada. Uma vez que diferenciacedilhaão ordinária é comutativa, os índices de derivacedilhaão são ordenados alfanumericamente, a menos que iframe_flag seja escolhida para true, indicando que uma moldura métrica está sendo usada. Essa ordenacedilhaã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).  Diferenciacedilhaão de um objeto indexado com relacedilhaão a alguma coordenada cujos índices não aparecem como um argumento para o objeto indexado podem normalmente retornar zero. Isso é porque Maxima pode não saber que o tensor representado através do objeto indexado possívelmente depende implicitamente da respectiva coordenada.  Pela modificacedilhaão da funcedilhaão existente no Maxima, diff,  em itensor, Maxima sabe assumir que todos os objetos indexados dependem de qualquer variável de diferenciacedilhaão a menos que seja declarado de outra forma.  Isso torna possível para a convencedilhaà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 funcedilhaões estão disponíveis no pacote tensor para manipulacedilhaão de objetos.  Atualmente, com relacedilhaão às rotinas de simplificacedilhaão, é assumido que objetos 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 objetos 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 objetos opacos. Equacedilhaões tensoriais são manipuladas baseadas em regras algébricas, especificamente simetria e regras de contracedilhaão. Adicionalmente, o pacote itensor não entende diferenciacedilhaão covariante, curvatura, e torsão. Cálculos podem ser executados relativamente a um métrica de molduras 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

Funcedilhaões e Variáveis Definidas para itensor
================================================

Gerenciando objetos indexados
-----------------------------

 -- Funcedilhaão: entertensor (NOME)

     É uma funcedilhaão que, através da linha de comando, permite criar um objeto indexado chamado NOME com qualquer número de índices de tensores e derivativos. Ou um índice simples ou uma lista de índices (às quais podem ser nulas) são entradas aceitáveis (veja o exemplo sob covdiff).

 -- Funcedilhaão: changename (ANTIGO, NOVO, EXPR)

     Irá mudar o nome de todos os objetos indexados chamados ANTIGO para NOVO em EXPR. ANTIGO pode ser ou um símbolo ou uma lista da forma [NOME, M, N] nesse caso somente esses objetos indexados chamados NOME com índice covariante M e índice contravariante N serão renomeados para NOVO.

 -- Funcedilhaão: listoftens

     Lista todos os tensores em uma expressão tensorial, incluindo seus índices. E.g.,

          (%i6) ishow(a([i,j],[k])*b([u],[],v)+c([x,y],[])*d([],[])*e)$
                                                   k
          (%t6)                        d e c    + a    b
                                            x y    i j  u,v
          (%i7) ishow(listoftens(%))$
                                         k
          (%t7)                        [a   , b   , c   , d]
                                         i j   u,v   x y

 -- Funcedilhaão: ishow (EXPR)

     Mostra EXPR com os objetos indexados tendo seus índices covariantes como subscritos e índices contravariantes como sobrescritos.  Os índices derivativos são mostrados como subscritos, separados dos índices covariantes por uma vírgula (veja os exemplos através desse documento).

 -- Funcedilhaão: indices (EXPR)

     Retorna uma lista de dois elementos.  O primeiro é uma lista de índices livres em EXPR (aqueles que ocorrem somente uma vez). O segundo é uma lista de indices que ocorrem exatamente duas vezes em EXPR (dummy) como demonstra o seguinte exemplo.

          (%i1) load(itensor);
          (%o1)      /share/tensor/itensor.lisp
          (%i2) ishow(a([i,j],[k,l],m,n)*b([k,o],[j,m,p],q,r))$
                                          k l      j m p
          (%t2)                          a        b
                                          i j,m n  k o,q r
          (%i3) indices(%);
          (%o3)                 [[l, p, i, n, o, q, r], [k, j, m]]

     Um produto de tensores contendo o mesmo índice mais que duas vezes é sintaticamente ilegal. indices tenta lidar com essas expressões de uma forma razoável; todavia, quando indices é chamada para operar sobre tal uma expressão ilegal, seu comportamento pode ser considerado indefinido.

 -- Funcedilhaão: rename (EXPR)
 -- Funcedilhaão: rename (EXPR, CONTADOR)

     Retorna uma expressão equivalente para EXPR mas com índices que ocorrem exatamente duas vezes em cada termo alterado do conjunto [%1, %2,...], se o segundo argumento opcional for omitido. De outra forma, os índices que ocorrem exatamente duas vezes são indexados comecedilhaando no valor de CONTADOR.  Cada índice que ocorre exatamente duas vezes em um produto será diferente. Para uma adicedilhaão, rename irá operar sobre cada termo na a adicedilhaão zerando o contador com cada termo. Nesse caminho rename pode servir como um simplificador tensorial. Adicionalmente, os índices serão ordenados alfanumericamente (se allsym for true) com relacedilhaão a índices covariantes ou contravariantes dependendo do valor de flipflag. Se flipflag for false então os índices serão renomeados conforme a ordem dos índices contravariantes. Se flipflag for true a renomeacedilhaão ocorrerá conforme a ordem dos índices covariantes. Isso muitas vezes ajuda que o efeito combinado dos dois restantes sejam reduzidos a uma expressão de valor um ou mais que um por si mesma.

          (%i1) load(itensor);
          (%o1)      /share/tensor/itensor.lisp
          (%i2) allsym:true;
          (%o2)                                true
          (%i3) g([],[%4,%5])*g([],[%6,%7])*ichr2([%1,%4],[%3])*
          ichr2([%2,%3],[u])*ichr2([%5,%6],[%1])*ichr2([%7,r],[%2])-
          g([],[%4,%5])*g([],[%6,%7])*ichr2([%1,%2],[u])*
          ichr2([%3,%5],[%1])*ichr2([%4,%6],[%3])*ichr2([%7,r],[%2]),noeval$
          (%i4) expr:ishow(%)$

                 %4 %5  %6 %7      %3         u          %1         %2
          (%t4) g      g      ichr2      ichr2      ichr2      ichr2
                                   %1 %4      %2 %3      %5 %6      %7 r

                        %4 %5  %6 %7      u          %1         %3         %2
                     - g      g      ichr2      ichr2      ichr2      ichr2
                                          %1 %2      %3 %5      %4 %6      %7 r
          (%i5) flipflag:true;
          (%o5)                                true
          (%i6) ishow(rename(expr))$
                 %2 %5  %6 %7      %4         u          %1         %3
          (%t6) g      g      ichr2      ichr2      ichr2      ichr2
                                   %1 %2      %3 %4      %5 %6      %7 r

                        %4 %5  %6 %7      u          %1         %3         %2
                     - g      g      ichr2      ichr2      ichr2      ichr2
                                          %1 %2      %3 %4      %5 %6      %7 r
          (%i7) flipflag:false;
          (%o7)                                false
          (%i8) rename(%th(2));
          (%o8)                                  0
          (%i9) ishow(rename(expr))$
                 %1 %2  %3 %4      %5         %6         %7        u
          (%t9) g      g      ichr2      ichr2      ichr2     ichr2
                                   %1 %6      %2 %3      %4 r      %5 %7

                        %1 %2  %3 %4      %6         %5         %7        u
                     - g      g      ichr2      ichr2      ichr2     ichr2
                                          %1 %3      %2 %6      %4 r      %5 %7

 -- Variável de Opcedilhaão: flipflag

     Valor padrão: false. Se false então os índices irão ser renomeados conforme a ordem dos índices contravariantes, de outra forma serão ordenados conforme a ordem dos índices covariantes.

     Se flipflag for false então rename forma uma lista de índices contravariantes na ordem em que forem encontrados da esquerda para a direita (se true então de índices contravariantes). O primeiro índice que ocorre exatamente duas vezes na lista é renomeado para %1, o seguinte para %2, etc. Então a ordenacedilhaão ocorre após a ocorrência do rename (veja o exemplo sob rename).

 -- Funcedilhaão: defcon (TENSOR_1)
 -- Funcedilhaão: defcon (TENSOR_1, TENSOR_2, TENSOR_3)
     Dado TENSOR_1 a propriedade que a contracedilhaão de um produto do TENSOR_1 e do TENSOR_2 resulta em TENSOR_3 com os índices apropriados.  Se somente um argumento, TENSOR_1, for dado, então a contracedilhaão do produto de TENSOR_1 com qualquer objeto indexado tendo os índices apropriados (digamos my_tensor) irá retornar como resultado um objeto indexado com aquele nome, i.e. my_tensor, e com uma nova escolha de índices refletindo as contracedilhaões executadas. Por exemplo, se imetric:g, então defcon(g) irá implementar o incremento e decremento de índices através da contracedilhaão com o tensor métrico. Mais de uma defcon pode ser dada para o mesmo objeto indexado; o último  fornecido que for aplicado a uma contracedilhaão particular será usado. contractions é uma lista de objetos indexados que tenham fornecido propriedades de contracedilhaões com defcon.

 -- Funcedilhaão: remcon (TENSOR_1, ..., TENSOR_N)
 -- Funcedilhaão: remcon (all)
     Remove todas as propriedades de contracedilhaão de TENSOR_1, ..., TENSOR_N). remcon(all) remove todas as propriedades de contracedilhaão de todos os objetos indexados.

 -- Funcedilhaão: contract (EXPR)

     Realiza contracedilhaões tensoriais em EXPR a qual pode ser qualquer combinacedilhaão de adicedilhaões e produtos. Essa funcedilhaão usa a informacedilhaão dada para a funcedilhaão defcon. Para melhores resultados, expr pode ser completamente expandida. ratexpand é o meio mais rápido para expandir produtos e expoentes de adicedilhaões se não existirem variáveis nos denominadores dos termos. O comutador gcd pode ser false se cancelamentos de máximo divisor comum forem desnecessários.

 -- Funcedilhaão: indexed_tensor (TENSOR)

     Deve ser executada antes de atribuir componentes para um TENSOR para o qual um valor interno já existe como com ichr1, ichr2, icurvature. Veja o exemplo sob icurvature.

 -- Funcedilhaão: components (TENSOR, EXPR)

     Permite que se atribua um valor indicial a uma expressão EXPR dando os valores das componentes do TENSOR. Esses são automaticamente substituídos para o tensor mesmo que isso ocorra com todos os seus índices. O tensor deve ser da forma t([...],[...]) onde qualquer lista pode ser vazia. EXPR pode ser qualquer expressão indexada envolvendo outros objetos com os mesmos índices livres que TENSOR. Quando usada para atribuir valores a um tensor métrico no qual as componentes possuem índices que ocorrem exatamente duas vezes se deve ser cuidadoso para definir esses índices de forma a evitar a geracedilhaão de índices que ocorrem exatamente duas vezes e que são multiplos. a remocedilhaão dessas atribuicedilhaões é dada para a funcedilhaão remcomps.

     É importante ter em mente que components cuida somente da valência de um tensor, e que ignora completamente qualquer ordenacedilhaão particular de índices. Dessa forma atribuindo componentes a, digamos, x([i,-j],[]), x([-j,i],[]), ou x([i],[j]) todas essas atribuicedilhaões produzem o mesmo resultado, a saber componentes sendo atribuidas a um tensor chamado x com valência (1,1).

     Componentes podem ser atribuidas a uma expressão indexada por quatro caminhos, dois dos quais envolvem o uso do comando components:

     1) Como uma expressão indexada. Por exemplo:

          (%i2) components(g([],[i,j]),e([],[i])*p([],[j]))$
          (%i3) ishow(g([],[i,j]))$
                                                i  j
          (%t3)                                e  p

     2) Como uma matriz:

          (%i6) components(g([i,j],[]),lg);
          (%o6)                                done
          (%i7) ishow(g([i,j],[]))$
          (%t7)                                g
                                                i j
          (%i8) g([3,3],[]);
          (%o8)                                  1
          (%i9) g([4,4],[]);
          (%o9)                                 - 1

     3) Como uma funcedilhaão. Você pode usar uma funcedilhaão Maxima para especificar as componentes de um tensor baseado nesses índices. Por exemplo, os seguintes códigos atribuem kdelta a h se h tiver o mesmo número de índices covariantes e índices contravariantes e nenhum índice derivativo, e atribui kdelta a g caso as condicedilhaões anteriores não sejam atendidas:

          (%i4) h(l1,l2,[l3]):=if length(l1)=length(l2) and length(l3)=0
            then kdelta(l1,l2) else apply(g,append([l1,l2], l3))$
          (%i5) ishow(h([i],[j]))$
                                                    j
          (%t5)                               kdelta
                                                    i
          (%i6) ishow(h([i,j],[k],l))$
                                               k
          (%t6)                               g
                                               i j,l

     4) Usando a compatibilidade dos modelos de coincidência do Maxima, especificamente os comandos defrule e applyb1:

          (%i1) load(itensor);
          (%o1)      /share/tensor/itensor.lisp
          (%i2) matchdeclare(l1,listp);
          (%o2)                                done
          (%i3) defrule(r1,m(l1,[]),(i1:idummy(),
                g([l1[1],l1[2]],[])*q([i1],[])*e([],[i1])))$

          (%i4) defrule(r2,m([],l1),(i1:idummy(),
                w([],[l1[1],l1[2]])*e([i1],[])*q([],[i1])))$

          (%i5) ishow(m([i,n],[])*m([],[i,m]))$
                                              i m
          (%t5)                              m    m
                                                   i n
          (%i6) ishow(rename(applyb1(%,r1,r2)))$
                                     %1  %2  %3 m
          (%t6)                     e   q   w     q   e   g
                                                   %1  %2  %3 n

 -- Funcedilhaão: remcomps (TENSOR)

     Desassocia todos os valores de TENSOR que foram atribuídos com a funcedilhaão components.

 -- Funcedilhaão: showcomps (TENSOR)

     Mostra atribuicedilhaões de componentes de um tensor, feitas usando o comando components. Essa funcedilhaão pode ser particularmente útil quando uma matriz é atribuída a um tensor indicial usando components, como demonstrado através do seguinte exemplo:

          (%i1) load(ctensor);
          (%o1)       /share/tensor/ctensor.mac
          (%i2) load(itensor);
          (%o2)      /share/tensor/itensor.lisp
          (%i3) lg:matrix([sqrt(r/(r-2*m)),0,0,0],[0,r,0,0],
                          [0,0,sin(theta)*r,0],[0,0,0,sqrt((r-2*m)/r)]);
                         [         r                                     ]
                         [ sqrt(-------)  0       0              0       ]
                         [      r - 2 m                                  ]
                         [                                               ]
                         [       0        r       0              0       ]
          (%o3)          [                                               ]
                         [       0        0  r sin(theta)        0       ]
                         [                                               ]
                         [                                      r - 2 m  ]
                         [       0        0       0        sqrt(-------) ]
                         [                                         r     ]
          (%i4) components(g([i,j],[]),lg);
          (%o4)                                done
          (%i5) showcomps(g([i,j],[]));
                            [         r                                     ]
                            [ sqrt(-------)  0       0              0       ]
                            [      r - 2 m                                  ]
                            [                                               ]
                            [       0        r       0              0       ]
          (%t5)      g    = [                                               ]
                      i j   [       0        0  r sin(theta)        0       ]
                            [                                               ]
                            [                                      r - 2 m  ]
                            [       0        0       0        sqrt(-------) ]
                            [                                         r     ]
          (%o5)                                false

     O comando showcomps pode também mostrar componentes de um tensor de categoria maior que 2.

 -- Funcedilhaão: idummy ()

     Incrementos icounter e retorno como seu valor um índice da forma %n onde n é um inteiro positivo.  Isso garante que índices que ocorrem exatamente duas vezes e que são necessários na formacedilhaão de expressões não irão conflitar com índices que já estiverem sendo usados (veja o exemplo sob indices).

 -- Variável de opcedilhaão: idummyx
     Valor padrão: %

     É o prefixo para índices que ocorrem exatamente duas vezes (veja o exemplo sob índices indices).

 -- Variável de Opcedilhaão: icounter
     Valor padrão: 1

     Determina o sufixo numérico a ser usado na geracedilhaão do próximo índice que ocorre exatamente duas vezes no pacote tensor.  O prefixo é determinado através da opcedilhaão idummy (padrão: %).

 -- Funcedilhaão: kdelta (L1, L2)
     é a funcedilhaão delta generalizada de Kronecker definida no pacote itensor com L1 a lista de índices covariantes e L2 a lista de índices contravariantes.  kdelta([i],[j]) retorna o delta de Kronecker comum.  O comando ev(EXPR,kdelta) faz com que a avaliacedilhaão de uma expressão contendo kdelta([],[]) se dê para a dimensão de multiplicacedilhaão.

     No que conduzir a um abuso dessa notacedilhaão, itensor também permite kdelta ter 2 covariantes e nenhum contravariante, ou 2 contravariantes e nenhum índice covariante, com efeito fornecendo uma compatibilidade para "matriz unitária" covariante ou contravariante. Isso é estritamente considerado um recurso de programacedilhaão e não significa implicar que kdelta([i,j],[]) seja um objeto tensorial válido.

 -- Funcedilhaão: kdels (L1, L2)

     Delta de Kronecker simetrizado, usado em alguns cálculos. Por exemplo:

          (%i1) load(itensor);
          (%o1)      /share/tensor/itensor.lisp
          (%i2) kdelta([1,2],[2,1]);
          (%o2)                                 - 1
          (%i3) kdels([1,2],[2,1]);
          (%o3)                                  1
          (%i4) ishow(kdelta([a,b],[c,d]))$
                                       c       d         d       c
          (%t4)                  kdelta  kdelta  - kdelta  kdelta
                                       a       b         a       b
          (%i4) ishow(kdels([a,b],[c,d]))$
                                       c       d         d       c
          (%t4)                  kdelta  kdelta  + kdelta  kdelta
                                       a       b         a       b

 -- Funcedilhaão: levi_civita (L)
     é o tensor de permutacedilhaão (ou de Levi-Civita) que retorna 1 se a lista L consistir de uma permutacedilhaão par de inteiros, -1 se isso consistir de uma permutacedilhaão ímpar, e 0 se alguns índices em L forem repetidos.

 -- Funcedilhaão: lc2kdt (EXPR)
     Simplifica expressões contendo os símbolos de Levi-Civita, convertendo esses para expressões delta de Kronecker quando possível. A principal diferencedilhaa entre essa funcedilhaão e simplesmente avaliar os simbolos de Levi-Civita é que a avaliacedilhaão direta muitas vezes resulta em expressões Kronecker contendo índices numéricos. Isso é muitas vezes indesejável como na prevencedilhaão de simplificacedilhaão adicional. A funcedilhaão lc2kdt evita esse problema, retornando expressões que são mais facilmente simplificadas com rename ou contract.

          (%i1) load(itensor);
          (%o1)      /share/tensor/itensor.lisp
          (%i2) expr:ishow('levi_civita([],[i,j])*'levi_civita([k,l],[])*a([j],[k]))$
                                            i j  k
          (%t2)                  levi_civita    a  levi_civita
                                                 j            k l
          (%i3) ishow(ev(expr,levi_civita))$
                                            i j  k       1 2
          (%t3)                       kdelta    a  kdelta
                                            1 2  j       k l
          (%i4) ishow(ev(%,kdelta))$
                       i       j         j       i   k
          (%t4) (kdelta  kdelta  - kdelta  kdelta ) a
                       1       2         1       2   j

                                         1       2         2       1
                                  (kdelta  kdelta  - kdelta  kdelta )
                                         k       l         k       l
          (%i5) ishow(lc2kdt(expr))$
                               k       i       j    k       j       i
          (%t5)               a  kdelta  kdelta  - a  kdelta  kdelta
                               j       k       l    j       k       l
          (%i6) ishow(contract(expand(%)))$
                                           i           i
          (%t6)                           a  - a kdelta
                                           l           l

     A funcedilhaão lc2kdt algumas vezes faz uso de tensores métricos. Se o tensor métrico não tiver sido definido previamente com imetric, isso resulta em um erro.

          (%i7) expr:ishow('levi_civita([],[i,j])*'levi_civita([],[k,l])*a([j,k],[]))$
                                           i j            k l
          (%t7)                 levi_civita    levi_civita    a
                                                               j k
          (%i8) ishow(lc2kdt(expr))$
          Maxima encountered a Lisp error:

           Error in $IMETRIC [or a callee]:
           $IMETRIC [or a callee] requires less than two arguments.

          Automatically continuing.
          To reenable the Lisp debugger set *debugger-hook* to nil.
          (%i9) imetric(g);
          (%o9)                                done
          (%i10) ishow(lc2kdt(expr))$
                   %3 i       k   %4 j       l     %3 i       l   %4 j       k
          (%t10) (g     kdelta   g     kdelta   - g     kdelta   g     kdelta  ) a
                              %3             %4               %3             %4   j k
          (%i11) ishow(contract(expand(%)))$
                                            l i      l i
          (%t11)                           a    - a g

 -- Funcedilhaão: lc_l

     Regra de simplificacedilhaão usada para expressões contendo símbolos não avaliados de Levi-Civita (levi_civita). Juntamente com lc_u, pode ser usada para simplificar muitas expressões mais eficientemente que a avaliacedilhaão de levi_civita. Por exemplo:

          (%i1) load(itensor);
          (%o1)      /share/tensor/itensor.lisp
          (%i2)  el1:ishow('levi_civita([i,j,k],[])*a([],[i])*a([],[j]))$
                                       i  j
          (%t2)                       a  a  levi_civita
                                                       i j k
          (%i3) el2:ishow('levi_civita([],[i,j,k])*a([i])*a([j]))$
                                                 i j k
          (%t3)                       levi_civita      a  a
                                                        i  j
          (%i4) ishow(canform(contract(expand(applyb1(el1,lc_l,lc_u)))))$
          (%t4)                                  0
          (%i5) ishow(canform(contract(expand(applyb1(el2,lc_l,lc_u)))))$
          (%t5)                                  0

 -- Funcedilhaão: lc_u

     Regra de simplificacedilhaão usada para expressões contendo símbolos não avaliados de Levi-Civita (levi_civita). Juntamente com lc_u, pode ser usada para simplificar muitas expressões mais eficientemente que a avaliacedilhaão de levi_civita. Para detalhes, veja lc_l.

 -- Funcedilhaão: canten (EXPR)
     Simplifica EXPR por renomeacedilhaão (veja rename) e permutando índices que ocorrem exatamente duas vezes. rename é restrito a adicedilhaões de produto de tensores nos quais nenhum índice derivativo estiver presente. Como tal isso é limitado e pode somente ser usado se canform não for capaz de realizar a simplificacedilhaão requerida.

     A funcedilhaão canten retorna um resultado matematicamente correto somente se seu argumento for uma expressão que é completamente simétrica em seus índices. Por essa razão, canten retorna um erro se allsym não for posicionada em true.

 -- Funcedilhaão: concan (EXPR)
     Similar a canten mas também executa contracedilhaão de índices.

Simetrias de tensores
---------------------

 -- Variável de Opcedilhaão: allsym

     Valor padrão: false. Se true então todos os objetos indexados são assumidos simétricos em todos os seus índices covariantes e contravariantes. Se false então nenhum simétrico de qualquer tipo é assumidos nesses índices. Índices derivativos são sempre tomados para serem simétricos a menos que iframe_flag seja escolhida para true.

 -- Funcedilhaão: decsym (TENSOR, M, N, [COV_1, COV_2, ...], [CONTR_1, CONTR_2, ...])

     Declara propriedades de simetria para TENSOR de covariante M e N índices contravariantes. As COV_I e CONTR_I são pseudofuncedilhaões expressando relacedilhaões de simetrias em meio a índices covariante e índices contravariantes respectivamente.  Esses são da forma symoper(INDEX_1, INDEX_2,...) onde symoper é um entre sym, anti ou cyc e os INDEX_I são inteiros indicando a posicedilhaão do índice no TENSOR.  Isso irá declarar TENSOR para ser simétrico, antisimétrico ou cíclico respectivamente nos INDEX_I. symoper(all) é também forma permitida que indica todos os índices obedecem à condicedilhaão de simetria. Por exemplo, dado um objeto b com 5 índices covariantes, decsym(b,5,3,[sym(1,2),anti(3,4)],[cyc(all)]) declara b simétrico no seu primeiro e no seu segundo índices e antisimétrico no seu terceiro e quarto índices covariantes, e cíclico em todos de seus índices contravariantes. Qualquer lista de declaracedilhaões de simetria pode ser nula.  A funcedilhaão que executa as simplificacedilhaões é canform como o exemplo abaixo ilustra.

          (%i1) load(itensor);
          (%o1)      /share/tensor/itensor.lisp
          (%i2) expr:contract(expand(a([i1,j1,k1],[])*kdels([i,j,k],[i1,j1,k1])))$
          (%i3) ishow(expr)$
          (%t3)         a      + a      + a      + a      + a      + a
                         k j i    k i j    j k i    j i k    i k j    i j k
          (%i4) decsym(a,3,0,[sym(all)],[]);
          (%o4)                                done
          (%i5) ishow(canform(expr))$
          (%t5)                              6 a
                                                i j k
          (%i6) remsym(a,3,0);
          (%o6)                                done
          (%i7) decsym(a,3,0,[anti(all)],[]);
          (%o7)                                done
          (%i8) ishow(canform(expr))$
          (%t8)                                  0
          (%i9) remsym(a,3,0);
          (%o9)                                done
          (%i10) decsym(a,3,0,[cyc(all)],[]);
          (%o10)                               done
          (%i11) ishow(canform(expr))$
          (%t11)                        3 a      + 3 a
                                           i k j      i j k
          (%i12) dispsym(a,3,0);
          (%o12)                     [[cyc, [[1, 2, 3]], []]]

 -- Funcedilhaão: remsym (TENSOR, M, N)
     Remove todas as propriedades de simetria de TENSOR que tem M índices covariantes e N índices contravariantes.

 -- Funcedilhaão: canform (EXPR)
     Simplifica EXPR através de mudancedilhaa de nome de índices que ocorrem exatamente duas vezes e reordenacedilhaão de todos os índices como ditados pelas condicedilhaões de simetria impostas sobre eles. Se allsym for true então todos os índices são assumidos simétricos, de outra forma a informacedilhaão de simetria fornecida pelas declaracedilhaões decsym irão ser usadas. Os índices que ocorrem exatamente duas vezes são renomeados da mesma maneira que na funcedilhaão rename. Quando canform é aplicada a uma expressão larga o cálculo pode tomar um considerável montante de tempo. Esse tempo pode ser diminuído através do uso de rename sobre a expressão em primeiro lugar. Também veja o exemplo sob decsym. Nota: canform pode não estar apta a reduzir um expressão completamente para sua forma mais simples embora retorne sempre um resultado matemáticamente correto.

Cálculo de tensores indiciais
-----------------------------

 -- Funcedilhaão: diff (EXPR, V_1, [N_1, [V_2, N_2] ...])

     É a funcedilhaão usual de diferenciacedilhaão do Maxima que tem sido expandida nessas habilidades para itensor. diff toma a derivada de EXPR N_1 vezes com relacedilhaão a V_1, N_2 vezes com relacedilhaão a V_2 , etc. Para o pacote tensor, a funcedilhaão tem sido modificada de forma que os V_I possam ser inteiros de 1 até o valor da variável dim.  Isso causará a conclusão da diferenciacedilhaão com relacedilhaão ao V_Iésimo membro da lista vect_coords.  Se vect_coords for associado a uma variável atômica, então aquela variável subscrita através de V_I será usada para a variável de diferenciacedilhaão.  Isso permite que um array de nomes de coordenadas ou nomes subscritos como x[1], x[2], ...  sejam usados.

 -- Funcedilhaão: idiff (EXPR, V_1, [N_1, [V_2, N_2] ...])
     Diferenciacedilhaão indicial. A menos que diff, que diferencia com relacedilhaão a uma variável independente, idiff possa ser usada para diferenciar com relacedilhaão a uma coordenada. Para um objeto indexado, isso equivale a anexar ao final os V_I como índices derivativos. Subseqüêntemente, índices derivativos irão ser ordenados, a menos que iframe_flag seja escolhida para true.

     idiff pode também ser o determinante de um tensor métrico. Dessa forma, se imetric tiver sido associada a G então idiff(determinant(g),k) irá retornar 2*determinant(g)*ichr2([%i,k],[%i]) onde o índice que ocorre exatamente duas vezes %i é escolhido apropriadamente.

 -- Funcedilhaão: liediff (V, TEN)

     Calcula a derivada de Lie da expressão tensorial TEN com relacedilhaão ao campo vetorial V. TEN pode ser qualquer expressão tensorial indexada; V pode ser o nome (sem índices) de um campo vetorial. Por exemplo:

          (%i1) load(itensor);
          (%o1)      /share/tensor/itensor.lisp
          (%i2) ishow(liediff(v,a([i,j],[])*b([],[k],l)))$
                 k    %2            %2          %2
          (%t2) b   (v   a       + v   a     + v   a    )
                 ,l       i j,%2    ,j  i %2    ,i  %2 j

                                          %1  k        %1  k      %1  k
                                      + (v   b      - b   v    + v   b   ) a
                                              ,%1 l    ,l  ,%1    ,l  ,%1   i j

 -- Funcedilhaão: rediff (TEN)

     Avalia todas as ocorrências do comando idiff na expressão tensorial TEN.

 -- Funcedilhaão: undiff (EXPR)

     Retorna uma expressão equivalente a EXPR mas com todas as derivadas de objetos indexados substituídas pela forma substantiva da funcedilhaão idiff. Seu argumento pode retornar aquele objeto indexado se a diferenciacedilhaão for concluída.  Isso é útil quando for desejado substituir um objeto indexado que sofreu diferenciacedilhaão com alguma definicedilhaão de funcedilhaão resultando em EXPR e então concluir a diferenciacedilhaão através de digamos ev(EXPR, idiff).

 -- Funcedilhaão: evundiff (EXPR)

     Equivalente à execucedilhaão de undiff, seguida por ev e rediff.

     O ponto dessa operacedilhaão é facilmente avaliar expressões que não possam ser diretamente avaliadas na forma derivada. Por exemplo, o seguinte causa um erro:

          (%i1) load(itensor);
          (%o1)      /share/tensor/itensor.lisp
          (%i2) icurvature([i,j,k],[l],m);
          Maxima encountered a Lisp error:

           Error in $ICURVATURE [or a callee]:
           $ICURVATURE [or a callee] requires less than three arguments.

          Automatically continuing.
          To reenable the Lisp debugger set *debugger-hook* to nil.

     Todavia, se icurvature é informado em sua forma substantiva, pode ser avaliado usando evundiff:

          (%i3) ishow('icurvature([i,j,k],[l],m))$
                                                   l
          (%t3)                          icurvature
                                                   i j k,m
          (%i4) ishow(evundiff(%))$
                       l              l         %1           l           %1
          (%t4) - ichr2        - ichr2     ichr2      - ichr2       ichr2
                       i k,j m        %1 j      i k,m        %1 j,m      i k

                          l              l         %1           l           %1
                   + ichr2        + ichr2     ichr2      + ichr2       ichr2
                          i j,k m        %1 k      i j,m        %1 k,m      i j

     Nota: Em versões anteriores do Maxima, formas derivadas dos símbolos de Christoffel também não podiam ser avaliadas. Isso foi corrigido atualmente, de forma que evundiff não mais é necessária para expressões como essa:

          (%i5) imetric(g);
          (%o5)                                done
          (%i6) ishow(ichr2([i,j],[k],l))$
                 k %3
                g     (g         - g         + g        )
                        j %3,i l    i j,%3 l    i %3,j l
          (%t6) -----------------------------------------
                                    2

                                   k %3
                                  g     (g       - g       + g      )
                                   ,l     j %3,i    i j,%3    i %3,j
                                + -----------------------------------
                                                   2

 -- Funcedilhaão: flush (EXPR, TENSOR_1, TENSOR_2, ...)
     Escolhe para zero, em EXPR, todas as ocorrências de TENSOR_I que não tiverem índices derivativos.

 -- Funcedilhaão: flushd (EXPR, TENSOR_1, TENSOR_2, ...)
     Escolhe para zero, em EXPR, todas as ocorrências de TENSOR_I que tiverem índices derivativos.

 -- Funcedilhaão: flushnd (EXPR, TENSOR, N)
     Escolhe para zero, em EXPR, todas as ocorrências do objeto diferenciado TENSOR que tem N ou mais índices derivativos como demonstra o seguinte exemplo.

          (%i1) load(itensor);
          (%o1)      /share/tensor/itensor.lisp
          (%i2) ishow(a([i],[J,r],k,r)+a([i],[j,r,s],k,r,s))$
                                          J r      j r s
          (%t2)                          a      + a
                                          i,k r    i,k r s
          (%i3) ishow(flushnd(%,a,3))$
                                               J r
          (%t3)                               a
                                               i,k r

 -- Funcedilhaão: coord (TENSOR_1, TENSOR_2, ...)

     Dados os TENSOR_I a propriedade de diferenciacedilhaão da coordenada que a derivada do vetor contravariante cujo nome é um dos TENSOR_I retorna um delta de Kronecker. Por exemplo, se coord(x) tiver sido concluída então idiff(x([],[i]),j) fornece kdelta([i],[j]). coord que é uma lista de todos os objetos indexados tendo essa propriedade.

 -- Funcedilhaão: remcoord (TENSOR_1, TENSOR_2, ...)
 -- Funcedilhaão: remcoord (all)

     Remove a propriedade de coordenada de diferenciacedilhaão dos tensor_i que foram estabelecidos através da funcedilhaão coord.  remcoord(all) remove essa propriedade de todos os objetos indexados.

 -- Funcedilhaão: makebox (EXPR)
     Mostra EXPR da mesma maneira que show; todavia, qualquer tensor d'Alembertiano ocorrendo em EXPR será indicado usando o símbolo [].  Por exemplo, []p([m],[n]) representa g([],[i,j])*p([m],[n],i,j).

 -- Funcedilhaão: conmetderiv (EXPR, TENSOR)

     Simplifica expressões contendo derivadas comuns de ambas as formas covariantes e contravariantes do tensor métrico (a restricedilhaão corrente).  Por exemplo, conmetderiv pode relatar a derivada do tensor contravariante métrico com símbolos de Christoffel como visto adiante:

          (%i1) load(itensor);
          (%o1)      /share/tensor/itensor.lisp
          (%i2) ishow(g([],[a,b],c))$
                                                a b
          (%t2)                                g
                                                ,c
          (%i3) ishow(conmetderiv(%,g))$
                                   %1 b      a       %1 a      b
          (%t3)                 - g     ichr2     - g     ichr2
                                             %1 c              %1 c

 -- Funcedilhaão: simpmetderiv (EXPR)
 -- Funcedilhaão: simpmetderiv (EXPR[, STOP])

     Simplifica expressões contendo produtos de derivadas de tensores métricos. Especificamente, simpmetderiv reconhece duas identidades:

             ab        ab           ab                 a
            g   g   + g   g     = (g   g  )   = (kdelta )   = 0
             ,d  bc        bc,d         bc ,d          c ,d

     conseqüêntemente

             ab          ab
            g   g   = - g   g
             ,d  bc          bc,d

     e

            ab          ab
           g   g     = g   g
            ,j  ab,i    ,i  ab,j

     que seguem de simetrias de símbolos de Christoffel.

     A funcedilhaão simpmetderiv toma um parâmetro opcional que, quando presente, faz com que a funcedilhaão pare após a primeira substituicedilhaão feita com sucesso em uma expressão produto. A funcedilhaão simpmetderiv também faz uso da variável global FLIPFLAG que determina como aplicar uma ordenacedilhaão ``canonica'' para os índices de produto.

     Colocados juntos, essas compatibilidades podem ser usadas poderosamente para encontrar simplificacedilhaões que são difíceis ou impossíveis de realizar de outra forma. Isso é demonstrado através do seguinte exemplo que explicitamente usa o recurso de simplificacedilhaão parcial de simpmetderiv para obter uma expressão contractível:

          (%i1) load(itensor);
          (%o1)      /share/tensor/itensor.lisp
          (%i2) imetric(g);
          (%o2)                                done
          (%i3) ishow(g([],[a,b])*g([],[b,c])*g([a,b],[],d)*g([b,c],[],e))$
                                       a b  b c
          (%t3)                       g    g    g      g
                                                 a b,d  b c,e
          (%i4) ishow(canform(%))$

          errexp1 has improper indices
           -- an error.  Quitting.  To debug this try debugmode(true);
          (%i5) ishow(simpmetderiv(%))$
                                       a b  b c
          (%t5)                       g    g    g      g
                                                 a b,d  b c,e
          (%i6) flipflag:not flipflag;
          (%o6)                                true
          (%i7) ishow(simpmetderiv(%th(2)))$
                                         a b  b c
          (%t7)                         g    g    g    g
                                         ,d   ,e   a b  b c
          (%i8) flipflag:not flipflag;
          (%o8)                                false
          (%i9) ishow(simpmetderiv(%th(2),stop))$
                                         a b  b c
          (%t9)                       - g    g    g      g
                                              ,e   a b,d  b c
          (%i10) ishow(contract(%))$
                                              b c
          (%t10)                           - g    g
                                              ,e   c b,d

     Veja também weyl.dem para um exemplo que usa simpmetderiv e conmetderiv juntos para simplificar contracedilhaões do tensor de Weyl.

 -- Funcedilhaão: flush1deriv (EXPR, TENSOR)

     Escolhe para zero, em expr, todas as ocorrências de tensor que possuem exatamente um índice derivativo.

Tensores em espacedilhaos curvos
--------------------------------

 -- Funcedilhaão: imetric (G)
 -- Variável de sistema: imetric

     Especifica a métrica através de atribuicedilhaão à variável imetric:G adicionalmente, as propriedades de contracedilhaão da métrica G são escolhidas através da execucedilhaão dos comandos defcon(G),defcon(G,G,kdelta). A variável imetric (desassociada por padrão), é associada à métrica, atribuida pelo comando imetric(G).

 -- Funcedilhaão: idim (N)
     Escolhe as dimensões da métrica. Também inicializa as propriedades de antisimetria dos símbolos de Levi-Civita para as dimensões dadas.

 -- Funcedilhaão: ichr1 ([I, J, K])
     Retorna o símbolo de Christoffel de primeiro tipo via definicedilhaão

                 (g      + g      - g     )/2 .
                   ik,j     jk,i     ij,k

     Para avaliar os símbolos de Christoffel para uma métrica particular, à variável imetric deve ser atribuída um nome como no exemplo sob chr2.

 -- Funcedilhaão: ichr2 ([I, J], [K])
     Retorna o símbolo de Christoffel de segundo tipo definido pela relacedilhaão

                                 ks
             ichr2([i,j],[k]) = g    (g      + g      - g     )/2
                                       is,j     js,i     ij,s

 -- Funcedilhaão: icurvature ([I, J, K], [H])
     Retorna o tensor da curvatura de Riemann em termos de símbolos de Christoffel de segundo tipo (ichr2).  A seguinte notacedilhaão é usada:

                         h             h            h         %1         h
               icurvature     = - ichr2      - ichr2     ichr2    + ichr2
                         i j k         i k,j        %1 j      i k        i j,k
                                         h          %1
                                  + ichr2      ichr2
                                         %1 k       i j

 -- Funcedilhaão: covdiff (EXPR, V_1, V_2, ...)
     Retorna a derivada da covariante de EXPR com relacedilhaão às variáveis V_I em termos de símbolos de Christoffel de segundo tipo (ichr2).  Com o objetivo de avaliar esses, se pode usar ev(EXPR,ichr2).

          (%i1) load(itensor);
          (%o1)      /share/tensor/itensor.lisp
          (%i2) entertensor()$
          Enter tensor name: a;
          Enter a list of the índices covariantes: [i,j];
          Enter a list of the índices contravariantes: [k];
          Enter a list of the derivative indices: [];
                                                k
          (%t2)                                a
                                                i j
          (%i3) ishow(covdiff(%,s))$
                       k         %1     k         %1     k            k     %1
          (%t3)     - a     ichr2    - a     ichr2    + a      + ichr2     a
                       i %1      j s    %1 j      i s    i j,s        %1 s  i j
          (%i4) imetric:g;
          (%o4)            g
          (%i5) ishow(ev(%th(2),ichr2))$
            %1 %4  k
           g      a     (g       - g       + g  )
            i %1   s %4,j  j s,%4    j %4,s
          (%t5) - ------------------------------------------
                 2
              %1 %3  k
             g   a     (g       - g    + g     )
              %1 j   s %3,i    i s,%3    i %3,s
           - ------------------------------------------
                   2
              k %2  %1
             g     a    (g        - g    + g      )
             i j   s %2,%1    %1 s,%2    %1 %2,s   k
           + ------------------------------------------- + a
             2     i j,s
          (%i6)

 -- Funcedilhaão: lorentz_gauge (EXPR)
     Impõe a condicedilhaão de Lorentz através da substituicedilhaão de 0 para todos os objetos indexados em EXPR que possui um índice de derivada idêntico ao índice contravariante.

 -- Funcedilhaão: igeodesic_coords (EXPR, NOME)

     Faz com que símbolos de Christoffel não diferenciados e a primeira derivada do tensor métrico tendam para zero em EXPR. O NOME na funcedilhaão igeodesic_coords refere-se à métrica NOME (se isso aparecer em EXPR) enquando os coeficientes de coneccedilhaão devem ser chamados com os nomes ichr1 e/ou ichr2. O seguinte exemplo demonstra a verificacedilhaão da identidade cíclica satisfeita através do tensor da curvatura de Riemann usando a funcedilhaão igeodesic_coords.

          (%i1) load(itensor);
          (%o1)      /share/tensor/itensor.lisp
          (%i2) ishow(icurvature([r,s,t],[u]))$
                       u            u         %1         u            u         %1
          (%t2) - ichr2      - ichr2     ichr2    + ichr2      + ichr2     ichr2
                       r t,s        %1 s      r t        r s,t        %1 t      r s
          (%i3) ishow(igeodesic_coords(%,ichr2))$
                                           u            u
          (%t3)                       ichr2      - ichr2
                                           r s,t        r t,s
          (%i4) ishow(igeodesic_coords(icurvature([r,s,t],[u]),ichr2)+
                      igeodesic_coords(icurvature([s,t,r],[u]),ichr2)+
                      igeodesic_coords(icurvature([t,r,s],[u]),ichr2))$
                       u            u            u            u            u
          (%t4) - ichr2      + ichr2      + ichr2      - ichr2      - ichr2
                       t s,r        t r,s        s t,r        s r,t        r t,s

                                                                            u
                                                                     + ichr2
                                                                            r s,t
          (%i5) canform(%);
          (%o5)                                  0

Molduras móveis
---------------

Maxima atualmente tem a habilidade de executar cálculos usando molduras móveis. Essas podem ser molduras ortonormais (tetrads, vielbeins) ou uma moldura arbitrária.

Para usar molduras, você primeiro escolhe iframe_flag para true. Isso faz com que os símbolos de Christoffel, ichr1 e ichr2, sejam substituídos pelas molduras mais gerais de coeficientes de coneccedilhaão icc1 e icc2 em cálculos. Especialmente, o comportamento de covdiff e icurvature são alterados.

A moldura é definida através de dois tensores: o campo de moldura inversa (ifri), a base tetrad dual), e a métrica da moldura ifg. A métrica da moldura é a matriz identidade para molduras ortonormais, ou a métrica de Lorentz para molduras ortonormais no espacedilhao-tempo de Minkowski. O campo de moldura inversa define a base da moldura (vetores unitários). Propriedades de contracedilhaão são definidas para o campo de moldura e para a métrica da moldura.

Quando iframe_flag for true, muitas expressões itensor usam a métrica da moldura ifg em lugar da métrica definida através de imetric para o decremento e para o incremento de índices.

IMPORTANTE: Escolhendo a variável iframe_flag para true NÃO remove a definicedilhaão das propriedades de contracedilhaão de uma métrica definida através de uma chamada a defcon ou imetric. Se um campo de moldura for usado, ele é melhor para definir a métrica através de atribuicedilhaão desse nome para a variável imetric e NÃO invoque a funcedilhaão imetric.

Maxima usa esses dois tensores para definir os coeficientes de moldura (ifc1 e ifc2) cuja forma parte dos coeficientes de coneccedilhaão (icc1 e icc2), como demonstra o seguinte exemplo:

     (%i1) load(itensor);
     (%o1)      /share/tensor/itensor.lisp
     (%i2) iframe_flag:true;
     (%o2)                                true
     (%i3) ishow(covdiff(v([],[i]),j))$
                                    i        i     %1
     (%t3)                         v   + icc2     v
                                    ,j       %1 j
     (%i4) ishow(ev(%,icc2))$
                             %1      i           i        i
     (%t4)                  v   (ifc2     + ichr2    ) + v
                                     %1 j        %1 j     ,j
     (%i5) ishow(ev(%,ifc2))$
                 %1    i %2
                v   ifg     (ifb        - ifb        + ifb       )
                                j %2 %1      %2 %1 j      %1 j %2     i
     (%t5)      -------------------------------------------------- + v
                                        2                             ,j
     (%i6) ishow(ifb([a,b,c]))$
                            %5    %4
     (%t6)               ifr   ifr   (ifri        - ifri       )
                            a     b       c %4,%5       c %5,%4

Um método alternativo é usado para calcular o suporte da moldura (ifb) se o sinalizador iframe_bracket_form é escolhido para false:

     (%i8) block([iframe_bracket_form:false],ishow(ifb([a,b,c])))$
                            %7    %6        %6      %7
     (%t8)              (ifr   ifr     - ifr     ifr  ) ifri
                            a     b,%7      a,%7    b       c %6

 -- Funcedilhaão: iframes ()

     Uma vez que nessa versão do Maxima, identidades de contracedilhaão para ifr e ifri são sempre definidas, como é o suporte da moldura (ifb), essa funcedilhaão não faz nada.

 -- Variável: ifb

     O suporte da moldura. A contribuicedilhaão da métrica da moldura para os coeficientes de coneccedilhaão é expressa usando o suporte da moldura:

                    - ifb      + ifb      + ifb
                         c a b      b c a      a b c
          ifc1    = --------------------------------
              abc                  2

     O suporte da moldura por si mesmo é definido em termos de campo de moldura e métrica da moldura. Dois métodos alternativos de cálculo são usados dependendo do valor de frame_bracket_form. Se true (o padrão) ou se o sinalizador itorsion_flag for true:

                    d      e                                      f
          ifb =  ifr    ifr   (ifri      - ifri      - ifri    itr   )
             abc    b      c       a d,e       a e,d       a f    d e

     Otherwise:

                       e      d        d      e
          ifb    = (ifr    ifr    - ifr    ifr   ) ifri
             abc       b      c,e      b,e    c        a d

 -- Variável: icc1

     Coeficientes de coneccedilhaão de primeiro tipo. Em itensor, definido como

          icc1    = ichr1    - ikt1    - inmc1
              abc        abc       abc        abc

     Nessa expressão, se iframe_flag for true, o símbolo de Christoffel ichr1 é substituído com o coeficiente de coneccedilhaão da moldura ifc1. Se itorsion_flag for false, ikt1 será omitido. ikt1 é também omitido se uma base de moldura for usada, como a torsão está já calculada como parte do suporte da moldura. Ultimamente, como inonmet_flag é false, inmc1 não estará presente.

 -- Variável: icc2

     Coeficientes de coneccedilhaão de segundo tipo. Em itensor, definido como

              c         c        c         c
          icc2   = ichr2   - ikt2   - inmc2
              ab        ab       ab        ab

     Nessa expressão, se iframe_flag for true, o símbolo de Christoffel ichr2 é substituído com o coeficiente de coneccedilhaão ifc2. Se itorsion_flag for false, ikt2 será omitido. ikt2 também será omitido se uma base de moldura for usada, uma vez que a torsão já está calculada como parte do suporte da moldura. Ultimamente, como inonmet_flag é false, inmc2 não estará presente.

 -- Variável: ifc1

     Coeficiente de moldura de primeiro tipo (também conhecido como coeficientes de rotacedilhaão de Ricci).  Esse tensor representa a contribuicedilhaão da métrica da moldura para o coeficiente de coneccedilhaão de primeiro tipo. Definido como:

                    - ifb      + ifb      + ifb
                         c a b      b c a      a b c
          ifc1    = --------------------------------
              abc                   2

 -- Variável: ifc2

     Coeficiente de moldura de primeiro tipo. Esse tensor representa a contribuicedilhaão da métrica da moldura para o coeficiente de coneccedilhaão de primeiro tipo. Definido como uma permutacedilhaão de suporte de moldura (ifb) com os índices apropriados incrementados e decrementados como necessário:

              c       cd
          ifc2   = ifg   ifc1
              ab             abd

 -- Variável: ifr

     O campo da moldura. Contrai (ifri) para e com a forma do campo inverso da moldura para formar a métrica da moldura (ifg).

 -- Variável: ifri

     O campo inverso da moldura. Especifica a base da moldura (vetores base duais). Juntamente com a métrica da moldura, forma a base de todos os cálculos baseados em molduras.

 -- Variável: ifg

     A métrica da moldura. O valor padrão é kdelta, mas pode ser mudada usando components.

 -- Variável: ifgi

     O inverso da métrica da moldura. Contrai com a métrica da moldura (ifg) para kdelta.

 -- Variável de Opcedilhaão: iframe_bracket_form
     Valor padrão: true

     Especifica como o suporte da moldura (ifb) é calculado.

Torsão e não metricidade
------------------------

Maxima pode trabalhar com torsão e não metricidade. Quando o sinalizador itorsion_flag for escolhido para true, a contribuicedilhaão de torsão é adicionada aos coeficientes de coneccedilhaão. Similarmente, quando o sinalizador inonmet_flag for true, componentes de não metricidades são incluídos.

 -- Variável: inm

     O vetor de não metricidade. Conforme a não metricidade está definida através da derivada covariante do tensor métrico. Normalmente zero, o tensor da métrica derivada covariante irá avaliar para o seguinte quando inonmet_flag for escolhido para true:

          g     =- g  inm
           ij;k     ij  k

 -- Variável: inmc1

     Permutacedilhaão covariante de componentes do vetor de não metricidade. Definida como

                     g   inm  - inm  g   - g   inm
                      ab    c      a  bc    ac    b
          inmc1    = ------------------------------
               abc                 2

     (Substitue ifg em lugar de g se uma moldura métrica for usada.)

 -- Variável: inmc2

     Permutacedilhaão covariante de componentes do vetor de não metricidade. Usada nos coeficicientes de coneccedilhaão se inonmet_flag for true. Definida como:

                                c         c         cd
                    -inm  kdelta  - kdelta  inm  + g   inm  g
               c        a       b         a    b          d  ab
          inmc2   = -------------------------------------------
               ab                        2

     (Substitue ifg em lugar de g se uma moldura métrica for usada.)

 -- Variável: ikt1

     Permutacedilhaão covariante do tensor de torsão (também conhecido como contorsão). Definido como:

                            d           d       d
                    -g   itr  - g    itr   - itr   g
                      ad    cb    bd    ca      ab  cd
          ikt1    = ----------------------------------
              abc                   2

     (Substitue ifg em lugar de g se uma moldura métrica for usada.)

 -- Variável: ikt2

     Permutacedilhaão contravariante do tensor de torsão (também conhecida como contorsão). Definida como:

              c     cd
          ikt2   = g   ikt1
              ab           abd

     (Substitue ifg em lugar de g se uma moldura métrica for usada.)

 -- Variável: itr

     O tensor de torsão. Para uma métrica com torsão, diferenciacedilhaão covariante repetida sobre uma funcedilhaào escalar não irá comutar,como demonstrado através do seguinte exemplo:

          (%i1) load(itensor);
          (%o1)      /share/tensor/itensor.lisp
          (%i2) imetric:g;
          (%o2)                                  g
          (%i3) covdiff(covdiff(f([],[]),i),j)-covdiff(covdiff(f([],[]),j),i)$
          (%i4) ishow(%)$
                                             %4              %2
          (%t4)                    f    ichr2    - f    ichr2
                                    ,%4      j i    ,%2      i j
          (%i5) canform(%);
          (%o5)                                  0
          (%i6) itorsion_flag:true;
          (%o6)                                true
          (%i7) covdiff(covdiff(f([],[]),i),j)-covdiff(covdiff(f([],[]),j),i)$
          (%i8) ishow(%)$
                                     %8             %6
          (%t8)             f    icc2    - f    icc2    - f     + f
                             ,%8     j i    ,%6     i j    ,j i    ,i j
          (%i9) ishow(canform(%))$
                                             %1             %1
          (%t9)                     f    icc2    - f    icc2
                                     ,%1     j i    ,%1     i j
          (%i10) ishow(canform(ev(%,icc2)))$
                                             %1             %1
          (%t10)                    f    ikt2    - f    ikt2
                                     ,%1     i j    ,%1     j i
          (%i11) ishow(canform(ev(%,ikt2)))$
                                %2 %1                    %2 %1
          (%t11)          f    g      ikt1       - f    g      ikt1
                           ,%2            i j %1    ,%2            j i %1
          (%i12) ishow(factor(canform(rename(expand(ev(%,ikt1))))))$
                                     %3 %2            %1       %1
                               f    g      g      (itr    - itr   )
                                ,%3         %2 %1     j i      i j
          (%t12)               ------------------------------------
                                                2
          (%i13) decsym(itr,2,1,[anti(all)],[]);
          (%o13)                               done
          (%i14) defcon(g,g,kdelta);
          (%o14)                               done
          (%i15) subst(g,nounify(g),%th(3))$
          (%i16) ishow(canform(contract(%)))$
                                                     %1
          (%t16)                           - f    itr
                                              ,%1    i j

Álgebra externa (como em produto externo)
-----------------------------------------

O pacote itensor pode executar operacedilhaões sobre campos tensores covariantes totalmente antisimétricos. Um campo tensor totalmente antisimétrico de classe (0,L) corresponde a uma forma diferencial L. Sobre esses objetos, uma operacedilhaão de multiplicacedilhaão funciona como um produto externo, ou produto cunha, é definido.

Desafortunadamente, nem todos os autores concordam sobre a definicedilhaão de produto cunha. Alguns autores preferem uma definicedilhaão que corresponde à nocedilhaão de antisimetrizacedilhaão: nessas palavras, o produto cunha de dois campos vetoriais, por exemplo, pode ser definido como

                 a a  - a a
                  i j    j i
      a  /\ a  = -----------
       i     j        2

Mais geralmente, o produto de uma forma p e uma forma q pode ser definido como

                            1     k1..kp l1..lq
     A       /\ B       = ------ D              A       B
      i1..ip     j1..jq   (p+q)!  i1..ip j1..jq  k1..kp  l1..lq

onde D simboliza o delta de Kronecker.

Outros autores, todavia, preferem uma definicedilhaão ``geométrica'' que corresponde à notacedilhaão de elemento volume:

     a  /\ a  = a a  - a a
      i     j    i j    j i

e, no caso geral

                            1    k1..kp l1..lq
     A       /\ B       = ----- D              A       B
      i1..ip     j1..jq   p! q!  i1..ip j1..jq  k1..kp  l1..lq

Uma vez que itensor é um pacote de algebra de tensores, a primeira dessas duas definicedilhaões aparenta ser a mais natural por si mesma. Muitas aplicacedilhaões, todavia, usam a segunda definicedilhaão. Para resolver esse dilema, um sinalizador tem sido implementado que controla o comportamento do produto cunha: se igeowedge_flag for false (o padrão), a primeira, definicedilhaão "tensorial" é usada, de outra forma a segunda, definicedilhaão "geométrica" irá ser aplicada.

 -- Operador: ~
     O operador do produto cunha é definido como sendo o acento til ~. O til é um operador binário. Seus argumentos podem ser expressões envolvendo escalares, tensores covariantes de categoria 1, ou tensores covariantes de categoria l que tiverem sido declarados antisimétricos em todos os índices covariantes.

     O comportamento do operador do produto cunha é controlado através do sinalizador igeowedge_flag, como no seguinte exemplo:

          (%i1) load(itensor);
          (%o1)      /share/tensor/itensor.lisp
          (%i2) ishow(a([i])~b([j]))$
                                           a  b  - b  a
                                            i  j    i  j
          (%t2)                            -------------
                                                 2
          (%i3) decsym(a,2,0,[anti(all)],[]);
          (%o3)                                done
          (%i4) ishow(a([i,j])~b([k]))$
                                    a    b  + b  a    - a    b
                                     i j  k    i  j k    i k  j
          (%t4)                     ---------------------------
                                                 3
          (%i5) igeowedge_flag:true;
          (%o5)                                true
          (%i6) ishow(a([i])~b([j]))$
          (%t6)                            a  b  - b  a
                                            i  j    i  j
          (%i7) ishow(a([i,j])~b([k]))$
          (%t7)                     a    b  + b  a    - a    b
                                     i j  k    i  j k    i k  j

 -- Operador: |
     A barra vertical | denota a operacedilhaão binária "contracedilhaão com um vetor". Quando um tensor covariante totalmente antisimétrico é contraído com um vetor contravariante, o resultado é o mesmo independente de qual índice foi usado para a contracedilhaão. Dessa forma, é possível definir a operacedilhaão de contracedilhaão de uma forma livre de índices.

     No pacote itensor, contracedilhaão com um vetor é sempre realizada com relacedilhaão ao primeiro índice na ordem literal de ordenacedilhaão. Isso garante uma melhor simplificacedilhaão de expressões envolvendo o operador |. Por exemplo:

          (%i1) load(itensor);
          (%o1)      /share/tensor/itensor.lisp
          (%i2) decsym(a,2,0,[anti(all)],[]);
          (%o2)                                done
          (%i3) ishow(a([i,j],[])|v)$
                                              %1
          (%t3)                              v   a
                                                  %1 j
          (%i4) ishow(a([j,i],[])|v)$
                                               %1
          (%t4)                             - v   a
                                                   %1 j

     Note que isso é essencial que os tensores usado como o operador | seja declarado totalmente antisimétrico em seus índices covariantes. De outra forma, os resultados serão incorretos.

 -- Funcedilhaão: extdiff (EXPR, I)

     Calcula a derivada externa de EXPR com relacedilhaão ao índice I. A derivada externa é formalmente definida como o produto cunha do operador de derivada parcial e uma forma diferencial. Como tal, essa operacedilhaão é também controlada através da escolha de igeowedge_flag. Por exemplo:

          (%i1) load(itensor);
          (%o1)      /share/tensor/itensor.lisp
          (%i2) ishow(extdiff(v([i]),j))$
                                            v    - v
                                             j,i    i,j
          (%t2)                             -----------
                                                 2
          (%i3) decsym(a,2,0,[anti(all)],[]);
          (%o3)                                done
          (%i4) ishow(extdiff(a([i,j]),k))$
                                     a      - a      + a
                                      j k,i    i k,j    i j,k
          (%t4)                      ------------------------
                                                3
          (%i5) igeowedge_flag:true;
          (%o5)                                true
          (%i6) ishow(extdiff(v([i]),j))$
          (%t6)                             v    - v
                                             j,i    i,j
          (%i7) ishow(extdiff(a([i,j]),k))$
          (%t7)                      a      - a      + a
                                      j k,i    i k,j    i j,k

 -- Funcedilhaão: hodge (EXPR)

     Calcula o Hodge dual de EXPR. Por exemplo:

          (%i1) load(itensor);
          (%o1)      /share/tensor/itensor.lisp
          (%i2) imetric(g);
          (%o2)                            done
          (%i3) idim(4);
          (%o3)                            done
          (%i4) icounter:100;
          (%o4)                             100
          (%i5) decsym(A,3,0,[anti(all)],[])$

          (%i6) ishow(A([i,j,k],[]))$
          (%t6)                           A
                                           i j k
          (%i7) ishow(canform(hodge(%)))$
                                    %1 %2 %3 %4
                         levi_civita            g        A
                                                 %1 %102  %2 %3 %4
          (%t7)          -----------------------------------------
                                             6
          (%i8) ishow(canform(hodge(%)))$
                           %1 %2 %3 %8            %4 %5 %6 %7
          (%t8) levi_civita            levi_civita            g        g
                                                               %1 %106  %2 %107
                                                      g        g      A        /6
                                                       %3 %108  %4 %8  %5 %6 %7
          (%i9) lc2kdt(%)$

          (%i10) %,kdelta$

          (%i11) ishow(canform(contract(expand(%))))$
          (%t11)                     - A
                                        %106 %107 %108

 -- Variável de Opcedilhaão: igeowedge_flag
     Valor padrão: false

     Controla o comportamento de produto cunha e derivada externa. Quando for esconhida para false (o padrão), a nocedilhaão de formas diferenciais irá corresponder àquela de um campo tensor covariante totalmente antisimétrico. Quando escolhida para true, formas diferenciais irão concordar com a nocedilhaão do elemento volume.

Exportando expressões TeX
-------------------------

O pacote itensor fornece suporte limitado à exportacedilhaão de expressões de tensores para o TeX.  Uma vez que expressões itensor aparecem como chamada a funcedilhaões, o comando regular tex do Maxima não produzirá a saída esperada. Você pode tentar em seu lugar o comando tentex, o qual tenta traduzir expressões de tensores dentro de objetos TeX indexados apropriadamente.

 -- Funcedilhaão: tentex (EXPR)

     Para usar a funcedilhaão tentex, você deve primeiro chamar tentex, como no seguinte exemplo:

          (%i1) load(itensor);
          (%o1)      /share/tensor/itensor.lisp
          (%i2) load(tentex);
          (%o2)       /share/tensor/tentex.lisp
          (%i3) idummyx:m;
          (%o3)                                  m
          (%i4) ishow(icurvature([j,k,l],[i]))$
                      m1       i           m1       i           i            i
          (%t4)  ichr2    ichr2     - ichr2    ichr2     - ichr2      + ichr2
                      j k      m1 l        j l      m1 k        j l,k        j k,l
          (%i5) tentex(%)$
          $$\Gamma_{j\,k}^{m_1}\,\Gamma_{l\,m_1}^{i}-\Gamma_{j\,l}^{m_1}\,
           \Gamma_{k\,m_1}^{i}-\Gamma_{j\,l,k}^{i}+\Gamma_{j\,k,l}^{i}$$

     Note o uso da declaracedilhaão idummyx, para evitar o aparecimento do sinal de porcentagem na expressão TeX, o qual pode induzir a erros de compilacedilhaão.

     Note Bem: Essa vesão da funcedilhaão tentex é um tanto quanto experimental.

Interagindo com o pacote ctensor
--------------------------------

O pacote itensor possui a habilidade de gerar código Maxima que pode então ser executado no contexto do pacote ctensor. A funcedilhaão que executa essa tarefa é ic_convert.

 -- Funcedilhaão: ic_convert (EQN)

     Converte a equacedilhaão EQN na sintaxe itensor para uma declaracedilhaão de atribuicedilhaão ctensor. Adicedilhaões implícitas sobre índices que ocorrem exatamente duas vezes são tornadas explícitas enquanto objetos indexados são transformados em arrays (os arrays subscritos estão na ordem de covariância seguidos de índices contravariantes dos objetos indexados). A derivada de um objeto indexado será substituída pela forma substantiva de diff tomada com relacedilhaão a ct_coords subscrita pelo índice de derivacedilhaão. Os símbolos de Christoffel ichr1 e ichr2 irão ser traduzidos para lcs e mcs, respectivamente e se metricconvert for true então todas as ocorrências da métrica com dois índices covariantes (ou contravariantes) irão ser renomeadas para lg (ou ug). Adicionalmente, ciclos do irão ser introduzidos adicionando sobre todos os índices livres de forma que a declaracedilhaão de atribuicedilhaão transformada pode ser avaliada através de apenas fazendo ev. Os seguintes exemplos demonstam os recursos dessa funcedilhaão.

          (%i1) load(itensor);
          (%o1)      /share/tensor/itensor.lisp
          (%i2) eqn:ishow(t([i,j],[k])=f([],[])*g([l,m],[])*a([],[m],j)*b([i],[l,k]))$
                                       k        m   l k
          (%t2)                       t    = f a   b    g
                                       i j      ,j  i    l m
          (%i3) ic_convert(eqn);
          (%o3) for i thru dim do (for j thru dim

          do (for k thru dim do t        : f sum(sum(diff(a , ct_coords ) b
                                 i, j, k                   m           j   i, l, k

           g    , l, 1, dim), m, 1, dim)))
            l, m
          (%i4) imetric(g);
          (%o4)                                done
          (%i5) metricconvert:true;
          (%o5)                                true
          (%i6) ic_convert(eqn);
          (%o6) for i thru dim do (for j thru dim

          do (for k thru dim do t        : f sum(sum(diff(a , ct_coords ) b
                                 i, j, k                   m           j   i, l, k

           lg    , l, 1, dim), m, 1, dim)))
             l, m

Palavras reservadas
-------------------

As palavras seguintes do Maxima são usadas internamente pelo pacote itensor e não podem ser redefinidas:

       Keyword    Comments
       ------------------------------------------
       indices2() versão interna de indices()
       conti      Lista de índices contravariantes
       covi       Lista de índices covariantes de um objeto indexado
       deri       Lista de índices de derivada de um objeto indexado
       name       Retorna o nome de um objeto indexado
       concan
       irpmon
       lc0
       _lc2kdt0
       _lcprod
       _extlc