11.20.1 Tensor Variance Verification Index Position

Tensor Variance Verification Index Position shows how tensor variance is checked via index placement, ensuring correct coordinate transformation behavior.

Tensor Variance Verification Index Position is the specific stage of the verification procedure that inspects the vertical placement of every index in a candidate expression, checking that each index sits in the position, upper or lower, actually justified by its transformation behavior, rather than trusting the placement chosen merely by notational habit or convenience.

Foundational Setting

Placement as a Claim to Be Checked

Writing an index as a superscript or subscript is itself a claim about how that index's component transforms. The index position check within the verification procedure treats this placement not as given but as an assertion requiring confirmation against the actual transformation behavior of the underlying quantity.

Distinguishing This Check from Other Verification Stages

While other stages of the broader verification procedure confirm that a transformation law holds numerically under an explicit basis change, the index position check specifically asks whether the chosen upper or lower placement correctly anticipates which of the two possible laws, direct or inverse matrix, will actually be found to hold.

Procedure for the Position Check

Step One: Note the Claimed Position

Begin with the position as written in the candidate expression, for instance treating a component $v^{i}$ as claiming contravariant, upper-index behavior.

Step Two: Derive the Actual Transformation

Independently derive how the component actually changes under an explicit basis change described by matrix $A$ , without assuming the claimed law in advance.

Step Three: Match Actual Behavior to Claimed Position

Confirm that the derived behavior matches the position: if the component is found to satisfy

{\tilde{v}}^{i} = \sum_{j} {(A^{- 1})}_{j}^{i} v^{j}

the upper placement is confirmed correct. If instead it satisfies the direct-matrix law, the upper placement is contradicted and the index should properly be written as a subscript.

Detecting a Position Mismatch

An Illustrative Mismatch

Suppose a quantity is initially written with an upper index, $ω^{i}$ , but direct derivation shows it transforms according to the direct-matrix, covariant law:

{\tilde{ω}}^{i} = \sum_{j} A_{i}^{j} ω^{j}

The index position check flags this as a mismatch: the object's true behavior is covariant, so consistent notation requires rewriting it with a lower index, as $ω_{i}$ .

Why Such Mismatches Arise

Position mismatches typically arise from importing notation from a different context without re-deriving the transformation behavior in the new setting, or from a computational error in an intermediate step that silently altered how a quantity responds to a basis change.

Visual Overview

Diagram of the Position Check

Application to Mixed and Multi-Index Objects

Checking Each Slot Independently

For a candidate mixed tensor with several indices, the index position check is applied separately to each slot: an object claimed to be of type $(1, 1)$ requires its single upper index to pass the inverse-matrix check and its single lower index to pass the direct-matrix check independently, with both needing to succeed for the overall claimed type to be confirmed.

Partial Confirmation Is Insufficient

If one index of a multi-index object passes its check while another fails, the object as a whole does not qualify as a tensor of the originally claimed type, even though part of its index structure behaved correctly, since tensor status requires every index to satisfy its designated transformation law simultaneously.

Summary of Key Traits

Defining Characteristics

The index position check tests whether a component's claimed upper or lower placement matches its independently derived transformation behavior.
A mismatch between claimed position and derived behavior signals that the notation must be corrected to reflect the object's true transformation type.
Mismatches commonly arise from borrowed notation or from errors introduced during intermediate calculation steps.
For multi-index objects, every index slot must pass its own position check independently for the overall claimed type to be confirmed.