Blog posts on EPH

Costa Rica photos

Sun, 15 Feb 2026 00:00:00 +0000

I visited family in Costa Rica and got to see tons of cool animals and birds. Pretty happy with how some of these came out! Was also very excited to see some night herons, I have not been able to find any in Madrid, although supposedly they are around.

LibImageQuant.jl

Mon, 01 Dec 2025 00:00:00 +0000

This post is cross-posted from the Julia language community’s Discourse forum. See here for the original post where you can read and leave comments.

libimagequant is a GPL Rust library (originally C, ported to rust by the maintainers) which performs color quantization (available from the command line as pngquant). I got it building with Binary Builder and wrote a small Julia wrapper called LibImageQuant.jl to make it easier (and slightly more efficient) to use from Julia. Instead of saving a PNG to disk and then calling pngquant, you can do it in-memory with quantize_image(figure_or_matrix).

Birb Stalker (2021)

Mon, 24 Nov 2025 00:00:00 +0000

In 2021, I had a project I called “birb stalker”. It was kind of a weird project. I was interested in taking “paparazzi” photos of birds, in which they were potentially partially obscured, etc, to emphasize the role of the photographer and that photos always are part of some physical context, which in many cases we try to omit. I had a couple fuzzy thoughts circling my head at the time:

Counting short package names

Sun, 16 Nov 2025 00:00:00 +0000

Introduction

In my post yesterday Thoughts on being a package registry maintainer, I discussed package registration moderation, exercise of power, and some historical moderation decisions. One piece of it was about Julia packages with 3-letter names, and in particular the question of how many such packages there can be. I wrotelightly edited here for clarity:

Thoughts on being a package registry maintainer

Sat, 15 Nov 2025 00:00:00 +0000

Introduction

Julia is a modern programming language with a fairly large package ecosystem (currently ~10k packages) that provide all kinds of useful functionality to build on. Packages are registered in a global registry called General, which is installed by default by the package manager, allowing users to easily add and use registered packages.

Bus factor 0

Tue, 28 Oct 2025 00:00:00 +0000

“Bus factor” is a somewhat morbid term used in software engineering (and possibly elsewhere), meaning the number of people who would have to get “hit by a bus” for a project to fall apart. In programming terms, it’s often used to mean the number of people who understand a codebase. It’s also called the “lottery factor” sometimes to try to have a less morbid spin; the number of people who would win the lottery and quit working. That doesn’t quite feel appropriate for open source projects done by volunteers, because potentially those people would not stop working on a project just because of petty concerns like winning the lottery (lol).

I can't stop vibe-coding

Tue, 28 Oct 2025 00:00:00 +0000

I just keep vibe coding. I don’t think I’ve written about this on my blog before but I was diagnosed with classical hodgkin’s lymphoma (CHL) in late June and have been on medical leave basically since then doing ABVD chemo¹. I want to write a post on that at some point (and PET scans, medical imaging is pretty cool), but the relevance for this post is that (1) I have kind of a lot of time, (2) sometimes a strong need for escapism, and (3) sometimes I am kind of out of it². I had infusion 5 on October 17 (hopefully second-to-last), and after an infusion I’m kinda out of it, but also pretty nauseous and can’t watch movies or tv or play games because the moving images trigger nausea. Turns out, vibe coding is pretty great though. You can turn off your brain and let the robot make something interesting at your direction, with only a bit of text moving around on the screen.

valuetier.org (and some thoughts on LLMs)

Sun, 05 Oct 2025 00:00:00 +0000

Note: the first half of the blog post documents my experience and takeways making valuetier.org, a webapp for helping users (or specifically, me) identify their values. The second half is more of a personal exploration of my thoughts & feelings about LLMs.

ValueTier.org (& “vibecoding good”)

I’ve been doing some Acceptance and Commitment Therapy (ACT) and have found it pretty helpful. One of the components is to identify your values, so that you can align your actions to your values. My therapist suggested I search online or use ChatGPT to find a list of 100 human values, then group them into categories “very important”, “somewhat important”, “not important”, and try to narrow down to 8-12 “very important” values to focus on. That sounded a lot like a tier list, so I searched online to see if there would be a nice ergonomic privacy-conscious tool to use, but I didn’t find one I liked, and I decided to make a webapp to do so. A few days later and thanks to the magic of code-generating LLMs, I have https://valuetier.org/ (code: https://github.com/ericphanson/value-tier).

Julia's package registration tooling

Sun, 27 Oct 2024 00:00:00 +0000

Julia has a large ecosystem of over 10,000 registered packages in it’s “General” open-source package registry.

Package registration is mostly automated, but it can be hard to understand how all the various bits fit together. There are some helpful resources and tutorials on how to create and register a package, such as

and I won’t provide a step-by-step tutorial here. Instead, I aim to provide a point-in-time snapshot of many of the different pieces of tooling currently used in the Julia package registration system, and explain how they work together. I will also try to mention how they can be applied to alternative registries beyond General.

Why you might avoid `deepcopy` in Julia

Sun, 21 Jul 2024 00:00:00 +0000

Why use `deepcopy`?

In Julia, copy is a function which creates a shallow copy. For example:

julia> a = [1] # vector with one element, namely 1
1-element Vector{Int64}:
 1

julia> b = [a] # vector with one element, `a`
1-element Vector{Vector{Int64}}:
 [1]

julia> b2 = copy(b) # new vector, also with one element which is `a`
1-element Vector{Vector{Int64}}:
 [1]

julia> push!(a, 2) # mutate `a` so it contains 1 and 2
2-element Vector{Int64}:
 1
 2

julia> b # since `b` contains `a`, we can see its (nested) contents have changed
1-element Vector{Vector{Int64}}:
 [1, 2]

julia> b2 # same for `b2`!
1-element Vector{Vector{Int64}}:
 [1, 2]

Since copy is shallow, b2 still contains the same vector a (whose contents we modified to be [1,2]), just like b, even though they are independent vectors which do not share memory:

Learning algorithmic techniques: dynamic programming

Sun, 10 Nov 2019 00:00:00 +0000

Three nice techniques

In the past months, I’ve found myself really appreciating some nice techniques for constructing algorithms. These are probably quite familiar to those with a computer science background, but are new to me. There are three in particular that I have in mind; I’ll just highlight the first two here, and then discuss the third in detail.

The first such technique I learned about was solving the traveling salesman problem via mixed-integer programming, using lazy constraints. In essence, you encode a solution to the traveling salesman problem (a tour) as a permutation (of the cities to visit), which you represent with a binary matrix. Then you minimize the cost of the tour over all permutation matrices. The difficulty is that this can yield “tours” that don’t aren’t full cycles: a permutation of \((1,2,3,4)\) could be \(1\) goes to \(2\), \(2\) goes to \(1\), \(3\) goes to \(4\), and \(4\) goes to \(3\). That’s actually just two transpositions instead of a single cycle of all the cities. So instead, one needs to rule out all the permutations that aren’t cycles. However, there doesn’t seem to be a good way to do that; one could impose exponentially many linear constraints, one for each non-full-cycle, for example, but that would be very inefficient (if you can even fit them all into memory). But what you can do is solve the problem without such constraints, and then just add constraints corresponding to any non-full-cycles that you obtain in the solution. Then you re-solve the problem. That way, you only need to impose the constraints that actually matter (which usually is far fewer than the total number of constraints). I thought this was really cool! I learned about it from the blog post MIP - Travelling Salesman by Ole Kröger. To explore it for myself, I wrote a Julia package TravelingSalesmanExact.jl to use this technique for solving the problem (using JuMP.jl). In fact, shortly after coming across this approach to the traveling salesman problem, I realized that I could use the same technique to find good upper bounds on an optimization problem that came up in my research (that project is still in progress, so I won’t go into details here).

When do we lose correlations under Markovian evolution?

Fri, 22 Mar 2019 00:00:00 +0000

⊕ This post started as a talk for the CCIMI retreat, the slides of which are available here. But I added a lot of words to turn this into a blog post, so I encourage you to stay here instead!

Consider the following divided box with \(N=20\) particlesA discrete-time Ehrenfest model

.

At each time step, exactly one particle jumps from one side of the box to the other. The more particles there are on one side, the more likely one will jump away from that side. Let us think of this as a joint system, the state of which is the number of particles on each sideWe won’t consider positions, velocities, etc.– just how many particles are on each side

. This is a perfectly correlated system: if there are \(n\) particles on the left, there are exactly \(N-n\) particles on the right. So we can exactly figure out the state of the right side of the box only knowing the state on the left side.

Another example of using type domain information in Julia

Sat, 09 Mar 2019 00:00:00 +0000

In a previous post, I discussed using type domain information to speed up generation of random density matrices with small dimension in Julia. There, we gave the Julia compiler knowledge of the dimension of the matrices at the time it generates code, instead of passing that dimension as a runtime variable, and saw significant runtime speedups as a consequence. This time, let’s push this further by giving the compiler a whole vector of numbers instead of a single integer.

Carathéodory's theorem and the Holevo capacity

Tue, 18 Dec 2018 00:00:00 +0000

Let \(\Lambda: \mathcal{B}(\mathcal{H})\to \mathcal{B}(\mathcal{H})\) be a quantum channelcompletely positive and trace-preserving map

on a finite-dimensional Hilbert space \(\mathcal{H}\), and let \(d:= \dim \mathcal{H}\). The Holevo capacity of \(\Lambda\) is defined as \[ \chi(\Lambda) := \sup_{\{p_k, \rho_k\}} \left[ S\Big(\sum_k p_k \Lambda(\rho_k)\Big) - \sum_k p_k S( \Lambda(\rho_k)) \right] \] where supremum is over ensembles of quantum states \(\rho_k\) and probability distributions \(\{p_k\}\). The HSW theorem (Holevo 1998; Schumacher and Westmoreland 1997) states that the product state classical capacity of a quantum channel \(\Lambda\) is given by its Holevo capacity, thus providing the quantity with an operational meaning. It is well known that that the supremum may be restricted to ensembles of at most \(d^2\) pure states; in fact, this is exercise 12.11 in the classic textbook (Nielsen and Chuang 2009).

Fast small random density matrices

Sun, 23 Sep 2018 20:07:42 +0000

Update (19 January 2019): I looked at this code again, and realized I had made a few basic mistakes, such as constructing a statically sized normally-distributed random matrix via SMatrix{d,d,Float64, d*d}(randn(Float64, d,d)) which constructs a random matrix (allocating memory dynamically) and then converts it to a static SMatrix, instead of randn(SMatrix{d,d,Float64}) which directly constructs an SMatrix without dynamic memory allocation. I also hadn’t written the function randsimplexpt in a very good way. I’ve updated the code in the post with these improvements; the static versions of the methods are now allocation-free and twice as fast, in some cases.

Website rewrite

Sat, 25 Aug 2018 19:26:42 -0400

I decided to redo my website using Hugo (before I was using Jekyll). Both are static site generators: you write in Markdown, a simple clean formatting language, and it generates HTML webpages following a consistent format. It’s great because the generation only has to occur once after the Markdown is written, and nothing active has to happen for each user of the website (unlike a so-called dynamic website). This reduces costs, increases reliability, and improves securitythe user needs very little access to the server hosting the webpages in a static site

. The problem I was having with Jekyll was that it was taking about 40 seconds to generate the site, which meant that if I wanted to make a small change and see how it looked, I had to wait for it to generate to see the result (like a long LaTeX compilation). Hugo is super fast; my site takes less than a second to generate fully now.

Locally maximizing the Rényi entropies

Sat, 25 Aug 2018 00:00:00 +0000

As I was rewriting my website, I found some visualizations I had stored on my old website to show a collaborator, and I figured it was worth writing a little to have a more proper place to put them; hence this post 😊.

Probability distributions on three letters consist just of three non-negative numbers which add up to 1, which we can see as a vector in \(\mathbb{R}^3\). The set of all such distributions form a simplex, which looks like a 2D triangle laying in \(\mathbb{R}^3\):

How to make an index in LaTeX

Wed, 20 Jun 2018 00:00:00 +0000

I’m sure there are many ways to make an index in LaTeX, but I was asked this question recently and thought I’d put my response here, which is based on what I did in my combinatorics notes.

In the preamble, make a command \defw (short for “define word”), use the package imakeidx, and call \makeindex:

\usepackage{imakeidx}
\usepackage{xparse}
\NewDocumentCommand{\defw}{m o}{%
 {\emph{#1}}%
 \IfNoValueTF{#2}
 {\index{#1}}
 {\index{#2}}%
}
\makeindex

Generate the index at the end of the file with \printindex, like one does with a bibliography.

arXiv-search (the sad goodbye-for-now post)

Mon, 14 May 2018 00:00:00 +0000

Update (26 January 10): The source code is now available under a MIT license at https://github.com/ericphanson/arxiv-search.

For a few months, I and a few others were working on a project we called “arxiv-search”, an attempt to search and sort all of the arxiv (~1 million papers). We were inspired by Andrej Karpathy’s arxiv sanity preserver which is an excellent tool for a limited set of papers (~50,000). Starting from that project, we ended up writing a new backend and frontend. Our backend used elasticsearch which is a large scale search engine which runs constantly on a big server, indexing metadata and responding to search requestsIn fact, the arxiv itself very recently started using elasticsearch to improve their own search results.

. The original arxiv-sanity implementation kept the metadata for all the papers in the server’s RAM which limits how many papers can be hosted; the idea was that elasticsearch can scale far better, as well as perhaps do more sophisticated searching efficiently. Our frontend was written by my officemate Ed Ayers in react.js, and was responsive and useful. Our ambitions expanded; we set up an AWS Lambda pipeline to process new papers (get the metadata, generate thumbnails, scrape the text), which we hoped to include semantic elements (parse definitions and theoremsLars Mennen wrote a nice python script to work on this task.

, etc), and to generate recommendations for our users.

A synchronized dance of eigenvalues

Tue, 26 Sep 2017 00:00:00 +0000

The motivation behind this post is to show some off some nice gifs. But I thought maybe they aren’t actually interesting without any context, so below I’ll try to explain what the gifs are about.

Perceptron demo

Wed, 19 Jul 2017 00:00:00 +0000

A javascript demonstration of the perceptron algorithm, written for a reading group session. This was originally a separate webpage, but when I rewrote my website I decided to make it a blog post. This post can still be reached from /perceptron-demo, though.

Perceptron

Perceptron is a very simple binary classification online learning algorithm, dating from the 1950s¹. Such an algorithm tries to classify input (here, points in the plane) into one of two categories. It receives the correct answer each time, and aims to minimize the total number of mistakes compared to a hypothesis class. Here, the hypothesis class is the set of halfplanes. Perceptron thus aims to perform as well at classifying the input points as any halfplane, which simply assigns points to one category if they are in the halfplane, and to the other if they are out of the halfplane. In the so-called realizable case, the true classifications really do come from a halfplane in this manner. Even in the realizable case, there is no online classification algorithm which can be guaranteed to make only finitely many mistakes given an infinite stream of inputs, even if all the points lie within some radius R of the origin².

The arrow of time in RIS

Wed, 18 Jan 2017 21:09:03 +0000

Repeated interaction systems (RIS)
Introduction to arrow of time
A more careful description of the forward and backward processes
Hypothesis testing on the arrow of time
Connection to Landauer’s Principle

I gave an informal talk today on the arrow of time in repeated interaction systems and I thought I’d write about it here.

The traveling salesman and 10 lines of Python

Tue, 25 Oct 2016 00:00:00 +0000

Update (21 May 18): It turns out this post is one of the top hits on google for “python travelling salesmen”! That means a lot of people who want to solve the travelling salesmen problem in python end up here. While I tried to do a good job explaining a simple algorithm for this, it was for a challenge to make a progam in 10 lines of code or fewer. That constraint means it’s definitely not the best code around for using for a demanding application, and not the best for learning to write good, readable code. On the other hand, it is simple and short, and I explain each line. So stick around if you’re up for that. Otherwise, while I haven’t used it myself, Google has a library “OR-Tools” that has a nice page about solving the travelling salesmen problem in python via their library. So maybe check that out!

Setting up SublimeText

Fri, 14 Oct 2016 00:00:00 +0000

I’m setting up a new laptop and figured it was a good chance to document setting up SublimeText for LaTeX, as quasi follow up to my recent post about live LaTeXing. However, installing LaTeX can be hard, and configuring the SublimeText package LaTeXTools to work with LaTeX has the potential to be hard (often just works, but if not, can be confusing), and I won’t write about those parts, because they are better documented elsewhere. So this is simply the easy part (configuring SublimeText) to try to remove a barrier from those who might be looking to switch.

Live notetaking with LaTeX

Sat, 24 Sep 2016 00:00:00 +0000

A friend suggested I write a guide about live notetaking in LaTeX, since it’s pretty useful and something I have a fair amount of experience with. I had been making attempts at live-LaTeXing course notes for a year or two before I was able to make it through a semester long class; the first course I fully LaTeX’d was Vojkan Jaksic’s excellent Analysis 3 (introduction to metric spaces and topology)PDF. Not my best work, but it did the job.

. Most recently, I wrote notes for Sergey Norin’s Combinatorics course which I submitted as a project for the classPDF, source. Probably my best work.

.

Landauer's Principle and the balance equation

Mon, 29 Feb 2016 21:50:00 +0000

I’ve been working on my thesisEdit: this was my master’s thesis

over reading week, and I think I’ve finished my introduction to Landauer’s Principle. I ended up writing a pretty detailed derivation of the balance equation, and thus Landauer’s bound, so I thought it might be useful to post here.

Landauer's principle states that there is a minimal energetic cost for a state transformation \(\rho^\text{i}\to \rho^\text{f}\) on a system \(\mathcal{S}\) via the action of a thermal reservoir \(\mathcal{E}\) at temperature \((k_B\beta)^{-1}\)⊕ \(k_B \approx 1.38 \times 10^{-23}\) Joules per Kelvin is Boltzmann's constant.

. In particular, if \(\Delta S_\mathcal{S}\) is the change of entropy of the system \(\mathcal{S}\), and \(\Delta Q_\mathcal{E}\) is the change in energy of the reservoir \(\mathcal{E}\), then \[ \Delta Q_\mathcal{E}\geq \beta^{-1}\Delta S_\mathcal{S}. \qquad(1)\] This principle has generated interest since its inception in 1961; see [Section 1, RW14]⊕ [RW14]: An improved Landauer Principle with finite-size corrections, D. Reeb and M. Wolf, 2014 (v3).

for a recent summary. First, the bound has allusions to practicality: perhaps the energy efficiency of our computers will be limited. For changing the state of a classical or quantum bit however, the bound is at most \[ \Delta Q_\mathcal{E}\geq k_B\cdot T \log 2 \approx (9.6 \times 10^{-24} J/K)\cdot \] which is extremely small for reasonable temperatures \(T\); yet, modern processors are within several orders of magnitude of this limit, as shown in Figure 1.

Cantor's set and function

Tue, 09 Feb 2016 00:00:00 +0000

Cantor’s Set
- Construction
- Properties
Cantor’s function

I wrote these notes in February 2016 for an Analysis 2 tutorial when I was a teaching assistant at McGill, and always intended to put them here eventually; before August 2018 though, I hadn’t translated them to something web-friendly and only had posted a PDFThe web version has slightly improved wording in some parts.

.

Cantor’s Set

Cantor’s set is an interesting subset of \([0,1]\), with properties that help illuminate concepts in analysis. It can often serve as a counter-example or edge-case on which to test ideas, and to construct further unusual objects; one such object is the Cantor function, which we’ll define here as well. To me, one of the most immediate clarifications provided by the Cantor set is the idea that looking at on object in different ways yields different notions of size, and these do not have to play nicely with each other. As we will see, the Cantor set is nowhere dense, yet uncountable.

Completeness I

Fri, 01 Jan 2016 00:00:00 +0000

Last semester, I helped a friend review McGill’s Analyis 3 course by trying to provide a better feel for completeness; this post will be a slightly edited version of that. Originally, I wanted to write about both completeness and compactness, and their connections, but I ended up only getting to completeness, and actually not everything I wanted to talk about. So I’ll call this Completeness I, leaving open the possibility for more of these in the future. Hopefully the style is casual and expository without being misleading.

New blog

Mon, 14 Dec 2015 00:00:00 +0000

I’ve made a new blog!

I started a “coffee blog” a month or so ago but only posted once (I think I’ll bring that post over here, too). I do like the idea though, and want to write about math and my research. So this should become a place for me to do that.

Part of my impetus is that journals and traditional publication methods don’t provide a pathway for discussing failed attempts. And I think on a global scale, that can slow down progress — it’s useful to know what has been tried and why it failedOf course, we must avoid groupthink

. It seems to me that some mathematicians are beginning to use blogs as an informal publication method, one in which partial progress or a lack of progress can be reported and discussed.

Blog posts on EPH

Costa Rica photos

LibImageQuant.jl

Birb Stalker (2021)

Counting short package names

Introduction

Thoughts on being a package registry maintainer

Introduction

Bus factor 0

I can't stop vibe-coding

valuetier.org (and some thoughts on LLMs)

ValueTier.org (& “vibecoding good”)

Julia's package registration tooling

Why you might avoid `deepcopy` in Julia

Why use deepcopy?

Learning algorithmic techniques: dynamic programming

Three nice techniques

When do we lose correlations under Markovian evolution?

Another example of using type domain information in Julia

Carathéodory's theorem and the Holevo capacity

Fast small random density matrices

Website rewrite

Locally maximizing the Rényi entropies

How to make an index in LaTeX

arXiv-search (the sad goodbye-for-now post)

A synchronized dance of eigenvalues

Perceptron demo

Perceptron

The arrow of time in RIS

The traveling salesman and 10 lines of Python

Setting up SublimeText

Live notetaking with LaTeX

Landauer's Principle and the balance equation

Cantor's set and function

Cantor’s Set

Completeness I

New blog

Why use `deepcopy`?