Generational Dynamics: Forecasting America's Destiny Generational
 Forecasting America's Destiny ... and the World's


Generational Dynamics Web Log for 23-Jul-07
Researchers solve the game of checkers (draughts)

Web Log - July, 2007

Researchers solve the game of checkers (draughts)

We now know: With perfect play on both sides, the game is a draw.

Jonathan Schaeffer, a 50-year-old computer scientist from the University of Alberta, has written a computer program that plays a perfect game of checkers, and he's proven that he's done so.

You can play against Chinook, the checker-playing program by visiting its web site. There you'll also find sample games, move databases, history of the project, and Schaeffer's proof. However, the version of Chinook on that web site has reduced playing strength, so that you might have a prayer of winning the game if you're very, very lucky.

Although this is being hailed as a great achievement in Artificial Intelligence (AI), it's actually one more example of the total failure of AI as it was envisioned in the 1950s.

Actually, an AI pioneer named Arthur Samuel developed a pretty good checker-playing program in the late 1950s, running on an IBM 701 computer. The computer could play at near-master strength.

An innovative feature of Samuel's program was its ability to "learn." It would save positions it had seen before, along with the final result. It also played games against itself to build up its library of games. It would use that saved data to guide it in future games. In time, the computer program became a stronger and stronger player.

This was quite a remarkable thing in 1957, and researchers increasingly turned their attention to the game of chess, leading to this prediction by Herbert A. Simon and Allen Newell: "Within ten years a computer will be the world's chess champion, unless the rules bar it from competition."

The assumption was that AI researchers would figure out many clever new things, like the way they got the checkers program to "learn," and that by 1967, they would have found enough clever new things for the computer to be able to beat a human at chess.

The prediction didn't come true, of course. By the late 1960s there was a chess playing program available, written by Richard Greenblatt at MIT, that could play as well as a good amateur, but no better.

Last year, a computer did essentially become world champion, when the Deep Fritz computer beat world chess champion Vladimir Kramnik, by a score of 4-2 in a 6-game match.

Well, that was 40 years late, but better late than never.

What clever new things did the AI researchers have to figure out to make that computer a world champion? Virtually none. The Deep Fritz world champion chess program used the same algorithms as the amateur program from the 1ate 1960s. There's only one difference: Computers are faster. Since computers are faster, they can look ahead more moves, and compute more variations in a small amount of time.

The new checker champion carries this "brute force" technique to its ultimate limit. It uses virtually no clever AI things at all.

The new Chinook computer software was developed by letting super-fast computers run and compile a huge database of as many checker board positions as possible, along with the outcome of each position. When it plays a game, it simply looks up the current position in its database and plays the correct move. Some AI!

What's even more ironic is that the Chinook checker program "learned" in exactly the same way that the Arthur Samuel's 1957 program worked. It played against itself and built up a huge database of games and the best move for each one. The only difference is that computers are faster and data storage is larger.

In my 2004 article, "I, Robot is science fiction, but intelligent computers will soon be science fact," I mentioned that I had developed an intelligent computer algorithm that would allow a computer to be more intelligent than a human being.

How did I do that? I just used the same ideas that the chess and checker software programs use. A computer can understand what it sees and hears by matching up the sights and sounds with those stored in a huge database of sights and sounds, just like the checkers program looks up checkerboard positions in a database.

And the computer figures out what to do next by looking making a list of all the things it can do, then making a list of things that will happen in response for each one, then making a list of things that it can do in response to those, and so forth, evaluating huge numbers of "variations," just as the chess-playing program looks ahead at moves and counter-moves.

So, why don't we have computers that are smarter than humans today?

Because computers aren't fast enough yet. With 5-10 years, there will be computers fast enough to implement the above algorithm, those computers will become more intelligent than humans.

Just like the checker playing programs, these super-intelligent computers will "learn." But for these computers, "learning" will take (at least) two different forms: In one form, the computers will build up their databases of different situations and how to handle them, and the computers will share those databases with one another.

The second form is much more important. Intelligent computers will become physicists and engineers and inventors, and they will invent faster and faster computers that will become even more intelligent. That's when the Singularity will occur.

My estimate is that the Singularity will occur in the late 2020s. After that, the computers will be in charge, and the continued survival of the human race will be in doubt.

Does this worry you, Dear Reader? Then perhaps this F-Minus comic strip from Saturday's paper may cheer you up:

F-Minus comic strip, 21-Jul-2007
F-Minus comic strip, 21-Jul-2007

(23-Jul-07) Permanent Link
Receive daily World View columns by e-mail
Donate to Generational Dynamics via PayPal

Web Log Pages

Current Web Log

Web Log Summary - 2016
Web Log Summary - 2015
Web Log Summary - 2014
Web Log Summary - 2013
Web Log Summary - 2012
Web Log Summary - 2011
Web Log Summary - 2010
Web Log Summary - 2009
Web Log Summary - 2008
Web Log Summary - 2007
Web Log Summary - 2006
Web Log Summary - 2005
Web Log Summary - 2004

Web Log - December, 2016
Web Log - November, 2016
Web Log - October, 2016
Web Log - September, 2016
Web Log - August, 2016
Web Log - July, 2016
Web Log - June, 2016
Web Log - May, 2016
Web Log - April, 2016
Web Log - March, 2016
Web Log - February, 2016
Web Log - January, 2016
Web Log - December, 2015
Web Log - November, 2015
Web Log - October, 2015
Web Log - September, 2015
Web Log - August, 2015
Web Log - July, 2015
Web Log - June, 2015
Web Log - May, 2015
Web Log - April, 2015
Web Log - March, 2015
Web Log - February, 2015
Web Log - January, 2015
Web Log - December, 2014
Web Log - November, 2014
Web Log - October, 2014
Web Log - September, 2014
Web Log - August, 2014
Web Log - July, 2014
Web Log - June, 2014
Web Log - May, 2014
Web Log - April, 2014
Web Log - March, 2014
Web Log - February, 2014
Web Log - January, 2014
Web Log - December, 2013
Web Log - November, 2013
Web Log - October, 2013
Web Log - September, 2013
Web Log - August, 2013
Web Log - July, 2013
Web Log - June, 2013
Web Log - May, 2013
Web Log - April, 2013
Web Log - March, 2013
Web Log - February, 2013
Web Log - January, 2013
Web Log - December, 2012
Web Log - November, 2012
Web Log - October, 2012
Web Log - September, 2012
Web Log - August, 2012
Web Log - July, 2012
Web Log - June, 2012
Web Log - May, 2012
Web Log - April, 2012
Web Log - March, 2012
Web Log - February, 2012
Web Log - January, 2012
Web Log - December, 2011
Web Log - November, 2011
Web Log - October, 2011
Web Log - September, 2011
Web Log - August, 2011
Web Log - July, 2011
Web Log - June, 2011
Web Log - May, 2011
Web Log - April, 2011
Web Log - March, 2011
Web Log - February, 2011
Web Log - January, 2011
Web Log - December, 2010
Web Log - November, 2010
Web Log - October, 2010
Web Log - September, 2010
Web Log - August, 2010
Web Log - July, 2010
Web Log - June, 2010
Web Log - May, 2010
Web Log - April, 2010
Web Log - March, 2010
Web Log - February, 2010
Web Log - January, 2010
Web Log - December, 2009
Web Log - November, 2009
Web Log - October, 2009
Web Log - September, 2009
Web Log - August, 2009
Web Log - July, 2009
Web Log - June, 2009
Web Log - May, 2009
Web Log - April, 2009
Web Log - March, 2009
Web Log - February, 2009
Web Log - January, 2009
Web Log - December, 2008
Web Log - November, 2008
Web Log - October, 2008
Web Log - September, 2008
Web Log - August, 2008
Web Log - July, 2008
Web Log - June, 2008
Web Log - May, 2008
Web Log - April, 2008
Web Log - March, 2008
Web Log - February, 2008
Web Log - January, 2008
Web Log - December, 2007
Web Log - November, 2007
Web Log - October, 2007
Web Log - September, 2007
Web Log - August, 2007
Web Log - July, 2007
Web Log - June, 2007
Web Log - May, 2007
Web Log - April, 2007
Web Log - March, 2007
Web Log - February, 2007
Web Log - January, 2007
Web Log - December, 2006
Web Log - November, 2006
Web Log - October, 2006
Web Log - September, 2006
Web Log - August, 2006
Web Log - July, 2006
Web Log - June, 2006
Web Log - May, 2006
Web Log - April, 2006
Web Log - March, 2006
Web Log - February, 2006
Web Log - January, 2006
Web Log - December, 2005
Web Log - November, 2005
Web Log - October, 2005
Web Log - September, 2005
Web Log - August, 2005
Web Log - July, 2005
Web Log - June, 2005
Web Log - May, 2005
Web Log - April, 2005
Web Log - March, 2005
Web Log - February, 2005
Web Log - January, 2005
Web Log - December, 2004
Web Log - November, 2004
Web Log - October, 2004
Web Log - September, 2004
Web Log - August, 2004
Web Log - July, 2004
Web Log - June, 2004

Copyright © 2002-2016 by John J. Xenakis.