Imperfect Chess

Or: How to Kill Robots in Your Spare Time

I liked chess when I was a kid, but didn’t love it. I was never eaten by it. Chess is one of those exotic sports that eats the brains of little boys, like figure skating or gymnastics eats the bodies of little girls. But not me. That’s because, in some indescribably deep place, I sensed that chess was broken.

So, following on a grand tradition of idiocy, I tried to fix it. The workshop existed mostly in my head, though it would occasionally leak onto the pages of those Mead composition notebooks, the kind whose covers looked like camouflage for a Grand Bovine War.

I easily filled up dozens of these suckers in the 80’s, and possibly hundreds. Many of the early volumes were dedicated to bad stories and bad poetry, others to half-remembered dreams and nightmares. Possibly some crossover. But by the end of the decade, a massive wing of my cowhide library was devoted to game design.

I’d switched to graph-ruled pages by then, using them as a kind of dot matrix printer for my mental files. Although I didn’t know jack shit about programming at the time, I would nevertheless plot out elaborate video games, using the grid squares for my pixel art, screen layouts, property lists, and behavior modes. I’m sure most of it was nonsensical, and it would be a hoot to dig one of those up. But I was a disorganized, reckless, and fickle kid, so I have hardly any record of my pre-teen youth. It was all lost in a fire called the 90’s.

But the mental files still exist, including from that long ago summer when I tried to fix chess. There was no internet back then, so the best we could do is stumble across books in shops and libraries. I vaguely recall paging through some collections of chess variants. Most of those involved minor rule changes, fairy pieces, rifle tactics, and so forth. Minor tinkering and superficial patch jobs, in other words. Nothing like the radical surgery I thought was warranted.

It was only many years later that I realized most of my own designs weren’t all that dissimilar to variants that already existed. One was almost a clone of Fisher/960/Freestyle chess, with shuffled poker cards used to randomly set each player’s home line. Another was essentially Benko’s Pre-Chess with Battleship-style hidden deployment (If I recall correctly, I used a cardboard screen between ranks 4 and 5 to simulate the “fog of war” during the setup phase).

In addition to alternative setups, I also experimented with mechanical changes. It seemed wrong to me that all pieces should be equally capturable, for instance, or that a single blundered piece should ruin a game. I also liked the idea of emphasizing the battle aspects of chess, in which a contest isn’t always decided by the first man to attack.

For example: one variant I called “Melee Chess” experimented with dual-occupancy of squares, representing a swirling, medieval melee in progress. To decide the outcome, each type of piece would be assigned a default numerical attack value. For instance, a pawn might attack with strength of 1, a bishop with 2, rooks with 3, and so forth (I don’t recall the actual strengths I settled on, except that I created special variable strengths for knights and queens based on position). Added to these starting values would be the strengths of other pieces that were supporting the attack on the dual-occupied square. If the values were equal, the melee would continue through the turn.

This was around the time I started fooling around with additional components, too. In one version of “Melee”, one or more coins could be secreted into the players’ hands, to be revealed simultaneously. The coins would then be flipped, with each “heads” result adding one attack point to their side of the contest. To keep the randomness to a minimum and add some strategic oomph, each player would be issued a limited supply of coins to spend on such contests.

I built other mutants in my chess garage, each one sillier and freakier than the last. Some variants were so bizarre they really couldn’t be called “chess” at all. Adding dice, adding hit-points, adding defensive “wall” pieces and multiple adjoined chess boards. That last game — “Castle Chess” — marked the beginning of the end. After that, I finally gave up on my maniacal quest, and started looking to modern wargames by Avalon Hill and Strategic Simulations to get my fix.

After much blood, sweat, and tears, I finally understood the problem wasn’t that chess was broken. The problem was that chess was perfect. It was a game of perfect information. Nothing about it was natively mysterious or unknown. Chess could therefore be “solved” in the mathematical sense. Even Chess960 could theoretically be solved, given enough time and resources. To my way of thinking, that made it boring.

So, while I never stopped liking chess, it was only in the nostalgic way we sometimes think of ex-lovers. Hard fought checkmates, memorable moves, but as detached from current sentiment as a Saturday morning cartoon show. It was only in the early 00’s, after I #LearnedToCode, that I began to peek in on her again from time to time. It no longer felt like catching up with a high school girlfriend, but rather visiting an elderly relative dying in the hospital. Thanks to several decades of software development, the ancient Game of Kings was finally put on life support.

Garry Kasparov loses to Deep Blue on May 11, 1997 (Peter Morgan/Reuters)

Kasparov vs Deep Blue was the canary in the coal mine. Watching this mighty grandmaster reduced to tearful rants and lawsuits was quite the sight, like John Henry’s Pyrrhic victory minus the victory part. “Sad,” as the Orange Man might bellow.

In 2006, after the programmers of Deep Blue’s German cousin Fritz humiliated Vlad Kramnik, I decided to return to the chess garage one last time. Unlike my future linguistic death matches with GPT, there was no animus on my part back then. The romantic arcade hooligan in me still wanted to Beat the Machine, I suppose. But Pragmatic Mark approached it more as an economic thought experiment. The game we would play wasn’t even chess, exactly. It was something more akin to a stress test.

I started from first principles:

Who is my opponent?

I came up with three candidates:

1. The Programmers

2. The Software

3. The Hardware

I could rule the first one out immediately. Even if taking a hatchet to some smelly MIT lab and settling business Jack Torrance-style could be counted as a “victory”, the program itself would still exist in its last updated, GM-trouncing form.

Could the software itself be attacked? Not directly, no. Hacking it might allow you to install a gremlin or two, I suppose, to throw some shoes in the gears or partially blind it. That would be cheating, however, and all “victories” over it would therefore ring hollow. At best, the codebase might contain weaknesses to be exploited. But that’s a strange way of putting it; an exploit doesn’t harm or weaken the program itself, because its substance is ethereal. Programs, in a manner of speaking, don’t exist, any more than a book could be said to exist without pages or printed words.

That left only one true opponent and strategic path to victory:

We attack the body of the Machine.

Before we begin, let’s get this out of the way: hardware/software analogies really piss me off. They tend to be retreads of the old mind/body problem, only stupider. For one thing, software doesn’t correlate to mind in any sensible way. It does not choose, because it does not want. AlphaZero doesn’t want to win chess games, any more than Babe Ruth’s favorite bat wanted to hit homeruns. We are dealing with a lattice of algorithms and pre-game training montages. When such a trained lattice presents us with a challenge, at best we could call it an animated puzzle. But animation doesn’t equate to mind either. Or at least, not necessarily. The resolution matters, too. Some organisms that appear to be inanimate are animate upon closer inspection.

Do there exist animate bodies without minds? Here, we could take a deep dive into the panpsychist argument (and I’ve been writing a rather long piece about exactly that subject). But for now, let’s stipulate that the answer is yes, when it comes to computational devices. In fact, we’ll go a bit further than animation here, and say that computer bodies are also metabolic. They require inputs of energy, which they then process and convert into observable action.

In this framework, we could see chess engines like Deep Blue or Stockfish as hylics: purely physical structures without essence. The computational golem walks and talks, but includes no aspect of mind. It is not alive, but shares certain existential requirements with living things. For instance, it must eat in order to produce its owner’s desired result, just as the car eats gasoline to squire you around town.

There are two ways to attack such a golem.

One method is to starve it (i.e. unplug the machine from the socket). But where’s the fun in that? Besides, that’s a trivial engineering problem to solve: just equip AlphaZero with an automatic gun turret and a command to shoot intruders on sight. Then we’ll see just who will be unplugging who!

The other method is to overload its carrying capacities. Like all bodies, the chess engine’s physical components can only carry so much weight, so fast. When it tries to lift and carry too much, too fast, we begin to see malfunction. At the very least, we will slow its operation down. In certain kinds of games, that’s not a problem. In competitive chess, slowness equals death. Or, failing that, the system may just be forced to expend more energy to perform the same FLOPs¹ or attain the same depth per second.

Because of these stress factors, a counter strategy can therefore be recontextualized as an economic attack on the golem’s programmers and financial backers. In order to maintain a competitive edge, they must build out the infrastructure of the monster’s body, and simultaneously find energy resources to power said expanded body. That’s why AI developers are looking to relocate next to nuclear reactors.

Note that expanded infrastructure isn’t the only way to respond to the attack. For instance, they could also invest in optimization, as Google did when developing its Tensor Processing Unit (TPU). But the efficiency curve isn’t infinite. “Zero point energy” is just a daydream for now, and might prove to be imaginary. The checkmate monster must be fed, and feeding it involves real costs.

In that light, bear this in mind: the remainder of this article isn’t really about chess.

If at any point you think you understand what this experiment was actually about, please DM me. Maybe I’ll give you a prize!

Or, more importantly, maybe we’ll have a good talk about what needs to be done, in the world to come.

---

The Hidden King

In 2006, I decided to base my design on beating Fritz: the robotic “champion” of the moment. No cow-camo notebooks were employed this time around, but neither was any deep math or heuristic models. Instead, I tried to intuit an elegant solution that wouldn’t require adding a bunch of additional rules or randomness.

First, I assessed Fritz’s body, at the time it defeated Kramnik.

Hardware:

• Ran on a dual-core Intel Xeon 5160 (3 GHz), estimated at ~8 cores total with hyper-threading.

• Evaluated 8–10 million positions per second (far less than Deep Blue’s ~100–200 million but more efficient due to software optimizations).

• ~2–4 GB RAM, supporting large hash tables for caching.

Not exactly Ultron or the Terminator. But it was still sufficient to beat a 2800 Elo grandmaster (Kramnik had a FIDE rating of ~2770 at the time).

Next comes the “brain” (but not really, LMAO).

Software:

• Minimax with alpha-beta pruning. Enhanced by null-move pruning, transposition tables, and selective search extensions.

• Evaluation function: handcrafted position weights, scoring material, king safety, pawn structure, and piece activity. Less complex than Deep Blue’s (~8,000 features) but well-optimized for commercial PC hardware.

• Opening book: Curated from grandmaster games.

• Endgame database: Access to 5-piece (and some 6-piece) Nalimov tablebases for perfect endgame play.

Again, this shit ain’t Skynet. Poor ol’ Fritzie can’t even “think” in the way modern engines built around neural networks can simulate thinking. But, as mentioned, the algorithm isn’t the target, and chess isn’t the game. We don’t want Fritz clobbering us with those horrifying endgame tablebases. In our game, the monster never gets that far, having lost on time or blunders long before that.

I knew at the outset I’d need to “break” chess in order to exploit the hardware’s weaknesses, but only mildly. My goal wasn’t to make a variant that would allow average chess players to outperform Fritz, but one where grandmasters would regularly smash it, due to the tactical essentials remaining untouched.

What I came up with was a game I called “Arthurian Chess.” In this variant, all of the standard rules of setup, movement, and capturing remain the same. The only difference is as follows:

1. At the start of play, each player secretly chooses which of their major pieces must be captured to win the game (i.e. a rook, a knight, a bishop, the queen, or the king).

Whichever piece-type you secretly choose will move and capture as usual. However, if your opponent captures a piece of that type you will instantly lose the game. In other words, those pieces count as hidden kings, in a manner of speaking.

Here, you might have a few reasonable questions. For instance:

What about announcing checks?

If you don’t know which of your opponent’s pieces is the ‘king’, then how will you know when you’ve placed it in check?

Here’s a dirty secret about chess: there is no such thing as “check.” The goal of chess is to capture the opposing King, period. Announcing check is just a gentlemanly innovation, reminding your opponent that he is in danger of losing the game on your next turn. The “rule” requiring a King to move out of check isn’t a rule at all. The announcement is just a way of making the endgame more pleasurable, so that an otherwise great game isn’t suddenly cut short by an epic blunder. As a game designer, I approve: games should be pleasurable.

Now that the identity of the target piece — the Arthur — is unknown information, we swap gentlemanly pleasures for enhanced suspense. We can only study our opponent’s behavior in the face of threats, and what he’s (seemingly) willing and unwilling to jeopardize.

When played over the board, the players can simply write their chosen Arthur’s identity on a scrap of folded paper. If one player is non-human, it’s up to the programmers to decide how their software engine chooses its Arthur.²

When I ran the numbers back in ‘06, it turned out that this single change would be enough to sufficiently strain the resources used to defeat Kramnik.

For a 3-minute move (as Fritz used in the Kramnik contests), the depth it would reach after 180 seconds would be significantly impacted. The inclusion of a hidden element would force Fritz to track scoring progress towards 5 goals (king, queen, bishop, knight, rook) instead of one, requiring ~10–100M evaluations/move to maintain accuracy. The 5× increased demand (~324M positions/move in 3 minutes at ~1.8M positions/second to maintain accuracy, vs. ~1.62B in standard chess). allows for ~10-14 p-ply searches — sufficient for tactical captures, perhaps, but not for deep strategies.

To demonstrate the increased computational demand for eval, let’s start with Fritz’s capabilities in Standard chess.

• Fritz evaluated ~8–10M positions/second.

• Positions/move: 9×10⁶×180≈1.62×10⁹=1.62 billion

• Depth: ~12–16 plies at 1.62B positions, yielding ~2800–2900 Elo.

In Arthurian Chess, we could say the evaluation cost is roughly five times the number of FLOPs, due to five potential goal targets instead of one:

• With an evaluation cost of k_c≈5, the new throughput is 9×10⁶/5 ​≈1.8×10⁶ positions/second.

• Positions/move: 1.8×10⁶×180≈324×10⁶=324 million

• Depth: ~10–14 plies at 324M positions (5× slower evaluations, ~2× more nodes), yielding ~2000 - 2500 Elo.

With ~324M positions, Fritz achieves ~10–14 plies to cover its ~10–100M accuracy needs. But to compete in live time, it must maintain ~180 seconds/move to balance clock management with tactical strength, avoiding rushed moves that will drop Elo significantly. Still good enough to beat my ass? Probably. Grandmasters? Not so much.

If you listen closely, you can almost hear the golem’s clay bones creaking.

But beyond evaluation metrics, Fritz faces a much deeper (bluer?) problem. The secret target creates uncertainty, unsuited to Fritz’s perfect-information minimax. It must now evaluate positions under 5 concurrent scenarios without dynamic belief updates to an inference model (e.g., inferring the queen as “Arthur” based on the opponent’s heavy defense).

So in a typical game of Arthurian chess, Fritz will presumably beat standard chess amateurs and club players (~1200–1800 Elo) with strong tactics, but lose to experts like Kramnik (~2800) who will exploit its static evaluation and inability to deduce secret targets based on intuition or inference. It will play aggressive, capture-focused games (~40–80 moves), outperforming the Deep Blue Brute due to efficiency and better heuristics. But it remains a bewildered field general on the Arthurian battlefield, out of its depth in a war with hidden goals.

This little project was just a bit of fun. After all, by 2006 I was working as a tech professional, and could predict where this “AI” gravy train was headed. The neural networks of the near future would quickly learn and dominate Arthurian chess, just as they had the standard version.

It would take much more than a steel-driving John Henry to stress those circuits, even if he were using Excalibur to drive. More like a brigade of John Connors wielding portable EMPs and mini-railguns. That’s the level of animated puzzle complexity we’d be facing, in such an absurd quest. Frankly, crafting a minor chess variant that could defeat a self-teaching chess engine is basically impossible.

Or is it?

---

The Next Victim

As far as I was concerned, Fritz was toast. Top players on the Arthurian competitive circuit would salivate when they heard its name, and the system would only get worse over time as players developed fresh strategies. Call it an early scalp for Magnus Robot Fighter, back before he even knew he was fighting the Machine War.

But 2006 was nearly twenty years ago. That might as well be the Dark Ages, when it comes to enhancements in computational power. For instance, AlphaZero currently uses 4 TPUs per move. With Arthurian Chess, and barring any unforeseen optimizations in AZ’s neural net and search algorithm, you’d at best be looking at a 2-5x increase at in requisite computational power to perform the same depth of efficient analysis. That might sound like a lot, but it’s trivial considering the reduced costs from optimization. and the megalithic corporations who bankroll such projects.

Worse, AlphaZero doesn’t need nearly the processing power it currently deploys to defeat us puny humans. Including this puny human.

My Magnus-From-Another-Mother takes such losses in stride. He isn’t trying to “beat” the machine, but rather uses it as a tool of learning. Carlsen is the best chess player alive today, and arguably the best who ever lived. He might also be situated at the apex of the curve, for all we know. Human resources are limited as well.

As for me?

Here in 2025, I still don’t love chess. And neural networks, while they show promise for many useful and beautiful applications, are proving themselves ontologically dangerous to humanity’s portrait of itself, and by extension that of all living creatures.

So, I recently headed back into the garage, and set to work on a variant that could beat the ever-loving shit out of Google's pet monster. Once again, the change had to be so minimal, it wouldn’t radically alter the way computers or human grandmasters play the game.

A question, for my longtime readers:

ĐØ ɎØɄ ₮Ⱨł₦₭ ł ₱ɄⱠⱠɆĐ ł₮ Ø₣₣?

The name of my new Variant is called “Lovers Chess.” The result in early modelling shows a demand of 80 to 400 additional TPUs from AlphaZero during active gameplay (vs. the measly 4 TPUs it uses currently) on 2025 hardware.

If you are curious to learn how to play Lovers Chess, and want to know the reason why its heuristic chokes out current-gen neural networks, please let me know by liking, sharing, subscribing, and all that jazz.

Seriously: even clicking “like” helps me get noticed by our mighty Substack overlord, Al Gore-Rhythm. But paid subscriptions would be better, so let’s sweeten the pot:

• Bonus #1: If I can get 5 paid subscriptions before May 1st, I will release Lovers Chess to the world.

• Bonus #2: I will also give those first 5 subscribers a sneak preview of some artwork from my upcoming crowdfunded game project.

That’s a fair deal, right?

Still no takers?

Fine. How about we sweeten it further:

The Cat in the Tinfoil Hat Sale!

If you sign up for a paid subscription before May 1, 2025, you will receive a 25% discount for your first 12 months.

That’s just $5.25 USD per month!

No commitments necessary. Cancel any time.

(offer details here)

Seriously, cancel ANY time. I can understand why you wouldn’t want to commit to a full year’s worth of payments: all those little recurring bills pile up.

But even a single month of a paid subscription would help me out, both financially and algorithmically. If you’ve enjoyed any of my writing over the past 3 years but have never contributed, now would be the time.

But wait, there’s more!

If you can’t bring yourself to sign up for a month (or worry that you’ll forget to cancel), consider a one-time donation at my tip jar site. It will also grant you access to my“Posts” section on the site, which includes some special content.

1. Floating-point operations per second.

2. I admit to plenty of snickering, whenever I placed myself in those engineering bays at IBM, or in some smelly lab in Boston. I pictured all those high IQ brainiacs suddenly realizing the prank I just played right out of the gate: if the identity of the opponent is blinded, the only possible solution is a goddamned dice roll. In other words, even a dummy like me could code that part in my sleep. Even the AGI cultists among them might blush.

Some might claim that it’s no different than the Prime Mover dilemma (i.e. the engine’s first move when playing with the white piece). But in order to solve that dilemma with any degree of accuracy, they needed to add another wing to their codebase (i.e. training data for known opponents, curated from a pool of active, living grandmasters). But playing against an anon in Washington Square Park, the only options are random or rote.