The Two-Button Calculator

One operator rebuilds every function on the keypad, and then the trouble starts.

Here is a scientific calculator with the sine button removed. Not disabled, removed: there is no code anywhere in the machine that knows what a sine is. Press the key labelled sin and it will still answer, correctly, to about fifteen decimal places. It gets there by evaluating a single two-input formula, exp(x) − ln(y), three hundred and ninety-nine times.

In March 2026 Andrzej Odrzywołek, a theoretical physicist at the Jagiellonian University in Kraków, posted a preprint claiming that this one operator generates all of them.¹ Not approximates. Generates: every function in the list is a finite composition of copies of eml(x, y) = exp(x) − ln(y) applied to itself and to the constant 1. He called it a Sheffer operator, after the single logic gate that generates all of Boolean algebra.

Then it sat there for three weeks. The earliest discussion of it I can find anywhere is 13 April, and on that day all of it happened at once. Eight hundred and fifty-eight points on Hacker News.⁹ A Wikipedia article by the evening. Coverage in The Register the next morning, filed under offbeat.¹³ A YouTube explainer that eventually reached more people than every comment thread about it combined.¹⁴

Three weeks later the Wikipedia article was deleted.

Both of those things are correct responses to this paper, which is what makes it worth an hour of your attention. The construction is real, it is checkable, and you can watch it happen below. The claim wrapped around the construction is smaller than the title suggests, the author says so himself in his own supplementary material, and the arithmetic that carries it out breaks in at least four separate and genuinely different ways, one of which nobody had noticed until I went looking.

So: the operator, built from nothing. Then why one gate can possibly be enough, which turns out to be an old and rather beautiful piece of algebra, and how anybody found it in the first place. Then what it costs, which is the part the headlines skipped. Then where the arithmetic breaks, in three places and four different ways. Then the half of the paper almost nobody read, where the author tries to find operators like this one by gradient descent and mostly fails. Then what the thing cannot do at all, including a specific number it can never name. Then whether any of this is new, which takes three separate literatures to settle, and the one serious mathematical objection anybody raised. Then how it landed, and why, and the quieter ending the author wrote for himself. And at the end, my own analysis, plus a ledger of the forty-seven times I got this wrong while writing it.

Two symbols and a one

Take a machine that knows exactly two things. It knows the number 1, and it knows how to compute eml(x, y) = exp(x) − ln(y). That is the whole machine. There is no addition, no multiplication, no negation, no zero.

The first move is forced, because there is only one thing to do: feed the machine its own leaf, twice.

That is the entire trick and it is worth being precise about why it works. The operator has an exponential on one side and a logarithm on the other, and they are inverse to each other. Nest one inside the other and they annihilate, leaving behind whatever was riding along. Everything the machine can do comes from arranging that annihilation so it leaves the right passenger behind.

Once you have ln, the rest cascades. eml(x, 1) = exp(x), three symbols, because ln 1 is zero. eml(1, 1) = e. Feed ln into the log slot of something and you get quotients; feed exp into the exp slot and you get products. The author's supplementary information lists a chain of thirty-two such steps that walks from the bare constant 1 all the way out to arctan, and every function on the keypad falls out along the way.¹

Here is a small one you can check by hand, from an independent follow-up by Mark Carney which happens to contain the shortest known formulas for the basics. E below is just eml, written short so the nesting stays readable:⁴

I checked all seven of Carney's formulas symbolically, and then I did something he did not: I enumerated every possible tree up to nineteen symbols, all two hundred and nine million of them, to find out whether anything shorter existed. Nothing does. All seven are exactly optimal.²² Carney claimed nothing about optimality and turns out to have hit it seven times out of seven, which tells you something about how tightly this grammar constrains what can be written in it.

Note the third line. Zero costs seven symbols. There is no zero in this system; you have to build one, and the cheapest way to do it is to take the logarithm of one. Zero is the sore point of this whole construction, and it keeps coming back: once as a discount, once as a pole, and once as the reason the one theorem people want to use against this operator does not apply to it.

Why one gate can be enough

The natural suspicion, on first contact, is that this is a trick. Something has been smuggled in.

Nothing has, and the reason is older than the paper. Two weeks after the thread that made the paper famous, Tomasz Stachowiak published a two-page note that explains the whole family in one line.³ Take any function f that is invertible, and any operation M that behaves like addition. Then

is a generator, for structural reasons that have nothing to do with exponentials. eml is the case f = exp, M = subtraction. What makes it work is not the exponential. It is that f and f⁻¹ sit on opposite sides of a group operation, so composing the gate with itself lets you slide freely between the two coordinate systems.

That sounds abstract. It is completely concrete, and you can watch it.

Stachowiak proves something sharper than "there are others." He shows that behind every valid M there is an abelian group: a set with an addition-like operation where the order of the two operands does not matter. Subtraction is what you actually see, and subtraction is famously not symmetric, but the group underneath it is. He also shows that step three of his universal chain has Polish length seven for any choice of f. The seven-symbol tree for ln that we built above, which looks like a discovery about logarithms, is not about logarithms at all. It is a structural constant of the construction. Any generator of this shape pays seven for its third step.

The author knew eml was not unique. His own supplementary information lists four rival five-symbol candidates, including eˣ / ln y and ln y / eˣ.¹ He proposes all four as complete generators and verifies none of them: his own disclaimer calls them unverified candidates from a numerical sieve. So I ran all four through the same exhaustive enumerator. Two of them rebuild all six of the primitives I checked closely, zero, one, e, exp, ln and division, inside fifteen symbols. A third misses only zero. The fourth reached two of the eight targets I priced across all five gates, which is my search running out of room rather than evidence against it. None of the four reaches all eight inside fifteen symbols, and neither does eml itself. But the price list rearranges completely. eml buys exp for three symbols and pays seven for ln and seven for zero. Its mirror image, ln y / eˣ, which I will write LDE, buys zero for three and ln for five, and pays nine for exp. You can verify the cheap end of that by hand: LDE(1, 1) = ln 1 / e = 0, and then LDE(0, y) = ln y.

Which is the real lesson of the whole non-uniqueness question. On the author's account all of these reach the same place. What changes, and changes completely, is what everything costs to get there.

One negative result tells you more than all of those alternatives put together. The author also searched for a generator with no constant at all, one binary operation and nothing else. He found nothing. NAND needs no constants; eml needs its 1, and cannot be rescued from that.¹

How anybody found this

The discovery method is the most charming part of the paper and it is barely mentioned in the coverage.

The author enumerated integers. He printed each integer in base 36, and treated its digits as a program in reverse Polish notation, where each of the thirty-six digits 0 through z maps to one entry on the keypad. Then he ran the program. The choice of thirty-six is not aesthetic; it is the largest radix the C standard library's strtol accepts.¹ The contents of the keypad came from ISO 80000-2 and <math.h>, which is why there is no secant or cosecant, and why the logistic sigmoid, a function that belongs to machine learning rather than to trigonometry, is sitting there on the pad already.

Then the ablation: remove buttons, re-run the search, see what still reconstructs. Keep going until removing anything else breaks the calculator. The paper's own summary of the endpoint is worth quoting exactly, because it is more careful than its title:

two buttons are sufficient... No further reduction of operator count is possible.

Two buttons: the operator, and the 1. And the reason it stops there rather than at one is stated as a limitation, not a theorem. "The continuous Sheffer operator, if it exists, is not among the familiar named functions."

The pattern that emerged from the ablation is the useful part. Every minimal configuration involves a pair of inverse functions and a non-commutative operation. That is Stachowiak's theorem, arrived at empirically, five weeks before Stachowiak proved it.

The search itself was not easy, and the author names the hard step directly. It is the one we just built. Reconstructing ln was "the first non-trivial reconstruction and the hardest single step," and he offers it as his explanation for why nobody found this earlier. The original search ran in Mathematica and took forty minutes; a port to Rust, which the author had GPT Codex 5.3 translate for him, brought it to about four seconds.²

The bill

Now the part that got left out of every summary.

The construction is exact and the construction is enormous. Sine is three hundred and ninety-nine applications of the operator. tan is five hundred and ninety-one. Every one of them is a floating-point exponential or logarithm, and every one rounds.

The −∞ discount is my own result and I want to be clear about what it is. The author's supplementary information asks, as open question seven, whether the extended reals change the minimum tree sizes. They do, by exactly two symbols, for exactly four targets, and for a reason you can state in one sentence. A reader on Reddit noticed the phenomenon within two days of publication.¹¹ The exact price had not been computed anywhere I could find.

There is a trap in doing this kind of enumeration that cost me two full runs, and it generalises. The obvious optimisation is to keep a table of subtree values and throw away duplicates. This is unsound in eml. At fifteen symbols my table held five hundred and seventy-six distinct expressions agreeing with −ln x to eleven significant digits, and not one of them was −ln x. The genuine construction had been deleted as a duplicate of an impostor. There is no substitute for full enumeration with a symbolic gate.

Where the arithmetic breaks, one: the answer near one

Everything above is exact mathematics. Now the floating point, which is a different subject with a different answer.

eml computes ln x as e − ln(e^e / x). The final subtraction is from a quantity pinned near e. That is a fixed absolute scale, and a fixed absolute scale is fatal wherever the answer goes to zero. The logarithm goes to zero at x = 1.

I want to be careful about how this is stated, because I got it wrong three times in a row while writing this and the wrong versions were all more quotable than the right one.

The first version was that half a ULP of e, about 2.22 × 10⁻¹⁶, is a hard ceiling on the absolute error. False: measured against sixty-digit arithmetic rather than against the library's own answer, the error exceeds it in about seven percent of arguments on (1, 2]. The second version was that it is a hard floor. Also false: over the wider range (1, 20], almost ninety-nine percent of arguments are below it, and the smallest I measured was 1.5 × 10⁻²¹.

The third version finally got the shape right and the formula wrong. The object is not a bound at all, it is a grid, and I wrote its spacing as ULP(e − ln x), the spacing of the subtraction the reduction ends on. That is right wherever the subtraction is the coarser of the two steps and wrong wherever ln x is, because an answer cannot be quantised more finely than its own grid. At x = 7 it predicts a step of 1.11 × 10⁻¹⁶ and the measured step is twice that.

The correct object is that same grid with the right spacing. The reduction's output can only land on a lattice, and how coarse that lattice is depends on where you are standing. At x = 1.5 its possible answers sit eight of the host's last-place units apart, so seven of every eight representable results are unreachable. At x = 2 the gap is four. At x = 3 it is one: the reduction resolves the answer exactly as finely as the host's own logarithm does, and the defect vanishes entirely.

One formula covers all three. The spacing of that lattice is

which is max(r, 1) times the host's own grid, where r is the ratio of the two. Verified at twelve hundred of twelve hundred randomized windows on (1, 20], spanning twenty different values of that ratio.

That the defect vanishes entirely at x = 3 is a materially more favourable statement about the paper than the two bounds it replaces. The loss is real, it is unbounded as x → 1, and it closes at x = e, where ln x finally reaches one and its own spacing doubles to match the grid it is being subtracted from. It does not stay closed, but what comes back is a different defect, and the formula survives it. The formula bounds the gap between the answers that appear, not how many of them appear. Above x = e^(e−1) ≈ 5.57 the subtraction runs on a finer grid than the answer's own, so two neighbouring internal values can round to the same output and the answer in between is simply never produced. Those are holes punched in a correctly spaced lattice, not evidence of a coarser one: the smallest gap is still exactly one of the host's last-place units, but at x = 7 only about three quarters of them are ever reached. At x = e² ≈ 7.39 full coverage returns for good. Which is why the honest way to quote this is as a ratio: at 1 + 10⁻⁸ the reconstruction's relative error is about 3.4 × 10⁷ times the host's, seven and a half decades, and at x = 3 it is one.

The reusable lesson, and I paid for it: never measure floating-point error as computed − library_result when both are doubles. Their difference is by construction a multiple of the last-place unit, so the measurement is structurally blind to the rounding inside the library call, which is exactly the term that breaks the bound. Always reference a high-precision value.

Where the arithmetic breaks, two: two times three

In late July 2026, four months after the paper, a commenter on the original Hacker News thread posted a small table.⁹ They had implemented eml in six languages and tabulated 2 × 3 in five of them.

Node.js and Go returned exactly 6. Python, PHP and Rust returned 6.000000000000001. That is the shortest decimal that picks out the double sitting one unit above six; printed to its full seventeen digits, as the figure below prints it, the same number reads 6.0000000000000009.

The mechanism is worth naming because it explains the split without any appeal to luck. V8 and Go both use a software logarithm derived from Sun's FDLIBM, from 1993. Go's port states the guarantee outright in its source: "the error is always less than 1 ulp." That is explicitly weaker than correct rounding, which promises half a unit. Python, PHP and Rust call the platform's own math library, which on modern systems is correctly rounded at these arguments. The split is not language against language. It is one 1993 algorithm against everybody else, and it happens to produce a value that makes one famous example look right.²²

I have not measured Go. The mechanism predicts that Go's math.Log(3) returns the same bit pattern as V8's, 3ff193ea7aad030a, and one run would settle it.

There is one more thing in this figure worth pausing on, because it is the control that the original thread did not run. Over the forty-five distinct pairs from two to ten, the ordinary route exp(ln a + ln b) is inexact in thirty-four of them, and eml in thirty-six, and thirty-one of those miss by exactly the same amount, including the worst case. The scatter in that table is not eml's scatter. It is ordinary floating-point multiplication's scatter, and eml is barely making it worse. The place eml genuinely fails is the previous section, not this one.

Where the arithmetic breaks, three: the chain that verifies pairwise

The supplementary information ships a chain of thirty-two steps, each one building a new function out of functions already built. Each step comes with a witness expression, and the author's Rust verifier checks each witness against the host's own built-in.

Every step passes. I transcribed all thirty-two and evaluated them at twenty-five digits, and they pass.

That is not the same thing as the chain being correct, and step twenty-eight is where the difference shows.

Then the question of why nobody caught it, which I answered by reading the verifier's Rust source rather than guessing.² For every unary function the guard evaluates the target and skips any sample whose target is not real:

For arcosh, six of the eight probe constants are less than one, so arcosh of them is complex, so those six samples are discarded before any comparison happens. The two survivors are Glaisher's constant at 1.2824 and Khinchin's at 2.6854, the only two anchors greater than one, which is precisely the half-line on which arcosh is real. And four of the eight probes are negative, which is exactly where the witness fails. Every one of those four was thrown away before the subtraction. The safeguard never performed it.

Worse, the author shipped a stricter validator that would have caught it. validate_witness_highprec defaults to false, and validate_witness itself only runs under --explain. The check that missed the defect was doubly opt-in, and the check that would have found it was switched off.

None of this refutes the theorem. arcosh is reachable, and a correct witness is buildable from primitives available fifteen steps earlier. It does not refute the supplement's own reassurance about principal branches either, and being precise about that makes the finding sharper rather than weaker: that sentence quantifies over candidates the search rejected and replaced, and step twenty-eight was never flagged, so it sits outside the sentence entirely. The reassurance is true as written, and a witness that is wrong on half the real line is sitting in the published chain anyway, because the check that would have caught it threw its evidence away first. Which is the general lesson, and it has nothing to do with this paper: verifying every link is not verifying the chain.

For completeness, the four failures I promised, because they are genuinely different and it would be easy to lump them into one. Only two of them live in the three sections just past. The other two turned up earlier, one in the figure that built the logarithm and one in the price list. The first is a branch cut: the logarithm construction returns Log(z) − 2πi on the negative reals, and, as that figure shows, double precision then hides the break by landing on the other side of the cut and cancelling it exactly. The second is a pole: the logarithm has no value at zero, so any tree that routes a zero into a log slot leaves the reals entirely. It is the only one of the four that the construction ever turns to its advantage, and it does that twice, once as the −∞ pricing above and once as the technicality that keeps eml outside Buck's theorem below. The third is the resolution loss near x = 1, which is not a branch problem at all but an argument-reduction problem. The fourth is step twenty-eight's parity loss from squaring, which involves no logarithm whatsoever.

And a fifth that is really the first wearing a disguise. Step thirty, artanh, fails on the entire region |x| > 1, and its published score of thirteen out of seventeen is a precision artifact: the negative ray passes by accident, because a rounding residue of order 10⁻³¹ happens to push the evaluation onto the correct side of a branch cut. Chop that residue to its true value of zero and the whole ray fails. Test at fifteen digits, or fifty, or five hundred, and it fails; test at twenty, or thirty, or a hundred, and it passes. The precision-independent score is nine out of seventeen. Step twenty-eight is a bug you can see. Step thirty is a bug whose test result depends on what precision you tested it at.

The half nobody read

Sections one through four of the paper are the construction. Section five is something else entirely, and in the eight hundred and fifty-eight point Hacker News thread with two hundred and ninety-eight comments, exactly one comment engages with it.⁹

The author asks: could you find an operator like eml by gradient descent? Take a binary tree of gates. Make every input to every gate a soft, learnable mixture of the available quantities through a softmax. Train it on a target function. Then anneal the temperature to zero, so the mixtures harden into choices, and read off a discrete expression tree.

It is a good idea, the relaxation is complete by construction in the sense that every discrete tree is a vertex of the continuous space, and it mostly does not work.

Look at what the snap does to the other three runs and the picture completes itself. The depth-four success goes from 1.9e-16 to 1.9e-16, unchanged. The depth-six failure goes from 0.47 to 0.45, which is nineteen thousandths of a decade. The warm-started run goes from 9.1e-16 to 9.8e-16, which is worse. Only one run jumps, and it jumps thirteen and a half decades. An optimisation stage would have improved all four.

What is really happening is that at the exact instant the mixtures collapse to choices, the expression either happens to be the right one or it does not, and the continuous loss beforehand carries almost no information about which. This is not a criticism unique to this paper. An independent follow-up trying the same relaxation on a generalised version of the operator found at most seven of forty-two parameters snappable and zero atoms discrete.¹⁷

One caveat I have to state, because I nearly published the opposite. The per-strategy spread at depth four looks like a ranking of initialisation schemes. It is not. A chi-squared test puts the chance of seeing a spread that wide from four schemes that are genuinely identical at about two in five, p = 0.384. The apparent ranking is noise, and there is no evidence any strategy beats any other.

The number it cannot name

So far every limit has been about cost or precision. Here is a limit that is absolute.

The set of numbers eml can write down, using closed terms over the single leaf 1, is countable: you could in principle stand them in a queue and number them off, one, two, three, forever. That much is obvious, because there are finitely many symbols and so only countably many strings to make out of them. Carney's follow-up proves something much more precise: the set is exactly Timothy Chow's class 𝔼 of exponential-logarithmic numbers, defined in 1999.^{4 5} Not contained in, not approximately: equal.

The corollary everyone quoted is that the numbers eml cannot express have full measure. Which is a way of saying that if you could throw a dart at the number line, you would miss the reachable set with probability one. Almost every real number is unnameable here, and it is worth sitting with how weak a statement that actually is: almost every real number is unnameable by any notation, because notations are countable and the reals are not.

That corollary is the cheap half. Chow observed the countability himself in 1999 and the measure statement follows from it in one line. The result that carries the weight is the equality, and a summary that leads with the measure credits the wrong theorem.

The equality buys you something specific: you can now point at a particular number and say why.

One caveat has to travel with that, and it is not a small one. The argument leans on Schanuel's conjecture, which is the central open problem about how exponentials and logarithms are allowed to conspire. Informally it says there are no coincidences: take numbers that are independent in the simplest possible sense, meaning no whole-number combination of them adds up to zero, and then those numbers together with their exponentials satisfy no surprise algebraic relation either. Almost every hard question about transcendence would fall out of it. Nobody can prove it. So what follows is a very strong hint, not a theorem, and I would rather say that twice than once.

Two traps in that argument, both of which I fell into.

W(1) is unconditionally transcendental, by a one-line Hermite-Lindemann argument, and that fact is completely irrelevant. e and π are transcendental too and both are in 𝔼. Transcendence is not the obstruction; the Schanuel conditional is doing all the work and must stay in the caption. And the claim has to be scoped to closed terms over {1}. A free variable defeats it trivially: eml can obviously produce −W(1) if you are allowed to hand it −W(1).

There is a nice asymmetry hiding here too. Chow builds 𝔼 starting from {0}. eml starts from 1 and pays seven symbols to manufacture a zero. Same class, different entry fee.

Is any of this new?

The strongest objection to the paper is not that it is wrong. It is that it might be trivial, and there are three separate literatures that could make it so. I went through all three.

Set functions. Martin Goldstern has a one-page note, dated September 2010 and never published, proving that for any countably many operations on any infinite set, a single binary generator exists.⁷ The finite case is Webb, in PNAS, in 1935. So existence is free and it is ninety-one years old. But Goldstern's generator is a piecewise counting gadget requiring unbounded nesting. eml is analytic, two operations long, and reaches the whole calculator in a few dozen symbols. The theorem also needs the family being generated to be countable, which is satisfied here because the keypad is finite, and it does not include constants in the generated clone whereas eml needs its 1.

Continuous functions. A nomographic function has the shape outer(inner₁(x) + inner₂(y)): bend each input, add them, bend the result back. eml has exactly that shape. And R.C. Buck, in Proceedings of the AMS in 1982, proved that functions of this shape are nowhere dense among the continuous functions on a cube.⁸ Nowhere dense is a much stronger statement than "not all of them". It says you cannot even get arbitrarily close: pick the wrong target and there is a gap you cannot shrink, however you tune the three components.

That reads like a death sentence for the whole programme. It is not one, for two separate reasons.

The first is that eml is not in Buck's class. He requires every component to be continuous on all of ℝ, and −ln is not, because it falls off a cliff at zero. The same ln 0 that bought four targets a two-symbol discount in the pricing section also puts the operator outside the literal hypothesis of the theorem people want to use against it.

The second is that Buck constrains one application, and this paper is about compositions of hundreds. Buck pre-empts the inference himself, on page 195: "This does not conflict with the Kolmogorov result; for example, [0,1] is the algebraic sum of two copies of a nowhere dense subset E." The Kolmogorov result he means is from 1957, and it says every continuous function of n variables is a sum of at most 2n + 1 nomographic ones. So inside Buck's own paper the individually rare objects are collectively universal. Being topologically tiny and being enough to build everything are routinely both true at once, which is precisely the inference a reader is tempted to draw from his title and should not.

Buck's real contribution here is a lineage. His reference list is Hilbert's thirteenth problem end to end: Kolmogorov, Arnol'd, Vitushkin, Fridman, Henkin, Sprecher. One two-place operation, composed, is enough is not a new thought. It is close to the oldest thought in this corner of analysis, it has been continuously worked on since 1957, and the machine-learning follow-ups to this paper are walking back into that same room through the opposite door without mentioning that anyone was already in it.

Closed-form elementary functions. Which is the actual claim, and here I have to be careful, because the tidy version of this frame is wrong and I wrote it before I caught it. It is not that neither result applies. Goldstern's does apply, outright: the keypad is finite, so his hypothesis is satisfied and a binary generator provably exists before anybody goes looking. And Buck's says nothing at all about approximation power, only about a single application. What neither result answers is whether a generator that is natural and cheap exists. That is the question this paper is actually about.

That three-row frame is the honest summary of the novelty question. Existence in general is old and settled. Topological density is a different question with a different answer. What is new is the exhibition of a specific, recognisable, analytic generator with small trees. Whether that is worth a paper is a matter of taste. It is not a matter of priority.

One correction on vocabulary, because the paper's title turns on it. "Sheffer function" is a defined term in universal algebra: f is Sheffer for a set A exactly when ⟨A; f⟩ is primal, meaning that literally every operation on A, of every number of arguments, is a composition of f with itself and the projections.²³ That is a far heavier demand than reaching thirty-six named functions, and eml does not meet it on ℝ, so the identification is wrong even though the analogy to NAND is apt. And the natural next move, applying Rosenberg's classification of maximal clones, does not work either. Rosenberg's criterion is finite-only, and on an infinite set nobody knows whether the clone lattice even has the structure the argument would need. The question is open, not settled against.

The one serious objection

Robert Smith's rebuttal, which drew its own hundred-and-forty-six-point thread, is the one serious mathematical objection anybody raised, and it is worth unpacking properly, because the idea underneath it is lovely.⁶

Take a function that has more than one value, and walk its input in a slow loop around a point where it misbehaves. You have already watched this happen. The logarithm picks up a full turn when you circle the origin, which is the branch cut from the figure that built the logarithm. Do the same to a function with several branches and the branches come back shuffled. The collection of shuffles you can reach by looping is called the function's monodromy, and it forms a group.

Smith's argument, built on Khovanskii's topological Galois theory, is that anything you can write with eml has a monodromy that comes apart into commuting layers. He proves it by induction over the tree: an exponential can only simplify the group beneath it, a logarithm only adds winding numbers, which commute with each other, and the subtraction cannot help either. Groups that come apart this way are called solvable, and that word is not a coincidence. The five roots of a general fifth-degree polynomial shuffle in a way that does not come apart, which is exactly why there is no quintic formula. And the standard definition of an elementary function, unchanged since Liouville, admits roots of polynomials.

So if Smith is right, eml reaches every button on the calculator and still falls short of the elementary functions, because that class contains something no arrangement of exponentials and logarithms can reach. This gap has nothing to do with cost, or rounding, or branch cuts. It is the wall that killed the quintic formula in 1824.

It is a good argument, and Smith handles it well. He states he is not a professional mathematician, explicitly declines to call the post a refutation, and in a later edit withdrew a separate claim about the absolute value. He also grants that the construction is "correct and clever, so long as we accept some of his modifications to the conventional log function and do arithmetic with infinities", which names, from the other side of the table, the same two defects this notebook has already spent whole sections on: the branch cut and the −∞. That is a more careful public epistemics than most of what surrounded it.