Institute for Information Systems

As software systems are getting increasingly connected, there is a need for equipping nonmonotonic logic programs with access to external sources that are possibly remote and may contain information in heterogeneous formats. To cater for this need,hexprograms were designed as a generalization of answer set programs with an API style interface that allows to access arbitrary external sources, providing great flexibility. Efficient evaluation of such programs however is challenging, and it requires to interleave external computation and model building; to decide when to switch between these tasks is difficult, and existing approaches have limited scalability in many real-world application scenarios. We present a new approach for the evaluation of logic programs with external source access, which is based on a configurable framework for dividing the non-ground program into possibly overlapping smaller parts called evaluation units. The latter will be processed by interleaving external ...

The evaluation of logic programs with access to external knowledge sources requires to interleave external computation and model building. Deciding where and how to stop with one task and proceed with the next is a difficult problem, and existing approaches have severe scalability limitations in many real-world application scenarios. We introduce a new approach for organizing the evaluation of logic programs with external knowledge sources and describe a configurable framework for dividing the non-ground program into overlapping possiblysmaller parts called evaluation units. These units will then be processed by interleaving external evaluations and model building according to an evaluation and a model graph, and by combining intermediate results. Experiments with our prototype implementation show a significant improvement of this technique compared to existing approaches. Interestingly, even for ordinary logic programs (with no external access), our decomposition approach speeds up existing state of the art ASP solvers in some cases, showing its potential for wider usage.

Multi-context systems are a formalism for interlinking knowledge based system (contexts) which interact via (possibly nonmonotonic) bridge rules. Such interlinking provides ample opportunity for unexpected inconsistencies. These are undesired, and come in different categories: some are serious and must be inspected by a human operator, while some should simply be repaired automatically. However, no one-fits-all solution exists, as these categories depend on the application scenario. To tackle inconsistencies in a general way, we thus propose a declarative policy language for inconsistency management in multicontext systems. We define syntax and semantics, give methodologies for applying the language in real world applications, and discuss a possible implementation.

are an extension of the Answer Set Programming (ASP) paradigm incorporating external means of computation into the declarative programming language through so-called external atoms. Their semantics is defined in terms of minimal models of the Faber-Leone-Pfeifer (FLP) reduct. Developing native solvers for HEX-programs based on an appropriate notion of unfounded sets has been subject to recent research for reasons of efficiency. Although this has lead to an improvement over naive minimality checking using the FLP reduct, testing for foundedness remains a computationally expensive task. In this work we improve on HEX-program evaluation in this respect by identifying a syntactic class of programs, that can be efficiently recognized and allows to entirely skip the foundedness check. Moreover, we develop criteria for decomposing a program into components, such that the search for unfounded sets can be restricted. Observing that our results apply to many HEX-program applications provides analytic evidence for the significance and effectiveness of our approach, which is complemented by a brief discussion of preliminary experimental validation.

Combinatory categorial grammar (CCG) is a grammar formalism used for natural language parsing. CCG assigns structured lexical categories to words and uses a small set of combinatory rules to combine these categories to parse a sentence. In this work we propose and implement a new approach to CCG parsing that relies on a prominent knowledge representation formalism, answer set programming (ASP) -a declarative programming paradigm. We formulate the task of CCG parsing as a planning problem and use an ASP computational tool to compute solutions that correspond to valid parses. Compared to other approaches, there is no need to implement a specific parsing algorithm using such a declarative method. Our approach aims at producing all semantically distinct parse trees for a given sentence. From this goal, normalization and efficiency issues arise, and we deal with them by combining and extending existing strategies. We have implemented a CCG parsing tool kit -ASPCCGTK-that uses ASP as its main computational means. The C&C supertagger can be used as a preprocessor within ASPCCGTK, which allows us to achieve wide-coverage natural language parsing.

We propose and advocate the use of an advanced declarative programming paradigm-answer set programming-as a uniform platform for integrated approach towards syntax-semantic processing in natural language. We illustrate that (a) the parsing technology based on answer set programming implementation reaches performance sufficient for being a useful NLP tool, and (b) the proposed method for incorporating semantic information from FRAMENET into syntactic parsing may prove to be useful in allowing semantic-based disambiguation of syntactic structures. * We would like to thank Vladimir Lifschitz and Ray Mooney for useful discussions and comments related to the topic of this work. Peter Schüller was supported by a TUBITAK scholarship.

We study the problem of finding optimal plans for multiple teams of robots through a mediator, where each team is given a task to complete in its workspace on its own and where teams are allowed to transfer robots between each other, subject to the following constraints: 1) teams (and the mediator) do not know about each other's workspace or tasks (e.g., for privacy purposes); 2) every team can lend or borrow robots, but not both (e.g., transportation/calibration of robots between/for different workspaces is usually costly). We present a mathematical definition of this problem and analyze its computational complexity. We introduce a novel, logic-based method to solve this problem, utilizing action languages and answer set programming for representation, and the state-of-the-art ASP solvers for reasoning. We show the applicability and usefulness of our approach by experiments on various scenarios of responsive and energy-efficient cognitive factories.

HEX programs extend logic programs with external computations through external atoms, whose answer sets are the minimal models of the Faber-Leone-Pfeifer-reduct. As already reasoning from Horn programs with nonmonotonic external atoms of polynomial complexity is on the second level of the polynomial hierarchy, answer set checking needs special attention; simply computing reducts and searching for smaller models does not scale well. We thus extend an approach based on unfounded sets to HEX and integrate it in a Conflict Driven Clause Learning framework for HEX program evaluation. It reduces the check to a search for unfounded sets, which is more efficiently implemented as a SAT problem. We give a basic encoding for HEX and show optimizations by additional clauses. Experiments show that the new approach significantly decreases runtime.

Combinatory categorial grammar (CCG) is a grammar formalism used for natural language parsing. CCG assigns structured lexical categories to words and uses combinatory rules to combine these categories to parse a sentence. In this work we propose and implement a new approach to CCG parsing that relies on a prominent knowledge representation formalism, answer set programming (ASP)-a declarative programming paradigm. We formulate the task of CCG parsing as a planning problem and use an ASP computational tool to compute solutions that correspond to valid parses. Compared to other approaches, there is no need to implement a specific parsing algorithm using such a declarative method. Our approach aims at producing all semantically distinct parse trees for a given sentence. From this goal, normalization and efficiency issues arise, and we deal with them by combining and extending existing strategies. We have implemented a CCG parsing tool kit-ASPCCGTK-that uses ASP as its main computational means. The C&C supertagger can be used as a preprocessor within ASPCCGTK, which allows us to achieve wide-coverage natural language parsing.

Multi-context systems are a formalism to interlink decentralized and heterogeneous knowledge based systems (contexts), which interact via (possibly nonmonotonic) bridge rules. Inconsistency is a major problem, as it renders such systems useless. In addition, it is likely that complete knowledge about all system parts is unavailable and cannot be obtained, for instance in applications where confidentiality or trust are prohibitive. We therefore aim at explaining reasons for inconsistency in multi-context systems without having an omniscient view of the whole system. To this end we propose a representation for partial knowledge about contexts, and define over-and underapproximations for existing notions characterizing inconsistency in multi-context systems. Furthermore, we discuss query selection strategies for improving approximations in situations where a limited number of queries can be posed to a partially known context.

Multi-Context Systems (MCSs) are an expressive framework for interlinking heterogeneous knowledge systems, called contexts. Possible contexts are ontologies, relational databases, logic programs, RDF triplestores, etc. MCSs contain bridge rules to specify knowledge exchange between contexts. We extend the MCS formalism and propose SPARQL-MCS where knowledge exchange is specified in the style of SPARQL CONSTRUCT queries. Different from previous approaches to variables in MCSs, we do not impose any restrictions on contexts. To achieve this, we introduce a general approach for variable substitutions in heterogeneous systems. We define syntax and semantics of SPARQL-MCS and investigate fixpoint evaluation of monotonic MCSs. This research has been supported by the Vienna Science and Technology Fund (WWTF) project ICT08-020. 1 RDF is a semantic web framework for storing information as graphs, encoded in (subject predicate object) triples.

The Multi-Context System Inconsistency Explainer allows for evaluation of semantics and explanation of inconsistencies in systems where heterogeneous knowledge bases are linked via nonmonotonic rules. The implementation is based on the dlvhex tool, which is an extension of answer set programming with external atoms and higher order features.

Pathfinding for a single agent is the problem of planning a route from an initial location to a goal location in an environment, going around obstacles. Pathfinding for multiple agents also aims to plan such routes for each agent, subject to different constraints, such as restrictions on the length of each path or on the total length of paths, no self-intersecting paths, no intersection of paths/plans, no crossing/meeting each other. It also has variations for finding optimal solutions, e.g., with respect to the maximum path length, or the sum of plan lengths. These problems are important for many real-life applications, such as motion planning, vehicle routing, environmental monitoring, patrolling, computer games. Motivated by such applications, we introduce a formal framework that is general enough to address all these problems: we use the expressive high-level representation formalism and efficient solvers of the declarative programming paradigm Answer Set Programming. We also introduce heuristics to improve the computational efficiency and/or solution quality. We show the applicability and usefulness of our framework by experiments, with randomly generated problem instances on a grid, on a real-world road network, and on a real computer game terrain.

We provide a systematic analysis of levels of integration between discrete high-level reasoning and continuous low-level reasoning to address hybrid planning problems in robotics. We identify four distinct strategies for such an integration: (i) low-level checks are done for all possible cases in advance and then this information is used during plan generation, (ii) low-level checks are done exactly when they are needed during the search for a plan, (iii) first all plans are computed and then infeasible ones are filtered, and (iv) by means of replanning, after finding a plan, low-level checks identify whether it is infeasible or not; if it is infeasible, a new plan is computed considering the results of previous lowlevel checks. We perform experiments on hybrid planning problems in robotic manipulation and legged locomotion domains considering these four methods of integration, as well as some of their combinations. We analyze the usefulness of levels of integration in these domains, both from the point of view of computational efficiency (in time and space) and from the point of view of plan quality relative to its feasibility. We discuss advantages and disadvantages of each strategy in the light of experimental results and provide some guidelines on choosing proper strategies for a given domain.

Pathfinding for a single agent is the problem of planning a route from an initial location to a goal location in an environment, going around obstacles. Pathfinding for multiple agents also aims to plan such routes for each agent, subject to different constraints, such as restrictions on the length of each path, no intersection of paths/plans, no crossing/meeting each other. It also has variations for finding optimal solutions with respect to the maximum path length or the sum of plan lengths. These problems are important for many real-life applications, such as motion planning, vehicle routing, environmental monitoring, patrolling, computer games. We evaluate the applicability of Answer Set Programming to solve variations of multi-agent pathfinding problems, by experiments with randomly generated problem instances on a grid, on a real-world road network, and on a real computer game terrain.

Özetçe -Bu makalede robotlardan oluşan birden fazla takım için, bir aracı yardımı ile, eniyileştirilmiş planları bulmak amacıyla geliştirdigimiz yöntemler açıklanmaktadır. Bu problemde, her takımın kendine ait çalışma alanında tamamlaması gereken görevleri vardır ve takımlar arası robot degişimi yapılabilmektedir. Ayrıca takımlar şu kısıtları göz önünde bulundurmaktadırlar: 1) takımlar (ve aracı) birbirlerinin çalışma alanı ya da görevleri hakkında bilgi sahibi degildirler (örn. gizlilik nedeniyle); 2) her takım ya robot ödünç verebilir ya da ödünç alabilir, ama ikisini birden yapamaz (örn. robotların çalışma alanları arasında taşınmaları ve ayarlanmaları genelde zor ve masraflıdır). Bu problemi çözmek için önerdigimiz yöntem, güncel SAT çözücülerini ve çözüm kümesi programlama (ASP) çözücülerini kullanmaktır. Yaklaşımımızın uygulanabilirligi ve kullanışlılıgı bilişsel fabrikalar üzerinde çeşitli senaryolarla yaptıgımız deneylerle gösterilmiştir.

HEX programs extend logic programs with external computations through external atoms. As already reasoning from Horn programs with nonmonotonic external atoms of polynomial complexity is on the second level of the polynomial hierarchy, minimality checking of answer set candidates needs special attention. To this end, we present an approach based on unfounded sets as a generalization of related techniques for ordinary ASP programs. The unfounded set detection is efficiently expressed as a propositional SAT problem, for which we provide two different encodings and optimizations to them. We then integrate our approach into a previously developed evaluation framework for HEX-programs, which is enriched by additional learning techniques that aim at avoiding the reconstruction of the same or related unfounded sets. Furthermore, we provide a syntactic criterion that allows one to skip the minimality check in practically relevant cases. It benignly carries over to the components of an appropriate program decomposition, which can be exploited to restrict unfounded set search to relevant parts of the program. An experimental evaluation shows that the new approach significantly decreases runtime. Acknowledgements: This research has been supported by the Vienna Science and Technology Fund (WWTF) project ICT08-020. This report is an extended version of [Eiter et al., 2012c,b,d].

We study disambiguating of pronoun references in Winograd Schemas, which are part of the Winograd Schema Challenge, a proposed replacement for the Turing test. In particular we consider sentences where the pronoun can be resolved to both antecedents without semantic violations in world knowledge, that means for both readings of the sentence there is a possible consistent world. Nevertheless humans will strongly prefer one answer, which can be explained by pragmatic effects described in Relevance Theory. We state formal optimization criteria based on principles of Relevance Theory in a simplification of Roger Schank's graph framework for natural language understanding. We perform experiments using Answer Set Programming and report the usefulness of our criteria for disambiguation and their sensitivity to parameter variations.

Answer set programming (ASP) is a declarative programming paradigm stemming from logic programming that has been successfully applied in various domains. Despite amazing advancements in ASP solving, many applications still pose a challenge that is commonly referred to as grounding bottleneck. Devising, implementing, and evaluating a method that alleviates this problem for certain application domains is the focus of this paper. The proposed method is based on combining backtracking-based search algorithms employed in answer set solvers with SLDNF resolution from PROLOG. Using PROLOG inference on non-ground portions of a given program, both grounding time and the size of the ground program can be substantially reduced.

We provide two approaches for explaining inconsistency in multi-context systems, where decentralized and heterogeneous system parts interact via nonmonotonic bridge rules. Inconsistencies arise easily in such scenarios, and nonmonotonicity calls for specific methods of inconsistency analysis. Both our approaches characterize inconsistency in terms of involved bridge rules: either by pointing out rules which need to be altered for restoring consistency, or by finding combinations of rules which cause inconsistency. We show duality and modularity properties, give precise complexity characterizations, and provide algorithms for computation using HEXprograms. Our results form a basis for inconsistency management in heterogeneous knowledge integration systems.