The machine probed to a depth of at least six and at most twenty moves ahead,depending on how thorough an analysis was required. In other words, it oftenhad to compute thousands and tens of thousands of different positions beforecoming up with the best over-all score indicating its official move. Suchfeats, of course, are impossible for the human player. The [IBM] 7094 [computer]can do some 15 million additions or six million multiplications in a single minute,which is about as much arithmetic as a man at an ordinary adding machine coulddo in a year.
Computer Program For Checkers
Note The Sfcdetails.txt file contains details from every time that the System File Checker tool has been run on the computer. The file includes information about files that were not repaired by the System File Checker tool. Verify the date and time entries to determine the problem files that were found the last time that you ran the System File Checker tool.
After you determine which system file was corrupted and could not be repaired through the detail information in the Sfcdetails.txt file, find where the corrupted file located, and then manually replace the corrupted file with a known good copy of the file. To do this, follow these steps:Note You may be able to get a known good copy of the system file from another computer that is running the same version of Windows with your computer. You may perform a System File Checker process on that computer to make sure the system file that you intend to copy is a good copy.
Copy Source_File DestinationNote The Source_File placeholder represents the path and file name of the known good copy of the file on your computer, and the Destination placeholder represents the path and file name of the corrupted file. For example, type copy E:\temp\jscript.dll C:\windows\system32\jscript.dll.
After 18-and-a-half years and sifting through 500 billion billion (a five followed by 20 zeroes) checkers positions, Dr. Jonathan Schaeffer and colleagues have built a checkers-playing computer program that cannot be beaten. Completed in late April this year, the program, Chinook, may be played to a draw but will never be defeated.
"I think we've raised the bar--and raised it quite a bit--in terms of what can be achieved in computer technology and artificial intelligence," said Schaeffer, chair of the U of A Department of Computing Science. "With Chinook, we've pushed the envelope about one million times more than anything that's been done before."
A self-described "awful" checkers player, Schaeffer created Chinook to exploit the superior processing and memory capabilities of computers and determine the best way to incorporate artificial intelligence principals in order to play checkers.
With the help of some top-level checkers players, Schaeffer programmed heuristics ("rules of thumb") into a computer software program that captured knowledge of successful and unsuccessful checkers moves. Then he and his team let the program run, while they painstakingly monitored, fixed, tweaked, and updated it as it went.
An average of 50 computers--with more than 200 running at peak times--were used everyday to compute the knowledge necessary to complete Chinook. Now that it is complete, the program no longer needs heuristics--it has become a database of information that "knows" the best move to play in every situation of a game. If Chinook's opponent also plays perfectly the game would end in a draw.
Schaeffer started the Chinook project in 1989, with the initial goal of winning the human world checkers championship. In 1990 it earned the right to play for the championship. The program went on to lose in the championship match in 1992, but won it in 1994, becoming the first computer program to win a human world championship in any game--a feat recognized by the Guinness Book of World Records.
Chinook remained undefeated until the program was "retired" in 1997. With his sights set on developing Chinook into the perfect checkers program, Schaeffer restarted the project in 2001."I'm thrilled with this achievement," he said. "Solving checkers has been something of an obsession of mine for nearly two decades, and it's really satisfying to see it through to its conclusion."
"I'm also really proud of the artificial intelligence program that we've built at the University of Alberta," he added. "We've built up the premier games group in the world, definitely second-to-none. And we've built up a strong, international, truly world-class reputation, and I'm very proud of that."
On July 24 and 25 this year, Polaris, a poker-playing computer program built by Schaeffer and his U of A colleagues, will challenge two poker professionals in a $50,000 man versus machine poker world championship event in Vancouver, as part of the annual conference for the Association for the Advancement of Artificial Intelligence.
Checkers is the most complex two-player game to be solved. It's a million times more complex than Connect Four, which was solved two decades ago. (After many long car trips where I was separated from my brother in the backseat of our station wagon by a miniature, travel version of Connect Four, I would like to think I may qualify as a Connect Four grand master.) Checkers is roughly the square root of chess in terms of complexity, however. While IBM's Deep Blue supercomputer famously beat chess grand master Gary Kasparov, it has yet to solve the game. Researchers say we're still a long way off from a program that can solve chess. Chinook was able to solve checkers by focusing on the end game, where there are eight or fewer pieces on the board.
Automated formal verification using model checking is a mature field with many tools available. We summarize the recent trends in the design and architecture of model checking tools. An important design goal of modern model checkers is to support many input languages (front-end) and many verification strategies (back-end), and to allow arbitrary combinations of them. This widens the applicability of new verification algorithms, avoids duplicate implementation of the analysis techniques, improves quality of the tools, and eases use of verification for a newly introduced high-level specification, such as a domain specific language.
Ideally a modern model checker should be adaptive, able to transparently select for a given model instance and a given property the best verification strategy. This design goal forces the software architecture of model checkers to evolve from tightly integrated or monolithic approaches to more open architectures that rely on pivot representations to support both many languages and many verification strategies.
Recent work also considers software verification (i.e. analyzing programs directly at the code level). Program verification mainly relies on strong abstractions of programs to cope with the combinatorial explosion caused by analysis at the instruction level, thus generating abstract models from software. This abstraction process for software verification is not considered directly in this paper; we focus on verification engines for model checking.
Section 2 presents the current trends in architectures for model checkers; Sect. 3 shows a first approach involving ProB and existing languages (e.g. Prolog, Java) while Sects. 4 and 5 are presenting updated visions (language based and library based) of such an architecture when analyzing high-level languages. Finally, Sect. 6 details two typical examples before a conclusion.
Model checkers exist now for more than three decades and have proven their usefulness to understand and debug complex systems. However, their software architecture is evolving, following a similar evolution as compilers, which were once monolithic but are now structured for a better reuse of code.
High-level logic-based languages, i.e., specification languages which are not necessarily executable [36], can provide a convenient way to translate a wide variety of domain specific formalisms. Logic and set theory pervade large areas of computer science, and are used to express many formalisms, properties and concepts. On the one hand this explains the popularity of SAT and SMT solvers: many properties from wide areas of computer science can be expressed or compiled to logic. Similarly, the dynamic behaviour of a wide variety of languages and formalisms can be easily expressed in terms of a state-based formal method using logic and set theory.
This is very close to the mathematical definition in theoretical computer science books such as [40]. The main difference is the use of \(\hat\) for concatenating sequences and seq(A) for finite sequences over the set A. Executing this event within a model checker, however, requires a limited form of constraint solving: to compute the next state for a given value of cur, one needs to determine the possible decompositions of cur into three substrings a, L, b such that L is a left-hand side of a grammar production in P. E.g., given \(P=\ N \mapsto [y,N,z]\\) and \( cur =[x,N,N,x]\), there are two ways to execute the event, leading to two possible successor states with \( cur =[x,y,N,z,N,x]\) and \(cur=[x,N,y,N,z,x]\).
This approach has a few advantages. It is easy to use the tool for other languages by providing an interpreter (or compiler). This is helped by the fact that Prolog, aka logic programming, is quite convenient to express the semantics of various programming and specification languages, in particular due to its support for non-determinism. E.g., the operational semantics rules of CSP [61] can be translated into Prolog clauses [51]. Furthermore, within Prolog one can make use of constraint logic programming for dealing with complex specifications, such as the grammar rewriting specification above. Finally, it is relatively straightforward to combine or integrate several formalisms, as was done for CSP \(\Vert \) B [17].
Quite a few other tools also use Prolog as an intermediate input language. E.g, the XMC model checker [60] provides an explicit-state CTL model checker, targeting languages such as CCS via an interpreter or via translation. Techniques such as partial evaluation [52] and unfold-fold transformations [29] can be used for optimization, but also for a form of infinite state model checking. Finally, constraint programming techniques can be used for various validation tasks [23, 24]. Similarly, in Horn-Clause Verification, SMT solvers are applied to Prolog or Datalog like specifications [12, 58]. 2ff7e9595c
Kommentare