Datasets:

sumuks

/

arxiv_dataset

like 0

Optimality in Goal-Dependent Analysis of Sharing

http://arxiv.org/abs/cs/0503055v2

http://arxiv.org/abs/cs/0503055v2

http://arxiv.org/pdf/cs/0503055v2

2005-03-22

2009-06-15

We face the problems of correctness, optimality and precision for the static analysis of logic programs, using the theory of abstract interpretation. We propose a framework with a denotational, goal-dependent semantics equipped with two unification operators for forward unification (calling a procedure) and backward unification (returning from a procedure). The latter is implemented through a matching operation. Our proposal clarifies and unifies many different frameworks and ideas on static analysis of logic programming in a single, formal setting. On the abstract side, we focus on the domain Sharing by Jacobs and Langen and provide the best correct approximation of all the primitive semantic operators, namely, projection, renaming, forward and backward unification. We show that the abstract unification operators are strictly more precise than those in the literature defined over the same abstract domain. In some cases, our operators are more precise than those developed for more complex domains involving linearity and freeness. To appear in Theory and Practice of Logic Programming (TPLP)

Theory and Practice of Logic Programming, volume 9, issue 05, pp. 617-689, 2009

10.1017/S1471068409990111

cs.PL

Stabilization of Cooperative Information Agents in Unpredictable Environment: A Logic Programming Approach

http://arxiv.org/abs/cs/0503028v2

http://arxiv.org/abs/cs/0503028v2

http://arxiv.org/pdf/cs/0503028v2

2005-03-14

2005-03-24

An information agent is viewed as a deductive database consisting of 3 parts: an observation database containing the facts the agent has observed or sensed from its surrounding environment, an input database containing the information the agent has obtained from other agents, and an intensional database which is a set of rules for computing derived information from the information stored in the observation and input databases. Stabilization of a system of information agents represents a capability of the agents to eventually get correct information about their surrounding despite unpredictable environment changes and the incapability of many agents to sense such changes causing them to have temporary incorrect information. We argue that the stabilization of a system of cooperative information agents could be understood as the convergence of the behavior of the whole system toward the behavior of a "superagent", who has the sensing and computing capabilities of all agents combined. We show that unfortunately, stabilization is not guaranteed in general, even if the agents are fully cooperative and do not hide any information from each other. We give sufficient conditions for stabilization and discuss the consequences of our results.

To appear in Theory and Practice of Logic Programming (TPLP)

cs.LO

A Systematic Aspect-Oriented Refactoring and Testing Strategy, and its Application to JHotDraw

http://arxiv.org/abs/cs/0503015v1

http://arxiv.org/abs/cs/0503015v1

http://arxiv.org/pdf/cs/0503015v1

2005-03-05

2005-03-05

Aspect oriented programming aims at achieving better modularization for a system's crosscutting concerns in order to improve its key quality attributes, such as evolvability and reusability. Consequently, the adoption of aspect-oriented techniques in existing (legacy) software systems is of interest to remediate software aging. The refactoring of existing systems to employ aspect-orientation will be considerably eased by a systematic approach that will ensure a safe and consistent migration. In this paper, we propose a refactoring and testing strategy that supports such an approach and consider issues of behavior conservation and (incremental) integration of the aspect-oriented solution with the original system. The strategy is applied to the JHotDraw open source project and illustrated on a group of selected concerns. Finally, we abstract from the case study and present a number of generic refactorings which contribute to an incremental aspect-oriented refactoring process and associate particular types of crosscutting concerns to the model and features of the employed aspect language. The contributions of this paper are both in the area of supporting migration towards aspect-oriented solutions and supporting the development of aspect languages that are better suited for such migrations.

25 pages

cs.SE

Structuring quantum effects: superoperators as arrows

http://arxiv.org/abs/quant-ph/0501151v1

http://arxiv.org/abs/quant-ph/0501151v1

http://arxiv.org/pdf/quant-ph/0501151v1

2005-01-25

2005-01-25

We show that the model of quantum computation based on density matrices and superoperators can be decomposed in a pure classical (functional) part and an effectful part modeling probabilities and measurement. The effectful part can be modeled using a generalization of monads called arrows. We express the resulting executable model of quantum computing in the programming language Haskell using its special syntax for arrow computations. The embedding in Haskell is however not perfect: a faithful model of quantum computing requires type capabilities which are not directly expressible in Haskell.

21 pages, 4 figures

quant-ph

Proving Correctness and Completeness of Normal Programs - a Declarative Approach

http://arxiv.org/abs/cs/0501043v1

http://arxiv.org/abs/cs/0501043v1

http://arxiv.org/pdf/cs/0501043v1

2005-01-25

2005-01-25

We advocate a declarative approach to proving properties of logic programs. Total correctness can be separated into correctness, completeness and clean termination; the latter includes non-floundering. Only clean termination depends on the operational semantics, in particular on the selection rule. We show how to deal with correctness and completeness in a declarative way, treating programs only from the logical point of view. Specifications used in this approach are interpretations (or theories). We point out that specifications for correctness may differ from those for completeness, as usually there are answers which are neither considered erroneous nor required to be computed. We present proof methods for correctness and completeness for definite programs and generalize them to normal programs. For normal programs we use the 3-valued completion semantics; this is a standard semantics corresponding to negation as finite failure. The proof methods employ solely the classical 2-valued logic. We use a 2-valued characterization of the 3-valued completion semantics which may be of separate interest. The presented methods are compared with an approach based on operational semantics. We also employ the ideas of this work to generalize a known method of proving termination of normal programs.

To appear in Theory and Practice of Logic Programming (TPLP). 44 pages

Theory and Practice of Logic Programming, 5(6):669-711, 2005

cs.LO

Optimal Union-Find in Constraint Handling Rules

http://arxiv.org/abs/cs/0501073v1

http://arxiv.org/abs/cs/0501073v1

http://arxiv.org/pdf/cs/0501073v1

2005-01-25

2005-01-25

Constraint Handling Rules (CHR) is a committed-choice rule-based language that was originally intended for writing constraint solvers. In this paper we show that it is also possible to write the classic union-find algorithm and variants in CHR. The programs neither compromise in declarativeness nor efficiency. We study the time complexity of our programs: they match the almost-linear complexity of the best known imperative implementations. This fact is illustrated with experimental results.

12 pages, 3 figures, to appear in Theory and Practice of Logic Programming (TPLP)

cs.PL

Extending Design by Contract for Aspect-Oriented Programming

http://arxiv.org/abs/cs/0501070v1

http://arxiv.org/abs/cs/0501070v1

http://arxiv.org/pdf/cs/0501070v1

2005-01-24

2005-01-24

Design by Contract (DbC) and runtime enforcement of program assertions enables the construction of more robust software. It also enables the assignment of blame in error reporting. Unfortunately, there is no support for runtime contract enforcement and blame assignment for Aspect-Oriented Programming (AOP). Extending DbC to also cover aspects brings forward a plethora of issues related to the correct order of assertion validation. We show that there is no generally correct execution sequence of object assertions and aspect assertions. A further classification of aspects as agnostic, obedient, or rebellious defines the order of assertion validation that needs to be followed. We describe the application of this classification in a prototyped DbC tool for AOP named Cona, where aspects are used for implementing contracts, and contracts are used for enforcing assertions on aspects.

cs.SE

Widening Operators for Weakly-Relational Numeric Abstractions (Extended Abstract)

http://arxiv.org/abs/cs/0412043v1

http://arxiv.org/abs/cs/0412043v1

http://arxiv.org/pdf/cs/0412043v1

2004-12-10

2004-12-10

We discuss the divergence problems recently identified in some extrapolation operators for weakly-relational numeric domains. We identify the cause of the divergences and point out that resorting to more concrete, syntactic domains can be avoided by researching suitable algorithms for the elimination of redundant constraints in the chosen representation.

cs.PL

An Efficient and Flexible Engine for Computing Fixed Points

http://arxiv.org/abs/cs/0412041v2

http://arxiv.org/abs/cs/0412041v2

http://arxiv.org/pdf/cs/0412041v2

2004-12-09

2005-01-02

An efficient and flexible engine for computing fixed points is critical for many practical applications. In this paper, we firstly present a goal-directed fixed point computation strategy in the logic programming paradigm. The strategy adopts a tabled resolution (or memorized resolution) to mimic the efficient semi-naive bottom-up computation. Its main idea is to dynamically identify and record those clauses that will lead to recursive variant calls, and then repetitively apply those alternatives incrementally until the fixed point is reached. Secondly, there are many situations in which a fixed point contains a large number or even infinite number of solutions. In these cases, a fixed point computation engine may not be efficient enough or feasible at all. We present a mode-declaration scheme which provides the capabilities to reduce a fixed point from a big solution set to a preferred small one, or from an infeasible infinite set to a finite one. The mode declaration scheme can be characterized as a meta-level operation over the original fixed point. We show the correctness of the mode declaration scheme. Thirdly, the mode-declaration scheme provides a new declarative method for dynamic programming, which is typically used for solving optimization problems. There is no need to define the value of an optimal solution recursively, instead, defining a general solution suffices. The optimal value as well as its corresponding concrete solution can be derived implicitly and automatically using a mode-directed fixed point computation engine. Finally, this fixed point computation engine has been successfully implemented in a commercial Prolog system. Experimental results are shown to indicate that the mode declaration improves both time and space performances in solving dynamic programming problems.

26 pages

cs.PL

Jartege: a Tool for Random Generation of Unit Tests for Java Classes

http://arxiv.org/abs/cs/0412012v1

http://arxiv.org/abs/cs/0412012v1

http://arxiv.org/pdf/cs/0412012v1

2004-12-03

2004-12-03

This report presents Jartege, a tool which allows random generation of unit tests for Java classes specified in JML. JML (Java Modeling Language) is a specification language for Java which allows one to write invariants for classes, and pre- and postconditions for operations. As in the JML-JUnit tool, we use JML specifications on the one hand to eliminate irrelevant test cases, and on the other hand as a test oracle. Jartege randomly generates test cases, which consist of a sequence of constructor and method calls for the classes under test. The random aspect of the tool can be parameterized by associating weights to classes and operations, and by controlling the number of instances which are created for each class under test. The practical use of Jartege is illustrated by a small case study.

cs.PL

A machine-independent port of the SR language run-time system to the NetBSD operating system

http://arxiv.org/abs/cs/0411028v1

http://arxiv.org/abs/cs/0411028v1

http://arxiv.org/pdf/cs/0411028v1

2004-11-10

2004-11-10

SR (synchronizing resources) is a PASCAL - style language enhanced with constructs for concurrent programming developed at the University of Arizona in the late 1980s. MPD (presented in Gregory Andrews' book about Foundations of Multithreaded, Parallel, and Distributed Programming) is its successor, providing the same language primitives with a different syntax. The run-time system (in theory, identical) of both languages provides the illusion of a multiprocessor machine on a single single- or multi- CPU Unix-like system or a (local area) network of Unix-like machines. Chair V of the Computer Science Department of the University of Bonn is operating a laboratory for a practical course in parallel programming consisting of computing nodes running NetBSD/arm, normally used via PVM, MPI etc. We are considering to offer SR and MPD for this, too. As the original language distributions are only targeted at a few commercial Unix systems, some porting effort is needed, outlined in the SR porting guide. The integrated POSIX threads support of NetBSD-2.0 should allow us to use library primitives provided for NetBSD's phtread system to implement the primitives needed by the SR run-time system, thus implementing 13 target CPUs at once and automatically making use of SMP on VAX, Alpha, PowerPC, Sparc, 32-bit Intel and 64 bit AMD CPUs. This paper describes work in progress.

presented at 3rd European BSD Conference, Karlsruhe, Germany, 2004 Oct. 29-31; 4 pages

Juergen Egeling (Ed.): Proceedings of the 3rd European BSD Conference, Karlsruhe, Germany 2004, p.181

cs.DC

Intelligent search strategies based on adaptive Constraint Handling Rules

http://arxiv.org/abs/cs/0411016v2

http://arxiv.org/abs/cs/0411016v2

http://arxiv.org/pdf/cs/0411016v2

2004-11-08

2004-11-18

The most advanced implementation of adaptive constraint processing with Constraint Handling Rules (CHR) allows the application of intelligent search strategies to solve Constraint Satisfaction Problems (CSP). This presentation compares an improved version of conflict-directed backjumping and two variants of dynamic backtracking with respect to chronological backtracking on some of the AIM instances which are a benchmark set of random 3-SAT problems. A CHR implementation of a Boolean constraint solver combined with these different search strategies in Java is thus being compared with a CHR implementation of the same Boolean constraint solver combined with chronological backtracking in SICStus Prolog. This comparison shows that the addition of ``intelligence'' to the search process may reduce the number of search steps dramatically. Furthermore, the runtime of their Java implementations is in most cases faster than the implementations of chronological backtracking. More specifically, conflict-directed backjumping is even faster than the SICStus Prolog implementation of chronological backtracking, although our Java implementation of CHR lacks the optimisations made in the SICStus Prolog system. To appear in Theory and Practice of Logic Programming (TPLP).

Number of pages: 27 Number of figures: 14 Number of Tables: 2

cs.AI

Synchronization from a Categorical Perspective

http://arxiv.org/abs/cs/0411001v1

http://arxiv.org/abs/cs/0411001v1

http://arxiv.org/pdf/cs/0411001v1

2004-11-01

2004-11-01

We introduce a notion of synchronization for higher-dimensional automata, based on coskeletons of cubical sets. Categorification transports this notion to the setting of categorical transition systems. We apply the results to study the semantics of an imperative programming language with message-passing.

cs.PL

On Spatial Conjunction as Second-Order Logic

http://arxiv.org/abs/cs/0410073v1

http://arxiv.org/abs/cs/0410073v1

http://arxiv.org/pdf/cs/0410073v1

2004-10-28

2004-10-28

Spatial conjunction is a powerful construct for reasoning about dynamically allocated data structures, as well as concurrent, distributed and mobile computation. While researchers have identified many uses of spatial conjunction, its precise expressive power compared to traditional logical constructs was not previously known. In this paper we establish the expressive power of spatial conjunction. We construct an embedding from first-order logic with spatial conjunction into second-order logic, and more surprisingly, an embedding from full second order logic into first-order logic with spatial conjunction. These embeddings show that the satisfiability of formulas in first-order logic with spatial conjunction is equivalent to the satisfiability of formulas in second-order logic. These results explain the great expressive power of spatial conjunction and can be used to show that adding unrestricted spatial conjunction to a decidable logic leads to an undecidable logic. As one example, we show that adding unrestricted spatial conjunction to two-variable logic leads to undecidability. On the side of decidability, the embedding into second-order logic immediately implies the decidability of first-order logic with a form of spatial conjunction over trees. The embedding into spatial conjunction also has useful consequences: because a restricted form of spatial conjunction in two-variable logic preserves decidability, we obtain that a correspondingly restricted form of second-order quantification in two-variable logic is decidable. The resulting language generalizes the first-order theory of boolean algebra over sets and is useful in reasoning about the contents of data structures in object-oriented languages.

16 pages

cs.LO

Checking modes of HAL programs

http://arxiv.org/abs/cs/0409038v1

http://arxiv.org/abs/cs/0409038v1

http://arxiv.org/pdf/cs/0409038v1

2004-09-21

2004-09-21

Recent constraint logic programming (CLP) languages, such as HAL and Mercury, require type, mode and determinism declarations for predicates. This information allows the generation of efficient target code and the detection of many errors at compile-time. Unfortunately, mode checking in such languages is difficult. One of the main reasons is that, for each predicate mode declaration, the compiler is required to appropriately re-order literals in the predicate's definition. The task is further complicated by the need to handle complex instantiations (which interact with type declarations and higher-order predicates) and automatic initialization of solver variables. Here we define mode checking for strongly typed CLP languages which require reordering of clause body literals. In addition, we show how to handle a simple case of polymorphic modes by using the corresponding polymorphic types.

46 pages, 3 figures To appear in Theory and Practice of Logic Programming

Theory and Practice of Logic Programming: 5(6):623-668, 2005

cs.PL

Automatic Generation of CHR Constraint Solvers

http://arxiv.org/abs/cs/0409030v1

http://arxiv.org/abs/cs/0409030v1

http://arxiv.org/pdf/cs/0409030v1

2004-09-14

2004-09-14

In this paper, we present a framework for automatic generation of CHR solvers given the logical specification of the constraints. This approach takes advantage of the power of tabled resolution for constraint logic programming, in order to check the validity of the rules. Compared to previous works where different methods for automatic generation of constraint solvers have been proposed, our approach enables the generation of more expressive rules (even recursive and splitting rules) that can be used directly as CHR solvers.

to be published in Theory and Practice of Logic Programming, 16 pages, 2 figures

cs.LO

Using a hierarchy of Domain Specific Languages in complex software systems design

http://arxiv.org/abs/cs/0409016v1

http://arxiv.org/abs/cs/0409016v1

http://arxiv.org/pdf/cs/0409016v1

2004-09-09

2004-09-09

A new design methodology is introduced, with some examples on building Domain Specific Languages hierarchy on top of Scheme.

8 pages, 1 figure

cs.PL

CrocoPat 2.1 Introduction and Reference Manual

http://arxiv.org/abs/cs/0409009v1

http://arxiv.org/abs/cs/0409009v1

http://arxiv.org/pdf/cs/0409009v1

2004-09-07

2004-09-07

CrocoPat is an efficient, powerful and easy-to-use tool for manipulating relations of arbitrary arity, including directed graphs. This manual provides an introduction to and a reference for CrocoPat and its programming language RML. It includes several application examples, in particular from the analysis of structural models of software systems.

19 pages + cover, 2 eps figures, uses llncs.cls and cs_techrpt_cover.sty, for downloading the source code, binaries, and RML examples, see http://www.software-systemtechnik.de/CrocoPat/

cs.PL

On computing the fixpoint of a set of boolean equations

http://arxiv.org/abs/cs/0408045v1

http://arxiv.org/abs/cs/0408045v1

http://arxiv.org/pdf/cs/0408045v1

2004-08-19

2004-08-19

This paper presents a method for computing a least fixpoint of a system of equations over booleans. The resulting computation can be significantly shorter than the result of iteratively evaluating the entire system until a fixpoint is reached.

15 pages

cs.PL

CHR Grammars

http://arxiv.org/abs/cs/0408027v1

http://arxiv.org/abs/cs/0408027v1

http://arxiv.org/pdf/cs/0408027v1

2004-08-12

2004-08-12

A grammar formalism based upon CHR is proposed analogously to the way Definite Clause Grammars are defined and implemented on top of Prolog. These grammars execute as robust bottom-up parsers with an inherent treatment of ambiguity and a high flexibility to model various linguistic phenomena. The formalism extends previous logic programming based grammars with a form of context-sensitive rules and the possibility to include extra-grammatical hypotheses in both head and body of grammar rules. Among the applications are straightforward implementations of Assumption Grammars and abduction under integrity constraints for language analysis. CHR grammars appear as a powerful tool for specification and implementation of language processors and may be proposed as a new standard for bottom-up grammars in logic programming. To appear in Theory and Practice of Logic Programming (TPLP), 2005

36 pp. To appear in TPLP, 2005

cs.CL

Optimizing compilation of constraint handling rules in HAL

http://arxiv.org/abs/cs/0408025v1

http://arxiv.org/abs/cs/0408025v1

http://arxiv.org/pdf/cs/0408025v1

2004-08-10

2004-08-10

In this paper we discuss the optimizing compilation of Constraint Handling Rules (CHRs). CHRs are a multi-headed committed choice constraint language, commonly applied for writing incremental constraint solvers. CHRs are usually implemented as a language extension that compiles to the underlying language. In this paper we show how we can use different kinds of information in the compilation of CHRs in order to obtain access efficiency, and a better translation of the CHR rules into the underlying language, which in this case is HAL. The kinds of information used include the types, modes, determinism, functional dependencies and symmetries of the CHR constraints. We also show how to analyze CHR programs to determine this information about functional dependencies, symmetries and other kinds of information supporting optimizations.

29 pages 6 figures, 4 tables. To appear in Theory and Practice of Logic Programming (TPLP)

Theory and Practice of Logic Programming: 5(4-5):503-532, 2005

cs.PL

On Global Warming (Softening Global Constraints)

http://arxiv.org/abs/cs/0408023v1

http://arxiv.org/abs/cs/0408023v1

http://arxiv.org/pdf/cs/0408023v1

2004-08-09

2004-08-09

We describe soft versions of the global cardinality constraint and the regular constraint, with efficient filtering algorithms maintaining domain consistency. For both constraints, the softening is achieved by augmenting the underlying graph. The softened constraints can be used to extend the meta-constraint framework for over-constrained problems proposed by Petit, Regin and Bessiere.

15 pages, 7 figures. Accepted at the 6th International Workshop on Preferences and Soft Constraints

cs.AI

On Generalized Records and Spatial Conjunction in Role Logic

http://arxiv.org/abs/cs/0408019v1

http://arxiv.org/abs/cs/0408019v1

http://arxiv.org/pdf/cs/0408019v1

2004-08-05

2004-08-05

We have previously introduced role logic as a notation for describing properties of relational structures in shape analysis, databases and knowledge bases. A natural fragment of role logic corresponds to two-variable logic with counting and is therefore decidable. We show how to use role logic to describe open and closed records, as well the dual of records, inverse records. We observe that the spatial conjunction operation of separation logic naturally models record concatenation. Moreover, we show how to eliminate the spatial conjunction of formulas of quantifier depth one in first-order logic with counting. As a result, allowing spatial conjunction of formulas of quantifier depth one preserves the decidability of two-variable logic with counting. This result applies to two-variable role logic fragment as well. The resulting logic smoothly integrates type system and predicate calculus notation and can be viewed as a natural generalization of the notation for constraints arising in role analysis and similar shape analysis approaches.

30 pages. A version appears in SAS 2004

cs.PL

On Role Logic

http://arxiv.org/abs/cs/0408018v1

http://arxiv.org/abs/cs/0408018v1

http://arxiv.org/pdf/cs/0408018v1

2004-08-05

2004-08-05

We present role logic, a notation for describing properties of relational structures in shape analysis, databases, and knowledge bases. We construct role logic using the ideas of de Bruijn's notation for lambda calculus, an encoding of first-order logic in lambda calculus, and a simple rule for implicit arguments of unary and binary predicates. The unrestricted version of role logic has the expressive power of first-order logic with transitive closure. Using a syntactic restriction on role logic formulas, we identify a natural fragment RL^2 of role logic. We show that the RL^2 fragment has the same expressive power as two-variable logic with counting C^2 and is therefore decidable. We present a translation of an imperative language into the decidable fragment RL^2, which allows compositional verification of programs that manipulate relational structures. In addition, we show how RL^2 encodes boolean shape analysis constraints and an expressive description logic.

20 pages. Our later SAS 2004 result builds on this work

cs.PL

On the Theory of Structural Subtyping

http://arxiv.org/abs/cs/0408015v1

http://arxiv.org/abs/cs/0408015v1

http://arxiv.org/pdf/cs/0408015v1

2004-08-05

2004-08-05

We show that the first-order theory of structural subtyping of non-recursive types is decidable. Let $\Sigma$ be a language consisting of function symbols (representing type constructors) and $C$ a decidable structure in the relational language $L$ containing a binary relation $\leq$. $C$ represents primitive types; $\leq$ represents a subtype ordering. We introduce the notion of $\Sigma$-term-power of $C$, which generalizes the structure arising in structural subtyping. The domain of the $\Sigma$-term-power of $C$ is the set of $\Sigma$-terms over the set of elements of $C$. We show that the decidability of the first-order theory of $C$ implies the decidability of the first-order theory of the $\Sigma$-term-power of $C$. Our decision procedure makes use of quantifier elimination for term algebras and Feferman-Vaught theorem. Our result implies the decidability of the first-order theory of structural subtyping of non-recursive types.

51 page. A version appeared in LICS 2003

cs.LO

Typestate Checking and Regular Graph Constraints

http://arxiv.org/abs/cs/0408014v1

http://arxiv.org/abs/cs/0408014v1

http://arxiv.org/pdf/cs/0408014v1

2004-08-05

2004-08-05

We introduce regular graph constraints and explore their decidability properties. The motivation for regular graph constraints is 1) type checking of changing types of objects in the presence of linked data structures, 2) shape analysis techniques, and 3) generalization of similar constraints over trees and grids. We define a subclass of graphs called heaps as an abstraction of the data structures that a program constructs during its execution. We prove that determining the validity of implication for regular graph constraints over the class of heaps is undecidable. We show undecidability by exhibiting a characterization of certain "corresponder graphs" in terms of presence and absence of homomorphisms to a finite number of fixed graphs. The undecidability of implication of regular graph constraints implies that there is no algorithm that will verify that procedure preconditions are met or that the invariants are maintained when these properties are expressed in any specification language at least as expressive as regular graph constraints.

21 page. A version appeared in SAS 2003

cs.PL

Roles Are Really Great!

http://arxiv.org/abs/cs/0408013v1

http://arxiv.org/abs/cs/0408013v1

http://arxiv.org/pdf/cs/0408013v1

2004-08-05

2004-08-05

We present a new role system for specifying changing referencing relationships of heap objects. The role of an object depends, in large part, on its aliasing relationships with other objects, with the role of each object changing as its aliasing relationships change. Roles therefore capture important object and data structure properties and provide useful information about how the actions of the program interact with these properties. Our role system enables the programmer to specify the legal aliasing relationships that define the set of roles that objects may play, the roles of procedure parameters and object fields, and the role changes that procedures perform while manipulating objects. We present an interprocedural, compositional, and context-sensitive role analysis algorithm that verifies that a program respects the role constraints.

29 pages. A version appeared in POPL 2002

cs.PL

The First-Order Theory of Sets with Cardinality Constraints is Decidable

http://arxiv.org/abs/cs/0407045v2

http://arxiv.org/abs/cs/0407045v2

http://arxiv.org/pdf/cs/0407045v2

2004-07-17

2004-10-03

We show that the decidability of the first-order theory of the language that combines Boolean algebras of sets of uninterpreted elements with Presburger arithmetic operations. We thereby disprove a recent conjecture that this theory is undecidable. Our language allows relating the cardinalities of sets to the values of integer variables, and can distinguish finite and infinite sets. We use quantifier elimination to show the decidability and obtain an elementary upper bound on the complexity. Precise program analyses can use our decidability result to verify representation invariants of data structures that use an integer field to represent the number of stored elements.

18 pages

cs.LO

A Hyper-Arc Consistency Algorithm for the Soft Alldifferent Constraint

http://arxiv.org/abs/cs/0407043v1

http://arxiv.org/abs/cs/0407043v1

http://arxiv.org/pdf/cs/0407043v1

2004-07-16

2004-07-16

This paper presents an algorithm that achieves hyper-arc consistency for the soft alldifferent constraint. To this end, we prove and exploit the equivalence with a minimum-cost flow problem. Consistency of the constraint can be checked in O(nm) time, and hyper-arc consistency is achieved in O(m) time, where n is the number of variables involved and m is the sum of the cardinalities of the domains. It improves a previous method that did not ensure hyper-arc consistency.

11 pages, 1 figure

cs.PL

Exploiting Semidefinite Relaxations in Constraint Programming

http://arxiv.org/abs/cs/0407041v1

http://arxiv.org/abs/cs/0407041v1

http://arxiv.org/pdf/cs/0407041v1

2004-07-16

2004-07-16

Constraint programming uses enumeration and search tree pruning to solve combinatorial optimization problems. In order to speed up this solution process, we investigate the use of semidefinite relaxations within constraint programming. In principle, we use the solution of a semidefinite relaxation to guide the traversal of the search tree, using a limited discrepancy search strategy. Furthermore, a semidefinite relaxation produces a bound for the solution value, which is used to prune parts of the search tree. Experimental results on stable set and maximum clique problem instances show that constraint programming can indeed greatly benefit from semidefinite relaxations.

18 pages, 4 figures. Submitted preprint

cs.DM

A Process Algebraic Approach to Concurrent and Distributed Quantum Computation: Operational Semantics

http://arxiv.org/abs/quant-ph/0407005v1

http://arxiv.org/abs/quant-ph/0407005v1

http://arxiv.org/pdf/quant-ph/0407005v1

2004-07-01

2004-07-01

Full formal descriptions of algorithms making use of quantum principles must take into account both quantum and classical computing components and assemble them so that they communicate and cooperate. Moreover, to model concurrent and distributed quantum computations, as well as quantum communication protocols, quantum to quantum communications which move qubits physically from one place to another must also be taken into account. Inspired by classical process algebras, which provide a framework for modeling cooperating computations, a process algebraic notation is defined, named QPAlg for Quantum Process Algebra, which provides a homogeneous style to formal descriptions of concurrent and distributed computations comprising both quantum and classical parts. On the quantum side, QPAlg provides quantum variables, operations on quantum variables (unitary operators and measurement observables), as well as new forms of communications involving the quantum world. The operational semantics makes sure that these quantum objects, operations and communications operate according to the postulates of quantum mechanics.

22 pages, Proceedings of the 2nd International Workshop on Quantum Programming Languages, July 12-13, 2004, Turku, Finland

quant-ph

Well-Definedness and Semantic Type-Checking in the Nested Relational Calculus and XQuery

http://arxiv.org/abs/cs/0406060v1

http://arxiv.org/abs/cs/0406060v1

http://arxiv.org/pdf/cs/0406060v1

2004-06-29

2004-06-29

Two natural decision problems regarding the XML query language XQuery are well-definedness and semantic type-checking. We study these problems in the setting of a relational fragment of XQuery. We show that well-definedness and semantic type-checking are undecidable, even in the positive-existential case. Nevertheless, for a ``pure'' variant of XQuery, in which no identification is made between an item and the singleton containing that item, the problems become decidable. We also consider the analogous problems in the setting of the nested relational calculus.

cs.DB

Non-Termination Inference of Logic Programs

http://arxiv.org/abs/cs/0406041v1

http://arxiv.org/abs/cs/0406041v1

http://arxiv.org/pdf/cs/0406041v1

2004-06-22

2004-06-22

We present a static analysis technique for non-termination inference of logic programs. Our framework relies on an extension of the subsumption test, where some specific argument positions can be instantiated while others are generalized. We give syntactic criteria to statically identify such argument positions from the text of a program. Atomic left looping queries are generated bottom-up from selected subsets of the binary unfoldings of the program of interest. We propose a set of correct algorithms for automating the approach. Then, non-termination inference is tailored to attempt proofs of optimality of left termination conditions computed by a termination inference tool. An experimental evaluation is reported. When termination and non-termination analysis produce complementary results for a logic procedure, then with respect to the leftmost selection rule and the language used to describe sets of atomic queries, each analysis is optimal and together, they induce a characterization of the operational behavior of the logic procedure.

Long version (algorithms and proofs included) of a paper submitted to TOPLAS

cs.PL

Improving Prolog Programs: Refactoring for Prolog

http://arxiv.org/abs/cs/0406026v1

http://arxiv.org/abs/cs/0406026v1

http://arxiv.org/pdf/cs/0406026v1

2004-06-16

2004-06-16

Refactoring is an established technique from the OO-community to restructure code: it aims at improving software readability, maintainability and extensibility. Although refactoring is not tied to the OO-paradigm in particular, its ideas have not been applied to Logic Programming until now. This paper applies the ideas of refactoring to Prolog programs. A catalogue is presented listing refactorings classified according to scope. Some of the refactorings have been adapted from the OO-paradigm, while others have been specifically designed for Prolog. Also the discrepancy between intended and operational semantics in Prolog is addressed by some of the refactorings. In addition, ViPReSS, a semi-automatic refactoring browser, is discussed and the experience with applying \vipress to a large Prolog legacy system is reported. Our main conclusion is that refactoring is not only a viable technique in Prolog but also a rather desirable one.

To appear in ICLP 2004

cs.SE

O(1) Reversible Tree Navigation Without Cycles

http://arxiv.org/abs/cs/0406014v1

http://arxiv.org/abs/cs/0406014v1

http://arxiv.org/pdf/cs/0406014v1

2004-06-07

2004-06-07

Imperative programmers often use cyclically linked trees in order to achieve O(1) navigation time to neighbours. Some logic programmers believe that cyclic terms are necessary to achieve the same in logic-based languages. An old but little-known technique provides O(1) time and space navigation without cyclic links, in the form of reversible predicates. A small modification provides O(1) amortised time and space editing.

Appeared in Theory and Practice of Logic Programming, vol. 1, no. 5, 2001

Theory and Practice of Logic Programming, vol. 1, no. 5, 2001

cs.PL

Secure Prolog-Based Mobile Code

http://arxiv.org/abs/cs/0406012v1

http://arxiv.org/abs/cs/0406012v1

http://arxiv.org/pdf/cs/0406012v1

2004-06-07

2004-06-07

LogicWeb mobile code consists of Prolog-like rules embedded in Web pages, thereby adding logic programming behaviour to those pages. Since LogicWeb programs are downloaded from foreign hosts and executed locally, there is a need to protect the client from buggy or malicious code. A security model is crucial for making LogicWeb mobile code safe to execute. This paper presents such a model, which supports programs of varying trust levels by using different resource access policies. The implementation of the model derives from an extended operational semantics for the LogicWeb language, which provides a precise meaning of safety.

Appeared in Theory and Practice of Logic Programming, vol. 1, no. 3, 2001

Theory and Practice of Logic Programming, vol. 1, no. 3, 2001

cs.PL

A Proof Theoretic Approach to Failure in Functional Logic Programming

http://arxiv.org/abs/cs/0405102v1

http://arxiv.org/abs/cs/0405102v1

http://arxiv.org/pdf/cs/0405102v1

2004-05-27

2004-05-27

How to extract negative information from programs is an important issue in logic programming. Here we address the problem for functional logic programs, from a proof-theoretic perspective. The starting point of our work is CRWL (Constructor based ReWriting Logic), a well established theoretical framework for functional logic programming, whose fundamental notion is that of non-strict non-deterministic function. We present a proof calculus, CRWLF, which is able to deduce negative information from CRWL-programs. In particular, CRWLF is able to prove finite failure of reduction within CRWL.

Appeared in Theory and Practice of Logic Programming, vol. 4, no. 1&2, 2004

Theory and Practice of Logic Programming, vol. 4, no. 1&2, 2004

cs.PL

Worst-Case Groundness Analysis Using Definite Boolean Functions

http://arxiv.org/abs/cs/0405101v1

http://arxiv.org/abs/cs/0405101v1

http://arxiv.org/pdf/cs/0405101v1

2004-05-27

2004-05-27

This note illustrates theoretical worst-case scenarios for groundness analyses obtained through abstract interpretation over the abstract domains of definite (Def) and positive (Pos) Boolean functions. For Def, an example is given for which any Def-based abstract interpretation for groundness analysis follows a chain which is exponential in the number of argument positions as well as in the number of clauses but sub-exponential in the size of the program. For Pos, we strengthen a previous result by illustrating an example for which any Pos-based abstract interpretation for groundness analysis follows a chain which is exponential in the size of the program. It remains an open problem to determine if the worst case for Def is really as bad as that for Pos.

Appeared in Theory and Practice of Logic Programming, vol. 1, no. 5, 2001

Theory and Practice of Logic Programming, vol. 1, no. 5, 2001

cs.PL

Typing constraint logic programs

http://arxiv.org/abs/cs/0405100v1

http://arxiv.org/abs/cs/0405100v1

http://arxiv.org/pdf/cs/0405100v1

2004-05-27

2004-05-27

We present a prescriptive type system with parametric polymorphism and subtyping for constraint logic programs. The aim of this type system is to detect programming errors statically. It introduces a type discipline for constraint logic programs and modules, while maintaining the capabilities of performing the usual coercions between constraint domains, and of typing meta-programming predicates, thanks to the flexibility of subtyping. The property of subject reduction expresses the consistency of a prescriptive type system w.r.t. the execution model: if a program is "well-typed", then all derivations starting from a "well-typed" goal are again "well-typed". That property is proved w.r.t. the abstract execution model of constraint programming which proceeds by accumulation of constraints only, and w.r.t. an enriched execution model with type constraints for substitutions. We describe our implementation of the system for type checking and type inference. We report our experimental results on type checking ISO-Prolog, the (constraint) libraries of Sicstus Prolog and other Prolog programs.

Appeared in Theory and Practice of Logic Programming, vol. 1, no. 6, 2001

Theory and Practice of Logic Programming, vol. 1, no. 6, 2001

cs.PL

A Coalgebraic Approach to Kleene Algebra with Tests

http://arxiv.org/abs/cs/0405097v1

http://arxiv.org/abs/cs/0405097v1

http://arxiv.org/pdf/cs/0405097v1

2004-05-26

2004-05-26

Kleene algebra with tests is an extension of Kleene algebra, the algebra of regular expressions, which can be used to reason about programs. We develop a coalgebraic theory of Kleene algebra with tests, along the lines of the coalgebraic theory of regular expressions based on deterministic automata. Since the known automata-theoretic presentation of Kleene algebra with tests does not lend itself to a coalgebraic theory, we define a new interpretation of Kleene algebra with tests expressions and a corresponding automata-theoretic presentation. One outcome of the theory is a coinductive proof principle, that can be used to establish equivalence of our Kleene algebra with tests expressions.

21 pages, 1 figure; preliminary version appeared in Proc. Workshop on Coalgebraic Methods in Computer Science (CMCS'03)

Theoretical Computer Science, 327 (1-2), 23-44 (2004)

cs.LO

Learning Hybrid Algorithms for Vehicle Routing Problems

http://arxiv.org/abs/cs/0405092v1

http://arxiv.org/abs/cs/0405092v1

http://arxiv.org/pdf/cs/0405092v1

2004-05-24

2004-05-24

This paper presents a generic technique for improving hybrid algorithms through the discovery of and tuning of meta-heuristics. The idea is to represent a family of push/pull heuristics that are based upon inserting and removing tasks in a current solution, with an algebra. We then let a learning algorithm search for the best possible algebraic term, which represents a hybrid algorithm for a given set of problems and an optimization criterion. In a previous paper, we described this algebra in detail and provided a set of preliminary results demonstrating the utility of this approach, using vehicle routing with time windows (VRPTW) as a domain example. In this paper we expand upon our results providing a more robust experimental framework and learning algorithms, and report on some new results using the standard Solomon benchmarks. In particular, we show that our learning algorithm is able to achieve results similar to the best-published algorithms using only a fraction of the CPU time. We also show that the automatic tuning of the best hybrid combination of such techniques yields a better solution than hand tuning, with considerably less effort.

Appeared in Theory and Practice of Logic Programming, vol. 1, no. 6, 2001

Theory and Practice of Logic Programming, vol. 1, no. 6, 2001

cs.PL

CLAIRE: Combining Sets, Search And Rules To Better Express Algorithms

http://arxiv.org/abs/cs/0405091v1

http://arxiv.org/abs/cs/0405091v1

http://arxiv.org/pdf/cs/0405091v1

2004-05-24

2004-05-24

This paper presents a programming language which includes paradigms that are usually associated with declarative languages, such as sets, rules and search, into an imperative (functional) language. Although these paradigms are separately well known and are available under various programming environments, the originality of the CLAIRE language comes from the tight integration, which yields interesting run-time performances, and from the richness of this combination, which yields new ways in which to express complex algorithmic patterns with few elegant lines. To achieve the opposite goals of a high abstraction level (conciseness and readability) and run-time performance (CLAIRE is used as a C++ preprocessor), we have developed two kinds of compiler: first, a pattern pre-processor handles iterations over both concrete and abstract sets (data types and program fragments), in a completely user-extensible manner; secondly, an inference compiler transforms a set of logical rules into a set of functions (demons that are used through procedural attachment).

Appeared in Theory and Practice of Logic Programming, vol. 2, no. 6, 2002

Theory and Practice of Logic Programming, vol. 2, no. 6, 2002

cs.PL

High-Level Networking With Mobile Code And First Order AND-Continuations

http://arxiv.org/abs/cs/0405088v1

http://arxiv.org/abs/cs/0405088v1

http://arxiv.org/pdf/cs/0405088v1

2004-05-24

2004-05-24

We describe a scheme for moving living code between a set of distributed processes coordinated with unification based Linda operations, and its application to building a comprehensive Logic programming based Internet programming framework. Mobile threads are implemented by capturing first order continuations in a compact data structure sent over the network. Code is fetched lazily from its original base turned into a server as the continuation executes at the remote site. Our code migration techniques, in combination with a dynamic recompilation scheme, ensure that heavily used code moves up smoothly on a speed hierarchy while volatile dynamic code is kept in a quickly updatable form. Among the examples, we describe how to build programmable client and server components (Web servers, in particular) and mobile agents.

Appeared in Theory and Practice of Logic Programming, vol. 1, no. 3, 2001

Theory and Practice of Logic Programming, vol. 1, no. 3, 2001

cs.PL

On the Expressive Power of First-Order Boolean Functions in PCF

http://arxiv.org/abs/cs/0405085v1

http://arxiv.org/abs/cs/0405085v1

http://arxiv.org/pdf/cs/0405085v1

2004-05-24

2004-05-24

Recent results of Bucciarelli show that the semilattice of degrees of parallelism of first-order boolean functions in PCF has both infinite chains and infinite antichains. By considering a simple subclass of Sieber's sequentiality relations, we identify levels in the semilattice and derive inexpressibility results concerning functions on different levels. This allows us to further explore the structure of the semilattice of degrees of parallelism: we identify semilattices characterized by simple level properties, and show the existence of new infinite hierarchies which are in a certain sense natural with respect to the levels.

23 pages

Theoretical Computer Science 266(1-2), pp. 543-567, 2001

cs.PL

A Framework for Interoperability

http://arxiv.org/abs/cs/0405084v1

http://arxiv.org/abs/cs/0405084v1

http://arxiv.org/pdf/cs/0405084v1

2004-05-23

2004-05-23

Practical implementations of high-level languages must provide access to libraries and system services that have APIs specified in a low-level language (usually C). An important characteristic of such mechanisms is the foreign-interface policy that defines how to bridge the semantic gap between the high-level language and C. For example, IDL-based tools generate code to marshal data into and out of the high-level representation according to user annotations. The design space of foreign-interface policies is large and there are pros and cons to each approach. Rather than commit to a particular policy, we choose to focus on the problem of supporting a gamut of interoperability policies. In this paper, we describe a framework for language interoperability that is expressive enough to support very efficient implementations of a wide range of different foreign-interface policies. We describe two tools that implement substantially different policies on top of our framework and present benchmarks that demonstrate their efficiency.

16 pages; 1 figure; appeared in Proceedings of the 1st International Workshop on Multi-Language Infrastructure and Interoperability (BABEL'01), ENTCS 59(1), 2001

cs.PL

The Design of a COM-Oriented Module System

http://arxiv.org/abs/cs/0405083v1

http://arxiv.org/abs/cs/0405083v1

http://arxiv.org/pdf/cs/0405083v1

2004-05-23

2004-05-23

We present in this paper the preliminary design of a module system based on a notion of components such as they are found in COM. This module system is inspired from that of Standard ML, and features first-class instances of components, first-class interfaces, and interface-polymorphic functions, as well as allowing components to be both imported from the environment and exported to the environment using simple mechanisms. The module system automates the memory management of interfaces and hides the IUnknown interface and QueryInterface mechanisms from the programmer, favoring instead a higher-level approach to handling interfaces.

15 pages; appeared in Proceedings of the Joint Modular Languages Conference (JMLC'00). LNCS 1897, pp. 104-118, 2000

cs.PL

Aspects de la Programmation d'Applications Win32 avec un Langage Fonctionnel

http://arxiv.org/abs/cs/0405082v1

http://arxiv.org/abs/cs/0405082v1

http://arxiv.org/pdf/cs/0405082v1

2004-05-23

2004-05-23

A useful programming language needs to support writing programs that take advantage of services and communication mechanisms supplied by the operating system. We examine the problem of programming native Win32 applications under Windows with Standard ML. We introduce an framework based on the IDL interface language et a minimal foreign-functions interface to explore the Win32 API et COM in the context of Standard ML.

In french, 25 pages, 3 figures. Appeared in the Proceedings of the "Journees Francophones des Langages Applicatifs" (JFLA'99), 1999

cs.PL

Reactive Programming in Standard ML

http://arxiv.org/abs/cs/0405080v1

http://arxiv.org/abs/cs/0405080v1

http://arxiv.org/pdf/cs/0405080v1

2004-05-23

2004-05-23

Reactive systems are systems that maintain an ongoing interaction with their environment, activated by receiving input events from the environment and producing output events in response. Modern programming languages designed to program such systems use a paradigm based on the notions of instants and activations. We describe a library for Standard ML that provides basic primitives for programming reactive systems. The library is a low-level system upon which more sophisticated reactive behaviors can be built, which provides a convenient framework for prototyping extensions to existing reactive languages.

11 pages; appeared in Proceedings of the IEEE International Conference on Computer Languages (ICCL'98), pp. 48-57, 1998

10.1109/ICCL.1998.674156

cs.PL

Higher-Order Concurrent Win32 Programming

http://arxiv.org/abs/cs/0405079v1

http://arxiv.org/abs/cs/0405079v1

http://arxiv.org/pdf/cs/0405079v1

2004-05-23

2004-05-23

We present a concurrent framework for Win32 programming based on Concurrent ML, a concurrent language with higher-order functions, static typing, lightweight threads and synchronous communication channels. The key points of the framework are the move from an event loop model to a threaded model for the processing of window messages, and the decoupling of controls notifications from the system messages. This last point allows us to derive a general way of writing controls that leads to easy composition, and can accommodate ActiveX Controls in a transparent way.

10 pages; appeared in Proceedings of the 3rd Usenix Windows NT Symposium, Seattle, pp. 113-122, 1999

cs.PL

Reduction Strategies in Lambda Term Normalization and their Effects on Heap Usage

http://arxiv.org/abs/cs/0405075v1

http://arxiv.org/abs/cs/0405075v1

http://arxiv.org/pdf/cs/0405075v1

2004-05-22

2004-05-22

Higher-order representations of objects such as programs, proofs, formulas and types have become important to many symbolic computation tasks. Systems that support such representations usually depend on the implementation of an intensional view of the terms of some variant of the typed lambda-calculus. Various notations have been proposed for lambda-terms to explicitly treat substitutions as basis for realizing such implementations. There are, however, several choices in the actual reduction strategies. The most common strategy utilizes such notations only implicitly via an incremental use of environments. This approach does not allow the smaller substitution steps to be intermingled with other operations of interest on lambda-terms. However, a naive strategy explicitly using such notations can also be costly: each use of the substitution propagation rules causes the creation of a new structure on the heap that is often discarded in the immediately following step. There is thus a tradeoff between these two approaches. This thesis describes the actual realization of the two approaches, discusses their tradeoffs based on this and, finally, offers an amalgamated approach that utilizes recursion in rewrite rule application but also suspends substitution operations where necessary.

This is a modified version of the master's thesis of Xiaochu Qi

cs.PL

Finite-Tree Analysis for Constraint Logic-Based Languages: The Complete Unabridged Version

http://arxiv.org/abs/cs/0404055v2

http://arxiv.org/abs/cs/0404055v2

http://arxiv.org/pdf/cs/0404055v2

2004-04-26

2004-04-27

Logic languages based on the theory of rational, possibly infinite, trees have much appeal in that rational trees allow for faster unification (due to the safe omission of the occurs-check) and increased expressivity (cyclic terms can provide very efficient representations of grammars and other useful objects). Unfortunately, the use of infinite rational trees has problems. For instance, many of the built-in and library predicates are ill-defined for such trees and need to be supplemented by run-time checks whose cost may be significant. Moreover, some widely-used program analysis and manipulation techniques are correct only for those parts of programs working over finite trees. It is thus important to obtain, automatically, a knowledge of the program variables (the finite variables) that, at the program points of interest, will always be bound to finite terms. For these reasons, we propose here a new data-flow analysis, based on abstract interpretation, that captures such information.

89 pages, 1 table

cs.PL

Constraint Logic Programming with Hereditary Harrop Formula

http://arxiv.org/abs/cs/0404053v1

http://arxiv.org/abs/cs/0404053v1

http://arxiv.org/pdf/cs/0404053v1

2004-04-26

2004-04-26

Constraint Logic Programming (CLP) and Hereditary Harrop formulas (HH) are two well known ways to enhance the expressivity of Horn clauses. In this paper, we present a novel combination of these two approaches. We show how to enrich the syntax and proof theory of HH with the help of a given constraint system, in such a way that the key property of HH as a logic programming language (namely, the existence of uniform proofs) is preserved. We also present a procedure for goal solving, showing its soundness and completeness for computing answer constraints. As a consequence of this result, we obtain a new strong completeness theorem for CLP that avoids the need to build disjunctions of computed answers, as well as a more abstract formulation of a known completeness theorem for HH.

Appeared in Theory and Practice of Logic Programming, vol. 1, no. 4, 2001. Appeared in Theory and Practice of Logic Programming, vol. 1, no. 4, 2001

cs.PL

Multi-Threading And Message Communication In Qu-Prolog

http://arxiv.org/abs/cs/0404052v1

http://arxiv.org/abs/cs/0404052v1

http://arxiv.org/pdf/cs/0404052v1

2004-04-25

2004-04-25

This paper presents the multi-threading and internet message communication capabilities of Qu-Prolog. Message addresses are symbolic and the communications package provides high-level support that completely hides details of IP addresses and port numbers as well as the underlying TCP/IP transport layer. The combination of the multi-threads and the high level inter-thread message communications provide simple, powerful support for implementing internet distributed intelligent applications.

Appeared in Theory and Practice of Logic Programming, vol. 1, no. 3, 2001

Theory and Practice of Logic Programming, vol. 1, no. 3, 2001

cs.PL

A General Framework For Lazy Functional Logic Programming With Algebraic Polymorphic Types

http://arxiv.org/abs/cs/0404050v1

http://arxiv.org/abs/cs/0404050v1

http://arxiv.org/pdf/cs/0404050v1

2004-04-24

2004-04-24

We propose a general framework for first-order functional logic programming, supporting lazy functions, non-determinism and polymorphic datatypes whose data constructors obey a set C of equational axioms. On top of a given C, we specify a program as a set R of C-based conditional rewriting rules for defined functions. We argue that equational logic does not supply the proper semantics for such programs. Therefore, we present an alternative logic which includes C-based rewriting calculi and a notion of model. We get soundness and completeness for C-based rewriting w.r.t. models, existence of free models for all programs, and type preservation results. As operational semantics, we develop a sound and complete procedure for goal solving, which is based on the combination of lazy narrowing with unification modulo C. Our framework is quite expressive for many purposes, such as solving action and change problems, or realizing the GAMMA computation model.

Appeared in Theory and Practice of Logic Programming, vol. 1, no. 2, 2001

Theory and Practice of Logic Programming, vol. 1, no. 2, 2001

cs.PL

NLOMJ--Natural Language Object Model in Java

http://arxiv.org/abs/cs/0404041v2

http://arxiv.org/abs/cs/0404041v2

http://arxiv.org/pdf/cs/0404041v2

2004-04-21

2006-02-06

In this paper we present NLOMJ--a natural language object model in Java with English as the experiment language. This modal describes the grammar elements of any permissible expression in a natural language and their complicated relations with each other with the concept "Object" in OOP(Object Oriented Programming). Directly mapped to the syntax and semantics of the natural language, it can be used in information retrieval as a linguistic method. Around the UML diagram of the NLOMJ the important classes(Sentence, Clause and Phrase) and their sub classes are introduced and their syntactic and semantic meanings are explained.

11 pages, 1 figure. Submitted to ICICP04

cs.CL

A treatment of higher-order features in logic programming

http://arxiv.org/abs/cs/0404020v1

http://arxiv.org/abs/cs/0404020v1

http://arxiv.org/pdf/cs/0404020v1

2004-04-07

2004-04-07

The logic programming paradigm provides the basis for a new intensional view of higher-order notions. This view is realized primarily by employing the terms of a typed lambda calculus as representational devices and by using a richer form of unification for probing their structures. These additions have important meta-programming applications but they also pose non-trivial implementation problems. One issue concerns the machine representation of lambda terms suitable to their intended use: an adequate encoding must facilitate comparison operations over terms in addition to supporting the usual reduction computation. Another aspect relates to the treatment of a unification operation that has a branching character and that sometimes calls for the delaying of the solution of unification problems. A final issue concerns the execution of goals whose structures become apparent only in the course of computation. These various problems are exposed in this paper and solutions to them are described. A satisfactory representation for lambda terms is developed by exploiting the nameless notation of de Bruijn as well as explicit encodings of substitutions. Special mechanisms are molded into the structure of traditional Prolog implementations to support branching in unification and carrying of unification problems over other computation steps; a premium is placed in this context on exploiting determinism and on emulating usual first-order behaviour. An extended compilation model is presented that treats higher-order unification and also handles dynamically emergent goals. The ideas described here have been employed in the Teyjus implementation of the Lambda Prolog language, a fact that is used to obtain a preliminary assessment of their efficacy.

50 pages, 4 figures, 2 tables. To appear in Theory and Practice of Logic Programming (TPLP)

cs.PL

Delimited continuations in natural language: quantification and polarity sensitivity

http://arxiv.org/abs/cs/0404006v1

http://arxiv.org/abs/cs/0404006v1

http://arxiv.org/pdf/cs/0404006v1

2004-04-05

2004-04-05

Making a linguistic theory is like making a programming language: one typically devises a type system to delineate the acceptable utterances and a denotational semantics to explain observations on their behavior. Via this connection, the programming language concept of delimited continuations can help analyze natural language phenomena such as quantification and polarity sensitivity. Using a logical metalanguage whose syntax includes control operators and whose semantics involves evaluation order, these analyses can be expressed in direct style rather than continuation-passing style, and these phenomena can be thought of as computational side effects.

10 pages

In CW'04: Proceedings of the 4th ACM SIGPLAN workshop on continuations, ed. Hayo Thielecke, 55-64. Technical report CSR-04-1, School of Computer Science, University of Birmingham (2004)

cs.CL

Schedulers and Redundancy for a Class of Constraint Propagation Rules

http://arxiv.org/abs/cs/0403037v3

http://arxiv.org/abs/cs/0403037v3

http://arxiv.org/pdf/cs/0403037v3

2004-03-23

2004-11-02

We study here schedulers for a class of rules that naturally arise in the context of rule-based constraint programming. We systematically derive a scheduler for them from a generic iteration algorithm of [Apt 2000]. We apply this study to so-called membership rules of [Apt and Monfroy 2001]. This leads to an implementation that yields a considerably better performance for these rules than their execution as standard CHR rules. Finally, we show how redundant rules can be identified and how appropriately reduced sets of rules can be computed.

25 pages, to appear in the journal "Theory and Practice of Logic Programming"

cs.DS

Phantom Types and Subtyping

http://arxiv.org/abs/cs/0403034v3

http://arxiv.org/abs/cs/0403034v3

http://arxiv.org/pdf/cs/0403034v3

2004-03-23

2006-01-29

We investigate a technique from the literature, called the phantom-types technique, that uses parametric polymorphism, type constraints, and unification of polymorphic types to model a subtyping hierarchy. Hindley-Milner type systems, such as the one found in Standard ML, can be used to enforce the subtyping relation, at least for first-order values. We show that this technique can be used to encode any finite subtyping hierarchy (including hierarchies arising from multiple interface inheritance). We formally demonstrate the suitability of the phantom-types technique for capturing first-order subtyping by exhibiting a type-preserving translation from a simple calculus with bounded polymorphism to a calculus embodying the type system of SML.

41 pages. Preliminary version appears in the Proceedings of the 2nd IFIP International Conference on Theoretical Computer Science, pp. 448--460, 2002

cs.PL

Integrating design synthesis and assembly of structured objects in a visual design language

http://arxiv.org/abs/cs/0403033v1

http://arxiv.org/abs/cs/0403033v1

http://arxiv.org/pdf/cs/0403033v1

2004-03-21

2004-03-21

Computer Aided Design systems provide tools for building and manipulating models of solid objects. Some also provide access to programming languages so that parametrised designs can be expressed. There is a sharp distinction, therefore, between building models, a concrete graphical editing activity, and programming, an abstract, textual, algorithm-construction activity. The recently proposed Language for Structured Design (LSD) was motivated by a desire to combine the design and programming activities in one language. LSD achieves this by extending a visual logic programming language to incorporate the notions of solids and operations on solids. Here we investigate another aspect of the LSD approach; namely, that by using visual logic programming as the engine to drive the parametrised assembly of objects, we also gain the powerful symbolic problem-solving capability that is the forte of logic programming languages. This allows the designer/programmer to work at a higher level, giving declarative specifications of a design in order to obtain the design descriptions. Hence LSD integrates problem solving, design synthesis, and prototype assembly in a single homogeneous programming/design environment. We demonstrate this specification-to-final-assembly capability using the masterkeying problem for designing systems of locks and keys.

20 pages, 15 figures, to be published in The Theory and Practice of Logic programming (TPLP)

cs.LO

A Comparative Study of Arithmetic Constraints on Integer Intervals

http://arxiv.org/abs/cs/0403016v1

http://arxiv.org/abs/cs/0403016v1

http://arxiv.org/pdf/cs/0403016v1

2004-03-12

2004-03-12

We propose here a number of approaches to implement constraint propagation for arithmetic constraints on integer intervals. To this end we introduce integer interval arithmetic. Each approach is explained using appropriate proof rules that reduce the variable domains. We compare these approaches using a set of benchmarks.

24 pages. To appear in "Recent Advances in Constraints, 2003" K.R. Apt, F. Fages, F. Rossi, P. Szeredi and J. Vancza, eds, LNAI 3010, Springer-Verlag, 2004

cs.PL

Specialization of Functional Logic Programs Based on Needed Narrowing

http://arxiv.org/abs/cs/0403011v1

http://arxiv.org/abs/cs/0403011v1

http://arxiv.org/pdf/cs/0403011v1

2004-03-09

2004-03-09

Many functional logic languages are based on narrowing, a unification-based goal-solving mechanism which subsumes the reduction mechanism of functional languages and the resolution principle of logic languages. Needed narrowing is an optimal evaluation strategy which constitutes the basis of modern (narrowing-based) lazy functional logic languages. In this work, we present the fundamentals of partial evaluation in such languages. We provide correctness results for partial evaluation based on needed narrowing and show that the nice properties of this strategy are essential for the specialization process. In particular, the structure of the original program is preserved by partial evaluation and, thus, the same evaluation strategy can be applied for the execution of specialized programs. This is in contrast to other partial evaluation schemes for lazy functional logic programs which may change the program structure in a negative way. Recent proposals for the partial evaluation of declarative multi-paradigm programs use (some form of) needed narrowing to perform computations at partial evaluation time. Therefore, our results constitute the basis for the correctness of such partial evaluators.

48 pages. This paper has been accepted for publication in the Journal of Theory and Practice of Logic Programming. In contrast to the journal version, this paper contains the detailed proofs of the results presented in this paper

cs.PL

Polymorphic lemmas and definitions in Lambda Prolog and Twelf

http://arxiv.org/abs/cs/0403010v1

http://arxiv.org/abs/cs/0403010v1

http://arxiv.org/pdf/cs/0403010v1

2004-03-09

2004-03-09

Lambda Prolog is known to be well-suited for expressing and implementing logics and inference systems. We show that lemmas and definitions in such logics can be implemented with a great economy of expression. We encode a higher-order logic using an encoding that maps both terms and types of the object logic (higher-order logic) to terms of the metalanguage (Lambda Prolog). We discuss both the Terzo and Teyjus implementations of Lambda Prolog. We also encode the same logic in Twelf and compare the features of these two metalanguages for our purposes.

Andrew W. Appel and Amy P. Felty, Polymorphic Lemmas and Definitions in Lambda Prolog and Twelf, Theory and Practice of Logic Programming, 4(1&2):1-39, January & March 2004

cs.LO

A Tribute to Alain Colmerauer

http://arxiv.org/abs/cs/0402058v1

http://arxiv.org/abs/cs/0402058v1

http://arxiv.org/pdf/cs/0402058v1

2004-02-25

2004-02-25

The paper describes the contributions of Alain Colmerauer to the areas of logic programs (LP) and constraint logic programs (CLP).

9 pages

cs.PL

Transformation Rules for Locally Stratified Constraint Logic Programs

http://arxiv.org/abs/cs/0402048v1

http://arxiv.org/abs/cs/0402048v1

http://arxiv.org/pdf/cs/0402048v1

2004-02-20

2004-02-20

We propose a set of transformation rules for constraint logic programs with negation. We assume that every program is locally stratified and, thus, it has a unique perfect model. We give sufficient conditions which ensure that the proposed set of transformation rules preserves the perfect model of the programs. Our rules extend in some respects the rules for logic programs and constraint logic programs already considered in the literature and, in particular, they include a rule for unfolding a clause with respect to a negative literal.

To appear in: M. Bruynooghe, K.-K. Lau (Eds.) Program Development in Computational Logic, Lecture Notes in Computer Science, Springer

cs.PL

The UPLNC Compiler: Design and Implementation

http://arxiv.org/abs/cs/0402043v1

http://arxiv.org/abs/cs/0402043v1

http://arxiv.org/pdf/cs/0402043v1

2004-02-18

2004-02-18

The implementation of the compiler of the UPLNC language is presented with a full source code listing.

134 pages, 2 figures, LaTeX

cs.PL

A system for reflection in C++

http://arxiv.org/abs/cs/0401024v1

http://arxiv.org/abs/cs/0401024v1

http://arxiv.org/pdf/cs/0401024v1

2004-01-27

2004-01-27

Object-oriented programming languages such as Java and Objective C have become popular for implementing agent-based and other object-based simulations since objects in those languages can {\em reflect} (i.e. make runtime queries of an object's structure). This allows, for example, a fairly trivial {\em serialisation} routine (conversion of an object into a binary representation that can be stored or passed over a network) to be written. However C++ does not offer this ability, as type information is thrown away at compile time. Yet C++ is often a preferred development environment, whether for performance reasons or for its expressive features such as operator overloading. In this paper, we present the {\em Classdesc} system which brings many of the benefits of object reflection to C++.

Proceedings AUUG 2001: Always on and Everywhere, 207. ISBN 0957753225

cs.PL

Enhanced sharing analysis techniques: a comprehensive evaluation

http://arxiv.org/abs/cs/0401022v1

http://arxiv.org/abs/cs/0401022v1

http://arxiv.org/pdf/cs/0401022v1

2004-01-26

2004-01-26

Sharing, an abstract domain developed by D. Jacobs and A. Langen for the analysis of logic programs, derives useful aliasing information. It is well-known that a commonly used core of techniques, such as the integration of Sharing with freeness and linearity information, can significantly improve the precision of the analysis. However, a number of other proposals for refined domain combinations have been circulating for years. One feature that is common to these proposals is that they do not seem to have undergone a thorough experimental evaluation even with respect to the expected precision gains. In this paper we experimentally evaluate: helping Sharing with the definitely ground variables found using Pos, the domain of positive Boolean formulas; the incorporation of explicit structural information; a full implementation of the reduced product of Sharing and Pos; the issue of reordering the bindings in the computation of the abstract mgu; an original proposal for the addition of a new mode recording the set of variables that are deemed to be ground or free; a refined way of using linearity to improve the analysis; the recovery of hidden information in the combination of Sharing with freeness information. Finally, we discuss the issue of whether tracking compoundness allows the computation of more sharing information.

43 pages, 10 tables, to appear on "Theory and Practice of Logic Programming"

cs.PL

A correct, precise and efficient integration of set-sharing, freeness and linearity for the analysis of finite and rational tree languages

http://arxiv.org/abs/cs/0401021v1

http://arxiv.org/abs/cs/0401021v1

http://arxiv.org/pdf/cs/0401021v1

2004-01-26

2004-01-26

It is well-known that freeness and linearity information positively interact with aliasing information, allowing both the precision and the efficiency of the sharing analysis of logic programs to be improved. In this paper we present a novel combination of set-sharing with freeness and linearity information, which is characterized by an improved abstract unification operator. We provide a new abstraction function and prove the correctness of the analysis for both the finite tree and the rational tree cases. Moreover, we show that the same notion of redundant information as identified in (Bagnara et al. 2002; Zaffanella et al. 2002) also applies to this abstract domain combination: this allows for the implementation of an abstract unification operator running in polynomial time and achieving the same precision on all the considered observable properties.

35 pages, 1 table, to appear on "Theory and Practice of Logic Programming"

cs.PL

Generalized Strong Preservation by Abstract Interpretation

http://arxiv.org/abs/cs/0401016v3

http://arxiv.org/abs/cs/0401016v3

http://arxiv.org/pdf/cs/0401016v3

2004-01-21

2006-03-14

Standard abstract model checking relies on abstract Kripke structures which approximate concrete models by gluing together indistinguishable states, namely by a partition of the concrete state space. Strong preservation for a specification language L encodes the equivalence of concrete and abstract model checking of formulas in L. We show how abstract interpretation can be used to design abstract models that are more general than abstract Kripke structures. Accordingly, strong preservation is generalized to abstract interpretation-based models and precisely related to the concept of completeness in abstract interpretation. The problem of minimally refining an abstract model in order to make it strongly preserving for some language L can be formulated as a minimal domain refinement in abstract interpretation in order to get completeness w.r.t. the logical/temporal operators of L. It turns out that this refined strongly preserving abstract model always exists and can be characterized as a greatest fixed point. As a consequence, some well-known behavioural equivalences, like bisimulation, simulation and stuttering, and their corresponding partition refinement algorithms can be elegantly characterized in abstract interpretation as completeness properties and refinements.

cs.LO

Distributed WWW Programming using (Ciao-)Prolog and the PiLLoW library

http://arxiv.org/abs/cs/0312031v1

http://arxiv.org/abs/cs/0312031v1

http://arxiv.org/pdf/cs/0312031v1

2003-12-16

2003-12-16

We discuss from a practical point of view a number of issues involved in writing distributed Internet and WWW applications using LP/CLP systems. We describe PiLLoW, a public-domain Internet and WWW programming library for LP/CLP systems that we have designed in order to simplify the process of writing such applications. PiLLoW provides facilities for accessing documents and code on the WWW; parsing, manipulating and generating HTML and XML structured documents and data; producing HTML forms; writing form handlers and CGI-scripts; and processing HTML/XML templates. An important contribution of PiLLoW is to model HTML/XML code (and, thus, the content of WWW pages) as terms. The PiLLoW library has been developed in the context of the Ciao Prolog system, but it has been adapted to a number of popular LP/CLP systems, supporting most of its functionality. We also describe the use of concurrency and a high-level model of client-server interaction, Ciao Prolog's active modules, in the context of WWW programming. We propose a solution for client-side downloading and execution of Prolog code, using generic browsers. Finally, we also provide an overview of related work on the topic.

32 pages, 4 figures

Theory and Practice of Logic Programming, Vol 1(3), 2001, 251-282

cs.DC

An Open Ended Tree

http://arxiv.org/abs/cs/0312027v1

http://arxiv.org/abs/cs/0312027v1

http://arxiv.org/pdf/cs/0312027v1

2003-12-15

2003-12-15

An open ended list is a well known data structure in Prolog programs. It is frequently used to represent a value changing over time, while this value is referred to from several places in the data structure of the application. A weak point in this technique is that the time complexity is linear in the number of updates to the value represented by the open ended list. In this programming pearl we present a variant of the open ended list, namely an open ended tree, with an update and access time complexity logarithmic in the number of updates to the value.

TPLP Vol 3(3) 2003 pp 377-385

cs.PL

Speedup of Logic Programs by Binarization and Partial Deduction

http://arxiv.org/abs/cs/0312026v1

http://arxiv.org/abs/cs/0312026v1

http://arxiv.org/pdf/cs/0312026v1

2003-12-15

2003-12-15

Binary logic programs can be obtained from ordinary logic programs by a binarizing transformation. In most cases, binary programs obtained this way are less efficient than the original programs. (Demoen, 1992) showed an interesting example of a logic program whose computational behaviour was improved when it was transformed to a binary program and then specialized by partial deduction. The class of B-stratifiable logic programs is defined. It is shown that for every B-stratifiable logic program, binarization and subsequent partial deduction produce a binary program which does not contain variables for continuations introduced by binarization. Such programs usually have a better computational behaviour than the original ones. Both binarization and partial deduction can be easily automated. A comparison with other related approaches to program transformation is given.

15 pages; to appear in Theory and Practice of Logic Programming

cs.PL

Inferring Termination Conditions for Logic Programs using Backwards Analysis

http://arxiv.org/abs/cs/0312023v1

http://arxiv.org/abs/cs/0312023v1

http://arxiv.org/pdf/cs/0312023v1

2003-12-12

2003-12-12

This paper focuses on the inference of modes for which a logic program is guaranteed to terminate. This generalises traditional termination analysis where an analyser tries to verify termination for a specified mode. Our contribution is a methodology in which components of traditional termination analysis are combined with backwards analysis to obtain an analyser for termination inference. We identify a condition on the components of the analyser which guarantees that termination inference will infer all modes which can be checked to terminate. The application of this methodology to enhance a traditional termination analyser to perform also termination inference is demonstrated.

cs.PL

Derivation of Efficient Logic Programs by Specialization and Reduction of Nondeterminism

http://arxiv.org/abs/cs/0311044v1

http://arxiv.org/abs/cs/0311044v1

http://arxiv.org/pdf/cs/0311044v1

2003-11-27

2003-11-27

Program specialization is a program transformation methodology which improves program efficiency by exploiting the information about the input data which are available at compile time. We show that current techniques for program specialization based on partial evaluation do not perform well on nondeterministic logic programs. We then consider a set of transformation rules which extend the ones used for partial evaluation, and we propose a strategy for guiding the application of these extended rules so to derive very efficient specialized programs. The efficiency improvements which sometimes are exponential, are due to the reduction of nondeterminism and to the fact that the computations which are performed by the initial programs in different branches of the computation trees, are performed by the specialized programs within single branches. In order to reduce nondeterminism we also make use of mode information for guiding the unfolding process. To exemplify our technique, we show that we can automatically derive very efficient matching programs and parsers for regular languages. The derivations we have performed could not have been done by previously known partial evaluation techniques.

74 pages. To appear in: Higher-Order and Symbolic Computation (Special Issue in Honor of Bob Paige)

cs.PL

Combining Logic Programs and Monadic Second Order Logics by Program Transformation

http://arxiv.org/abs/cs/0311043v1

http://arxiv.org/abs/cs/0311043v1

http://arxiv.org/pdf/cs/0311043v1

2003-11-27

2003-11-27

We present a program synthesis method based on unfold/fold transformation rules which can be used for deriving terminating definite logic programs from formulas of the Weak Monadic Second Order theory of one successor (WS1S). This synthesis method can also be used as a proof method which is a decision procedure for closed formulas of WS1S. We apply our synthesis method for translating CLP(WS1S) programs into logic programs and we use it also as a proof method for verifying safety properties of infinite state systems.

25 pages. Full version of a paper that appears in: M. Leuschel (ed.) Proceedings of LOPSTR'02, Twelfth International Workshop on Logic-based Program Development and Transformation, Madrid, Spain, 17-20 Sept. 2002. Lecture Notes in Computer Science 2664. Springer-Verlag Berlin Heidelberg, 2003, pp. 160-181

cs.PL

Idempotent I/O for safe time travel

http://arxiv.org/abs/cs/0311040v1

http://arxiv.org/abs/cs/0311040v1

http://arxiv.org/pdf/cs/0311040v1

2003-11-26

2003-11-26

Debuggers for logic programming languages have traditionally had a capability most other debuggers did not: the ability to jump back to a previous state of the program, effectively travelling back in time in the history of the computation. This ``retry'' capability is very useful, allowing programmers to examine in detail a part of the computation that they previously stepped over. Unfortunately, it also creates a problem: while the debugger may be able to restore the previous values of variables, it cannot restore the part of the program's state that is affected by I/O operations. If the part of the computation being jumped back over performs I/O, then the program will perform these I/O operations twice, which will result in unwanted effects ranging from the benign (e.g. output appearing twice) to the fatal (e.g. trying to close an already closed file). We present a simple mechanism for ensuring that every I/O action called for by the program is executed at most once, even if the programmer asks the debugger to travel back in time from after the action to before the action. The overhead of this mechanism is low enough and can be controlled well enough to make it practical to use it to debug computations that do significant amounts of I/O.

In M. Ronsse, K. De Bosschere (eds), proceedings of the Fifth International Workshop on Automated Debugging (AADEBUG 2003), September 2003, Ghent. cs.SE/0309027

cs.PL

A Very Short Self-Interpreter

http://arxiv.org/abs/cs/0311032v1

http://arxiv.org/abs/cs/0311032v1

http://arxiv.org/pdf/cs/0311032v1

2003-11-21

2003-11-21

In this paper we would like to present a very short (possibly the shortest) self-interpreter, based on a simplistic Turing-complete imperative language. This interpreter explicitly processes the statements of the language, which means the interpreter constitutes a description of the language inside that same language. The paper does not require any specific knowledge; however, experience in programming and a vivid imagination are beneficial.

cs.PL

Staging Transformations for Multimodal Web Interaction Management

http://arxiv.org/abs/cs/0311029v1

http://arxiv.org/abs/cs/0311029v1

http://arxiv.org/pdf/cs/0311029v1

2003-11-20

2003-11-20

Multimodal interfaces are becoming increasingly ubiquitous with the advent of mobile devices, accessibility considerations, and novel software technologies that combine diverse interaction media. In addition to improving access and delivery capabilities, such interfaces enable flexible and personalized dialogs with websites, much like a conversation between humans. In this paper, we present a software framework for multimodal web interaction management that supports mixed-initiative dialogs between users and websites. A mixed-initiative dialog is one where the user and the website take turns changing the flow of interaction. The framework supports the functional specification and realization of such dialogs using staging transformations -- a theory for representing and reasoning about dialogs based on partial input. It supports multiple interaction interfaces, and offers sessioning, caching, and co-ordination functions through the use of an interaction manager. Two case studies are presented to illustrate the promise of this approach.

Describes framework and software architecture for multimodal web interaction management

cs.IR

The Chameleon Type Debugger (Tool Demonstration)

http://arxiv.org/abs/cs/0311023v1

http://arxiv.org/abs/cs/0311023v1

http://arxiv.org/pdf/cs/0311023v1

2003-11-17

2003-11-17

In this tool demonstration, we give an overview of the Chameleon type debugger. The type debugger's primary use is to identify locations within a source program which are involved in a type error. By further examining these (potentially) problematic program locations, users gain a better understanding of their program and are able to work towards the actual mistake which was the cause of the type error. The debugger is interactive, allowing the user to provide additional information to narrow down the search space. One of the novel aspects of the debugger is the ability to explain erroneous-looking types. In the event that an unexpected type is inferred, the debugger can highlight program locations which contributed to that result. Furthermore, due to the flexible constraint-based foundation that the debugger is built upon, it can naturally handle advanced type system features such as Haskell's type classes and functional dependencies.

In M. Ronsse, K. De Bosschere (eds), proceedings of the Fifth International Workshop on Automated Debugging (AADEBUG 2003), September 2003, Ghent. cs.SE/0309027

cs.PL

Generic and Efficient Program Monitoring by trace analysis

http://arxiv.org/abs/cs/0311016v1

http://arxiv.org/abs/cs/0311016v1

http://arxiv.org/pdf/cs/0311016v1

2003-11-14

2003-11-14

Program execution monitoring consists of checking whole executions for given properties in order to collect global run-time information. Monitoring is very useful to maintain programs. However, application developers face the following dilemma: either they use existing tools which never exactly fit their needs, or they invest a lot of effort to implement monitoring code. In this article we argue that, when an event-oriented tracer exists, the compiler developers can enable the application developers to easily code their own, relevant, monitors which will run efficiently. We propose a high-level operator, called foldt, which operates on execution traces. One of the key advantages of our approach is that it allows a clean separation of concerns; the definition of monitors is neither intertwined in the user source code nor in the language compiler. We give a number of applications of the foldt operator to compute monitors for Mercury program executions: execution profiles, graphical abstract views, and two test coverage measurements. Each example is implemented by a few simple lines of Mercury. Detailed measurements show acceptable performance of the basic mechanism of foldt for executions of several millions of execution events.

E. Jahier and M. Ducass'e "Generic Program Monitoring by Trace Analysis" in the Theory and Practice of Logic Programming journal, Volume 2 part 4&5, pp 613-645, September 2002, Special Issue Program Development, Cambridge University Press

cs.PL

Computing Convex Hulls with a Linear Solver

http://arxiv.org/abs/cs/0311002v1

http://arxiv.org/abs/cs/0311002v1

http://arxiv.org/pdf/cs/0311002v1

2003-11-04

2003-11-04

A programming tactic involving polyhedra is reported that has been widely applied in the polyhedral analysis of (constraint) logic programs. The method enables the computations of convex hulls that are required for polyhedral analysis to be coded with linear constraint solving machinery that is available in many Prolog systems. To appear in Theory and Practice of Logic Programming (TPLP)

13 pages, 1 figure

cs.PL

A Monitoring Language for Run Time and Post-Mortem Behavior Analysis and Visualization

http://arxiv.org/abs/cs/0310025v1

http://arxiv.org/abs/cs/0310025v1

http://arxiv.org/pdf/cs/0310025v1

2003-10-14

2003-10-14

UFO is a new implementation of FORMAN, a declarative monitoring language, in which rules are compiled into execution monitors that run on a virtual machine supported by the Alamo monitor architecture.

In M. Ronsse, K. De Bosschere (eds), proceedings of the Fifth International Workshop on Automated Debugging (AADEBUG 2003), September 2003, Ghent. cs.SE/0309027

cs.SE

Pure Prolog Execution in 21 Rules

http://arxiv.org/abs/cs/0310020v1

http://arxiv.org/abs/cs/0310020v1

http://arxiv.org/pdf/cs/0310020v1

2003-10-10

2003-10-10

A simple mathematical definition of the 4-port model for pure Prolog is given. The model combines the intuition of ports with a compact representation of execution state. Forward and backward derivation steps are possible. The model satisfies a modularity claim, making it suitable for formal reasoning.

15 pages. Appeared in Proc. of the 5th Workshop on Rule-Based Constraint Reasoning and Programming (RCoRP'03), within CP'03, Kinsale, September 2003

cs.PL

A uniform approach to constraint-solving for lists, multisets, compact lists, and sets

http://arxiv.org/abs/cs/0309045v1

http://arxiv.org/abs/cs/0309045v1

http://arxiv.org/pdf/cs/0309045v1

2003-09-24

2003-09-24

Lists, multisets, and sets are well-known data structures whose usefulness is widely recognized in various areas of Computer Science. These data structures have been analyzed from an axiomatic point of view with a parametric approach in (*) where the relevant unification algorithms have been developed. In this paper we extend these results considering more general constraints including not only equality but also membership constraints as well as their negative counterparts. (*) A. Dovier, A. Policriti, and G. Rossi. A uniform axiomatic view of lists, multisets, and sets, and the relevant unification algorithms. Fundamenta Informaticae, 36(2/3):201--234, 1998.

27 pages, 11 figures

cs.PL

cTI: A constraint-based termination inference tool for ISO-Prolog

http://arxiv.org/abs/cs/0309028v1

http://arxiv.org/abs/cs/0309028v1

http://arxiv.org/pdf/cs/0309028v1

2003-09-16

2003-09-16

We present cTI, the first system for universal left-termination inference of logic programs. Termination inference generalizes termination analysis and checking. Traditionally, a termination analyzer tries to prove that a given class of queries terminates. This class must be provided to the system, for instance by means of user annotations. Moreover, the analysis must be redone every time the class of queries of interest is updated. Termination inference, in contrast, requires neither user annotations nor recomputation. In this approach, terminating classes for all predicates are inferred at once. We describe the architecture of cTI and report an extensive experimental evaluation of the system covering many classical examples from the logic programming termination literature and several Prolog programs of respectable size and complexity.

16 pages, 3 tables, to appear on "Theory and Practice of Logic Programming"

cs.PL

Proceedings of the Fifth International Workshop on Automated Debugging (AADEBUG 2003)

http://arxiv.org/abs/cs/0309027v4

http://arxiv.org/abs/cs/0309027v4

http://arxiv.org/pdf/cs/0309027v4

2003-09-15

2004-12-21

Over the past decades automated debugging has seen major achievements. However, as debugging is by necessity attached to particular programming paradigms, the results are scattered. To alleviate this problem, the Automated and Algorithmic Debugging workshop (AADEBUG for short) was organised in 1993 in Link"oping (Sweden). As this workshop proved to be successful, subsequent workshops have been organised in 1995 (Saint-Malo, France), 1997 (again in Link"oping, Sweden) and 2000 (Munich, Germany). In 2003, the workshop is organised in Ghent, Belgium, the proceedings of which you are reading right now.

Workshop homepage at http://www.elis.UGent.be/aadebug2003/

cs.SE

Model Checking Linear Logic Specifications

http://arxiv.org/abs/cs/0309003v1

http://arxiv.org/abs/cs/0309003v1

http://arxiv.org/pdf/cs/0309003v1

2003-09-01

2003-09-01

The overall goal of this paper is to investigate the theoretical foundations of algorithmic verification techniques for first order linear logic specifications. The fragment of linear logic we consider in this paper is based on the linear logic programming language called LO enriched with universally quantified goal formulas. Although LO was originally introduced as a theoretical foundation for extensions of logic programming languages, it can also be viewed as a very general language to specify a wide range of infinite-state concurrent systems. Our approach is based on the relation between backward reachability and provability highlighted in our previous work on propositional LO programs. Following this line of research, we define here a general framework for the bottom-up evaluation of first order linear logic specifications. The evaluation procedure is based on an effective fixpoint operator working on a symbolic representation of infinite collections of first order linear logic formulas. The theory of well quasi-orderings can be used to provide sufficient conditions for the termination of the evaluation of non trivial fragments of first order linear logic.

53 pages, 12 figures "Under consideration for publication in Theory and Practice of Logic Programming"

cs.PL

On Applying Or-Parallelism and Tabling to Logic Programs

http://arxiv.org/abs/cs/0308007v1

http://arxiv.org/abs/cs/0308007v1

http://arxiv.org/pdf/cs/0308007v1

2003-08-04

2003-08-04

The past years have seen widening efforts at increasing Prolog's declarativeness and expressiveness. Tabling has proved to be a viable technique to efficiently overcome SLD's susceptibility to infinite loops and redundant subcomputations. Our research demonstrates that implicit or-parallelism is a natural fit for logic programs with tabling. To substantiate this belief, we have designed and implemented an or-parallel tabling engine -- OPTYap -- and we used a shared-memory parallel machine to evaluate its performance. To the best of our knowledge, OPTYap is the first implementation of a parallel tabling engine for logic programming systems. OPTYap builds on Yap's efficient sequential Prolog engine. Its execution model is based on the SLG-WAM for tabling, and on the environment copying for or-parallelism. Preliminary results indicate that the mechanisms proposed to parallelize search in the context of SLD resolution can indeed be effectively and naturally generalized to parallelize tabled computations, and that the resulting systems can achieve good performance on shared-memory parallel machines. More importantly, it emphasizes our belief that through applying or-parallelism and tabling to logic programs the range of applications for Logic Programming can be increased.

45 pages, 12 figures, to appear in the journal of Theory and Practice of Logic Programming (TPLP)

cs.PL

Transformations of Logic Programs with Goals as Arguments

http://arxiv.org/abs/cs/0307022v2

http://arxiv.org/abs/cs/0307022v2

http://arxiv.org/pdf/cs/0307022v2

2003-07-09

2004-02-20

We consider a simple extension of logic programming where variables may range over goals and goals may be arguments of predicates. In this language we can write logic programs which use goals as data. We give practical evidence that, by exploiting this capability when transforming programs, we can improve program efficiency. We propose a set of program transformation rules which extend the familiar unfolding and folding rules and allow us to manipulate clauses with goals which occur as arguments of predicates. In order to prove the correctness of these transformation rules, we formally define the operational semantics of our extended logic programming language. This semantics is a simple variant of LD-resolution. When suitable conditions are satisfied this semantics agrees with LD-resolution and, thus, the programs written in our extended language can be run by ordinary Prolog systems. Our transformation rules are shown to preserve the operational semantics and termination.

51 pages. Full version of a paper that will appear in Theory and Practice of Logic Programming, Cambridge University Press, UK

cs.PL

Distributive Computability

http://arxiv.org/abs/cs/0306136v1

http://arxiv.org/abs/cs/0306136v1

http://arxiv.org/pdf/cs/0306136v1

2003-06-27

2003-06-27

This thesis presents a series of theoretical results and practical realisations about the theory of computation in distributive categories. Distributive categories have been proposed as a foundational tool for Computer Science in the last years, starting from the papers of R.F.C. Walters. We shall focus on two major topics: distributive computability, i.e., a generalized theory of computability based on distributive categories, and the Imp(G) language, which is a language based on the syntax of distributive categories. The link between the former and the latter is that the functions computed by Imp(G) programs are exactly the distributively computable functions.

cs.LO

Quantum Domain Theory - Definitions and Applications

http://arxiv.org/abs/quant-ph/0306077v1

http://arxiv.org/abs/quant-ph/0306077v1

http://arxiv.org/pdf/quant-ph/0306077v1

2003-06-11

2003-06-11

Classically domain theory is a rigourous mathematical structure to describe denotational semantics for programming languages and to study the computability of partial functions. Recently, the application of domain theory has also been extended to the quantum setting. In this note we review these results and we present some new thoughts in this field.

quant-ph

Quanta: a Language for Modeling and Manipulating Information Structures

http://arxiv.org/abs/cs/0306038v1

http://arxiv.org/abs/cs/0306038v1

http://arxiv.org/pdf/cs/0306038v1

2003-06-09

2003-06-09

We present a theory for modeling the structure of information and a language (Quanta) expressing the theory. Unlike Shannon's information theory, which focuses on the amount of information in an information system, we focus on the structure of the information in the system. For example, we can model the information structure corresponding to an algorithm or a physical process such as the structure of a quantum interaction. After a brief discussion of the relation between an evolving state-system and an information structure, we develop an algebra of information pieces (infons) to represent the structure of systems where descriptions of complex systems are constructed from expressions involving descriptions of simpler information systems. We map the theory to the Von Neumann computing model of sequences/conditionals/repetitions, and to the class/object theory of object-oriented programming (OOP).

cs.LO

Minimum Model Semantics for Logic Programs with Negation-as-Failure

http://arxiv.org/abs/cs/0306017v1

http://arxiv.org/abs/cs/0306017v1

http://arxiv.org/pdf/cs/0306017v1

2003-06-03

2003-06-03

We give a purely model-theoretic characterization of the semantics of logic programs with negation-as-failure allowed in clause bodies. In our semantics the meaning of a program is, as in the classical case, the unique minimum model in a program-independent ordering. We use an expanded truth domain that has an uncountable linearly ordered set of truth values between False (the minimum element) and True (the maximum), with a Zero element in the middle. The truth values below Zero are ordered like the countable ordinals. The values above Zero have exactly the reverse order. Negation is interpreted as reflection about Zero followed by a step towards Zero; the only truth value that remains unaffected by negation is Zero. We show that every program has a unique minimum model M_P, and that this model can be constructed with a T_P iteration which proceeds through the countable ordinals. Furthermore, we demonstrate that M_P can also be obtained through a model intersection construction which generalizes the well-known model intersection theorem for classical logic programming. Finally, we show that by collapsing the true and false values of the infinite-valued model M_P to (the classical) True and False, we obtain a three-valued model identical to the well-founded one.

28 pages

ACM Trans. Comput. Log. 6(2): 441-467 (2005)

cs.LO

A Development Calculus for Specifications

http://arxiv.org/abs/cs/0303021v2

http://arxiv.org/abs/cs/0303021v2

http://arxiv.org/pdf/cs/0303021v2

2003-03-21

2003-04-02

A first order inference system, called R-calculus, is defined to develop the specifications. It is used to eliminate the laws which is not consistent with the user's requirements. The R-calculus consists of the structural rules, an axiom, a cut rule, and the rules for logical connectives. Some examples are given to demonstrate the usage of the R-calculus. The properties about reachability and completeness of the R-calculus are formally defined and are proved.

14 pages with some minor errors in the original version corrected

cs.LO

Recursive function templates as a solution of linear algebra expressions in C++

http://arxiv.org/abs/cs/0302026v1

http://arxiv.org/abs/cs/0302026v1

http://arxiv.org/pdf/cs/0302026v1

2003-02-19

2003-02-19

The article deals with a kind of recursive function templates in C++, where the recursion is realized corresponding template parameters to achieve better computational performance. Some specialization of these template functions ends the recursion and can be implemented using optimized hardware dependent or independent routines. The method is applied in addition to the known expression templates technique to solve linear algebra expressions with the help of the BLAS library. The whole implementation produces a new library, which keeps object-oriented benefits and has a higher computational speed represented in the tests.

Latex2e, 8 pages, 3 figures

cs.MS

Cg in Two Pages

http://arxiv.org/abs/cs/0302013v1

http://arxiv.org/abs/cs/0302013v1

http://arxiv.org/pdf/cs/0302013v1

2003-02-12

2003-02-12

Cg is a language for programming GPUs. This paper describes Cg briefly.

2 pages

cs.GR

Unique Pattern Matching in Strings

http://arxiv.org/abs/cs/0302004v1

http://arxiv.org/abs/cs/0302004v1

http://arxiv.org/pdf/cs/0302004v1

2003-02-03

2003-02-03

Regular expression patterns are a key feature of document processing languages like Perl and XDuce. It is in this context that the first and longest match policies have been proposed to disambiguate the pattern matching process. We formally define a matching semantics with these policies and show that the generally accepted method of simulating longest match by first match and recursion is incorrect. We continue by solving the associated type inference problem, which consists in calculating for every subexpression the set of words the subexpression can still match when these policies are in effect, and show how this algorithm can be used to efficiently implement the matching process.

22 pages

cs.PL

Subclassing errors, OOP, and practically checkable rules to prevent them

http://arxiv.org/abs/cs/0301032v1

http://arxiv.org/abs/cs/0301032v1

http://arxiv.org/pdf/cs/0301032v1

2003-01-28

2003-01-28

This paper considers an example of Object-Oriented Programming (OOP) leading to subtle errors that break separation of interface and implementations. A comprehensive principle that guards against such errors is undecidable. The paper introduces a set of mechanically verifiable rules that prevent these insidious problems. Although the rules seem restrictive, they are powerful and expressive, as we show on several familiar examples. The rules contradict both the spirit and the letter of the OOP. The present examples as well as available theoretical and experimental results pose a question if OOP is conducive to software development at all.

10 pages, 1 LaTeX file; accompanying C++ and Haskell code and compilation instructions

Proc. "Monterey Workshop 2001: Engineering Automation for Software Intensive System Integration," sponsored by ONR/AFOSR/ARO/DARPA. June 18-22, 2001, Monterey, CA. -- pp. 33-42

cs.PL

Flavor: A Language for Media Representation

http://arxiv.org/abs/cs/0301003v1

http://arxiv.org/abs/cs/0301003v1

http://arxiv.org/pdf/cs/0301003v1

2003-01-07

2003-01-07

Flavor (Formal Language for Audio-Visual Object Representation) has been created as a language for describing coded multimedia bitstreams in a formal way so that the code for reading and writing bitstreams can be automatically generated. It is an extension of C++ and Java, in which the typing system incorporates bitstream representation semantics. This allows describing in a single place both the in-memory representation of data as well as their bitstream-level (compressed) representation. Flavor also comes with a translator that automatically generates standard C++ or Java code from the Flavor source code so that direct access to compressed multimedia information by application developers can be achieved with essentially zero programming. Flavor has gone through many enhancements and this paper fully describes the latest version of the language and the translator. The software has been made into an open source project as of Version 4.1, and the latest downloadable Flavor package is available at http://flavor.sourceforge.net.

20 pages and 15 figures

cs.PL