It absolutely does matter. The first, and most important reason, is one needs to know the guarantees of every operation in order to design numerical algorithms that meet some guarantee. Without knowing that the components provide, it's impossible to design algorithms on top with some guarantee. And this is needed in a massive amount of applications, from CAD, simulation, medical and financial items, control items, aerospace, and on and on.

And once one has a guarantee, making the lower components tighter allows higher components to do less work. This is a very low level component, so putting the guarantees there reduces work for tons of downstream work.

All this is precisely what drove IEEE 754 to become a thing and to become the standard in modern hardware.

> the problem is that languages traditionally rely on an OS provided libm leading to cross architecture differences

No, they don't not things like sqrt and atanh and related. They've relied on compiler provided libs since, well, as long as there have been languages. And the higher level libs, like BLAS, are built on specific compilers that provide guarantees by, again, libs the compiler used. I've not seen OS level calls describing the accuracy of the floating point items, but a lot of languages do, including C/C++ which underlies a lot of this code.

Then, subtraction is (x#y)#0 = x-y. Reciprocal is x#0 = 1/x. Addition follows from x+y=x-((x-x)-y). This used the additive identity 0.

Multiplication follows from

x^2= x-1/(1/x + 1/(1-x)), so we can square things. Then -2xy = (x-y)^2 -x^2 - y^2 is constructible. Then we can divide by -2 via x/-2 = 1/((0-1/x)-1/x), and there’s multiplication. In terms of #, this expression only needed the constant 1, which is the multiplicative identity.

Now mult and reciprocal give x * 1/y = x/y, division.

Any nontrivial ring needs additive and multiplicative identities 1!=0, which are the only constants needed above. If you assume this is Q or R or C, it may be possible to derive one from the other, not sure. But if you’re in these fields, you know 0 and 1 exist.

Then any element of Q is a finite set of ops. R can be constructed in whatever way you want: Dedekind cuts, Cauchy sequences, whatever usual constructions. Or assume R exists, and compute in it via the f(x,y).

This also works over finite fields (eml does not), division rings, even infinite fields of positive characteristic, function fields (think elements are ratio of polynomials), basically any algebraic object with the 4 ops.

I just looked through many of the best known real analysis texts, and not a single one defines them this way. This list included the texts by

Royden, Terence Tao, Rudin, Spivak, Bartle & Sherbert, Pugh, and a few others....

Can you cite a single text book that has this definition you claim is in every real analysis course? I find all evidence points to the opposite.

A limit process is a definition. Try computing with it. You’ll end up with an infinite sequence, or an approximation.

An iterative process is an infinite series. They’re equivalent.

Newtons method is the same. Completely equivalent to an infinite series as you increase precision.

And both require constants, infinitely precise. So you’re still not doing anything the 1/(x-y) operation cannot do, and to do those series you’ll compute using things amenable to being done via ops easy to do by hand or machine via the 1/(x-y) op.

If we’re making sloppy approximations to a tiny range of exp, then I too can do it with a few terms.

And the basic monomial basis is not a single binary operation capable of reproducing the set of basic arithmetic ops. If you want trivial and basic, pick Peano postulates. But that’s not what this thread was about.

Go ahead and show how to compute exp or ln without an infinite series without circular reasoning. You can’t, since they’re transcendental.

There are infinitely many ways to make these binary operators. Picking extremely high compute cost ones really doesn’t make a good basis for computation.

You don’t get to make up free ops, claim there is no cost in reality, and hand wave away reality.

There are infinitely many ways to do what the paper did. There’s no gain other than it’s pretty. It loses on every practical front to simply using current ops and architectures.

The paper above was published in 2012 [1], so that’s quite a feat for an LLM. This takes about zero effort to check.

Put some thought or effort into your claims; they’ll look less silly.

[1] https://orcid.org/0000-0002-0438-633X

write x#y for 1/(x-y).

x#0 = 1/(x-0) = 1/x, so you get reciprocals. Then (x#y)#0 = 1/((1/(x-y)) - 0) = x-y, so subtraction.

it's common problem to show in any (insert various algebraic structure here ) inverse and subtraction gives all 4 elementary ops.

I haven't checked this carefully, but this note seems to give a short proof (modulo knowing some other items...) https://dmg.tuwien.ac.at/goldstern/www/papers/notes/singlebi...