# Qubic: The Long Version (QC, Qubic Church)

## Qubic: The Long Version — Chapter 2. Axelrod’s Tournament

Source: https://qubic.church/books/qubic-the-long-version/02-axelrods-tournament
Author: QC · Publisher: Qubic Church · 2026

In June 2014, one person (more precisely, one exchange) had in its hands, for twentyfour hours, the technical capacity to destroy Bitcoin. He didn’t destroy it. The standard explanation — “it’s irrational to break the network you earn from” — is correct, but it doesn’t explain why it’s irrational. Because there are networks where breaking is profitable. There are situations where people destroy what they earn from. There are countries where elites kill the country they rule. There are relationships where partners methodically annihilate each other. Irrational? Yes. Happens all the time. So the question isn’t why GHash.IO didn’t attack. The question is: under what conditions does honest behavior become rational and cheating — not.

This turned out to be a concrete, technical, verifiable question. And the answer to it was first found not by a philosopher and not by an economist. It was found by a thirtyeight-year-old political scientist who in 1977 was sitting in his office at the University of Michigan, watching computer programs play chess.

This chapter is about what he eventually figured out. But to understand why his discovery matters for Qubic, Bitcoin, and everything we’ll be talking about later, we have to first break down one very simple game.

### The Prisoner’s Dilemma

Imagine that you and your accomplice have been caught. There isn’t much evidence on either of you — they can solidly prove only a minor crime, for which each of you will get a year. But the investigators suspect you pulled off something big together, and they want to prove it.

You’ve been split up into separate cells. An investigator comes to each of you and offers a deal.

“Listen. If your accomplice keeps quiet, and you give testimony against him — he goes down for five years, and you walk free. If you both give testimony — you both go down, but you get not five but three years each. If you both keep quiet — we won’t be able to prove the major crime, and each of you only gets a year for the minor one.” You sit in your cell and think.

If my accomplice keeps quiet — it pays for me to give him up. I walk, he goes down. If my accomplice gives me up — it also pays for me to give him up. I’ll get three years instead of five.

Any variant of his behavior leads to one conclusion: it pays me to give him up. The accomplice in the next cell over is thinking the same thing. And he too arrives at the conclusion: it pays for him to give me up.

In the end, you both give each other up and you each get three years. If you’d both kept quiet, you’d each have gotten a year.

That’s the Prisoner’s Dilemma. In its pure form, it looks like this: there are two participants, each can choose to “cooperate” (keep quiet) or “defect” (give up). The payoffs are arranged so that the individually rational choice is always to defect, but when both do it, both lose.

The game isn’t complicated. They came up with it in 1950 at the RAND Corporation — two mathematicians, Merrill Flood and Melvin Dresher, were trying to come up with an example that would stump the rational-behavior theories of the day. Their colleague Albert Tucker formalized it and gave it the story about the two prisoners, in which we know it.

Since then — for seventy years — this game has become one of the most studied objects in the humanities and social sciences. Because it turned out to be everywhere. Arms race — Prisoner’s Dilemma. It pays each country to build more weapons than the neighbor. But when everyone builds — everyone is worse off.

Tax evasion — Prisoner’s Dilemma. It pays each person not to pay. But when nobody pays — the state stops working.

Pollution of the environment — Prisoner’s Dilemma. It pays each factory to dump its waste in the river. But when everyone dumps — there’s no river left for anyone. Corruption, cartel collusion, overfishing, traffic jams, harvesting on common fields — everywhere the same structure. And everywhere — the same result: each person’s rational choice leads to a bad result for all.

John Nash, a mathematician from Princeton, in 1950 proved one unpleasant thing about this game and got a Nobel Prize for it. He showed that “both defect” is an equilibrium. Meaning: if you’re both in this state, neither of you benefits from a unilateral change of strategy. If my accomplice gives me up, and I decide to keep quiet — I lose. If I give him up, and my accomplice keeps quiet — he loses. Both giving up — stable. Not good. But stable.

The Nash equilibrium. The system stuck in a bad but durable state.

That was the diagnosis. The trap was described. Whether you could get out of it — for a long time there was no answer to that question.

### Michigan, March 1980

Robert Axelrod was the name of the man I mentioned at the beginning of the chapter. By 1977 he had been teaching at the University of Michigan for six years, had defended his PhD at Yale in political science in 1969, specialized in conflicts between states. Forty years old, son of Lithuanian Jews, he had spent his whole life on the question of how people manage to come to agreement at all.

Axelrod had a whole closet’s worth of papers on the Prisoner’s Dilemma. He’d read them all and was unhappy with them. The papers were mostly trying to prove one of two things: either that people in real life are “irrational” and cooperate contrary to theory, or that you have to change the payoff matrix — add a tax on defection, an outside arbitrator, something like that. Neither explanation satisfied him. He was interested in a concrete question. The game was run once — the rational move is to defect. Fine. But what if you run it many times? If two participants know they’ll be playing each other not for one round but for two hundred? Will that change anything?

Intuition suggested it should. If I defect now, and we’re going to play another one hundred and ninety-nine rounds, my accomplice will have many opportunities to take revenge on me. He’ll stop cooperating too. We’ll both get little. Most likely it’ll be more profitable to cooperate from the very start.

But how exactly? Which strategy in the iterated Prisoner’s Dilemma is the most profitable? The intuition wouldn’t formalize. Different theorists proposed different strategies — some complex, others simple — and no one could convincingly show whose was best.

Axelrod was at the time following computer chess tournaments. By the late seventies, chess programs had begun outplaying each other — and you could see that victory belonged to whoever had written the most complex, deep, multi-tiered algorithms. The programs were getting longer, smarter, more cunning.

And then a thought occurred to him.

What if you set up a tournament like that for the Prisoner’s Dilemma? Send out invitations to all the well-known specialists who had published on this game. Ask each of them to send in a program. A program in Fortran — a simple one, that takes as input what the opponent has done in past rounds, and returns a decision: cooperate or defect. Bring all the programs together in a single tournament, each with each, two hundred rounds. Tally the points. See who wins.

In 1977–78 Axelrod sent out the invitations. His assistant Jeff Pynnonen wrote, in Fortran, the environment in which the programs would play. By the start of 1980, fourteen programs had been received.

The senders were world-class specialists. Economists. Mathematicians. Political scientists. Psychologists. One sociologist. They had all been publishing papers on the Prisoner’s Dilemma for years. Each was convinced that his strategy was the best. Axelrod opened the envelopes. He read the code. And launched the tournament. What was in the envelopes I won’t retell all fourteen strategies. But it’s worth breaking down a few — to understand against what background the main thing happened.

One program always defected. The author reasoned this way: if the theory says the only equilibrium is “defect,” let’s just do that. The program got a guaranteed bad result against other defectors and an excellent one — if it ran into someone who always cooperates.

Another program always cooperated. The author reasoned: if everyone does that, everyone will be well off. The program played excellently with itself and against other cooperators, but constantly lost when running into defectors.

Some programs were cunning. One — a program by the name of JOSS — cooperated in ninety percent of cases after the opponent’s cooperation, but in ten percent of cases it randomly defected “as a test.” The author thought this would let it pick up a bonus from naive partners.

Another program — DOWNING — tried to model the opponent’s behavior. It assessed what was the probability that the opponent would cooperate after its defection, and what — after cooperation. If the opponent was predictable, DOWNING tried to exploit him. If not — it adapted.

Some programs were openly complex. One used regression analysis. Another — Markov chains. One program was seventy-seven lines long in Fortran — the author was proud of its multi-level logic.

And somewhere in the middle of an envelope from Toronto lay a program four lines long.

### The four-line winner

The program from Toronto worked like this:

First move — cooperate. Every following move — do what the opponent did in the previous move.

If the opponent cooperated — cooperate. If the opponent defected — defect. Next time, look again at what he did in response, and mirror.

That’s all of it. No modeling. No regression. No “when to exploit, when to forgive” logic. A mirror. Literally a mirror.

The author called it TIT FOR TAT — an everyday English expression. Though a more accurate name for what the program actually does would be: “mirror.”Axelrod saw this program, read the code — and decided someone had sent it as a joke. Then he looked at the sender’s name. This person didn’t like jokes.

His name was Anatol Rapoport.

Axelrod launched the tournament. Fourteen programs played each other, every one with every one, two hundred rounds each. Plus each played against itself. Plus one neutral program was added as a benchmark. All the points were counted. When the last round ended, the results were such that Axelrod rewrote his entire research program.

Tit-for-Tat won. By a wide margin.

Everything complicated lost. The long seventy-seven-line program took a middling place. JOSS with its random defections — below average. DOWNING with its modeling of the opponent — mediocre. Programs that always defected — at the bottom. Programs that always cooperated — also at the bottom, because they got exploited. Four lines of code from Toronto beat fourteen years of work by experts. The man from Lozovaya It’s worth pausing for a minute and telling who the man was who wrote the winning program. Because this isn’t just some random mathematician.

Anatol Borisovich Rapoport was born on May 22, 1911, in Lozovaya, in the Kharkov Governorate of the Russian Empire. Today Lozovaya is in eastern Ukraine, in the Kharkiv region. In December 1921, when Anatoly was ten years old, his family fled from Soviet Ukraine to Poland. Across the frozen border river Zbruch. On skates. To be precise, he was the one fleeing on skates — a ten-year-old boy who, dressing warmly and buying himself new skates, walked up to the river, crouched by a fence, watched the carefree Polish children skating on the Polish side of the dam, waited for the moment when the border guards got distracted, and rolled out. Suddenly, from somewhere above, a Red Army soldier spotted him and started shouting. Anatol picked up speed, raced over to the Polish children, wedged himself into their circle — and calmly skated off with them, away from the Soviet border. Many years later he would describe this moment in his memoirs.

A year later the family made it to the United States and settled in Chicago. Anatol was sent to study music. At sixteen he was already a promising pianist. At eighteen he entered the Vienna Conservatory. Until 1934 he studied there as a composer, pianist, and conductor. He gave concerts in Austria, Poland, Hungary, Italy. He spoke four languages.

Then the Nazis came to power in Germany. The career of a Jewish concert pianist in central Europe ended before it had begun. Rapoport returned to the States and discovered that in America too, no one needed yet another pianist from Chicago. At the age of twenty-three he enrolled at the University of Chicago. Seven years later he defended his dissertation in mathematics.

Then for fifteen years he worked on mathematical biology — modeling the spread of epidemics, the behavior of parasites and symbionts. In 1955 he came to the University of Michigan as one of the founders of the Mental Health Research Institute. There he began studying the behavior of people in conflict situations — through laboratory games, including the Prisoner’s Dilemma. It was Rapoport who introduced this experiment into broad scientific use, in his 1965 book Prisoner’s Dilemma: A Study in Conflict and Cooperation.

In 1970, when the Vietnam War entered its dirtiest phase, Rapoport left the United States for Canada. He wrote later that he wanted to live “in a country not committed to a messianic role.” He took a position in Toronto, where by 1980 he was already a professor emeritus on a pension — a seventy-year-old elder, the author of twenty books and three hundred articles, who had spent his whole life on one question: how to get people to stop killing each other.

By this moment Rapoport was one of the world’s most well-known researchers in game theory and conflict. And one of the most consistent pacifists. He founded Science for Peace. He wrote that war is “a contagious disease with a fatal outcome.” When the invitation came from Axelrod, Rapoport sat down and wrote four lines. Sent it.

Many years later he confessed to Axelrod that he himself didn’t much like Tit-forTat. Too harsh, he said. Too ready to take revenge. Not really suitable as a moral position for a peace researcher. But he wanted to see how it would play. It won.

### Why the mirror won

Axelrod spent the next two years trying to understand why.

After analyzing all the played matches, he singled out four properties of the winning strategy.

First: niceness. Tit-for-Tat never defects first. On the first move it always cooperates. On any move after the opponent’s cooperation — it cooperates. This property divides all fourteen programs into “nice” (never defect first) and “mean” (defect at some point without provocation). Eight of the fourteen programs were “nice.” In the final results table, all eight of the nice programs took the top places. All six mean ones — the bottom.

Second: retaliation. Tit-for-Tat answers a defection immediately. Not after a delay, not in reserve, not with some probability — exactly on the next move, exactly once. This protects it from exploitation. The “nice” programs that didn’t know how to retaliate (always-cooperate) got mercilessly exploited and in the end lost.

Third: forgiveness. Tit-for-Tat doesn’t hold grudges. If the opponent cooperated on the last move — it forgets everything that came before and cooperates in response. Programs that piled up grudges and started taking revenge forever after a single defection got stuck in eternal war and lost points. Forgiveness restores cooperation. Fourth: clarity. Tit-for-Tat is predictable. It’s easy for the opponent to understand what it’s doing and why. That means cooperation can quickly be established with it — all it takes is one try at cooperating, and it’ll cooperate too. Programs that tried to be cunning and unpredictable (like JOSS with its random defections) confused their partners and destroyed cooperation that could otherwise have been established. Niceness, retaliation, forgiveness, clarity. All in four lines of code. Axelrod published the results in March 1980 in the Journal of Conflict Resolution. The article was called “Effective Choice in the Prisoner’s Dilemma.” It made an impression, but the scientific community received it with the usual healthy skepticism: well, one program won one tournament. Maybe it was a fluke. Maybe the others didn’t try. Maybe if you ran the tournament differently, somebody else would win. Axelrod read the criticism and decided to run a second tournament.

### The second round

For the second tournament, Axelrod did three things.

First: he published a full report on the first tournament. All the programs, all the matches, all the results, a full analysis of why TfT won. All future participants got this report. That is, now no one could say they hadn’t known the weaknesses of their own strategy or the strengths of their opponent.

Second: he ran an announcement in computer magazines — like Creative Computing and Personal Computing. He invited everyone, not just academic experts. In the end he received sixty-two programs from all over the world — from professors to teenage hobbyists. In the first tournament there were fourteen programs. In the second — almost five times as many.

Third: he changed the rule for ending the game. In the first tournament there were exactly two hundred rounds. This created the “last move” problem — on the last round there’s no point in cooperating, so you should defect; but then there’s no point on the second-to-last either; and so on all the way back to the start. This is called “backward induction” and theoretically destroys the whole construction. In real life backward induction doesn’t work, because nobody knows the exact moment of the end. Axelrod modeled this: in the second tournament, after each move, with probability 0.00346 the game ended. On average this gave about 200 moves, but no one knew in advance which move would be the last.

The participants knew everything. They knew TfT had won. They knew which properties make a program successful. They knew that Axelrod had even specifically suggested a strategy that might beat TfT — Tit-for-Two-Tats, a softer version that forgives two defections in a row before retaliating.

Out of sixty-two programs, many tried to beat TfT directly. Some were more aggressive. Others — more cunning. Still others used complex models of the opponent. One person looked at all this commotion, sat down, and once again wrote four lines. Anatol Rapoport submitted Tit-for-Tat again.

The second tournament TfT won too.

Axelrod published the results in September 1980. And he added something else I haven’t mentioned. He ran six variants of the second tournament — with different ecological conditions, where certain types of programs were represented more or less. In five out of six variants TfT won again. In the sixth it took second place. And one more thing: Axelrod ran an evolutionary simulation. He imagined that each program produces offspring in proportion to its success. The less successful die out, the more successful reproduce. After a thousand generations TfT dominated. After several thousand — it occupied most of the population. Cooperation, which had seemed like a naive alternative to rational selfishness, turned out to be a stable evolutionary attractor.

The picture was clear. Cooperation is stable. Cooperation is profitable. Cooperation wins in repeated interactions — provided that the strategy that implements it has four properties: niceness, retaliation, forgiveness, clarity.

### Three conditions

Axelrod went further. Over the next several years, he and his colleagues worked on understanding under which conditions exactly the picture described above works. Because it’s one thing to show that TfT wins in a specific tournament. It’s another thing to understand why.

In the 1984 book The Evolution of Cooperation, and even more sharply — in articles from 1985–1987 with the biologist William Hamilton, Axelrod formulated the answer. It turned out that for cooperation to be able to arise and be sustained through something like TfT, three conditions are needed. All three. Remove any one of them — cooperation collapses.

Condition one: iteration. The game has to repeat. If I know I’ll meet you only once in life, the optimal strategy is to defect. Take and run. You won’t find me anyway. In the tournament each pair of programs had two hundred rounds. In real life iteration arises when people live in the same village, work at the same company, trade in the same market for many years. When I know I’ll see you tomorrow, I behave differently than if I know I’ll never see you again.

Destroy iteration — and you get the behavior of a tourist in an unfamiliar city. You can leave no tip. You can be rude. No consequences.

Condition two: memory. Participants have to remember what the opponent did in past rounds. Without memory TfT doesn’t work — you can’t “answer in the mirror” to something you don’t remember. In the tournament memory was built into the mechanics: each program got, as input, the full history of interaction. In real life memory arises when I recognize you by face, remember our past conversations, have an idea of how you’ve behaved with others.

Destroy memory — and you get the behavior of a big anonymous crowd. Nobody remembers anybody. Every interaction is the first and the last. To deceive is safe. Condition three: clarity. Or reputation, or observability — it’s formulated in different ways. The essence is one: behavior has to be visible. Not only to the one I’m interacting with, but also to other participants. Because if I cheated you and no one besides the two of us knows about it, I can go and cheat the next person. But if news of my cheating spreads through the community — they’ll stop letting me through to the next ones. Destroy clarity — and you get the behavior of a world where you can buy a new name and move to another town. Whatever I do, the trail doesn’t follow. Three conditions. Iteration, memory, clarity. Remove any one — and the optimal strategy shifts from TfT toward pure selfishness.

### How this connects to the Nash equilibrium

Remember the Nash equilibrium from the start of the chapter? In the Prisoner’s Dilemma it was “both defect.” Stable but bad.

Axelrod found another equilibrium. When the three conditions are satisfied — when the game is repeated, the participants remember, and behavior is visible — a new equilibrium appears: both cooperate by TfT. If one deviates and starts to defect, the other mirrors — and both become worse off. If one returns to cooperation — the other does too. Stable. And good.

This is fundamental. Nash described the trap: the system gets stuck in a bad state because unilateral movement out of it isn’t profitable. Axelrod showed the way out: if there’s the right structure around the game (three conditions), a second equilibrium appears in which everyone cooperates. And this equilibrium is also stable — unilateral deviation from cooperation is automatically punished.

The task, then, isn’t to convince people to “be better.” The task is to create a structure where selfishness leads to cooperation. Not to change people. To change the rules of the game.

### Five paths to one idea

For millennia before Axelrod, a similar idea had independently been found five times. Confucius, around 500 BCE, taught: do not do unto others what you do not wish for yourself. This is formulated in the Analects, in a conversation between the disciple Zigong and Confucius. Zigong asked: is there one word by which one might live one’s whole life? Confucius answered: perhaps, “reciprocity.”

Rabbi Hillel the Elder in Jerusalem around 30 BCE, when a gentile asked him to lay out the whole essence of the Torah while standing on one foot, answered: what is hateful to you, do not do to your neighbor — that is the whole Torah, the rest is commentary.

Jesus of Nazareth, around the year 30 CE, said something similar but in a positive formulation: as you would have people treat you, so treat them. Later this would be called the Golden Rule.

Immanuel Kant in 1785 proved this logically, as the categorical imperative: act only according to that maxim by which you can at the same time will that it should become a universal law. If you can’t will that everyone lie — don’t lie.

Anatol Rapoport in 1980 proved it mathematically. Four lines of code in Fortran. Five independent paths. Two and a half thousand years. Different cultures, religions, eras, instruments. One formula.

You can say this confirms a deep moral truth — that the Golden Rule has always existed and is found everywhere. You can also say it differently: this confirms a structural truth. In repeated interactions with memory and clarity, Tit-for-Tat is the optimal strategy. That is exactly why any culture, any philosophy that has seriously thought about the question “how to live among others” finds it. That is exactly why a mathematical proof gives the same answer as moral intuition.

The problem, as Rapoport himself formulated it, is not in the rule. The problem is in the architecture of its application.

The three conditions have to be satisfied. In a family, between friends, in a small business — they’re often satisfied of themselves. We interact iteratively, we remember each other, we see behavior. TfT works intuitively, without mathematics. In big anonymous systems — the state, the global economy, the crowd — the conditions break. And the Golden Rule stops working not because people have gotten worse. But because the architecture is broken.

Axelrod and Rapoport showed what makes the architecture right. And, by the same token, showed what makes it wrong.

### Return to Bitcoin

Now we can return to the question we started the chapter with.

Why didn’t GHash.IO attack Bitcoin in July 2014?

Because in Bitcoin all three of Axelrod’s conditions are satisfied.

Iteration. Each block is a new round of the game. A block comes out every ten minutes. Twenty-four hours is one hundred and forty-four rounds. A year is fifty-two thousand rounds. A mining pool that wants to earn over five years will play this game a quarter of a million times. This isn’t a one-off situation. The shadow of the future is longer than any possible one-time gain.

Memory. The blockchain is literally the network’s shared memory. Every transaction, every block, every miner — all of it is on the record. If GHash.IO had tried to rewrite transaction history in July 2014, that attempt would have stayed in the blockchain forever. Forever — in the cryptographic sense of the word. To erase is impossible. Clarity. The hashrate of every mining pool is publicly visible. This isn’t secret information. Any researcher, any journalist, any community member can look in real time at what share which pool occupies. When GHash.IO crossed 50 percent in June 2014, this was known within hours. Not days, not months — hours.

Three conditions satisfied. Which means TfT should work. And it did work: the community mirrored the pool’s actions — miners left, the reputation collapsed, the price of bitcoin fell. The economic pressure was a retaliatory response to the threat of breaking cooperation. When GHash.IO publicly promised to limit itself to 40 percent — forgiveness restored cooperation. After a few months the situation returned to normal. That was TfT at the level of the global mining community. Without a coordination center. Without a formal contract. Just four properties working through three conditions.

Now it becomes clear why in other situations pressure doesn’t work. If a network is small and not visible from the outside — clarity is broken. If the miners are anonymous and there’s no reputation — memory is broken. If the game is played once (say, if the network is on the verge of collapse and won’t survive the next year) — iteration is broken. Anywhere even one of the three conditions is broken, Tit-for-Tat stops being the optimal strategy, and defection becomes rational.

So if we’re building a distributed system and we want cooperation without a central arbitrator to work in it — we have to design it so that all three conditions are satisfied. Iteration, memory, clarity.

This looks like a recipe. And it almost is a recipe. But there’s one nuance which none of Axelrod, Rapoport, or anyone who read their work in the 1980s could have predicted. What was left unclear If everything is so simple — three conditions, four properties, an optimal strategy — then why did we say at the end of Chapter 1 that Bitcoin has a structural flaw? After all, in it the three conditions are satisfied.

The answer: Axelrod’s three conditions are a necessary condition for cooperation. But not a sufficient one.

Bitcoin satisfies Axelrod. There is iteration in it, and memory, and clarity, and Titfor-Tat works there. That explains why the network survived in 2014. But there is one more factor that Axelrod didn’t write about, because in 1980 it was impossible to see. This factor is connected not to the conditions of the game, but to what exactly is being won in this game. To the prize itself.

In Axelrod’s tournament the prize was abstract — points. The programs couldn’t exchange those points for something else, asymmetric. They couldn’t, for example, use their points to buy votes in determining the future rules of the tournament. They couldn’t buy their reputation.

In Bitcoin the prize is real money. And this money can be used, among other things, to influence the system itself. To buy more equipment. To capture a larger share. To push through certain changes in the protocol. To direct the industry in a particular direction.

This creates a different problem. Not the problem of the absence of the three conditions — the three conditions are satisfied. But the problem that the very prize in the game contains, inside itself, an asymmetry that was not in the 1980 tournament. The prize gives the ability to change the rules of the game. And that is a class of attack which Axelrod did not model.

It’s exactly this flaw — structural, subtle, almost invisible — that is the reason Bitcoin, for all its remarkable properties, remains the Darby phase, not the Murdoch phase. It solves the problem of cooperation between participants within the framework of the current game. But it does not solve the problem that the money earned in this game can be used to change the game itself.

But before moving further, it’s worth pausing for a minute. Because we’ve derived something important.

Cooperation without an arbitrator is possible. This is not a utopia and not mysticism. It is a mathematical fact, proven in 1980 in a tournament that fourteen programs took part in. It requires three conditions — iteration, memory, clarity — and one strategy made of four lines of code.

And if we want to build systems in which millions of people, without coercion, act in common interests, we now know what to build from.

That’s the first piece of good news in this book.

The next chapter is about the bad news.