royvanrijn

Vibe-mathing: the Generalized Vanishing Conjecture

Tue, 04 Aug 2026 16:25:21 +0200

I am a developer.

Right now it is difficult to ignore the argument around “vibe coding.”

People who could not have written an application in the traditional way are describing what they want to an AI, running the result, reporting what broke, and iterating. Some of the resulting software is fragile. Some of it is surprisingly capable.

Either way, the phenomenon is real.

The uncomfortable part for experienced developers is not only that code is being generated. It is that the people producing it do not necessarily read or understand every line of code. They generate tests and just look at the result.

Vibe-coders sometimes even seem to have a major advantage.

Their unwillingness or unability to read the code makes it possible to work with several agents in parallel, producing incredible speedups. However, I am not going to settle the questions of viability or quality of vibe-coded software here… I’m too invested.

Instead, I decided to take that instinct somewhere else: to vibe my way into a field about which I had very limited knowledge, not burdened by knowledge, deep understanding, or preconceptions:

Straight into: Mathematics

As a developer, I have spent a lot of time using tools like Codex, refining prompts, and running parallel experiments. Also, large software systems have always exceeded the understanding of any one person. So abstractions and unknowns is part of what we do.

We navigate them through interfaces, types, tests, logs, debuggers, reproducible builds, and carefully chosen experiments. None of these makes a program correct. Together, however, they let us ask much better questions than “does this code accomplish the goal(s)?”

I began to wonder whether something similar was possible in mathematics.

Could I enter a field in which I did not have the expected training, use AI to navigate definitions and possible constructions, generate exact data, loop through failed ideas, and gradually replace intuition with artifacts that could be checked? Could I begin exploring before I understood the whole territory in the traditional order?

Or, stated more provocatively: could I too vibe-math my way to a genuine mathematical frontier?

The tweet…

The real spark here was Levent posting the JC(3) counterexample.

hello there the jacobian conjecture is false thanx to my close friend akhil for asking about it and my other close friend fable for working during the world cup final

Suddenly there was a concrete mathematical object to inspect: a three-variable construction connected to the Jacobian Conjecture, with a new algebraic structure that could be tested, generalized, formalized, and attacked from several directions.

This was my starting point. Instead of just asking whether AI could “do a breakthrough”, or produce mathematics that looked plausible, I could ask whether an AI-assisted process could locate the exact boundary or a new counterexample.

Counterexamples are especially useful here, they are easy to check and verify. Do the calculation, and done.

Proofs require way more human feedback, analysis and scrutiny.

The experiment was never supposed to be “can AI produce a paper that looks like mathematics?” We already know that it can. There is more than enough slob online. That is precisely the problem: A plausible-looking proof is now almost free, while the time needed to find the hidden gap still belongs to a human reader.

The real question was:

Can AI-assisted exploration turn this counterexample into a result that survives exact computation, independent implementations, formal proof, explicit statement boundaries, and eventually human mathematical review?

The Generalized Vanishing Conjecture became one of my test cases, one of my goals. And the result is a sharp boundary: it holds for every constant-coefficient differential operator in one or two variables, and it fails from dimension three onward.

This is the story of how Levent’s post became a theorem, a counterexample, and a collection of steps/receipts.

The Generalized Vanishing Conjecture: The Two-Variable Theorem and the First Failing Dimension

The counterexample and failure in every dimension at least three are fully Lean-verified; nearly all supporting algebraic machinery and much of the binary proof infrastructure are checked as well

Repository source: papers/generalized-vanishing-two-variables/main.tex
Lean proof: github.com/royvanrijn/jacobian-research/tree/main/formal/gvc

A conjecture with an infinite premise

Lets start with the Generalized Vanishing Conjecture (GVC):

Let \(\Lambda\) be a constant-coefficient differential operator and let \(P\) be a polynomial. GVC asks whether

\[\Lambda^m(P^m)=0\quad\text{for every }m\geq1\]

forces

\[\Lambda^m(QP^m)=0\quad\text{for all sufficiently large }m\]

for every fixed polynomial multiplier \(Q\).

The statement grew out of work around the Vanishing Conjecture and the Jacobian Conjecture. But what made it especially interesting to me was its shape. The premise is an infinite sequence of exact identities, and the conclusion is eventual vanishing after inserting any fixed multiplier.

This is exactly the kind of statement on which vibe-mathing can go wrong. A search can verify the first ten powers, or the first hundred, and still prove nothing about the next one. Perhaps we can explain why a visible pattern “should” continue and bury the missing quantifier inside a polished proof.

My biggest rule became:

A bounded search will not proof GVC.

It does not mean bounded searches are useless, but it changed what I allowed them to mean.

The long route through exact computation

I began classifying low-degree cases in two variables. The calculations separated operator symbols by root type, exposed exceptional coefficient branches, and tracked which weighted faces could survive the first several pure identities.

Again and again, the same patterns appeared. Surviving supports became one-sided. Moment ideals developed staircase-shaped radicals. A complicated coefficient system would collapse onto a face where a simple weighted degree deficit forced every mixed expression to vanish eventually.

Degree by degree, exact calculations closed polynomial degrees four, five, six, and seven for arbitrary binary constant-coefficient operators. These were real theorems in their stated ranges. They were not a license to draw an all-degree curve through four data points.

The attempted general proof grew into a much larger machine: Hall matchings, factorial packets, prime-power carries, characters, Graver bases, and finite traces. AI was useful here in the same way it is useful in an unfamiliar codebase. It could suggest representations, translate between formulations, generate experiments, and help turn a failed idea into a smaller exact question.

Many pieces of that machine became valid mathematics. The machine as a whole did not close the conjecture. One promotion step kept moving away: I could understand a packet after it had been isolated, but I could not prove that the original infinite vanishing premise always exposed one fixed packet in the required way.

This was an important part of the experiment. The repository accumulated more positive results without quietly changing the status of the missing step. The route was productive, but it remained incomplete.

I kept telling Codex to “find general patterns, try to think about global structures at play here”. Sometimes I would have one thread list ideas, and spin up agent threads to experiment until they either reach an extension, elimination, or a dead end.

Then the proof became shorter.

Two moving Newton faces

Take the symbol of \(\Lambda\) and the support of \(P\). For every positive weight

\[w_s=(s,1),\]

look at two faces:

the lowest-weight face of the operator symbol;
the highest-weight face of the polynomial.

The pure vanishing identity passes to these extremal faces. Hall’s marriage theorem orders their horizontal Newton intervals just after ordinary degree. A separate prime-dilation argument shows that, while the two faces have unequal weights, their intervals cannot overlap.

In two variables, this has a decisive consequence. The projection of each face is an interval on a line. Two disjoint intervals cannot exchange order without meeting.

Now define the lower operator envelope \(L(s)\) and the upper polynomial envelope \(U(s)\). Their gap

\[\Delta(s)=U(s)-L(s)\]

is piecewise linear because both supports are finite. Just after \(s=1\), Hall localization puts the operator interval strictly to the right of the polynomial interval. Shifted-ray rigidity prevents the intervals from overlapping, so they cannot pass one another while \(\Delta(s)>0\).

The gap cannot stay positive forever. After the last breakpoint its slope is forced to be negative, so it must reach zero. At the first meeting, every operator monomial lies on or above one common weighted threshold and every polynomial monomial lies on or below it. A fixed multiplier contributes only a bounded defect; it cannot repair a deficit that grows linearly with the power \(m\).

That proves:

Over a characteristic-zero field, every constant-coefficient differential operator in two variables satisfies the Generalized Vanishing Conjecture.

The short proof also explains the staircase radicals from the earlier computer algebra. They were not mysterious survivors. They were finite shadows of a geometric fact: the moving Newton intervals were forbidden to overlap.

Years of imagined mathematical labor had collapsed into following two piecewise-linear envelopes until they met.

Then the conjecture broke completely

The binary theorem raised the obvious question: was two variables merely the first case of a higher-dimensional principle?

It turns out: no!

Put

\[\rho=t^2+xy,\qquad A=\rho+x^2,\] \[C=y\rho^2-2xt^2\rho-x^3t^2, \qquad P=AC^2,\]

and let

\[\Delta=4\partial_x\partial_y+\partial_t^2, \qquad \Lambda=\Delta^6.\]

Then, for every \(m\geq1\),

\[\Lambda^m(P^m)=0, \qquad \Lambda^m(x^2P^m)\ne0.\]

The first identity supplies the complete pure premise. The second uses the single fixed multiplier \(Q=x^2\) and fails at every power, not merely infinitely often. This is a homogeneous counterexample in three variables.

And once it fails in three variables, every larger dimension follows almost for free.

Rename the three variables \(x_1,x_2,x_3\) and regard the same polynomial as one in \(ngeq4\) variables:

\[\widetilde P(x_1,\ldots,x_n)=P(x_1,x_2,x_3),\]

so \(\widetilde P\) is completely independent of \(x_4,\ldots,x_n\). Extend the three-variable quadratic operator by putting

\[\widetilde\Delta_n =4\partial_{x_1}\partial_{x_2}+\partial_{x_3}^2 +\sum_{i=4}^n\partial_{x_i}^2.\]

For every polynomial \(f\) depending only on the first three variables,

\[\widetilde\Delta_n f =\left(4\partial_{x_1}\partial_{x_2}+\partial_{x_3}^2\right)f =\Delta_3f,\]

because

\[\partial_{x_i}f=0\qquad(i\geq4).\]

Applying the same observation repeatedly gives

\[\widetilde\Delta_n^k f=\Delta_3^k f\]

for every \(k\geq0\). We can therefore take

\[\Lambda_n=\widetilde\Delta_n^6.\]

The pure identity is inherited verbatim:

\[\Lambda_n^m(\widetilde P^m) =\widetilde\Delta_n^{6m}(\widetilde P^m) =\Delta_3^{6m}(P^m) =0.\]

And for the same multiplier \(Q(x_1,x_2,x_3)\), the obstruction survives:

\[\Lambda_n^m(Q\widetilde P^m) =\Delta_3^{6m}(QP^m) \neq0.\]

So the counterexample in three variables automatically produces one in every dimension \(n\geq3\). Combined with the binary theorem, the exact dimensional classification is:

\[\boxed{\operatorname{GVC}(n)\text{ holds if and only if }n\leq2.}\]

The same boundary already holds when the differential operator is required to be homogeneous.

In two variables, Newton faces project to intervals and inherit a total order. In three variables, higher-dimensional faces can move around one another. The mechanism that makes the binary proof work is precisely what disappears at the first failing dimension.

From a witness to an all-order Lean theorem

Because we’re using AI here, we want to be extra careful and complete. One way to achieve this is formal verification in Lean, next to the Python, SymPy and Singluar scripts used in the discovery.

The GVC public Lean development is not a small certificate attached to the end of the project. It currently contains more than 3,100 lines across sixteen modules and 164 theorem or lemma declarations, with no sorry, admit, or explicit axiom declarations. We have now checked almost every part of the argument that can be cleanly isolated into an algebraic interface.

Most importantly, the three-variable counterexample is formalized end to end.

The development does not check a list of sample powers. It defines the literal polynomials \(\rho,A,C,P\), the operator \(\Delta\), its sixth power \(\Lambda\), and the multiplier \(Q\). It then proves the algebraic machinery connecting them:

coefficientwise semantics for constant-coefficient differential operators;
composition of operator symbols and apolar top contraction;
the cusp identity behind the construction;
the Reynolds–phase identity by exact coefficient expansion;
the endpoint coefficient extraction for every power;
the zero pure coefficient and exact nonzero neighboring coefficient;
base change from the rationals to every characteristic-zero field;
padding from three variables to every larger finite dimension.

The resulting Lean theorem is unconditional:

GVC fails over every characteristic-zero field in every finite dimension at least three

That is the entire negative half of the dimensional classification, fully checked for all powers, fields, and finite dimensions in its stated scope. Nothing in the counterexample is left as an assumed computational bridge.

The formalization goes considerably further. It checks the coefficientwise definition of GVC, operator composition, top contraction, the full endpoint coefficient ladder, formal beta evaluation, exact factorial valuations, Reynolds expansion, Laurent phase extraction, coefficient-ring base change, unused-variable padding, the winding–profile–radial degree formulas, and the final piecewise-linear envelope crossing used by the positive theorem.

What remains outside Lean is concentrated: the global Hall-localization and shifted-ray separation bridge that drives the short binary proof, together with its no-reversal and common-threshold termination argument. Those steps are common and proved in the paper. Everything around that bridge has been reduced to explicit definitions, exact lemmas, or independent degree-four through degree-seven regressions.

This combination matters to me. Exploration found the construction and the proof architecture. Exact computation kept killing false branches. Formalization then converted the entire negative half of the dimensional classification, and as much of the positive machinery as possible, into declarations that can be checked from definitions.

What (I think) I learned

The strongest version of “vibe-mathing” is not mathematics without understanding.

It is mathematics in which understanding does not always have to arrive first.

I could begin by navigating representations, generating examples, asking AI for possible bridges, and trying to falsify every bridge that appeared. Exact computation let me reject bad directions. Formalization forced vague claims to split into precise ones. Writing the proof forced me to explain why the surviving path worked.

Most of my understanding followed the artifacts. It did not precede all of them.

That changes what may be possible for people outside the normal research pipeline. It does not abolish expertise, and I would not say that it makes the work easier for them. It creates a new and confusing landscape and experience: people will begin exploring unfamiliar mathematics before they have the usual training, but they will probably also produce a great deal of low-quality material that needs to be filtered.

AI may actually be very useful for a first pass, helping rate, sort, and identify which artifacts deserve closer human attention. But that is only a pre-check, not a substitute for expert judgment. The remaining human questions become:

Is this the right theorem?
Is the interface with the literature correct?
Is an apparently small hypothesis carrying hidden mathematical content?
Is the ordinary proof outside the formal boundary sound?
Has the result already appeared in another language?

Those are exactly the questions on which I now want expert criticism.

The GVC project forced the process in both directions at once: a general positive theorem in two variables and a concrete failure in three. Crossing between those modes was far harder than generating plausible candidates. It required a growing system of definitions, tests, exact certificates, failed searches, formal proofs, literature boundaries, and prose.

I do not know yet how the mathematical community will judge the result. That judgment cannot be automated, sped up, made easier…

As a software developer struggling with accepting vibe-coded codebases, I can imagine what mathematicians are going through right now. But the right response is the same, now we inspect the statement, run the checks, read the proof, and try to break it.

The vibes helped find the path. Verification decided what survives, counterexamples are easy to verify, proofs are definitely not.

There was one final twist. On the very same day, Christopher D. Long messaged me and reported that he had independently found two other proofs, using ideas unrelated to this one. We had reached the same conclusion from three different directions, without coordination.

For a result about the exact boundary between truth and failure, that convergence felt especially remarkable.

Links

The formal development is pinned to Lean and Mathlib versions recorded in the repository. From the repository root, build the GVC verification with:

make verify-gvc-lean

The Anatomy of an LLM

Thu, 28 May 2026 13:00:00 +0200

I think I’ve finished something I’ve been building for a while:

The Anatomy of an LLM

It is a visual, interactive walk-through of the main machinery inside a large language model.

Not just “it predicts the next token”, but what actually happens before that:

How text becomes tokens
How tokens become vectors
How neural networks process those vectors
How attention works
How transformer blocks are stacked together
How the model ends up choosing the next token
And why things like context windows, KV cache and quantization matter

It started as a small explanation, but of course that quickly got out of hand.

It is still marked beta, and I’m sure there are things that can be improved. But at some point you have to stop tweaking and publish.

Take a look: The Anatomy of an LLM

Introduction to Java Notebooks

Wed, 04 Jan 2023 23:35:00 +0100

Java Notebook is a new and exciting way to explore the Java programming language. It works a lot like Jupyter Notebooks.

Notebooks are a community standard for communicating and performing interactive computing. They are a document that blends computations, outputs, explanatory text, mathematics, images, and rich media representations of objects.

It allows you to interleave blocks of text (in Markdown), editable and executable Java code blocks and output blocks.

[1] [Run] [Edit]

System.out.println("Hello world!");

> Hello world!

As you can see, when we run the code block above, the output is immediately updated. It is similar to JShell, but in the browser.

Maven support

Notebooks are an ideal tool to teach programming languages and to display and explore libraries and frameworks. Notebooks also support the import of external libraries using Apache Maven. Here is an example using the load command to import Apache Commons.

[2] [Run] [Edit]

load org.apache.commons:commons-lang3;
import org.apache.commons.lang3.StringUtils;

System.out.println(StringUtils.reverse("Hello world!"));

> !dlrow olleH

Data processing with jandas

It is also possible to directly import resources from internet and parse them to Java objects and records using frameworks like jandas (loosely based on pandas).

Here is an interactive example:

[3] [Run] [Edit]

load jandas:jandas:0.24.0;
import org.jandas.*;

record Song(int rank, String songName, long amountStreams, String artist, Date releaseDate) {}

var songs = CsvReader.read("https://www.royvanrijn.com/examples/data/spotify_top_1000.csv", Song.class);

System.out.println("Lady Gaga currently has " +
    songs.stream().filter(s -> s.artist.equals("Lady Gaga")).count() + " top 1000 hits.");

System.out.println("Ed Sheeran has " +
    songs.stream().filter(s -> s.artist.equals("Ed Sheeran")).mapToLong(s -> s.amountStreams).sum() + " total streams");

System.out.println("Bohemian Rhapsody was released: " +
    songs.stream().filter(s -> s.songName.equals("Bohemian Rhapsody")).map(s -> s.releaseDate).findAny());

> Lady Gaga currently has 6 top 1000 hits.
> Ed Sheeran has 26513653 total streams.
> Bohemian Rhapsody was released: Fri Oct 31 00:00:00 CET 1975

Hosting your own Notebooks

It is very easy to host your own notebooks. Users can run notebooks locally (using Docker) or use one of the following free cloud services to run your Java Notebook:

If you build or maintain a framework or library, or if you have a website explaining Java programming: Please add these interactive notebooks to your website. This makes it incredibly easy for new developers to get acquainted with your code.

Wake up!

Sadly (as you might have noticed) the examples above do not work. It was all just a dream. There is no such thing as a (widely used) Java Notebook.

The reason I wrote this post is the famous TIOBE Index of programming languages.

Today is the first day since 2001 that Java isn’t in the top 3.

That is why we, as the Java community, should look at our competition. What did Python do right? Why is it topping the chart?

A major reason, I think, is the feedback and steep learning curve of Java. If you want to parse some data, would you rather download a Java Runtime, install an IDE, install Maven etc? Or would you rather open the browser, have documentation and tutorials inlined with running examples? This is SO much easier.

The same is true for learning frontend/Javascript, there are so many websites that allow you to jump right in and test your code, sites like jsfiddle or codepen.

My wish for 2023: Oracle, Microsoft, Google, Azul… PLEASE make this a reality.

They do exist…

Update 2023-05-01:

Almost forgot: There are some online Java Notebooks that provide much of the functionality given above, here are some options you can consider:

Apache Zeppelin (a Jupyter-like runtime that has Java bindings)
IJava (a Jupyter kernel for executing Java code)
And more, mostly single developer hacked/weekend projects

The main problem I have isn’t that these project don’t exist; we just don’t utilize them, at all. There is no widespread support for this. It would be such a powermove if Oracle launched a similar product and encouraged libraries to embed it (running on their cloud for example).

If you want to get into AI/deep learning for example, here are two examples, Java or Python, I know which I’d pick:

Java: Quickstart DeepLearning4J:

Twenty steps of installing Java, Maven, git, IntelliJ, check out a project…

Python: Tensorflow Quickstart for Beginners:

No setup at all; from the start you’re importing Tensorflow and running the examples.

It isn’t all bad, here is an example where it does work:

Java: DJL

Easy to overlook, but press the top button “Run this notebook online”. Using IJava and Jupyter, yay!

Perfect for: https:://dev.java

I’d love for dev.java to become more engaging or interactive, something like a notebook. Have a place online where you can “Try now” without having to install everything.

Currently the Getting Started goes as follows:

Open a plain text file, write your first class, without code formatting etc.
Now you could compile it and run TADAA!
But wait, you need to install a JDK first
Download JDK
Install JDK
Learn to use the compiler
Now run it.

Nobody got time for that anymore, sure, perhaps after you’ve decided to really go for it. But with notebooks you get instant results, you can tinker away, run stuff in the browser and see the results, perfect.

Anywaaaay, enough ranting for today ✌️

Solving the daily calendar puzzle

Thu, 07 Jul 2022 20:42:12 +0200

About a month ago I was watching a YouTube video where YouTuber Drew Gooden was struggling with a “weird” puzzle:

This is what the puzzle looks like:

It has 10 pieces that can be flipped/rotated and placed on a calendar. They claim there is a solution for each day/month/weekday combination. In the YouTube video Drew is struggling and says:

The problem is, I’ll never be able to prove that

But… what if we can?

As a programmer this sounds like a perfect little puzzle to solve.

Solving the puzzle

To solve this, I first encoded all the puzzle pieces, this is relatively easy to do because it’s just a 2D grid.

Next I wrote the code to generate all the possible rotations of a certain puzzle piece (and eliminated duplicates). Some pieces have more rotations than others because some are the same after a 180 degree rotation, others are not.

Next I blocked the target puzzle solutions on the board, for example “2nd June Monday”, placing three markers.

After that I just go through all possible piece/location combinations, placing the first puzzle piece in the top position and continuing down.

This was fast enough to solve the first puzzle after a couple of minutes.

But… not fast enough to generate all: 12 (months) x 31 (days) x 7 (weekdays) = 2.604 solutions

Example output: The image above has a solution for Thursday 8th of April. The code outputs this as:

Solution for: 8/4 [5]:
0 0 0 X 1 1 X 
2 2 0 0 4 1 X 
2 2 3 3 4 1 1 
X 2 3 4 4 5 5 
7 6 3 3 5 5 9 
7 6 6 6 6 8 9 
7 7 7 8 8 8 9 
X X X X X 8 9 

Each number 0-9 stands for a certain puzzle piece. The X’s are blocked off (solution and edge).

Improve solving speed

To improve the speed of the solver I decided to do a small flood fill after placing each puzzle piece. If we’ve created a spot where there are just 4 places left (a small island) I stopped looking further, because no puzzle piece will ever fill this spot.

This small algorithmic improvement was enough to make it fast enough to generate a puzzle solution for every single combination.

Links

Solutions: If you’re just looking for all the solutions: solutions.txt.

Code: If you want to take a look at the (Java) code, check out PuzzleADaySolver.java.

All The Music: the Megamix

Wed, 23 Mar 2022 22:23:03 +0100

Or a clickbait title:

How I became the world’s most prolific DJ, using code.

This week I stumbled across a cool project: All The Music.

Damien Riehl (programmer/copyright attorney) and Noah Rubin (programmer) decided to generate all possible songs with the basic 8 major notes (C4,D4,E4,F4,G4,A4,B4 and C5) with length 12. All these songs have been ‘freely’ released under the ‘Creative Commons’ license. Their goal is to stop copyright claims on melodies.

While watching their excellent TED talk and hearing about the challenges they had to generate these songs, my head instantly made some connections. They generated all songs of length n=12 with k=8 notes, this amounts to a staggering n^k = 8^12 = 68,719,476,736 unique songs.

All these songs are 12 notes long and have their own MIDI file which adds even more overhead. The size of this dataset is huge, 1.2TB compressed using GZIP.

Using a de Bruijn sequence

This is when I got an idea: perhaps we can use a de Bruijn sequence for this?

I’ve blogged about those sequences before, basically it is an optimal way to arrange these N elements into a single sequence so that each and every combination of K-length is present in the sequence.

For example if we have all combinations of 0,1,2 of length 4 the naïve way would be to do it:

Instead when creating a de Bruijn we have:

000012200210002212021211212222011221022211012101001011112001102111002012010202202[000]

Every possible 4-length combination/permutation is present in this single line (check them!).

What if we could remix every possible 12 note melody into one huge megamix!?

That would mean I’m mathematically the world’s best DJ, remixing almost all existing songs including EVERY song from the All The Music dataset into one song.

Setting to work

I already have some very efficient code to generate these sequences. What if I output the sequence as a single MIDI file?

Because a de Bruijn sequence usually wraps around, if we want to create all n=12 length melodies we’ll need to append the first n-1 notes to the end of the sequence (which I’ve done above as well). This means we’ll need just a single MIDI file with 68,719,476,747 unique notes in it.

This gave me a tiny problem: a MIDI file has a ‘LENGTH’ field stored in just 4-bytes. And 2^32 is only 4,294,967,295. So we’ve hit a technical problem, we can’t fit our remix into a single MIDI file.

To solve this I decided to cut the single song up into a collection of ‘smaller’ more managable songs. In the end I settled on 2052 unique songs that create one huge megamix album. On this album is every single song possible with notes C4,D4,E4,F4,G4,A4,B4 and C5 of length 12. The same as is contained in the ATM’s dataset.

When breaking up a de Bruijn sequence, each new song has to repeat the final n-1 notes of the previous song, that way each melody is contained in full. For example if we split the above sequence into two parts we’ll need to do:

Song 1: 000012200210002212021211212222011221022211012
Song 2: [012]101001011112001102111002012010202202[000]

This results in the following:

1 remix album: debruijn8-12.tar
Size: 16.735.957.504 bytes (16,75 GB on disk)

Contains:

2052 GZIP-ed MIDI songs
2051 songs with a 33,500,000 note melody
1 song with a 10,999,308 note melody

Really? Every song?

Let’s listen to some songs that are in the dataset (somewhere):

Example 1, Twinkle Twinkle:

Example 2, Jingle Bells:

Example 3, Can You Feel The Love Tonight.

All possible 12 note melodies are in the remix.

Is this better?

This got me thinking, why didn’t Damien and Noah go for this approach? It is much smaller and faster to generate (in a single morning).

So I turned to Twitter and asked Damien Riehl! And sure enough: his answer makes total sense:

We had initially considered a “de Bruijn” sequence. But if we were to use a single file, that would have down sides:

If someone infringes our work, it would only be a tiny percentage (0.0000000001%?) of the “work” — so someone would argue “fair use”

Same idea with others incorporating ATM works in theirs (“tiny percentage”)

So our technical/legal design is “One MIDI file per melody” — which I think is a legal feature, not a bug. 🙂

Of course I should have known there was a valid reason. He encouraged me to continue though and so I generated my own de Bruijn album. Now I can say I’ve officially remixed 68,719,476,736 songs. Is there like a Guiness Book of World Records entry for me now?

If you’re curious what this remix sounds like, here is a snippet:

It was a fun exercise! I really love de Bruijn sequences and learned a lot about streaming GZIP/File API’s to easily store everything (generating the sequence first isn’t an option).

The album is, for now, only stored on my hard disk, but I’m working with Damien to get the songs added to their ATM collection on the Internet Archive.

Oh, and you can’t have a remix album without a proper album cover:

Roadtrip to Ludolph van Ceulen

Mon, 14 Mar 2022 03:14:15 +0100

Today is March 14th (3/14), otherwise known as Pi Day!

Calculating Pi

To celebrate Pi Day people often try to come up with cool and interesting ways to calculate π, or to celebrate the number in weird ways.

Here is a great example by the excellent Matt Parker (from Stand-up Maths):

He’s using the “Isaac Newton”-way to calculate π by hand. This method was discovered by Isaac Newton and German mathematician Gottfried Wilhelm Leibniz in 1665. And it uses ‘infinite series’.

Before Newton

The method Newton used (infinite series) was mathematically superiour to all previous methods of calculating π.

That does raise a question: How did they calculate π before 1665?

First let’s take one step back, what exactly IS π? π is a mathematical constant: the ratio between a circle’s circumference and diameter. This means that if you have a circle with a diameter of 1, the circumference is π (~ 3.14159…).

Let’s try to come up with a very rough estimate what this ratio needs to be. What if we put our unit-circle with length 1 inside a square:

We can conclude that the circumference, and therefor π, is at most 4 x 1 = 4, this gives us the first upper bound.

Now lets look at the other case, where the square fits inside the circle. In this case we can see that we have an equilateral triangle, with two sides a that make the square. The length of a is easy to calculate using Pythagoras theorom, the long side has a diameter of 1, this means a needs to be a^2 + a^2 = 1. If we rearrange everything we’ll come to the conclusion that a = sqrt(0.5).

This means that the circumference of the smaller square is 4 x sqrt(0.5) = ~ 2.82...

We can conclude that π lies somewhere between 4 and 2.82 🎉

Archimedes method

But can we do even better? Sure! What if, instead of placing our circle between two squares, we use pentagons, hexagons, or shapes with even more sides?

As you can see, the shape get more and more rounded. So the upper and lower bounds converge towards our beloved π!

This method is known as Archimedes method. Archimedes calculated, using a shape with 128 sides, that π had to be between 3.141 and 3.142.

Ludolph van Ceulen

Now it’s time to introduce our hero of today: Ludolph van Ceulen

Ludolph spend his entire life to improve the calculated value of π. Instead of using a 128-sided shape like Archimedes, he calculated π using shapes with up to millions of sides. Let that sink in, a shape with a million sides, by hand. By the time of his death van Ceulen managed to calculate π up to 35 digits, an incredible feat.

Ludolph was so pleased with his life goal that he requested the upper and lower bounds to be carved into his tombstone. Sadly the original tombstone went missing not long after his death. However a new tombstone was added to the famous St. Peter’s Church in Leiden (The Netherlands) in the year 2000.

Visiting Leiden

About a month ago, my girlfriend and I, bored in lockdown, decided to take a roadtrip and visit the church in Leiden to see the tombstone for ourselves.

And there it is, here is a better picture of the plaque:

I’ve tried to translate the plaque from ‘old Dutch’ into English and it reads something like:

Buried here is Mr. Ludolph van Ceulen.
He was a Dutch professor of Mathematics at the university of this city (Leiden).
Born in Hildesheim in the year 1540 at 28th of January.
Passed away 31st of December 1610.
During his life, through hard labour, he found the circle's circumference compared to the diameter to be...

If the diameter is 1
The circumference is at least:

3141592653589793238462643383279502881
-------------------------------------
100000000000000000000000000000000000

And at most:

3141592653589793238462643383279502891
-------------------------------------
100000000000000000000000000000000000

And if the diameter is 100000000000000000000000000000000000

The circumference is at least 
314159265358979323846264338327950288

And at most:
314159265358979323846264338327950289

He spend his entire life to improve the upper and lower bounds, using more and more sided shapes, up to millions of sides. He was also the last person to improve the records using this labour intensive method. The method co-discovered by Isaac Newton (using infinite series) proved to be much easier and faster to calculate. After that calculating π by using complex shapes was a thing of the past.

If you’re ever in Leiden, be sure to visit the church and pay respects to the incredible diligence of Ludolph van Ceulen.

Happy Pi Day!

From Wordle to Nerdle

Thu, 03 Mar 2022 08:01:25 +0100

About two months ago I wrote a blogpost about what strategies you could use to solve Wordle in the most efficient way. In the end I wrote a program that looks ahead a single guess and finds the word that gives you the most information.

The main hype around Wordle (and all of the clones), seems to have settled down now… but I still play some of them.

Nerdle

One clone I really enjoyed playing the last couple of weeks has been Nerdle. In the game Nerdle all your guesses need to be a valid mathematical calculation. For example: 31 + 56 = 87.

In this game, you can’t just write down anything, each and every try needs to be a valid calculation.

Generating the guesses

Yesterday, when I had a bit of time with a colleague, we set about trying to adapt the Wordle-bot into a Nerdle-bot. In theory this would be extremely easy, the only hard part is getting a valid “wordlist”.

When I created the Wordle bot, I just downloaded a list of all valid Wordle words. But in this case I set myself the challenge to create all the valid guesses from scratch.

Patterns

First, let’s look at some of the rules. There are 8 characters you can fill, and the final part will always be:

=N with N is a single digit number between 0-9
=NN with NN being between 10 and 99; or
=NNN with NNN being between 100 and 999

It’s easy to generate all those options. However: the part before that is a little bit harder.

Calculations can, because of the limited size, be just one of two patterns (of various sizes): Value1 Operator Value2 or Value1 Operator Value2 Operator Value3

For example 12+34=46 or 10/2+1=6

These patterns are build up from left to right, starting first with a single digit number, appending the first operator, etc, until we have all valid 4, 5 or 6-character calculations.

Now obviously, the tricky part is that we need to evaluate all these calculations and check if the result fits in the amount of characters we have left, for example =NN! This code isn’t pretty… at all, even though I tried to make it generic. I won’t share it haha.

Bugs/problems

I quickly ran into the first big obstacle: How do you calculate the result of something like 1+10/2? You’ll first need to evaluate 10/2, store the result, and finally do 1+5 and check if =6 fits (which it does).

After writing some code and making sure we always evaluate in the correct order in case of Value1 Operator Value2 Operator Value3 I thought we were done. It showed me there are about 13k valid guesses. And this was wrong.

The first bug I encountered was silly. I falsely put in a rule that no result can be zero. But in some cases zero’s are allowed, for example ending with =0. After fixing this bug I found out I was still missing some valid guesses.

After diff-ing my list with a list I found online I noticed I was missing things like: 9/6*8=12

Because Nerdle doesn’t handle fractions, I thought that the divides should never have remainders. Thus I marked 9/6 invalid because it doesn’t evenly divide. However… we are multiplying afterwards (!) so the actual result (12) IS a valid guess for Nerdle.

Results

After fixing all the bugs I had a complete list of all valid Nerdle guesses, and here are some stats:

There are 17723 valid Nerdle answers

6839 of which contain a +
7810 of which contain a -
5574 of which contain a *
4024 of which contain a /
8607 of which contain two math operators
5890 end with =N
10515 end with =NN
1318 of which end with =NNN

And when I fired up the Wordle-checker, my code thinks the best start is: 49-37=12

Other great starters are: 39-24=15 34+27=61 9+8/2=13 7+8-13=2

After writing the bot I’ve tried it against the last three Nerdle challenges, and each game was solved after just three guesses!

For example yesterday the bot calculated the following guesses:

49-37=12 : ⬛⬛🟩🟪🟪🟪🟪⬛
31+56=87 : 🟪🟩⬛⬛⬛🟪⬛🟩

After just these two guesses there is only ONE valid guess left: 11-1-3=7: 🟩🟩🟩🟩🟩🟩🟩🟩

An algorithm for Wordle

Fri, 07 Jan 2022 08:01:25 +0100

If you’ve used Twitter during the begining of 2022 you’ll almost certainly have seen people posting tweets like this:

Wordle 202 3/6

⬜⬜⬜⬜🟨
🟨⬜⬜⬜⬜
🟩🟩🟩🟩🟩

This is the result of playing the latest viral game “Wordle”. The concept is very easy, you have to guess a 5-letter word each day. For each guess you get the basic “Mastermind” reply, green for the correct character, yellow if it’s in the wrong spot.

This game was fun, for a couple of days, but my curious mind started to wonder… what are the BEST words to play?

So I downloaded a huge list of 5-character words and started playing around with the dataset.

Update: I’ve updated the post using the ‘correct’ Wordle word-list, there are two lists, one with possible secret words, and one list with all words valid for guessing.

Eliminate by frequency

The first thing I tried was to try and eliminate the most frequently used characters first. With 5 guesses we can try and guess the most frequently present letters in the English language.

To get the frequency of the letters I used the following code:

        // Read all the words:
        List<String> words = Files.readAllLines(Path.of("wordle.txt"));

        // Count all the characters frequencies:
        final Map<Character, Long> frequency = words.stream()
                .flatMapToInt(w -> w.chars())
                .mapToObj(i -> (char)i)
                .collect(Collectors.groupingBy(
                        Function.identity(),
                        Collectors.counting()
                ));

        // Sort the characters by frequency and print:
        frequency.entrySet().stream()
                .sorted((e1, e2) -> Long.compare(e2.getValue(), e1.getValue()))
                .forEach(entry ->
            System.out.println(entry.getKey() + " " + entry.getValue())
        );

This results in the following distribution:

Using some simple code it’s easy to find pretty good words to start with, for example:

laser -> tonic -> dumpy

These three guesses will tell you information about the 15 most common characters in all of the 5-letter words. This is “a” strategy, but it’s far from perfect. We can do much better!

Most information per guess

Each time we guess a word, we get a reply back, it can be something like “⬜⬜⬜⬜⬜” or “🟨⬜⬜🟩🟨”. What we want to do is optimize for the information we’re getting in return. Each guess we do should eliminate most options.

If we go over the entire list of words, and compare all the replies we could get back against all other words, we get a distribution of the returned patterns.

I’ve decided to write some code to do this. For example if we pick the word smile, these patterns can be returned:

🟨⬜⬜⬜⬜: 1464 ⬜⬜⬜⬜⬜: 1352 ⬜⬜⬜⬜🟨: 1122 🟨⬜⬜⬜🟨:  967 ⬜⬜🟨⬜⬜:  690 ⬜⬜⬜🟨⬜:  610 
⬜⬜⬜⬜🟩:  504 🟨⬜🟨⬜⬜:  468 🟩⬜⬜⬜⬜:  467 ⬜🟨⬜⬜⬜:  417 🟨⬜⬜🟨⬜:  263 🟩⬜⬜⬜🟨:  252 
⬜⬜🟨⬜🟨:  251 ⬜⬜🟩⬜⬜:  196 🟨🟨⬜⬜⬜:  191 🟨⬜🟩⬜⬜:  187 ⬜⬜⬜🟨🟨:  183 ⬜⬜🟨🟨⬜:  154 
⬜🟨⬜⬜🟨:  154 🟨⬜🟨⬜🟨:  147 🟨⬜⬜⬜🟩:  136 ⬜⬜🟨⬜🟩:  136 ⬜⬜⬜🟩⬜:  128 🟨⬜⬜🟩⬜:  117 
⬜🟨🟨⬜⬜:  115 ⬜⬜⬜🟨🟩:  115 🟩⬜🟨⬜⬜:  112 🟩⬜⬜⬜🟩:  109 🟩⬜⬜🟨⬜:  107 ⬜🟨⬜🟨⬜:  106 
⬜🟨⬜⬜🟩:   99 🟩⬜🟩⬜⬜:   87 ⬜⬜🟩⬜🟩:   82 ⬜⬜⬜🟩🟩:   79 🟩🟨⬜⬜⬜:   63 ⬜⬜🟩🟨⬜:   63 
🟨⬜⬜🟨🟨:   62 ⬜⬜🟩⬜🟨:   58 🟨🟨⬜⬜🟨:   53 ⬜⬜⬜🟩🟨:   52 🟨⬜⬜🟩🟨:   49 ⬜⬜🟨🟩⬜:   46 
🟩⬜⬜🟩⬜:   43 🟨⬜🟩⬜🟨:   41 🟩⬜🟨⬜🟨:   41 🟨⬜🟨🟩⬜:   36 ⬜⬜🟩🟩⬜:   35 ⬜🟨🟩⬜⬜:   31 
🟩⬜🟩⬜🟩:   27 ⬜🟩⬜⬜🟨:   27 🟩⬜⬜🟨🟨:   27 🟨⬜🟩🟩⬜:   25 🟨⬜🟩🟨⬜:   25 ⬜🟨⬜🟩⬜:   23 
🟩⬜⬜🟩🟨:   20 🟨🟩⬜⬜⬜:   20 🟨⬜🟩⬜🟩:   19 🟨🟨🟩⬜⬜:   19 ⬜⬜🟨🟨🟩:   18 🟩⬜🟩⬜🟨:   18 
🟩⬜⬜🟩🟩:   18 🟩🟩⬜⬜⬜:   18 🟩⬜🟨🟨⬜:   17 ⬜⬜🟨🟨🟨:   17 ⬜⬜🟩🟨🟩:   15 ⬜🟩⬜⬜⬜:   15 
⬜🟩🟨⬜⬜:   15 ⬜⬜🟩🟩🟩:   14 🟩⬜⬜🟨🟩:   14 🟩⬜🟩🟩⬜:   13 🟩⬜🟩🟨⬜:   13 ⬜🟨🟩⬜🟩:   13 
🟩🟨⬜⬜🟨:   13 🟩🟨🟩⬜⬜:   12 ⬜⬜🟨🟩🟩:   12 🟨🟨⬜🟨⬜:   11 ⬜🟩🟩⬜⬜:   11 ⬜🟩⬜⬜🟩:   11 
⬜🟨🟨⬜🟩:   10 🟩🟨🟨⬜⬜:   10 🟨🟩🟩⬜⬜:   10 ⬜🟨⬜🟩🟩:    9 🟨⬜🟨⬜🟩:    9 🟨⬜⬜🟨🟩:    9 
🟩⬜🟨⬜🟩:    8 🟩🟨⬜⬜🟩:    7 🟨⬜🟨🟨⬜:    7 ⬜🟨🟨🟨⬜:    7 🟨🟨🟨⬜⬜:    7 🟨⬜🟩🟩🟨:    6 
🟩⬜🟨🟩⬜:    6 ⬜🟩🟩⬜🟩:    5 🟩🟩⬜⬜🟨:    5 ⬜🟩⬜🟩🟩:    5 🟩🟩⬜⬜🟩:    5 🟨🟩⬜⬜🟨:    5 
🟩🟩🟩⬜⬜:    5 ⬜🟨⬜🟨🟩:    4 🟨⬜⬜🟩🟩:    4 ⬜🟩🟨⬜🟨:    4 🟩🟩⬜🟩⬜:    4 🟨🟨⬜⬜🟩:    4 
🟩⬜🟩🟨🟩:    4 ⬜🟩🟨⬜🟩:    3 ⬜🟩⬜🟨⬜:    3 🟩🟨⬜🟨⬜:    3 🟩⬜🟩🟩🟩:    3 ⬜🟨🟩🟩🟩:    2 
🟩🟨🟩⬜🟩:    2 🟨⬜🟨🟩🟩:    2 ⬜⬜🟩🟩🟨:    2 🟩🟩🟨⬜⬜:    2 🟩🟩⬜🟩🟨:    2 🟨🟩🟨⬜⬜:    2 
⬜🟩⬜🟩⬜:    2 ⬜⬜🟩🟨🟨:    2 🟩🟨⬜🟩⬜:    2 ⬜🟨⬜🟩🟨:    1 ⬜🟩🟨🟨🟨:    1 ⬜🟨🟨⬜🟨:    1 
🟩⬜🟨🟩🟩:    1 ⬜🟨⬜🟨🟨:    1 🟩🟨🟨⬜🟩:    1 ⬜🟨🟨🟩⬜:    1 🟨🟩⬜🟨⬜:    1 🟩🟩🟩🟩🟩:    1 
🟨🟩⬜⬜🟩:    1 🟩🟨⬜🟩🟨:    1 ⬜⬜🟨🟩🟨:    1 🟩🟩🟩⬜🟩:    1 🟨🟩⬜🟩⬜:    1 🟨⬜🟩🟩🟩:    1 
🟨🟩🟩⬜🟨:    1 ⬜🟩🟨🟩⬜:    1 🟨🟨⬜🟩⬜:    1 ⬜🟨🟩🟩⬜:    1 🟩⬜🟩🟩🟨:    1 ⬜🟩🟨🟨⬜:    1

This means that, if we pick smile, we can get 101 different resulting patterns. The largest group we’re left with contains 316 words. So by guessing this single word, we can eliminate most of the words.

If we do this for all the words, my algorithm gives back that raise is the absolute best first word. This word returns 107 different patterns and the worst case is that we have 168 words left after the initial guess.

Another good candidate would be slate, this splits the words into more groups: 129. But the worst-case is a little bit worse, leaving just 221 words.

After `raise`, repeat.

After our first guess, we just continue with the following guesses. We calculate which words are still left and we go over all the words to find the one that gives us most information about the target word. Also: Don’t limit yourself to using/guessing just the possible words. For example look at the following case:

tares: 🟨⬜⬜⬜⬜
pilot: ⬜🟩⬜⬜🟨
dunsh: ⬜⬜⬜⬜🟩

There are now still eight possible words:

hitch, fifth, witch, aitch, bitch, fitch, gitch, mitch

Instead of guessing one of these words, often getting just a single piece of information… it’s much better to guess the word awful. This guess splits the possible words into 5 groups:

🟩⬜⬜⬜⬜: aitch
⬜🟨⬜⬜⬜: witch
⬜⬜🟩⬜⬜: fifth
⬜⬜🟨⬜⬜: fitch
⬜⬜⬜⬜⬜: hitch, bitch, gitch, mitch

If we get ⬜🟨⬜⬜⬜ in return we can conclude that the only option left to guess is witch and we’re done 🟩🟩🟩🟩🟩.

This algorithm allows me to solve all words within the given 6 tries you get with Wordle. For a single move I think this algorithm is optimal. However, we might be able to do better if we consider multiple moves into the future. It should be possible to extend this, build a tree and check the depth.

Perhaps raise is great for a single move, eliminating a lot of options, but what if the largest (worst-case) group is very hard to break up after that?

I haven’t tried to figure this out… but perhaps you will? What other algorithms can we come up with?

Bot tournament…?

Perhaps we can host a tournament where we have bots playing Wordle, taking turns solving and giving the opponent a next word to solve. We can even make the bots smart enough to recognise and counter certain words and/or tactics.

Sounds fun :)

Divide by three using shift and add

Fri, 31 Dec 2021 09:01:25 +0100

Today I stumbled across this excellent short video bij Mathologer:

This simple proof shows that 1/3 is the same as: 1/4 + 1/4^2 + 1/4^3 + 1/4^N…

As a programmer I wanted to try and program this.

Dividing by multiples of two (like 4^3) is extremely easy in binary, we just shift a number to the right. So if you have some integer X and we want to divide by 4, we do X >> 2, if we want to divide by 4^2 we shift X >> 4 etc.

This means we can just add these fractions together and approximate the result, just by dividing (shifting) up to >> 30 for an integer (which is 32-bit).

        int bignr = 612644632;

        // Approximate Using: 1/3 = 1/4 + 1/4^2 + 1/4^3 + etc
        int divless = (bignr >> 2) + (bignr >> 4) + (bignr >> 6) + (bignr >> 8) +
                (bignr >> 10) + (bignr >> 12) + (bignr >> 14) + (bignr >> 16) +
                (bignr >> 18) + (bignr >> 20) + (bignr >> 22) + (bignr >> 24) +
                (bignr >> 26) + (bignr >> 28) + (bignr >> 30);

        System.out.println(bignr + " / 3     = " + (bignr / 3));
        System.out.println(bignr + " + magic = " + divless);

        // 612644632 / 3     = 204214877
        // 612644632 + magic = 204214872 <- close, a bit too low

The accuracy isn’t great… but it’s pretty close. We’re always a bit below the actual sum because for each part we add, we lose a bit of information which we’re shifted away. To counter this we could first add things and shift the final result, making the accuracy a bit better:

        int bignr = 612644632;

        // Approximate Using: 1/3 = 1/4 + 1/4^2 + 1/4^3 + etc
        int divless = (bignr + (bignr >> 2) + (bignr >> 4) + (bignr >> 6) + (bignr >> 8) +
                (bignr >> 10) + (bignr >> 12) + (bignr >> 14) + (bignr >> 16) +
                (bignr >> 18) + (bignr >> 20) + (bignr >> 22) + (bignr >> 24) +
                (bignr >> 26) + (bignr >> 28) + (bignr >> 30)) >> 2;

        System.out.println(bignr + " / 3     = " + (bignr / 3));
        System.out.println(bignr + " + magic = " + divless);

        // 612644632 / 3     = 204214877
        // 612644632 + magic = 204214876 <- off by one haha

Probably a useless trick, but fun nonetheless.

Hex grid in single integer

Tue, 28 Dec 2021 11:19:31 +0100

AZsPCs: AP Math

Al Zimmermann hosts awesome Programming Contests every once in a while. They usually run for a long time (multiple months) and it allows mathematicians and programmers to compete in optimization problems. Usually the search space is very large and optimal solutions aren’t found for large N-values.

This time the contest was called “AP Math” and the goal was:

Given a hexagonal grid of size N, select the maximum amount of cells so no three cells form an arithmetic progression.

During this contest I didn’t find the right way to attack the problem, but I did discover a clever way to store all the hex coordinates in a singe integer value and do the math on that; which I wanted to share here.

Arithmetic progression?

The main goal in the contest is to select cells in a hex grid with this one rule “no three cells form an arithmetic progression”.

What does this mean? If you look at the example above for a N=3 hex grid you can see that we have to select cells, with the rule that no two points can have another cell in between, on the mid point.

Look at this website for more examples and a complete description: AP Math.

So to find solutions, we need a way to store the coordinates of this hex grid and a way to determine given two cells, which other cells are illegal.

Storing coordinates as single 32-bit integer

There are multiple ways to store the coordinates of an hexagonal grid. The best write-up I’ve found is located at redblobgames.com. I’m using an axial grid, so each coordinate has an x and y value.

But instead of working with an x and y value, I’m storing each coordinate as a single 32-bit integer.

To generate all of them I used the following (Java) code:

int N = 11;
int S = N + N - 1;

Set<Integer> indexes = new HashSet<>();
// Generate all hex points: (as single int)
for(int x = 0; x < S; x++) {
    for(int y = 0; y < S; y++) {
        // Cut off the two triangular edges to make a hex grid:
        if(x+y >= (N-1) && x+y < (3*N - 2)) {
            indexes.add(x << 16 | y);  //<-- store all the positions x, y both into a single integer value.
        }
    }
}

As you can see, I’m storing x and y in a single integer value, shifted 16 bits.

Now you might ask: how is storing each coordinate as a single 32-bit value useful? What does it add?

Well, suppose we have two coordinates from the complete list of all hex grid coordinates mentioned above. With these two indexes in our hex grid we can do the following:

// A bitmask to check for even numbers
int BOTH_EVEN_MASK = 1 << 16 | 1;

if (((index1 ^ index2) & BOTH_EVEN_MASK) == 0) {
    // Points index1 and index2 has the following midpoint:
    int invalidMid = (index1 + index2) >> 1;
}

int invalid1 = (index2 << 1) - index1;
int invalid2 = (index1 << 1) - index2;

Using very limited control code and little math we can calculate all three points that are needed for this contest. Given just the two coordinates we get the two or three points that are invalidated. This is much faster than any other coordinate system I tried. A single subtract of two indexes gives the x and y of the new point: less work for the CPU.

Turns out, I didn’t even need to use the actual x and y values anywhere, I could stay in this coordinate-system while searching. If you want to though, just mask and shift:

int x = index >>16 & 0xFFFF;
int y = index & 0xFFFF;

This was my little ‘hack’ for this contest. I might be able to use this xy as a single integer on more occasions, in other contests. It’s a nice tool to have in the toolbox.

royvanrijn

Vibe-mathing: the Generalized Vanishing Conjecture

Straight into: Mathematics

The tweet…

A conjecture with an infinite premise

The long route through exact computation

Two moving Newton faces

Then the conjecture broke completely

From a witness to an all-order Lean theorem

What (I think) I learned

Links

The Anatomy of an LLM

The Anatomy of an LLM

Introduction to Java Notebooks

Maven support

Data processing with jandas

Hosting your own Notebooks

Wake up!

They do exist…

Perfect for: https:://dev.java

Solving the daily calendar puzzle

Solving the puzzle

Improve solving speed

Links

All The Music: the Megamix

Using a de Bruijn sequence

Setting to work

Really? Every song?

Is this better?

Roadtrip to Ludolph van Ceulen

Calculating Pi

Before Newton

Archimedes method

Ludolph van Ceulen

Visiting Leiden

From Wordle to Nerdle

Nerdle

Generating the guesses

Patterns

Bugs/problems

Results

An algorithm for Wordle

Eliminate by frequency

Most information per guess

After raise, repeat.

Bot tournament…?

Divide by three using shift and add

Hex grid in single integer

AZsPCs: AP Math

Arithmetic progression?

Storing coordinates as single 32-bit integer

After `raise`, repeat.