8.21.1 Tensor Index to Component Translation

Tensor Index to Component Translation converts abstract index notation into concrete component values through coordinate system mapping and basis transformations.

Tensor Index to Component Translation is the correspondence rule that converts an abstract, basis-free tensor object into the concrete array of numbers — its components — obtained by pairing the tensor with a chosen basis of the underlying vector space and a chosen dual basis of its dual space, together with the bookkeeping of upper and lower index placement that records how each component transforms when the basis is changed. It is the bridge that lets an object defined without reference to any coordinates be manipulated, computed with, and expanded as ordinary indexed numbers once a specific basis has been fixed.

From Abstract Vector to Indexed Number

Pairing With a Basis

Given a vector space V with basis {e₁, ..., eₙ} and dual basis {e¹, ..., eⁿ} of the dual space V* satisfying eⁱ(eⱼ) = δⁱⱼ, an abstract vector v ∈ V translates into components by evaluating the dual basis on it:

v^{i} = e^{i} (v)

so that v = vⁱeᵢ (with the repeated index summed). The upper placement of the index on vⁱ records that these are the coefficients of a vector expanded in the basis {eᵢ}, as opposed to the coefficients of a covector.

Covectors Translate With Lower Indices

A covector ω ∈ V* translates into components by evaluating it on the basis vectors themselves, ωᵢ = ω(eᵢ), and these components carry a lower index. The consistent placement — upper for vector components, lower for covector components — is not an arbitrary typographical choice but is fixed by exactly how each type of object is paired with the basis to extract a number.

General Tensors of Higher Order

Multilinear Evaluation Produces Multi-Index Components

A tensor T of type (p, q), viewed as a multilinear map taking p covectors and q vectors to a scalar, translates into components by evaluating it on all combinations of dual-basis covectors and basis vectors in its appropriate slots:

T_{j_{1} \dots j_{q}}^{i_{1} \dots i_{p}} = T (e^{i_{1}}, \dots, e^{i_{p}}, e_{j_{1}}, \dots, e_{j_{q}})

with one upper index generated for each covector slot and one lower index generated for each vector slot the tensor takes as argument. This single rule — evaluate on basis elements in every slot and record the result with matching index placement — is the entire content of index-to-component translation for tensors of arbitrary order.

Reconstructing the Abstract Tensor From Its Components

The translation is reversible: given the full array of components T^{i₁⋯iₚ}_{j₁⋯jq} in a fixed basis, the original abstract tensor is recovered as the sum

T = T_{j_{1} \dots}^{i_{1} \dots} e_{i_{1}} \otimes \dots \otimes e^{j_{1}} \otimes \dots

confirming that the component array, together with the basis it was computed against, carries exactly the same information as the original coordinate-free tensor.

Why the Translation Depends on the Chosen Basis

Components Are Basis-Relative

The numbers produced by index-to-component translation depend entirely on the basis chosen; the same abstract vector v translates into a different array vⁱ for a different basis {e'ᵢ}, related to the original array by the standard change-of-basis formula. Index-to-component translation is therefore always performed relative to an explicitly or implicitly fixed basis, and any component array quoted without reference to its basis is incomplete information.

Upper/Lower Placement Encodes Transformation Behavior

The reason the translation assigns an upper index to vector components and a lower index to covector components is that these two placements transform oppositely under a change of basis — contravariantly and covariantly, respectively — and this opposite transformation behavior is exactly what allows a fully contracted pairing such as ωᵢvⁱ to produce a basis-independent scalar even though each individual component array is basis-dependent.

Diagram of the Translation Process

Practical Role in Tensor Computation

Enabling Numerical and Symbolic Manipulation

Every concrete numerical computation involving tensors — matrix multiplication, contraction, evaluating a specific component — operates on the translated component arrays rather than on the abstract tensor directly, since abstract multilinear maps are not themselves objects a computer or a hand calculation manipulates numerically. Index-to-component translation is therefore the necessary first step that makes any such computation possible.

Consistency Check Across Different Bases

Because the same abstract tensor can be translated into components in more than one basis, comparing the component arrays obtained in two different bases, related by the known change-of-basis transformation, serves as a check that a computation has correctly tracked basis dependence: if the two translated component sets do not relate to each other by the expected transformation rule for the tensor's declared type, an error has been made either in the translation or in the intervening computation.