Cooling / Examples

Path: <= CGT path =>
Sub-page of Cooling

Table of contents


xela: This may appear a bit pedantic, or tedious, but I feel the need to work things out from the definitions to get a feel for this theory. This is motivated by the discussion at chilling/discussion; I’m starting with cooling rather than chilling because the definition seems simpler, and I’m still not clear on the difference between the two! (Maybe this will get clearer as I work out these examples.)

I want to start by working with some abstract games; then I’ll make some subpages for actual go positions.

So, first, let’s have the definition (Mathematical Go, page 50–51, notation slightly changed):


We start with a short game ``G = { a, b, … | p, q, … }`` (where ``a, b, …`` are the left options, and ``p, q, …`` the right options) and a number ``t >= 0`` (remember, ``0`` is the zero game).

``G`` cooled by ``t`` is denoted ``G_t``, and is defined by:

``G_t = { a_t - t, b_t - t, … | p_t + t, q_t + t, … }`` (where ``a_t`` is ``a`` cooled by ``t``, and so on)
unless there exists some number ``r`` such that ``0 <= r < t`` and ``{ a_r - r, b_r - r, … | p_r + r, q_r + r, … }`` is infinitesimally close to some number ``x`` — in which case we define ``G_t`` to be the number ``x``.
Such a number ``r`` is called the temperature of ``G``, and ``x`` the mean value of ``G``.

To paraphrase: to cool ``G`` by ``t``:

  • first we need to find out what happens to all the options of ``G`` when they are cooled;
  • then we subtract ``t`` from all the left options, and add ``t`` to all the right options;
  • if the result is not a number, we’re done. If it is a number, we need to check whether ``t`` was “too big” compared to the temperature.

Example 1: numbers

If ``G`` is already a number, then the “unless” clause of the definition is always true for ``r = 0``, regardless of what ``t`` is, and so ``G_t = G`` for any ``t``. ``G`` has temperature ``0`` and is equal to its own mean value.

Example 2: {4 | 0}

Suppose ``G = {4 | 0}``. Let’s work out ``G_1, G_2, G_3`` and ``G_5``.

Note first that ``G`` is not a number, because it has ``4`` as a left option, ``0`` as a right option, and ``4 > 0``.

Note also that the options ``4`` and ``0`` are themselves numbers: so ``4_1`` (“``4`` cooled by ``1``”) equals ``4``, ``4_2 = 4``, ``0_1 = 0`` and so on.

Now I’m ready to calculate ``G_1``. It’s ``{4_1 - 1 | 0_1 + 1}``, which is the same as ``{4 - 1 | 0 + 1}``, or ``{3 | 1}``. Since ``3 > 1``, ``{3 | 1}`` isn’t a number, so we can stop here.

Similarly, ``G_2 = {4 - 2 | 0 + 2} = {2 | 2}``. Since ``2 >= 2``, this also isn’t a number. In fact, ``{2 | 2} = {:"2"ast:}`` (that is, the number ``2`` plus the infinitesimal STAR). [2] It’s infinitesimally close to the number ``2``. Do we have to worry about the “unless” clause of the definition? No, because if ``r`` is some number smaller than ``2``, then ``G_r = {4 - r | 0 + r}``, and ``4-r > r``, so ``G_r`` isn’t close to a number [3]. So we stop here: ``G_2 = {:"2"ast:}``. But we can see from this that ``G`` has temperature ``2`` and mean ``2``.

Now it’s tempting to say ``G_3 = {4 - 3 | 0 + 3} = {1 | 3}`` — and then ``{1 | 3}`` is a number (because ``1 < 3``) — in fact it’s equal to the number ``2``. But we haven’t strictly followed the definition: ``G_2`` is infinitesimally close to a number, so we have to invoke the “unless” clause. Actually we get the same answer: ``G_3`` really does equal ``2``. This is a lucky accident.

Can we say ``G_5 = {4 - 5 | 0 + 5} = {-1 | 5}``? No! ``{-1 | 5}`` isn’t just the average of ``-1`` and ``5``, it’s actually equal to ``0``. [4] But remember that ``5`` is also greater than the temperature of ``G``. So ``G_5``, like ``G_3``, is equal to ``2``.

Example 2a: “half a point” in go.

I was confused earlier about half points in go, expressed in CGT terms. What we call “half a point for black” in a go endgame is usually a position where black can earn a whole point by playing first, but zero if white plays first. In other words, it’s the game ``{1 | 0}``. This isn’t a number (because ``1 > 0``). But if we cool it by half a point, we get ``{1 - 1/2 | 0 + 1/2}``, that is ``{1/2 | 1/2}``, which is equal to ``1/2""ast`` (the number ``1/2`` plus the infinitesimal STAR). And if we cool it by a whole point, invoking the “unless” part of the definition, ``{1 | 0}_1 equals 1/2``. So “half a point” is a position with temperature ``1/2`` and mean value ``1/2``.

Bill: If you want to be strict (and I think you do), you should represent a dame as a ``ast``. So the half point is either ``{1 | ast}`` or ``{{:"1"ast:} | 0}``.

xela: Good point. I need to look closely at how go positions relate to abstract games[5]. In any case, ``{1 | ast}`` cooled by one point is still ``1/2``, right?

Bill: Right. :-)

Example 3: ``{ 3" || "2 | 0}``

Let’s add an extra step: suppose ``G = { 3" || "2 | 0}`` (remember that this is an alternative way of writing ``{ 3 | { 2 | 0} }`` — see tree representation). That is, the left option of ``G`` is the number ``3``, and the right option of ``G`` is the game ``{2 | 0}``.

To calculate ``G_1``, first we need to work out what happens when each of the options is cooled by ``1``.

``3`` is easy: it’s a number, so ``3_1 = 1``.

Now ``{2 | 0}_1 = {2 - 1 | 0 + 1} = {1 | 1}`` — this is similar to example 1 above, and it’s equal to ``"1"ast``.

Now we can go ahead and cool ``G``:

``G_1 = { 3 - 1 | {:"1"ast:} + 1} = {2 | {:"2"ast:}}``. This is equal to ``"2"uarr`` (that is, the number 2 plus the infinitesimal UP). It’s infinitesimally close to a number. This game ``G`` has temperature ``1`` and mean value ``2``.

Application to go positions

To be continued... I intend to look at the two corridors Bill showed at Chilling/discussion, and maybe one more example.

/corridor 1?

/corridor 2?


Any comments or suggestions for this page will be greatly appreciated! Do other people find this sort of thing useful?

[1] Robert Pauli: (actually this footnote was number 7)
I added space, commas, and removed the name clash (``r`` no longer is a right option). However, struggling with it, I think it still needs improvement (but see below):

  • We start with a game ``G``, okay, but not with a number ``t``, since if ``t`` were fixed, the formula couldn’t approach ``x``.
  • After “unless” IMHO it should rather be (as I explain at On Numbers and Games / Cooling):
    there exists some number ``r`` that is the smallest among those ``t >= 0`` with the property
    that what would have been ``G_(t')`` converges to some number ``x`` if ``t' > t`` converges to ``t`` —
    in which case we override the definition of ``G_t`` for ``t > r`` to be ``G_r`` if that is a number and to be ``x`` otherwise. Such …
  • Later, guided by example 2, I substituted ``r`` for ``t`` in ``{ … }`` in the unless clause.

Now it seems to make sense . . . and to agree with my ONAG interpretation. The definition from Mathematical Go used on this page is more elegant. However, ``r`` only depends on ``G`` — needs not be recomputed for every ``t``. This is obscured. And this definition also depends on defining the distance between a number and a non-number since ``G_r`` mostly is no number.

[2] Does this fact deserve some explanation? I don’t want to go on a huge digression on this page, but it might be worth exploring as a separate issue. I think the easiest way to see that ``{2 | 2} = {:"2"ast:}`` is to look at the difference game ``{2 | 2} + (-2) + ast``

Patrick Traill: We can show that with simple formal manipulation of games, which I find more helpful than a tactical discussion of a difference game.
For a strictly positive integer ``n``, simply applying the definition of addition, bearing in mind that `` n = { n-1 | }`` , we get the rule:

`` n+G={n-1+G,n+G^L|n+G^R}``

So we can calculate `` {:"2"ast:} = 2 + ast = 2 + {0|0} = { 1 + ast, 2 + 0 | 2 + 0 } = { 1 + ast, 2 | 2 } `` Since `` 1 + ast < 2, {:"1"ast:} `` is a dominated option, and we can simplify to ``{2|2}`` as desired.

FALLACIOUS: I originally wrongly wrote: ``cancel color(DarkRed)({2 | 2} = 2 + {0|0} = 2 + ast = {:"2"ast:})``, but you may not just bring numbers inside the brackets: you must use the formula above!

[3] Why not? At this moment I can’t immediately see how to prove such a thing.

[4] Is this fact explained anywhere on SL?

Karl Knechtel: I think it’s analogous to the go knowledge that playing a 4-point gote when a 5-point gote is available (another representation of a 5-point tax on moves) is (obviously) not optimal play.

Bill: It could be explained on the zero game page. Offhand, I do not know a go position it represents.

[5] In abstract games, play continues until one side runs out of moves, and then there is a winner and a loser — but there is no concept of “score”, and no possibility of jigo. Mathematical Go says “score will fall out of the theory naturally”, but doesn’t explicitly address that. From my (so far superficial) browsing through Winning Ways, I think that the idea of score arises from saying “let’s play until we reach a number, then stop” — because numbers are well understood, so playing on from that point won’t be interesting. So the goal is for Left (Black) to try to reach the maximum possible number, and for Right (White) to aim for the minimum.

How does this apply to go positions? Let’s look at a short corridor:


(As usual, we assume that stones at the border of the diagram are alive.)

If Black plays a, then there are two points of territory for Black: we’ve reached a number [6], so play stops. Therefore the position is ``{2 | "something" }``, where “``"something"``” depends on what happens when white goes first. If White a, Black b, there’s one point, so now we have ``{2" || "1, "something"}``. If White gets two moves in a row, there’s no points, so it’s ``{2" || "1 | 0}``. Then we can go ahead and cool it, or compare it with other positions using difference games, and work out that it’s worth ``1 1/4``.

Without the “stop at a number” rule, the results look absurd: if Black plays a, White can’t stop but must play either b or c, Black must capture, White can’t play, Black must fill the remaining point... or if Black has two moves in a row from the starting position then Black plays both a and b... the game tree will be rather complicated, but I don’t believe it will give the same result.

It seems to me that an unchilled dame should be seen in the same light. There are no points for either player – it’s zero, let’s stop. I’m aware that Mathematical Go says otherwise (page 17), but this result isn’t either explained or used (as far as I can see).

Bill: The unchilled game tree for the corridor is ``{2" ||| "1" || "0 | 0}``. After chilling it is ``{1 " ||| "1" || "1 | 3}``, which equals ``{1" || "1 | 2}``, which equals ``{1 | 1.5}``, which equals ``1.25``, as you indicate. Neither player cares to move, because each player loses ``0.25`` point by doing so. Now a dame in unchilled go is ``{0 | 0}``. Neither player loses points by filling it. To be sure, neither player gains points by filling it, either, and so if you want to represent a dame as 0, nobody is really going to care. Still, ``{0 | 0}`` is its game tree.

[6] Confusion of viewpoints again! Is it just a number because we count the territory and say so? or is it technically a number in the sense of surreal numbers?


Black can play either b or c, leaving a position where White can’t move but Black still has one more move, so the left option is ``{1 | 0}`` — that’s the definition of the (surreal) number ``2``. If White plays first, White b gives a position that to a go player looks like 3 points — so the starting position must be ``{2 | 3}``. But wait! After White b, there are no legal moves for White, but Black can play c then b, then we’ve reached zero (no moves left) — so White b moves to ``{ {0 | } } | }`` — that’s the same as ``{1 | }``, or ``2``. So the original position is ``{2 | 2}``? That’s not a number! But maybe we should give black an extra point for the prisoner (how does that fit into the CGT framework?), so it really is ``{2 | 3}``. So it is a number — but it’s equal to ``2 1/2``, not the ``2`` points we wanted.

As you can probably tell, I’m a bit confused here :-)

Bill: With the stones immortalized, the eye has this tree: ``{1 | 3}``, which equals ``2``. Explanation of the tree: After Black moves, he can move again, while White cannot. That is the definition of ``1``. After White moves, he cannot move again, but Black can move three times (once by returning the captured White stone). That’s the definition of ``3``.

xela: Aha! Returning a captured stone is equivalent to making a move on the board! That’s how the prisoners fit into the CGT framework.

Looking at it again, I realise that I made a mistake: “White can’t move but Black still has one more move” — that’s ``{0 | }``, i.e, ``1``, not ``2`` as I said above. So it comes out to ``{1 | 3}`` by either method, but Bill’s way is much simpler.

Path: <= CGT path =>
Cooling / Examples last edited by PJTraill on January 30, 2019 - 20:52
RecentChanges · StartingPoints · About
Edit page ·Search · Related · Page info · Latest diff
[Welcome to Sensei's Library!]
Search position
Page history
Latest page diff
Partner sites:
Go Teaching Ladder
Login / Prefs
Sensei's Library