625 research outputs found
SWISH: SWI-Prolog for Sharing
Recently, we see a new type of interfaces for programmers based on web
technology. For example, JSFiddle, IPython Notebook and R-studio. Web
technology enables cloud-based solutions, embedding in tutorial web pages,
atractive rendering of results, web-scale cooperative development, etc. This
article describes SWISH, a web front-end for Prolog. A public website exposes
SWI-Prolog using SWISH, which is used to run small Prolog programs for
demonstration, experimentation and education. We connected SWISH to the
ClioPatria semantic web toolkit, where it allows for collaborative development
of programs and queries related to a dataset as well as performing maintenance
tasks on the running server and we embedded SWISH in the Learn Prolog Now!
online Prolog book.Comment: International Workshop on User-Oriented Logic Programming (IULP
2015), co-located with the 31st International Conference on Logic Programming
(ICLP 2015), Proceedings of the International Workshop on User-Oriented Logic
Programming (IULP 2015), Editors: Stefan Ellmauthaler and Claudia Schulz,
pages 99-113, August 201
Proving Correctness of Imperative Programs by Linearizing Constrained Horn Clauses
We present a method for verifying the correctness of imperative programs
which is based on the automated transformation of their specifications. Given a
program prog, we consider a partial correctness specification of the form
prog , where the assertions and are
predicates defined by a set Spec of possibly recursive Horn clauses with linear
arithmetic (LA) constraints in their premise (also called constrained Horn
clauses). The verification method consists in constructing a set PC of
constrained Horn clauses whose satisfiability implies that prog
is valid. We highlight some limitations of state-of-the-art
constrained Horn clause solving methods, here called LA-solving methods, which
prove the satisfiability of the clauses by looking for linear arithmetic
interpretations of the predicates. In particular, we prove that there exist
some specifications that cannot be proved valid by any of those LA-solving
methods. These specifications require the proof of satisfiability of a set PC
of constrained Horn clauses that contain nonlinear clauses (that is, clauses
with more than one atom in their premise). Then, we present a transformation,
called linearization, that converts PC into a set of linear clauses (that is,
clauses with at most one atom in their premise). We show that several
specifications that could not be proved valid by LA-solving methods, can be
proved valid after linearization. We also present a strategy for performing
linearization in an automatic way and we report on some experimental results
obtained by using a preliminary implementation of our method.Comment: To appear in Theory and Practice of Logic Programming (TPLP),
Proceedings of ICLP 201
Verification of Imperative Programs by Constraint Logic Program Transformation
We present a method for verifying partial correctness properties of
imperative programs that manipulate integers and arrays by using techniques
based on the transformation of constraint logic programs (CLP). We use CLP as a
metalanguage for representing imperative programs, their executions, and their
properties. First, we encode the correctness of an imperative program, say
prog, as the negation of a predicate 'incorrect' defined by a CLP program T. By
construction, 'incorrect' holds in the least model of T if and only if the
execution of prog from an initial configuration eventually halts in an error
configuration. Then, we apply to program T a sequence of transformations that
preserve its least model semantics. These transformations are based on
well-known transformation rules, such as unfolding and folding, guided by
suitable transformation strategies, such as specialization and generalization.
The objective of the transformations is to derive a new CLP program TransfT
where the predicate 'incorrect' is defined either by (i) the fact 'incorrect.'
(and in this case prog is not correct), or by (ii) the empty set of clauses
(and in this case prog is correct). In the case where we derive a CLP program
such that neither (i) nor (ii) holds, we iterate the transformation. Since the
problem is undecidable, this process may not terminate. We show through
examples that our method can be applied in a rather systematic way, and is
amenable to automation by transferring to the field of program verification
many techniques developed in the field of program transformation.Comment: In Proceedings Festschrift for Dave Schmidt, arXiv:1309.455
Taylor: A Magazine for Taylor University Alumni and Friends (Summer 2003)
The Summer 2003 edition of Taylor Magazine, published by Taylor University in Upland, Indiana.https://pillars.taylor.edu/tu_magazines/1115/thumbnail.jp
The impact on firms of ICT skill-supply strategies: an Anglo-German comparison
This paper compares the supply of specialist ICT skills in Britain and Germany from higher education and from apprenticeship and assesses the relative impact on companies in the two countries. In contrast to Britain, where numbers of ICT graduates have expanded rapidly, the supply of university graduates in Germany has not increased. Combined with the constraints of the German occupational model of work organization, it is concluded that this failure of supply may have contributed to slower growth of ICT employment in Germany. At the same time, German firms have turned to a newly developed model of apprenticeship to supply routine technical ICT skills. This strategy contrasts with British firms which recruit from a wide range of graduate specialisms and invest more heavily in graduate training. Probably in part as a consequence, apprenticeship in ICT occupations in Britain has failed to develop
Removing Algebraic Data Types from Constrained Horn Clauses Using Difference Predicates
We address the problem of proving the satisfiability of Constrained Horn
Clauses (CHCs) with Algebraic Data Types (ADTs), such as lists and trees. We
propose a new technique for transforming CHCs with ADTs into CHCs where
predicates are defined over basic types, such as integers and booleans, only.
Thus, our technique avoids the explicit use of inductive proof rules during
satisfiability proofs. The main extension over previous techniques for ADT
removal is a new transformation rule, called differential replacement, which
allows us to introduce auxiliary predicates corresponding to the lemmas that
are often needed when making inductive proofs. We present an algorithm that
uses the new rule, together with the traditional folding/unfolding
transformation rules, for the automatic removal of ADTs. We prove that if the
set of the transformed clauses is satisfiable, then so is the set of the
original clauses. By an experimental evaluation, we show that the use of the
differential replacement rule significantly improves the effectiveness of ADT
removal, and we show that our transformation-based approach is competitive with
respect to a well-established technique that extends the CVC4 solver with
induction.Comment: 10th International Joint Conference on Automated Reasoning (IJCAR
2020) - version with appendix; added DOI of the final authenticated Springer
publication; minor correction
- …