









                         Appendix B
                      REDTEN Functions

     REDTEN provides  a  large  number  of  functions  which
perform  many of the common tensor operations of interest in
General Relativity and differential  geometry.  In  general,
REDTEN  functions  are  of  three types: those which perform
mathematical operations with indexed  objects;  those  which
provide  utility  functions  related to indexed objects; and
those which are general functions, of use in  a  system  not
supporting indexed objects.

     The  arguments  to  each  function  are  in  general  a
combination  of  indexed  objects  and other expressions. An
indexed object may be passed to a  routine  in  one  of  two
ways:  the  object name may be given, or an object reference
may be made (which can include shift  operators,  and  which
will  generate  the  necessary object if it does not exist).
When a name is required for the output object, the name must
be  atomic.  Since all indexed objects are auto-quoted (they
evaluate to their own name), quoting of these names  is  not
required. File-name arguments are given as strings.






_c_h_r_i_s_t_o_f_f_e_l_1 ({name})
Returns: <name> or <_L_i_s_p:_c_h_r_i_s_t_o_f_f_e_l_1>
   For  the  current  metric  this  function  computes   the
   Christoffel  symbols of the first kind. If <name> is non-
   NIL, the symbol is  computed  and  given  that  name.  If
   <name>  is  NIL,  a  look-up  is  performed  to  find the
   currently defined symbol; if none is found the symbol  is
   computed, with the value of _L_i_s_p:_c_h_r_i_s_t_o_f_f_e_l_1 [_c_1] as its
   name.  This object is symmetric in its first two indices.

_c_h_r_i_s_t_o_f_f_e_l_2 ({name})
Returns: <name> or <_L_i_s_p:_c_h_r_i_s_t_o_f_f_e_l_2>
   For  the  current  metric  this  function  computes   the
   Christoffel  symbols  of  the  second  kind. If <name> is
   non-NIL, the symbol is computed and given that  name.  If
   <name>  is  NIL,  a  look-up  is  performed  to  find the
   currently defined symbol; if none is found the symbol  is
   computed, with the value of _L_i_s_p:_c_h_r_i_s_t_o_f_f_e_l_2 [_c_2] as its
   name.  This object has a contravariant first index and is
   symmetric in its second and third indices.

_c_l_e_a_r_t_m_p ()
Returns: t
   This  function  removes  all  temporary  indexed  objects
   currently  in the system. These objects have names of the
   form tmp*<number>. _c_l_e_a_r_t_m_p also  resets  certain  system
   variables to their initial state.

_c_m_o_d (z)
Returns: complex modulus of z
                                 _
   _c_m_o_d computes |z| = sqrt (z * z).

_c_o_f_a_c_t_o_r (name1, name2, {transpose-flag})
Returns: <name2>
   The function _c_o_f_a_c_t_o_r computes the cofactor matrix of the
   rank-2 object <name1>; the result is assigned to <name2>.
   This object  has  the  same  symmetries  as  <name1>.  If
   <transpose-flag>   is   non-NIL,  the  transpose  of  the
   cofactor matrix is placed in <name2>.

_c_o_m_p_l_e_x (z1, {z2, ..})
Returns: t
   _c_o_m_p_l_e_x flags the variables <z1>,  <z2>, ..  as  complex.
   _o_n_j  uses this flag to determine which variables are real
   and which are complex.

_c_o_n_j (z)
Returns: conjugate of <z>
                 _
   _c_o_n_j computes z. Complex quantities are  either  declared
   complex with _c_o_m_p_l_e_x or involve I explicitly.

_c_o_p_y (inname, outname)
Returns: <outname>
   The indexed object  <inname>  is  copied  to  the  object
   <outname>.  If <outname> is protected, _c_o_p_y will fail.

_c_o_v (name)
Returns: <name>#CD
   This function computes the covariant derivative of <name>
   and places the result on <name>'s property list under the
   key #_D_B_R. The name of  the  derivative  is  of  the  form
   <name>#CD  (unless  the  covariant  derivative  is 0). If
   <name> is a shifted object, then the covariant derivative
   of  the parent object is found or computed and shifted as
   required.  Note that this function is  implicitly  called
   during  an  evaluation  when  an  index  contains  the ||
   operator.

_d (exp)
Returns: total derivative of <exp>.

                 n-1
                 --  di(exp)
      _d computes >   ------- d(x ).
                 --  di(x )     i
                 i=0     i

   This function is used in constructing  line-elements  for
   _m_e_t_r_i_c.  It computes the total derivative of its argument
   if this is not a coordinate name.

_d_a_l_a_m_b_e_r_t (exp)
Returns: d'Alambertian of <exp>
   For   the   current   metric   _d_a_l_a_m_b_e_r_t   computes   the
   d'Alambertian  of  the  given expression. This expression
   must be a scalar, or contract to one.

_d_e_l_t_a (name, frame)
Returns: <name>
   This function constructs three  delta  functions  in  the
   frame determined by the integer <frame> (frame = 1, 2, 3,
   4, 5, where these integers are determined by  the  _c_o_n_c_o_v
   list  required).   Normally,  this function should not be
   needed since a complete set of system delta functions  is
   generated  during  the  system-build. Note that the above
   mentioned delta functions are hidden, they do not  appear
   in  the  directory  listing and cannot be deleted by _r_e_m.
   These objects are named d<frame>.

_d_e_t (name, {exp})
Returns: determinant of <name>
   _d_e_t computes the determinant of <name>, which must  be  a
   rank-2  object.  The  determinant  is  stored on <name>'s
   property list under the key _d_e_t.  If  <exp>  is  non-NIL,
   then  <exp>  replaces  the  stored  determinant.   If the
   object is  changed,  the  value  returned  by  _d_e_t  still
   reflects  the  previous  state  of  the  object;  do  PUT
   (<name>, 'DET, 'NIL) to clear the value and re-run _d_e_t.
     Note that the REDUCE matrix  determinant  function  has
   been moved to _m_d_e_t.

_d_e_t_e_r_m (name, cofactor-name, {transpose-flag})
Returns: <determinant>
   _d_e_t_e_r_m is similar to _d_e_t, but uses  the  cofactor  matrix
   computed   by   a   call   to  _c_o_f_a_c_t_o_r  to  compute  the
   determinant. See _c_o_f_a_c_t_o_r.

_d_i_r ({name1, name2, ..})
Returns: t
   This function displays a directory of all indexed objects
   currently   in   existence   (or   just  those  named  as
   arguments), along with certain  information  about  each,
   and  a summary of total numbers and total top-level nodes
   used.

_d_i_v (name, {exp})
Returns: divergence of <name>
   _d_i_v computes the divergence of  the  vector  <name>,  and
   returns  this  scalar.  This  function  also  requires  a
   current tensor metric  be  defined.   The  divergence  is
   stored  on  <name>'s  property list under the key _d_i_v. If
   <exp>  is  non-NIL,  then  <exp>  replaces   the   stored
   divergence.  If <exp> is t, simp is applied to the stored
   divergence and the result replaces it.

_e_i_n_s_t_e_i_n ({name})
Returns: <name> or <_L_i_s_p:_e_i_n_s_t_e_i_n>
   For  the  current  metric  this  function  computes   the
   Einstein  tensor.   If  <name>  is non-NIL, the tensor is
   computed and given that name. If <name> is NIL, a look-up
   is  performed  to  find  the currently defined tensor; if
   none is found the tensor is computed, with the  value  of
   _L_i_s_p:_e_i_n_s_t_e_i_n  [_e_i] as its name. This object is symmetric
   in its two covariant indices.

_f_n (function, index)
Returns: <index> applied to value of <function>.
   _f_n allows the user to call an  indexed  object  returning
   function  with  an  index.   The  index is applied to the
   object,  and  the  value  returned  is  that   which   is
   appropriate    for    the    index.   For   example,   fn
   (christoffel1(), [0,1,1]); calls _c_h_r_i_s_t_o_f_f_e_l_1 and returns
   the  value  of  the  [0,1,1]  element.  <index>  must  be
   enclosed in square brackets.

_f_r_e_i_n_s_t_e_i_n ({name})
Returns: <name> or <_L_i_s_p:_f_r_e_i_n_s_t_e_i_n>
   For the current frame metric this function  computes  the
   frame  Einstein tensor.  If <name> is non-NIL, the object
   is computed and given that name.  If  <name>  is  NIL,  a
   look-up  is  performed  to  find  the  currently  defined
   object; if none is found the object is computed, with the
   value  of _L_i_s_p:_f_r_e_i_n_s_t_e_i_n [_f_r_e_i] as its name. This object
   is symmetric in its two covariant frame indices.

_f_r_m_e_t_r_i_c ({name}, {flag})
Returns: <name> or <_L_i_s_p:_f_r_m_e_t_r_i_c>
   This function creates an frame metric with the  value  of
   _L_i_s_p:_f_r_m_e_t_r_i_c [_e_t_a] as its name.

_f_r_r_i_c_c_i ({name})
Returns: <name> or <_L_i_s_p:_f_r_r_i_c_c_i>
   For the current frame metric this function  computes  the
   frame  Ricci tensor.  If <name> is non-NIL, the object is
   computed and given that name. If <name> is NIL, a look-up
   is  performed  to  find  the currently defined object; if
   none is found the object is computed, with the  value  of
   _L_i_s_p:_f_r_r_i_c_c_i  [_f_r_r_i_c] as its name. The frame Ricci tensor
   is symmetric in its two covariant frame indices.

_f_r_r_i_c_c_i_s_c ({name}, {exp})
Returns: Ricci scalar
   For the current frame metric, this function will  compute
   the  Ricci  scalar.  If  <name> is non-NIL, the scalar is
   computed and assigned to that name. If <name> is  NIL,  a
   look-up  is  performed  to  find  the  currently  defined
   scalar, or if none is found the scalar  is  computed  and
   assigned to the value of _L_i_s_p:_f_r_r_i_c_c_i_s_c [_f_r_r_i_c_s_c].
      If <exp> is non-NIL it replaces the scalar returned by
   _f_r_r_i_c_c_i_s_c  from storage on the property list of the frame
   Ricci tensor; The  value  should  be  the  same  as  that
   returned by _r_i_c_c_i_s_c for the corresponding tensor metric.

_f_r_r_i_e_m_a_n_n ({name})
Returns: <name> or <_L_i_s_p:_f_r_r_i_e_m_a_n_n>
   For the current frame metric this function  computes  the
   frame  Riemann  tensor.  If <name> is non-NIL, the object
   is computed and given that name.  If  <name>  is  NIL,  a
   look-up  is  performed  to  find  the  currently  defined
   object; if none is found the object is computed, with the
   value  of  _L_i_s_p:_f_r_r_i_e_m_a_n_n [_f_r_r_i] as its name. This object
   is fully covariant and has the full Riemann symmetry.

_f_r_w_e_y_l ({name})
Returns: <name> or <_L_i_s_p:_f_r_w_e_y_l>
   For the current frame metric this function  computes  the
   frame  Weyl conformal curvature tensor. If <name> is non-
   NIL, the object is  computed  and  given  that  name.  If
   <name>  is  NIL,  a  look-up  is  performed  to  find the
   currently defined object; if none is found the object  is
   computed,  with  the  value  of  _L_i_s_p:_f_r_w_e_y_l [_f_r_c] as its
   name. This object has the Riemann symmetry and  has  four
   covariant indices.

_g_a_m_m_a ({name})
Returns: <name> or <_L_i_s_p:_g_a_m_m_a>
   For the current frame metric and tensor-frame  connection
   this function computes the Ricci rotation coefficients in
   a tetrad frame. If  <name>  is  non-NIL,  the  object  is
   computed and given that name. If <name> is NIL, a look-up
   is performed to find the  currently  defined  object;  if
   none  is  found the object is computed, with the value of
   _L_i_s_p:_g_a_m_m_a [_g_a_m] as its name.

_g_e_o_d_e_s_i_c (name, {param})
Returns: <name>
   For the current metric tensor, this function computes the
   geodesic  equations  of  motion,  and  places them in the
   matrix <name>. The affine parameter [_s] may be  specified
   by  entering  the  desired variable as <param>. Note that
   the current  coordinates  are  made  to  depend  on  this
   parameter.

_g_e_t_c_o_n (con)
Returns: name of connection of type <con>
   _g_e_t_c_o_n     looks     into     the     connection     list
   _L_i_s_p:_c_u_r_r_e_n_t_c_o_n_n_e_c_t_i_o_n to find the name of the connection
   of type <con>; 1 -- tensor-frame, 2 --  tensor-spinor,  3
   -- frame-spinor.

_g_e_t_m_e_t (met)
Returns: metric of type <met>
   _g_e_t_m_e_t looks into the metric list  _L_i_s_p:_c_u_r_r_e_n_t_m_e_t_r_i_c  to
   find the name of the metric of type <met>.  If <met> = 1,
   the tensor metric is returned, if <met> =  2,  the  frame
   component  metric  is  returned, if <met> = 3, the spinor
   metric is returned, if  <met>  =  4,  the  dotted  spinor
   metric  is  returned,  if <met> = 5, the matrix metric is
   returned. If <met> is negative, the corresponding inverse
   metric names are returned.

_h_e_l_p ({name})
Returns: t
   _h_e_l_p provides an on-line help facility.  When  <name>  is
   that of a REDTEN function or subroutine _h_e_l_p will display
   information about that routine from this section  of  the
   manual.  When  <name>  is  missing,  _h_e_l_p lists all those
   routines for which help is available. _h_e_l_p reads the file
   named under the key _h_e_l_p_f_i_l_e on the symbol _h_e_l_p_l_i_s_t*.

_i_a_s (name)
Returns: <name>
   This function provides a simple  facility  for  assigning
   elements to an indexed object. Only the canonical form of
   symmetrically  related   elements   is   considered   for
   assignment.  The  user  is  prompted for the input, which
   must be terminated by a valid terminator.  A  input  line
   consisting solely of a terminator causes a premature exit
   from the function. Only indexed  objects  which  are  not
   write-protected may be assigned.

_i_m (z)
Returns: imaginary part of <z>


                    _
   _i_m computes (z - z)/(2 I).

_i_n_d_e_x_e_d (name)
Returns: indexed property of <name>
   This function determines whether  the  object  <name>  is
   indexed.  The  value returned is NIL if the object is not
   indexed; otherwise one of _t_e_n_s_o_r, _f_r_a_m_e, _s_p_i_n_o_r,  _m_a_t_r_i_x,
   _m_i_x_e_d or _s_c_a_l_a_r is returned.

_i_n_v_e_r_t (name)
Returns: <name>#INV
   _i_n_v_e_r_t computes the matrix inverse of the  rank-2  object
   <name>,  and gives it the name <name>#INV. The indices of
   the inverse are shifted with respect to those of  <name>.
   The reciprocal of the determinant of the matrix is placed
   in the _m_u_l_t_i_p_l_i_e_r property of the  inverse.  The  inverse
   matrix has the same symmetries as <name>.

_i_p_r_o_p (name)
Returns: t
   _i_p_r_o_p displays a pretty printed version of those elements
   of  <name>'s  property  list  which  are specified in the
   control variable _L_i_s_p:_i_p_r_o_p**.   This  function  is  also
   called  when  the  elements  of a single object are being
   displayed. In this case, if the switch _i_p_r_o_p [t] is  NIL,
   the property list is not displayed.

_k_i_l_l_i_n_g (name, {conf})
Returns: <name>
   This function computes  the  Killing  equations  for  the
   current  tensor  metric.  The equations are placed in the
   matrix <name>. If the parameter <conf>  is  non-NIL,  the
   conformal  Killing  equations are computed, otherwise the
   conformal factor is taken as  zero.  The  Killing  vector
   name is the value of _L_i_s_p:_k_i_l_l_i_n_g [_k], and is declared to
   be implicit and to depend on all the current coordinates.

_l_i_e (name, vector)
Returns: <name>
   This function computes the Lie derivative  of  <name>  in
   the  direction  of  <vector>. The result is placed in the
   object named <name><vector>#LIE.

_m_a_p_f_i (indexed-object)
or
_m_a_p_f_i (function ({args,..,} indexed-object, {args,..}))
Returns: <indexed-object>
   _m_a_p_f_i maps either the system evaluation  function  (first
   form)  or  the  function indicated by the formal function
   call (second form) with the  given  arguments.  <indexed-
   object>  is  either  simply  the object name or an object
   reference with a formal index which may indicate a  shift
   operation.   Integer indices may restrict the application
   of the mapping to parts of  the  object.  The  multiplier
   becomes  1 after the mapping is done.  The original value
   of <name> and its multiplier  are  saved  in  the  global
   variable _L_i_s_p:_m_a_p_b_a_c_k.

_m_c_l_e_a_r ()
Returns: 80
   _m_c_l_e_a_r resets parser variables and the linelength if  the
   i/o system becomes confused due to an error or interrupt.

_m_e_t_r_i_c ({line-element}, {name})
or
_m_e_t_r_i_c (name)
Returns: <name> or <_L_i_s_p:_m_e_t_r_i_c>
   Given the  line  element  <line-element>,  this  function
   computes the corresponding metric tensor and its inverse.
   If name is not given, the value  of  _L_i_s_p:_m_e_t_r_i_c  [_g]  is
   used as the default tensor name; the inverse is given the
   name <_L_i_s_p:_m_e_t_r_i_c>#INV. If the current metric  tensor  is
   undefined,  _m_e_t_r_i_c  declares  it  to be this object. Note
   that the names of all geometrical objects are  stored  on
   the property list of the metric tensor.
      The line element is of the form:

      name: g     _d (x )^2 + g     _d (x )  _d (x ) + ...
             0 0      0       0 1      0       1

   where each x   is  one  of  the  current  coordinates  as
               i
   defined  on  the  global _L_i_s_p:_c_o_o_r_d_s list. The operator _d
   indicates  which  elements  of  the  line   element   are
   coordinate displacements.
      If <line-element> is NIL, the metric is computed  from
   the  frame metric and the tensor-frame connection. In the
   second form of use, a previously computed  object  <name>
   will  be  turned  into  a metric tensor if it is a rank-2
   covariant tensor. The inverse metric will have  the  name
   <name>#INV.

_m_k_c_o_o_r_d_s (name, {coords})
Returns: <name>
   _m_k_c_o_o_r_d_s  constructs  a  contravariant  vector  from  the
   currently  defined coordinates in <name>. The coordinates
   which are placed on the  property  list  are  either  the
   current coordinates or the parameter <coords>.

_m_k_s_c_a_l_a_r (name)
Returns: <name>
   _m_k_s_c_a_l_a_r declares <name> to be an 'indexed'  scalar.  The
   value  of <name> can only be accessed with an empty index
   (eg. Q[]); any previous value of <name> is moved  to  the
   required location when the object is created and returned
   to the value cell of <name> when the  object  is  deleted
   via  _r_e_m. If name is used with a non-empty index, it must
   indicate a derivative operation.

_m_k_t_n_s_r (name, {concov}, {symmetry}, {implicit}, {type})
Returns: <name>[<test index>]
   This function creates the  indexed  object  <name>,  with
   indices  as  indicated  by  the  parameter  <concov>. The
   number of indices is given by the length of <concov>;  an
   index  is contravariant or covariant if the corresponding
   element   of   <concov>   is   positive,   or   negative,
   respectively.  The  type  of  each indice is given by the
   numerical value of the elements of <concov>: 1 --  tensor
   index, 2 -- frame component index, 3 -- spinor index, 4 -
   dotted spinor index, 5 -- matrix index.  If  <concov>  is
   NIL,  <name>  is  partially  created, this is useful when
   placing a symmetry list on <name>.
      The symmetries of the object are given  by  a  non-NIL
   <symmetry>,  which  consists  of  a  list  of independent
   symmetry lists of the form:

       (({c,} l, p , p , p , ..), .. {(h, p , p , ..)})
                  1   2   3                1   2

      In each list <l> is the size of the blocks involved in
   the symmetry, if <l> is negative then an anti-symmetry is
   implied. If <l> is 0, then a trace  symmetry  is  implied
   but  the  block size is 1. The locations of each block in
   the index are given by the pointers p . If the letter 'C'
                                        i
   is  prepended  to  the  list, it indicates that a complex
   conjugate is to be taken when permuting  the  index.  The
   form  beginning with the letter 'H' specifies a Hermitian
   symmetry. In this case, the pointers  p   must  point  to
                                          i
   spinor  dotted-spinor  blocks  within  the _c_o_n_c_o_v list of
   <name>. An example of  a  symmetry  list  describing  the
   Riemann  symmetry  is  '((-1 1 2) (-1 3 4) (2 1 3)). Note
   that the internal form of the symmetry list  is  somewhat
   different.
      If <implicit> is non-NIL and the name of an equivalent
   indexed  object,  then  any  element reference that would
   otherwise return zero (and is  not  identically  zero  by
   virtue  of the intrinsic symmetries), will instead return
   the  value  <implicit>  as  an  indexed  element;  or  if
   <implicit> is an integer, that integer is returned.
      The type of the object may be specified if  <type>  is
   non-NIL.

_m_u_l_t_i_p_l_i_e_r (name, {exp})
Returns: multiplier of <name>
   This function provides access to the _m_u_l_t_i_p_l_i_e_r  property
   of <name>.  If <exp> is NIL, the multiplier is retrieved,
   if <exp> is non-NIL, <exp> replaces the multiplier.

_n_o_c_o_m_p_l_e_x (z1, {z2, ..})
Returns: t
   _n_o_c_o_m_p_l_e_x removes the complex flag from the <z >.
                                                 i

_n_o_d_i_r (name1, {name2, ..})
Returns: t
   This function flags each of the indexed objects name   so
                                                       i
   they will not appear in a directory listing. Each flagged
   object is counted into the statistics however.

_n_u_l_l_t_e_t_r_a_d ({name})
Returns: <name> or <_L_i_s_p:_n_u_l_l_t_e_t_r_a_d>
   For the current frame metric this function  constructs  a
   null-tetrad  connection  for a diagonal tensor metric. It
   requires  that  the  spin-matrices  have   already   been
   computed  via  _s_p_i_n_m_a_t.  If <name> is non-NIL, the object
   is computed and given that name. If  <name>  is  NIL  the
   object is computed, with the value of _L_i_s_p:_n_u_l_l_t_e_t_r_a_d [_z]
   as its name.

_p_d_f (exp, index)
Returns: formal partial derivative of <exp>
   _p_d_f provides a method of indicating  partial  derivatives
   of an expression with respect to the current coordinates.
   Unlike  a  scalar  object,  <exp>  may  contain   indexed
   objects,  their index structures will be correctly sorted
   out.  <index> must be enclosed in square brackets.  Until
   involved in an indexed assignment operation this function
   remains unevaluated.

_p_r_o_t_e_c_t (name, {protect-flag})
Returns: t
   This function sets the protection  flag  on  the  indexed
   object  <name>. The protection is checked by other system
   functions  to  determine  the  legality  of  deleting  or
   modifying  the  object.  The allowed values for <protect-
   flag> are:
             w -- prevent any routine writing to the object,
             k -- prevent the object from being deleted,
             kw or wk -- combine the above protections,
             NIL -- remove existing protection,
             other -- no action.

_r_a_t (z/w)
Returns: rationalization of <z/w>
                   _
   _r_a_t computes (z w)/|w2|. Unless <w> involves  I  directly
   this  function  will  not  result  in  any  change to the
   argument.

_r_e (z)
Returns: real part of <z>

                    _
   _r_e computes (z + z)/2.

_r_e_m (name1, {name2, name3, ..})
or
_r_e_m (_a_l_l, {flag})
Returns: t
   _r_e_m attempts to delete  from  the  system  the  specified
   indexed objects. It has two input formats.
      In the first format, those arguments which are indexed
   objects  and are not delete protected are removed. If any
   name is not that of an indexed object, it is ignored.
      In the second format, the atom _a_l_l indicates that  _r_e_m
   will  attempt  to  delete all indexed objects whose names
   are in the _i_n_a_m_e_s list. If <flag> is non-NIL, this action
   is done immediately, without user intervention. If <flag>
   is NIL, then _r_e_m considers each object in turn, with  the
   question "Delete? (Y/N/Q/G)". If the user responds with a
   Y, the object is deleted. If a  Q  is  entered,  the  _r_e_m
   aborts.  If  G is entered, _r_e_m will attempt to delete all
   remaining  objects,  without  further  query.  To   guard
   against   accident,   the  message  "Are  you  sure?"  is
   displayed, it must be answered with a Y, or the operation
   is  abandoned.  If  any  response  other  than Y, Q, G is
   entered, it is treated as N, and no action is taken.
      _r_e_m will fail to delete those objects which are delete
   protected.

_r_i_c_c_i ({name})
Returns: <name> or <_L_i_s_p:_r_i_c_c_i>
   For the current metric this function computes  the  Ricci
   tensor.  If <name> is non-NIL, the tensor is computed and
   given that name. If <name> is NIL, a look-up is performed
   to  find  the  currently defined tensor; if none is found
   the tensor is computed,  with  the  value  of  _L_i_s_p:_r_i_c_c_i
   [_r_i_c]  as  its name. The Ricci tensor is symmetric in its
   two covariant indices.

_r_i_c_c_i_s_c ({name}, {exp})
Returns: Ricci scalar
   For the current metric, this function  will  compute  the
   Ricci  scalar.  If  <name>  is  non-NIL,  the  scalar  is
   computed and assigned to that name. If <name> is  NIL,  a
   look-up  is  performed  to  find  the  currently  defined
   scalar, or if none is found the scalar  is  computed  and
   assigned to the value of _L_i_s_p:_r_i_c_c_i_s_c [_r_i_c_s_c].
      If <exp> is non-NIL it replaces the scalar returned by
   _r_i_c_c_i_s_c  from  storage  on the property list of the Ricci
   tensor;

_r_i_e_m_a_n_n ({name})
Returns: <name> or <_L_i_s_p:_r_i_e_m_a_n_n>
   For the current metric this function computes the Riemann
   tensor.  If <name> is non-NIL, the tensor is computed and
   given that name. If <name> is NIL, a look-up is performed
   to  find  the  currently defined tensor; if none is found
   the tensor is computed, with the  value  of  _L_i_s_p:_r_i_e_m_a_n_n
   [_r_i]  as its name. This object is fully covariant and has
   the full Riemann symmetry.

_s_a_v_e_c (file, name1, {name2, ..})
or
_s_a_v_e_c (file, _a_l_l, { name1, name2, ..})
Returns: t
   _s_a_v_e_c provides a facility for saving  the  components  of
   selected indexed objects and other non-indexed objects in
   the disk file <file>. The components of each  object  are
   saved independently, under the names <name><index>, where
   <index> is the compressed  index  of  the  element;  only
   explicit  elements  are  saved.   These  values cannot be
   reintroduced in indexed format. As each object  is  saved
   its  name is displayed. If the atom _a_l_l is present, _s_a_v_e_c
   saves all indexed  objects  present  in  the  _L_i_s_p:_i_n_a_m_e_s
   list,  as  well  as  any  non-indexed objects whose names
   follow. To reload the values, lisp load the file (in  PSL
   versions use `lapin', in Franz versions use `load').
      In  addition  to  the  named  objects,  those   system
   variables  whose names appear in the  _L_i_s_p:_s_a_v_e_l_i_s_t* list
   are  also  saved.  File   names   found   in   the   list
   _L_i_s_p:_l_o_a_d_l_i_s_t  will be read-in when the save file is read
   in.  If the variable _L_i_s_p:_t_i_t_l_e has a string value,  that
   value  is  used  for  the title of the file; it is echoed
   when the file is reloaded, along with the date  and  time
   the file was saved.

_s_a_v_e_i (file, name1, {name2, ..})
or
_s_a_v_e_i (file, _a_l_l, { name1, name2, ..})
Returns: t
   _s_a_v_e_i provides a facility for saving selected indexed  or
   non-indexed  objects in the disk file <file>. The objects
   are saved in a format that allows them to be reintroduced
   to  the  system  in  exactly  the same form as originally
   present. As each object is saved its name  is  displayed.
   If  the  atom  _a_l_l  is  present  _s_a_v_e_i  saves all indexed
   objects present in the inames list, as well as  any  non-
   indexed   objects  whose  names  follow.  To  reload  the
   objects, lisp load the file; as each object  is  restored
   its name is echoed.
      In  addition  to  the  named  objects,  those   system
   variables  whose  names appear in the _L_i_s_p:_s_a_v_e_l_i_s_t* list
   are  also  saved.  File   names   found   in   the   list
   _L_i_s_p:_l_o_a_d_l_i_s_t  will be read-in when the save file is read
   in. If the variable _L_i_s_p:_t_i_t_l_e has a string  value,  that
   value  is  used  for  the title of the file; it is echoed
   when the file is reloaded, along with the date  and  time
   the file was saved.

_s_e_t_c_o_n (name, con)
Returns: <name>
   _s_e_t_c_o_n set the current connection of type <con> to be the
   object <name> which must be of type  _c_o_n_n_e_c_t_i_o_n.  <con> =
   1: tensor-frame, <con> = 2:  tensor-spinor,  <con>  =  3:
   frame-spinor.   The  preferred  _c_o_n_c_o_v  lists  for  these
   connections are: <con> = 1: (-2 -1), <con> = 2: (-1 3 4),
   <con> = 3: (-2 3 4).

_s_e_t_m_e_t (name)
Returns: <name>
   This function sets the current metric to  be  the  object
   <name>.   <name>  must be of type _m_e_t_r_i_c, and must be the
   covariant  metric.  The   _c_o_n_c_o_v   property   of   <name>
   determines  which  metric  <name> becomes. <name> must be
   covariant in both its indices.

_s_h_i_f_t (name[shifted-index])
Returns: <offspring name>[<index>]
   This function is used to raise  and  lower  indices.  The
   object is entered as a name and index, where the index is
   symbolic. The indices to be shifted are marked by placing
   an  at  sign (@) before each indice as a prefix operator.
   When the shifted object is computed it is given a name of
   the  form <name#n1n2..>, where n1, n2, ..  are determined
   by coverting the _c_o_n_c_o_v  difference  list  to  a  base-16
   number,  whose  digits  are  the letters of the alphabet.
   This name is placed on the property list  of  the  parent
   object  <name>  under  the  key  *_A_T*. In order that full
   advantage be  taken  of  symmetries,  the  parent  object
   should  be  the  most  symmetric  representation  of  the
   geometric object. Any future reference  to  this  shifted
   object  is  given in the same format as the input to this
   function.

_s_p_c_h_r_i_s_t_o_f_f_e_l ({name})
Returns: <name> or <_L_i_s_p:_s_p_c_h_r_i_s_t_o_f_f_e_l>
   For the current spinor  metric  and  spin  matrices  this
   function  computes  spinor Christoffel symbols. If <name>
   is non-NIL, the object is computed and given  that  name.
   If  <name>  is  NIL,  a  look-up is performed to find the
   currently defined object; if none is found the object  is
   computed,  with  the value of _L_i_s_p:_s_p_c_h_r_i_s_t_o_f_f_e_l [_s_p_c] as
   its name.

_s_p_i_n_m_a_t ({name})
Returns: <name> or <_L_i_s_p:_s_p_i_n_m_a_t>
   For the current tensor this function  computes  the  spin
   matrices.  Currently  this  function can only compute the
   spin matrices if the tensor metric is diagonal. The  form
   of  the  spin  matrices  is that of the generalized Pauli
   spin matrices.  If <name> is  non-NIL,  the  matrices  is
   computed and given that name. If <name> is NIL, a look-up
   is performed to find the currently defined  matrices;  if
   none is found the matrices is computed, with the value of
   _L_i_s_p:_g_a_m_m_a [_g_a_m] as its name.

_s_p_m_e_t_r_i_c ({name})
Returns: <name> or <_L_i_s_p:_s_p_m_e_t_r_i_c>
   This  function  generates  the  standard  set  of  spinor
   metrics,  with  both  dotted and un-dotted indices. These
   objects are given names from the  list  on  _L_i_s_p:_s_p_m_e_t_r_i_c
   [_e_3  and  _e_4].  Each  of  these  objects  is  the  others
   conjugate.  The  inverse  metrics  are  hidden  from  the
   directory listing.

_t_r_a_c_e (name)
Returns: trace of <name>
   _t_r_a_c_e computes the trace  of  <name>,  which  must  be  a
   rank-2  object. The REDUCE matrix trace function has been
   moved to _m_t_r_a_c_e.

_w_e_y_l ({name})
Returns: <name> or <_L_i_s_p:_w_e_y_l>
   For the current metric this function  computes  the  Weyl
   conformal  curvature  tensor.  If  <name> is non-NIL, the
   tensor is computed and given that name. If <name> is NIL,
   a  look-up  is  performed  to  find the currently defined
   tensor; if none is found the tensor is computed, with the
   value  of  _L_i_s_p:_w_e_y_l [_c] as its name. This object has the
   Riemann symmetry and has four covariant indices.
















































































