









                         Appendix B

     muTENSOR provides a large  number  of  functions  which
perform  many of the common tensor operations of interest in
General Relativity and differential  geometry.  In  general,
muTENSOR  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.






CHRISTOFFEL1 ({name})
Returns: <name> or <CHRISTOFFEL1>
   For  the  current  metric  this  function  computes   the
   Christoffel  symbols of the first kind. If <name> is non-
   FALSE, the symbol is computed and  given  that  name.  If
   <name>  is  FALSE,  a  look-up  is  performed to find the
   currently defined symbol; if none is found the symbol  is
   computed,  with  the  value  of  CHRISTOFFEL1 [C1] as its
   name.  This object is symmetric in its first two indices.

CHRISTOFFEL2 ({name})
Returns: <name> or <CHRISTOFFEL2>
   For  the  current  metric  this  function  computes   the
   Christoffel  symbols  of  the  second  kind. If <name> is
   non-FALSE, the symbol is computed and given that name. If
   <name>  is  FALSE,  a  look-up  is  performed to find the
   currently defined symbol; if none is found the symbol  is
   computed, with the value of CHRISTOFFEL2[C2] as its name.
   This object  has  a  contravariant  first  index  and  is
   symmetric in its second and third indices.

CLEARTMP ()
Returns: TRUE
   This  function  removes  all  temporary  indexed  objects
   currently  in the system. These objects have names of the
   form TMP#<number>. CLEARTMP also  resets  certain  system
   variables to their initial state.

CMOD (z)
Returns: complex modulus of z
                                 _
   CMOD computes |z| = sqrt (z * z).

COFACTOR (name1, name2, {transpose-flag})
Returns: <name2>
   The function  COFACTOR 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-FALSE, the transpose of the
   cofactor matrix is placed in <name2>.

COMPLEX (z1, {z2, ..})
Returns: TRUE
   COMPLEX flags the variables <z1>,  <z2>, ..  as  complex.
   CONJ uses this flag to determine which variables are real
   and which are complex.

CONJ (z)
Returns: conjugate of <z>
                 _
   CONJ computes z. Complex quantities are  either  declared
   complex with COMPLEX or involve #I explicitly.

COPY (inname, outname)
Returns: <outname>
   The indexed object  <inname>  is  copied  to  the  object
   <outname>.  If <outname> is protected, COPY will fail.

COV (name)
Returns: <name>#CD
   This function computes the covariant derivative of <name>
   and places the result on <name>'s property list under the
   key ||. 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
   METRIC.  It computes the total derivative of its argument
   if this is not a coordinate name.

DALAMBERT (exp)
Returns: d'Alambertian of <exp>
   For   the   current   metric   DALAMBERT   computes   the
   d'Alambertian  of  the  given expression. This expression
   must be a scalar, or contract to one.

DATE ()
Returns: time and date string.

DELTA (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  CONCOV
   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 REM.
   These objects are named d<frame>.

DET (name, {exp})
Returns: determinant of <name>
   DET computes the determinant of <name>, which must  be  a
   rank-2  object.  The  determinant  is  stored on <name>'s
   property list under the key DET. If <exp>  is  non-FALSE,
   then  <exp>  replaces  the  stored  determinant.   If the
   object is  changed,  the  value  returned  by  DET  still
   reflects  the  previous  state  of  the  object;  do  PUT
   (<name>, 'DET) to clear the value and re-run DET.

DETERM (name, cofactor-name, {transpose-flag})
Returns: <determinant>
   DETERM is similar to DET, but uses  the  cofactor  matrix
   computed   by   a   call   to  COFACTOR  to  compute  the
   determinant. See  COFACTOR.

DIF (name, difvar1, {difvar2, ..})
Returns: <derivative>
   This function is the standard DIF  function  modified  to
   handle   indexed   objects.  Note  that  if  there  is  a
   dependency, the  return  value  displays  as  the  tensor
   element  with  a derivative index.  If the <difvar > is a
                                                     i
   member of the current coordinates, it is replaced by  the
   corresponding index; otherwise it is displayed directly.

DIR ({name1, name2, ..})
Returns: TRUE
   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.

DIV (name, {exp})
Returns: divergence of <name>
   DIV 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 DIV. If
   <exp>  is  non-FALSE,  then  <exp>  replaces  the  stored
   divergence.   If  <exp>  is  TRUE, EVAL is applied to the
   stored divergence and the result replaces it.

EINSTEIN ({name})
Returns: <name> or <EINSTEIN>
   For  the  current  metric  this  function  computes   the
   Einstein  tensor.   If <name> is non-FALSE, the tensor is
   computed and given that  name.  If  <name>  is  FALSE,  a
   look-up  is  performed  to  find  the  currently  defined
   tensor; if none is found the tensor is computed, with the
   value   of  EINSTEIN[G]  as  its  name.  This  object  is
   symmetric in its two covariant indices.

EVSUBLET (exp)
Returns: <exp>
   This function applies all defined LET rules to <exp>  and
   EVAL's the result. See also LET and SUBLET.

FRDS (file)
Returns: <file> or FALSE
   This function is  similar  to  RDS  but  takes  a  string
   argument as a file name.

FWRS (file, {reopen})
Returns: <file> or FALSE
   This function is  similar  to  WRS  but  takes  a  string
   argument as a file name.

GARB ({file})
Returns: TRUE
   GARB  compactifies  the  virtual   memory   file   <file>
   [<OFFLOADFILE>].   Note that the file will be bigger than
   is reported by garb.exe because updates are written  onto
   the end of the file.

GEODESIC (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;  and  that the control variable DIFVAR [FALSE]
   is set to this parameter if it is not already defined.

GETCON (con)
Returns: name of connection of type <con>
   GETCON looks into the connection  list  CURRENTCONNECTION
   to  find  the  name of the connection of type <con>; 1 --
   tensor-frame, 2 -- tensor-spinor, 3 -- frame-spinor.

GETMET (met)
Returns: metric of type <met>
   GETMET looks into the metric list CURRENTMETRIC  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.

GRADEF (name, var , val , {var , val , ..})
                 1     1      2     2
Returns: <name>
   GRADEF puts explicit dependencies on <name>. For each  of
   the  variables  <var >,  the  derivative  of  <name> with
                       i
   respect to  <var >  becomes  <val >,  which  may  be  any
                   i                i
   expression. Those of the <val > which are atomic are made
                                i
   to depend on all the  <var >,  so  that  implicit  higher
                             i
   derivatives are not lost.

GRADV (name, val)
Returns: <name>
   The function  GRADV  will  assign  <val>  to  <name>  and
   compute  and  assign  all the defined gradients of <name>
   which are atomic.  The symbolic forms may be regained  if
   <name> is quoted, and <val> is also the quote of <name>.

HELP ({name})
Returns: TRUE
   HELP provides an on-line help facility.  When  <name>  is
   that  of  a  muTENSOR  function  or  subroutine HELP will
   display information about that routine from this  section
   of  the  manual.  When  <name> is missing, HELP lists all
   those routines for which help is  available.  HELP  reads
   the  file  named  under  the  key  HELPFILE on the symbol
   HELPLIST#. The pager program displays a page  and  pauses
   with  the  prompt  "--MORE--";  valid  responses are Q to
   quit, U to back-up a page, and  any  other  character  to
   continue paging forward through the help file. A carriage
   return is required to send the response.

IAS (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.

IM (z)
Returns: imaginary part of <z>

                    _
   IM computes (z - z)/(2 #I).

INDEXED (name)
Returns: indexed property of <name>
   This function determines whether  the  object  <name>  is
   indexed. The value returned is FALSE if the object is not
   indexed; otherwise one of TENSOR, FRAME, SPINOR,  MATRIX,
   MIXED or SCALAR is returned.

INVERT (name)
Returns: <name>#INV
   INVERT 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 MULTIPLIER property of the  inverse.  The  inverse
   matrix has the same symmetries as <name>

IPROP (name)
Returns: TRUE
   IPROP displays a pretty printed version of those elements
   of  <name>'s  property  list  which  are specified in the
   control variable IPROP#.  This function  is  also  called
   when the elements of a single object are being displayed.
   In this case, if the switch IPROP [TRUE]  is  FALSE,  the
   property list is not displayed.

KILLING (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-FALSE,  the
   conformal  Killing  equations are computed, otherwise the
   conformal factor is taken as  zero.  The  Killing  vector
   name  is  the value of KILLING [k], and is declared to be
   implicit and to depend on all the current coordinates.

LET (exp, replacement)
Returns: <replacement>
   LET defines a rule for replacing <exp>  by  <replacement>
   in  expressions passed through SUBLET or EVSUBLET. A rule
   remains in effect until removed by a call to  UNLET.  LET
   rules are simple text replacement rules.

LIE (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.

MAPFI (indexed-object)
   or
MAPFI (function ({args,..,} indexed-object, {args,..}))
Returns: <indexed-object>
   MAPFI 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 MAPBACK.

METRIC ({line-element}, {name})
   or
METRIC (name)
Returns: <name> or <METRIC>
   Given the  line  element  <line-element>,  this  function
   computes the corresponding metric tensor and its inverse.
   If name is not given, the value of METRIC [g] is used  as
   the  default  tensor  name; the inverse is given the name
   <METRIC>#INV. If the current metric tensor is  undefined,
   METRIC declares it to be this object. Note that the names
   of all geometric 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  COORDS  list.  The  operator  d
   indicates  which  elements  of  the  line   element   are
   coordinate displacements.
      If <line-element> is FALSE,  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.

MKCOORDS (name, {coords})
Returns: <name>
   MKCOORDS  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>.

MKSCALAR (name)
Returns: <name>
   MKSCALAR 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  REM. If name is used with a non-empty index, it must
   indicate a derivative operation.

MKTNSR (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
   FALSE,  <name>  is partially created, this is useful when
   placing a symmetry list on <name>.
      The symmetries of the object are given by a  non-FALSE
   <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 CONCOV 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-FALSE  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-FALSE.

MULTIPLIER (name, {exp})
Returns: multiplier of <name>
   This function provides access to the MULTIPLIER  property
   of   <name>.   If  <exp>  is  FALSE,  the  multiplier  is
   retrieved, if <exp>  is  non-FALSE,  <exp>  replaces  the
   multiplier.

NOCOMPLEX (z1, {z2, ..})
Returns: TRUE
   NOCOMPLEX removes the complex flag from the <zi>.

NODIR (name1, {name2, ..})
Returns: TRUE
   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.

OFF (switch1, {switch2, ..})
Returns: TRUE
   OFF sets each given switch to FALSE. The internal  switch
   name is prepended by a #. See ON.

OFFLOAD (file, name1, {name2, ..})
   or
OFFLOAD (file, ALL)
Returns: <file>
   This function writes the named indexed  objects  (or  all
   indexed  object objects if ALL is present) to the virtual
   memory file <file> [<OFFLOADFILE>].  All future writes to
   these objects will also go to the offload file. To reload
   the objects into the system, use ONLOAD.

ON (switch1, {switch2, ..})
Returns: TRUE
   ON sets each given switch to TRUE.  The  internal  switch
   name is prepended by a #. See OFF.

ONLOAD (name1, {name2, ..})
   or
ONLOAD (ALL)
Returns: TRUE
   This function loads the named indexed  objects  from  the
   virtual memory files to internal muSIMP memory. The links
   to the virtual memory files are discarded.

PDIF (exp, index)
Returns: formal partial derivative of <exp>
   PDIF provides a method of indicating partial  derivatives
   of an expression with respect to the current coordinates.
   <exp> may contain indexed objects, the  index  structures
   will  be  correctly  sorted  out when <exp> is evaluated.
   <index>  must  be  enclosed  in  square  brackets.  Until
   involved in an indexed assignment operation this function
   remains unevaluated.

PROTECT (name, {protect-flag})
Returns: TRUE
   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,
             FALSE -- remove existing protection,
             other -- no action.

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

RE (z)
Returns: real part of <z>
                    _
   RE computes (z + z)/2.

RECOVER (file)
Returns: TRUE
   This function looks into the virtual memory  file  <file>
   [<OFFLOADFILE>]  and  recovers the indexed objects stored
   there. This is useful if  the  system  has  crashed  with
   objects  on  disk. There is, of course, no way to recover
   those objects which were residing in muSIMP memory at the
   time of the crash.

REM (name1, {name2, name3, ..})
   or
REM (ALL, {flag})
Returns: TRUE
   REM 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 ALL indicates that  REM
   will  attempt  to  delete all indexed objects whose names
   are in the INAMES list.  If  <flag>  is  non-FALSE,  this
   action is done immediately, without user intervention. If
   <flag> is FALSE, then REM 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,  then  REM  aborts.  If  G  is entered, REM 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.
      REM will fail to delete those objects which are delete
   protected.

RICCI ({name})
Returns: <name> or <RICCI>
   For the current metric this function computes  the  Ricci
   tensor.   If  <name> is non-FALSE, the tensor is computed
   and given that name. If <name> is  FALSE,  a  look-up  is
   performed  to  find the currently defined tensor; if none
   is found the tensor is computed, with the value of  RICCI
   [RIC]  as  its name. The Ricci tensor is symmetric in its
   two covariant indices.

RICCISC ({name}, {exp})
Returns: Ricci scalar
   For the current metric, this function  will  compute  the
   Ricci  scalar.  If  <name>  is  non-FALSE,  the scalar is
   computed and assigned to that name. If <name> is FALSE, 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 RICCISC [RICSC].
      If <exp> is non-FALSE it replaces the scalar  returned
   by RICCISC from storage on the property list of the Ricci
   tensor;

RIEMANN ({name})
Returns: <name> or <RIEMANN>
   For the current metric this function computes the Riemann
   tensor.   If  <name> is non-FALSE, the tensor is computed
   and given that name. If <name> is  FALSE,  a  look-up  is
   performed  to  find the currently defined tensor; if none
   is found the  tensor  is  computed,  with  the  value  of
   RIEMANN  [R]  as its name. This object is fully covariant
   and has the full Riemann symmetry.

SAVEC (file, name1, {name2, ..})
   or
SAVEC (file, ALL, { name1, name2, ..})
Returns: TRUE
   SAVEC 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 ALL is present, SAVEC
   saves all indexed objects present in the INAMES list,  as
   well  as  any  non-indexed objects whose names follow. To
   reload the values, RDS the file.
      In  addition  to  the  named  objects,  those   system
   variables  whose  names  appear in the SAVELIST# list are
   also saved. File names found in the list LOADLIST will be
   read-in  when  the save file is read in.  If the variable
   TITLE 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.

SAVEI (file, name1, {name2, ..})
   or
SAVEI (file, ALL, { name1, name2, ..})
Returns: TRUE
   SAVEI 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  ALL  is  present  SAVEI  saves all indexed
   objects present in the inames list, as well as  any  non-
   indexed   objects  whose  names  follow.  To  reload  the
   objects, RDS 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 SAVELIST# list are
   also saved. File names found in the list LOADLIST will be
   read-in  when  the  save file is read in. If the variable
   TITLE 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.

SETCON (name, con)
Returns: <name>
   SETCON set the current connection of type <con> to be the
   object  <name> which must be of type CONNECTION.  <con> =
   1: tensor-frame, <con> = 2:  tensor-spinor,  <con>  =  3:
   frame-spinor.   The  preferred  CONCOV  lists  for  these
   connections are: <con> = 1: (-2 -1), <con> = 2: (-1 3 4),
   <con> = 3: (-2 3 4).

SETMET (name)
Returns: <name>
   This function sets the current metric to  be  the  object
   <name>.   <name>  must be of type METRIC, and must be the
   covariant  metric.  The   CONCOV   property   of   <name>
   determines  which  metric  <name> becomes. <name> must be
   covariant in both its indices.

SHIFT (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
   a circumflex (^) 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 CONCOV  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  ^.  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.

SUBLET (exp)
Returns: <exp>
   This function applies all defined  LET  rules  to  <exp>.
   See also LET and EVSUBLET.

TRACE (name)
Returns: trace of <name>
   TRACE computes the trace  of  <name>,  which  must  be  a
   rank-2 object.

TRANSFER (file, name1, {name2, ..})
   or
TRANSFER (file, ALL)
Returns: <file>
   This function moves the named objects from their  current
   virtual  memory  file  to  <file> [<OFFLOADFILE>]. If the
   object  is  currently  in  memory,  TRANSFER  acts   like
   OFFLOAD.

UNLET (exp)
Returns: <exp>
   UNLET removes the LET rule defined for <exp>.

UPDATE (name)
Returns: TRUE
   UPDATE writes a copy of the  current  state  of  <name>'s
   property  list  to the virtual memory file where <name>'s
   elements have been placed. This allows offloaded  objects
   to  be  recovered  in  the  event  of a system crash.  An
   UPDATE is done automatically when the object is offloaded
   or  when  the  object  is created with USEDISK TRUE. This
   function is provided to allow the  user  to  reflect  any
   changes  made  to <name>'s property list into the virtual
   memory file.

WEYL ({name}
Returns: <name> or <WEYL>
   For the current metric this function  computes  the  Weyl
   conformal  curvature  tensor. If <name> is non-FALSE, the
   tensor is computed and given  that  name.  If  <name>  is
   FALSE,  a  look-up  is  performed  to  find the currently
   defined tensor; if none is found the tensor is  computed,
   with  the  value of WEYL [C] as its name. This object has
   the Riemann symmetry and has four covariant indices.













































































