template<std::ranges::range R>
void f(R&& rg) {
  bool b = std::ranges::is_heap(rg, std::greater<>());
  assert(b);
}

int a[] = {1,2,3,4,5};
std::vector<int> v = {1,2,3,4,5};
f(a);
f(v);
f(std::views::iota(1, 6));
f(std::vector<int>{1,2,3,4,5});

with non-templated code like this:

// This is not a function template!
void g(std::ranges::any_view<int, std::ranges::any_view_options::random_access, int> rg) {
  bool b = std::ranges::is_heap(rg, std::greater<>());
  assert(b);
}

g(a);
g(v);
g(std::views::iota(1, 6));
g(std::vector<int>{1,2,3,4,5});

Because there are so many different flavors of range, any_view takes a few template parameters to specify what kind of range you mean — just like std::function takes a function signature as a template parameter to specify what kind of function you mean. In the example above, we specify that g takes a type-erased copy of a random-access view of a range of int. The third template parameter forces the copy’s reference type to int (as opposed to int& or const int&), for the benefit of views::iota.

any_view inherits from std::ranges::view_interface, so it gets many convenient member functions for free. For example,

using enum std::ranges::any_view_options;
void g(std::ranges::any_view<int, random_access, int> rg) {
  assert(rg.front() == 1);
}

because view_interface provides front whenever its iterator category is forward-or-better. Recently on std-proposals it was noted that back is different:

void h(std::ranges::any_view<int, random_access | sized, int> rg) {
  assert(rg.back() == 5);  // error
}

You might think rg.back() would be defined as equivalent to rg[rg.size()-1] — perfectly well-defined for a sized random-access range as we have here — but in fact it’s defined as *prev(rg.end()), which is well-defined only for common bidirectional ranges. (Recall that a common range is one where end() returns the same iterator type as begin(), so that prev(end()) is legal. For a general, non-common, range, end() is allowed to return a sentinel that doesn’t support arithmetic.)

The problem is already addressed inside the views::common adaptor itself. Ordinarily, to make a non-common range into a common_view, you basically have to turn every iterator into a variant — a common_iterator<I, S> — that can hold either an iterator or a sentinel, and you represent views::common(rg).end() as common_iterator<I, S>(rg.end()). Since a common_iterator value might hold a sentinel, common_iterator itself can’t support decrement; it is always at best a forward iterator. But, in the special case where rg is a sized random-access range, views::common(rg) does not use common_iterator: in that case views::common(rg).end() is represented as rg.begin() + rg.size(). Godbolt:

struct UnsizedRA {
  int *begin();
  std::unreachable_sentinel_t end();
};
UnsizedRA r1;
std::forward_iterator auto it1 = std::views::common(r1).begin();
static_assert(sizeof(it1) > sizeof(int*));

struct SizedRA {
  int *begin();
  std::unreachable_sentinel_t end();
  int size() const;
};
SizedRA r2;
std::same_as<int*> auto it2 = std::views::common(r2).begin();

So, from the C++ user’s perspective, the way to deal with the absence of any_view::back() in this odd corner case is simply to feed your sized random-access any_view to views::common:

void h(std::ranges::any_view<int, random_access | sized, int> rgin) {
  auto rg = std::views::common(std::move(rgin));
  static_assert(std::random_access_range<decltype(rg)>);
  static_assert(std::sized_range<decltype(rg)>);
  assert(rg.back() == 5);  // OK
}

LWG 4003 asked whether we should “improve” the definition of view_interface::back() so that it’d work if either of the expressions *prev(rg.end()) or rg[rg.size()-1] were valid. However, that direction was rejected, because it was rightly pointed out that while this would solve the inconsistency in the API of view_interface (and therefore any_view), it wouldn’t solve the basic inconsistency that right now the C++ user can create a range type (like SizedRA above) that is

• random-access,
• sized,
• but not common.

Unfortunately, the library can’t exactly forbid such a type. At best it could amend some concept definitions so that SizedRA would fail to be a sized_range — but that seems silly, because SizedRA definitely does provide size(), and failing to recognize that fact would just silently pessimize a bunch of Ranges algorithms.

I have the same pet peeve about random_access_range’s requiring operator[]. If you forget to provide it, then your type just quietly degrades to a bidirectional range, pessimizing some algorithms but not necessarily failing to compile.

Alternatively — but this is a crazy idea — the library might amend the definition of ranges::end(rg) to return a different type in this case, so that SizedRA would become a common range! Given the current wording:

Given a subexpression E with type T, let t be an lvalue that denotes the reified object for E. Then:

• […] if T is an array type, ranges::end(E) is expression-equivalent to t + extent_v<T>.
• Otherwise, if auto(t.end()) is a valid expression whose type models sentinel_for<iterator_t<T>>, then ranges::end(E) is expression-equivalent to auto(t.end()).
• Otherwise, if T is a class or enumeration type and auto(end(t)) is a valid expression whose type models sentinel_for<iterator_t<T>> […] then ranges::end(E) is expression-equivalent to that expression.

we might remove the first bullet point and then add one at the end like:

• […] if ranges::begin(t) + ranges::size(t) is a valid expression whose type is iterator_t<T>, then ranges::end(E) is expression-equivalent to that expression.

I say “remove the first” because ranges::size(t) is already equivalent to extent_v<T> when T is an array type; this amendment would just generalize the array case. Core-language arrays are already a kind of type that provide a begin (sort of) but no iterator-returning end (in fact, no end at all); this amendment would handle other kinds of ranges that provide a begin but no iterator-returning end.

I say “add one at the end” because ranges::size itself already has a bullet point defining ranges::size(rg) in terms of ranges::end(rg) - ranges::begin(rg), and we don’t want a circular dependency there. The bullet point in ranges::size basically enforces that any random-access common range is by definition sized (as long as you go through ranges::size instead of t.size()); the proposed bullet point here would enforce that any random-access sized range is by definition common (as long as you go through ranges::end instead of t.end()).

One obvious problem — and I bet there are also less obvious ones — is that the amendment above would make

struct NotCurrentlyARange {
  int *begin();
  int size();
};

into a Ranges range, even though it wouldn’t be iterable by a core-language for-loop. The mismatch between core-language ranges and library Ranges is already arguably a problem: see “When ranges::for_each behaves differently from for” (2024-12-09). Let’s not make the existing problem worse!

Since piping a sized random-access range through views::common already Does The Right Thing, and since trying to use back() on an any_view is already a super niche problem, I’m inclined to think the status quo is perfectly acceptable. But, at the same time, since we can’t forbid types like SizedRA at the language level, and since trying to “fix” them at the level of ranges::end is crazy, and since view_interface::back admittedly doesn’t work quite right… why not just fix view_interface::back in the way LWG 4003 originally proposed?

Basically, the issue is that if you have a recipe in your Makefile like this:

ser:
    make -C subdir

and then you run make -j4 ser, recent versions of GNU Make will give a warning (jobserver unavailable: using -j1). And you’ll lose the parallelism you wanted, because the “jobserver” (basically, the -j option) isn’t forwarded to the child make. And, incidentally, it won’t necessarily use the same make binary that you invoked; it’ll run whatever make happens to be in your path.

You can fix all three of those issues by prefixing + to the recipe line, or (since that feels uncomfortably magical) replacing make with $(MAKE). More on this at the end of the post. Now that we’re forwarding the “jobserver” properly, I wondered, how exactly do the various -j options interact, when you specify one degree of parallelism on the command line and another in the recursive recipe?

Here’s the pair of Makefiles I used for my test:

detab -E -4 - >Makefile <<EOF
ser:
    make -C subdir
par2:
    make -j2 -C subdir
par4:
    make -j4 -C subdir
par:
    make -j -C subdir
serplus:
    +make -C subdir
par2plus:
    +make -j2 -C subdir
par4plus:
    +make -j4 -C subdir
parplus:
    +make -j -C subdir
sermake:
    $(MAKE) -C subdir
par2make:
    $(MAKE) -j2 -C subdir
par4make:
    $(MAKE) -j4 -C subdir
parmake:
    $(MAKE) -j -C subdir
EOF
mkdir subdir
detab -E -4 - >subdir/Makefile <<EOF
all: one two three four five
one:
    echo 'one' && sleep 1 && echo 'ONE'
two:
    echo 'two' && sleep 1 && echo 'TWO'
three:
    echo 'thr' && sleep 1 && echo 'THR'
four:
    echo 'fou' && sleep 1 && echo 'FOU'
five:
    echo 'fiv' && sleep 1 && echo 'FIV'
EOF

Then I tested running make ser, make -j2 ser, etc., on various versions of Make available to me.

Here’s GNU Make 3.81 (on OS X). The number in each cell indicates the number of recipes running in parallel. The four rows marked with a dagger † differ among the versions of Make I tested; those idioms are “non-portable” and IMHO should be avoided in practice.

In the table above, “b” indicates this warning:

$ make -j2 par2
make[1]: warning: -jN forced in submake: disabling jobserver mode.

GNU Make 4.0 (on Debian 8.11):

In the table above, “a” and “b” indicate these two warnings, respectively:

$ make -j2 ser
make[1]: warning: jobserver unavailable: using -j1.  Add '+' to parent make rule.

$ make -j2 par2
make[1]: warning: -jN forced in submake: disabling jobserver mode.

GNU Make 4.2.1 (on Rocky 8.10) and GNU Make 4.3 (on Red Hat 9 or Ubuntu 22.04) tweak the latter error message to include the value of N:

$ make -j2 par
make[1]: warning: -j0 forced in submake: resetting jobserver mode.
$ make -j2 par2
make[1]: warning: -j2 forced in submake: resetting jobserver mode.

and also change the behavior of rows par, parplus, and parmake:

Warning “a,” which explicitly tells you to “Add '+' to parent make rule,” will indeed always vanish if you prefix the make-containing line with +, like this:

serplus:
    +make -C subdir

I find that solution as uncomfortably magical as prefix @ or prefix -. (Personally, I’d rather see “|| true” at the end of a recipe line than a magic “-” at the beginning.) A solution that’s less magic-looking (although equally magic under the hood, apparently) is to use $(MAKE), like this:

sermake:
    $(MAKE) -C subdir

Neither method silences warning “b,” about “resetting jobserver mode,” though.

What we really want is a row that would look like fantasy below. But at the moment, it seems we have to choose our preferred tradeoff from one of the quoted rows, instead.

struct MyLengthilyNamedClass {
  int i_;
  int f(this MyLengthilyNamedClass self) { return self.i_; }
};

You can shorten each member function declaration at the expense of some repetitive boilerplate up front:

struct MyLengthilyNamedClass {
  using Self = MyLengthilyNamedClass;
  int i_;
  int f(this Self self) { return self.i_; }
};

Sebastian Wittmeier observes that we can eliminate that boilerplate’s error-prone repetition of the class name MyLengthilyNamedClass by using C++26 Reflection:

struct MyLengthilyNamedClass {
  using Self = [: std::meta::current_class() :];
  int i_;
  int f(this Self self) { return self.i_; }
};

Thibault Ricord-Marchal observes that because the values of defaulted template arguments are evaluated in the context of the “caller,” rather than where they appear lexically, we can even factor out that boilerplate to the top level:

template<std::meta::info R = std::meta::current_class()>
using Self = [: R :];

struct MyLengthilyNamedClass {
  int i_;
  int f(this Self<> self) { return self.i_; }
};

Now, in these toy examples, I see no reason to prefer any of the above snippets over the simple idiomatic implicit-object-parameter member function we’ve been writing since the dawn of time:

struct MyLengthilyNamedClass {
  int i_;
  int f() const { return i_; }
};

But notice the difference in calling convention. Our first four snippets pass self by value, while the ordinary f() const needs to do a memory load through the this pointer. I could just barely imagine a situation where that cost mattered. (Godbolt.)

I imagine one might find other uses for Self<>. Off the top of my head, it provides a way to shorten some of the boilerplate of special member functions:

struct MyLengthilyNamedClass {
  MyLengthilyNamedClass(const MyLengthilyNamedClass&) = default;
  MyLengthilyNamedClass& operator=(const MyLengthilyNamedClass&) = default;
};

P2952, coming soon to C++29, will permit auto’ing the assignment operator’s return type:

struct MyLengthilyNamedClass {
  MyLengthilyNamedClass(const MyLengthilyNamedClass&) = default;
  auto& operator=(const MyLengthilyNamedClass&) = default;
};

But with Self<>, you could shorten fully three of the four repetitions (Godbolt):

struct MyLengthilyNamedClass {
  MyLengthilyNamedClass(const Self<>&) = default;
  Self<>& operator=(const Self<>&) = default;
};

I wouldn’t want to see that in my own codebases. But it’s an idea.

After populating the board with 40 random pyramids from the stash such that no two adjacent pyramids share a color, your goal is to use the fewest moves to finish the game — where a “move” swaps two pyramids of the same color and/or size, and the game is “finished” when each color occupies its own contiguous region of the board.

The official rules encourage you to finish the game within 27 moves, mainly because the Pyramid Arcade box happens to contain 27 more pyramids, and you use those to keep score. If the game had said “within 23 moves,” then you could have used the 23 leftover colored pyramids to keep score instead.

How many possible Color Wheel setups are there in total?

A quick Monte Carlo experiment (source) suggests that there are about \(2.003\times 10^{46}\) distinct Color Wheel setups, up to rotation and reflection. There are another \(2.195\times 10^{49}\) distinct midgame positions (i.e. positions flouting setup’s no-color-adjacency criterion). Both kinds of positions have an average branching factor of roughly 327 (standard deviation about 5).

What fraction of Color Wheel setups are solvable within 27 moves? Within 23?

I have no idea. Pretty trivially we can observe that every Color Wheel game must take at least six moves to complete: The game starts with 40 connected components, and the best possible move replaces 8 components with 2. Five perfect moves could reduce the number of components to 10, but a solved board has even fewer (no more than 7).

It’s easy to construct a valid setup that’s solvable in seven moves. I doubt that any valid setup is solvable in six.

How about the number of moves that suffices to solve any setup — what’s God’s Number for Color Wheel? I’ve got only another trivial observation: the 40 pyramids on the board can be selection-sorted into any configuration at all using no more than 39 unconstrained swaps, and any unconstrained swap can be simulated by at most 5 valid moves. (If the pieces match in size, swap them in one move; otherwise, if any of the six pieces that share color with one and size with the other is on the board, use three swaps; otherwise, find \(p_1, p_2\) of the same size, \(p_1\) sharing color with one and \(p_2\) sharing color with the other, and use five swaps.) That gives us a comically loose upper bound — 195 moves certainly suffice.

Challenge: Write a Color Wheel solver.

Here’s a vibe-coded Color Wheel solver that can do the average board in about 33.8 moves (standard deviation about 4.5); the worst case I’ve seen so far took 50 moves. This is dramatically worse than the rules’ suggestion of 27 moves! Is that more readily explained by the badness of this solver’s heuristics, or by the conjecture that most Color Wheel boards are not solvable in 27 moves?

The Python code that generated that plot was:

import matplotlib.pyplot as plt
plt.hist(values, bins=[x-0.5 for x in range(20, 52)], edgecolor="white", color="#4f81bd")
plt.xticks(range(20, 51, 2))
plt.xlabel("Number of moves taken by the heuristic solver")
plt.show()

In [my previous book’s] chapter about “The Second Thoughts of Poets” … I fathered on Babbage a delightful emendation of two lines in Tennyson’s “Vision of Sin,” which I now restore to its rightful author. The emendation is to be found in Letter vii. of The Competition Wallah. It is attributed to “a friend who is passionately devoted to the study of the laws of sanitation and mortality. He carries his enthusiasm on the subject so far as to tinge with it his view of every conceivable matter — religious, political, and literary. He once wrote an anonymous letter to the Laureate, commenting on the lines in the Vision of Sin:

Every moment dies a man, / Every moment one is born.

He observed, with great truth, that if this statement were correct the population of the world would remain stationary, and urged the poet to alter the lines thus:

Every moment dies a man, / And one and one-sixteenth is born.

He owned that the exact figure was one, decimal point, ought, four, seven; but (as he said) some allowance must be made for metre.” I must hope that Sir George Trevelyan will forgive me for having invested his jeu d’esprit with a mythical origin.

Indeed the anecdote, exactly as quoted, appears in George Trevelyan’s The Competition Wallah (1864), at the end of the seventh letter, titled “About Calcutta and its Climate.” This comic essay was first published in Macmillan’s Magazine 9:49 (November 1863), pp. 117–135, datelined “April 12, 1863.”

The false attribution to Babbage was likely originated by David Ker in Harper’s Magazine 81:483 (August 1890), p. 486. Ker presents his version as a “story, which, if not literally true, certainly deserves to be so.”

The attribution may have been suggested by the fact that Babbage had authored in 1826 A Comparative View of the Various Institutions for the Assurance of Lives (a treatise on the mathematics of life insurance), which originated this widely reprinted observation:

Nothing is more proverbially uncertain than the duration of human life, when the maxim is applied to an individual; yet there are few things less subject to fluctuation than the average duration of a multitude of individuals. … Among the inhabitants of a kingdom, the uniformity is such, that the excess of deaths in any year above the average number seldom exceeds a small fractional part of the whole.

See also:

• “Pray-Mister-Babbage problems” (2018-09-26)

struct A {
  static constexpr size_t size() { return 42; }
  int data_[size()];
};

The problem is that the size (and therefore the type) of data member data_ can’t be computed until we know the value of size(); but evaluating size() requires A to be complete ([class.mem.general]), which won’t happen until the closing brace on the next line.

One workaround, obviously, is to repeat the magic number 42 in two places. That’s probably the simplest option; but here are a few other workarounds.

Do the work in data_ instead of size()

struct B {
  constexpr size_t size() const { return std::size(data_); }
  int data_[42];
};

This one matches my advice in “The ‘array size constant’ antipattern” (2020-08-06). Sadly, now that size() depends on data_, we must make size() a non-static member function. We can actually fix that by exploiting a quirk of unevaluated operands:

struct C {
  static constexpr size_t size() { return sizeof(data_) / sizeof(data_[0]); }
  int data_[42];
};

std::size(data_) treats data_ as meaning this->data_, and requires a this pointer. But sizeof(data_) treats data_ as meaning C::data_, and is able to tell us the size of that member “hypothetically,” without associating it with any particular C object. Likewise sizeof(data_[0]), and even complicated expressions like decltype(data_ + 1) — as long as the id-expression appears inside an unevaluated expression. This is specified in [expr.prim.id]/4.3 (via N2253 “Extending sizeof to apply to non-static data members without an object,” 2007).

This approach is great when the array bound is just 42, but it’s not so great when the array bound is computed and lengthy to spell out. In that case, we might want a different workaround.

Introduce a static constexpr helper variable

struct D {
  static constexpr size_t N = 42;
  static constexpr size_t size() { return N; }
  int data_[N];
};

Notice that we can make size() return N, but we cannot flip it around and make N initialized to size()…

struct D_does_not_work {
  static constexpr size_t size() { return 42; }
  static constexpr size_t N = size(); // error
};

…for the same reason as the original failure. The value of N must be known at that point, while the class type is still incomplete and size() is still not evaluable.

Put the size computation outside the class

Obviously this is fine:

static constexpr size_t E_size() { return 42; }
struct E {
  static constexpr size_t size() { return E_size(); }
  int data_[E_size()];
};

Put size() in a base class

This is also fine:

struct Base {
  static constexpr size_t size() { return 42; }
};
struct F : Base {
  int data_[size()];
};

Here size() refers to Base::size(), and Base is a complete type. Perhaps surprisingly, there’s an order dependency here: If you declare an F::size() before the declaration of data_ then you’ll be right back in case A, and get an error. But you can declare a new meaning for F::size() after the declaration of data_, and the compiler won’t complain. (Should you do so? No. Is it IFNDR to do so? Possibly; I’m not sure.)

Turn size into a data member

See “The new static constexpr integral_constant idiom” (Jonathan Müller, August 2023). You can actually do this:

struct G {
  static constexpr std::integral_constant<size_t, 42> size = {};
  int data_[size()];
};

Here size() is not a function call, requiring a complete G; it’s an evaluation of the operator() of a static data member, and data members (unlike member functions) are perfectly usable in incomplete-class contexts.

This is maybe the cleanest-looking workaround out of all of these. But it seems like a bad idea for social reasons; your coworkers will not expect size to be a static data member instead of a member function!

In fact, C++26 Reflection might eventually make this a bad idea for technical reasons too: surely many Reflection-based libraries will do things like “loop over all the member functions of G” without considering that some of G’s member functions might be hiding among its static data members. Notably, Ryan Keane’s type-erasure library rjk::duck doesn’t understand this idiom. (Godbolt.)

Another surprising detail of this workaround is the redundant “={}.” Try leaving it off; the code means the same thing (“default-initialize this object”), but the compiler will no longer accept it! For historical reasons, C++ rejects any attempt to default-initialize a const variable unless you put the initializer really explicitly in the code. For some types, like int, this makes perfect sense:

int x;        // OK
const int x;  // rejected, reasonably enough

but for other types it’s frankly annoying:

std::true_type x;       // OK
const std::true_type x; // rejected for no good reason

See “Implementation divergence with const int i; and mutable” (2019-12-04).

A core-language variation on this idea is to use a lambda, which incidentally removes the redundancy:

struct H {
  static constexpr auto size = [](){ return 42; };
  int data_[size()];
};

The auto keyword cannot be used to declare non-static data members, but static data members (as here) are fair game: this version works in C++17 and later. (Before C++17, the lambda’s operator() isn’t constexpr, so that size() isn’t a constant expression.)

Conclusion

I wish there were a clear winner out of all these sub-par options. I’ve placed them basically in the order I’d recommend them, starting with the most straightforward and finishing with the one I found to have the greatest number of identifiable disadvantages. (Which is too bad, because it’s also very clever!)

Draw a 4-by-4 grid. Colour each square red or blue. Select any square, S, and write 1 in it. Then write 1 in every square you can reach from S by a series of moves, where each move is from a square to an adjacent, horizontally, vertically, or diagonally, square of the same colour.

Select any empty square, T, and write 2 in it. Then write 2 in every square you can reach from T by a series of moves. Repeat this procedure for 3 and then 4 and so on until every square has a number. The last number you write down is called the “score” for that colouring. If we imagine the grid is the map of a farm, then you have divided the map into fields, one field for each number.

(1) What is the largest score possible?

(2) If we work with a 5-by-5 grid, what is the largest score possible?

In brief: What is the maximum number of queenwise-connected monochromatic regions you can make by coloring each square of an \(n\times n\) grid either red or blue? If we were asking about rookwise-connected regions, the answer would obviously be \(n^2\). But queenwise-connected is at least slightly less obvious!

For the 5-by-5 grid, the “obvious” answer is

rBrBr
BBBBB
rBrBr
BBBBB
rBrBr

for a total of 10 regions. But the answer for 4×4 is not simply

rBrB
BBBB
rBrB
BBBB

for a total of 5; you can in fact make 6 regions! (Once you’ve seen the trick it’s hard to unsee; but I didn’t see it at first myself.)

Discussion on the SeqFan mailing list tentatively produced the sequence: 1, 2, 5, 6, 10, 12, 17, 19, 26, (28?)… Here’s the pattern for odd \(n\), and a conjectured pattern for all even \(n>4\).

For odd \(n\): \(\lceil n/2\rceil^2 + 1\) regions. For even \(n>4\): \(\lceil n/2\rceil^2 + 3\) regions.

was ignorant of the dispute two years ago when he developed a competitive crossword game called Pago Pago and first became aware of crossword fans’ passion for the pastime.

“Guilbert invented the crossword-based game Pago Pago” is repeated in Thomas Frisbie, “Fan passes word on puzzle hall of fame” (Chicago Sun-Times, 1988-08-14). (Thanks to Ben Zimmer for identifying the article!) But that’s all I can find in print about Pago Pago.

Helene Hovanec’s article “Robert Guilbert’s Crossword Academy” (CROSSW RD, Nov/Dec 1992) contains no text about Pago Pago, but does include this uncaptioned photograph of Guilbert (1911–1990) hard at work:

David Steinberg of the “Pre-Shortzian Puzzle Project” blog has mentioned Guilbert several times in connection with Guilbert’s short-lived Crossword Academy, and even received in 2016 a very nice blog comment from Guilbert’s son Jonathan and a little more via email. Jonathan wrote, in part:

In the photo he can be seen working on a puzzle that he designed as a “Moebius Strip” — an “Infinity Crossword Puzzle” — a puzzle without a beginning and an end. He was going to have this game manufactured and marketed under the name “Pago Pago,” I believe.

Personally I suspect that Jonathan’s hunch was wrong: that the Möbius-strip puzzle and the “Pago Pago” puzzle-game (whatever its nature was) were two separate projects. However, apparently on the strength of Jonathan’s guess, the Möbius–Pago Pago hypothesis was reproduced as fact in Adrienne Raphel’s dissertation “The Crossword Mentality in Modern Literature and Culture” (Harvard, 2018): “In 1986, Robert Guilbert, a former ad copywriter from Milwaukee who enjoyed spending his retirement doing the puzzle, invented a game called Pago Pago, an infinite crossword on a Möbius strip, and began to peddle it around to crossword fans.” The same sentence appears in Raphel’s book Thinking Inside the Box (2020). The game of telephone continues in Natan Last’s Across the Universe (2025): “he’d invented a game called Pago Pago, an infinite crossword on a Möbius strip, and wanted to hawk it to the greats.”

UPDATE, 2026-08-13: Actually, Guilbert had already gotten Pago Pago into circulation long before these articles were written! The July 1986 issue of GAMES magazine has a review of Pago Pago (Garden City, New York: Just Games). Indeed there’s no Möbius element; the game is simply a pack of 24 William Lutwiniak crosswords plus rules for up to four players to complete a set of grids competitively: fill squares for three minutes, then pass the grid to your left and fill squares in your opponent’s old grid. Whoever fills in the most squares correctly (“with penalties for errors and bonuses for correcting opponents’ errors”) is the winner. The game has an entry on BoardGameGeek, and as of this writing you can buy a copy for $25 on eBay. (Thanks to Virginia Downes for this information!)

But what does a crossword on a Möbius strip look like, anyway? said I to myself.

Presumably it would be a crossword that loops around on itself from bottom to top (and vice versa). A crossword that does that on all four edges would be “toroidal,” like this one (which I found on Keith Calkins’ “tori crosswords” page, although I infer that Jeff Weeks was the author):

Jeff Weeks has made a bunch of these; see this PDF from MoMath. In fact he’s even made crosswords “on a Klein bottle.” Here the right and left edges connect as before, while the top and bottom edges connect with a Möbius half-twist.

The above crossword is neat because despite being 5x5, its two longest entries are 9 letters each. But it’s less than perfectly satisfying in that half of the Across entries read right-to-left; and in that if it actually wrapped around on itself with a half-twist, wouldn’t the letters wind up backwards too? Then 6-Down wouldn’t be MESSENGER but rather MESSENGER, and so on. (2-Down mirror-reverses very nicely, though!)

Now, a real mathematical Möbius strip, says Martin Gardner,

is what topologists call “nonorientable.” Imagine the strip to be a true surface of zero thickness. Embedded in this 2-space are flat creatures that are mirror-asymmetric (not identical with their mirror images). If such a creature moves once around the band to rejoin his fellows, he will have changed his parity and will have become a mirror reflection of his former self.

If our “flat creatures” are the letter-forms of the crossword entries, then when the crossword loops around on itself the letter-forms will change parity: S becomes S, and so on. So the only letters we seem to be able to use are the vertically symmetric ones, and we’ll have great difficulty constructing any crossword more complex than the following infinite jest:

Or we could loop horizontally with horizontally symmetric letters (HEEHEEHEE…). But to create entries that aren’t infinitely long, we should create a diagonal “ladder” of words instead — as I fancy I see Robert Guilbert doing in that photo! If our “ladder” runs diagonally down and left, like this:

  ABC
 DEF
GHI

then we’ll be able to use letters whose axis of symmetry is on that 45-degree line, such as (of course) O and X, but also L: “LOX” horizontally will flip to produce “XOL” as one of the Down entries. In fact we can also use W, which (if you draw it just right) flips to become E; H, which flips to become I (with serifs); C, which flips to become U; and even D, which (with long serifs) flips to become a nice round capital A. This gives us enough degrees of freedom to create the following Möbius-strip crossword:

Print out this strip and tape the ends together with a half-twist. Fill it out with a heavy ink marker and you’ll find you only need to solve the first five clues — then you can flip the strip over and read off the answers to the last five clues in the letter-forms that have bled through the paper! (Or hold the back of the paper up to the light; or, for the really lazy, just lay a mirror alongside it.)

Mine is not a good crossword. Not only does it have awful fill, it repeats entries: six of the Acrosses are repeated among the Downs. But it was the best three-letter ladder I could find even with computer assistance. My dictionary of possible answers consisted of only 23 pairs of words. (Remember, every Across entry flips into a Down entry: if we have LAW across, we necessarily get EDL down. And since EDL isn’t a word, LAW isn’t in our dictionary either.) Words mirrorable this way of more than three letters are rare as hen’s teeth: HOWL flips into LEO I, ALOE into WOLD, and ALOUD into A COLD; that’s about all.

Can you come up with a better Möbius-strip crossword? or do you have additional information on Robert Guilbert’s Pago Pago and Möbius-strip projects? Email and tell me about it!

See also:

• “Fully Schrödinger crosswords” (2025-01-03)

Ford’s canto, like Dante’s, is exactly 136 lines of pure terza rima, containing a few impressively novel rhymes and many powerful images. Notably Ford finds room to expand Dante’s Oh felice colui cu’ ivi elegge! from one line into three.

Just halfway through my own trip in our living,
Provisional, short world, I found that I
Had lost my path — woods dark and unforgiving
Making my way so hard that I must sigh
If I would say how brutal was that wood,
To think on which will always horrify.
If anything, it’s only dying could
Outdo that acrid wood’s malignity.
But I will turn from horror, towards that good
Which also on that pathway, luckily,
I found, though I can’t say what hid all truth
Away in total blank stupidity.
I cannot work out how it was, in sooth,
That in that gloom awaking, full of stupor,
I’d lost that saving road I took in youth.
I got at last to what you’d call a croup or
Boundary of that dark and dismal hollow,
A bank of rocks transforming hill-wall to floor.
To that bluff’s scapula my look did follow
Upwards still that guiding morning glow,
Bright from that star so holy to Apollo.
Thus did that anxious horror, which had so
Brought churning with it, all that awful night,
To my soul’s pool, diminish, calm its flow.
And as a man who pants hard, still in sight
Of billows which, almost, brought him to sink,
From land looks back on that main, full of fright,
So did my spirit, panicking, still think
On that grim pass no mortal human can
Go out of without passing living’s brink.
At last my body pausing for a span
Until invigoration from that stop
Could now allow it motion, though no plan
Could show it how to go, with constant prop
On foot in back and downwards, sought to gain,
By climbing always upwards, that mount’s top.
And lo! A cougar stood stock still, though plain
Its quick and light agility. No turning
Could pass it by. Upon its skin a rain
Of spots, which I, that bright and airy morning
(As sun and star-companions Loving God
Had first spun, still did spin) saw as adorning
That cat, a sign of succor I might laud,
During that blissful dawn, but not so bright
That I did not start shaking, on that road,
At what was now arising in my sight:
A lion, drawn up high, intimidating,
So much that air and I, both full of fright
About how it its stomach might start sating,
Must stop — for what? A wolf; and I was pavid,
So skinny was it, though anticipating
It would sup soon on anything, for avid
It was for food: though lank it was full too:
That wolf so ruinous to man was gravid!
And I was too — with fright! I could not do
What I was hoping for — to climb that hill.
Alas, I found no pathway round nor through.
And as a man who’d got just what his will
Saw as most worth wishing of all things,
Now gasps on losing it, a poignant thrill
Of brutal pain, transfixing with its stings
From that wolf, did I sob at, and I shrank
Darkwards, away from Sol’s loud blazonings.
Back did I go, back to that lowland dank.
Abruptly in my sight shows up a man,
Who, dumb so long, I thought would sound as blank
As our surround was. Straight to him I ran,
Still crying “Pity!” to him, “Man or shadow
Of a man!” “Not a man, but Mantuan,
By birth,” was his account, “born sub Julio,
But it was good Augustus, though his gods
Did not say truth nor know your Christian Trio,
Who was my king. My song got many nods,
All praising it as Roman history,
From Trojan loss to gain, against all odds,
From burning Ilion to victory.
But why do you avoid that joyous mountain,
As though to climb you’d no ability?”
“Now art thou Virgil? That riparian fountain,”
All blushingly I said, within his sight,
“Of words that all who follow find a sound in
Which our own songs would sing too? If I might,
I’ll say how much I honor you, what study
I sanctify with loving to your light.
But now look on that animal so bloody,
To you I turn for aid, to you I’m flying.
O horror!” “You must go this path, though muddy,”
Did Virgil say, to try to hush my crying,
“If you would from this dark wood find a way.
For past that wolf can no amount of trying
Attain that goal; whoso will try will pay
With his annihilation; hungrily,
Voraciously that wolf puts him away.
Marrying many animals bodily,
It looks to go on doing so, until
A Sighthound, coming with finality,
Shall bring its pain to culmination, kill
That awful wolf, who did not pity show.
That hound, consuming not, such is its will,
Things of this world, but only what would go
With wisdom — loving all morality —
In fabrics of Franciscan monks will know
His nation. Savior of low Italy
That hound is, land for which Camilla, dying
A maid, and Nisus, and his loving ally,
And Turnus, all lay down for good. Now plying
Its way through any town that it might harry,
That wolf cannot avoid damnation, buying,
Through vicious rivalry, a day to tarry,
So soon to finish. So I think it right
That I conduct you, and that you stay wary
As onwards through this always-lasting night
You go, with sounds of always-lasting sorrow
Imploring total dying, not this blight.
But going through, I will bring you tomorrow
To souls who, though in pain, stay happy with it,
Hoping to pay back soon what sin did borrow
And climb salvation’s mount to that first orbit
To which I must not go. But if you will
You’ll find at that hill’s top a worthy spirit,
Which I am not, as I did not fulfill
Writs laid down by that just, all-causing King,
Combatting what was law. His codicil
About my task thus says: I may not bring
A pilgrim to his city. Though his might’s
Ubiquitous, from that city starts its ring
Circling all worlds. O happy, any sights
Of Him; most so, who in that city strong
Find bright salvation in its million lights.”
And I to him: “I pray, by your high song —
And by that God you did not know, I pray —
That you will as conductor, for as long
As you can do so, bring us on that way
Of pain, at last to portals which saints hallow,
And far from this soil’s sorrow.” With no stay
On did Virgil go; downwards did I follow.

  —Kinton Ford, 2020 or 2021

Editorial notes: I adjusted some little punctuation relative to the Exquisite Pandemic text. For example I removed a comma before “About how” and a period after “stay wary,” changed a semicolon after “dank” to a period, and inserted commas around “though in pain.”

Though I didn’t alter them above, the confusing lines “a poignant thrill / Of brutal pain, transfixing with its stings / From that wolf, did I sob at, and I shrank / Darkwards” seem to detach the phrase “from that wolf” a bit too much from “I shrank.” One might take this as a cleverly jarring bit of textual iconicity (“I” literally retreating behind the “sob” to get away from the “wolf”), and/or one might prefer to imagine something more straightforward like “…stings, / Brought sobs; and, wolf advancing, so I shrank” or “…stings, / Shot through my gut, and from that wolf I shrank.” I also find some disorder in the sentence beginning “Upon its skin a rain,” but I’m less sure what might be done about that or even whether anything ought to be done, beyond maybe changing the comma after “dawn” to a semicolon.

The amount and quality of intelligence utilized in the working out of cross-word puzzles almost precisely equal those that were revealed some years ago when an amazing — and discouraging — army of Americans filled the newspapers that cater to such folk with triumphant solutions of an arithmetical problem concerning the age of a supposititious Ann — a problem that any eighth-grade boy or girl who is “all there” should have solved in his or her head in about thirty seconds.

The older I get, the more sense it makes when the phrase “some years ago” turns out to refer to something from two decades back. The problem, apparently first published in the New York World circa 1903-10-09,^[1] goes like this:

Mary is 24 years old. She is twice as old as Ann was when Mary was as old as Ann is now. How old is Ann?

(A writer to the Montgomery (Alabama) Advertiser of 1903-10-24 points out that you can get the apparently-most-common wrong answer if you read the puzzle incorrectly as “She was twice as old as Ann was when Mary [sic] was as old as Ann now is.”)

The New York Evening Post (quoted in the Princeton (Minn.) Union) opined:

“Wherever it may have originated — and this is itself a matter of controversy — the problem concerning the ages of Ann and Mary has caught the country’s fancy as few such things have since ‘Pigs in Clover.’ ”

Billboard (1904-02-20): “The question ‘How Old Is Ann?’ has been dramatized and was staged at White Plains. Barney Gerard, the author, makes Ann a mischievous little girl, who refuses to go to school. The school authorities get after her to punish her but must first find out how old she is. Complications result.” • The New York Evening World (1903-11-17): “ ‘How Old Is Ann?’ is the title of a new song which Frank Daniels sang last night at the Victoria Theatre. When the opening lines sounded the audience settled back in its seats with a sigh of relief. ‘At last,’ it meant just as if it was expressed in words, ‘we are going to find out how old that cussed sister of Mary is.’ But they didn’t, and there’s where the fun came in. The song has a rattling chorus and a catchy tune.” • Cartoonist Ed F. Flinn fingered Ann as the cause of the Panamanian secession. • The World of 1903-11-07 “revealed” the perpetrator of the problem as one “Mr. Perkin Warbeck, of Newark, N.J.”

The Philadelphia North American published “the answers of a few leading Philadelphians.”

“I don’t see why that simple question is puzzling anybody. I knew Ann is 12 years old as soon as I saw the problem,” said Frank R. Shattuck. “There is no other solution, I tell you. Look here, I’ll explain it to you. Mary is 24 years old. She is twice as old as Ann — that’s a cinch. Of course, then, Ann is half Mary’s age, or 12 years. There ought to be a comma after ‘Ann,’ though.”

It was suggested to Mr. Shattuck that there was no comma in the problem.

“Doesn’t make any difference,” replied he promptly. “Let’s see — twice as old as Ann ‘was.’ That ought to be ‘is’ — as Mary was when Ann is. I’m not mixed up. I tell you, Ann is 12.”

Not to be outdone, the New York Evening World published on 1903-11-09 and 1903-11-10 the answers of “many prominent men of New York,” including:

Policeman Bert Gallagher: “Ann is old enough to know better than not tell her age when she knows how much trouble her silence is causing. She ought to be ashamed.”

John T. Meehan: “Ann was ninety years old. I know, because she and her brother shook hands with Lafayette on his visit to New York in 1824. Old Peter was the steward of the beanery for forty years, and he was ninety-two when he died; Ann was three years younger. He and Ann used to sell newspapers on the Vesey Street corner during Jackson’s first term. Why, Ann was— Oh, that World question about the girl who’s twice as old as herself? I haven’t time to fuss with that. I thought you were talking about old Peter Rose’s sister Ann.”

Timothy P. Sullivan: “Just twice as old as she was when Mary was twice as old as Ann. That’s easy. Six years ago Mary was eighteen and Ann was thirteen. To-day Mary is twenty-four and Ann is nineteen. Figure it out for yourself. Don’t you see that if Mary is twice as old as Ann was when Mary was— I mean twice as old as Mary when Ann was half as old as Mary, consequently— but there, let the professors figure it out. It’s as bad as ‘when is a mice when it spins.’ ”

The Wyoming Tribune of 1903-10-28 calls it “No Puzzle At All”:

Anyone could figure it out if they would stop to think. Ann is 16, of course, because if Mary is twice as old as Ann was, all you have to do is to find out when. Now she is 24, Ann’s age was 12, or twice six. Mary is now four times six, which being divided by six, gives four. Add this to twelve, and there you are. —Smith.

adding:

When Mary had a little lamb, she was twice as old as Ann was when Ann was as old as Mary now claims to be. How old is the sheep? —James Barton Adams.

A correspondent for the Kansas Journal wrote:

Constant Reader,
Ann is sixty-three years of age. Obviously, Ann is as old now as Mary was when Mary was half as old as her present age less the age of Ann at the time she was half as old as Mary was when she was twice as old as Ann is, unless you figure that Ann was half as old as if she were twice Mary’s present age, less Ann’s age when she was twice as old as Mary is now, or twenty-four. Twenty-four and fifteen are thirty-nine, and twenty-four and thirty-nine are sixty-three, which represents Mary’s present age subtracted from half of Mary’s age at the time she was half as old as Ann. I would not solve this problem for any one but a constant reader.

The Washington Times of 1903-10-27 prints an anonymous poet’s take:

I used to be contented and took comfort in my life,
I dwelt in deep placidity, removed from care and strife,
I never worried as I jogged along my even way,
I worked a bit, I slept a bit, and still had time for play;
I never had such things as nerves; my brain was clear and cool,
But now I am a nervous wreck, and soon will be a fool.

It came about in this wise: One fell day a genial friend,
Whose mind is full of whist and chess and problems without end,
Propounded in a guileless way a problem which, to scan,
Seemed simple: All you had to do was find the age of Ann.
Now, Ann is Mary’s sister, which you’ve no doubt heard before,
And Mary— it is impolite, but Mary’s twenty-four.

Now, Mary’s twenty-four, and she is twice as old today
As Ann was when her sister was — that is, of course, to say,
When Mary was — as old as Mary’s sister Ann is now.
Which brings the question up to you: What’s Ann’s age, anyhow?
That’s what my friend propounded, and I answered, at a pinch,
“The problem you propound, sir, is dead easy — it’s a cinch.”

I worked all day upon it, and I also worked all night,
But somehow that confounded thing would never come out right:
At first I figured it that Ann was twelve, then eight, then ten,
And then I twisted it around and worked it out again.
This time I learned, to my dismay, that figures disagree:
That although Mary’s twenty-four, her sister’s sixty-three!

I raved and swore; my hair I tore; I vented all my spleen
Upon some luckless wight who said that Ann was sweet sixteen.
I’ve worried nights, I’ve worried days, I cannot eat my meals;
I jabber those confounded words until my poor brain reels;
If this thing keeps up many moons, good-bye, old world — farewell!
For me ’twill be the welcome grave, or else the padded cell.

(A less entertaining, but more democratic, sampling of “Ann” correspondence appears in the Evening World of 1903-11-11.)

The craze was short-lived. By 1903-12-21 “Prof. Josh M. A. Long” of the Society for the Prevention of Cruelty to Humor was advertising in the World for any information as to “the whereabouts of ‘How Old Is Ann?’ Has been missing about ten days. Recently released from the Old Jokes’ Home, last heard of in Harlem.”

Footnote: Or in the New York Press of 1903-10-12, signed “John Mahon,” if you believe a column from 1937 (Bellefonte (Penn.) Democratic-Watchman 1937-11-26; South Hill (Va.) Enterprise 1937-12-23). Or maybe the Press of 1903-10-16 (Highland (Va.) Recorder 1951-10-05).

But the true story, as relayed by William J. Lampton in a Scrap-Book article titled “The Vicissitudes of a Problem” (August 1906), is that “How old is Ann?” first appeared in the Newark Evening News of 1903-04-21, headlined “Stories of the Town.” The author was one Robert D. Towne; and when the meme didn’t catch at first in Newark, he tried again, Lampton says, by sending it to the Philadelphia North American and signing it “Perkin Warbeck.” Towne certainly let it be known that he was the “Ann” man (1, 2, 3), earning his obituary a spot among Time magazine’s “Milestones” of 1952-03-03.

Now hear this, from the Sequachee Valley (Tenn.) News of 1903-10-29:

A man is twice the age his wife was when he was the age she is now. When she reaches his present age, their combined years will be 100. Find the age of each.

See also:

• “What is 8÷2(2+2)?” (2019-08-01)