Hacker News Reader

Comment by yodelshady | Hacker News Reader

No question about it. Mathematical notation is pure evil that should be cast into mount doom and then some. Mathematical notation makes Javascript operators look sane.

There is barely a single operation in the last few maths papers I've read that doesn't have at least four possible interpretations at first glance, so the only way to understand a single line is to understand the entire theory at once. Needless to say, all variables are described with single letters.

The best defense for it is that it evolved from handwriting, where the difference between `matmul(a,b)` and `a x b`, repeated a few dozen times, is significant. These days, as I type, I define commands to turn the unambiguous longhand into the shorthand.

("But yodel, a and b aren't bolded or uppercase so according to convention they must be scalars!", I hear you say. Ha, ha, ha.)

I am genuinely angry about this. A great deal of practical mathematics is not hard. Mathematical notation is hard, and everyone using it should be a little bit ashamed at how needlessly difficult the field is.

View on HN

>No question about it. Mathematical notation is pure evil that should be cast into mount doom and then some.

This sort of juvenile over-the top hyperbole is getting pretty boring now. Can you present your criticisms like a normal person instead of calling technical things you don't like "terrible and evil"? Especicially when you say (imo) ridiculous statements like "maths is not hard, it's the notation that's hard".

Notation is, most of the time, trivial compared to the concepts they represent. Funny you should give "matmul(a,b)" as an example, that would be a pretty atrocious way to write mathematics. Imagine writing "equals( matmul(S,matmul(A,inv(S))) , A)" rather than "SAS⁻¹ = A". Which do you think most clearly represents the concept at hand? The "overloading" that you complain so much about, it actually illuminates the fact that the underlying concept of "scalarmul(a,b)" and "matmul(A,B)" is the same. Going even one step further, Einstein notation: a development purely of notation, that makes dealing with tensor algebra a million times more clear.

I swear I don't understand this line of reasoning.

EDIT: I'll go out on a limb here: you're a programmer, not a mathematician, so you tend to look at these things from the prism of a programmer, not a mathematician. When all you have is a hammer...

While I get your reasoning, I think it misses a few important points.

-- 1. Having the same symbol for several things is the mathematicians way of having polymorphism and is a very nice feature.

Take for example the plus sign. Everytime we encounter it, we will most likely be dealing with some kind of abelian group. So just from seing the sign, we can already tell a lot about the context.

Another example would be the sign for the tensor product. I we see it, we are most likely dealing with some symmetric monoidal category . It might be vector spaces, modules over some commutative ring, coherent sheaves, objects in some derived category, etc. But still the important part is that all the stuff we know about this context can be applied.

-- 2. "so the only way to understand a single line is to understand the entire theory at once."

What do you expect out of a single line? Just think of a codebase with 800k lines. Would you expect to understand what the codebase is about by just looking at a single line?

I guess not: You'd rely on the naming of the functions/classes/etc. and how they are composed to understand what the codebase is doing. You'd also need a lot of knowledge about the area the codebase is concerned with to tell what is going on: Is it about a webserver providing a SPA? Is it a database? Is it a compiler?

You also don't expect to understand the whole codebase and it's dependencies (including low level abstractions)in its entirety: If you write a frontend `<div>` tag as part of a frontend do you really need to know the exact way this will end up as instructions on the chip of the computer that is running running a specific version of a specific browser running a certain version using drivers for a specific monitor, graphics card, etc...

All this is also true for mathematics.

-- 3. "A great deal of practical mathematics is not hard. Mathematical notation is hard ..."

Of course mathematics is hard. In fact: If anything related to human thought is hard, it is mathematics.

And more explicit notation will not make it easier. Do you think the twin prime conjecture is still unsolved because a layperson may misinterpret the meaning of a plus sign?

> What do you expect out of a single line? Just think of a codebase with 800k lines. Would you expect to understand what the codebase is about by just looking at a single line?

The whole point is not having to understand everything at once. And I would expect to understand what that particular line does to whatever level of detail I want by reading that line and recursively working backwards through the definitions of each operation invoked. Like clicking on each identifier and then doing ‘jump to definition’ in an IDE, instead of reading a book from cover to cover.

With code, I do this on a regular basis. With mathematics, it is plain impossible.

(And yes, this is why literate programming is a silly idea best forgotten.)

> Do you think the twin prime conjecture is still unsolved because a layperson may misinterpret the meaning of a plus sign?

No. But it very much may be because too few people understand the relevant portions of number theory in sufficient depth — from the highest levels of abstraction down to the bits and bolts of set theory — to notice the key insight necessary to solve it.

> With code, I do this on a regular basis. With mathematics, it is plain impossible.

It's easily possible with systems like Coq [1] plus a nice IDE [2]. There are mathematical libraries for the foundations [3][4].

[1] https://github.com/coq-community/awesome-coq

[2] https://github.com/coq-community/vscoq

[3] https://github.com/UniMath

[4] https://github.com/math-comp

That only works if someone bothered to write their proof in Coq in the first place. Most don’t.

Polymorphism is lovely - if you have strong typing, otherwise it's horrible. I shouldn't have to guess (!!!) that I am "most likely dealing with some kind of abelian group".

I don't expect to solve the twin prime conjecture. I do expect to understand, say, a kalman filter, or a multilayer perceptron. Those are not difficult concepts. And yet... I could not name a single paper that I could say to someone who doesn't already understand them "go read <x>".

How is that anything but damning? What is the point of a means of communication if I cannot impart a novel concept with it, because the reader must already understand all possible and imagined meanings of the plus sign to understand what I'm doing with it?

(side note: who's going to be solving the twin prime conjecture and not providing the proof as code? Why? A computer as an automated theorem checker is revolutionary.)

Sure often guessing is undesirable, but that guess can quickly be resolved with a little extra context. And with only a tiny piece of context you have an immensely powerful tool

> Take for example the plus sign. Everytime we encounter it, we will most likely be dealing with some kind of abelian group. So just from seing the sign, we can already tell a lot about the context.

This! This is exactly my biggest pet peeve in Python. That the plus operator is used, in the base language, for such a notoriously non-abelian operation as string concatenation. As Carlin would say, this is not a pet peeve, this is a major psychiatric hatred of mine. In the (fortunately few) occasions that I have to do string processing in Python, I go to great lengths to avoid any usage of the concatenation operator. I cannot bear myself to use it.

Maybe you've used it already, but you'll like how Julia does it. String concatenation is *, repetition is ^, and the identity element is one(String) = "".

Good because it's rarely a good idea to use it nowaday. Python has much better alternatives with join, __format__ and f-strings.

Aren't the key words, "most likely"?

Exactly. It could be what you expect, or it could be that the particular paper/journal/field has a slightly different syntactic convention, where underlined or bold letters mean something entirely different than usual. And even if the paper explains the syntax it uses somewhere, it's still a new ruleset that you have to constantly remind yourself of as you're reading the paper.

Yes, but sometimes you just want to code up a formula from a book.

> Of course mathematics is hard.

That wasn't what was said. What was said was "A great deal of practical mathematics is not hard.".

The notation "e^(i x pi)"is a crime in 2 languages against countless students. Why E? No good reason. Why pi? Also no good reason. i? When they named it they didn't even know if it was a real thing. They have many faces, and the notation manages to avoid representing a single one of them. Even "self_diff(rotate*half_turn)" would be an improvement; at least some of the meanings are captured.

Naming things is hard, but this is literally 1-letter-naming applied to the 3 most common and important functions humanity has ever defined. The only excuse for it was up until ~2,000AD the mathematicians were working by hand.

It's worse than that: The constant π is the wrong one! Never mind that it's a Greek letter, because we all studied that in our Ancient Greek classes, right alongside Latin and philosophy, where we read Plato.

No, the real issue is that the circle constant is 6.28319, not 3.14159. That's why a "full turn" is 2π instead of 1.

That's why every time I read an equation involving circles, or spheres, or any similar notion I have to take the constant that is in front of π and mentally divide by two.

And nobody should dare pipe up and claim that these are isomorphic and it "doesn't matter", because it does.

There's a tendency in modern theoretical physics to just ignore random small constant factors in equations, even when using natural units. In that case there ought not to be any unexplained constants! Any numbers in those equations ought to have an essential physical meaning, a real interpretation. Numbers ought to count things. But they don't, because of stupid extra constants like the ones needed next to π. This "2" gets blended into everything else, so you get stupid shit like the "8" in the Einstein field equations. Eight of what is being counted here exactly? Oops.. no wait.. 4 circle constants are actually 8 half-circle-constants.

Learn that i := imaginary unit. From then on, every time you want to write the imaginary unit just write i.

Skip learning that i := imaginary unit. Write "imaginary_unit" every time you want to refer to it, for maximum clarity.

Choose the latter and now you have to write "pow(euler_constant, mul(imaginary_unit, circle_half_turn))". Does this sound "maintainable"?

As a professional software engineer who is also formally educated in statistics, I actually think it does sound more maintainable.

But pi has lots of meanings. Sure, it represents a half-turn in geometry, but that is in no way its only meaning (for example, it is also a transcendental real number). The same is true for S. And the fact that that exponentiation with complex exponents is isomorphic with geometric operations is a non-trivial result that your notation losses. For example, log(e^i x pi) = i x pi. Would that be as self-evident as log(self_diff(rotate x half_turn)) = rotate x half_turn?

That "log(e^i x pi) = i x pi" is not self-evident at all. The only reason you know it is because you attended a math class and your professor made you solve 60 problems from a $1,000 textbook until you memorized it.

I don't even know what "e^i x pi" means. How does that translate into C notation? Is it pow(e, i) * pi, or is it pow(e, i) * x * pi, or is it something else entirely?

Unfortunately, the text inputs I have available are not good enough to represent the actual maths notation, which is extremely clear in this respect: it would have an e, and then in the superscript, i π. Since this is such a well known formula (Euler's Identity), I didn't think it would be a problem.

In C notation, this would be pow(e, i * π). Or maybe pow(i*π, e), I don't remember and the notation is pretty bad.

And the point about exponentiation is very simple, and I didn't need to do hundreds of exercises to remember: the natural logarithm of e raised to some X is X, whatever that X may be.

The other commenter's note was that raising some constant to an imaginary number is a very obscure way of expressing the geometric operation that this represents (multiplying by e^iπ is equivalent to rotating a complex number by a half circle). I was pointing out that, while that is true, it loses the algebraic interpretation, which also has value.

I agree with the other poster. If you can memorize log(e^N) = N, you could have memorized other notations for expressing the same. Math notation doesn't make Euler's Identity self-evident, and can be used to obscure the geometric operations taking place.

To those who haven't memorized Euler's Identity (I'm aware of it due to your comment, but will probably forget it in a day or two), this "self-evident" truth is invisible no matter which notation is used.

C notation is bad, but has the advantage of being precisely representable in ASCII. To post math notation you'd need to upload a PNG somewhere.

There is a lot more to work with there than with traditional notation. Traditional notation is literally one letter.

I'd be surprised, on a tech forum, if people didn't see at least the smallest hint of a problem at single-letter naming. The tech industry moved away from that approach with a certain implicit urgency.

There are many differences between the practice of mathematics and programming, to the point that I do t believe that they are comparable.

One basic thing is that PI (and even more so E) are pure abstractions. They correspond to certain physical or intuitive concepts in certain contexts, but their identity across contexts is more important. Even in programming, we sometimes use one-letter variable for very abstract things (the loop variables i, j, k; T, U, V as type arguments in C++ and co, or a, b, c in Haskell; and probably others).

Another major difference is the way this is actually done. Programs are written once and then mostly read, tweaked, debugged. Mathematics is all about writing and writing and writing, a lot of times from scratch. You're not as Lilly to be editing a file from 2 years ago, you're more likely to be writing a new attempt from scratch. And, people will likely only read your final version, not your hundreds of attempts before. So efficiency in writing your ideas is all the more important than in coding.

Another aspect is that, a lot of the time, the mathematician will spell out a lot of intermediate steps between a problem and a solution that, in a computer program, actually fall in the execution, since we're not in the habit of proving our code reaches the final state we envision (even informally); and certainly not in-line with the rest of the program. So again, in mathematics you end up writing a lot more the same few symbols, making long words all the more harmful.

Imagine

    X + 6 = 5X
    X - 5X = -6
    -4X = -6
    X = 6 / 4

Spelled out as

    Unkown plus 6 is equal to 5 times Unknown
    Unknown minus 5 times Unknown is equal to negative 6
    Negative 4 times Unknown is equal to negative 6
    Unknown is equal to 4 divided by 6

Which of these is clearer and easier to follow?

Edit: I'll also add that function notation works great for unary and maybe binary functions (though operator notation is generally nicer for binary functions), but it becomes horrible for anything past that. For example, the sigma notation for sums is much easier to remember than if I wrote `sum(1, 789, some_value squared)`.

Don't get me started on the notation for negative numbers, that notation is so easy to miss. Mucking up a calculation because it isn't clear which term a minus is associated with must be one of the single most common errors in all of mathematics. I might actually start experimenting with neg(6) instead of -6 after this conversation now that you've made me think about it.

> Mathematics is all about writing and writing and writing, a lot of times from scratch.

Mathematics is all about clever people communicating precise ideas.

> Even in programming, we sometimes use one-letter variable for very abstract things (the loop variables i, j, k; T, U, V as type arguments in C++ and co, or a, b, c in Haskell; and probably others).

They're defined locally though. A loop variable in one program is totally logically unconnected from a loop variable in another program to the point where programmers might give them mutually contradictory meanings. If the meaning was shared across all programs then yes the 1-letter-names would be troubling.

> or a, b, c in Haskell

And part of the reason Haskell doesn't catch on is because very few people can read Haskell programs; I know my interest in it ended when I saw =<< then decided to learn a lisp instead. I still live in cheerful ignorance of whatever that symbol means. I can't even search for it I get results pages in Chinese (!!). It is a bad community to look to on the subject of how to communicate ideas.

I agree that figuring out what the symbols mean can be a frustrating part of mathematics, but once that part is done, I find the notation to be lightyears ahead of what normal programming languages can do in the way of communicating an idea directly.

Seriously, take any 100 ksloc codebase; how many bugs do you expect to be in there? How many of the developers do you expect to really grok what their code is doing on all functional levels of abstraction?

Math papers certainly contain bugs sometimes, even critical ones, but the density of bugs is way lower overall. It's simply much easier to find a bug by staring at a terse one-liner than it is by groveling around 10 pages of "readable" code.

Arthur Whitney's code is definitely not approachable, but once you get over the hump, I find it emminently readable compared to what we hackers tend to tout as "readable code."

I think most of the debate boils down to different concerns. As a communication tool, what is the function of your code? If it's to introduce ideas to a large audience or many non-inductees, then please, use Python or similar. But if your primary communications are only between the system experts, do you really need to optimize for "this code looks grokkable at first sight"?

You are demanding to be able to read a random line in the middle of a book and understand everything. This is stupoid, the book/article/theory will have a section that defines everything is used.

You have same shit on JS where + can mean do a numeric addition or it can mean concat 2 strings and other powerful languages will allow you to have + enhanced so you can use it to add matrices,vectors,fractions time intervals etc.

If you want for example to understand the fundamental theorem of statistics you can read only it and his proof you need to read and understand everything in the book before it.

I disagree completely. You have to be aware of the context. It's like having hundreds of different programming languages. You work in a particular context and you get used to it. I assume you come from a non mathematical perspective.

yeah, I would view every Mathmatical discipline or any discipline that heavily involves maths as a different "programming language". Each having evolved their own sets of conventions and styles (e.g. Mathmatical physics vs Statistics sometimes differ in notations despite describing the same thing). You can't switch from one to the other without learning their style of writing.

They seem like a crazy mix of noise at first, but that's just because you're not used to it. It's like a javascript developer reading their first lines of rust, or the C-programmer reading their first lines of Haskell.

> The best defense for it is that it evolved from handwriting, where the difference between `matmul(a,b)` and `a x b`, repeated a few dozen times, is significant. These days, as I type, I define commands to turn the unambiguous longhand into the shorthand.

How much math/physics have you actually done? In deriving something, or solving a problem, I can have pages of the concise notation. Dealing with your expanded notation would be Hell that no mathematician/physicist would put up with. We struggle even with the concise notation. We'd like an equation to fit on a line, for example, and it's a pain when it doesn't. With your notation, very little of substance would fit on a line.

It's a bit like programming in that sense. If you can fit a function in one screen, it greatly improves the chances of you understanding it. With your notation, you're intentionally going verbose. It may help you understand that one line, but will likely make it harder to understand the overall picture.

And really, it's not `a x b`, it's 'ab' :-)

(And with matrices, it's more often 'AB').

> Mathematical notation is hard, and everyone using it should be a little bit ashamed at how needlessly difficult the field is.

Everyone has his preference of comfort. I don't like much of the notation of logic, and I'm thankful most other math disciplines don't replace "and" and "or" and "negation" with the symbols used in logic. However, the set of practicing mathematicians who share your comfort preference is virtually nil. I don't like the concise, implicit notation in general relativity, either (where lots of stuff isn't even written down but kept in your head) - but I'll trust what everyone who has studied it says: You'd go crazy if it were as explicit as I want it - let alone your level of verbosity.

Also, as an aside, I've had to read code that represented mathematical operations (numerical integration, matrix operations, etc) written by others, and without comments or access to the author it was virtually impossible to follow. Most of the standard programming language's syntax is poor for mathematics.

Edit: I'll add that if your primary exposure is through math journal papers, then I do understand your frustration. They're usually much, much harder to understand than the level in a typical textbook. Unfortunately, this is intentional.

Have you ever read a perl program?

> that doesn't have at least four possible interpretations at first glance

show us

Reply on news.ycombinator.com