| blob | 94fa8c06d43373a12ea8ff2288ff0f6d3f2665a9 |
1 @c /Itensor.texi/1.40/Sat Nov 4 16:15:55 2006//
2 @c RECOMMEND REVISE TEXT THROUGHOUT TO LOSE NOTION OF TIME RELATIVE TO PRESENT
3 @c LOOK FOR "NOW", "OLD", "NEW", "RECENT", "EARLIER", DATES
5 @c RERUN EXAMPLES WITH ADDT'L WHITESPACE IN INPUT TO AID LEGIBILITY
7 @menu
8 * Introdução a itensor::
9 * Definições para itensor::
10 @end menu
12 @node Introdução a itensor, Definições para itensor, itensor, itensor
13 @section Introdução a itensor
15 Maxima implementa a manipulação de tensores simbólicos d dois tipos distintos:
16 manipulação de componentes de tensores (pacote @code{ctensor}) e manipulação de tensores indiciais (pacote @code{itensor}).
18 Note bem: Por favor veja a nota sobre 'nova notação de tensor' abaixo.
20 Manipulação de componentes de tensores significa que objectos do tipo
21 tensor geométrico são representados como arrays ou matrizes. Operações com tensores tais com
22 contração ou diferenciação covariante são realizadas
23 sobre índices (que ocorrem exactamente duas vezes) repetidos com declarações @code{do}.
24 Isto é, se executa explicitamente operações sobre as componentes apropriadas do
25 tensor armazenadas em um array ou uma matriz.
27 Manipulação tensorial de índice é implementada através da representação
28 de tensores como funções e suas covariantes, contravariantes e índices de
29 derivação. Operações com tensores como contração ou diferenciação
30 covariante são executadas através de manipulação dos índices em si mesmos
31 em lugar das componentes para as quais eles correspondem.
33 Esses dois métodos aproximam-se do tratamento de processos diferenciais, algébricos e
34 analíticos no contexto da geometria de Riemannian possuem várias
35 vantagens e desvantagens as quais se revelam por si mesmas somente apesar da
36 natureza particular e dificuldade dos problemas de utilizador. Todavia, se
37 pode ter em mente as seguintes características das duas
38 implementações:
40 As representações de tensores e de operações com tensores explicitamente em
41 termos de seus componntes tornam o pacote @code{ctensor} fácil de usar. Especificação da
42 métrica e o cálculo de tensores induzidos e invariantes
43 é directo. Embora todas a capacidade de simplificação poderosa do
44 Maxima está em manusear, uma métrica complexa com intrincada dependência funcional
45 e de coordenadas pode facilmente conduzir a expressões cujo tamanho é
46 excessivo e cuja estrutura está escondida. Adicionalmente, muitos cálculos
47 envolvem expressões intermédias cujo crescimento fazem com que os programas
48 terminem antes de serem completados. Através da experiência, um utilizador pode evitar
49 muitas dessas dificuldade.
51 O motivo de caminhos especiais através dos quais tensores e operações de tensores
52 são representados em termos de operações simbólicas sobre seus índices,
53 expressões cujas representação de componentes podem ser
54 não gerenciaveis da forma comum podem algumas vezes serem grandemente simplificadas através do uso das rotinas
55 especiais para objectos simétricos em @code{itensor}. Nesse caminho a estrutura
56 de uma expressão grande pode ser mais transparente. Por outro lado, o motivo
57 da representação indicial especial em @code{itensor}, faz com que em alguns casos o
58 utilizador possa encontrar dificuldade com a especificação da métrica, definição
59 de função, e a avaliação de objectos "indexados" diferenciados.
61 @subsection Nova notação d tensores
63 Até agora, o pacote @code{itensor} no Maxima tinha usado uma notação que algumas vezes
64 conduzia a ordenação incorrecta de índices. Considere o seguinte, por exemplo:
66 @example
67 (%i2) imetric(g);
68 (%o2) done
69 (%i3) ishow(g([],[j,k])*g([],[i,l])*a([i,j],[]))$
70 i l j k
71 (%t3) g g a
72 i j
73 (%i4) ishow(contract(%))$
74 k l
75 (%t4) a
76 @end example
78 O resultado está incorrecto a menos que ocorra ser @code{a} um tensor simétrico.
79 A razão para isso é que embora @code{itensor} mantenha correctamente
80 a ordem dentro do conjunto de índices covariantes e contravariantes, assim que um
81 índice é incrementado ou decrementado, sua posição relativa para o outro conjunto de
82 índices é perdida.
84 Para evitar esse problema, uma nova notação tem sido desenvolvida que mantém total
85 compatibilidade com a notação existente e pode ser usada intercambiavelmente. Nessa
86 notação, índices contravariantes são inseridos na posição
87 apropriada na lista de índices covariantes, mas com um sinal de menos colocado antes.
88 Funções como @code{contract} e @code{ishow} estão agora consciente dessa
89 nova notação de índice e podem processar tensores apropriadamente.
91 Nessa nova notação, o exemplo anterior retorna um resultado correcto:
93 @example
94 (%i5) ishow(g([-j,-k],[])*g([-i,-l],[])*a([i,j],[]))$
95 i l j k
96 (%t5) g a g
97 i j
98 (%i6) ishow(contract(%))$
99 l k
100 (%t6) a
101 @end example
103 Presentemente, o único código que faz uso dessa notação é a função
104 @code{lc2kdt}. Através dessa notação, a função @code{lc2kdt} encontra com êxito resultados consistentes como
105 a aplicação do tensor métrico para resolver os símbolos de Levi-Civita sem reordenar
106 para índices numéricos.
108 Uma vez que esse código é um tipo novo, provavelmente contém erros. Enquanto esse tipo novo não tiver sido
109 testado para garantir que ele não interrompe nada usando a "antiga" notação de
110 tensor, existe uma considerável chance que "novos" tensores irão falhar em
111 interoperar com certas funções ou recursos. Essas falhas serão corrigidas
112 à medida que forem encontradas... até então, seja cuidadoso!
115 @subsection Manipulação de tensores indiciais
117 o pacote de manipulação de tensores indiciais pode ser chamado através de
118 @code{load("itensor")}. Demonstações estão também disponíveis: tente @code{demo(tensor)}.
119 Em @code{itensor} um tensor é representado como um "objecto indexado" . Um "objecto indexado" é uma
120 função de 3 grupos de índices os quais representam o covariante,
121 o contravariante e o índice de derivação. Os índices covariantes são
122 especificados através de uma lista com o primeiro argumento para o objecto indexado, e
123 os índices contravariantes através de uma lista como segundo argumento. Se o
124 objecto indexado carece de algum desses grupos de índices então a lista
125 vazia @code{[]} é fornecida como o argumento correspondente. Dessa forma, @code{g([a,b],[c])}
126 representa um objecto indexado chamado @code{g} o qual tem dois índices covariantes
127 @code{(a,b)}, um índice contravariante (@code{c}) e não possui índices de derivação.
129 Os índices de derivação, se estiverem presente, são anexados ao final como
130 argumentos adicionais para a função numérica representando o tensor.
131 Eles podem ser explicitamente especificado pelo utilizador ou serem criados no
132 processo de diferenciação com relação a alguma variável coordenada.
133 Uma vez que diferenciação ordinária é comutativa, os índices de derivação
134 são ordenados alfanumericamente, a menos que @code{iframe_flag} seja escolhida para @code{true},
135 indicando que um referencial métrico está a ser usado. Essa ordenação canónica torna
136 possível para Maxima reconhecer que, por exemplo, @code{t([a],[b],i,j)} é
137 o mesmo que @code{t([a],[b],j,i)}. Diferenciação de um objecto indexado com
138 relação a alguma coordenada cujos índices não aparecem como um argumento
139 para o objecto indexado podem normalmente retornar zero. Isso é porque
140 Maxima pode não saber que o tensor representado através do objecto
141 indexado possívelmente depende implicitamente da respectiva coordenada. Pela
142 modificação da função existente no Maxima, @code{diff}, em @code{itensor}, Maxima sabe
143 assumir que todos os objectos indexados dependem de qualquer variável de
144 diferenciação a menos que seja declarado de outra forma. Isso torna possível para
145 a convençào de somatório ser extendida para índices derivativos. Pode
146 ser verificado que @code{itensor} não possui a compatibilidade de
147 incrementar índices derivativos, e então eles são sempre tratados como
148 covariantes.
150 As seguintes funções estão disponíveis no pacote tensor para
151 manipulação de objectos. Actualmente, com relação às
152 rotinas de simplificação, é assumido que objectos indexados não
153 possuem por padrão propriedades simétricas. Isso pode ser modificado através
154 da escolha da variável @code{allsym[false]} para @code{true}, o que irá
155 resultar no tratamento de todos os objectos indexados completamente simétricos em suas
156 listas de índices covariantes e simétricos em suas listas de
157 índices contravariantes.
159 O pacote @code{itensor} geralmente trata tensores como objectos opacos. Equações
160 tensoriais são manipuladas baseadas em regras algébricas, especificamente simetria
161 e regras de contração. Adicionalmente, o pacote @code{itensor} não entende
162 diferenciação covariante, curvatura, e torsão. Cálculos podem ser
163 executados relativamente a um métrica de referenciais de movimento, dependendo da escolha para
164 a variável @code{iframe_flag}.
166 Uma sessão demonstrativa abaixo mostra como chamar o pacote @code{itensor},
167 especificando o nome da métrica, e executando alguns cálculos simples.
169 @example
170 (%i1) load("itensor");
171 (%o1) /share/tensor/itensor.lisp
172 (%i2) imetric(g);
173 (%o2) done
174 (%i3) components(g([i,j],[]),p([i,j],[])*e([],[]))$
175 (%i4) ishow(g([k,l],[]))$
176 (%t4) e p
177 k l
178 (%i5) ishow(diff(v([i],[]),t))$
179 (%t5) 0
180 (%i6) depends(v,t);
181 (%o6) [v(t)]
182 (%i7) ishow(diff(v([i],[]),t))$
183 d
184 (%t7) -- (v )
185 dt i
186 (%i8) ishow(idiff(v([i],[]),j))$
187 (%t8) v
188 i,j
189 (%i9) ishow(extdiff(v([i],[]),j))$
190 (%t9) v - v
191 j,i i,j
192 -----------
193 2
194 (%i10) ishow(liediff(v,w([i],[])))$
195 %3 %3
196 (%t10) v w + v w
197 i,%3 ,i %3
198 (%i11) ishow(covdiff(v([i],[]),j))$
199 %4
200 (%t11) v - v ichr2
201 i,j %4 i j
202 (%i12) ishow(ev(%,ichr2))$
203 %4 %5
204 (%t12) v - g v (e p + e p - e p - e p
205 i,j %4 j %5,i ,i j %5 i j,%5 ,%5 i j
207 + e p + e p )/2
208 i %5,j ,j i %5
209 (%i13) iframe_flag:true;
210 (%o13) true
211 (%i14) ishow(covdiff(v([i],[]),j))$
212 %6
213 (%t14) v - v icc2
214 i,j %6 i j
215 (%i15) ishow(ev(%,icc2))$
216 %6
217 (%t15) v - v ifc2
218 i,j %6 i j
219 (%i16) ishow(radcan(ev(%,ifc2,ifc1)))$
220 %6 %8 %6 %8
221 (%t16) - (ifg v ifb + ifg v ifb - 2 v
222 %6 j %8 i %6 i j %8 i,j
224 %6 %8
225 - ifg v ifb )/2
226 %6 %8 i j
227 (%i17) ishow(canform(s([i,j],[])-s([j,i])))$
228 (%t17) s - s
229 i j j i
230 (%i18) decsym(s,2,0,[sym(all)],[]);
231 (%o18) done
232 (%i19) ishow(canform(s([i,j],[])-s([j,i])))$
233 (%t19) 0
234 (%i20) ishow(canform(a([i,j],[])+a([j,i])))$
235 (%t20) a + a
236 j i i j
237 (%i21) decsym(a,2,0,[anti(all)],[]);
238 (%o21) done
239 (%i22) ishow(canform(a([i,j],[])+a([j,i])))$
240 (%t22) 0
241 @end example
245 @c end concepts itensor
247 @node Definições para itensor, , Introdução a itensor, itensor
249 @section Definições para itensor
250 @subsection Gerenciando objectos indexados
252 @deffn {Função} entertensor (@var{nome})
254 É uma função que, através da linha de comando, permite criar um objecto
255 indexado chamado @var{nome} com qualquer número de índices de tensores e
256 derivativos. Ou um índice simples ou uma lista de índices (às quais podem ser
257 nulas) são entradas aceitáveis (veja o exemplo sob @code{covdiff}).
259 @end deffn
261 @deffn {Função} changename (@var{antigo}, @var{novo}, @var{expr})
263 Irá mudar o nome de todos os objectos indexados chamados @var{antigo} para @var{novo}
264 em @var{expr}. @var{antigo} pode ser ou um símbolo ou uma lista da forma
265 @code{[@var{nome}, @var{m}, @var{n}]} nesse caso somente esses objectos indexados chamados
266 @var{nome} com índice covariante @var{m} e índice contravariante @var{n} serão
267 renomeados para @var{novo}.
269 @end deffn
271 @deffn {Função} listoftens
273 Lista todos os tensores em uma expressão tensorial, incluindo seus índices. E.g.,
275 @example
277 (%i6) ishow(a([i,j],[k])*b([u],[],v)+c([x,y],[])*d([],[])*e)$
278 k
279 (%t6) d e c + a b
280 x y i j u,v
281 (%i7) ishow(listoftens(%))$
282 k
283 (%t7) [a , b , c , d]
284 i j u,v x y
286 @end example
288 @end deffn
290 @deffn {Função} ishow (@var{expr})
292 Mostra @var{expr} com os objectos indexados tendo seus
293 índices covariantes como subscritos e índices contravariantes como
294 sobrescritos. Os índices derivativos são mostrados como subscritos,
295 separados dos índices covariantes por uma vírgula (veja os exemplos
296 através desse documento).
298 @end deffn
300 @deffn {Função} indices (@var{expr})
302 Retorna uma lista de dois elementos. O primeiro é uma lista de índices
303 livres em @var{expr} (aqueles que ocorrem somente uma vez). O segundo é uma
304 lista de indices que ocorrem exactamente duas vezes em @var{expr} (dummy)
305 como demonstra o seguinte exemplo.
307 @example
309 (%i1) load("itensor");
310 (%o1) /share/tensor/itensor.lisp
311 (%i2) ishow(a([i,j],[k,l],m,n)*b([k,o],[j,m,p],q,r))$
312 k l j m p
313 (%t2) a b
314 i j,m n k o,q r
315 (%i3) indices(%);
316 (%o3) [[l, p, i, n, o, q, r], [k, j, m]]
318 @end example
320 Um produto de tensores contendo o mesmo índice mais que duas vezes é sintaticamente
321 ilegal. @code{indices} tenta lidar com essas expressões de uma
322 forma razoável; todavia, quando @code{indices} é chamada para operar sobre tal uma
323 expressão ilegal, seu comportamento pode ser considerado indefinido.
326 @end deffn
328 @deffn {Função} rename (@var{expr})
329 @deffnx {Função} rename (@var{expr}, @var{contador})
331 Retorna uma expressão equivalente para @var{expr} mas com índices que ocorrem exactamente duas vezes
332 em cada termo alterado do conjunto @code{[%1, %2,...]}, se o segundo argumento
333 opcional for omitido. De outra forma, os índices que ocorrem exactamente duas vezes são indexados
334 começando no valor de @var{contador}. Cada índice que ocorre exactamente duas vezes em um produto
335 será diferente. Para uma adição, @code{rename} irá operar sobre cada termo na
336 a adição zerando o contador com cada termo. Nesse caminho @code{rename} pode
337 servir como um simplificador tensorial. Adicionalmente, os índices serão
338 ordenados alfanumericamente (se @code{allsym} for @code{true}) com relação a
339 índices covariantes ou contravariantes dependendo do valor de @code{flipflag}.
340 Se @code{flipflag} for @code{false} então os índices serão renomeados conforme
341 a ordem dos índices contravariantes. Se @code{flipflag} for @code{true}
342 a renomeação ocorrerá conforme a ordem dos índices
343 covariantes. Isso muitas vezes ajuda que o efeito combinado dos dois restantes sejam
344 reduzidos a uma expressão de valor um ou mais que um por si mesma.
346 @example
348 (%i1) load("itensor");
349 (%o1) /share/tensor/itensor.lisp
350 (%i2) allsym:true;
351 (%o2) true
352 (%i3) g([],[%4,%5])*g([],[%6,%7])*ichr2([%1,%4],[%3])*
353 ichr2([%2,%3],[u])*ichr2([%5,%6],[%1])*ichr2([%7,r],[%2])-
354 g([],[%4,%5])*g([],[%6,%7])*ichr2([%1,%2],[u])*
355 ichr2([%3,%5],[%1])*ichr2([%4,%6],[%3])*ichr2([%7,r],[%2]),noeval$
356 (%i4) expr:ishow(%)$
358 %4 %5 %6 %7 %3 u %1 %2
359 (%t4) g g ichr2 ichr2 ichr2 ichr2
360 %1 %4 %2 %3 %5 %6 %7 r
362 %4 %5 %6 %7 u %1 %3 %2
363 - g g ichr2 ichr2 ichr2 ichr2
364 %1 %2 %3 %5 %4 %6 %7 r
365 (%i5) flipflag:true;
366 (%o5) true
367 (%i6) ishow(rename(expr))$
368 %2 %5 %6 %7 %4 u %1 %3
369 (%t6) g g ichr2 ichr2 ichr2 ichr2
370 %1 %2 %3 %4 %5 %6 %7 r
372 %4 %5 %6 %7 u %1 %3 %2
373 - g g ichr2 ichr2 ichr2 ichr2
374 %1 %2 %3 %4 %5 %6 %7 r
375 (%i7) flipflag:false;
376 (%o7) false
377 (%i8) rename(%th(2));
378 (%o8) 0
379 (%i9) ishow(rename(expr))$
380 %1 %2 %3 %4 %5 %6 %7 u
381 (%t9) g g ichr2 ichr2 ichr2 ichr2
382 %1 %6 %2 %3 %4 r %5 %7
384 %1 %2 %3 %4 %6 %5 %7 u
385 - g g ichr2 ichr2 ichr2 ichr2
386 %1 %3 %2 %6 %4 r %5 %7
387 @end example
389 @end deffn
391 @defvr {Variável de Opção} flipflag
393 Valor por omissão: @code{false}. Se @code{false} então os índices irão ser
394 renomeados conforme a ordem dos índices contravariantes,
395 de outra forma serão ordenados conforme a ordem dos índices covariantes.
397 Se @code{flipflag} for @code{false} então @code{rename} forma uma lista
398 de índices contravariantes na ordem em que forem encontrados da esquerda para a direita
399 (se @code{true} então de índices contravariantes). O primeiro índice
400 que ocorre exactamente duas vezes na lista é renomeado para @code{%1}, o seguinte para @code{%2}, etc.
401 Então a ordenação ocorre após a ocorrência do @code{rename} (veja o exemplo
402 sob @code{rename}).
404 @end defvr
406 @deffn {Função} defcon (@var{tensor_1})
407 @deffnx {Função} defcon (@var{tensor_1}, @var{tensor_2}, @var{tensor_3})
408 Dado @var{tensor_1} a propriedade que a
409 contração de um produto do @var{tensor_1} e do @var{tensor_2} resulta em @var{tensor_3}
410 com os índices apropriados. Se somente um argumento, @var{tensor_1}, for
411 dado, então a contração do produto de @var{tensor_1} com qualquer objecto
412 indexado tendo os índices apropriados (digamos @code{my_tensor}) irá retornar como resultado um
413 objecto indexado com aquele nome, i.e. @code{my_tensor}, e com uma nova escolha de
414 índices refletindo as contrações executadas.
415 Por exemplo, se @code{imetric:g}, então @code{defcon(g)} irá implementar o
416 incremento e decremento de índices através da contração com o tensor
417 métrico.
418 Mais de uma @code{defcon} pode ser dada para o mesmo objecto indexado; o
419 último fornecido que for aplicado a uma contração particular será
420 usado.
421 @code{contractions} é uma lista de objectos indexados que tenham fornecido
422 propriedades de contrações com @code{defcon}.
424 @end deffn
426 @deffn {Função} remcon (@var{tensor_1}, ..., @var{tensor_n})
427 @deffnx {Função} remcon (all)
428 Remove todas as propriedades de contração
429 de @var{tensor_1}, ..., @var{tensor_n}). @code{remcon(all)} remove todas as propriedades de
430 contração de todos os objectos indexados.
432 @end deffn
434 @deffn {Função} contract (@var{expr})
436 Realiza contrações tensoriais em @var{expr} a qual pode ser qualquer
437 combinação de adições e produtos. Essa função usa a informação
438 dada para a função @code{defcon}. Para melhores resultados, @code{expr}
439 pode ser completamente expandida. @code{ratexpand} é o meio mais rápido para expandir
440 produtos e expoentes de adições se não existirem variáveis nos denominadores
441 dos termos. O comutador @code{gcd} pode ser @code{false} se cancelamentos de
442 máximo divisor comum forem desnecessários.
444 @end deffn
446 @deffn {Função} indexed_tensor (@var{tensor})
448 Deve ser executada antes de atribuir componentes para um @var{tensor} para o qual
449 um valor interno já existe como com @code{ichr1}, @code{ichr2},
450 @code{icurvature}. Veja o exemplo sob @code{icurvature}.
452 @end deffn
454 @deffn {Função} components (@var{tensor}, @var{expr})
456 Permite que se atribua um valor indicial a uma expressão
457 @var{expr} dando os valores das componentes do @var{tensor}. Esses
458 são automaticamente substituídos para o tensor mesmo que isso ocorra com
459 todos os seus índices. O tensor deve ser da forma @code{t([...],[...])}
460 onde qualquer lista pode ser vazia. @var{expr} pode ser qualquer expressão indexada
461 envolvendo outros objectos com os mesmos índices livres que @var{tensor}. Quando
462 usada para atribuir valores a um tensor métrico no qual as componentes
463 possuem índices que ocorrem exactamente duas vezes se deve ser cuidadoso para definir esses índices de forma a
464 evitar a geração de índices que ocorrem exactamente duas vezes e que são múltiplos. a remoção dessas
465 atribuições é dada para a função @code{remcomps}.
467 É importante ter em mente que @code{components} cuida somente da
468 valência de um tensor, e que ignora completamente qualquer ordenação particular de índices. Dessa forma
469 atribuindo componentes a, digamos, @code{x([i,-j],[])}, @code{x([-j,i],[])}, ou
470 @code{x([i],[j])} todas essas atribuições produzem o mesmo resultado, a saber componentes sendo
471 atribuidas a um tensor chamado @code{x} com valência @code{(1,1)}.
473 Componentes podem ser atribuidas a uma expressão indexada por quatro caminhos, dois
474 dos quais envolvem o uso do comando @code{components}:
476 1) Como uma expressão indexada. Por exemplo:
478 @example
480 (%i2) components(g([],[i,j]),e([],[i])*p([],[j]))$
481 (%i3) ishow(g([],[i,j]))$
482 i j
483 (%t3) e p
485 @end example
487 2) Como uma matriz:
489 @example
491 (%i6) components(g([i,j],[]),lg);
492 (%o6) done
493 (%i7) ishow(g([i,j],[]))$
494 (%t7) g
495 i j
496 (%i8) g([3,3],[]);
497 (%o8) 1
498 (%i9) g([4,4],[]);
499 (%o9) - 1
501 @end example
503 3) Como uma função. Pode usar uma função Maxima para especificar as
504 componentes de um tensor baseado nesses índices. Por exemplo, os seguintes
505 códigos atribuem @code{kdelta} a @code{h} se @code{h} tiver o mesmo número de
506 índices covariantes e índices contravariantes e nenhum índice derivativo, e
507 atribui @code{kdelta} a @code{g} caso as condições anteriores não sejam atendidas:
509 @example
511 (%i4) h(l1,l2,[l3]):=if length(l1)=length(l2) and length(l3)=0
512 then kdelta(l1,l2) else apply(g,append([l1,l2], l3))$
513 (%i5) ishow(h([i],[j]))$
514 j
515 (%t5) kdelta
516 i
517 (%i6) ishow(h([i,j],[k],l))$
518 k
519 (%t6) g
520 i j,l
522 @end example
524 4) Usando a compatibilidade dos modelos de coincidência do Maxima, especificamente os
525 comandos @code{defrule} e @code{applyb1}:
527 @example
529 (%i1) load("itensor");
530 (%o1) /share/tensor/itensor.lisp
531 (%i2) matchdeclare(l1,listp);
532 (%o2) done
533 (%i3) defrule(r1,m(l1,[]),(i1:idummy(),
534 g([l1[1],l1[2]],[])*q([i1],[])*e([],[i1])))$
536 (%i4) defrule(r2,m([],l1),(i1:idummy(),
537 w([],[l1[1],l1[2]])*e([i1],[])*q([],[i1])))$
539 (%i5) ishow(m([i,n],[])*m([],[i,m]))$
540 i m
541 (%t5) m m
542 i n
543 (%i6) ishow(rename(applyb1(%,r1,r2)))$
544 %1 %2 %3 m
545 (%t6) e q w q e g
546 %1 %2 %3 n
549 @end example
551 @end deffn
553 @deffn {Função} remcomps (@var{tensor})
555 Desassocia todos os valores de @var{tensor} que foram atribuídos com a
556 função @code{components}.
558 @end deffn
560 @c NEED LIST OF ARGUMENTS HERE
561 @deffn {Função} showcomps (@var{tensor})
563 Mostra atribuições de componentes de um tensor, feitas usando o comando
564 @code{components}. Essa função pode ser particularmente útil quando uma matriz é atribuída
565 a um tensor indicial usando @code{components}, como demonstrado através do
566 seguinte exemplo:
568 @example
570 (%i1) load("ctensor");
571 (%o1) /share/tensor/ctensor.mac
572 (%i2) load("itensor");
573 (%o2) /share/tensor/itensor.lisp
574 (%i3) lg:matrix([sqrt(r/(r-2*m)),0,0,0],[0,r,0,0],
575 [0,0,sin(theta)*r,0],[0,0,0,sqrt((r-2*m)/r)]);
576 [ r ]
577 [ sqrt(-------) 0 0 0 ]
578 [ r - 2 m ]
579 [ ]
580 [ 0 r 0 0 ]
581 (%o3) [ ]
582 [ 0 0 r sin(theta) 0 ]
583 [ ]
584 [ r - 2 m ]
585 [ 0 0 0 sqrt(-------) ]
586 [ r ]
587 (%i4) components(g([i,j],[]),lg);
588 (%o4) done
589 (%i5) showcomps(g([i,j],[]));
590 [ r ]
591 [ sqrt(-------) 0 0 0 ]
592 [ r - 2 m ]
593 [ ]
594 [ 0 r 0 0 ]
595 (%t5) g = [ ]
596 i j [ 0 0 r sin(theta) 0 ]
597 [ ]
598 [ r - 2 m ]
599 [ 0 0 0 sqrt(-------) ]
600 [ r ]
601 (%o5) false
603 @end example
605 O comando @code{showcomps} pode também mostrar componentes de um tensor de
606 categoria maior que 2.
608 @end deffn
610 @deffn {Função} idummy ()
612 Incrementos @code{icounter} e retorno como seu valor um índice da forma
613 @code{%n} onde n é um inteiro positivo. Isso garante que índices que ocorrem exactamente duas vezes
614 e que são necessários na formação de expressões não irão conflitar com índices
615 que já estiverem sendo usados (veja o exemplo sob @code{indices}).
617 @end deffn
619 @defvr {Variável de opção} idummyx
620 Valor por omissão: @code{%}
622 É o prefixo para índices que ocorrem exactamente duas vezes (veja o exemplo sob índices @code{indices}).
624 @end defvr
626 @defvr {Variável de Opção} icounter
627 Valor por omissão: @code{1}
629 Determina o sufixo numérico a ser usado na
630 geração do próximo índice que ocorre exactamente duas vezes no pacote tensor. O prefixo é
631 determinado através da opção @code{idummy} (padrão: @code{%}).
632 @end defvr
634 @deffn {Função} kdelta (@var{L1}, @var{L2})
635 é a função delta generalizada de Kronecker definida no
636 pacote @code{itensor} com @var{L1} a lista de índices covariantes e @var{L2}
637 a lista de índices contravariantes. @code{kdelta([i],[j])} retorna o delta de
638 Kronecker comum. O comando @code{ev(@var{expr},kdelta)} faz com que a avaliação de
639 uma expressão contendo @code{kdelta([],[])} se dê para a dimensão de
640 multiplicação.
642 No que conduzir a um abuso dessa notação, @code{itensor} também permite
643 @code{kdelta} ter 2 covariantes e nenhum contravariante, ou 2 contravariantes
644 e nenhum índice covariante, com efeito fornecendo uma compatibilidade para "matriz unitária" covariante ou
645 contravariante. Isso é estritamente considerado um recurso de programação e não significa
646 implicar que @code{kdelta([i,j],[])} seja um objecto tensorial válido.
648 @end deffn
650 @deffn {Função} kdels (@var{L1}, @var{L2})
652 Delta de Kronecker simetrizado, usado em alguns cálculos. Por exemplo:
654 @example
656 (%i1) load("itensor");
657 (%o1) /share/tensor/itensor.lisp
658 (%i2) kdelta([1,2],[2,1]);
659 (%o2) - 1
660 (%i3) kdels([1,2],[2,1]);
661 (%o3) 1
662 (%i4) ishow(kdelta([a,b],[c,d]))$
663 c d d c
664 (%t4) kdelta kdelta - kdelta kdelta
665 a b a b
666 (%i4) ishow(kdels([a,b],[c,d]))$
667 c d d c
668 (%t4) kdelta kdelta + kdelta kdelta
669 a b a b
671 @end example
673 @end deffn
675 @deffn {Função} levi_civita (@var{L})
676 é o tensor de permutação (ou de Levi-Civita) que retorna 1 se
677 a lista @var{L} consistir de uma permutação par de inteiros, -1 se isso
678 consistir de uma permutação ímpar, e 0 se alguns índices em @var{L} forem
679 repetidos.
681 @end deffn
683 @deffn {Função} lc2kdt (@var{expr})
684 Simplifica expressões contendo os símbolos de Levi-Civita, convertendo esses
685 para expressões delta de Kronecker quando possível. A principal diferença entre
686 essa função e simplesmente avaliar os simbolos de Levi-Civita é que a avaliação
687 directa muitas vezes resulta em expressões Kronecker contendo índices
688 numéricos. Isso é muitas vezes indesejável como na prevenção de simplificação adicional.
689 A função @code{lc2kdt} evita esse problema, retornando expressões que
690 são mais facilmente simplificadas com @code{rename} ou @code{contract}.
692 @example
694 (%i1) load("itensor");
695 (%o1) /share/tensor/itensor.lisp
696 (%i2) expr:ishow('levi_civita([],[i,j])*'levi_civita([k,l],[])*a([j],[k]))$
697 i j k
698 (%t2) levi_civita a levi_civita
699 j k l
700 (%i3) ishow(ev(expr,levi_civita))$
701 i j k 1 2
702 (%t3) kdelta a kdelta
703 1 2 j k l
704 (%i4) ishow(ev(%,kdelta))$
705 i j j i k
706 (%t4) (kdelta kdelta - kdelta kdelta ) a
707 1 2 1 2 j
709 1 2 2 1
710 (kdelta kdelta - kdelta kdelta )
711 k l k l
712 (%i5) ishow(lc2kdt(expr))$
713 k i j k j i
714 (%t5) a kdelta kdelta - a kdelta kdelta
715 j k l j k l
716 (%i6) ishow(contract(expand(%)))$
717 i i
718 (%t6) a - a kdelta
719 l l
721 @end example
723 A função @code{lc2kdt} algumas vezes faz uso de tensores métricos.
724 Se o tensor métrico não tiver sido definido previamente com @code{imetric},
725 isso resulta em um erro.
727 @example
729 (%i7) expr:ishow('levi_civita([],[i,j])*'levi_civita([],[k,l])*a([j,k],[]))$
730 i j k l
731 (%t7) levi_civita levi_civita a
732 j k
733 (%i8) ishow(lc2kdt(expr))$
734 Maxima encountered a Lisp error:
736 Error in $IMETRIC [or a callee]:
737 $IMETRIC [or a callee] requires less than two arguments.
739 Automatically continuing.
740 To reenable the Lisp debugger set *debugger-hook* to nil.
741 (%i9) imetric(g);
742 (%o9) done
743 (%i10) ishow(lc2kdt(expr))$
744 %3 i k %4 j l %3 i l %4 j k
745 (%t10) (g kdelta g kdelta - g kdelta g kdelta ) a
746 %3 %4 %3 %4 j k
747 (%i11) ishow(contract(expand(%)))$
748 l i l i
749 (%t11) a - a g
751 @end example
754 @end deffn
756 @c HMM, WHICH CATEGORY DOES THIS FALL INTO -- FUNCTION, VARIABLE, OTHER ??
757 @deffn {Função} lc_l
759 Regra de simplificação usada para expressões contendo símbolos não avaliados de
760 Levi-Civita (@code{levi_civita}). Juntamente com @code{lc_u}, pode ser usada para simplificar
761 muitas expressões mais eficientemente que a avaliação de @code{levi_civita}.
762 Por exemplo:
764 @example
766 (%i1) load("itensor");
767 (%o1) /share/tensor/itensor.lisp
768 (%i2) el1:ishow('levi_civita([i,j,k],[])*a([],[i])*a([],[j]))$
769 i j
770 (%t2) a a levi_civita
771 i j k
772 (%i3) el2:ishow('levi_civita([],[i,j,k])*a([i])*a([j]))$
773 i j k
774 (%t3) levi_civita a a
775 i j
776 (%i4) ishow(canform(contract(expand(applyb1(el1,lc_l,lc_u)))))$
777 (%t4) 0
778 (%i5) ishow(canform(contract(expand(applyb1(el2,lc_l,lc_u)))))$
779 (%t5) 0
781 @end example
783 @end deffn
785 @c HMM, WHICH CATEGORY DOES THIS FALL INTO -- FUNCTION, VARIABLE, OTHER ??
786 @deffn {Função} lc_u
788 Regra de simplificação usada para expressões contendo símbolos não avaliados de
789 Levi-Civita (@code{levi_civita}). Juntamente com @code{lc_u}, pode ser usada para simplificar
790 muitas expressões mais eficientemente que a avaliação de @code{levi_civita}.
791 Para detalhes, veja @code{lc_l}.
793 @end deffn
795 @deffn {Função} canten (@var{expr})
796 Simplifica @var{expr} por renomeação (veja @code{rename})
797 e permutando índices que ocorrem exactamente duas vezes. @code{rename} é restrito a adições de produto
798 de tensores nos quais nenhum índice derivativo estiver presente. Como tal isso é limitado
799 e pode somente ser usado se @code{canform} não for capaz de realizar a
800 simplificação requerida.
802 A função @code{canten} retorna um resultado matematicamente correcto somente
803 se seu argumento for uma expressão que é completamente simétrica em seus índices.
804 Por essa razão, @code{canten} retorna um erro se @code{allsym} não for
805 posicionada em @code{true}.
807 @end deffn
809 @deffn {Função} concan (@var{expr})
810 Similar a @code{canten} mas também executa contração de índices.
812 @end deffn
814 @subsection Simetrias de tensores
816 @defvr {Variável de Opção} allsym
818 Valor por omissão: @code{false}. Se @code{true} então todos os objectos indexados
819 são assumidos simétricos em todos os seus índices covariantes e
820 contravariantes. Se @code{false} então nenhum simétrico de qualquer tipo é assumidos
821 nesses índices. Índices derivativos são sempre tomados para serem simétricos
822 a menos que @code{iframe_flag} seja escolhida para @code{true}.
824 @end defvr
826 @deffn {Função} decsym (@var{tensor}, @var{m}, @var{n}, [@var{cov_1}, @var{cov_2}, ...], [@var{contr_1}, @var{contr_2}, ...])
828 Declara propriedades de simetria para @var{tensor} de covariante @var{m} e
829 @var{n} índices contravariantes. As @var{cov_i} e @var{contr_i} são
830 pseudofunções expressando relações de simetrias em meio a índices covariante e
831 índices contravariantes respectivamente. Esses são da forma
832 @code{symoper(@var{index_1}, @var{index_2},...)} onde @code{symoper} é um entre
833 @code{sym}, @code{anti} ou @code{cyc} e os @var{index_i} são inteiros
834 indicando a posição do índice no @var{tensor}. Isso irá
835 declarar @var{tensor} para ser simétrico, antisimétrico ou cíclico respectivamente
836 nos @var{index_i}. @code{symoper(all)} é também forma permitida que
837 indica todos os índices obedecem à condição de simetria. Por exemplo, dado um
838 objecto @code{b} com 5 índices covariantes,
839 @code{decsym(b,5,3,[sym(1,2),anti(3,4)],[cyc(all)])} declara @code{b}
840 simétrico no seu primeiro e no seu segundo índices e antisimétrico no seu terceiro e
841 quarto índices covariantes, e cíclico em todos de seus índices contravariantes.
842 Qualquer lista de declarações de simetria pode ser nula. A função que
843 executa as simplificações é @code{canform} como o exemplo abaixo
844 ilustra.
846 @example
848 (%i1) load("itensor");
849 (%o1) /share/tensor/itensor.lisp
850 (%i2) expr:contract(expand(a([i1,j1,k1],[])*kdels([i,j,k],[i1,j1,k1])))$
851 (%i3) ishow(expr)$
852 (%t3) a + a + a + a + a + a
853 k j i k i j j k i j i k i k j i j k
854 (%i4) decsym(a,3,0,[sym(all)],[]);
855 (%o4) done
856 (%i5) ishow(canform(expr))$
857 (%t5) 6 a
858 i j k
859 (%i6) remsym(a,3,0);
860 (%o6) done
861 (%i7) decsym(a,3,0,[anti(all)],[]);
862 (%o7) done
863 (%i8) ishow(canform(expr))$
864 (%t8) 0
865 (%i9) remsym(a,3,0);
866 (%o9) done
867 (%i10) decsym(a,3,0,[cyc(all)],[]);
868 (%o10) done
869 (%i11) ishow(canform(expr))$
870 (%t11) 3 a + 3 a
871 i k j i j k
872 (%i12) dispsym(a,3,0);
873 (%o12) [[cyc, [[1, 2, 3]], []]]
875 @end example
878 @end deffn
880 @deffn {Função} remsym (@var{tensor}, @var{m}, @var{n})
881 Remove todas as propriedades de simetria de @var{tensor} que tem @var{m}
882 índices covariantes e @var{n} índices contravariantes.
883 @end deffn
885 @deffn {Função} canform (@var{expr})
886 Simplifica @var{expr} através de mudança de nome de índices
887 que ocorrem exactamente duas vezes e reordenação de todos os índices como ditados pelas condições de simetria
888 impostas sobre eles. Se @code{allsym} for @code{true} então todos os índices são assumidos
889 simétricos, de outra forma a informação de simetria fornecida pelas declarações
890 @code{decsym} irão ser usadas. Os índices que ocorrem exactamente duas vezes são renomeados da mesma
891 maneira que na função @code{rename}. Quando @code{canform} é aplicada a uma expressão
892 larga o cálculo pode tomar um considerável montante de tempo.
893 Esse tempo pode ser diminuído através do uso de @code{rename} sobre a expressão em primeiro lugar.
894 Também veja o exemplo sob @code{decsym}. Nota: @code{canform} pode não estar apta a
895 reduzir um expressão completamente para sua forma mais simples embora
896 retorne sempre um resultado matemáticamente correcto.
897 @end deffn
899 @subsection Cálculo de tensores indiciais
901 @deffn {Função} diff (@var{expr}, @var{v_1}, [@var{n_1}, [@var{v_2}, @var{n_2}] ...])
903 É a função usual de diferenciação do Maxima que tem sido expandida
904 nessas habilidades para @code{itensor}. @code{diff} toma a derivada de @var{expr}
905 @var{n_1} vezes com relação a @var{v_1}, @var{n_2} vezes com relação a @var{v_2}
906 , etc. Para o pacote @code{tensor}, a função tem sido modificada de
907 forma que os @var{v_i} possam ser inteiros de 1 até o valor da variável
908 @code{dim}. Isso causará a conclusão da diferenciação com
909 relação ao @var{v_i}ésimo membro da lista @code{vect_coords}. Se
910 @code{vect_coords} for associado a uma variável at@^omica, então aquela variável
911 subscrita através de @var{v_i} será usada para a variável de
912 diferenciação. Isso permite que um array de nomes de coordenadas ou
913 nomes subscritos como @code{x[1]}, @code{x[2]}, ... sejam usados.
914 @end deffn
916 @deffn {Função} idiff (@var{expr}, @var{v_1}, [@var{n_1}, [@var{v_2}, @var{n_2}] ...])
917 Diferenciação indicial. A menos que @code{diff}, que diferencia
918 com relação a uma variável independente, @code{idiff} possa ser usada
919 para diferenciar com relação a uma coordenada. Para um objecto indexado,
920 isso equivale a anexar ao final os @var{v_i} como índices derivativos.
921 Subsequêntemente, índices derivativos irão ser ordenados, a menos que @code{iframe_flag}
922 seja escolhida para @code{true}.
924 @code{idiff} pode também ser o determinante de um tensor
925 métrico. Dessa forma, se @code{imetric} tiver sido associada a @code{G} então
926 @code{idiff(determinant(g),k)} irá retornar
927 @code{2*determinant(g)*ichr2([%i,k],[%i])} onde o índice que ocorre exactamente duas vezes @code{%i}
928 é escolhido apropriadamente.
931 @end deffn
933 @deffn {Função} liediff (@var{v}, @var{ten})
935 Calcula a derivada de Lie da expressão tensorial @var{ten} com
936 relação ao campo vectorial @var{v}. @var{ten} pode ser qualquer expressão tensorial
937 indexada; @var{v} pode ser o nome (sem índices) de um campo
938 vectorial. Por exemplo:
940 @example
942 (%i1) load("itensor");
943 (%o1) /share/tensor/itensor.lisp
944 (%i2) ishow(liediff(v,a([i,j],[])*b([],[k],l)))$
945 k %2 %2 %2
946 (%t2) b (v a + v a + v a )
947 ,l i j,%2 ,j i %2 ,i %2 j
949 %1 k %1 k %1 k
950 + (v b - b v + v b ) a
951 ,%1 l ,l ,%1 ,l ,%1 i j
953 @end example
956 @end deffn
958 @deffn {Função} rediff (@var{ten})
960 Avalia todas as ocorrências do comando @code{idiff} na expressão
961 tensorial @var{ten}.
963 @end deffn
965 @deffn {Função} undiff (@var{expr})
967 Retorna uma expressão equivalente a @var{expr} mas com todas as derivadas
968 de objectos indexados substituídas pela forma substantiva da função @code{idiff}. Seu
969 argumento pode retornar aquele objecto indexado se a diferenciação for
970 concluída. Isso é útil quando for desejado substituir um
971 objecto indexado que sofreu diferenciação com alguma definição de função resultando
972 em @var{expr} e então concluir a diferenciação através de digamos
973 @code{ev(@var{expr}, idiff)}.
975 @end deffn
977 @deffn {Função} evundiff (@var{expr})
979 Equivalente à execução de @code{undiff}, seguida por @code{ev} e
980 @code{rediff}.
982 O ponto dessa operação é facilmente avaliar expressões que não possam
983 ser directamente avaliadas na forma derivada. Por exemplo, o seguinte
984 causa um erro:
986 @example
987 (%i1) load("itensor");
988 (%o1) /share/tensor/itensor.lisp
989 (%i2) icurvature([i,j,k],[l],m);
990 Maxima encountered a Lisp error:
992 Error in $ICURVATURE [or a callee]:
993 $ICURVATURE [or a callee] requires less than three arguments.
995 Automatically continuing.
996 To reenable the Lisp debugger set *debugger-hook* to nil.
997 @end example
999 Todavia, se @code{icurvature} é informado em sua forma substantiva, pode ser avaliado
1000 usando @code{evundiff}:
1002 @example
1003 (%i3) ishow('icurvature([i,j,k],[l],m))$
1004 l
1005 (%t3) icurvature
1006 i j k,m
1007 (%i4) ishow(evundiff(%))$
1008 l l %1 l %1
1009 (%t4) - ichr2 - ichr2 ichr2 - ichr2 ichr2
1010 i k,j m %1 j i k,m %1 j,m i k
1012 l l %1 l %1
1013 + ichr2 + ichr2 ichr2 + ichr2 ichr2
1014 i j,k m %1 k i j,m %1 k,m i j
1015 @end example
1017 Nota: Em versões anteriores do Maxima, formas derivadas dos
1018 símbolos de Christoffel também não podiam ser avaliadas. Isso foi corrigido actualmente,
1019 de forma que @code{evundiff} não mais é necessária para expressões como essa:
1021 @example
1022 (%i5) imetric(g);
1023 (%o5) done
1024 (%i6) ishow(ichr2([i,j],[k],l))$
1025 k %3
1026 g (g - g + g )
1027 j %3,i l i j,%3 l i %3,j l
1028 (%t6) -----------------------------------------
1029 2
1031 k %3
1032 g (g - g + g )
1033 ,l j %3,i i j,%3 i %3,j
1034 + -----------------------------------
1035 2
1036 @end example
1039 @end deffn
1041 @deffn {Função} flush (@var{expr}, @var{tensor_1}, @var{tensor_2}, ...)
1042 Escolhe para zero, em
1043 @var{expr}, todas as ocorrências de @var{tensor_i} que não tiverem índices derivativos.
1045 @end deffn
1047 @deffn {Função} flushd (@var{expr}, @var{tensor_1}, @var{tensor_2}, ...)
1048 Escolhe para zero, em
1049 @var{expr}, todas as ocorrências de @var{tensor_i} que tiverem índices derivativos.
1051 @end deffn
1053 @deffn {Função} flushnd (@var{expr}, @var{tensor}, @var{n})
1054 Escolhe para zero, em @var{expr}, todas as
1055 ocorrências do objecto diferenciado @var{tensor} que tem @var{n} ou mais
1056 índices derivativos como demonstra o seguinte exemplo.
1057 @example
1059 (%i1) load("itensor");
1060 (%o1) /share/tensor/itensor.lisp
1061 (%i2) ishow(a([i],[J,r],k,r)+a([i],[j,r,s],k,r,s))$
1062 J r j r s
1063 (%t2) a + a
1064 i,k r i,k r s
1065 (%i3) ishow(flushnd(%,a,3))$
1066 J r
1067 (%t3) a
1068 i,k r
1069 @end example
1070 @end deffn
1072 @deffn {Função} coord (@var{tensor_1}, @var{tensor_2}, ...)
1074 Dados os @var{tensor_i} a propriedade de diferenciação da coordenada que a
1075 derivada do vector contravariante cujo nome é um dos
1076 @var{tensor_i} retorna um delta de Kronecker. Por exemplo, se @code{coord(x)} tiver
1077 sido concluída então @code{idiff(x([],[i]),j)} fornece @code{kdelta([i],[j])}.
1078 @code{coord} que é uma lista de todos os objectos indexados tendo essa propriedade.
1080 @end deffn
1082 @deffn {Função} remcoord (@var{tensor_1}, @var{tensor_2}, ...)
1083 @deffnx {Função} remcoord (all)
1085 Remove a propriedade de coordenada de diferenciação dos @code{tensor_i}
1086 que foram estabelecidos através da função @code{coord}. @code{remcoord(all)}
1087 remove essa propriedade de todos os objectos indexados.
1089 @end deffn
1091 @deffn {Função} makebox (@var{expr})
1092 Mostra @var{expr} da mesma maneira que @code{show}; todavia,
1093 qualquer tensor d'Alembertiano ocorrendo em @var{expr} será indicado usando o
1094 símbolo @code{[]}. Por exemplo, @code{[]p([m],[n])} representa
1095 @code{g([],[i,j])*p([m],[n],i,j)}.
1097 @end deffn
1099 @deffn {Função} conmetderiv (@var{expr}, @var{tensor})
1101 Simplifica expressões contendo derivadas comuns de
1102 ambas as formas covariantes e contravariantes do tensor métrico (a
1103 restrição corrente). Por exemplo, @code{conmetderiv} pode relatar a
1104 derivada do tensor contravariante métrico com símbolos de
1105 Christoffel como visto adiante:
1107 @example
1109 (%i1) load("itensor");
1110 (%o1) /share/tensor/itensor.lisp
1111 (%i2) ishow(g([],[a,b],c))$
1112 a b
1113 (%t2) g
1114 ,c
1115 (%i3) ishow(conmetderiv(%,g))$
1116 %1 b a %1 a b
1117 (%t3) - g ichr2 - g ichr2
1118 %1 c %1 c
1119 @end example
1120 @end deffn
1122 @deffn {Função} simpmetderiv (@var{expr})
1123 @deffnx {Função} simpmetderiv (@var{expr}[, @var{stop}])
1125 Simplifica expressões contendo produtos de derivadas de
1126 tensores métricos. Especificamente, @code{simpmetderiv} reconhece duas identidades:
1128 @example
1130 ab ab ab a
1131 g g + g g = (g g ) = (kdelta ) = 0
1132 ,d bc bc,d bc ,d c ,d
1134 @end example
1136 consequêntemente
1138 @example
1140 ab ab
1141 g g = - g g
1142 ,d bc bc,d
1143 @end example
1145 e
1147 @example
1149 ab ab
1150 g g = g g
1151 ,j ab,i ,i ab,j
1153 @end example
1155 que seguem de simetrias de símbolos de Christoffel.
1157 A função @code{simpmetderiv} toma um parâmetro opcional que, quando
1158 presente, faz com que a função pare após a primeira substituição feita com
1159 sucesso em uma expressão produto. A função @code{simpmetderiv}
1160 também faz uso da variável global @var{flipflag} que determina
1161 como aplicar uma ordenação ``canonica'' para os índices de produto.
1163 Colocados juntos, essas compatibilidades podem ser usadas poderosamente para encontrar
1164 simplificações que são difíceis ou impossíveis de realizar de outra forma.
1165 Isso é demonstrado através do seguinte exemplo que explicitamente usa o
1166 recurso de simplificação parcial de @code{simpmetderiv} para obter uma
1167 expressão contractível:
1169 @example
1171 (%i1) load("itensor");
1172 (%o1) /share/tensor/itensor.lisp
1173 (%i2) imetric(g);
1174 (%o2) done
1175 (%i3) ishow(g([],[a,b])*g([],[b,c])*g([a,b],[],d)*g([b,c],[],e))$
1176 a b b c
1177 (%t3) g g g g
1178 a b,d b c,e
1179 (%i4) ishow(canform(%))$
1181 errexp1 has improper indices
1182 -- an error. Quitting. To debug this try debugmode(true);
1183 (%i5) ishow(simpmetderiv(%))$
1184 a b b c
1185 (%t5) g g g g
1186 a b,d b c,e
1187 (%i6) flipflag:not flipflag;
1188 (%o6) true
1189 (%i7) ishow(simpmetderiv(%th(2)))$
1190 a b b c
1191 (%t7) g g g g
1192 ,d ,e a b b c
1193 (%i8) flipflag:not flipflag;
1194 (%o8) false
1195 (%i9) ishow(simpmetderiv(%th(2),stop))$
1196 a b b c
1197 (%t9) - g g g g
1198 ,e a b,d b c
1199 (%i10) ishow(contract(%))$
1200 b c
1201 (%t10) - g g
1202 ,e c b,d
1204 @end example
1206 Veja também @code{weyl.dem} para um exemplo que usa @code{simpmetderiv}
1207 e @code{conmetderiv} juntos para simplificar contrações do tensor de Weyl.
1209 @end deffn
1211 @deffn {Função} flush1deriv (@var{expr}, @var{tensor})
1213 Escolhe para zero, em @code{expr}, todas as ocorrências de @code{tensor} que possuem
1214 exactamente um índice derivativo.
1216 @end deffn
1218 @subsection Tensores em espaços curvos
1220 @deffn {Função} imetric (@var{g})
1221 @deffnx {Variável de sistema} imetric
1223 Especifica a métrica através de atribuição à variável @code{imetric:@var{g}}
1224 adicionalmente, as propriedades de contração da métrica @var{g} são escolhidas através da
1225 execução dos comandos @code{defcon(@var{g}),defcon(@var{g},@var{g},kdelta)}.
1226 A variável @code{imetric} (desassociada por padrão), é associada à métrica, atribuida pelo
1227 comando @code{imetric(@var{g})}.
1229 @end deffn
1231 @deffn {Função} idim (@var{n})
1232 Escolhe as dimensões da métrica. Também inicializa as propriedades de
1233 antisimetria dos símbolos de Levi-Civita para as dimensões dadas.
1235 @end deffn
1237 @deffn {Função} ichr1 ([@var{i}, @var{j}, @var{k}])
1238 Retorna o símbolo de Christoffel de primeiro tipo via
1239 definição
1240 @example
1241 (g + g - g )/2 .
1242 ik,j jk,i ij,k
1243 @end example
1244 @noindent
1245 Para avaliar os símbolos de Christoffel para uma métrica particular, à
1246 variável @code{imetric} deve ser atribuída um nome como no exemplo sob @code{chr2}.
1248 @end deffn
1250 @deffn {Função} ichr2 ([@var{i}, @var{j}], [@var{k}])
1251 Retorna o símbolo de Christoffel de segundo tipo
1252 definido pela relação
1253 @example
1254 ks
1255 ichr2([i,j],[k]) = g (g + g - g )/2
1256 is,j js,i ij,s
1257 @end example
1258 @end deffn
1260 @deffn {Função} icurvature ([@var{i}, @var{j}, @var{k}], [@var{h}])
1261 Retorna o tensor da curvatura de
1262 Riemann em termos de símbolos de Christoffel de segundo
1263 tipo (@code{ichr2}). A seguinte notação é usada:
1264 @example
1265 h h h %1 h
1266 icurvature = - ichr2 - ichr2 ichr2 + ichr2
1267 i j k i k,j %1 j i k i j,k
1268 h %1
1269 + ichr2 ichr2
1270 %1 k i j
1271 @end example
1272 @end deffn
1274 @deffn {Função} covdiff (@var{expr}, @var{v_1}, @var{v_2}, ...)
1275 Retorna a derivada da covariante de @var{expr} com
1276 relação às variáveis @var{v_i} em termos de símbolos de Christoffel de
1277 segundo tipo (@code{ichr2}). Com o objectivo de avaliar esses, se pode usar
1278 @code{ev(@var{expr},ichr2)}.
1280 @example
1282 (%i1) load("itensor");
1283 (%o1) /share/tensor/itensor.lisp
1284 (%i2) entertensor()$
1285 Enter tensor name: a;
1286 Enter a list of the índices covariantes: [i,j];
1287 Enter a list of the índices contravariantes: [k];
1288 Enter a list of the derivative indices: [];
1289 k
1290 (%t2) a
1291 i j
1292 (%i3) ishow(covdiff(%,s))$
1293 k %1 k %1 k k %1
1294 (%t3) - a ichr2 - a ichr2 + a + ichr2 a
1295 i %1 j s %1 j i s i j,s %1 s i j
1296 (%i4) imetric:g;
1297 (%o4) g
1298 (%i5) ishow(ev(%th(2),ichr2))$
1299 %1 %4 k
1300 g a (g - g + g )
1301 i %1 s %4,j j s,%4 j %4,s
1302 (%t5) - ------------------------------------------
1303 2
1304 %1 %3 k
1305 g a (g - g + g )
1306 %1 j s %3,i i s,%3 i %3,s
1307 - ------------------------------------------
1308 2
1309 k %2 %1
1310 g a (g - g + g )
1311 i j s %2,%1 %1 s,%2 %1 %2,s k
1312 + ------------------------------------------- + a
1313 2 i j,s
1314 (%i6)
1315 @end example
1317 @end deffn
1319 @deffn {Função} lorentz_gauge (@var{expr})
1320 Impõe a condição de Lorentz através da substituição de 0 para todos os
1321 objectos indexados em @var{expr} que possui um índice de derivada idêntico ao
1322 índice contravariante.
1324 @end deffn
1326 @deffn {Função} igeodesic_coords (@var{expr}, @var{nome})
1328 Faz com que símbolos de Christoffel não diferenciados e
1329 a primeira derivada do tensor métrico tendam para zero em @var{expr}. O @var{nome}
1330 na função @code{igeodesic_coords} refere-se à métrica @var{nome}
1331 (se isso aparecer em @var{expr}) enquando os coeficientes de conecção devem ser
1332 chamados com os nomes @code{ichr1} e/ou @code{ichr2}. O seguinte exemplo
1333 demonstra a verificação da identidade cíclica satisfeita através do tensor da
1334 curvatura de Riemann usando a função @code{igeodesic_coords}.
1336 @example
1338 (%i1) load("itensor");
1339 (%o1) /share/tensor/itensor.lisp
1340 (%i2) ishow(icurvature([r,s,t],[u]))$
1341 u u %1 u u %1
1342 (%t2) - ichr2 - ichr2 ichr2 + ichr2 + ichr2 ichr2
1343 r t,s %1 s r t r s,t %1 t r s
1344 (%i3) ishow(igeodesic_coords(%,ichr2))$
1345 u u
1346 (%t3) ichr2 - ichr2
1347 r s,t r t,s
1348 (%i4) ishow(igeodesic_coords(icurvature([r,s,t],[u]),ichr2)+
1349 igeodesic_coords(icurvature([s,t,r],[u]),ichr2)+
1350 igeodesic_coords(icurvature([t,r,s],[u]),ichr2))$
1351 u u u u u
1352 (%t4) - ichr2 + ichr2 + ichr2 - ichr2 - ichr2
1353 t s,r t r,s s t,r s r,t r t,s
1355 u
1356 + ichr2
1357 r s,t
1358 (%i5) canform(%);
1359 (%o5) 0
1361 @end example
1363 @end deffn
1365 @subsection Referenciais móveis
1367 Maxima actualmente tem a habilidade de executar cálculos usando referenciais móveis.
1368 Essas podem ser referenciais ortonormais (tetrads, vielbeins) ou um referencial arbitrária.
1370 Para usar referenciais, primeiro escolha @code{iframe_flag} para @code{true}. Isso
1371 faz com que os símbolos de Christoffel, @code{ichr1} e @code{ichr2}, sejam substituídos
1372 pelos referenciais mais gerais de coeficientes de conecção @code{icc1} e @code{icc2}
1373 em cálculos. Especialmente, o comportamento de @code{covdiff} e
1374 @code{icurvature} são alterados.
1376 O referencial é definido através de dois tensores: o campo de referencial inversa (@code{ifri}),
1377 a base tetrad dual),
1378 e a métrica do referencial @code{ifg}. A métrica do referencial é a matriz identidade para
1379 referenciais ortonormais, ou a métrica de Lorentz para referenciais ortonormais no espaço-tempo de
1380 Minkowski. O campo de referencial inverso define a base do referencial (vectores unitários).
1381 Propriedades de contração são definidas para o campo de referencial e para a métrica do referencial.
1383 Quando @code{iframe_flag} for @code{true}, muitas expressões @code{itensor} usam a métrica do
1384 referencial @code{ifg} em lugar da métrica definida através de @code{imetric} para
1385 o decremento e para o incremento de índices.
1387 IMPORTANTE: Escolhendo a variável @code{iframe_flag} para @code{true} N@~{A}O
1388 remove a definição das propriedades de contração de uma métrica definida através de uma chamada a
1389 @code{defcon} ou @code{imetric}. Se um campo de referencial for usado, ele é melhor para
1390 definir a métrica através de atribuição desse nome para a variável @code{imetric}
1391 e N@~{A}O invoque a função @code{imetric}.
1393 Maxima usa esses dois tensores para definir os coeficientes de referencial (@code{ifc1}
1394 e @code{ifc2}) cuja forma parte dos coeficientes de conecção (@code{icc1}
1395 e @code{icc2}), como demonstra o seguinte exemplo:
1397 @example
1399 (%i1) load("itensor");
1400 (%o1) /share/tensor/itensor.lisp
1401 (%i2) iframe_flag:true;
1402 (%o2) true
1403 (%i3) ishow(covdiff(v([],[i]),j))$
1404 i i %1
1405 (%t3) v + icc2 v
1406 ,j %1 j
1407 (%i4) ishow(ev(%,icc2))$
1408 %1 i i i
1409 (%t4) v (ifc2 + ichr2 ) + v
1410 %1 j %1 j ,j
1411 (%i5) ishow(ev(%,ifc2))$
1412 %1 i %2
1413 v ifg (ifb - ifb + ifb )
1414 j %2 %1 %2 %1 j %1 j %2 i
1415 (%t5) -------------------------------------------------- + v
1416 2 ,j
1417 (%i6) ishow(ifb([a,b,c]))$
1418 %5 %4
1419 (%t6) ifr ifr (ifri - ifri )
1420 a b c %4,%5 c %5,%4
1422 @end example
1424 Um método alternativo é usado para calcular o suporte do referencial (@code{ifb}) se
1425 o sinalizador @code{iframe_bracket_form} é escolhido para @code{false}:
1427 @example
1429 (%i8) block([iframe_bracket_form:false],ishow(ifb([a,b,c])))$
1430 %7 %6 %6 %7
1431 (%t8) (ifr ifr - ifr ifr ) ifri
1432 a b,%7 a,%7 b c %6
1434 @end example
1437 @deffn {Função} iframes ()
1439 Uma vez que nessa versão do Maxima, identidades de contração para @code{ifr} e
1440 @code{ifri} são sempre definidas, como é o suporte do referencial (@code{ifb}), essa
1441 função não faz nada.
1443 @end deffn
1445 @defvr {Variável} ifb
1447 O suporte do referencial. A contribuição da métrica do referencial para os coeficientes
1448 de conecção é expressa usando o suporte do referencial:
1450 @example
1452 - ifb + ifb + ifb
1453 c a b b c a a b c
1454 ifc1 = --------------------------------
1455 abc 2
1457 @end example
1459 O suporte do referencial por si mesmo é definido em termos de campo de
1460 referencial e métrica do referencial. Dois métodos alternativos de
1461 cálculo são usados dependendo do valor de
1462 @code{frame_bracket_form}. Se @code{true} (o padrão) ou se o
1463 sinalizador @code{itorsion_flag} for @code{true}:
1465 @example
1467 d e f
1468 ifb = ifr ifr (ifri - ifri - ifri itr )
1469 abc b c a d,e a e,d a f d e
1472 @end example
1474 Otherwise:
1476 @example
1478 e d d e
1479 ifb = (ifr ifr - ifr ifr ) ifri
1480 abc b c,e b,e c a d
1482 @end example
1485 @end defvr
1488 @defvr {Variável} icc1
1490 Coeficientes de conecção de primeiro tipo. Em @code{itensor}, definido como
1492 @example
1494 icc1 = ichr1 - ikt1 - inmc1
1495 abc abc abc abc
1497 @end example
1499 Nessa expressão, se @code{iframe_flag} for @code{true}, o símbolo de Christoffel
1500 @code{ichr1} é substituído com o coeficiente de conecção do referencial @code{ifc1}.
1501 Se @code{itorsion_flag} for @code{false}, @code{ikt1}
1502 será omitido. @code{ikt1} é também omitido se uma base de referencial for usada, como a
1503 torsão está já calculada como parte do suporte do referencial.
1504 Ultimamente, como @code{inonmet_flag} é @code{false},
1505 @code{inmc1} não estará presente.
1508 @end defvr
1510 @defvr {Variável} icc2
1512 Coeficientes de conecção de segundo tipo. Em @code{itensor}, definido como
1514 @example
1516 c c c c
1517 icc2 = ichr2 - ikt2 - inmc2
1518 ab ab ab ab
1520 @end example
1522 Nessa expressão, se @code{iframe_flag} for @code{true}, o símbolo de Christoffel
1523 @code{ichr2} é substituído com o coeficiente de conecção @code{ifc2}.
1524 Se @code{itorsion_flag} for @code{false}, @code{ikt2}
1525 será omitido. @code{ikt2} também será omitido se uma base de referencial for usada, uma vez que a
1526 torsão já está calculada como parte do suporte do referencial.
1527 Ultimamente, como @code{inonmet_flag} é @code{false},
1528 @code{inmc2} não estará presente.
1530 @end defvr
1532 @defvr {Variável} ifc1
1534 Coeficiente de referencial de primeiro tipo (também conhecido como coeficientes de
1535 rotação de Ricci). Esse tensor representa a contribuição
1536 da métrica do referencial para o coeficiente de conecção de primeiro tipo. Definido
1537 como:
1539 @example
1541 - ifb + ifb + ifb
1542 c a b b c a a b c
1543 ifc1 = --------------------------------
1544 abc 2
1547 @end example
1549 @end defvr
1551 @defvr {Variável} ifc2
1553 Coeficiente de referencial de primeiro tipo. Esse tensor representa a contribuição
1554 da métrica do referencial para o coeficiente de conecção de primeiro tipo. Definido
1555 como uma permutação de suporte de referencial (@code{ifb}) com os índices
1556 apropriados incrementados e decrementados como necessário:
1558 @example
1560 c cd
1561 ifc2 = ifg ifc1
1562 ab abd
1564 @end example
1566 @end defvr
1568 @defvr {Variável} ifr
1570 O campo do referencial. Contrai (@code{ifri}) para e com a forma do
1571 campo inverso do referencial para formar a métrica do referencial
1572 (@code{ifg}).
1574 @end defvr
1576 @defvr {Variável} ifri
1578 O campo inverso do referencial. Especifica a base do referencial (vectores base duais). Juntamente
1579 com a métrica do referencial, forma a base de todos os cálculos baseados em
1580 referenciais.
1582 @end defvr
1584 @defvr {Variável} ifg
1586 A métrica do referencial. O valor padrão é @code{kdelta}, mas pode ser mudada usando
1587 @code{components}.
1589 @end defvr
1591 @defvr {Variável} ifgi
1593 O inverso da métrica do referencial. Contrai com a métrica do referencial (@code{ifg})
1594 para @code{kdelta}.
1596 @end defvr
1598 @defvr {Variável de Opção} iframe_bracket_form
1599 Valor por omissão: @code{true}
1601 Especifica como o suporte do referencial (@code{ifb}) é calculado.
1603 @end defvr
1605 @subsection Torsão e não metricidade
1607 Maxima pode trabalhar com torsão e não metricidade. Quando o sinalizador
1608 @code{itorsion_flag} for escolhido para @code{true}, a contribuição de torsão
1609 é adicionada aos coeficientes de conecção. Similarmente, quando o sinalizador
1610 @code{inonmet_flag} for @code{true}, componentes de não metricidades são incluídos.
1612 @defvr {Variável} inm
1614 O vector de não metricidade. Conforme a não metricidade está definida através da
1615 derivada covariante do tensor métrico. Normalmente zero, o tensor da
1616 métrica derivada covariante irá avaliar para o seguinte quando
1617 @code{inonmet_flag} for escolhido para @code{true}:
1619 @example
1621 g =- g inm
1622 ij;k ij k
1624 @end example
1626 @end defvr
1629 @defvr {Variável} inmc1
1631 Permutação covariante de componentes do vector de não metricidade. Definida como
1633 @example
1635 g inm - inm g - g inm
1636 ab c a bc ac b
1637 inmc1 = ------------------------------
1638 abc 2
1640 @end example
1642 (Substitue @code{ifg} em lugar de @code{g} se um referencial métrico for usada.)
1644 @end defvr
1646 @defvr {Variável} inmc2
1648 Permutação covariante de componentes do vector de não metricidade. Usada
1649 nos coeficicientes de conecção se @code{inonmet_flag} for @code{true}. Definida
1650 como:
1652 @example
1654 c c cd
1655 -inm kdelta - kdelta inm + g inm g
1656 c a b a b d ab
1657 inmc2 = -------------------------------------------
1658 ab 2
1660 @end example
1662 (Substitue @code{ifg} em lugar de @code{g} se um referencial métrico for usada.)
1664 @end defvr
1666 @defvr {Variável} ikt1
1668 Permutação covariante do tensor de torsão (também conhecido como contorsão).
1669 Definido como:
1671 @example
1673 d d d
1674 -g itr - g itr - itr g
1675 ad cb bd ca ab cd
1676 ikt1 = ----------------------------------
1677 abc 2
1679 @end example
1681 (Substitue @code{ifg} em lugar de @code{g} se um referencial métrico for usada.)
1683 @end defvr
1685 @defvr {Variável} ikt2
1687 Permutação contravariante do tensor de torsão (também conhecida como contorsão).
1688 Definida como:
1690 @example
1692 c cd
1693 ikt2 = g ikt1
1694 ab abd
1696 @end example
1698 (Substitue @code{ifg} em lugar de @code{g} se um referencial métrico for usada.)
1700 @end defvr
1702 @defvr {Variável} itr
1704 O tensor de torsão. Para uma métrica com torsão, diferenciação covariante
1705 repetida sobre uma funçào escalar não irá comutar,como demonstrado
1706 através do seguinte exemplo:
1708 @example
1710 (%i1) load("itensor");
1711 (%o1) /share/tensor/itensor.lisp
1712 (%i2) imetric:g;
1713 (%o2) g
1714 (%i3) covdiff(covdiff(f([],[]),i),j)-covdiff(covdiff(f([],[]),j),i)$
1715 (%i4) ishow(%)$
1716 %4 %2
1717 (%t4) f ichr2 - f ichr2
1718 ,%4 j i ,%2 i j
1719 (%i5) canform(%);
1720 (%o5) 0
1721 (%i6) itorsion_flag:true;
1722 (%o6) true
1723 (%i7) covdiff(covdiff(f([],[]),i),j)-covdiff(covdiff(f([],[]),j),i)$
1724 (%i8) ishow(%)$
1725 %8 %6
1726 (%t8) f icc2 - f icc2 - f + f
1727 ,%8 j i ,%6 i j ,j i ,i j
1728 (%i9) ishow(canform(%))$
1729 %1 %1
1730 (%t9) f icc2 - f icc2
1731 ,%1 j i ,%1 i j
1732 (%i10) ishow(canform(ev(%,icc2)))$
1733 %1 %1
1734 (%t10) f ikt2 - f ikt2
1735 ,%1 i j ,%1 j i
1736 (%i11) ishow(canform(ev(%,ikt2)))$
1737 %2 %1 %2 %1
1738 (%t11) f g ikt1 - f g ikt1
1739 ,%2 i j %1 ,%2 j i %1
1740 (%i12) ishow(factor(canform(rename(expand(ev(%,ikt1))))))$
1741 %3 %2 %1 %1
1742 f g g (itr - itr )
1743 ,%3 %2 %1 j i i j
1744 (%t12) ------------------------------------
1745 2
1746 (%i13) decsym(itr,2,1,[anti(all)],[]);
1747 (%o13) done
1748 (%i14) defcon(g,g,kdelta);
1749 (%o14) done
1750 (%i15) subst(g,nounify(g),%th(3))$
1751 (%i16) ishow(canform(contract(%)))$
1752 %1
1753 (%t16) - f itr
1754 ,%1 i j
1756 @end example
1758 @end defvr
1760 @subsection Álgebra externa (como em produto externo)
1762 O pacote @code{itensor} pode executar operações sobre campos tensores
1763 covariantes totalmente antisimétricos. Um campo tensor totalmente antisimétrico de classe
1764 (0,L) corresponde a uma forma diferencial L. Sobre esses objectos, uma
1765 operação de multiplicação funciona como um produto externo, ou produto cunha,
1766 é definido.
1768 Desafortunadamente, nem todos os autores concordam sobre a definição de produto
1769 cunha. Alguns autores preferem uma definição que corresponde à
1770 noção de antisimetrização: nessas palavras, o produto cunha de
1771 dois campos vectoriais, por exemplo, pode ser definido como
1773 @example
1774 a a - a a
1775 i j j i
1776 a /\ a = -----------
1777 i j 2
1778 @end example
1780 Mais geralmente, o produto de uma forma p e uma forma q pode ser definido como
1782 @example
1783 1 k1..kp l1..lq
1784 A /\ B = ------ D A B
1785 i1..ip j1..jq (p+q)! i1..ip j1..jq k1..kp l1..lq
1786 @end example
1788 onde @code{D} simboliza o delta de Kronecker.
1790 Outros autores, todavia, preferem uma definição ``geométrica'' que corresponde à
1791 notação de elemento volume:
1793 @example
1794 a /\ a = a a - a a
1795 i j i j j i
1796 @end example
1798 e, no caso geral
1800 @example
1801 1 k1..kp l1..lq
1802 A /\ B = ----- D A B
1803 i1..ip j1..jq p! q! i1..ip j1..jq k1..kp l1..lq
1804 @end example
1806 Uma vez que @code{itensor} é um pacote de algebra de tensores, a primeira dessas duas
1807 definições aparenta ser a mais natural por si mesma. Muitas aplicações, todavia,
1808 usam a segunda definição. Para resolver esse dilema, um sinalizador tem sido
1809 implementado que controla o comportamento do produto cunha: se
1810 @code{igeowedge_flag} for @code{false} (o padrão), a primeira, definição
1811 "tensorial" é usada, de outra forma a segunda, definição "geométrica" irá
1812 ser aplicada.
1814 @defvr {Operador} ~
1815 @ifinfo
1816 @fnindex Produto Externo
1817 @end ifinfo
1818 O operador do produto cunha é definido como sendo o acento til @code{~}. O til é
1819 um operador binário. Seus argumentos podem ser expressões envolvendo escalares,
1820 tensores covariantes de categoria 1, ou tensores covariantes de categoria @code{l} que
1821 tiverem sido declarados antisimétricos em todos os índices covariantes.
1823 O comportamento do operador do produto cunha é controlado através do
1824 sinalizador @code{igeowedge_flag}, como no seguinte exemplo:
1826 @example
1827 (%i1) load("itensor");
1828 (%o1) /share/tensor/itensor.lisp
1829 (%i2) ishow(a([i])~b([j]))$
1830 a b - b a
1831 i j i j
1832 (%t2) -------------
1833 2
1834 (%i3) decsym(a,2,0,[anti(all)],[]);
1835 (%o3) done
1836 (%i4) ishow(a([i,j])~b([k]))$
1837 a b + b a - a b
1838 i j k i j k i k j
1839 (%t4) ---------------------------
1840 3
1841 (%i5) igeowedge_flag:true;
1842 (%o5) true
1843 (%i6) ishow(a([i])~b([j]))$
1844 (%t6) a b - b a
1845 i j i j
1846 (%i7) ishow(a([i,j])~b([k]))$
1847 (%t7) a b + b a - a b
1848 i j k i j k i k j
1849 @end example
1851 @end defvr
1853 @defvr {Operador} |
1854 @ifinfo
1855 @fnindex Contração com um vector
1856 @end ifinfo
1857 A barra vertical @code{|} denota a operação binária
1858 "contração com um vector". Quando um tensor covariante totalmente antisimétrico é contraído
1859 com um vector contravariante, o resultado é o mesmo independente de qual índice
1860 foi usado para a contração. Dessa forma, é possível definir a
1861 operação de contração de uma forma livre de índices.
1863 No pacote @code{itensor}, contração com um vector é sempre realizada
1864 com relação ao primeiro índice na ordem literal de ordenação. Isso garante
1865 uma melhor simplificação de expressões envolvendo o operador @code{|}. Por exemplo:
1867 @example
1868 (%i1) load("itensor");
1869 (%o1) /share/tensor/itensor.lisp
1870 (%i2) decsym(a,2,0,[anti(all)],[]);
1871 (%o2) done
1872 (%i3) ishow(a([i,j],[])|v)$
1873 %1
1874 (%t3) v a
1875 %1 j
1876 (%i4) ishow(a([j,i],[])|v)$
1877 %1
1878 (%t4) - v a
1879 %1 j
1880 @end example
1882 Note que isso é essencial que os tensores usado como o operador @code{|} seja
1883 declarado totalmente antisimétrico em seus índices covariantes. De outra forma,
1884 os resultados serão incorrectos.
1886 @end defvr
1888 @deffn {Função} extdiff (@var{expr}, @var{i})
1890 Calcula a derivada externa de @var{expr} com relação ao índice
1891 @var{i}. A derivada externa é formalmente definida como o produto
1892 cunha do operador de derivada parcial e uma forma diferencial. Como
1893 tal, essa operação é também controlada através da escolha de @code{igeowedge_flag}.
1894 Por exemplo:
1896 @example
1897 (%i1) load("itensor");
1898 (%o1) /share/tensor/itensor.lisp
1899 (%i2) ishow(extdiff(v([i]),j))$
1900 v - v
1901 j,i i,j
1902 (%t2) -----------
1903 2
1904 (%i3) decsym(a,2,0,[anti(all)],[]);
1905 (%o3) done
1906 (%i4) ishow(extdiff(a([i,j]),k))$
1907 a - a + a
1908 j k,i i k,j i j,k
1909 (%t4) ------------------------
1910 3
1911 (%i5) igeowedge_flag:true;
1912 (%o5) true
1913 (%i6) ishow(extdiff(v([i]),j))$
1914 (%t6) v - v
1915 j,i i,j
1916 (%i7) ishow(extdiff(a([i,j]),k))$
1917 (%t7) a - a + a
1918 j k,i i k,j i j,k
1919 @end example
1921 @end deffn
1923 @deffn {Função} hodge (@var{expr})
1925 Calcula o Hodge dual de @var{expr}. Por exemplo:
1927 @example
1929 (%i1) load("itensor");
1930 (%o1) /share/tensor/itensor.lisp
1931 (%i2) imetric(g);
1932 (%o2) done
1933 (%i3) idim(4);
1934 (%o3) done
1935 (%i4) icounter:100;
1936 (%o4) 100
1937 (%i5) decsym(A,3,0,[anti(all)],[])$
1939 (%i6) ishow(A([i,j,k],[]))$
1940 (%t6) A
1941 i j k
1942 (%i7) ishow(canform(hodge(%)))$
1943 %1 %2 %3 %4
1944 levi_civita g A
1945 %1 %102 %2 %3 %4
1946 (%t7) -----------------------------------------
1947 6
1948 (%i8) ishow(canform(hodge(%)))$
1949 %1 %2 %3 %8 %4 %5 %6 %7
1950 (%t8) levi_civita levi_civita g g
1951 %1 %106 %2 %107
1952 g g A /6
1953 %3 %108 %4 %8 %5 %6 %7
1954 (%i9) lc2kdt(%)$
1956 (%i10) %,kdelta$
1958 (%i11) ishow(canform(contract(expand(%))))$
1959 (%t11) - A
1960 %106 %107 %108
1962 @end example
1964 @end deffn
1966 @defvr {Variável de Opção} igeowedge_flag
1967 Valor por omissão: @code{false}
1969 Controla o comportamento de produto cunha e derivada externa. Quando
1970 for esconhida para @code{false} (o padrão), a noção de formas diferenciais irá
1971 corresponder àquela de um campo tensor covariante totalmente antisimétrico.
1972 Quando escolhida para @code{true}, formas diferenciais irão concordar com a noção do
1973 elemento volume.
1975 @end defvr
1978 @subsection Exportando expressões TeX
1980 O pacote @code{itensor} fornece suporte limitado à exportação de expressões
1981 de tensores para o TeX. Uma vez que expressões @code{itensor} aparecem como chamada a funções,
1982 o comando regular @code{tex} do Maxima não produzirá a saída
1983 esperada. Pode tentar no seu lugar o comando @code{tentex}, o qual tenta
1984 traduzir expressões de tensores dentro de objectos TeX indexados apropriadamente.
1986 @deffn {Função} tentex (@var{expr})
1988 Para usar a função @code{tentex}, deve primeiro chamar @code{tentex},
1989 como no seguinte exemplo:
1991 @example
1993 (%i1) load("itensor");
1994 (%o1) /share/tensor/itensor.lisp
1995 (%i2) load("tentex");
1996 (%o2) /share/tensor/tentex.lisp
1997 (%i3) idummyx:m;
1998 (%o3) m
1999 (%i4) ishow(icurvature([j,k,l],[i]))$
2000 m1 i m1 i i i
2001 (%t4) ichr2 ichr2 - ichr2 ichr2 - ichr2 + ichr2
2002 j k m1 l j l m1 k j l,k j k,l
2003 (%i5) tentex(%)$
2004 $$\Gamma_@{j\,k@}^@{m_1@}\,\Gamma_@{l\,m_1@}^@{i@}-\Gamma_@{j\,l@}^@{m_1@}\,
2005 \Gamma_@{k\,m_1@}^@{i@}-\Gamma_@{j\,l,k@}^@{i@}+\Gamma_@{j\,k,l@}^@{i@}$$
2007 @end example
2009 Note o uso da declaração @code{idummyx}, para evitar o aparecimento
2010 do sinal de porcentagem na expressão TeX, o qual pode induzir a erros de compilação.
2012 Note Bem: Essa vesão da função @code{tentex} é um tanto quanto experimental.
2014 @end deffn
2016 @subsection Interagindo com o pacote @code{ctensor}
2018 O pacote @code{itensor} possui a habilidade de gerar código Maxima que pode
2019 então ser executado no contexto do pacote @code{ctensor}. A função que executa
2020 essa tarefa é @code{ic_convert}.
2022 @deffn {Função} ic_convert (@var{eqn})
2024 Converte a equação @var{eqn} na sintaxe @code{itensor} para uma declaração de atribuição @code{ctensor}.
2025 Adições implícitas sobre índices que ocorrem exactamente duas vezes são tornadas explícitas enquanto objectos
2026 indexados são transformados em arrays (os arrays subscritos estão na
2027 ordem de covariância seguidos de índices contravariantes dos objectos
2028 indexados). A derivada de um objecto indexado será substituída pela
2029 forma substantiva de @code{diff} tomada com relação a @code{ct_coords} subscrita
2030 pelo índice de derivação. Os símbolos de Christoffel @code{ichr1} e @code{ichr2}
2031 irão ser traduzidos para @code{lcs} e @code{mcs}, respectivamente e se
2032 @code{metricconvert} for @code{true} então todas as ocorrências da métrica
2033 com dois índices covariantes (ou contravariantes) irão ser renomeadas para @code{lg}
2034 (ou @code{ug}). Adicionalmente, ciclos @code{do} irão ser introduzidos adicionando sobre
2035 todos os índices livres de forma que a
2036 declaração de atribuição transformada pode ser avaliada através de apenas fazendo
2037 @code{ev}. Os seguintes exemplos demonstam os recursos dessa
2038 função.
2040 @example
2041 (%i1) load("itensor");
2042 (%o1) /share/tensor/itensor.lisp
2043 (%i2) eqn:ishow(t([i,j],[k])=f([],[])*g([l,m],[])*a([],[m],j)*b([i],[l,k]))$
2044 k m l k
2045 (%t2) t = f a b g
2046 i j ,j i l m
2047 (%i3) ic_convert(eqn);
2048 (%o3) for i thru dim do (for j thru dim
2050 do (for k thru dim do t : f sum(sum(diff(a , ct_coords ) b
2051 i, j, k m j i, l, k
2053 g , l, 1, dim), m, 1, dim)))
2054 l, m
2055 (%i4) imetric(g);
2056 (%o4) done
2057 (%i5) metricconvert:true;
2058 (%o5) true
2059 (%i6) ic_convert(eqn);
2060 (%o6) for i thru dim do (for j thru dim
2062 do (for k thru dim do t : f sum(sum(diff(a , ct_coords ) b
2063 i, j, k m j i, l, k
2065 lg , l, 1, dim), m, 1, dim)))
2066 l, m
2067 @end example
2069 @end deffn
2071 @subsection Palavras reservadas
2073 As palavras seguintes do Maxima são usadas internamente pelo pacote @code{itensor} e
2074 não podem ser redefinidas:
2076 @c REFORMAT THIS TABLE USING TEXINFO MARKUP
2077 @example
2078 Keyword Comments
2079 ------------------------------------------
2080 indices2() versão interna de @code{indices()}
2081 conti Lista de índices contravariantes
2082 covi Lista de índices covariantes de um objecto indexado
2083 deri Lista de índices de derivada de um objecto indexado
2084 name Retorna o nome de um objecto indexado
2085 concan
2086 irpmon
2087 lc0
2088 _lc2kdt0
2089 _lcprod
2090 _extlc
2091 @end example