Jtdylktuy

I think one reason is that often one does not want to remember what the variable names really represent.

As an example, when we choose to talk about the matrix $(a_{ij})$ instead of the matrix $(mathrm{TransitionProbability}_{ij})$, this expresses the important fact that once we have formulated our problem in terms of matrices, it is perfectly safe to forget where the problem came from originally -- in fact, remembering what the matrix "really" describes might only be unnecessary psychological baggage that prevents us from applying all linear-algebraic tools at our disposal.

(As an aside, have you ever seen code written by a mathematician? It very often looks exactly like your first example.)

We are very, very lazy. I am very, very serious about this.

NB1: The history is told in Florian Cajori's book on the history of notation. In very old times, there were no variables (and no formulas, really) and everything was incredibly verbose. Cajori's book beautifully shows the very long and tortuous way from that to modern day notation for variables; there are several sections regarding the notation of unknowns and of their powers.

NB2: Additionally, we usually deal with very complicated expressions, so using verbose names for variables you render things almost impossible. Writing down the formula for Gaussian curvature in terms of $E$, $F$, $G$ and the Christoffel symbols if we wrote $mathsf{Christoffel}^i_{jk}$ instead of $Gamma^{i}_{jk}$ would turn differential geometry into a dead subject very soon :P

Perhaps the most compelling reason for using single character variables is that it enables the usual convention of omitting the multiplication sign in products. This enables great conciseness in notating polynomials - which is important since polynomials are ubiquitous in mathematics, so any convention that simplifies their notation, comprehension, etc is surely worthwhile. Thus we can write $rm xyz $ to mean $rm xcdot ycdot z $ without any worry that it will be mistaken for a variable name.

While having to insert the multiplication signs doesn't reduce conciseness much for a monomial, it can greatly increase complexity for a polynomial of many terms. For it may cause equations to overflow the line/page length, etc, greatly hindering comprehension. Moreover, as many cognitive studies show, humans read read words by their shape (e.g. cover up the top/bottom half of a line of text and note how you can still easily read it), so any convention that alters shapes (or increases their visual complexity) may inhibit visual parsing, pattern-matching, and global inference of key structural characteristics.

My linear algebra professor (J. Komlos) said something that has always stuck with me: we should always use the same letters to denote certain variables, and different letters for different (math) subjects. In this way, our brains are able to build mental pathways so that when we see certain letters we can remember lots of other things we know about that subject because we associate those letters with certain facts, theorems, etc.

I actually think it's mostly a cultural phenomenon, comp-sci people like to use acronyms in part because it's more clear to program with an acronym than a single letter. But similarly, chemists like to use Latin words, physicists make up descriptive names for things, and mathematicians make up new words no one has ever heard of before.

A few thoughts:

• It is not true that one does not see formulae as you wrote in the very last line, something like $$ mathrm{velocity} = frac{mathrm{displacement}}{mathrm{time}} $$ In fact, I was taught algebra that way: start with word problems and write down mathematical expressions with words and labels, instead of numbers. I believe this kind of notation is also often used in textbooks.


• Like Mariano and Templar said in their answers, one of the main advantage of the short single letter notation is ease of copying. For computations it is much easier to write (by hand) single letters than whole strings.


• Another issue similar to the above is that it is easier to visually recognize identical terms when you use single letters. Take the expression for the "final amount" you wrote down. I happen to think that using the string "periods_per_yr" makes it harder to notice that the same term appear both in the denominator inside the brackets and in the exponent outside. Algebraically it is perhaps easier to keep track of structures using single letters.


• Also, what about when performing abstract arguments where the variables do not refer to anything specific and concrete? Is the phrase "take three points in the plane, point_one, point_two, and point_three..." more easily to understand than "take three points $P,Q,R$ in the plane..."?


• Lastly, in my PhD dissertation I have several computations involving expressions that span close to half a page when printed. I shudder to think what would happen if I use verbose names for all the terms: is it worth it to make individual variables more "legible" at the expense of making each equation span 3 pages? Does that actually improve overall legibility?

A number of excellent explanations have been given, ranging from laziness of mathematicians to convention. I'd like to add one more that may be slightly more debatable than others.

I dare to say I experience some sort of freedom when assigning variable names. This freedom is very typical to math: ideas are not bound by physical reality, the only constraints are your own imagination and the consistency of your thoughts. This freedom suffers if you're thinking about your math too concretely.

Here are a few remarks to explain my point of view:

1. Somewhere in the 15th century ($pm$ a few centuries) people realised they didn't have to discribe their equations in words, they could just assign letters to their quantities and let the formulae speak for themselves. Suddenly people realised it was not necessary for algebraic equations to have a direct geometric meaning. If people had kept writing $rm area = lengthcdot width$ until the end of days, this might never have happened.


2. Let's say we were thinking about distance. We might write
   $$ rm distance = sqrt{horizontal displacement^2 + vertical displacement^2}.$$ However, would you ever dare to write $rm distance = |horizontal displacement| + |vertical displacement|$? Maybe you would, but write this on the blackboard of an average high-school physics teacher (no offence meant) and they might try to hit you with something. This is because they're thinking about the physical reality, not about the abstract properties of such a formula or it's consequences in a more abstract setting. Therefore if you ever want to define the concept of a metric space and study it's properties in full generality, it's probably safer to denote distance simply by "d". (Choosing 'd' as a small mnemonic to where it all started.)


3. Let's say we're thinking about a curve this time. At some point you may come to realise there's actually an interesting group structure on your curve. If you're refering to your curve simply as "curve" everywhere, it's probably a giant leap to suddenly rebaptize your curve into "curve that is actually a group as well". You'll probably still call your curve "curve" all the time and you may unconsciously make it harder for yourself to realise the importance and usefullness of it's group structure.

In conclusion: math is an abstract science, assigning the name all to concrete names to objects will constrain your imagination, which is always a bad thing in math.

You're sort of comparing apples and oranges.

Mathematical papers are written in verbose, descriptive language (e.g. English); equations and such are introduced to introduce precision and brevity when needed.

A computer program, however, is written in a very precise language. The role of some coding style guidelines (e.g. long identifier names) are to introduce the verbose, descriptive language where needed.

Also, mathematics is "executed" -- humans have to manipulate them.

Computer programs, however are almost never executed. Even in an interpreted language, your program will get tokenized and parsed, and the interpreter will operate on the result.

I can't imagine writing full words when solving equation and rewriting it 10 times, when programming you usually don't write it so much, you can use functions, classes, copy/paste, programs which automatically insert variables etc.

Its quite self explanatory if you read of how Cardan wrote polynomials:

Instead of

$$x^4+6x^2+36 = 60x$$

He'd write

$$1overline{q}doverline{q}d. p: 6overline{q}d. p:36 text{ aequalia. } 60 pos.$$

or to write

$$x^4+(2y+12)x^2 +y^2+12y+36 = (2y+6)x^3+60x+y^2+12y$$

He'd put

$$1overline{q}doverline{q}d. p:2 pos.p:12 overline{q}d text{ R }p:1overline{q}d.p:1 pos. text{ additi numeri } p:36 text{ aequalia. } $$
$$2 pos.6overline{q}dratoroverline{u},p:60 pos.p:1 overline{q}d. p:12 pos. text{ numeri additi }$$

Actually, I think the reason why single letter identifiers are popular in math, and not so popular in programming is Intelisense. Today, every profesional developer would flinch if shown something like return P * pow(1 + r / n, n * t), but we have been spoiled by the ease of use of automatic filling of long names.

As I remember, 10-15 years ago it was more common to use single or double letter names for any local variable, because the developer would have to write each character himself, by hand. Right now, I just press a few keys, and the IDE does the rest.

BTW, the name of the function used in the example (pow for Power) fits nicely with the explanation.

Because the intellisense & autocompletion on my piece of paper is turned off. :)

(So is the context sensitive color highlighting.)

Holy cow, imagine a sheaf cohomology commutative diagram chase with camel casing and vaguely Java like method syntax for all operations. Or even just the chain rule:

derivative(firstSmoothFunction.composedWith(secondSmoothFunction)) = derivative(firstSmoothFunction).composedWith(secondSmoothFunction) * derivative(secondSmoothFunction)

In many cases the more concise notation may make it harder to remember what stands for what, but well chosen notation makes the relations between things much more apparent.

It's a convention like any other; never underestimate the power of historical inertia! Different disciplines have different conventions.

I would also guess (and I have no evidence to support this) that a big reason it is currently still around is that typesetting equations was expensive and time-consuming before the rise of modern typesetting (e.g. TeX) and writers of textbooks were probably encouraged to keep their notation as concise as possible. This would explain the disparity between mathematicians and programmers since the latter, after all, have the benefit of a history of using computers.

When doing algebra by hand with pencil and paper, it's a lot easier - and a lot faster - to work with something like

PV=nRT

instead of

(pressure)(volume) = (number of moles of gas) (gas constant) (temperature).

And this matters a lot when you're doing a timed exam.

I think mathematicians continue to use such terse notation because they don't have to maintain their creations under time pressure. Mathematics is essentially a write-once language and it only runs inside another mathematician's very forgiving brain. You can spend an hour rereading the same paragraph in a math paper until you understand it, taking time to absorb and reabsorb the sundry meanings of the Greek and Roman characters arrayed before you, and nothing bad will happen in the meantime. In an IT operating environment, we don't have that luxury. If I were ever rolled out of bed at 0300 to deal with a computer system problem and I had to deal with scripts/logs written anything like a typical math theorem, the person/idiot responsible for those scripts/logs would be strangled/fired before sunup.

I am a retired software engineer and a math person. I am going to answer your question based on my own personal experience and observation.

The coding style in your first example is unacceptable today but was common in old days. The FORTRAN programs written in 60's and 70's are like that.

The programmers deal with real life problems. The reasons programmers use long variable names are mostly for readability and easy to debug. Programmers are asked to use long names because they were having difficulty understanding code written by others and debugging code written in short names. I was once shown a piece of code written by myself and could not figure out what I was doing.

On the other hand, mathematicians mostly deal with abstractions. The formula in your example generally will be present with the explanation you provided. Later on in the literature,
the author can use t, which is the number of years, wherever it is needed without repeated explanations. Most mathematicians follow certain conventions, say they usually use x for an unknown, c for a constant without explanation. This sometimes will give the readers some trouble understanding the text if unusual conventions were used. Also, the reader will have to get used to the notation the author adopts. Sometimes it's a pain.

In either case, there is a compiler there. In the programming case, you have a compiler to help generating machine code for the computer to understand. In the math case, your brain is the compiler to generate the knowledge.

I don't think that substituting single-letter variables with more letters would do much positive in most mathematics, because most theorems (and such) are short enough so that remembering a few variables isn't a problem. And if you forget, it is just to look at the start of the theorem. Also, there is conventions for what variable-letters to use in different circumstances. And last, it is a way to make it easier to separate words from variables.

In programming, the ability to have more letters for one variable, is a huge advantage because a program often consists of thousands of lines, and hundreds of variables.

Because a variable is just a number and they all behave equally, different variables dont have any different meaning or interpretation in math, you dont gain any additional information by writing "final_amount" instead of x. Its only confusing and unproffesional. Even if you try to follow this path, there can be intermediate steps in solving an equation in which these words can not be interpreted in any sensible physical or informal way. For instance it can be convenient to introduce imaginary numbers even when solving equations with real solutions.

I'm a programmer as well. Note that your initial phrasing would be better as "As an imperative programmer, ..."

If you look at functional programming languages like F# or Lisp, the single letter variable paradigm is quite common for many of the reasons mentioned in the other answers. Take the functions:

let square x = x * x;;

let power x y = x ^ y;;

These are common and accepted ways to write your functional functions. This is mostly due to stateless/immutability differences in variables, but if we can skip the why explanations I'll just assert that the functional programming style parallels mathematical thinking far better than imperative.

Now imperative programming (by far the majority of programming) is more like a list of instructions, what I would compare in mathematics to a proof. If you remember back to 'doing proofs,' you state your reason for making each step along the way; in some cases rather verbosely.

I write: Solutions of quadratic equation $ax^2 + bx + c=0$ are $(-bpmsqrt{b^2-4ac})/(2a)$. I would not want to write this with time in place of $x$ and acceleration_of_gravity in place of $a$ and so on!

The point is that we usually want to be as concise as possible, in other words, we want to be capable of being understood and on the same time do not need to write lots of things. In truth, you'll never see in the middle of a serious text of math some equations with letters appearing from nowhere without explanations: we always have the definitions first. The point is that there are some conventions that we follow: things that always have the same name, and that our audience is supposed to know about. But if we do not assume even those basic things from our audience, we define them as well.

Now, I'll give you an example that you'll agree that writting everything like you say will make us even unable to proceed with the theory (only a masochist would proceed with something like that). This is an equation from differential geometry:

$$sum_{r=1}^ng_{lr}(gamma(t)) frac{d^2gamma^r}{dt^2}+sum_{i,j=1}^n[ij,l](gamma(t))frac{dgamma^i}{dt}frac{dgamma^j}{dt}=0$$

Now, that $[ij,l]$ expands also into another kind of big expression. Now imagine if for each of the letters we write the word it means. An equation like this one, that after making the definitions is at same time compact and understandable, would become a real mess and people would get lazzy to write down equations like that writing every word. So, we do use letters because we gain compactness, we gain simplicity and we do not waste too much time writing, but the benefits of that are only achievable if we combine with clear definitions and organized line of thought. If so, when someone reaches an equation like that will look at it and say: "well, that's easy to read, the author defined all those terms properly!" and although in the paper will appear only letters, for one who knows the definitions the entire words will "be there" but without making a real mess with the text.

Try writing:

$$e^{ipi}=-1$$

using big words!

If we saw something like the above, then the alphabet implicitly used in mathematics would consist of words. So, then the individual letters of that alphabet basically require another language to get understood in the first place. In other words if you have something like "velocity=distance/time" then you have "velocity", "distance", and "time" at least as implied as existing in some language as part of its alphabet. But, of course, you're wanting those symbols also to represent English words which have meaning also. Thus, you need two alphabets working together at once, as well as two languages working together at once, and it's not at all clear that you'll avoid ambiguity in principle when you do this. You will have character strings which consist of a word in one language and a letter of the alphabet in the other language at the same time.

On the other hand the more common way just requires one alphabet and one language. In principle, one doesn't need any understanding of any natural languages to have v=(d/t) mathematically speaking. You just need "v", "d" and "t" as variables in your alphabet... and to perhaps make this clearer you could write the same formula mathematically as 6=(7/8) given 6, 7, and 8 as variables in your alphabet for some language. But, then we wouldn't seek to use "6", "7", and "8" to denote numbers, because then we would have two languages working simultaneously.

Basically, it comes as simpler to have v=(d/t) than to have velocity=(distance/time).

First of all, if mathematicians used more-than-one-letter variables, they might confuse them for multiplication. Second, mathematicians like to be as accurate in as little words as possible. And finally, there are 26 letters in the alphabet. It's not like one equation will use them all, anyways.

The way things are now has to do with momentum.

Much of formal math was developed before there were computers. Thus computation was done by hand, a very repetitive process. Much literature was written with this in mind. Since pure math is not an applied field, it generally does not throw away models used in the past, the body of relevant work extends back quite far. If the field were to decide that they want to change notation, there would be countless books and journal articles to update to the new notation. While it may be simple enough to update digital documents, a large number of document stored in analog or raster formats, would likely never get updated. This body of knowledge would likely become inaccessible to future generations and thus lost to history. It is unlikely that the field will change notation unless there is a really really good reason to do so. For example the adoption of Arabic numerals was a vas improvement over Roman numerals and happened at a time when there was a much smaller body of pre-existing literature.

Computer science on the other hand is a new, applied field, a good deal of the advancement of the field has been after the creation of the electronic computer. The field focuses on elimination of redundant work and aims to build working systems.

I'd say partially because mathematical notation has much bigger vocabulary of "symbols" than source code notation.

Consider the following (shortened):

$$sum x_i$$

You probably will write that in a programming language as:

np.sum(x)

Why not...?

np.Σ(x)

Σ is much easier to write on paper than on computer (typical setups).

You'll also realize that even in the whole of Math StackExchange and LaTeX users, you'll almost never see anyone write Σ, what you'll find is either sum or Sigma :

sum x_i

That's the LaTeX notation for the mathematical notation I first mentioned.

Either way, what's important is the concept of sum, regardless of how long or short it's needed to write that concept. And when math can use one consise letter $Sigma$, why would it want to use sum?

As for variable names themselves, I agree with most other answers in this thread.

If I'm doing a piece of maths, I want to fit as much of it as possible on a single sheet of paper so I can see it all at once. Maths is hard enough without having to root through pages and pages to remind myself whether the inequality I'm about to use had $le$ or $<$ in it.

I've often wondered whether this as why people who are good at maths often have tiny handwriting.