Introducedilhaão a ctensor
==========================

ctensor é um pacote de manipulacedilhaão de componentes.  Para usar o pacote ctensor, digite load(ctensor).  Para comecedilhaar uma sessão iterativa com ctensor, digite csetup(). O primeiro que será pedido pelo pacote é a dimensão a ser manipulada. Se a dimensão for 2, 3 ou 4 então a lista de coordenadas padrão é [x,y], [x,y,z] ou [x,y,z,t] respectivamente.  Esses nomes podem ser mudados através da atribuicedilhaão de uma nova lista de coordenadas para a variável ct_coords (descrita abaixo) e o utilizador é questionado sobre isso. Deve ter o cuidado de evitar conflitos de nomes de coordenadas com outras definicedilhaões de objectos.

No próximo passo, o utilizador informa a métrica ou directamente ou de um ficheiro especificando sua posicedilhaão ordinal. Como um exemplo de um ficheiro de métrica comum, veja share/tensor/metrics.mac. A métrica é armazenada na matriz LG. Finalmente, o inverso da métrica é calculado e armazenado na matriz UG. Se tem a opcedilhaão de realizar todos os cálculos em séries de potência.

A seguir, mostramos um exemplo de protocolo para a métrica estática, esfericamente simétrica (coordenadas padrão) que será aplicada ao problema de derivacedilhaão das equacedilhaões de vácuo de Einstein (que levam à solucedilhaão de Schwarzschild). Muitas das funcedilhaões em ctensor irão ser mostradas como exemplos para a métrica padrão.

     (%i1) load(ctensor);
     (%o1)      /usr/local/lib/maxima/share/tensor/ctensor.mac
     (%i2) csetup();
     Enter the dimension of the coordinate system:
     4;
     Do you wish to change the coordinate names?
     n;
     Do you want to
     1. Enter a new metric?

     2. Enter a metric from a file?

     3. Approximate a metric with a Taylor series?
     1;

     Is the matrix  1. Diagonal  2. Symmetric  3. Antisymmetric  4. General
     Answer 1, 2, 3 or 4
     1;
     Row 1 Column 1:
     a;
     Row 2 Column 2:
     x^2;
     Row 3 Column 3:
     x^2*sin(y)^2;
     Row 4 Column 4:
     -d;

     Matrix entered.
     Enter functional dependencies with the DEPENDS function or 'N' if none
     depends([a,d],x);
     Do you wish to see the metric?
     y;
                               [ a  0       0        0  ]
                               [                        ]
                               [     2                  ]
                               [ 0  x       0        0  ]
                               [                        ]
                               [         2    2         ]
                               [ 0  0   x  sin (y)   0  ]
                               [                        ]
                               [ 0  0       0       - d ]
     (%o2)                                done
     (%i3) christof(mcs);
                                                 a
                                                  x
     (%t3)                          mcs        = ---
                                       1, 1, 1   2 a

                                                  1
     (%t4)                           mcs        = -
                                        1, 2, 2   x

                                                  1
     (%t5)                           mcs        = -
                                        1, 3, 3   x

                                                 d
                                                  x
     (%t6)                          mcs        = ---
                                       1, 4, 4   2 d

                                                   x
     (%t7)                          mcs        = - -
                                       2, 2, 1     a

                                                cos(y)
     (%t8)                         mcs        = ------
                                      2, 3, 3   sin(y)

                                                    2
                                               x sin (y)
     (%t9)                      mcs        = - ---------
                                   3, 3, 1         a

     (%t10)                   mcs        = - cos(y) sin(y)
                                 3, 3, 2

                                                 d
                                                  x
     (%t11)                         mcs        = ---
                                       4, 4, 1   2 a
     (%o11)                               done

Definicedilhaões para ctensor
=============================

Inicializacedilhaão e configuracedilhaão
----------------------------------------

 -- Funcedilhaão: csetup ()
     É uma funcedilhaão no pacote ctensor (component tensor) que inicializa o pacote e permite ao utilizador inserir uma métrica interativamente. Veja ctensor para mais detalhes.

 -- Funcedilhaão: cmetric (DIS)
 -- Funcedilhaão: cmetric ()
     É uma funcedilhaão no pacote ctensor que calcula o inverso da métrica e prepara o pacote para cálculos adiante.

     Se cframe_flag for false, a funcedilhaão calcula a métrica inversa ug a partir da matriz lg (definida pelo utilizador). O determinante da métrica é também calculado e armazenado na variável gdet. Mais adiante, o pacote determina se a métrica é diagonal e escolhe o valor de diagmetric conforme a determinacedilhaão. Se o argumento opcional DIS estiver presente e não for false, a saída é mostrada ao utilizador pela linha de comando para que ele possa ver o inverso da métrica.

     Se cframe_flag for true, a funcedilhaão espera que o valor de fri (a matriz referencial inversa) e lfg (a métrica do referencial) sejam definidas. A partir dessas, a matriz do referencial fr e a métrica do referencial inverso ufg são calculadas.

 -- Funcedilhaão: ct_coordsys (SISTEMA_DE_COORDENADAS, EXTRA_ARG)
 -- Funcedilhaão: ct_coordsys (SISTEMA_DE_COORDENADAS)
     Escolhe um sistema de coordenadas predefinido e uma métrica. O argumento SISTEMA_DE_COORDENADAS pode ser um dos seguintes símbolos:

            SYMBOL               Dim Coordenadas       Descricedilhaão/comentários
            --------------------------------------------------------------------------
            cartesian2d           2  [x,y]             Sist. de coord. cartesianas 2D
            polar                 2  [r,phi]           Sist. de coord. Polare
            elliptic              2  [u,v]
            confocalelliptic      2  [u,v]
            bipolar               2  [u,v]
            parabolic             2  [u,v]
            cartesian3d           3  [x,y,z]           Sist. de coord. cartesianas 3D
            polarcylindrical      3  [r,theta,z]
            ellipticcylindrical   3  [u,v,z]           Elíptica 2D com Z cilíndrico
            confocalellipsoidal   3  [u,v,w]
            bipolarcylindrical    3  [u,v,z]           Bipolar 2D com Z cilíndrico
            paraboliccylindrical  3  [u,v,z]           Parabólico 2D com Z cilíndrico
            paraboloidal          3  [u,v,phi]
            conical               3  [u,v,w]
            toroidal              3  [u,v,phi]
            spherical             3  [r,theta,phi]     Sist. de coord. Esféricas
            oblatespheroidal      3  [u,v,phi]
            oblatespheroidalsqrt  3  [u,v,phi]
            prolatespheroidal     3  [u,v,phi]
            prolatespheroidalsqrt 3  [u,v,phi]
            ellipsoidal           3  [r,theta,phi]
            cartesian4d           4  [x,y,z,t]         Sist. de coord. 4D
            spherical4d           4  [r,theta,eta,phi]
            exteriorschwarzschild 4  [t,r,theta,phi]   Métrica de Schwarzschild
            interiorschwarzschild 4  [t,z,u,v]        Métrica de Schwarzschild Interior
            kerr_newman           4  [t,r,theta,phi]   Métrica simétrica axialmente alterada

     sistema_de_coordenadas pode também ser uma lista de funcedilhaões de transformacedilhaão, seguida por uma lista contendo as varáveis coordenadas. Por exemplo, pode especificar uma métrica esférica como segue:

          (%i1) load(ctensor);
          (%o1)       /share/tensor/ctensor.mac
          (%i2) ct_coordsys([r*cos(theta)*cos(phi),r*cos(theta)*sin(phi),
                r*sin(theta),[r,theta,phi]]);
          (%o2)                                done
          (%i3) lg:trigsimp(lg);
                                     [ 1  0         0        ]
                                     [                       ]
                                     [     2                 ]
          (%o3)                      [ 0  r         0        ]
                                     [                       ]
                                     [         2    2        ]
                                     [ 0  0   r  cos (theta) ]
          (%i4) ct_coords;
          (%o4)                           [r, theta, phi]
          (%i5) dim;
          (%o5)                                  3

     Funcedilhaões de transformacedilhaão podem também serem usadas quando cframe_flag for true:

          (%i1) load(ctensor);
          (%o1)       /share/tensor/ctensor.mac
          (%i2) cframe_flag:true;
          (%o2)                                true
          (%i3) ct_coordsys([r*cos(theta)*cos(phi),r*cos(theta)*sin(phi),
                r*sin(theta),[r,theta,phi]]);
          (%o3)                                done
          (%i4) fri;
                [ cos(phi) cos(theta)  - cos(phi) r sin(theta)  - sin(phi) r cos(theta) ]
                [                                                                       ]
          (%o4) [ sin(phi) cos(theta)  - sin(phi) r sin(theta)   cos(phi) r cos(theta)  ]
                [                                                                       ]
                [     sin(theta)            r cos(theta)                   0            ]
          (%i5) cmetric();
          (%o5)                                false
          (%i6) lg:trigsimp(lg);
                                     [ 1  0         0        ]
                                     [                       ]
                                     [     2                 ]
          (%o6)                      [ 0  r         0        ]
                                     [                       ]
                                     [         2    2        ]
                                     [ 0  0   r  cos (theta) ]

     O argumento opcional EXTRA_ARG pode ser qualquer um dos seguintes:

     cylindrical diz a ct_coordsys para anexar uma coordenada adicional cilíndrica.

     minkowski diz a ct_coordsys para anexar uma coordenada com assinatura métrica negativa.

     all diz a ct_coordsys para chamar cmetric e christof(false) após escolher a métrica.

     Se a variável global verbose for escolhida para true, ct_coordsys mostra os valores de dim, ct_coords, e ou lg ou lfg e fri, dependendo do valor de cframe_flag.

 -- Funcedilhaão: init_ctensor ()
     Inicializa o pacote ctensor.

     A funcedilhaão init_ctensor reinicializa o pacote ctensor. Essa funcedilhaão remove todos os arrays e matrizes usados por ctensor, coloca todos os sinalizadores de volta a seus valores padrão, retorna dim para 4, e retorna a métrica do referencial para a métrica do referencial de Lorentz.

Os tensores do espacedilhao curvo
---------------------------------

O principal propósito do pacote ctensor é calcular os tensores do espacedilha(tempo) curvo, mais notavelmente os tensores usados na relatividade geral.

Quando uma base métrica é usada, ctensor pode calcular os seguintes tensores:

      lg  -- ug
        \      \
         lcs -- mcs -- ric -- uric
                   \      \       \
                    \      tracer - ein -- lein
                     \
                      riem -- lriem -- weyl
                          \
                           uriem

ctensor pode também usar referenciais móveis. Quando cframe_flag for escolhida para true, os seguintes tensores podem ser calculados:

      lfg -- ufg
          \
      fri -- fr -- lcs -- mcs -- lriem -- ric -- uric
           \                       |  \      \       \
            lg -- ug               |   weyl   tracer - ein -- lein
                                   |\
                                   | riem
                                   |
                                   \uriem

 -- Funcedilhaão: christof (DIS)
     Uma funcedilhaão no pacote ctensor.  Essa funcedilhaão calcula os símbolos de Christoffel de ambos os tipos.  O argumento DIS determina quais resultados são para serem imediatamente mostrados.  Os símbolos de Christoffel de primeiro e de segundo tipo são armazenados nos arrays lcs[i,j,k] e mcs[i,j,k] respectivamente e definidos para serem simétricos nos primeiros dois índices. Se o argumento para christof for lcs ou for mcs então o único valor não nulo de lcs[i,j,k] ou de mcs[i,j,k], respectivamente, será mostrado. Se o argumento for all então o único valor não nulo de lcs[i,j,k] e o único valor não nulo de mcs[i,j,k] serão mostrados.  Se o argumento for false então a exibicedilhaão dos elementos não acontecerá. Os elementos do array mcs[i,j,k] são definidos de uma tal maneira que o índice final é contravariante.

 -- Funcedilhaão: ricci (DIS)
     Uma funcedilhaão no pacote ctensor.  ricci calcula as componentes contravariantes (simétricas) ric[i,j] do tensor de Ricci.  Se o argumento DIS for true, então as componentes não nulas são mostradas.

 -- Funcedilhaão: uricci (DIS)
     Essa funcedilhaão primeiro calcula as componentes contravariantes ric[i,j] do tensor de Ricci.  Então o tensor misto de Ricci é calculado usando o tensor métrico contravariante. Se o valor do argumento DIS for true, então essas componentes mistas, uric[i,j] (o índice "i" é covariante e o índice "j" é contravariante), serão mostradas directamente.  De outra forma, ricci(false) irá simplesmente calcular as entradas do array uric[i,j] sem mostrar os resultados.

 -- Funcedilhaão: scurvature ()

     Retorna a curvatura escalar (obtida através da contracedilhaão do tensor de Ricci) do Riemaniano multiplicado com a métrica dada.

 -- Funcedilhaão: einstein (DIS)
     Uma funcedilhaão no pacote ctensor.  einstein calcula o tensor misto de Einstein após os símbolos de Christoffel e o tensor de Ricci terem sido obtidos (com as funcedilhaões christof e ricci).  Se o argumento DIS for true, então os valores não nulos do tensor misto de Einstein ein[i,j] serão mostrados quando j for o índice contravariante.  A variável rateinstein fará com que a simplificacedilhaão racional ocorra sobre esses componentes. Se ratfac for true então as componentes irão também ser factoradas.

 -- Funcedilhaão: leinstein (DIS)
     Tensor covariante de Einstein. leinstein armazena o valor do tensor covariante de Einstein no array lein. O tensor covariante de Einstein é calculado a partir tensor misto de Einstein ein através da multiplicacedilhaão desse pelo tensor métrico. Se o argumento DIS for true, então os valores não nulos do tensor covariante de Einstein são mostrados.

 -- Funcedilhaão: riemann (DIS)
     Uma funcedilhaão no pacote ctensor.  riemann calcula o tensor de curvatura de Riemann a partir da métrica dada e correspondendo aos símbolos de Christoffel. As seguintes convencedilhaões de índice são usadas:

                          l      _l       _l       _l   _m    _l   _m
           R[i,j,k,l] =  R    = |      - |      + |    |   - |    |
                          ijk     ij,k     ik,j     mk   ij    mj   ik

     Essa notacedilhaão é consistente com a notacedilhaão usada por no pacote itensor e sua funcedilhaão icurvature.  Se o argumento opcional DIS for true, as componentes não nulas riem[i,j,k,l] serão mostradas.  Como com o tensor de Einstein, vários comutadores escolhidos pelo utilizador controlam a simplificacedilhaão de componentes do tensor de Riemann.  Se ratriemann for true, então simplificacedilhaão racional será feita. Se ratfac for true então cada uma das componentes irá também ser factorada.

     Se a variável cframe_flag for false, o tensor de Riemann é calculado directamente dos símbolos de Christoffel. Se cframe_flag for true, o tensor covariante de Riemann é calculado primeiro dos coeficientes de campo do referencial.

 -- Funcedilhaão: lriemann (DIS)
     Tensor covariante de Riemann (lriem[]).

     Calcula o tensor covariante de Riemann como o array lriem. Se o argumento DIS for true, únicos valores não nulos são mostrados.

     Se a variável cframe_flag for true, o tensor covariante de Riemann é calculado directamente dos coeficientes de campo do referencial. De outra forma, o tensor (3,1) de Riemann é calculado primeiro.

     Para informacedilhaão sobre a ordenacedilhaão de índice, veja riemann.

 -- Funcedilhaão: uriemann (DIS)
     Calcula as componentes contravariantes do tensor de curvatura de Riemann como elementos do array uriem[i,j,k,l].  Esses são mostrados se DIS for true.

 -- Funcedilhaão: rinvariant ()
     Compõe o invariante de Kretchmann (kinvariant) obtido através da contracedilhaão dos tensores

          lriem[i,j,k,l]*uriem[i,j,k,l].

     Esse objecto não é automaticamente simplificado devido ao facto de poder ser muito largo.

 -- Funcedilhaão: weyl (DIS)
     Calcula o tensor conformal de Weyl.  Se o argumento DIS for true, as componentes não nulas weyl[i,j,k,l] irão ser mostradas para o utilizador.  De outra forma, essas componentes irão simplesmente serem calculadas e armazenadas.  Se o comutador ratweyl é escolhido para true, então as componentes irão ser racionalmente simplificadas; se ratfac for true então os resultados irão ser factorados também.

Expansão das séries de Taylor
-----------------------------

O pacote ctensor possui a habilidade para truncar resultados assumindo que eles são aproximacedilhaões das séries de Taylor. Esse comportamenteo é controlado através da variável ctayswitch; quando escolhida para true, ctensor faz uso internamente da funcedilhaão ctaylor quando simplifica resultados.

A funcedilhaão ctaylor é invocada pelas seguintes funcedilhaões de ctensor:

         Function     Comments
         ---------------------------------
         christof()   só para mcs
         ricci()
         uricci()
         einstein()
         riemann()
         weyl()
         checkdiv()

 -- Funcedilhaão: ctaylor ()

     A funcedilhaão ctaylor trunca seus argumentos através da conversão destes para uma série de Taylor usando taylor, e então chamando ratdisrep. Isso tem efeito combinado de abandonar termos de ordem mais alta na variável de expansão ctayvar. A ordem dos termos que podem ser abandonados é definida através de ctaypov; o ponto em torno do qual a expansão da série é realizada está especificado em ctaypt.

     Como um exemplo, considere uma métrica simples que é uma perturbacedilhaão da métrica de Minkowski. Sem restricedilhaões adicionais, mesmo uma métrica diagonal produz expressões para o tensor de Einstein que são de longe muito complexas:

          (%i1) load(ctensor);
          (%o1)       /share/tensor/ctensor.mac
          (%i2) ratfac:true;
          (%o2)                                true
          (%i3) derivabbrev:true;
          (%o3)                                true
          (%i4) ct_coords:[t,r,theta,phi];
          (%o4)                         [t, r, theta, phi]
          (%i5) lg:matrix([-1,0,0,0],[0,1,0,0],[0,0,r^2,0],[0,0,0,r^2*sin(theta)^2]);
                                  [ - 1  0  0         0        ]
                                  [                            ]
                                  [  0   1  0         0        ]
                                  [                            ]
          (%o5)                   [          2                 ]
                                  [  0   0  r         0        ]
                                  [                            ]
                                  [              2    2        ]
                                  [  0   0  0   r  sin (theta) ]
          (%i6) h:matrix([h11,0,0,0],[0,h22,0,0],[0,0,h33,0],[0,0,0,h44]);
                                      [ h11   0    0    0  ]
                                      [                    ]
                                      [  0   h22   0    0  ]
          (%o6)                       [                    ]
                                      [  0    0   h33   0  ]
                                      [                    ]
                                      [  0    0    0   h44 ]
          (%i7) depends(l,r);
          (%o7)                               [l(r)]
          (%i8) lg:lg+l*h;
                   [ h11 l - 1      0          0                 0            ]
                   [                                                          ]
                   [     0      h22 l + 1      0                 0            ]
                   [                                                          ]
          (%o8)    [                        2                                 ]
                   [     0          0      r  + h33 l            0            ]
                   [                                                          ]
                   [                                    2    2                ]
                   [     0          0          0       r  sin (theta) + h44 l ]
          (%i9) cmetric(false);
          (%o9)                                done
          (%i10) einstein(false);
          (%o10)                               done
          (%i11) ntermst(ein);
          [[1, 1], 62]
          [[1, 2], 0]
          [[1, 3], 0]
          [[1, 4], 0]
          [[2, 1], 0]
          [[2, 2], 24]
          [[2, 3], 0]
          [[2, 4], 0]
          [[3, 1], 0]
          [[3, 2], 0]
          [[3, 3], 46]
          [[3, 4], 0]
          [[4, 1], 0]
          [[4, 2], 0]
          [[4, 3], 0]
          [[4, 4], 46]
          (%o12)                               done

     Todavia, se nós recalcularmos esse exemplo como uma aproximacedilhaão que é linear na variável l, pegamos expressões muito simples:

          (%i14) ctayswitch:true;
          (%o14)                               true
          (%i15) ctayvar:l;
          (%o15)                                 l
          (%i16) ctaypov:1;
          (%o16)                                 1
          (%i17) ctaypt:0;
          (%o17)                                 0
          (%i18) christof(false);
          (%o18)                               done
          (%i19) ricci(false);
          (%o19)                               done
          (%i20) einstein(false);
          (%o20)                               done
          (%i21) ntermst(ein);
          [[1, 1], 6]
          [[1, 2], 0]
          [[1, 3], 0]
          [[1, 4], 0]
          [[2, 1], 0]
          [[2, 2], 13]
          [[2, 3], 2]
          [[2, 4], 0]
          [[3, 1], 0]
          [[3, 2], 2]
          [[3, 3], 9]
          [[3, 4], 0]
          [[4, 1], 0]
          [[4, 2], 0]
          [[4, 3], 0]
          [[4, 4], 9]
          (%o21)                               done
          (%i22) ratsimp(ein[1,1]);
                                   2      2  4               2     2
          (%o22) - (((h11 h22 - h11 ) (l )  r  - 2 h33 l    r ) sin (theta)
                                        r               r r

                                          2               2      4    2
                            - 2 h44 l    r  - h33 h44 (l ) )/(4 r  sin (theta))
                                     r r                r

     Essa compatibilidade pode ser útil, por exemplo, quando trabalhamos no limite do campo fraco longe de uma fonte gravitacional.

Campos de referencial
---------------------

Quando a variável cframe_flag for escolhida para true, o pacote ctensor executa seus cálculos usando um referencial móvel.

 -- Funcedilhaão: frame_bracket (FR, FRI, DIAGFRAME)
     O delimitador do referencial (fb[]).

     Calcula o delimitador do referencial conforme a seguinte definicedilhaão:

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

Classificacedilhaão Algébrica
-----------------------------

Um novo recurso (a partir de November de 2004) de ctensor é sua habilidade para calcular a classificacedilhaão de Petrov de uma métrica espacedilhao tempo tetradimensional. Para uma demonstracedilhaão dessa compatibilidade, veja o ficheiro share/tensor/petrov.dem.

 -- Funcedilhaão: nptetrad ()
     Calcula um tetrad nulo de Newman-Penrose (np) e seus índices ascendentes em contrapartida (npi). Veja petrov para um exemplo.

     O tetrad nulo é construído assumindo que um referencial métrico ortonormal tetradimensional com assinatura métrica (-,+,+,+) está sendo usada.  As componentes do tetrad nulo são relacionadas para a matriz referencial inversa como segue:

          np  = (fri  + fri ) / sqrt(2)
            1       1      2

          np  = (fri  - fri ) / sqrt(2)
            2       1      2

          np  = (fri  + %i fri ) / sqrt(2)
            3       3         4

          np  = (fri  - %i fri ) / sqrt(2)
            4       3         4

 -- Funcedilhaão: psi (DIS)
     Calcula os cinco coeficientes de Newman-Penrose psi[0]...psi[4]. Se psi for escolhida para true, os coeficientes são mostrados. Veja petrov para um exemplo.

     Esses coeficientes são calculados a partir do tensor de Weyl em uma base de coordenada.  Se uma base de referencial for usada, o tensor de Weyl é primeiro convertido para a base de coordenada, que pode ser um procedimento computacional expansível. Por essa razão, em alguns casos pode ser mais vantajoso usar uma base de coordenada em primeiro lugar antes que o tensor de Weyl seja calculado. Note todavia, que para a construcedilhaão de um tetrad nulo de Newman-Penrose é necessário uma base de referencial. Portanto, uma sequência de cálculo expressiva pode comecedilhaar com uma base de referencial, que é então usada para calcular lg (calculada automaticamente através de cmetric) e em seguida calcula ug. Nesse ponto, pode comutar de volta para uma base de coordenada escolhendo cframe_flag para false antes de comecedilhaar a calcular os símbolos de Christoffel. Mudando para uma base de referencial num estágio posterior pode retornar resultados inconsistentes, já que pode terminar com uma grande mistura de tensores, alguns calculados numa base de referencial, e outros numa base de coordenada, sem nenhum modo para distinguir entre os dois tipos.

 -- Funcedilhaão: petrov ()
     Calcula a classificacedilhaão de petrov da métrica caracterizada através de psi[0]...psi[4].

     Por exemplo, o seguinte demonstra como obter a classificacedilhaão de Petrov da métrica de Kerr:

          (%i1) load(ctensor);
          (%o1)       /share/tensor/ctensor.mac
          (%i2) (cframe_flag:true,gcd:spmod,ctrgsimp:true,ratfac:true);
          (%o2)                                true
          (%i3) ct_coordsys(exteriorschwarzschild,all);
          (%o3)                                done
          (%i4) ug:invert(lg)$
          (%i5) weyl(false);
          (%o5)                                done
          (%i6) nptetrad(true);
          (%t6) np =

                 [  sqrt(r - 2 m)           sqrt(r)                                     ]
                 [ ---------------   ---------------------      0             0         ]
                 [ sqrt(2) sqrt(r)   sqrt(2) sqrt(r - 2 m)                              ]
                 [                                                                      ]
                 [  sqrt(r - 2 m)            sqrt(r)                                    ]
                 [ ---------------  - ---------------------     0             0         ]
                 [ sqrt(2) sqrt(r)    sqrt(2) sqrt(r - 2 m)                             ]
                 [                                                                      ]
                 [                                              r      %i r sin(theta)  ]
                 [        0                    0             -------   ---------------  ]
                 [                                           sqrt(2)       sqrt(2)      ]
                 [                                                                      ]
                 [                                              r       %i r sin(theta) ]
                 [        0                    0             -------  - --------------- ]
                 [                                           sqrt(2)        sqrt(2)     ]

                                       sqrt(r)          sqrt(r - 2 m)
          (%t7) npi = matrix([- ---------------------, ---------------, 0, 0],
                                sqrt(2) sqrt(r - 2 m)  sqrt(2) sqrt(r)

                    sqrt(r)            sqrt(r - 2 m)
          [- ---------------------, - ---------------, 0, 0],
             sqrt(2) sqrt(r - 2 m)    sqrt(2) sqrt(r)

                     1               %i
          [0, 0, ---------, --------------------],
                 sqrt(2) r  sqrt(2) r sin(theta)

                     1                 %i
          [0, 0, ---------, - --------------------])
                 sqrt(2) r    sqrt(2) r sin(theta)

          (%o7)                                done
          (%i7) psi(true);
          (%t8)                              psi  = 0
                                                0

          (%t9)                              psi  = 0
                                                1

                                                    m
          (%t10)                             psi  = --
                                                2    3
                                                    r

          (%t11)                             psi  = 0
                                                3

          (%t12)                             psi  = 0
                                                4
          (%o12)                               done
          (%i12) petrov();
          (%o12)                                 D

     A funcedilhaão de classificacedilhaão Petrov é baseada no algoritmo publicado em "Classifying geometries in general relativity: III Classification in practice" por Pollney, Skea, e d'Inverno, Class. Quant. Grav. 17 2885-2902 (2000). Exceto para alguns casos de teste simples, a implementacedilhaão não está testada até 19 de Dezembro de 2004, e é provável que contenha erros.

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

ctensor possui a habilidade de calcular e incluir coeficientes de torsão e não metricidade nos coeficientes de coneccedilhaão.

Os coeficientes de torsão são calculados a partir de um tensor fornecido pelo utilizador tr, que pode ser um tensor de categoria (2,1).  A partir disso, os coeficientes de torsão kt são calculados de acordo com a seguinte fórmula:

                   m          m      m
            - g  tr   - g   tr   - tr   g
               im  kj    jm   ki     ij  km
     kt   = -------------------------------
       ijk                 2

       k     km
     kt   = g   kt
       ij         ijm

Note que somente o tensor de índice misto é calculao e armazenado no array kt.

Os coeficientes de não metricidade são calculados a partir  do vector de não metricidade fornecido pelo utilizador nm. A partir disso, os coeficientes de não metricidade nmc são calculados como segue:

                  k    k        km
            -nm  D  - D  nm  + g   nm  g
        k      i  j    i   j         m  ij
     nmc  = ------------------------------
        ij                2

onde D simboliza o delta de Kronecker.

Quando ctorsion_flag for escolhida para true, os valores de kt são subtraídos dos coeficientes de coneccedilhaão indexados mistos calculados através de christof e armazenados em mcs. Similarmente, se cnonmet_flag for escolhida para true, os valores de nmc são subtraídos dos coeficientes de coneccedilhaão indexados mistos.

Se necessário, christof chama as funcedilhaões contortion e nonmetricity com o objectivo de calcular kt e nm.

 -- Funcedilhaão: contortion (TR)

     Calcula os coeficientes de contorsão de categoria (2,1) a partir do tensor de torsão TR.

 -- Funcedilhaão: nonmetricity (NM)

     Calcula o coeficiente de não metricidade de categoria (2,1) a partir do vector de não metricidade NM.

Recursos diversos
-----------------

 -- Funcedilhaão: ctransform (M)
     Uma funcedilhaão no pacote ctensor que irá executar uma transformacedilhaão de coordenadas sobre uma matriz simétrica quadrada arbitrária M. O utilizador deve informar as funcedilhaãoes que definem a transformacedilhaão.  (Formalmente chamada transform.)

 -- Funcedilhaão: findde (A, N)

     Retorna uma lista de equacedilhaões diferenciais únicas (expressões) correspondendo aos elementos do array quadrado N dimensional A. Actualmente, N pode ser 2 ou 3. deindex é uma lista global contendo os índices de A correspondendo a essas únicas equacedilhaões diferenciais. Para o tensor de Einstein (ein), que é um array dimensional, se calculado para a métrica no exemplo abaixo, findde fornece as seguintes equacedilhaões diferenciais independentes:

          (%i1) load(ctensor);
          (%o1)       /share/tensor/ctensor.mac
          (%i2) derivabbrev:true;
          (%o2)                                true
          (%i3) dim:4;
          (%o3)                                  4
          (%i4) lg:matrix([a,0,0,0],[0,x^2,0,0],[0,0,x^2*sin(y)^2,0],[0,0,0,-d]);
                                    [ a  0       0        0  ]
                                    [                        ]
                                    [     2                  ]
                                    [ 0  x       0        0  ]
          (%o4)                     [                        ]
                                    [         2    2         ]
                                    [ 0  0   x  sin (y)   0  ]
                                    [                        ]
                                    [ 0  0       0       - d ]
          (%i5) depends([a,d],x);
          (%o5)                            [a(x), d(x)]
          (%i6) ct_coords:[x,y,z,t];
          (%o6)                            [x, y, z, t]
          (%i7) cmetric();
          (%o7)                                done
          (%i8) einstein(false);
          (%o8)                                done
          (%i9) findde(ein,2);
                                                      2
          (%o9) [d  x - a d + d, 2 a d d    x - a (d )  x - a  d d  x + 2 a d d
                  x                     x x         x        x    x            x

                                                                  2          2
                                                          - 2 a  d , a  x + a  - a]
                                                               x      x
          (%i10) deindex;
          (%o10)                     [[1, 1], [2, 2], [4, 4]]

 -- Funcedilhaão: cograd ()
     Calcula o gradiente covariante de uma funcedilhaão escalar permitindo ao utilizador escolher o nome do vector correspondente como o exemplo sob contragrad ilustra.

 -- Funcedilhaão: contragrad ()

     Calcula o gradiente contravariante de uma funcedilhaão escalar permitindo ao utilizador escolher o nome do vector correspondente como o exemplo abaixo como ilustra a métrica de Schwarzschild:

          (%i1) load(ctensor);
          (%o1)       /share/tensor/ctensor.mac
          (%i2) derivabbrev:true;
          (%o2)                                true
          (%i3) ct_coordsys(exteriorschwarzschild,all);
          (%o3)                                done
          (%i4) depends(f,r);
          (%o4)                               [f(r)]
          (%i5) cograd(f,g1);
          (%o5)                                done
          (%i6) listarray(g1);
          (%o6)                            [0, f , 0, 0]
                                                r
          (%i7) contragrad(f,g2);
          (%o7)                                done
          (%i8) listarray(g2);
                                         f  r - 2 f  m
                                          r        r
          (%o8)                      [0, -------------, 0, 0]
                                               r

 -- Funcedilhaão: dscalar ()
     Calcula o tensor d'Alembertiano da funcedilhaão escalar assim que as dependências tiverem sido declaradas sobre a funcedilhaão. Po exemplo:

          (%i1) load(ctensor);
          (%o1)       /share/tensor/ctensor.mac
          (%i2) derivabbrev:true;
          (%o2)                                true
          (%i3) ct_coordsys(exteriorschwarzschild,all);
          (%o3)                                done
          (%i4) depends(p,r);
          (%o4)                               [p(r)]
          (%i5) factor(dscalar(p));
                                    2
                              p    r  - 2 m p    r + 2 p  r - 2 m p
                               r r           r r        r          r
          (%o5)               --------------------------------------
                                                 2
                                                r

 -- Funcedilhaão: checkdiv ()

     Calcula a divergência covariante do tensor de segunda categoria misto (cujo primeiro índice deve ser covariante) imprimindo as correspondentes n componentes do campo do vector (a divergência) onde n = dim. Se o argumento para a funcedilhaão for g então a divergência do tensor de Einstein será formada e pode ser zero. Adicionalmente, a divergência (vector) é dada no array chamado div.

 -- Funcedilhaão: cgeodesic (DIS)
     Uma funcedilhaão no pacote ctensor. cgeodesic calcula as equacedilhaões geodésicas de movimento para uma dada métrica.  Elas são armazenadas no array geod[i].  Se o argumento DIS for true então essas equacedilhaões são mostradas.

 -- Funcedilhaão: bdvac (F)

     Gera as componentes covariantes das equacedilhaões de campo de vácuo da teoria de gravitacedilhaão de Brans-Dicke. O campo escalar é especificado através do argumento F, que pode ser um nome de funcedilhaão (com apóstrofo) com dependências funcionais, e.g., 'p(x).

     As componentes de segunda categoria do tensor campo covariante são as componentes de segunda categoria representadas pelo array bd.

 -- Funcedilhaão: invariant1 ()

     Gera o tensor misto de Euler-Lagrange (equacedilhaões de campo) para a densidade invariante de R^2. As equacedilhaões de campo são componentes de um array chamado inv1.

 -- Funcedilhaão: invariant2 ()

     *** NOT YET IMPLEMENTED ***

     Gera o tensor misto de Euler-Lagrange (equacedilhaões de campo) para a densidade invariante de ric[i,j]*uriem[i,j]. As equacedilhaões de campo são as componentes de um array chamado inv2.

 -- Funcedilhaão: bimetric ()

     *** NOT YET IMPLEMENTED ***

     Gera as euauacedilhaões de campo da teoria bimétrica de Rosen. As equacedilhaões de campo são as componentes de um array chamado rosen.

Funcedilhaões utilitárias
-------------------------

 -- Funcedilhaão: diagmatrixp (M)

     Retorna true se M for uma matriz diagonal ou um array (2D).

 -- Funcedilhaão: symmetricp (M)

     Retorna true se M for uma matriz simétrica ou um array (2D).

 -- Funcedilhaão: ntermst (F)
     Fornece ao utilizador um rápido quadro do "tamanho" do tensor duplamente subscrito (array) F.  Imprime uma lista de dois elementos onde o segundo elemento corresponde a N-TERMOS de componentes especificadas através dos primeiros elementos.  Nesse caminho, é possível rapidamente encontrar as expressões não nulas e tentar simplificacedilhaão.

 -- Funcedilhaão: cdisplay (TEN)
     Mostra todos os elementos do tensor TEN, como representados por um array multidimensional. Tensores de categoria 0 e 1, assim como outros tipos de variáveis, são mostrados com ldisplay. Tensores de categoria 2 são mostrados como matrizes bidimensionais, enquanto tensores de alta categoria são mostrados como uma lista de matrizes bidimensionais. Por exemplo, o tensor de Riemann da métrica de Schwarzschild pode ser visto como:

          (%i1) load(ctensor);
          (%o1)       /share/tensor/ctensor.mac
          (%i2) ratfac:true;
          (%o2)                                true
          (%i3) ct_coordsys(exteriorschwarzschild,all);
          (%o3)                                done
          (%i4) riemann(false);
          (%o4)                                done
          (%i5) cdisplay(riem);
                         [ 0               0                    0            0      ]
                         [                                                          ]
                         [                              2                           ]
                         [      3 m (r - 2 m)   m    2 m                            ]
                         [ 0  - ------------- + -- - ----       0            0      ]
                         [            4          3     4                            ]
                         [           r          r     r                             ]
                         [                                                          ]
              riem     = [                                 m (r - 2 m)              ]
                  1, 1   [ 0               0               -----------       0      ]
                         [                                      4                   ]
                         [                                     r                    ]
                         [                                                          ]
                         [                                              m (r - 2 m) ]
                         [ 0               0                    0       ----------- ]
                         [                                                   4      ]
                         [                                                  r       ]

                                          [    2 m (r - 2 m)       ]
                                          [ 0  -------------  0  0 ]
                                          [          4             ]
                                          [         r              ]
                               riem     = [                        ]
                                   1, 2   [ 0        0        0  0 ]
                                          [                        ]
                                          [ 0        0        0  0 ]
                                          [                        ]
                                          [ 0        0        0  0 ]

                                          [         m (r - 2 m)    ]
                                          [ 0  0  - -----------  0 ]
                                          [              4         ]
                                          [             r          ]
                               riem     = [                        ]
                                   1, 3   [ 0  0        0        0 ]
                                          [                        ]
                                          [ 0  0        0        0 ]
                                          [                        ]
                                          [ 0  0        0        0 ]

                                          [            m (r - 2 m) ]
                                          [ 0  0  0  - ----------- ]
                                          [                 4      ]
                                          [                r       ]
                               riem     = [                        ]
                                   1, 4   [ 0  0  0        0       ]
                                          [                        ]
                                          [ 0  0  0        0       ]
                                          [                        ]
                                          [ 0  0  0        0       ]

                                         [       0         0  0  0 ]
                                         [                         ]
                                         [       2 m               ]
                                         [ - ------------  0  0  0 ]
                              riem     = [    2                    ]
                                  2, 1   [   r  (r - 2 m)          ]
                                         [                         ]
                                         [       0         0  0  0 ]
                                         [                         ]
                                         [       0         0  0  0 ]

                             [     2 m                                         ]
                             [ ------------  0        0               0        ]
                             [  2                                              ]
                             [ r  (r - 2 m)                                    ]
                             [                                                 ]
                             [      0        0        0               0        ]
                             [                                                 ]
                  riem     = [                         m                       ]
                      2, 2   [      0        0  - ------------        0        ]
                             [                     2                           ]
                             [                    r  (r - 2 m)                 ]
                             [                                                 ]
                             [                                         m       ]
                             [      0        0        0         - ------------ ]
                             [                                     2           ]
                             [                                    r  (r - 2 m) ]

                                          [ 0  0       0        0 ]
                                          [                       ]
                                          [            m          ]
                                          [ 0  0  ------------  0 ]
                               riem     = [        2              ]
                                   2, 3   [       r  (r - 2 m)    ]
                                          [                       ]
                                          [ 0  0       0        0 ]
                                          [                       ]
                                          [ 0  0       0        0 ]

                                          [ 0  0  0       0       ]
                                          [                       ]
                                          [               m       ]
                                          [ 0  0  0  ------------ ]
                               riem     = [           2           ]
                                   2, 4   [          r  (r - 2 m) ]
                                          [                       ]
                                          [ 0  0  0       0       ]
                                          [                       ]
                                          [ 0  0  0       0       ]

                                                [ 0  0  0  0 ]
                                                [            ]
                                                [ 0  0  0  0 ]
                                                [            ]
                                     riem     = [ m          ]
                                         3, 1   [ -  0  0  0 ]
                                                [ r          ]
                                                [            ]
                                                [ 0  0  0  0 ]

                                                [ 0  0  0  0 ]
                                                [            ]
                                                [ 0  0  0  0 ]
                                                [            ]
                                     riem     = [    m       ]
                                         3, 2   [ 0  -  0  0 ]
                                                [    r       ]
                                                [            ]
                                                [ 0  0  0  0 ]

                                         [   m                      ]
                                         [ - -   0   0       0      ]
                                         [   r                      ]
                                         [                          ]
                                         [        m                 ]
                                         [  0   - -  0       0      ]
                              riem     = [        r                 ]
                                  3, 3   [                          ]
                                         [  0    0   0       0      ]
                                         [                          ]
                                         [              2 m - r     ]
                                         [  0    0   0  ------- + 1 ]
                                         [                 r        ]

                                              [ 0  0  0    0   ]
                                              [                ]
                                              [ 0  0  0    0   ]
                                              [                ]
                                   riem     = [            2 m ]
                                       3, 4   [ 0  0  0  - --- ]
                                              [             r  ]
                                              [                ]
                                              [ 0  0  0    0   ]

                                          [       0        0  0  0 ]
                                          [                        ]
                                          [       0        0  0  0 ]
                                          [                        ]
                               riem     = [       0        0  0  0 ]
                                   4, 1   [                        ]
                                          [      2                 ]
                                          [ m sin (theta)          ]
                                          [ -------------  0  0  0 ]
                                          [       r                ]

                                          [ 0        0        0  0 ]
                                          [                        ]
                                          [ 0        0        0  0 ]
                                          [                        ]
                               riem     = [ 0        0        0  0 ]
                                   4, 2   [                        ]
                                          [         2              ]
                                          [    m sin (theta)       ]
                                          [ 0  -------------  0  0 ]
                                          [          r             ]

                                        [ 0  0          0          0 ]
                                        [                            ]
                                        [ 0  0          0          0 ]
                                        [                            ]
                             riem     = [ 0  0          0          0 ]
                                 4, 3   [                            ]
                                        [                2           ]
                                        [         2 m sin (theta)    ]
                                        [ 0  0  - ---------------  0 ]
                                        [                r           ]

                           [        2                                             ]
                           [   m sin (theta)                                      ]
                           [ - -------------         0                0         0 ]
                           [         r                                            ]
                           [                                                      ]
                           [                         2                            ]
                           [                    m sin (theta)                     ]
                riem     = [        0         - -------------         0         0 ]
                    4, 4   [                          r                           ]
                           [                                                      ]
                           [                                          2           ]
                           [                                   2 m sin (theta)    ]
                           [        0                0         ---------------  0 ]
                           [                                          r           ]
                           [                                                      ]
                           [        0                0                0         0 ]

          (%o5)                                done

 -- Funcedilhaão: deleten (L, N)
     Retorna uma nova lista consistindo de L com o N'ésimo elemento apagado.

Variáveis usadas por ctensor
----------------------------

 -- Variável de opcedilhaão: dim
     Valor por omissão: 4

     Uma opcedilhaão no pacote ctensor. dim é a dimensão de multiplicacedilhaão com o padrão 4. O comando dim: n irá escolher a dimensão para qualquer outro valor n.

 -- Variável de opcedilhaão: diagmetric
     Valor por omissão: false

     Uma opcedilhaão no pacote ctensor. Se diagmetric for true rotinas especiais calculam todos os objectos geométricos (que possuem o tensor métrico explicitamente) levando em consideracedilhaão a diagonalidade da métrica. Tempo de execucedilhaào reduzido irá, com certeza, resultar dessa escolha. Nota: essa opcedilhaão é escolhida automaticamente por csetup se uma métrica diagonal for especificada.

 -- Variável de opcedilhaão: ctrgsimp

     Faz com que simplificacedilhaões trigonométricas sejam usadas quando tensores forem calculados. Actualmente, ctrgsimp afecta somente cálculos envolvendo um referencial móvel.

 -- Variável de opcedilhaão: cframe_flag

     Faz com que cálculos sejam executados relativamente a um referencial móvel em oposicedilhaão a uma métrica holonómica. O referencial é definido através do array do referencial inverso fri e da métrica do referencial lfg. Para cálculos usando um referencial Cartesiano, lfg pode ser a matriz unitária de dimensão apropriada; para cálculos num referencial de Lorentz, lfg pode ter a assinatura apropriada.

 -- Variável de opcedilhaão: ctorsion_flag

     Faz com que o tensor de contorsão seja incluído no cálculo dos coeficientes de coneccedilhaão. O tensor de contorsão por si mesmo é calculado através de contortion a partir do tensor tr fornecido pelo utilizador.

 -- Variável de opcedilhaão: cnonmet_flag

     Faz com que os coeficientes de não metricidade sejam incluídos no cálculo dos coeficientes de coneccedilhaão. Os coeficientes de não metricidade são calculados a partir do vector de não metricidade nm fornecido pelo utilizador através da funcedilhaão nonmetricity.

 -- Variável de opcedilhaão: ctayswitch

     Se escolhida para true, faz com que alguns cálculos de ctensor sejam realizados usando expansões das séries de Taylor. actualmente, christof, ricci, uricci, einstein, e weyl levam em conta essa escolha.

 -- Variável de opcedilhaão: ctayvar

     Variável usada pela expansão de séries de Taylor se ctayswitch é escolhida para true.

 -- Variável de opcedilhaão: ctaypov

     Maximo expoente usado em expansões de séries de Taylor quando ctayswitch for escolhida para true.

 -- Variável de opcedilhaão: ctaypt

     Ponto em torno do qual expansões de séries de Taylor sao realizadas quando ctayswitch for escolhida para true.

 -- Variável de sistema: gdet

     O determinante do tensor métrico lg. Calculado através de cmetric quando cframe_flag for escolhido para false.

 -- Variável de opcedilhaão: ratchristof

     Faz com que simplificacedilhaões racionais sejam aplicadas através de christof.

 -- Variável de opcedilhaão: rateinstein
     Valor por omissão: true

     Se true simplificacedilhaão racional será executada sobre as componentes não nulas de tensores de Einstein; se ratfac for true então as componentes irão também ser factoradas.

 -- Variável de opcedilhaão: ratriemann
     Valor por omissão: true

     Um dos comutadores que controlam simplificacedilhaões dos tensores de Riemann; se true, então simplificacedilhaões racionais irão ser concluídas; se ratfac for true então cada uma das componentes irá também ser factorada.

 -- Variável de opcedilhaão: ratweyl
     Valor por omissão: true

     Se true, esse comutador faz com que a funcedilhaão de weyl aplique simplificacedilhaões racionais aos valores do tensor de Weyl. Se ratfac for true, então as componentes irão também ser factoradas.

 -- Variável: lfg
     O referencial métrico covariante. Por padrão, é inicializado para o referencial tetradimensional de Lorentz com assinatura (+,+,+,-). Usada quando cframe_flag for true.

 -- Variável: ufg
     A métrica do referencial inverso. Calculada de lfg quando cmetric for chamada enquanto cframe_flag for escolhida para true.

 -- Variável: riem
     O tensor de categoria (3,1) de Riemann. Calculado quando a funcedilhaão riemann é invocada. Para informacedilhaão sobre ordenacedilhaão de índices, veja a descricedilhaão de riemann.

     Se cframe_flag for true, riem é calculado a partir do tensor covariante de Riemann lriem.

 -- Variável: lriem

     O tensor covariante de Riemann. Calculado através de lriemann.

 -- Variável: uriem

     O tensor contravariante de Riemann. Calculado através de uriemann.

 -- Variável: ric

     O tensor misto de Ricci. Calculado através de ricci.

 -- Variável: uric

     O tensor contravariante de Ricci. Calculado através de uricci.

 -- Variável: lg

     O tensor métrico. Esse tensor deve ser especificado (como uma dim através da matriz dim) antes que outro cálculo possa ser executado.

 -- Variável: ug

     O inverso do tensor métrico. Calculado através de cmetric.

 -- Variável: weyl

     O tensor de Weyl. Calculado através de weyl.

 -- Variável: fb

     Coeficientes delimitadores do referencial, como calculado através de frame_bracket.

 -- Variável: kinvariant

     O invariante de Kretchmann. Calculado através de rinvariant.

 -- Variável: np

     Um tetrad nulo de Newman-Penrose. Calculado através de nptetrad.

 -- Variável: npi

     O índice ascendente do tetrad nulo de Newman-Penrose. Calculado através de nptetrad. Definido como ug.np. O produto np.transpose(npi) é constante:

          (%i39) trigsimp(np.transpose(npi));
                                        [  0   - 1  0  0 ]
                                        [                ]
                                        [ - 1   0   0  0 ]
          (%o39)                        [                ]
                                        [  0    0   0  1 ]
                                        [                ]
                                        [  0    0   1  0 ]

 -- Variável: tr

     Tensor de categoria 3 fornecido pelo utilizador representando torsão. Usado por contortion.

 -- Variável: kt

     O tensor de contorsão, calculado a partir de tr através de contortion.

 -- Variável: nm

     Vetor de não metrcidade fornecido pelo utilizador. Usado por nonmetricity.

 -- Variável: nmc

     Os coeficientes de não metricidade, calculados a partir de nm por nonmetricity.

 -- Variável de sistema: tensorkill

     Variável indicando se o pacote tensor foi inicializado. Escolhida e usada por csetup, retornada ao seu valor original através de init_ctensor.

 -- Variável de opcedilhaão: ct_coords
     Valor por omissão: []

     Uma opcedilhaão no pacote ctensor. ct_coords contém uma lista de coordenadas. Enquanto normalmente definida quando a funcedilhaão csetup for chamada, se pode redefinir as coordenadas com a atribuicedilhaão ct_coords: [j1, j2, ..., jn] onde os j's são os novos nomes de coordenadas. Veja também csetup.

Nomes reservados
----------------

Os seguintes nomes são usados internamente pelo pacote ctensor e não devem ser redefinidos:

       Name         Description
       ---------------------------------------
       _lg()        Avalia para lfg se for usado o referencial métrico,
                         para lg de outra forma
       _ug()        Avalia para ufg se for usado o referencial métrico,
                         para ug de outra forma
       cleanup()    Remove ítens da lista deindex
       contract4()  Usado por psi()
       filemet()    Usado por csetup() quando lendo a métrica de um ficheiro
       findde1()    Usado por findde()
       findde2()    Usado por findde()
       findde3()    Usado por findde()
       kdelt()      Delta de Kronecker (não generalizado)
       newmet()     Usado por csetup() para escolher uma métrica
                         interativamente
       setflags()   Usado por init_ctensor()
       readvalue()
       resimp()
       sermet()     Usado por csetup() para informar uma métricacom série
                         de Taylor
       txyzsum()
       tmetric()    Referencial métrico, usado por cmetric() quando
                         cframe_flag:true
       triemann()   Tensor de Riemann na base do referencial, usado quando
                         cframe_flag:true
       tricci()     Tensor de Ricci na base do referencial, usado quando
                         cframe_flag:true
       trrc()       Coeficientes de rotacedilhaão de Ricci, usado por
                         christof()
       yesp()

Modificacedilhaões
------------------

Em Novembro de 2004, o pacote ctensor foi extensivamente reescrito. Muitas funcedilhaões e variáveis foram renomeadas com o objectivo de tornar o pacote com a versão comercial do Macsyma.

       Novo Nome    Nome Antigo     Descricedilhaão
       --------------------------------------------------------------------
       ctaylor()    DLGTAYLOR()     Expansão da série de Taylor de uma
       -----------------------------expressão
       lgeod[]      EM              Equacedilhaões geodésicas
       ein[]        G[]             Tensor misto de Einstein
       ric[]        LR[]            Tensor misto de Ricci
       ricci()      LRICCICOM()     Calcula o tensor misto de Ricci
       ctaypov      MINP            Maximo expoente em expansões de séries de
       -----------------------------Taylor
       cgeodesic()  MOTION          Calcula as equacedilhaões geodésicas
       ct_coords    OMEGA           Coordenadas métricas
       ctayvar      PARAM           Variável de expansão de séries de
       -----------------------------Taylor
       lriem[]      R[]             Tensor covariante de Riemann
       uriemann()   RAISERIEMANN()  Calcula o tensor contravariante de
       -----------------------------Riemann
       ratriemann   RATRIEMAN       Simplificacedilhaão racional do tensor de
       -----------------------------Riemann
       uric[]       RICCI[]         Tensor de Ricci contravariante
       uricci()     RICCICOM()      Calcula o tensor de Ricci contravariante
       cmetric()    SETMETRIC()     Escolhe a métrica
       ctaypt       TAYPT           Ponto para expansões de séries de Taylor
       ctayswitch   TAYSWITCH       Escolhe o comutador de séries de Taylor
       csetup()     TSETUP()        Inicia sessão interativa de configuracedilhaão
       ctransform() TTRANSFORM()    Transformacedilhaão de coordenadas interativa
       uriem[]      UR[]            Tensor contravariante de Riemann
       weyl[]       W[]             Tensor (3,1) de Weyl