Fix minor typos

Author: adrhill

docs/src/theory.md

@@ -14,10 +14,10 @@ i.e., the function value and the directional derivative up to order $p$.
 This notation might be unfamiliar to Julia users that had experience with other AD packages, but $\partial f(x)$ is simply the jacobian $J$, and $\partial f(x)\times v$ is simply the Jacobian-vector product (JVP).
 In other words, this is a simple generalization of Jacobian-vector product to Hessian-vector-vector product, and to even higher orders.
 
-The main advantage of doing this instead of doing $p$ first-order Jacobian-vector products is that nesting first-order AD results in exponential scaling w.r.t $p$, while this method, also known as Taylor mode, should be (almost) linear scaling w.r.t $p$. 
+The main advantage of doing this instead of doing $p$ first-order Jacobian-vector products is that nesting first-order AD results in exponential scaling w.r.t $p$, while this method, also known as Taylor mode, should scale (almost) linearly w.r.t $p$. 
 We will see the reason of this claim later.
 
-In order to achieve this, assuming that $f$ is a nested function $f_k\circ\cdots\circ f_2\circ f_1$, where each $f_i$ is a basic and simple function, or called "primitives". 
+In order to achieve this, we assume that $f$ is a nested function $f_k\circ\cdots\circ f_2\circ f_1$, where each $f_i$ is a basic and simple function, also called "primitive". 
 We need to figure out how to propagate the derivatives through each step. 
 In first order AD, this is achieved by the "dual" pair $x_0+x_1\varepsilon$, where $\varepsilon^2=0$, and for each primitive we make a method overload
 ```math
@@ -118,20 +118,20 @@ Note that this is an elegant and straightforward corollary from the definition o
 
 ## Generic pushforward rule
 
-For a generic $f(x)$, if we don't bother deriving the specific recurrence rule for it, we can still automatically generate pushforward rule in the following manner.
+For a generic $f(x)$, if we don't bother deriving the specific recurrence rule for it, we can still automatically generate a pushforward rule in the following manner.
 Let's denote the derivative of $f$ w.r.t $x$ to be $d(x)$, then for $f(t)=f(x(t))$  we have
 ```math
 f'(t)=d(x(t))x'(t);\quad f(0)=f(x_0)
 ```
 
 when we expand $f$ and $x$ up to order $p$ into this equation, we notice that only order $p-1$ is needed for $d(x(t))$. 
-In other words, we turn a problem of finding $p$-th order pushforward for $f$, to a problem of finding $p-1$-th order pushforward for $d$, and we can recurse down to the first order. 
-The first-order derivative expressions are captured from ChainRules.jl, which made this process fully automatic.
+In other words, we turn a problem of finding $p$-th order pushforward for $f$, to a problem of finding $(p-1)$-th order pushforward for $d$, and we can recurse down to the first order. 
+The first-order derivative expressions are captured from ChainRules.jl, which makes this process fully automatic.
 
-This strategy is in principle equivalent to nesting first-order differentiation, which could potentially leads to exponential scaling; however, in practice there is a huge difference. 
-This generation of pushforward rule happens at **compile time**, which gives the compiler a chance to check redundant expressions and optimize it down to quadratic time. 
-Compiler has stack limits but this should work for at least up to order 100.
+This strategy is in principle equivalent to nesting first-order differentiation, which could potentially lead to exponential scaling; however, in practice there is a huge difference. 
+This generation of pushforward rules happens at **compile time**, which gives the compiler a chance to check redundant expressions and optimize it down to quadratic time. 
+The compiler has stack limits but this should work at least up to order 100.
 
-In the current implementation of TaylorDiff.jl, all $\log$-like functions' pushforward rules are generated by this strategy, since their derivatives are simple algebraic expressions; some $\exp$-like functions, like sinh, is also generated; the most-often-used several $\exp$-like functions are hand-written with hand-derived recurrence relations.
+In the current implementation of TaylorDiff.jl, all $\log$-like functions' pushforward rules are generated by this strategy, since their derivatives are simple algebraic expressions; some $\exp$-like functions, like $\sinh$, are also generated; several of the most-often-used $\exp$-like functions are hand-written with hand-derived recurrence relations.
 
 If you find that the code generated by this strategy is slow, please file an issue and we will look into it.