AsciiMath | Hacker News Reader

AsciiMath

asciimath.org

141 pointssmartmic56 comments

The author of ConTeXt (a TeX format similar to LaTeX) has some interesting comments on AsciiMath [0] [1]. Its space handling looks especially problematic; the example given in [0]

  o ox x = xo
  a ax x = xa
  ooxx=xo
  aaxx=xa
  ac+sinx+xsqrtx+sinsqrtx+sinsqrt(x)

produces the following output

  o ⊗ x = x o
  a a x x = x a
  ∞ × = x o
  a a × = x a
  a c + sin x + x √x + sin √x + sin √x

Its handling of commas looks even worse, but it's tricky to demonstrate that in plain text.

[0]: https://tug.org/TUGboat/tb36-2/tb113hagen.pdf#page=3

[1]: https://github.com/contextgarden/context/blob/e9bd55ec/tex/c...

Why is the space handling "especially problematic"? It has significant whitespace, that shouldn't be problematic, should it?

> It has significant whitespace, that shouldn't be problematic, should it?

Significant whitespace is totally fine, but whitespace that is sometimes significant and sometimes not isn't. In the examples above, "sinsqrtx" produces the same output as "sin sqrt x", but "ooxx", "o ox x", and "o o x x" all produce completely different output.

I don't buy this argument. Sometimes something has a unique way of being interpreted, then you don't need spaces. It's the same with math and code.

2x+3=(2x)+3 != 2(x+3)

Parentheses are also "sometimes significant and sometimes not".

The problem is with the stream of alphanumeric symbols. Most languages treat sqrtx as a single token, but asciimath treats it as two (sqrt and x) if you put a symbol in between them (sqrt+x) most languages treats it as three tokens (sqrt, +, x) and asciimath is no different.

asciimath’s choice here is to make whitespace (sometimes) optional between two subsequent alphanumeric tokens, and it is a rather odd choice. I‘m not sure which other language (markup or otherwise) does it this way.

> the only robust way to edit \ASCIIMATH\ is to use a \WYSIWYG\ editor and hope that the parser doesn't change ever.

Ouch. I wrote a couple of parsers when I was young and foolish without trying to specify the grammar, and it’s a good thing they didn’t get popular, because every bugfix changed the syntax and broke texts that had been working before.

Shameless plug (again): This is one of the issues I addressed when I wrote the competing mathup library.

alphanumeric tokens MUST be separated from each other with a symbol or whitespace.

    ooxx => ooxx
    oo xx => ∞×
    sqrtx => sqrtx
    sqrt x => √x
    sqrt(x) => √x

The way I deal with commas is that I always treat commas as an operator (or a seperator in group context), unless the author configures comma to be the decimal mark (and I only allow exactly one decimal mark for each parse run).

https://mathup.xyz

I use Typst a lot now (which this reminds me of), and the equation support is generally very good, but the thing that gives me pause is that I'm afraid that there's going to be something missing, or worse than the LaTeX equivalent.

LaTeX has been the industry standard for the mathematical world for decades and as a result it has had the most work adding new notation or making nicer formatting.

For example, I needed to do a proof tree recently. Typically I would use bussproofs in LaTeX but I was using Typst, and while there is a package for handling proof trees in Typst [1], I think they're not very pretty, and as a result I ended up porting the document over to Pandoc markdown and doing the rest of my work there (which is annoying because Typst renders around ~1000x faster and has better tooling).

[1] https://github.com/SkiFire13/typst-prooftree

I remember using curryst for my proof trees (a few months ago) and they looked fine if I recall correctly. But I agree that often using typst means searching for package that may not exist or is not working correctly since the ecosystem is not very mature currently.

Hadn't seen curryst. Looking at the examples it looks ok. Maybe I should have used that and stuck with Typst.

One could just use the math fragment of typst, no?

https://typerino.com/

Shameless plug: I made a competing library to asciimath called mathup

https://mathup.xyz

Nice! I was confused about your "Why AsciiMath" section, which doesn't say anything about AsciiMath. It's also unclear to me what the difference is between Mathup and AsciiMath - you write that Mathup is inspired by it but it's not clear to me what made you invent something else - i assume AsciiMath has flaws that you're addressing? Would be worth writing down I suppose.

I see this is confusing, this segment I wrote a long time ago and I felt I had to justify why I chose to write an asciimath dialog instead of just picking LaTeX (and doing what Temml did years later).

I suppose I should change the title to say “Why an AsciiMath Dialog” and then add another subsection “Why not AsciiMath”.

The short answer is that AsciiMath is an excellent language IMO but a rather lacking implementation. Shortcomings of this particular dialog are raised in a different thread here, but for me personally the biggest issue was in the output format. AsciiMath is pretty tightly integrated into each implementation (like MathJax) instead of just outputting standard MathML. I also altered the dialog a bit, e.g. the matrix notation is a bit different in mathup, and I also add the possibility to use whitespace to group sub-expressions (similar to typist).

I don’t understand what you mean with “Dialog”. This is a language right? And not a UI?

Sorry, meant to say dialect. I have confused these two words before, haha.

Yes, why did you make this if asciimath exists? Not to say that you shouldn't have made it, but what does it do that asciimath doesn't in your view? Just curious to understand

The main difference is in the output. AsciiMath is tightly integrated into each tool (e.g. mathjax), while mathup simply outputs standard MathML.

There are also small differences in the language, main one being the use of whitespace to group expressions in mathup (similar [but not identical] to typist).

I'm a big fan of AsciiMath and have been supporting it in my note taking program (MicroPad) since ~2016.

It was the key for me being able to write maths in a classroom/lecture theatre at the same speed (or faster) than those doing it by hand.

The amount of effort we are putting into transcribing doodles into pixel accurate text is astonishing. In my undergrad days I loved LaTeX and friends because it let me convert my notes to digital paper and websites without having to change how I thought.

Now that I'm older and wiser I think the whole thing is a waste of time and a perfect example of cargo culting. The current maths notation was largely invented by Euler so he could write to his contemporaries with parchment and quill, e.g. https://www.themorgan.org/blog/all-math-nerds-out-there

That we are still using his notation three centuries later on computers is both astonishing and saddening.

It's much better to use a sane and consistent notation that can be entered as ascii in the first place (or Unicode if you hate long names), viz. s-expressions.

    | TeX          | S-Expression                  |
    |--------------+-------------------------------|
    | 1 + 2        | (+ 1 2)                       |
    | 1 - 2        | (- 1 2)                       |
    | 1 \times 2   | (* 1 2)                       |
    | frac{1}{2}   | (/ 1 2)                       |
    | a_i          | (map a (range 0 n))           |
    | \sum_i a_i   | (apply + (map a (range 0 n))) |
    | \int x^2, dx | (integrate '(expt x 2) 'x)    |

Not only are the expressions consistent between all the normal mathematical operators, they force you to think about what you're doing. E.g. a sequence is a function from the nats to whatever objects you are enumerating and an indefinite integral is a symbolic operation - not a numerical one like the definite integral - both of those are something that everyone is aware of, the same way they are aware of a "Wet Paint" sign on a bench before they sit down.

Instead of the computer serving the user, this is a glaring example of forcing the user to serve the computer.

Even though we might use a digital device, its output is still visual, so it is unclear why Euler's notation (which is a subset of mathematical notation) is obsolete. Latex is a tool for creating documents, not programs or proofs. So it's natural that it tries to make the conversion between what we want to see and what we want to write as seamless as possible.

Changing to a better notation is no more humans serving computers than replacing Roman numerals with Arabic ones was humans serving parchment and ink.

In both cases a superior system was held back by people too used to an inferior one to understand why they need something better.

I'm still waiting for an explanation about how this would be superior when writing math documents

Here is a rather nice video that explains just how bad maths notation is at describing maths operations without a mountain of implicit assumptions about what each expression means: https://m.youtube.com/watch?v=iqlxsSrd-M4

This does not answer my question. For the third time, we are talking about writing a document, not doing maths. At this point I just think you're being obtuse

If you aren't doing maths when you're writing or reading a maths document I have no idea what you're doing, but you sure as hell aren't reading it in any sense a mathematician would recognise.

TeX is a typesetting system and not interested in semantics; AM is similar but simpler format meant for more casual use and to be quite readable even when not typesetted. What you're describing is essentially a computer algebra system. There's some overlap but they're different things.

That said, your system kinda exists already (and has been for decades). Mathematica can be written fully in M-Expressions (given any expression can recover the M-Exp with `FullForm[HoldForm[...]]`) and can convert to TeX (given any expression with `TeXForm[HoldForm[...]]`) for each if you want.

    | TeX          | M-Expression                      |
    |--------------+-----------------------------------|
    | 1 + 2        | Plus[1, 2]                        |
    | 1 - 2        | Plus[-1, 2]                       |
    | 1 \times 2   | Times[1, 2]                       |
    | frac{1}{2}   | Times[2, Power[2, -1]]            |
    | a_i          | Map[a, Range[0, n]]               | (* or better: a[i] *)
    | \sum_i a_i   | Apply[Plus, Map[a, Range[0, n]]]  | (* or better: Sum[a[i], i] *)
    | \int x^2, dx | Integrate[Power[x, 2], x]]]       |

Interestingly (didn't know it myself either) internally notation is even simpler than your described system as you can see by minus/frac examples. Note that `a_i` examples can exist in indefinite form, which is why the commented forms are more correct given no other context.

There's also Emmy which is a vastly expanded port of scmutils (from SICM) embedded in Clojure but haven't used it much. Being embedded in Clojure, uses sexps and, when used in Clerk environment, can render to TeX.

While you're right about Tex, that was more a critique of LaTeX, which is the only language that understands how to typeset everything after the '- in the table.

As for m-expressions they also came from lisp, but were abandoned because s-expressions had so much more expressional power, since they were composable as expressions and as code.

If you like this, check out typst https://typst.app

What exactly is the distinction between this and mathjax? At first glance it looks like this is a wrapper on top of mathjax, or is it something different?

I guess it’s just more “natural” and less latex like.

$$\sum_{i=0}^n i^2 = \frac{(n)}{2}$$

sum_(i=o)^n i^2=((n)/2)

asciimath does a lot of things automatically, like parenthesis sizing and auto-frac, that latex requires you to do yourself. \left and \right and \frac do add quite a bit of noise to simple equations.

Neat. Personally, I wasn't aware of mathjax, it's a bit of a revelation to learn you can do this. I like very much the fact that the ASCII side is highly readable - compared to say, LaTeX (to me, anyway!) - as something I could use in code comments.

I use Unicode to type math, which is the closest you can get in plain text to what you see in the rendered output. The latex package unicodemath is amazing. As a bonus you can paste the code in chat applications when communicating with peers.

This works surprisingly well. If you look into enough dark corners of Unicode, it turns out that you can do a shocking amount of typography, going far beyond the obvious italics and bolds: https://gwern.net/utext

In fact, I found that writing as much math as possible in Unicode makes for the best HTML reading experience: it's fast, simple, and looks more natural (avoids font inconsistency and line-height jagginess, among other things). https://gwern.net/design-graveyard#mathjax

And if you find writing Unicode yourself a pain, you can just ask a LLM to translate from LaTeX to Unicode! https://github.com/gwern/gwern.net/blob/master/build/latex2u...

Regarding typing latex vs unicode, I use WinCompose/XCompose with a list of bindings that include most latex symbols. So instead of \cup I'd type <compose>cup

For reference, here is my personal (still evolving) .XCompose https://github.com/chtenb/dotfiles/blob/master/.XCompose

I actually confused AsciiMath with UnicodeMath[0]. Interesting that this hasn't been mentioned here yet. Check out its playground[1].

[0]: https://www.unicode.org/notes/tn28/UTN28-PlainTextMath-v3.1....

[1]: https://murrayiii.github.io/UnicodeMathML/playground/

> While HTML5 now includes MathML as an official recommendation, the remaining browsers do not appear to be implementing it

Who are the "remaining browsers" here? caniuse suggests support across all the usual suspects (albeit I think some implementations leave a lot to be desired on the formatting end of things)

Answer: this page is ancient and unmaintained. That line’s from late 2017. Chromium only shipped its implementation in early 2023, and back then you also had EdgeHTML to consider.

Wayback Machine investigation: from the first capture in https://web.archive.org/web/20141227061758/http://asciimath.... until https://web.archive.org/web/20171213211317/http://asciimath...., that line read:

> As HTML5 including MathML has currently become an official recommendation, the remaining browsers are likely to follow with first implementations soon!

Then, finally accepting that Google did not intend to support MathML, by https://web.archive.org/web/20171113100326/http://asciimath...., they changed it to what you read today:

> While HTML5 now includes MathML as an official recommendation, the remaining browsers do not appear to be implementing it. For widest browser compatibility, the use of MathJax is recommended.

Since then, Edge has abandoned its own engine in favour of Chromium, and Igalia has driven MathML with the end result of MathML Core (a reduced and better-specified subset of MathML) and an implementation in Chromium.

What strange choices. For example, to express the sum from i=1 to n:

    sum_(i=1)^n

Why use the exponent sign to indicate the upper limit? Am I taking crazy pills here?

How about using some symmetry instead, e.g.

    sum(i=1)(n)    "Means: sum from i=1 to n"

That's because the positioning of n is similar to that of exponent? As author says, this is more about expressing "visual rendering" using the text. Hence the term "ASCII math" like in ASCII Art.

I think the real answer is "because LaTeX does it that way and everybody inventing their own fancy math syntax used a lot of LaTeX".

> Why use the exponent sign to indicate the upper limit?

The caret is used to indicate the upper limit for the same reason some programming languages use it as the exponentiation operator (other programming languages may use something else, like **, neither is normally how exponentiation is “normally”, outside of programming and its historic limitation to ASCII characters, indicated), because its upward-pointing character is a considered a way of suggesting that the following number should be thought of as presented raised from the normal baseline, which is (in somewhat different ways) true of both exponents and upper limits in summation (this is the mirroelr image of why _ is used for the lower limit.)

^ is not the symbol of exponentiation but the symbol of superscript, just like _ is the symbol of subscript.

I really like typst's [1] syntax, personally. I can't wait for their html rendering to be stable.

[1]: https://github.com/typst/typst

It's too bad MathML never supported ASCII math. The web might be a different place if it did.

Asciidoctor renders AsciiMath to MathML [1], I imagine that it's a fairly common target after MathML (Core) was revived from the dead. While MathML is pretty verbose to write by hand, I think things like AsciiMath and LaTeX are on a different level of abstraction. You can't embed AsciiMath directly in HTML in the same way that you can't embed Markdown directly in HTML.

1. https://docs.asciidoctor.org/asciidoctor/latest/stem/asciima...

XML as a standard has a concept of "notations": you can specify that contents of an element are written in such-and-such notation, which can be "asciimath" too. Of course at the XML level these are merely labels; you still need to agree on notation names and make the processors of that document to understand that notation. But as a foundation it is there.

So technically a web could indeed be a different place: a network of XML documents where all the original notations are kept as they are and merely marked with tags that formally specify: this is AsciiMath, this is C, this is SQL, and so on.

    AAccAltccBinbbbR,cc|A|ltoo

It's not exactly easy to read, is it?

This is cool. I could see myself using this for notes.

You can use it with AsciiDoc readily, if you use that [1]. With anything you could also use MathML in an HTML-passthrough block, but it's pretty verbose.

1. https://docs.asciidoctor.org/asciidoctor/latest/stem/asciima...

-> GsciiMath

Great! Another LaTeX competitor, doubtless "better" for an obscure reason known only to its author. Especially appealing is the fact that, when embedded in a Web page, it must be translated into LaTeX syntax before rendering by MathJax.

The "AsciiMath" name reveals volumes, because prior to rendering, LaTeX code is already ASCII characters meant to represent math symbols. We just didn't call it that.

Oh well, a tempest in a teapot, soon to be forgotten. We can already tell a chatbot, "Show me the tensor equations of General Relativity, and render the result in LaTeX."

I close with the obligatory XKCD reference: https://xkcd.com/927/

>for an obscure reason known only to its author

It's, in project's words, simple calculator-style syntax (can also call it simplified LaTeX subset or that ad hoc math syntax used in emails but standardized) made to easily embed math on web pages by converting to MathML, with its existence predating MathJax by few years (and even MathJax's predecessor, jsMath). It was never meant to be LaTeX competitor.

With last point, have noticed people most often use this xkcd strip opposite to what it means. It's about when, for a particular use case, one standard/tech/whatever tries to replace all others rather when one standard/tech/whatever attempts to fulfill a distinct use case.

Not having to write \left and \right everywhere doesn’t seem like an obscure reason…

Why does it make you angry when people make things? Making things is good! You should try it!

The failure to understand what is Ascii means in this math along with a meme comic as a substitute for critical evaluation reveals even more:

> LaTeX code is already ASCII characters meant to represent math symbols

Not really, it's long \escaped \English \words that are made of ascii symbols, a difference clear if you just look at the comparison table

$3\times4$

vs 3 xx 4

Reply on news.ycombinator.com