You do not have permission to edit this page, for the following reasons:

This IP address has been blocked from editing Wikipedia.
This does not affect your ability to read Wikipedia pages.
Most people who see this message have done nothing wrong. Some kinds of blocks restrict editing from specific service providers or telecom companies in response to recent abuse or vandalism, and can sometimes affect other users who are unrelated to that abuse. Review the information below for assistance if you do not believe that you have done anything wrong.

The IP address or range 44.197.0.0/16 has been blocked (disabled) by ‪Blablubbs‬ for the following reason(s):

The IP address that you are currently using has been blocked because it is believed to be a web host provider or colocation provider. To prevent abuse, web hosts and colocation providers may be blocked from editing Wikipedia.
You will not be able to edit Wikipedia using a web host or colocation provider because it hides your IP address, much like a proxy or VPN.
We recommend that you attempt to use another connection to edit. For example, if you use a proxy or VPN to connect to the internet, turn it off when editing Wikipedia. If you edit using a mobile connection, try using a Wi-Fi connection, and vice versa. If you are using a corporate internet connection, switch to a different Wi-Fi network. If you have a Wikipedia account, please log in.
If you do not have any other way to edit Wikipedia, you will need to request an IP block exemption.

How to appeal if you are confident that your connection does not use a colocation provider's IP address:
If you are confident that you are not using a web host, you may appeal this block by adding the following text on your talk page: ((unblock|reason=Caught by a colocation web host block but this host or IP is not a web host. My IP address is _______. Place any further information here. ~~~~)). You must fill in the blank with your IP address for this block to be investigated. Your IP address can be determined here. Alternatively, if you wish to keep your IP address private you can use the unblock ticket request system. There are several reasons you might be editing using the IP address of a web host or colocation provider (such as if you are using VPN software or a business network); please use this method of appeal only if you think your IP address is in fact not a web host or colocation provider.

Administrators: The IP block exemption user right should only be applied to allow users to edit using web host in exceptional circumstances, and requests should usually be directed to the functionaries team via email. If you intend to give the IPBE user right, a CheckUser needs to take a look at the account. This can be requested most easily at SPI Quick Checkuser Requests. Unblocking an IP or IP range with this template is highly discouraged without at least contacting the blocking administrator.

This block will expire on 10:52, 20 August 2024.

Even when blocked, you will usually still be able to edit your user talk page, as well as email administrators and other editors.

For information on how to proceed, please read the FAQ for blocked users and the guideline on block appeals. The guide to appealing blocks may also be helpful.

Other useful links: Blocking policy · Help:I have been blocked
Your IP address is in a range that has been blocked on all Wikimedia Foundation wikis. The block was made by ‪AntiCompositeNumber‬. The reason given is Open proxy/Webhost: Visit the FAQ if you are affected .
- Start of block: 13:55, 18 August 2022
- Expiry of block: 13:55, 18 November 2024
Your current IP address is 44.197.119.13. The blocked range is 44.197.0.0/16. Please include all above details in any queries you make. If you believe you were blocked by mistake, you can find additional information and instructions in the No open proxies global policy. Otherwise, to discuss the block please post a request for review on Meta-Wiki. You could also send an email to the stewards VRT queue at stewards@wikimedia.org including all above details.

You can view and copy the source of this page:

((about|the study of [[Go (game)]] in artificial intelligence|the computer programming language|Go (programming language)))
((distinguish|Go software))
((short description|Field of artificial intelligence around Go computer programs))
((GoBoardGame))
'''Computer Go''' is the field of [[artificial intelligence]] (AI) dedicated to creating a [[computer program]] that plays the traditional [[board game]] [[Go (board game)|Go]].  The field is sharply divided into two eras.  Before 2015, the programs of the era were weak.  The best efforts of the 1980s and 1990s produced only AIs that could be defeated by beginners, and AIs of the early 2000s were intermediate level at best.  Professionals could defeat these programs even given handicaps of 10+ stones in favor of the AI.  Many of the algorithms such as [[Alpha–beta pruning|alpha-beta minimax]] that performed well as AIs for [[checkers]] and [[chess]] fell apart on Go's 19x19 board, as there were too many branching possibilities to consider.  Creation of a human professional quality program with the techniques and hardware of the time was out of reach.  Some AI researchers speculated that the problem was unsolvable without creation of [[artificial general intelligence|human-like AI]].

The application of [[Monte Carlo tree search]] to Go algorithms provided a notable improvement in the late [[2000s decade]], with programs finally able to achieve a [[Go ranks and ratings|low-dan level]]: that of an advanced amateur.  High-dan amateurs and professionals could still exploit these programs' weaknesses and win consistently, but computer performance had advanced past the intermediate (single-digit ''kyu'') level.  The tantalizing unmet goal of defeating the best human players without a handicap, long thought unreachable, brought a burst of renewed interest.  The key insight proved to be an application of [[machine learning]] and [[deep learning]].  [[DeepMind]], a [[Google]] acquisition dedicated to AI research, produced [[AlphaGo]] in 2015 and announced it to the world in 2016.  [[AlphaGo versus Lee Sedol|AlphaGo defeated Lee Sedol]], a 9 dan professional, in a no-handicap match in 2016, then [[AlphaGo versus Ke Jie|defeated Ke Jie in 2017]], who at the time continuously held the world No. 1 ranking for two years.  Just as [[English_draughts#Computer_players|checkers had fallen to machines in 1995]] and [[Deep Blue versus Garry Kasparov|chess in 1997]], computer programs finally conquered humanity's greatest Go champions in 2016&ndash;2017.  DeepMind did not release AlphaGo for public use, but various programs have been built since based on the journal articles DeepMind released describing AlphaGo and its variants.

== Overview and history ==
Professional Go players see the game as requiring intuition, creative and strategic thinking.<ref>((cite magazine|url=https://www.wired.com/2016/03/googles-ai-wins-first-game-historic-match-go-champion/|title=Google's AI Wins First Game in Historic Match With Go Champion|date=9 March 2016|magazine=WIRED|last1=Metz|first1=Cade))</ref><ref>((Cite web |url=https://www.koreatimes.co.kr/www/news/tech/2016/03/325_200068.html |title=AlphaGo victorious once again |date=10 March 2016))</ref> It has long been considered a difficult challenge in the field of [[artificial intelligence]] (AI) and is considerably more difficult to solve than [[chess]].<ref>((cite journal|last1=Bouzy|first1=Bruno|last2=Cazenave|first2=Tristan|title=Computer Go: An AI oriented survey |journal=Artificial Intelligence|date= 9 August 2001|volume=132|issue=1|pages=39–103|doi=10.1016/S0004-3702(01)00127-8|doi-access=))</ref> Many in the field considered Go to require more elements that mimic human thought than chess.<ref>((Citation| url=https://query.nytimes.com/gst/fullpage.html?res=9C04EFD6123AF93AA15754C0A961958260 | title=To Test a Powerful Computer, Play an Ancient Game | last=Johnson | first=George | work=[[The New York Times]]| date=1997-07-29 | access-date = 2008-06-16))</ref> Mathematician [[I. J. Good]] wrote in 1965:<ref>((Cite web|url=http://www.chilton-computing.org.uk/acl/literature/reports/p019.htm|title = Go, Jack Good))</ref>

((quote|Go on a computer? – In order to programme a computer to play a reasonable game of Go, rather than merely a legal game – it is necessary to formalise the principles of good strategy, or to design a learning programme. The principles are more qualitative and mysterious than in chess, and depend more on judgment. So I think it will be even more difficult to programme a computer to play a reasonable game of Go than of chess.))

Prior to 2015, the best Go programs only managed to reach [[Go ranks and ratings#Kyu and dan ranks|amateur dan]] level.<ref name="AlphaGo">((Cite journal|title = Mastering the game of Go with deep neural networks and tree search|journal = [[Nature (journal)|Nature]]| issn= 0028-0836|pages = 484–489|volume = 529|issue = 7587|doi = 10.1038/nature16961|pmid = 26819042|first1 = David|last1 = Silver|author-link1=David Silver (programmer)|first2 = Aja|last2 = Huang|author-link2=Aja Huang|first3 = Chris J.|last3 = Maddison|first4 = Arthur|last4 = Guez|first5 = Laurent|last5 = Sifre|first6 = George van den|last6 = Driessche|first7 = Julian|last7 = Schrittwieser|first8 = Ioannis|last8 = Antonoglou|first9 = Veda|last9 = Panneershelvam|first10= Marc|last10= Lanctot|first11= Sander|last11= Dieleman|first12=Dominik|last12= Grewe|first13= John|last13= Nham|first14= Nal|last14= Kalchbrenner|first15= Ilya|last15= Sutskever|author-link15=Ilya Sutskever|first16= Timothy|last16= Lillicrap|first17= Madeleine|last17= Leach|first18= Koray|last18= Kavukcuoglu|first19= Thore|last19= Graepel|first20= Demis |last20=Hassabis|author-link20=Demis Hassabis|date= 28 January 2016|bibcode = 2016Natur.529..484S|s2cid = 515925))((closed access))</ref><ref name=humancomputermatchs>((cite web|last=Wedd|first=Nick|title=Human-Computer Go Challenges|url=http://www.computer-go.info/h-c/index.html|work=computer-go.info|access-date=2011-10-28))</ref> On the small 9×9 board, the computer fared better, and some programs managed to win a fraction of their 9×9 games against professional players. Prior to AlphaGo, some researchers had claimed that computers would never defeat top humans at Go.<ref>((cite web|url=https://www.science.org/content/article/huge-leap-forward-computer-mimics-human-brain-beats-professional-game-go|title='Huge leap forward': Computer that mimics human brain beats professional at game of Go))</ref>

=== Early decades ===

The first Go program was written by [[Albert Lindsey Zobrist]] in 1968 as part of his thesis on [[pattern recognition]].<ref>Albert Zobrist (1970), [http://www.cs.wisc.edu/techreports/1970/TR88.pdf Feature Extraction and Representation for Pattern Recognition and the Game of Go]. Ph.D. Thesis (152 pp.), University of Wisconsin. Also published as technical report</ref> It introduced an [[Influence function (statistics)|influence function]] to estimate territory and [[Zobrist hashing]] to detect [[Ko rule|ko]].

In April 1981, Jonathan K Millen published an article in ''[[Byte (magazine)|Byte]]'' discussing Wally, a Go program with a 15x15 board that fit within the [[KIM-1]] microcomputer's 1K RAM.<ref name="millen198104">((cite news | url=https://archive.org/stream/byte-magazine-1981-04/1981_04_BYTE_06-04_Future_Computers#page/n101/mode/2up | title=Programming the Game of Go | work=[[Byte (magazine)|Byte]] | date=April 1981 | access-date=18 October 2013 | author=Millen, Jonathan K | pages=102))</ref> [[Bruce F. Webster]] published an article in the magazine in November 1984 discussing a Go program he had written for the [[Apple Macintosh]], including the [[MacFORTH]] source.<ref name="webster198411">((cite news | url=https://archive.org/stream/byte-magazine-1984-11/1984_11_BYTE_09-12_New_Chips#page/n125/mode/2up | title=A Go Board for the Macintosh | work=[[Byte (magazine)|Byte]] | date=November 1984 | access-date=23 October 2013 | first=Bruce |last=Webster | author-link=Bruce Webster | pages=125))</ref>  Programs for Go were weak; a 1983 article estimated that they were at best equivalent to 20 ''kyu'', the rating of a naive novice player, and often restricted themselves to smaller boards.<ref>((cite book |last=Campbell |first=J A |date=1983 |editor-last=Bramer |editor-first=M A |title=Computer Game-Playing: Theory and Practice |publisher=Ellis Horwood Limited |page=138 |chapter=Part III: Go Introduction |isbn=0-85312-488-4))</ref>  AIs who played on the [[IGS Go server|Internet Go Server (IGS)]] on 19x19 size boards had around 20&ndash;15 ''kyu'' strength in 2003, after substantial improvements in hardware.<ref>((cite book |last=Shotwell |first=Peter  |date=2003 |title=Go! More than a Game |location= |publisher=Tuttle Publishing |page=164 |isbn=0-8048-3475-X))</ref>

In 1998, very strong players were able to beat computer programs while giving handicaps of 25–30 stones, an enormous handicap that few human players would ever take. There was a case in the 1994 World Computer Go Championship where the winning program, Go Intellect, lost all three games against the youth players while receiving a 15-stone handicap.<ref>((cite web|url=http://www.itee.uq.edu.au/~janetw/Computer%20Go/CS-TR-339.html#6.2|title=CS-TR-339 Computer Go Tech Report|access-date=28 January 2016|archive-date=4 February 2014|archive-url=https://web.archive.org/web/20140204184516/http://itee.uq.edu.au/~janetw/Computer%20Go/CS-TR-339.html#6.2|url-status=dead))</ref> In general, players who understood and exploited a program's weaknesses could win even through large handicaps.<ref>[http://www.intgofed.org/history/computer_go_dec2005.pdf See for instance intgofed.org] ((webarchive |url=https://web.archive.org/web/20080528195407/http://www.intgofed.org/history/computer_go_dec2005.pdf |date=May 28, 2008 ))</ref>

=== 2007&ndash;2014: Monte Carlo tree search ===
In 2006 (with an article published in 2007), [[Rémi Coulom]] produced a new algorithm he called [[Monte Carlo tree search]].<ref>((cite book|author=Rémi Coulom|chapter=Efficient Selectivity and Backup Operators in Monte-Carlo Tree Search|pages=72–83|others=H. Jaap van den Herik, Paolo Ciancarini, H. H. L. M. Donkers (eds.)|title=Computers and Games, 5th International Conference, CG 2006, Turin, Italy, May 29–31, 2006. Revised Papers |publisher=Springer|year=2007|isbn=978-3-540-75537-1|citeseerx=10.1.1.81.6817|author-link=Rémi Coulom))</ref>  In it, a game tree is created as usual of potential futures that branch with every move.  However, computers "score" a terminal leaf of the tree by repeated random playouts (similar to [[Monte Carlo method|Monte Carlo]] strategies for other problems).  The advantage is that such random playouts can be done very quickly.  The intuitive objection - that random playouts do not correspond to the actual worth of a position - turned out not to be as fatal to the procedure as expected; the "tree search" side of the algorithm corrected well enough for finding reasonable future game trees to explore.  Programs based on this method such as MoGo and Fuego saw better performance than classic AIs from earlier.   The best programs could do especially well on the small 9x9 board, which had fewer possibilities to explore.  In 2009, the first such programs appeared which could reach and hold low [[Go ranks and ratings|dan-level ranks]] on the [[KGS Go Server]] on the 19x19 board.

In 2010, at the 2010 European Go Congress in Finland, MogoTW played 19x19 Go against [[Catalin Taranu]] (5p). MogoTW received a seven-stone handicap and won.<ref>((cite web|url=http://www.egc2010.fi/news.php|title=EGC 2010 Tampere News|access-date=28 January 2016|url-status=dead|archive-url=https://web.archive.org/web/20090814112411/http://www.egc2010.fi/news.php|archive-date=14 August 2009))</ref>

In 2011, [[Zen (software)|Zen]] reached 5 dan on the server KGS, playing games of 15 seconds per move. The account which reached that rank uses a cluster version of Zen running on a 26-core machine.<ref name="gokgs.com">((cite web|url=http://www.gokgs.com/gameArchives.jsp?user=+Zen19D|title=KGS Game Archives|access-date=28 January 2016))</ref>

In 2012, Zen beat [[Takemiya Masaki]] (9p) by 11 points at five stones handicap, followed by a 20-point win at four stones handicap.<ref>((cite web|url=https://gogameguru.com/zen-computer-go-program-beats-takemiya-masaki-4-stones/|title=Zen computer Go program beats Takemiya Masaki with just 4 stones!|work=Go Game Guru|access-date=28 January 2016|archive-url=https://web.archive.org/web/20160201162313/https://gogameguru.com/zen-computer-go-program-beats-takemiya-masaki-4-stones/|archive-date=2016-02-01|url-status=dead))</ref>

In 2013, [[Crazy Stone (software)|Crazy Stone]] beat [[Yoshio Ishida]] (9p) in a 19×19 game at four stones handicap.<ref>((cite web|title=「アマ六段の力。天才かも」囲碁棋士、コンピューターに敗れる 初の公式戦 |url=http://sankei.jp.msn.com/life/news/130320/igo13032020420000-n1.htm |publisher=MSN Sankei News |access-date=27 March 2013 |url-status=dead |archive-url=https://web.archive.org/web/20130324221549/http://sankei.jp.msn.com/life/news/130320/igo13032020420000-n1.htm |archive-date=24 March 2013 ))</ref>

The 2014 Codecentric Go Challenge, a best-of-five match in an even 19x19 game, was played between Crazy Stone and Franz-Jozef Dickhut (6d). No stronger player had ever before agreed to play a serious competition against a go program on even terms. Franz-Jozef Dickhut won, though Crazy Stone won the first match by 1.5 points.<ref>((cite web|url=https://go.codecentric.de/#homepage|title=codecentric go challenge – Just another WordPress site|access-date=28 January 2016))</ref>

=== 2015 onwards: The deep learning era ===
((Further|AlphaGo|AlphaGo versus Fan Hui|AlphaGo versus Lee Sedol|AlphaGo versus Ke Jie))

[[AlphaGo]], developed by [[Google DeepMind]], was a significant advance in computer strength compared to previous Go programs.  It used techniques that combined [[deep learning]] and [[Monte Carlo tree search]].<ref name="googlego">((cite web|url=http://googleresearch.blogspot.com/2016/01/alphago-mastering-ancient-game-of-go.html|title=Research Blog: AlphaGo: Mastering the ancient game of Go with Machine Learning|date=27 January 2016|work=Google Research Blog))</ref>  In October 2015, it defeated [[Fan Hui]], the European Go champion, five times out of five in tournament conditions.<ref>((cite journal|title=Google AI algorithm masters ancient game of Go|journal=Nature News & Comment |year=2016|doi=10.1038/529445a|last1=Gibney|first1=Elizabeth |volume=529|issue=7587 |pages=445–446 |pmid=26819021 |bibcode=2016Natur.529..445G|s2cid=4460235|doi-access=free))</ref> In March 2016, AlphaGo beat [[Lee Sedol]] in the first three of five matches.<ref name="BBC News 12 March 2016">((cite web | title= Artificial intelligence: Google's AlphaGo beats Go master Lee Se-dol |url= https://www.bbc.co.uk/news/technology-35785875| author=<!--Staff writer(s); no by-line.-->|date= 12 March 2016| website= [[BBC News Online]] | access-date= 12 March 2016 ))</ref> This was the first time that a [[9-dan]] master had played a professional game against a computer without handicap.<ref>((cite web|url=https://www.theverge.com/2016/3/9/11184362/google-alphago-go-deepmind-result|title=Google's DeepMind defeats legendary Go player Lee Se-dol in historic victory|date=9 March 2016|publisher=www.theverge.com|access-date=9 March 2016))</ref> Lee won the fourth match, describing his win as "invaluable".<ref name="BBC News 13 March 2016">((cite web | title= Artificial intelligence: Go master Lee Se-dol wins against AlphaGo program |url= https://www.bbc.co.uk/news/technology-35797102| author=<!--Staff writer(s); no by-line.-->|date= 13 March 2016| website= [[BBC News Online]] | access-date= 13 March 2016 ))</ref> AlphaGo won the final match two days later.<ref name="The Verge 15 March 2016">((cite web|url=https://www.theverge.com/2016/3/15/11213518/alphago-deepmind-go-match-5-result|title=Google's AlphaGo AI beats Lee Se-dol again to win Go series 4-1|website=[[The Verge]]|date=15 March 2016|access-date=15 March 2016))</ref><ref>((cite magazine|url=https://www.wired.com/2017/05/win-china-alphagos-designers-explore-new-ai/|title=After Win in China, AlphaGo's Designers Explore New AI|magazine=Wired|date=2017-05-27|last1=Metz|first1=Cade))</ref>  With this victory, AlphaGo became the first program to beat a 9 dan human professional in a game without handicaps on a full-sized board.

In May 2017,  AlphaGo beat [[Ke Jie]], who at the time was ranked top in the world,<ref>((Cite web|url=https://www.goratings.org/en/history/|title=World's Go Player Ratings|date=May 2017))</ref><ref>((Cite web|title=柯洁迎19岁生日 雄踞人类世界排名第一已两年|url=http://sports.sina.com.cn/go/2016-08-02/doc-ifxunyya3020238.shtml|language=zh|date=May 2017))</ref> in a [[AlphaGo versus Ke Jie|three-game match]] during the [[Future of Go Summit]].<ref name="wuzhensecond">((cite magazine|url=https://www.wired.com/2017/05/googles-alphago-continues-dominance-second-win-china/|title=Google's AlphaGo Continues Dominance With Second Win in China|magazine=Wired|date=2017-05-25|last1=Metz|first1=Cade))</ref>

In October 2017, DeepMind revealed a new version of AlphaGo, trained only through self play, that had surpassed all previous versions, beating the Ke Jie version in 89 out of 100 games.<ref name="alphagozero">((cite journal |first1=David |last1=Silver|author-link1=David Silver (programmer)|first2= Julian|last2= Schrittwieser|first3= Karen|last3= Simonyan|first4= Ioannis|last4= Antonoglou|first5= Aja|last5= Huang|author-link5=Aja Huang|first6=Arthur|last6= Guez|first7= Thomas|last7= Hubert|first8= Lucas|last8= Baker|first9= Matthew|last9= Lai|first10= Adrian|last10= Bolton|first11= Yutian|last11= Chen|author-link11=Chen Yutian|first12= Timothy|last12= Lillicrap|first13=Hui|last13= Fan|author-link13=Fan Hui|first14= Laurent|last14= Sifre|first15= George van den|last15= Driessche|first16= Thore|last16= Graepel|first17= Demis|last17= Hassabis |author-link17=Demis Hassabis|title=Mastering the game of Go without human knowledge|journal=[[Nature (journal)|Nature]]|issn= 0028-0836|pages=354–359|volume =550|issue =7676|doi =10.1038/nature24270|pmid=29052630|date=19 October 2017|bibcode=2017Natur.550..354S|s2cid=205261034|url= http://discovery.ucl.ac.uk/10045895/1/agz_unformatted_nature.pdf))((closed access))</ref>

After the basic principles of AlphaGo were published in the journal ''Nature'', other teams have been able to produce high-level programs. Work on Go AI since has largely consisted of emulating the techniques used to build AlphaGo, which proved so much stronger than everything else. By 2017, both [[Zen (software)|Zen]] and [[Tencent]]'s project [[Fine Art (software)|Fine Art]] were capable of defeating very high-level professionals some of the time.  The open source [[Leela Zero]] engine was created as well.

== Challenges for strategy and performance for classic AIs ==
((More citations needed section|date=October 2007))
((Update section|date=June 2022|reason=Most of this section dates back to 2010, before there were high-level Go computers. The entire section might need to be condensed and rewritten, since these obstacles are now largely historical.))

For a long time, it was a widely held opinion that computer Go posed a problem fundamentally different from [[computer chess]]. Many considered a strong Go-playing program something that could be achieved only in the far future, as a result of fundamental advances in general artificial intelligence technology.  Those who thought the problem feasible believed that domain knowledge would be required to be effective against human experts. Therefore, a large part of the computer Go development effort was during these times focused on ways of representing human-like expert knowledge and combining this with local search to answer questions of a tactical nature. The result of this were programs that handled many specific situations well but which had very pronounced weaknesses in their overall handling of the game. Also, these classical programs gained almost nothing from increases in available computing power.  Progress in the field was generally slow.

;Size of board 
The large board (19×19, 361 intersections) is often noted as one of the primary reasons why a strong program is hard to create. The large board size prevents an [[alpha–beta pruning|alpha-beta searcher]] from achieving deep look-ahead without significant search extensions or [[Pruning (decision trees)|pruning]] heuristics.

In 2002, a computer program called MIGOS (MIni GO Solver) completely solved the game of Go for the 5×5 board. Black wins, taking the whole board.<ref>((cite web|url=http://erikvanderwerf.tengen.nl/5x5/5x5solved.html|title=5x5 Go is solved|access-date=28 January 2016))</ref>

;Number of move options
Continuing the comparison to chess, Go moves are not as limited by the rules of the game.  For the first move in chess, the player has twenty choices. Go players begin with a choice of 55 distinct legal moves, accounting for symmetry. This number rises quickly as symmetry is broken, and soon almost all of the 361 points of the board must be evaluated.

;Evaluation function
One of the most basic tasks in a game is to assess a board position: which side is favored, and by how much?  In chess, many future positions in a tree are direct wins for one side, and boards have a reasonable heuristic for evaluation in simple material counting, as well as certain positional factors such as pawn structure.  A future where one side has lost their queen for no benefit clearly favors the other side.  These types of positional evaluation rules cannot efficiently be applied to Go. The value of a Go position depends on a complex analysis to determine whether or not the group is alive, which stones can be connected to one another, and heuristics around the extent to which a strong position has influence, or the extent to which a weak position can be attacked.  A stone placed might not have immediate influence, but after many moves could become highly important in retrospect as other areas of the board take shape.

Poor evaluation of board states will cause the AI to work toward positions it incorrectly believes favor it, but actually do not.

;Life and death
One of the main concerns for a Go player is which groups of stones can be kept alive and which can be captured. This general class of problems is known as [[life and death]].  Knowledge-based AI systems sometimes attempted to understand the life and death status of groups on the board.  The most direct approach is to perform a [[tree search]] on the moves which potentially affect the stones in question, and then to record the status of the stones at the end of the main line of play.  However, within time and memory constraints, it is not generally possible to determine with complete accuracy which moves could affect the 'life' of a group of stones.  This implies that some [[heuristic]] must be applied to select which moves to consider.  The net effect is that for any given program, there is a trade-off between playing speed and life and death reading abilities.

== State representation ==
An issue that all Go programs must tackle is how to represent the current state of the game.  The most direct way of representing a board is as a one- or two-dimensional array, where elements in the array represent points on the board, and can take on a value corresponding to a white stone, a black stone, or an empty intersection. Additional data is needed to store how many stones have been captured, whose turn it is, and which intersections are illegal due to the [[Ko rule]].  In general, machine learning programs stop there at this simplest form and let the organic AIs come to their own understanding of the meaning of the board, likely simply using Monte Carlo playouts to "score" a board as good or bad for a player.  "Classic" AI programs that attempted to directly model a human's strategy might go further, however, such as layering on data such as stones believed to be dead, stones that are unconditionally alive, stones in a ''seki'' state of mutual life, and so forth in their representation of the state of the game.

== System design ==
Historically, [[symbolic artificial intelligence]] techniques have been used to approach the problem of Go AI.  [[Artificial neural network|Neural networks]] began to be tried as an alternative approach in the 2000s decade, as they required immense computing power that was expensive-to-impossible to reach in earlier decades.  These approaches attempt to mitigate the problems of the game of Go having a high [[branching factor]] and numerous other difficulties.

The only choice a program needs to make is where to place its next stone.  However, this decision is made difficult by the wide range of impacts a single stone can have across the entire board, and the complex interactions various stones' groups can have with each other.  Various architectures have arisen for handling this problem.  Popular techniques and design philosophies include:
* some form of [[tree search]],
* [[pattern matching]] and [[knowledge-based systems]], 
* the application of [[Monte Carlo method]]s,
* the use of [[machine learning]].

=== Minimax tree search ===
One [[symbolic AI|traditional AI]] technique for creating game playing software is to use a [[minimax]] [[tree search]].  This involves playing out all hypothetical moves on the board up to a certain point, then using an [[evaluation function]] to estimate the value of that position for the current player.  The move which leads to the best hypothetical board is selected, and the process is repeated each turn.  While tree searches have been very effective in [[computer chess]], they have seen less success in Computer Go programs.  This is partly because it has traditionally been difficult to create an effective evaluation function for a Go board, and partly because the large number of possible moves each side can make each leads to a high [[branching factor]].  This makes this technique very computationally expensive.  Because of this, many programs which use search trees extensively can only play on the smaller 9×9 board, rather than full 19×19 ones.

There are several techniques, which can greatly improve the performance of search trees in terms of both speed and memory.  Pruning techniques such as [[alpha–beta pruning]], [[Principal variation search|Principal Variation Search]], and [[MTD(f)]] can reduce the effective branching factor without loss of strength.  In tactical areas such as life and death, Go is particularly amenable to caching techniques such as [[transposition table]]s. These can reduce the amount of repeated effort, especially when combined with an [[iterative deepening]] approach.  In order to quickly store a full-sized Go board in a transposition table, a [[hash function|hashing]] technique for mathematically summarizing is generally necessary.  [[Zobrist hashing]] is very popular in Go programs because it has low collision rates, and can be iteratively updated at each move with just two [[XOR]]s, rather than being calculated from scratch.  Even using these performance-enhancing techniques, full tree searches on a full-sized board are still prohibitively slow.  Searches can be sped up by using large amounts of domain specific pruning techniques, such as not considering moves where your opponent is already strong, and selective extensions like always considering moves next to groups of stones which are [[Go terms#Atari|about to be captured]].  However, both of these options introduce a significant risk of not considering a vital move which would have changed the course of the game.

Results of computer competitions show that pattern matching techniques for choosing a handful of appropriate moves combined with fast localized tactical searches (explained above) were once sufficient to produce a competitive program. For example, [[GNU Go]] was competitive until 2008.

=== Knowledge-based systems ===
Human novices often learn from the game records of old games played by master players.  AI work in the 1990s often involved attempting to "teach" the AI human-style heuristics of Go knowledge. In 1996, Tim Klinger and David Mechner acknowledged the beginner-level strength of the best AIs and argued that "it is our belief that with better tools for representing and maintaining Go knowledge, it will be possible to develop stronger Go programs."<ref name="klinger-mechner">Klinger, Tim and Mechner, David. ''[https://web.archive.org/web/20070928015006/http://mechner.com/david/compgo/acg/ An Architecture for Computer Go]'' (1996)</ref>  They proposed two ways: recognizing common configurations of stones and their positions and concentrating on local battles. In 2001, one paper concluded that "Go programs are still lacking in both quality and quantity of knowledge," and that fixing this would improve Go AI performance.<ref name="Muller" />

In theory, the use of expert knowledge would improve Go software. Hundreds of guidelines and rules of thumb for strong play have been formulated by both high-level amateurs and professionals. The programmer's task is to take these [[heuristics]], formalize them into computer code, and utilize [[pattern matching]] and [[pattern recognition]] algorithms to recognize when these rules apply.  It is also important to be able to "score" these heuristics so that when they offer conflicting advice, the system has ways to determine which heuristic is more important and applicable to the situation.  Most of the relatively successful results come from programmers' individual skills at Go and their personal conjectures about Go, but not from formal mathematical assertions; they are trying to make the computer mimic the way they play Go.  Competitive programs around 2001 could contain 50–100 modules that dealt with different aspects and strategies of the game, such as joseki.<ref name="Muller" />

Some examples of programs which have relied heavily on expert knowledge are Handtalk (later known as Goemate), The Many Faces of Go, Go Intellect, and Go++, each of which has at some point been considered the world's best Go program.  However, these methods ultimately had diminishing returns, and never really advanced past an intermediate level at best on a full-sized board.  One particular problem was overall game strategy.  Even if an expert system recognizes a pattern and knows how to play a local skirmish, it may miss a looming deeper strategic problem in the future.  The result is a program whose strength is less than the sum of its parts; while moves may be good on an individual tactical basis, the program can be tricked and maneuvered into ceding too much in exchange, and find itself in an overall losing position.  As the 2001 survey put it, "just one bad move can ruin a good game. Program performance over a full game can be much lower than master level."<ref name="Muller" />

=== Monte-Carlo methods ===
((Main|Monte-Carlo tree search))
One major alternative to using hand-coded knowledge and searches is the use of [[Monte Carlo method]]s.  This is done by generating a list of potential moves, and for each move playing out thousands of games at random on the resulting board.  The move which leads to the best set of random games for the current player is chosen as the best move.  No potentially fallible knowledge-based system is required.  However, because the moves used for evaluation are generated at random it is possible that a move which would be excellent except for one specific opponent response would be mistakenly evaluated as a good move. The result of this are programs which are strong in an overall strategic sense, but are imperfect tactically.((Citation needed|date=January 2015)) This problem can be mitigated by adding some domain knowledge in the move generation and a greater level of search depth on top of the random evolution.  Some programs which use Monte-Carlo techniques are Fuego,<ref name="sourceforge.net">((cite web|url=http://fuego.sourceforge.net/|title=Fuego))</ref> The Many Faces of Go v12,<ref name="davidfotland">((cite web|url=http://www.smart-games.com/manyfaces.html|title=Dan Level Go Software – Many Faces of Go|author=David Fotland))</ref> Leela,<ref name="sjeng.org">((cite web|url=http://www.sjeng.org/leela|title=Sjeng – chess, audio and misc. software))</ref>  MoGo,<ref name="lri.fr">((Cite web |url=http://www.lri.fr/~teytaud/mogo.html |title=Archived copy |access-date=2008-06-03 |archive-url=https://web.archive.org/web/20080810222849/http://www.lri.fr/~teytaud/mogo.html |archive-date=2008-08-10 |url-status=dead ))</ref> [[Crazy Stone (software)|Crazy Stone]], MyGoFriend,<ref name="mygofriend.com">((cite web|url=http://www.mygofriend.com/|title=MyGoFriend – Gold Medal Winner 15th Computer Olympiad, Go (9x9)|url-status=dead|archive-url=https://web.archive.org/web/20101208200028/http://mygofriend.com/|archive-date=2010-12-08))</ref> and Zen.

In 2006, a new search technique, ''upper confidence bounds applied to trees'' (UCT),<ref>((cite web|url=http://senseis.xmp.net/?UCT|title=UCT))</ref> was developed and applied to many 9x9 Monte-Carlo Go programs with excellent results. UCT uses the results of the ''play outs'' collected so far to guide the search along the more successful lines of play, while still allowing alternative lines to be explored. The UCT technique along with many other optimizations for playing on the larger 19x19 board has led MoGo to become one of the strongest research programs. Successful early applications of UCT methods to 19x19 Go include MoGo, Crazy Stone, and Mango.<ref>((cite web|url=http://www.cs.unimaas.nl/go4go/mango/|title=Mango |url-status=dead |archive-url=https://web.archive.org/web/20071103202224/http://www.cs.unimaas.nl/go4go/mango/|archive-date=2007-11-03))</ref> MoGo won the 2007 [[Computer Olympiad]] and won one (out of three) blitz game against Guo Juan, 5th Dan Pro, in the much less complex 9x9 Go.  The Many Faces of Go<ref>((cite web|url=http://www.smart-games.com|title=Smart Games|author=David Fotland))</ref> won the 2008 [[Computer Olympiad]] after adding UCT search to its traditional knowledge-based engine.

Monte-Carlo based Go engines have a reputation of being much more willing to play ''tenuki'', moves elsewhere on the board, rather than continue a local fight than human players.  This was often perceived as a weakness early in these program's existence.<ref>((Cite news|url=https://www.bbc.com/news/technology-35419141|title=Facebook trains AI to beat humans at Go board game – BBC News|work=BBC News|date=27 January 2016|language=en-GB|access-date=2016-04-24))</ref>  That said, this tendency has persisted in AlphaGo's playstyle with dominant results, so this may be more of a "quirk" than a "weakness."<ref name="ggg">((cite web |url=https://gogameguru.com/alphago-shows-true-strength-3rd-victory-lee-sedol/ |title=AlphaGo shows its true strength in 3rd victory against Lee Sedol |first=David |last=Ormerod |publisher=Go Game Guru |date=12 March 2016 |access-date=12 March 2016 |archive-url=https://web.archive.org/web/20160313032049/https://gogameguru.com/alphago-shows-true-strength-3rd-victory-lee-sedol/ |archive-date=13 March 2016 |url-status=dead |df=dmy-all ))</ref>

=== Machine learning ===
The skill level of knowledge-based systems is closely linked to the knowledge of their programmers and associated domain experts.  This limitation has made it difficult to program truly strong AIs.  A different path is to use [[machine learning]] techniques.  In these, the only thing that the programmers need to program are the rules and simple scoring algorithms of how to analyze the worth of a position.  The software will then automatically generates its own sense of patterns, heuristics, and strategies, in theory.

This is generally done by allowing a [[artificial neural network|neural network]] or [[genetic algorithm]] to either review a large database of professional games, or play many games against itself or other people or programs.  These algorithms are then able to utilize this data as a means of improving their performance.  Machine learning techniques can also be used in a less ambitious context to tune specific parameters of programs that rely mainly on other techniques. For example, [[Crazy Stone (software)|Crazy Stone]] learns move generation patterns from several hundred sample games, using a generalization of the [[Elo rating system]].<ref>((cite web|url=http://remi.coulom.free.fr/Amsterdam2007/|title=Computing Elo Ratings of Move Patterns in the Game of Go|access-date=28 January 2016))</ref>

The most famous example of this approach is AlphaGo, which proved far more effective than previous AIs.  In its first version, it had one layer that analyzed millions of existing positions to determine likely moves to prioritize as worthy of further analysis, and another layer that tried to optimize its own winning chances using the suggested likely moves from the first layer.  AlphaGo used Monte Carlo tree search to score the resulting positions.  A later version of AlphaGo, AlphaGoZero, eschewed learning from existing Go games, and instead learnt only from playing itself repeatedly.  Other earlier programs using neural nets include NeuroGo and WinHonte.

== Computer Go and other fields==
Computer Go research results are being applied to other similar fields such as [[cognitive science]], [[pattern recognition]] and [[machine learning]].<ref name="Muhammad Mohsin">Muhammad, Mohsin. [https://web.archive.org/web/20200128091728/https://revolveurdu.blogspot.com/2020/01/thinking-games.html ''Thinking games''], Artificial Intelligence 134 (2002): p150</ref> [[Combinatorial game theory|Combinatorial Game Theory]], a branch of [[applied mathematics]], is a topic relevant to computer Go.<ref name="Muller">((cite journal|last=Müller|first=Martin |title=Computer Go |journal=[[Artificial Intelligence (journal)|Artificial Intelligence]] |volume=134|date=January 2002|issue=1–2 |pages=148–151|doi=10.1016/S0004-3702(01)00121-7|doi-access=))</ref>  

[[John H. Conway]] suggested applying [[surreal number]]s to analysis of the endgame in Go.  This idea has been further developed by [[Elwyn R. Berlekamp]] and [[David Wolfe (mathematician)|David Wolfe]] in their book ''Mathematical Go''.<ref>((cite book |last1=Berlekamp |first1=Elwyn |author-link=Elwyn Berlekamp |last2=Wolfe |first2=David |author2-link=David Wolfe (mathematician) |date=1994 |title=Mathematical Go: Chilling Gets the Last Point |url= |location= |publisher= Taylor & Francis|page= |isbn=978-1-56881-032-4))</ref>  Go endgames have been proven to be [[PSPACE-hard]] if the absolute best move must be calculated on an arbitrary mostly filled board.  Certain complicated situations such as Triple Ko, Quadruple Ko, Molasses Ko, and Moonshine Life make this problem difficult.<ref>((ubl|((cite web|url=http://senseis.xmp.net/?TripleKo|title=Triple Ko))|((cite web|url=http://senseis.xmp.net/?QuadrupleKo|title=Quadruple Ko)) |((cite web|url=http://senseis.xmp.net/?MolassesKo|title=Molasses Ko)) |((cite web|url=http://senseis.xmp.net/?MoonshineLife|title=Moonshine Life))))</ref>  (In practice, strong Monte Carlo algorithms can still handle normal Go endgame situations well enough, and the most complicated classes of life-and-death endgame problems are unlikely to come up in a high-level game.)<ref>((cite web|url=http://senseis.xmp.net/?ComputerGoProgramming|title=Computer Go Programming))</ref>

Various difficult combinatorial problems (any [[NP-hard]] problem) can be converted to Go-like problems on a sufficiently large board; however, the same is true for other abstract board games, including [[chess]] and [[minesweeper (video game)|minesweeper]], when suitably generalized to a board of arbitrary size. [[NP-complete]] problems do not tend in their general case to be easier for unaided humans than for suitably programmed computers: unaided humans are much worse than computers at solving, for example, instances of the [[subset sum problem]].<ref name="Go-Demaine-Hearn">On page 11: "Crasmaru shows that it is NP-complete to determine the status of certain restricted forms of life-and-death problems in Go." (See the following reference.) ((cite arXiv |author=Erik D. Demaine, Robert A. Hearn |title=Playing Games with Algorithms: Algorithmic Combinatorial Game Theory |date=2008-04-22 |eprint=cs/0106019))</ref><ref name="Go-Crasmaru">((cite book |author=Marcel Crasmaru |title=Computers and Games |chapter=On the complexity of Tsume-Go |volume=1558 |doi=10.1007/3-540-48957-6_15 |pages= 222–231 | location=London, UK |publisher=[[Springer-Verlag]] |year=1999 |series=Lecture Notes in Computer Science |isbn=978-3-540-65766-8))</ref>

== List of Go-playing computer programs ==
((See also|Go software))
* [[AlphaGo]], a machine learning program by Google DeepMind, and the first computer program to win in no-handicap matches against a 9-dan human Go player
* BaduGI, a program by Jooyoung Lee<ref>[https://service.tygem.com/mobile/news/view.php?seq=31226 BaduGI]</ref>
* [[Crazy Stone (software)|Crazy Stone]], by [[Rémi Coulom]] (sold as Saikyo no Igo in Japan)
* [[Darkforest]], by [[Facebook]]
* [[Fine Art (software)|Fine Art]], by [[Tencent]]
* Fuego, an [[Open-source software|open source]] Monte Carlo program<ref name="sourceforge.net" />
* Goban, a Macintosh Go program by Sen:te (requires free Goban Extensions)<ref>
* ((cite web|url=http://www.sente.ch/?p=1206&lang=en|title=Goban. Play Go on Mac – Sen:te|access-date=2013-06-14|archive-url=https://web.archive.org/web/20130519003959/http://www.sente.ch/?p=1206&lang=en|archive-date=2013-05-19|url-status=dead))
* ((cite web|url=http://www.sente.ch/?p=1221&lang=en|title=Goban Extensions – Sen:te|access-date=2013-06-14|archive-url=https://web.archive.org/web/20160518114148/http://www.sente.ch/?p=1221&lang=en|archive-date=2016-05-18|url-status=dead))</ref>
* [[GNU Go]], an open source classical Go program
* [[KataGo]], by David Wu.
* [[Leela (software)|Leela]], the first Monte Carlo program for sale to the public<ref name="sjeng.org" />
* [[Leela Zero]], a reimplementation of the system described in the AlphaGo Zero paper<ref name="sjeng.org" />
* The Many Faces of Go, by David Fotland (sold as AI Igo in Japan)<ref name="davidfotland" />
* MyGoFriend, a program by Frank Karger<ref name="mygofriend.com" />
* MoGo by Sylvain Gelly; parallel version by many people.<ref>((cite web|url=http://www.lri.fr/~gelly/MoGo.htm |title=Sylvain GELLY's Home Page |access-date=2007-02-21 |url-status=dead |archive-url=https://web.archive.org/web/20061128074317/http://www.lri.fr/~gelly/MoGo.htm |archive-date=2006-11-28 ))</ref><ref name="lri.fr" />
* Pachi, an open source Monte Carlo program by Petr Baudiš<ref>((cite web|url=http://pachi.or.cz/|title=Pachi – Board Game of Go / Weiqi / Baduk))</ref>
* Smart Go, by Anders Kierulf, inventor of the [[Smart Game Format]]<ref>((cite web|url=http://www.smartgo.com/|title=SmartGo|author=Anders Kierulf))</ref>
* Steenvreter, by Erik van der Werf<ref>((cite web|url=http://erikvanderwerf.tengen.nl/steenvreter.html|title=STEENVRETER))</ref>
* [[Zen (software)|Zen]], by Yoji Ojima aka Yamato (sold as Tencho no Igo in Japan); parallel version by Hideki Kato.<ref>((cite web|url=http://senseis.xmp.net/?ZenGoProgram|title=Zen (go program)))</ref>

== Competitions among computer Go programs ==
Several annual competitions take place between Go computer programs, including Go events at the [[Computer Olympiad]]. Regular, less formal, competitions between programs used to occur on the KGS Go Server<ref>((cite web|url=http://www.weddslist.com/kgs/index.html|title=Computer Go Tournaments on KGS))</ref> (monthly) and the Computer Go Server<ref>((cite web|url=http://cgos.boardspace.net/|title=9x9 Go Server|access-date=2007-03-25|archive-url=https://web.archive.org/web/20070119034515/http://cgos.boardspace.net/|archive-date=2007-01-19|url-status=dead))</ref> (continuous).

Many programs are available that allow computer Go engines to play against each other; they almost always communicate via the Go Text Protocol (GTP).

=== History ===
The first computer Go competition was sponsored by [[Acornsoft]],<ref>((cite web|title=Acorn 1984 The First Computer Go Tournament|url=http://computer-go.info/events/acorn/1984/index.html|website=computer-go.info))</ref> and the first regular ones by [[USENIX]]. They ran from 1984 to 1988. These competitions introduced Nemesis, the first competitive Go program from [[Bruce Wilcox]], and G2.5 by David Fotland, which would later evolve into Cosmos and The Many Faces of Go.

One of the early drivers of computer Go research was the Ing Prize, a relatively large money award sponsored by Taiwanese banker [[Ing Chang-ki]], offered annually between 1985 and 2000 at the World Computer Go Congress (or Ing Cup). The winner of this tournament was allowed to challenge young players at a handicap in a short match. If the computer won the match, the prize was awarded and a new prize announced: a larger prize for beating the players at a lesser handicap. The series of Ing prizes was set to expire either 1) in the year 2000 or 2) when a program could beat a 1-dan professional at no handicap for 40,000,000 [[New Taiwan dollar|NT dollars]]. The last winner was Handtalk in 1997, claiming 250,000 NT dollars for winning an 11-stone handicap match against three 11–13 year old amateur 2–6 dans. At the time the prize expired in 2000, the unclaimed prize was 400,000 NT dollars for winning a nine-stone handicap match.<ref>((cite web|url=http://www.smart-games.com/worldcompgo.html|title=World Computer Go Championships|author=David Fotland|access-date=28 January 2016))</ref>

Many other large regional Go tournaments ("congresses") had an attached computer Go event.  The European Go Congress has sponsored a computer tournament since 1987, and the USENIX event evolved into the US/North American Computer Go Championship, held annually from 1988–2000 at the US Go Congress.

Japan started sponsoring computer Go competitions in 1995. The FOST Cup was held annually from 1995 to 1999 in Tokyo. That tournament was supplanted by the Gifu Challenge, which was held annually from 2003 to 2006 in Ogaki, Gifu. The [[Computer Go UEC Cup]] has been held annually since 2007.

=== Scoring formalization in computer-computer games ===
When two computers play a game of Go against each other, the ideal is to treat the game in a manner identical to two humans playing while avoiding any intervention from actual humans.  However, this can be difficult during end game scoring.  The main problem is that Go playing software, which usually communicates using the standardized [[Go Text Protocol]] (GTP), will not always agree with respect to the alive or dead status of stones.

While there is no general way for two different programs to "talk it out" and resolve the conflict, this problem is avoided for the most part by using  [[Rules of go#Chinese rules|Chinese]], [[Rules of go#Basic rules|Tromp-Taylor]], or [[American Go Association]] (AGA) rules in which continued play (without penalty) is required until there is no more disagreement on the status of any stones on the board.  In practice, such as on the KGS Go Server, the server can mediate a dispute by sending a special GTP command to the two client programs indicating they should continue placing stones until there is no question about the status of any particular group (all dead stones have been captured).  The CGOS Go Server usually sees programs resign before a game has even reached the scoring phase, but nevertheless supports a modified version of Tromp-Taylor rules requiring a full play out.

These rule sets mean that a program which was in a winning position at the end of the game under Japanese rules (when both players have passed) could theoretically lose because of poor play in the resolution phase, but this is very unlikely and considered a normal part of the game under all of the area rule sets.

The main drawback to the above system is that some [[Rules of Go#Rulesets|rule sets]] (such as the traditional Japanese rules) penalize the players for making these extra moves, precluding the use of additional playout for two computers.  Nevertheless, most modern Go Programs support Japanese rules against humans.

Historically, another method for resolving this problem was to have an expert human judge the final board.  However, this introduces subjectivity into the results and the risk that the expert would miss something the program saw.

== See also ==
* [[Computer chess]]
* [[Computer Othello]]
* [[Computer shogi]]
* [[Go Text Protocol]]

== References ==
((Reflist|30em))

== Further reading ==
* [http://nn.cs.utexas.edu/downloads/papers/lubberts.coevolution-gecco01.pdf Co-Evolving a Go-Playing Neural Network], written by Alex Lubberts & Risto Miikkulainen, 2001
* ''Computer Game Playing: Theory and Practice'', edited by M.A. Brauner (The Ellis Horwood Series in Artificial Intelligence), Halstead Press, 1983. A collection of computer Go articles. The American Go Journal, vol. 18, No 4. page 6. [ISSN 0148-0243]
* [https://web.archive.org/web/20070610163332/http://www.cs.princeton.edu/~jbagdis/jp.pdf A Machine-Learning Approach to Computer Go], Jeffrey Bagdis, 2007.
* [http://affect.media.mit.edu/pdfs/04.wren-reynolds.pdf Minimalism in Ubiquitous Interface Design] Wren, C. and Reynolds, C. (2004) Personal and Ubiquitous Computing, 8(5), pages 370–374. [https://www.youtube.com/watch?v=ntYq8PdKLCA&feature=RecentlyWatched&page=1&t=t&f=b Video of computer Go vision system in operation] shows interaction and users exploring [[Joseki]] and [[Fuseki]].
* [https://web.archive.org/web/20040919093249/http://www.cs.ualberta.ca/~emarkus/monte-carlo/monte-carlo.pdf Monte-Carlo Go], presented by Markus Enzenberger, Computer Go Seminar, University of Alberta, April 2004
* [http://www.math-info.univ-paris5.fr/~bouzy/publications/bouzy-helmstetter.pdf Monte-Carlo Go], written by B. Bouzy and B. Helmstetter from Scientific Literature Digital Library
* [http://www.cs.ualberta.ca/~games/go/seminar/2002/020703/ld.pdf Static analysis of life and death in the game of Go], written by Ken Chen & Zhixing Chen, 20 February 1999
* [http://www.pleinsud.u-psud.fr/specialR2008/en/12_GOthique.pdf article describing the techniques underlying Mogo]

== External links ==
((Wikibooks|Computer Go))
* [http://www.computer-go.info/events/index.html Extensive list of computer Go events]
* [https://web.archive.org/web/20070211211314/http://www.mechner.com/david/compgo/sciences/  All systems Go] by David A. Mechner (1998), discusses the game where professional Go player [[Janice Kim]] won a game against program [[Handtalk]] after giving a 25-stone handicap.
* [http://senseis.xmp.net/?ComputerGo Computer Go] and [http://senseis.xmp.net/?ComputerGoProgramming Computer Go Programming] pages at [http://senseis.xmp.net/ Sensei's Library]
* [http://www.cs.ualberta.ca/~games/go/compgo_biblio/ Computer Go bibliography]
* [http://www.xs4all.nl/~janrem/Artikelen/Artikelen.html Another Computer Go Bibliography]
* [https://web.archive.org/web/20060823204015/http://computer-go.org/mailman/listinfo/computer-go/ Computer Go mailing list]
* Published articles about computer Go on [http://www.ideosphere.com/fx-bin/Claim?claim=GoCh Ideosphere] gives current estimate of whether a Go program will be best player in the world
* [http://www.lysator.liu.se/~gunnar/gtp/ Information on the Go Text Protocol] commonly used for interfacing Go playing engines with graphical clients and internet servers
* The Computer Go Room on the [https://web.archive.org/web/20190928031924/https://www.gokgs.com/ K Go Server] (KGS) for online discussion and running "bots"
* [http://www.cs.ualberta.ca/~mmueller/cgo/survey/twogames.html Two Representative Computer Go Games], an article about two computer Go games played in 1999, one with two computers players, and the other a 29-stone handicap human-computer game
* [http://research.microsoft.com/en-us/news/features/go.aspx What A Way to Go] describes work at Microsoft Research on building a computer Go player.
* [https://web.archive.org/web/20090317022230/http://www.spectrum.ieee.org/oct07/5552 Cracking Go] by Feng-hsiung Hsu, ''IEEE Spectrum'' magazine (October 2007) – Why it should be possible to build a Go machine stronger than any human player
* [https://github.com/yenw/computer-go-dataset/ computer-go-dataset, SGF datasets of 1,645,958 games]

((Go (game)))
[[Category:Computer Go| ]]
[[Category:Game artificial intelligence]]
[[Category:Electronic games]]

Pages transcluded onto the current version of this page (help):

Computer Go (edit)
Template:About (view source) (template editor protected)
Template:Ambox (view source) (template editor protected)
Template:Ambox globe (view source) (template editor protected)
Template:Ambox globe current red (view source) (template editor protected)
Template:Blockquote (view source) (template editor protected)
Template:Blockquote/styles.css (view source) (template editor protected)
Template:Category handler (view source) (protected)
Template:Citation (view source) (protected)
Template:Citation needed (view source) (protected)
Template:Cite arXiv (view source) (template editor protected)
Template:Cite book (view source) (protected)
Template:Cite journal (view source) (protected)
Template:Cite magazine (view source) (protected)
Template:Cite news (view source) (protected)
Template:Cite web (view source) (protected)
Template:Closed access (view source) (extended confirmed protected)
Template:Delink (view source) (template editor protected)
Template:Distinguish (view source) (template editor protected)
Template:Fix (view source) (protected)
Template:Fix/category (view source) (template editor protected)
Template:Further (view source) (template editor protected)
Template:GoBoardGame (edit)
Template:Go (game) (edit)
Template:Go (game) series sidebar (edit)
Template:Hlist/styles.css (view source) (protected)
Template:Main (view source) (template editor protected)
Template:Main other (view source) (protected)
Template:More citations needed (view source) (template editor protected)
Template:More citations needed section (view source) (template editor protected)
Template:Navbox (view source) (template editor protected)
Template:Pagetype (view source) (protected)
Template:Plainlist/styles.css (view source) (protected)
Template:Portal-inline (view source) (template editor protected)
Template:Quote (view source) (template editor protected)
Template:Reflist (view source) (protected)
Template:Reflist/styles.css (view source) (protected)
Template:SDcat (view source) (template editor protected)
Template:SUBJECTSPACE formatted (view source) (template editor protected)
Template:See also (view source) (template editor protected)
Template:Short description (view source) (protected)
Template:Short description/lowercasecheck (view source) (protected)
Template:Side box (view source) (template editor protected)
Template:Sidebar (view source) (template editor protected)
Template:Sister project (view source) (template editor protected)
Template:Sp (view source) (template editor protected)
Template:Trim (view source) (protected)
Template:Ubl (view source) (template editor protected)
Template:Unbulleted list (view source) (template editor protected)
Template:Update (view source) (template editor protected)
Template:Update section (view source) (extended confirmed protected)
Template:Webarchive (view source) (template editor protected)
Template:Wikibooks (view source) (template editor protected)
Module:About (view source) (template editor protected)
Module:Arguments (view source) (protected)
Module:Category handler (view source) (protected)
Module:Category handler/blacklist (view source) (protected)
Module:Category handler/config (view source) (protected)
Module:Category handler/data (view source) (protected)
Module:Category handler/shared (view source) (protected)
Module:Check for unknown parameters (view source) (protected)
Module:Citation/CS1 (view source) (protected)
Module:Citation/CS1/COinS (view source) (protected)
Module:Citation/CS1/Configuration (view source) (protected)
Module:Citation/CS1/Date validation (view source) (protected)
Module:Citation/CS1/Identifiers (view source) (protected)
Module:Citation/CS1/Utilities (view source) (protected)
Module:Citation/CS1/Whitelist (view source) (protected)
Module:Citation/CS1/styles.css (view source) (protected)
Module:Delink (view source) (template editor protected)
Module:Disambiguation/templates (view source) (protected)
Module:Distinguish (view source) (template editor protected)
Module:Format link (view source) (template editor protected)
Module:Hatnote (view source) (template editor protected)
Module:Hatnote/styles.css (view source) (template editor protected)
Module:Hatnote list (view source) (template editor protected)
Module:Labelled list hatnote (view source) (template editor protected)
Module:List (view source) (protected)
Module:Message box (view source) (protected)
Module:Message box/ambox.css (view source) (protected)
Module:Message box/configuration (view source) (protected)
Module:Namespace detect/config (view source) (protected)
Module:Namespace detect/data (view source) (protected)
Module:Navbar (view source) (protected)
Module:Navbar/configuration (view source) (protected)
Module:Navbar/styles.css (view source) (protected)
Module:Navbox (view source) (template editor protected)
Module:Navbox/configuration (view source) (template editor protected)
Module:Navbox/styles.css (view source) (template editor protected)
Module:Pagetype (view source) (protected)
Module:Pagetype/config (view source) (protected)
Module:Pagetype/disambiguation (view source) (template editor protected)
Module:Pagetype/setindex (view source) (template editor protected)
Module:Pagetype/softredirect (view source) (template editor protected)
Module:Portal (view source) (template editor protected)
Module:Portal-inline (view source) (template editor protected)
Module:Portal/images/g (view source) (template editor protected)
Module:SDcat (view source) (template editor protected)
Module:Side box (view source) (template editor protected)
Module:Side box/styles.css (view source) (template editor protected)
Module:Sidebar (view source) (template editor protected)
Module:Sidebar/configuration (view source) (template editor protected)
Module:Sidebar/styles.css (view source) (template editor protected)
Module:String (view source) (protected)
Module:TableTools (view source) (protected)
Module:Unsubst (view source) (protected)
Module:Webarchive (view source) (template editor protected)
Module:Webarchive/data (view source) (template editor protected)
Module:Wikitext Parsing (view source) (template editor protected)
Module:Yesno (view source) (protected)

Return to Computer Go.

Retrieved from "https://en.wikipedia.org/wiki/Computer_Go"