5053470
Learning Extended Logic Programs
This paper presents a method to generate nonmonotonic rules with exceptions from positive/ negative examples and background knowledge in Inductive Logic Programming. We adopt extended logic programs as the form of programs to be learned, where two kinds of negation--negation as failure and classical negation--are effectively used in the presence of incomplete information. While default rules axe generated as specialization of general rules that cover positive examples, exceptions to general rules are identified from negative examples and are then generalized to rules for cancellation of defaults. We implemented the learning system LELP based on the proposed method. In LELP, when the numbers of positive and negative examples are very close, either parallel default rules with positive and negative consequents or nondeterministic rules are learned. Moreover, hierarchical defaults can also be learned by recursively calling the exception identification algorithm.
18018809
Consequence-Finding Based on Ordered Linear Resolution
Since linear resolution with clause ordering is incomplete for consequence-finding, it has been used mainly for proof-finding. In this paper, we re-evaluate consequence-finding. Firstly, consequence-finding is generalized to the problem in which only interesting clauses having a certain property (called characteristic clauses) should be found. Then, we show how adding a skip rule to ordered linear resolution makes it complete for consequence-finding in this general sense. Compared with set-of-support resolution, the proposed method generates fewer clauses to find such a subset of consequences. In the propositional case, this is an elegant tool for computing the prime implicants/implicates. The importance of the results lies in their applicability to a wide class of AI problems including procedures for nonmonotonic and abductive reasoning and truth maintenance systems.
1816077
Representing Priorities in Logic Programs
Reasoning with priorities is a central topic in knowledge representation. A number of techniques for prioritized reasoning have been developed in the eld of AI, but existing logic programming lacks the mechanism of explicit representation of priorities in a program. In this paper, we introduce a framework for representing priorities in logic programming. Prioritized logic programming represents preference knowledge more naturally than stratied programs, and is used to reduce non-determinism in logic programming. Moreover, it can realize various forms of commonsense reasoning such as abduction, default reasoning, and prioritized circumscription. The proposed framework increases the expressive power of logic programming and exploits new applications in knowledge representation.
11399248
Linear Resolution for Consequence Finding
Abstract In this paper, we re-evaluate the consequence finding problem within first-order logic. Firstly, consequence finding is generalized to the problem in which only interesting clauses having a certain property (called characteristic clauses) should be found. The use of characteristic clauses enables characterization of various reasoning problems of interest to AI, including abduction, nonmonotonic reasoning, prime implicates and truth maintenance systems. Secondly, an extension of the Model Elimination theorem proving procedure (SOL-resolution) is presented, providing an effective mechanism complete for finding the characteristic clauses. An important feature of SOL-resolution is that it constructs such a subset of consequences directly without testing each generated clause for the required property. We also discuss efficient but incomplete variations of SOL-resolution and their properties, which address finding the most specific and the least specific abductive explanations.
4789511
Computing extended abduction through transaction programs
To explain observations from nonmonotonic background theories, one often needs removal of some hypotheses as well as addition of other hypotheses. Moreover, some observations should not be explained, while some are to be explained. In order to formalize these situations, extended abduction was introduced by Inoue and Sakama (1995) to generalize traditional abduction in the sense that it can compute negative explanations by removing hypotheses and anti‐explanations to unexplain negative observations. In this paper, we propose a computational mechanism for extended abduction. When a background theory is written in a normal logic program, we introduce its transaction program for computing extended abduction. A transaction program is a set of non‐deterministic production rules that declaratively specify addition and deletion of abductive hypotheses. Abductive explanations are then computed by the fixpoint of a transaction program using a bottom‐up model generation procedure. The correctness of the proposed procedure is shown for the class of acyclic covered abductive logic programs. In the context of deductive databases, a transaction program provides a declarative specification of database update.
16797379
Transforming Abductive Logic Programs to Disjunctive Programs
A new xpoint semantics for abductive logic programs is provided, in which the generalized stable models of an abductive program are characterized as the xpoint of a disjunctive program obtained by a suitable program transformation. In the transformation, both negative hypotheses through negation as failure and positive hypotheses from the abducibles are dealt with uniformly. This characterization allows us to have a parallel bottomup model generation procedure for computing abductive explanations from arbitrary (range-restricted and function-free) general, extended, and disjunctive programs with integrity constraints.
6398416
Analysis of the Linux Kernel Evolution Using Code Clone Coverage
Most studies of the evolution of software systems are based on the comparison of simple software metrics. In this paper, we present our preliminary investigation of the evolution of the Linux kernel using code-clone analysis and the code-clone coverage metrics. We examined 136 versions of the stable Linux kernel using a distributed extension of the code clone detection tool CCFinder. The result is shown as a heat map.
10199005
Ranking significance of software components based on use relations
Collections of already developed programs are important resources for efficient development of reliable software systems. In this paper, we propose a novel graph-representation model of a software component library (repository), called component rank model. This is based on analyzing actual usage relations of the components and propagating the significance through the usage relations. Using the component rank model, we have developed a Java class retrieval system named SPARS-J and applied SPARS-J to various collections of Java files. The result shows that SPARS-J gives a higher rank to components that are used more frequently. As a result, software engineers looking for a component have a better chance of finding it quickly. SPARS-J has been used by two companies, and has produced promising results.
17693551
Analysis of functional programs to detect run-time garbage cells
We propose a method for detecting the generation of garbage cells by analyzing a source text written in a functional programming language which uses ordinary linked lists to implement list-type values. For a subexpression such as <italic>F</italic>(<italic>G</italic>( . . . )) in a program where the function values of <italic>F</italic> and <italic>G</italic> are of list type, if a cell <italic>c</italic> is created during the computation of <italic>G</italic> and if <italic>c</italic> does not appear in a list-type value of <italic>F</italic>, then <italic>c</italic> becomes a garbage cell at the end of the computation of <italic>F</italic>. We discuss this problem on the basis of formal languages derived from the functional program text and show some sufficient conditions that predict the generation of garbage cells. Also, we give an efficient algorithm to detect at compile time the generation of garbage cells which are linearly linked. We have implemented these algorithms in an experimental LISP system. By executing several sample programs on the system, we conclude that our method is effective in detecting the generation of garbage cells.