Dummy Variables in Mathematics

When you set up mathematical formulas, you often have to introduce various kinds of local objects or "dummy variables". You can treat such dummy variables using modules and other Wolfram Language scoping constructs.

Integration variables are a common example of dummy variables in mathematics. When you write down a formal integral, conventional notation requires you to introduce an integration variable with a definite name. This variable is essentially "local" to the integral, and its name, while arbitrary, must not conflict with any other names in your mathematical expression.

Here is a function for evaluating an integral:

p[n_]:=Integrate[f[s] s^n,{s,0,1}]

The s here conflicts with the integration variable:

p[s+1]

Here is a definition with the integration variable specified as local to a module:

pm[n_]:=Module[{s},Integrate[f[s] s^n,{s,0,1}]]

Since you have used a module, the Wolfram Language automatically renames the integration variable to avoid a conflict:

pm[s+1]

In many cases, the most important issue is that dummy variables should be kept local, and should not interfere with other variables in your mathematical expression. In some cases, however, what is instead important is that different uses of the same dummy variable should not conflict.

Repeated dummy variables often appear in products of vectors and tensors. With the "summation convention", any vector or tensor index that appears exactly twice is summed over all its possible values. The actual name of the repeated index never matters, but if there are two separate repeated indices, it is essential that their names do not conflict.

This sets up the repeated index j as a dummy variable:

q[i_]:=Module[{j},a[i,j] b[j]]

The module gives different instances of the dummy variable different names:

q[i1] q[i2]

There are many situations in mathematics where you need to have variables with unique names. One example is in representing solutions to equations. With an equation like cos(x)==1, there are an infinite number of solutions, each of the form x==2π n, where n is a dummy variable that can be equal to any integer.

When the Wolfram Language solves this equation, it creates a dummy variable:

Reduce[Cos[x]==1,x]

Here is a way to make the dummy variable unique:

Reduce[Cos[x]==1,x,GeneratedParameters:>Unique[C]]

Another place where unique objects are needed is in representing "constants of integration". When you do an integral, you are effectively solving an equation for a derivative. In general, there are many possible solutions to the equation, differing by additive "constants of integration". The standard Wolfram Language (RefLink[Integrate, paclet:ref/Integrate]) function always returns a solution with no constant of integration. But if you were to introduce constants of integration, you would need to use modules to make sure that they are always unique.