8.16.2 Tensor Free Dummy Index Collision

Tensor Free Dummy Index Collision is the specific collision pattern in which a single index letter is simultaneously required to function as a free index — appearing once, denoting a retained slot in the result — and as one member of a repeated dummy pair summed away within the same term, a dual role that the rules of index notation do not permit any letter to hold at once. This particular collision is among the most common notational errors in tensor algebra because it typically arises silently, through the combination of two separately well-formed pieces of notation rather than through an obviously malformed single expression.

Anatomy of the Collision

Three Occurrences Where Only One or Two Are Allowed

A free–dummy collision manifests as a letter occurring three times within a single term: once in the role intended as free, and twice more in the pattern of a dummy pair. In

the third occurrence of $i$ on $C_i$ cannot be reconciled with a reading in which $i$ is simply a dummy pair between $A^i$ and $B_i$, nor with a reading in which $i$ is simply free on $C_i$, because the notation as written demands both readings of the same letter at once.

Why the Convention Cannot Resolve This Automatically

The implicit summation convention is defined only for a letter occurring exactly twice, once upper and once lower, within a term; it offers no rule for interpreting a third occurrence, and no rule for treating one occurrence as free while the other two are summed. This is why a free–dummy collision renders an expression ill-formed rather than simply ambiguous — the standard convention provides no default resolution, forcing the notation to be corrected before it can be assigned any meaning.

Typical Circumstances of Occurrence

Merging Two Independently Correct Expressions

The collision most often arises when a free-index expression and a separately valid dummy-pair expression, each unobjectionable on its own, are multiplied or added together while happening to use the same letter for unrelated purposes. An author working with $C_i$ as a free-index component in one part of a derivation, and $A^{i}B_{i}$ as a contracted scalar elsewhere, introduces the collision the moment these two pieces are combined into a single term without first renaming one of the occurrences.

Substitution of an Identity Into a Larger Expression

The collision can also appear when a known tensor identity, expressed with a particular dummy letter by convention, is substituted into a larger expression that already uses that same letter as a free index. Even though the identity was correctly stated in isolation, inserting it into a context with a pre-existing free index of the same name produces the collision at the moment of substitution.

Recognizing the Collision

The Occurrence-Count Test

The most direct way to detect a free–dummy collision is to count the occurrences of every distinct index letter within each term of an expression: a count of one indicates a legitimate free index, a count of two in opposite positions indicates a legitimate dummy pair, and a count of three or more for any single letter is a definitive signal that a free–dummy collision has occurred somewhere in that letter's usage.

Cross-Checking Against the Intended Free-Index Structure

A subtler variant of this check compares the free-index pattern actually present in a combined expression against the free-index pattern that was intended before the expressions were merged; if a letter that was meant to remain free has vanished from the count of single occurrences because it now also appears in a dummy pair, the collision has silently altered what should have been a retained slot in the result.

Resolving the Collision

Renaming the Dummy Occurrence

The standard resolution is to apply the index renaming operation to the dummy pair rather than to the free index, since the free index typically must retain its letter to remain consistent with the rest of the surrounding equation, while the dummy pair's letter is, by its nature, an arbitrary and freely replaceable placeholder. Renaming $i$ to $k$ in the dummy pair of $A^{i}B_{i}C_{i}$ yields

restoring a well-formed expression in which $i$ is unambiguously free and $k$ is unambiguously a dummy pair.

Checking the Result Against Free Index Protection

Because the free index in the resolved expression must remain exactly as it was before the collision was introduced, resolving a free–dummy collision is itself an application of free index protection: the corrective renaming must touch only the dummy occurrences and must never alter the letter used for the genuinely free index, since doing so would simply relocate the ambiguity rather than eliminate it.

Consequences of Leaving the Collision Unresolved

Loss of a Well-Defined Value

An expression exhibiting an unresolved free–dummy collision does not have a determinate value under the standard summation convention, since the convention supplies no rule for a triple occurrence; any further computation built on such an expression inherits this indeterminacy rather than producing a meaningful result.

Obscured Rank and Free-Index Structure

Beyond the immediate ambiguity, an unresolved collision obscures how many free indices — and therefore what rank — the intended result was supposed to have, since one of what should have been the free indices has been absorbed into an apparent, but invalid, dummy pairing.

Role Within the Index Collision Pattern

The free–dummy index collision is one of the three elementary sub-patterns comprising the general phenomenon of index collision, alongside dummy-against-dummy and free-against-free collisions. It is typically the most frequently encountered of the three in practice, precisely because free indices and dummy indices are handled by different notational rules and different intuitions, making their inadvertent conflation easy to overlook until the occurrence-count of a shared letter is checked explicitly.