What about the confidence in the result? Math is never done willy nilly, and without the ability to show how it is done, this will go no where. That said, this is a exciting result

In general, differentiating a function is a lot easier than integrating one.

Because functions can be written in multiple ways (simple example: ‘x+1’ vs ‘1+x’. For harder examples, see for example https://en.wikipedia.org/wiki/List_of_trigonometric_identiti...), it may still be difficult to prove that the derivative of a proposed integral of some function f is equal to f, but most of the time, checking a proposed solution to ".

That reminds me of a joke that goes something like this:

> Me: What is 2+2?

> AI: It’s 42.

> Me: Wrong, it’s 4. What’s 2+3?

> AI: It’s 4.

Can someone explain me the joke

AI (or more accurately, machine learning (ML)) learns by being told when it’s wrong and right (like a child). The AI makes a mistake on what 2+2 is, so it’s corrected. However, when it’s asked 2+3, it doesn’t know that 3 is one more than 2, and the only answer it’s learned is 4, so it says 4.

As is well known, a child learning language will often initially assume that rules/patterns are more regular that they actually are.

The ai was trained that the answer is 4, so the second time around it went with 4.

This paper was posted earlier with Anonymous authors: https://news.ycombinator.com/item?id=21084748

Headline reminds me of cold war era "the Soviets have a x that can do y"

> Other neural nets haven’t progressed beyond simple addition and multiplication, but this one calculates integrals and solves differential equations.

And this one can't solve addition or multiplication. Turns out they are different problem spaces that require different approaches.

Quick, someone stick the navier-stokes equations in.

I'd rather see if it can infer anything about the input from a SHA-256 hash.

Is there anything machine learning is bad for?

Un-differentiable output. Take, for instance, writing a program. Change the input by the smallest possible amount, one character, and generally the output changes by a rather large amount (it could, say, go from working to failing to compile). Rarely would changing one character get us X% closer to a solution, or produce a change in a working solution that is X% faster.

OTOH, the example in the OP has somewhat the flavor of the hard problem you just sketched.

The tree-based (RPN-esque) notation itself gets around much of the "perturbed program fails to compile" problem.

unique or novel untrained situations.

that said ,we're not great at those, either.

(untrained meaning that the dataset is a poor match with regards to the expected outcome)

employment