Funções e Variáveis Definidas para itensor (Manual do Maxima)

Previous: Introdução a itensor, Up: itensor [Contents][Index]

### 27.2 Funções e Variáveis Definidas para itensor

#### 27.2.1 Gerenciando objetos indexados

Função: entertensor (nome)

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

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

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

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

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

Função: rename (expr)
Funçã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 começando no valor de contador. Cada índice que ocorre exatamente duas vezes em um produto será diferente. Para uma adição, `rename` irá operar sobre cada termo na a adiçã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 relaçã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 renomeaçã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 Opçã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 ordenação ocorre após a ocorrência do `rename` (veja o exemplo sob `rename`).

Função: defcon (tensor_1)
Função: defcon (tensor_1, tensor_2, tensor_3)

  Dado tensor_1 a propriedade que a contraçã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 contraçã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 contrações executadas. Por exemplo, se `imetric:g`, então `defcon(g)` irá implementar o incremento e decremento de índices através da contraçã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 contração particular será usado. `contractions` é uma lista de objetos indexados que tenham fornecido propriedades de contrações com `defcon`.

Função: remcon (tensor_1, ..., tensor_n)
Função: remcon (all)

  Remove todas as propriedades de contração de tensor_1, ..., tensor_n). `remcon(all)` remove todas as propriedades de contração de todos os objetos indexados.

Função: contract (expr)

  Realiza contrações tensoriais em expr a qual pode ser qualquer combinação de adições e produtos. Essa função usa a informação dada para a função `defcon`. Para melhores resultados, `expr` pode ser completamente expandida. `ratexpand` é o meio mais rápido para expandir produtos e expoentes de adiçõ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.

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

Funçã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 geração de índices que ocorrem exatamente duas vezes e que são multiplos. a remoção dessas atribuições é dada para a função `remcomps`.

  É importante ter em mente que `components` cuida somente da valência de um tensor, e que ignora completamente qualquer ordenação particular de índices. Dessa forma atribuindo componentes a, digamos, `x([i,-j],[])`, `x([-j,i],[])`, ou `x([i],[j])` todas essas atribuiçõ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 função. Você pode usar uma funçã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 condiçõ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

Função: remcomps (tensor)

  Desassocia todos os valores de tensor que foram atribuídos com a função `components`.

Função: showcomps (tensor)

  Mostra atribuições de componentes de um tensor, feitas usando o comando `components`. Essa funçã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.

Funçã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 formação de expressões não irão conflitar com índices que já estiverem sendo usados (veja o exemplo sob `indices`).

Variável de opção: idummyx

  Valor padrão: `%`

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

Variável de Opção: icounter

  Valor padrão: `1`

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

Função: kdelta (L1, L2)

  é a funçã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 avaliação de uma expressão contendo `kdelta([],[])` se dê para a dimensão de multiplicação.

  No que conduzir a um abuso dessa notaçã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 programação e não significa implicar que `kdelta([i,j],[])` seja um objeto tensorial válido.

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

Função: levi_civita (L)

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

Funçã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 diferença entre essa função e simplesmente avaliar os simbolos de Levi-Civita é que a avaliação direta muitas vezes resulta em expressões Kronecker contendo índices numéricos. Isso é muitas vezes indesejável como na prevenção de simplificação adicional. A funçã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 funçã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

Função: lc_l

  Regra de simplificaçã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 avaliaçã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

Função: lc_u

  Regra de simplificaçã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 avaliação de `levi_civita`. Para detalhes, veja `lc_l`.

Função: canten (expr)

  Simplifica expr por renomeação (veja `rename`) e permutando índices que ocorrem exatamente duas vezes. `rename` é restrito a adiçõ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 simplificação requerida.

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

Função: concan (expr)

  Similar a `canten` mas também executa contração de índices.

#### 27.2.2 Simetrias de tensores

Variável de Opçã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`.

Funçã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 pseudofunções expressando relaçõ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 posiçã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 à condiçã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 declarações de simetria pode ser nula. A função que executa as simplificaçõ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]], []]]

Função: remsym (tensor, m, n)

  Remove todas as propriedades de simetria de tensor que tem m índices covariantes e n índices contravariantes.

Função: canform (expr)

  Simplifica expr através de mudança de nome de índices que ocorrem exatamente duas vezes e reordenação de todos os índices como ditados pelas condições de simetria impostas sobre eles. Se `allsym` for `true` então todos os índices são assumidos simétricos, de outra forma a informação de simetria fornecida pelas declarações `decsym` irão ser usadas. Os índices que ocorrem exatamente duas vezes são renomeados da mesma maneira que na funçã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.

#### 27.2.3 Cálculo de tensores indiciais

Função: diff (expr, v_1, [n_1, [v_2, n_2] ...])

  É a função usual de diferenciação do Maxima que tem sido expandida nessas habilidades para `itensor`. `diff` toma a derivada de expr n_1 vezes com relação a v_1, n_2 vezes com relação a v_2 , etc. Para o pacote `tensor`, a funçã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 diferenciação com relaçã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 diferenciação. Isso permite que um array de nomes de coordenadas ou nomes subscritos como `x[1]`, `x[2]`, ... sejam usados.

Função: idiff (expr, v_1, [n_1, [v_2, n_2] ...])

  Diferenciação indicial. A menos que `diff`, que diferencia com relação a uma variável independente, `idiff` possa ser usada para diferenciar com relaçã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.

Função: liediff (v, ten)

  Calcula a derivada de Lie da expressão tensorial ten com relaçã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

Função: rediff (ten)

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

Função: undiff (expr)

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

Função: evundiff (expr)

  Equivalente à execução de `undiff`, seguida por `ev` e `rediff`.

  O ponto dessa operaçã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

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

Função: flushd (expr, tensor_1, tensor_2, ...)

  Escolhe para zero, em expr, todas as ocorrências de tensor_i que tiverem índices derivativos.

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

Função: coord (tensor_1, tensor_2, ...)

  Dados os tensor_i a propriedade de diferenciaçã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.

Função: remcoord (tensor_1, tensor_2, ...)
Função: remcoord (all)

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

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

Função: conmetderiv (expr, tensor)

  Simplifica expressões contendo derivadas comuns de ambas as formas covariantes e contravariantes do tensor métrico (a restriçã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

Função: simpmetderiv (expr)
Funçã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 função `simpmetderiv` toma um parâmetro opcional que, quando presente, faz com que a função pare após a primeira substituição feita com sucesso em uma expressão produto. A função `simpmetderiv` também faz uso da variável global flipflag que determina como aplicar uma ordenação “canonica” para os índices de produto.

  Colocados juntos, essas compatibilidades podem ser usadas poderosamente para encontrar simplificaçõ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 simplificaçã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 contrações do tensor de Weyl.

Função: flush1deriv (expr, tensor)

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

#### 27.2.4 Tensores em espaços curvos

Função: imetric (g)
Variável de sistema: imetric

  Especifica a métrica através de atribuição à variável `imetric:g` adicionalmente, as propriedades de contração da métrica g são escolhidas através da execuçã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)`.

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

Função: ichr1 ([i, j, k])

  Retorna o símbolo de Christoffel de primeiro tipo via definiçã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`.

Função: ichr2 ([i, j], [k])

  Retorna o símbolo de Christoffel de segundo tipo definido pela relação

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

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

Função: covdiff (expr, v_1, v_2, ...)

  Retorna a derivada da covariante de expr com relaçã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)

Função: lorentz_gauge (expr)

  Impõe a condição de Lorentz através da substituição de 0 para todos os objetos indexados em expr que possui um índice de derivada idêntico ao índice contravariante.

Funçã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 função `igeodesic_coords` refere-se à métrica nome (se isso aparecer em expr) enquando os coeficientes de conecção devem ser chamados com os nomes `ichr1` e/ou `ichr2`. O seguinte exemplo demonstra a verificação da identidade cíclica satisfeita através do tensor da curvatura de Riemann usando a funçã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

#### 27.2.5 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 conecçã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 espaço-tempo de Minkowski. O campo de moldura inversa define a base da moldura (vetores unitários). Propriedades de contraçã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 definição das propriedades de contraçã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 atribuição desse nome para a variável `imetric` e NÃO invoque a função `imetric`.

Maxima usa esses dois tensores para definir os coeficientes de moldura (`ifc1` e `ifc2`) cuja forma parte dos coeficientes de conecçã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

Função: iframes ()

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

Variável: ifb

  O suporte da moldura. A contribuição da métrica da moldura para os coeficientes de conecçã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 conecçã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 conecçã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 conecçã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 conecçã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 rotação de Ricci). Esse tensor representa a contribuição da métrica da moldura para o coeficiente de conecçã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 contribuição da métrica da moldura para o coeficiente de conecção de primeiro tipo. Definido como uma permutaçã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 Opção: iframe_bracket_form

  Valor padrão: `true`

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

#### 27.2.6 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 contribuição de torsão é adicionada aos coeficientes de conecçã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

  Permutaçã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

  Permutação covariante de componentes do vetor de não metricidade. Usada nos coeficicientes de conecçã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

  Permutaçã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

  Permutaçã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, diferenciação covariante repetida sobre uma funçà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

#### 27.2.7 Álgebra externa (como em produto externo)

O pacote `itensor` pode executar operaçõ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 operação de multiplicação funciona como um produto externo, ou produto cunha, é definido.

Desafortunadamente, nem todos os autores concordam sobre a definição de produto cunha. Alguns autores preferem uma definição que corresponde à noção de antisimetrizaçã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 definição “geométrica” que corresponde à notaçã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 definições aparenta ser a mais natural por si mesma. Muitas aplicações, todavia, usam a segunda definiçã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, definição "tensorial" é usada, de outra forma a segunda, definiçã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 operação binária "contraçã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 contração. Dessa forma, é possível definir a operação de contração de uma forma livre de índices.

  No pacote `itensor`, contração com um vetor é sempre realizada com relação ao primeiro índice na ordem literal de ordenação. Isso garante uma melhor simplificaçã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.

Função: extdiff (expr, i)

  Calcula a derivada externa de expr com relaçã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 operaçã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

Funçã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 Opçã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 noçã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 noção do elemento volume.

#### 27.2.8 Exportando expressões TeX

O pacote `itensor` fornece suporte limitado à exportação de expressões de tensores para o TeX. Uma vez que expressões `itensor` aparecem como chamada a funçõ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.

Função: tentex (expr)

  Para usar a funçã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 declaração `idummyx`, para evitar o aparecimento do sinal de porcentagem na expressão TeX, o qual pode induzir a erros de compilação.

  Note Bem: Essa vesão da função `tentex` é um tanto quanto experimental.

#### 27.2.9 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 função que executa essa tarefa é `ic_convert`.

Função: ic_convert (eqn)

  Converte a equação eqn na sintaxe `itensor` para uma declaração de atribuição `ctensor`. Adiçõ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 relação a `ct_coords` subscrita pelo índice de derivaçã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 declaração de atribuição transformada pode ser avaliada através de apenas fazendo `ev`. Os seguintes exemplos demonstam os recursos dessa funçã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

#### 27.2.10 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

Previous: Introdução a itensor, Up: itensor [Contents][Index]