title
stringlengths 4
246
| id
stringlengths 32
39
| arxiv_url
stringlengths 32
39
| pdf_url
stringlengths 32
39
| published_date
stringlengths 10
10
| updated_date
stringlengths 10
10
| authors
sequencelengths 1
535
| affiliations
sequencelengths 1
535
| summary
stringlengths 23
3.54k
| comment
stringlengths 0
762
| journal_ref
stringlengths 0
545
| doi
stringlengths 0
151
| primary_category
stringclasses 156
values | categories
sequencelengths 1
11
|
---|---|---|---|---|---|---|---|---|---|---|---|---|---|
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 | [
"Gianluca Amato",
"Francesca Scozzari"
] | [
"",
""
] | 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 | [
"cs.PL",
"cs.LO",
"F.3.2; D.1.6"
] |
|
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 | [
"Phan Minh Dung",
"Do Duc Hanh",
"Phan Minh Thang"
] | [
"",
"",
""
] | 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 | [
"cs.LO",
"cs.MA",
"cs.PL",
"F.4.1; I.2.3; I.2.11"
] |
||
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 | [
"Arie van Deursen",
"Marius Marin",
"Leon Moonen"
] | [
"",
"",
""
] | 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 | [
"cs.SE",
"cs.PL",
"D.2.7; D.2.5; D.1.5"
] |
||
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 | [
"J. K. Vizzotto",
"T. Altenkirch",
"A. Sabry"
] | [
"",
"",
""
] | 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 | [
"quant-ph",
"cs.PL"
] |
||
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 | [
"W. Drabent",
"M. Milkowska"
] | [
"",
""
] | 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 | [
"cs.LO",
"cs.PL",
"F.3.1; D.1.6; D.2.4"
] |
|
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 | [
"Tom Schrijvers",
"Thom Fruehwirth"
] | [
"",
""
] | 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 | [
"cs.PL",
"cs.CC",
"cs.DS",
"cs.PF"
] |
||
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 | [
"David H. Lorenz",
"Therapon Skotiniotis"
] | [
"",
""
] | 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 | [
"cs.SE",
"cs.PL",
"D.2.2, D.2.3, D.2.4"
] |
|||
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 | [
"Roberto Bagnara",
"Patricia M. Hill",
"Elena Mazzi",
"Enea Zaffanella"
] | [
"",
"",
"",
""
] | 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 | [
"cs.PL",
"F.3.2"
] |
|||
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 | [
"Hai-Feng Guo",
"Gopal Gupta"
] | [
"",
""
] | 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 | [
"cs.PL",
"cs.AI",
"cs.LO"
] |
||
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 | [
"Catherine Oriat"
] | [
""
] | 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 | [
"cs.PL",
"ACM: D.2 ; D.2.5"
] |
|||
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 | [
"Ignatios Souvatzis"
] | [
""
] | 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 | [
"cs.DC",
"cs.PL",
"D.1.3; D.3.4"
] |
|
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 | [
"Armin Wolf"
] | [
""
] | 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 | [
"cs.AI",
"cs.PL",
"I.1.4"
] |
||
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 | [
"Krzysztof Worytkiewicz"
] | [
""
] | 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 | [
"cs.PL",
"cs.DM"
] |
|||
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 | [
"Viktor Kuncak",
"Martin Rinard"
] | [
"",
""
] | 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 | [
"cs.LO",
"cs.PL",
"cs.SE"
] |
||
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 | [
"Maria Garcia de la Banda",
"Warwick Harvey",
"Kim Marriott",
"Peter J. Stuckey",
"Bart Demoen"
] | [
"",
"",
"",
"",
""
] | 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 | [
"cs.PL",
"D.3.2; F.3.2"
] |
|
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 | [
"Slim Abdennadher",
"Christophe Rigotti"
] | [
"",
""
] | 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 | [
"cs.LO",
"cs.PL",
"D.3.2; I.2.2"
] |
||
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 | [
"V. S. Lugovsky"
] | [
""
] | 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 | [
"cs.PL",
"cs.DS",
"cs.SE",
"D.1.1;I.2.2;D.3.2;D.2.10"
] |
||
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 | [
"Dirk Beyer",
"Andreas Noack"
] | [
"",
""
] | 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 | [
"cs.PL",
"cs.DM",
"cs.DS",
"cs.SE",
"D.1.6; G.2.2.a; E.1.d; D.2.7m"
] |
||
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 | [
"Viktor Kuncak",
"K. Rustan M. Leino"
] | [
"",
""
] | 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 | [
"cs.PL",
"cs.LO",
"cs.SE",
"D.2.4; D.3.1; F.3.1; F.3.2; F.4.1"
] |
||
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 | [
"Henning Christiansen"
] | [
""
] | 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 | [
"cs.CL",
"cs.PL"
] |
||
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 | [
"Christian Holzbaur",
"Maria Garcia de la Banda",
"Peter J. Stuckey",
"Gregory J. Duck"
] | [
"",
"",
"",
""
] | 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 | [
"cs.PL",
"D.3.2 Constraint and logic langauges; D.3.4 Optimization"
] |
|
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 | [
"Willem Jan van Hoeve",
"Gilles Pesant",
"Louis-Martin Rousseau"
] | [
"",
"",
""
] | 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 | [
"cs.AI",
"cs.PL",
"D.3.2; D.3.3; G.2.2"
] |
||
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 | [
"Viktor Kuncak",
"Martin Rinard"
] | [
"",
""
] | 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 | [
"cs.PL",
"cs.LO",
"D.2.4; D.3.1; D.3.3; F.3.1; F.3.2; F.4.1"
] |
||
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 | [
"Viktor Kuncak",
"Martin Rinard"
] | [
"",
""
] | 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 | [
"cs.PL",
"cs.LO",
"D.2.4; D.3.1; D.3.3; F.3.1; F.3.2; F.4.1"
] |
||
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 | [
"Viktor Kuncak",
"Martin Rinard"
] | [
"",
""
] | 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 | [
"cs.LO",
"cs.PL",
"cs.SE",
"D.2.4; D.3.1; D.3.3; F.3.1; F.3.2; F.4.1"
] |
||
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 | [
"Viktor Kuncak",
"Martin Rinard"
] | [
"",
""
] | 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 | [
"cs.PL",
"cs.LO",
"D.2.4; D.3.1; D.3.3; F.3.1; F.3.2; F.4.1"
] |
||
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 | [
"Viktor Kuncak",
"Patrick Lam",
"Martin Rinard"
] | [
"",
"",
""
] | 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 | [
"cs.PL",
"cs.SE",
"D.2.4; D.3.1; D.3.3; F.3.1; F.3.2"
] |
||
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 | [
"Viktor Kuncak",
"Martin Rinard"
] | [
"",
""
] | 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 | [
"cs.LO",
"cs.PL"
] |
||
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 | [
"Willem Jan van Hoeve"
] | [
""
] | 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 | [
"cs.PL",
"D.3.2; D.3.3; G.2.2"
] |
||
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 | [
"Willem Jan van Hoeve"
] | [
""
] | 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 | [
"cs.DM",
"cs.PL",
"G.1.6; G.2.2; D.3.3"
] |
||
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 | [
"Marie Lalire",
"Philippe Jorrand"
] | [
"",
""
] | 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 | [
"quant-ph",
"cs.PL"
] |
||
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 | [
"Jan Van den Bussche",
"Dirk Van Gucht",
"Stijn Vansummeren"
] | [
"",
"",
""
] | 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 | [
"cs.DB",
"cs.PL"
] |
|||
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 | [
"Etienne Payet",
"Fred Mesnard"
] | [
"",
""
] | 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 | [
"cs.PL",
"cs.LO"
] |
||
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 | [
"Tom Schrijvers",
"Alexander Serebrenik"
] | [
"",
""
] | 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 | [
"cs.SE",
"cs.PL",
"D.2.7; D.1.6"
] |
||
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 | [
"Richard A. O'Keefe"
] | [
""
] | 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 | [
"cs.PL",
"D.1.6; D.3.2"
] |
|
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 | [
"Seng Wai Loke",
"Andrew Davison"
] | [
"",
""
] | 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 | [
"cs.PL",
"D.1.6; D.3.2"
] |
|
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 | [
"Francisco Javier Lopez-Fraguas",
"Jaime Sanchez-Hernandez"
] | [
"",
""
] | 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 | [
"cs.PL",
"D.1.6; D.3.2"
] |
|
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 | [
"Samir Genaim",
"Michael Codish",
"Jacob M. Howe"
] | [
"",
"",
""
] | 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 | [
"cs.PL",
"D.1.6; D.3.2"
] |
|
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 | [
"Francois Fages",
"Emmanuel Coquery"
] | [
"",
""
] | 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 | [
"cs.PL",
"D.1.6; D.3.2"
] |
|
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 | [
"Hubie Chen",
"Riccardo Pucella"
] | [
"",
""
] | 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 | [
"cs.LO",
"cs.PL",
"F.3.1;I.1.1;I.1.3"
] |
|
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 | [
"Yves Caseau",
"Glenn Silverstein",
"Francois Laburthe"
] | [
"",
"",
""
] | 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 | [
"cs.PL",
"D.1.6; D.3.2"
] |
|
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 | [
"Yves Caseau",
"Francois-Xavier Josset",
"Francois Laburthe"
] | [
"",
"",
""
] | 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 | [
"cs.PL",
"D.1.6; D.3.2"
] |
|
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 | [
"Paul Tarau",
"Veronica Dahl"
] | [
"",
""
] | 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 | [
"cs.PL",
"D.1.6; D.3.2"
] |
|
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 | [
"Riccardo Pucella",
"Prakash Panangaden"
] | [
"",
""
] | 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 | [
"cs.PL",
"F.3.2"
] |
|
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 | [
"Kathleen Fisher",
"Riccardo Pucella",
"John Reppy"
] | [
"",
"",
""
] | 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 | [
"cs.PL",
"D.2.12;D.3.4"
] |
||
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 | [
"Riccardo Pucella"
] | [
""
] | 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 | [
"cs.PL",
"D.2.2;D.3.3"
] |
||
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 | [
"Riccardo Pucella",
"Erik Meijer",
"Dino Oliva"
] | [
"",
"",
""
] | 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 | [
"cs.PL",
"D.1.1;D.3.3;H.5.2"
] |
||
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 | [
"Riccardo Pucella"
] | [
""
] | 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 | [
"cs.PL",
"D.1.1;D.3.3"
] |
|
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 | [
"Riccardo Pucella"
] | [
""
] | 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 | [
"cs.PL",
"D.1.1;D.3.3;H.5.2"
] |
||
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 | [
"Xiaochu Qi"
] | [
""
] | 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 | [
"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 | [
"Roberto Bagnara",
"Roberta Gori",
"Patricia M. Hill",
"Enea Zaffanella"
] | [
"",
"",
"",
""
] | 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 | [
"cs.PL",
"F.3.2"
] |
||
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 | [
"Javier Leach",
"Susana Nieva",
"Mario Rodriguez-Artalejo"
] | [
"",
"",
""
] | 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 | [
"cs.PL",
"D.1.6; D.3.2"
] |
||
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 | [
"Keith L. Clark",
"Peter J. Robinson",
"Richard Hagen"
] | [
"",
"",
""
] | 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 | [
"cs.PL",
"D.1.6; D.3.2"
] |
|
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 | [
"Puri Arenas-Sanchez",
"Mario Rodriguez-Artalejo"
] | [
"",
""
] | 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 | [
"cs.PL",
"D.1.6; D.3.2"
] |
|
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 | [
"Jiyou Jia"
] | [
""
] | 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 | [
"cs.CL",
"cs.PL",
"I.2.7; D.1.5"
] |
||
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 | [
"Gopalan Nadathur"
] | [
""
] | 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 | [
"cs.PL",
"D.3.2; D.3.3; D.3.4"
] |
||
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 | [
"Chung-chieh Shan"
] | [
""
] | 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 | [
"cs.CL",
"cs.PL",
"D.3.3; J.5"
] |
|
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 | [
"Sebastian Brand",
"Krzysztof R. Apt"
] | [
"",
""
] | 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 | [
"cs.DS",
"cs.PL",
"I.2.2; I.2.3; D.1.2; D.3.3; D.3.4"
] |
||
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 | [
"Matthew Fluet",
"Riccardo Pucella"
] | [
"",
""
] | 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 | [
"cs.PL",
"D.1.1; D.3.3; F.3.3"
] |
||
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 | [
"Omid Banyasad",
"Philip T. Cox"
] | [
"",
""
] | 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 | [
"cs.LO",
"cs.PL",
"D.1.6; D.1.7; J.6"
] |
||
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 | [
"Krzysztof R. Apt",
"Peter Zoeteweij"
] | [
"",
""
] | 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 | [
"cs.PL",
"cs.AI",
"D.3.2; D.3.3"
] |
||
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 | [
"Maria Alpuente",
"Michael Hanus",
"Salvador Lucas",
"German Vidal"
] | [
"",
"",
"",
""
] | 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 | [
"cs.PL",
"D.1.1; D.1.6; D.3.4"
] |
||
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 | [
"Andrew W. Appel",
"Amy P. Felty"
] | [
"",
""
] | 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 | [
"cs.LO",
"cs.PL",
"F.3.1; D.2.4; I.2.3; D.1.6"
] |
||
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 | [
"Jacques Cohen"
] | [
""
] | The paper describes the contributions of Alain Colmerauer to the areas of
logic programs (LP) and constraint logic programs (CLP). | 9 pages | cs.PL | [
"cs.PL",
"D 3.2"
] |
||
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 | [
"Fabio Fioravanti",
"Alberto Pettorossi",
"Maurizio Proietti"
] | [
"",
"",
""
] | 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 | [
"cs.PL",
"cs.LO",
"D.1.2;D.1.6;I.2.2;F.3.1"
] |
||
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 | [
"Evgueniy Vitchev"
] | [
""
] | The implementation of the compiler of the UPLNC language is presented with a
full source code listing. | 134 pages, 2 figures, LaTeX | cs.PL | [
"cs.PL",
"D.3.4"
] |
||
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 | [
"Duraid Madina",
"Russell K. Standish"
] | [
"",
""
] | 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 | [
"cs.PL",
"D.1.5;D.2.3"
] |
||
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 | [
"Roberto Bagnara",
"Enea Zaffanella",
"Patricia M. Hill"
] | [
"",
"",
""
] | 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 | [
"cs.PL",
"F.3.2"
] |
||
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 | [
"Patricia M. Hill",
"Enea Zaffanella",
"Roberto Bagnara"
] | [
"",
"",
""
] | 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 | [
"cs.PL",
"F.3.2"
] |
||
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 | [
"Francesco Ranzato",
"Francesco Tapparo"
] | [
"",
""
] | 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 | [
"cs.LO",
"cs.PL",
"D.2.4; F.3.1; F.3.2"
] |
|||
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 | [
"Daniel Cabeza",
"Manuel V. Hermenegildo"
] | [
"",
""
] | 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 | [
"cs.DC",
"cs.PL",
"D.1.3; D.1.6"
] |
|
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 | [
"Henk Vandecasteele",
"Gerda Janssens"
] | [
"",
""
] | 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 | [
"cs.PL",
"D.1.6;D.3.3;.E.2"
] |
||
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 | [
"Jan Hruza",
"Petr Stepanek"
] | [
"",
""
] | 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 | [
"cs.PL",
"cs.AI",
"D.1.6;I.2.2;I.2.3;F.4.1"
] |
||
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 | [
"Samir Genaim",
"Michael Codish"
] | [
"",
""
] | 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 | [
"cs.PL",
"D.1.6,F.3.1"
] |
|||
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 | [
"Alberto Pettorossi",
"Maurizio Proietti",
"Sophie Renault"
] | [
"",
"",
""
] | 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 | [
"cs.PL",
"cs.LO",
"D.1.2;D.1.6;I.2.2;F.3.1"
] |
||
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 | [
"F. Fioravanti",
"A. Pettorossi",
"M. Proietti"
] | [
"",
"",
""
] | 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 | [
"cs.PL",
"cs.LO",
"D.1.2;D.1.6;I.2.2;F.3.1"
] |
||
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 | [
"Zoltan Somogyi"
] | [
""
] | 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 | [
"cs.PL",
"cs.SE",
"D.2.5"
] |
||
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 | [
"Oleg Mazonka",
"Daniel B. Cristofani"
] | [
"",
""
] | 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 | [
"cs.PL",
"D.3"
] |
|||
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 | [
"Michael Narayan",
"Chris Williams",
"Saverio Perugini",
"Naren Ramakrishnan"
] | [
"",
"",
"",
""
] | 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 | [
"cs.IR",
"cs.PL",
"H.5.4; H.5.2; F.3.2"
] |
||
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 | [
"Peter J. Stuckey",
"Martin Sulzmann",
"Jeremy Wazny"
] | [
"",
"",
""
] | 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 | [
"cs.PL",
"D.2.5"
] |
||
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 | [
"Erwan Jahier",
"Mireille Ducass'e"
] | [
"",
""
] | 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 | [
"cs.PL",
"D.2.5"
] |
||
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 | [
"Florence Benoy",
"Andy King",
"Fred Mesnard"
] | [
"",
"",
""
] | 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 | [
"cs.PL",
"D.1.6; F.3.2"
] |
||
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 | [
"Mikhail Auguston",
"Clinton Jeffery",
"Scott Underwood"
] | [
"",
"",
""
] | 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 | [
"cs.SE",
"cs.PL",
"D.2.5"
] |
||
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 | [
"Marija Kulas"
] | [
""
] | 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 | [
"cs.PL",
"cs.LO",
"F.3.2; F.3.1; D.2.5; I.2.3"
] |
||
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 | [
"Agostino Dovier",
"Carla Piazza",
"Gianfranco Rossi"
] | [
"",
"",
""
] | 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 | [
"cs.PL",
"cs.LO",
"cs.SC",
"D.3.3; F.4.1; F.2.2; I.1.2; I.2.3"
] |
||
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 | [
"Fred Mesnard",
"Roberto Bagnara"
] | [
"",
""
] | 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 | [
"cs.PL",
"F.3.2"
] |
||
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 | [
"Michiel Ronsse",
"Koen De Bosschere"
] | [
"",
""
] | 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 | [
"cs.SE",
"cs.PL",
"D.2.5"
] |
||
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 | [
"M. Bozzano",
"G. Delzanno",
"M. Martelli"
] | [
"",
"",
""
] | 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 | [
"cs.PL",
"cs.SC",
"D.3.1;F.3.1;F.3.2"
] |
||
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 | [
"Ricardo Rocha",
"Fernando Silva",
"Vitor Santos Costa"
] | [
"",
"",
""
] | 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 | [
"cs.PL",
"D.1.6;D.3.2"
] |
||
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 | [
"Alberto Pettorossi",
"Maurizio Proietti"
] | [
"",
""
] | 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 | [
"cs.PL",
"cs.LO",
"D.1.2;D.1.6;I.2.2;F.3.1"
] |
||
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 | [
"Sebastiano Vigna"
] | [
""
] | 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 | [
"cs.LO",
"cs.PL",
"F.1.1"
] |
|||
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 | [
"Elham Kashefi"
] | [
""
] | 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 | [
"quant-ph",
"cs.PL"
] |
|||
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 | [
"Bruce Long"
] | [
""
] | 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 | [
"cs.LO",
"cs.PL",
"I.1.3; D.3.2; F.4.1"
] |
|||
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 | [
"Panos Rondogiannis",
"William W. Wadge"
] | [
"",
""
] | 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 | [
"cs.LO",
"cs.AI",
"cs.PL",
"F.3.2;F.4.1;D.1.6;I.2.3"
] |
|
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 | [
"Wei Li"
] | [
""
] | 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 | [
"cs.LO",
"cs.PL",
"F.3.1"
] |
||
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 | [
"Volodymyr Myrnyy"
] | [
""
] | 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 | [
"cs.MS",
"cs.PL",
"G.4; I.1.2; I.1.3"
] |
||
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 | [
"Mark J. Kilgard"
] | [
""
] | Cg is a language for programming GPUs. This paper describes Cg briefly. | 2 pages | cs.GR | [
"cs.GR",
"cs.PL",
"I.3.6; C.1.3"
] |
||
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 | [
"Stijn Vansummeren"
] | [
""
] | 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 | [
"cs.PL",
"cs.DB",
"D.3.3; F.1.1; H.2.3; H.3.3; H.2.4; I.5.5"
] |
||
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 | [
"Oleg Kiselyov"
] | [
""
] | 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 | [
"cs.PL",
"cs.SE",
"F.3.3; D.1.5; D.1.1; D.2.3; D.2.4; D.2.11"
] |
|
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 | [
"Alexandros Eleftheriadis",
"Danny Hong"
] | [
"",
""
] | 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 | [
"cs.PL",
"D.3.4; D.3.0"
] |