It is a standard result that any Cartan subalgebra of a (complex) semisimple Lie algebra has the same size, so what’s going on?

The answer is simple: Poincaré isn’t a semisimple Lie algebra. Therefore we have to be careful about how to define the rank. First, let’s see why Poincaré isn’t semisimple.

Definition. If is a complex Lie algebra, then an ideal in is a complex subalgebra of such that, for all and , .

The brackets of a Lie algebra can be thought of as a product of two elements in that algebra. Then, an ideal (as always), is a sort of ‘zero’, making anything it multiplies a member of itself (just like for any ).

Definition. A complex Lie algebra is called simple if , and the only ideals in are and .

Definition. A complex Lie algebra is called semisimple if it’s (isomorphic to) a direct sum of simple Lie algebras.

We can now see why the Poincaré algebra isn’t simple. Translations, namely , form a basis for an ideal: Translations commute, and the commutator of a translation with a rotation is a sum of translations. It is also not semisimple, which I guess can be seen by considering the decomposition of the Lorentz subalgebra, then adding translations which will ‘link’ the two components.

The Cartan can be defined for non-semisimple algebras, and it turns out it is the Cartan of the largest semisimple subalgebra. In the case of Poincaré, the largest semisimple subalgebra is the Lorentz subalgebra. So we can still define the rank to be the size of the Cartan, with this more general definition. I don’t know if the relation between the number of Casimirs and the rank still holds in this case, but at least for the Poincaré algebra it does turn out correctly, since the rank of the Lorentz algebra is 2.

This function should be taken outside and shot.

I want to give my own derivation, which I hope is clear and straightforward. If you’re already familiar with the transform, you can skip straight to Derivation of the Legendre Transform.

Some Background

Let’s start with the definition. If you have a function f(x), its Legendre transform is a function g(p), where p is thought of as f(x)’s derivative. g(p) is defined as:

This definition is already confusing, because x is considered a function of p. This function is found by solving the following equation for x:

To clarify matters, let’s consider an example. Take , then:

The Legendre transform is then:

Okay, what is it good for? The usual explanation starts with some geometric construction like the one you see on Wikipedia(*). Then, to explain why the transform works, you are shown the differential:

And the conclusion is that g is indeed a function of p, which is f’s derivative. Mathematically speaking, this argument is quite unconvincing, because saying that g is a function of f’(x) has no meaning. g is a function of some real number, and this number has no intrinsic connection to any derivatives.

One possible relation could be that g and f agree if you give the corresponding arguments:

but this is not the case! Some better explanation is obviously needed.

Derivation of the Legendre Transform

We define as before:

And we are looking for a function g(p). The crucial point is this: We require that g’s derivative will correspond to x:

Rigorously, this means:

Where p(x) is the function defined by the first requirement.

Now we have something we can use. We look at the function g(p(x)) and we calculate:

Both requirements were used in the last transition. We now integrate this equation by dx:

Integrating by parts on the right-hand side:

Thus g(p) is defined up to a constant, and choosing C=0 we get the familiar Legendre transform:

Motivation

Finally, I want to comment on this second requirement that x=g’(p), which is how I came up with this derivation. In Thermodynamics, the important parameters of a problem always come in pairs: Pressure and Volume, Temperature and Entropy, Number of particles and the Chemical constant, and so on. They are paired by the First Law, which is conservation of energy:

So here, the internal energy U is a natural function of S,V,N. Its partial derivatives are T,-P, and mu. Of course it can depend on other variables and there are other derivatives, but these are the ones that are easiest to calculate.

The Legendre transform is used to get new forms of energy that are naturally dependent on other parameters. This is done by switching between pairs of variables. For instance, if you know the temperature T instead of the entropy S, you can transform like this:

F is called the ‘Helmholtz Free Energy’, and its natural parameters are T,V,N:

So T, which was a derivative before, is now a parameter. But equally as important, S is now a derivative. This is very important because it allows us to calculate S very easily. If we had a new function F=F(T,V,N) that wouldn’t allow simple calculation of S, it would be useless. This is what makes the Legendre transform so useful.

Having said that, we now see that we can define other transforms by changing this requirement. We still get functions that can be thought of as ‘functions of the derivative of f’. For example, require:

Where a,b are some arbitrary parameters. Then we get a new transform:

Perhaps this method can generate some other useful transforms.

(*) I just saw that Wikipedia has something that is related to my explanation under ‘Another definition’, although it goes through a different route and still uses the geometric requirements.

In my first implementation of the solution I used a simple method to calculate the derivative:

-
This is just the average of the right and left derivatives. I wanted to improve the accuracy of the derivative calculation because of various reasons, so I turned to Savitsky-Golay filters, which were also described in the previous post. Using this method you get a digital filter that you apply to your data. If you’re not familiar with digital filters, you can think of a filter as an array of numbers which are applied to your function f as follows:

-
(I’m probably mixing up some of the signs here, but the intention is clear I’m sure). To calculate a derivative using S-G, you first apply their filter to your data, and then divide by the spatial resolution dx — the distance between adjacent points on the grid. It is worth noting that there is a highly efficient way of doing this calculation using FFT. For more details, see Numerical Recipes.

I implemented S-G and tested it using a simple sin(x) function, and it worked flawlessly. But after I inserted it into my main program, the simulation started spewing out strange results. After some debugging I discovered something very strange: Using S-G, the derivative of a constant function wasn’t zero, and in one case reached . How odd! Debugging further, I found that non-zero derivatives only happened when the initial function f had very large (and constant) values, on the order of , and dx was very small, about .

To continue debugging, I dropped the fancy FFT convolution and switched to straightforward calculation — the one that’s shown in the last equation. This finally revealed the problem: When multiplying each value of the function f by the factor and summing, some of the least significant bits are lost, because the numbers don’t all have the same exponent. So even though the calculation is accurate, the limitation of the computer’s double precision causes a loss of data. When the convolution is done, you’re left with a small value that’s not zero. But then to get the derivative you divide by dx, a very small number, and this shoots that small error through the roof. The smaller dx, the larger the derivative of the constant function! So once again, decreasing dx actually caused a larger error.

What helped me solve this problem was noticing that the S-G coefficients are anti-symmetric, i.e. . Specifically, anti-symmetric coefficients have the same exponent. Therefore I changed the summing order to sum pairs of anti-symmetric factors:

-
This solved the problem: Constant functions now had a zero derivative, because each term in the sum was exactly zero, even in double precision. And the happy consequence was that this fix also solved the weird simulation results I started with.

PDE Primer

In case you’re not familiar with the terminology, I’ll first explain what a PDE is. A simple equation contains one or more unknowns which represent numbers. For example: . An ordinary differential equation (ODE) is similar, except the unknown is a function rather than a number. Such an equation involves derivatives of the function. Here is an example:

-
The solution of this particular equation is , where can be any number. Finally, a partial differential equation (PDE) involves a function that has two or more parameters, and includes partial derivatives of this function. For example, the following equation describes waves propagating through a medium:

-
PDEs are very important in physics. In fact, many of the basic laws of nature are described as PDEs. Examples include Maxwell’s equations, Shcrodinger’s equation, and Einstein’s field equations.

On to the simulation!

Pitfall 1: Exploding Waves

So, I built my model for the problem, derived the equations, and was ready to solve them. By ‘solving’ I mean that I start out with the known function at time t=0, and I want to find out what that function is at a later time. My function initially looked like this:

Some thousands of time-steps later, it evolved into this:

So far so good, but then it completely exploded:

Going back a bit in time, I was able to trace the beginning of this explosion:

And zooming in on the ‘wavy’ part:

It looked as though waves were forming on my function, and then ‘exploding’.

Inherent Instabilities

I was certain I had a bug, but I couldn’t find it. While debugging, at one point I decreased the spatial resolution — using less points per unit of space to describe the function… and the problem was gone! So, decreasing the accuracy of my solution actually solved the instability… That was very weird.

Mentioning this to a Ph.D student at the lab, he said this problem sounded familiar to him. And as it turns out, this is a universal problem with PDEs: If the time step is too large compared with the spatial resolution, the amplitude of small waves with short wavelengths quickly increases with time until they dominate the solution. This is due to the way numerical derivatives are calculated. The difficulty here is that the time step needs to be incredibly small, making calculation unfeasible. For some equation, the situation is even worse, as they are unstable for any time step, no matter how small.

For simple PDEs, it is very easy to see this effect by taking the function f to be a wave, and watching what happens to the amplitude over time. You can see a derivation of this result here. For a more in-depth discussion, Numerical Recipes is your friend. This method of analyzing equations is called von Neumann stability analysis.

In Comes Lax

Okay, so I found out not alone, but what can be done to solve this problem? The first thing I tried was to calculate the derivative more accurately. There is a method called Savitzky-Golay, where you fit a polynomial to your function at each point, and calculate the polynomial’s derivative at that point. The brilliant thing is that this whole operation (fit + derive) can be done using a single convolution, which costs a meager O(n log n) of processing time.

So I implemented S-G, only to discover it doesn’t solve the problem. More on that in a future post.

As it turns out, there is an incredibly simple solution due to Lax, which says the following. When advancing the function value to the next time step, you do something like this for each position:

-
The Lax method says that the f[j] at the right-hand side should be replaced by an average of it’s neighboring cells:

-
And that’s it! This replacement causes a numerical diffusion that ‘sedates’ the unruly waves, causing them to decay instead of explode. The time step used in the simulation still needs to be below some value, but now it decreases linearly with the spatial distance dx, which is much better than before. So Lax saved the day — and that was the end of my first pitfall. This is getting to be quite a long post, so I’ll describe the second problem in another post. Cheers!

Let be a real function such that has a limit at each point. Does have at least one continuity point?

Everything you need to solve this question is covered in the first year or so of undergraduate math. Don’t continue reading if you want to try solving it yourself…

Solution. We will show that has a continuity point. has a limit at each point, so let be a function such that

Which means that for all such x

or

Therefore, . But for large enough , we must have

Likewise we can define

We were in the office a while back, and we started talking about compound interest. You can calculate compound interest over different time intervals: Yearly, monthly, weekly, and so on. What will happen if we take the limit as the interval approaches zero, i.e. use continuous time? How much interest will we get?

Let’s see. If M(t) is the money you have at time t, how much money will you have at t+dt for some interval dt? That’s M(t) plus an additional amount that’s proportional to M(t) — the interest. Let’s assume this additional amount is also proportional to dt (this seems like a reasonable assumption to make). So we get:

For some constant which will determine the rate at which interest is accumulated. Rearranging, we get:

And the limit as dt approaches zero is:

So this tells us continuous compound interest grows exponentially in time, which isn’t too surprising when you think about it.

After working this out at the office, that final equation was left on the whiteboard. A couple of days later, our product manager walked in and saw it. He immediately recognized it. Apparently, this formula was taught in his MBA program as the maximum amount of interest one can get…

This model is used to calculate various properties of magnets. For example, suppose we want to measure the average magnetization of the grid in a given temperature. The magnetization of a specific state is just the sum of all the spin values in that state. So if all the spins are up and the grid size is 5×5, the magnetization is 25. To calculate the average magnetization, we’d have to know the probability of each state. We’d then multiply each state’s magnetization by the probability of reaching that state, and sum over all the states. The probability distribution is given by the Maxwell-Boltzmann distribution, an important result of statistical physics.

If the grid size is sufficiently small (up to about 5×5), we can actually go over all the possible states and calculate an accurate average value for the magnetization. What is the most efficient way of going over all the states? It is very convenient to implement this algorithm by flipping just one spin at a time. In this case, the most efficient algorithm would iterate over the possible states by flipping just one spin in each step.

Let’s think of a state as a series of bits, 0 meaning a spin value of ‘down’ and 1 meaning a spin value of ‘up’. We can think of this series as a binary number, and iterate the states by incrementing this number. For example, if the grid size is 2×2, then we can iterate as follows: 0000, 0001, 0010, 0011, 0100, … This method works, but it takes more than one spin to switch states (on average). For example, going from 0111 to 1000 requires 4 flips. It is easy to see that the average number of flips per step for a series of length n is approximately:

With the limit taken as .

Let’s try to improve on this. In a previous post, I noted that we can think of a hypercube’s vertex as a series of bits. So iterating over all the spin states is like walking on a hypercube, visiting all of its vertices. We want to flip just one spin at each step — that would be the most efficient algorithm. In the hypercube analogy, this is the same as saying we are allowed to walk only on the graph’s edges, because edges only connect vertices that differ by exactly one bit. So now we’re trying to find an algorithm that walks the edges of a hypercube, vists all the vertices, and vists each vertex exactly once. This is almost the definition of a Hamilton circuit, except we don’t have to go back to the first vertex at the end.

Trying it out for a 3D cube, it’s obviously very easy to do this: We can start at the top face and walk through the 4 vertices there. Then we can ‘climb down’ to the bottom face, and finish walking through the bottom 4 vertices. We can generalize this concept inductively: Given such an algorithm for an (n-1)-hypercube, we can use it to build an algorithm for an n-hypercube: Start with the vertex 0000…0, and use the (n-1) algorithm to go over all the 0xxx..x vertices. Let’s say the algorithm finishes at vertex 0111…1. Next, ‘climb up’ to vertex 1111…1, and run the (n-1) algo. backwards to go through all the ‘upper’ states, reaching 1000…0. We can even complete a full Hamilton cycle by climbing back down to 0000…0.

Of course, we have an algorithm for n=0, so inductively we get an algorithm for every n. This algorithm goes over all the states, using just one flip (or edge) for each step.

When I told my girlfriend about my discovery, she told me this was a well-known method called Gray code. Party pooper.

MSD	Probability
1	0.26
2	0.20
3	0.10
4	0.13
5	0.07
6	0.08
7	0.07
8	0.05
9	0.04

The MathWorld article offers an explanation in terms of distributions that are invariant under changes of the measurement unit. I have to say, I wasn’t entirely convinced by that explanation. I’d like to offer a different theory that might account for this phenomenon.

Suppose X is a real random variable with a distribution P(X). For example, X may represent the population of a nation. Further suppose that P(X) is monotonically decreasing in X, and that X ranges from 1 to +infinity. Now look at the most-significant digit of X. I claim that, in this very common situation, ’1′ will be more likely than the rest of the digits. Further, ’1′ will be more likely than ’2′, which will be more likely than ’3′, and so on.

To prove this claim, let’s consider different orders of 10. With 10^0, i.e. the range 1 through 10, what is the likelihood that 1 is the MSD (most significant digit)? That’s the likelihood that X is between 1 and 2, or P([1,2)). Similarly, the likelihood that digit 'k' is the MSD is P([k,k+1)). Because P(X) is monotonically decreasing, we have P([1,2)) > P([2,3)) > ... > P([9,10)).

Now let's look at 10^1. In the same manner, the range [10, 20) is more likely than [20, 30), and so on. And the same is true for any order of 10. Now, what is the probability of getting 1 as an MSD when we select X at random? That's the sum over all orders of 10:

And the probability of getting 2 as the MSD? That’s

.

We already showed that, for any k, , hence . In the same manner, and so on. QED

So ’1′ is more likely than ’2′, but can this account for the difference we see in Benford’s law? (There, ’1′ is more likely than ’2′ by a factor of about 2). It’s hard to say, because we don’t have the probability distributions for the datasets he used. But we can look at another, well-known distribution — the power law distribution:

.

This distribution occurs in many natural phenomena, including, for example, the sizes of earthqukes. It is also a monotonically decreasing distribution, so it fits the bill. Let’s calculate the likelihood of getting an MSD of ‘m’:

[Unparseable or potentially dangerous latex formula. Error 5 : 571x44]

Now let’s plug in some numbers. Let’s take and calculate the probability ratio between an MSD of ’1′ and ’2′:

Which is even greater than the ratio of about 2 as appears in mathworld.

As a final note, using Zipf’s law I checked a couple of datasets on the CIA fact book, and they do not distribute according to a power law. So what I’ve shown isn’t a direct explanation of Benford’s law for these datasets. But it does explain why Benford’s law appears in many naturally-occuring phenomena.

I can say now that all that studying paid off, as I was able to swing back at almost all the topological curvballs prof. Lapid threw at us. There was one question that stumped me though. Here it is. If you can solve it, more power to ya (and please let me know the answer!)

Let be a continuous, injective function from the sphere (that’s the unit sphere in ) to some metrizable space Y. Is the image necessarily homeomorphic to ?

Anyway, while studying I stumbled on a fun little something involving polarizing sunglasses. More on that in a future post.