Most Ignorant Bot Imaginable

Keywords: Online Go

The Most Ignorant Imaginable Go Engine

Short: What is the most ignorant Go player? If you know Go, you can voluntarily lose against a random player - by using this knowledge. So losing is not a sufficient criterion, if we want to talk about ignorance, we must look into the knowledge of the playing engine.

This may be interesting e.g. as exercise for thoughts about ranking. The maximal rank is obvious: It is for the best player. So the minimal rank should be for the worst player, and that's what I talk about here.

(Background: Currently I learn a new (to me) computer language. (Haskell, just for the curious.) My first small program was a GTP engine with a random player.)

I know, there are random bots, at KGS for example, but I never tried playing one. So building it was interesting to me.

1. A Go engine must know the rules, otherwise it just cannot be called Go engine. (Well, "THE rules" is a difficult concept in go, I tend to start with something simple. Say e.g. Tromp Taylor Rules or New Zealand Rules.)

2. A Go engine must know some conditions for passing. Otherwise the game will never end. A possible solution here is to use rules that prohibit suicide - in that case the game may end if the other - and not so ignorant - player owns the whole board, and has only one point eyes. If two players such ignorant play each other, they will play forever even when suicide is not allowed: They fill their own liberties up to one, and get captured. Over and over again. (Modulo Superko: With a rule set containing, e.g., Positional Superko, board positions are not allowed to repeat, and thus a game can have only finite length. But that's a rather theoretical limit. The "finite" we talk about here usually takes aeons.)

It is a question of taste whether this kind of engine should be taken among the Go Engines. If we want an engine that serves as minimum to rank engines, this may be a candidate.

But what without using suicide prohibition? It would be nice if our Minimal Engine is not affected by choice of rules.

What I suggest in step 3 is to prohibit certain moves that no reasonable player ever makes. But I don't prohibit anything that might be useful sometimes. (E.g. prohibiting self atari may come to mind. But you use self atari often: in ko fights as well as in a snapback. So I want to prohibit something that will really not be used.)

3a. A possible next step is to "tell" the engine not to commit single stone suicide. So it will not try and do something that doesn't change the board (without being a pass).

Here again there is no end at self play. And it is not possible to let it win at all because, simply, the game does not end if you try. It passes exactly if the only empty points are single point eyes of its opponent.

In a way this speeds things up a bit, but doesn't change them.

3b. Alternatively we can prevent it from filling its own single point eyes.

Why single point? Why not just avoid filling own territory? Well, it is easy to tell what is an single point eye. The concept of an n-point eye might be easy too. But to decide whether an eye is already territory gets difficult.

Remark: Not every single point eye is territory, e.g. if the group has just one eye, it may be dead. The described bot will only not kill it.

I'm talking about a minimal engine here, so I suggest to use only eyes that are completely surrounded by the stones of one single string. Recognition of eyes that belong to more than one string that make a group is (among the) next level(s).

Explanation, see also the diagram: String: Set of stones that is directly connected (direct neighbours on the board). Group : Set of stones that live together. (Every string is a group. In the picture are two living groups, one is one string the other two strings.)

Funnily, this 3b engine only passes after it owns the whole board. If its opponent has a group then it will play in her eyes for the rest of the existence of this universe. (Again, here a superko rule might help immediately. But I'm kinda reluctant to be rule dependent, as said already.)

So, each of them is not enough, thus we take the possibility to combine both:

3. No single stone suicide, and no filling of own single point eyes.

Now it wouldn't do this annoyingly stupid thing to go on playing if nothing good can be done anymore, AND it doesn't always prepare its own capture. This leads to an engine that a) passes if it e.g. lost the whole board. b) passes if it e.g. won the whole board. c) plays finite games against itself. In self games it even plays in a way that both engines pass at the same time.

Remark: The minimal engine will run into superko easily if its opponent passes and it suicides its own groups. So it must implement this rule.

Sounds like a plausible minimal engine to me. (Minimal in the sense of least number of rules it draws its behaviour from.)

Or does anybody see something that knows less, and does something similar?

By the way, such bot even won several games at KGS: it's play is so boring that some of its opponents ended the game by resigning.

Phelan: This concept, of the possible worst bot, has been discussed before elsewhere on Sensei's. I can't find it now, but from what I remember of the discussion, the conclusion was that the worst possible go playing engine, would actually have to be really good, to calculate what the worst possible move is at any moment. Think of it as changing MoGo from finding games that win, to finding games that lose by the biggest amount.

Herman: I assume you are referring to the discussion at random play, in the section anti-Go.

Phelan: Thanks Herman, that was it. :)

RJHacker? Thats why this article talks about the most ignorant bot, not the worst (aka the one that is able to loose most). Important difference. Here we talk about a minimal set of knowledge that makes a bot a Go player. Then we may talk about different such sets or so.