Ulysses’ trip

Ways of reducing mass rebuilds in Nix without changing Nix

2026-04-16T09:45:36-07:00

Introduction

Nix as a software package manager is amazing in its reproducibility, the cost of which, however, is the problem of mass rebuilds. When a package gets an update, every package that depends on it, directly or indirectly, will be rebuilt. This means that even a small update can lead to conceptually unnecessary mass rebuilds involving thousands of packages or even much more if the update touches a package on which many packages depend, such as glibc. This imposes huge burden on all kinds of resources, such as CPU resources (compiling software is generally CPU intense), storage resources (different rebuilds of a software reside in different store paths), and network resources (all users of rebuilt packages have to redownload them from the binary caches).

Nixpkgs has staging branches to manage such mass rebuilds. Every update in Nixpkgs that triggers mass rebuilds will go through a staging process, which takes some time for it to be merged into the master branch. If updates that conceptually do not require mass rebuilds can actually be done without mass rebuilds, then they can be applied to the master branch much more quickly than going through the staging process.

This article aims at brainstorming some ways to reduce mass rebuilds without changing Nix itself. In other words, I will think of some ways in which we can refactor Nixpkgs or develop alternative package sets to avoid some mass rebuilds without switching to another implementation of Nix language or ditching Nix altogether.

The most common kinds of dependencies between Nix derivations are:

The output of the dependent derivation includes the out path of the depended derivation. This happens when you use autoPatchelf and patchShebangs.
Besides the point above, the builder of the dependent derivation actually also needs to look at the file contents of the output of the depended derivation. This happens when you compile a software against the depended library.
The builder of the dependent derivation runs executables or calls functions in the depended derivation. This happens when the depended software is a compiler used to compile the dependent software.

I am going to try to pose some ideas to improve the situation for each of the three kinds of dependencies.

Store path replacements

For the first kind of dependencies, conceptually there is absolutely no need to rebuild the dependent software. Building the dependent derivation is bound to succeed, and the result in the output will differ by nothing more than the updated store path of the depended derivation. Therefore, the idea to solve this is simple: instead of rebuilding the dependent derivation from scratch, simply substitute the store path in the output of the dependent derivation.

Now, let us take a simple example. Assume that foo_1 is a program that simply outputs hello to the standard output and that foo_2 is a program that simply outputs howdy to the standard output. Assume that bar is simply a wrapper around foo made using makeWrapper. In the builder of bar, I will include a sleep command to simulate a time-consuming building process. An update in its dependent is then simulated as we switch from foo = foo_1 to foo = foo_2. When you build bar, it will take you 5 seconds of waiting during the build. Then, when you switch to foo = foo_2 and build bar again, it will take you another 5 seconds of waiting during the build, which is conceptually totally unnecessary because that part does not change for the foo update at all.

Supposed packaging in Nixpkgs

Determining the stabilizability of the abelian sandpile model

2026-01-03T14:56:49-08:00

Introduction

Suppose that we have $n$ sandpiles denoted as a set $V$ . Each sandpile $x\in V$ has a toppling threshold $\fc\tht x\in\bR_{>0}$ , and each ordered pair of sandpiles $x,x'\in V$ has a toppling transfer amount $\fc\alp{x,x'}\in\bR_{\ge0}$ . The tuple $\p{V,\tht,\alp}$ is called an abelian sandpile model.

A configuration $\eta:x\to\bR$ is to assign an amount of sand $\fc\eta x$ to each sandpile $x\in V$ , and it is legal if $\fc\eta x\ge0$ for all $x\in V$ (or conveniently denoted as $\eta\ge0$ ). For any configuration $\eta$ , any $y\in V$ can topple, which is a transition to a new configuration $\eta'$ defined as $\fc{\eta'}x\ceq\fc\eta x-\fc\tht y\dlt_{xy}+\fc\alp{y,x}.$ The toppling is legal if $\fc\eta y\ge\fc\tht y$ , in which case we call $y$ an unstable site of the configuration $\eta$ . Notice that a legal configuration undergoing a legal toppling must become a legal configuration. A sequence of topplings where each toppling uses the resultant configuration of the previous toppling as the initial configuration is called a toppling procedure.

In its historically original form (Dhar, 1990), $V$ is the lattice sites on a 2D rectangular grid, and $\fc\tht x=4$ for all $x\in V$ , and $\fc\alp{x,x'}$ is $1$ if $x$ and $x'$ are nearest neighbors or $0$ otherwise. It is then generalized to an arbitrary directed multigraph (Holroyd et al., 2008), where $V$ is its vertices, and $\fc\tht x$ is the out-degree of vertex $x$ , and $\fc\alp{x,x'}$ is the number of edges from $x$ to $x'$ .

A configuration where none of the sandpiles can legally topple is called a stable configuration. In other words, configuration $\eta$ is stable if $\fc\eta x<\fc\tht x$ for all $x\in V$ , or denoted as $\eta<\tht$ in abbreviation. A toppling procedure that makes a configuration stable is called a stabilizing toppling procedure that stabilizes the configuration. A legal configuration is stabilizable if it has a finite legal stabilizing toppling procedure. Otherwise, the configuration is exploding. A natural question to ask then is how to determine whether a configuration is stabilizable or exploding.

Abelian property

One important fact to notice is that the abelian sandpile model has the so-called abelian property: if a configuration is stabilizable, then every legal toppling procedure of it is finite, and the stabilizing legal toppling procedure is unique up to the order of topplings. In other words, if we define the toppling counting function $u:V\to\bN$ such that $\fc ux$ is the number of times that $x\in V$ topples throughout the toppling procedure, then every legal stabilizing toppling procedure of a stabilizable configuration has the same toppling counting function, which is called the odometer of the configuration. We will leave the proof of the abelian property to a later part in this section.

In order to better describe the model, we can define a function $\Dlt:V\times V\to\bR$ (the notation comes from the notation of the Laplacian operator in vector analysis due to its direct analogy in the case of the abelian sandpile model on a grid, in which case it is called a Laplacian matrix in the language of graph theory) as follows: $\fc\Dlt{x,y}=\fc\tht x\dlt_{xy}-\fc\alp{x,y}.$ It encodes information from both $\tht$ and $\alp$ and provides everything we need to know to find the resultant configuration given any initial configuration and the toppling counting function. Explicitly, configuration $\eta$ undergoing a toppling procedure with the toppling counting function $u$ becomes $\fc{\eta'}x=\fc\eta x-\sum_y\fc\Dlt{x,y}\fc uy.$ For abbreviation, we denote $x\mapsto\sum_y\fc\Dlt{x,y}\fc uy$ as $\Dlt u$ so that $\fc{\Dlt u}x=\sum_y\fc\Dlt{x,y}\fc uy$ . Therefore, the resultant configuration of a toppling procedure can be denoted as $\eta'=\eta-\Dlt u$ . This notation is natural if we think of $\Dlt$ as an $n$ -dimensional matrix and think of $\eta$ and $u$ as $n$ -dimensional column vectors. This equation tells us that the resultant configuration of two toppling procedures is the same as long as they have the same toppling counting function.

A toppling procedure can then be expressed as a sequence of toppling counting functions where the $t$ th toppling counting function $u_t$ is that of the toppling procedure derived by truncating the full toppling procedure up to the first $t$ topplings. If the $t$ th toppling happens at site $y$ , then $\fc{u_t}x-\fc{u_{t-1}}x=\dlt_{xy}.$ We stipulate that $u_0$ is the zero function. From now on, we call a sequence $\B{u_t}_{t=0}^T$ (where $T$ is either a natural number or infinity) as a toppling procedure as long as the following conditions are satisfied: $u_0=0$ , and for all $0\le t$ , there exists $y\in V$ such that $\fc{u_{t+1}}x=\fc{u_t}x+\dlt_{xy}$ . It is obvious to see that $\sum_x\fc{u_t}x=t$ for all $t$ . Therefore, the length $T$ of a toppling procedure is the same as the sum $\sum_x\fc ux$ , where $u\ceq u_T$ is the final toppling counting function of the toppling procedure. The definition of the legality of a toppling procedure is also naturally extended to this formulation.

Because the resultant configuration of a toppling procedure is independent of the order of the topplings, for two different sites $y$ and $y'$ , toppling $y$ and then $y'$ is equivalent to toppling $y'$ and then $y$ . Both toppling procedures have the same toppling counting function $\dlt_{xy}+\dlt_{xy'}$ . If both sites are unstable sites of the initial configuration, then both toppling procedures are legal. To see this, suppose that $y$ and $y'$ are two different unstable sites of the configuration $\eta$ . Then, the configuration $\eta'$ after $y$ topples is given by $\fc{\eta'}x=\fc\eta x-\fc\tht y\dlt_{xy}+\fc\alp{y,x}$ . Its value at $y'$ is $\fc{\eta'}{y'}=\fc\eta{y'}+\fc\alp{y,y'}$ (notice that $\dlt_{yy'}=0$ because $y\ne y'$ ). The first term is at least $\fc\tht{y'}$ because $y'$ is an unstable site of $\eta$ . The second term is nonnegative by definition. We then have $\fc{\eta'}{y'}\ge\fc\tht{y'}$ , which means that $y'$ is also an unstable site of $\eta'$ , so toppling $y$ and then $y'$ is legal. By the same logic, toppling $y'$ and then $y$ is legal.

Now, we proceed to prove the abelian property: a stabilizable configuration has a unique odometer. To prove this, it is sufficient to prove that, if a configuration is stabilizable, then you can always construct a legal stabilizing toppling procedure by choosing an arbitrary unstable site to topple at each step until the configuration becomes stable, which is guaranteed to happen in finite steps, and the resultant toppling counting function is independent of the choices of unstable sites to topple at each step.

We prove this by induction on the length of an arbitrary legal stabilizing toppling procedure. We will prove case by case for length being $0$ and $1$ as base cases, and then prove the inductive step for length being $T+1$ assuming the case for length being $T\ge1$ .

The base case with zero length is trivial. For the base case with length $1$ , suppose that the configuration $\eta$ has a legal stabilizing toppling procedure of length $1$ . We need to prove that any choice of unstable site to topple leads to a stable configuration, and the odometer is uniquely determined. Becasue the constraint on the length of the toppling procedure, we need to prove that the unstable site $y$ in the initial configuration that topples in the legal stabilizing toppling procedure is the only unstable site in the initial configuration (so that the odometer can only be $\fc ux=\dlt_{xy}$ ). This is obvious because we have already proven that, if there is another unstable site $y'$ , then $y'$ is also an unstable site of the configuration after $y$ topples, which contradicts the assumption that toppling $y$ is stabilizing.

Then proceed with the inductive part of the proof. Suppose that, for any configuration with a legal stabilizing toppling procedure of length $T\ge1$ , arbitrarily choosing an unstable site to topple at each step will always stabilize after exactly $T$ steps, and the toppling counting function of the resultant toppling procedure is unique. Then, we need to prove the same thing for length $T+1$ . Suppose that configuration $\eta$ has a legal stabilizing toppling procedure of length $T+1$ and that its toppling counting function is $u$ . Denote $y$ as the first toppling site in this toppling procedure. Then, the configuration $\eta'$ after the first toppling is given by $\fc{\eta'}x=\fc\eta x-\fc\tht y\dlt_{xy}+\fc\alp{y,x}$ , and it has a legal stabilizing toppling procedure of length $T$ whose toppling counting function is $\fc{u'}x=\fc ux-\dlt_{xy}$ . By the induction assumption, $\eta'$ stabilizes after $T$ arbitrary legal topplings, and the toppling counting function must be $u'$ . Now, arbitrarily choose an unstable site $y'$ of $\eta$ . If $y'=y$ , then toppling $y'$ gives $\eta'$ , which stabilizes after $T$ arbitrary legal topplings. If $y'\ne y$ , then the fact that $y'$ is an unstable site of $\eta$ implies that $y'$ is an unstable site of $\eta'$ , so we can construct a legal stabilizing toppling procedure of $\eta'$ such that the first toppling site is $y'$ . We then get a legal stabilizing toppling procedure of $\eta$ whose toppling counting function is $u$ such that the first two toppling sites are $y$ and $y'$ . Because both $y$ and $y'$ are unstable sites of $\eta$ , we can simply swap the first two toppling sites to get a toppling procedure of $\eta$ such that the first two toppling sites are $y'$ and $y$ . This means that toppling $y'$ makes $\eta$ become a configuration with a legal stabilizing toppling procedure of length $T$ with toppling counting function $\fc ux-\dlt_{xy'}$ . By the induction assumption, $\eta$ stabilizes after $y'$ topples followed by another $T$ arbitrary topplings. Because $y'$ itself is an arbitrary choice of an unstable site, $\eta$ stabilizes after $T+1$ arbitrary topplings, and the toppling counting function is $u$ . This finishes the induction step of the proof.

Least action principle

Another property of the abelian sandpile model is the least action principle ¹: assuming that $u$ is the odometer of a stabilizable configuration $\eta$ , then for any $u':V\to\bN$ such that $\eta-\Dlt u'<\tht$ , we have $u'\ge u$ .

Here I present a proof inspired by Fey et al. (2009). Construct a legal toppling procedure starting from the configuration $\eta$ as follows. At each step where $\fc{u_{t+1}}x=\fc{u_t}x+\dlt_{xy}$ , the toppling site $y$ satisfies $\fc\eta y-\fc{\Dlt u_t}y\ge\fc\tht y$ and $\fc{u_t}y<\fc{u'}y$ . When there are multiple sites satisfying the conditions, arbitrarily choose one. Continue until none of the sites satisfy the conditions, which always happen after finite steps because any toppling procedure of a stabilizable configuration is finite. This is a legal toppling procedure whose toppling counting function never exceeds $u'$ . Suppose that the length of the toppling procedure is $T$ . We then prove by contradiction that this toppling procedure is stabilizing. Suppose that the final configuration $\eta'=\eta-\Dlt u_T$ of this toppling procedure has an unstable site $y$ . Because the final configuration is unstable, the only reason that the toppling procedure stops is that $\fc{u_T}y=\fc{u'}y$ . Define $u''\ceq u'-u_T$ , so $\fc{u''}y=0$ and $u''\ge0$ . We have $\begin{align*} \fc\eta y-\fc{\Dlt u'}y &=\fc{\eta'}y-\fc{\Dlt u''}y\\ &=\fc{\eta'}y-\fc\tht y\fc{u''}y+\sum_x\fc\alp{y,x}\fc{u''}x\\ &\ge\fc{\eta'}y\ge\fc\tht y, \end{align*}$ which contradicts the assumption that $y$ is an unstable site of $\eta'$ .

What the least action principle tells us is that, the odemeter $u$ of a stabilizable configuration $\eta$ is the unique minimum natural number solution to the system of linear inequalities $\eta-\Dlt u<\tht$ . The toppling procedure defined above also provides a constructive way to find the odometer once we have any natural number solution to the system of linear inequalities.

Notice that we cannot relax $u'$ to be a more general real-valued function. If so, in the proof above, the condition $\fc{u''}y=0$ becomes $\fc{u''}y<1$ . In fact, we can easily find counterexamples where, there exists a real-valued solution $u'$ to the system of linear inequalities, but the configuration is exploding. This is sad news because it means that determining the stabilizability of a configuration cannot be done by linear programming.

A corollary of the least action principle is that, if $\eta-\Dlt u<\tht$ has a natural number solution, then there exists a unique minimum solution, whose value at each site is the minimum among all natural number solutions at that site.

A related property is that, if $u=u_1$ and $u=u_2$ both satisfies $\eta-\Dlt u<\tht$ , then $u=\opc{min}{u_1,u_2}$ also satisfies $\eta-\Dlt u<\tht$ , where $\fc{\opc{min}{u_1,u_2}}x\ceq\opc{min}{\fc{u_1}x,\fc{u_2}x}$ denotes the pointwise minimum. This property also applies to general real-valued solutions instead of just natural number solutions. To prove this, assuming $\fc{u_1}x\le\fc{u_2}x$ without loss of generality, notice that $\begin{align*} \fc{\Dlt\opc{min}{u_1,u_2}}x &=\fc\tht x\fc{u_1}x-\sum_y\fc\alp{x,y}\opc{min}{\fc{u_1}y,\fc{u_2}y}\\ &\ge\fc\tht x\fc{u_1}x-\sum_y\fc\alp{x,y}\fc{u_1}y\\ &=\fc{\Dlt u_1}x. \end{align*}$ By this property, under the binary operator $\opc{min}{\cdot,\cdot}$ , the set $P\ceq\set{u:V\to\bR}{\eta-\Dlt u<\tht,u\ge0}$ forms an idempotent commutative semigroup if not empty. Its closure $\overline P\ceq\set{u:V\to\bR}{\eta-\Dlt u\le\tht,u\ge0}$ is an idempotent commutative monoid if not empty, whose identity element is the unique minimum element of $\overline P$ , which obviously exists. The set $P_\bN\ceq\set{u:V\to\bN}{\eta-\Dlt u<\tht}$ is a subsemigroup of $P$ and also a monoid if not empty. However, notice that the identity element of $P_\bN$ is always different from that of $\overline P$ .

Integer linear programming

As we have seen, determining the stabilizability of a configuration $\eta$ is equivalent to determining whether there exists a natural number solution to the system of linear inequalities $\eta-\Dlt u<\tht$ . Such problems are called integer linear programming (ILP) problems.

The most general form of an ILP problem is, given a matrix $A$ and vectors $b$ and $c$ , to find natural number vector $x$ that minimizes $c^\mrm Tx$ subject to the constraint $Ax\le b$ . There is also the feasibility version of ILP problems, which only asks whether there exists a natural number vector $x$ satisfying the constraint $Ax\le b$ without the objective of optimizing some objective.

Now come back to the problem of determining the stabilizability of a configuration $\eta$ . From a computational point of view, because we cannot really store arbitrary real numbers in a computer, we are only going to consider the case where $\eta$ and $\Dlt$ are both rational-valued functions. Then, without loss of generality, when $V$ is finite, we can multiply both functions by a common multiple of denominators to make them both integer-valued functions ². The problem of determining the stabilizability of a configuration then becomes a special case of the feasibility version of ILP problems, which is to determine whether there exists a natural number solution to $\Dlt u\ge\psi$ , where $\psi\ceq\eta-\tht+1$ . It is only a special case because $\Dlt$ by the definition of the abelian sandpile model can only be a Z-matrix, which is defined as a square matrix whose off-diagonal entries are all nonpositive. Because of this restriction, it may not be as hard as the general ILP problems, which are known to be NP-complete. However, Z-matrix ILP problems are in fact also NP-complete.

Proving NP-completeness of Z-matrix ILP problems

From Picard iteration to Feynman path integral

2025-11-13T17:31:24-08:00

Discrete path integral

As we all know, the Schrödinger equation is $\fr\d{\d t}\ket{\fc\psi t}=-\i\fc Ht\ket{\fc\psi t},$ where $\ket\psi$ is the state vector and $H$ is the Hamiltonian operator (may be time-dependent). This is an ordinary differential equation (ODE), so we can express its solution as a sum $\ket{\fc\psi t}=\sum_{n=0}^\infty\ket{\fc{\psi^{\p n}}t},$ where each term in the sum is defined iteratively by (see also my past article) $\ket{\fc{\psi^{\p0}}t}\ceq\ket{\fc\psi0},\quad \ket{\fc{\psi^{\p{n+1}}}t}\ceq-\i\int_0^t\d t'\,\fc H{t'}\ket{\fc{\psi^{\p n}}{t'}}.$ This iteration is called the Picard iteration, which is most known as a method to prove the Picard–Lindelöf theorem.

Let us actually write out the general term in this sum as $\ket{\fc{\psi^{\p n}}t}=\fc{K^{\p n}}t\ket{\fc\psi0},$ where $\fc{K^{\p n}}t=\p{-\i}^n\int_0^t\d t_n\,\fc H{t_n}\int_0^{t_n}\d t_{n-1}\,\fc H{t_{n-1}}\cdots\int_0^{t_2}\d t_1\,\fc H{t_1}.$ Now with the trick of time-ordering, we can rewrite this as $\begin{align*} \fc{K^{\p n}}t&=\fr{\p{-\i}^n}{n!}\int_0^t\d t_n\int_0^t\d t_{n-1}\cdots\int_0^t\d t_1\,\bfc{\mcal T}{\fc H{t_n}\fc H{t_{n-1}}\cdots\fc H{t_1}}\\ &=\fr{\p{-\i}^n}{n!}\mcal T\p{\int_0^t\d t'\,\fc H{t'}}^n, \end{align*}$ where $\bfc{\mcal T}\cdots$ means to order the operators inside according to their time arguments. The factor of $1/n!$ appears because there are $n!$ ways to order $n$ time variables, but another way to see this is to note that the domain of integration is an $n$ -simplex, whose volume is $1/n!$ of the corresponding $n$ -parallelotope. When we then sum over all $n$ , we get the time-ordered exponential $\ket{\fc\psi t}=\fc Kt\ket{\fc\psi0},\quad \fc Kt=\sum_n\fc{K^{\p n}}t=\mcal T\fc\exp{-\i\int_0^t\d t'\,\fc H{t'}}.$ The operator $\fc Kt$ has a bunch of equivalent names, such as the time evolution operator, the propagator, the Green’s function, the Dyson operator, and the S-matrix (well, they are not entirely equivalent because they are used under different contexts).

The interesting part comes when we consider the matrix elements of $\fc Kt$ and how they relate to the matrix elements of $\fc Ht$ . We choose an orthonormal basis $\B{\ket x}$ , and then insert a $\sum_x\ket x\bra x$ between each pair of Hamiltonian operators in the expression of $\fc{K^{\p n}}t$ : $\bra{x_n}\fc{K^{\p n}}t\ket{x_0} =\fr{\p{-\i}^n}{n!}\int_0^t\d^nt\sum_{x_1,\ldots,x_{n-1}} \fc{h_{x_nx_{n-1}}}{t_n}\fc{h_{x_{n-1}x_{n-2}}}{t_{n-1}}\cdots\fc{h_{x_1x_0}}{t_1},$ where we have abbreviated $\fc{h_{xy}}t\ceq\bra x\fc Ht\ket y$ , and $t_1\le\cdots\le t_n$ are a specific ordering of the integrated time variables. We can pull out the sum over intermediate basis states and call the summand a contribution from a walk ¹ from $x_0$ to $x_n$ . In other words, $\bra y\fc{K^{\p n}}t\ket x =\sum_{\B{x_i}}^{\substack{x_n=y\\x_0=x}}\fc K{\B{x_i},t},$ where the sum is over all walks of length $n$ from $x$ to $y$ , and $\fc K{\B{x_i},t}\ceq\fr{\p{-\i}^n}{n!}\int_0^t\d^nt\, \prod_{i=1}^n\fc{h_{x_ix_{i-1}}}{t_i}.$ Now, the matrix elements of the full propagator is then the sum over contributions from all walks: $\bra y\fc Kt\ket x=\sum_{\text{walks }x\to y}\fc K{\text{walk},t}.$ We can imagine a “Hamiltonian graph” formed by taking the basis states as vertices and the Hamiltonian matrix elements as edge weights (the weight of the directed edge from $x$ to $y$ is $-\i\bra y\fc Ht\ket x$ ). Note that an edge can be a self-loop. Then, the propagator contribution from a walk is given by integrating the product of all the edge weights along the walk (for a trivial walk, which has zero length, the contribution is simply $1$ ). This formulation may be called the discrete path integral. There is a paper on arXiv that delivers the idea of the Hamiltonian graph. Its difference from the current article is that it only focuses on time-independent Hamiltonians and that it treats self-loops separately instead of just like normal edges. The following two sections (excluding self-loops and the Feynman path integral) largely follow from the ideas from this paper.

Excluding self-loops

In some cases, it may be hard to consider self-loops on the Hamiltonian graph. We may then benefit from counting only walks without self-loops. However, the contributions from each walk will now be different because we have to account for the same walk with self-loops inserted at various positions. In other words, for a walk $\B{x_i}$ without self-loops, instead of contributing $\fc K{\B{x_i},t}$ , we now want to find the contribution $\fc L{\B{x_i},t}$ that sums over all ways to insert self-loops into $\B{x_i}$ : $\fc L{\B{x_i},t}=\sum_{m_0,\ldots,m_n=0}^\infty \fc K{\B{x_i^{m_i}},t},$ where $m_i$ is the number of self-loops inserted at the vertex $x_i$ , and $\B{x_i^{m_i}}$ is an abbreviation of this walk: $\underbrace{x_0,\ldots,x_0}_{m_0}, \underbrace{x_1,\ldots,x_1}_{m_1},\ldots, \underbrace{x_n,\ldots,x_n}_{m_n}.$

I will show that we can find an expression for $\fc L{\B{x_i},t}$ for the case when the Hamiltonians at different times commute with each other. In this case, we have $\fc K{\B{x_i},t}=\fr{1}{n!}\prod_{i=1}^n \p{-\i\int_0^t\d t\,\fc{h_{x_ix_{i-1}}}t}.$ Therefore, by the definition of $\fc L{\B{x_i},t}$ , we have $\fc L{\B{x_i},t}=\fc K{\B{x_i},t}\sum_{m_0,\ldots,m_n} \fr{n!}{\p{n+\sum_i m_i}!} \prod_i\p{-\i\int_0^t\d t\,\fc{h_{x_ix_i}}t}^{m_i}.$ For abbreviation, for the rest of this section, we denote $S_i\ceq-\i\int_0^t\d t\,\fc{h_{x_ix_i}}t$ .

Now, we use a trick to replace the factorial in the denominator with an contour integral: $\fr1{N!}=\fr1{2\pi\i}\oint\d z\fr{\e^z}{z^{N+1}},$ where the contour is a counterclockwise simple closed curve around the origin in the complex plane. We then have $\fr{\fc L{\B{x_i},t}}{n!\,\fc K{\B{x_i},t}} =\fr1{2\pi\i}\sum_{m_0,\ldots,m_n} \oint\d z\fr{\e^z}{z^{n+\sum_im_i+1}} \prod_i S_i^{m_i} =\fr1{2\pi\i}\oint\d z\fr{\e^z}{z^{n+1}} \prod_i\sum_{m_i}\fr{S_i^{m_i}}{z^{m_i}}.$ We have thus separated the sums over different $m_i$ . Each sum is a geometric series that converges when we choose the contour large enough, so $\fr{\fc L{\B{x_i},t}}{n!\,\fc K{\B{x_i},t}} =\fr1{2\pi\i}\oint\d z\fr{\e^z}{z^{n+1}} \prod_i\fr1{1-S_i/z} =\sum_i\fr{\e^{S_i}}{\prod_{j\ne i}\p{S_i-S_j}},$ where the last step used the residue theorem for each pole at $z=S_i$ . This expression is exactly the expanded form of the divided difference of $\B{\e^{S_i}}$ , often denoted $\e^{\b{S_0,\ldots,S_n}}$ . Therefore, $\fc L{\B{x_i},t}=n!\,\fc K{\B{x_i},t}\e^{\b{S_0,\ldots,S_n}}.$

The discrete path integral can then be rewritten in a form that only involves collecting contributions from walks without self-loops: $\bra y\fc Kt\ket x=\sum_{\text{walks }x\to y}^{\text{no self-loops}}\fc L{\text{walk},t}.$

Feynman path integral

This discrete path integral formulation of the propagator already looks similar to the Feynman path integral, but we have to go a step further to take the continuum limit to actually get there. For simplicity, I will only consider a particle with unvarying mass $m$ moving in a time-independent potential in one dimension. Its Hamiltonian is $H=p^2/2m+\fc Vx$ , and the orthonormal basis is chosen to be the position basis, also denoted as $\B{\ket x}$ .

The more standard way to derive the Feynman path integral is to slice the time integral in Equation 1, to express the total exponentiation as a product as many small exponentiations, and then to insert $\int\d x\ket x\bra x$ between each pair of exponentiations (see, e.g., chapter 6 of Quantum Field Theory by Mark Srednicki). However, this approach does not make its connection to the discrete path integral clear. Instead, we will discretize the position space into a lattice with spacing $a$ , use the discrete path integral formulation on this lattice, and then take the continuum limit $a\to0$ at the end. Now, instead of $x\in\bR$ , we have $x\in a\bZ$ . Each basis vector $\ket x$ now has two nearest neighbors $\ket{x-a}$ and $\ket{x+a}$ .

In the position basis, the kinetic part of the Hamiltonian $p^2/2m$ is a second derivative operator. From numerical differentiation, we can approximate it on the lattice as $\fr{p^2}{2m}=\fr1{2ma^2}\p{2\ket x-\ket{x+a}-\ket{x-a}}\bra x.$ Therefore, the discretized Hamiltonian is $H=\sum_x\p{\fr1{2ma^2}\p{2\ket x-\ket{x+a}-\ket{x-a}}+\fc Vx\ket x}\bra x.$ Its matrix elements are then $h_{yx}=\fr1{2ma^2}\p{2\dlt_{y,x}-\dlt_{y,x+a}-\dlt_{y,x-a}}+\fc Vx\dlt_{y,x}.$ Conceptually, it consists of on-site energy $1/ma^2+\fc Vx$ and nearest-neighbor hops. The on-site energy looks bothersome, but we can remove it if we only consider walks without self-loops. Equation 2 becomes $\bra y\fc Kt\ket x =\sum_{n=0}^\infty\p{\fr\beta{ma^2}}^n \sum_{\B{x_i}}^{\substack{x_n=y\\x_0=x}}\e^{\b{S_0,\ldots,S_n}} \prod_{i=1}^n\p{\fr12\dlt_{x_i,x_{i-1}+a}+\fr12\dlt_{x_i,x_{i-1}-a}},$ where $\beta=\i t$ is the imaginary time, and $S_i\ceq-\beta\p{1/ma^2+\fc V{x_i}}$ is defined for the same abbreviation reason as the previous section. The terms proportional to $\dlt_{x_i,x_{i-1}}$ in the multiplicant are omitted because we only consider walks without self-loops. The rest of this section is done under a Wick rotation so that $\beta$ is assumed to be a positive real parameter.

First, let us tackle the divided difference $\e^{\b{S_0,\ldots,S_n}}$ . Define $\Dlt S_i\ceq S_i-\bar S$ , where $\bar S\ceq\sum_i S/\p{n+1}$ is the mean of $\B{S_i}$ . Then, $\Dlt S_i$ is of order unity (while $S_i$ is of order $\beta/ma^2$ , which is much larger than unity for small $a$ ). Then, from the expanded form of the divided difference, we can easily get $\e^{\b{S_0,\ldots,S_n}}=\e^{\bar S}\e^{\b{\Dlt S_0,\ldots,\Dlt S_n}}.$ Recalling how we initially derived the divided difference, we have $\e^{\b{\Dlt S_0,\ldots,\Dlt S_n}}=\sum_{m_0,\ldots,m_n}\fr1{\p{n+\sum_im_i}!}\prod_i\Dlt S_i^{m_i}.$ When $n$ is large (the reason of which will be explained in a minute), we have $n!\ll\p{n+1}!\ll\p{n+2}!$ etc., while $Q_i$ is of the order of unity, so we only need to consider the terms with the lowest $\sum_im_i$ . The leading term is the term with $\sum_im_i=0$ , which is trivially $1/n!$ , so we have $\e^{\b{S_0,\ldots,S_n}}=\fr1{n!}\e^{\i\bar S} =\fr1{n!}\fc\exp{-\fr{\beta}{ma^2}-\fr{\beta}{n+1}\sum_i\fc V{x_i}}.$ This contributes to the potential part of the action.

Substitute Equation 4 into Equation 3, and we have $\bra y\fc Kt\ket x =\sum_{n=0}^\infty\fr{\e^{-\lmd}\lmd^n}{n!} \sum_{\B{x_i}}^{\substack{x_n=y\\x_0=x}} \fc\exp{-\fr{\beta}{n+1}\sum_i\fc V{x_i}}\prod_{i=1}^n\p{\fr12\dlt_\cdots+\fr12\dlt_\cdots},$ where $\lmd\ceq\beta/ma^2$ is a large positive number when $a$ is small. Observe that the factor $\e^{-\lmd}\lmd^n/n!$ is the probability mass function of the Poisson distribution with mean $\lmd$ evaluated at $n$ . When $\lmd$ is very large, the Poisson distribution can be approximated by a delta distribution because the standard deviation $\sqrt\lmd$ is much smaller than $\lmd$ . In other words, $\e^{-\lmd}\lmd^n/n!\approx\dlt_{n,\lmd}$ . Therefore, $\bra y\fc Kt\ket x =\sum_{\B{x_i}}^{\substack{x_\lmd=y\\x_0=x}} \fc\exp{-\fr{\beta}{n+1}\sum_i\fc V{x_i}} \prod_{i=1}^\lmd\p{\fr12\dlt_{x_i,x_{i-1}+a}+\fr12\dlt_{x_i,x_{i-1}-a}}.$

Imaginary parameter Poisson distribution

Imperative programming in Nix language

2025-11-06T23:47:51-08:00

Nix, a purely functional language best known for describing reproducible systems, seems to have just enough power to model imperative behavior. This article walks through a small experiment: an embedded DSL in Nix that lets you write programs with imperative features, such as mutable variables, loops, exceptions, functions, and I/O.

This article is an expansion of my earlier forum post about writing an interactive program in Nix.

Assign and print

Monads are the standard abstraction for mutation of states. A monad wraps values with extra information (such as side effects). A monadic operation can be seen as a function from some state to a new state, possibly with side effects encoded as data rather than real I/O.

This DSL adopts that idea. Each statement is a function of a state that returns an instruction of how to mutate the state. Consider this do function that “executes” a statement:

          
            do = statement: state: state // statement state state;

Each statement receives the current state and returns a function that mutates the current state into an updated one. It is equivalent to a monadic bind, but the monads are very trivial here because the unit operation is just the identity function.

Let us define some simple statements such as assignment and printing to the console:

          
            #!/usr/bin/env nix-build

            

            let

            	do = statement: state: state // statement state state;

            	assign = variables: state: state // variables;

            	print = builtins.trace;

            

            	state0 = { };

            	state1 = do (state: assign { i = 1; }) state0;

            	state2 = do (state: print "Current value: ${toString state.i}") state1;

            	state3 = do (state: assign { i = state.i + 1; }) state2;

            	state4 = do (state: print "Current value: ${toString state.i}") state3;

            

            in builtins.seq state4 { }

The final builtins.seq call forces the final state to be evaluated so that all the statements will be executed. There is no need for a builtins.deepSeq because any data that we wish to see via print will be force evaluated. The output:

          
            trace: Current value: 1

            trace: Current value: 2

This is nice! We can slightly modify do to make it handle a list of statements instead so that we do not have to call do for each statement. We can also rename state to just _ so that the code does not look too verbose.

          
            #!/usr/bin/env nix-build

            

            let

            	do = statements: _:

            		if statements == [ ] then _

            		else do (builtins.tail statements) (_ // builtins.head statements _ _);

            	assign = variables: _: _ // variables;

            	print = builtins.trace;

            

            in builtins.seq (do [

            	(_: assign { i = 1; })

            	(_: print "Current value: ${toString _.i}")

            	(_: assign { i = _.i + 1; })

            	(_: print "Current value: ${toString _.i}")

            ] { }) { }

This gives the same output as before. I used a recursion to iterate over the list of statements instead of just using builtins.foldl' because this form is easier to be modified later to incorporate exception handling.

Exception handling

Next, we add exception handling to the DSL. I introduce it before control flow because I will make loops rely on exceptions to implement break and continue.

For simplicity, I will make throwing an exception just setting a special variable _thrown_ in the state:

          
            throw = thrown: assign { _thrown_ = thrown; };

(Notice that this shadows the built-in throw function, so we will refer to the built-in one as builtins.throw if needed.) In do, we need to check whether an exception has been thrown after each statement. If so, we stop executing further statements.

          
            do = statements: _:

            	if statements == [ ] then _

            	else let result = _ // builtins.head statements _ _; in

            		if builtins.hasAttr "_thrown_" result then result

            		else do (builtins.tail statements) result;

Then, in the try statement, we check for _thrown_ after executing the try block. If an exception was thrown, we execute the catch block with the exception value passed to it (after unsetting the _thrown_ variable).

          
            try = statements: catch: _: let result = do statements _; in

            	if builtins.hasAttr "_thrown_" result then

            		do (catch result._thrown_) (removeAttrs result [ "_thrown_" ])

            	else result;

With these definitions, we can now write code that throws and catches exceptions:

          
            let # ...

            in builtins.seq (do [

            	(_: try [

            		(_: throw "Some error message.")

            	] (exception: [

            		(_: print "Caught exception: ${exception}")

            	]))

            ] { }) { }

Control flow

The control flow statements include if and while, and the latter is accompanied by break and continue. Both of them needs a condition expression that evaluates to a boolean value. The while condition will be evaluated multiple times for different states, so it at least needs to be a function that maps the state to a boolean instead of just a boolean. While the if condition can be a simple boolean expression, I will make it a function as well for consistency.

          
            if' = condition: trueStatements: falseStatements: _:

            	do (if condition _ then trueStatements else falseStatements) _;

            whileWithoutJump = condition: body:

            	if' condition [ body (_: whileWithoutJump condition body) ] [ ];

Now, to implement break and continue, we can use exception handling. Define them as throwing special exception values:

          
            break = throw "_break_";

            continue = throw "_continue_";

Then, define while to use try to catch these exceptions. The "_continue_" exception is caught inside the loop body, and the "_break_" exception is caught outside the loop to terminate the loop.

          
            catchOnly = handled: thrown: if thrown == handled then [ ] else [ (_: throw thrown) ];

            while = condition: statements: try [

            	(_: whileWithoutJump condition (_: try statements (catchOnly "_continue_")))

            ] (catchOnly "_break_");

We can now write some loops.

          
            let # ...

            in builtins.seq (do [

            	(_: assign { i = 0; })

            	(_: while (_: _.i < 5) [

            		(_: if' (_: _.i == 4) [

            			(_: break)

            		] [ ])

            		(_: if' (_: _.i == 2) [

            			(_: assign { i = _.i + 1; })

            			(_: continue)

            		] [ ])

            		(_: print "Current i: ${toString _.i}")

            		(_: assign { i = _.i + 1; })

            	])

            ] { }) { }

This prints:

          
            trace: Current i: 0

            trace: Current i: 1

            trace: Current i: 3

Functions

Defining functions is already possible without any special constructs, but only assign and do is needed:

          
            let # ...

            in builtins.seq (do [

            	(_: assign { hello = name: do [

            		(_: print "Hello, ${name}!")

            	]; })

            	(_: _.hello "world")

            ] { }) { }

We can make it nicer by having it support return to exit early from the function. Similar to break and continue, we can implement return using exceptions.

          
            return = throw "_return_";

            function = functions: assign (builtins.mapAttrs (name: fun: arg: try (fun arg) (catchOnly "_return_")) functions);

Then, we can define functions with return support:

          
            let # ...

            in builtins.seq (do [

            	(_: function { hello = arg: [

            		(_: if' (_: arg == "") [

            			(_: print "What's your name?")

            			(_: return)

            		] [ ])

            		(_: print "Hello, ${arg}!")

            	]; })

            	(_: _.hello "")

            	(_: _.hello "world")

            ] { }) { }

This prints:

          
            trace: What's your name?

            trace: Hello, world!

Input

We can use builtins.readFile to read input from files. To read from stdin, we need to use Lix to do that because the vanilla implementation of Nix does not support builtins.readFile /dev/stdin.

          
            let # ...

            	read = builtins.readFile;

            in builtins.seq (do [

            	(_: assign { input = read /dev/stdin; })

            	(_: print "You entered: ${_.input}")

            ] { }) { }

Because builtins.readFile reads the entire file until EOF, when you finish input, you need to send an EOF signal, typically by pressing Ctrl+D on an empty line. Notice that you need to press this combination on a empty line, so the input you get in Nix probably ends with a newline character that you want to trim.

If you want to read from stdin multiple times, to ensure that the Nix interpreter tries to reopen /dev/stdin each time, you must not write input = builtins.readFile /dev/stdin; in the first let block and refer to input every time you want to read from stdin. Instead, you should use read /dev/stdin every time, or wrap it in a function and call the function every time.

Other minor improvements

We may want to separate all those things in the first let block into a separate file, which let us call imperative.nix, so that we do not need to write out all those things like assign, print every time we write an imperative program. However, this would still mean that we have to pass a bunch of variables like this:

          
            let

            	inherit (import ./imperative.nix) do assign print throw;

            	# ...

            in builtins.seq (do [

            	# ...

            ] { }) { }

One way to avoid this is to use builtins.scopedImport in imperative.nix, but in my opinion, a better approach is to simply put all those things in the initial state _. Now, the actually executable Nix file just contain the list of statements, and imperative.nix will import it to run it. All the keywords like while and assign become variables in _, so nothing needs to be imported or scoped in the executable Nix file. However, this would also mean that we need to import the program in imperative.nix instead of the other way around. To make imperative.nix know which file to import, we can provide it with an argument, so it looks like this:

          
            { input }: let # ...

            in builtins.seq (

            	do

            	(import (if builtins.match input "^/" != null then input else "${toString ./.}/${input}"))

            	{ inherit assign if' while print throw break continue return function read try; }

            ) { }

To run a program in program.nix, you need to run nix-build imperative.nix --argstr input program.nix. You may encapsulate it in a shebang in imperative.nix:

          
            #!/usr/bin/env nix-shell

            #!nix-shell --pure -i "nix-build --no-out-link" -p lix

If you now make imperative.nix executable, you can run a program using imperative.nix --argstr input program.nix.

This now enables us to implement an import function that runs programs from other files:

          
            import = file: do (builtins.import file);

(This shadows the built-in import function, so we will refer to the built-in one as builtins.import if needed.) You can now do something like this:

          
            # program.nix

            [

            	(_: _.import ./other-program.nix)

            ]

          
            # other-program.nix

            [

            	(_: _.print "Hello from other program!")

            ]

When you run imperative.nix --argstr input program.nix, it will print:

          
            trace: Hello from other program!

We may improve it further by removing the need of --argstr input and also adding support for passing command line arguments to the program, at the cost of having to write a little bit of shell script and jq in the shebang (so really we cannot call it a “purely Nix” implementation now, but the nix-shell shebang is simply too powerful):

          
            #!/usr/bin/env nix-shell

            #!nix-shell --pure -i "sh -c '_1=\$1; _2=\$2; shift 2; exec nix-build --no-out-link \"\$_1\" --argstr input \"\$_2\" --argstr argvJSON \"\$(printf \"%s\\\\0\" \"\$@\" | jq -Rsc \"split(\\\"\\\\u0000\\\")[:-1]\")\"' --" -p lix jq

            

            { input, argvJSON }: let # ...

            	argv = builtins.fromJSON argvJSON;

            in builtins.seq # ...

The mechanism is that the shell script in the shebang extracts the first two command line arguments as the Nix file to run and the input file, and the rest of the command line arguments are concatenated with null characters and converted to a JSON array using jq. In imperative.nix, we parse the JSON array back to a Nix list and provide it as the variable argv in the initial state _. You can now simply use a shebang #!/usr/bin/env imperative.nix in program.nix, and then you can run it with ./program.nix arg1 arg2 if you make it executable, and the command line arguments will be available in the list _.argv.

Finally, we can use try instead of do in the ultimate builtins.seq call to catch any uncaught exceptions in the program. Here is the final version of imperative.nix and an example program.nix that uses most of the features we introduced:

          
            #!/usr/bin/env nix-shell

            #!nix-shell --pure -i "sh -c '_1=\$1; _2=\$2; shift 2; exec nix-build --no-out-link \"\$_1\" --argstr input \"\$_2\" --argstr argvJSON \"\$(printf \"%s\\\\0\" \"\$@\" | jq -Rsc \"split(\\\"\\\\u0000\\\")[:-1]\")\"' --" -p lix jq

            

            { input, argvJSON }: let

            	do = statements: _:

            		if statements == [ ] then _

            		else let result = _ // builtins.head statements _ _; in

            			if builtins.hasAttr "_thrown_" result then result

            			else do (builtins.tail statements) result;

            	assign = variables: _: _ // variables;

            	read = builtins.readFile;

            	print = builtins.trace;

            	if' = condition: trueStatements: falseStatements: _:

            		do (if condition _ then trueStatements else falseStatements) _;

            	whileWithoutJump = condition: body:

            		if' condition [ body (_: whileWithoutJump condition body) ] [ ];

            	catchOnly = handled: thrown: if thrown == handled then [ ] else [ (_: throw thrown) ];

            	while = condition: statements: try [

            		(_: whileWithoutJump condition (_: try statements (catchOnly "_continue_")))

            	] (catchOnly "_break_");

            	throw = thrown: assign { _thrown_ = thrown; };

            	break = throw "_break_";

            	continue = throw "_continue_";

            	return = throw "_return_";

            	try = statements: catch: _: let result = do statements _; in

            		if builtins.hasAttr "_thrown_" result then

            			do (catch result._thrown_) (removeAttrs result [ "_thrown_" ])

            		else result;

            	function = functions: assign (builtins.mapAttrs (name: fun: arg: try (fun arg) (catchOnly "_return_")) functions);

            	import = file: do (builtins.import file);

            	argv = builtins.fromJSON argvJSON;

            in builtins.seq (

            	try

            	(builtins.import (if builtins.match input "^/" != null then input else "${toString ./.}/${input}"))

            	builtins.throw

            	{ inherit assign if' while print throw break continue return function read try import builtins argv; }

            ) { }

          
            #!/usr/bin/env imperative.nix

            

            [

            	(_: _.import (_.builtins.toFile "other-input.nix" "[ (_: _.print \"Hello from other file!\") ]"))

            	(_: _.function { hello = arg: [

            		(_: _.if' (_: arg == "") [

            			(_: _.print "What's your name?")

            			(_: _.return)

            		] [ ])

            		(_: _.print "Hello, ${arg}!")

            	]; })

            	(_: _.hello "")

            	(_: _.hello "World")

            	(_: _.while (_: _.argv != [ ]) [

            		(_: _.hello (_.builtins.head _.argv))

            		(_: _.assign { argv = _.builtins.tail _.argv; })

            	])

            	(_: _.assign { i = 0; })

            	(_: _.while (_: _.i < 5) [

            		(_: _.if' (_: _.i == 4) [

            			(_: _.break)

            		] [ ])

            		(_: _.if' (_: _.i == 2) [

            			(_: _.assign { i = _.i + 1; })

            			(_: _.continue)

            		] [

            			(_: _.hello "${_.builtins.toString _.i}")

            		])

            		(_: _.assign { i = _.i + 1; })

            	])

            	(_: _.try [

            		(_: _.throw "Some error message.")

            	] (exception: [

            		(_: _.print "Caught exception: ${exception}")

            	]))

            	(_: _.print "Goodbye!")

            ]

When you run ./program.nix Kat "Ulysses Zhan", it will print:

          
            trace: Hello from other file!

            trace: What's your name?

            trace: Hello, World!

            trace: Hello, Kat!

            trace: Hello, Ulysses Zhan!

            trace: Hello, 0!

            trace: Hello, 1!

            trace: Hello, 3!

            trace: Caught exception: Some error message.

            trace: Goodbye!

Possible improvements

Maybe I can improve it further by adding support for local variables. It would also be nice if functions with side effects can also have return values, but this would be tricky to implement.

Multi-pass Gaussian blur filter

2025-07-17T01:06:08-07:00

In image processing, a Gaussian blur filter is the transformation of an image that blurs it by a Gaussian function. Mathematically, a Gaussian blur filter is a linear transformation $G$ on a measurable function $f:\bR^d\to\bR$ that does not grow too fast at infinity (or more generally, $f:\bR^d\to V$ , where $V$ is a locally convex topological vector space) which results in a function $Gf:\bR^d\to\bR$ defined by the integral $\fc{Gf}x\ceq\int\frac{\d^dy}{\sqrt{\p{2\pi}^d\det A}}\fc\exp{-\fr12\p{A^{-1}}_{jk}y_jy_k}\fc f{x+y},$ where $A$ is a symmetric positive definite matrix called the covariance matrix of the Gaussian kernel.

By looking at this formula, we can see that $\fc{Gf}x$ is exactly the expectation value of $\fc f{x+Y}$ , where $Y$ is a random vector distributed according to the multivariate normal distribution with mean $0$ and covariance matrix $A$ . Let’s say, however, that instead of a multivariate normal distribution, we have a discrete distribution on a finite set of points $\B{a_i}$ , each with probability $w_i$ , satisfying $\sum_i w_i=1,\quad\sum_i w_ia_i=0.$ Then, for $Y$ distributed according to this discrete distribution, the expectation value of $\fc f{x+Y}$ is $\bopc E{\fc f{x+Y}}=\sum_i w_i\fc f{x+a_i}.$ This distribution has the covariance matrix $A_{jk}=\sum_i w_ia_{ij}a_{ik}$ , but this expectation value is not the same as the result $\fc{Gf}x$ of the Gaussian blur filter. In order to approach the Gaussian distribution, we need to sum $N$ independent samples $\B{Y_\alpha}$ , each distributed according the same discrete distribution with covariance matrix $A/N$ . Without changing the relation between $A$ and $\B{a_i}$ , we can achieve this by taking the distribution to be among the points $\B{a_i/\sqrt N}$ , with the same probabilities $w_i$ . Then, according to the central limit theorem, we have $\fc{Gf}x=\lim_{N\to\infty}\bopc E{\fc f{x+\sum_\alpha Y_\alpha}} =\lim_{N\to\infty}\sum_{\B{i_\alpha}}\p{\prod_\alpha w_{i_\alpha}}\fc f{x+\fr{1}{\sqrt N}\sum_\alpha a_{i_\alpha}}.$ By staring at this formula, one may notice that it is actually the result of the same linear transformation $P_N$ applied $N$ times to the function $f$ , where $\fc{P_Nf}x\ceq\sum_iw_i\fc f{x+\fr{a_i}{\sqrt N}}.$ Thus, we can write $G=\lim_{N\to\infty}P_N^N.$

We can now see why we can implement a Gaussian blur filter as a multi-pass filter: each pass of the filter is equivalent to applying the linear transformation $P_N$ once, and the Gaussian blur filter is the limit of applying this transformation infinitely many times. After choosing the points $\B{a_i}$ and the weights $w_i$ , we can easily implement the filter in a fragment shader. After implementing $P_N$ , one can implement the multi-pass filter by flip-flopping between two textures $N$ times. Here is an example implementation of $P_N$ for a 2D ( $d=2$ ) texture, with $a_0=\begin{pmatrix}\sgm\\0\end{pmatrix},\quad a_1=\begin{pmatrix}-\sgm\\0\end{pmatrix},\quad w_0=w_1=\fr12,$ where $\sgm$ would be the standard deviation of the resulting Gaussian blur filter:

          
            varying vec2 vTextureCoord;

            

            uniform sampler2D uTexture;

            uniform float uStrength; // sigma / sqrt(N)

            

            void main() {

            	gl_FragColor  = texture2D(uTexture, vTextureCoord + vec2( uStrength, 0.0)) * 0.5;

            	gl_FragColor += texture2D(uTexture, vTextureCoord + vec2(-uStrength, 0.0)) * 0.5;

            }

When using the shader, the texture is input as the uniform uTexture, and $\sgm/\sqrt N$ is input as the uniform uStrength. This example is then called the 2-tap horizontal Gaussian blur filter (because to find $\fc fx$ for some $x$ one needs to evaluate $f$ twice).

To get a good Gaussian blur effect, $N$ should be large enough, which can quickly become computationally expensive. We can reduce the number of passes by rewriting $P_N^N=\p{P_N^n}^{N/n}$ so that the number of passes is now reduced from $N$ to $N/n$ without changing the result, but the cost is to implement $P_N^n$ instead of $P_N$ in the shader. With the $P_N$ example above, the $P_N^n$ filter is then a $\p{n+1}$ -tap horizontal Gaussian blur filter. The total number of times to fetch the texture is $\p{n+1}N/n$ to render the whole blurred texture, which decreases as $n$ increases.

By utilizing the linear sampling feature of the GPU, this number can be further reduced (by half) if $\sgm/\sqrt N=1$ . One can read further about this in this article.

Let us now move on to an interesting relation to the heat equation. The heat equation is a partial differential equation that reads $\partial_t\fc{f_t}x=\sum_j\partial_j\partial_j\fc{f_t}x.$ The physical meaning of $\fc{f_t}x$ is the temperature at position $x$ at time $t$ , and the solution to this equation gives the time evolution of the temperature distribution in a medium with unit thermal diffusivity. More generally, we can have some other thermal diffusivities, which may even be anisotropic, in which case the equation reads $\partial_t\fc{f_t}x=\fr12\sum_{jk}A_{jk}\partial_j\partial_k\fc{f_t}x,$ where $A$ is a symmetric positive definite matrix. Such an equation can always be reduced to the form with unit thermal diffusivity by a linear transformation of the coordinates $x\mapsto Lx$ , where $L$ satisfies $A/2=L^\mrm TL$ (the Cholesky decomposition of $A/2$ ). By using operator exponentiation, we can write the solution to the heat equation as $\fc{f_t}x=G^t\fc{f_0}x$ , where $G^t\ceq\fc\exp{\fr t2\sum_{jk}A_{jk}\partial_j\partial_k}$ is called the time evolution operator (which is not generally defined for $t<0$ , which means that $\B{G^t}$ cannot form a group but only a monoid).

The reason that I denote it as $G^t$ is that $G^1$ gives exactly the Gaussian blur filter $G$ (when acting on real analytic functions). This is not immediately obvious, and I will justify its correctness by starting from the multi-pass expression of the Gaussian blur filter. For analytic functions, we can get the translation operator by exponentiating the derivative operator, so $\fc f{x+\fr{a_i}{\sqrt N}}=\fc\exp{\sum_j\fr{a_{ij}}{\sqrt N}\partial_j}\fc fx.$ Therefore, we can write $\begin{align*} P_N&=\sum_iw_i\fc\exp{\sum_j\fr{a_{ij}}{\sqrt N}\partial_j}\\ &=\underbrace{\sum_iw_i}_1 +\fr1{\sqrt N}\sum_j\underbrace{\sum_iw_ia_{ij}}_0\partial_j +\fr1{2N}\sum_{jk}\underbrace{\sum_iw_ia_{ij}a_{ik}}_{A_{jk}}\partial_j\partial_k +\order{N^{-3/2}}. \end{align*}$ Now, in the limit of infinite $N$ , we have $G=\lim_{N\to\infty}P_N^N =\lim_{N\to\infty}\p{1+\fr1{2N}\sum_{jk}A_{jk}\partial_j\partial_k}^N =\fc\exp{\fr12\sum_{jk}A_{jk}\partial_j\partial_k}=G^1.$ This means that applying the Gaussian blur filter is equivalent to evolving one unit of time according to the heat equation. Therefore, the equation in the beginning of this article, the definition of the Gaussian blur filter, can then be used to express the unit time evolution under the heat equation in the form of a integral transformation. To get the general $G^t$ , we can just replace $A$ with $tA$ .

As a byproduct, we can then show that the heat kernel is a Gaussian kernel. The heat kernel $\fc{K_t}{x,x'}$ is defined as the solution to the heat equation with initial condition $\fc{K_0}{x,x'}=\fc\dlt{x-x'}$ . Directly applying $G^t$ to $\fc\dlt{x-x'}$ gives $\begin{align*} \fc{K_t}{x,x'}&=G^t\fc\dlt{x-x'}\\ &=\int\fr{\d^dy}{\sqrt{\p{2\pi t}^d\det A}}\fc\exp{-\fr1{2t}\p{A^{-1}}_{jk}y_jy_k}\fc\dlt{x+y-x'}\\ &=\fr{1}{\sqrt{\p{2\pi t}^d\det A}}\fc\exp{-\fr1{2t}\p{A^{-1}}_{jk}\p{x_j-x'_j}\p{x_k-x'_k}}, \end{align*}$ which is the form that you would find in textbooks.

The reason that I decided to study the Gaussian blur filter is that I spotted a flaw in the implementation of the blur filter in PixiJS, where the uniform uStrength in the example shader above is scaled by $1/N$ instead of $1/\sqrt N$ . I was very happy to find the bug because this is the first time that I found a bug without actually producing an unexpected phenomenon first but by just staring at the source codes and deducing the mathematical formulas by hand. I opened an issue for my findings.

The buildup kickroll in Time to beat the odds

2025-06-22T00:31:43-07:00

There is a gradually-accelerating buildup kickroll at 1:18 in the song Time to beat the odds by 影虎。. In order to know the details of this rhythm, I have to analyze the sample using Python. The main method is to do a short-time Fourier transform and to find the peaks in the high-frequency region of the spectrogram. A linear regression shows that the time intervals decay geometrically.

Eigenfunctions of the Laplacian on an annulus with homogeneous Neumann boundary condition

2025-04-11T00:40:49-07:00

The problem and the solution

Suppose there is an annulus defined by the region $\set{\p{\rho,\vphi}}{R_\mrm{in}<\rho$ . What are the functions $\Phi$ defined on this region that satisfy $\lmd\Phi=\nabla^2\Phi=\fr1\rho\partial_\rho\p{\rho\partial_\rho\Phi}+\fr1{\rho^2}\partial_\vphi^2\Phi$ and the boundary conditions $\partial_\rho\fc\Phi{\rho=R_\mrm{in},\vphi}=\partial_\rho\fc\Phi{\rho=R_\mrm{out},\vphi}=0,$ i.e., eigenfunctions of the Laplacian on the annulus with homogeneous Neumann boundary conditions?

For any boundary condition with azimuthal symmetry, an easy separation of variable gives you solutions of the general form $\fc\Phi{\rho,\vphi}=\p{\Xi^{\p J}\fc{J_m}{z\rho/R_\mrm{out}}+\Xi^{\p Y}\fc{Y_m}{z\rho/R_\mrm{out}}}\e^{\i m\vphi},$ where $\Xi^{\p J}$ , $\Xi^{\p Y}$ , and $z$ are constants fixed by the boundary conditions, and $m$ is an integer and the azimuthal quantum number. The functions $J_m$ and $Y_m$ are Bessel functions of the first and second kind, respectively, which are two linearly independent solutions of the Bessel equation $z^2\fc{y''}z+z\fc{y'}z+\p{z^2-m^2}\fc{y}z=0$ with some particular normalization. Plugging the general form into the boundary condition, and we have $\Xi^{\p J}\fc{J_m'}{z}+\Xi^{\p Y}\fc{Y_m'}{z}=0,\quad \Xi^{\p J}\fc{J_m'}{rz}+\Xi^{\p Y}\fc{Y_m'}{rz}=0,$ where $r\ceq R_\mrm{in}/R_\mrm{out}$ . This is regarded as a homogeneous linear system of equations for $\Xi^{\p J}$ and $\Xi^{\p Y}$ . In order for it to have nontrivial solutions, the determinant of the coefficient matrix must vanish, which gives $\fc gz\ceq\fc{J_m'}{rz}\fc{Y_m'}z-\fc{Y_m'}{rz}\fc{J_m'}z=0.$ We can then assign a radial quantum number $n$ to the eigenfunctions by making the value of $z$ the $n$ th root of $g$ , which we may casually call $z_{mn}$ .

We then have the final solution (up to normalization) $\fc{\Phi_{mn}}{\rho,\vphi}=\p{\fc{Y_m'}{z_{mn}}\fc{J_m}{z_{mn}\rho/R_\mrm{out}} -\fc{J_m'}{z_{mn}}\fc{Y_m}{z_{mn}\rho/R_\mrm{out}}}\e^{\i m\vphi},$ where $m$ is the azimuthal quantum number, and $n$ is the radial quantum number, and $z_{mn}$ is defined as the $n$ th root of the function $g$ . The eigenvalue is $\lmd_{mn}=-z_{mn}^2/R_\mrm{out}^2$ . In order for the eigenfunctions to be complete, we need to allow $m$ to be any integer, but we will restrict ourselves to non-negative $m$ in the rest of the article because the negative ones are practically the same as the positive ones.

Distribution of eigenvalues

From the well-known asymptotic form of the Bessel functions (source) $\fc{J_m}{z\to\infty}=\sqrt{\fr2{\pi z}}\fc\cos{z-\fr{m\pi}2-\fr\pi4},\quad \fc{Y_m}{z\to\infty}=\sqrt{\fr2{\pi z}}\fc\sin{z-\fr{m\pi}2-\fr\pi4},$ we can easily conclude that the asymptotic form of $g$ is $\fc g{z\to\infty}=\fr{2\fc\sin{\p{1-r}z}}{\pi\sqrt r\,z}.$ This inspires us to define a function in companion with $g$ as $\fc fz\ceq\fc{J_m'}{rz}\fc{J_m'}z+\fc{Y_m'}{rz}\fc{Y_m'}z,$ which will have the asymptotic form $\fc f{z\to\infty}=\fr{2\fc\cos{\p{1-r}z}}{\pi\sqrt r\,z}.$ Therefore, $f\sim\cos\fc\tht z$ and $g\sim\sin\fc\tht z$ are like the cosine and sine pair of oscillatory functions, with a phase angle $\fc\tht{z\to\infty}=\p{1-r}z$ asymptotically directly proportional to $z$ .

Here is a plot that shows how $\tht$ behaves:

The blue line is $\fc\arctan{\fc gz/\fc fz}$ , and the orange line is $\arctan\fc\tan{\p{1-r}z}$ . we can see that the two functions are asymptotically equal.

A good thing about this description is that we can now see that $z_{mn}$ as a root of $g$ is just the solution to the equation $\fc\tht z=n\pi$ . In other words, $z_{mn}$ are just the points at which the blue line crosses the horizontal axis in the plot above. Therefore, if we can find the inverse function $\fc z\tht$ (maybe in a series expansion), we can directly get $z_{mn}=\fc z{n\pi}$ . We can see from the plot that $\fc z\tht=\tht/\p{1-r}$ is probably not a good enough approximation. Therefore, we would like to seek higher order terms.

Kummer’s equation

For this part, we employ a method similar to a paper by Bremer.

First, for a general homogeneous second-order linear ODE in the form $y''+2\chi y'+\psi y=0$ , where $\chi$ and $\psi$ are known functions of $z$ , we can define $y_\mrm n\ceq py,\quad p\ceq C\exp\int\chi\,\d z, \quad q\ceq p\psi-p'',$ and the ODE will become a normal form $y_\mrm n''+qy_\mrm n=0$ . Therefore, for any second-order linear ODE, we only need to consider those without the first-derivative term.

Then, one can prove that, for the ODE $y''+qy=0$ , its two linearly independent solutions can be expressed as $u=\fr{\cos\alp}{\sqrt{\alp'}},\quad v=\fr{\sin\alp}{\sqrt{\alp'}},$ where $\alp$ satisfy Kummer’s equation $\alp^{\prime2}+\fr{\alp'''}{2\alp'}-\fr{3\alp^{\prime\prime2}}{4\alp^{\prime2}}=q.$ This may seem like converting a problem to a more complicated one, but the advantage is that $\alp$ is not oscillatory while $u$ and $v$ are oscillatory, which means that it would be easier to expand $\alp$ as a series for large $z$ . Notice that $\alp'=1/\p{u^2+v^2}$ , which provides a means of finding $\alp$ if the solutions of the original ODE are known.

Derivation

The role of particle indistinguishability in statistical mechanics

2025-03-03T22:53:47-08:00

Classical vs. quantum statistical mechanics

Previously, I have written two blog articles (part 1 about thermal ensembles and part 2 about non-thermal ensembles) about a formalism of statistical ensembles. I will be using it as the formalism of classical statistical mechanics in this article.

In that formalism, the space of microstates of a system is a measure space $\mcal M$ , and the physical meaning of the measure is the number of microstates. A macrostate is described by the extensive quantities, which are a function of the microstate, so designating a macrostate restricts the microstates that can realize it to a subset of $\mcal M$ .

A state of the system is a probability density function $p$ on $\mcal M$ , whose physical meaning is an ensemble of microstates. The macroscopically measured extensive quantities of the system are defined to be the ensemble average, i.e., the measured value of $A:\mcal M\to\bR$ is $\int_{\mcal M}pA$ . Generally, any probability density function is a perfectly valid state, but the most important ones are those that are thermal equilibrium states, including the microcanonical ensembles, the thermal ensembles, and the non-thermal ensembles. The term about an ensemble being thermal or non-thermal is made up by me, but for most practical reasons, we only need to focus on thermal ensembles (because both canonical ensembles and grand canonical ensembles are thermal ensembles).

To avoid subtleties about measure theory and topology, in this article, we will only use counting measure and discrete spaces for the space of microstates and the space of extensive quantities.

Possible confusion of macrostate vs. state and an example

Why it is a bad idea to use GitHub for submiting school homework

2025-01-09T23:51:35-08:00

Do not take this artical as legal advice because I am not a lawyer.

It is common for school courses to require students to submit their homework using GitHub, especially in college-level courses offered in universities, but this may not be the best idea.

The first reason why GitHub is not suitable for that is that it is not controlled by the school. GitHub has its own terms of service (TOS), which students must agree to. This may not sound bad because it is not hard for students to do so, but the course instructors may be forcing students to violate the TOS by “threatening” that they will get a bad grade otherwise. There are different possible reasons why the instructors may be doing this. Maybe they are not familiar with the TOS enough; maybe they are just not familar enough with GitHub to come up with an actually good way of managing homework; or maybe they are aware of that but do not care.

What is the big deal? Why is it bad to violate the TOS? Well, the GitHub account of a student may be really important to him: he may be contributing to dozens of open-source projects, or he may be presenting his GitHub username in his resume. This account is not only important for the owner himself, it is also important for the community: some of the repositories that the account owns may be very popular projects; there may be hundreds of people following the account because they are interested in the work of its owner; important webpages (hosted on GitHub Pages) or important package registries (hosted on GitHub Packages) may be associated with the account; and many pages on the internet may be linking to contents of the account. Now, if the account violates the TOS, it may be subject to being suspended, losing privileges, or getting hidden from the public, any of which may cause a lot of harm to the owner and the community. Because of violation of TOS, the account owner may face trouble when reaching GitHub support because it tends to refuse to help users who violate the TOS.

What about creating a new account just for the course? Yes, it sounds like a effective and simple solution, only if it is allowed by the TOS. Actually, the TOS explicitly prohibits one person to own multiple non-bot accounts:

One person or legal entity may maintain no more than one free Account (if you choose to control a machine account as well, that’s fine, but it can only be used for running a machine).

Therefore, it is still a violation of TOS to create a new account just for the course. People may argue that GitHub will not know whether different accounts are owned by the same person, but the answer is it will know if it really wants to know. Also, even if it does not ban the account for this reason, it is still possible for GitHub support to ignore the tickets filed by the account owner because his violation of the TOS. There are actually multiple real-life cases of this.

What is worse is that the students do not have a proper way to defend against this. The most likely case that will happen is that all the students are not familiar enough with the TOS to discover that the instructors are forcing them to violate the TOS. The consequences of the violation may only appear long after they are out of the course or even long after they graduate. There is no way they can trace back to the instructors and ask them to take responsibility for the harm they have caused. Even if there is a student that discovers the potential problem in violating the TOS and sends an email to the instructors to ask for a change in the policy of the course, it is still up to the instructors to decide whether they are actually going to do that. If they are, it is good, but if they are not, there is no place for the student to appeal to. GitHub will not care about this because the account owner takes all the responsibility in the issues related to his account. The school will not care about this because the course is still “fair” for the students. Other students will not care about this because most of them are not going to heavily use their GitHub accounts after the course or after they graduate.

After saying so much about the consequences of the instructors forcing students to violate the TOS, what are the TOS that may be violated? The first one is the one mentioned above: multiple accounts. Instructors may tell students to create a new account just for the course, or they may tell students to do so if they do not feel comfortable using their existing personal account for the course, due to ignoring or not knowing that this is a violation of the TOS.

Another TOS that may be violated is the one that enforces the right for GitHub users to fork public repositories. The instructors may tell students to comply with academic integrity codes by stating that the work done in the repo must not be “plagiarized”. However, not only is this not enforceable, but it also violates the TOS of GitHub because any public repository grants the right for other GitHub users to freely use and create their own copies:

If you set your pages and repositories to be viewed publicly, you grant each User of GitHub a nonexclusive, worldwide license to use, display, and perform Your Content through the GitHub Service and to reproduce Your Content solely on GitHub as permitted through GitHub’s functionality (for example, through forking).

While this can be circumvented by making the repositories private, many instructors do not allow using private repositories for homework for some reasons. Maybe they do not want to bother managing the access permissions to many students’ private repositories, or maybe they are only coping with the academic integrity codes without actually enforcing it.

Besides violation of the TOS, the instructors may also be forcing students to do harm to their own. One example is that some instructors force the names of the repositories that students create for homework, and the repositories must be under the account of the student (so no designated GitHub organization for that). However, the names of the repositories under the same account must be unique, which means that students may have to delete or rename their old repositories. This definitely is doing harm to the account as well as the community because it breaks the links to the old repositories, and students have to do this because their grades are at stake.

Another harm that using GitHub for schoolwork can cause is the privacy issue. If the repositories are public, people can see the work of the students and infer school information from them. If the repositories are private, people can still see when the repositories are created and updated, which may be enough to infer school information. Because the GitHub account is also used by the student to communicate with other people in the open-source community on the internet, the partial disclosure of these information may cause harm to the student by enabling others to identify his real-life identity.

Another harm is that the school activities may be “polluting” the GitHub account activities and thus affecting the students’ reputation in the community. Some people may be following the account because they are interested in the work of the student, but if the student starts using the account for schoolwork, the account activities will be filled with schoolwork activities for some time, which may not be the things that the student may want to show to the followers. This may cause the followers to unfollow the account. It is similar to the situation where the instructors ask students to upload public videos using their personal YouTube accounts for schoolwork, which can do harm to the students if they are already popular YouTubers. However, YouTube actually allows one account to have multiple channels, so that does not have negative effects like GitHub.

The third reason why GitHub is not suitable for submitting school homework is that the school has no control over the service. GitHub is also probably not receiving any money from the school to take the responsibility of providing the service for schoolwork purposes. Apparently, GitHub can refuse its service for any or no reason:

GitHub has the right to suspend or terminate your access to all or any part of the Website at any time, with or without cause, with or without notice, effective immediately. GitHub reserves the right to refuse service to anyone for any reason at any time.

This means that students have to “pray” that GitHub will continue be reliable for them to keep using it for schoolwork. If GitHub decides to stop providing services for some students, their grades may get penalized because they cannot submit their homework, and this situation is definitely possible considering that the students may actually be violating the TOS of GitHub whether for the course or not. GitHub will not care about this because the account owner takes all the responsibility. The instructor or the school may not care about this because they may deem the students’ own fault to be the cause of the suspension of the service. There is simply no way for students to tackle this situation.

This situation is very different from other third-party services, such as Google Workspace, Zoom Workplace, or Microsoft 365, because the school is actually paying for the service so that the providers are liable to provide the service.

There is indeed paid services provided by GitHub, though, such as GitHub Enterprise, which may actually be suitable for school contexts. However, the school is not motivated to pay for the service because the free services provided by GitHub are already enough for educational purposes.

The fourth reason of not using GitHub for schoolwork is that Git and GitHub are just too difficult to use while being designed to be user-friendly. This causes an awkward situation: it does not worth a full course designated to teach Git and GitHub, but it would also have to take up a considerable part of a course to teach all the relevant best practices of Git and GitHub to students. This leads to the problem of students actually misusing Git and GitHub when learning it in school because instructors may not bother to spend time to teach them Git instead of teaching the actually relevant course materials. Not to mention that the instructors may intentionally tell students to follow bad practices because GitHub is missing on LMS (learning management system) features to conveniently suit schoolwork needs or because the instructors are simply not aware of better practices. It is also possible that the instructor just does not want to bother teaching those practicies because most students are not going to use Git and GitHub after the course or after they graduate.

One common bad practice that especially happens in school contexts is to use Git to manage frequently-updated binary files. While it is arguable whether Git should be used to manage binary files at all, it definitely causes resource waste to use Git to manage frequently-updated binary files because diffs on them can only be resolved if the old version mathces exactly. Also, in most cases, it is impossible to efficiently store the history version of binary files by storing deltas between versions. Another common bad practice is to include running results of the code in the repository. Instead, they should be produced by CI systems (e.g. GitHub Actions) and stored in the artifacts of the CI systems (e.g. GitHub releases or GitHub Packages). A worse common bad practice is that some instructors are just using GitHub as a file hosting service instead of a version control system. They may tell students to upload their homework as a zip file or tarball on GitHub, which is really confusing because you can actually download the tarball of a repository directly on GitHub. The list of bad practices can go on.

Some may argue that the problem of teaching bad practices can happen in any course besides those use GitHub for homework submission. Some incapable instructors may even teach false information in the course, which is just inevitable. However, the problem especially with GitHub is that GitHub is also the place where worldwide developers form the community, and a concensus on good practices is important for a community. Having students employ bad practices on GitHub may affect the atmosphere of the community and can also cause resource wasting from the perspective of GitHub the platform. This is different from usual academic situations because, in most academic situations, misusage can only propagate through paper publications and academic conferences, which are much more formal and have a much higher barrier of entry than GitHub.

The final reason of not using GitHub for schoolwork is that GitHub is not a learning management system (LMS). It lacks essential features that are needed for schoolwork.

There are existing LMS softwares that are designed to be used in school contexts, suited for material distribution, homework submission and collection, grading, communication, and so on, designed with the consideration of being used by the instructors, graders, students, and possibly other roles. There are even open-source ones that can actually be self-hosted by the school such as Canvas (I am a big fan of Canvas).

What is more devious is that, in order to use the workflow of the existing LMS, some instructors ask students to submit their homework in the LMS after they finish it on GitHub. Sometimes instructors ask students to submit a GitHub link in the LMS. While this may seem like a good idea, some instructors may ask students to submit wierd things such as a PDF consisting of screenshots of webpages on GitHub so that graders can annotate using the features shipped with the LMS. These are just inefficient ways of working around the limitations of the LMS and GitHub.

If the course needs to use GitHub for source version control, CI/CD, or other software development-related purposes, besides normal LMS features such as homework submission and grading, there is a LMS provided GitHub dedicated for that purpose called GitHub Classroom. Though it looks very promising, it seems rare for schools to actually use it, so I have never used it myself.

How to use JavaScript in GitHub Actions without committing `node_modules`

2024-11-15T16:34:55-08:00

I was creating my first GitHub Action (it is now working, which you can check out here). I am familiar with JavaScript, so I chose to create a JavaScript action. According to the official documentation, I need to do one of the following to make my JavaScript code correctly import 3rd-party modules:

commit the node_modules to the repo, or
use @vercel/ncc to bundle everything into a single script.

I think both of these methods are not good practices. Especially, for my case, the way with @vercel/ncc is not feasible because some package uses require.

The best way to handle this is to make GitHub cache and install all the dependencies for the user every time the action is run. This can be made possible by creating a composite action. Here is a snippet in action.yml:

          
            runs:

              using: composite

              steps:

                - name: Setup Node.js

                  uses: actions/setup-node@v4

                  with:

                    node-version: '20'

            

                - name: Get cache key and path

                  id: lock

                  run: |

                    cd $GITHUB_ACTION_PATH

                    node <<'JAVASCRIPT'

                      const fs = require('fs');

                      const os = require('os');

                      const sha256 = require('crypto').createHash('sha256');

                      const hash = sha256.update(fs.readFileSync('package-lock.json')).digest('hex');

                      fs.appendFileSync(process.env.GITHUB_OUTPUT, `key=${os.platform()}-${os.arch()}-grs-modules-${hash}\n`);

                    JAVASCRIPT

                    modules=$(pwd)/node_modules

                    command -v cygpath &> /dev/null && modules=$(cygpath -w $modules)

                    echo "modules=$modules" >> $GITHUB_OUTPUT

                    cat $GITHUB_OUTPUT

                    cd $GITHUB_WORKSPACE

                  shell: bash

            

                - name: Restore cache

                  uses: actions/cache/restore@v4

                  id: cache-restore

                  with:

                    path: ${{ steps.lock.outputs.modules }}

                    key: ${{ steps.lock.outputs.key }}

            

                - name: CI

                  if: steps.cache-restore.outputs.cache-hit != 'true'

                  run: |

                    cd $GITHUB_ACTION_PATH

                    npm ci

                    cd $GITHUB_WORKSPACE

                  shell: bash

            

                - name: Save cache

                  if: steps.cache-restore.outputs.cache-hit != 'true'

                  uses: actions/cache/save@v4

                  with:

                    path: ${{ steps.lock.outputs.modules }}

                    key: ${{ steps.lock.outputs.key }}

            

                - name: Run

                  run: node $GITHUB_ACTION_PATH/index.js

                  shell: bash

I manually use actions/cache to cache the node_modules directory although actions/setup-node has caching functionality. This is because it is not good yet. Also, because github.action_path ends with /./, it can cause some problem due to the relative pathing. My workflow here works around those problems.

The hash in the cache key is calculated using JavaScript because there is no sha256sum command on macOS and Ubuntu runners.

Some understanding of Grassmann numbers out of intuition

2024-10-10T22:40:02-07:00

This article (except the introduction and the afterwords) is my answer to one of the homework problems that I did when I took a quantum field theory course. The original problem asked to verify the formula for linear change of variables in integration. It was originally written on 2024-02-06.

Introduction

Although Grassmann numbers are purely mathematical concept, but like most people, I was introduced to them in physics class. I then had the natural question: how to formally define Grassmann numbers? In a homework given by my professor of QFT course, I found that I had to answer the question to do a problem in the homework in a way that I am satisfied with.

Numbers

Let $\p{\mbb G_0,+}$ and $\p{\mbb G_1,+}$ be two abelian groups such that $\mbb G_0\cap\mbb G_1=\B{0}$ . For convenience, for any $k\in\bN$ , define $\mbb G_k\ceq\mbb G_{k\bmod2}$ . Define a multiplication on $\mbb G_0\cup\mbb G_1$ such that

multiplication is associative, non-degenerate, and distributive over addition;
$\mbb G_0$ are commuting numbers and $\mbb G_1$ are anticommuting numbers: $\forall\psi_1\in\mbb G_{k_1},\psi_2\in\mbb G_{k_2}: \psi_1\psi_2=\p{-}^{k_1k_2}\psi_2\psi_1;$
and there is a unity $1\in\mbb G_0$ such that $1+\cdots+1\ne0$ for any finite number of summands.

We then have to have $\forall\psi_1\in\mbb G_{k_1},\psi_2\in\mbb G_{k_2}: \psi_1\psi_2\in\mbb G_{k_1+k_2}.$ Therefore, $\mbb G_0$ is a commutative ring with characteristic zero, and $\mbb G_1$ is a $\mbb G_0$ -module. We can then define linear functions with this structure. In this sense, the multiplication on $\mbb G_1$ defines a symplectic bilinear form.

These are not enough to define every property we need for $\mbb G_0$ and $\mbb G_1$ . I will introduce more properties as axioms later.

Tensors

It seems that we need this property as an axiom: for any linear function $\func\lmd{\mbb G_k}{\mbb G_0}$ , $\exists!\vphi\in\mbb G_k:\lmd=\p{\psi\mapsto\vphi\psi}.$ I call this property the first representation property, analog to the Riez representation theorem. I will call linear functions that maps objects to $\mbb G_0$ linear functionals, and the dual space of a $\mbb G_0$ -module as the set of all linear functionals on it.

With the fist representation property, we can identify $\mbb G_k$ with its dual space so that any multilinear map (tensor) have well-defined components. For any $k$ -linear map $\func T{\p{\mbb G_1^n}^k}{\mbb G_0}$ (or alternatively called a rank- $k$ tensor on $\mbb G_1^n$ ), we can write it uniquely in the form $\fc T{\psi_1,\dots,\psi_k}=\psi_{1i_1}\cdots\psi_{ki_k}a_{i_1\cdots i_k},$ where the components $T_{i_1\cdots i_k}\in\mbb G_k$ , and the dummy indices are summed from $1$ to $n$ . Denote the set of all rank- $k$ tensors on $\mbb G_1^n$ as $\mcal T_1^{nk}$ .

Similarly, we can define $k$ -linear maps $\func T{\p{\mbb G_0^n}^k}{\mbb G_0}$ (or rank- $k$ tensors on $\mbb G_0^n$ ), whose components are in $\mbb G_0$ , and denote the set of all of them as $\mcal T_0^{nk}$ . Tensors from $\mcal T_0^{nk}$ and those from $\mcal T_1^{nk}$ can be multiplied and contracted together without any problems. However, the result of these operations may not be in $\mcal T_0^{nk}$ or $\mcal T_1^{nk}$ , but some tensor that takes arguments from both $\mbb G_0^n$ and $\mbb G_1^n$ .

Linear endomorphisms

Here we will need another property as an axiom: for any linear function $\func\lmd{\mbb G_k}{\mbb G_k}$ , $\exists!\vphi\in\mbb G_0:\lmd=\p{\psi\mapsto\vphi\psi}.$ I call this property the second representation property. This is very similar to the first representation property, but it covers linear endomorphisms on $\mbb G_k$ instead of linear functionals on $\mbb G_k$ .

With the second representation property, we can prove that any possible linear endomorphism $J$ on $\mbb G_k^n$ can be written as a unique matrix in $\mbb G_0^{n\times n}$ acting on the components of the argument: $\fc J\psi_i=J_{ij}\psi_j,$ where $J_{ij}\in\mbb G_0$ are called the components of the linear endomorphism $J$ . From now on, we do not need to distinguish between matrices in $\mbb G_0^{n\times n}$ and linear endomorphisms on $\mbb G_k^n$ .

For a matrix $J\in\mbb G_0^{n\times n}$ , we can define its determinant as $\det J\ceq J_{1i_1}\cdots J_{ni_n}\veps^{\b n}_{i_1\cdots i_n}\in\mbb G_0,$ where $\veps^{\b n}\in\mcal T_0^{nn}$ is the Levi-Civita symbol, which is a completely antisymmetric tensor on $\mbb G_0^n$ whose components take values in $\B{-1,0,1}\subset\mbb G_0$ .

Analytic functions

For any $T\in\mcal T_1^{nk}$ , define a degree- $k$ monomial on $\mbb G_1^n$ as $\vfunc{M_T}{\mbb G_1^n}{\mbb G_0}{\psi}{\fc T{\psi,\dots,\psi}},$ which is a degree- $k$ homogeneous function on $\mbb G_1^n$ . Note that different tensors may correspond to the same monomial. Especially, for any $k>n$ , a degree- $k$ monomial must be trivial (send any input to zero). Also, if there is any pair of indices such that $T$ is symmetric in exchanging them, then the monomial $M_T$ must be trivial. Therefore, we only need to consider the those completely antisymmetric tensors when studying monomials. Denote the set of all completely antisymmetric rank- $k$ tensors on $\mbb G_1^n$ as $\mcal T_1^{n\b k}$ , and then the fact that we only need antisymmetric tensors to define monomials can be written as $M_{\mcal T_1^{n\b k}}=M_{\mcal T_1^{nk}}$ .

An analytic function $f$ on $\mbb G_1^n$ is defined as a sum of monomials: $\vfunc f{\mbb G_1^n}{\mbb G_0}\psi{\sum_k \fc{M_{T^{\b k}}}\psi},$ where $T^{\b k}\in\mcal T_1^{n\b k}$ , whose components may be referred to as expansion coefficients. We do not need to worry about the convergence because this is a finite sum ( $k\le n$ ). Denote the set of all analytic functions on $\mbb G_1^n$ as $\mcal A_n$ .

Two properties of analytic functions:

If $f\in\mcal A_n$ , then for any $\dlt\in\mbb G_1^n$ , the translation $\p{\psi\mapsto\fc f{\psi+\dlt}}\in\mcal A_n$ .
If $f\in\mcal A_n$ , then for any $J\in\mbb G_0^{n\times n}$ , the linear transformation in the argument $f\circ J\in\mcal A_n$ .

Integrals

Now we define that a linear function $\int:\mcal A_n\to\mbb G_n$ is called an integral if it satisfies the following property: $\forall f\in\mcal A_n,\dlt\in\mbb G_1^n:\int f=\int\psi\mapsto\fc f{\psi+\dlt},$ which intuitively means that an integral is invariant under translation.

With this definition of an integral, we are now interested in the most general form of an integral.

Because $\int$ is linear, we can find its form on monomials, and then sum them up to get the form on all analytic functions. As a linear function on monomials, it must be of the form (by the second representation property) $\int M_{T^{\b k}}=c^{\b k}_{i_1\cdots i_k}T^{\b k}_{i_1\cdots i_k},$ where $c^{\b k}\in\mcal T_0^{n\b k}$ does not depend on $T^{\b k}$ . Plug this form into the translational invariance of $\int$ , and we have $\begin{align*} c_{i_1\cdots i_k}^{\b k}T^{\b k}_{i_1\cdots i_k} &=\int\psi\mapsto\p{\psi_{i_1}+\dlt_{i_1}}\cdots\p{\psi_{i_k}+\dlt_{i_k}}T^{\b k}_{i_1\cdots i_k}\\ &=\int\psi\mapsto\sum_l\binom kl\psi_{i_1}\cdots\psi_{i_l} \dlt_{i_{l+1}}\cdots\dlt_{i_k}T^{\b k}_{i_1\cdots i_k}\\ &=\sum_l\binom kl c^{\b l}_{i_1\cdots i_l}\dlt_{i_{l+1}}\cdots\dlt_{i_k}T^{\b k}_{i_1\cdots i_k} \end{align*}$ (here the binomial coefficient should be regarded as its image under the natural ring homomorphism from $\bZ$ to $\mbb G_0$ , which must be non-zero because $\mbb G_0$ has characteristic zero). Regarding $T^{\b k}$ as the independent variable, this equation is a homogeneous linear equation $\fc{L^{\b k}}{T^{\b k}}=0$ associated with the linear operator $L$ on $\mcal T_1^{n\b k}$ defined as $L^{\b k}_{i_1\cdots i_k}\ceq c^{\b k}_{i_1\cdots i_k}-\sum_l\binom kl c^{\b l}_{i_1\cdots i_l}\dlt_{i_{l+1}}\cdots\dlt_{i_k}.$ For the solution set of the linear equation to be the whole space $\mcal T_1^{n\b k}$ , we need $L^{\b k}=0$ . Again by the second representation property, we need all the components to vanish (strictly speaking, we need the completely antisymmetric part to vanish, but they are already completely antisymmetric): $\forall k\le n,\dlt\in\mbb G_1^n,i_1,\dots,i_k: c^{\b k}_{i_1\cdots i_k}-\sum_l\binom kl c^{\b l}_{i_1\cdots i_l}\dlt_{i_{l+1}}\cdots\dlt_{i_k}=0.$ The first term cancels with the $l=k$ term in the sum, so this equation does not impose any requirement for $c^{\b k}$ but only impose requirements for $c^{\b l}$ with $l$ . Then, we can induce on $k$ : the equation for $k=0$ does nothing; the equation for $k=1$ requires $c^{\b 0}$ to vanish; the equation for $k=2$ , given that $c^{\b 0}$ vanishes, now requires $c^{\b 1}$ to vanish; and so on. For each $k$ , the equation additionally requires $c^{\b{k-1}}$ to vanish. Finally, when we reach $k=n$ , which is the end of the induction, we require $c^{\b l}$ to vanish for all $l$ , and there is no requirement for $c^{\b n}$ . Therefore, the integral of any monomial is zero except for the degree- $n$ monomial, and thus we only need to consider the $n$ th degree term when finding the integral of an analytic function.

Note that $\mcal T_k^{n\b n}=\mbb G_k\veps^{\b n}$ (in other words, the most general form of a completely antisymmetric rank- $n$ tensor on $\mbb G_k^n$ is a constant in $\mbb G_k$ times the Levi-Civita symbol). Therefore, $c^{\b n}_{i_1\cdots i_n}=c_n\veps^{\b n}_{i_1\cdots i_n}, \quad T^{\b n}_{i_1\cdots i_n}=d\veps^{\b n}_{i_1\cdots i_n},$ where $c_n=\in\mbb G_0$ and $d\in\mbb G_n$ . The definition of an integral does not impose any requirement for $c_n$ , so it can be any element in $\mbb G_0$ . For convenience, define $c_n\ceq1$ for all $n$ , and then we have $\int M_{d\veps^{\b n}}=\veps^{\b n}_{i_1\cdots i_n}d\veps^{\b n}_{i_1\cdots i_n} =n!\,d,$ where $n!$ is the image of $n!$ under the natural ring homomorphism from $\bZ$ to $\mbb G_0$ . The integral of any monomial with its degree different from $n$ is zero, so the integral of any analytic function is just that of its degree- $n$ term: $\int\psi\mapsto\sum_k \fc{M_{T^{\b k}}}\psi=n!\,T^{\b n}_{1\cdots n}.$

Linear change of integrated variable

Now, for a linear endomorphism $J\in\mbb G_0^{n\times n}$ and an analytic function $f\in\mcal A_n$ , consider the integral $\int f\circ J$ . We only needs to consider the degree- $n$ monomial term, which is $\fc{M_{T^{\b n}}}{\fc J\psi}=J_{i_1j_1}\psi_{j_1}\cdots J_{i_nj_n}\psi_{j_n}d\veps^{\b n}_{i_1\cdots i_n},$ where $T^{\b n}=d\veps^{\b n}$ is used. Notice that $\veps_{i_1\cdots i_n}J_{i_1j_1}\cdots J_{i_nj_n}$ itself is a rank- $n$ completely antisymmetric tensor on $\mbb G_0^n$ , so it can also be written as a constant times $\veps^{\b n}$ . By letting $j_1,\dots,j_n$ be $1,\dots,n$ respectively, we see that the constant is just $\det J$ . Therefore, $\fc{M_{T^{\b n}}}{\fc J\psi}=\fc{M_{T^{\b n}}}\psi\det J.$ By the linearty of the integral, we have $\forall f\in\mcal A_n:\int f\circ J=\det J\int f.$

Afterwords

Actually, before I wrote my answer, I already know the exterior algebra. In this article, my definition to Grassmann numbers is more abstract and puts the commuting numbers and anticomuuting numbers in more equal footings. This definition is closer to what I intuitively think Grassmann numbers could be.

There are several potential problems in this article:

Some axioms are given, but I did not prove that they are consistent.
Some claims are made without proof. They may turn out to be wrong.
I did not prove that the usual definition of Grassmann numbers (with exterior algebra) can be formulated as a special case of my definition.
I am not educated in supersymmetry, which is where Grassmann numbers are applied most. I only made my definition comply with the properties of Grassmann numbers that I have learned for doing the path integral of fermionic fields.

The notational convenience of imaginary time in the derivation of the metric in Poincaré coordinates

2024-09-10T14:19:33-07:00

Introduction

There are two major conventions for the metric signature: $\p{+,-,-,-}$ (west coast) and $\p{-,+,+,+}$ (east coast). However, the first convention that I have met in my journey of learning physics is neither of them: the imaginary time. Shortly after, I started using the west coast convention, so I never really used the imaginary time convention seriously. I personally dislike the imaginary time convention, and so do most people in the physics community and history, which is why most modern textbooks use either the west coast or the east coast convention. One of my past physics teachers deemed the imaginary time convention to be a heresy (异端邪说).

However, in some cases, the imaginary time convention can be convenient due to the use of multi-index notation (which is more concise and feature-rich than the Einstein notation). Here is one of such cases: the derivation of the metric in Poincaré coordinates for the anti-de Sitter space.

The $d$ -dimensional anti-de Sitter space $\mrm{AdS}_d$ of scale $l$ is defined as the hyperboloid $-l^2=-T_1^2-T_2^2+\sum_{i=1}^{d-1}\p{X^i}^2$ in $M^{d-1,2}$ (the analogue of the Minkowski space, but with signature $d-1,2$ ). The Poincaré coordinates are defined as $\begin{align*} z&\ceq\fr{l^2}{T_1+X^{d-1}},\\ t&\ceq\fr{lT_2}{T_1+X^{d-1}},\\ x^i&\ceq\fr{lX^i}{T_1+X^{d-1}},&i=1,\ldots,d-2. \end{align*}$

The derivation

Define $T\ceq T_1$ and $X\ceq X^{d-1}$ just for fun. Then, define two $\p{d-1}$ -dimensional multi-indices $Y\ceq\p{\i T_2,X^1,\ldots,X^{d-2}},\quad y\ceq\p{\i t,x^1,\ldots,x^{d-2}}.$

The hyperboloid constraint and the metric (east coast convention) are then $X^2-T^2+Y^2=-l^2,\quad \d s^2=\d X^2-\d T^2+\d Y^2,$ which are equivalently $\p{X+T}\p{X-T}=-l^2-Y^2,\quad\d s^2=\p{\d X+\d T}\p{\d X-\d T}+\d Y^2.$ The definition of the Poincaré coordinates can be written as $z=\fr{l^2}{X+T},\quad y=\fr zlY,$ or equivalently $X+T=\fr{l^2}z,\quad Y=\fr{ly}z.$

Substitute Equation 2 into the first equation in Equation 1. Then, we have $X-T=-z-\fr{y^2}z.$ Differentiate Equation 2 and 3, and we have $\d X+\d T=-\fr{l^2}{z^2}\,\d z,\quad \d X-\d T=-\d z+\fr{y^2}{z^2}\,\d z-\fr{2y}z\,\d y,\quad \d Y=l\p{\fr{\d y}z-\fr y{z^2}\,\d z}.$ Substitute this into the second equation in Equation 1, and we have $\d s^2=-\fr{l^2}{z^2}\d z\p{-\d z+\fr{y^2}{z^2}\,\d z-\fr{2y}z\,\d y}+l^2\p{\fr{\d y}z-\fr y{z^2}\,\d z}^2 =\fr{l^2}{z^2}\p{\d y^2+\d z^2}.$

Finally, substitute back the definition of $y$ , and we have the result $\d s^2=\fr{l^2}{z^2}\p{-\d t^2+\sum_{i=1}^{d-2}\p{\d x^i}^2+\d z^2}.$

The smallest wave packet in the lowest Landau level

2024-07-01T01:01:46-07:00

Introduction

Exercise 12.5 from Modern Condensed Matter Physics (Girvin and Yang, 2019) asks to construct a Gaussian wave packet in the lowest Landau level in the Landau gauge, such that it is localized as closely as possible around some point $\mbf R\ceq\p{R_x,R_y}$ .

Actually, we can prove that the smallest wave packet is a Gaussian wave packet. Here is the derivation.

The problem

First, for readers who are not familiar with the Landau levels, here is a brief introduction. For an electron confined in the $xy$ plane under a magnetic field $\mbf B=B\bhat z$ , its Hamiltonian is $H=\fr1{2m_e}\p{p_x^2+\p{p_y-\fr{eB}cx}^2}$ under the Landau gauge $\mbf A=Bx\bhat y$ . Its eigenstates in the position representation are $\fc{\psi_{nk}}{x,y}=\e^{\i ky}\fc{H_n}{\fr xl-kl} \e^{-\p{x-kl^2}^2/2l^2}$ labeled by $n\in\bN$ and $k\in\bR$ , where $H_n$ is the Hermite polynomial of degree $n$ and $l\ceq\sqrt{\hbar c/eB}$ . States with the same $n$ are degenerate in energy ( $E_n=\p{n+1/2}\hbar eB/m_ec$ ) and make up the $n$ th Landau level. The Landau level with $n=0$ is called the lowest Landau level.

The problem, now, is this optimization problem: $\begin{align*} \min_{a_k}\quad&\mel{\Psi}{x^2+y^2}{\Psi}\\ \st\quad&\braket{\Psi}{\Psi}=1,\\ &\mel{\Psi}{x}{\Psi}=R_x,\\ &\mel{\Psi}{y}{\Psi}=R_y \end{align*}$ (optimizing $\a{x^2+y^2}$ is equivalent to optimizing $\sgm_x^2+\sgm_y^2$ because $\a x$ and $\a y$ are both fixed), where $\ket\Psi$ is defined as the state whose position representation is $\fc\Psi{x,y}=\int\d k\,a_k\e^{\i ky}\e^{-\p{x-kl^2}^2/2l^2}.$

The solution

Consider the moment-generating function $\begin{align*} \fc M{u,v}&\ceq\mel{\Psi}{\e^{ux+vy}}{\Psi}\\ &=\iint\d x\d y\,\e^{ux+vy} \int\d k\,a_k^*\e^{-\i ky}\e^{-\fr1{2l^2}\p{x-kl^2}^2} \int\d k'\,a_{k'}\e^{\i k'y}\e^{-\fr1{2l^2}\p{x-k'l^2}^2}\\ &=\iint\d k\d k'\,a_k^*a_{k'}\int\d x\,\e^{ ux-\fr1{2l^2}\p{x-kl^2}^2-\fr1{2l^2}\p{x-k'l^2}^2 }\underbrace{\int\d y\,\fc\exp{vy+\i\p{k'-k}y}}_{2\pi\fc\dlt{k'-k-\i v}}\\ &=2\pi\int\d k\,a_k^*a_{k+\i v}\underbrace{\int\d x\,\fc\exp{ ux-\fr1{2l^2}\p{x-kl^2}^2-\fr1{2l^2}\p{x-\p{k+\i v}l^2}^2 }}_{l\sqrt\pi\fc\exp{\fr14l^2\p{4ku+u^2+2\i uv+v^2}}}\\ &=2\pi^{3/2}l\fc\exp{\fr14l^2\p{u^2+2\i uv+v^2}} \int\d k\,a_k^*a_{k+\i v}\e^{kl^2u}\\ &=2\pi^{3/2}l\int\d k\,a_k^*\left( a_k+kl^2a_ku+\i a_k'v+\fr14l^2\p{1+2k^2l^2}a_ku^2 \right.\\&\qquad\qquad\qquad\qquad\left. {}+\fr14\p{l^2a_k-2a_k''}v^2 +\fr\i2l^2\p{a_k+2ka_k'}uv+\cdots \right), \end{align*}$ where $a_k'\ceq\d a_k/\d k$ and $a_k''\ceq\d^2a_k/\d k^2$ . On the other hand, we have $\fc M{u,v}=\mel{\Psi}{1+ux+uy+\fr12u^2x^2+\fr12v^2y^2+uvxy+\cdots}{\Psi}.$ Compare the expansion coefficients, and we have $\begin{align*} \braket{\Psi}{\Psi}&=2\pi^{3/2}l\int\d k\,a_k^*a_k,\\ \mel{\Psi}{x}{\Psi}&=2\pi^{3/2}l^3\int\d k\,a_k^*ka_k,\\ \mel{\Psi}{y}{\Psi}&=2\i\pi^{3/2}l\int\d k\,a_k^*a_k',\\ \mel{\Psi}{x^2}{\Psi}&=\fr12\pi^{3/2}l^3\int\d k\,a_k^*\p{1+2k^2l^2}a_k,\\ \mel{\Psi}{y^2}{\Psi}&=\fr12\pi^{3/2}l\int\d k\,a_k^*\p{l^2-2a_k''}a_k. \end{align*}$

Define $\fc\vphi k\ceq a_k\sqrt{2\pi^{3/2}l}$ . Define fictitious position and momentum operators acting on $\vphi$ as $\Xi\vphi:k\mapsto k\fc\vphi k,\quad \Pi\vphi:k\mapsto-\i\fc{\vphi'}k.$ Using the constraints of the original optimization problem and abusing the bra–ket notation on $\vphi$ , we have $\braket{\vphi}{\vphi}=1,\quad\mel\vphi\Xi\vphi=\fr{R_x}{l^2},\quad \mel\vphi\Pi\vphi=-R_y.$ The objective function then becomes $\mel{\Psi}{x^2+y^2}{\Psi}=\fr12l^2+\mel{\vphi}{\mcal H}{\vphi},$ where $\mcal H\ceq \Pi^2/2+l^4\Xi^2/2$ is a fictitious Hamiltonian, which is the Hamiltonian of a harmonic oscillator with mass $1$ and angular frequency $\omg\ceq l^2$ .

The optimization problem can now be re-stated in terms of $\ket\vphi$ as $\begin{align*} \min_{\ket\vphi}\quad&\mel\vphi{\mcal H}{\vphi}\\ \st\quad&\braket\vphi\vphi=1,\quad\mel\vphi\Xi\vphi=R_x/\omg,\quad\mel\vphi\Pi\vphi=-R_y. \end{align*}$ Physically, this means that we want to find the state of a harmonic oscillator with the given expectation values of position and momentum and the lowest energy. To find it, we can use Hisenberg’s uncertainty principle: $\begin{align*} \a{\mcal H}&=\fr12\a{\Pi^2}+\fr12\omg^2\a{\Xi^2}\\ &=\fr12\p{\a\Pi^2+\sgm_\Pi^2}+\fr12\omg^2\p{\a{\Xi^2}+\sgm_\Xi^2}\\ &=\fr12\sgm_\Pi^2+\fr12\omg^2\sgm_\Xi^2+\fr12R_y^2+\fr12 R_x^2\\ &\ge\omg\sgm_\Pi\sgm_\Xi+\fr12R^2 \ge\fr12\omg+\fr12R^2. \end{align*}$ The equality in the first “ $\ge$ ” is achieved when $\sgm_\Pi=\omg\sgm_\Xi$ , and that in the second “ $\ge$ ” is achieved when the uncertainty principle is saturated. As we know from quantum mechanics, the coherent state of a harmonic oscillator satisfies both conditions. The wavefunction of this state is $\fc\vphi k=\p{\fr\omg\pi}^{1/4} \fc\exp{-\fr12\omg\p{k-\fr{R_x}{\omg}}^2-\i R_yk}.$ Express the final result in terms of $a_k$ : $a_k=\fr1{\sqrt2\pi}\e^{-\i kR_y}\e^{-\fr1{2l^2}\p{R_x-kl^2}^2}.$ We may work out the integral to get the wave function of the wave packet: $\fc{\Psi}{x,y}=\fr1{\sqrt{2\pi}l}\fc\exp{-\fr1{4l^2}\p{ \p{x-R_x}^2+\p{y-R_y}^2-2\i\p{x+R_x}\p{y-R_y} }}.$ This is a Gaussian wave packet centered at $\mbf R$ with covariance matrix $\opc{Diag}{l^2,l^2}$ .

Further problems

The optimal wave packet is indeed Gaussian. This makes me curious about whether this is a coincidence or not.

Another thing worth noting is that this result is actually the Dirac delta wave function peaking at $\mbf R$ projected into the lowest Landau level. This was actually my first idea to solve the problem. I was like: well, isn’t the Dirac delta the smallest possible wave packet by all means? If the basis is complete, I can surely combine them into a Dirac delta, and it would be very easy to work out $a_k$ in this case. Then, I was like: nah, merely a single Landau level is not complete, so I cannot do that anyway. I then did not even bother to proceed with this approach and went on to trying other methods. It turns out that this approach is actually correct—at least it gives the same result as the correct approach.

Regularizing the partition function of a hydrogen atom

2024-06-30T21:18:12-07:00

The partition function of a hydrogen atom diverges (only considering bound states). However, we can regularize it to get finite answers. Different regularizations give the same result. They largely agree with the physical arguments for the case of the hydrogen atom at room or cold temperature, but this should be considered a mere coincidence. The results from regularized partition functions cannot generally be trusted.

Letting people know when you are asleep

2024-02-21T02:26:45-08:00

While I have been trying to respond whenever people reach out to me, it is impossible to be available 24/7 due to the simple fact that a human has to sleep to be alive. While this is annoying, it is also a fact that I cannot change.

Therefore, a natural idea that comes to my mind is to simply let people know when I am asleep so that they do not expect me to respond immediately.

Discord and GitHub have been among my most used platforms for some time, and they both have a feature to let users set a custom status (with a custom text and an emoji). This opens up a possibility of using a program to automatically set the status to indicate that I am asleep.

For Discord, this is as simple as invoking a REST API (Notice that this is against Discord’s ToS):

          
            # Set sleeping status

            curl -X PATCH \

            	-H "Content-Type: application/json" \

            	-H "Authorization: YoUr.DiScOrD.ToKeN" \

            	-d '{"settings":"WhwKBQoDZG5kEhMKC1NsZWVwaW5nLi4uGgTwn5i0"}' \

            	https://discord.com/api/v9/users/@me/settings-proto/1

            

            

            # Clear sleeping status

            curl -X PATCH \

            	-H "Content-Type: application/json" \

            	-H "Authorization: YoUr.DiScOrD.ToKeN" \

            	-d '{"settings":"WgoKCAoGb25saW5l"}' \

            	https://discord.com/api/v9/users/@me/settings-proto/1

If you wonder what those base64-encoded strings mean, they are actually the binary contents of protobuf-encoded messages. See this .proto file for the definition of the message structure.

API v8

Using nmcli to connect to eduroam in UCSB

2024-01-08T01:03:36-08:00

Save this certificate to some file, say /YOUR/PATH/TO/ca.pem:

Then, run

          
            nmcli con mod eduroam 802-1x.eap peap

            nmcli con mod eduroam 802-11-wireless-security.key-mgmt wpa-eap

            nmcli con mod eduroam 802-11-wireless-security.proto rsn

            nmcli con mod eduroam 802-11-wireless-security.pairwise ccmp

            nmcli con mod eduroam 802-11-wireless-security.group ccmp,tkip

            nmcli con mod eduroam 802-1x.ca-cert /YOUR/PATH/TO/ca.pem

            nmcli con mod eduroam 802-1x.phase2-autheap mschapv2

            nmcli con mod eduroam 802-1x.anonymous-identity anonymous@ucsb.edu

            nmcli con mod eduroam 802-1x.identity YOUR_EDU_EMAIL_ADDRESS

            nmcli con mod eduroam 802-1x.password YOUR_PASSWORD

Finally, you can connect to eduroam now!

This may also apply to eduroam in other campuses, but I haven’t tested it yet.

The duality between two plane trajectories related by a conformal map

2023-12-22T11:19:04-08:00

I always feel amazed about how 2D physics can often be fascinating due to theorems in complex analysis. This article is about one among such cases.

Theorem. The conformal map $\fc wz$ transforms the trajectory with energy $-B$ in potential $\fc Uz\ceq A\v{\d w/\d z}^2$ into the trajectory with energy $-A$ in potential $\fc Vw\ceq B\v{\d z/\d w}^2$ .

This result is pretty amazing in that it reveals a quite implicit duality between the two potentials, and it looks very symmetric as written.

This theorem, as I know of, was first introduced in the appendix of V. I. Arnold’s book Huygens and Barrow, Newton and Hooke. Part of this article is already covered in the relevant part of the book.

Power-law central-force potentials

Before I show the proof of it, let me first introduce it by a much more well-known example.

As we all know, Bertrand’s theorem states that the only two types of central-force potentials where all bound orbits are closed are $U\propto r^{-1}$ (the Kepler problem) and $U\propto r^2$ (the harmonic oscillator). How the two potentials are special among all sorts of different central-force potentials makes people wonder if there is any connection between them. Fortunately, there is one, and it is obvious once we notice that the complex squaring transforms any center-at-origin ellipses into focus-at-origin ellipses. Inspired by this, it is easy to see that trajectories in the Kepler problem can be transformed into trajectories of harmonic oscillators under complex squaring.

You may ask, how can we notice complex squaring does the said transformation on ellipses? The observation is noticing the simple algebra $\p{z+\fr1z}^2=z^2+\fr1{z^2}+2,$ which means that the Joukowski transform $z\mapsto z+1/z$ of a unit circle simply translates under complex squaring. We can then try to generalize this to circles of other radii, whose Joukowski transformations are just ellipses! (If you remember, this is the second time Joukowski transformation appears in my blog. The first time was here.)

Then, are the Kepler problem and the harmonic oscillator the only two central-force potentials whose trajectories can be transformed into each other by a complex function? The answer is no. In fact, for any trajectory in almost any power-law central-force potential, we can take some power of it to get a trajectory in another power-law central-force potential.

This result can be summarized as follows. Taking the $\p{\alp/2+1}$ th power of a trajectory with energy $E$ in the potential $U=ar^\alp$ ( $\alp\ne-2$ ) gives a trajectory with energy $F$ in the potential $V=br^\beta$ , where $\p{\alp+2}\p{\beta+2}=4,\quad b=-\fr14\p{\alp+2}^2E,\quad F=-\fr14\p{\alp+2}^2a.$ To prove this, we just need to reparameterize the transformed trajectory in a new time coordinate $\tau$ defined as $\d\tau=\v z^\alp\,\d t$ , where $z$ is the complex position of the original trajectory. Then, by some calculation and utilizing the energy conservation, we can show that the parameter equation in terms of the new time coordinate satisfy the equation of motion we expect. I will not show the details here because they would be redundant once I prove the more general case using the same methods.

Corollaries and applications

There is an interesting special case, which is $\alp=-2$ . There is no potential that is dual to $U\propto r^{-2}$ . Another interesting case is $\alp=-4$ , which is dual to itself ( $\beta=-4$ ). It kind of means that the coefficient in the potential is “interchangeable” with the energy, and the trajectories can be derived from each other by taking the complex reciprocal.

We can get some interesting results with $a=0$ , which is just the case of a free particle, whose trajectories are all straight lines. Since in this case we necessary have $F=0$ , we can say that the zero-energy trajectory in any power-law potential is related to a straight line by a power. From this result, we can derive some interesting corollaries. For example, the zero-energy trajectory in the Kepler problem is a parabola (square of a straight line), which is well-known. The zero-energy trajectory in $U\propto-r^{-4}$ is a circle passing through the origin (reciprocal of a straight line), which is a pretty interesting not-so-well-known result.

Another interesting result is that, the deflection angle of an incident zero-energy particle scattered by the potential $U\propto-r^\alp$ is $\tht$ under paraxial limit, if $\alp=\fr{2\vphi}{\pi-\vphi},\quad\vphi=\pm\tht-2k\pi,\quad k\in\bN.$ This result can be easily derived by using the conformal transform of the real line (actually, a straight line that approaches the real line). The crucial part here is that $k$ cannot take negative integers because we need $\alp>-2$ . The reason is that, when $\alp\le-2$ , paraxial zero-energy particles are bound to sink into the origin, and thus no scattering actually happens. This small pitfall indicates that the trajectory in the dual potential is not a two-side infinite straight line, either, in that limit, in contrast to being seemingly a free particle.

Some straightforward proofs

Let’s go back to the theorem I stated at the beginning of this article.

Proof. Consider a new time coordinate $\tau$ defined as $\d\tau=\v{\d w/\d z}^2\,\d t$ . Then, the motion of $w$ satisfies $\begin{align*} m\fr{\d^2w}{\d\tau^2} &=m\fr{\d t}{\d\tau}\fr{\d}{\d t}\p{\fr{\d t}{\d\tau}\fr{\d w}{\d t}}\\ &=m\v{\fr{\d z}{\d w}}^2\fr{\d}{\d t}\p{\v{\fr{\d z}{\d w}}^2\fr{\d w}{\d z}\fr{\d z}{\d t}}\\ &=m\fr{\d z}{\d w}\p{\fr{\d z}{\d w}}^*\p{\p{\fr{\d^2z}{\d w^2}\fr{\d w}{\d z}\fr{\d z}{\d t}}^*\fr{\d z}{\d t} +\p{\fr{\d z}{\d w}}^*\fr{\d^2 z}{\d t^2}}. \end{align*}$ Here we need to substitute $\d^2 z/\d t^2$ by the equation of motion for $z$ . By computing the real and imaginary parts separately, we can derive that for any holomorphic function $f$ , the gradient of $\v f^2$ expressed as a complex number is $\nabla\v f^2=2\p{\d f/\d z}^*f$ . Therefore, the equation of motion for $z$ is $m\fr{\d^2z}{\d t^2}=-2A\fr{\d w}{\d z}\p{\fr{\d^2w}{\d z^2}}^*.$ According to series reversion, we have $\d^2 w/\d z^2=-\p{\d w/\d z}^3\d^2 z/\d w^2$ . Therefore, the equation of motion for $z$ can also be written as $m\fr{\d^2z}{\d t^2}=2A\v{\fr{\d w}{\d z}}^2\p{\fr{\d w}{\d z}}^{*2}\p{\fr{\d^2 z}{\d w^2}}^*.$ Substitute this, and we have $m\fr{\d^2w}{\d\tau^2}=\fr{\d z}{\d w}\p{\fr{\d^2z}{\d w^2}}^* \p{m\v{\fr{\d z}{\d t}}^2+2A\v{\fr{\d w}{\d z}}^2}.$ Substitute the energy conservation of the motion of $z$ : $\fr12m\v{\fr{\d z}{\d t}}^2+A\v{\fr{\d w}{\d z}}^2=-B,$ and we have $m\fr{\d^2w}{\d\tau^2}=-2B\fr{\d z}{\d w}\p{\fr{\d^2z}{\d w^2}}^*,$ which is the equation of motion for $w$ that we expect.

To get the energy of the motion of $w$ , we calculate $\begin{align*} \fr12m\v{\fr{\d w}{\d\tau}}^2+B\v{\fr{\d z}{\d w}}^2 &=\fr12m\v{\fr{\d w}{\d z}\fr{\d z}{\d t}\fr{\d t}{\d\tau}}^2+B\v{\fr{\d z}{\d w}}^2\\ &=\v{\fr{\d w}{\d z}}^2\p{-B-A\v{\fr{\d w}{\d z}}^2}\v{\fr{\d z}{\d w}}^4+B\v{\fr{\d z}{\d w}}^2\\ &=-A, \end{align*}$ which is the energy conservation of the motion of $w$ in the potential $V$ that we expect. $\square$

Noticing that we are only interested in the trajectory, we can just use Maupertuis’ principle to get a simpler proof.

Proof. $\mcal S_0=\int\v{\d z}\sqrt{2m\p{-B-A\v{\fr{\d w}{\d z}}^2}}=\int\v{\d w}\sqrt{2m\p{-A-B\v{\fr{\d z}{\d w}}^2}}.$ The abbreviated action is then exactly the same for the motion of $z$ and the motion of $w$ . Therefore, by Maupertuis’ principle, for any physical trajectory of $z$ , the trajectory of $w$ is also physical. $\square$

Details worth noting

Invertibility of the conformal map

There are two different definitions of a conformal transformation in two dimensions. One is that a function defined on an open subset of $\bC$ is conformal iff it is holomorphic and its derivative is nowhere zero. The other is that a function is conformal iff it is biholomorphic (is bijective and has a holomorphic inverse).

You may think here I have adopted the second definition because when I say $\fc Vw\ceq B\v{\d z/\d w}^2$ , I am implicitly assuming that I can take the inverse of $\fc wz$ to get the function $\fc zw$ and then take the derivative of it. However, if that is the case, an immediate problem is that then the duality between the Kepler problem and the harmonic oscillator, from which I introduced the more general result in the first place, would not be actually covered by the “more general” result. This is because $z\mapsto z^2$ is not biholomorphic (because it is not injective).

Then, why did this never become a problem when we were studying the duality between the Kepler problem and the harmonic oscillator? All we have talked about is how we can derive a trajectory in the Kepler problem by squaring the trajectory of a harmonic oscillator, but we have not discussed about how we can reverse this process, as an essential part of the duality. You may think the reverse of the process would be totally natural given how symmetric our theorem is regarding the two potentials. However, the reverse is not actually well-defined since the inverse of squaring, i.e., taking the square root, is not a single-valued function. Nevertheless, it is still well-defined in some sense: starting with whichever branch we like, tracing one point on the trajectory of the Kepler problem, and moving it along this trajectory for two cycles, we will end up with a trajectory of the harmonic oscillator if we take the square root of the position and ensure we always choose the branch so that the mapping is continuously done.

What about other power-law central potentials? In those cases, we have non-closed trajectories, so we cannot just move along the trajectory for two cycles. For example, if we take $w=z^3$ , then the potential would be $U=9A\v z^4$ . For any non-closed trajectory, we can uniquely map it to a trajectory of the potential $V=B\v w^{-4/3}/9$ . However, we cannot uniquely do the reverse mapping. There would be three different trajectories in the potential $U$ that can be mapped to the same trajectory in $V$ , and we can in turn map the trajectory in $V$ to any of the three trajectories in $U$ depending on which branch we choose.

Therefore, to generalize this for more general potentials, we can use similar arguments. Because $z\mapsto w$ has non-zero derivative everywhere in our considered region, it is everywhere locally invertible by the Lagrange inversion theorem. We can then bijectively map the trajectories in the two dual potentials locally for every small (and finite) segment and then patch them together to get the global correspondence between the two trajectories. This mapping may not be well-defined globally, but the trajectories can still be considered dual to each other. If the potential also becomes multi-valued due to the mapping $w\mapsto z$ being multi-valued, then we should imagine this situation like this: at some point, the potential may be different when the particle visit here for the second time. This case does not happen if we only look at power-law potentials, but it does happen for more general cases.

What makes this sense of duality weaker is that one trajectory can be dual to multiple different trajectories. A case worth noting is that sometimes one trajectory can be mapped to infinitely many different trajectories. This happens when the trajectory runs around a logarithmic branch point. However, we can gain the sense of duality back if we can also consider the case where $z\mapsto w$ is multi-valued. The notion of conformal transformation is now too limited to cover this case, a better notion is a global analytic function, which generalizes the notion of analytic function to allow for multiple branches.

Requirements for the potential

Not any potential can be expressed as $A\v{\d w/\d z}^2$ . How can we determine whether a potential can be expressed in this form?

Theorem. A continuous potential $U$ can be expressed in the form of $A\v{\d w/\d z}^2$ (where $\fc wz$ is a conformal transformation) iff one of the following conditions is met:

$U$ is zero everywhere, or
$\ln\v U$ is a harmonic function on the domain of $U$ .

Proof. First, prove the necessity.

An obvious requirement is that the potential must be positive everywhere or negative everywhere (or zero everywhere, but that is trivial). The sign is determined by the sign of $A$ . Therefore, without loss of generality, we can assume $A=1$ because we can always absorb a factor of $\sqrt{\v A}$ into $w$ and adjust the overall sign of $U$ accordingly.

We can decompose $\p{\d w/\d z}^2$ in the polar form $\p{\d w/\d z}^2=\v{\d w/\d z}^2\e^{\i\vphi}=U\e^{\i\vphi},$ where $\vphi$ is a real function of $z$ . Applying the Cauchy–Riemann equations to $\p{\d w/\d z}^2$ gives $\i\partial_x\p{\fr{\d w}{\d z}}^2=\partial_y\p{\fr{\d w}{\d z}}^2 \implies\i\p{\e^{\i\vphi}\partial_xU+\i U\e^{\i\vphi}\partial_x\vphi} =\e^{\i\vphi}\partial_yU+\i U\e^{\i\vphi}\partial_y\vphi.$ Equate the real and imaginary parts, and we have $\begin{cases}U\partial_x\vphi=-\partial_yU,\\U\partial_y\vphi=\partial_xU.\end{cases}$ Use the symmetry of second derivatives on $\vphi$ , and we have $\partial_x\partial_y\vphi-\partial_y\partial_x\vphi=0 \implies\partial_x\fr{\partial_xU}U+\partial_y\fr{\partial_yU}U=0.$ In the language of vector analysis, this is just $\nabla^2\ln U=0$ .

Considering the case where $U$ is negative everywhere, we have that $\ln\v U$ is a harmonic function.

Then, prove the sufficiency.

The case where $U$ is zero everywhere is trivial. Otherwise, because $\ln\v U$ is defined everywhere on the domain of $U$ , we must have $U$ is non-zero everywhere. Because $U$ is continuous, we have $U$ is either positive everywhere or negative everywhere.

Without loss of generality, assume $U$ is positive everywhere. Let $\vphi$ be the harmonic conjugate of $\ln U$ . Then, $\ln U+\i\vphi$ is a holomorphic function. We can then define $\fr{\d w}{\d z}=\sqrt U\e^{\i\vphi/2},$ which is also a holomorphic function. $\square$

From now on, we will call this requirement on $U$ as being log-harmonic for obvious resons.

We should notice that whether $U$ is log-harmonic does not respect that any potential can have an additive constant and still be essentially the same potential. An immediate example is that a function that is positive everywhere may be negative somewhere if we add a constant to it. We may then want to ask whether $U$ can be log-harmonic if we allow it to be added an additive constant. It is easy to do this: we can just apply the same test to $U+C$ , and see if there is some $C$ that makes it work. To illustrate, solve the equation $\nabla^2\ln\v{U+C}=0$ for $C$ , and then see whether it is a constant over the whole complex plane.

A property of log-harmonic functions is that the product of two log-harmonic functions is also log-harmonic.

Trajectories that run out of the domain

Trajectories often run out of the domain of the potential. For example, in the discussions about power-law potentials before, though not emphasized, the origin is outside the domain of the potential because it is either a pole or a zero of $\d w/\d z$ (except the trivial case where $w$ is simply proportional to $z$ ). Another example that is rather overlooked is that unbound trajectories go to infinity while infinity is often not in the domain of the potential, either.

What need to take care of is that, when the trajectories run out of the domain, the trajectory is cut off there, and the rest of the trajectory is never considered (even if it may come back to the domain again later). Take the Kepler problem ane the harmonic oscillator as an example. If a trajectory of the harmonic oscillator passes through the origin, which is outside the domain, the trajectory degrades from a closed ellipse to a segment. If you take the square of a segment passing through the origin, you will get a broken line folded into itself, which looks like a particle in the Coulomb field may sink into the origin and then goes back along the exact path it came along. This would confusing if it were physical.

Arbitrariness in the construction of the conformal map

The construction of $z\mapsto w$ is not unique for a given $U$ .

Rotation and translation

First, we can observe that the substitution $w\to w'\ceq w\e^{\i\tht}+w_0$ does not change $\v{\d w/\d z}$ (nor thus $U$ ). The real number $\tht$ is a function of $z$ in principle, but if we want $w$ to be holomorphic on a connected region, then $\tht$ must be a constant (except the trivial case where $w=0$ ).

The dual trajectory does change, though, but the dual potential $V$ is also changed, too. Because $\v{\d z/\d w'}=\v{\d z/\d w}$ , we have $\fc{V'}{w'}=\fc Vw=\fc V{\p{w'-w_0}\e^{-\i\tht}}.$ Therefore, the dual trajectory and the dual potential are also rotated and translated by the same amount.

Scaling

Before introducing scaling, I need to add some words about the unit systems. In the above discussions, I have never mentioned what units or dimensions do $z,w,A,B$ have. The natural way of thinking is to let $z,w$ have the dimension of length and let $A,B$ have the dimension of energy. However, this is not the only way of thinking. We will later see that the $z$ -space and the $w$ -space can have totally different dimensions.

The dimensions or units of variables in a physical formula can be totally different from what they were originally intended to be. For example, when a particle is rotating, its motion needs to satisfy $\dot{\mbf r}=\bs\omg\times\mbf r$ , where $\bs\omg$ is the angular velocity. However, although $\mbf r$ has the dimension of length when it is first introduced, this formula is satisfied by any rotating vectors. A typical example is that the angular momentum changes according to this formula when a rigid body is doing precession. For another example, in classical mechanics and general relativity, the coordinates used to describe the motion of a particle are often not in the dimension of length, but have all sorts of dimensions. For another example that is less well-known, just because the Berry connection has the same gauge transformation as the electromagnetic potential, a bunch of formulas that are useful in electromagnetic theory can be applied to the Berry connection to define all sorts of interesting quantities with rich physical implications. The units of Berry connection are, however, very unimportant because they are literally arbitrary.

Therefore, what does a unit system actually bring us in a physical theory? The only thing it brings us is the ability to conveniently see in what aspects our theories are invariant under the scaling of some quantities. For example, in classical mechanics, we can scale the mass and the potential of any system with the same factor, and then the system will still behave the same in terms of the time-dependent length-based motion. This is because the part of the dimension of energy that is independent of length and time is to the first power of the dimension of mass. For similar reasons, we can derive another two scaling invariances, one about length-scaling and the other about time-scaling. In quantum mechanics, we suffer one less such scaling invariances because of the existence of $\hbar$ ; in special relativity, we suffer one less such scaling invariances because of the existence of $c$ ; and in general relativity, we suffer two less such scaling invariances because of the existence of $G$ and $c$ . This is the incentive of introducing natural units in physics: they give us a more clear image of how our theory can be scaled leaving the physics invariant.

As for dimensional analysis, the essence of it is to find the required form of theory so that it satisfies some sort of scaling invariance. For example, we can use dimensional analysis to derive that the frequency of a harmonic oscillator is proportional to the square root of the ratio of the stiffness to the mass. We know this must be correct because this is the only theory that is consistent with the three scaling invariances that must be satisfied by any theories under the framework of classical mechanics.

Now, consider the scaling in $w$ , i.e., $w\to w'\ceq w/C$ for some non-zero real number $C$ . The potential $U$ can be kept invariant by scaling $A\to A'\ceq C^2A$ . However, we cannot change $B$ if we want to leave the trajectory of $z$ unchanged because it is determined by the energy of the trajectory of $z$ . Therefore, the dual potential $V$ would be scaled to $\fc{V'}{w'}=C^2\fc Vw=C^2\fc V{Cw'}.$ This means that physics is unchanged if length is scaled by $C$ and energy and potential are both scaled by $C^2$ . This corresponds to one of the three scaling invariances in classical mechanics that we talked about before.

What is interesting here is that the length-scaling in the $w$ -space is done independently of that in the $z$ -space. This means that the length dimension in the two systems are independent of each other, so the two systems can have totally different unit systems.

Canonical transformation of time

The transformation from $z$ to $w$ seems like a coordinate transformation, which is covered by canonical transformations. However, here we have an additional requirement about the form of the Hamiltonian: $H=\fr{p_z^2}{2m}+\fc Uz,\quad K=\fr{p_w^2}{2m}+\fc Vw,$ where $K$ is the transformed Hamiltonian (or called the Kamiltonian in the jargon of canonical transformations). This is not generally true because the transformation in the generalized momentum is restrictively determined when the transformation in the generalized coordinate is already given. From the proof of the original theorem, we can see that a transformation in time is a must, which is given by $\d\tau=\v{\d w/\d z}^2\,\d t$ .

The problem is that the canonical transformations covered in most textbooks usually do not allow for a transformation in time, but only for a transformation in the canonical variables. Therefore, I need to first address the problem of integrating the transformation of time into the theory of canonical transformations. I will not do this for the most general case, but only for the case general enough for the purpose of explaining the case interesting this article.

Change in the time variable in the stationary-action principle

Before diving into the general canonical transformation, let’s first consider the case where the transformation is only in the time variable.

Consider a system with the Lagrangian $\fc L{q,\dot q}$ (not explicitly dependent on time). Then, the action can be expressed as $S=\int_{t_1}^{t_2}\fc L{q,\dot q}\d t.$ The same integral can be expressed in terms of a new time variable $\tau$ as $S=\int_{\tau_1}^{\tau_2}\fc L{q,\mathring q\dot\tau}\fr{\d\tau}{\dot\tau},$ where $\mathring q\ceq\d q/\d\tau$ is the generalized velocity in the new time variable. The transformed Lagrangian, or what I want to call the Magrangian ¹, is then $\fc M{q,\mathring q}\ceq\fc L{q,\mathring q\dot\tau}\fr1{\dot\tau}.$ For the case that we are concerning, $\dot\tau$ is a positive real function of $q$ but does not (explicitly) depend on $t$ . The limits $\tau_1,\tau_2$ satisfy the condition $\tau_2-\tau_1=\int_{t_1}^{t_2}\fc{\dot\tau}q\,\d t.$ This relation is crucial. When finding the variation $\dlt S$ , we are fixing $t_1,t_2$ . However, we cannot fix both $\tau_1,\tau_2$ because their difference is dependent on the path $\fc qt$ . What we can do is to fix $\tau_1$ and to let $\tau_2$ have a variation given by $\dlt\tau_2=\int_{t_1}^{t_2}\fc{\dot\tau'}q\dlt q\,\d t =\int_{\tau_1}^{\tau_2}\fr{\fc{\dot\tau'}q}{\fc{\dot\tau}q}\dlt q\,\d\tau,$ where $\dot\tau'$ is the derivative (or gradient, in higher dimensions) of $\dot\tau$ as a function of $q$ . As can be seen, only if $\dot\tau$ is a constant (i.e., $\tau$ is simply an affine transform of $t$ ) does $\dlt\tau_2$ vanish for any $\dlt q$ .

Using the well-known variation of the action when there is variation in the time coordinate, we have $\dlt S=\int_{\tau_1}^{\tau_2} \p{\fr{\partial M}{\partial q}-\fr{\d}{\d\tau}\fr{\partial M}{\partial\mathring q}}\dlt q\,\d t -\fc{K}{\fc q{\tau_2},\fc{\mathring q}{\tau_2}}\dlt\tau_2,$ where $\fc K{q,\mathring q}\ceq\mathring q\fr{\partial M}{\partial\mathring q}-M$ is the energy (or the Kamiltonian, but as a function of generalized coordinates and velocities) of the system.

A quick check of this variation

Embed the latest Mastodon post in my website

2023-11-19T13:51:36-08:00

As we all know you can embed a Twitter timeline in your website like this:

A Twitter timeline

Rotational symmetry of plane lattices as a simple example of algebraic number theory

2023-11-09T23:53:41-08:00

Exercise 3.9. Show that five-fold rotation symmetry is inconsistent with lattice translation symmetry in 2D. Since 3D lattices can be formed by stacking 2D lattices, this conclusion holds in 3D as well.

Before I saw this problem, I had never thought about whether a plane lattice can have $m$ -fold symmetry for any positive integer $m$ . I was surprised at first that I cannot have a translationally symmetric lattice with 5-fold symmetry. After some thinking, I did realize that I cannot imagine a 5-fold symmetric plane lattice, so such a lattice cannot exist intuitively.

Actually, the only allowed rotational symmetries are 2-fold, 3-fold, 4-fold, and 6-fold. This result is known as the crystallographic restriction theorem. Then, how to prove it?

After jiggling around the possible structure of the symmetry group of a plane lattice, I finally proved it. I found that this proof is actually a simple and good example of how algebraic number theory can be used in physics.

Before diving into the proof, we need to first prove a simple lemma about real analysis:

Lemma 1. If $G$ is a subgroup of $(\mathbb R^2,+)$ that is discrete and spans $\mathbb R^2$ , then there exist two linearly independent elements in $\mathbb R^2$ that generate $G$ .

Proof. Because $G$ spans $\mathbb R^2$ , there exist two linearly independent elements $g_1,g_2\in G$ .

Consider the vector subspace $V_1\coloneqq g_1\mathbb R$ and the subgroup $G_1\coloneqq G\cap V_1$ . Obviously, $G_1$ should be generated by some element $h_1\in G_1$ (this is because $V_1\simeq\mathbb R$ , and $G_1$ as a discrete set must have a smallest positive element under that isomorphism, which must be the generator of $G_0$ because it would otherwise not be the smallest positive element). Therefore, $G_1=h_1\mathbb Z$ . Also, because $h_1\ne0$ , $\left\{h_1,g_2\right\}$ must span $\mathbb R^2$ .

Let $T\coloneqq\left\{ah_1+bg_2\in G\,\middle|\,a\in\left[0,1\right),b\in\left[0,1\right]\right\}.$ Then, $T$ must be discrete (because $G$ is) and bounded, and contains at least the element $g_2$ . Express every element in $T$ as $ah_1+bg_2$ and pick out the one element with the smallest non-zero $b$ , and denote it as $h_2=a^\star h_1+b^\star g_2$ . Certainly, $\left\{h_1,h_2\right\}$ span $\mathbb R^2$ .

Now, for any $g\in G$ , we can express it uniquely as $g=ah_1+bg_2$ . Define $c_2\coloneqq\left\lfloor\frac{b}{b^\star}\right\rfloor,\quad c_1\coloneqq\left\lfloor a-a^\star c_2\right\rfloor,\quad g'\coloneqq g-c_1h_1-c_2h_2.$ Then, $g'\in T$ , and if we express it as $g'=a'h_1+b'g_2$ , then $b'$ is smaller than $b^\star$ . By definition of $b^\star$ , $b'=0$ , so $g'\in G_1$ . Hence, $\left\{h_1,h_2\right\}$ generates $G$ . $\square$

Now, we are ready to prove our main result:

Theorem. There is a discrete subset of $\mathbb R^2$ that has both translational symmetry and $m$ -fold symmetry iff $\varphi(m)\le2$ , where $\varphi$ is Euler’s totient function.

Proof. For the neccessity, prove by contradiction. I instead prove that a set that has the said symmetries must not be discrete.

Denote the plane as $\mathbb C$ . Assume that there is an $m$ -fold symmetry around point $0$ . Then, for any lattice site $z$ , the point $Rz\coloneqq\alpha z$ (where $\alpha\coloneqq\mathrm e^{2\pi\mathrm i/m}$ ) is also a lattice site. Assume that there is a translational symmetry with translation $a$ , then the point $Tz\coloneqq z+a$ is also a lattice site. Without loss of generality, we can adjust the orientation of our coordinate system and the length unit so that $a=1$ .

The group $G$ generated by $\{R,T\}$ is a subgroup of the symmetry group of the lattice. Its action $S\coloneqq\left\{g0\,\middle|\,g\in G\right\}$ on the point $0$ is a subset of all the lattice sites (this is only true when $0$ is a lattice site; I will discuss later the other case). Notice that for any $z\in S,n\in\mathbb Z$ , we have $T^nRz=n+\alpha z\in S$ . Therefore, by expanding any polynomial with integer coefficients using Horner’s rule, we can see that $\mathbb Z[\alpha]\subseteq S$ .

Because $\alpha$ is an algebraic integer of degree $\varphi(m)$ (the minimal polynomial of $\alpha$ is known as the $m$ th cyclotomic polynomial), the generating set of $\mathbb Z[\alpha]$ must have at least $\varphi(m)$ elements. Therefore, according to Lemma 1, $\mathbb Z[\alpha]$ is discrete iff $\varphi(m)\le2$ .

For the case where $0$ is not a lattice site, we can generate $S$ by acting $G$ on any lattice site $z_0$ . We can then easily prove that $z_0+\mathbb Z[\alpha]\subseteq S$ . To prove this, we just need to see that we can act $R^{-k}$ on $z_0$ before further acting $T^nR$ on it for $k$ times. All the other steps are the same and still valid.

For the sufficiency, because there are only finitely many $m$ ’s that satisfy $\varphi\!\left(m\right)\le2$ . Therefore, we can enumerate these $m$ ’s and see that we can easily construct a plane lattice with both translational symmetry and $m$ -fold symmetry for each $m$ . $\square$

I know the original problem in the book was probably not intended to be solved in this way, but it is really amazing how some seemingly purely mathematical areas can have their applications in physics, especially in an exercise problem of a physics textbook where pure mathematics is pretty unexpected.

Unfortunately, this proof, which is based on algebraic properties of certain complex numbers, does not generalize to higher dimensions because we cannot use the complex plane to represent a high-dimensional space.

I restructured my blog

2023-11-06T00:06:52-08:00

Rendering equations server-side

I have been using MathJax as a client-side equation renderer to render equations on my blog for a long time.

The main problem about the client-side rendering is that it makes people that turn off JavaScript on their browsers (e.g. for privacy reasons) unable to see the equations in my articles. Another problem is that it is annoying to wait for the browser to render all the equations, especially if the site owner could have rendered them for you.

I actually have had some experience in server-side equation rendering in Jekyll. In a past post, I talked about how I used Jekyll and KaTeX to render equations in emails server-side. For the website of Sunniesnow (see here for a related post), I use jekyll-katex to render the equations server-side.

Then, I thought, what is stopping me to render equations server-side on my blog? I then started the migration.

The painful building

The easiest way to switch to server-side equation rendering is just to use kramdown-math-katex. Install the gem, add an option math_engine: katex into the Kramdown configurations of _config.yml, add the needed CSS to the theme, and… What is my computer doing? It is just stuck at building the site!

By adding the --verbose option to the jekyll serve command, I can see what it was doing. I can see that it is never stuck on any step, but rendering each article that has equations (especially those with a ton of ones) takes seconds. Because I have dozens of articles with equations, it takes minutes to build the site. It seems that although KaTeX has always been advertising itself as the fastest math typesetting library for the web, it is not fast enough for me to use it to render equations server-side.

A way to mitigate this issue is to use the --incremental option of jekyll serve. This makes the building much faster except the first time. I can also expect Jekyll to support lazy building in the future, which will entirely skip the building phase and build the files as needed on the fly.

I found another way to partially mitigate this issue. On my blog, I have been extensively utilizing the markdownify filter to render Markdown inside the templates, including the title of the posts, the excerpt of the posts, and something else. Those are rendered in multiple places, including the homepage, the archive page, the Atom feed, and the search page. Since now rendering Markdown is being very slow, I decided to cache the rendered Markdowns. A very simple strategy is as follows:

          
            def markdownify input

            	UlyssesZhan.markdown_snippet_cache[input] ||= Filters.instance_method(:markdownify).bind_call self, input

            end

Also, for most of the time I actually do not need to see the Markdown styling in the titles and excerpts, so I can also disable the markdownify filter depending on the site configuration, like this:

          
            def markdownify input

            	return input if @context.registers[:site].config['avoid_markdown']

            	UlyssesZhan.markdown_snippet_cache[input] ||= Filters.instance_method(:markdownify).bind_call self, input

            end

If I do not want to modify the site configuration file, I can also utilize an environment variable. I can use a after-init hook to set the configuration item based on the environment variable.

Rendering archives has also been very slow even with this Markdown disabling trick (for some reason I do not know). I decide to use another environment variable to disable the rendering of archives. Change the line gem 'jekyll-archives' in Gemfile to this:

          
            gem 'jekyll-archives', install_if: !ENV['JEKYLL_NO_ARCHIVE']

By using --incremental and these two tricks together, I can finally build the site in seconds if I only modify one post during jekyll serve.

Cross-referencing

It seems that I cannot cross-reference equations using server-side means. First, KaTeX does not support cross-referencing, and the current workarounds are not acceptable for my use cases.

I then looked at kramdown-math-mathjaxnode, which uses the MathJax Node library to render equations server-side. The MathJax Node library itself does support rendering equation numbers, but kramdown-math-mathjaxnode does not support cross-referencing either. What is worse is that it has not been maintained for years, which means I probably had to rewrite the plugin myself, but I did not have spare time.

Even worse, Kramdown is just not suitable for implementing cross-referencing. I briefly looked at Kramdown’s source codes, and I realized that if I was about to write a math engine for Kramdown to support cross-reference, I would have to refactor Kramdown a bit. Actually, cross-referencing is quite a non-trivial feature for markup languages because of references that cannot be resolved during the first compilation. In $\LaTeX$ , those references are resolved in the second compilation. I would need to refactor Kramdown to support a similar workflow to make it possible to implement cross-referencing.

Then, I looked at other Markdown engines. For Ruby, the only successful Markdown engine besides Kramdown that I know was Redcarpet (it used to be the default Markdown engine of Jekyll), and it was not designed with cross-referencing in mind either. Its developer even rejected to support math-related features a long time ago.

This is why I looked at non-Ruby Markdown engines. The first option that I came up with and also the option that I finally chose is Pandoc.

Pandoc is power in that its form of customization is filters, which transforms the whole parsed AST of the document. Because the whole AST is visible at once for a filter, it is then possible to implement cross-referencing by using a filter. Fortunately, someone has already written such a filter, and it is called pandoc-crossref. What is good about this approach is that it is independent of the math engine that I use: I can use MathJax or KaTeX, client-side or server-side, and it does not matter. The only drawback about it is that it does not support cross-reference a particular line in align or eqnarray environment, which is a feature that I have used in some of my posts. I have to reword those posts to avoid using that feature.

Now that we have a filter, we then need a way to let Pandoc render the math expressions server-side. Fortunately (again), someone has already written a filter for this purpose, and it is called pandoc-katex. Append this filter after the pandoc-crossref filter, and we are done.

The drawback about Pandoc is that it has no Ruby implementations, which means the only way to utilize Pandoc in Jekyll is to write a wrapper of it in Ruby and develop a Jekyll plugin for using that wrapper of Pandoc as the Markdown engine. Fortunately, someone has already done this: the wrapper is called pandoc-ruby, and the Jekyll plugin is called jekyll-pandoc.

Although the math rendering problem is solved, a somewhat unrelated problem arises: Pandoc does not use Rouge to highlight code blocks, but I like Rouge. Unfortunately, no one has written a Pandoc filter to use Rouge to highlight code blocks for me; but fortunately, I can write one myself quickly because it is easy enough, especially if I utilize Paru, which contains an API library to help me with writing Pandoc filters in Ruby.

Paru is actually an alternative to pandoc-ruby. Now that I also use Paru, I started to wonder if I should use pandoc-ruby at all. Considering that jekyll-pandoc has not been maintained for years, I decided to write my own Jekyll plugin to use Paru as the Markdown engine, and the simple plugin is called jekyll-paru.

Tedious work of reformatting the old posts

Using kramdown-math-katex is the only option that I do not need to adjust most of my posts. Another option, jekyll-katex, is not compatible with the markup that I use to write equations. I could not either just wrap the whole {{ content }} inside the {% katexmm %} block (due to some errors that I do not know), and the error messages then were impossible to utilize to help me locate the incompatibilities.

For the option that I finally use, Pandoc, I also have to adjust most of my posts. The major incompatibility is that I need to change all \label and \ref to the format recognizable by pandoc-crossref. Another incompatibility is that I need to use {target=_blank} instead of {:target="_blank"} to indicate a link to be opened in a new tab (as well as other HTML attributes that I use this syntax to embed in Markdown). Also, Pandoc does not allow blank lines inside math display blocks, which I have used in some of my posts (by the way, $\LaTeX$ does not allow those blank lines either, which is pretty annoying).

I then wrote a simple script that use regular expressions to help me with this refactoring task. However, because of the diversity of the syntaxes that I used, I still need to check the posts manually after I ran the script. This makes the refactoring task still very tedious.

The much more complicated GitHub Actions workflow

Now, to build my site, the machine needs pandoc, pandoc-crossref, and pandoc-katex, none of which are Ruby Gems. I need to set up Haskell environment and Rust environment to install them. In GitHub Actions, I can use haskell-actions/setup to set up Haskell environment and cargo-install to install Cargo packages.

I do not know how I managed to make the GitHub Actions workflow file work expectedly at one shot, but I did.

Table of contents and searching

I have been using jekyll-toc to generate the table of contents for each post. The problem with using it now is that it strips the HTML in headings and only keeps the text, so headings with math expressions will not be rendered with nice math typesetting. It was not a problem previously because the client-side math rendering script will render the math expressions in the table of contents. Now that I switched to server-side math rendering, I had to patch jekyll-toc to make it work.

The search functionality was implemented by myself. It is a simple client-side searching powered by Lunr. I also had to refactor the search functionality a bit to make the search results be rendered with math expressions (which were previously also handled by the client-side math rendering script).

Updating the theme

The reason that I updated the theme is actually quite dramatic. This originated from me trying to use kramdown-math-katex. To ensure that the KaTeX CSS has the correct version with the KaTeX renderer used by katex-ruby, I decided to @import the SCSS file found in the repo of katex-ruby into my theme. I found that the SCSS file utilizes a function asset-path to load the fonts, but my CSS pre-processor does not support it, so I tried to extend my CSS pre-processor.

Jekyll uses jekyll-sass-converter to render CSS files, which once (v2) used sassc, but now (v3) uses sass-embedded. The former does not support extension of custom SCSS functions, but the latter does. Therefore, I need to upgrade my jekyll-sass-converter to v3. I actually could have upgraded it earlier because I have been using Jekyll v4 for a long time, but I deliberately kept using jekyll-sass-converter v2 because jekyll-action, which I used, had an issue about using sass-embedded. However, I have long ago migrated from jekyll-action to GitHub’s official upload-pages-artifact, so I can now upgrade jekyll-sass-converter to v3.

Then why does this have anything to do with the theme I used (which is Minima)? After I upgraded jekyll-sass-converter to v3, I found that there are some deprecation warnings in the SCSS files (they are actually already fixed, but I do not know why the issue is still open). This was also when I noticed that Minima has not released a new version for 4 years, and the last stable release is v2.5.1.

Then, how did I upgrade to Minima v3? I actually just tried to use the master branch of the Git repo of Minima, and I found that it was great.

Placeholder files for customization

I am glad to see Minima v3 introduced the include custom-head.html which allows for custom additional HTML metadata and the SCSS file minima/custom-variables.scss and minima/custom-styles.scss which allows for custom SCSS rules to override the default ones.

Although it took me some time to migrate my already present SCSS files and HTML metadata to the new structure, I am glad that Minima adopted this new structure that is more useful and more modern.

Skins

Another feature that I really like about Minima v3 is the support of skins. Minima now comes with several pre-defined skins which I can choose from. The default skin called classic is the one that originated from Minima v2, based on which I wrote my own skin.

I still remember a long time ago I tried to make my site support dark theme. It was such a pain because there are so many colors hardcoded in the theme so that I have to rewrite a large part of the SCSS files provided by Minima to support dark theme. Now, Minima v3 has a pre-defined skin called auto, which adaptively looks the same as classic or dark based on the browser’s prefers-color-scheme. I can now implement my skin based on auto (select my skin in the site’s configuration file and @import the auto skin in my skin’s SCSS file), and the codes are now much cleaner.

Ulysses’ trip

Ways of reducing mass rebuilds in Nix without changing Nix

Store path replacements

Determining the stabilizability of the abelian sandpile model

Abelian property

Least action principle

Integer linear programming

From Picard iteration to Feynman path integral

Excluding self-loops

Feynman path integral

Imperative programming in Nix language

Assign and print

Exception handling

Control flow

Functions

Input

Other minor improvements

Possible improvements

Multi-pass Gaussian blur filter

The buildup kickroll in Time to beat the odds

Eigenfunctions of the Laplacian on an annulus with homogeneous Neumann boundary condition

Distribution of eigenvalues

Kummer’s equation

The role of particle indistinguishability in statistical mechanics

Why it is a bad idea to use GitHub for submiting school homework

How to use JavaScript in GitHub Actions without committing node_modules

Some understanding of Grassmann numbers out of intuition

Introduction

Numbers

Tensors

Linear endomorphisms

Analytic functions

Integrals

Linear change of integrated variable

Afterwords

The notational convenience of imaginary time in the derivation of the metric in Poincaré coordinates

Introduction

The derivation

The smallest wave packet in the lowest Landau level

Introduction

The problem

The solution

Further problems

Regularizing the partition function of a hydrogen atom

Letting people know when you are asleep

Using nmcli to connect to eduroam in UCSB

The duality between two plane trajectories related by a conformal map

Power-law central-force potentials

Corollaries and applications

Some straightforward proofs

Details worth noting

Invertibility of the conformal map

Requirements for the potential

Trajectories that run out of the domain

Arbitrariness in the construction of the conformal map

Rotation and translation

Scaling

Canonical transformation of time

Change in the time variable in the stationary-action principle

Embed the latest Mastodon post in my website

Rotational symmetry of plane lattices as a simple example of algebraic number theory

I restructured my blog

Rendering equations server-side

The painful building

Cross-referencing

Tedious work of reformatting the old posts

The much more complicated GitHub Actions workflow

Table of contents and searching

Updating the theme

Placeholder files for customization

Skins

How to use JavaScript in GitHub Actions without committing `node_modules`