Patrick Van der Spiegel's Posts

Your work is not just content

Fri, 06 Feb 2026 00:00:00 +0000

Social media platforms provide value to independent creatives by allowing them to fully focus on creating instead of having to figure out how to share their work. Sadly, however, these same platforms reduce creative artists to content creators. When we label artwork — be it short- or long-form writing, illustration, photography, music, or video — as content, we turn unique works into interchangeable slop for consumption by users. I believe that the corporate web’s focus on user engagement plays a large role in this degradation, and that the independent web might offer a solution.

Keep reading at Good Internet!

Visualising Order in Sequences

Tue, 13 Jan 2026 00:00:00 +0000

Sequences

Linear Order

In a sequence, each element directly follows at most one element and precedes at most one other, forming a linear chain. We can visualise this through nodes of directed graphs that are connected using directed edges that represent the linear order between consecutive elements.

The English word “sequence” (which is an ordered sequence of the eight consecutive elements s, e, q, u, e, n, c, e), for example, can be visualised using a directed graph:

Full sentences can also be seen as sequences of ordered symbols. As an example, we have the sentence “This is a visualisation of linear order”. Spaces are also considered elements of the sequence, but we slightly reduce the opacity of their nodes for readability:

We can drop the node labels to visualise the same sentence as:

Order in sequences matters, and these sequences are not restricted to written language. Other examples include sequences of actions (e.g., the sequence of actions that you perform to pour yourself a cup of coffee, as you can’t brew coffee before turning on the machine) or music (e.g., the consecutive notes that make up a specific melody, as swapping the notes around gives us another melody).

Hierarchically Nested Matchings

Many structures also have a natural hierarchical organisation (e.g., we can group words into sentences, paragraphs, sections, and so on). For this reason, we also want a way to describe and visualise hierarchical structure.

This is the visualisation of the linear order in the sequence “nested word”:

We know that the sequence “nested word” can naturally be split into two contiguous subsequences: “nested” and “word”. If we add symbols “⟨” and “⟩” that respectively denote the start and end of a word, we get the following:

We name the “start of a word” a call position and “the end of that same word” its matching return position. All other elements are internal positions. These matches give rise to different nestings.

We represent call and return positions using differently-coloured nodes, and represent matches using dashed directed edges from nodes representing call positions to nodes representing matching return positions:

Nested Words

More formally, a nested wordNested Words - Rajeev Alur is a sequence of elements $w = s_{1} \ldots s_{\ell}$ together with a matching relation, which is a set of matches $i \rightsquigarrow j$ that connect call positions $i$ to their return positions $j$.

For all matches $i \rightsquigarrow j$:

Nestings only go forward: $i < j$

No two nestings share positions: $|\{ i \mid i \rightsquigarrow j \}| \leq 1$ and $|\{ j \mid i \rightsquigarrow j \}| \leq 1$

No two nestings cross: if $i \rightsquigarrow j$ and $i’ \rightsquigarrow j’$, we cannot have $i < i’ < j < j'$

Visualising Nestings

If we visualise “this is a visualisation of linear order”, we get:

Trying out different graph layouts, we get:

Visualising the palindromic phraseList of English palindromic phrases - Wikipedia “⟨⟨⟨Lived⟩ ⟨on⟩ ⟨decaf⟩;⟩ ⟨⟨faced⟩ ⟨no⟩ ⟨devil⟩.⟩⟩”, for example, gives us some nice symmetries (as we have two groups, each with three words, that each respectively have five, two, and five elements):

Nested Substitution Rules

Reading through Stephen Wolfram’s ruliology, I wondered what kind of nested structures we could obtain using simple substitution rules (like repeatedly changing internal positions labelled a with a nesting ⟨aaa⟩).

Example #1

Initial Condition

Replacement Rule

a → ⟨aaa⟩

Looping Visualisation (6 steps)

Example #2

Initial Condition

ab

Replacement Rule

a → bb
b → ⟨aa⟩

Looping Visualisation (9 steps)

Visualising this post

Finally, we can apply nested word visualisation to this post itself by treating the post’s structure as a nested word:

Scrambled Stations

Fri, 08 Aug 2025 00:00:00 +0000

Scrambled Stations

August 8, 2025

Gehusselde stationsnaam (NS)

The Dutch NS railway operator has the “gehusselde stationsnaam” game on their on-board train information displays: a puzzle where you have to figure out the hidden train station through an anagram of that station’s name. These puzzles are also on their Instagram page: the puzzle “Los Pichor Pathir”, for example, matches the Schiphol Airport railway station when unscrambled. As I barely know any Dutch railway station names, I was curious if something similar was feasibile for Belgian railway stations using Flemish dialect words.

Retrieving wordlists

We first retrieve two wordlists: a list of Belgian railway stations, and a wordlist of Flemish dialect words. Afterwards, we use these wordlists to figure out if there are any single- or multi-word anagrams of one wordlist inside the other.

Belgian railway stations

There’s a complete list of Belgian railway stations available on GitHub, maintained by iRail. We can curl the stations.csv file from that repository.

curl --output railway_stations.csv \ 
https://raw.githubusercontent.com/iRail/stations/refs/heads/master/stations.csv

This list of railway stations also contains lots of non-Belgian (often Dutch, German, and French) stations, which I assume are included as they are reachable by train from Belgium. We can filter out these non-Belgian stations using the country-code column.

$ xan filter 'col("country-code") ne "be"' railway_stations.csv | \
 xan select 'name,country-code' | \
 xan view -l 5

┌───┬─────────────────────┬──────────────┐
│ - │ name │ country-code │
├───┼─────────────────────┼──────────────┤
│ 0 │ 's Hertogenbosch │ nl │
│ 1 │ Aachen Hbf │ de │
│ 2 │ Agde │ fr │
│ 3 │ Aime-la-Plagne │ fr │
│ 4 │ Aix-en-Provence TGV │ fr │
│ … │ … │ … │
└───┴─────────────────────┴──────────────┘

Belgian railway stations sometimes have both a Dutch and French name. These names are mostly similar (like “Brussel-Centraal” in Dutch and “Bruxelles-Central” in French), but sometimes completely different (like “Diesdelle” and “Vivier d’Oie”). For railway stations in Brussels, these variants are separated by a slash in the name column of our CSV.

$ xan filter "'/' in col('name')" railway_stations.csv | \ 
 xan select "name" | \
 xan view -l 5

┌───┬────────────────────────────────────┐
│ - │ name │
├───┼────────────────────────────────────┤
│ 0 │ Arcaden/Arcades │
│ 1 │ Boondaal/Boondael │
│ 2 │ Bosvoorde/Boitsfort │
│ 3 │ Brussel-Centraal/Bruxelles-Central │
│ 4 │ Brussel-Congres/Bruxelles-Congrès │
│ … │ … │
└───┴────────────────────────────────────┘

We filter out non-Belgian railway stations, select the names of the remaining stations, split these names on forward slashes so that we get both the Dutch and French name on separate lines where appropriate, and write these lines to a separate text file.

xan filter 'col("country-code") eq "be"' railway_stations.csv | \ 
xan select name | \ 
tr '/' '\n' > railway_stations.txt

Flemish dialect words

As far as I can tell, the “Flemish dictionary” does not provide a downloadable wordlist. They do, however, have a page per letter of the alphabet containing all words starting with that letter. Luckily, these letter pages follow the same structure and contain all words on a single page, so by looping through only 26 pages (one for each letter of the alphabet), we can extract all listed words using grep and sed.

for letter in {a..z}; do
 curl -s https://www.vlaamswoordenboek.be/definities/begintmet/$letter | \
 grep -o '<a href="/definities/term/[^"]*">[^<]*</a> <br />' | \
 sed 's/<a href="[^"]*">\([^<]*\)<\/a> <br \/>/\1/' >> flemish_wordlist.txt
done

Finding anagrams

We first look at how to find single-word anagrams—where single Flemish dialect words are anagrams of certain railway stations—using “alphabetic maps”. We pair sets of railway stations with their anagram set, for example:

{'Ternat'} = {'ratten'}
{'Drongen'} = {'gronden'}
{'Aalst'} = {'slaat', 'staal'}

Ratten 🐀

Afterwards, we look at possible ways of finding multi-word anagrams—where multiple words combine to make up an anagram. Some examples, of which "houten afritser" (“wooden playground slide”) is my favourite:

{'Athus-Frontiere'} = {'houten'} + {'afritser'}
{'Mechelen-Nekkerspoel'} = {'schoempelen'} + {'krekelen'}
{'Dave-Saint-Martin'} = {'mandataris'} + {'in vet'}
{'Mortsel-Deurnesteenweg'} = {'lutter'} + {'messe'} + {'onderwegen'}

Houten Afritser 🛝

Single-word anagrams

When alphabetically ordering all characters within words, two distinct words result in the same ordering only if they are anagrams of each other. In Python, for example:

>>> sorted("undefinability") == sorted("unidentifiably")
True

Thus, to find anagrams of Belgian railway stations in Flemish dialect words, we build two alphabetic maps: dictionaries that map ordered characters to a set of “intra-wordlist anagrams”.

from collections import defaultdict

def get_key(word):
	return "".join(sorted(filter(str.isalpha, word.lower())))

def group(words):
	groups = defaultdict(set)
	for word in words:
		groups[get_key(word)].add(word)
	return groups

with open('railway_stations.txt', 'r') as f:
 stations = set(line.strip() for line in f)
 grouped_stations = group(stations)
 
with open('flemish_wordlist.txt', 'r') as f:
 wordlist = set(line.strip() for line in f)
 grouped_wordlist = group(wordlist)

To obtain the keys of these maps, we turn all characters of the words lowercase and filter out non-alphabetic characters before sorting. We loop through the set of words from each wordlist and build two separate alphabetic maps. Using these alphabetic maps, we can look for anagrams within the wordlists themselves. It turns out, for example, that only two pairs of stations are anagrams of each other:

Mollem = Lommel

Diegem = Idegem

To find the “inter-wordlist anagrams”—which is what we were originally interested in—we look at the intersection of the keys between alphabetic maps. Every common key corresponds to pairs of anagrams:

for key in (grouped_stations.keys() & grouped_wordlist.keys()):
	grouped_stations[key], grouped_wordlist[key]

This results in the following set of single-word anagrams. (As there’s a small overlap between our wordlists, we also get a couple of trivial anagrams in return.)

Details

({'Jette'}, {'tetje'})
({'Temse'}, {'smete'})
({'Lierde'}, {'leider'})
({'Leman'}, {'lamen'})
({'Ternat'}, {'ratten'})
({'Kijkuit'}, {'kijkuit'})
({'Boom'}, {'boom'})
({'Godinne'}, {'doening'})
({'Bleret'}, {'bretel'})
({'Muizen'}, {'muizen'})
({'Asse'}, {'asse'})
({'Landen'}, {'landen'})
({'Weerde'}, {'weerde'})
({'Mol'}, {'mol'})
({'Geel'}, {'leeg', 'Geel'})
({'Sint-Niklaas'}, {'Sint-Niklaas'})
({'Drongen'}, {'gronden'})
({'Welle'}, {'welle'})
({'Ruisbroek'}, {'ruisbroek'})
({'Zele'}, {'zeel'})
({'Meiser'}, {'misere', 'remise', 'eremis'})
({'Spa'}, {'SAP', 'pas'})
({'Menen'}, {'menne', 'nemen'})
({'Lens'}, {'snel'})
({'Tielt'}, {'titel'})
({'Eupen'}, {'peune'})
({'Engis'}, {'signe'})
({'Eichem'}, {'chemie'})
({'Ekeren'}, {'ne keer', 'nekeer'})
({'Niel'}, {'lein'})
({'Manage'}, {'gemaan'})
({'Ronet'}, {'tenor'})
({'Lot'}, {'lot', 'tol'})
({'Essen'}, {'se-n-se', 'sense'})
({'Lobbes'}, {'belbos'})
({'Merode'}, {'moedre'})
({'Blankenberge'}, {'Blankenberge'})
({'Luttre'}, {'lutter'})
({'Lede'}, {'Deel', 'elde', 'leed'})
({'Wavre'}, {'verwa'})
({'Eine'}, {'eine'})
({'Tienen'}, {'ineten', 'tienen'})
({'Aalst'}, {'slaat', 'staal'})
({'Coo'}, {'C.O.O.'})
({'Mollem', 'Lommel'}, {'mollem'})
({'Simonis'}, {'simonis'})
({'Puurs'}, {'Pruus'})

Click to collapse

({'Jette'}, {'tetje'})
({'Temse'}, {'smete'})
({'Lierde'}, {'leider'})
({'Leman'}, {'lamen'})
({'Ternat'}, {'ratten'})
({'Kijkuit'}, {'kijkuit'})
({'Boom'}, {'boom'})
({'Godinne'}, {'doening'})
({'Bleret'}, {'bretel'})
({'Muizen'}, {'muizen'})
({'Asse'}, {'asse'})
({'Landen'}, {'landen'})
({'Weerde'}, {'weerde'})
({'Mol'}, {'mol'})
({'Geel'}, {'leeg', 'Geel'})
({'Sint-Niklaas'}, {'Sint-Niklaas'})
({'Drongen'}, {'gronden'})
({'Welle'}, {'welle'})
({'Ruisbroek'}, {'ruisbroek'})
({'Zele'}, {'zeel'})
({'Meiser'}, {'misere', 'remise', 'eremis'})
({'Spa'}, {'SAP', 'pas'})
({'Menen'}, {'menne', 'nemen'})
({'Lens'}, {'snel'})
({'Tielt'}, {'titel'})
({'Eupen'}, {'peune'})
({'Engis'}, {'signe'})
({'Eichem'}, {'chemie'})
({'Ekeren'}, {'ne keer', 'nekeer'})
({'Niel'}, {'lein'})
({'Manage'}, {'gemaan'})
({'Ronet'}, {'tenor'})
({'Lot'}, {'lot', 'tol'})
({'Essen'}, {'se-n-se', 'sense'})
({'Lobbes'}, {'belbos'})
({'Merode'}, {'moedre'})
({'Blankenberge'}, {'Blankenberge'})
({'Luttre'}, {'lutter'})
({'Lede'}, {'Deel', 'elde', 'leed'})
({'Wavre'}, {'verwa'})
({'Eine'}, {'eine'})
({'Tienen'}, {'ineten', 'tienen'})
({'Aalst'}, {'slaat', 'staal'})
({'Coo'}, {'C.O.O.'})
({'Mollem', 'Lommel'}, {'mollem'})
({'Simonis'}, {'simonis'})
({'Puurs'}, {'Pruus'})

Click to expand

Multi-word anagrams

Above, we only look at one-to-one mappings where a shuffling of one Flemish dialect word gives us a Belgian railway station name. What if we want to have a combination of two (or more) words that, when shuffled together, gives us a station name?

Bruteforce

A bruteforce approach to multi-word anagrams is straightforward: for anagrams of one word list that are made up of $n$ words of the other wordlist, we can take all unordered combinations of $n$ keys of one alphabetic map with replacement, combine them, and check if this combined key is present in the other alphabetic map:

from itertools import combinations_with_replacement as cwr

def combine_keys(*keys):
	return "".join(sorted("".join(keys)))

def n_agrams(n):
	keys = list(grouped_wordlist)
	for key in cwr(keys, n):
		word_sets = (grouped_wordlist[k] for k in key)
		if (combined_key := combine_keys(*key)) in grouped_stations:
			stations = grouped_stations[combined_key]
			print(f"{stations} = {list(word_sets)}")

For $n = 2$, we get 1078 different combinations:

Details

{'Diesdelle'} = {'dees'} + {'dille'}
{'Kapelle-op-den-Bos'} = {'bedelke'} + {'salonpop'}
{'Kapelle-op-den-Bos'} = {'poekele', 'poeleke'} + {'plonsbad'}
{'Kapelle-op-den-Bos'} = {'sloppel'} + {'bakendoe'}
{'Kortemark'} = {'karot'} + {'merk'}
{'Kortemark'} = {'krak'} + {'om ter'}
{'Kortemark'} = {'kram'} + {'kroet', 'krote', 'roket'}
{'Kortemark'} = {'kroam', 'kraom'} + {'trek'}
{'Kortemark'} = {'rakker', 'kraker'} + {'mot'}
{'Kortemark'} = {'ram'} + {'kroket'}
{'Landskouter'} = {'dals'} + {'konteur'}
{'Landskouter'} = {'dokteur'} + {'lans'}
{'Landskouter'} = {'duks'} + {'lantoer'}
{'Landskouter'} = {'dutsen'} + {'akrol'}
{'Landskouter'} = {'kadul'} + {'storen', 'roste(n)', 'rotsen'}
...

Click to collapse

{'Diesdelle'} = {'dees'} + {'dille'}
{'Kapelle-op-den-Bos'} = {'bedelke'} + {'salonpop'}
{'Kapelle-op-den-Bos'} = {'poekele', 'poeleke'} + {'plonsbad'}
{'Kapelle-op-den-Bos'} = {'sloppel'} + {'bakendoe'}
{'Kortemark'} = {'karot'} + {'merk'}
{'Kortemark'} = {'krak'} + {'om ter'}
{'Kortemark'} = {'kram'} + {'kroet', 'krote', 'roket'}
{'Kortemark'} = {'kroam', 'kraom'} + {'trek'}
{'Kortemark'} = {'rakker', 'kraker'} + {'mot'}
{'Kortemark'} = {'ram'} + {'kroket'}
{'Landskouter'} = {'dals'} + {'konteur'}
{'Landskouter'} = {'dokteur'} + {'lans'}
{'Landskouter'} = {'duks'} + {'lantoer'}
{'Landskouter'} = {'dutsen'} + {'akrol'}
{'Landskouter'} = {'kadul'} + {'storen', 'roste(n)', 'rotsen'}
...

Click to expand

For $n \geq 3$, however, things start to slow down drastically. This naive bruteforce approach could further be optimised through some tricks to disregard impossible candidates, but as $n$ increases this would be “mopping with the faucet running”, as we say in Dutch. For $n \geq 3$, we could use a specialised data structure.

Anatrees

An anatreeCharles Reams. 2012. Anatree: A Fast Data Structure for Anagrams. ACM J. Exp. Algorithmics 17, Article 1.1 (2012), 16 pages. https://doi.org/10.1145/2133803.2133804 is a directed edge-labelled tree that describes a set of words. Internal nodes of the anatree represent symbols of an alphabet, and the leaves represent subsets of the set of words. Edges are labelled with positive integers, including zero. Paths of nodes $n_1, \ldots, n_l$ from the root $n_1$ to a leaf $n_l$ along edges labelled with integers $e_1, \ldots, e_l$ arrive at a leaf $n_l$, representing the subset of words that contains exactly $e_i$ times the symbol $n_i$, for all nodes on its path.

One possible anatree for the same set of words {'odd', 'goo', 'dog', 'fog', 'loo'} as used in the original anatree paper, using an own implementation of anatrees and Graphviz

The anatree shown above is just one possible anatree for a certain set of words, as there is not just one anatree for a given set. You could have different strategies to pick which character a certain node represents, each resulting in a different anatree. To generate the figure used above, at every step of construction, the most frequently occurring but not yet considered character of the remaining set of words is used as the symbol for the next node. Creating the anatree for the Flemish wordlist resulted in a tree consisting of 172.210 nodes, if we use the least frequent character first. If we use the most frequent character first, we get 127.534 nodes. Other strategies might lead to further reduction of the size of the anatree.

One approach to find multi-word anagrams of one specific train station is starting with that station’s bag of letters and using it as a “budget” while traversing the anatree of dialect words. For a train station with two occurrences of the letter e, for example, we could explore paths that contain at most two e’s, subtracting “spent” e’s from our available budget. After reaching a leaf node on a partial budget, we could explore other paths with the remaining budget. If we are able to reach another leaf with that remaining budget, we have found a multi-word anagram.

I did not implement this multi-word anagram algorithm in the end, as I’m not sure on performance (you’d have to perform a lot of different anatree traversals to find multi-word anagrams, and there are a lot of different ways in which you could “spend” your budget). Exploring this idea already took a bit more time than expected, and I was happy with my $n = 2$ anagram list.

Side notes

Displaying anagrams

To display these anagrams (and eventually also the title of this post), I wanted to imitate the classic Belgian railway station name signs using CSS. Looking for the typeface, I landed on a 2017 thread on a Belgian train forum where a poster named Nadieeh found out that the Brussels-based graphic design studio Speculoos created Alfphabet, a digitised version of the typeface I was looking for. I ended up downloading the typeface from the osp.kitchen.

The FONTLOG.txt, which is included with a download of Alfphabet, also contains some typical Belgian history:

The Alfphabet family is based on the Belgian road signage called ‘Alphabet’ in French and ‘Alfabet’ in Flemish. It was introduced in 1945 by 3M system working for the Marshall plan after the end of the war. In 1975, it was replaced by the Swiss SNV fonts, but is still in used randomly by the Belgian railroad and Charleroi’s metro. In the early nineties, Pierre Huyghebaert was able to copy the original plates just before the split of the national office of the roads ‘Fond des Routes’ in three regional entities and the burial of the documents deep into regional archives.

Alfphabet FONTLOG.txt

For the background colour, I used a colour picker on a picture of an old railway station sign to end up with rgb(0, 33, 84), and with some trial and error managed to get a white rounded border to simulate old railway signage:

Alfphabet Typeface

Shortest stations

Going through the CSV of train stations with a friend, we were curious about the shortest name for a station in Belgium, which turns out to be Sy (part of Ferrières near the Ourthe river):

$ awk '{ print length, $0 }' railway_stations.txt | sort -n | cut -d" " -f2- | head -n 5

Sy
Ans
Ath
Aye
Coo

The Dutch Wikipedia page claims that Sy is the shortest name for a train station in the whole Benelux.

Bucket lists

I recently read Adam Aaronson’s "I Drank Every Cocktail" about how he managed to drink all “IBA official cocktails” spread over a couple of years; and I loved his story.

Based on his journey, I wonder how long it would take me to visit all Belgian railway stations. Not just passing the station by train, but to actually visit and take a picture with one of the station name signs.

$ xan filter 'col("country-code") eq "be"' railway_stations.csv | \ 
 xan count
 
578

Almost 600 stations spread over a couple of years is certainly not impossible, I guess. Who knows, maybe I’ll be able to post my own “I Visited Every Station” eventually!

Cryptmanteaux

Sun, 01 Jun 2025 00:00:00 +0000

I recently learned through Wikipedia and Wiktionary that the word electrocution is a portmanteau of electro- and execution.The New York Times hating the word electrocution, and Thomas Edison preferring alternative words like dynamort, are also some fun facts found on Wikipedia. This makes sense in hindsight, but it never clicked before that the -cution part of electrocution comes from execution. As I like short word puzzles (like Minute Cryptic and Connections), I wondered if there were any similar word games that use portmanteaux as their main mechanic.

In cryptic crosswords, you find words based on clues which themselves are kind of word puzzles consisting of a definition (typically at the start or end of a clue) and the wordplay (giving instructions on how to get the answer based on the clue). As an easy example clue, which I found online:

Error concealed by city police (4)

decrypting-crosswords

Here, “error” is the definition: we’re looking for an alternative word for “error”. The words “concealed by” indicate that the four-letter word we’re looking for is hidden inside the words “city police”. Other possible types of wordplay include anagrams, double definitions, homophones, and more (as seen on the Minute Cryptic guide.)

Combining portmanteaux, cryptic crosswords, and Connections gives us a word game where you need to find two related portmanteaux through four cryptic clues that describe four base words. By correctly matching pairs of base words, you find the two hidden portmanteaux. Try it out, and check the walkthrough afterwards!

Clue 1

Fast brake ruined morning meal. (9)

Clue 2

Dairy product makes one grin! (6)

Clue 3

Noon activity sounds like lunging. (8)

Clue 4

Sandwiches for German citizens. (10)

Find two portmanteaux: one with (9) letters and one with (13) letters!

Answer 1:

Answer 2:

Coming up with a name for this game, I found the made-up portmanteau of cryptic and portmanteau to be appropriate: “cryptmanteau”. I guess all ideas really are second-hand, as Googling this name returns a PDF file dating back to 2015, containing a game where you are given two cryptic clues for two words that form a portmanteau when combined.

Google search results for cryptmanteau, with one result: a pdf titled GALAXY WORD GAMES from the English Literary Society

The PDF linked above has some fun examples of the concept, like the one quoted below:

cerebrum puzzled Nabir (5)

fan in man I acknowledge (6)

GALAXY WORD GAMES (AV round)

The clues state that the first base word is a five-letter word related to “cerebrum”, and that it is an anagram (hinted at by “puzzled”) of the word “Nabir”, and the second word is a six-letter word related to “fan” that we can find “in” "man I acknowledge". Combining “brain” and “maniac” gives us the portmanteau “brainiac”.

Walkthrough

In the interactive example above, we are looking for two related portmanteaux of length 9 and 13, and we are given four cryptic clues for their base words:

Fast brake ruined morning meal. (9)

Dairy product makes one grin! (6)

Noon activity sounds like lunging. (8)

Sandwiches for German citizens. (10)

Solving these cryptic clues gives us:

Breakfast (morning meal that is an anagram of “fast brake”)

Cheese (exclamation when smiling for picture, also dairy product)

Lunching (noon activity that is a homophone of lunging)

Hamburgers (double definition: citizens of Hamburg, Germany + meat sandwiches)

Connecting the right base words gives us the two portmanteaux:

Breakfast + Lunching → Brunching (9)

Cheese + Hamburgers → Cheeseburgers (13)

Part of the fun is that you might not need to find all four base words from scratch; maybe one from each pair combined with the other clue and figuring out the common theme could be enough to connect the dots.

I’ll certainly be trying to come up with more cryptmanteaux in the future and posting them on my website; send me a message if you come up with some yourself!

"Using AI to Detect the Unusual"

Mon, 25 Nov 2024 00:00:00 +0000

This is an abbreviated transcript of my FARI “Happy Hour” talk titled “Using AI to Detect the Unusual”, held at BeCentral on the 25th of November, 2024. The slides I used during my talk can be found here. This transcript was created using OpenAI’s Whisper model and edited using GPT-4o.

Introduction

Tonight, I’m going to talk about how we can use artificial intelligence to detect the unusual. If I knew nothing about artificial intelligence, I would have three main questions regarding this title:

What is artificial intelligence and how do we use it in general?
What is the unusual, and how would we traditionally detect this without using artificial intelligence?
How would we then use AI to detect the unusual?

What is Artificial Intelligence?

Artificial intelligence (AI) is a field of research. It is a subset of mathematics and computer science, and it overlaps with philosophy and linguistics, depending on the specific subset of AI being studied. This interdisciplinary nature makes it a fascinating field because you often collaborate with a diverse group of people across various domains.

AI has been researched since the 1950s, and although we’ve heard a lot about it in media recently, the increase in computing power over the last few decades has enabled us to perform remarkable tasks based on the research conducted during this time.

Examples of AI Applications

I have some examples of how we use artificial intelligence:

Search:
- In 1996, an AI algorithm named Deep Blue managed to beat the world chess champion, Garry Kasparov.
- More recently, AlphaGo competed against the second-best player in Go, a game with greater complexity than chess. For those who haven’t seen it, I recommend the excellent documentary about it.
- Day-to-day applications like Google Maps and Waze help you navigate from point A to point B in the most efficient way possible. You might not think of this as AI, but it results from extensive AI research.
Classification: If you have a large dataset containing labeled images of cats and dogs, for instance, you can use AI to assign the correct label to new images as they come in. Google offers “teachable machines” that allows users to train classification models using their webcam, requiring no programming experience.
Generative AI: Tools like ChatGPT for text generation and DALL-E for image generation have gained popularity recently. While impressive, it’s crucial to recognize that generative AI is not the only area of AI research. There are also significant studies in classification, search, and reinforcement learning, for example.

What AI Isn’t

Now that we’ve discussed what artificial intelligence is, it’s also important to clarify what AI isn’t.

First, AI isn’t about creating conscious machines, a notion often propagated in science fiction. While artificial general intelligence—AI with capabilities akin to human intelligence—is a goal for some researchers, most focus on narrow AI tasks. When companies vaguely claim they “use an AI” for significant goals, it raises red flags.

For example, it would be like a toothpaste manufacturer saying they used “a chemistry” to create better toothpaste—it doesn’t quite make sense. It’s important not to fall for the hype surrounding AI in the media. AI has nothing to do with Terminators or humanoid robots; it’s grounded in real-world applications.

Examples of AI Misuse

I’ve put together some examples of how AI can be misused:

The Smartschool Case: Smartschool is a platform where parents can communicate with their child’s teachers and access their test results. Recently, the company behind the platform announced plans to use AI to predict student dropout risks. This admirable goal (trying to reduce student dropout) was poorly executed, essentially reducing these students to test results and vaguely implementing AI in their product without public dialogue, leading to significant backlash.
Social Media Companies: Social media platforms are designed to maximize user engagement for profit through targeted advertisement. However, this focus can pose risks to younger users: vulnerable youth are presented with content that romanticizes self-harm, for example. Internal Facebook reports revealed that toxic content on Instagram negatively affects teenagers, but the company plays this down in public.
Dutch Child Care Benefit Scandal: Thousands of families in the Netherlands were wrongly accused of fraud when applying for child care benefits, based on algorithmic predictions. This led to severe financial hardships for these families, illustrating how false positives can have disastrous impacts.

Detecting the Unusual

Let’s now discuss the unusual and how we detect it.

Gathering Data

Everything around us—every process, system, or activity—produces data, which we can collect through observation and measurement. Here are some examples:

Health Monitoring: Tracking heart rate and blood pressure.
Financial Activity: Every transaction you make with a credit card—transaction date, time, location, and amount.
Social Network Activity: Actions like sending messages, making friend requests, and liking posts.

Understanding Anomalies

Anomalies are deviations from what we consider to be normal behavior, and these deviations leave traces in our observations. We are interested in understanding the underlying causes of these deviations. For example:

Health Monitoring: An ECG can show if you have arrhythmia, indicating an underlying health issue.
Financial Activity: If you generally conduct transactions in Belgium, an unexpected transaction from Nigeria would likely be labeled as anomalous.
Social Network Activity: You can have spam messages or friend requests, also classifiable as anomalies.

Anomalies vs. Outliers

It’s essential to distinguish between anomalies and outliers. Some sources claim they are the same, but this is misleading.

Traditional examples of anomalies often show high peaks and obvious outliers in time series data. However, context matters significantly in determining whether a data point is an anomaly. For instance, a large peak in time series data could be normal if it occurs at regular intervals, suggesting that context is critical.

Using AI to Detect the Unusual

Now that we’ve reached the point of understanding what anomalies are, we can discuss using AI for detecting these unusual patterns.

Anomaly Detection

Anomaly detection refers to finding patterns in data that do not conform to expected behavior. The goal of identifying anomalies is to alert domain experts that something deviates from the norm and to provide actionable information to address the situation.

For instance, in the medical field, detecting arrhythmia would alert healthcare professionals to investigate further.

The Role of Context

Detecting anomalies is highly context-dependent. While classification involves labeling items, anomaly detection focuses on recognizing deviations from expected patterns—often rare occurrences.

Traditional approaches to identifying anomalies are rule-based, which can be cumbersome and require constant updating. Relying solely on these rules may lead to missed anomalies or false triggers.

A Rule-Based Approach

If we would have a manual rule-based configuration for anomaly detection:

Some anomalies would be missed if predefined rules do not trigger: no rule for certain anomalies means that these anomalies go undetected
Rule-based trigger check on a “per event” basis, no “bigger picture”: context matters, and anomalies can involve multiple events
Expert time would be wasted on hard-coded rule design instead of tackling the root cause of anomalies

Challenges in Anomaly Detection

In my research, I previously focused on developing a pattern-based series framework. Instead of relying on hard-coded rules, my framework allows us to apply various AI algorithms to learn a model of normal behavior and test new data against it. However, challenges exist, including:

Complexity of Normal Behavior: Context and variation can make defining ’normal’ difficult.
Domain-Specific Definitions of Anomalies: Definitions of anomalies can vary significantly depending on the domain (e.g., cybersecurity vs. healthcare).
Ambiguity of Artifacts: Different events might present similarly in data, making it challenging to differentiate between normal and anomalous behavior.
Impact of Mistakes: Algorithms can produce both false positives and false negatives, leading to significant consequences.

Conclusion

In summary:

AI is a research field: It focuses on narrow tasks and is not about conscious machines.
Anomaly detection aims to identify unusual patterns in various domains. These patterns are often context-dependent deviations from what is deemed normal.
Algorithms can make mistakes, resulting in false positives and negatives that can have disastrous consequences.

Thank you all for your attention. Slides and transcripts are available on my website. If you have any questions, please feel free to ask. Thank you!

"Hell's Hex Station" Write-Up

Fri, 22 Nov 2024 00:00:00 +0000

In this write-up, I go over the step-by-step solution of “Hell’s Hex Station”, a challenge I created for the 2024 edition of Infogroep’s Capture the Flag.

Description

Mein Fraulein,
I haven't heard from you in a while. Won't you write me?

Solution

The title of the challenge is a reference to Rudolf Hell (inventor of the “Hellschreiber”), the hexadecimal system, and numbers stations. The description is a reference to a 2006 talk at DEF CON and also references the recurring German theme of this challengeThe “Mein Fraulein” description, Rudolf Hell being a German engineer, and the correct flag of this challenge containing a ß..

The provided .wav file starts with the tune of the “Lincolnshire Poacher” numbers station followed by a voice repeating "CP437" and ends with beeping. Using exiftool to look at the metadata of the audio file, we get the following output:

$ exiftool recording.wav

⋯
Comment : FELDHELL freq=14071.500
Software : fldigi-4.1.06 (libsndfile-1.0.28)
⋯

The Comment and Software values bring us to the solution of the challenge: the beeping that makes up the bulk of the .wav file is “Hellschreiber” in Feld Hell mode, a technique developed in 1927 by Rudolf Hell and currently in use by Ham radio hobbyists. Hellschreiber modes are based on character scanningFeld Mode: we transmit characters as patterns of beeps, resembling a dot-matrix printer.

As fldigi contains Feld Hell as one of their supported digital modes, we can use it to decode the beeping in our file. After installing and opening fldigi, we select the correct operational mode via "Op Mode → Hell → Feld Hell" and load our .wav file via "File → Audio → Playback".

In the waterfall view on the bottom of the fldigi window, we select the area that lights up when the beeping begins. Below, you can see a screenshot of the fldigi program, around a minute after loading the .wav file. A list of numbers in hexadecimal representation appear on screen:

A screenshot of the fldigi program, a minute after loading the provided .wav file. A list of numbers appeared on the screen.

49 47 43 54 46 7b 48 33 4c 4c e1 43 48 52 33 31 42 33 52 21 7d

In general, we could use a range of different tools to transform this list of hexadecimal numbers to a string of characters. The simplest way of doing this would be through CyberChef. After giving our list of numbers as input, we can pick the "From Hex" recipe (or choose “Magic” and provide IGCTF as the crib) to obtain the following output:

IGCTF{H3LLáCHR31B3R!}

This is not the correct flag, however! The provided .wav file specifically mentioned "CP437", which is a specific character encoding. Using Python (or any other tool that allows us to use CP437), we obtain IGCTF{H3LLßCHR31B3R!}, which is the correct flag:

>>> bytes.fromhex(hex_string).decode("cp437")
'IGCTF{H3LLßCHR31B3R!}'

Mindful use of LLMs

Tue, 24 Sep 2024 00:00:00 +0000

I believe large language models can bring value in use cases where they assist with tasks like summarising, translating, and reformulating text. I have previously used these models for some quick translation work, and I also started using the OpenAI API to help me summarise the contents of my clipboard through an Espanso shortcut.

Outside of summarising and translating texts, there are advantages for software developers as well. GitHub Copilot drastically reduces the time needed to figure out popular APIs and successfully assists in writing proper documentation, for example. These tools could increase both the speed of development, codebase quality, and consistency as long as developers understand, reason about, and ultimately agree with every generated line of code and comment before committing their changes.

I am also surprised about the quick adoption by a non-technical audience. LLMs would have seemed like magic to me only a couple of years ago, even though they are now commonplace—with friends and family members asking me to teach them “how to use ChatGPT” or enthusiastically telling me they already use it regularly. During a lightning talk on the risks of these models, for example, I asked the audience to raise their hands if they had already used ChatGPT in a professional setting. Almost everyone in the audience had done so recently.

Flip side of the coin

Assistance with writing and coding aside, I believe there is also a serious flip side of the coin. Overreliance and excessive use of this technology could degrade writing proficiency and programming skills. As Belgian universities allow LLM usage by their students, we urgently need to reform how we evaluate the quality of a student’s work now that we can’t rely on traditional assignments. I’ve learned a lot by struggling through my university classes’ programming projects, and I’m afraid I would have learned a lot less if I had easy access to software that completes my work for me.

Next, it is easy to misuse these models (not always out of malice, but also out of misunderstanding how the technology works) — applying them to use cases that range from wasteful but innocent to downright unethical and harmful. Consequences of this misuse include the pollution of the internet with slop and spreading misinformation (as some users do not realise that tools like ChatGPT are not a replacement for search engines and should not be trusted to return reliable information). Sadly, because of these consequences, the whole field of AI is getting backlash—even though the field itself is so much more than just generative AI.

As an example of unethical and harmful misuse, we have ZetaForge, a no-code tool to “rapidly build and deploy advanced AI pipelines”. The video linked above demonstrates how they use their tool to generate a textual description of war scenario images, on which they use a large language model to suggest a course of action to military personnel. In their own words, their demonstration pipeline “can be deployed as is, without any modification.” I’m not looking forward to a future where we rely on statistical models outputting As a large language model, I recommend opening fire. 🔫🤠 as a military strategy to ensure civilian safety.

Finally, the resources necessary to keep these models operational: a summary of a scientific paper — which I can perfectly write myself, albeit slower — is not worth the computing time, energy, and the bottle of water necessary to generate that summary. Combined with the fact that these models are trained on data without permission from artists and writers made me question my own use of these models in their current form.

Personal ethics

I have decided to stop using LLMs as a writing tool, as — personally — their downsides outweigh the benefits. Summarising text was my initial use case for LLMs, but I summarise text to internalise and learn from the material I am working with. In my case, summarising should take time. LLMs promise speed, but speed isn’t always desired.

I also previously used an LLM to help write a blog post for a small half-day project. I still believe I used the tool responsibly, in this case, as I only used it to rephrase or expand certain lines of text, using the output as an initial draft and not copying generated text verbatim. I also clearly indicated which text was written with assistance, even though most was still my own. However, I plan to never use LLMs for writing blog posts again: I strongly believe that if I don’t take the time to write a text, no one should waste their time reading it either.

I plan to put my money where my mouth is by taking the amount that I usually pay for API costs (which is only pennies, so I’m throwing in the price of a subscription to ChatGPT Plus) and donating it to a charity standing up for nature and biodiversity in my region. I know I am not making a dent by donating a small amount of money to a charity and mindful use of LLMs, but I am doing my best to align my actions to my values.

Notes from August

Thu, 05 Sep 2024 00:00:00 +0000

In August, after learning about the IndieWeb, I updated my website and turned it into this blog. It has been years since I did something web-related, and I always enjoyed tinkering on the web, so I am glad I took the time to try and rebuild my website. This month was my first time using Hugo, customising an existing theme to fit my needs. I also:

Automated the creation of daily notes on this blog using GitHub Actions
Created category filters for this blog using the :has selector in CSS
Pulled up-to-date statistics, like distance ran in a year — 418.2 kmData pulled from intervals.icu, and my current Tetra League ranking — 11126.88 TR (), using various APIs

In terms of other small projects,

I found new breakfast spots using Overture Places and duckdb,
Created a Pomodoro timer script that keeps track of my work in Obsidian,
Started learning the Rust programming language,
Looked into visualising Belgian roads,
Learned more about uv for Python

Writing daily notes

Initially, I aimed to write a daily note on this blog, sharing small personal projects or interesting things I encountered that day. After twenty consecutive notes, however, I started putting quantity before quality on days I did not feel like writing. If I did not enjoy writing a note, I am sure it isn’t pleasant for others to read that note either. I am still looking for how and when to best write and share short notes for “blogumentation”.

Blogs I enjoyed reading this August

Fabien Sanglard’s 0X10 RULES are great rules to follow when creating (small) websites. On that note, I also appreciated Justin Wong’s collection of “monospace webpages”, The Brutalist Report, and computer.rip.

Other blogs that I added to my RSS feed this month include Simon Willison’s Weblog, Sebastian De Deyne, Matt Hodges, Robin Rendle, Brad Barrish, anhvn.com, and James G.

Sharing daily notes

Wed, 07 Aug 2024 00:00:00 +0000

For my work, I picked up the habit of transferring my daily notes and insights from my physical notebooks to an Obsidian vault. Thanks to using Obsidian and git, I have a locally-stored, version-controlled, and easily searchable overview of my work that I can reference when preparing reports and presentations.

Equivalently, I miss a digital space where I can transfer personal insights, store interesting links and quotes, and write down notes unrelated to my work. Topics of these notes could include everything from programming, research, and literature, to physical exercise and ceramics.

Why make these notes public?

I could start a new Obsidian vault for these notes, but I think they should be someplace public as I want to “work with my garage door up.” I also want to keep up a daily writing streak: if I would just create another private Obsidian vault, it’ll be too easy to convince myself to skip writing to do other things instead. Public challenges like #100DaysToOffload seem appealing to participate in, as well.

We can write whatever we want on personal websites, without being vulnerable to tech companies and their social media algorithms + keeping ownership of content. I am currently hosting this website through GitHub Pages, but I can pack up my content and move it elsewhere whenever I want. Read more about this in this great article by Matthias Ott:

If you decide to publish your work on a platform like Medium, you’re giving away control over it. What if Medium suddenly decided to extend the already existing paywall to all articles? There’s not much you could do about it. Simply because you don’t own your content anymore.

Matthias Ott

But maybe the most compelling reason why a personal website (⋯) is incredibly valuable is this: community. Since the days of “guest books”, personal websites have been a place to receive feedback and discuss ideas and concepts with others. (⋯) Now imagine, for a moment, an environment where a decentralized fabric of connected personal sites allows everyone to publish their own content but also enables each individual to engage in an open discussion – answering, challenging, and acknowledging the ideas of others through this universe of personal sites.

Matthias Ott

To allow for this engagement, I’m planning to add Webmentions to this website soon.

By trying to write and publish a quick note every day, I’ll hopefully improving my writing. Not all of these notes will be polished, which is why I plan to keep them separate from my regular posts. It is okay to create unpolished things — a quote from Robin Rendle:

I feel like I’m free now to write absolute junk. And this is vital for any creative thing! You have to feel like your mistakes won’t be judged, that there’s no one watching you write shameful, embarrassing things. Because if you have all that pressure of trying to write the next great American novel then I reckon you’re destined to fail.

Robin Rendle

Hopefully, these notes give me inspiration to write some longer posts, where I can combine ideas and flesh out concepts of multiple related notes.

Writing streak

I currently have a writing streak of 0 daysUpdated on May 10, 2026, and my largest streak to date is 20 daysAchieved on Aug 27, 2024. You can find these daily notes here. To find the note for a corresponding date, go to /notes/YYYY-MM-DD. Each date since 2024-08-07 should have an existing entry, even if I did not write anything that day.

Obsidian.md, Espanso, and llm

Tue, 23 Jul 2024 00:00:00 +0000

I switched from Notion to Obsidian.md to keep track of meeting notes, to store highlights from scientific papers (using a Zotero plugin), and to maintain a knowledge base for my PhD research.

Obsidian and `llm`

To summarise or rephrase parts of notes and paper highlights, I often use OpenAI models through llm, a CLI utility that provides an easy way to interact with the OpenAI API. Traditionally, my workflow consisted of piping Markdown files from my Obsidian vault to llm, combining them with a system prompt that described the requested task.

cat papers/paper.md | llm -m 'gpt-4o' 
-s "Summarise the methodology described in the provided paper notes"

I then copied the model output from the terminal and pasted it in a custom callout that I specifically defined for LLM-generated content (as to keep it separate from my own writing), giving me a first rough draft that I can edit later.

.callout[data-callout="llm"] {
 --callout-color: 0, 100, 100;
 --callout-icon: bot;
}

A main disadvantage, however, is that I kept switching between Obsidian and the terminal to copy and paste model output. Another disadvantage was that I had no control over which lines from the relevant file to send to OpenAI when piping the full contents of a file to llmI am sure that there are plenty of ways to cat specific lines only given a file, but I assume for this you need to provide specific line numbers, making the process a bit more complex..

Obsidian and Espanso

Outside of tagging LLM output, I also use custom Obsidian callouts to highlight definitions, examples, and quotes from papers and textbooks. For this, I started using Espanso — a text expander that automatically replaces specific keywords with predefined text. This helps me avoid repeatedly typing callout boilerplate:

- trigger: ":def"
 replace: "> [!Definition] ⋯\n> ⋯"

- trigger: ":ex"
 replace: "> [!Example]- ⋯ \n> ⋯"

Every time I type :def — inside or outside of Obsidian — it replaces this keyword with the boilerplate that is needed to define a Definition callout in Obsidian. Other custom triggers include arrows (←, →), dots (⋯, ⋮), and dashes (—) that I use in notes, and abbreviations for commonly used words (all preceded by the : character, which I have reserved for Espanso keywords only).

Regex Triggers, Arguments, and Shell Commands

Regex triggers are an advanced alternative to regular triggers in Espanso. Instead of the static triggers shown above, these dynamic triggers provide flexibility through regex syntax and the use of named groups to pass arguments to expansions. The following two examples are taken from the Espanso documentation:

 - regex: ":greet\\((?P<person>.*)\\)"
 replace: "Hi {{person}}!"

We can also execute scripts and shell commands through Espanso:

 - regex: "=sum\\((?P<num1>.*?),(?P<num2>.*?)\\)"
 replace: "{{result}}"
 vars:
 - name: result
 type: shell
 params:
 cmd: "expr $ESPANSO_NUM1 + $ESPANSO_NUM2"

Expanding LLM Output

My initial goal was to create a new trigger — :llm(⋯) — that allows for the following workflow: copy the text that we want the LLM to work with to the system’s clipboard (so that we don’t have to pipe a full file), type the trigger with the system prompt in the parenthesis, and expand this trigger to the custom LLM callout in Obsidian (with the system prompt as title, and the output of the LLM as the body of the callout). The trigger :llm("Summarise the provided text.") would expand to:

> [!llm]- "Summarise the provided text." 💬
⋯ (→ Summary of text currently in clipboard)

Limitation of Regex Triggers

Regex triggers have a limitation where the maximum length of a regex match, including captured named groups, are restricted to 30 charactersRegex triggers - Espanso Documentation. This constraint is intended to enhance performance, but makes it harder to write an expressive system prompt.

To circumvent this issue, we can use an LLM to first write us a full-sized prompt based on one or two provided keywords (as to keep our trigger under 30 characters) that we can then feed to our main LLM.

We could do this in one call — asking to expand the prompt and then use this prompt to perform the task at hand — but this would make it harder to extract the expanded prompt for the title for our custom callout. Another approach would be to provide the callout boilerplate to llm, asking it to return the filled-in callout; but as API calls are cheap, we’ll go with the most straightforward approach:

- regex: ":llm\\((?P<userprompt>.*?)\\)"
 replace: "> [!llm]- \"{{prompt}}\" 💬\n⋯\n\n"
 vars:
 - name: prompt
 type: shell
 params:
 cmd: "echo $ESPANSO_USERPROMPT | llm -s
 \ 'Expand provided keywords to a short but effective, 
 \ imperative one-sentence prompt in UK English.
 \ The final output when using this prompt should be 
 \ short and to the point.'

For now, if we type :llm(explain to 5yo), we get the following in return:

> [!llm]- "Explain the provided text in simple words 
that a 5-year-old can easily understand." 💬
⋯

Passing Full-Sized Prompt

Now that we can circumvent our character limit and have access to our full-sized prompt, we just have to provide it to another call of llm. We can access the full-sized prompt by using the variable name in all caps, preceded by $ESPANSO_. I pass the output through sed — replacing newlines with the > character — as to make sure that everything sticks together in the final callout.

- regex: ":llm\\((?P<userprompt>.*?)\\)"
 replace: "> [!llm]- \"{{prompt}}\" 💬\n{{output}}\n\n"
 vars:
 - name: prompt
 type: shell
 params:
 cmd: "echo $ESPANSO_USERPROMPT | llm -m 'gpt-4o' -s
 \ 'Expand provided keywords to a short but effective, 
 \ imperative one-sentence prompt in UK English.
 \ The final output when using this prompt should be 
 \ short and to the point.'
 - name: output
 type: shell
 params:
 cmd: "llm -m 'gpt-4o' -s
 \ \"$ESPANSO_PROMPT.\" | sed -z \"s/\\n/\\n> /g\""

Final Espanso Trigger

The last thing we have to do is accessing our clipboard. We do this by creating a new variable inside our trigger,

- name: clipboard
 type: clipboard

and piping it to our final call to llm. The final Espanso trigger looks as follows:

- regex: ":llm\\((?P<userprompt>.*?)\\)"
 replace: "> [!llm]- \"{{prompt}}\" 💬\n{{output}}\n\n"
 vars:
 - name: clipboard
 type: clipboard
 - name: prompt
 type: shell
 params:
 cmd: "echo $ESPANSO_USERPROMPT | llm -m 'gpt-4o' -s
 \ 'Expand provided keywords to a short but effective, 
 \ imperative one-sentence prompt in UK English.
 \ The final output when using this prompt should be 
 \ short and to the point.'
 - name: output
 type: shell
 params:
 cmd: "echo $ESPANSO_CLIPBOARD | llm -m 'gpt-4o' -s
 \ \"$ESPANSO_PROMPT.\" | sed -z \"s/\\n/\\n> /g\""

Demonstration

Demonstration of LLM expansion

Automating Boggle

Sat, 06 Apr 2024 00:00:00 +0000

Last week, I had a conversation with a good friend in the spirit of the “Cult of Done” (valuing action over perfection, boldly experimenting and learning through doing) and sharing our work. Based on this conversation, I decided to get my hands dirty and attempt to create a quick and fun project, constraining myself to a couple hours of work on a Saturday morning. Key here is not worrying about perfection, but getting something out there quicklyAs the goal of this experiment was to move fast, this writing is assisted using GPT-4 through the OpenAI API. Everything with a highlighted background was first written with the help of an LLM using my instructions and provided information, and rewritten and tweaked afterwards to fit my writing style..

Thrifted Boggle

My girlfriend and I enjoy playing board and card games. Recently, we’ve picked up a copy of Boggle in a thrift shop. Boggle is a word game where you try to find as many words as you can from 16 dice, each with a different letter, that are shaken in a covered tray and then set in a $4\times4$ grid. Players get three minutes to find words that are at least three letters long, and each letter in the word has to touch the letter before it in any direction. Players are not allowed to use the same letter dice more than once in a word. Once time’s up, players compare their lists and any word that appears on more than one list gets cancelled out, with players scoring points based on the length of their unique words.

Boggle board

Our second-hand copy of Boggle has a couple of problems, however (excluding the fact that one of the dice was replaced by a Scrabble block by the previous owner). Our main problem is that the hourglass provided with our copy is broken, so we have to set up a smartphone timer. Other problems include:

Counting the points afterwards takes up a lot of time, especially if we want to confirm that our words are actually on the board
Confirming if a found word is an actual word takes time as well (as I love making up some plausible sounding Dutch words, looking them up in the dictionary, and claiming that I was certain that it exists if it’s not there.)

Project Goals

As I want to create something that both helps solve the problems above, but I also want to get something done quickly, the goal for this project is threefold:

First, create a Telegram bot that can:
- Receive a picture of the shaken tray of dice
- Start a built-in timer to know when the round starts and ends
- Count our points by confirming that our words are on the board and that the words themselves exist based on a (Dutch) dictionary
Next, I want to share my work using this blog post (in the spirit of the Cult of Done)
Do all this in a couple of hours on a Saturday morning (instead of enjoying the nice Spring weather like a normal person)

Implementation

I started with a planning, trying to come up with the necessary sub-tasks:

Recognising labelled dice from a picture, which we need to reconstruct the grid
Create a data structure that contains the allowed list of words
Algorithm that traverses the grid, finding all valid words
Create a Telegram bot that uses the above to act as a “referee”
Write the text (that you’re currently reading) whilst doing all of the above

Recognising labelled dice

As I am not that familiar with computer vision techniques, and I wanted to move quickly, my first attempt was to use GPT-4V, or gpt-4-vision-preview, to take a picture of the Boggle grid as input and retrieve the letters from that picture as a continuous string. If this would work out, I could quickly move to the other steps of the project. I used the following prompt:

Given the image of a 4x4 grid of Boggle dice, 
convert the letters visible on the dice into a 
continuous 16-character string by reading from left to right,
top to bottom. 

For example, if the top row contains the letters 'A', 'B', 'C', 'D', 
and the second row contains letters 'E', 'F', 'G', and 'H', etc., 
your output should be 'ABCDEFGH...etc', up to the 16th letter.

Keep in mind that letters could be rotated!

This failed miserably, however. The received output based on the image above (cropped to only display the grid of dice) was:

The continuous 16-character string from the Boggle dice 
is "INRAWMNBUDOVSOLO".

Afterwards, I lost an hour trying out different things with OpenCV and tesseract, but this did not seem to work out. As I still wanted to move quickly, I skipped this step and will rely on user input for the grid.

Recognising valid words

The trie is an efficient data structure for storing large word lists. The data structure itself can be seen as a finite state machine that only accepts words used for its creation. Each node of the trie represents a prefix, with the root as the empty string. Transitions between nodes adds characters to the prefixes. This offers quick search capabilities, therefore making it suitable for our project.

As I’ve recently had to create an implementation of tries for other work, I simply reused this for this project. The idea behind the construction algorithm is very simple: starting from the initial state, we check every symbol in each word. We follow transitions to states if they already exist, and create new states and transitions if they don’t. At the end of each word, we mark the last state as the final state.

def trie(sequences): 
 """Constructs a trie from given collection of sequences.""" 
 fsm = Automaton() 
 for sequence in sequences: 
 current = fsm.initial 
 for symbol in sequence: 
 if symbol not in fsm.alphabet: 
 fsm.add_symbol(symbol) 
 if (next_state := fsm.follow(current, symbol)) is None: 
 next_state = fsm.add_state() 
 fsm.set_transition(current, next_state, symbol) 
 current = next_state 
 fsm.accepting.add(current) 
 return fsm

words = {"tree", "three", "trie", "tried"}
automaton = trie(words)

automaton.accept("tree") # True
automaton.accept("tried") # True
automton.accept("thr") # False

show(automaton)

Example of the trie for set (tree, trie, three, tried)

For the dictionary of valid words, I relied on the OpenTaal wordlist, containing over 400k Dutch words. We can shorten this list significantly by filtering out the ones that are impossible to find in Boggle:

Words that contain something other than the letters from a to z
Words shorter than 3 letters or longer than 10 letters (as we’re usually never finding any words longer than 6, 10 is very generous)

In the end, we end up with a large trie that accepts all words from our Dutch wordlist.

Searching for words in a grid

If we have a string representing the grid as input (e.g., "NTAWIRIRNBDAOASO"), we can find all possible words by converting our grid into a graph, allowing us to utilize graph traversal algorithms to systematically search for potential word formations. This graph representation simplifies the problem into a more navigable structure where each dice is a vertex, denoted by its character. Edges between vertices are formed based on a dice’s spatial relation to its neighbours, indicating possible transitions or movements in our word formation process.

To find all words in the grid, we can perform a depth-first traversal starting from each dice, exploring as far as possible along each branch before backtracking. It is an ideal choice for our case here since we are interested in finding all potential paths that form words. Starting from each dice (or vertex), our DFT traces all unique paths devoid of cycles, while continuously inspecting the trie to confirm whether the traced path is leading to a valid word. We stop traversing further in a given path if the prefix is not present in the trie. This way, we retrieve all acyclic paths in the graph that have a path in the trie, and we don’t go deeper than necessary into the current path.

Telegram bot

Using the above, we can create a Telegram bot that uses the above to confirm our words and to keep track of our scores:

Screenshot of the Telegram chat with bogglebot

Users input their Boggle game board as a grid by invoking the /new command in a chat with the bot, and the bot generates a list of all possible words by simulating all possible paths in the grid. The bot will then confirm the start and the counter of the game. During the game, the users type in the words they find, and the bot checks if the word is valid (i.e., is in the list of possible words). If the word is valid, the user’s score is incremented according to the length of the word. The score and game updates are sent back to the user in the chat. The bot is built using the python-telegram-bot library, which allows easy interaction with the Telegram Bot API.

Possible Extensions

Given the flexibility of the implementation, there are various ways we could extend this project in the future:

Wordlist Variants: Depending on our mood or the challenge we desire, we could spice up our games by introducing different wordlists for specific themes. For example, a game could be based solely on palindromes, or we could introduce a Flemish dialect-based wordlist. The possibilities and variations are endless, making each game a fresh and exciting challenge.
Custom Time Counter: A part of the thrill of Boggle comes from the time pressure. We could experiment with this element by introducing a varying time or perhaps even a countdown whereby the time decreases each round, raising the stakes progressively.
Automatic Scoring: One of the main appeals of this project is that it removes the cumbersome task of manual point counting. This could be further extended to automatically keep track of our scores across multiple games or even different days. Thus, we could concentrate on the game at hand, while the bot takes care of the statistics and progress tracking.
Speed Chess Inspired Mode: Perhaps one of the most exciting possibilities would be to create a ‘speed chess’ inspired mode. Each player could have an individual clock, and you’d need to quickly spot and share a unique word to pause your countdown and switch turns. The game would then continue until someone’s time reaches zero. This offers the perfect blend of frantic quick-thinking, strategy, and suspense — a true test of one’s Boggle skills!

In the spirit of the “Cult of Done”, I have focused on quickly getting this project up and running first in a short amount of allotted time, before worrying about enhancements or delivering the perfect project.

Inferno CTF — Write-Up

Sat, 28 Dec 2019 00:00:00 +0000

In this short write-up, we will go over two challenges in the Misc category of Inferno CTF, which was hosted by Dc1ph3R. The challenges that we will discuss are “Color Blind” (which can be solved with a simple one-liner) and “Registering X” (which was a bit more complex). I completed these challenges with our CTF team, U+1F966.

In this challenge, we are provided with a PNG image with a resolution of $64 \times 1$. Running strings, binwalk, and foremost on the given file does not give us any useful information.

Looking closer at this image, we can see that each pixel has a specific colour. A teammate mentioned that the actual colours of the pixels could be the key to our flag. Each pixel has a colour code that can be expressed in RGB or in HEX. Stringing together all the HEX values is the key to obtaining our flag.

Opening an image, retrieving all the HEX values of the pixels, and stringing them together is a trivial task that can be done with a simple one-liner in the Julia programming language:

using FileIO, Colors
join(map(hex, load("colorblind.png")))

This works because images in Julia are simple arrays containing the RGB value of each pixel. We map the hex function (provided to us by Colors) over the color values, which returns an array with HEX values. We then join all the values together, which gives us the following string:

626C6168626C6168626C61685F68656C6C6F5F686F775F6172655F796F755F746F6461795F695F686F70655F796F755F6172655F6E6F745F646F696E675F746869735F6D616E75616C6C795F696E6665726E6F4354467B6833795F3130306B5F7930755F3472335F6E30375F6833785F626C316E445F3A4F7D5F646F696E675F746869735F6D616E75616C6C795F776F756C645F62655F615F6261645F696465615F796F755F73686F756C646E745F646F5F69745F6D616E75616C6C795F6F6B

This string can probably be translated to readable text using Julia, but it was quicker to copy this output and paste it in an online hex to string converter:

blahblahblah_hello_how_are_you_today_i_hope_you_are_not_doing_this_manually_infernoCTF{h3y_100k_y0u_4r3_n07_h3x_bl1nD_:O}_doing_this_manually_would_be_a_bad_idea_you_shouldnt_do_it_manually_ok

The output above contains the flag:

infernoCTF{h3y_100k_y0u_4r3_n07_h3x_bl1nd_:O}

Registering X

The goal of this challenge was to construct a string that matches the regex given to us in the challenge attachment:

infernoCTF{.(?<=H){21}.[a-z](?<=\+a){1024}[a-z][a-j](?<!([a-u]|[w-z])(j|[a-h])).{2,64}(?<!\S){255}n.{2}(?<=\s)g_fUn\W(?<=[A-z])}(?<=\..{14})(?<=^.{33})

The given regex is complex at first glance, but the challenge itself is very straightforward. We did not find a way to automate the solution of this challenge, so we solved it by hand. First, we simplified the regex by removing the quantifiers after the lookbehinds, because they do not serve a purpose. Removing these quantifiers will give us an equivalent, but shorter, regex:

infernoCTF{.(?<=H).[a-z](?<=\+a)[a-z][a-j](?<!([a-u]|[w-z])(j|[a-h])).{2,64}(?<!\S)n.{2}(?<=\s)g_fUn\W(?<=[A-z])}(?<=\..{14})(?<=^.{33})

We start by learning about lookbehinds. Positive lookbehinds (e.g, "(?<=a)b" ) match the character after the parenthesis, but only if the character is followed by the character in the parenthesis, after the =. Negative lookbehinds (e.g, "(?<!a)b" ) match the character after the parenthesis, but only if they are not followed by the character in the parenthesis, after the !. Knowing this, we can start constructing our flag.

Our flag starts with infernoCTF{, because the given regex states that we have to match these characters literally. . in our regex matches any character in our flag, so we will put an X as a placeholder. We now have to match the positive lookbehind (?<=H)., which means that our string will only match the regex when we have a character following the character H. We could try adding H+ to our flag (making our flag infernoCTF{XH+), but this will not match the given regex. The cause of this mismatch is the fact that lookbehinds only match the character after the parenthesis. It will not match the character in the parenthesis.

The solution for this problem is replacing our previous X with an H. We now have infernoCTF{H+, which matches the first part of our regex. The rest of the regex follows the same principle: we have a bunch of lookbehinds that force us to precede a character with another character. Around those lookbehinds we have more common regex symbols that make it possible to match the character in the parenthesis. Now that we got the gist of the challenge, we will quickly go over the solution:

infernoCTF{ forces us to start our flag with infernoCTF{
.(?<=H).[a-z](?<=\+a) forces us to add H+a
[a-z][a-j](?<!([a-u]|[w-z)(j|[a-h])).{2,64} makes us add vi to our flag, followed by an unspecified amount (between two and sixty-four, which will be constrained later in the regex) of placeholder characters
(?<!\S)n forces us to add an n after a whitespace character
.{2}(?<=\s)g forces us to add a g after a whitespace character
_fUn forces us to add _fUn to our flag
\W(?<=[A-z])} forces us to add a } after a non-word character between A and z in the ASCII table (e.g., ])

(?<=\..{14}) forces us to count fourteen characters back and add a .. We can safely put our . in the collection of unspecified characters mentioned in the third step above.

The last part of our regex forces us to make the flag exactly thirty-three characters long. This can be achieved by adding or removing a bunch of unspecified characters (which were mentioned in the same third step). One of the possible solutions is infernoCTF{H+avi . ng no g_fUn]}.

Because of a lack of knowledge about tools that generate strings based on given regex (that also support lookbehinds!), we decided to solve this challenge by hand. Although it is a bit of tedious work, it certainly is possible to construct the flag manually.

Patrick Van der Spiegel's Posts

Your work is not just content

Visualising Order in Sequences

Sequences

Linear Order

Hierarchically Nested Matchings

Nested Words

Visualising Nestings

Nested Substitution Rules

Example #1

Initial Condition

Replacement Rule

Looping Visualisation (6 steps)

Example #2

Initial Condition

Replacement Rule

Looping Visualisation (9 steps)

Visualising this post

Scrambled Stations

Gehusselde stationsnaam (NS)

Retrieving wordlists

Belgian railway stations

Flemish dialect words

Finding anagrams

Single-word anagrams

Multi-word anagrams

Bruteforce

Anatrees

Side notes

Displaying anagrams

Shortest stations

Bucket lists

Cryptmanteaux

Walkthrough

"Using AI to Detect the Unusual"

Introduction

What is Artificial Intelligence?

Examples of AI Applications

What AI Isn’t

Examples of AI Misuse

Detecting the Unusual

Gathering Data

Understanding Anomalies

Anomalies vs. Outliers

Using AI to Detect the Unusual

Anomaly Detection

The Role of Context

A Rule-Based Approach

Challenges in Anomaly Detection

Conclusion

"Hell's Hex Station" Write-Up

Description

Solution

Mindful use of LLMs

Flip side of the coin

Personal ethics

Notes from August

Writing daily notes

Blogs I enjoyed reading this August

Sharing daily notes

Why make these notes public?

Why share these on a personal website?

Why share unpolished work?

Writing streak

Obsidian.md, Espanso, and llm

Obsidian and llm

Obsidian and Espanso

Regex Triggers, Arguments, and Shell Commands

Expanding LLM Output

Limitation of Regex Triggers

Passing Full-Sized Prompt

Final Espanso Trigger

Demonstration

Automating Boggle

Thrifted Boggle

Project Goals

Implementation

Recognising labelled dice

Recognising valid words

Searching for words in a grid

Obsidian and `llm`