Introducción a ctensor
======================

El paquete ctensor dispone de herramientas para manipular componentes de tensores. Para poder hacer uso de ctensor es necesario cargarlo previamente en memoria ejecutando  load(ctensor). Para comenzar una sesión interactiva con ctensor, ejecutar la función csetup(). Primero se le pregunta al usuario la dimensión de la variedad. Si la dimensión es 2, 3 o 4, entonces la lista de coordenadas será por defecto  [x,y], [x,y,z] o [x,y,z,t], respectivamente. Estos nombres pueden cambiarse asignando una nueva lista de coordenadas a la variable ct_coords (que se describe más abajo), siendo el usuario advertido sobre este particular. Se debe tener cuidado en evitar que los nombres de las coordenadas entren en conflicto con los nombres de otros objetos en Maxima.

A continuación, el usuario introduce la métrica, bien directamente, o desde un fichero especificando su posición ordinal. La métrica se almacena en la matriz lg. Por último, la métrica inversa se obtiene y almacena en la matriz ug. También se dispone de la opción de efectuar todos los cálculos en serie de potencias.

Se desarrolla a continuación un ejemplo para la métrica estática, esférica y simétrica, en coordenadas estándar, que se aplicará posteriormente al problema de derivar las ecuaciones de vacío de Einstein (de las que se obtiene la solución de Schwarzschild). Muchas de las funciones de ctensor se mostrarán  en los ejemplos para la métrica estándar.

     (%i1) load(ctensor);
     (%o1)      /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

Funciones y variables para ctensor
==================================

Inicialización y preparación
----------------------------

 -- Función: csetup ()
     Es la función del paquete ctensor que inicializa el paquete y permite al usuario introducir una métrica de forma interactiva. Véase ctensor para más detalles.

 -- Función: cmetric (DIS)
 -- Función: cmetric ()
     Es la función del paquete ctensor que calcula la métrica inversa y prepara el paquete para cálculos ulteriores.

     Si cframe_flag vale false, la función calcula la métrica inversa ug a partir de la matriz lg definida por el usuario. Se calcula también la métrica determinante y se almacena en la variable gdet. Además, el paquete determina si la métrica es diagonal y ajusta el valor de diagmetric de la forma apropiada. Si el argumento opcional DIS está presente y no es igual a false, el usuario podrá ver la métrica inversa.

     Si cframe_flag vale true, la función espera que los valores de fri (la matriz del sistema de referencia inverso) y lfg (la matriz del sistema de referencia) estén definidos. A partir de ellos, se calculan la matriz del sistema de referencia fr y su métrica ufg.

 -- Función: ct_coordsys (SISTEMA_COORDENADAS, EXTRA_ARG)
 -- Función: ct_coordsys (SISTEMA_COORDENADAS)

     Prepara un sistema de coordenadas predefinido y una métrica. El argumento SISTEMA_COORDENADAS puede ser cualquiera de los siguientes símbolos:

            Símbolo              Dim Coordenadas       Descripción/comentarios
            --------------------------------------------------------------------------------
            cartesian2d           2  [x,y]             Sistema de coordenadas cartesianas en 2D
            polar                 2  [r,phi]           Sistema de coordenadas polares
            elliptic              2  [u,v]             Sistema de coordenadas elípticas
            confocalelliptic      2  [u,v]             Coordenadas elípticas confocales
            bipolar               2  [u,v]             Sistema de coordenas bipolares
            parabolic             2  [u,v]             Sistema de coordenadas parabólicas
            cartesian3d           3  [x,y,z]           Sistema de coordenadas cartesianas en 3D
            polarcylindrical      3  [r,theta,z]       Polares en 2D con cilíndrica z
            ellipticcylindrical   3  [u,v,z]           Elípticas en 2D con cilíndrica z
            confocalellipsoidal   3  [u,v,w]           Elipsoidales confocales
            bipolarcylindrical    3  [u,v,z]           Bipolares en 2D con cilíndrica z
            paraboliccylindrical  3  [u,v,z]           Parabólicas en 2D con cilíndrica z
            paraboloidal          3  [u,v,phi]         Coordenadas paraboloidales
            conical               3  [u,v,w]           Coordenadas cónicas
            toroidal              3  [u,v,phi]         Coordenadas toroidales
            spherical             3  [r,theta,phi]     Sistema de coordenadas esféricas
            oblatespheroidal      3  [u,v,phi]         Coordenadas esferoidales obleadas
            oblatespheroidalsqrt  3  [u,v,phi]
            prolatespheroidal     3  [u,v,phi]         Coordenadas esferoidales prolatas
            prolatespheroidalsqrt 3  [u,v,phi]
            ellipsoidal           3  [r,theta,phi]     Coordenadas elipsoidales
            cartesian4d           4  [x,y,z,t]         Sistema de coordenadas cartesianas en 4D
            spherical4d           4  [r,theta,eta,phi] Sistema de coordenadas esféricas en 4D
            exteriorschwarzschild 4  [t,r,theta,phi]   Métrica de Schwarzschild
            interiorschwarzschild 4  [t,z,u,v]         Métrica interior de Schwarzschild
            kerr_newman           4  [t,r,theta,phi]   Métrica simétrica con carga axial

     El argumento sistema_coordenadas puede ser también una lista de funciones de transformación, seguida de una lista que contenga los nombres de las coordenadas. Por ejemplo, se puede especificar una métrica esférica como se indica a continuación:

          (%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

     Las funciones de transformación se pueden utilizar también si cframe_flag vale 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) ]

     El argumento opcional EXTRA_ARG puede ser cualquiera de los siguientes:

     cylindrical indica a ct_coordsys que añada una coordenada cilíndrica más.

     minkowski indica a  ct_coordsys que añada una coordenada más con signatura métrica negativa.

     all indica a  ct_coordsys que llame a  cmetric y a christof(false) tras activar la métrica.

     Si la variable global verbose vale true, ct_coordsys muestra los valores de dim, ct_coords, junto con lg o lfg y fri, dependiendo del valor de cframe_flag.

 -- Función: init_ctensor ()
     Inicializa el paquete ctensor.

     La función init_ctensor reinicializa el paquete ctensor. Borra todos los arreglos ("arrays") y matrices utilizados por ctensor y reinicializa todas las variables, asignando a dim el valor 4 y la métrica del sistema de referencia a la de Lorentz.

Los tensores del espacio curvo
------------------------------

El propósito principal del paquete ctensor es calcular los tensores del espacio (-tiempo) curvo, en especial los tensores utilizados en relatividad general.

Cuando se utiliza una métrica, ctensor puede calcular los siguientes tensores:

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

El paquete ctensor también puede trabajar con sistemas de referencia móviles. Si cframe_flag vale true, se pueden calcular los siguientes tensores:

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

 -- Función: christof (DIS)
     Es una función del paquete ctensor. Calcula los símbolos de Christoffel de ambos tipos. El argumento DIS determina qué resultados se mostrarán de forma inmediata. Los símbolos de Christoffel de primer y segundo tipo se almacenan en los arreglos  lcs[i,j,k] y mcs[i,j,k], respectivamente, y se definen simétricos en sus dos primeros índices. Si el argumento de christof es lcs o mcs entonces serán mostrados únicamente los valores no nulos de lcs[i,j,k] o mcs[i,j,k], respectivamente. Si el argumento es all entonces se mostrarán los valores no nulos de lcs[i,j,k] y mcs[i,j,k].  Si el argumento vale false entonces no se mostrarán los elementos. El arreglo mcs[i,j,k] está definido de tal modo que el último índice es contravariante.

 -- Función: ricci (DIS)
     Es una función del paquete ctensor. La función ricci calcula las componentes covariantes (simétricas) ric[i,j] del tensor de Ricci. Si el argumento DIS vale true, entonces se muestran las componentes no nulas.

 -- Función: uricci (DIS)
     Esta función calcula en primer lugar las componentes covariantes  ric[i,j] del tensor de Ricci. Después se calcula el tensor de Ricci utilizando la métrica contravariante. Si el valor del argumento DIS vale true, entonces se mostrarán directamente las componentes uric[i,j] (el índice I es covariante y el J contravariante). En otro caso,  ricci(false) simplemente calculará las entradas del arreglo uric[i,j] sin mostrar los resultados.

 -- Función: scurvature ()

     Devuelve la curvatura escalar (obtenida por contracción del tensor de Ricci) de la variedad de Riemannian con la métrica dada.

 -- Función: einstein (DIS)
     Es una función del paquete ctensor. La función  einstein calcula el tensor de Einstein después de que los símbolos de  Christoffel y el tensor de Ricci hayan sido calculados (con las funciones christof y ricci).  Si el argumento DIS vale true, entonces se mostrarán los valores no nulos del tensor de Einstein ein[i,j], donde j es el índice contravariante. La variable rateinstein causará la simplificación racional de estas componentes. Si ratfac vale true entonces las componentes también se factorizarán.

 -- Función: leinstein (DIS)
     Es el tensor covariante de Einstein. La función leinstein almacena los valores del tensor covariante de Einstein en el arreglo lein. El tensor covariante de Einstein se calcula a partir del tensor de Einstein ein multiplicándolo por el tensor métrico. Si el argumento  DIS vale true, entonces se mostrarán los valores no nulos del tensor covariante de Einstein.

 -- Función: riemann (DIS)
     Es una función del paquete ctensor. La función riemann calcula el tensor de curvatura de Riemann a partir de la métrica dada y de los símbolos de Christoffel correspondientes. Se utiliza el siguiente convenio sobre los índices:

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

     Esta notación es consistente con la notación utilizada por el paquete itensor y su función icurvature. Si el argumento opcional DIS vale true, se muestran las componentes no nulas de riem[i,j,k,l]. Como en el caso del tensor de Einstein, ciertas variables permiten controlar al usuario la simplificación de las componentes del tensor de Riemann. Si  ratriemann vale true, entonces se hará la simplificación racional. Si ratfac vale true, entonces se factorizarán todas las componentes.

     Si la variable cframe_flag vale false, el tensor de Riemann se calcula directamente a partir de los símbolos de Christoffel. Si cframe_flag vale true, el tensor covariante de Riemann se calcula a partir de los coeficientes del campo.

 -- Función: lriemann (DIS)
     Es el tensor covariante de Riemann (lriem[]).

     Calcula el tensor covariante de Riemann como un arreglo lriem. Si el argumento DIS vale true, sólo se muestran los valores no nulos.

     Si la variable cframe_flag vale true, el tensor covariante de Riemann se calcula directamente de los coeficientes del campo. En otro caso, el tensor de Riemann (3,1) se calcula en primer lugar.

     Para más información sobre la ordenación de los índices, véase riemann.

 -- Función: uriemann (DIS)
     Calcula las componentes contravariantes del tensor de curvatura de Riemann como un arreglo uriem[i,j,k,l].  Éstos se muestran si DIS vale true.

 -- Función: rinvariant ()
     Calcula la invariante de Kretchmann (kinvariant) obtenida por contracción de los tensores.

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

     Este objeto no se simplifica automáticamente al ser en ocasiones muy grande.

 -- Función: weyl (DIS)
     Calcula el tensor conforme de Weyl. Si el argumento DIS vale true, se le mostrarán al usuario las componentes no nulas weyl[i,j,k,l]. En otro caso, estas componentes serán únicamente calculadas y almacenadas. Si la variable ratweyl vale true, entonces las componentes se simplifican racionalmente; si ratfac vale true los resultados también se simplificarán.

Desarrollo de Taylor
--------------------

El paquete ctensor puede truncar resultados e interpretarlos como aproximaciones de Taylor. Este comportamiento se controla con lavariable ctayswitch; cuando vale true, ctensor utiliza internamente la función ctaylor cuando simplifica resultados.

La función ctaylor es llamada desde las siguientes funciones del paquete ctensor:

         Función      Comentarios
         ---------------------------------
         christof()   Sólo para mcs
         ricci()
         uricci()
         einstein()
         riemann()
         weyl()
         checkdiv()

 -- Función: ctaylor ()

     La función ctaylor trunca su argumento convirtiéndolo en un desarrollo de Taylor por medio de la función taylor e invocando después a ratdisrep. Esto tiene el efecto de eliminar términos de orden alto en la variable de expansión ctayvar. El orden de los términos que deben ser eliminados se define ctaypov; el punto alrededor del cual se desarrolla la serie se especifica en ctaypt.

     Como ejemplo, considérese una sencilla métrica que es una perturbación de la de Minkowski. Sin añadir restricciones, incluso una métrica diagonal produce expansiones del tensor de Einstein que pueden llegar a ser muy complejas:

          (%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

     Sin embargo, si se recalcula este ejemplo como una aproximación lineal en la variable l, se obtienen expresiones más sencillas:

          (%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

     Esta capacidad del paquete ctensor puede ser muy útil; por ejemplo, cuando se trabaja en zonas del campo gravitatorio alejadas del origen de éste.

Campos del sistema de referencia
--------------------------------

Cuando la variable cframe_flag vale true, el paquete ctensor realiza sus cálculos utilizando un sistema de referencia móvil.

 -- Función: frame_bracket (FR, FRI, DIAGFRAME)
     Es el sistema de referencia soporte (fb[]).

     Calcula el soporte del sistema de referencia de acuerdo con la siguiente definición:

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

Clasificación algebraica
------------------------

Una nueva funcionalidad (Noviembre de 2004) de ctensor es su capacidad de obtener la clasificación de Petrov de una métrica espaciotemporal de dimensión 4. Para una demostración de esto véase el fichero share/tensor/petrov.dem.

 -- Función: nptetrad ()
     Calcula la cuaterna nula de Newman-Penrose (np). Véase petrov para un ejemplo.

     La cuaterna nula se construye bajo la suposición de que se está utilizando una métrica tetradimensional ortonormal con signatura métrica (-,+,+,+). Los componentes de la cuaterna nula se relacionan con la inversa de la matriz del sistema de referencia de la siguiente manera:

          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

 -- Función: psi (DIS)
     Calcula los cinco coeficientes de Newman-Penrose psi[0]...psi[4]. Si psi vale true, se muestran estos coeficientes. Véase petrov para un ejemplo.

     Estos coeficientes se calculan a partir del tensor de Weyl.

 -- Función: petrov ()
     Calcula la clasificación de  Petrov de la métrica caracterizada por psi[0]...psi[4].

     Por ejemplo, lo que sigue demuestra cómo obtener la clasificación de Petrov para la 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

     La función de clasificación de Petrov se basa en el algoritmo publicado en "Classifying geometries in general relativity: III Classification in practice" de Pollney, Skea, and d'Inverno, Class. Quant. Grav. 17 2885-2902 (2000). Excepto para algunos ejemplos sencillos, esta implementación no ha sido exhaustivamente probada, por lo que puede contener errores.

Torsión y no metricidad
-----------------------

El paquete ctensor es capaz de calcular e incluir coeficientes de torsión y no metricidad en los coeficientes de conexión.

Los coeficientes de torsión se calculan a partir de un tensor suministrado por el usuario, tr, el cual debe ser de rango (2,1). A partir de ahí, los coeficientes de torsión kt se calculan de acuerdo con las siguientes fórmulas:

                   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

Los coeficientes de no metricidad se calculan a partir de un vector de no metricidad, nm, suministrado por el usuario. A partir de ahí, los coeficientes de no metricidad, nmc, se calculan como se indica a continuación:

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

donde D es la delta de Kronecker.

 -- Función: contortion (TR)

     Calcula los coeficientes (2,1) de contorsión del tensor de torsión TR.

 -- Función: nonmetricity (NM)

     Calcula los coeficientes (2,1) de no metricidad del vector de no metricidad NM.

Otras funcionalidades
---------------------

 -- Función: ctransform (M)
     Es una función del paquete ctensor.  Realiza una transformación de coordenadas a partir de una matriz cuadrada simétrica M arbitraria. El usuario debe introducir las funciones que definen la transformación.

 -- Función: findde (A, N)

     Devuelve la lista de las ecuaciones diferenciales que corresponden a los elementos del arreglo cuadrado N-dimensional. El argumento N puede ser 2 ó 3; deindex es una lista global que contiene los índices de A que corresponden a estas ecuaciones diferenciales. Para el tensor de Einstein (ein), que es un arreglo bidimensional, si se calcula para la métrica del ejemplo de más abajo, findde devuelve las siguientes ecuaciones diferenciales independientes:

          (%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]]

 -- Función: cograd ()
     Calcula el gradiente covariante de una función escalar permitiendo al usuario elegir el nombre del vector correspondiente, como ilustra el ejemplo que acompaña a la definición de la función contragrad.

 -- Function: contragrad ()

     Calcula el gradiente contravariante de una función escalar permitiendo al usuario elegir el nombre del vector correspondiente, tal como muestra el siguiente ejemplo para la 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

 -- Función: dscalar ()
     Calcula el tensor de d'Alembertian de la función escalar una vez se han declarado las dependencias. Por ejemplo:

          (%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

 -- Función: checkdiv ()

     Calcula la divergencia covariante del tensor de segundo rango (mixed second rank tensor), cuyo primer índice debe ser covariante, devolviendo las n componentes correspondientes del campo vectorial (la divergencia), siendo n = dim.

 -- Función: cgeodesic (DIS)
     Es una función del paquete ctensor que calcula las ecuaciones geodésicas del movimiento para una métrica dada, las cuales se almacenan en el arreglo geod[i]. Si el argumento  DIS vale true entonces se muestran estas ecuaciones.

 -- Función: bdvac (F)

     Genera las componentes covariantes de las ecuaciones del campo vacío de la teoría gravitacional de Brans- Dicke gravitational. El campo escalar se especifica con el argumento  F, el cual debe ser el nombre de una función no evaluada (precedida de apóstrofo) con dependencias funcionales, por ejemplo,  'p(x).

     Las componentes del tensor covariante (second rank covariant field tensor) se almacenan en el arreglo bd.

 -- Función: invariant1 ()

     Genera el tensor de Euler-Lagrange (ecuaciones de campo) para la densidad invariante de  R^2. Las ecuaciones de campo son las componentes del arreglo inv1.

Utilidades
----------

 -- Función: diagmatrixp (M)

     Devuelve true si M es una matriz diagonal o un arreglo bidimensional.

 -- Función: symmetricp (M)

     Devuelve true si M es una matriz simétrica o un arreglo bidimensional.

 -- Función: ntermst (F)
     Permite hacerse una idea del tamaño del tensor F.

 -- Función: cdisplay (TEN)
     Muestra todos los elementos del tensor TEN como arreglo multidimensional. Tensors de rango 0 y 1, así como otros tipos de variables, se muestran como en ldisplay. Tensors de rango 2 se muestran como matrices bidimensionales, mientras que tensores de mayor rango se muestran como listas de matrices bidimensionales. Por ejemplo, el tensor de Riemann de la métrica de Schwarzschild se puede ver 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

 -- Función: deleten (L, N)
     Devuelve una nueva lista consistente en L sin su N-ésimo elemento.

Variables utilizadas por ctensor
--------------------------------

 -- Variable opcional: dim
     Valor por defecto: 4

     Es la dimensión de la variedad, que por defecto será 4. La instrucción dim: n establecerá la dimensión a cualquier otro valor n.

 -- Variable opcional: diagmetric
     Valor por defecto: false

     Si diagmetric vale true se utilizarán rutinas especiales para calcular todos los objetos geométricos teniendo en cuenta la diagonalidad de la métrica, lo que redundará en una reducción del tiempo de cálculo. Esta opción se fija automáticamente por csetup si se especifica una métrica diagonal.

 -- Variable opcional: ctrgsimp

     Provoca que se realicen simplificaciones trigonométricas cuando se calculan tensores. La variable ctrgsimp afecta únicamente a aquellos cálculos que utilicen un sistema de referencia móvil.

 -- Variable opcional: cframe_flag

     Provoca que los cálculos se realicen respecto de un sistema de referencia móvil.

 -- Variable opcional: ctorsion_flag

     Obliga a que se calcule también el tensor de contorsión junto con los coeficientes de conexión. El propio tensor de contorsión se calcula con la función contortion a partir del tensor tr suministrado por el usuario.

 -- Variable opcional: cnonmet_flag

     Obliga a que se calculen también los coeficientes de no metricidad junto con los coeficientes de conexión. Los coeficientes de no metricidad se calculan con la función nonmetricity a partir del vector de no metricidadnm suministrado por el usuario.

 -- Variable opcional: ctayswitch

     Si vale true, obliga a que ciertos cálculos de ctensor se lleven a cabo utilizando desarrollos de series de Taylor. Estos cálculos hacen referencia a las funciones christof, ricci, uricci, einstein y weyl.

 -- Variable opcional: ctayvar

     Variable utilizada para desarrollos de Taylor cuando la variable ctayswitch vale true.

 -- Variable opcional: ctaypov

     Máximo exponente utilizado en los desarrollos de Taylor cuando ctayswitch vale true.

 -- Variable opcional: ctaypt

     Punto alrededor del cual se realiza un desarrollo de Taylor cuando ctayswitch vale true.

 -- Variable opcional: gdet

     Es el determinante del tensor métrico lg, calculado por  cmetric cuando cframe_flag vale false.

 -- Variable opcional: ratchristof

     Obliga a que la función christof aplique la simplificación racional.

 -- Variable opcional: rateinstein
     Valor por defecto: true

     Si vale true entonces se hará la simplificación racional en los componentes no nulos de los tensores de Einstein; si ratfac vale true entonces las componentes también serán factorizadas.

 -- Variable opcional: ratriemann
     Valor por defecto: true

     Es una de las variables que controlan la simplificación de los tensores de Riemann; si vale true, entonces se llevará a cabo la simplificación racional; si ratfac vale true entonces las componentes también serán factorizadas.

 -- Variable opcional: ratweyl
     Valor por defecto: true

     Si vale true, entonces la función weyl llevará a cabo la simplificación racional de los valores del tensor de Weyl. si ratfac vale true entonces las componentes también serán factorizadas.

 -- Variable: lfg
     Es la covariante de la métrica del sistema de referencia. Por defecto, está inicializada al sistema de referencia tetradimensional de Lorentz con signatura  (+,+,+,-). Se utiliza cuando cframe_flag vale true.

 -- Variable: ufg
     Es la métrica del sistema de referencia inverso. La calcula lfg cuando cmetric es invocada tomando  cframe_flag el valor  true.

 -- Variable: riem
     Es el tensor (3,1) de Riemann. Se calcula cuando se invoca la función riemann. Para información sobre el indexado, véase la descripción de  riemann.

     Si cframe_flag vale true, riem se calcula a partir del tensor covariante de Riemann lriem.

 -- Variable: lriem

     Es el tensor covariante de Riemann. Lo calcula la función lriemann.

 -- Variable: uriem

     Es el tensor contravariante de Riemann. Lo calcula la función uriemann.

 -- Variable: ric

     Es el tensor de Ricci. Lo calcula la función ricci.

 -- Variable: uric

     Es el tensor contravariante de Ricci. Lo calcula la función uricci.

 -- Variable: lg

     Es el tensor métrico. Este tensor se debe especificar (como matriz cuadrada de orden dim) antes de que se hagan otros cálculos.

 -- Variable: ug

     Es la inversa del tensor métrico. Lo calcula la función cmetric.

 -- Variable: weyl

     Es el tensor de Weyl. Lo calcula la función weyl.

 -- Variable: fb

     Son los coeficientes del sistema de referencia soporte, tal como los calcula frame_bracket.

 -- Variable: kinvariant

     Es la invariante de Kretchmann, tal como la calcula la función rinvariant.

 -- Variable: np

     Es la cuaterna nula de Newman-Penrose, tal como la calcula la función nptetrad.

 -- Variable: npi

     Es la cuaterna nula "raised-index Newman-Penrose". Lo calcula la función nptetrad. Se define como ug.np. El producto np.transpose(npi) es constante:

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

 -- Variable: tr

     Tensor de rango 3 suministrado por el usuario y que representa una torsión. Lo utiliza la función contortion.

 -- Variable: kt

     Es el tensor de contorsión, calculado a partir de tr por la función contortion.

 -- Variable: nm

     Vector de no metricidad suministrado por el usuario. Lo utiliza la función nonmetricity.

 -- Variable: nmc

     Son los coeficientes de no metricidad, calculados a partir de nm por la función nonmetricity.

 -- Variable del sistema: tensorkill

     Variable que indica si el paquete de tensores se ha inicializado. Utilizada por csetup y reinicializada por init_ctensor.

 -- Variable opcional: ct_coords
     Valor por defecto: []

     La variable ct_coords contiene una lista de coordenadas. Aunque se define normalmente cuando se llama a la función csetup, también se pueden redefinir las coordenadas con la asignación ct_coords: [j1, j2, ..., jn] donde  j es el nuevo nombre de las coordenadas. Véase también csetup.

Nombres reservados
------------------

Los siguientes nombres se utilizan internamente en el paquete ctensor y no deberían redefinirse:

       Nombre       Descripción
       ---------------------------------------
       _lg()        Toma el valor lfg si se utiliza métrica del sistema de referencia,
                    lg en otro caso
       _ug()        Toma el valor ufg si se utiliza métrica del sistema de referencia,
                    ug en otro caso
       cleanup()    Elimina elementos de la lista deindex
       contract4()  Utilizada por psi()
       filemet()    Utilizada por csetup() cuando se lee la métrica desde un fichero
       findde1()    Utilizada por findde()
       findde2()    Utilizada por findde()
       findde3()    Utilizada por findde()
       kdelt()      Delta de Kronecker (no generalizada)
       newmet()     Utilizada por csetup() para establecer una métrica interactivamente
       setflags()   Utilizada por init_ctensor()
       readvalue()
       resimp()
       sermet()     Utilizada por csetup() para definir una métrica como serie de Taylor
       txyzsum()
       tmetric()    Métrica del sistema de referencia, utilizada por cmetric()
                    cuando cframe_flag:true
       triemann()   Tensor de Riemann en la base del sistema de referencia, se utiliza cuando
                    cframe_flag:true
       tricci()     Tensor de Ricci en la base del sistema de referencia, se utiliza cuando
                    cframe_flag:true
       trrc()       Coeficientes de rotación de Ricci, utilizada por christof()
       yesp()