6.15.2 Tensor Two Zero Component Index Pair

Tensor Two Zero Component Index Pair is the pair of numerical labels i and j attached to each entry T^{ij} of a type (2,0) tensor once a basis has been fixed, identifying that entry's position within the full array of components and distinguishing the concrete, basis-dependent numerical description of the tensor from the abstract, basis-independent object itself. This index pair is the bookkeeping device that lets a type (2,0) tensor be stored, manipulated, and computed with as an ordinary array of numbers, while still carrying enough structure to recover the transformation behavior that makes it a genuine tensor rather than an arbitrary table of values.

Counting and Organizing the Components

Total Number of Components

If the underlying vector space V has dimension n, then each of the two indices i and j independently ranges over n values, so the component index pair produces a total of n² independent numbers:

For example, in a three-dimensional space, a type (2,0) tensor has nine components, T^{11} through T^{33}, each addressed by a distinct pair (i, j).

Arranging the Pair into a Square Array

The natural way to organize the component index pair is a square array with n rows and n columns, where the first index i selects the row and the second index j selects the column:

for the case n = 2. Although this arrangement visually resembles a matrix, the component index pair here carries a specific transformation meaning, both indices being contravariant, that a generic matrix of numbers does not automatically possess.

Behavior of the Index Pair Under Relabeling and Transformation

Free Indices Versus Summed Indices

Within the component index pair, both i and j are free indices when the tensor is written on its own as T^{ij}, meaning they are not summed and instead range independently over all their values to enumerate the full set of components. This is different from an expression such as T^{ij} S_j, where j becomes a summed, or dummy, index because it is repeated once as an upper index and once as a lower index, leaving only i as a free index in the result.

Transformation of the Pair as a Unit

Under a change of basis with transition matrix A and inverse B, the entire component index pair transforms together, each index picking up its own factor of B:

Every one of the n² new components is generally a linear combination of all n² old components, since the sums over k and l mix entries across the entire array; the index pair does not transform entry by entry in isolation, but only as part of the complete array.

Symmetry Patterns Detected Through the Index Pair

Diagonal and Off-Diagonal Entries

Within the component index pair, entries with i = j lie on the diagonal of the array, while entries with i ≠ j lie off the diagonal. A tensor is called symmetric when swapping the index pair leaves each component unchanged, T^{ij} = T^{ji}, and antisymmetric when swapping the pair negates the component, T^{ij} = -T^{ji}, which forces every diagonal entry to vanish since T^{ii} = -T^{ii} implies T^{ii} = 0.

Independent Components Under Symmetry

When a type (2,0) tensor is known to be symmetric, the component index pair is effectively unordered, since T^{ij} and T^{ji} carry the same value, reducing the count of independent components from n² to n(n+1)/2. When it is antisymmetric, the diagonal vanishes and only pairs with i < j are independent, reducing the count to n(n-1)/2.

Visualizing the Index Grid

Distinguishing the Index Pair from a Generic Array of Numbers

What the Index Pair Alone Does Not Guarantee

Simply arranging n² numbers into a square grid and labeling them with a pair (i, j) does not by itself make the array a type (2,0) tensor; the defining property is that the labeled entries transform by the contravariant rule shown above whenever the basis changes. Many arrays that happen to have two indices, such as a table of exam scores indexed by student and subject, use the index pair purely as a labeling convenience without any associated transformation law, and are therefore not tensors in this technical sense.

Role of the Index Pair in Computation

Despite this caveat, once an array of numbers has been confirmed to satisfy the transformation law, the component index pair becomes the practical handle for all computation: contractions, symmetrizations, and constructions such as the inverse metric are all expressed as explicit manipulations of the indices i and j, making the index pair the operational language through which the abstract type (2,0) tensor is manipulated in concrete calculations.