Abstract: The game of Nine Men's Morris is a draw. We obtained this result using a combination of endgame databases (10 10 states) and search. Our improved algorithm for computing endgame databases allowed the game to be solved on a personal computer. Other games have been solved using knowledge-based methods to dramatically prune the search tree. Nine Men's Morris does not seem to profit from such methods, making it the first nontrivial game solved in which almost the entire state space has to be considered.

Abstract: This paper introduces METAGAMER, the first program designed within the paradigm of Metagame-playing (Metagame). This program plays games in the class of symmetric chess-like games, which includes chess, Chinese chess, checkers, draughts, and Shogi. METAGAMER takes as input the rules of a specific game and analyzes those rules to construct an efficient representation and an evaluation function for that game; they are used by a generic search engine. The strategic analysis performed by METAGAMER relates a set of general knowledge sources to the details of the particular game. Among other properties, this analysis determines the relative value of the different pieces in a given game. Although METAGAMER does not learn from experience, the values resulting from its analysis are qualitatively similar to values used by experts on known games and are sufficient to produce competitive performance the first time METAGAMER plays a new game. Besides being the first Metagame-playing program, this is the first program to have derived useful piece values directly from analysis of the rules of different games. This paper describes the knowledge implemented in METAGAMER, illustrates the piece values METAGAMER derives for chess and checkers, and discusses experiments with METAGAMER on both existing and newly generated games.

Abstract: Numerous examples of temporal reasoning involve a process of abstraction from the number of times an event is to occur or the number of times events stand in a temporal relation. For example, scheduling a recurring event such as one's office hours may consider things like the relative temporal ordering of the office hours and a number of other events in a given work day. The number of times office hours will actually be held may be unknown, even irrelevant, at the time of scheduling them. The objective of this article is to formulate a domain-independent framework for reasoning about recurring events and their relations. To achieve this end, we propose an ontology of recurrence based on the model-theoretic structure underlying collective predication using plural noun phrases. We offer a calculus of binary temporal relations for temporal collections based on a well-defined transformation of interval temporal relations into recurrence relations. Finally, we describe a reasoning framework based on manipulating knowledge stored in temporal relation networks, which is in turn a specialization of the CSP (constraint satisfaction problem) framework. The reasoner manipulates recurrence relations in the network to determine the network's consistency or to generate scenarios.

Abstract: Hypothetical reasoning about actions is the activity of preevaluating the effect of performing actions in a changing domain; this reasoning underlies applications of knowledge representation, such as planning and explanation generation. Action effects are often specified in the language of situation calculus, introduced by McCarthy and Hayes in 1969. More recently, the event calculus has been defined to describe actual actions, i.e., those that have occurred in the past, and their effects on the domain. Altough the two formalisms share the basic ontology of atomic actions and fluents, situation calculus cannot represent actual actions while event calculus cannot represent hypotethical actions. In this article, the language and the axioms of event calculus are extended to allow representing and reasoning about hypothetical actions, performed either at the present time or in the past, altough counterfactuals are not supported. Both event calculus and its extension are defined as logic programs so that theories are readily adaptable for Prolog query interpretation. For a reasonably large class of theories and queries, Prolog interpretation is shown to be sound and complete w.r.t. the main semantics for logic programs.

Abstract: In this paper, we describe the implementation and evaluation of the AbTweak planning system, a test bed for studying and teaching concepts in partial-order planning, abstraction, and search control. We start by extending the hierarchical, precondition-elimination abstraction of ABSTRIPS to partial-order-based, least-commitment planners such as Tweak. The resulting system, AbTweak, illustrates the advantages of using abstraction to improve the efficiency of search. We show that by protecting a subset of abstract conditions achieved so far, and by imposing a bias on search toward deeper levels in a hierarchy, planning efficiency can be greatly improved. Finally, we relate AbTweak to other planning systems SNLP, ALPINE, and SIPE by exploring their similarities and differences.

Abstract: This article studies finite size networks that consist of interconnections of synchronously evolving processors. Each processor updates its state by applying an activation function to a linear combination of the previous states of all units. We prove that any function for which the left and right limits exist and are different can be applied to the neurons to yield a network which is at least as strong computationally as a finite automaton. We conclude that if this is the power required, one may choose any of the aforementioned neurons, according to the hardware available or the learning software preferred for the particular application.

Abstract: Games with imperfect information are an interesting and important class of games. They include most card games (e.g., bridge and poker) as well as many economic and political models. Here we investigate algorithms for findi ng the simplest form of a solution (a pure-strategy equilibrium point) to imperfect information games expressed in their extensive (game tree) form. We introduce to the artificial intelligence community a classic algorithm, due to Wilson, that solves one-player games with perfect recall. Wilson's algorithm, which we call iMP-minimax, runs in time linear in the size of the game-tree searched. In contrast to Wilson's result, Koller and Meggido have shown that finding a pure-strategy equilibrium point in one-player games without perfect recall is NP-hard. Here, we provide another contrast to Wilson's result–we show that in games with perfect recall but more than one player, finding a pure-strategy equilibrium point, given that such an equilibrium point exists, is NP-hard. Our second contribution is to present a pruning technique for Wilson's IMP-minimax algorithm to make the latter more tractable. We call this new algorithm IMP-alpha-beta. We provide a theoretical framework (model) and analyze IMP-alpha-beta in that model. IMP-alpha-beta is of direct value for one-player, perfect-recall games. It also has strong potential for other imperfect information games, as it is a natural (but as yet untested) heuristic in those cases.

Abstract: As they gain expertise in problem solving, people increasingly rely on patterns and spatially oriented reasoning. This paper describes an associative visual-pattern classifier and the automated acquisition of new, spatially oriented reasoning agents that simulate such behavior. They are incorporated into a multi-agent game-learning program whose architecture robustly combines agents with conflicting perspectives. When tested on three games, the visual-pattern classifier learns meaningful patterns, and the pattern-based, spatially oriented agents generalized from these patterns are generally correct. The accuracy of the contribution of each of the newly created agents to the decision-making process is measured against an expert opponent, and a perceptron-Iike algorithm is used to learn game-specific weights for these agents. Much of the knowledge encapsulated by the new agents was previously inexpressible in the program's representation and in some cases is not readily deducible from the rules.

Abstract: An uncertainty reasoning method is presented in this article. The method can be used to compute from a given set of conditional probabilities the best lower bounds and the best upper bounds of those conditional probabilities that are not explicitly provided. The computation of the best upper(lower) bound of such a conditional probability relies on solution of a linear programming problem. Some reduction techniques are proposed in this article to improve the efficiency of our uncertainty reasoning method. As illustrated in Section 4.3, for many uncertainty reasoning problems in medical diagnosis, by using our reduction techniques, the best range of a conditional probability, which is specified by a lower bound and an upper bound, can be computed in polynomial time in terms of the number of basic events involved in the reasoning.

Abstract: Sentence syntax is the basis for organizing semantic relations in TANKA, a project that aims to acquire knowledge from technical text. Other hallmarks include an absence of precoded domain-specific knowledge; significant use of public-domain generic linguistic information sources; involvement of the user as a judge and source of expertise; and learning from the meaning representations produced during processing. These elements shape the realization of the TANKA project: implementing a trainable text processing system to propose correct semantic interpretations to the user. A three-level model of sentence semantics, including a comprehensive Case system, provides the framework for TANKA's representations. Text is first processed by the DIPETT parser, which can handle a wide variety of unedited sentences. The semantic analysis module HAIKU then semi-automatically extracts semantic patterns from the parse trees and composes them into domain knowledge representations. HAIKU's dictionaries and main algorithm are described with the aid of examples and traces of user interaction. Encouraging experimental results are described and evaluated.

Abstract: It is believed that chess masters use pattern-based knowledge to analyze a position, followed by a pattern-based controlled search to verify or correct the analysis. This paper describes a first-order system called PAL that can learn patterns in the form of Horn clauses from simple example descriptions and general purpose knowledge. It is shown how PAL can leam chess patterns that are beyond the learning capabilities of current inductive systems. The patterns learned by PAL can be used for analysis of positions and for the construction of playing strategies. By taking the learned patterns as attributes for describing examples, a set of rules which decide whether a Pawn can safely be promoted without moving the King in a King and Pawn vs King endgame, is automatically constructed with a similarity-based learning algorithm. Similarly, a playing strategy for the King and Rook vs King endgame is automatically constructed with a simple learning algorithm by following traces of games and using the patterns learned by PAL. Limitations of first-order systems, PAL imparticularly, are exposed in domains where a large number of background definitions may be required for induction. Conclusions and future research directions are given.

Abstract: A clear understanding and formalization of actions is essential to computing, and especially so to reasoning about and constructing intelligent agents. Several approaches have been proposed over the years. However, most approaches concentrate on the causes and effects of actions, but do not give general characterizations of actions themselves. A useful formalization of actions would be based on a general, possibly nondiscrete, model of time that allows branching (to capture agents'' choices). A desirable formalization would also allow actions to be of arbitrary duration and would permit multiple agents to act concurrently. We develop a branching-time framework that allows great flexibility in how time and action are modeled. We motivate and formalize several coherence constraints on our models, which capture some nice intuitions and validate some useful inferences relating actions with time.

Abstract: We are concerned with temporal reasoning problems where there is uncertainty about the order in which events occur The task of temporal reasoning is to derive an event sequence consistent with a given set of ordering constraints to achieve a goal Previous research shows that the associated decision problems are hard even for very restricted cases In this article, we investigate locality in event ordering and causal dependencies We present a localized temporal reasoning algorithm that uses subgoals and abstract events to exploit locality The computational efficiency of our algorithm for a problem instance is quantified by the inherent locality in the instance We theoretically demonstrate the substantial improvement in performance gained by exploiting locality This work provides solid evidence of the usefulness of localized reasoning in exploiting locality

Abstract: This article presents our work on the effective implementation of abduction in temporal reasoning. This works builds on some results, both in the logic programming field and in the automated reasoning area. We have defined and implemented an abductive procedure, which is well adapted for temporal reasoning because it is based on a constrained resolution principle. Constrained resolution has two advantages for temporal reasoning: First, it allows us to deal efficiently with temporal ordering and equality predicates, which are otherwise too much trouble with classical resolution; second, it allows a restricted form of abduction where hypotheses are limited to ordering relationships. From the logic programming area, our work uses results and procedures developed by others in the abductive logic programming field. The procedure we define and implement in this work is relatively independent of the temporal formalism: It has been used with some reified temporal logics and with the event calculus. More generally it can be used on any point-based temporal formalism, provided that a correct and complete algorithm is available for checking the consistency of a set of temporal ordering relationships in this language.

Abstract: Allen's interval algebra has been shown to be useful for representing plans. We present a strengthened algorithm for temporal reasoning about plans, which improves on straightforward applications of the existing reasoning algorithms for the algebra. This is made possible by viewing plans as both temporal networks and hierarchical structures. The temporal network view allows us to check for inconsistencies as well as propagate the effects of new temporal constraints, whereas the hierarchical view helps us to get the strengthened results by taking into account the dependency relationships between actions. We further apply our algorithm to the process of plan recognition through the analysis of natural language input. We show that such an application has two useful effects: the temporal relations derived from the natural language input can be used as constraints to reduce the number of candidate plans, and the derived constraints can be made more specific by combining them with the prestored constraints in the plans being recognized.

Abstract: This special issue on temporal representation and reasoning contains seven articles written by the authors of the best papers of the TIME-94 International Workshop on Temporal Representation and Reasoning, which was held in Pensacola, Florida, on May 4, 1994. The workshop’s goal was to bring together researchers concerned with temporal representation and reasoning in a wide variety of areas and promote interaction and cross-fertilization. Consequently, the articles here, while focused on time, address a wide range of issues. The article by Chittaro and Montanari discusses the efficient implementation of Kowalski and Sergot’s event calculus (extended with context dependency). They define a cache-based implementation that moves computational complexity from query processing to update processing and features an absolute improvement in performance because query processing in the event calculus costs much more than update processing in the proposed cached version. Chleq is concerned with the efficient implementation of abduction for temporal reasoning. He defines and implements an abductive procedure based on a constrained resolution principle that efficiently handles ordering relations and can limit hypotheses to ordering relations. Leasure’s article proposes a formal theory of concurrent actions based on the modal logic Z. The theory addresses the qualification, ramification, and frame problems and allows forward and backward reasoning and temporal explanation. It extends Lifschitz and Rabinov’s miracle concept to encompass concurrent actions. Temporal reasoning involving uncertainty about event ordering is the topic of the article by Lin and Dean. They investigate locality in event ordering and causal dependencies. Locality is exploited by using subgoals and abstract events. Their analysis shows a significant performance gain using localized reasoning. Moms et al. formulate a domain-independent framework for reasoning about recurring events and their relations. They propose an ontology of recurrence based on the modeltheoretic structure underlying collective predication using plural noun phrases. Their reasoning framework, which is a specialization of the constraint satisfaction problem framework, allows the manipulation of knowledge stored in a temporal relation network to determine the network’s consistency or to generate scenarios. Provetti is concerned with hypothetical reasoning about actions. He describes how situation calculus cannot represent actual actions while event calculus cannot represent hypothetical actions. He then presents an extention to event calculus capable of representing and reasoning with both actual and hypothetical actions. The resulting formalism is easily implemented as a Prolog program. The article by Tambe and Rosenbloom examines event tracking in a dynamic multiagent environment, namely, air-combat simulation. In addition to monitoring events initiated by other agents, a given agent must be able to make inferences about unobserved events. All this must be handled in an environment of reactive behaviors, continuous interactions, and real-time events. Temporal representation and reasoning has always been and continues to be an important area of research in AI. The approaches have become quite diverse and specialized. Because of

Abstract: Knowledge base validation and knowledge base refinement aim to help the expert to improve an existing knowledge base They deal with the final knowledge acquisition phase and rely on a quality measurement of an existing knowledge base We present our approach to knowledge base refinement, which is based on results in the domain of knowledge base validation Our approach is based on a general consistency definition of a knowledge base and on a study of causes of knowledge base inconsistency Our approach relies significantly on a differentiation of sure and expert knowledge in the knowledge base We have implemented a system that has two phases: one computational phase decides on the consistency of a knowledge base, and, if necessary, a second phase helps the expert to interactively update the knowledge base We present some related work in the domain We illustrate the use of our system with an example

Abstract: Monotonicity and concavity play important roles in human cognition, reasoning, and decision making. This paper shows that neural networks can learn monotonic-concave interval concepts based on real-world data, Traditionally, the training of neural networks has been based only on raw data. In cases where the training samples carry statistical fluctuations, the products of the training have often suffered. This paper suggests that global knowledge about monotonicity and concavity of a problem domain can be incorporated in neural network training. This paper proposes a learning scheme for the back-propagation layered neural networks in learning monotonic-concave interval concepts and provides an example to show its application.

Abstract: The universality of strategy games suggests that they reflect some basic insights into the nature of human intelligence. Turing cited rudimentary chess reasoning as a hallmark of AI, and some of the earliest significant research was on chess and checkers. Today, computer game playing continues to be a central concern because it addresses the fundamental issues in AI: knowledge representation, search, planning, and learning. Moreover, the multi-agent nature of games makes game playing an excellent forum for addressing core issues such as contingency planning and reasoning about actions and plans of other agents, while competition between programs and with humans provides useful benchmarks and encourages progress. This special issue highlights recent innovative work by a broad spectrum of researchers and practitioners. There are clearly at least three very different approaches to computer game playing: a high-performance determination to play better than any human, a cognitively oriented exploration of learning and behavior, and a mathematical theory of heuristics and game playing. The competition and cooperation among these approaches drive exciting and significant work whose results extend to many other problems with large search spaces. The traditional A1 approach to game playing relies upon fast, deep search to look ahead from the current game state to all possible ways to complete the contest. For difficult games, there are so many alternatives that only a fragment of the future possibilities can be considered. Therefore, move selection must also rely upon a human-designed evaluation function to estimate the worth of game states prior to the end of a contest. This technique is classically supplemented by an extensive catalog of expert openings (an opening book) and precomputed solutions to simple endgame positions (an endgame database). Because this approach tends to rely on raw computer power to compensate for a lack of knowledge or selectivity in search, these methods are often referred to as the “brute-force’’ approach. By many standards, this brute-force approach has been remarkably successful. Carefully engineered, deep-searching computers now dominate all but a few humans in a number of challenging games, including chess, checkers, and Othello. The surprising success of the engineering approach on these games has prompted researchers in other fields to seek similar search-intensive solutions to their problems, including theorem proving and natural language processing (see Marsland’s discussion in (Levinson et al. 1991)). The brute-force approach to games has its limitations, however. First, where this approach is applicable, considerable engineering effort is required to achieve success. This effort manifests itself in highly efficient, special-purpose representations (sometimes with gamespecific hardware (Ebeling 1986)), fine-tuned evaluation functions with hand-crafted features

Abstract: This article presents a formal theory of concurrent actions that handles the qualification, ramification, and frame problems. The theory is capable of temporal explanation, i.e., reasoning forward and backward. The approach uses the modal logic Z to extend the work of Lifschitz and Rabinov on miracle-based temporal reasoning. The advantages of miracles for describing unknown actions are augmented with the ability to handle concurrent actions that can provide for the most economical explanation of state changes. For temporal explanation problems restricted to finite domains, it has a worst-case exponential decision procedure. The theory is as general as first-order logic in what it can express as preconditions and consequences of actions.

Abstract: This article deals with the problem of providing Kowaiski and Sergot's event calculus, extended with context dependency, with an efficient implementation in a logic programming framework. Despite a widespread recognition that a positive solution to efficiency issues is necessary to guarantee the computational feasibility of existing approaches to temporal reasoning, the problem of analyzing the complexity of temporal reasoning programs has been largely overlooked. This article provides a mathematical analysis of the efficiency of query and update processing in the event calculus and defines a cached version of the calculus that (i) moves computational complexity from query to update processing and (ii) features an absolute improvement of performance, because query processing in the event calculus costs much more than update processing in the proposed cached version.

Abstract: Human chess players exhibit a large variation in the amount of time they allocate for each move. Yet, the problem of devising resource allocation strategies for game playing has not received enough attention. In this paper we present a framework for studying resource allocation strategies. We define allocation strategy and identify three major types of strategies: static, semi-dynamic, and dynamic. We then describe a method for learning semi-dynamic strategies from self-generated examples. We present an algorithm for assigning classes to the examples based on the utility of investing extra resources. The method was implemented in the domain of checkers, and experimental results show that it is able to learn strategies that improve game-playing performance.

Abstract: In a dynamic, multiagent environment, an automated intelligent agent is often faced with the possibility that other agents may instigate events that hinder or help the achievement of its own goals. To act intelligently in such an environment, an automated agent needs an event tracking capability to continually monitor the occurrence of such events and the temporal relationships among them. This capability enables an agent to infer the occurrence of important unobserved events as well as to obtain a better understanding of the interaction among events. This article focuses on event tracking in one complex and dynamic multiagent environment: the air-combat simulation environment. It analyzes the challenges that an automated pilot agent must face when tracking events in this environment. This analysis reveals three new issues that have not been addressed in previous work in this area: (i) tracking events generated by agents' flexible and reactive behaviors, (ii) tracking events in the context of continuous agent interactions, and (iii) tracking events in real time. This article proposes one solution to address these issues. One key idea in this solution is that the (architectural) mechanisms that an agent employs in generating its own flexible and reactive behaviors can be used to track other agents' flexible and reactive behaviors in real time. A second key idea is the use of a world-centered representation for modeling agent interactions. The solution is demonstrated using an implementation of an automated pilot agent.

Abstract: This article introduces a temporal deductive database system featuring a logic programming language and an algebraic front-end. The language, called Temporal DATALOG, is an extension of DATALOG based on a linear-time temporal logic in which the flow of time is modeled by the set of natural numbers. Programs of Temporal DATALOG are considered as temporal deductive databases, specifying temporal relationships among data and providing base relations to the algebraic front-end. The minimum model of a given Temporal DATALOG program is regarded as the temporal database the program models intensionally. The algebraic front-end, called TRA, is a point-wise extension of the relational algebra upon the set of natural numbers. When needed during the evaluation of TRA expressions, slices of temporal relations over intervals can be retrieved from a given temporal deductive database by bottom-up evaluation strategies. A modular extension of Temporal DATALOG is also proposed, through which temporal relations created during the evaluation of TRA expressions may be fed back to the deductive part for further manipulation. Modules therefore enable the algebra to have full access to the deductive capabilities of Temporal DATALOG and to extend it with nonstandard algebraic operators. This article also shows that the temporal operators of TRA can be simulated in Temporal DATALOG by program clauses.

Abstract: A method for finding all deterministic and maximally general rules for a target classification is explained in detail and illustrated with examples. Maximally general rules are rules with minimal numbers of conditions. The method has been developed within the context of the rough sets model and is based on the concepts of a decision matrix and a decision function. The problem of finding all the rules is reduced to the problem of computing prime implicants of a group of associated Boolean expressions. The method is particularly applicable to identifying all potentially interesting deterministic rules in a knowledge discovery system but can also be used to produce possible rules or nondeterministic rules with decision probabilities, by adapting the method to the definitions of the variable precision rough sets model.

Abstract: Since Samuel's work on checkers over thirty years ago, much effort has been devoted to learning evaluation functions. However, all such methods are sensitive to the feature set chosen to represent the examples. If the features do not capture aspects of the examples significant for problem solving, the learned evaluation function may be inaccurate or inconsistent. Typically, good feature sets are carefully handcrafted and a great deal of time and effort goes into refining and tuning them. This paper presents an automatic knowledge-based method for generating features for evaluation functions. The feature set is developed iteratively: features are generated, then evaluated, and this information is used to develop new features in turn. Both the contribution of a feature and its computational expense are considered in determining whether and how to develop it further. This method has been applied to two problem-solving domains: the Othello board game and the domain of telecommunications network management. Empirical results show that the method is able to generate many known features and several novel features and to improve concept accuracy in both domains.