Semantic disambiguation is a difficult problem in natural language analysis. A better strategy for semantic disambiguation is to accumulate constraints obtained during the analytical process of a sentence, and disambiguate as early as possible the meaning incrementally using the constraints. We propose such a computational model of natural language analysis, and call it the 'incremental disambiguation model.' The semantic disambiguation process can be equated with the downward traversal of a discrimination network. However, the discrimination network has a problem in that it cannot be traversed unless constraints are entered in an a priori-fixed order. In general, the order in which constraints are obtained cannot be a priori fixed, so it is not always possible to traverse the network downward during the analytical process. In this paper, we propose a method which can traverse the discrimination network according to the order in which constraints are obtained incrementally during the analytical process. This order is independent of the a priori-fixed order of the network.

STRIPS is well known as one of unidirectional search algorithms in which the search tree is rooted at the goal. In order to avoid the defect, the number of nodes in a search tree grows exponentially with its depth, of STRIPS like some other unidirectional algorithms, many improved algorithms have been proposed. Here we would furthermore introduce a new efficient bidirectional heuristic search algorithm into STRIPS to make its search more efficient. We would like call our new algorithm Bi-STRIPS. Being different from other bidirectional heuristic searches, the forward search, from the initial state, and the backward search, from the goal, of Bi-STRIPS both aim at a set of nodes between the initial state and the goal. Those nodes are called middle goals and any solution path must go througth one of them. By utilizing this kind of bidirectional heuristic search, the two search trees not only will expand less nodes than STRIPS but also can be expanded parallely, and the search time for planning can be reduced. Therefore, efficiency of planning can be improved. We would call an element of a state destructive element if it can be deleted by applying a production rule to the state. Surfacing an element of a state means to search for a new state in which the element will get to be a destructive element. We would call those elements of a state differences between that state and a subgoal if they cannot exist with the subgoal at the same time. A middle goal is such a state in which every element of differences between that state and the present subgoal is surfaced. The forward search tree of our algorithm is a destructive one because a node contains no less surfaced elements than its ancestors. In this paper, we will describe the deduction process of the middle goals and show the algorithms of the main parts of Bi-STRIPS. Some examples also will be shown to clarify the efficiency of our system.

This paper presents the design and implementation of SHUTEN, a system for formal development of programs in constructive logic. The design goal is to provide a flexible and friendly programming environment in which a specification of a program can be developed gradually from incomplete ones. SHUTEN is, in a sense, a redesign of the pioneering proof development systems based on constructive logics such as Nuprl and PX as a programming tool. SHUTEN provides a natural language like proof description language called DOHJI in which proofs are developed in the backward reasoning style. DOHJI has two facilities to describe proofs easily and concisely : The lemma facility and the formula macro definition. The lemma facility, which is designed for the gradual proof development, is an extension of referring lemmas in ordinary mathematical proofs, but it allows more concise description with the help of the proof linkage mechanism of SHUTEN. By the formula macros facility, which is almost similar to those used in other proof development systems such as PX, complex formula definitions can be drastically compressed. The SHUTEN proof checker can handle incomplete proofs and points out which part of the given proof needs more refinement. In other words, the checker assures the correctness of the proof provided that the correctness of the incomplete part is assured. With these mechanism and facilities-DOHJI, the lemma facility together with the proof linkage mechanism, the formula macros definition and the sophisticated proof checker-large proofs can be developed rather easily without using automated theorem proving systems, and also they keep the whole programming system compact.

A new framework for a Knowledge Compiler is proposed from two kinds of design principle. One is constructibility (ease to be constructed) and generality in deep knowledge. The other is a new model for investigating failure-cause. Thus the framework is free from the following problems with conventional model-based approach : (1) Domain model must be prepared in advance, (2) Real failure-cause could not be discovered. The Knowlege Compiler has five kinds of deep knowledge with two deep engines. The first four of them are manipulated on the first deep engine based on propagation mechanism of qualitative values. The first deep engine identifies faulty components from an abnormal symptom and generates abnormal symptoms from some trouble-hypothesis. The last of them, which is called a failure model, is manipulated on the second deep engine based on pattern matching mechanism. It is used for treating failure-mechanism. In the Knowledge Compiler, these two deep engines co-operate for finding out real failure-cause. Note that domain model is not prepared in advance but dynamically constructed from the first four kinds of deep knowledge and that the failure model is not heuristics in conventional expert systems but a generic model for treating failure-mechanism. Finally fault trees generated by the Knowledge Compiler are compared with ones made by human experts. As a result of the comparison, it is shown that the Knowledge Compiler is profitable in actual practice.

A new concept learning method CLIP (Concept Learning from Inference Pattern) is proposed. CLIP learns new concepts from inference patterns in contrast with the fact that most of the conventional concept learning methods learn a new concept from positive/negative examples. The learned concepts enables efficient inference on a more abstract level. The learning process consists of the following two steps : 1) Convert the original inference patterns to a colored digraph, and 2) Extract a set of typical patterns which appears frequently in the digraph. The basic idea is that : 1) The smaller the size of the digraph becomes, the less becomes the number of the data to handle and accordingly the more efficient becomes the inference that uses these data, 2) The reduced graph does not lose information, and the original information can be restored whenever needed, and 3) The reduced node represents a new cencept component (a new vocabulary). A parallel-search algorithm based on "Pattern Modification" (mu-tation : to find a typical pattern), "Pattern Combination" (crossover : to mix patterns), and "View Selection" (to select a good set of patterns) extracts a set of typical patterns (chunks) which appear frequently in the digraph. The algorithm is similar to a previously reported Genetic Algorithm. In Pattern Modification, a partial digraph representing some meaningful component are extracted as a Pattern. In Pattern Combination, a new View is created as a set of Patterns. In View Selection, Views which result in smaller digraphs after being rewritten by the Patterns in the View are selected. Without this algorithm, we may have to rely on an exhaustive search which is computationally very expensive.

We view a set of chunks, the use of which makes inference more efficient, as a concept. The idea is based on the assumption that a chunk that appears often in an inference may mean something important. The extraction of a chunk is solely based on finding the repetition of a typical inference pattern in a given environment. This idea, implemented as CLIP (Concept Learning from Inference Pattern), adapts Genetic Algorithm like parallel search algorithm and when applied to the digraphs of a carry chain circuit, CLIP extracted the chunks corresponding to analog NOR and NOT. This paper discusses some of the important factors for concept hierarchy formation. Introduction of approximation is very important to step up to a more abstract level concept. This can also be processed as a reduction of digraph. Another important factor for the concept hierarchy formation is the characteristics of the inference system. This must be reflected on the matching cost. The different weight for the matching cost generates a hierarchy of different levels/depths. Environment of the inference system is also important. It must be reflected on the choice of color. Choice of a different color forms a hierarchy of different kinds. Presence of noise effects the performance, but the analysis indicates that CLIP can cope with a certain type of noise.

This paper proposes a reinforcement learning method based on an instance-based learning approach. The learning take is assumed as follows. The input on each learning cycle is a vector of real numbers, the output is a symbol selected from a Priori known finite set, and the reinforcement from environment is +1, 0 or -1 usually being 0, that is, in the manner of delayed reinforcement. The last assumption makes it difficult to apply any conventional supervised concept learning schema because the evaluation of its output is not given at every cycle. The key idea is to propagate reinforcement backward through the memorized experiences in the order of time. The learner tends to select the output which is associated with the input similar to current situation and which will likely lead to high positive reinforcement, scanning all of the past experiences stored in memory verbatim. In addition to this basic mechanism, two types of extensions are proposed. The first is to restrict the capacity of memory to avoid infinite increase of time and space complexity, replacing the oldest data by new data in each cycle. The second is to embed a feedback mechanism concerning with reliability of each memorized experience. Reliability of the experience employed to decide the output of nearly previous cycle is increased when the learner gets positive reinforcement, and is decreased when negative reinforcement. Experimental results show these learning algorithms work well for a domain of simulating adaptive behavior, and the extension methods are effective.

This paper presents two kinds of search strategies for a means-ends analysis and their knowledge acquisition from problem solving cases. One strategy rejects an applicable operator on the search tree if an action, called the forestalling operator, can be applied to the current state space. The other strategy makes the problem solver clear all of the stacked goals except the last one, where the problem solver regards the pattern of the current state space on the search tree as one solved before. The knowledge for these strategies, as well as the control rules for the original means-ends analysis, is acquired by detecting the case that the problem solver has made a mistake.