Showing papers on "Functional logic programming published in 2001"

Complexity and expressive power of logic programming

Abstract: This article surveys various complexity and expressiveness results on different forms of logic programming. The main focus is on decidable forms of logic programming, in particular, propositional logic programming and datalog, but we also mention general logic programming with function symbols. Next to classical results on plain logic programming (pure Horn clause programs), more recent results on various important extensions of logic programming are surveyed. These include logic programming with different forms of negation, disjunctive logic programming, logic programming with equality, and constraint logic programming.

Aspect-oriented programming: Introduction

Abstract: Computer science has experienced an evolution in programming languages and systems from the crude assembly and machine codes of the earliest computers through concepts such as formula translation, procedural programming, structured programming, functional programming, logic programming, and programming with abstract data types. Each of these steps in programming technology has advanced our ability to achieve clear separation of concerns at the source code level. Currently, the dominant programming paradigm is object-oriented programming - the idea that one builds a software system by decomposing a problem into objects and then writing the code of those objects. Such objects abstract together behavior and data into a single conceptual and physical entity. Object-orientation is reflected in the entire spectrum of current software development methodologies and tools - we have OO methodologies, analysis and design tools, and OO programming languages. Writing complex applications such as graphical user interfaces, operating systems, and distributed applications while maintaining comprehensible source code has been made possible with OOP. Success at developing simpler systems leads to aspirations for greater complexity. Object orientation is a clever idea, but has certain limitations. We are now seeing that many requirements do not decompose neatly into behavior centered on a single locus. Object technology has difficulty localizing concerns invoking global constraints and pandemic behaviors, appropriately segregating concerns, and applying domain-specific knowledge. Post-object programming (POP) mechanisms that look to increase the expressiveness of the OO paradigm are a fertile arena for current research. Examples of POP technologies include domain-specific languages, generative programming, generic programming, constraint languages, reflection and metaprogramming, feature-oriented development, views/viewpoints, and asynchronous message brokering. (Czarneclu and Eisenecker s book includes a good survey of many of these technologies).

Studying the language and structure in non-programmers' solutions to programming problems

Abstract: Programming may be more difficult than necessary because it requires solutions to be expressed in ways that are not familiar or natural for beginners. To identify what is natural, this article examines the ways that non-programmers express solutions to problems that were chosen to be representative of common programming tasks. The vocabulary and structure in these solutions is compared with the vocabulary and structure in modern programming languages, to identify the features and paradigms that seem to match these natural tendencies as well as those that do not. This information can be used by the designers of future programming languages to guide the selection and generation of language features. This design technique can result in languages that are easier to learn and use, because the languages will better match beginners' existing problem-solving abilities.

IBAL: a probabilistic rational programming language

Abstract: In a rational programming language, a program specifies a situation faced by an agent; evaluating the program amounts to computing what a rational agent would believe or do in the situation. This paper presents IBAL, a rational programming language for probabilistic and decision-theoretic agents. IBAL provides a rich declarative language for describing probabilistic models. The expression language allows the description of arbitrarily complex generative models. In addition, IBAL’s observation language makes it possible to express and compose rejective models that result from conditioning on the observations. IBAL also integrates Bayesian parameter estimation and decisiontheoretic utility maximization thoroughly into the framework. All these are packaged together into a programming language that has a rich type system and built-in extensibility. This paper presents a detailed account of the syntax and semantics of IBAL, as well as an overview of the implementation.

Parallel execution of prolog programs: a survey

Abstract: Since the early days of logic programming, researchers in the field realized the potential for exploitation of parallelism present in the execution of logic programs. Their high-level nature, the presence of nondeterminism, and their referential transparency, among other characteristics, make logic programs interesting candidates for obtaining speedups through parallel execution. At the same time, the fact that the typical applications of logic programming frequently involve irregular computations, make heavy use of dynamic data structures with logical variables, and involve search and speculation, makes the techniques used in the corresponding parallelizing compilers and run-time systems potentially interesting even outside the field. The objective of this article is to provide a comprehensive survey of the issues arising in parallel execution of logic programming languages along with the most relevant approaches explored to date in the field. Focus is mostly given to the challenges emerging from the parallel execution of Prolog programs. The article describes the major techniques used for shared memory implementation of Or-parallelism, And-parallelism, and combinations of the two. We also explore some related issues, such as memory management, compile-time analysis, and execution visualization.

Program Does Not Equal Program: Constraint Programming and Its Relationship to Mathematical Programming

Abstract: Arising from research in the computer science community, constraint programming is a fairly new technique for solving optimization problems. For those familiar with mathematical programming, a number of language barriers make it difficult to understand the concepts of constraint programming. In this short tutorial on constraint programming, we explain how it relates to familiar mathematical programming concepts and how constraint programming and mathematical programming technologies are complementary. We assume a minimal background in linear and integer programming.

A Comparison of Programming Languages and Algebraic Notation as Expressive Languages for Physics.

Abstract: The purpose of the present work is to consider some of the implications of replacing, for the purposes of physics instruction, algebraic notation with a program- ming language. What is novel is that, more than previous work, I take seriously the possibility that a programming language can function as the principle representational system for physics instruction. This means treating programming as potentially having a similar status and performing a similar function to algebraic notation in physics learn- ing. In order to address the implications of replacing the usual notational system with programming, I begin with two informal conjectures: (1) Programming-based representa- tions might be easier for students to understand than equation-based representations, and (2) programming-based representations might privilege a somewhat different "intuitive vocabulary." If the second conjecture is correct, it means that the nature of the under- standing associated with programming-physics might be fundamentally different than the understanding associated with algebra-physics. In order to refine and address these conjectures, I introduce a framework based around two theoretical constructs, what I call interpretive devices and symbolic forms. A con- clusion of this work is that algebra-physics can be characterized as a physics of balance and equilibrium, and programming-physics as a physics of processes and causation .M ore generally, this work provides a theoretical and empirical basis for understanding how the use of particular symbol systems affects students' conceptualization.

The Smodels System

Abstract: The Smodels system is an Answer Set Programming (ASP) implementation based on the stable model semantics of normal logic programs. The basic idea of ASP is to encode the constraints of a problem as a logic program such that the answer sets (stable models) of the program correspond to the solutions of the problem. Then we can solve the problem by letting a logic program engine to find the answer sets of the program.

Monotonic and Residuated Logic Programs

Abstract: In this paper we define the rather general framework of Monotonic Logic Programs, where the main results of (definite) logic programming are validly extrapolated. Whenever defining new logic programming extensions, we can thus turn our attention to the stipulation and study of its intuitive algebraic properties within the very general setting. Then, the existence of a minimum model and of a monotonic immediate consequences operator is guaranteed, and they are related as in classical logic programming. Afterwards we study the more restricted class of residuated logic programs which is able to capture several quite distinct logic programming semantics. Namely: Generalized Annotated Logic Programs, Fuzzy Logic Programming, Hybrid Probabilistic Logic Programs, and Possibilistic Logic Programming. We provide the embedding of possibilistic logic programming.

AutoHAN: an architecture for programming the home

Abstract: AutoHAN is a networking and software architecture that enables user programmable specification of the interaction between appliances in a domestic house. This concept represents an immense challenge for End-User Programming. The characteristics of the potential user population are far broader than any other population of end-user programmers. It is therefore essential to approach the design of the programming environment from a well founded perspective of cognitive ergonomics and user modelling. We have created a novel programming language, Media Cubes, which is aimed at the same user population as existing domestic remote controls. Moreover, we have applied a cognitive model of programming behaviour in order to specify a language that gives the advantages of direct manipulation as well as the power of more conventional languages.

A semantics for advice and dynamic join points in aspect-oriented programming

Abstract: A characteristic of aspect-oriented programming [KLM+97], as embodied in AspectJ [KHH+01], is the use of advice to incrementally modify the behavior of a base program. An advice expression specifies an action to be taken whenever some condition arises during the course of execution of the base program.

Constructor-based conditional narrowing

Abstract: We define a transformation from a left-linear constructor-based conditional rewrite system into an overlapping inductively sequential rewrite system. This transformation is sound and complete for the computations in the source system. Since there exists a sound and complete narrowing strategy for the target system, the combination of these results offers the first procedure for provably sound and complete narrowing computations for the whole class of the leftlinear constructor-based conditional rewrite systems. We address the differences between demand driven and lazy strategies and between narrowing strategies and narrowing calculi. In this context, we analyze the efficiency and practicality of using our transformation for the implementation of functional logic programming languages. The results of this paper complement, extend, and occasionally rectify, previously published results in this area.

A Procedural Semantics for Multi-adjoint Logic Programming

Abstract: Multi-adjoint logic program generalise monotonic logic programs introduced in [1] in that simultaneous use of several implications in the rules and rather general connectives in the bodies are allowed. In this work, a procedural semantics is given for the paradigm of multiadjoint logic programming and completeness theorems are proved.

An Introduction to Inductive Logic Programming

Abstract: Inductive logic programming (ILP) is concerned with the development of techniques and tools for relational data mining Besides the ability to deal with data stored in multiple tables, ILP systems are usually able to take into account generally valid background (domain) knowledge in the form of a logic program They also use the powerful language of logic programs for describing discovered patterns This chapter introduces the basics of logic programming and relates logic programming terminology to database terminology It then defines the task of relational rule induction, the basic data mining task addressed by ILP systems, and presents some basic techniques for solving this task It concludes with an overview of other relational data mining tasks addressed by ILP systems

A Comparative Study of Logic Programs with Preference: Preliminary Report

Abstract: We are interested in semantical underpinnings for existing approaches to preference handling in extended logic programming (within the framework of answer set programming). As a starting point, we explore three different approaches that have been recently proposed in the literature. Because these approaches use rather different formal means, we furnish a series of uniform characterizations that allow us to gain insights into the relationships among these approaches. To be more precise, we provide different characterizations in terms of (i) fixpoints, (ii) order preservation, and (iii) translations into standard logic programs. While the two former provide semantics for logic programming with preference information, the latter furnishes implementation techniques for these approaches.

A comparative study of logic programs with preference

Abstract: We are interested in semantical underpinnings for existing approaches to preference handling in extended logic programming (within the framework of answer set programming). As a starting point, we explore three different approaches that have been recently proposed in the literature. Because these approaches use rather different formal means, we furnish a series of uniform characterizations that allow us to gain insights into the relationships among these approaches. To be more precise, we provide different characterizations in terms of (i) fixpoints, (ii) order preservation, and (iii) translations into standard logic programs. While the two former provide semantics for logic programming with preference information, the latter furnishes implementation techniques for these approaches.

MINERVA - A Dynamic Logic Programming Agent Architecture

Abstract: The agent paradigm, commonly implemented by means of imperative languages mainly for reasons of efficiency, has recently increased its influence in the research and development of computational logic based systems. Since efficiency is not always the crucial issue, but clear specification and correctness is, Logic Programming and Non-monotonic Reasoning have been brought back into the spotlight. To this accrues the recent significant improvements in the efficiency of Logic Programming implementations for Non-monotonic Reasoning.This paper presents an overall description of MINERVA, an agent architecture and system designed with the intention of providing a common agent framework based on the unique strengths of Logic Programming, to allow for the combination of several non-monotonic knowledge representation and reasoning mechanisms developed in recent years. In [10], the semantics of the multi-dimensional structure and combination of the evolving societal knowledge of agents in described and discussed in detail.

Functional and constraint logic programming

Abstract: Starting at a seminal paper published by J. Jaffar and J.L. Lassez in 1987 [JL87], Constraint Logic Programming (CLP) has developed as a powerful programming paradigm which supports a clean combination of logic (in the form of Horn clauses) and domain-specific methods for constraint satisfaction, simplification and optimization. The well established mathematical foundations of logic programming [Llo87, Apt90] have been succesfully extended to CLP [JMMS96]. Simultaneously, practical applications of CLP have arisen in many fields. Good introductions to the theory, implementation issues and programming applications of CLP languages can be found in [JM94, MS98]. On the other hand, the combination of logic programming with other declarative programming paradigms (especially functional programming) has been widely investigated during the last decade, leading to useful insights for the design of more expressive declarative languages. The first attempt to combine functional and logic languages was done by J.A. Robinson and E.E. Sibert when proposing the language LOGLISP [RS82]. Some other early proposals for the design of functional + logic languages are described in [De86]. A more recent survey of the operational principles and implementation techniques used for the integration of functions into logic programming can be found in [Han94b].

Cognitive Factors in Programming with Diagrams

Abstract: Visual programming languages aim to broaden the use of diagrams within the software industry, to the extent that they are integrated into the programming language itself. As a result, they provide an ideal opportunity to study the benefits of diagrams as an external representation during problem solving: not only is programming a challenging problem-solving activity, but the effect of diagram usage can be directly assessed by comparing performance while using a visual programming language to performance with a standard textual language. There have been several misconceptions amongst visual language researchers regarding the role of diagrams in software design, but these are being addressed by empirical studies and by new theories of notation design derived from studies of visual programming. Based on this research, the authors are able to recommend several new directions for research into thinking with diagrams.

Programming by demonstration: a machine learning approach

Abstract: Programming by Demonstration: a Machine Learning Approach

Experimenting with heuristics for answer set programming

Abstract: Answer Set Programming (ASP) is a novel programming paradigm, which allows to solve problems in a simple and highly declarative way. The language of ASP (function-free disjunctive logic programming) is very expressive, and allows to represent even problems of high complexity (every problem in the complexity class P2 = NPNP). As for SAT solvers, the heuristic for the selection of the branching literal (i.e., the criterion determining the literal to be assumed true at a given stage of the computation) dramatically affects the performance of an ASP system. While heuristics for SAT have received a fair deal of research in AI, only little work in heuristics for ASP has been done so far. In this paper, we extend to the ASP framework a number of heuristics which have been successfully employed in existing systems, and we compare them experimentally. To this end, we implement such heuristics in the ASP system DLV, and we evaluate their respective efficiency on a number of benchmark problems taken from various domains. The experiments show interesting results, and evidence a couple of promising heuristic criteria for ASP, which sensibly outperform the heuristic of DLV.

Polymorphic Types in Functional Logic Programming.

Abstract: The rewriting logic CRWL has been proposed as a semantic frame- work for higher-order functional logic programming, using applicative rewriting systems as programs and lazy narrowing as the goal solving procedure. We present an extension of CRWL with a polymorphic type system, and we investigate the consequences of type discipline both at the semantic level and at the operational level. Semanti- cally, models must be extended to incorporate a type universe. Oper- ationally, lazy narrowing must maintain suitable type information in goals, in order to guarantee well-typed computed answers. ∗This research has been partially supported by the Spanish National Project TIC98- 0445-C03-02 “TREND” and the Esprit BRA Working Group EP-22457 “CCLII”. A pre- liminary version of the paper, much shorter and including no proofs, was published as [20].

Functional vector generation for HDL models using linear programming and Boolean satisfiability

Abstract: Our strategy for automatic generation of functional vectors is based on exercising selected paths in the given hardware description language (HDL) model. The HDL model describes interconnections of arithmetic, logic, and memory modules. Given a path in the HDL model, the search for input stimuli that exercise the path can be converted into a standard satisfiability (SAT) checking problem by expanding the arithmetic modules into logic gates. However, this approach is not very efficient. We present a new HDL-SAT checking algorithm that works directly on the HDL model. The primary feature of our algorithm is a seamless integration of linear-programming techniques for feasibility checking of arithmetic equations that govern the behavior of data-path modules and SAT checking for logic equations that govern the behavior of control modules. This feature is critically important to efficiency, since it avoids module expansion and allows us to work with logic and arithmetic equations whose cardinality tracks the size of the HDL model. We describe the details of the HDL-SAT checking algorithm in this paper. Experimental results that show significant speedups over state-of-the-art gate-level SAT checking methods are included.

Abduction in logic programming: a new definition and an abductive procedure based on rewriting

Abstract: A long outstanding problem for abduction in logic programming has been on how minimality might be defined. Without minimality, an abductive procedure is often required to generate exponentially many subsumed explanations for a given observation. In this paper, we propose a new definition of abduction in logic programming where the set of minimal explanations can be viewed as a succinct representation of the set of all explanations. We then propose an abductive procedure where the problem of generating explanations is formalized as rewriting with confluent and terminating rewrite systems. We show that these rewrite systems are sound and complete under the partial stable model semantics, and sound and complete under the answer set semantics when the underlying program is so-called odd-loop free. We discuss an application of abduction in logic programming to a problem in reasoning about actions and provide some experimental results.

Programming Languages: Principles and Paradigms

Abstract: From the Publisher: Programming Languages: Principles and Paradigms by Allen Tucker and Robert Noonan is provides balanced coverage of both the principles of language design and the different programming paradigms. The principles of language design are covered using a formal model and a hands-on laboratory suite that uses a Java interpreter to implement the formal model. This approach gives students an excellent grasp of language design theory and its relationship to practice. It also lays the foundation for the paradigms that are presented in the second half of the book. The text presents and contrasts six major programming paradigms: imperitave,object-oriented,functional,logic,concurrent,and event-driven programming. Through the use of one language for each paradigm,students gain a deep understanding of the paradigm without being distracted by a profusion of languages.

A Reactive Model-based Programming Language for Robotic Space Explorers

Abstract: Model-based autonomous agents have emerged recently as vital technologies in the development of highly autonomous reactive systems, particularly in the aerospace domain. These agents utilize many automated reasoning capabilities, but are complicated to use because of the variety of languages employed for each capability. To address this problem, we introduce model-based programming, a novel approach to designing embedded software systems. In particular, we introduce the Reactive Model-based Programming Language (RMPL), which provides a framework for constraint-based modeling, as well as a suite of reactive programming constructs. To convey the expressiveness of RMPL, we show how it captures the main features of synchronous programming languages and advanced robotic execution languages. This paper focuses on using the rich behavior modeling of RMPL to provide sequencing and robotic execution capabilities for spacecraft.

What Is Aspect-Oriented Programming, Revisited

Abstract: For the Advanced Separation of Concerns workshop at OOPSLA 2000 in Minneapolis, Dan Friedman and I wrote a paper [10] that argued that the distinguishing characteristic of Aspect-Oriented Programming systems (qua programming systems) is that they provide quantification and obliviousness. In this paper, I expand on the themes of our Minneapolis workshop paper, re-spond to some of the comments we?ve received on that paper, and provide a computational for-malization of the notion of quantification.

An interactive semantics of logic programming

Abstract: We apply to logic programming some recently emerging ideas from the field of reduction-bas ed communicating systems, with the aim of giving evidence of the hidden interactions and the coordination mechanisms that rule the operational machinery of such a programming paradigm. The semantic framework we have chosen for presenting our results is tile logic, which has the advantage of allowing a uniform treatment of goals and observations and of applying abstract categorical tools for proving the results. As main contributions, we mention the finitary presentation of abstract unification, and a concurrent and coordinated abstract sema ntics consistent with the most common semantics of logic programming. Moreover, the compositionality of the tile semantics is guaranteed by standard results, as it reduces to check that the tile syst ems associated to logic programs enjoy the tile decomposition property. An extension of the approach for handling constraint systems is also discussed.