Fractals to Quasiparticles

[programjames]

The Serpinski triangle is usually introduced as a fractal made up of three smaller Serpinski triangles. However, that isn’t enough to know what it looks like. Which of these is the Serpinski triangle?

The issue with recursive definitions is they create a vicious circle. To get around this, you need to specify a base case, and constructively build out your definition from there. The Python code used to generate the middle triangle looks somewhat like

import turtle
def serpinski(length, min_length=5):
   if length < min_length:
      return # Stop recursing!

   for i in range(3):
      serpinski(length / 2, min_length=min_length)
      turtle.forward(length)
      turtle.left(120)

serpinski(400)

Notice that it halts the recursion after a minimum length. Even if it were not hardcoded, Python’s builtin recursion limit or the computer’s hardware would force the base case with a RecursionError or MemoryError. Unfortunately, this also means the triangles are no longer self-similar. The outer triangle has six subdivisions, and is made out of triangles with five subdivisions. This can be rectified with an axiom of infinity; then we can choose each triangle to have an ordinal number $\omega$ of subdivisions, and since $\omega =-1+\omega$ it will be self-similar. However, at the end of the subdivisions we still need to define a base case!

Ordinal numbers are sometimes represented by bars, so

$$1=|,2=||,n=\stackrel{n\text{bars}}{\stackrel{}{|||\dots |}},\omega =|||\cdots ,$$

and the Serpinski triangle looks somewhat like

$$|||\cdots △.$$

Space too is self-similar, so it should have a base defined. In algebraic geometry, these are called simplices. Below, we have a 0-simplex, 1-simplex, and 2-simplex. An $n$-simplex exists in $n$-dimensional space, and we build lines, shapes, or volumes by chaining together simplices.

Notice that the boundary of each simplex is built from simplices of one fewer dimension (shown above with arrows). In our notation, $[012\dots n]$ will mean an $n$-simplex, and $\partial$ the boundary operator. We can explicitly calculate the boundary by projecting (dropping) one dimension at a time,

$$\partial [012\dots n]=\sum _{k=0}^n(-1{)}^k[01\dots k-1,k+1\dots n].$$

The factor $(-1{)}^k$ makes it so simplices chain together nicely:

We find

$$\begin{array}{cc}\partial \left(\right[012]+[132\left]\right)& =\left[12\right]-\left[02\right]+\left[01\right]+\left[32\right]-\left[12\right]+\left[13\right]\\ & =\left[01\right]+\left[13\right]+\left[32\right]-\left[02\right]\\ & =\left[01\right]+\left[13\right]+\left[32\right]+\left[20\right](\text{since}-\partial [02]=\partial [20\left]\right)\end{array}$$

i.e. a path from $0\to 1\to 3\to 2\to 0$. The shared boundary gets eliminated. This is also how the determinant is derived. Let $\left[x\right]\wedge \left[y\right]=\left[xy\right]$. Then

$$|A|\cdot [01\dots n]=\begin{array}{c}\left(a_{00}\right[0]+a_{01}[1]+\cdots +a_{0n}[n\left]\right)\wedge \\ \left(a_{10}\right[0]+a_{11}[1]+\cdots +a_{1n}[n\left]\right)\wedge \\ ⋮\\ \left(a_{n0}\right[0]+a_{n1}[1]+\cdots +a_{nn}[n\left]\right)\end{array}$$

As

$$\partial \left[xx\right]=\left[x\right]-\left[x\right]=0,$$

you only need to look at wedge products with every coordinate, hence the famous formula

$$|A|=\sum sgn\left(\sigma \right)a_{0{\sigma }_0}{a}_{1{\sigma }_1}\dots a_{n{\sigma }_n}$$

over permutations $\sigma$. However, it turns out the $(-1)$ is rather arbitrary. If you chose $(+1)$ you end up with the permanent,

$$|A|=\sum a_{0{\sigma }_0}{a}_{1{\sigma }_1}\dots a_{n{\sigma }_n}.$$

In fact any group representation can be chosen,

$$|A|=Tr\sum \rho \left(\sigma \right)a_{0{\sigma }_0}{a}_{1{\sigma }_1}\dots a_{n{\sigma }_n},$$

giving something called the immanant. Essentially, $\rho$ represents how much “stuff” gets transferred from one vertex to the others. The above assumes all vertices are equivalent (i.e. you have a symmetric group), but the boundary operator could be defined for any group and representation,

$$\partial [abc\dots n]=\sum _{g\in G}\rho \left(g\right)[abc\dots fh\dots n].$$

To give an intuitive idea of representations, suppose you are representing rotations in 3D space with matrices. If you want a faithful representation, you would assign a unique matrix to each rotation. Alternatively, a very unfaithful representation would map all rotations to the identity matrix. As long as the application of several rotations is equivalent to matrix multiplication, it is still a valid representation.

Just increasing the dimensions of your matrix implies there must be an infinite number of representations. However, most of these can be broken down into smaller pieces. Remember that matrices are linear operators in vector spaces, e.g.$2\times 2$ matrices are operators on $R^2$. If there is a subspace that is invariant under every matrix in the representation, it means the representation can be further reduced. The set of irreducible representations is much smaller, and satisfies nice orthogonality rules. For example, their characters (${\chi }_i=Tr\left[{\rho }_i\right]$) form an orthonormal basis:

$$⟨{\chi }_i,{\chi }_j⟩=\frac{1}{|G|}\sum _{g\in G}{\chi }_i\left(g{)}^{†}{\chi }_j\right(g)=\{\begin{array}{cc}1& i=j\\ 0& i\ne j.\end{array}$$

Now, suppose we have two physical states $|x⟩,|y⟩$ such as electron orbitals. Via relativity, we expect our observations to look the same if particles in these states are translated, rotated, or have some other transformation $T$ applied. Observations come from inner products between states, so

$$⟨y|x⟩=⟨y|T^{†}T|x⟩⟹T^{†}T=I.$$

Thus, if we have a group of transformations, the types of states can be classified by the group’s unitary representations. Elementary particles are just unitary irreducible representations! This is known as Wigner’s classification.

All we need to do is find the group, the “base case” of reality, our elementary particles represent. As best we can tell, our universe has three spatial dimensions, which gives three translations and three rotations. The time dimension adds another translation and three “boosts” from special relativity. These ten transformations make up the Poincaré group, known as $ISO(3,1)$. Finally, particles make closed loops within this group, so we need to look at its universal cover $\widetilde{ISO}(3,1)$, which we’ll shortly explain.

In some groups, all closed loops can be continuously deformed to a point. In others, such as the circle group (points around a circle), not all loops can. The fundamental group is all the kinds of loops, where two loops are considered the same if they can be continuously deformed into each other. For the circle group this is $Z$, representing an integer number of loops clockwise or counterclockwise. Similarly, a torus’ fundamental group is $Z^2$, and a plane’s fundamental group is the identity (all loops can be deformed). The universal cover modulo the fundamental group should give you your original group back, i.e.

$$\tilde{G}/{\pi }_1\left(G\right)=G.$$

The four translations in the Poincaré group make the subgroup $R^4$, which has trivial fundamental group and thus $\widetilde{R^4}=R^4$. The other six elements are called the Lorentz transformations, and form the group $SO(3,1)$. Their universal cover is a little more difficult to find.

Looking at just the rotations, $SO\left(3\right)$, we can represent them by a rotation axis of a sphere, and cover it by the sphere. Both of the poles would map to the same axis, so you could draw a path from one pole to its antipole which would form a closed loop in rotation-space, but not sphere-space. This means there are two kinds of loops—line segments and loops on the sphere—so ${\pi }_1\left(SO\right(3\left)\right)=Z_2$. I do not have an intuitive explanation, but this also happens to be true when you add the time boosts. Thus, the universal cover of $SO(3,1)$ is the double cover $SL(2,C)$. Put together, the group we’re looking for is

$$\widetilde{ISO}(3,1)=R^4⋊SL(2,C).$$

In two or one space dimensions, we’d get

$$\widetilde{ISO}(2,1)=R^3⋊\widetilde{SL}(2,R),\widetilde{ISO}(1,1)=R^2⋊SO(1,1).$$

One-dimensional “quantum cellular automata” are described by the little group of $\widetilde{ISO}(1,1),$

$$SO(1,1)=e^{\left[\begin{array}{cc}0& 1\\ 1& 0\end{array}\right]\theta }.$$

It is commutative, so the irreducible representations are one-dimensional (i.e. complex numbers), and the unitary ones lie on the unit circle. This gives the representations

$$\rho \left(e^{\left[\begin{array}{cc}0& 1\\ 1& 0\end{array}\right]\theta }\right)=e^{i\alpha \theta }$$

for some real number $\alpha$. If you want a finite number of rules, then $\alpha$ needs to be rational, and your quasiparticles are abelian anyons. To keep them stable, you probably want your space dimension to form a circle rather than a line. For example, in the fractional quantum Hall effect, a magnetic field is applied to a metal plate which (at low temperature) creates small circular cyclotrons for these anyons to exist in.

---

Caution! The following is speculative.

We can use these representations to compute physically meaningful values. The density of states for non-interacting particles is given by

$$\frac{\Omega }{kT}=Tr\sum _{g\in G}\rho \left(g\right)\ln (1-x^{|g|})=\sum _{g\in G}\chi \left(g\right)\ln (1-x^{|g|})$$

where $x=e^{-E/kT}$ is the probability of a single particle being in a state with energy $E$. The interpretation of $x^{|g|}$ is that the particle must diffuse through the full subgroup generated by $g$. Then,

$$\ln (1-x^{|g|})=\frac{x^{1|g|}}{1}+\frac{x^{2|g|}}{2}+\frac{x^{3|g|}}{3}+\cdots$$

means it may be dispersed in either one loop, two loops, three loops, etc. Finally, since irreducible representations are orthogonal, the multiplication by $\rho$ or $\chi$ projects these loops into our particular representation.

For example, fermions are faithful to the subgroup $C_2=\{1,-1\}$. The grand canonical partition function for fermions is then

$$\begin{array}{cc}Z=e^{-\Omega /kT}& =\exp [-\sum _{g\in \{1,-1\}}\chi (g\left)\ln (1-x^{|g|})\right]\\ & =\exp [\ln (1-x^2)-\ln (1-x^1)]\\ & =1+e^{-E/kT}.\end{array}$$

Similarly, when the abelian anyons mentioned above exchange clockwise, they pickup a phase of $\omega =e^{2\pi i/n}$ rather than $\pm 1$. This naturally corresponds to the group

$$C_n=\{1,\omega ,{\omega }^2,\dots ,{\omega }^{n-1}\},$$

so we find

$$\begin{array}{cc}\frac{\Omega }{kT}& =\sum _{d|n}\ln (1-x^d)\sum _{|g|=d}\chi \left(g\right)\\ & =\sum _{d|n}\ln (1-x^d)\sum _{gcd(k,d)=1}{\omega }^{nk/d}\\ \left(\text{Möbius inversion}\right)& =\sum _{d|n}\mu \left(d\right)\ln (1-x^d)\end{array}$$

where

$$\mu \left(d\right)=\{\begin{array}{cc}0& d\text{has a squared prime factor},\\ (-1{)}^k& d\text{has}k\text{distinct prime factors}\end{array}$$

is the Möbius function. For example, $n=6$ gives

$$\begin{array}{cc}Z=e^{-\Omega /kT}& =\prod _{d|6}{(1-x^d)}^{-\mu \left(d\right)}\\ & =\frac{(1-x^2)(1-x^3)}{(1-x)(1-x^6)}\\ & =\frac{1}{1-x+x^2}.\end{array}$$

[XelaP]

The issue with recursive definitions is they create a vicious circle. To get around this, you need to specify a base case, and constructively build out your definition from there.

...no. Frequently, recursive definitions don’t require a base case—you can find a (or the) object that makes the definition work, usually via a fixed point theorem.

In the Sierpinski case, we want to find a fixed point of the function that takes a subset of the triangle and maps it to the union of the 3 shrinked versions positioned in the appropriate way. We don’t want the empty set, nor the thing we’d get if we iterated a single point—we want the largest fixed point. First, note that the iteration function is monotonic under the subset relation. Next, we can apply the Knaster-Tarski fixed point theorem to prove that for some ordinal w, the wth iteration of the triangle is the greatest fixed point (where a limit ordinal means we take the infimum of all previous). Now in this case, if w is the integers, we see that the intersection of all the finite iterates in fact a fixed point. Thus we get Sierpinksi’s triangle.

In fact, we can instead just take three points A,B,C that are corners of a triangle and use the dilations d_A, d_B, d_C where e.g. d_A moves a point p halfway towards A. If we require the input to be a nonempty compact (aka closed bounded) set, and use the Hausdorff metric’s limits for iteration, we will get the Sierpinski triangle. That is, each individual dilation is a contraction map, and the iteration that unions each dilation (as a function from subsets to subsets) is easily shown to be a contraction map—and since the Huasdorff metric is complete on compact sets, the contraction mapping theorem gives us a unique fixed set that we can get via taking the limit of iteration.

All we need to do is find the group, the “base case” of reality, our elementary particles represent

The group isn’t the base case, it’s the iteration.

I was wondering why we go from the group of symmetries to the universal cover. I don’t think the story about loops you gave is why, unless there’s an equivalent way to make that interpretation cash out physically. The explanation I am finding (though there’s others for other more general cases that involve math I don’t know at all like group cohomology): What we really want is projective representations (just because we are doing quantum physics, and the wavefunction is only defined up to a scalar factor). Now, it turns out you can lift these. It looks like you need to pass to the lie algebra representations, then you can deprojectivize by choosing traceless representatives. Then you can lift to the lie group, except now it’s the universal cover. So you get determinant one reps. You can do the converse too. In nice cases you have that all reps of the universal cover are det one so you don’t have to worry about that; otherwise you need to look only at irreps.

I don’t see why rational alpha is needed to have a finite number of rules for a cellular automata. After all, who said your rules perform one of the group representation operations! Just take, like, any quantum gate on qubits. Also, like, who said the states are wavefunctions in 1D? I should be able to build a quantum turing machine operating on a linear tape of hydrogen atom states (or more realistically spin states) to give me a perfectly cromulent cellular automaton whose rules aren’t a representation of the poincare group, let alone the 1D one.

[programjames]

My perspective is that logical truth is the ability to write a proof, and since humans (or computers) can only do finite computations, the proof must be finite. Now, we can smuggle in infinities with—proofs. A short example: for any , we can find an such that, for any

and the proof of this “for any … for any” is finite:

This is why I initially said you had to define a base case, and build out the Serpinski triangle as a limit of this base case. I think we have almost the same thing in mind in your second construction: take three points as the corners of a triangle, iteratively refine the set with dilations, and use an—proof to show this converges to a fixed set of points.

However, you are right that we don’t actually need the base case! I don’t know enough about how the Knaster-Tarski fixed point theorem is defined or proven. It can probably be written constructively, but I’m not sure. An easier construction for me is to define iterate and then apply a fixed point combinator. So, we have a finite program defining

iterate(S) = S + three smaller copies

and then we define the Serpinski triangle as

Y(iterate)

No need for an initial set of points to feed into this object, unless there are properties we care about like the boundary being a triangle. I think you also have to be careful to make sure this actually converges, but I’m sure that can be worked out.

As for the rest of your comment, note that this post was written in around a day, after I figured out Wigner’s classification by thinking really hard (I only learned it was called Wigner’s classification during the writeup). Looking back on it, there are things that are not quite right, and things that could be explained better. I am writing an updated version that’s more careful with how things are being defined, where things come from, and what actually follows from what, but this has been in the works for many months and I’ve just never really gotten around to finishing it.

The idea behind the universal cover is that, if you had a loop of simplices and hopped around it in a circle, when you get back to where you started you should have the same “value”. The representations tell you how this value changes as you hop around (translate/​rotate). If you can continuously deform every loop into a point, or a point into any loop, then any representation will satisfy this “same value” property. So you lift to a universal cover and then ask for the representations.

This isn’t quite right. Why stop at 1D loops, not go further in the Postnikov tower? What actually are these simplices and their boundaries? Also, what actually are rotations? Why not just redefine them as a bigger, lifted group that looks like SO(3, 1) when projected down?

As for rational , yes the idea was that the representations were the rules. This was over a year ago, and I’m also a little confused why I said that. My best guess is I thought the problem assumed the cellular automaton implemented the same rule for every group of three qubits, so something with superposition and Schroedinger’s equation (like here) somehow implies we can break the combined wavefunction of all the qubits into a bunch of 1D waves. But I’m not entirely sure what my train of thought was, and there was probably a mistake.

[XelaP]

The idea behind the universal cover is that, if you had a loop of simplices and hopped around it in a circle, when you get back to where you started you should have the same “value”. The representations tell you how this value changes as you hop around (translate/​rotate). If you can continuously deform every loop into a point, or a point into any loop, then any representation will satisfy this “same value” property. So you lift to a universal cover and then ask for the representations.

This can’t be why it shows up. Let’s take the group action of the circle on R^2 that just rotates. The circle is not simply connected, yet when I go in a loop my representation will continuously go back to where I started, as must be the case simply because I have a loop and a continuous group action.

In general, lie group representations should always lift to the universal cover I think; the whole point here is I think that there’s a correspondence the other way, and that’s only there because we’re looking at a projective representation.

Lastly I think using the Y combinator is probably a bad idea, because you could get fixed points that don’t correspond to a set in whatever your interpretation of lambda functions as sets is. And also, how are you interpreting, exactly??

I believe I needed the axiom of choice for Knaster-Tarski and possibly somewhere in the contraction mapping theorem, but not sure.

[programjames]

1. You kind of just have to assume that the interpreter works, and your computer wasn’t hit by a cosmic ray that flipped a random bit invalidating your proof. You can try some sort of probabilistic thing, but with what interpreter do you define your probabilities? There is no probabilistic Loeb’s theorem. Once you take the leap of faith though, you can build your interpreter by assuming you have some number of bits and NAND gates, and asking what circuits you can make. Then you can write finite programs that prove things about the relationships between different strings of bits. There are many similar kinds of interpreters (e.g. rather than NAND gates, a human chooses a set of ‘logical operators’, writes them down on paper, and runs the program through with their brain).

2. Yes, the correspondence is the other way. See the paragraph after the one you quoted. I think my earlier self was wrong, though there is the possibility I just cannot reconstruct their thought process.

[XelaP]

I don’t understand why you are talking about interpreters. Do you agree that the Y combinator, when applied to a lambda function, might not be a lambda function corresponding to a number? Or, say, a lambda function that encodes the set in question? I still don’t see how you are encoding the set in question—are you literally manipulating first order logic strings encoded as numbers? If so, then once again you might get a fixed point that corresponds to no number—and even if you get a number, the encoded string might not correspond to a set.

To clarify 2 (though I think we don’t disagree here) - the reason you stop at the universal cover is simply because that’s where you get a bijection.

[programjames]

I thought you were asking about interpreters: “And also, how are you interpreting, exactly??” I guess not. So, I think there’s some confusion about the Y combinator here. Consider the factorial function:

iter(n) = n * iter(n-1) if n > 0 else 1
factorial = Y(iter)

You might encode n as a Church numeral. In this particular case, factorial(n) can also be beta-reduced to a Church numeral. Note though, that factorial itself is not a Church numeral. Now, consider the Serpinski triangle

iter(S) = S + (1 + w + w^2)(S/3) ; S + three dilated copies
serpinski = Y(iter)

You have some notion of how sets S should be encoded, and you are worried that serpinski(S) may not beta-reduce to fit that notion. Perhaps then you’ve got the wrong notion of sets, and should expand it to include objects like serpinski(S). But perhaps that leads to nasty problems like Russell’s paradox. I’m not sure, but I suspect you won’t run into this problem.

“To clarify 2 (though I think we don’t disagree here) - the reason you stop at the universal cover is simply because that’s where you get a bijection.”

Sorry, what bijection? Between the lifted rotations and… what?

[XelaP]

Well, you really have F = lambda f,n: n * f(n-1) if n > 0 else 1, and then (YF)(n) beta-reduces to a church numeral. Our fixed point is the factorial function.

Trying to duplicate this with the sets in question: how should sets be encoded? I suspect that for any reasonable notion, you will have a problem where the fixed point might be some terrible thing.

As an example, suppose you try the most obvious way: a set is represented by a function that returns true for all elements in the set, and false otherwise. But how are we to plug in real numbers? Well, we could take computable approximations to the reals… but then we can’t even define the set {0} as a computable function! Even if we don’t allow something as pathological as the reals, decidable sets are much lesser than all the sets.

Any other way would, I think, have to basically be manipulating formal logic strings represented via e.g. a godel numbering and church numerals. Then, one defines the iteration as a function that takes in a string defining a set in first order logic, then outputs a first order logic string defining of the next iteration. But then, there’s no guarantee that the fixed point is a number, let alone a number corresponding to a logical formula that defines a set.

About the representations: in the finite dimensional case, there is a bijection between projective irreps of G and determinant 1 ordinary irreps of the universal cover of G. Apparently in the infinite dimensional case, you can only lift projective irreps to ordinary irreps in certain cases which include the Poincare group. I can’t tell if you would get a bijection in those cases.

[programjames]

I would be surprised if the motivation for projective irreps does not also motivate extending higher up the Postnikov tower; you don’t just stop at the universal cover.

As for sets, suppose you went with the definition: any function that takes in a rational number and spits out a boolean. So the Dedekind cut for could be expressed as

sqrt2 = lambda x. (x * x < 2)

I expect that

((serpinski sqrt2) 3/4)

could indeed be -reduced to a boolean, if you choose the right path. So basically, (serpinski S) is also a set if S is a set.