Ulysses’ trip

How Pareto optimizations of distances relate to closed convex hulls

2026-10-07T14:03:46-07:00

Introduction

For a real normed space $X$ , let $S\subseteq X$ and $x\in X$ . Define $\fc I{S,x}\ceq\bigcap_{a\in S}\fc B{a,\V{x-a}},\qquad \fc{\bar I}{S,x}\ceq\bigcap_{a\in S}\fc{\bar B}{a,\V{x-a}}$ (specially, $\fc I{\varnothing,x}=\fc{\bar I}{\varnothing,x}=X$ ), where $\fc B{a,r}\ceq\set{y\in X}{\V{y-a}$ denote the respectively open and closed ball centered at $a$ with radius $r$ , and $\fc PS\ceq\set{x\in X}{\fc I{S,x}=\varnothing},\qquad \fc{\bar P}S\ceq\set{x\in X}{\fc{\bar I}{S,x}=\B x}.$ This article studies the four properties: $P_\supset:\qquad \opn{\overline{conv}}S\subseteq\fc PS,\qquad \bar P_\supset:\qquad \opn{\overline{conv}}S\subseteq\fc{\bar P}S,$ $P_\subset:\qquad \fc PS\subseteq\opn{\overline{conv}}S,\qquad \bar P_\subset:\qquad \fc{\bar P}S\subseteq\opn{\overline{conv}}S,$ where $\opn{\overline{conv}}S$ denotes the closed convex hull of $S$ .

Based on the property of $S$ , the four properties multiply to sixteen properties: $P_{\supset,\subset}^\mrm f$ means $P_{\supset,\subset}$ holds for all finite $S\subseteq X$ ; $P_{\supset,\subset}^\mrm c$ means $P_{\supset,\subset}$ holds for all compact $S\subseteq X$ ; $P_{\supset,\subset}^\mrm b$ means $P_{\supset,\subset}$ holds for all bounded $S\subseteq X$ ; $P_{\supset,\subset}^\mrm a$ means $P_{\supset,\subset}$ holds for all $S\subseteq X$ ; and similarly for $\bar P_{\supset,\subset}^{\mrm f,\mrm c,\mrm b,\mrm a}$ .

We assume $X\ne\B0$ throughout. For $S=\varnothing$ , all sixteen properties then hold trivially, so proofs involving $S$ may assume it is nonempty. If $X=\B0$ and empty sets of ideal points are allowed, $\bar P_\subset$ fails for $S=\varnothing$ .

Some of the properties are stronger than others. First, all finite sets are compact, and all compact sets are bounded. Second, we can easily see that $\fc{\bar P}S\subseteq\fc PS$ . Therefore, $P_{\supset,\subset}^\mrm a\Rightarrow P_{\supset,\subset}^\mrm b\Rightarrow P_{\supset,\subset}^\mrm c\Rightarrow P_{\supset,\subset}^\mrm f,\qquad \bar P_{\supset,\subset}^\mrm a\Rightarrow \bar P_{\supset,\subset}^\mrm b\Rightarrow \bar P_{\supset,\subset}^\mrm c\Rightarrow \bar P_{\supset,\subset}^\mrm f,$ $\bar P_\supset^{\mrm f,\mrm c,\mrm b,\mrm a}\Rightarrow P_\supset^{\mrm f,\mrm c,\mrm b,\mrm a},\qquad P_\subset^{\mrm f,\mrm c,\mrm b,\mrm a}\Rightarrow \bar P_\subset^{\mrm f,\mrm c,\mrm b,\mrm a}.$

The established characterizations and the remaining gaps are summarized in the following table:

Property	Characterization
$P_\supset^{\mrm f,\mrm c,\mrm b}$ , $\bar P_\subset^\mrm b$	inner product space or plane
$\bar P_\supset^{\mrm f,\mrm c,\mrm b}$ , $P_\subset^\mrm b$	inner product space or strictly convex plane
$P_\supset^\mrm a$	inner product space or plane with balanced tangent chords
$\bar P_\supset^\mrm a$	inner product space or strictly convex plane with balanced tangent chords
$P_\subset^{\mrm f,\mrm c}$	finite dimensions: inner product space or strictly convex plane; infinite dimensions: open
$\bar P_\subset^{\mrm f,\mrm c}$	finite dimensions: inner product space or plane; infinite dimensions: open
$P_\subset^\mrm a$	Hilbert space or strictly convex plane
$\bar P_\subset^\mrm a$	Hilbert space or plane

Here, a plane means a two-dimensional real normed space. See Definition 24 for balanced tangent chords.

If we only consider the characterizations of spaces satisfying both $P_\supset^{\mrm f,\mrm c,\mrm b,\mrm a}$ and $P_\subset^{\mrm f,\mrm c,\mrm b,\mrm a}$ (or both $\bar P_\supset^{\mrm f,\mrm c,\mrm b,\mrm a}$ and $\bar P_\subset^{\mrm f,\mrm c,\mrm b,\mrm a}$ ), then there are no open gaps:

Property	Characterization
$P_\supset^{\mrm f,\mrm c,\mrm b}\land P_\subset^{\mrm f,\mrm c,\mrm b}$ , $\bar P_\supset^{\mrm f,\mrm c,\mrm b}\land\bar P_\subset^{\mrm f,\mrm c,\mrm b}$	inner product space or strictly convex plane
$P_\supset^\mrm a\land P_\subset^\mrm a$ , $\bar P_\supset^\mrm a\land\bar P_\subset^\mrm a$	Hilbert space or strictly convex plane with balanced tangent chords

In the following sections, a vector space is assumed to be over the real numbers unless otherwise specified.

Background

The background of this study is in economics, where preference relations and Pareto efficiency are studied.

My motivation of studying the properties originates from my previous article on voting systems, dates back to more than three years ago.

In the end of that article, I used an example of this preference relation: an agent prefers points nearer to the ideal point. Mathematically, it says that in the metric space $\p{X,d}$ , for an agent with ideal point $a\in X$ , $y\succeq x$ iff $\fc d{y,a}\le\fc d{x,a}$ . Such a preference relation is what I call a distance preference relation.

That article also focuses on the concept of Pareto efficiency, or particularly, weak Pareto efficiency. Suppose that we have a set $S$ of agents, and we denote the preference relation of each agent $a\in S$ as $\succeq_a$ , and suppose all preference relations are complete over a space $X$ . Then, we say $y\in X$ is a strong Pareto improvement of $x\in X$ iff $\forall a\in S:y\succ_a x$ ; $y$ is a weak Pareto improvement of $x$ iff $\forall a\in S:y\succeq_a x$ . Note the terminological quirk: a strong Pareto optimal has no weak Pareto improvement, and a weak Pareto optimal has no strong Pareto improvement. Note that neither concept is the actual definition of Pareto improvement used in economics, which says that $y$ is an (economic) Pareto improvement of $x$ iff $\forall a\in S:y\succeq_a x$ and $\exists a\in S:y\succ_a x$ . However, since the weak Pareto improvement and the strong Pareto improvement have simpler mathematical definitions, they will be the focus of this article.

The set of all strong Pareto improvements of $x$ is denoted as $\fc I{S,x}$ . We say $x$ is weak Pareto optimal iff $\fc I{S,x}=\varnothing$ , and the weak Pareto set is the set of all weak Pareto optimals, denoted as $\fc PS$ . Similarly, we can denote the set of weak Pareto improvements as $\fc{\bar I}{S,x}$ . We say $x$ is strong Pareto optimal iff $\fc{\bar I}{S,x}=\B x$ , and the strong Pareto set $\fc{\bar P}S$ is the set of all strong Pareto optimals. When $X$ is a metric space and the preference relations are distance preference relations, the definitions of $\fc I{S,x}$ , $\fc{\bar I}{S,x}$ , $\fc PS$ , and $\fc{\bar P}S$ match exactly with the definitions in Equation 1 and Equation 2.

In the end of my previous article referenced here, there was an example taking $X$ as a Euclidean plane as an example. There was a figure visualizing the weak Pareto sets for finite numbers of agents, but I never explained how I derived the weak Pareto sets. From the figure, it seems that the weak Pareto set is the convex hull of the ideal points of the agents. I originally planned to prove this in that article, but it turned out that it was too difficult, so I just left it without justification.

Questions of the same type were raised and answered by Durier (1987). In his paper, he called $\fc{\bar P}S$ the strictly efficient points, $\fc PS$ the weakly efficient points, and the economic Pareto set the efficient points. He also studied another type of optimal points called the properly efficient points.

Preliminaries

Theorem 1. If a normed space is not strictly convex, then it does not satisfy $P_\subset^\mrm f$ .

Proof

Reducing build time of my blog by 88% by optimizing cross-language invocations

2026-09-12T05:06:46-07:00

Introduction

In a past post, I shared my experience of restructuring my blog to use Pandoc and $\KaTeX$ to convert the articles from Markdown to HTML. However, the cost is that building the blog becomes very slow. I developed a plugin to make Jekyll support multithread rendering, but the boost is not enough. Generating the full site in production configurations takes 49 seconds on my local development machine and 156 seconds on the CI machine (GitHub Actions runners provided by GitHub).

The main reason of the slow building is the slow conversion from Markdown to HTML. The full pipeline of converting a piece of Markdown into HTML is as follows. Paru invokes Pandoc CLI. Then, Pandoc CLI invokes three filters: my Pandoc filter written in Ruby, pandoc-crossref written in Haskell, and pandoc-katex written in Rust (which in turn invokes JavaScript codes using QuickJS), the input and output of each of which are JSON representation of Pandoc AST. The order of languages being executed is Haskell, Ruby, Haskell, native (Rust) (embedded JavaScript). A lot of repetitive work is done for each converted document:

Spawning a Haskell process (Pandoc CLI).
Spawning a Ruby process and loading gems (Paru and Rouge).
Spawning another Haskell process (pandoc-crossref).
Spawning a native binary (pandoc-katex) that initializes a JavaScript engine (QuickJS).
Serialize and deserialize the entire AST to JSON between every two steps.

Optimization of calling JavaScript

The most natural idea is simply to ditch pandoc-katex and directly call JavaScript from Ruby.

At first I thought it might be difficult because it is quite complicated to achieve multithread parallellism in Node.js. However, it seems that multithread parallellism is quite easy with MiniRacer (much easier than in Node.js) because different JavaScript contexts can run parallelly in different threads. However, calling functions in the same JavaScript context from different threads does not make the function calls parallel but merely concurrent.

I note that require and import does not work in MiniRacer, so I have to bundle all dependencies into one JavaScript file. I can achieve this using esbuild.

The Pandoc filter for rendering math equations can now be written in Ruby. The order of executed languages is now Haskell, Ruby, Haskell, and Ruby (embedded JavaScript). I then should reorder the filters so that the two Ruby filters can be combined so that the order of executed language can then be Haskell, Haskell, and Ruby (embedded JavaScript). The reason that my custom Ruby filter was before pandoc-crossref was that pandoc-crossref introduces MetaInlines nodes, which greatly reduces performance of Paru filters by having it spawning additional Pandoc CLI processes. Therefore, to make this reorder, I also need to ditch Paru for writing the filter. Fortunately, writing a custom Pandoc filter without an external library is quite easy.

I also note that, to avoid repeatedly serializing the same $\KaTeX$ rendering options, I should pass the options only once to each JavaScript context.

Optimization of calling Haskell

How to reduce the startup overhead when using Pandoc with JSON filters to convert a large amount of documents? I thought of a few candidates that may not work:

Using Lua filters: Pandoc has built-in Lua interpreter, so using Lua avoids JSON serialization and spawning external processes. However, this is not possible because of the complexity of Rouge and pandoc-crossref.
Using Pandoc server: This keeps Pandoc process running to avoid the startup overhead of Pandoc CLI. It introduces overhead due to network protocols, but it is much smaller. However, the improvement is limited because the major overhead is in spawning filter processes.
Batching documents: Combining multiple Markdown documents into one large Markdown and then split out separate HTML codes from the resultant HTML greatly reduces the number of spawned processes. However, this requires major rewriting of the filters and Jekyll itself, which imposes huge maintenance workload in the future.

It seems that the only way out is to write my own program in Haskell for document processing, using Pandoc and pandoc-crossref as libraries. There are two ways that it may work:

A custom server with IPC: I can write a separate program at standby, handling requests from Jekyll and returning converted documents. Each program handle requests from one Ruby thread, and they communicate with Jekyll through Unix domain socket.
An FFI library: I can write a library that can be called using FFI. If compiled with the -threaded flag of GHC, the functions can be invoked parallelly in different threads. Note that one needs to initialize the Haskell RTS with the same number of capabilities as threads in the Ruby side (document).

Both approaches are actually straight forward, but it is not obvious which one should have higher performance. For the IPC approach, there is the process startup overhead of the Haskell program for each Ruby thread, and there is the overhead of IPC. For the FFI approach, there is the overhead of managing bound threads and parallellism.

Before I decided, I asked an AI agent to write a benchmark to compare the two different approaches. The result is that the FFI approach performs better in most cases, so I decided to take the FFI approach.

Optimization of serialization

MessagePack is faster than JSON, so using MessagePack instead of JSON is an improvement.

I also avoid sending configuration options through cross-language barriers. Instead of calling convert(payload, options) from Ruby, call init(options) once and then convert(payload) afterwards. This makes sure that the same options are only serialized at most once. For JavaScript, one can simply store the options in a local variable. For Haskell, there are several ways for storing some persistent data: IORef, MVar, and StablePtr are all viable solutions, between which there should be negligible difference in terms of performance.

The data flow between language barriers for each document conversion is now as follows:

Ruby to Haskell: raw string (Markdown).
Haskell to Ruby: MessagePack (AST).
Ruby to JavaScript: multiple raw strings ( $\TeX$ ).
JavaScript to Ruby: multiple raw strings (HTML).
Ruby to Haskell: MessagePack (AST).
Haskell to Ruby: raw string (HTML).

As we can see, there are only two serializations and deserializations for the full AST. All other cross-language communications are direct string copying.

Result

The time spent on generation of the full site in production configurations on the CI machine (GitHub provided runners for GitHub Actions) before and after the revamp on the Markdown engine is 156 seconds and 19 seconds respectively, marking a 88% reduction.

Local development

For local development, I usually only edit one post at a time, so it should not be necessary to build the full site. Fortunately, Jekyll has the feature of incremental build, which only renders the documents that depend on the changed files. However, for changes in a single blog article, besides the article itself, there are actually a lot of things that get rebuilt because they all depend on the article:

Homepage. The homepage lists articles, so any change in any article changes the homepage. Note that because the homepage is paginated, every paginated page of the homepage gets rebuilt.
Archives. In my blog, the archives are lists of articles categorized by dates, categories, and tags. Because changing one article modifies the full list of articles, all archive pages are rebuilt.
Atom feed. The Atom feed directly contains the HTML contents of articles, so it gets rebuilt when an article changes.
All articles. It sounds absurd at first, but you may note that there are navigation links to the previous article and the next article at the bottom of every article page. This makes all articles depend on each other.

The cost of rendering the homepage is still manageable, so I passed it for now. However, the other items are quite slow to generate because of the large amount of contents. I added some patches to Jekyll and some Jekyll plugins to disable the archives and the Atom feed and to cut the dependency between articles when some environment variables are set.

Now, the time for incremental build of the site when one article is changed is 0.3 seconds on my development machine. It is now on the level of Jekyll without any plugins.

Analyzing the narrative of Kittens Game

2026-06-25T07:11:44-07:00

This article is adapted from my submission to a writing class assignment at school.

This analysis centers about a game called Kittens Game.

Calling Kittens Game a video game is a bit of a far stretch in that it is a text-based game, where the only visual feedback is textual instead of having visual images. Furthermore, even though it is text-based, there is not a single line of narrative in the game. All the texts are just statistical numbers, names and descriptions of events and upgrades, and other miscellaneous texts such as the game settings. However, the story it tells is extremely content-rich. I am not going to insert screenshots of the game in the middle of this analysis because screenshots would be the least interesting thing in this analysis before I explain the story. A screenshot or a short video of the gameplay does not tell anything about the rhetorics of the game, but the player can only feel the progression in story by unlocking game mechanics through weeks or even years of gameplay. Rather, I will include some flowcharts of the upgrades that the player can unlock throughout the game. In the end of the analysis, I will include a few screenshots and leave some remarks on them.

For its genre, Kittens Game is an incremental game. Like any incremental games, the main game mechanics is to do repetitive actions or buy automations to accumulate in-game resources. Incremental games can usually be categorized into clicker games and idle games, determined by whether repetitive actions or automation upgrades are more central to the gameplay. Kittens Game is neither. It is not a clicker game because repetitive clicking can produce meaningful amounts of resources only during the first ten minutes of gameplay, which is a very small portion of the full gameplay compared with the months a player has to spend before unlocking the late-game mechanics. It is not an idle game because resources max out so quickly that almost all resource incomes are obtained during active playing. Requiring the player’s active non-repetitive attendance makes the game extraordinarily engaging compared with other incremental games. This gameplay style makes the player experience the progression in the game very attentively.

However, the player does not immediately get to know what the game tries to tell the player through the attentive experience of the progressions in numbers. At first, the upgrades and buildings in the game just feel like any other game with resources and buildings: there are different kinds of buildings, such as Huts for population, Warehouses for storage, Lumbermills for production, and Academies for development; there are different kinds of jobs, such as Farmers, Miners, Hunters, and Scholars; there are different upgrades, whether scientific or political, with different consequences, such as Clear Cutting vs. Strip Mining vs. Environmentalism, Monarchy vs. Autocracy vs. Republic, etc. The game even feels cute in that the population are kittens instead of humans. The player gets to make a lot of choices, such as different assignment of jobs for the kittens and different priorities in purchasing upgrades, but the choices feel purely strategic rather than having rhetorical meanings.

The turning point is when kittens discover Zebras and start trading with them. There are races that the player gets to trade with before Zebras appear, but what is different is that Zebras are especially hostile towards kittens while being the sole source of getting a crucial resource at this stage: titanium. At this point, the player realizes that diplomacy is mostly just about managing hostility, revealing the cruelty of the political world of the game: it is a Hobbesian world of bellum omnium contra omnes (the war of all against all). It is then interesting to think about why the author chose “Zebras” out of all possible names of such a race. This choice of author is not random but a reference to the books The Exegesis of Philip K. Dick (abbreviated as Exegesis) and VALIS (acronym for Vast Active Living Intelligence System) by Philip K. Dick (abbreviated as PKD). PKD explores the idea of gnosticism in those books: the material world is inherently flawed or illusory, referred to as the Black Iron Prison (abbreviated as BIP), created by a lower, often malevolent, deity, referred to as the Demiurge. For PKD, the world we inhabit may be a simulation or illusion, controlled by an external or higher force, the true god. “Zebra” is a name for gnostic gods, a divine, camouflaged intelligence that mimics the environment to communicate with humans. They are not the Demiurge but is the true god, who lives in a higher dimension over the material simulation world; their goal is to wake up mortal people in the BIP, which is the reason why Zebras in Kittens Game act as the external force to provide titanium, the very material needed to build ships and leave the planet. PKD’s visions of the BIP refer to a world of oppression and confinement, which resonates with the gnostic idea of the material world as a prison for the soul.

Speaking of leaving the planet, let us come back to the technological advancement of kittens. As we mentioned, science and technology start as being utilitarianistic, consisting of mostly agricultrue, mining, and construction. However, the story shifts drastically as the player advances to unlocking Rocketry. The story shifts from kittens on a farm to kittens as a galactic force. Science tells the kittens that their home planet is finite and insufficient, but they have to leave the planet to gain more space and more energy. From this point, the focus of the gameplay shifts from constructing earth-based buildings to constructing space-based buildings: there are space-based population buildings such as Space Stations and space-based resource production buildings such as Hydraulic Fracturers. In the next stage, the player gets to unlock more sciences that do not sound like physics at all, but the kittens are using technology to mold the reality itself. For example, Quantum Cryptography signifies the realization that the universe is made of information instead of just matter, and kittens start hacking their way out of reality; Chronophysics signifies the realization that time is but a variable that can be manipulated, and kittens step outside of the linear flow of the game to gain resources from the future. This process is not the normal kind of technological development at all, but the process of breaking out of the BIP.

I have been talking about kittens for a while, but what does this have to do with the player, the one who actually makes the choices that lead all the things to happen to kittens? This leads to the ultimate philosophical question in the game: who is the player? To answer this question, I will introduce another concept in the game: resetting. It is actually a common game mechanics called “prestige” shared by many incremental games, which typically clears the current progress in exchange for permanent upgrades. It mainly serves as a strategic move that players can choose to take to accelerate future advancement. In Kittens Game, the player gains Karma and Paragon by resetting, which are resources that persist through resetting. In order to advance at a reasonable rate, the player has to reset once in a while. This is just like the myth of Sisyphus: the player pushes the boulder up the hill (build the kittens civilization) and then intentionally roll it back down (reset for Paragon). Then, what does the kittens’ lives mean if they are destined to be erased? The game suggests that the only meaning is the accumulation of gnosis, symbolized as Karma and Paragon. What does it mean for the player if the game is just an endless cycle of resetting? The game forces the player to answer the same question posed to Sisyphus every time the player chooses to click the “reset” button. The answer suggested by the game is that the player is playing the role of the Demiurge. The player, or the Demiurge, creates this world in which kittens live, traps the kittens in a loop and forces them to labor for their own amusement (seeing the statistical numbers going up). From this point of view, this game that looks cute from far actually tells a tragic story, where the kittens use their accumulated gnosis through the endless destructions of the world in order to escape the BIP created by the Demiurge, yet they are still under the control of the Demiurge after countless trials, merely serving as the source of amusement for the Demiurge.

All of these are just a small part of the game. Every one of the game mechanics tells a part of the story. For example, the Order of the Sun religion in the game can be viewed through a gnostic lens as the worship of the Demiurge, and the kittens later find out that the traditional “worship” is just another layer of the prison to be exploited for higher understanding. The Leviathans, another race with which kittens can trade that appear after Zebras, is a reference to Thomas Hobbes’ book Leviathan or The Matter, Forme and Power of a Commonwealth Ecclesiasticall and Civil, and they act as the wardens of the BIP by providing Relics as part of the prison to prevent the bellum omnium contra omnes. The Void, a late-game resource gained from Temporal Paradoxes, signifies kittens’ use of the nothingness of the BIP to power their escape. Literally every mid-game and late-game mechanics can be expanded in long paragraphs on how it contribute to what the game wants to tell the player.

The fact that the game is able to tell the player so rich a story without a single line of narrative is what this game is amazing at and what makes this game stand out among all incremental games. Instead of directly telling the player the story, it urges the player to think and construct the story on their own every time the player makes a choice, clicks a button, and receive a feedback. This form of story-telling is unique to interactive digital media, and Kittens Game pushes it to its limit in utilizing this way to tell the full picture of an extremely rich story.

Now it is time to look back on the visual interface of the game.

As can be seen, this is an extremely plain game interface, which is indeed the least interesting thing about the game at first glance. However, as the player connects the game with the BIP, the asthetic choice of this game interface suddenly makes sense: the interface itself depicts a literal BIP, where everything is just plainly laid out without deep thoughts and freedom. Seeking amusement from such a lifeless-looking thing, is not the player themself looking like something under the control of the Demiurge? Through the interface design, the game breaks the fourth wall to tell its deep philosophical and religional message to the player in the most subtle way.

Text-based visual art in LaTeX

2026-06-06T22:15:30-07:00

I was writing an essay to analyze a text-based game for a class assignment. The game has an Easter egg of saving a text file locally in the computer, and there is a text-based visual art in it (guess what game it is!). I want to show the art in a figure. How can I do that?

After messing around with some packages, I finally found the way to use the verbatimbox package to draw a text art:

\documentclass{article}

\usepackage{verbatimbox}
\usepackage{varwidth}
\usepackage{graphicx}

\begin{filecontents}[noheader,overwrite]{art.txt}
  ______________
< Kat loves Mar. >
  --------------
         \   ^__^ 
          \  (oo)\_______
             (__)\       )\/\\
                 ||----w |
                 ||     ||
\end{filecontents}

\begin{filecontents}[noheader,overwrite]{wide-art.txt}
  ______________          ______________          _______________________
< Kat loves Mar. >      < Mar loves Kat. >      < They live a happy life. >
  --------------          --------------          -----------------------
         \   ^__^                \   ^__^                \   ^__^ 
          \  (oo)\_______         \  (oo)\_______         \  (oo)\_______
             (__)\       )\/\\       (__)\       )\/\\       (__)\       )\/\\
                 ||----w |               ||----w |               ||----w |
                 ||     ||               ||     ||               ||     ||
\end{filecontents}

\begin{document}

\begin{figure}[h!]
	\centering
	\begin{varwidth}{\linewidth}
		\verbfilenobox[\fontsize{10pt}{10pt}\selectfont]{art.txt}
	\end{varwidth}
	\caption{A text-based visual art.}
\end{figure}

\begin{figure}[h!]
	\resizebox{\linewidth}{!}{\vbox{\verbfilenobox[\fontsize{10pt}{10pt}\selectfont]{wide-art.txt}}}
	\caption{A wider text-based visual art.}
\end{figure}

\end{document}

If the art is not wide enough to exceed the line width, use the first approach. The package varwidth is needed for the varwidth environment. Otherwise, use the second approach. The package graphicx is needed for the \resizebox command.

The command \fontsize{10pt}{10pt} is so that there is no baseline skip between lines. Usually the baseline skip messes with text-based arts.

If the art is large, I recommend using LuaLaTeX. Otherwise, you may encounter the error TeX capacity exceeded, sorry.

End result:

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.

Ulysses’ trip

How Pareto optimizations of distances relate to closed convex hulls

Background

Preliminaries

Reducing build time of my blog by 88% by optimizing cross-language invocations

Introduction

Optimization of calling JavaScript

Optimization of calling Haskell

Optimization of serialization

Result

Local development

Analyzing the narrative of Kittens Game

Text-based visual art in LaTeX

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

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