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, listofequations or lineelement (synonym: line_element), to return a set or list 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.
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
Setting lowercaselatin_is letters to represent space indices
⁢The Schwarzschild metric in coordinates ⁢r,θ,φ,t
Signature: - - - +
Define now an arbitrary tensor A
Defined objects with tensor properties
Construct now the tensorial expression mentioned
Check the indices
The repeated indices per term are: ...,...,..., the free indices are: ...
Construct now the tensor-array
T ≔ TensorArray⁡
In the above, the sum over ρ is performed. With performsumoverrepeatedindices = false the sum is not performed:
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⁡,freeindices=ν,μ
Depending on the context, instead of an Array of components, it is more convenient to receive as a set or list of equations with each of components of the Array equal to 0. For that purpose use the output = setofequations (or listofequations on the right-hand side) option
T ≔ TensorArray⁡,freeindices=ν,μ,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])
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⁡,simplifier=simplify@normal
Verify the result comparing R, constructed with the definition of Riemann in terms of Christoffel symbols, with the Riemann tensor itself
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:
A contraction of the Riemann tensor over two of its indices
The output of TensorArray is clear when there are at most 2 free indices. When there are 3 or more free indices, however, while the whole array of components is returned, only a slice of it is displayed. For example, for the Riemann tensor, which for the Schwarzschild metric has non-zero components,
It is not evident which slice of the 4 x 4 x 4 x 4 array of components is being displayed, that is: what indices are being shown in the 4 x 4 matrix, in what order, and what are the values of the indices not being shown. To address these issues, the explore option allows for visualizing the different possible slices of components while making clear which indices are shown, in what order, and what are the values of the indices not shown:
⁢Rα,β,μ,ν ordering of free indices=α,β,μ,ν
Value of Index 1
Value of Index 2
In this output we see:
In the title, the tensorial expression being explored and an indication of its free indices, as well as the ordering used to produce the display. Note that, for a tensorial expression that is not just a tensor, that ordering is not determined by the expression.
Which indices are being explored: Index 1 = alpha and Index 2 = beta, so the 4 x 4 matrix displayed is for the remaining indices μ and ν, in that order (as shown in ordering of free indices = [...] within the title).
You can move the slider of each Value of Index to set the values of alpha or beta without having to recompute anything, and the 4 x 4 matrix for μ and ν is automatically updated.
You can actually choose which of the 4 indices will be Index 1 or Index 2 by clicking in the corresponding boxes, and in that way also indirectly select the remaining two indices shown in the 4 x 4 matrix of components, always with the ordering you see in ordering of free indices (after removing Index 1 and Index 2).
When the number of free indices is larger, being able to explore is even more significant. For example, consider a metric for which the Ricci tensor has non-zero components and explore the expression formed by the product of three non-contracted Ricci tensors Rα,ρ⁢Rβ,ν⁢Rμ,σ
Coordinates: r,θ,φ,t. Signature: - - - +
⁢Rα,ρ⁢Rβ,ν⁢Rμ,σ ordering of free indices=α,β,μ,ν,ρ,σ
Value of Index 3
Value of Index 4
The Physics package includes representations for the Dirac, Pauli and Gell-Mann matrices. These matrices, respectively represented by Dgamma, Psigma and Glambda, are implemented as tensors in spacetime or the corresponding SU(n) groups. Each tensor component, in turn, also has matrix components, the ones corresponding to the fundamental representation of the group. To visualize the matrix components you can use the option rewriteinmatrixform, or if there are also matrix operations that could be performed, to visualize and perform those operations use the option performmatrixoperations.
As an example, consider the Pauli matrices at this point of the session, with the spacetime set with a curved value. By default the Pauli matrices are implemented as spacetime 4-vectors in a Minkowski flat spacetime. To work with Pauli matrices using tensor notation, and within a curved spacetime, you can set su2indices using Setup and redo the definition of these matrices as a tensor in a SU(2) space (indicating them with su2 indices) using Define and its redo option.
Defined Pauli sigma matrices (Psigma): σ1 , σ2 , σ3
So the spacetime is curved,
and the Pauli matrices now form a SU(2) 3D tensor, with commutator and anticommutator algebras defined in a SU(2) space.
TensorArray can be used to visualize the SU(2) components of these two equations as well as the matrix components of each SU(2) component. For example for the first commutator algebra tensorial equation, the following shows the SU(2) components.
Note that in these definitions the commutators are expressed in inert form. To visualize the matrix form of each component you can use rewriteinmatrixform.
To activate the inert commutators in these equations you can use value.
or indicate value as the simplifier
or use the performmatrixoperations option of TensorArray, whose purpose is not just to rewrite in matrix form but also to perform the resulting matrix operations
Alternatively, you can compute in steps, for example, first expand the commutators
To visualize the matrix operations, you can use TensorArray over the result above with its rewriteinmatrixform option, or to additionally perform them use its option performmatrixoperations. Alternatively, you can always call, directly, the corresponding Library commands. For example
Check, Coordinates, Define, Dgamma, g_, Library, Physics, Physics conventions, Physics examples, Physics Updates, Tensors - a complete guide, Mini-Course Computer Algebra for Physicists, Psigma, Setup
Landau, L.D., and Lifshitz, E.M. The Classical Theory of Fields, Course of Theoretical Physics Volume 2, fourth revised English edition. Elsevier, 1975.
The Physics[TensorArray] command was introduced in Maple 16.
For more information on Maple 16 changes, see Updates in Maple 16.
The Physics[TensorArray] command was updated in Maple 2020.
The explore and output = ... parameters were introduced in Maple 2020.
For more information on Maple 2020 changes, see Updates in Maple 2020.
Download Help Document