Math Abuse¶

When I shows a mathematician some of the homework problems I have done, he was a little shocked. So I went on and looked for other notations that physicists use differently or even naively.

Multiple Integrals¶

This is a multiple integral in the regular notation:

Theoretical physicists often use the following notation:

The integrals is not , but the integrate everything after the ! The advantage is that, just like with a summation sign, you can see the bounds right away, and swap integrals easier.

Summation Convention¶

Let me start with the regular inner product. A mathematician would write it either or .

Physicists might use the mathematician’s notation, or write , since we write vector arrows (or bold vectors, then ). I prefer bold vectors by now, so I will continue to use them.

If you assume a particular basis for your vector space, then you can access the components of your vectors with upper index, if they are regular (contravariant) vectors: . If you transpose the vector, it will become a covector (covariant) and has a lower index: . If your “transpose” is a “complex conjugate transpose”, the inequality holds in the general case.

With that in mind, you can write the scalar product like so:

And physicists like to omit the summation sign and just write for the scalar product.

The transpose is induced by a metric tensor , so the transpose works like this: .

As a corollary, the physicist distinguishes between Latin and Greek indexes in the summation. A Latin index means , where a Greek index means . This is important for the theory of special relativity, where the zeroth coordinate is the time. That way, one can construct the Laplace () and d’Alambert () Operators:

Where I have used the metric tensor of special relativity:

Separation of Variables¶

Say a physicist is given the following ordinary differential equation: . He might do the following:

In some programming languages, it is possible to overload a function with different arguments:

int f();
int f(int x);
int f(int x, int y);


Those all have the same name, but the compiler will be able to distinguish that from your arguments. f(1) and f(1, 1) will call two distinct functions.

The same applies for different types. So this is also possible:

int h(int x);
int h(std::string x);


When you call h(1) and h(""), it will pick out the right function to call. Unless the functions do a roughly the same thing, this will lead to confusion pretty easily.

Now physicists are doing it even worse! Say you have a function . Then you use and write stuff like which is fine. Now you create the Fourier transform that I will denote with a . With you could write:

This seems correct and unambiguous to me. Physicists like decorators more than different letters, so they would write instead of , which should be fine as well.

But even that seems to much writing. So they write for the Fourier transformed function and for the original function. That means that even if , it does not need to follow that , since they are different functions! The function is overloaded, and the correct one is chosen by the symbol you write the argument with. I think this is a gross violation of scoping.

I have seen a case where somebody wrote to make sure the reader understands that the transformed function is meant. Just write !