*x*³ + *bx*² + *cx* + *d* = 0

to one of the form

*y*³ + *py* + *q* = 0.

This process can be carried further through Tschirnhausen transformations, a generalization of an idea going back to Ehrenfried Walther von Tschirnhaus in 1683.

For a polynomial of degree *n* > 4, a Tschirnhausen transformations is a rational change of variables

*y* = *g*(*x*) / *h*(*x*)

turning the equation

*x*^{n} + *a*_{n-1} *x*^{n-1} + *a*_{n-2} *x*^{n-2} + … + *a*_{0} = 0

into

*y*^{n} + *b*_{n-4} *y*^{n-4} + *b*_{n-5} *y*^{n-5} + … + *b*_{0} = 0

where the denominator *h*(*x*) of the transformation is not zero at any root of the original equation.

I believe the details of how to construct the transformations are in An essay on the resolution of equations by G. B. Jerrad.

where *x* is a function of *t*. Typically *x* is position and *t* is time.

This form of equation is common for differential equations coming from mechanical systems. The form is more general than it may seem at first. It does not allow terms involving first-order derivatives, but these terms can often be eliminated via a change of variables. See this post for a way to eliminate first order terms from a linear ODE.

The leapfrog integrator is also known as the Störmer-Verlet method, or the Newton-Störmer-Verlet method, or the Newton-Störmer-Verlet-leapfrog method, or …

The leapfrog integrator has some advantages over, say, Runge-Kutta methods, because it is specialized for a particular (but important) class of equations. For one thing, it **solves the second order ODE directly**. Typically ODE solvers work on (systems of) first order equations: to solve a second order equation you turn it into a system of first order equations by introducing the first derivative of the solution as a new variable.

For another thing, it is **reversible**: if you advance the solution of an ODE from its initial condition to some future point, make that point your new initial condition, and reverse time, you can step back to exactly where you started, aside from any loss of accuracy due to floating point; in exact arithmetic, you’d return to exactly where you started.

Another advantage of the leapfrog integrator is that it approximately **conserves energy**. The leapfrog integrator could perform better over time compared to a method that is initially more accurate.

Here is the leapfrog method in a nutshell with step size *h*.

And here’s a simple Python demo.

import numpy as np import matplotlib.pyplot as plt # Solve x" = f(x) using leapfrog integrator # For this demo, x'' + x = 0 # Exact solution is x(t) = sin(t) def f(x): return -x k = 5 # number of periods N = 16 # number of time steps per period h = 2*np.pi/N # step size x = np.empty(k*N+1) # positions v = np.empty(k*N+1) # velocities # Initial conditions x[0] = 0 v[0] = 1 anew = f(x[0]) # leapfrog method for i in range(1, k*N+1): aold = anew x[i] = x[i-1] + v[i-1]*h + 0.5*aold*h**2 anew = f(x[i]) v[i] = v[i-1] + 0.5*(aold + anew)*h

Here’s a plot of the solution over five periods.

There’s a lot more I hope to say about the leapfrog integrator and related methods in future posts.

Dirichlet’s integral for *v*, also called the Dirichlet energy of *v*, is

Among functions with specified values on the boundary of Ω, Dirichlet’s principle says that minimizing Dirichlet’s integral is equivalent to solving Laplace’s equation.

In a little more detail, let *g* be a continuous function on the boundary ∂Ω of the region Ω. A function *u* has minimum Dirichlet energy, subject to the requirement that *u* = *g* on ∂Ω, if and only if *u* solves Laplace’s equation

subject to the same boundary condition.

Dirichlet’s principle requires some hypotheses not stated here, as Hadamard’s example below shows.

Let *g*(θ) be the function [1]

The function *g* is continuous and so there exists a unique solution to Laplace’s equation on the unit disk with boundary values given by *g*, but the Dirichlet energy of the solution diverges.

The solution, in polar coordinates, is

The Laplace operator in polar coordinates is

and you can differentiate *u* term by-term to show that it satisfies Laplace’s equation.

Dirichlet’s integral in polar coordinates is

Integrating term-by-term, the *n*th term in the series for the Dirichlet energy in Hadamard’s example is

and so the series rapidly diverges.

Dirichlet’s principle requires that there be at least one function satisfying the specified boundary conditions that has finite Dirichlet energy. In the example above, the solution to Laplace’s equation with boundary condition *g* has infinite Dirichlet energy. It turns out the same is true for every function satisfying the same boundary condition, whether it satisfies Laplace’s equation or not.

[1] What is the motivation for this function? The function is given by a **lacunary series**, a Fourier series with increasingly large gaps between the frequency components. The corresponding series for *u* cannot be extended to an analytic function outside the closed unit circle. If it could be so extended, Dirichlet’s principle would apply and the example wouldn’t work.

The problem is putting the pieces back together. If you’ve only written small programs, you haven’t had many pieces to put together. It’s harder to put the pieces together when you write a large program by yourself. It’s even harder when you work on a large program with other people.

Synthesis is harder than analysis. Or as Perdita Stevens put it, integration is harder than separation.

The image above is a screenshot from her keynote at the RC2020 conference on reversible computation.

**Related post**: The cost of taking things apart and putting them back together.

The variation between mortality in different states is really large. *Something* caused that, though not the length of the names. But **here’s the kicker**: you may come up with an explanation that’s much more plausible than length of name, and be just as wrong. Discovering causation is hard work, much harder than looking for correlations.

Morse code is a sort of approximate Huffman coding of letters: letters are assigned symbols so that more common letters can be transmitted more quickly. You can read about how well Morse code achieves this design objective here.

But digits in Morse code are kinda strange. I imagine they were an afterthought, tacked on after encodings had been assigned to each of the letters, and so had to avoid encodings that were already in use. Here are the assignments:

|-------+-------| | Digit | Code | |-------+-------| | 1 | .---- | | 2 | ..--- | | 3 | ...-- | | 4 | ....- | | 5 | ..... | | 6 | -.... | | 7 | --... | | 8 | ---.. | | 9 | ----. | | 0 | ----- | |-------+-------|

There’s no attempt to relate transmission length to frequency. Maybe the idea was that all digits are equally common. While in some contexts this is true, it’s not true in general for mathematical and psychological reasons.

There is a sort of mathematical pattern to the Morse code symbols for digits. For 1 ≤ *n* ≤ 5, the symbol for *n* is *n* dots followed by 5-*n* dashes. For 6 ≤ *n* ≤ 9, the symbol is *n*-5 dashes followed by 10-*n* dots. The same rule extends to 0 if you think of 0 as 10.

A more mathematically satisfying way to assign symbols would have been binary numbers padded to five places:

0 -> ..... 1 -> ....- 2 -> ..._. etc.

Because the Morse encoding of digits is awkward, it’s not easy to describe succinctly. And here is where golf comes in.

The idea of code golf is to write the shortest program that does some task. Fewer characters is better, just as in golf the lowest score wins.

**Here’s the challenge**: Write two functions as small you can, one to encode digits as Morse code and another to decode Morse digits. Share your solutions in the comments below.

A natural question is just what kind of circle approximates the corners. This post answers that question, finding the radius of curvature of the osculating circle.

The squircle has a parameter *p* which determines how close the curve is to a circle or a square.

The case *p* = 2 corresponds to a circle, and in the limit as *p* goes to infinity you get a square.

We’ll work in the first quadrant so we can ignore absolute values. The curvature at each point is complicated [1] but simplifies in the corner to

and the radius of curvature is the reciprocal of this. So for moderately large *p*, the radius of curvature is approximately √2/(*p*-1).

In the image at the top of the post, *p* = 3.5. Here’s an image with a larger value of *p*, *p* = 10.

And here’s one with a smaller value, *p* = 2.5.

When *p* = 2 we get a circle. When *p* is between 1 and 2 we get more of a diamond than a square. Notice in the image below with *p* = 1.5 the osculating circle is larger than the squircle, and the “corner” is nearly the whole side.

Finally, for *p* between 0 and 1 the sides of the diamond cave in giving a concave shape. Now the osculating circle is on the outside.

[1] The general expression is

]]>One example was a post where I commented on a song from Fiddler on the Roof where Teva sings

If I were a rich man,

Yubba dibby dibby dibby dibby dibby dibby dum.

Another example is a post on cryptography describes a very large number as “over 400 million million million million.”

As I mentioned in the post on double words, logarithms of logarithms come up often in number theory. For example, the time it would take Shor’s algorithm to factor an *n*-digit number is

O( log(n)² log(log(n)) log(log(log(n))) )

I mentioned that in a post and added in a footnote

Obligatory old joke: What sound does a number theorist make when drowning? log log log …

Finally, I wrote a post called Gamma gamma gamma!, an allusion to the WWII film Tora! Tora! Tora!. The post explains how the gamma function, the gamma constant, and the gamma distribution are all related.

]]>In general the curvature of a curve at a point is defined to be the curvature of the circle that best fits at that point. This circle is called the **osculating circle** which means the circle that “kisses” the curve at that point.

From Online Etymology Dictionary:

osculate (v.) “to kiss (one another),” 1650s, from Latin osculatus, past participle of osculari “to kiss,” from osculum “a kiss; pretty mouth, sweet mouth,” literally “little mouth,” diminutive of os “mouth”

The center of the osculating circle is called the **center of curvature** and the radius of the circle is called the **radius of curvature**.

I’ll give two examples. The first is a set of ellipses that all have the unit circle as their osculating circle on the left end. So they all have curvature 1.

An ellipse with equation

has varying curvature at each point. At *x* = –*a* the curvature simplifies to *a*/*b*². So to make the graph above, I used a range of values for *a* and set each corresponding value of *b* to √*a*.

Next, instead of fixing the osculating circle I’ll fix the curve. I’ll use the equation to fit an egg that I’ve used before and plot the osculating circles at each end. The plot below uses *a* = 3, *b* = 2, and *k* = 0.1.

The curvature at the fat end is *a*(1-*ka*)/*b*² and the curvature at the pointy end is *a*(1+*ka*)/*b*². These are derived here.

Setting *k* = 0 gives the curvature of an ellipse at each end used above.

I’ve been looking through my web site to purge erroneous double words, and found a few doubles that are correct in context but would probably be incorrect elsewhere.

In ordinary English prose, **long long** is probably not what the author intended. There should either be a comma between the two words or a different choice of words. But in C code snippets, you’ll see `long long`

as a type of integer. Also, it is common in many programming languages for a type and a variable to have the same name with varying capitalization, such as `FILE file`

in C.

There are several pages on my site that refer to the **Blum Blum Shub** cryptographic random number generator. (The name of this algorithm always makes me think of a line from Night at the Museum.)

There are several pages on this site that use **log log**, always in the context of number theory. Logarithms of logarithms come up frequently in that context.

I also refer to **unknown unknowns**. The press ridiculed Donald Rumsfeld mercilessly when he first used this expression, but now the phrase is commonly used because more people understand that it names an important concept. It comes up frequently in statistics because so much attention is focused on known unknowns, even though unknown unknowns are very often the weakest link.

***

By the way, if you’d like to make a list of doubled words in a file, you could run the following shell one-liner:

egrep -i -o '\<([a-z]+) \1\>' myfile | sort | uniq > doubles

I used something like this on a backup of my site to search for doubled words.

]]>where *M* is large and *f* is an increasing function. For large *M*, the integral is asymptotically

That is, the ratio of *A*(*M*) to *I*(*M*) goes to 1 as *M* goes to infinity.

This looks like a strange variation on Laplace’s approximation. And although Laplace’s method is often useful in practice, no applications of the approximation above come to mind. Any ideas? I have a vague feeling I could have used something like this before.

There is one more requirement on the function *f*. In addition to being an increasing function, it must also satisfy

In [1] the author gives several examples, including using *f*(*x*) = *x*². If we wanted to approximate

the method above gives

exp(10000)/200 = 4.4034 × 10^{4340}

whereas the correct value to five significant figures is 4.4036 × 10^{4340}.

Even getting an estimate of the order of magnitude for such a large integral could be useful, and the approximation does better than that.

[1] Ira Rosenholtz. Estimating Large Integrals: The Bigger They Are, The Harder They Fall. The College Mathematics Journal, Vol. 32, No. 5 (Nov., 2001), pp. 322-329

]]>*y* = *x*²

is a parabola and the graph of

*y* = cosh(*x*) = (*e*^{x} + *e*^{–x})/2

is a catenary. You’ve probably seen parabolas in a math class; you’ve seen a catenary if you’ve seen the St. Louis arch.

Depending on the range and scale, parabolas and catenaries can be too similar to distinguish visually, though over a wide range enough range the exponential growth of the catenary becomes apparent.

For example, for *x* between -1 and 1, it’s possible to scale a parabola to match a catenary so well that the graphs practically overlap. The blue curve is a catenary and the orange curve is a parabola.

The graph above looks orange because the latter essentially overwrites the former. The relative error in approximating the catenary by the parabola is about 0.6%.

But when *x* ranges over -10 to 10, the best parabola fit is not good at all. The catenary is much flatter in the middle and much steeper in the sides. On this wider scale the hyperbolic cosine function is essentially *e*^{|x|}.

Here’s an intermediate case, -3 < x < 3, where the parabola fits the catenary pretty well, though one can easily see that the curves are not the same.

Now for some details. How are we defining “best” when we say best fit, and how do we calculate the parameters for this fit?

I’m using a least-squares fit, minimizing the *L*² norm of the error, over the interval [*M*, *M*]. That is, I’m approximating

cosh(*x*)

with

*c* + *k**x*²

and finding *c* and *k* that minimize the integral

The optimal values of *c* and *k* vary with *M.* As *M* increases, *c* decreases and *k* increases.

It works out that the optimal value of *c* is

and the optimal value of *k* is

Here’s a log-scale plot of the *L*² norm of the error, the square root of the integral above, for the optimal parameters as a function of *M.*

The first time I wrote about the Sierpiński triangle was when it came up in the context of a simple random process called the chaos game.

Next I ran into Sierpiński in the context of cellular automata, specifically Rule 90. A particular initial condition for this rule leads to the image below. With other initial conditions you don’t get such a clean Sierpiński triangle, but you do get similar variations on the theme.

Next I ran into Sierpiński in the context of low-level programming. The following lines of C code prints an asterisk when the bit-wise and of two numbers is non-zero.

for (int i = 0; i < N; i++) { for (int j = 0; j < N; j++) printf("%c", (i&j) ? ' ' : '*'); printf("\n"); }

A screenshot of the output shows our familiar triangle.

Then later I wrote a post looking at constructible *n*-gons, *n*-sided figures that can be constructed using only a straight edge and a compass. These only exist for special values of *n*. If you write these special values in binary, and replace the 1’s with a black square and the 0’s with a blank, you get yet another Sierpiński triangle.

Finally, if you look at the odd numbers in Pascal’s triangle, they also form a Sierpiński triangle.

]]>If we replace the ellipse with an egg, we get a similar shape, but less symmetric.

The equation for the egg is described here with parameters *a* = 3, *b* = 2, and *k* = 0.1. The ellipse above has the same *a* and *b* but *k* = 0.

I made the lines slightly transparent, setting alpha = 0.4, so the graph would be darker where many lines cross.

Related post: Envelopes of epicycloids

]]>A researcher comes to talk to a statistician. The statistician asks what effect size the researcher wants to detect. Do you think the new thing will be 10% better than the old thing? If so, you’ll need to design an experiment with enough subjects to stand a good chance of detecting a 10% improvement. Roughly speaking, sample size is inversely proportional to the square of effect size. So if you want to detect a 5% improvement, you’ll need 4 times as many subjects as if you want to detect a 10% improvement.

You’re never guaranteed to detect an improvement. The race is not always to the swift, nor the battle to the strong. So it’s not enough to think about what kind of effect size you want to detect, you also have to think about how likely you want to be to detect it.

Here’s what often happens in practice. The researcher makes an arbitrary guess at what effect size she expects to see. Then initial optimism may waver and she decides it would be better to design the experiment to detect a more modest effect size. When asked how high she’d like her chances to be of detecting the effect, she thinks 100% but says 95% since it’s necessary to tolerate some chance of failure.

The statistician comes back and says the researcher will need a gargantuan sample size. The researcher says this is far outside her budget. The statistician asks what the budget is, and what the cost per subject is, and then the real work begins.

The sample size the negotiation will converge on is the **budget divided by the cost per sample**. The statistician will fiddle with the effect size and probability of detecting it until the inevitable sample size is reached. This sample size, calculated to 10 decimal places and rounded up to the next integer, is solemnly reported with a post hoc justification containing no mention of budgets.

Sample size is always implicitly an economic decision. If you’re willing to make it explicitly an economic decision, you can compute the expected value of an experiment by placing a value on the possible outcomes. You make some assumptions—you always have to make assumptions—and calculate the probability under various scenarios of reaching each conclusion for various sample sizes, and select the sample size that leads to the best expected value.

- Robustness and the two-sample t-test
- Dose finding is not dose escallation
- Stopping trials of ineffective drugs sooner

[1] There are three ways an A/B test can turn out: A wins, B wins, or there isn’t a clear winner. There’s a tendency to not think enough about the third possibility. Interim analysis often shuts down an experiment not because there’s a clear winner, but because it’s becoming clear there is unlikely to be a winner.

]]>The correct result is

and so the first calculation is off by 25 orders of magnitude.

But there’s a variation on the calculation above that is correct! A theorem by Édouard Lucas from 1872 that says for *p* prime and for any nonnegative integers *m* and *n*,

So while the initial calculation was grossly wrong as stated, it is perfectly correct mod 19. If you divide 487343696971437395556698010 by 19 you’ll get a remainder of 10.

A stronger versions of Lucas’ theorem [1] says that if *p* is at least 5, then you can replace mod *p* with mod *p*³. This is a stronger conclusion because it says not only is the difference between the left and right side of the congruence divisible by *p*, it’s also divisible by *p*² and *p*³.

In our example, not only is the remainder 10 when 487343696971437395556698010 is divided by 19, the remainder is also 10 when dividing by 19² = 361 and 19³ = 6859.

- Binomial coefficient trick
- Maximum gap between binomial coefficients
- Lebesgue’s proof of Weierstrass’ theorem

[1] V. Brun, J. O. Stubban, J. E. Fjeldstad, L. Tambs, K. E. Aubert, W. Ljunggren, E. Jacobsthal. On the divisibility of the difference between two binomial coefficients, Den 11te Skandinaviske Matematikerkongress, Trondheim, 1949, 42–54.

]]>You can state this as a problem in calculus of variations, which leads to a differential equation, which leads to the solution

*f*(*x*) = *c* cosh((*x* + *d*)/*c*).

In other words, the surface area is minimized when the graph of *f* is a piece of a catenary [1].

This is interesting because the answer is not something you’re likely to guess, unlike say the isoperimetric problem, where the it’s easy to guess (but hard to prove) that the solution is a circle.

There’s also some interesting fine print to the solution. It’s not quite right to say that the solution is a catenary. To be more precise we should say that **if** there is a unique catenary that passes through both specified points, then it is the smooth curve with minimal area when rotated about the *x*-axis. But there are a couple things that could go wrong.

It’s possible that two catenaries pass through the given points, and in that case one of the catenaries leads to minimal surface area. But it’s also possible that there is no catenary passing through the given points.

My first thought would be that you could always find values of *c* and *d* so that the function *f* passes through the points (*x*_{1}, *y*_{1}) and (*x*_{2}, *y*_{2}), but that’s not true. Often you can, but if the difference in the *y*‘s is very high relative to the difference in the *x*‘s it might not be possible.

Suppose the graph of *f* passes through (0, 1) and (1, *y*_{2}).

Since the graph passes through the first point, we have

*c* cosh(*d*/*c*) = 1.

Since cosh(*x*) ≥ 1, we must also have *c* ≤ 1. And since our curve is positive, we must have *c* > 0. We can maximize

*c* cosh((1 + *d*)/c)

for 0 < *c* ≤ 1 subject to the constraint

*c* cosh(*d*/*c*) = 1

to find the maximum possible value of *y*_{2}. If we ask Mathematica

NMaximize[ { c Cosh[(1 + d)/c], {0 < c <= 1}, {c Cosh[d/c] == 1} }, {c, d} ]

we get

{6.45659*10^8, {c -> 0.0352609, d -> -0.142316}}

meaning the largest possible value of *y*_{2} is 6.45659 × 10^{8}, and it occurs when *c* = 0.0352609, *d* = -0.142316.

**Update**: See the comment by Bill Smathers below arguing that the maximum should be unbounded. If the argument is correct, this would imply the code above ran into a numerical limitation.

[1] See Calculus of Variations by I. M. Gelfand and S. V. Fomin.

]]>It turns out the answer is “not really.” The rarest elements rarely appear in writing. We don’t have much to say about dysprosium, thulium, or lutetium, for example. But overall there’s only a small correlation between word frequency and chemical frequency. (The rank correlation is substantially higher than ordinary linear correlation.)

We write often about things like oxygen and iron because they’re such a part of the human experience. On the other hand, we care about some things like silver and gold precisely because they are rare.

Here are the most common elements according to text usage.

|------------+--------+-----------+---------+------------| | element | word % | word rank | earth % | earth rank | |------------+--------+-----------+---------+------------| | lead | 15.50 | 1 | 0.001 | 36 | | gold | 11.64 | 2 | 0.000 | 75 | | iron | 11.14 | 3 | 5.612 | 4 | | silver | 7.38 | 4 | 0.000 | 68 | | carbon | 5.15 | 5 | 0.012 | 17 | | oxygen | 5.13 | 6 | 45.956 | 1 | | copper | 4.61 | 7 | 0.006 | 26 | | hydrogen | 3.51 | 8 | 0.139 | 10 | | sodium | 3.38 | 9 | 2.352 | 6 | | calcium | 2.84 | 10 | 4.137 | 5 | | nitrogen | 2.79 | 11 | 0.002 | 34 | | mercury | 2.22 | 12 | 0.000 | 67 | | tin | 2.13 | 13 | 0.000 | 51 | | potassium | 1.94 | 14 | 2.083 | 8 | | zinc | 1.70 | 15 | 0.007 | 24 | | silicon | 1.12 | 16 | 28.112 | 2 | | nickel | 1.08 | 17 | 0.008 | 23 | | phosphorus | 1.05 | 18 | 0.104 | 11 | | magnesium | 0.98 | 19 | 2.322 | 7 | | sulfur | 0.84 | 20 | 0.035 | 16 | |------------+--------+-----------+---------+------------|

This is based on the Google book corpus summarized here. There’s some ambiguity; I imagine most used of “lead” are the verb and not the element name. Some portion of the uses of “iron” refer to a device for smoothing wrinkles out of clothes.

Word percentage is relative to the set of chemical element names. Earth percentage is relative to the Earth’s crust.

The percentages above have been truncated for presentation’ obviously the abundance of gold, silver, mercury, and tin is not zero, though it is when rounded to three decimal places. The full data for the first 111 elements is available here.

]]>Let *A* be a real symmetric *n*×*n* matrix, or more generally a complex *n*×*n* Hermitian matrix, with entries *a*_{ij}. Note that the diagonal elements *a*_{ii} are real numbers even if some of the other entries are complex. (A Hermitian matrix equals its conjugate transpose, which means the elements on the diagonal equal their own conjugate.)

A general theorem says that *A* has *n* eigenvalues. Denote these eigenvalues λ_{1}, λ_{2}, …, λ_{n}.

It is well known that the sum of the diagonal elements of *A* equals the sum of its eigenvalues.

We could trivially generalize this to say that for any linear function φ: *R* → *R*,

because we could pull any shifting and scaling constants out of the sum.

The theorem Sam Walters posted says that the equality above extends to an inequality if φ is convex.

Here’s an application of this theorem. Assume the eigenvalues of *A* are all positive and let φ(*x*) = – log(*x*). Then φ is convex, and

and so

i.e. the product of the diagonals of *A* is an upper bound on the determinant of *A*.

This post illustrates two general principles:

- Linear equalities often generalize to convex inequalities.
- When you hear a new theorem about convex functions, see what it says about exp or -log.

It turns out the answer is no, but apparently it is very often the case an odd number *is* just a bit flip away from being prime. I find that surprising.

Someone pointed out that 2131099 is not a bit flip away from a prime, and that this may be the smallest example [1]. The counterexample 2131099 is itself prime, so you could ask whether an odd number is either a prime or a bit flip away from a prime. Is this always the case? If not, is it often the case?

The MathOverflow question was stated in terms of Hamming distance, counting the number of bits in which two bit sequences differ. It asked whether odd numbers are always Hamming distance 1 away from a prime. My restatement of the question asks whether the Hamming distance is always *at most* 1, or how often it is no more than 1.

You could ask more generally about the Hamming distance to the nearest prime. Is it bounded, if not by 1, then by another finite number? If so, what is the smallest such bound? What is the probability that its value is 1? Etc.

This ties into a couple of other things I’ve blogged about. A few weeks ago I wrote about new work on the problem of finding the proportion of odd numbers that can be written as the sum of a power of 2 and a prime. That’s a little different problem since bit flipping is taking the XOR (exclusive or) and not always the same as addition. It also leaves out the possibility of flipping a bit beyond the most significant bit of the number, i.e. adding to a number *n* a power of 2 greater than *n*.

Another related post is on the Rowhammer attack on public key cryptography. By flipping a bit in the product of two primes, you can produce a number which is much easier to factor.

These two posts suggest a variation on the original problem where we disallow flipping bits higher than the most significant bit of *n*. So giving a *k*-bit number *n*, how often can we flip one of its *k* bits and produce a prime?

[1] Note that the bit flipped may be higher than the most significant bit of the number, unless ruled out as in the paragraph above. Several people have asked “What about 85?” It is true that flipping any of the seven lowest bits of 85 will not yield a prime. But flipping a zero bit in a more significant position will give a prime. For example, 1024 + 85 is prime. Bur for 2131099 it is not possible to add any larger power of 2 to the number and produce a prime.

]]>A report [1] that I stumbled on was concerned with shapes with boundary described by

The superellipse corresponds to α = β = 2.5, and the squircle corresponds to α = β = 4 (or so), but the report was interested in the more general case in which α and β could be different.

By changing α and β separately we can let the curvature of the sides vary separately. Here are a couple examples. Both use *A* = 0.5, *B* = 0.8, and β = 1.8. The first uses α = 3.5

and the second creates a straighter line on the vertical sides by using α** = **6.

So why was NASA interested in these shapes? According to [1], “The primary objective of the current research has been the optimun [sic] design of structural shapes” subject to the equation above and its three dimensional analog.

In order to provide material useful to the space program, it was decided to initiate the research with a determination of the geometrical and inertial properties of the above classes of shells. This was followed with a study of shells of revolution which were optimized with respect to maximum enclosed volume and minimum weight. A study on the vibration of beams was also reported in which the beam cross-section was defined by (1). Since bulkheads for bodies of type (2) require plate shapes of type (1), investigation was continued on clamped plates defined by (1).

Here (1) refers to the equation above and (2) refers to its 3-D version. The goal was to optimize various objectives over a family of shapes that was flexible but still easy enough to work with mathematically. The report [1] is concerned with computing conformal maps of the disk into these shapes in order to make it easier to solve equations defined over regions of that shape.

***

[1] The conformal mapping of the interior of the unit circle onto the interior of a class of smooth curves. Thomas F. Moriarty and Will J. Worley. NASA Contractor Report CR-1357. May 1969.

]]>The winner was a predictor-corrector scheme known as Gauss-Jackson, a method I have not heard of outside of orbital mechanics, but one apparently particularly well suited to NASA’s needs.

The Gauss-Jackson second-sum method is strongly recommended for use in either Encke or Cowell [approaches to orbit modeling]. For comparable accuracy, it will allow step-sizes larger by factors of four or more than any of the forth order methods. … As compared with unsummed methods of comparable accuracy, the Gauss-Jackson method has the very important advantage that roundoff error growth is inhibited. … The Gauss-Jackson method is particularly suitable on orbits where infrequent changes in the step-size are necessary.

Here is a table summarizing the characteristics of each of the solvers.

Notice that Gauss-Jackson is the only method whose roundoff error accumulation is described as “excellent.”

A paper from 2004 [1] implies that the Gauss-Jackson method was still in use at NASA at the time of writing.

The Gauss-Jackson multi-step predictor-corrector method is widely used in numerical integration problems for astrodynamics and dynamical astronomy. The U.S. space surveillance centers have used an eighth-order Gauss-Jackson algorithm since the 1960s.

I could imagine a young hotshot explaining to NASA why they should use some other ODE solver, only to be told that the agency had already evaluated the alternatives half a century ago, and that the competitors didn’t have the same long-term accuracy.

- Golay codes (used on Voyager)
- Reed-Solomon codes (also used on Voyager)
- Hohmann transfer orbit

[1] Matthew M. Berry and Liam M. Healy. Implementation of the Gauss-Jackson Integration for Orbit Propagation. The Journal of the Astronautical Sciences, Vol 52, No 3, July-September 2004, pp. 311–357.

]]>The most energy-efficient way to move between circular orbits is the Hohmann transfer orbit [1]. The Hohmann orbit is an idealization, but it approximates maneuvers actually done in practice.

The Hohmann transfer requires applying thrust twice: once to leave the first circular orbit into the elliptical orbit, and once again to leave the elliptical orbit for the new circular orbit.

Suppose we’re in the orbit represented by the inner blue circle above and we want to move to the outer green circle. We apply our first instantaneous burst of thrust, indicated by the inner ×, and that puts us into the orange elliptical orbit.

(We can’t move faster in our current orbit without continually applying trust because velocity determines altitude. The new orbit will pass through the point at which we applied the thrust, and so our new orbit cannot be a circle because distinct concentric circles don’t intersect.)

The point at which we first apply thrust will be the point of the new orbit closest the planet, the point with maximum *kinetic* energy. The point furthest from the planet, the point with maximum *potential* energy, will occur 180° later on the opposite side. The first burst of thrust is calculated so that the maximum altitude of the resulting elliptical orbit is the desired altitude of the new circular orbit.

Once the elliptical orbit is at its maximum distance from the planet, marked by the outer ×, we apply the second thrust. The amount of thrust is whatever it needs to be in order to maintain a circular orbit at the new altitude. The second half of the elliptical orbit, indicated by the dashed orange curve, is not taken; it’s only drawn to show the orbit we would stay on if we didn’t apply the second thrust.

So in summary, we use one burst of thrust to enter an elliptic orbit, and one more burst of thrust to leave that elliptical orbit for the new circular orbit. There are ways to move between circular orbits more quickly, but they require more fuel.

The same principles work in reverse, and so you could also use a Hohmann transfer to descend from a higher orbit to a lower one. You would apply your thrust opposite direction of motion.

There are several idealizations to the Hohmann transfer orbit. The model assume orbits are planar, that the initial orbit and the final orbit are circular, and that the two burns are each instantaneous.

The Hohmann transfer also assumes that the mass of the spacecraft is negligible compared to the planet. This would apply, for example, to a typical communication satellite, but perhaps not to a Death Star.

[1] If you’re moving from one orbit to another at 12 times the radius, then the bi-elliptic orbit maneuver would use less fuel. Instead of taking half of an elliptical orbit to make the transfer, it fires thrusters three times, using half each of two different elliptical orbits to reach the desired circular orbit.

]]>1, *x*, *x*², *x*³, …

But the power basis is not the only possible basis, and often not the most useful basis in application.

In some applications the *falling* powers of *x* are a more useful basis. For positive integers *n*, the *n*^{th} falling power of *x* is defined to be

Falling powers come up in combinatorics, in the calculus of finite differences, and in hypergeometric functions.

Since we have two bases for the vector space of polynomials, we can ask about the matrices that represent the change of basis from one to the other, and here’s where we see an interesting connection.

The entries of these matrices are numbers that come up in other applications, namely the Stirling numbers. You can think of Stirling numbers as variations on binomial coefficients. More on Stirling numbers here.

In summation notation, we have

where the *S*_{1} are the (signed) Stirling numbers of the 1st kind, and the *S*_{2} are the Stirling numbers of the 2nd kind.

(There are two conventions for defining Stirling numbers of the 1st kind, differing by a factor of (-1)^{n-k}.)

This means the (*i*, *j*)th element of matrix representing the change of basis from the power basis to the falling power basis is *S*_{1}(*i*, *j*) and the (*i*, *j*)th entry of the matrix for the opposite change of basis is *S*_{2}(*i*, *j*). These are lower triangular matrices because *S*_{1}(*i*, *j*) and *S*_{2}(*i*, *j*) are zero for *j* > *i*.

These are infinite matrices since there’s no limit to the degree of a polynomial. But if we limit our attention to polynomials of degree less than *m*, we take the upper left *m* by *m* submatrix of the infinite matrix. For example, if we look at polynomials of degree 4 or less, we have

to convert from powers to falling powers, and

going from falling powers to powers.

Incidentally, if we filled a matrix with *unsigned* Stirling numbers of the 1st kind, we would have the change of basis matrix going from the power basis to *rising* powers defined by

It may be hard to see, but there’s a bar on top of the exponent *n* for rising powers whereas before we had a bar under the *n* for falling powers.

The table below shows the four combinations of these categories and gives some examples of each.

**Runge-Kutta methods** advance the solution of a differential equation one step at a time. That is, these methods approximate the solution at the next time step using only the solution at the current time step and the differential equation itself.

**Linear multistep methods** approximate the solution at the next time step using the computed solutions at the latest several time steps.

**Explicit methods** express the solution at the next time step as an explicit function of other information, not including the solution itself. The solution at the next time step appears on only one side of the equations.

**Implicit methods** express the solution at the next time step as a function of other information including the solution itself. The solution at the next time step appears on *both* sides of the equations. Additional work needs to be done to solve for the solution.

More on explicit vs implicit methods here.

In the table above, **ERK** stands for, not surprisingly, explicit Runge-Kutta methods. **DIRK** stands for diagonally implicit Runge-Kutta. **SDIRK** stands for singly diagonally implicit Runge-Kutta. **BDF** stands for backward difference formulas.

Before I went to college, I’d heard that it took new math and science for Apollo to get to the moon. Then in college I picked up the idea that Apollo required a lot of engineering, but not really any new math or science. Now I’ve come full circle and have some appreciation for the math research that was required for the Apollo landings.

Celestial mechanics had been studied long before the Space Age, but that doesn’t mean the subject was complete. According to One Giant Leap,

In the weeks after Sputnik, one Langley [Research Center] scientist went looking for books on orbital mechanics—how to fly in space—and in the Langley technical library he found exactly one: Forest R. Moulton’s [1]

An Introduction to Celestial Mechanics. In 1958 Langley was in possession of one of the most recent editions of Moulton: the 1914 update of the 1902 edition.

I have a quibble with part of the quote above. The author describes orbital mechanics as “how to fly in space.” More technically, at the time, orbital mechanics was “how things fly through space.” **Orbital mechanics was passive**. You wanted to know how, for example, Titan moves around Saturn. Nobody asked about the most efficient way to change the orbit of Titan so that it ends up at a certain place at a certain time.

NASA needed **active** orbital mechanics. It had to do more than simply **describe** existing orbits; it had to **design** orbits. And it had to **control** orbits. None of the terms in your equations are known to infinite precision, so it is not enough to understand the exact equations under ideal circumstances. You have to understand how uncertainties in the parts impact the whole, and how to adjust for them.

And all this has to be done in a computer with about 500 kilobits of ROM [2]. Because the computer memory was limited, NASA had to know which terms in the equations could be dropped, what approximations could be made, etc. Understanding how to approximate a system well with limited resources is much harder than working with exact equations [3].

Nobody at NASA would have said “We’ve got the math in the bag. Now we just need the engineers to get busy.”

- The orbit that took men to the moon
- Proving that life exists on Earth
- Small course corrections
- Kalman filters

[1] This is the same Moulton of Adams-Moulton and Adams-Bashforth-Moulton numerical methods for solving differential equations. Presumably Mr. Moulton’s interest in numerical solutions to differential equations came out of his interest in celestial mechanics. See where Adams-Moulton fits into the ODE solver landscape in the next post.

[2] Each word in the Apollo Guidance Computer was 15 bits of data plus one check bit. There were 2048 words of RAM, 36,864 words of ROM. This amounts to 552,960 bits of ROM, excluding check bits, as much as 68 kilobytes using 8-bit bytes.

[3] Not that the “exact” equations are actually exact. When you write down the equations of motion for three point masses, for example, you’ve already done a great deal of simplification.

]]>Gabriel’s horn is the surface created by rotating 1/*x* around the *x*-axis. It is often introduced in calculus classes as an example of a surface with finite volume and infinite surface area. If it were a paint can, it could not hold enough paint to paint itself!

This post will do two things:

- explain why the paradox works, and
- explain why it’s not paradoxical after all.

Rather than working out the surface area and volume exactly as one would do in a calculus class, we’ll be a little less formal but also more general.

When you set up the integral to compute the volume of the solid bounded by rotating the graph of a function *f*, the integrand is proportional to the **square** of *f*. So rotating the graph of 1/*x* gives us an integral whose integrand is proportional to 1/*x*² and the integral converges.

When you set up the integral to compute the surface area, the integrand is proportional to *f* itself, not its square. So the integrand is proportional to 1/*x* and diverges.

For the volume to be finite, all we need is that *f* is *O*(1/*x*), i.e. eventually bounded above by some multiple of 1/*x*, and in fact we could get by with less.

For the area to be infinite, it is sufficient for the function to be Ω(1/*x*), i.e. eventually bounded below by some multiple of 1/*x*. An as before, we could get by with less.

So to make another example like Gabriel’s horn, we could use any function in Θ(1/*x*), i.e. eventually bounded above and below by some multiple of 1/*x*. So we could, for example, use

*f*(*x*) = (*x* + cos²*x*) / (x² + 42)

If you’re unfamiliar with the notation here, see these notes on big-O and related notation.

Now back to the idea of filling Gabriel’s horn with paint. If we spread the paint on the outside of the can with any constant thickness, we can only cover a finite area, but the area is infinite, so we can’t paint the whole thing.

**The resolution to the paradox** is that we’re requiring the paint to be more realistic than the can. We’re implicitly letting the material of our can become thinner and thinner without any limit to how thin it could be. If we also let our paint spread thinner and thinner as well at the right rate, we could cover the can with a coat of paint.

Notice that the plot has 7-fold symmetry. You might expect 6-fold symmetry from looking at the equation. Where did the 7 come from?

I produced the plot using the code from this post, changing the line defining the function to plot to

def f(t): return exp(6j*t)/2 + exp(20j*t)/3

You can find the solution in Eliot’s comment in this Twitter thread.

The image below comes from a previous post illustrating Gibbs phenomenon for a Chebyshev approximation to a step function.

Although Gibbs phenomena comes up in many different kinds of approximation, it was first observed in Fourier series, and not by Gibbs [1]. This post will concentrate on Fourier series, and will give an example to correct some wrong conclusions one might draw about Gibbs phenomenon from the most commonly given examples.

The uniform limit of continuous function is continuous, and so the Fourier series of a function cannot converge uniformly where the function is discontinuous. But what *does* the Fourier series do near a discontinuity?

It’s easier to say what the Fourier series does exactly *at* a discontinuity. If a function is piecewise continuous, then the Fourier series at a jump discontinuity converges to the average of the limits from the left and from the right at that point.

What the Fourier series does on either side of the discontinuity is more interesting. You can see high-frequency oscillations on either side. The series will overshoot on the high side of the jump and undershoot on the low side of the jump.

The amount of overshoot and undershoot is proportional to the size of the gap, about 9% of the gap. The exact proportion, in the limit, is given by the Wilbraham-Gibbs constant

Gibbs phenomenon is usually demonstrated with examples that have a single discontinuity at the end of their period, such as a square wave or a saw tooth wave. But Gibbs phenomenon occurs at **every **discontinuity, wherever located, no matter how many there are.

The following example illustrates everything we’ve talked about above. We start with the function *f* plotted below on [-π, π] and imagine it extended periodically.

Notice three things about *f*:

- It is continuous at the point where it repeats since it equals 0 at -π and π.
- It has two discontinuities inside [-π, π].
- One of the discontinuities is larger than the other.

The following plot shows the sum of the first 100 terms in the Fourier series for *f* plotted over [-2π, 2π].

Notice three things about this plot that correspond to the three observations about the function we started with:

- There nothing remarkable about the series at -π and π.
- You can see Gibbs phenomenon at the discontinuities of
*f*. - The overshoot and undershoot are larger at the larger discontinuity.

Related to the first point above, note that the derivative of *f* is discontinuous at the period boundary. A discontinuity in the derivative does not cause Gibbs phenomena.

Here’s a close-up plot that shows the wiggling near the discontinuities.

[1] Henry Wilbraham first described what Josiah Gibbs discovered independently 50 years later, what we now call Gibbs phenomenon. This is an example of Stigler’s law of eponymy.

]]>There is still demand for novel floating point work. Or maybe I should say there is once again demand for such work.

Companies are interested in low-precision arithmetic. They may want to save memory, and are willing to trade precision for memory. With deep neural networks, for example, quantity is more important than quality. That is, there are many weights to learn but the individual weights do not need to be very precise.

And while some clients want low-precision, others want extra precision. I’m usually skeptical when someone tells me they need extended precision because typically they just need a better algorithm. And yet some clients do have a practical need for extended precision.

Some clients don’t aren’t primarily interested precision, but they’re interested in ways to reduce energy consumption. They’re more concerned with watts than clock cycles or ulps. I imagine this will become more common.

For a while it seemed that 64-bit IEEE floating point numbers had conquered the world. Now I’m seeing more interest in smaller and larger formats, and simply different formats. New formats require new math algorithms, and that’s where I’ve helped clients.

If you’d like to discuss a novel floating point project, let’s talk.