Title: DEEP LEARNING FOR SYMBOLIC MATHEMATICS

Abstract: Neural networks have a reputation for being better at solving statistical or approximate problems than at performing calculations or working with symbolic data. In this paper, we show that they can be surprisingly good at more elaborated tasks in mathematics, such as symbolic integration and solving differential equations. We propose a syntax for representing mathematical problems, and methods for generating large datasets that can be used to train sequence-to-sequence models. We achieve results that outperform commercial Computer Algebra Systems such as Matlab or Mathematica.

1. INTRODUCTION:

A longstanding tradition in machine learning opposes rule-based inference to statistical learning (Rumelhart et al., 1986) , and neural networks clearly stand on the statistical side. They have proven to be extremely effective in statistical pattern recognition and now achieve state-of-the-art performance on a wide range of problems in computer vision, speech recognition, natural language processing (NLP), etc. However, the success of neural networks in symbolic computation is still extremely limited: combining symbolic reasoning with continuous representations is now one of the challenges of machine learning.

Only a few studies investigated the capacity of neural network to deal with mathematical objects, and apart from a small number of exceptions (Zaremba et al., 2014; Loos et al., 2017; Allamanis et al., 2017; Arabshahi et al., 2018b) , the majority of these works focus on arithmetic tasks like integer addition and multiplication (Zaremba & Sutskever, 2014; Kaiser & Sutskever, 2015; Trask et al., 2018) . On these tasks, neural approaches tend to perform poorly, and require the introduction of components biased towards the task at hand (Kaiser & Sutskever, 2015; Trask et al., 2018) .

In this paper, we consider mathematics, and particularly symbolic calculations, as a target for NLP models. More precisely, we use sequence-to-sequence models (seq2seq) on two problems of symbolic mathematics: function integration and ordinary differential equations (ODEs). Both are difficult, for trained humans and computer software. For integration, humans are taught a set of rules (integration by parts, change of variable, etc.), that are not guaranteed to succeed, and Computer Algebra Systems use complex algorithms (Geddes et al., 1992 ) that explore a large number of specific cases. For instance, the complete description of the Risch algorithm (Risch, 1970) for function integration is more than 100 pages long.

Yet, function integration is actually an example where pattern recognition should be useful: detecting that an expression is of the form yy (y 2 + 1) -1/2 suggests that its primitive will contain y 2 + 1. Detecting this pattern may be easy for small expressions y, but becomes more difficult as the number of operators in y increases. However, to the best of our knowledge, no study has investigated the ability of neural networks to detect patterns in mathematical expressions.

We first propose a representation of mathematical expressions and problems that can be used by seq2seq models, and discuss the size and structure of the resulting problem space. Then, we show how to generate datasets for supervised learning of integration and first and second order differential equations. Finally, we apply seq2seq models to these datasets, and show that they achieve a better performance than state-of-the-art computer algebra programs, namely Matlab and Mathematica.

2. MATHEMATICS AS A NATURAL LANGUAGE:



2.1. EXPRESSIONS AS TREES:

Mathematical expressions can be represented as trees, with operators and functions as internal nodes, operands as children, and numbers, constants and variables as leaves. The following trees represent expressions 2 + 3 × (5 + 2), 3x 2 + cos(2x) -1, and

∂ 2 ψ ∂x 2 -1 ν 2 ∂ 2 ψ ∂t 2 : + 2 × 3 + 5 2 + × 3 pow x 2 - cos × 2 x 1 - ∂ ∂ ψ x x × / 1 pow ν 2 ∂ ∂ ψ t t

Trees disambiguate the order of operations, take care of precedence and associativity and eliminate the need for parentheses. Up to the addition of meaningless symbols like spaces, punctuation or redundant parentheses, different expressions result in different trees. With a few assumptions, discussed in Section A of the appendix, there is a one-to-one mapping between expressions and trees.

We consider expressions as sequences of mathematical symbols. 2 + 3 and 3 + 2 are different expressions, as are √ 4x and 2x, and they will be represented by different trees. Most expressions represent meaningful mathematical objects. x / 0, √ -2 or log(0) are also legitimate expressions, even though they do not necessarily make mathematical sense.

Since there is a one-to-one correspondence between trees and expressions, equality between expressions will be reflected over their associated trees, as an equivalence : since 2+3 = 5 = 12-7 = 1×5, the four trees corresponding to these expressions are equivalent.

Many problems of formal mathematics can be reframed as operations over expressions, or trees. For instance, expression simplification amounts to finding a shorter equivalent representation of a tree. In this paper, we consider two problems: symbolic integration and differential equations. Both boil down to transforming an expression into another, e.g. mapping the tree of an equation to the tree of its solution. We regard this as a particular instance of machine translation.

2.2. TREES AS SEQUENCES:

Machine translation systems typically operate on sequences (Sutskever et al., 2014; Bahdanau et al., 2015) . Alternative approaches have been proposed to generate trees, such as Tree-LSTM (Tai et al., 2015) or Recurrent Neural Network Grammars (RNNG) (Dyer et al., 2016; Eriguchi et al., 2017) . However, tree-to-tree models are more involved and much slower than their seq2seq counterparts, both at training and at inference. For the sake of simplicity, we use seq2seq models, which were shown to be effective at generating trees, e.g. in the context of constituency parsing (Vinyals et al., 2015) , where the task is to predict a syntactic parse tree of input sentences.

Using seq2seq models to generate trees requires to map trees to sequences. To this effect, we use prefix notation (also known as normal Polish notation), writing each node before its children, listed from left to right. For instance, the arithmetic expression 2 + 3 * (5 + 2) is represented as the sequence [+ 2 * 3 + 5 2]. In contrast to the more common infix notation 2 + 3 * (5 + 2), prefix sequences need no parentheses and are therefore shorter. Inside sequences, operators, functions or variables are represented by specific tokens, and integers by sequences of digits preceded by a sign. As in the case between expressions and trees, there exists a one-to-one mapping between trees and prefix sequences.

2.3. GENERATING RANDOM EXPRESSIONS:

To create training data, we need to generate sets of random mathematical expressions. However, sampling uniformly expressions with n internal nodes is not a simple task. Naive algorithms (such as recursive methods or techniques using fixed probabilities for nodes to be leaves, unary, or binary) tend to favour deep trees over broad trees, or left-leaning over right leaning trees. Here are examples of different trees that we want to generate with the same probability. x

In Section C of the appendix, we present an algorithm to generate random trees and expressions, where the four expression trees above are all generated with the same probability.

2.4. COUNTING EXPRESSIONS:

We now investigate the number of possible expressions. Expressions are created from a finite set of variables (i.e. literals), constants, integers, and a list of operators that can be simple functions (e.g. cos or exp) or more involved operators (e.g. differentiation or integration). More precisely, we define our problem space as:

• trees with up to n internal nodes

• a set of p 1 unary operators (e.g. cos, sin, exp, log)

• a set of p 2 binary operators (e.g. +, -, ×, pow)

• a set of L leaf values containing variables (e.g. x, y, z), constants (e.g. e, π), integers (e.g. {-10, . . . , 10})

If p 1 = 0, expressions are represented by binary trees. The number of binary trees with n internal nodes is given by the n-th Catalan numbers C n (Sloane, 1996) . A binary tree with n internal nodes has exactly n + 1 leaves. Each node and leaf can take respectively p 2 and L different values. As a result, the number of expressions with n binary operators can be expressed by:

E n = C n p n 2 L n+1 ≈ 4 n n √ πn p n 2 L n+1 with C n = 1 n + 1 2n n

If p 1 > 0, expressions are unary-binary trees, and the number of trees with n internal nodes is the n-th large Schroeder number S n (Sloane, 1996) . It can be computed by recurrence using the following equation:

EQUATION

Finally, the number E n of expressions with n internal nodes, p 1 unary operator, p 2 binary operators and L possible leaves is recursively computed as

(n + 1)E n = (p 1 + 2Lp 2 )(2n -1)E n-1 -p 1 (n -2)E n-2 (2) If p 1 = p 2 = L = 1, Equation 2 boils down to Equation 1. If p 2 = L = 1, p 1 = 0, we have (n + 1)E n = 2(2n -1)E n-1

which is the recurrence relation satisfied by Catalan numbers. The derivations and properties of all these formulas are provided in Section B of the appendix.

In Figure 1 , we represent the number of binary trees (C n ) and unary-binary trees (S n ) for different numbers of internal nodes. We also represent the number of possible expressions (E n ) for different sets of operators and leaves. correspond to the number of unary and binary operators respectively, and L to the number of possible leaves.

The bottom two curves correspond to the number of binary and unary-binary trees (enumerated by Catalan and Schroeder numbers respectively). The top two curves represent the associated number of expressions. We observe that adding leaves and binary operators significantly increases the size of the problem space.

3. GENERATING DATASETS:

Having defined a syntax for mathematical problems and techniques to randomly generate expressions, we are now in a position to build the datasets our models will use. In the rest of the paper, we focus on two problems of symbolic mathematics: function integration and solving ordinary differential equations (ODE) of the first and second order.

To train our networks, we need datasets of problems and solutions. Ideally, we want to generate representative samples of the problem space, i.e. randomly generate functions to be integrated and differential equations to be solved. Unfortunately, solutions of random problems sometimes do not exist (e.g. the integrals of f (x) = exp(x 2 ) or f (x) = log(log(x)) cannot be expressed with usual functions), or cannot be easily derived. In this section, we propose techniques to generate large training sets for integration and first and second order differential equations.

3.1. INTEGRATION:

We propose three approaches to generate functions with their associated integrals.

Forward generation (FWD).:

A straightforward approach is to generate random functions with up to n operators (using methods from Section 2) and calculate their integrals with a computer algebra system. Functions that the system cannot integrate are discarded. This generates a representative sample of the subset of the problem space that can be successfully solved by an external symbolic mathematical framework.

Backward generation (BWD). An issue with the forward approach is that the dataset only contains functions that symbolic frameworks can solve (they sometimes fail to compute the integral of integrable functions). Also, integrating large expressions is time expensive, which makes the overall method particularly slow. Instead, the backward approach generates a random function f , computes its derivative f , and adds the pair (f , f ) to the training set. Unlike integration, differentiation is always possible and extremely fast even for very large expressions. As opposed to the forward approach, this method does not depend on an external symbolic integration system.

Backward generation with integration by parts (IBP). An issue with the backward approach is that it is very unlikely to generate the integral of simple functions like f (x) = x 3 sin(x). Its integral, F (x) = -x 3 cos(x) + 3x 2 sin(x) + 6x cos(x) -6 sin(x), a function with 15 operators, has a very low probability of being generated randomly. Besides, the backward approach tends to generate examples where the integral (the solution) is shorter than the derivative (the problem), while forward generation favors the opposite (see Figure 2 in Section E in the Appendix). To address this issue, we leverage integration by parts: given two randomly generated functions F and G, we compute their respective derivatives f and g. If f G already belongs to the training set, we know its integral, and we can compute the integral of F g as: With this approach, we can generate the integrals of functions like x 10 sin(x) without resorting to an external symbolic integration system.

F g = F G -f G Similarly, if F g

Comparing different generation methods. Table 1 in Section 4.1 summarizes the differences between the three generation methods. The FWD method tends to generate short problems with long solutions (that computer algebras can solve). The BWD approach, on the other hand, generates long problems with short solutions. IBP generates datasets comparable to FWD (short problems and long solutions), without an external computer algebra system. A mixture of BWD and IBP generated data should therefore provide a better representation of problem space, without resorting to external tools.

Examples of functions / integrals for the three approaches are given in Table 9 of the Appendix.

3.2. FIRST ORDER DIFFERENTIAL EQUATION (ODE 1):

We now present a method to generate first order differential equations with their solutions. We start from a bivariate function F (x, y) such that the equation F (x, y) = c (where c is a constant) can be analytically solved in y. In other words, there exists a bivariate function f that satisfies ∀(x, c), F x, f (x, c) = c. By differentiation with respect to x, we have that ∀x, c:

∂F x, f c (x)) ∂x + f c (x) ∂F (x, f c (x)) ∂y = 0 where f c = x → f (x, c

). As a result, for any constant c, f c is solution of the first order differential equation:

EQUATION

With this approach, we can use the method described in Section C of the appendix to generate arbitrary functions F (x, y) analytically solvable in y, and create a dataset of differential equations with their solutions.

Instead of generating a random function F , we can generate a solution f (x, c), and determine a differential equation that it satisfies.

If f (x, c) is solvable in c, we compute F such that F x, f (x, c) = c.

Using the above approach, we show that for any constant c, x → f (x, c) is a solution of differential Equation 3. Finally, the resulting differential equation is factorized, and we remove all positive factors from the equation.

A necessary condition for this approach to work is that the generated functions f (x, c) can be solved in c. For instance, the function f (x, c) = c × log(x + c) cannot be analytically solved in c, i.e. the function F that satisfies F x, f (x, c) = c cannot be written with usual functions. Since all the operators and functions we use are invertible, a simple condition to ensure the solvability in c is to guarantee that c only appears once in the leaves of the tree representation of f (x, c). A straightforward way to generate a suitable f (x, c) is to sample a random function f (x) by the methods described in Section C of the appendix, and to replace one of the leaves in its tree representation by c. Below is an example of the whole process:

Generate a random function

f (x) = x log(c / x) Solve in c c = xe f (x) x = F (x, f (x)) Differentiate in x e f (x) x 1 + f (x) - f (x) x = 0 Simplify xy -y + x = 0 3.3 SECOND ORDER DIFFERENTIAL EQUATION (ODE 2)

Our method for generating first order equations can be extended to the second order, by considering functions of three variables f (x, c 1 , c 2 ) that can be solved in c 2 . As before, we derive a function of three variables F such that F x, f (x, c 1 , c 2 ), c 1 = c 2 . Differentiation with respect to x yields a first order differential equation:

∂F (x, y, c 1 ) ∂x + f c1,c2 (x) ∂F x, y, c 1 ∂y y=fc 1 ,c 2 (x) = 0 where f c1,c2 = x → f (x, c 1 , c 2 ). If this equation can be solved in c 1 , we can infer another three- variable function G satisfying ∀x, G x, f c1,c2 (x), f c1,c2 (x) = c 1 .

Differentiating with respect to x a second time yields the following equation:

∂G(x, y, z) ∂x + f c1,c2 (x) ∂G(x, y, z) ∂y + f c1,c2 (x) ∂G(x, y, z) ∂z y=fc 1 ,c 2 (x) z=f c 1 ,c 2 (x) = 0

Therefore, for any constants c 1 and c 2 , f c1,c2 is solution of the second order differential equation:

∂G(x, y, y ) ∂x + y ∂G(x, y, y ) ∂y + y ∂G(x, y, y ) ∂z = 0

Using this approach, we can create pairs of second order differential equations and solutions, provided we can generate f (x, c 1 , c 2 ) is solvable in c 2 , and that the corresponding first order differential equation is solvable in c 1 . To ensure the solvability in c 2 , we can use the same approach as for first order differential equation, e.g. we create f c1,c2 so that c 2 has exactly one leaf in its tree representation. For c 1 , we employ a simple approach where we simply skip the current equation if we cannot solve it in c 1 . Although naive, we found that the differentiation equation can be solved in c 1 about 50% the time. As an example:

Generate a random function

f (x) = c 1 e x + c 2 e -x Solve in c 2 c 2 = f (x)e x -c 1 e 2x = F (x, f (x), c 1 ) Differentiate in x e x f (x) + f (x) -2c 1 e 2x = 0 Solve in c 1 c 1 = 1 2 e -x f (x) + f (x) = G(x, f (x), f (x)) Differentiate in x 0 = 1 2 e -x f (x) -f (x)

Simplify y -y = 0

3.4. DATASET CLEANING:



Equation simplification:

In practice, we simplify generated expressions to reduce the number of unique possible equations in the training set, and to reduce the length of sequences. Also, we do not want to train our model to predict x + 1 + 1 + 1 + 1 + 1 when it can simply predict x + 5. As a result, sequences [+ 2 + x 3] and [+ 3 + 2 x] will both be simplified to [+ x 5] as they both represent the expression x + 5. Similarly, the expression log(e x+3 ) will be simplified to x + 3, the expression cos 2 (x) + sin 2 (x) will be simplified to 1, etc. On the other hand, (x -1) 2 will not be simplified to x -1 as we do not make any assumption on the sign of x -1.

Coefficients simplification In the case of first order differential equations, we modify generated expressions by equivalent expressions up to a change of variable. For instance, x + x tan(3) + cx + 1 will be simplified to cx + 1, as a particular choice of the constant c makes these two expressions identical. Similarly, log(x 2 ) + c log(x) becomes c log(x).

We apply a similar technique for second order differential equations, although simplification is sometimes a bit more involved because there are two constants c 1 and c 2 . For instance, c 1 -c 2 x/5 + c 2 + 1 is simplified to c 1 x + c 2 , while c 2 e c1 e c1xe-1 can be expressed with c 2 e c1x , etc.

We also perform transformations that are not strictly equivalent, as long as they hold under specific assumptions. For instance, we simplify tan( √ c 2 x) + cosh(c 1 + 1) + 4 to c 1 + tan(c 2 x), although the constant term can be negative in the second expression, but not the first one. Similarly e 3 e c1x e c1 log(c2) is transformed to c 2 e c1x .

Invalid expressions Finally, we also remove invalid expressions from our dataset. For instance, expressions like log(0) or √ -2. To detect them, we compute in the expression tree the values of subtrees that do not depend on x. If a subtree does not evaluate to a finite real number (e.g. -∞, +∞ or a complex number), we discard the expression.

4. EXPERIMENTS:

4.1 DATASET For all considered tasks, we generate datasets using the method presented in Section 3, with:

• expressions with up to n = 15 internal nodes

• L = 11 leaf values in {x} ∪ {-5, . . . , 5} \ {0} • p 2 = 4 binary operators: +, -, ×, / • p 1 = 15 unary operators: exp, log, sqrt, sin, cos, tan, sin -1 , cos -1 , tan -1 , sinh, cosh, tanh, sinh -1 , cosh -1 , tanh -1

Statistics about our datasets are presented in Table 1 . As discussed in Section 3.1, we observe that the backward approach generates derivatives (i.e. inputs) significantly longer than the forward generator.

We discuss this in more detail in Section E of the appendix. 

4.2. MODEL:

For all our experiments, we train a seq2seq model to predict the solutions of given problems, i.e. to predict a primitive given a function, or predict a solution given a differential equation. We use a transformer model (Vaswani et al., 2017) with 8 attention heads, 6 layers, and a dimensionality of 512. In our experiences, using larger models did not improve the performance. We train our models with the Adam optimizer (Kingma & Ba, 2014) , with a learning rate of 10 -4 . We remove expressions with more than 512 tokens, and train our model with 256 equations per batch.

At inference, expressions are generated by a beam search (Koehn, 2004; Sutskever et al., 2014) , with early stopping. We normalize the log-likelihood scores of hypotheses in the beam by their sequence length. We report results with beam widths of 1 (i.e. greedy decoding), 10 and 50.

During decoding, nothing prevents the model from generating an invalid prefix expression, e.g.

[+ 2 * 3 ]. To address this issue, Dyer et al. (2016) use constraints during decoding, to ensure that generated sequences can always be converted to valid expression trees. In our case, we found that model generations are almost always valid and we do not use any constraint. When an invalid expression is generated, we simply consider it as an incorrect solution and ignore it.

4.3. EVALUATION:

At the end of each epoch, we evaluate the ability of the model to predict the solutions of given equations. In machine translation, hypotheses given by the model are compared to references written by human translators, typically with metrics like the BLEU score (Papineni et al., 2002) that measure the overlap between hypotheses and references. Evaluating the quality of translations is a very difficult problem, and many studies showed that a better BLEU score does not necessarily correlate with a better performance according to human evaluation. Here, however, we can easily verify the correctness of our model by simply comparing generated expressions to their reference solutions.

For instance, for the given differential equation xy -y + x = 0 with a reference solution x log(c / x) (where c is a constant), our model may generate x log(c) -x log(x). We can check that these two solutions are equal, although they are written differently, using a symbolic framework like SymPy (Meurer et al., 2017) .

However, our model may also generate xc -x log(x) which is also a valid solution, that is actually equivalent to the previous one for a different choice of constant c. In that case, we replace y in the differential equation by the model hypothesis. If xy -y + x = 0, we conclude that the hypothesis is a valid solution. In the case of integral computation, we can simply differentiate the model hypothesis, and compare it with the function to integrate. For the three problems, we measure the accuracy of our model on equations from the test set.

Since we can easily verify the correctness of generated expressions, we consider all hypotheses in the beam, and not only the one with the highest score. We verify the correctness of each hypothesis, and consider that the model successfully solved the input equation if one of them is correct. As a result, results with "Beam size 10" indicate that at least one of the 10 hypotheses in the beam was correct.

4.4. RESULTS:

Table 2 reports the accuracy of our model for function integration and differential equations. For integration, the model achieves close to 100% performance on a held-out test set, even with greedy decoding (beam size 1). This performance is consistent over the three integration datasets (FWD, BWD, and IBP). Greedy decoding (beam size 1) does not work as well for differential equations. In particular, we observe an improvement in accuracy of almost 40% when using a large beam size of 50 for second order differential equations. Unlike in machine translation, where increasing the beam size does not necessarily increase the performance (Ott et al., 2018) , we always observe significant improvements with wider beams. Typically, using a beam size of 50 provides an improvement of 8% accuracy compared to a beam size of 10. This makes sense, as increasing the beam size will provide more hypotheses, although a wider beam may displace a valid hypothesis to consider invalid ones with better log-probabilities. 

4.5. COMPARISON WITH MATHEMATICAL FRAMEWORKS:

We compare our model with three popular mathematical frameworks: Mathematica (Wolfram-Research, 2019), Maple and Matlab (MathWorks, 2019) 1 . Prefix sequences in our test set are converted back to their infix representations, and given as input to the computer algebra. For a specific input, the computer algebra either returns a solution, provides no solution (or a solution including integrals or special functions), or, in the case of Mathematica, times out after a preset delay. When Mathematica times out, we conclude that it is not able to compute a solution (although it might have found a solution given more time). For integration, we evaluate on the BWD test set. By construction, the FWD data only consists of integrals generated by computer algebra systems, which makes comparison uninteresting.

In Table 3 , we present accuracy for our model with different beam sizes, and for Mathematica with a timeout delay of 30 seconds. Table 8 in the appendix provides detailed results for different values of timeout, and explains our choice of 30 seconds. In particular, we find that with 30 seconds, only 20% of failures are due to timeouts, and only 10% when the timeout is set to 3 minutes. Even with timeout limits, evaluation would take too long on our 5000 test equations, so we only evaluate on a smaller test subset of 500 equations, on which we also re-evaluate our model. For Mathematica we report results by setting a timeout of 30 seconds per equation. On a given equation, our model typically finds the solution in less than a second.

On all tasks, we observe that our model significantly outperforms Mathematica. On function integration, our model obtains close to 100% accuracy, while Mathematica barely reaches 85%. On first order differential equations, Mathematica is on par with our model when it uses a beam size of 1, i.e. with greedy decoding. However, using a beam search of size 50 our model accuracy goes from 81.2% to 97.0%, largely surpassing Mathematica. Similar observations can be made for second order differential equations, where beam search is even more critical since the number of equivalent solutions is larger. On average, Matlab and Maple have slightly lower performance than Mathematica on the problems we tested.

Table 4 shows examples of functions that our model was able to solve, on which Mathematica and Matlab did not find a solution. The denominator of the function to integrate, -16x 8 + 112x 7 -204x 6 + 28x 5 -x 4 + 1, can be rewritten as 1 -(4x 4 -14x 3 + x 2 ) 2 . With the simplified input:

16x 3 -42x 2 + 2x 1 -(4x 4 -14x 3 + x 2 ) 2 1/2

integration becomes easier and Mathematica is able to find the solution.

Equation Solution

y = 16x 3 -42x 2 + 2x (-16x 8 + 112x 7 -204x 6 + 28x 5 -x 4 + 1) 1/2 y = sin -1 (4x 4 -14x 3 + x 2 )

3xy cos(x) -9x 2 sin(x) 2 + 1y + 3y sin(x) = 0 y = c exp sinh -1 (3x sin(x)) 4x 4 yy -8x 4 y 2 -8x 3 yy -3x 3 y -8x 2 y 2 -6x 2 y -3x 2 y -9xy -3y = 0 y = c1 + 3x + 3 log (x)

x (c2 + 4x) 

4.6. EQUIVALENT SOLUTIONS:

An interesting property of our model is that it is able to generate solutions that are exactly equivalent, but written in different ways. For instance, we consider the following first order differential equation, along with one of its solutions:

162x log(x)y + 2y 3 log(x) 2 -81y log(x) + 81y = 0

y = 9 √ x 1 log (x) √ c + 2x

In Table 5 , we report the top 10 hypotheses returned by our model for this equation. We observe that all generations are actually valid solutions, although they are expressed very differently. They are however not all equal: merging the square roots within the first and third equations would give the same expression except that the third one would contain a factor 2 in front of the constant c, but up to a change of variable, these two solutions are actually equivalent. The ability of the model to recover equivalent expressions, without having been trained to do so, is very intriguing.

Hypothesis Score Hypothesis Score

9 √ x 1 log (x) √ c + 2x -0.047 9 c log (x) x + 2 log (x) -0.124 9 √ x √ c + 2x log (x) -0.056 9 √ x c log (x) + 2x log (x) -0.139 9 √ 2 √ x 1 log (x) 2 √ c + x -0.115 9 c x + 2 log (x) -0.144 9 √ x 1 c log (x) + 2x log (x) -0.117 9 1 c log (x) x + 2 log (x) -0.205 9 √ 2 √ x 2 √ c + x log (x) -0.124 9 √ x 1 c log (x) + 2x log (x) + log (x) -0.232

Table 5 : Top 10 generations of our model for the first order differential equation 162x log(x)y +2y 3 log(x) 2 -81y log(x) + 81y = 0, generated with a beam search. All hypotheses are valid solutions, and are equivalent up to a change of the variable c. Scores are log-probabilities normalized by sequence lengths.

4.7. GENERALIZATION ACROSS GENERATORS:

Models for integration achieve close to 100% performance on held-out test samples generated with the same method as their training data. In Table 6 , we compare the accuracy on the FWD, BWD and IBP test sets for 4 models trained using different combinations of training data. When the test set is generated with the same generator as the training set, the model performs extremely well. For instance, the three models trained either on BWD, BWD + IBP or BWD + IBP + FWD achieve 99.7% accuracy on the BWD test set with a beam size of 50.

On the other hand, even with a beam size of 50, a FWD-trained model only achieves 17.2% accuracy on the BWD test set, and a BWD-trained model achieves 27.5% on the FWD test set. This results from the very different structure of the FWD and BWD data sets (cf. Table 6 : Accuracy of our models on function integration. We report the accuracy of our model on the three integration datasets: forward (FWD), backward (BWD), and integration by parts (IBP), for four models trained with different combinations of training data. We observe that a FWD-trained model performs poorly when it tries to integrate functions from the BWD dataset. Similarly, a BWD-trained model only obtain 27.5% accuracy on the FWD dataset, as it fails to integrate simple functions like x 5 sin(x). On the other hand, training on both the BWD + IBP datasets allows the model to reach up to 56.1% accuracy on FWD. Training on all datasets allows the model to perform well on the three distributions.

4.8. GENERALIZATION BEYOND THE GENERATOR -SYMPY:

Our forward generator, FWD, generates a set of pairs (f, F ) of functions with their integrals. It relies on an external symbolic framework, SymPy (Meurer et al., 2017) , to compute the integral of randomly generated functions. SymPy is not perfect, and fails to compute the integral of many integrable functions. In particular, we found that the accuracy of SymPy on the BWD test set is only 30%. Our FWD-trained model only obtains an accuracy of 17.2% on BWD. However, we observed that the FWD-trained model is sometimes able to compute the integral of functions that SymPy cannot compute. This means that by only training on functions that SymPy can integrate, the model was able to generalize to functions that SymPy cannot integrate. Table 7 presents examples of such functions with their integrals.

x 2 tan 2 (x) + 1 + 2x tan (x) + 1 x 2 tan (x) + x 1 + 2 cos (2x)

sin 2 (2x) + 1

x + asinh (sin (2x))

x tan (x) + log (x cos (x)) -1 log (x cos (x))

2 x log (x cos (x)) - 2x cos asin 2 (x) asin (x) √ 1 -x 2 sin 2 asin 2 (x) + 1 sin asin 2 (x)

x sin asin 2 (x)

√ x + x 2x √ x 4 + 1 + 1 + 1 2 √ x + x + asinh x 2 x √ x + x + asinh x 2 -3 - 3 -3x 2 sin (x 3 )+ 1 2 √ x √ x+cos (x 3 ) (x + log ( √ x + cos (x 3 ))) 2 3 x + log ( √ x + cos (x 3 )) -2 tan 2 (log (log (x))) -2 log (x) tan 2 (log (log (x))) + 2 tan (log (log (x))) 2x tan (log (log (x)))

Table 7 : Examples of functions / integrals that the FWD-trained model can integrate, but not SymPy.

Although the FWD model was only trained on a subset of functions that SymPy can integrate, it learned to generalize to functions that SymPy cannot integrate.

5. RELATED WORK:

Computers were used for symbolic mathematics since the late 1960s (Moses, 1974) . Computer algebra systems (CAS), such as Matlab, Mathematica, Maple, PARI and SAGE, are used for a variety of mathematical tasks (Gathen & Gerhard, 2013) . Modern methods for symbolic integration are based on Risch algorithm (Risch, 1970) . Implementations can be found in Bronstein (2005) and Geddes et al. (1992) . However, the complete description of the Risch algorithm takes more than 100 pages, and is not fully implemented in current mathematical framework.

Deep learning networks have been used to simplify treelike expressions. Zaremba et al. (2014) use recursive neural networks to simplify complex symbolic expressions. They use tree representations for expressions, but provide the model with problem related information: possible rules for simplification. The neural network is trained to select the best rule. Allamanis et al. (2017) propose a framework called neural equivalence networks to learn semantic representations of algebraic expressions. Typically, a model is trained to map different but equivalent expressions (like the 10 expressions proposed in Table 5 ) to the same representation. However, they only consider Boolean and polynomial expressions. More recently, Arabshahi et al. (2018a; b) used tree-structured neural networks to verify the correctness of given symbolic entities, and to predict missing entries in incomplete mathematical equations. They also showed that these networks could be used to predict whether an expression is a valid solution of a given differential equation.

Most attempts to use deep networks for mathematics have focused on arithmetic over integers (sometimes over polynomials with integer coefficients). For instance, Kaiser & Sutskever (2015) proposed the Neural-GPU architecture, and train networks to perform additions and multiplications of numbers given in their binary representations. They show that a model trained on numbers with up-to 20 bits can be applied to much larger numbers at test time, while preserving a perfect accuracy. Freivalds & Liepins (2017) proposed an improved version of the Neural-GPU by using hard non-linear activation functions, and a diagonal gating mechanism. Saxton et al. (2019) use LSTMs (Hochreiter & Schmidhuber, 1997) and transformers on a wide range of problems, from arithmetic to simplification of formal expressions. However, they only consider polynomial functions, and the task of differentiation, which is significantly easier than integration. Trask et al. (2018) propose the Neural arithmetic logic units, a new module designed to learn systematic numerical computation, and that can be used within any neural network. Like Kaiser & Sutskever (2015) , they show that at inference their model can extrapolate on numbers orders of magnitude larger than the ones seen during training.

6. CONCLUSION:

In this paper, we show that standard seq2seq models can be applied to difficult tasks like function integration, or solving differential equations. We propose an approach to generate arbitrarily large datasets of equations, with their associated solutions. We show that a simple transformer model trained on these datasets can perform extremely well both at computing function integrals, and solving differential equations, outperforming state-of-the-art mathematical frameworks like Matlab or Mathematica that rely on a large number of algorithms and heuristics, and a complex implementation (Risch, 1970) . Results also show that the model is able to write identical expressions in very different ways.

These results are surprising given the difficulty of neural models to perform simpler tasks like integer addition or multiplication. However, proposed hypotheses are sometimes incorrect, and considering multiple beam hypotheses is often necessary to obtain a valid solution. The validity of a solution itself is not provided by the model, but by an external symbolic framework (Meurer et al., 2017) . These results suggest that in the future, standard mathematical frameworks may benefit from integrating neural components in their solvers.

A A SYNTAX FOR MATHEMATICAL EXPRESSIONS:

We represent mathematical expressions as trees with operators as internal nodes, and numbers, constants or variables, as leaves. By enumerating nodes in prefix order, we transform trees into sequences suitable for seq2seq architectures.

For this representation to be efficient, we want expressions, trees and sequences to be in a one-to-one correspondence. Different expressions will always result in different trees and sequences, but for the reverse to hold, we need to take care of a few special cases.

First, expressions like sums and products may correspond to several trees. For instance, the expression 2 + 3 + 5 can be represented as any one of those trees:

+ 2 3 5 + + 2 3 5 + 2 + 3 5

We will assume that all operators have at most two operands, and that, in case of doubt, they are associative to the right. 2 + 3 + 5 would then correspond to the rightmost tree.

Second, the distinction between internal nodes (operators) and leaves (mathematical primitive objects) is somewhat arbitrary. For instance, the number -2 could be represented as a basic object, or as a unary minus operator applied to the number 2. Similarly, there are several ways to represent √ 5, 42x 5 , or the function log 10 . For simplicity, we only consider numbers, constants and variables as possible leaves, and avoid using a unary minus. In particular, expressions like -x are represented as -1 × x. Here are the trees for -2, √ 5, 42x 5 and -x:

-2 sqrt 5 × 42 pow

x 5

× -1 x:

Integers are represented in positional notation, as a sign followed by a sequence of digits (from 0 to 9 in base 10). For instance, 2354 and -34 are represented as +2 3 5 4 and -3 4. For zero, a unique representation is chosen (+0 or -0).

B MATHEMATICAL DERIVATIONS OF THE PROBLEM SPACE SIZE:

In this section, we investigate the size of the problem space by computing the number of expressions with n internal nodes. We first deal with the simpler case where we only have binary operators (p 1 = 0), then consider trees and expressions composed of unary and binary operators. In each case, we calculate a generating function (Flajolet & Sedgewick, 2009; Wilf, 2005) from which we derive a closed formula or recurrence on the number of expressions, and an asymptotic expansion.

B.1 BINARY TREES AND EXPRESSIONS:

The main part of this derivation follows (Knuth, 1997) (pages 388-389) .

Generating function Let b n be the number of binary trees with n internal nodes. We have b 0 = 1 and b 1 = 1. Any binary tree with n internal nodes can be generated by concatenating a left and a right subtree with k and n -1 -k internal nodes respectively. By summing over all possible values of k, we have that:

b n = b 0 b n-1 + b 1 b n-2 + • • • + b n-2 b 1 + b n-1 b 0 Let B(z) be the generating function of b n , B(z) = b 0 + b 1 z + b 2 z 2 + b 3 z 3 + . . . B(z) 2 = b 0 2 + (b 0 b 1 + b 1 b 0 )z + (b 0 b 2 + b 1 b 1 + b2b 0 )z 2 + . . . = b 1 + b 2 z + b 3 z 2 + . . . = B(z) -b 0 z

So, zB(z) 2 -B(z) + 1 = 0. Solving for B(z) gives:

B(z) = 1 ± √ 1 -4z 2z and since B(0) = b 0 = 1, we derive the generating function for sequence b n B(z) = 1 - √ 1 -4z 2z

We now derive a closed formula for b n . By the binomial theorem,

B(z) = 1 2z 1 - ∞ k=0 1/2 k (-4z) k = 1 2z 1 + ∞ k=0 1 2k -1 2k k z k = 1 2z ∞ k=1 1 2k -1 2k k z k = ∞ k=1 1 2(2k -1) 2k k z k-1 = ∞ k=0 1 2(2k + 1) 2k + 2 k + 1 z k = ∞ k=0 1 k + 1 2k k z k Therefore b n = 1 n + 1 2n n = (2n)! (n + 1)!n!

These are the Catalan numbers, a closed formula for the number of binary trees with n internal nodes. We now observe that a binary tree with n internal nodes has exactly n + 1 leaves. Since each node in a binary tree can represent p 2 operators, and each leaf can take L values, we have that a tree with n nodes can take p n 2 L n+1 possible combinations of operators and leaves. As a result, the number of binary expressions with n operators is given by:

E n = (2n)! (n + 1)!n! p n 2 L n+1

Asymptotic estimate To derive an asymptotic approximation of b n , we apply the Stirling formula:

n! ≈ √ 2πn n e n so 2n n ≈ 4 n √ πn and b n ≈ 4 n n √ πn

Finally, we have the following formulas for the number of expressions with n internal nodes:

E n ≈ 1 n √ πn (4p 2 ) n L n+1

B.2 UNARY-BINARY TREES Generating function Let s n be the number of unary-binary trees (i.e. trees where internal nodes can have one or two children) with n internal nodes. We have s 0 = 1 and s 1 = 2 (the only internal node is either unary or binary).

Any tree with n internal nodes is obtained either by adding a unary internal node at the root of a tree with n -1 internal nodes, or by concatenating with a binary operator a left and a right subtree with k and n -1 -k internal nodes respectively. Summing up as before, we have:

s n = s n-1 + s 0 s n-1 + s 1 s n-2 + • • • + s n-1 s 0

Let S(z) be the generating function of the s n . The above formula translates into

S(z) 2 = S(z) -s 0 z -S(z) zS(z) 2 + (z -1)S(z) + 1 = 0

solving and taking into account the fact that S(0) = 1, we obtain the generating function of the s n

S(z) = 1 -z - √ 1 -6z + z 2 2z

The numbers s n generated by S(z) are known as the Schroeder numbers (OEIS A006318) (Sloane, 1996) . They appear in different combinatorial problems (Stanley, 2011) . Notably, they correspond to the number of paths from (0, 0) to (n, n) of a n × n grid, moving north, east, or northeast, and never rising above the diagonal.

Calculation Schroeder numbers do not have a simple closed formula, but a recurrence allowing for their calculation can be derived from their generating function. Rewriting S(z) as

2zS(z) + z -1 = -1 -6z + z 2

and differentiating, we have

2zS (z) + 2S(z) + 1 = 3 -z √ 1 -6z + z 2 = 3 -z 1 -6z + z 2 (1 -z -2zS(z)) 2zS (z) + 2S(z) 1 + 3z -z 2 1 -6z + z 2 = (3 -z)(1 -z) 1 -6z + z 2 -1 2zS (z) + 2S(z) 1 -3z 1 -6z + z 2 = 2 + 2z 1 -6z + z 2 z(1 -6z + z 2 )S (z) + (1 -3z)S(z) = 1 + z

Replacing S(z) and S (z) with their n-th coefficient yields, for n > 1

ns n -6(n -1)s n-1 + (n -2)s n-2 + s n -3s n-1 = 0 (n + 1)s n = 3(2n -1)s n-1 -(n -2)s n-2

Together with s 0 = 1 and s 1 = 2, this allows for fast (O(n)) calculation of Schroeder numbers.

Asymptotic estimate:

To derive an asymptotic formula of s n , we develop the generating function around its smallest singularity (Flajolet & Odlyzko, 1990) , i.e. the radius of convergence of the power series. Since

1 -6z + z 2 = 1 -(3 - √ 8)z 1 -(3 + √ 8)z

The smallest singular value is

r 1 = 1 (3 + √ 8

) and the asymptotic formula will have the exponential term

r -n 1 = (3 + √ 8) n = (1 + √ 2) 2n

In a neighborhood of r 1 , the generating function can be rewritten as

S(z) ≈ (1 + √ 2) 1 -2 1/4 1 -(3 + √ 8)z + O(1 -(3 + √ 8)z) 3/2 Since [z n ] √ 1 -az ≈ - a n √

4πn 3 where [z n ]F (z) denotes the n-th coefficient in the formal series of F, we have

s n ≈ (1 + √ 2)(3 + √ 8) n 2 3/4 √ πn 3 = (1 + √ 2) 2n+1 2 3/4 √ πn 3

Comparing with the number of binary trees, we have

s n ≈ 1.44(1.46) n b n B.3 UNARY-BINARY EXPRESSIONS

In the binary case, the number of expressions can be derived from the number of trees. This cannot be done in the unary-binary case, as the number of leaves in a tree with n internal nodes depends on the number of binary operators (n 2 + 1).

Generating function:

The number of trees with n internal nodes and n 2 binary operators can be derived from the following observation: any unary-binary tree with n 2 binary internal nodes can be generated from a binary tree by adding unary internal nodes. Each node in the binary tree can receive one or several unary parents.

Since the binary tree has 2n 2 + 1 nodes and the number of unary internal nodes to be added is n -n 2 , the number of unary-binary trees that can be created from a specific binary tree is the number of multisets with 2n 2 + 1 elements on n -n 2 symbols, that is

n + n 2 n -n 2 = n + n 2 2n 2

If b q denotes the q-th Catalan number, the number of trees with n 2 binary operators among n is

n + n 2 2n 2 b n2

Since such trees have n 2 + 1 leaves, with L leaves, p 2 binary and p 1 unary operators to choose from, the number of expressions is

E(n, n 2 ) = n + n 2 2n 2 b n2 p n2 2 p n-n2 1 L n2+1

Summing over all values of n 2 (from 0 to n) yields the number of different expressions

E n = n n2=0 n + n 2 2n 2 b n2 p n2 2 p n-n2 1 L n2+1 z n

Let E(z) be the corresponding generating function.

E(z) = ∞ n=0 E n z n = ∞ n=0 n n2=0 n + n 2 2n 2 b n2 p n2 2 p n-n2 1 L n2+1 z n = L ∞ n=0 n n2=0 n + n 2 2n 2 b n2 Lp 2 p 1 n2 p n 1 z n = L ∞ n=0 ∞ n2=0 n + n 2 2n 2 b n2 Lp 2 p 1 n2 (p 1 z) n since n+n2 2n2 = 0 when n > n 2 E(z) = L ∞ n2=0 b n2 Lp 2 p 1 n2 ∞ n=0 n + n 2 2n 2 (p 1 z) n = L ∞ n2=0 b n2 Lp 2 p 1 n2 ∞ n=0 n + 2n 2 2n 2 (p 1 z) n+n2 = L ∞ n2=0 b n2 (Lp 2 z) n2 ∞ n=0 n + 2n 2 2n 2 (p 1 z) n

applying the binomial formula

E(z) = L ∞ n2=0 b n2 (Lp 2 z) n2 1 (1 -p 1 z) 2n2+1 = L 1 -p 1 z ∞ n2=0 b n2 Lp 2 z (1 -p 1 z) 2 n2

applying the generating function for binary trees

E(z) = L 1 -p 1 z   1 -1 -4 Lp2z (1-p1z) 2 2 Lp2z (1-p1z) 2   = 1 -p 1 z 2p 2 z 1 -1 -4 Lp 2 z (1 -p 1 z) 2 = 1 -p 1 z -(1 -p 1 z) 2 -4Lp 2 z 2p 2 z

Reducing, we have

E(z) = 1 -p 1 z -1 -2(p 1 + 2Lp 2 k)z + p 1 z 2 2p 2 z

Calculation As before, there is no closed simple formula for E n , but we can derive a recurrence formula by differentiating the generating function, rewritten as 

2p 2 zE(z) + p 1 z -1 = -1 -2(p 1 + 2p 2 L)z + p 1 z 2 2p 2 zE (z) + 2p 2 E(z) + p 1 = p 1 + 2p 2 L -p 1 z 1 -2(p 1 + 2p 2 L)z + p 1 z 2 2p 2 zE (z) + 2p 2 E(z) + p 1 = (p 1 + 2p 2 L -p 1 z)(1 -p 1 z -2p 2 zE(z)) 1 -2(p 1 + 2p 2 L)z + p 1 z 2 2p 2 zE (z) + 2p 2 E(z) 1 + z(p 1 + 2p 2 L -p 1 z) 1 -2(p 1 + 2p 2 L)z + p 1 z 2 = (p 1 + 2p 2 L -p 1 z)(1 -p 1 z) 1 -2(p 1 + 2p 2 L)z + p 1 z 2 -p 1 2p 2 zE (z) + 2p 2 E(z) 1 -(p 1 + 2p 2 L)z 1 -2(p 1 + 2p 2 L)z + p 1 z 2 = 2p 2 L(1 + p 1 z) + p 1 (p 1 -1)z 1 -2(p 1 + 2p 2 L)z + p 1 z 2 2p 2 zE (z)(1 -2(p 1 + 2p 2 L)z + p 1 z 2 ) + 2p 2 E(z)(1 -(p 1 + 2p 2 L)z) = (2p 2 L(1 + p 1 z) + p 1 (p 1 -1)z) replacing E(z) and E (z) with their coefficients 2p 2 (nE n -2(p 1 + 2p 2 L)(n -1)E n-1 + p 1 (n -2)E(n -2)) + 2p 2 (E n -(p 1 + 2p 2 L)E n-1 ) = 0 (n + 1)E n -(p 1 + 2p 2 L)(2n -1)E n-1 + p 1 (n -2)E n-2 = 0 (n + 1)E n = (p 1 + 2p 2 L)(2n -1)E n-1 -p 1 (n -2)E n-2

E GENERALIZATION ACROSS GENERATORS:

On the integration problem, we achieve (c.f. Table 6 ) near perfect performance when the training and test data are generated by the same method (either FWD, BWD, or IBP). Given the relatively small size of the training set (4.10 7 examples), the model cannot overfit to the entire problem space (10 34 possible expressions). This shows that:

• Our model generalizes well to functions created by the training generator.

• This property holds for the three considered generators, FWD, BWD, and IBP. ), but accuracy remains low. On the other hand, FWD-trained models achieve very good accuracy over an IBP-generated test set (88.9%), and BWD-trained models stand in the middle (59.2%).

Figure 2 provides an explanation for these results. The input/output pairs produced by FWD and BWD have very different distributions: integration tends to shorten BWD generated expressions, and to expand FWD generated expressions. As a result, a model trained on BWD generated data will learn this shortening feature of integration, which will prove wrong on a FWD test set. Similar problems will happen on a FWD trained model with a BWD test set. Since IBP keeps average expression lengths unchanged, BWD and FWD-trained models will generalize better to IBP test sets (and be more accurate on FWD-trained models, since their input length distributions are closer). This suggests that what looks at first glance like a generalization problem (bad accuracy of BWDtrained models on FWD generated sets, and the converse) is in fact a consequence of data generation. BWD and FWD methods generate training sets with specific properties, that our model will learn. But this can be addressed by adding IBP or FWD data to the BWD dataset, as shown in the two last lines of Table 6 . In practice, a better approach could be implemented with self-supervised learning, where new training examples are generated by the model itself.

Functions and their primitives generated with the forward approach (FWD) cos -1 (x)

x cos -1 (x) -1 -x 2

x (2x + cos (2x)) 2x 3 3 + x sin (2x) 2 + cos (2x) 4

x (x + 4)

x + 2

x 2 2 + 2x -4 log (x + 2) cos (2x) sin (x) log (cos (x) -1) 2 -log (cos (x) + 1) 2 + 2 cos (x) 3x 2 sinh -1 (2x)

x 3 sinh -1 (2x) -x 2 √ 4x 2 + 1 6 + √ 4x 2 + 1 12

x 3 log x 2 4

x 4 log x 2 4 4 -x 4 log x 2 3 2 + 3x 4 log x 2 2 4 -3x 4 log x 2 4 + 3x 4 8

Functions and their primitives generated with the backward approach (BWD) cos (x) + tan 2 (x) + 2 x + sin (x) + tan (x)

1 x 2 √ x -1 √ x + 1 √ x -1 √ x + 1 x 2x cos 2 (x)

+ tan (x) tan (x)

x tan 2 (x)

x tan e x x + (x-1)e x cos 2 ( e x x ) x

x tan e x x 1 + 1 log (log (x)) -1 log (x) log (log (x)) 2

x + x log (log (x)) -2x 2 sin x 2 tan (x) + x tan 2 (x) + 1 cos x 2 + cos x 2 tan (x)

x cos x 2 tan (x)

Functions and their primitives generated with the integration by parts approach (IBP)

x (x + log (x))

x 2 (4x + 6 log (x) -3) 12

x (x + 3) 2 -x + (x + 3) log (x + 3)

x + 3

x + √ 2 cos 2 (x)

x + √ 2 tan (x) + log (cos (x))

x (2x + 5) (3x + 2 log (x) + 1)

x 2 27x 2 + 24x log (x) + 94x + 90 log (x) 18

x -2x sin 2 (x) + 1 tan (x) log (x) sin (x)

x log (x) + tan (x) sin (x) tan (x)

x 3 sinh (x)

x 3 cosh (x) -3x 2 sinh (x) + 6x cosh (x) -6 sinh (x) We observe that the FWD and IBP approaches tend to generate short functions, with long integrals, while the BWD approach generates short functions with long derivatives.

:

All experiments were run with Mathematica 12.0.0.0, Maple

and Matlab R2019a.

Figures and Tables:

Figure 1: Number of trees and expressions for different numbers of operators and leaves. p1 and p2

Figure2: Distribution of input and output lengths for different integration datasets. The FWD generator produces short problems with long solutions. Conversely, the BWD generator creates long problems, with short solutions. The IBP approach stands in the middle, and generates short problems with short solutions.

is in the training set, we can infer the integral of f G. Whenever we discover the integral of a new function, we add it to the training set. If none of f G or F g are in the training set, we simply generate new functions F and G.

Table content: <table/>

Training set sizes and length of expressions (in tokens) for different datasets. FWD and IBP tend to generate examples with outputs much longer than the inputs, while the BWD approach generates shorter outputs. Like in the BWD case, ODE generators tend to produce solutions much shorter than their equations.

Table content: <table><tr><td/><td>Forward</td><td colspan="2">Backward Integration by parts</td><td>ODE 1</td><td>ODE 2</td></tr><tr><td>Training set size</td><td>20M</td><td>40M</td><td>20M</td><td>40M</td><td>40M</td></tr><tr><td>Input length</td><td>18.9±6.9</td><td>70.2±47.8</td><td>17.5±9.1</td><td colspan="2">123.6±115.7 149.1±130.2</td></tr><tr><td>Output length</td><td>49.6±48.3</td><td>21.3±8.3</td><td>26.4±11.3</td><td>23.0±15.2</td><td>24.3±14.9</td></tr><tr><td>Length ratio</td><td>2.7</td><td>0.4</td><td>2.0</td><td>0.4</td><td>0.1</td></tr><tr><td>Input max length</td><td>69</td><td>450</td><td>226</td><td>508</td><td>508</td></tr><tr><td>Output max length</td><td>508</td><td>75</td><td>206</td><td>474</td><td>335</td></tr></table>

Accuracy of our models on integration and differential equation solving. Results are reported on a held out test set of 5000 equations. For differential equations, using beam search decoding significantly improves the accuracy of the model.

Table content: <table><tr><td/><td colspan="5">Integration (FWD) Integration (BWD) Integration (IBP) ODE (order 1) ODE (order 2)</td></tr><tr><td>Beam size 1</td><td>93.6</td><td>98.4</td><td>96.8</td><td>77.6</td><td>43.0</td></tr><tr><td>Beam size 10</td><td>95.6</td><td>99.4</td><td>99.2</td><td>90.5</td><td>73.0</td></tr><tr><td>Beam size 50</td><td>96.2</td><td>99.7</td><td>99.5</td><td>94.0</td><td>81.2</td></tr></table>

Comparison of our model with Mathematica, Maple and Matlab on a test set of 500 equations.

Table content: <table><tr><td/><td colspan="3">Integration (BWD) ODE (order 1) ODE (order 2)</td></tr><tr><td>Mathematica (30s)</td><td>84.0</td><td>77.2</td><td>61.6</td></tr><tr><td>Matlab</td><td>65.2</td><td>-</td><td>-</td></tr><tr><td>Maple</td><td>67.4</td><td>-</td><td>-</td></tr><tr><td>Beam size 1</td><td>98.4</td><td>81.2</td><td>40.8</td></tr><tr><td>Beam size 10</td><td>99.6</td><td>94.0</td><td>73.2</td></tr><tr><td>Beam size 50</td><td>99.6</td><td>97.0</td><td>81.0</td></tr></table>

Examples

Table content: <table/>

Accuracy of Mathematica on 500 functions to integrate, for different timeout values. As the timeout delay increases, the percentage of failures due to timeouts decreases. With a limit of 3 minutes, timeouts only represent 10% of failures. As a result, the accuracy without timeout would not exceed 86.2%.

Table content: <table><tr><td colspan="4">Timeout (s) Success Failure Timeout</td></tr><tr><td>5</td><td>77.8</td><td>9.8</td><td>12.4</td></tr><tr><td>10</td><td>82.2</td><td>11.6</td><td>6.2</td></tr><tr><td>30</td><td>84.0</td><td>12.8</td><td>3.2</td></tr><tr><td>60</td><td>84.4</td><td>13.4</td><td>2.2</td></tr><tr><td>180</td><td>84.6</td><td>13.8</td><td>1.6</td></tr></table>

Table 6 also measures the ability of our model to generalize across generators. A FWD-trained model achieves a low performance (17.2% with beam 50) on a BWD-generated test set. A BWD-trained model does a little better on the FWD test set (27.5%

Table content: <table/>

Examples of functions with their integrals, generated by our FWD, BWD and IBP approaches.

Table content: <table/>

Peer review (iclr2020):
In this paper, the authors propose a method for generating two types of symbolic mathematics problems, integration and differential equations, and their solutions. The purpose of the method is to generate datasets for training transformer neural networks that solve integration and differential-equation problems. The authors note that while solving these problems is very difficult, generating solutions first and corresponding problems next automatically is feasible, and their method realizes this observation. The authors report that transformer networks trained on the synthetically generated solution-problem pairs outperform existing symbolic solvers for integration and differential equation. Here are the reasons that I like the paper. The observation that solving a symbolic mathematics problem is often a pattern matching process is interesting. It is surprising to know that a transformer network designed to translated the generating problem-solution pairs backward (from problem to solution) works better than the solvers in Mathematica and Matlab. Also, I like nice cute tricks used in the authors* method for generating solution-problem pairs, such as the syntactic condition on a possible position of some constant. The paper is overall clearly written. I presume that when the authors compare their learned solvers with Mathematica and Matlab, they used a dataset generated by their method. I feel that this comparison is somewhat unfair, although it still impresses me that even for this dataset, the authors* solvers beat Mathematica and Matlab. I suggest to try at least one more experiment on a dataset not generated by the authors* method (integration and differential equation problems from math textbooks or other sources) if possible. * p3: Why is it important to have a generator that produces the four expression trees in p3 with equal or almost equal probabilities? Do you have any semi-formal or informal justification that the distribution of such a generator better matches the kind of expressions arising in the real world? * p4: f(x)/x)) ===> f(x)/x) * *If this equation can be solved in c1*, p5: How realistic is this assumption? * p5: 1/2 e^x(...) ===> 0 = 1/2 e^x(...) * p5: If you have a thought or an observation on the impact of each of the data-cleaning steps in Section 3.4, I suggest you to share this in the paper. * p6: Why did you remove expressions with more than 512 tokens? * p6: compare to ===> compared to * p7: Would you put the reminder of the size of the training set in Section 4.4? It only mentions that of the test set currently. * p8: 1-(4x^2 ===> (1-(4x^2