Logic Programming Techniques Research Articles

Scaling Up Inductive Logic Programming by Learning from Interpretations

When comparing inductive logic programming (ILP) and attribute-value learning techniques, there is a trade-off between expressive power and efficiency. Inductive logic programming techniques are typically more expressive but also less efficient. Therefore, the data sets handled by current inductive logic programming systems are small according to general standards within the data mining community. The main source of inefficiency lies in the assumption that several examples may be related to each other, so they cannot be handled independently. Within the learning from interpretations framework for inductive logic programming this assumption is unnecessary, which allows to scale up existing ILP algorithms. In this paper we explain this learning setting in the context of relational databases. We relate the setting to propositional data mining and to the classical ILP setting, and show that learning from interpretations corresponds to learning from multiple relations and thus extends the expressiveness of propositional learning, while maintaining its efficiency to a large extent (which is not the case in the classical ILP setting). As a case study, we present two alternative implementations of the ILP system TILDE (Top-down Induction of Logical DEcision trees): TILDEclassic, which loads all data in main memory, and TILDELDS, which loads the examples one by one. We experimentally compare the implementations, showing TILDELDS can handle large data sets (in the order of 100,000 examples or 100 MB) and indeed scales up linearly in the number of examples.

Discovering rules to design newspapers: An inductive constraint logic programming approach

Inductive logic programming combines both machine learning and logic programming techniques. ILP uses first-order predicate logic restricted to Horn clauses as an underlying language. Thus, programs induced by an ILP system inherit the classical limitations of PROLOG programs. Constraint logic programming avoids some of the limitations of logic programming, and so ILP aims to induce programs that employ this paradigm. Current ILP systems that induce constrained logic programs extend systems based on the normal semantics ofILP. In this article we introduce IC-Log, a new system that induces constrained logic programs and relies on an extension ofa nonmonotonic semantics-based system. We then present an application of IC-Log in the field ofcomputer-aided publishing.

Integrating constraint logic programming and operations research techniques for the Crew Rostering Problem

In this paper, we investigate the possibility of integrating Artificial Intelligence (AI) and Operations Research (OR) techniques for solving the Crew Rostering Problem (CRP). CRP calls for the optimal sequencing of a given set of duties into rosters satisfying a set of constraints. The optimality criterion requires the minimization of the number of crews needed to cover the duties. This kind of problem has been traditionally solved by OR techniques. In recent years, a new programming paradigm based on Logic Programming, named Constraint Logic Programming (CLP), has been successfully used for solving hard combinatorial optimization problems. CLP maintains all the advantages of logic programming such as declarativeness, non-determinism and an incremental style of programming, while overcoming its limitations, mainly due to the inefficiency in exploring the search space. CLP achieves good results on hard combinatorial optimization problems which, however, are not comparable with those achieved by OR approaches. Therefore, we integrate both techniques in order to design an effective heuristic algorithm for CRP which fully exploits the advantages of the two methodologies: on the one hand, we maintain the declarativeness of CLP, its ease of representing knowledge and its rapid prototyping; on the other hand, we inherit from OR some efficient procedures based on a mathematical approach to the problem. Finally, we compare the results we achieved by means of the integration with those obtained by a pure OR approach, showing that AI and OR techniques for hard combinatorial optimization problems can be effectively integrated. © 1998 John Wiley & Sons, Ltd.

Qualifying Answers According to User Needs and Preferences

This paper presents a rigorous methodology for using annotated logic programming techniques to handle user preferences and needs in answering database queries. Two alternative transformations turn a database program into a new program that returns answers to queries according to qualitative labels. The two transformations have different semantics and are each appropriate in different situations. We have modified the standard definitions of annotated logic programs to handle user needs and preferences in databases. In the formalism, the user provides a lattice of domain-independent values that define preferences and needs and a set of domain specific user constraints qualified with lattice values. After the original database and the user constraints have been transformed into a new annotated deductive database, query-answering procedures for deductive databases are used, with minor modifications, to obtain annotated answers to queries. Because preference declaration is separated from data representation and management, preferences can be easily altered without touching the database. The resulting query language allows users to ask for answers at different preference levels.

Specification-based testing using cause-effect graphs

Software testing is a very important phase in the software development life cycle. There are two approaches to software testing. Specification based testing treats a program as a black box and disregards its internal structure. Program based testing, on the other hand, depends on the implementation code. Even though studies indicate that specification based testing is comparable, or even superior, to program based testing, most of specification based testing approaches are informal. This thesis presents a specification based testing strategy, called CEG-BOR, which combines the use of cause-effect graphs (CEGs) as a mechanism for representing specifications and the use of the Boolean operator (BOR) strategy for generating tests for a Boolean expression. If all causes of a CEG are independent from each other, a test set for the CEG can be constructed such that all boolean operator faults in the CEG can be detected and the size of this test set grows linearly with the number of nodes in the CEG. Four case studies are conducted to provide empirical data on the performance of CEG-BOR. Empirical results indicate that CEGs can be used to model a large class of software specifications and that CEG-BOR is very effective in detecting a broad spectrum of faults. Also, a BOR test set based on a CEG specification provides better coverage of the implementation code than test sets based on random testing, functional testing, and state-based testing. For a CEG that does not have mutually independent causes, the BOR strategy does not perform well. To remedy this problem, a new test generation strategy is presented, which combines the BOR strategy with the Meaningful Impact (MI) strategy, a recently developed test generation strategy for Boolean expressions. This new strategy, called BOR+MI, decomposes a Boolean expression into mutually independent components, applies the BOR or MI strategy to each component for test generation, and then applies the BOR strategy to combine the test sets for all components. The size and fault detection capability of a BOR+MI test set are investigated. Both analytical and empirical results show that the BOR+MI strategy generates a smaller test set than the MI strategy and provides comparable fault detection ability as the MI strategy. The BOR strategy is also refined to improve the detection of several types of parenthesis faults in a Boolean expression. The BOR+MI approach is further extended to CEGs with causes being relational expressions. This extension, called BRO+MI, detects incorrect relational operators in relational expressions and also accounts for user-defined or implicit restrictions on the causes of a CEG. Use of constraint logic programming techniques to automatically generate test data to satisfy BRO+MI test cases is proposed. Heuristics for incremental constraint propagation and deferred constraint satisfaction to make test data generation more efficient are presented. Empirical results indicate that the application of BOR based test generation strategies to specifications represented as predicates is a practical, scalable and cost-effective approach for development of effective software test suites across a wide set of application areas.

The Virtuality of Constraints and the Constraints of Virtuality

We propose to extend current Constraint Logic Programming techniques and to export them from their classical Logic Programming setting to more conventional and widely used paradigms, such as the Java language. We also advocate for the use of constraints in new types of applications such as 3D graphics and Virtual Reality systems.

The virtuality of constraints and the constraints of virtuality

We propose to extend current Constraint Logic Programming techniques and to export them from their classical Logic Programming setting to more conventional and widely used paradigms, such as the Java language. We also advocate for the use of constraints in new types of applications such as 3D graphics and Virtual Reality systems.

Logic programming and database schema in reverse engineering: Analysis and documentation for existing code in a multilanguage environment

This paper presents the experience that has been acquired over a period of three years during the Ph.D. dissertation of the first author. This experience has been characterised by three fundamental phases. The first of these produced an earlier paper [Eltantawi and Maresca, 1994] and dealt with the first experience of the application of logic programming (LP) to programming language analysis. This consisted of defining a methodology, and setting up a tool for the analysis of a few programming languages and for the representation of the main low-level design documents. The second phase stemmed from a second paper [Giannone and Maresca, 1995], which focused on the way in which useful documents were to be extracted during the System Comprehension activity, primarily in the reverse engineering phase. In this connection, applying LP techniques made it possible to define a methodology and set up a tool for generalising the extraction and abstraction of information to help in the building of the above documents, making them independent of the programming language. Phase three, this paper, represents the logical continuation of the first two, and tackles the application of LP techniques to RE activities and, in particular, the construction of low- and high-level design documents in a multilanguage environment. Specifically, this experience is concerned with the analysis of programming languages for reverse engineering (RE) topics using two approaches: a main approach based on logic, and a complementary approach based on database manipulation. The authors describe methodologies for the analysis of code belonging to a multilanguage environment, and discuss the motivations that made it possible to achieve the specific design and implementation of a software tool called “Multilanguage Analyser” (M-Lan-An). This tool can synthesise the candidate methodologies for the construction of low-level design documentation (such as the algebraic form), and high-level design documentation (such as the code structure-tree, the call-tree, the declaration-tree, and so forth). All the documents can be visualised and browsed using user-friendly interfaces, while the tool can determine some important objective metrics such as McCabe's number, Halstead's dimensional metrics, number of knots and their density, which are important indicators of the complexity of the analysed code. Currently, M-Lan-An can analyse several programming languages such as ANSI C/Turbo C, FORTRAN 77 and PL/1. The tool operates on PC (IBM-DOS) and is built in Turbo PROLOG V. 2.0 and CLIPPER V. 5.2.

A machine learning system for identifying transmembrane domains from amino acid sequences

We present our machine learning system, that uses inductive logic programming techniques to learn how to identify transmembrane domains from amino acid sequences. Our system facilitates the use of operators such as ‘contains’, that act on entire sequences, rather than on individual elements of a sequence. The prediction accuracy of our new system is around 93%, and this compares favourably with earlier results.

Using logic programming and coroutining for electronic CAD

We show how an extended Prolog can be exploited to implement different electronic CAD tools. Starting with a computer hardware description language (CHDL) several problems like digital circuit analysis, simulation, test generation, and code generation for programmable microprocessors are discussed. For that purpose the MIMOLA (machine independent microprogramming language) system MSS (MIMOLA hardware design system) is presented. It is shown that logic programming techniques have several advantages especially in the area of integrated circuit design. One of the main advantages is the small code size, which translates to easy maintenance. We make extensive use of two main features of standard Prolog and constraint logic programming, i.e., backtracking and the coroutining mechanism, to express Boolean constraints.

La modélisation lexicale dans le projet DELIS

The DELIS project ("Descriptive Lexical Specifications and Tools for Corpus-based Lexicon-building", project LRE 61.034 of the CEC) is building a generic toolbox for the interactive corpus-based construction of lexical specifications at the levels of lexical semantics, syntax and morphosyntax. The tools are used to build monolingual lexicon fragments for perception and speech act verbs and nouns of English, French, Italian, Danish and Dutch, as well as experimental bi- and multilingual fragments. Descriptive work is based on Fillmore's frame semantics and on ideas from Head-driven Phrase Structure Grammar (HPSG) ; it is represented in typed feature structures (TFS) which combine concepts from unification formalisms, logic programming and object-oriented techniques. In this article, we concentrate on the linguistic aspects of the lexical modélisation in DELIS.

A rule-based and object-oriented AI programming language

This paper presents a new artificial intelligence programming language called ROOP which is machine independent and has the ability to deal with logical programming in general. ROOP is a multiple paradigm language which combines rule-based, procedure, logic and object-oriented programming techniques.

Natural language processing and logic programming

This paper examines the main points of contact between logic programming and natural language processing, and covers some of the important issues that arise using logic programming techniques in natural language processing. It emphasizes the importance of taking into account the most general analyses from linguistic theory in building NLP systems, while also pointing out the need to adapt and combine the different theories to our ends, given that no single one can offer all- encompassing solutions. We concentrate on syntax, the most studied aspect of language processing. Our presentation of different approaches is centered whenever possible around treatment of one particular phenomenon, which serves as an axis of discussion throughout the article: long-distance dependencies between constituents.

Explicit Representation of Concept Negation

We present a learning method called Negative Explanation Based Generalization (NEBG) that performs automatic changes of representation by computing the negation of an already known concept. NEBG is similar to EBG as a deductive and valid learning method using a single example. It is based on new logic programming techniques based on example-guided transformation of the completed database. We also introduce a very powerful heuristic based on functional properties of the application domain. The implemented algorithms are described and several examples are given.

Survey of field programmable logic devices

This paper discusses the rapidly developing area of field programmable logic devices (FPLD) from the perspective of a user rather than a manufacturer. It aims to introduce the reader to the families of devices that are currently available, to identify common categories having similar characteristics and to summarize the main distinguishing features of specific devices. On the basis of logic block complexity and programming technique, a distinction is made between complex PLDs and field programmable gate arrays (FPGA). The discussion is restricted to those families of devices that offer logic complexities measured in thousands of gates, have the ability to include more than 100 register elements, and include more than 100 I/O pins. The devices considered include Aglotronix CAL, Altera MAX and Flex, AMD MACH, Actel ACT, AT&T ORCA, Concurrent Logic CLi6000, Crosspoint Solutions CP20K, Intel FLEXlogic, Lattice Semiconductor pLSI, Quicklogic pASIC, Xilinx LCA and EPLD.

A case-based approach to software reuse

This software reuse system helps a user build programs by reusing modules stored in an existing library. The system, dubbed caesar (Case-basEd SoftwAre Reuse), is conceived in the case-based reasoning framework, where cases consist of program specifications and the corresponding C language code. The case base is initially seeded by decomposing relevant programs into functional slices using algorithms from dataflow analysis. caesar retrieves stored specifications from this base and specializes and/or generalizes them to match the user specification. Testing techniques are applied to the construct assembled by caesar through sequential composition to generate test data which exhibits the behavior of the code. For efficiency, inductive logic programming techniques are used to capture combinations of functions that frequently occur together in specifications. Such combinations may be stored as new functional slices.

A first exploration of PrologIII's capabilities

AbstractThis paper explores PrologIII's capabilities through the study of two short but non‐trivial applications that are chosen to show the advantages of constraint logic programming languages over conventional Prologs, especially for tackling combinatorial problems.The first application (manipulation of causal graphs) highlights the expressive power of the constraints on booleans and shows that constraint logic programming techniques provide great flexibility for the exploration of the domain of an application, and therefore significantly improve Prolog's prototyping capabilities.The second application (map colouring) demonstrates that a combined use of numerical constraints and constraints on trees of PrologIII enables one to improve solutions based on standard backtracking, through the use of simple heuristics. Such heuristics allow drastic reduction of the search space and yield good performance even for quite complex problems. The adaptability of the approach to other combinatorial problems is shown on several examples.

Construction of university faculty timetables using logic programming techniques

A Prolog rule system for timetable construction in university faculties is proposed. The main module is concerned to the search of feasible instructor/room assignments under additional consideration of the faculty's education plan and certain a priori fixed assignment options. For accelerating the assignment search, a simple heuristic priority scheme is assumed. In another module, manual procedures for manipulating interactively the assignment results are possible. Further modules control the menu-driven input and maintenance of room and time planning data, manage the creation of timetable outputs and numerous survey tables, and thus contribute to a high transparency of the timetable planning process. The conceptional scheme of the underlying database contains information about lectures, exercises and seminars, lecturers and instructors, lecture halls, exercise rooms, and equivalent compatible rooms. Practical experiences with the program system, run on At microcomputers, will be reported.

Petri nets in logic

This paper discusses logic programming techniques applied to Petri nets. A Prolog representation of Petri nets is introduced, which is used to execute and analyse the nets.

The languages FCP(:) and FCP(:,?)

The language FCP(:,?) is the outcome of attempts to integrate the best of several flat concurrent logic programming languages, including Flat GHC, FCP (↓, |) and Flat Concurrent Prolog, in a single consistent framework. FCP(:) is a subset of FCP(:, ?), which is a variant of FPP(↓, |) and employs concepts of the concurrent constraint framework of cc(↓, |). FCP(:, ?) is a language which is strong enough to accommodate all useful concurrent logic programming techniques, including those which rely on atomic test unification and read-only variables, yet incorporates the weaker languages mentioned as subsets. This allows the programmer to remain within a simple subset of the language such as Flat GHC when the full power of atomic unification or read-only variables is not needed.