The theorem that lets you decompose rational functions can be generalized to an abstract setting, then specialized to a theorem about integer fractions. That also is good pedagogy: specific, general, specific.

I tried to formalize a proof of the abstract partial fraction decomposition theorem using Claude. It was a partial success. I managed to get a proof that builds, but it has some sections marked as “sorry,” which means the proof is valid modulo a few specific unproven assertions.

I’ve written a couple posts lately about getting an LLM to write Prolog code to solve a chess puzzle. This afternoon I wrote a post generating Z3/Python code to solve another chess puzzle.

Last night I posted an article about testing whether a number x is a pentagonal number P_n, and if so, how to find the value of n. It’s not likely anyone will ask you to validate a pentagonal number, but you might learn something useful from the derivation of the algorithm and its implementation.

This morning I posted an article about how pentagonal numbers are the difference between two triangular numbers. This isn’t the most useful observation, but the post illustrates a proof technique that is more generally useful.

I got to thinking about pentagonal numbers because someone let me know about an error in an older post. Fixing the error gave me the idea for the posts above.

Similarly, a typo report led to my post yesterday about formally verifying the equations for converting between quaternion and matrix representations of a rotation.

I solved another chess puzzle in Prolog, this time having ChatGPT generate the code.

Someone reported a typo in a post I wrote about converting between two representations of a rotation: quaternions and matrices. I used Claude to confirm the typo and generate Lean code to prove that the equations in the updated post are correct.

I asked Claude to formalize in Lean a calculation from an earlier post computing a sine series coefficient and wrote up the results here. I also asked Claude to generate Prolog to solve a chess puzzle I’d written about before. Results here.

The ongoing brouhaha between Anthropic and the US government over Fable and Mythos is reminiscent of a time when strong encryption was classified as a munition. This post looks back at the famous “munitions T-shirt” containing Perl code for implementing RSA encryption.

Turning Fable or Mythos into a Perl one-liner would be quite impressive, especially if the result could fit on a T-shirt.

This morning I wrote the post Pulling on a thread that explains how a series of nine posts were connected. You could count that post as the 10th in the series.

This evening I wrote a post on formally proving a calculation by having Claude generate Lean code. The calculation came from one of the posts alluded to above, so you could count the latest post as the 11th in the series.

“Pulling on a thread” made me think of Arachne from Greek mythology.

M = E − e sin(E)

using a sine series in M, whose coefficients depend on E. Another way of solving the equation is to find a power series in e, whose coefficients depend on M. The latter approach, due to Lagrange, came first.

Lagrange’s method is only good for values of eccentricity e less than about 2/3. For no apparent reason, Lagrange’s series diverges for larger values of e. This means the solution might work for the orbit of one asteroid but not another. The radius of convergence for Lagrange’s series is known as the Laplace limit.

A simpler method of solving Kepler’s equation, going back to Kepler himself, is to guess a solution, plug it in, take the output as the next guess, and iterate. Kepler said doing this a couple times would be enough, and it is enough, if you don’t need much accuracy and you’re not working with highly eccentric orbits. Otherwise you might need a lot of iterations.

Someone came up with a way of reducing the number of iterations needed, foreshadowing Aitken’s acceleration method. More on that here.

The post ends with links to three series acceleration methods, due to Aitken, Euler, and Cohen.

Have a good week.

Bessel functions look completely unmotivated if you start from just the definition. And yet they come up routinely in mechanical engineering, signal processing, combinatorics, etc.

Mr. Bessel was led to study his eponymous functions because they came up in his work in celestial mechanics. One way they came up was in solving Kepler’s equation. I mentions this very briefly here and go into the detailed calculation here.

The “ed” in the title of the post is not short for Edward. It’s the ed editor.

In the early days of computing, computers didn’t have monitors; they had printers. The commands you typed and the output the computer returned both went to the printer. You could only edit a file one line at a time.

The line editor ed would let you specify a line number, or a pattern describing several lines, and an action to carry out on the line(s). It would have been challenging to use since you had to hold the context in your head, not look at it on a screen.

A lot of patterns in command line tools and programming languages go back to ed. This makes ed analogous to Latin, a dead language that gives insight into features in living languages. You could object that ed isn’t dead, but by that same reasoning you could object that Latin isn’t dead either. There may be more people who speak Latin today than who edit files with ed.

The Unix ecosystem may seem cryptic, but it’s not arbitrary. There are consistent patterns in across tools and languages, and many of these go back to ed or even further. For example, it’s common for $ to represent the end of a line or the end of a file. Once this was an arbitrary choice, but it wasn’t arbitrary for subsequent software to follow this convention.

The approximation fits well on real axis but the error along the imaginary axis grows doubly exponentially, like exp( exp(x) ). When I looked up the power series for the double exponential function I was surprised that the terms in the series count partitions and permutations.

The cosine approximation cos(sin(x) + x) is just the kind of function for which the least accurate numerical integration method, the trapezoid rule, actually works incredibly well.

Enjoy.

The term “online” is still used in computer science literature to refer to algorithms that process data in one pass. This post looks at online algorithms for computing moments of data and for computing regression coefficients.

PIT stands for polynomial identity testing. PIT is useful for far more than checking algebra homework. General computations can be expressed as algebraic circuits, and so proving a polynomial identity can validate a computation. This is widely used in zero-knowledge proofs.

The Schwartz-Zippel lemma says that if a polynomial identity holds for a set of variables chosen at random from a large finite field, the identity holds with high probability. This post fills in the details around that statement.

It is sometimes useful to approximate the Gaussian function exp(−x²) with (1 + cos(x))/2. It’s a mediocre approximation, and only useful for a small range of x. But if you replace x with x + sin(x) the approximation gets much better.

You can see part of the story by comparing power series terms. This shows that the error in the approximation is on the order of the sixth power of x. And yet this isn’t the full story. The approximation is good over the interval [−4, 4]. The error at the ends of the interval is a few orders of magnitude smaller than you might expect from looking at the power series.

Have fun reading and have a good week.

Besace curves have two parameters. I show how to find the two parameters given the height and width of the curve, then apply this to the Meta logo.

This evening I wrote a post about how to turn Kullback-Leibler divergence into a metric. In a nutshell, K-L divergence has 2 out of 4 properties of a metric. Symmetrized K-L divergence has 3 out of 4. Jensen-Shannon distance has 4 out of 4.

Includes an example showing that symmetrized K-L does not satisfy the triangle inequality. The triangle inequality is the rock that every metric wannabe washes up on.

Before that I wrote a couple posts on the real and complex parts of an analytic function. The first was about harmonic functions and harmonic conjugates. The second was about the Hilbert transform.

Enjoy.

I find all this interesting because it’s an advanced perspective on a questions that are latent in a intro calculus class. What exactly do functions like arccos mean and why where they defined as they were? These are fairly deep and interesting questions that are swept under the rug, and swept there for good reason. A calculus class has to cover an enormous amount of material and there’s no time to dwell on fine points. Some of my favorite posts look back leisurely on things that go by in a blur when you’re a student.

The first post I wrote today was a warmup, giving the connection between circular and hyperbolic functions that establishes the expectation alluded to above. This post is interesting on its own, giving a perspective on functions like sine and hyperbolic sine that you may not have seen before.

The second post defines what it means for a pair of functions to be couth or uncouth. For example, in both Mathematica and Python (i.e. NumPy) the pair (sin, sinh) is couth and the pair (cos, cosh) is uncouth.

There are circular and hyperbolic functions that are not defined in NumPy, and whether these functions form couth pairs depends on how to choose to define their inverses.

For real numbers this is simple: the square root function √x returns the positive number whose square is x. But things are more complex for complex numbers.

My latest post looks at two ways of defining the function √(z² − 1). The less obvious choice is better.

The post on √(z² − 1) was motivated by looking more carefully at an identity from this morning’s blog post. Extending the identity to all real numbers, let alone to complex numbers, is complicated. But the right definition of √(z² − 1) simplifies everything.

Looking more critically at the identity alluded to above exposes complexity, which leads to more careful choices, which eliminates complexity. This reminds me of the quote attributed to Oliver Wendell Holmes Jr.

“I would not give a fig for the simplicity this side of complexity, but I would give my life for the simplicity on the other side of complexity.”

This morning I wrote a post about Don Zagier’s variation on Markov’s equation. By changing the equation slightly Zagier was able to design an equation he could solve conveniently and use it to estimate the number of solutions to the original equation.

What I find interesting about Zagier’s approximation is that it has two forms that are not obviously equivalent:

x² + y² + z² = 3xyz + 4/9

and

f(x) + f(y) = f(z)

where f(t) = arccosh(3t/2). I show that they are indeed equivalent, and pull out Osborn’s rule along the way.

The recent series of posts started with showing that the Mersenne Twister RNG can be hacked. You can infer its internal state from its outputs. This lead to several posts on how bit operations correspond to matrix operations.

That lead to a post on the probability that a binary matrix is invertible, which lead to a a post on Euler’s function and how easily it can be computed numerically. (There are several functions known as Euler’s function. I’m referring here to the one related to partitions and q-series.)

Returning to the theme of hacking RNGs, I wrote a post on inferring the internal state of the lehmer64 RNG. And that lead to a post on how to initialize and print 128-bit unsigned integers in C.

Continuing with the theme of bit twiddling and linear algebra, the inverse of a right shift is a left shift. Except a shift always loses some information because bits fall off one end or the other. So the corresponding matrices cannot be inverses. But they are pseudoinverses.

Have a great week.

The Mersenne Twister is the prime example of the principle that a random number generator can have excellent statistical properties but bad cryptographic properties. This post describes how to reverse engineer the internal state of the MT from its output.

The most interesting part of the post is that it reverses the MT, not by the usual bit twiddling, but using linear algebra mod 2.

The MT post shows how the tempering process as a whole can be seen as multiplication by a matrix. The follow up post backs up and shows how the individual components of the MT can be represented as matrix multiplication. These operations correspond to upper- or lower-triangular matrices with 1s on the diagonal, and so they are invertible.

The tempering process corresponds to multiplication by four invertible matrices, so the whole process is invertible.

If you replace the corner of a square with a quarter of a circle, the resulting figure has one derivative where the curves patch together, but not two. The slopes match but the curvatures to not. If you tried to drive on a track with this shape, you’d have to jerk your steering wheel at the patch points.

The “squircle” is a kind of rounded square with continuous curvature. This post derives generalizes a squircle using an approach from real analysis.

This post derives a generalization using an approach from algebraic geometry.

Thanks for reading. Have a good week.

First, a note on separating the realistic and unrealistic aspects of category theory.

Second, some suggestions for keeping config files in sync across computers.

Enjoy!