Physics[TensorArray] - construct an Array that can be indexed to return the values of a tensorial expression
any algebraic tensorial expression having spacetime free indices possibly having also repeated indices implying summation
optional, when given, an applet with sliders to give values to the free indices allows for exploration of the tensorial expression; useful when there are more than two free indices
freeindices = [...]
optional, the right-hand side is a list indicating the ordering of the free indices in the returned output - relevant when expression involves products and sums of tensors with free indices.
output = ...
optional, the right-hand side can be setofequations or lineelement (synonym: line_element), to return a set of equations where each of the components of the Array is equal to 0, instead of the Array itself, or the line_element when expression is the spacetime metric g_.
optional, can be true or false (default), to perform the matrix operations involving Pauli, Dirac or Gell-Mann matrices entering expression as tensors
optional, can be true (default) or false, to perform the sum over repeated tensor indices in the returned result
optional, can be true or false (default), to rewrite in matrix form (without performing matrix operations) the Pauli, Dirac or Gell-Mann matrices entering expression as tensors
simplifier = ...
optional, indicates the simplifier to be used instead; default is none
The TensorArray receives a tensorial expression having n free indices, typically involving sums and products, and returns a corresponding n dimensional Array, which can be indexed as a single object to return the values of the tensorial expression for given values of its free indices.
To check and determine the free and repeated indices of an expression use Check.
The returned Array is constructed taking into account the covariant and contravariant character of each free index in expression. To compute the values of expression you index this array giving values between 1 and the spacetime dimension to the indices.
Pauli, Dirac and Gell-Mann matrices, respectively represented by the Psigma Dgamma and StandardModel:-Glambda commands, are implemented as spacetime and SU(3) vectors, where each component represents a matrix. Thus, when computing tensor arrays of components, one can optionally visualize the matrices behind these tensor representations and rewrite in matrix form, or additionally perform the matrix operations involved if any. For this purpose, pass the optional arguments rewriteinmatrixform or performmatrixoperations.
By default, in the returned result, summation is explicitly performed over all the repeated indices found in expression, taking into account the covariant/contravariant character of each index. To avoid performing this summation and keep repeated indices not summed pass the optional argument performsumoverrepeatedindices = false.
By default, the Array is constructed without simplifying its components; to have them simplified indicate the simplifier on the right-hand-side of the optional argument simplifier = .... A frequently convenient simplification is achieved with simplifier = simplify.
When expression involves sums and products of tensors having free indices, the ordering of the free indices in the returned Array is arbitrary. To indicated a desired ordering of these free indices, use the option freeindices = [...] where the list [...] indicates the desired ordering.
The array of components of a tensorial expression with at most 2 free indices is all visible on the screen as the output TensorArray. Things are not so simple when that number is 3 or larger, when only a slice of the array of components is shown. To visualize the expression's components in these cases you can use the explore option, which launches an applet that allows for giving values to all but two of the free indices, and shows the 2x2 corresponding slice for the other two, with the ordering shown.
Setup(mathematicalnotation = true);
Set the spacetime metric to be the Schwarzschild metric and construct an Array for the product of the metric tensor g_ contracted and multiplied with an arbitrary tensor A as in gμ,ρ⁢A⁢ρ⁢Aν For this purpose, set first the metric and the coordinates -you can use Setup for that, or because the Schwarzschild metric is known to the system you can directly pass the keyword or an abbreviation of it to the metric g_ to do all in one step
⁢Systems of spacetime coordinates are:⁢X=r,θ,φ,t
⁢Default differentiation variables for d_, D_ and dAlembertian are:⁢X=r,θ,φ,t
⁢The Schwarzschild metric in coordinates ⁢r,θ,φ,t
Define now an arbitrary tensor A
Defined objects with tensor properties
Construct now the tensorial expression mentioned
g_[mu, rho] * A[~rho] * A[nu];
Check the indices
The repeated indices per term are: ...,...,..., the free indices are: ...
Construct now the tensor-array
T := TensorArray((4));
In the above, the sum over ρ is performed. With performsumoverrepeatedindices = false the sum is not performed:
TensorArray((4), performsumoverrepeatedindices = false);
Also, in (6) the ordering of the free indices μ,ν is not defined. In the computations above, TensorArray choose the ordering μ,ν but one may prefer, for instance, ν,μ, resulting in the transpose of the matrix (8). To indicate any desired ordering you can use the optional argument freeindices = [...]
T := TensorArray((4), freeindices = [nu, mu]);
Depending on the context, instead of an Array of components, it is more convenient to receive as a set of equations with each of components of the Array equal to 0. For that purpose use the output = setofequations option
T := TensorArray((4), freeindices = [nu, mu], output = setofequations);
In the particular case where the tensorial expression is the spacetime metric, the desired output could be the line element (that you can also get entering g_[lineelement])
TensorArray(g_[mu,nu], output = lineelement);
Rewrite the Riemann tensor with all its indices covariant in terms of Christoffel symbols and their derivatives and construct a tensor-array for the resulting tensorial expression; in view of the presence of trigonometric functions, use the simplifier option
R := TensorArray((12), simplifier = simplify);
Verify the result comparing R, constructed with the definition of Riemann in terms of Christoffel symbols, with the Riemann tensor itself
R[1, 3, 1, 3];
Riemann[1, 3, 1, 3];
Compare all the nonzero values of the two arrays: for Riemann, pass the option nonzero, for R use ArrayElems; all the nonzero components are same: