| Andreas Schulz and Georg Ringwelski. A Workforce-Scheduling Application Using a CP-AI-Hybrid |
| Abstract: Resource management of workforces covering large geographical regions is a complex task. In this domain poor scheduling is directly related to significant extra costs for useless driving. This can result from poor planning or sending teams with inadequate equipment or skills to a certain working task. The problem is well known in practice and solutions exist for several companies. In this paper we describe our application for a water supplier company in Germany. We used a hybrid approach that uses Constraint Programming for the optimization of the scheduling for each vehicle and a clustering algorithm for the assigning tasks to vehicles. |
| Ammar Mohammed and Frieder Stolzenburg. Implementing Hierarchical Hybrid Automata Using Constraint Logic Programming |
| Abstract: Hybrid systems are the result of merging the two most commonly used models for dynamical systems, namely continuous dynamical systems defined by differential equations and discrete-event systems defined by automata. One can view hybrid systems as constrained systems. The constraints are used to describe the possible process flows, invariants, and transitions on the one hand, and to mark certain parts of the state space (e.g. the set of initial states, or the set of unsafe states) on the other hand. Therefore, it is advantageous to use constraint logic programming (CLP) as an approach to model hybrid systems. In this paper, we provide a CLP implementation, that models a hybrid system comprising several concurrent hybrid automata, allowing different levels of abstraction by making use of hierarchies as in UML statecharts. In consequence, the CLP model can be used for analyzing and testing the absence or existence of behaviors in hybrid systems. |
| Johannes Oetsch and Hans Tompits. A Generalised Program-Correspondence Framework: Preliminary Report |
| Abstract: The
study of various notions of equivalence between logic programs in the
area of answer-set programming (ASP) gained increasing interest in
recent years. The main reason for this undertaking is the failure of
ordinary equivalence between answer-set programs to yield a replacement
property similar to the one of classical logic. Although many refined program correspondence notions have been introduced in the ASP literature so far, most of these notions were studied for propositional programs only, which limits their practical usability as concrete programming applications require the use of variables. In this paper, we address this issue and introduce a general framework for specifying parameterised notions of program equivalence for non-ground disjunctive logic programs under the answer-set semantics. Our framework is a generalisation of a similar one defined previously for the propositional case and allows the specification of several equivalence notions extending well-known ones studied for propositional programs. We provide semantic characterisations for instances of our framework generalising uniform equivalence, and we study decidability and complexity aspects. |
| Michael Hanus and Christof Kluss. Declarative Programming of User Interfaces |
| Abstract: This paper proposes a declarative description of user interfacesthat abstracts from low-level implementation details. In particular, the user interfaces specified in our frameworkare executable as graphical user interfaces on single local host computersas well as web user interfaces via web standard browsers. Thus, our approach combines the advantages of existinguser interface technologies in a flexible way without demandson the programmer's side. We sketch an implementation of this concept in thedeclarative multi-paradigm programming language Curryand show how the integrated functional and logic features ofCurry are exploited to enable a high-level implementation ofthis concept. |
| François Bry, Tim Furche, Clemens Ley, Benedikt Linse and Bruno Marnette. RDFLog: It's like Datalog for RDF |
| Abstract: RDF data is set apart from relational or XML data by its support of rich existential information in the form of blank nodes. Where SQL null values are always scoped over a single statement, blank nodes in RDF can span over any number of statements and thus can be seen as existentially quantified variables scoped over conjunctions of RDF triples. For RDF querying blank node querying is considered in most query languages, but blank node construction, i.e., the introduction of new blank nodes has been mostly ignored (e.g., in Triple) or treated in a very limited form (e.g., in SPARQL). In this paper, we classify three kinds of blank node in RDF query languages and introduce the recursive, rule-based RDF query language RDFLog. RDFLog is the first RDF query languages with full arbitrary quantifier alternation: blank nodes may occur in the scope of all, some, or none of the universal variables of a rule. In addition RDFLog is aware of important RDF features such as the distinction between blank nodes, literals and URIs or the RDFS vocabulary. The semantics of RDFLog is closed (every answer is an RDF graph), but lifts RDF's restrictions on literal and blank node occurrences for intermediary data. We show how to define a sound and complete operational semantics that can be implemented using existing logic programming techniques. Our experimental evaluation shows that our prototypical implementation of RDFLog is comparable in efficiency to SPARQL implementations, yet considerably more expressive. |
| Martin Baláž. Well-Supported Models of Disjunctive Logic Programs |
| Abstract: The stable models semantics is nowadays one of the most accepted semantics. For logic programs without disjunction, there also exists the well-supported model semantics. It describes the same set of models, but in spite of the stable model semantics it uses level mappings which can be used to detect cyclic dependencies among literals.We are interested in similar characterization of stable models of logic programs with disjunction. We will use AND/OR graphs to formalize the derivation of stable models and to detect cyclic dependencies among literals. |
| François Bry, Tim Furche, Benedikt Linse and Alexander Pohl. Xcerpt^RDF: A Pattern-based Answer to the Versatile Web Challenge |
| Abstract: We propose Xcerpt^RDF, an extension of the rule based XML query language Xcerpt with language constructs explicitly geared at comfortable querying RDF data, including convenient access to collections, containers, reified statements, and "concise bounded descriptions" for blank nodes. Simulation unification, the formal basis for evaluating Xcerpt queries, is extended to cover the new language constructs and thus to give a formal semantics for Xcerpt^RDF queries. In contrast to previous integration approaches such as XSPARQL or GRDDL that combine an XML query language such as XSLT or XQuery with an RDF query language such as SPARQL, Xcerpt^RDF requires the user to learn only a single language: most language constructs are sufficiently generic to be applied to both RDF and XML data. Xcerpt^RDF is thus a possible solution to the challenge of versatile data access on the Web which has emerged due to the plethora of data formats already online. |
| Ulrich Neumerkel, Markus Triska and Jan Wielemaker. A generalised finite domain constraint solver for SWI-Prolog |
| Abstract: In this paper we describe a new constraint solver over finite domains that has recently been included in the SWI-Prolog distribution1 . Our solver generalises finite domain constraint solving towards unbounded domains, and thus enables a uniform approach to integer arithmetic and constraints. We ensure termination of all predicates, which facilitates termination proofs of constraint logic programs. The solver is written in Prolog and can be ported to other systems as well. |
| Slim Abdennadher and Shehab Fawzy. JCHRIDE: An Integrated Development Environment for JCHR |
| Abstract: The rule-based programming language Constraint Handling Rules (CHR) has been introduced to ease the development and implementation of constraint solvers. Currently, several CHR libraries exist in languages such as Prolog, Haskell and Java. The K.U.Leuven JCHR system is a high-performance integration of Constraint Handling Rules (CHR) andJava. JCHR is currently by far the most efficient implementation of CHR in Java. Its performance is competitive with state-of-the-art CHRsystems in e.g. HAL and Prolog. To ease the duty of a CHR programmer, we introduce in this paper an integrated development environment (IDE) for theK.U.Leuven JCHR. The IDE is implemented as a plug-in in Eclipse. |
| Patrick Krümpelmann and Gabriele Kern-Isberner. Propagating Credibility in Answer Set Programs |
| Abstract: Usually, in multi-agent systems, agents are assumed to be honest, to reply frankly and truthfully in accordance with their beliefs. Reality is different agents may hold back information, or even lie. This paper addresses the problem of evaluating the credibility of information before incorporating it into the agent's belief. We present an approach that allows the agent to compare incoming information with its prior beliefs and update its belief state accordingly. As a basic method for this, we use an update mechanism for answer set programming which is modified for handling credibilities. Sharing this common base, both evaluating information and performing updates can be realized in one framework. |
| Yoshitaka Yamamoto and Katsumi Inoue. An efficient hypothesis-finding system implemented with deduction and dualization |
|
Abstract: We
show how the hypothesis finding problem, which deals with
inductive and
abductive inferences in logic-based Artificial Intelligence, can be
formalized using the two extensions of logic/constraint programming
techniques: the first one is the consequence finding
problem whose task
is to derive theories from a given axiom set, and is an extension of
SLD resolution. The second one is dualization, whose task
is to compute
a prime CNF formula from the dual of a given CNF formula, and is an
extension of SAT technique. Efficient algorithms for these two tasks have been individually proposed and recently realized as sophisticated systems. In this paper, we provide efficient hypothesis finding implementation based on these systems. |