25,062 research outputs found
Abstract State Machines 1988-1998: Commented ASM Bibliography
An annotated bibliography of papers which deal with or use Abstract State
Machines (ASMs), as of January 1998.Comment: Also maintained as a BibTeX file at http://www.eecs.umich.edu/gasm
A functional quantum programming language
We introduce the language QML, a functional language for quantum computations
on finite types. Its design is guided by its categorical semantics: QML
programs are interpreted by morphisms in the category FQC of finite quantum
computations, which provides a constructive semantics of irreversible quantum
computations realisable as quantum gates. QML integrates reversible and
irreversible quantum computations in one language, using first order strict
linear logic to make weakenings explicit. Strict programs are free from
decoherence and hence preserve superpositions and entanglement - which is
essential for quantum parallelism.Comment: 15 pages. Final version, to appear in Logic in Computer Science 200
On the Semantics of Gringo
Input languages of answer set solvers are based on the mathematically simple
concept of a stable model. But many useful constructs available in these
languages, including local variables, conditional literals, and aggregates,
cannot be easily explained in terms of stable models in the sense of the
original definition of this concept and its straightforward generalizations.
Manuals written by designers of answer set solvers usually explain such
constructs using examples and informal comments that appeal to the user's
intuition, without references to any precise semantics. We propose to approach
the problem of defining the semantics of gringo programs by translating them
into the language of infinitary propositional formulas. This semantics allows
us to study equivalent transformations of gringo programs using natural
deduction in infinitary propositional logic.Comment: Proceedings of Answer Set Programming and Other Computing Paradigms
(ASPOCP 2013), 6th International Workshop, August 25, 2013, Istanbul, Turke
Anaphora and the Logic of Change
This paper shows how the dynamic interpretation of natural language introduced in work by Hans Kamp and Irene Heim can be modeled in classical type logic. This provides a synthesis between Richard Montague's theory of natural language semantics and the work by Kamp and Heim
Combining Static and Dynamic Contract Checking for Curry
Static type systems are usually not sufficient to express all requirements on
function calls. Hence, contracts with pre- and postconditions can be used to
express more complex constraints on operations. Contracts can be checked at run
time to ensure that operations are only invoked with reasonable arguments and
return intended results. Although such dynamic contract checking provides more
reliable program execution, it requires execution time and could lead to
program crashes that might be detected with more advanced methods at compile
time. To improve this situation for declarative languages, we present an
approach to combine static and dynamic contract checking for the functional
logic language Curry. Based on a formal model of contract checking for
functional logic programming, we propose an automatic method to verify
contracts at compile time. If a contract is successfully verified, dynamic
checking of it can be omitted. This method decreases execution time without
degrading reliable program execution. In the best case, when all contracts are
statically verified, it provides trust in the software since crashes due to
contract violations cannot occur during program execution.Comment: Pre-proceedings paper presented at the 27th International Symposium
on Logic-Based Program Synthesis and Transformation (LOPSTR 2017), Namur,
Belgium, 10-12 October 2017 (arXiv:1708.07854
Logic programming in the context of multiparadigm programming: the Oz experience
Oz is a multiparadigm language that supports logic programming as one of its
major paradigms. A multiparadigm language is designed to support different
programming paradigms (logic, functional, constraint, object-oriented,
sequential, concurrent, etc.) with equal ease. This article has two goals: to
give a tutorial of logic programming in Oz and to show how logic programming
fits naturally into the wider context of multiparadigm programming. Our
experience shows that there are two classes of problems, which we call
algorithmic and search problems, for which logic programming can help formulate
practical solutions. Algorithmic problems have known efficient algorithms.
Search problems do not have known efficient algorithms but can be solved with
search. The Oz support for logic programming targets these two problem classes
specifically, using the concepts needed for each. This is in contrast to the
Prolog approach, which targets both classes with one set of concepts, which
results in less than optimal support for each class. To explain the essential
difference between algorithmic and search programs, we define the Oz execution
model. This model subsumes both concurrent logic programming
(committed-choice-style) and search-based logic programming (Prolog-style).
Instead of Horn clause syntax, Oz has a simple, fully compositional,
higher-order syntax that accommodates the abilities of the language. We
conclude with lessons learned from this work, a brief history of Oz, and many
entry points into the Oz literature.Comment: 48 pages, to appear in the journal "Theory and Practice of Logic
Programming
Logic Programming Approaches for Representing and Solving Constraint Satisfaction Problems: A Comparison
Many logic programming based approaches can be used to describe and solve
combinatorial search problems. On the one hand there is constraint logic
programming which computes a solution as an answer substitution to a query
containing the variables of the constraint satisfaction problem. On the other
hand there are systems based on stable model semantics, abductive systems, and
first order logic model generators which compute solutions as models of some
theory. This paper compares these different approaches from the point of view
of knowledge representation (how declarative are the programs) and from the
point of view of performance (how good are they at solving typical problems).Comment: 15 pages, 3 eps-figure
- …