MathTensor Usage Messages

Absorbg[expr] causes Metricg's with indices summed on some other tensor to be absorbed by raising or lowering the summed indices. Absorbg[expr,n] absorbs Metricg on the nth term of expr.

AbsorbKdelta[expr] will cause Kronecker deltas, Kdelta, in expr to act on indices in tensors that are paired with indices in Kdelta. AbsorbKdelta[expr,n], where expr is a sum of terms, will cause any Kdelta appearing in term n of the sum to be absorbed by changing index names and raising and lowering indices if possible. For space or spacetime indices, this is not what you want because the results will generally be different from those using the metric tensor Metricg to raise or lower indices. You should use Metricg with one covariant and one contravariant index instead of Kdelta, unless you are dealing with particular spaces, such as a Euclidean space in Cartesian coordinates, or a group space in Yang-Mills gauge theory. See also Kdelta, KdeltaRule.

AbsorbRule is the rule set used internally by the command Absorb.

AddIndexTypes causes the multiple index module to be loaded into memory. In addition to regular indices, this makes available to the user three new types of indices called type-a, type-b, and type-c indices. The input form of a type-a index is the same as that of a regular index, except that the index name is prefixed by the letter a. For example, you would type alc instead of lc. Similarly, the names of type-b indices start with the letter b and type-c with c. The output forms of these indices are like those of regular indices, but have one, two, or three primes for types a, b, and c, respectively.

AffineDrule is a transformation rule that orders indices in expressions such as OD[AffineG[ua,la,lc],lb] and OD[AffineG[ud,lb,ld],la].

AffineG[ua,lb,lc] is the affine connection associated with the covariant derivative CD. The function CDtoOD reduces CD to ordinary derivatives OD and affine connections AffineG.

AffineToMetric[expr] converts all AffineG's in an expression to ordinary derivatives of the metric.

AffineToMetricRule converts all AffineG's in an expression to ordinary derivatives of the metric.

aIndices are made available by the command AddIndexTypes and are input by typing ala, alb,... alo for lower indices, and aua, aub,..., auo for the corresponding upper indices. In output lines, ale, for example, appears as a subscripted e' index and aue as a superscripted e' index. See also AddIndexTypes, RegularIndices, bIndices, cIndices.

ala is the first type-a index.

all Internal function

AllSymmetries[tensor[la,lb,...]] returns a complete list of the permutations and weights of tensor[la,lb,...] under permutations of the indices. This list forms a group. It is created automatically when DefineTensor is used to enter a short list of symmetries. AllSymmetries will also return the complete list of symmetries of MathTensor system-defined tensors. For example, AllSymmetries[RicciR[la,lb]] gives {{1,2},1,{2,1},1}. See also Symmetries, MakePermWeightGroup, MakeAllSymmetries.

Antisymmetrize[expr,{la,lb,...}], where expr contains sums and products of tensors and la,lb,... are among the indices, will yield the tensor formed from expr and antisymmetrized with respect to indices la,lb,... . Thus Antisymmetrize[f[la,lb,lc],{la,lb}] gives (1/2)(f[la,lb,lc]-f[lb,la,lc]). Factor and function names should not be the same as index names when applying Antisymmetrize.

ApplyRules[expr,Rules] will apply the rules, Rules, once to the expression, expr, and replace newly generated dummy index names by standard dummy index names. An example set of rules included in MathTensor is RiemannRules. To apply to the nth term in an expression, use ApplyRules[expr,Rules,n]. See also ApplyRulesRepeated, SuperApplyRules, CanApplyRules.

ApplyRulesRepeated[expr,Rules] will canonicalize an expression expr, apply the rules Rules repeatedly and finally canonicalize again. One example set of Rules is RiemannRules. This function differs from ApplyRules in that Rules are applied repeatedly. To apply to the nth term in an expression, use ApplyRulesRepeated[expr,Rules,n]. See also ApplyRules, and SuperApplyRules, CanApplyRulesRepeated.

Arglist[expr] returns a list (like {lc,la,ua,lb}) consisting of the arguments of the tensors in a product of tensors. Thus Arglist[f[lc,ld]*g[la,ub]] returns {lc,ld,la,ub}. The ordering of the indices is retained. Integers and symbols other than recognized symbolic indices are not included in the returned list. See also ArglistInt.

ArglistAllTypes works just like Arglist, except that the list it returns includes all indices of the types listed by IndexTypes. The indices listed in IndexTypes are the ones that have been loaded into memory using AddIndexTypes and also SpaceTimeIndices.

ArglistInt[expr] acts like Arglist[expr], except that integers as well as recognized symbolic indices are included in the returned list. See also Arglist, ArglistIntUpLo.

ArglistIntUpLo[expr] acts like ArglistInt[expr], except that members of the list {lo1,up1,..., lo10, up10} as well as integers and recognized symbolic indices are included in the returned list. The {lo1,...,up10} symbols can appear in rules created by RuleUnique and DefUnique. Sometimes you may want to define functions that recognize these special symbols as possible indices. See also Arglist, ArglistInt.

AskSignsFlag is set to True or False in the file Conventions.m. If False, then the sign conventions are taken from Conventions.m. If True, then the sign conventions are set by a dialogue each time that MathTensor is loaded into a Mathematica session.

AskSignsProcedure asks for the desired sign conventions.

AskYes[question,statement1,statement2], where a question must be enclosed in quotes. If the answer starts with y or Y, then statement1 is executed; otherwise statement2 is executed. It is loaded in the Components.m file.

BianchiFirstPairRule[la,lb,lc,ld,le] performs the Bianchi identity on a Riemann tensor covariant derivative of the form CD[RiemannR[la,lb,lc,ld],le] using the la,lb, and le indices.

BianchiSecondPairRule[la,lb,lc,ld,le] performs the Bianchi identity on a Riemann tensor covariant derivative of the form CD[RiemannR[la,lb,lc,ld],le] using the lc,ld and le indices.

bIndices are made available by the command AddIndexTypes, and are input by typing bla, blb,..., blo for lower indices and bua, bub,..., buo for the corresponding upper indices. In output lines, ble, for example, appears as a subscripted e'' index and bue as a superscripted e'' index. See also AddIndexTypes, RegularIndices, aIndices, cIndices.

CanAll[expr] applies various internal canonicalizer functions to an expression to produce a unique canonical form. CanAll or Canonicalize automatically make use of the most efficient of the group of canonicalization functions available so that those other functions, with the possible exception of CanFree, need never be used directly.

CanApplyRules[expr,Rules] combines the functions CanAll and ApplyRules. First, expr is Canonicalized, then ApplyRules is used, and finally CanAll is run again. CanApplyRules can be slower than ApplyRules, but more Rules are likely to be found and provide a simpler expression. CanApplyRules[expr,Rules,n] applies CanApplyRules to the nth term in expr. See also ApplyRules and CanAll.

CanApplyRulesFast[expr,Rules] combines the functions CanAll and ApplyRules. CanApplyRulesFast is just like CanApplyRules except that no initial canonicalization is performed. It is assumed that expr is already canonical. Because CanAll is not performed first, this function is faster than CanApplyRules. CanApplyRulesFast[expr,Rules,n] applies CanApplyRulesFast to the n-th term in expr. See also CanApplyRules.

CanApplyRulesRepeated[expr,Rules], applies CanAll and ApplyRulesRepeated, then Canonicalize again. CanApplyRulesRepeated[expr,Rules,n] applies CanApplyRulesRepeated to the nth term in expr. See also ApplyRulesRepeated and Canonicalize.

CanDum[expr,n] will replace all paired indices by pairs li, ui from Downdummylist and Updummylist in such a way that the li are in ascending order and each ui comes after the corresponding li. Furthermore, the lowest i in li will start at n, and the numbering will run consecutively. In contrast, Dum replaces lower indices by lower indices and upper by upper but does not put the lower index first in each pair. CanDum[expr] takes n as 1.

CanFree[expr] will canonicalize tensor expressions that have, in addition to dummy indices, free indices. In almost all cases with free indices, it is sufficient to use CanAll or Canonicalize directly.

CanInvert[expr] runs Dum and then Invert on expr.

Cannn is used internally by the canonicalizers. Its algorithm is quadratic in the number of dummy indices.

CannnDum[expr] is similar to but more powerful than CanDum. However, its algorithm takes a time that increases quadratically with the number of paired indices. CannnDum can be used directly by the user, but the use of CanAll or Canonicalize is recommended.

CanNonInvert[expr] is equivalent to Dum[expr]. When an expression is not manifestly covariant or contains OD's, so that indices should not be raised or lowered, CanNonInvert, Dum, or Tsimplify can be used to perform simplification.

Canonicalize is another name for CanAll.

CanSame[expr] will replace all paired indices by pairs li, ui from Downdummylist and Updummylist in such a way that the li are in ascending order and each ui comes after the corresponding li. In contrast to CanDum, the li and ui that appear in the final expression will be the same ones that appeared in the original expression, except for the improved ordering. CanSame is used to help treat sets of repeating tensors appearing as subsets of larger products. Changing the names of the indices could cause conflicting with names already used in other terms of the larger product. The user would normally not directly use CanSame.

CanSuperApplyRules[expr,Rules] is the most powerful function for applying Rules but is also the slowest. It applies CanApplyRules over and over until no changes occur. CanSuperApplyRules[expr,Rules,n] applies CanSuperApplyRules to the nth term in expr.

CD[tensor expression,index1,index2,...]. For example, CD[f[la]*h[ua,lb]+j[lb],lc,ld] is the second covariant derivative, first with respect to lc and then to ld.

CDtoOD[expr] replaces covariant derivatives of the form CD by the corresponding expression in terms of ordinary partial derivatives OD and affine connections, AffineG. CDtoOD will not work on expressions with concrete indices and may need to be applied repeatedly to an expr. CDtoOD[expr,n] applies CDtoOD to the nth term of expr.

cIndices are made available by the command AddIndexTypes and are input by typing cla, clb,..., clo for lower indices and cua, cub,..., cuo for the corresponding upper indices. In output lines, cle, for example, appears as a subscripted e''' index and cue as a superscripted e''' index. See also AddIndexTypes, RegularIndices, aIndices, bIndices.

ClearComponents[tensor[la,lb]] will clear any values assigned to components of tensor having integer indices in the range -Dimension to Dimension, where Dimension must be a positive integer. The rank of the tensor to be cleared is indicated by the number of indices specified (2 in the above example). ClearComponents does not work fully in Mathematica 1.2 due to a bug in the UnSet function. This bug is fixed in versions 2.X.

ClearUnits will clear the values of various constants that are set when a system of units is chosen. See also Maxwellk1, Maxwellk3, Lightc, hbar, NewtonG, emuUnits, esuUnits, GaussianUnits, HeavisideLorentzUnits, RationalizedMKSUnits, SIUnits, NaturalUnits, GravitationalUnits.

CollectForm[form] groups a p-form that is expressed as a linear combination of coordinate basis p-forms (as produced by application of the command CoordRep), according to the independent coordinate basis exterior products of the same degree as the form. Dimension must already be set to an integer, and the names of the coordinates should have already been assigned, as in x[1] = r; x[2] = theta; x[3] = phi,... See also CoordRep.

CommuteCD[CD[tensor,i1,...,i2,i3,...,i4],i2,i3] commutes the i2 and i3 covariant derivatives generating the appropriate Riemann tensor terms. To apply CommuteCD to the nth term in an expression, use CommuteCD[tensor,i1,...,i2,i3,...,i4],i2,i3,n]. CommuteCD works only with abstract indices, not numerical ones.

CommuteCD1 Internal function

Components[inputfile,outputfile1,outputfile2] reads the value of Dimension, the coordinate names, the covariant metric components, and other options from inputfile. It then calculates, in accordance with the options specified in inputfile, the contravariant metric components, the metric determinant, the affine connections, and the covariant components of the Ricci, Einstein, Riemann, and Weyl tensors, and the scalar curvature. These results are put into outputfile1 in a form that can be read in at later sessions by Get and into outputfile2 in user editable form. As a guide in creating inputfile, the file CompInSchw.m may be copied, edited, and renamed to be used as inputfile. The arguments of Components must be quoted. Use the saved components in a new session. See also SaveDef, MakeSum, Perturb.

CompSimp is used by Components to do simplification. CompSimp can be defined by the user in the input file for Components. It is possible to define a set of simplification rules, called CompSimpRules, used by CompSimp inside Components. See a sample input file, such as CompInSchw.m, for examples of how to define CompSimp and CompSimpRules. The default value of CompSimp first applies Expand and then applies Together. The default CompSimpRules list is is an empty set { }.

CompSimpOptions is a list of SetOptions statements associated with the simplification commands used by CompSimp.

CompSimpRules is a list of rules used by Components to do simplification. CompSimpRules can be defined by the user in the input file for Components. See a sample input file, such as CompInSchw.m, for examples of how to define CompSimpRules and CompSimp. The default CompSimpRules list is the empty list. If you have the old form, CompSimpRules[1], in your metric input files, it must be changed to CompSimpRules for the files to work.

CoordRep[form] expresses a differential form expression in terms of a linear combination of basis exterior products of coordinates. Dimension must already be set to an integer, and the names of the coordinates should have already been assigned, as in x[1] = r; x[2] = theta; x[3] = phi,... See also CollectForm.

CountNewDums[expr] will give the number of new dummy indices that will have to be added in order to replace covariant derivatives by ordinary derivatives and affine connections in an expression involving one or more covariant derivatives. Internal function.

CoXD[w] is the codifferential, delta, of a p-form w. CoXD[w] is a (p-1)-form. The codifferential of a scalar function or 0-form is zero. In standard differential form notation, if w is a p-form in an n-dimensional space, then our definition of CoXD[w] or delta w is delta w = DetgSign (-1)^(np+n+1) * d * w, where DetgSign is the sign of the determinant of the metric tensor. See also FtoC, HodgeStar, XD, GenLap, Lap, DetgSign.

DefaultTensorList is a list of basic tensor or other object names in MathTensor.

DefineForm[name,p], where p is an integer, defines a differential form called name of degree or rank p. For example, the components of the 2-form w defined by DefineForm[w,2] would be the antisymmetric object w[la,lb]. Only the name w of the form , not its indices, should be typed when using it as a form. DefineForm[name[index1,index2],p], where p is an integer, defines a tensor valued p-form called name[index1,index2]. For example, the components of the tensor-valued 2-form r[ua,lb] defined byDefineForm[r[ua,lb],2] would be r[ua,lb,lc,ld], with antisymmetry under interchange of lc,ld. Only r[ua,lb] would be typed when using it as a form. DefineForm[{w,x,...},{2,1,...}] defines a 2-form w, a 1-form x,.... The names of forms or tensor-valued forms should all be different. See also RankForm, FtoC, XP, XD, CoXD, HodgeStar, GenLap, Lap.

DefineTensor[name,printString,permWeightList] defines the tensor called name that prints as printString and has symmetries specified by permWeightList. For example, DefineTensor[anti,"a",{{2,1},-1}]. Note that name is not quoted and printString is a quoted symbol or string. The length of each permutation in permWeightList must equal the number of indices of the tensor. If a tensor has no symmetries, permWeightList is {{1,2,...,rank},1}, where rank is the number of indices. In general, the smallest set of permutations and weights that give the desired symmetry should be entered as a list in DefineTensor. For a scalar, the form is DefineTensor[scalar,printString]. DefineTensor[name,permWeightList] gives the same print string as name. DefineTensor[{name1,name2,...},permWeightList] defines tensors name1, name2,... having the same print strings as their names and each having the same symmetry specified by permWeightList. See also PermWeight, Symmetries, AllSymmetries.

DefUnique[lhs,rhs], where lhs is the left-hand side of a rule and rhs is a tensor expression with dummy indices, uses SetDelayed (:=) to define lhs in terms of rhs in such a way that unique dummy indices are generated each time the definition is called. For example, DefUnique[f[la_,lc_], t[la,lb] t[ub,lc]] produces a definition such that typing f[le,lf] will produce t[le,ll1] t[ uu1,lf], where ll1,uu1 are a unique pair of dummy indices, that change each time that f is typed with two indices as arguments. The print forms of ll1, uu1 are as a subscript $1 and a superscript $1, respectively. DefUnique[lhs,rhs,cond] defines lhs to be rhs with unique dummy indices only if the conditional cond holds. A possible cond in the above example would be PairQ[la,lc].

DefUnique[lhs,rhs], where lhs is the left-hand side of a rule and rhs is a tensor expression with dummy indices, uses SetDelayed (:=) to define lhs in terms of rhs in such a way that unique dummy indices are generated each time the definition is called. For example, DefUnique[f[la_,lc _],t[la,lb] t[ub,lc]] produces a definition such that typing f[le,lf] will produce t[le,ll1] t[uu1,lf], where ll1,uu1 are a unique pair of dummy indices, that change each time that f is typed with two indices as arguments. Dummy indices of each available type can be used. The print forms of the dummy indices are $1, $a1, $b1, and $c1 for regular and type-a, b, and c indices. DefUnique[lhs,rhs,cond] defines lhs to be rhs with unique dummy indices only if the conditional cond holds. A possible cond in the above example would be PairQ[la,lc]. There are also PairaQ, PairbQ, and PaircQ.

DefUniqueAllTypes is an alternate name for DefUnique when multiple index types are present. See the usage message for DefUnique. See also AddIndexTypes.

DegreeForm[expr] gives the degree of a differential form expression. Unlike RankForm, DegreeForm recognizes that the components of a form are scalars of degree zero. DegreeForm also gives the correct degree when acting on a tensor-valued form and zero when acting on its components. RankForm will give the correct degree of a tensor-valued form but will not give zero for its components. Thus DegreeForm gives the correct degree of any form, while RankForm gives the correct degree only for forms not involving components of forms as factors (such forms may arise when using CoordRep). See also CoordRep, RankForm, TensorRankOfForm.

Detg is the determinant of the metric tensor.

DetgSign equals Abs[Detg]/Detg, giving the sign of the determinant of the metric tensor.

DiffFormOpQ[op] is True if op is a differential forms operator, such as XD, XP, HodgeStar, CoXD, GenLap, or Lap.

Dimension is the dimension of spacetime.

Downdummylist is the list of covariant dummy indices.

Downlist is the union of Downdummylist and Downuserlist.

Downuserlist is the list of tensor indices that may be used for covariant indices.

DualStar[F[la,lb],{ua,ub,uc,ud}] gives the antisymmetric tensor produced by the action of Epsilon on the tensor F. In this example, the dimension of the space is 4 and F is of rank 2. The result is an antisymmetric second-rank tensor equal to (1/2!)F[la,lb] Epsilon[ua,ub,uc,ud]. If F were of rank p, then the factor of (1/2!) would be replaced by (1/p!) and the sum would be over the p indices of the tensor. Generally, F would be an antisymmetric tensor. See also HodgeStar, Epsilon, DefineTensor, DefineForm.

Dum[expr,n] will replace all paired indices by pairs li,ui from Downdummylist and Updummylist in such a way that the li are in ascending order, replacing lower indices with lower indices and upper with upper. The numbering of the dummy indices will start with the second argument, n. Dum[expr] takes n as 1. If you want to multiply together two tensor expressions, then Dum or CanDum can be used with argument n to make sure that the expressions to be multiplied have no common sets of dummy indices. After you load the multiple index module using the command AddIndexTypes, the usage message for Dum will explain how to start dummy indices of each type at a number other than 1.

Dum[expr,{n,na,nb,nc}] will replace paired indices of all four types (regular, type-a, type-b, and type-c) by system-generated dummy indices. The numbering of regular dummy indices will start with integer n, that of type-a with na, type-b with nb, and type-c with nc. If fewer than four integers are entered in the second argument, the remaining integers will be assumed to be ones. Dum[expr] will start the numbering with 1 for each index-type.

DumAllTypes is another name for Dum when multiple index types are present. See the usage message for Dum. See also AddIndexTypes.

EinsteinG[la,lb] is the Einstein tensor.

EinsteinToRicciRule is used to replace any EinsteinG in an expression by its definition in terms of the Ricci tensor and the Riemann scalar. This is used only in 4 dimensions.

Entering the input line emuUnits will set up the emu system of units in electromagnetism by assigning the constants Maxwellk1 and Maxwellk3 values, Maxwellk1 = Lightc^2 ; Maxwellk3 = 1. See also Maxwellk1, Maxwellk3, emuUnits, esuUnits, GaussianUnits, HeavisideLorentzUnits, RationalizedMKSUnits, SIUnits.

Eps0 is the permittivity constant in MKS or SI units.

EpsDown[a,b,c,...] is antisymmetric under interchange of any two indices. All traces vanish, as do any cases with equal indices. At the same time, if Dimension is an integer, and all the indices are negative integers in the range -1 to -Dimension , then EpsDown[-1,-2,...,-Dimension] = EpsilonSign, where negative integers represent concrete covariant indices. EpsilonSign is 1 or -1 and is set in the file Conventions.m. EpsilonSign can also be altered interactively. After Dimension is set to an integer, the user should type Update[ ] in order to activate the rules that depend on the dimension. See also EpsUp, Epsilon, EpsilonProductTensor.

EpsDownToEpsilonRule takes expressions with EpsDown into ones with Epsilon.

EpsDownToEpsUpRule takes expressions with EpsDown into ones with EpsUp.

Epsilon[a,b,c,...] is a tensor that is antisymmetric under interchange of any two indices. All traces vanish, as do any cases with equal indices. At the same time, if Dimension is an integer, then Epsilon[-1,-2,...,-Dimension] = EpsilonSign*(Abs[Detg])^(1/2), where EpsilonSign is 1 or -1 and is set in the file Conventions.m. EpsilonSign can be altered interactively. With all indices contravariant, one has Epsilon[1,2,...,Dimension] = EpsilonSign*Detg^(-1)*(Abs[Detg])^(1/2). Also, Epsilon[...] = (Abs[Detg])^(1/2)*EpsDown[...]. After setting Dimension to an integer, the user should type Update[ ] in order to activate the rules that depend on the dimension. See also EpsDown, EpsUp, EpsilonProductTensor, EpsilonProductTensorRule.

EpsilonProductTensor is the product of two Epsilon tensors. It is expanded in terms of Kronecker deltas and metric tensors when Dimension is set to an integer. In 4, 3, and 2 dimensions, respectively, it is EpsilonProductTensor[a,b,c,d,e,f,g,h] = Epsilon[a,b,c,d]*Epsilon[e,f,g,h] when Dimension = 4, EpsilonProductTensor[a,b,c,d,e,f] = Epsilon[a,b,c]*Epsilon[e,f,g] when Dimension = 3, and EpsilonProductTensor[a,b,c,d] = Epsilon[a,b]*Epsilon[e,f] when Dimension = 2. Here Epsilon is the antisymmetric tensor. The sign of the result depends on DetgSign = Abs[Detg]/Detg, that is assigned a value in Conventions.m. The value can be changed interactively by typing DetgSign = 1 or -1 and then Update[ ]. See EpsilonProductTensorRule.

expr/.EpsilonProductTensorRule replaces the product of two Epsilons (or two EpsDowns or two EpsUps) in a tensor expression, expr, by the appropriate expression involving products of metric tensors or Kronecker deltas. Dimension must be an integer for this replacement to occur. See also EpsilonProductTensor, Epsilon.

EpsilonSign determines the sign of the Levi-Civita antisymmetric tensor density.

EpsilonToEpsDownRule takes expressions with Epsilon into ones with EpsDown.

EpsilonToEpsUpRule takes expressions with Epsilon into ones with EpsUp.

EpsUp[a,b,c,...] is antisymmetric under interchange of any two indices. All traces vanish, as do any cases with equal indices. At the same time, if Dimension is an integer and all the indices are integers in the range 1 to Dimension, then EpsUp[1,2,...,Dimension] = EpsilonSign, where EpsilonSign is 1 or -1 and is set in the file Conventions.m. EpsilonSign can be altered interactively. The user should type Update[ ] after Dimension is set to an integer in order to activate the rules that depend on the dimension. See also EpsDown, Epsilon, EpsilonProductTensor.

EpsUpToEpsDownRule takes expressions with EpsUp into ones with EpsDown.

EpsUpToEpsilonRule takes expression with EpsUp into ones with Epsilon.

EqApart[lhs_ == rhs_] applies Apart to each side of the equation. See Apart in the Mathematica book.

EqApply[lhs_ == rhs_, operator_, a___] applies operator to each side of the equation, with a as the second argument, unless the argument a is omitted. (This syntax differs from Apply.)

EqCancel[lhs_ == rhs_] applies Cancel to each side of the equation. See Cancel in the Mathematica book.

EqCollect[lhs_ == rhs_,x] collects together terms involving the same power of x on each side of the equation. If x is a list, collects terms having the same powers of the elements of the list. See Collect in the Mathematica book.

EqDivide[lhs_ == rhs_, a_] divides each side of the equation by the argument a. See Divide in the Mathematica book.

EqExpand[lhs_ == rhs_] applies Expand to each side of the equation. See Expand in the Mathematica book.

EqExpandAll[lhs_ == rhs_] applies ExpandAll to each side of the equation. See ExpandAll in the Mathematica book.

EqFactor[lhs_ == rhs_] applies Factor to each side of the equation. See Factor in the Mathematica book.

EqFactorTerms[lhs_ == rhs_] applies FactorTerms to each side of the equation. See FactorTerms in the Mathematica book.

EqMinus[lhs_ == rhs_] multiplies each side of the equation by -1. See Minus in the Mathematica book.

EqPlus[lhs_ == rhs_, a__] adds the arguments a to each side of the equation. See Plus in the Mathematica book.

EqPower[lhs_ == rhs_, a_] raises each side of the equation to the power a. See Power in the Mathematica book.

EqPowerExpand[lhs_ == rhs_] expands all powers of products and powers on each side of the equation. For example, ((x + y)^3)^(1/3) -> x + y. See PowerExpand in the Mathematica book.

EqReverse[lhs_ == rhs_] reverses the sides of the equation.

EqSimplify[lhs_ == rhs_] applies Simplify to each side of the equation. See Simplify in the Mathematica book.

EqSolve[lhs == rhs, expr] solves the equation lhs == rhs for the expression expr. This function is needed because the regular Mathematica Solve will not solve for complicated products of objects.

EqSubtract[lhs_ == rhs_, a_] subtracts the arguments a from each side of the equation. See Subtract in the Mathematica book.

EqTimes[lhs_ == rhs_, a_] multiplies each side of the equation by the arguments a. See Times in the Mathematica book.

EqTogether[lhs_ == rhs_] applies Together to each side of the equation. See Together in the Mathematica book.

EqTwoDivide[lhs1_ == rhs1_, lhs1_ == rhs2_] divides the first equation by the second.

EqTwoPlus[lhs1_ == rhs1_, lhs2_ == rhs2_] adds two equations.

EqTwoSubtract[lhs1_ == rhs1_, lhs1_ == rhs2_] subtracts the second equation from the first.

EqTwoTimes[lhs1_ == rhs1_, lhs2_ == rhs2_] multiplies two equations.

esuUnits. Entering the input line esuUnits will set up the esu system of units in electromagnetism by assigning the constants Maxwellk1 and Maxwellk3 values, Maxwellk1 = 1 ; Maxwellk3 = 1. See also Maxwellk1, Maxwellk3, emuUnits GaussianUnits, HeavisideLorentzUnits.

Euclid is a possible argument of MakeMetricFlat.

EvaluateODFlag. When EvaluateODFlag = True, OD is evaluated explicitly.

Evenlist[expr] gives the even-numbered elements of a list.

Explode[expr] turns an expression into a list of characters that make up expr.

FirstCubicRiemannRule relates the product of three Riemann tensors with summed indices mixed to the product of three Riemann tensors with summed indices in lexical order.

FirstQuadraticRiemannRule relates the product of two Riemann tensors with crossed summed indices to the product of two Riemann tensors with summed indices in lexical order, i.e., the Riemann tensor squared.

FormComponentQ[expr], where expr has the same Head as a single differential form or tensor-valued differential form, returns True if expr is a component of the form or tensor-valued form and False if it is the form itself. For other types of expressions, FormComponentQ will return True or False, but with no particular significance. On a scalar, it returns True.

FreeList[list_of_indices] gives the list of free indices, that is, of indices in list_of_indices that are not paired with corresponding up or down indices.

FtoC[expr, {la,lb,...}], where expr is a differential form expression that may involve exterior products, exterior derivatives, and other differential form operators, returns the components of expr with indices la,lb,.... There must be p indices specified if expr is a p-form. The components are the coefficients of the independent basis p-forms in the expansion of expr. For example, if w is a p-form with components w[la,lb,...], then w = (1/p!) w[la,lb,...] e[ua]^e[ub]^..., where the e[ua] are the basis 1-forms and the sum is over all values of the indices. See also XDtoCDflag, XP, XD, CoXD, HodgeStar, GenLap, Lap.

FtoCrule is used internally by FtoC, the command that takes any differential form expression to components.

Entering the input line GaussianUnits will set up the Gaussian system of units in electromagnetism by assigning the constants Maxwellk1 and Maxwellk3 values, Maxwellk1 = 1 ; Maxwellk3 = Lightc^(-1). See also Maxwellk1, Maxwellk3, emuUnits, esuUnits, GaussianUnits, HeavisideLorentzUnits, RationalizedMKSUnits, SIUnits.

GenLap stands for the generalized Laplacian, delta d + d delta, where delta is the codifferential, CoXD, and d is the exterior derivative, XD. GenLap[w] is a p-form if w is a p-form. Among the components of GenLap[w] are the components of -Lap[w], where Lap[w] is the standard or raw Laplacian having components CD[w[la,lb,...],le,ue]. The other terms in the components of the generalized Laplacian involve the curvature and vanish in flat spaces. See also FtoC, Lap, CoXD, XD.

Entering the input line GravitationalUnits will set up the system of units with the speed of light, Lightc, and the Newtonian gravitational constant, NewtonG, having the values: Lightc = 1 ; NewtonG = 1. See also NaturalUnits.

hbar is Planck's constant divided by 2 Pi.

Entering the input line HeavisideLorentzUnits will set up the Heaviside-Lorentz or rationalized Gaussian system of units in electromagnetism by assigning the constants Maxwellk1 and Maxwellk3 values, Maxwellk1 = (4*Pi)^(-1) ; Maxwellk3 = Lightc^(-1). See also Maxwellk1, Maxwellk3, emuUnits, esuUnits, GaussianUnits, HeavisideLorentzUnits, RationalizedMKSUnits, SIUnits.

HodgeStar[w] in n dimensions is the (n-p)-form representing the action of the Hodge star operation on the p-form w. For example, if the dimension of space is 4 and w is a 3-form, then HodgeStar[w] is a 1-form having components (1/3!)w[la,lb,lc] Epsilon[ua,ub,uc,ld]. To obtain these components you must set Dimension to an integer value (4 in this example) and then apply the command FtoC. A double application of HodgeStar gives in general, HodgeStar[HodgeStar[w] ] -> DetgSign (-1)^(p(n-p)) w, where DetgSign the sign of the determinant of the metric tensor. See also FtoC, Epsilon,XD, CoXD, GenLap, Lap, DualStar, DetgSign.

Implode[charlist] turns a list of characters into an expression.

IndexAllTypesQ works like IndexQ, except on all index types that are present in memory.

IndexAllTypesQ[index] gives True if index is a regular index or an index of types a, b, or c. See also IndexQ, IndexaQ, IndexbQ, IndexcQ.

IndexaQ[x] returns True if x is a tensor index of type-a and False otherwise. If x is an integer or a pattern such as a_, then False is returned. See also IndexbQ, IndexcQ.

IndexaQ[index] gives True if index is a type-a index and False otherwise. See also IndexQ, IndexbQ, IndexcQ, IndexAllTypesQ.

IndexbQ[x] returns True if x is a tensor index of type-b and False otherwise. If x is an integer or a pattern such as a_, then False is returned. See also IndexaQ, IndexcQ.

IndexbQ[index] gives True if index is a type-b index and False otherwise. See also IndexQ, IndexaQ, IndexcQ, IndexAllTypesQ.

IndexcQ[x] returns True if x is a tensor index of type-c and False otherwise. If x is an integer or a pattern such as a_, then False is returned. See also IndexaQ, IndexbQ.

IndexcQ[index] gives True if index is a type-c index and False otherwise. See also IndexQ, IndexaQ, IndexcQ, IndexAllTypesQ.

IndexIntQ[x] returns True if x is a possible tensor index or an integer and False otherwise. If x is a pattern such as a_, then False is returned. See also IndexQ, LowerIndexQ, UpperIndexQ, IndicesAndNotOrderedQ.

IndexIntUpLoQ[x] acts like IndexIntQ, except that in addition IndexIntUpLoQ returns True if x is in the list {lo1, up1, lo2, up2,..., lo10, up10}. Members of that list can appear in rules created by RuleUnique and DefineUnique and sometimes must be recognized by functions that appears in the rules created.

IndexQ[x] returns True if x is a possible tensor index and False otherwise. If x is an integer or a pattern such as a_, then False is returned. See also IndexIntQ, LowerIndexQ, UpperIndexQ, IndicesAndNotOrderedQ.

IndexQ[index] gives True if index is a regular index or an index of types a, b, or c. It gives False otherwise. See also IndexaQ, IndexbQ, IndexcQ, IndexAllTypesQ.

IndexRegQ[index] gives True if index is a regular index and False otherwise. See also IndexQ, IndexAllTypesQ, IndexaQ, IndexbQ, IndexcQ.

IndexTypes is a list of types of indices that Tsimplify will act upon. New index types are added to the list by the function AddIndexTypes. The possible index types are RegularIndices (always present), aIndices, bIndices, and cIndices (loaded by AddIndexTypes). See also AddIndexTypes, RegularIndices, aIndices, bIndices, cIndices.

IndexUpLoQ[x] returns True if and only if x is in the list {lo1, up1, lo2, up2,..., lo10, up10}. Members of that list can appear in rules created by RuleUnique and DefineUnique and sometimes must be recognized by functions that appear in the rules created.

IndicesAndNotOrderedQ[{el1,el2,...}] returns True if every element is a tensor index or an integer and the elements of the list are not in lexical order. This function is useful when defining rules to automatically reorder indices in a tensor. See also IndexQ.

InListQ[x,y] returns True if x is a list and y is a symbol that is an element of the list. Otherwise, False is returned. It differs from MemberQ in that the latter matches patterns also.

IntInArgQ[expr] is True if expr (that can be a sum of products of tensors) contains any integer indices and is False otherwise.

IntP[w1,wp], where w1 is a 1-form and wp is a p-form, is the interior product, that is defined to be a (p-1)-form with components w1[ua] wp[la,l2,...,lp] formed by contracting the index of the components of w1 with the first index of the components of wp.

Invert[expr] interchanges lower and upper dummy tensor indices in expr. It first applies Dum to put them in program-generated form. InvertFast assumes that the dummy indices are already in that form. To use Invert on the nth term of expr, use Invert[expr,n].

InvertFast. See Invert.

Kdelta[index1,index2] is the symmetric Kronecker delta symbol. It is 1 if index1 = index2 and 0 otherwise. The indices can be in upper, lower, or mixed positions. It is evaluated if the indices are integers and is manipulated with KdeltaRule or AborbKdelta if the indices are symbols. Conventions on upper and lower indices are recognized. For example, Kdelta[-2,2] and Kdelta[2,2] are both equal to 1. Kdelta should not be used to raise or lower indices in a space in that the metric is not equal to Kdelta. Kdelta is useful when dealing with group indices on Yang-Mills fields, for example. In general spaces or spacetimes, Kdelta does not transform as a tensor. With indices referring to such spaces, you should use Metricg with one covariant and one contravariant index, rather than Kdelta, in order to avoid potential inconsistencies. For example, Kdelta[la,lb] Metricg[ub,uc] gives Kdelta[la,uc], that is false unless Metricg equals Kdelta. Thus Kdelta should be reserved for particular applications in which its use is consistent. For more, see AbsorbKdelta. See also KdeltaRule, AbsorbKdelta.

KdeltaRule is the set of rules used by AbsorbKdelta. KdeltaRule can be applied directly if desired using Replace or ReplaceRepeated. For important warnings about absorbing Kdelta, see AbsorbKdelta and Kdelta.

Lap[w], where w is a p-form, is the standard or raw Laplacian having components CD[w[la,lb,...],le,ue]. Lap[w] is a p-form if w is a p-form. The generalized Laplacian, GenLap, has -Lap as one term. See also GenLap, FtoC, CoXD, XD.

LD[wp,w1] is the Lie derivative of the p-form wp with respect to the 1-form w1. LD[wp, w1] is a p-form with its la,lb,... component given by LieD[wp[la,lb,...], w1]. (Here la,lb,... represent p symbolic indices.) See LieD for the explicit expression for the component. Note that LieD is defined for tensors of arbitrary symmetry, while LD is defined only for forms (that correspond to antisymmetric tensors). FtoC gives the components of LD in terms of LieD. You can then use LieDtoCD or LieDtoOD if you want them expressed in terms of covariant or ordinary derivatives.

LDtoXD[expr] uses the identity LD[wp,w1] = XD[IntP[w1,wp]]+IntP[w1,XD[wp]] to replace, in expr, the Lie derivative, LD, of a p-form, wp, with respect to a 1-form, w1, by exterior derivatives, XD, and interior products, IntP. See also LDtoXDrule.

LDtoXDrule is a rule that uses the identity LD[wp,w1] = XD[IntP[w1,wp]]+IntP[w1,XD[wp]] to replace the Lie derivative, LD, of a p-form, wp, with respect to a 1-form, w1, by exterior derivatives, XD, and interior products, IntP. See also LDtoXD.

LieD[expr,vector] is the Lie Derivative of expr with respect to vector. The index of the vector should not be typed. For example, LieD[MaxwellF[la,lb],V] takes the Lie derivative of MaxwellF[la,lb] with respect to the vector V[uc]. The expression may be a sum of products of tensors. See also LieDtoCD, LD.

LieDtoCD[expr] replaces any Lie derivatives, LieD, in expr by the equivalent expressions involving covariant derivatives, CD. See LieDtoCDrule, LieDtoOD.

LieDtoCDrule. expr/.LieDtoCDrule replaces any Lie derivatives, LieD, in expr by the equivalent expressions involving covariant derivatives, CD. LieDtoCD[expr] is preferred to LieDtoCDrule, since it also introduces standard dummy indices in the resulting expression, as opposed to totally new ones. See also LieDtoCD, LieDtoOD.

LieDtoOD[expr] replaces any Lie derivatives, LieD, in expr by the equivalent expresssions involving ordinary derivatives, OD. See also LieDtoODrule, LieDtoCD.

LieDtoODrule. expr/.LieDtoODrule replaces any Lie derivatives, LieD, in expr by the equivalent expressions involving ordinary derivatives, OD. LieDtoOD[expr] is preferred to LieDtoODrule, since it also introduces standard dummy indices in the resulting expression, as opposed to totally new ones. See also LieDtoOD, LieDtoCD.

Lightc is the speed of light.

Lo. A unique covariant tensor summation index. For each Lo placed in an equation, there must be an Up also.

LorentzGaugeRule is the Lorentz gauge condition on the vector potential.

Lower[index] gives the lowered index if acting on an upper index. The action of Lower on other than regular indices is undefined.

Lowera[index] gives the corresponding lowered index if acting on an upper index of type-a and returns index otherwise. The action of Lowera on other than type-a indices is undefined. See also LowerAllTypes, Lowerb, Lowerc.

LowerAllPairs[expr] lowers the upper member of every paired set of indices (i.e., dummy pairs) appearing in expr. Here, expr is a product of tensors multiplied by numerical or symbolic factors, but expr may not be a sum of seperate terms.

LowerAllTypes works like Lower, except on all index types that are present in memory.

LowerAllTypes[index] gives the corresponding lowered index if acting on an upper index of any type and returns index otherwise. See also Lower, Lowera, Lowerb, Lowerc.

Lowerb[index] gives the corresponding lowered index if acting on an upper index of type-b and returns index otherwise. The action of Lowerb on other than type-b indices is undefined. See also LowerAllTypes, Lowera, Lowerc.

Lowerc[index] gives the corresponding lowered index if acting on an upper index of type-c and returns index otherwise. The action of Lowerc on other than type-c indices is undefined. See also LowerAllTypes, Lowera, Lowerb.

LowerIndexAllTypesQ[x] returns True if x is a possible tensor lower index of any type and False otherwise. If x is an integer of a pattern such as a_, then False is returned. See also IndexQ, IndexAllTypesQ.

LowerIndexAllTypesQ[index] -> True if index is a lower index of any types and False otherwise. See also LowerIndexQ, LowerIndexbQ, LowerIndexcQ, LowerIndexAllTypesQ, UpperIndexQ, UpperIndexaQ, UpperIndexbQ, UpperIndexcQ, UpperIndexAllTypesQ.

LowerIndexaQ[index] -> True if index is a lower index of type-a and False otherwise. See also LowerIndexQ, LowerIndexbQ, LowerIndexcQ, LowerIndexAllTypesQ, UpperIndexQ, UpperIndexaQ, UpperIndexbQ, UpperIndexcQ, UpperIndexAllTypesQ.

LowerIndexbQ[index] -> True if index is a lower index of type-b and False otherwise. See also LowerIndexQ, LowerIndexaQ, LowerIndexcQ, LowerIndexAllTypesQ, UpperIndexQ, UpperIndexaQ, UpperIndexbQ, UpperIndexcQ, UpperIndexAllTypesQ.

LowerIndexcQ[index] -> True if index is a lower index of type-c and False otherwise. See also LowerIndexQ, LowerIndexaQ, LowerIndexbQ, LowerIndexAllTypesQ, UpperIndexQ, UpperIndexaQ, UpperIndexbQ, UpperIndexcQ, UpperIndexAllTypesQ.

LowerIndexQ[x] returns True if x is a possible tensor lower index and False otherwise. If x is an integer of a pattern such as a_, then False is returned. See also IndexQ, UpperIndexQ.

LowerIndexQ[index] -> True if index is a regular lower index and False otherwise. See also LowerIndexa, LowerIndexbQ, LowerIndexcQ, LowerIndexAllTypesQ, UpperIndexaQ, UpperIndexbQ, UpperIndexcQ, UpperIndexAllTypesQ.

MakeAllSymmetries[tensor[la,lb]], when applied to a tensor for that Symmetries[tensor[la,lb]] has a value, will produce a list of all symmetries of that tensor by closing the symmetry list, that is, by producing the list of permutations and weights that contains the list, Symmetries[tensor[la,lb]], and that forms a group closed under multiplication. See MakePermWeightGroup.

MakeMetricFlat. MakeMetricFlat[Euclid] produces a flat metric with diagonal values of 1 and off-diagonal values of 0. It also sets MetricgSign to 1, DetgSign to 1, and Detg to 1. It uses the value of Dimension, that should be an integer. MakeMetricFlat[Minkowski] produces a Minkowski metric with the first (Dimension - 1) diagonal values equal to MetricgSign and the last covariant diagonal value equal to (-MetricgSign) (Lightc)^2. This means that x[4] corresponds to t and not to (Lightc t). The off-diagonal values are 0. It also sets the value of Detg and DetgSign to -(Lightc)^2 (MetricgSign)^Dimension. In both cases, the components of AffineG are set to 0 and CD is made equivalent to OD.

MakePermWeightGroup[symms], where symms is a list of permutations and weights such as {{2,1,-1}, produces the list of permutations and weights, that contains the original permutations and weights and forms a group closed under multiplication, such as {{1,2,1,{2,1},-1}. See MakeAllSymmetries.

MakeSum[expr] replaces symbolic summations of dummy indices by actual sums over concrete indices. Dimension should be an integer so that the Sum can be performed explicitly. MakeSum[expr,{la->lc,lb->ld}] will perform the summation with index la equal to lc and index lb equal to ld in each term. Each index appearing in the second argument must be a dummy index appearing in expr. For example, MakeSum[RiemannR[la,ub,lc,ud] RiemannR[ua,lb,uc,ld],{la->lc,lb->ld}] does the summation with the indicated dummy indices taking equal values in each term of the sum.

MakeSum1 Internal function

MakeSumRange[expr,{la,ala,bla,-4,-5},{cla,-6,-7}] means that the specific dummy index la appearing in expr will be summed over the values that follow it in the list, namely, ala, bla, -4, and -5. The complementary dummy index ua will be summed over the corresponding complementary indices. All values in each list should be permitted symbolic lower indices or negative integers. Similarly, the second list {cla,-6,-7} means that dummy index cla appearing in expr will be summed over the values -6 and -7 and its complementary dummy index cua will be summed on 6 and 7. All values to sum over must be listed, and only the indicated sums will be done. If more than regular indices appear, you should already have used AddIndexTypes to load the additional types of indices. Only recognized index-types and positive or negative integers should appear in the argument lists, and the first element of each list should be a lower dummy index in expr. See also AddIndexTypes, MakeSum.

MakeSumRange1. Internal function used by MakeSumRange

MakeTemplate. Internal function

Matchlist[list] returns a list of pairs of matching indices in the order in which they appear in list, but with the lower member of each pair first. Matching pair means paired lower and upper indices. The argument is an index list. Internal function.

Matchlist[list] returns a list of pairs of matching regular indices in the order in which they appear in list, but with the lower member of each pair first. Matching pair means paired lower and upper indices. See also Matchlista, Matchlistb, Matchlistc, MatchlistAllTypes.

Matchlista[list], after the command AddIndexTypes has been issued, returns a list of matching type-a indices.

Matchlista[list] returns a list of pairs of matching type-a indices in the order in which they appear in list, but with the lower member of each pair first. Matching pair means paired lower and upper indices. See also Matchlistb, Matchlistc, MatchlistAllTypes, Matchlist.

MatchlistAllTypes[list] returns a list of pairs of matching indices in the order in which they appear in list, but with the lower member of each pair first. Matching pair means paired lower and upper indices of any type (regular, type-a, b, or c). See also Matchlist, Matchlista, Matchlistb, Matchlistc.

Matchlistb[list], after the command AddIndexTypes has been issued, returns a list of matching type-b indices.

Matchlistb[list] returns a list of pairs of matching type-b indices in the order in which they appear in list, but with the lower member of each pair first. Matching pair means paired lower and upper indices. See also Matchlista, Matchlistc, MatchlistAllTypes,Matchlist.

Matchlistc[list], after the command AddIndexTypes has been issued, returns a list of matching type-c indices.

Matchlistc[list] returns a list of pairs of matching type-c indices in the order in which they appear in list, but with the lower member of each pair first. Matching pair means paired lower and upper indices. See also Matchlista, Matchlistb, MatchlistAllTypes, Matchlist.

MatchlistOrd[list] returns a list of pairs of matching indices in the order in which they appear in list, with the lower or upper member of each pair first, depending on original ordering. Matching pair means paired lower and upper indices. Internal function.

$MathTensorVersionNumber is the version of MathTensor running in the current session.

MatrixMap[op,matrix] applies the operator, op, to each element of a matrix.

MatrixXP[mat1, mat2], where mat1 and mat2 are matrices having differential form elements, carries out matrix multiplication, but with the exterior product, XP, replacing the ordinary product in the multiplication of matrix elements.

MaxwellA[la] is the electromagnetic vector potential.

MaxwellCyclicEquation[la,lb,lc] is one of the Maxwell equations.

MaxwellCyclicRule[la,lb,lc] implements the Cyclic Rule on the covariant derivative of the Maxwell field tensor.

MaxwellDivergenceEquation is one of the Maxwell equations.

MaxwellDivergenceRule replaces the divergence of the Maxwell field tensor by the current four-vector.

MaxwellF[la,lb] is the Maxwell Field Tensor.

MaxwellJ[la] is the electromagnetic current density.

Maxwellk1 is a constant that sets the system of units and is ordinarily assigned either by default or by the user in a file of conventions by putting in a single line with one of the following commands esuUnits, emuUnits, GaussianUnits, HeavisideLorentzUnits, RationalizedMKSUnits, or SIUnits. See also Maxwellk3, esuUnits, emuUnits, GaussianUnits, HeavisideLorentzUnits, RationalizedMKSUnits, SIUnits.

Maxwellk3 is a constant that sets the system of units and is ordinarily assigned either by default or by the user in a file of conventions by putting in a single line with one of the following commands esuUnits, emuUnits, GaussianUnits, HeavisideLorentzUnits, RationalizedMKSUnits, or SIUnits. See also Maxwellk3,esuUnits, emuUnits, GaussianUnits, HeavisideLorentzUnits, RationalizedMKSUnits, SIUnits.

Maxwellrho is the electromagnetic charge density.

MaxwellT[la,lb] is the Maxwell Stress Tensor. See also MaxwellTtoFrule, MaxwellTexpression.

MaxwellTexpression[la,lb] is the expression for the Maxwell stress tensor in terms of the Maxwell field tensor, MaxwellF. See MaxwellT, MaxwellTtoFrule.

MaxwellTtoFrule can be used with ApplyRules to replace the electromagnetic stress tensor, MaxwellT, by the appropriate expression in terms of the electromagnetic field, MaxwellF. See also MaxwellT, MaxwellTexpression.

MaxwellVectorPotentialRule replaces the Maxwell field tensor by its expression in terms of the vector potential.

Metricg[a_,b_], where a,b are lower or upper indices, is the metric tensor. When MetricgFlag is True (default), the metric tensor will automatically be absorbed in raising or lowering indices whenever that is possible. When MetricgFlag is set to False, one can use Absorbg to raise and lower indices with Metricg. After resetting MetricgFlag to True, do Update[ ] so that previous expressions referred to will be reevaluated with the new flag setting.

MetricgFlag. When MetricgFlag is True (default), the metric tensor will automatically be absorbed in raising or lowering indices whenever that is possible. When MetricgFlag is set to False, one can use Absorbg to raise and lower indices with Metricg. After resetting MetricgFlag to True, do Update[ ] so that previous expressions referred to will be reevaluated with the new flag setting.

MetricgFlagOn sets MetricgFlag to True and does an Update[ ].

MetricgFlagOff sets MetricFlag to False and does an Update[ ].

MetricgFlagOffMessage Internal function

MetricSign is the sign of Metricg[-1,-1] in a local inertial coordinate system. See the file Conventions.m.

Minkowski. A possible argument of MakeMetricFlat.

Mu0 is the permeability constant in MKS or SI units.

NamesLo is a string used in the CanAlt function that determines the name of the machine-generated lower indices.

NamesUp is a string used in the CanAlt function that determines the name of the machine-generated upper indices.

NaturalUnits. Entering the input line NaturalUnits will set up the system of units with the speed of light, Lightc, and the Planck constant divided by 2 Pi, hbar, having the values Lightc = 1 ; hbar = 1.

NegIntegerQ[x] returns True if x is a negative integer (not 0) and otherwise returns False.

NewtonG is the Newtonian gravitational constant.

NoIntInArgQ[expr] is False if expr (that can be a sum of products of tensors) contains any integer indices and is True otherwise.

NonTensorPart[expr] returns the non tensorial factors in an expression. Here, expr should not be a sum of terms.

NotAllPatQ[symbol] returns True if symbol is not one of the differential form operators. It is used internally.

OD[tensor expression,index1,index2,...]. For example, OD[f[la]*h[ua,lb]+j[lb],lc,ld] is the second ordinary partial derivative, first with respect to lc and then ld. OD is symmetric in derivative indices.

Oddlist[expr] gives the odd-numbered elements of a list.

OrderCD[CD[expr,list]] will reorder the indices in the list of derivatives into alphabetical order (the same order as Sort) generating the extra Riemann tensor terms. All covariant derivatives in the generated terms are also reordered. This function does not work with numerical indices. If indices are already in the appropriate order, nothing is done.

OrderCD1 Internal function

OrderedArgsQ[expr1,expr2] returns True if the argument list of expr1 is lexically before the argument list of expr2 and False otherwise.

Pair[index] gives the lowered index if acting on an upper index or the raised index if acting on a lower index.

PairAllTypes works like Pair, except that it works on all index types that are present in memory.

PairAllTypesInt[b] gives the complementary index to b if b is an index of any of the possible types. If b is an integer, then it gives the integer -b. Otherwise, it returns b itself. PairAllTypesInt has the Attribute Listable. See also Pair, Paira, Pairb, Pairc, PairAllTypes.

PairAllTypesQ works like PairQ, except that after all index types are present in memory it recognizes pairs of any type of index. It is the same as PairQ until after AddIndexTypes has been entered.

PairAllTypesQ[a,b] -> True if a and b are a corresponding pair of lower and upper indices of any type. It gives False otherwise. PairAllTypesQ[{a,b,...},{c,d,...}] -> PairAllTypesQ[a,c] && PairAllTypesQ[b,d] && ... See also PairaQ, PairbQ, PaircQ, PairQ.

PairAntisymmetrize[expr,list] takes a list of pairs of indices and anti-symmetrizes over all the pairs.

PairaQ[a,b] -> True if a and b are a corresponding pair of type-a lower and upper indices. It gives False otherwise. PairaQ[{a,b,...},{c,d,...}] -> PairaQ[a,c] && PairaQ[b,d] && ... See also PairbQ, PaircQ, PairAllTypesQ.

PairbQ[a,b] -> True if a and b are a corresponding pair of type-b lower and upper indices. It gives False otherwise. PairbQ[{a,b,...},{c,d,...}] -> PairbQ[a,c] && PairbQ[b,d] && ... See also PairaQ, PaircQ, PairAllTypesQ.

PaircQ[a,b] -> True if a and b are a corresponding pair of type-c lower and upper indices. It gives False otherwise. PaircQ[{a,b,...},{c,d,...}] -> PaircQ[a,c] && PaircQ[b,d] && ... See also PairaQ, PairbQ, PairAllTypesQ.

Pairdum[index] gives the lowered index if index is an upper program generated dummy index or the raised index if index is a lower program generated dummy index.

PairQ[a,b] -> True if a and b are a corresponding pair of regular lower and upper indices. It gives False otherwise. PairQ[{a,b,...},{c,d,...}] -> PairQ[a,c] && PairQ[b,d] && ... See also AddIndexTypes, PairaQ, PairbQ, PaircQ, PairAllTypesQ.

PairQ[a,b] -> True if a and b are a corresponding pair of regular lower and upper indices. It gives False otherwise. PairQ[{a,b,...},{c,d,...}] -> PairQ[a,c] && PairQ[b,d] && ... See also PairaQ, PairbQ, PaircQ, PairAllTypesQ.

PairSymmetrize[expr,list] takes a list of pairs of indices and symmetrizes over all the pairs.

PermWeight[name,list] assigns the symmetries specified in list to the tensor name. An example of list is {{2,1,3,4},-1,{1,2,4,3},1}, that indicates that under the permutation {2,1,3,4} of a 4-index tensor, the tensor is multiplied by the weight -1, while under the permutation {1,2,4,3} it is multiplied by 1. Thus, PermWeight[f,{{2,1,3,4},-1,{1,2,4,3},1}] will make the tensor f[la,lb,lc,ld] antisymmetric in the first pair of indices and symmetric in the second pair. If one then enters SymmetriesOfSymbol[f], the symmetry list is returned. If one enters ??SymmetriesOfSymbol, a list of tensors with their assigned symmetries is returned. You shoul, be sure the list of permutations and weights entered is consistent and pertains to all the indices of the tensor, even if some are not affected. DefineTensor should be used to enter symmetries, since only then will Tsimplify work correctly. See also DefineTensor, SymmetriesOfSymbol, Symmetries, AllSymmetries.

PIntegrate[expr,object] partially integrates one covariant derivative off of the object and takes the derivative of the other terms. PIntegrate[expr,object,n] will apply PIntegrate just to the nth term in expr.

PosIntegerQ[x] returns True if x is a positive integer (not 0) and otherwise returns False.

PrettyForm Internal function

PrettyOff turns off automatic pretty printing.

PrettyOn turns on automatic pretty printing. If you turn on global pretty printing, you will get tensors printed properly only if they have been defined using DefineTensor or loaded from a file.

Raise[index] gives the corresponding raised index if acting on a lower index. The action of Raise on other than regular indices is undefined.

Raisea[index] gives the corresponding raised index if acting on a lower index of type-a and returns index otherwise. The action of Raisea on other than type-a indices is undefined. See also RaiseAllTypes, Raiseb, Raisec.

RaiseAllTypes works like Raise, except on all index types that are present in memory.

RaiseAllTypes[index] gives the corresponding raised index if acting on a lower index of any type and returns index otherwise. See also Raise, Raisea, Raiseb, Raisec.

Raiseb[index] gives the corresponding raised index if acting on a lower index of type-b and returns index otherwise. The action of Raiseb on other than type-b indices is undefined. See also RaiseAllTypes, Raisea, Raisec.

Raisec[index] gives the corresponding raised index if acting on a lower index of type-c and returns index otherwise. The action of Raisec on other than type-c indices is undefined. See also RaiseAllTypes, Raisea, Raiseb.

RankForm[expr] gives the degree or rank of expr, where expr is a differential form expression. See also FtoC, XP, XD, CoXD, HodgeStar, GenLap, Lap.

Entering the input line RationalizedMKSUnits will set up SI or rationalized MKS units in electromagnetism by setting the constants Maxwellk1 and Maxwellk3 to values Maxwellk1 = (4*Pi*Eps0)^(-1) ; Maxwellk3 = 1. See also Maxwellk1, Maxwellk3, emuUnits, esuUnits, GaussianUnits, HeavisideLorentzUnits, SIUnits.

Rcsign. See the file Conventions.m

RegularIndices are always available and are input by typing la, lb,... lo for lower indices and ua, ub,..., uo for the corresponding upper indices. Additional types of indices are available after the command AddIndexTypes is issued. In output lines, le, for example, appears as a subscripted e index and ue as a superscripted e index. See also AddIndexTypes, aIndices, bIndices, cIndices.

RicciR[la,lb] is the Ricci tensor.

RicciToAffine[expr] replaces any Ricci tensors in expr by their equivalents in terms of affine connections, AffineG. Dummy indices appear with standard system-generated names.

ApplyRules[expr, RicciToAffineRule] replaces any Ricci tensors in expr by their equivalents in terms of affine connections, AffineG. New dummy indices appear with $ prefixes.

RicciToTraceFreeRicciRule converts expressions with Ricci tensors to expressions with trace-free Ricci tensors and ScalarR's.

RiemannCyclicFirstThreeRule[la,lb,lc,ld] performs the cyclic identity on la, lb, and lc in an expression using expr/.RiemannCyclicFirstThreeRule[la,lb,lc,ld].

RiemannCyclicSecondThreeRule[la,lb,lc,ld] performs the cyclic identity on lb, lc, and ld in an expression using expr/.RiemannCyclicSecondThreeRule[la,lb,lc,ld].

RiemannR[ua,lb,lc,ld] is the Riemann tensor.

RiemannRules. The Riemann tensor properties. The normal symmetries of the RiemannR, RicciR, and CD[ScalarR,la,lb] tensors are applied automatically if their indices are canonical. If the RiemannRules are applied after a Canonicalize function, then all symmetries will be applied. The RiemannRules are built up from the 40 individual RiemannRule[1-40] documented in this book. ??RiemannRule[1-40] will give the rule form for one of the rules 1 - 40. When the RiemannRules are applied, a message (or messages) is given indicating that one is used.

RiemannRuleX - One of the RiemannRules. For further information, type ??RiemannRuleX. To find out which RiemannRules exist in MathTensor, type ?RiemannRule*. Then select the numbered rule you want to determine the value of X in ??RiemannRuleX.

RiemannToAffine[expr] replaces any Riemann tensors in expr by their equivalents in terms of affine connections, AffineG. Dummy indices appear with standard system-generated names.

RiemannToAffineRule is used by the command RiemannToAffine. The user should use the latter command instead. See RiemannToAffine.

RiemannToWeylRule converts expressions with RiemannR's to expressions with Weyl tensors, Ricci tensors, and ScalarR's.

Rmsign. See the file Conventions.m.

Rulelists is defined in such a way that Rulelists[{a,b,c},{d,e,f}] gives {a->d, b->e, c->f}.

RuleUnique[ruleName,lhs,rhs], where ruleName is the name for a new rule, lhs is the left-hand side of a transformation rule, and rhs is a tensor expression with dummy indices, uses RuleDelayed (:>) to produce a rule called ruleName, that transforms lhs into rhs in such a way that unique dummy indices are generated each time the transformation rule is called. For example, RuleUnique[fTotRule,f[la_,lc_],t[la,lb] t[ub,lc]] produces a transformation rule, fTotRule, such that typing f[le,lf]/.fTotRule will produce t[le,ll1] t[uu1,lf]. Here, ll1,uu1 are a unique pair of dummy indices, that change each time that the transformation rule is applied in an expression. The print forms of ll1, uu1 are as a subscript $1 and a superscript $1, respectively. RuleUnique[ruleName,lhs,rhs,cond] causes ruleName to transform lhs to rhs with unique dummy indices only if the conditional cond holds. A possible cond in the above example would be PairQ[la,lc].

RuleUnique[ruleName,lhs,rhs], where ruleName is the name for a new rule, lhs is the left-hand side of a transformation rule, and rhs is a tensor expression with dummy indices, uses RuleDelayed (:>) to produce a rule called ruleName, that transforms lhs into rhs, in such a way that unique dummy indices are generated each time the transformation rule is called. For example, RuleUnique[fTotRule,f[la_,lc_],t[la,lb] t[ub,lc]] produces a transformation rule, fTotRule, such that typing f[le,lf]/.fTotRule will produce t[le,ll1] t[uu1,lf]. Dummy indices of each available type can be used. The print forms of the dummy indices are $1, $a1, $b1, $c1 for regular and type-a, type-b, and type-c indices, respectively. RuleUnique[ruleName,lhs,rhs,cond] causes ruleName to transform lhs to rhs with unique dummy indices only if the conditional cond holds. A possible cond in the above example would be PairQ[la,lc]. There are also PairaQ, PairbQ, PaircQ.

RuleUniqueAllTypes is an alternate name for RuleUnique when multiple index types are present. See the usage message for RuleUnique. See AddIndexTypes.

SAIsimp and SAIsimpRules determines the form of simplification used by SetAllIndices. The default is SAIsimp[a_] := Expand[Together[a/.SAIsimpRules]; SAIsimpRules = { }.

SAIsimpRules gives a list of rules to be applied in SetAllIndices. See SAIsimp.

ScalarR is the Riemann scalar.

ScalarRtoAffine[expr] replaces any appearance of ScalarR in expr by its equivalent in terms of affine connections, AffineG. Dummy indices appear with standard system-generated names.

ApplyRules[expr], ScalarRtoAffineRule] replaces any appearances of ScalarR in expr by their equivalents in terms of affine connections, AffineG. New dummy indices appear with $ prefixes.

SecondCubicRiemannRule relates the product of three Riemann tensor with certain cross sums to another product with pair to pair sums.

SecondQuadraticRiemannRule is the inverse of FirstQuadraticRiemannRule.

SetAllIndices[t[la,lb]] assumes that all components with indices in the indicated position (lower in this case) are already assigned, and sets the appropriate values to all the other components. All components of Metricg should already be assigned since they are used to raise and lower indices as needed. All indices in the argument should be symbols, not integers, and should be of the same type, i.e., all lower or all upper. The components to be set should not already be assigned, since such assignments will not be changed. See also SetMovedIndices, SetEuclideanIndices.

SetAntisymmetric[tensor[la,lb,lc,ld,le]] will make tensor totally antisymmetric in all its indices. The names of the indices entered do not matter. To get proper formatting, first use DefineTensor to define the tensor of the desired rank with no symmetries, as in DefineTensor[tensor,t,{{1,2,3,4,5},1}].

ClearComponents.

SetEuclideanIndices[t[la,lb]] assumes that the components of t with indices in the indicated positions are already assigned and assigns all other components of t, assuming the metric is Euclidean. The indices in the argument should be symbolic indices, not integers. All of the indices should be at the same level, upper or lower. Any number of indices up to four can appear in the tensor. See also SetMovedIndices, SetAllIndices.

SetMovedIndices[t1[ua,ub],t2[lc,ld]] will take the components of t2[lc,ld], that are assumed to be known, and will apply Metricg to raise both indices, assigning the resulting values to the components of t1[ua,ub]. Conventionally, the tensor name t1 will be the same as t2, although that is not strictly required. In general, the second argument should indicate the positions of the components that are already assigned values, and the first argument should indicate the positions of the indices for that you wish to have components calculated by raising or lowering with the metric tensor. Another example is SetMovedIndices[s[la,ub,uc],s[ud,ue,lf]], that would use Metricg to lower the first and raise the third index. Only symbolic indices, not integers, should appear in the arguments, and any two indices should not be either the same or the upper and lower versions of the same index. To save time, no simplification is done, so you may wish to simplify the results. See also SetAllIndices, SetEuclideanIndices.

SetSymmetric[tensor[la,lb,lc,ld,le]] will make tensor totally symmetric in all its indices. The names of the indices entered do not matter. To get proper formatting, first use DefineTensor to define the tensor of the desired rank with no symmetries, as in DefineTensor[tensor,"t",{{1,2,3,4,5},1}].

ShowNumbers[expr] splits up expr and numbers the terms so that a user can then find a particular term in expr.

On[ShowTime] turns timing info on. Off[ShowTime] turns it off again. The time taken for each command is printed just before the results (if any) of the command. ShowTime is not loaded automatically by MathTensor. You may turn it on with the On[ShowTime] command.

Entering the input line SIUnits will set up SI or rationalized MKS units in electromagnetism by setting the constants Maxwellk1 and Maxwellk3 to values Maxwellk1 = (4*Pi*Eps0)^(-1) ; Maxwellk3 = 1. See also Maxwellk1, Maxwellk3, emuUnits, esuUnits, GaussianUnits, HeavisideLorentzUnits, RationalizedMKSUnits.

SuperApplyRules[expr,Rules] is a more powerful version of ApplyRulesRepeated. It may take much longer to give the most simplified expression but is guaranteed to apply all rules as many times as possible. Most users will not need this except in very large computations. SuperApplyRules[expr,Rules,n] will apply to the nth term in expr only. See ApplyRules, ApplyRulesRepeated, CanSuperApplyRules.

SwapDum[expr,{a}] raises and lowers the dummy indices in expr. The pairs are defined by each element of the list {a}. {a} has one element from each pair that the user wishes to swap up and down. This function is primarily used to put terms into some particular form that the user wants that is different from the canonicalizer's form.

Symmetries[tensor[la,lb,...]] returns a list of the permutations and weights entered using DefineTensor for the symmetries of tensor under permutations of the indices. Symmetries will also return a short list of symmetries of MathTensor system-defined tensors. For example, Symmetries[RicciR[la,lb]] gives {{2,1},1}. See also AllSymmetries, MakePermWeightGroup, MakeAllSymmetries.

SymmetriesOfSymbol[name] returns a set of lists of symmetries assigned to tensors having the symbol name. For example, if r[la,lb] is symmetric and r[la,lb,lc] is symmetric only in the last two indices, then SymmetriesOfSymbol[r] returns {{{2,1},1},{{1,3,2},1} with the permutations and weights listed in the order that the symmetries were assigned. Entering ??SymmetriesOfSymbol will return this message followed by a listing of tensors with their assigned symmetries.

Symmetrize[expr,{la,lb,...}], where expr contains sums and products of tensors and la,lb,... are among the indices, will yield the tensor formed from expr, symmetrized with respect to indices a,b,... Thus Symmetrize[f[la,lb,lc],{la,lb}] gives (1/2)(f[la,lb,lc]+f[lb,la,lc]). Factor and function names should not be the same as index names when applying Symmetrize.

SyntaxCheck[expr] looks for unbalanced indices, duplicated indices, and bad dummy indices in a tensor equation. It can be applied explicitly or turned on or off using On[SyntaxCheck] and Off[SyntaxCheck]. It is designed to look for expressions with la or ub type indices and to not affect non-tensorial input equations. See also SyntaxCheckOff, SyntaxCheckOn.

SyntaxCheckOff turns off automatic use of the SyntaxCheck function.

SyntaxCheckOn turns on automatic use of the SyntaxCheck function.

TensorForm[expr] pretty prints tensor equations to the screen. Only those terms that have Format definitions will be pretty printed. See PrettyOn and PrettyOff.

TensorPart[expr] returns the tensorial factors in an expression. Here, expr should not be a sum of terms.

TensorPartSameQ[expr1,expr2] returns True if the tensor parts of expr1 and expr2 are identical and False otherwise. Here, expr1 and expr2 should not be sums of terms.

TensorQ[expr] returns True if expr contains tensors and False otherwise. Here, expr should not be a sum of terms.

TensorRankOfForm[expr], when acting on a differential form expression, that may contain tensor-valued forms, gives the tensor rank of the expression, i.e., the number of tensor indices coming from tensor-valued forms in the expression. TensorRankOfForm does not recognize that contracted tensor indices do not contribute to the rank of a tensor. Thus it also counts contracted indices.

TensorSimp[expr], where expr is a sum of terms, will combine terms that are equal in expr. It will recognize trace and similar identities involving dummy indices. It will not recognize equality of terms under complicated symmetry transformation, as will CanAll, CanAlt or Canonicalize. Sometimes it is advantageous to apply TensorSimp prior to canonicalization to reduce the number of terms or to find and simplify terms involving traces and internal summations. If one wants to combine like terms after canonicalization, TensorSimp is also the appropriate function to use.

TensorSimpAfter[expr,n], where expr is a sum of terms and n is an integer, will start at term n in the sum and combine terms that are equal in expr. It will leave unchanged the terms of the sum that come before term n. It will recognize trace and similar identities involving dummy indices. It will not recognize equality of terms under complicated symmetry transformation, as will CanAll, CanAlt, or Canonicalize. See also TensorSimp.

TraceFreeRicciR[la,lb] is the trace-free part of the Ricci tensor. It is given in arbitrary dimensions.

TraceFreeRicciToRicciRule converts expressions with trace-free Ricci tensors to expressions with Ricci tensors and ScalarR's.

Tsimplify simplifies tensor expressions, taking full account of symmetries. The expression should already be expanded using Expand. There are four basic forms. Tsimplify[expr,n,m], where expr is a sum of products of tensors, will compare terms n and m of expr and combine them if their tensor parts are equal. It will also recognize if they vanish by symmetry. Tsimplify[expr,n] will compare term n with all other terms in expr and combine terms with term n if that is possible. Tsimplify[expr] will combine all terms in expr that can be combined. Tsimplify[expr] is used also in the case in which expr consists of a single term that is a product of tensors. In that case, the term will be tested to see if it vanishes as a result of symmetry. Tsimplify should not be used on expressions having operators that do not commute with Metricg, such as OD. See also TsimplifyAfter, DefineTensor, Symmetries, AllSymmetries.

TsimplifyAfter[expr,n], where expr is a sum of products of tensors, will compare terms n with all terms following it in expr and combine them with term n if their tensor parts are equal. Symmetries are fully taken into account. It will also recognize if term n vanishes by symmetry (even if term n is the last term in expr). TsimplifyAfter should not be used on expressions having operators that do not commute with Metricg, such as OD. See also Tsimplify, DefineTensor, Symmetries, AllSymmetries.

Ttransform[t,s[la,ub],{x1,x2,x3},{rhs1,rhs2,rhs3},1or-1] transforms the components of s to a new coordinate system and names the transformed tensor t. The indices in s give positions of indices for that the components are known. The indices in t will have the same positions and are therefore not specified. The list {x1,x2,x3} gives the names of the old coordinates if the last argument of Ttransform is 1 (for forward transformation) or the names of the new coordinates if the last argument is -1 (for inverse transformation). The value of Dimension should already be set to the number of coordinates. The list {rhs1,rhs2,rhs3} gives the right-hand sides of the coordinate transformation equations and should involve the coordinates named in the previous list. The coordinate names and components of the t should not already have assignments.

Units is a list of the unit systems that are being used. The choices of electromagnetic unit systems are emu, esu, Gaussian, Heaviside-Lorentz or rationalized Gaussian, and Rationalized MKS or SI units. In addition, one may choose natural units or gravitational units. See the file Conventions.m for definitions. The choice of Rationalized MKS (or SI) units with natural or gravitational units is inconsistent. The speed of light is Lightc, Planck's constant divided by 2 Pi is hbar, and the Newtonian gravitational constant is NewtonG.

Unlist[expr] is useful in forming a range of arguments of Do from a list of lists. expr is a list.

A unique contravariant tensor summation index. For each Up placed in an equation, there must be a Lo also.

Updowndummylist is the union of the Up and Down dummy lists.

Updummylist is the list of contravariant dummy indices.

Uplist is the union of Updummylist and Upuserlist.

UpLo[up1,lo1] sets the value of up1 to be a new unique contravariant index, and lo1 to the corresponding covariant index. These indices are used in rules or definitions involving dummy indices that are not input by the user and that must not duplicate existing index names in an expression. UpLo generates the new indices at the time the rule or definition is called. When TensorForm is On, the new indices print as a raised or lowered $ followed by an integer, such as $1. UpLo[{up1,up2,...},{lo1,lo2,...}] sets the values of up1, up2,... to be a set of unique contravariant indices and the values of lo1,lo2,... to be the corresponding set of covariant indices. See also ApplyRules.

UpLo[up1,lo1] sets up1 to a unique system-generated upper dummy index of the regular type and lo1 to the corresponding unique lower dummy index of regular type. See also UpLoa, UpLob, UpLoc.

UpLoa[aup1,alo1] sets aup1 to a unique system-generated upper dummy index of type-a and alo1 to the corresponding unique lower dummy index of type-a.

UpLob[bup1,blo1] sets bup1 to a unique system-generated upper dummy index of type-b and blo1 to the corresponding unique lower dummy index of type-b.

UpLoc[cup1,clo1] sets cup1 to a unique system-generated upper dummy index of type-c and clo1 to the corresponding unique lower dummy index of type-c.

UpperIndexAllTypesQ[index] -> True if index is an upper index of any type and False otherwise. See also UpperIndexQ, UpperIndexbQ, UpperIndexcQ, UpperIndexAllTypesQ, LowerIndexQ, LowerIndexaQ, LowerIndexbQ, LowerIndexcQ, LowerIndexAllTypesQ.

UpperIndexaQ[index] -> True if index is an upper index of type-a and False otherwise. See also UpperIndexQ, UpperIndexbQ, UpperIndexcQ, UpperIndexAllTypesQ, LowerIndexQ, LowerIndexaQ, LowerIndexbQ, LowerIndexcQ, LowerIndexAllTypesQ.

UpperIndexbQ[index] -> True if index is an upper index of type-b and False otherwise. See also UpperIndexQ, UpperIndexaQ, UpperIndexcQ, UpperIndexAllTypesQ, LowerIndexQ, LowerIndexaQ, LowerIndexbQ, LowerIndexcQ, LowerIndexAllTypesQ.

UpperIndexcQ[index] -> True if index is an upper index of type-c and False otherwise. See also UpperIndexQ, UpperIndexaQ, UpperIndexbQ, UpperIndexAllTypesQ, LowerIndexQ, LowerIndexaQ, LowerIndexbQ, LowerIndexcQ, LowerIndexAllTypesQ.

UpperIndexQ[x] returns True if x is a possible tensor upper index and False otherwise. If x is an integer or a pattern such as a_, then False is returned. See also IndexQ, LowerIndexQ.

UpperIndexQ[index] -> True if index is a regular upper index and False otherwise. See also UpperIndexa, UpperIndexbQ, UpperIndexcQ, UpperIndexAllTypesQ, LowerIndexaQ, LowerIndexbQ, LowerIndexcQ, LowerIndexAllTypesQ.

Upuserlist is the list of tensor indices for use as contravariant indices.

Var. Internal variation function

Varg[la,lb] is the variation of Metricg[la,lb].

Variation[expr,Metricg] takes the functional variation of the expression, that is a functional of the metric, with respect to Metricg and canonicalizes the resulting expression.

VariationalDerivative[expr,Metricg,la,lb] factors off the Varg term from a functional derivative with respect to the metric. The resulting free indices ua and ub can be whatever the user wants.

VectorA[la] = CD[Varg[la,lb],ub] is used as a shorthand notation in problems involving the variations of the metric.

When VectorAFlag is set to True, the object CD[Varg[la,lb],ub] is automatically set to VectorA[la].

WeylC[ua,lb,lc,ld] is the Weyl tensor. It is given in arbitrary dimensions.

WeylToRiemannRule converts expressions with WeylC's to expressions with Riemann tensors, Ricci tensors, and ScalarR's.

XD[w] is the exterior derivative of a p-form w. XD[w] is a (p+1)-form. The flag XDtoCDflag controls whether the command FtoC acting on exterior derivatives will produce components involving covariant derivatives CD or ordinary partial derivatives OD. When exterior derivatives are converted to components, by default covariant derivatives CD will appear. If you want ordinary partial derivatives OD to appear instead, you must turn off XDtoCDflag by typing Off[XDtoCDflag]. When using tensor-valued p-forms, you should turn off XDtoCDflag before applying FtoC to produce components. The reason is that in the covariant derivative, there are affine connection terms associated with the tensor indices of the tensor-valued p-form, and those terms would not be taken into account if XDtoCDflag were True. See also FtoC, XDtoCDflag, XP, CoXD, HodgeStar, GenLap, Lap.

When XDtoCDflag is True, FtoC will replace exterior derivatives XD by expressions involving covariant derivatives CD. When XDtoCDflag is False, FtoC will replace exterior derivatives by expressions involving ordinary partial derivatives OD. The default setting is XDtoCDflag = True because covariant derivatives of the Epsilon tensor are zero, that simplifies expressions involving XD and HodgeStar, such as the codifferential and the generalized Laplacian. When using tensor-valued p-forms, the user should turn off XDtoCDflag by typing Off[XDtoCDflag], that sets the flag to False and updates the system. The flag can be turned on again by typing On[XDtoCDflag]. See also FtoC, DefineTensor.

XP[expr1,expr2] is the exterior product of expr1 and expr2, where expr1 and expr2 are any differential form expressions. There can be up to four differential form arguments of XP. The infix form of XP[f,g] is f~XP~g, where f and g are forms. See also FtoC, RankForm, XD, CoXD, HodgeStar, GenLap, Lap.

ZeroDegreeQ[expr] is True if expr is a 0-form or tensor-valued 0-form and False otherwise. ZeroDegreeQ differs from ZeroFormQ because the latter will not recognize that a component of a form or tensor-valued form is a scalar of degree zero.

ZeroFormQ[object] returns True if the object is a 0-form and False otherwise.

Return to MathTensor Home Page.

steve@smc.vnet.net

See also the Other Interesting WWW Sites.

© Copyright 1996 MathTensor, Inc.

MathTensor is a Trademark of MathTensor, Inc.

Mathematica is a Registered Trademark of Wolfram Research, Inc.

This page was last updated on December 9, 1996.