advertisement

Go and Percolation Theory Author: James Kirkpatrick Partner: Karen Chalmers 29th April 2003 In this project, a program is developed to analyse a database of over 7000 professional Go games obtained from gobase.org. The objective is to study the probability density function of cluster size and to compare it with the results predicted by percolation theory. The results from real games are compared with those from games generated randomly. The hypothesis being tested is that Go games are similar at all times to a percolation system at its critical point: there exists a power law region and the cut-off cluster size for this power law behaviour is larger and slower in growing than the cut-off for random games (that correspond exactly to a percolation problem). Applications to the development of computer Go strategist algorithms, that is algorithms that consider long term, poorly defined goals will be considered. 4 1.0 Introduction This project will study the link between percolation theory and the game of Go. In percolation theory a large lattice is randomly occupied by coloured dots with a particular probability. When this probability reaches a certain value - 0.59 for a 2-d lattice- the clusters of adjacent dots start spanning from side to side of the lattice, this is known as percolation. The motive behind comparing this model to the game of Go is simple: the patterns produced in the game seem remarkably similar to those produced by the fractal percolating clusters. The question then is whether this superficial similarity masks a deeper connection. We will try and answer this question by analysing the distribution of cluster sizes1 and by seeing whether or not this distribution follows patterns similar to those of percolation theory. 1.1 The game of Go and computer Go Go is probably the oldest board game on Earth: it was developed over 4000 years ago in China, the first text concerning itself exclusively with the game is the Yi Zhi (essence of Go), by Ban Gu(1) and dates back to the 1st century AD. The game was introduced to Japan in the 17th century and enjoyed such popularity and prestige that annual Go tournaments were held annually at the Shogun’s court from 1667 to 1863. So what is it that makes this game so fascinating? One of the factors that certainly fascinates people are the beautiful patterns that are drawn on the board at the end of the game, patterns which form a ‘mind map’, a record of the players’ intentions and strategies. Studying the nature of these patterns is the aim of this project, but first a couple of words on the rules that govern the game. A summary of the rules of Go can be found in appendix A, whereas for a better account of the rules of the game one can check http://gobase.org/studying/rules. Computer Go, on the other side, is a recent phenomenon: although people had written some programs for Go in the ‘70s as AI exercises, it was not until the ‘80s that Go started occupying the limelight of games programmers. Go is a fascinatingly complex game to model(2): unlike chess, the number of possible moves at any point is huge and very rarely does a single move change the board’s position radically. This means that if one were to write a program that simply went through all the possible moves, using some heuristic function to calculate which would be the ideal move, the program could not consider many moves ahead because of the rapid increase in the number of permutations. In other words, because the search tree is very wide, it cannot be very deep. It is possible nevertheless to write good Go ‘Tacticians’2, that is programs that can accomplish certain 1 In Percolation Theory the cluster number is normally considered: the cluster number is the number of clusters size of a particular size per lattice site. In our case, we simply looked at the cluster size distribution, because all the systems analysed were of the same size. 2 This goal had been achieved by the very first computer Go programs, written by Al Zobrist and Ryder (2). 5 goals - e.g. hinder connection of enemy stones, save program’s stones, make program eye, Atari enemy cluster etc. – whilst avoiding certain other situations – e.g. being killed, playing in the enemies territory, playing an easily isolated stone etc. Each of these goals is given a certain positive or negative value and the ‘best’ moves are analysed further. The Go Tactician does not have an ‘understanding’ of the game, all it does is try and achieve goals which are secondary to the main goal of Go: conquering territory. The purpose of our research is to find a simple mathematical quality that clusters that achieve conquest of territory possess. This principle could then be used as a Go Strategist, i.e. as a part of the program that analyses the moves suggested by the Tactician (or by a database of patterns) and helps choosing which one is best. We believe that this simple principle is that successful Go players subconsciously use clusters which are similar to percolation theory clusters at the critical point, i.e. clusters whose size distribution probability density function (PDF) follows a power law behaviour. One of the aims of this project is to measure the specific value of the critical exponent. 6 2.0 Method The main difficulty with this project is that some of the basic assumptions of percolation theory are clearly not applicable to Go games. In particular percolation theory assumes an infinite cluster size, or at least a cluster size for which single lattice points are irrelevant. Go on the other hand is played on a ‘tiny’ 19x19 board, which makes the total number of lattice point 361. The biggest possible cluster would then be of size 180. In general, scale-free behaviour is considered to be happening when we see power laws spanning over several decades, in our case we clearly cannot expect such a range, seeing as cluster sizes barely span over 2 decades! Unfortunately there is nothing that can be done to overcome this difficulty, so that our results will unavoidably be open to interpretation. The real game data was obtained from gobase.org, which stores over 7000 professional games in the same digital format, the standard Go format (SGF) (5). The number of games we are averaging our results over and the statistical techniques –such as logarithmic binning – we used at least ensure that the PDFs produces look smooth and are easy to fit. This is important because sophisticated mathematical fitting of the curves and adjusting of the parameters will not be used. The PDFs at various times of the game are obtained by implementing a particular modification of the Hoshen-Kopelman(3) algorithm, as explained in Appendix B. The results from real games were then compared to results from randomly generated games, these games provide a ‘neutral’ example, as we expect them to show scale-free behaviour only when the probability of occupation approaches the critical probability of occupation. The random games mimic percolation theory’s dependence on occupation probability almost perfectly, the actual games will show if Go players play stones in such a way as to create a system which is closer to criticality. 7 3.0 Results In this section we will consider the evidence that points towards the existence of scale free behaviour in the game of Go. We will begin by looking at the results from random games and then compare those results to the ones from actual games. 3.1 Random Games The PDF for random games were generated by generating 4000 games of 300 moves each, and calculating the aggregate PDF for the whole set. In order to cope with the fact that very few data points are available for high cluster number, the PDF was plotted in logarithmic binning(4): in other words the data was plotted on bins whose width was growing geometrically. This ensures that, at high cluster number, there would still be a sufficient number of data points. The same technique was used to improve the data from the actual games. Figure 1 shows the difference between logarithmically and nonlogarithmically binned data from a particular series of the actual games. 1 1 10 100 0.1 0.01 0.001 0.0001 0.00001 0.000001 binned data un-binned data Figure 1: Logarithmically binned and non-logarithmically binned probability density functions for cluster number distribution. The logarithmically binned data is clearly closer to what we might expect to see: it is monotonically decreasing and clearly it seems to follow a smooth curve of some kind. 8 Before looking at the data, lets remind ourselves what we expect to see from percolation theory(4). Percolation theory predicts that the distribution of cluster numbers should look like: n(s,p) = q0 s- f(q1s |p-pc|) (3.1) We chose to use the function f(x) = exp(x1/) so that we obtained the following ansatz for the PDF: n(s,p) = q0 s- exp(-s * |p-pc|1/) = q0 s- exp(-s/s) (3.2) Which assumes a particular relation between the cut-off cluster number s and p: s = |pc-p|-1/ (3.3) s is a measure of the correlation length of the clusters. We plotted our PDF every tenth move and fitted equation 3.2, adjusting the parameters until the graphs seemed to overlap, at least for s>2. We then inferred the correct values of , and s. There will definitely be a source of error in these ‘manual’ estimates, but seeing as there are many other statistical defects in the data, a more accurate and laborious method for fitting the curves was not deemed practical. So, here are three probability density functions after 60, 120 and 240 moves respectively, corresponding to a probability of occupation of 0.166, 0.332 and 0.665 respectively. The complete set of PDFs is shown in Appendix C. It should be noted that these probabilities of occupation are aggregate values of the black and white probabilities of occupation, i.e. the probability of occupation of white or black stones only would be half as much. 60th move 10 1 0.1 1 10 100 0.01 0.001 0.0001 data fit 0.00001 0.000001 0.0000001 0.00000001 9 120th move 10 1 0.1 1 10 100 0.01 0.001 data 0.0001 fit 0.00001 0.000001 0.0000001 0.00000001 240th move 10 1 0.1 1 10 100 0.01 0.001 0.0001 data fit 0.00001 0.000001 0.0000001 0.00000001 Figure 2: Log-log plots of the probability density functions of cluster number distribution at the 60 th, 120th and 240th move respectively. The fit corresponds to equation 3.2 with =2. It should be noted that the fits corresponded to the ansatz 3.2, except for the value of the constant of proportionality q0, which had to be adjusted to make sure the data and the fit were overlapping. The value of , the critical exponent, is 2. It is easy to pick out the trend in these graphs: the section that looks like a straight line on the log-log plot (i.e. the ‘scale-less’ section) becomes longer as the probability of occupation increases. This means that the value of s is increasing as p approaches pc (in percolation theory pc = 0.59, seeing as we calculate the probability of occupation as the sum of p for the white and black stones, pc = 1.18). 10 We also plotted s against (pc – p): 100 10 cut-off cluster size 1 0.1 0.1 |p-pc| Figure 3: Log-Log plot of the variation of cut-off cluster size with (pc-p), the value of which varies between 0.3 and 1.1. the purple line is a simple (pc-p)-1/ plot, with = 0.4. The value of pc was taken as 1.18 As we can see, this agrees pretty well with equation 3.2 over most of the range. We have now calculated the values of and and we can compare them to the results for percolation theory. In the random games = 20.1 = 0.40.013, percolation theory for a 2-d lattice predicts = 187/91=2.0549 and = 36/91= 0.3956 in good agreement with the theory. What does this represent? The random games are indeed a good percolation theory model, in fact the only difference between our random games and a true finite percolation system is that in our games stones can be eaten. However it seems that –at least for small lattices and for p<0.8 – this does not introduce any significant differences from the theory. Having looked at these simple results it will be easier to have a good frame of reference from which to consider the actual games. 3 The error is estimated as the smallest variation of the parameters used to fit the data. 11 3.2 Actual Games At first, the actual games were analysed just like the random games, the value of the PDF was calculated every 10 moves, i.e. at equal intervals of p. The following graph shows what the results of this experiment were. The PDFs have not been normalised to the total number of clusters, hence the curve grow further ‘out’ as more stones are played. non time-normalised 1000000 100000 10000 1000 100 10 1 1 10 100 s Figure 4: Non-time normalised total number of clusters of size s for 7000 actual games (log-log plot). The various curves represent different values of p. Unfortunately this data does not look very promising: we cannot see a power law region, and the curve is not very smooth. In order to obtain better results, we decided to try and normalise the game length, i.e. to sample the cluster number distribution after a different number of moves for each game to ensure that we would sample the PDF 30 times from each game. 12 With this procedure, the graph analogous to Figure 4 is: Time normalised 1000000 100000 10000 1000 100 10 1 1 10 100 Figure 5: Time normalised total number of clusters of size s for 7000 actual games (log-log plot). The various curves represent increasing percentages of the complete game. This time normalisation certainly produces a curve which is more regular and which has a greater section exhibiting power law behaviour. The time normalisation unfortunately introduces a very grave problem: much of the analysis that we performed for the random games cannot be done anymore because each PDF does not correspond uniquely to a value of p. Also the method of dividing the length of games by 30, creates between 30 and 39 PDF per game. This means that when we are averaging, whereas the first 30 PDFs are averaged over the whole set of games, the PDFs between 31 and 39 are incomplete and might therefore show some peculiar behaviour. Once we accept that the probability of occupation is not a relevant variable, we realise that the need for a time normalisation actually represents something very specific: although a game is formally over only when both players pass and the future of every piece of territory has been completely determined, very often games will end when one of the two players realises he will not be able to win and resigns. To interpret this with our assumption on percolation and the conquest of territory, the game is over when one of the two players realises that he will not be able to achieve his goal, he will not be able to reach percolation. The whole game should therefore be interpreted as a struggle to achieve the percolating cluster and it is clear in retrospective that the relevant ‘time-scale’ of the game is not so much the number of stones on the board, but the stage that the ‘percolation-battle’ is at. Having clarified what we mean by time normalisation, we can now look at the data that we obtained for the actual games. We picked the 6th, 12th and 24th time steps out of 30 to represent the whole data set. All the PDFs are shown in Appendix C. 13 6th PDF (out of 30) 1 0.1 1 10 100 0.01 0.001 fit 0.0001 data 0.00001 0.000001 0.0000001 0.00000001 12th PDF (out of 30) 1 0.1 1 10 100 0.01 0.001 0.0001 fit data 0.00001 0.000001 0.0000001 0.00000001 14 24th PDF (out of 30) 1 0.1 1 10 100 0.01 0.001 fit 0.0001 data 0.00001 0.000001 0.0000001 0.00000001 Figure 6 Log-log plots of the probability density functions of cluster number distribution at the 6 th, 12th and 24th thirtieths of the game respectively. The fit corresponds to equation 3.3 We cannot use the scaling ansatz 3.1 anymore, because of the lack of definition of the probability of occupation. However, inspired by equation 3.2 we can assume a distribution of the type: n(s,p) = q0 s- exp(-s/s) (3.3) i.e. a power law modulated by a stretched exponential. In the following diagrams we show how the quantities , and s change at various stages of the game. critical exponent Tau 1.8 1.6 1.4 Tau 1.2 1 0.8 0.6 0.4 0.2 0 0 5 10 15 20 25 30 35 40 30th of the game 15 exponent alpha 2 1.8 1.6 alpha 1.4 1.2 1 0.8 0.6 0.4 0.2 0 0 5 10 15 20 25 30 35 40 30th of the game Cutoff cluster size 12 cutoff cluster size 10 8 6 4 2 0 0 5 10 15 20 25 30 35 40 45 30th of the game Figure 7: values of the exponent and parameters in equation 3.3 at various thirtieths of the game. Note that the value for sections after 30 are not statistically significant. There are various observations to make about these graphs, for starters one should note that the values after the thirtieth thirtieth are not significant due to the considerations above on time normalisation. Also, one might notice that the graphs are very step-like: this is because the data fitting of the curves was performed by manually changing the values of the parameters in equation 3.3 until the best fit was obtained. If we 16 wanted to estimate the errors in these measurements they would therefore be 0.1, 0.05, 1 for the measurements of ,, and s respectively, these figures –as in the case of the random games- are the smallest variation of the parameters used in fitting the data. With these error margins in mind, the graphs seem to suggest that and are constant throughout, whereas s increases monotonically and certainly at a slower rate than s from figure 3. In fact, to better observe this fact, let us plot the variation of s at various thirtieths of the game for both the actual and the random games. Cutoff cluster size 16 cutoff cluster size 14 12 10 real games 8 random games 6 4 2 0 0 5 10 15 20 25 30 30th of the game Figure 8: Cut-off cluster size for real and random games. The significance of this graph is indeed huge: the cut-off cluster size increases as an exponential and if we were able to occupy 59% of the board with stones of a particular colour, we know that it would diverge, in accordance with percolation theory. The cut-off cluster size for the random games, however, decreases much more slowly, yet it is usually greater, indicating that the power law region were scale free behaviour is present is longer. This is in direct agreement with the hypothesis put forward: in Go the system is always in a critical state, the only reason why we see a finite cut-off cluster size is because the board is finite in size, and the reason why we see an increase in the cut-off is simply because more stones are being placed on the board. 17 4.0 Conclusion We have analysed the PDFs for random and actual games. Both show section were the cluster size distribution follows a power law, but the actual games have longer sections, with a cut-off that does not seem to have the same dependence on occupation probability as the random games. In fact, probability of occupation does not seem to have a significant role in the actual games. The data collected seems to suggest that cluster in actual games are similar to percolation cluster, we would therefore expect that a close investigation of these clusters would reveal fractal dimensionality: the cluster size varying to some power of the cluster radius by a constant D different from 2. It might be interesting to do some analysis on the clusters, trying to measure the exact value of D. More importantly however we have discovered a trend in the distribution of cluster sizes and given a simple explanation for it: Go is all about the conquest of the largest territory with the least number of stones, percolating clusters provide an ideal structure to achieve this goal, hence players unconsciously play in such a way as to develop percolating clusters, whilst impeding the opponents attempts at developing their own percolating clusters. It might be interesting to use the code developed to analyse large number of games between different computer Go programs, to see if the PDFs of cluster numbers follow a similar pattern to those made by human players. The observation we made might furthermore be useful to the development of algorithms for computer Go, in fact knowing what the distribution of clusters looks like might give some suggestion of when to reinforce a cluster and when to play isolated stones. This clearly cannot be the only criterion in the computer Go program, as there are many tactical issues that the computer would have to consider. However the importance of such an algorithm is that it translates a strategic goal - conquer territory with as few stones as possible – into a goal which an algorithm could try to achieve far more easily, i.e. try and build percolating clusters by creating cluster size distribution that follows a power law with a particular value for the exponent. Such a strategic goal would allow to make the tree search for moves thinner, allowing the computer program’s choice of moves to be smaller. More importantly it would allow the program to have a long term goal, i.e. it would make the move search tree much deeper, making it more similar to a human player’s. The next stage would therefore be the implementation of a computer Go program with a ‘strategy algorithm’ as outlined above. The observations made in this report, however, seem to suggest that percolation theory must have a role in the game of Go. 18 Appendix A Rules of the game of Go Go has very few and simple rules. The game is played on a 19x19 board by two players. In turns, the players place a stone on the intersections. Stones cannot be moved once they are on the board, however if they are totally surrounded by opponent pieces they will be removed. The aim of the game is to surround as much territory as possible, the finale score will be calculated by summing the number of intersections enclosed by one’s stones and adding the number of opponents’ pieces taken. A couple of diagrams will illustrate these rules. Diagram a: Territory A diagram showing the meaning of territory, the intersections marked with a red dot are black territory, as they are completely surrounded by black stones. Diagram b: Eating In this diagram we can see that the white stones are entirely surrounded by black pieces, except for the intersection labelled a. If black played in a, the three white stones would be removed from the board. These are all the rules we have had to implement. The only other rules are that ‘suicide’, i.e. playing in an intersection that is surrounded, is illegal and a rule to prevent infinite cycles, which prohibits a certain class of moves in a certain situation4. Both of these rules do not need taking into consideration in our program, because we are analysing data from games that will not contain illegal moves. 4 The so called Ko rule states that at any point no move can be made which will bring the board to exactly the same position as it was in the move before. 19 Appendix B: Program Outline In this section, we shall discuss the code that we used process the digital Go games to obtain probability density functions of the cluster sizes. The algorithm usually used to identify the sizes of clusters in percolation theory is the Hoshen-Kopelman5 algorithm (HK). HK is highly optimised at recording the cluster size PDF of the whole board at a certain time, whereas we need to record the cluster size PDF as it changes through the game. In other words all we need to measure is the changes that occur around the last stone placed. There are other pieces of code that we have had to implement: code to recognise when stones should be taken off the board and code to generate random Go games. B.1 The Burning algorithm The basic principle of the HK algorithm is a system to index the clusters depending on their adjacency: to do this it uses two registers. The first one (cluster class) records the position of the points on the lattice and labels them according to their adjacency and according to their colour. White stones were labelled with even labels and black with odd labels. The other register (label class) records the size of the cluster: the ith element of this register will contain a number describing what size the cluster labelled with i in the cluster register is. We borrowed these two data classes as the two fundamental data classes for our algorithm, and added another one (board class), which labels points on the grid exclusively depending on whether they are black (assigns them a –1 value) or white (assigns them a 1 value). This class is redundant, but useful in the development of the code. An example of what these registers would show for a particular game position is: a b c d e 0 1 2 0 0 0 1 2 0 0 0 0 0 4 0 0 0 0 0 0 0 0 0 3 0 a b c d e Figure 9: Cluster class. a b c d e 5 a b c d e 0 0 0 0 0 -1 -1 0 0 0 1 1 0 0 0 0 0 1 0 -1 0 0 0 0 0 -2 -2 -1 -1 Figure 10: Board class. Figure 11: Label class (J. Hoshen and R. Kopelman, Phys. Rev. B, 14, 3438 (1976).) 20 The values on the label register are all negative, because they represent cluster sizes: positive values represent adjacency between two different clusters. So, for example, if white played in bd, connecting the 2 and 4 cluster, the value of label[2] would change to –4 and that of label[4] would change to 2. All our program has to do is to update these registers appropriately every time a new stone is played, updating the information on the clusters surrounding it. B.2 Eating Algorithm The other piece of code we have written is the code which removes stones to be eaten: this piece of information is unfortunately absent from the digital Go games, unfortunately. In order to do this we tried to implement a simple algorithm. When we want to decide whether or not to eat a stone, we want to look at its neighbours: if they are of the same colour, then we need to check those neighbours to, if they are white they are ignored and finally if they are blank cells, the algorithm is stopped and the stones removed. To do this we created two registers: one contains the stones visited (i.e. whose neighbours have been investigated) the other contains the stones to visit (i.e. those who are in the same cluster as the stone investigated). When the two registers are the same, and none of the neighbours of any cell in the registers has proved to be blank, the cluster is removed and the registers are updated. 21 Appendix C This appendix contains all the PDfs generated. Firstly we will show 10 graphs for the random games. The fits (purple data points) correspond to formula 3.2, with the values for s according to figure 3 from chapter 3. 3 6 1 1 10 100 10 0.1 1 0.1 1 0.01 PDF(s) 0.001 PDF(s) 10 0.0001 0.001 0.0001 0.00001 0.00001 0.000001 0.000001 0.0000001 0.00000001 0.0000001 s s 9 12 10 10 1 0.1 1 1 0.1 1 10 100 10 100 0.01 PDF(s) 0.01 PDF(s) 100 0.01 0.001 0.0001 0.001 0.0001 0.00001 0.00001 0.000001 0.000001 0.0000001 0.0000001 0.00000001 0.00000001 s s 15 18 10 10 1 0.1 1 1 0.1 1 10 10 100 0.01 PDF(s) 0.01 PDF(s) 100 0.001 0.0001 0.001 0.0001 0.00001 0.00001 0.000001 0.000001 0.0000001 0.0000001 0.00000001 0.00000001 s s 22 24 21 10 10 1 0.1 1 1 0.1 1 10 100 100 0.01 PDF(s) 0.01 PDF(s) 10 0.001 0.0001 0.001 0.0001 0.00001 0.00001 0.000001 0.000001 0.0000001 0.0000001 0.00000001 0.00000001 s s 27 30 10 10 1 0.1 1 1 0.1 1 10 100 PDF(s) 0.01 PDF(s) 10 100 0.01 0.001 0.0001 0.001 0.0001 0.00001 0.00001 0.000001 0.000001 0.0000001 0.0000001 0.00000001 0.00000001 s s The next group of graphs is the 13 graphs from the actual games. The title contains the formula of the fit (blue in these graphs). 3=s^(-1.8)*EXP(-((s/4)^1.6)) 6 =s^(-1.6)*EXP(-((s/4)^1.5)) 1 1 0.1 1 10 10 100 0.01 PDF(s) 0.01 PDF(s) 0.1 1 100 0.001 0.0001 0.001 0.0001 0.00001 0.00001 0.000001 0.000001 0.0000001 0.0000001 s s 23 12=s^(-1.4)*EXP(-((s/5)^1.4)) 9 =s^(-1.6)*EXP(-((s/5)^1.5)) 1 0.1 1 1 0.1 1 10 100 0.0001 0.00001 0.0001 0.000001 0.00001 0.0000001 0.000001 0.00000001 0.0000001 s s 15=B1^(-1.4)*EXP(-((B1/6)^1.4)) 1 0.1 1 18=B1^(-1.4)*EXP(-((B1/7)^1.4)) 10 1 0.1 1 100 10 0.001 0.0001 0.00001 0.000001 0.001 0.0001 0.00001 0.000001 0.0000001 0.0000001 0.00000001 0.00000001 s s 21=s^(-1.4)*EXP(-((s/8)^1.4)) 1 0.1 1 24=s^(-1.4)*EXP(-((s/9)^1.4)) 10 1 0.1 1 100 10 100 0.01 0.001 0.001 PDF(s) PDF(s) 0.01 0.0001 0.00001 0.0001 0.00001 0.000001 0.000001 0.0000001 0.0000001 0.00000001 0.00000001 s s 30=B1^(-1.3)*EXP(-((B1/11)^1.3)) series 27=s^(-1.4)*EXP(-(s/10)^1.4)) 1 0.1 1 10 1 0.1 1 100 10 100 0.01 0.01 0.001 PDF(s) 0.001 0.0001 0.0001 0.00001 0.00001 0.000001 0.000001 0.0000001 0.0000001 0.00000001 s 0.00000001 33=B1^(-1.3)*EXP(-((B1/10)^1.3)) 39=s^(-1.3)*EXP(-((s/7)^1.9)) 36=s^(-1.3)*EXP(-((s/8)^1.7)) 1 1 1 10 100 0.1 1 10 0.1 1 100 PDF(s) 0.001 0.0001 0.00001 0.000001 0.001 0.0001 0.00001 100 0.001 0.0001 0.00001 0.000001 0.000001 0.0000001 0.0000001 0.0000001 0.00000001 0.00000001 0.00000001 s 10 0.01 0.01 PDF(s) 0.01 PDF(s) 100 0.01 PDF(s) PDF(s) 0.01 0.1 1 100 0.001 PDF(s) PDF(s) 0.01 0.001 10 0.01 s s 24 References (1) senseis.xmp.net/?GoHistory (2) Computer Go, Bruce Wilcox, Computer Games II 1987 Springer-Verlag (3) J. Hoshen, R. Kopelman Phys Rev. B 14 p3438-3445 (1976) (4) D. Stauffer and A. Aharony Introduction to Percolation Theory p.49 (Taylor & Francis 1994) (5) www.mit.edu/afs/athena/activity/g/go/src/standard/formspec.txt (6) gobase.org 25