Seeking Alpha

Four points sit at the corners of a square. Each of the top two can be labelled with one of eight letters, A to H, and each of the bottom two with one of three letters, J, K and L. Between each pair of points there are coloured connectors, shown on the left of the figure below. You label exactly two of the points, leave the other two blank, and choose one connector between the two points you labelled, subject to two rules.

• If the two letters are the same, you cannot use a yellow connector.

• You can use the blue connector only when the bottom points have the same letter.

Two diagrams are equivalent if they are reflections of each other: C at the top left joined by yellow to J at the bottom right is the same diagram as C at the top right joined by yellow to J at the bottom left. How many distinct (non-equivalent) diagrams can you make?

The Fiddler, Zach Wissner-Gross, October 30, 2026(original post)

The official solution appears in the post of November 6, 2026, which had not been published when this chapter was written. The answers here are my own.

Solution

There are six pairs of points: the top edge, the bottom edge, the two sides and the two diagonals. A diagram is a pair, a letter at each end and a connector. Before worrying about reflections, count the diagrams with the square held still, pair by pair.

One observation keeps the rules simple. Top letters (A to H) and bottom letters (J to L) never overlap, so two labelled points can carry the same letter only when both are on top or both are on the bottom. On a side or a diagonal the letters always differ, yellow is always allowed, and blue is not on offer.

• Top edge (green or yellow). Of the $8 \times 8 = 64$ ways to letter it, $56$ use two different letters and may take either connector, and $8$ repeat a letter and must take green. That gives $56 \times 2 + 8 = 120$.

• Bottom edge (yellow, green or blue). Of the $3 \times 3 = 9$ letterings, $6$ use different letters and may take yellow or green (blue needs equal letters), and $3$ repeat a letter and may take green or blue (yellow is barred). That gives $6 \times 2 + 3 \times 2 = 18$.

• Each side and each diagonal (yellow or red). Any of $8 \times 3 = 24$ letterings with either connector: $48$ each, $192$ for the four.

So there are $120 + 18 + 192 = 330$ diagrams on the fixed square.

Now the reflections. A top point can only hold A to H, so a reflection must keep the top on top, and the only one that does is the mirror in the vertical line through the centre, which swaps left and right. Mirroring twice gives back the original, so it splits the $330$ diagrams into mirror pairs, except for the diagrams that are their own mirror image. Those stay single.

Which diagrams are their own mirror image? The mirror sends a side to the other side and a diagonal to the other diagonal, so no diagram on those can be. It maps the top edge to itself but swaps its two letters, so a top-edge diagram is unchanged only when both letters are the same: $8$ of them, all green. The same goes for the bottom edge: $3$ equal letterings, each with green or blue, so $6$ diagrams. In all, $14$ diagrams are their own mirror image.

The remaining $330 - 14 = 316$ diagrams fall into $158$ mirror pairs, each of which counts once. Adding the $14$ singles, $$\boxed{\ 158 + 14 \;=\; \frac{330 + 14}{2} \;=\; 172 \text{ distinct diagrams.} \ }$$ The middle form is Burnside’s lemma in its smallest case: with a single symmetry, the number of distinct objects is the average of the number of objects (here $330$) and the number the symmetry leaves fixed (here $14$).

The computation

The check builds every diagram straight from the rules and lets the computer do the pairing. It lists every pair of points, every lettering of the pair and every connector shown on that pair, drops those that break a rule, and stores each survivor as a set of (point, letter) pairs together with its colour. A diagram and its mirror image become one class, and the classes are counted.

from itertools import product

TOP, BOTTOM = "ABCDEFGH", "JKL"
# points: 0 top left, 1 top right, 2 bottom left, 3 bottom right
LETTERS = [TOP, TOP, BOTTOM, BOTTOM]
CONNECTORS = {                       # read off the puzzle's figure
    (0, 1): ["green", "yellow"],
    (2, 3): ["yellow", "green", "blue"],
    (0, 2): ["yellow", "red"], (1, 3): ["yellow", "red"],
    (0, 3): ["yellow", "red"], (1, 2): ["yellow", "red"],
}
MIRROR = {0: 1, 1: 0, 2: 3, 3: 2}    # left-right reflection

def diagrams():
    """Every labelled diagram: (labelled points, connector)."""
    for (p, q), colours in CONNECTORS.items():
        for a, b in product(LETTERS[p], LETTERS[q]):
            for c in colours:
                if a == b and c == "yellow":
                    continue         # first rule
                if c == "blue" and a != b:
                    continue         # second rule (blue is on
                                     # the bottom edge only)
                yield frozenset({(p, a), (q, b)}), c

def mirror(d):
    points, c = d
    return frozenset((MIRROR[p], x) for p, x in points), c

labelled = set(diagrams())
classes = {frozenset({d, mirror(d)}) for d in labelled}
print("labelled diagrams:", len(labelled))
print("equal to their own mirror image:",
      sum(d == mirror(d) for d in labelled))
print("distinct diagrams:", len(classes))

It prints

labelled diagrams: 330
equal to their own mirror image: 14
distinct diagrams: 172

Extra Credit

Take the list of $172$ distinct diagrams, one from each mirror pair, and give each diagram a fixed “secret” letter at each of its two blank points (A to H on top, J to L on the bottom), so that every listed diagram carries four letters. Each round of a game generates a random diagram: each top point gets one of nine letters A to I, each bottom point one of four letters J to M, two points chosen at random become secret, and one of the four connectors between the two visible points (right of the figure) is picked at random. Grey is worth $0$ points, yellow $1$, red $\sqrt2$, green $\sqrt3$, and blue $\sqrt6$ if it joins identical letters and $0$ otherwise. If the generated diagram matches a listed diagram exactly (all four letters, which two are visible, the orientation with no reflection allowed, and the connector’s colour), you score its connector’s points; otherwise you score nothing. On average, how many rounds do you play for each point you earn?

Solution

The idea is that every listed diagram is a single, fully specified outcome of the random experiment, and all those outcomes are equally likely. Count the outcomes. The four letters can be chosen in $9 \times 9 \times 4 \times 4 = 1296$ ways, the visible pair in $6$ ways and the connector in $4$ ways, all uniformly and independently, so there are $1296 \times 6 \times 4 = 31104$ equally likely outcomes. (On the top edge two of the four connectors are grey, and they count as two outcomes that score nothing.)

A listed diagram corresponds to exactly one of these outcomes. Its letters are all among the nine and four on offer, its visible pair is one of the six, and its connector colour appears exactly once on that pair in the game’s figure: green and yellow on top; yellow, green and blue on the bottom; yellow and red on the sides and diagonals. No listed connector is grey. Different listed diagrams differ in something visible, so no outcome matches two of them. A generated diagram that is the mirror image of a listed one scores nothing, because the list holds only one diagram of each mirror pair and reflections no longer count.

So each listed diagram is hit with probability $1/31104$, and the expected score per round is $$E \;=\; \frac{S}{31104},$$ where $S$ is the total of the point values of the $172$ listed diagrams. Neither the secret letters nor the choice of representative changes $S$: a diagram and its mirror image have the same connector. Every blue connector in the list joins two equal bottom letters, so each is worth $\sqrt6$. Adding by pair, with one representative from each mirror pair:

• Top edge: $28$ unordered pairs of different letters, each with yellow and green, give $28(1 + \sqrt3)$; $8$ repeated letters with green give $8\sqrt3$.

• Bottom edge: $3$ pairs of different letters, each with yellow and green, give $3(1 + \sqrt3)$; $3$ repeated letters with green and blue give $3(\sqrt3 + \sqrt6)$.

• Sides: the left side and the right side are mirror images, so one represents both: $24$ letterings with yellow and red give $24(1 + \sqrt2)$. The two diagonals give the same again.

These are the $64 + 12 + 48 + 48 = 172$ diagrams, and $$S \;=\; 79 + 48\sqrt2 + 42\sqrt3 + 3\sqrt6 \;\approx\; 226.977 .$$ Over many rounds the points earned per round average $E$, so the rounds played per point earned approach $1/E$: $$\boxed{\ \frac{31104}{79 + 48\sqrt2 + 42\sqrt3 + 3\sqrt6} \;\approx\; 137.0359992 \ }$$

The number is the joke. The inverse of the fine-structure constant, the dimensionless strength of the electromagnetic force, has the recommended value $137.035\,999\,177$ with a standard uncertainty of $0.000\,000\,021$. ¹ The game’s answer, $137.035\,999\,190$, sits within one standard uncertainty of it. The post links to an announcement, made that week, of a physical theory said to predict this constant with no free parameters, and the game is the puzzle’s wink at it: the title promises alpha, and a counting rule delivers it.

The computation

The check plays out all $31104$ equally likely outcomes against an actual list. It reuses the enumeration from The computation above to get the $172$ classes, picks one member of each and gives it random secret letters. Then it runs through every lettering, every visible pair and every connector of the game’s figure (with grey listed twice on top), scores each outcome by the rules and adds the points exactly with sympy.

import random
from sympy import sqrt

# one representative per mirror pair, with fixed secret letters
random.seed(30)
listed = set()
for cls in classes:
    points, c = sorted(cls, key=repr)[0]
    letters = dict(points)
    for p in range(4):
        letters.setdefault(p, random.choice(LETTERS[p]))
    visible = frozenset(p for p, _ in points)
    listed.add((tuple(letters[p] for p in range(4)), visible, c))

TOP9, BOTTOM4 = "ABCDEFGHI", "JKLM"
EC_CONNECTORS = {                    # read off the second figure
    (0, 1): ["grey", "green", "yellow", "grey"],
    (2, 3): ["grey", "yellow", "green", "blue"],
    (0, 2): ["blue", "yellow", "red", "grey"],
    (1, 3): ["grey", "red", "yellow", "blue"],
    (0, 3): ["grey", "yellow", "red", "blue"],
    (1, 2): ["grey", "yellow", "red", "blue"],
}
VALUE = {"grey": 0, "yellow": 1, "red": sqrt(2), "green": sqrt(3)}

total, outcomes = 0, 0               # every outcome equally likely
for letters in product(TOP9, TOP9, BOTTOM4, BOTTOM4):
    for (p, q), colours in EC_CONNECTORS.items():
        for c in colours:
            outcomes += 1
            if (letters, frozenset({p, q}), c) in listed:
                if c == "blue":
                    total += sqrt(6) if letters[p] == letters[q] else 0
                else:
                    total += VALUE[c]
print("equally likely outcomes:", outcomes)
print("total points over them:", total)
rounds = outcomes/total
print("rounds per point:", rounds.evalf(12))

It prints

equally likely outcomes: 31104
total points over them: 3*sqrt(6) + 48*sqrt(2) + 42*sqrt(3) + 79
rounds per point: 137.035999190

Changing the seed, and so the secret letters and the representatives, leaves the total unchanged, as the argument says it must.

---

1. CODATA 2022 recommended value of $\alpha^{-1}$, NIST, https://physics.nist.gov/cgi-bin/cuu/Value?alphinv, as of October 30, 2026.↩︎