Filters








59 Hits in 1.3 sec

Asynchronous Multi-Context Systems [article]

Stefan Ellmauthaler, Jörg Pührer
2015 arXiv   pre-print
In this work, we present asynchronous multi-context systems (aMCSs), which provide a framework for loosely coupling different knowledge representation formalisms that allows for online reasoning in a dynamic environment. Systems of this kind may interact with the outside world via input and output streams and may therefore react to a continuous flow of external information. In contrast to recent proposals, contexts in an aMCS communicate with each other in an asynchronous way which fits the
more » ... s of many application domains and is beneficial for scalability. The federal semantics of aMCSs renders our framework an integration approach rather than a knowledge representation formalism itself. We illustrate the introduced concepts by means of an example scenario dealing with rescue services. In addition, we compare aMCSs to reactive multi-context systems and describe how to simulate the latter with our novel approach.
arXiv:1505.05367v1 fatcat:zolka4rxsbclvblkjoovfcpzby

Characterizing Realizability in Abstract Argumentation [article]

Thomas Linsbichler, Jörg Pührer, Hannes Strass
2016 arXiv   pre-print
Proposition 2 (Pührer 2015).  ...  Definition 1 (Pührer 2015). Let V be a set of interpreta- tions.  ... 
arXiv:1603.09545v1 fatcat:jnt55d7d7zc6vdkznprxnbu4ny

Stepwise Debugging of Answer-Set Programs [article]

Johannes Oetsch, Jörg Pührer, Hans Tompits
2017 arXiv   pre-print
the stepping methodology in his PhD thesis (Pührer 2014) .  ...  Pührer 2014), demands for unstable computations in the general case.  ... 
arXiv:1705.06564v1 fatcat:qea4blojk5dgtoxlgtdblyaym4

Towards a Simulation-Based Programming Paradigm for AI applications [article]

Jörg Pührer
2015 arXiv   pre-print
We present initial ideas for a programming paradigm based on simulation that is targeted towards applications of artificial intelligence (AI). The approach aims at integrating techniques from different areas of AI and is based on the idea that simulated entities may freely exchange data and behavioural patterns. We define basic notions of a simulation-based programming paradigm and show how it can be used for implementing AI applications.
arXiv:1505.05373v1 fatcat:mrgpwclx2zaxdkrqv6g5gxlecu

Stream Packing for Asynchronous Multi-Context Systems using ASP [article]

Stefan Ellmauthaler, Jörg Pührer
2016 arXiv   pre-print
When a processing unit relies on data from external streams, we may face the problem that the stream data needs to be rearranged in a way that allows the unit to perform its task(s). On arrival of new data, we must decide whether there is sufficient information available to start processing or whether to wait for more data. Furthermore, we need to ensure that the data meets the input specification of the processing step. In the case of multiple input streams it is also necessary to coordinate
more » ... ich data from which incoming stream should form the input of the next process instantiation. In this work, we propose a declarative approach as an interface between multiple streams and a processing unit. The idea is to specify via answer-set programming how to arrange incoming data in packages that are suitable as input for subsequent processing. Our approach is intended for use in asynchronous multi-context systems (aMCSs), a recently proposed framework for loose coupling of knowledge representation formalisms that allows for online reasoning in a dynamic environment. Contexts in aMCSs process data streams from external sources and other contexts.
arXiv:1611.05640v1 fatcat:fs7vrposcng57exlesgtwwcoya

Annotating Answer-Set Programs in LANA? [article]

Marina De Vos, Doğa Gizem Kıza, Johannes Oetsch, Jörg Pührer, Hans Tompits
2012 arXiv   pre-print
While past research in answer-set programming (ASP) mainly focused on theory, ASP solver technology, and applications, the present work situates itself in the context of a quite recent research trend: development support for ASP. In particular, we propose to augment answer-set programs with additional meta-information formulated in a dedicated annotation language, called LANA. This language allows the grouping of rules into coherent blocks and to specify language signatures, types, pre- and
more » ... conditions, as well as unit tests for such blocks. While these annotations are invisible to an ASP solver, as they take the form of program comments, they can be interpreted by tools for documentation, testing, and verification purposes, as well as to eliminate sources of common programming errors by realising syntax checking or code completion features. To demonstrate its versatility, we introduce two such tools, viz. (i) ASPDOC, for generating an HTML documentation for a program based on the annotated information, and (ii) ASPUNIT, for running and monitoring unit tests on program blocks. LANA is also exploited in the SeaLion system, an integrated development environment for ASP based on Eclipse. To appear in Theory and Practice of Logic Programming
arXiv:1210.2195v1 fatcat:3scweyzegfagzk33wwxogludpq

ArgueApply: A Mobile App for Argumentation [chapter]

Jörg Pührer
2017 Lecture Notes in Computer Science  
Formal models developed in the field of argumentation allow for analysing and evaluating problems that have previously been studied by philosophers on an informal level only. Importantly, they also give rise to the development of computational tools for argumentation. In this paper we report on ArgueApply, a mobile app for argumentation that is based on the Grappa framework, an extension of, e.g., abstract argumentation in the sense of Dung. With ArgueApply users can engage in online
more » ... and evaluate their semantics. Each of the resulting interpretations can be seen as a coherent view on a discussion in which some of the discussions statements are accepted and others rejected. Being a mobile tool, ArgueApply is intended to be more accessible than existing systems for computing argumentation semantics allowing, e.g., for spontaneous analysis of an ongoing discussion or collective preparation for an important debate. While having a practical system for these applications is the final goal of our work, an immediate objective is using the system for exploring which type of Grappa frameworks under which semantics are best suited for such applications.
doi:10.1007/978-3-319-61660-5_23 fatcat:we7xj5o7gzeslieg3yj6iypo7m

Multi-Context Systems for Reactive Reasoning in Dynamic Environments [article]

Gerhard Brewka and Stefan Ellmauthaler and Jörg Pührer
2015 arXiv   pre-print
We show in this paper how managed multi-context systems (mMCSs) can be turned into a reactive formalism suitable for continuous reasoning in dynamic environments. We extend mMCSs with (abstract) sensors and define the notion of a run of the extended systems. We then show how typical problems arising in online reasoning can be addressed: handling potentially inconsistent sensor input, modeling intelligent forms of forgetting, selective integration of knowledge, and controlling the reasoning
more » ... t spent by contexts, like setting contexts to an idle mode. We also investigate the complexity of some important related decision problems and discuss different design choices which are given to the knowledge engineer.
arXiv:1505.05366v1 fatcat:i4zy2l5jhncbnb7ftjuwg56tam

Stepping through an Answer-Set Program [chapter]

Johannes Oetsch, Jörg Pührer, Hans Tompits
2011 Lecture Notes in Computer Science  
We introduce a framework for interactive stepping through an answerset program as a means for debugging. In procedural languages, stepping is a widespread and effective debugging strategy. The idea is to gain insight into the behaviour of a program by executing statement by statement, following the program's control flow. Stepping has not been considered for answer-set programs so far, presumably because of their lack of a control flow. The framework we provide allows for stepwise constructing
more » ... nterpretations following the user's intuition on which rule instances to become active. That is, we do not impose any ordering on the rules but give the programmer the freedom to guide the stepping process. Due to simple syntactic restrictions, each step results in a state that guarantees stability of the intermediate interpretation. We present how stepping can be started from breakpoints as in conventional programming and discuss how the approach can be used for debugging using a running example.
doi:10.1007/978-3-642-20895-9_13 fatcat:wonmlwlzendm3bunnp5hgoildq

Stepwise Debugging of Description-Logic Programs [chapter]

Johannes Oetsch, Jörg Pührer, Hans Tompits
2012 Lecture Notes in Computer Science  
Besides that, a refined semantics for DL-programs to overcome counter-intuitive results that may emerge when input literals of DL-atoms cause inconsistency in the ontology was presented by Pührer et al  ... 
doi:10.1007/978-3-642-30743-0_34 fatcat:6hjtkvvucrhjbb7fywc5xefpd4

Stepwise debugging of answer-set programs

JOHANNES OETSCH, JÖRG PÜHRER, HANS TOMPITS
2017 Theory and Practice of Logic Programming  
the stepping methodology in his PhD thesis (Pührer 2014) .  ...  Pührer 2014), demands for unstable computations in the general case.  ... 
doi:10.1017/s1471068417000217 fatcat:pwi4pk775fflnn6kkq3g6pdhyq

Debugging Answer-Set Programs with Ouroboros – Extending the SeaLion Plugin [chapter]

Melanie Frühstück, Jörg Pührer, Gerhard Friedrich
2013 Lecture Notes in Computer Science  
In answer-set programming (ASP), there is a lack of debugging tools that are capable of handling programs with variables. Hence, we implemented a tool, called Ouroboros, for debugging non-ground answer-set programs. The system builds on a previous approach based on ASP meta-programming that has been recently extended to cover weight constraints and choice rules. The main debugging question addressed is "given a program P and an interpretation I, why is I not an answer set of P ". Our tool gives
more » ... answers in terms of two categories of explanations: unsatisfied rules and unfounded loops. Ouroboros is a plugin of the SeaLion integrated development environment for ASP that is built on Eclipse. Thereby, Ouroboros complements and profits from SeaLion's Stepping plugin, that implements a different debugging approach for ASP.
doi:10.1007/978-3-642-40564-8_32 fatcat:ezqen6b35fg2bovs53atpf33iu

Inconsistency Management in Reactive Multi-context Systems [chapter]

Gerhard Brewka, Stefan Ellmauthaler, Ricardo Gonçalves, Matthias Knorr, João Leite, Jörg Pührer
2016 Lecture Notes in Computer Science  
In this paper, we begin by introducing reactive multicontext systems (rMCSs), a framework for reactive reasoning in the presence of heterogeneous knowledge sources. In particular, we show how to integrate data streams into multi-context systems (MCSs) and how to model the dynamics of the systems, based on two types of bridge rules. We then discuss various methods for handling inconsistencies, a problem that occurs with reasoning based on multiple knowledge sources that need to be integrated, with a special focus on non-existence of equilibria.
doi:10.1007/978-3-319-48758-8_35 fatcat:2lr7e3u64zfbzk2ctk5uqhoqdq

Elimination of Disjunction and Negation in Answer-Set Programs under Hyperequivalence [chapter]

Jörg Pührer, Hans Tompits, Stefan Woltran
2008 Lecture Notes in Computer Science  
The study of different notions of equivalence is one of the cornerstones of current research in answer-set programming. This is mainly motivated by the needs of program simplification and modular programming, for which ordinary equivalence is insufficient. A recently introduced equivalence notion in this context is hyperequivalence, which includes as special cases strong, uniform, and ordinary equivalence. We study in this paper the question of replacing programs by syntactically simpler ones
more » ... eserving hyperequivalence (we refer to such a replacement as a casting). In particular, we provide necessary and sufficient semantic conditions under which the elimination of disjunction, negation, or both, in programs is possible, preserving hyperequivalence. In other words, we characterise in model-theoretic terms when a disjunctive logic program can be replaced by a hyperequivalent normal, positive, or Horn program, respectively. Furthermore, we study the computational complexity of the considered tasks and, based on similar results for strong equivalence developed in previous work, we provide methods for constructing the respective hyperequivalent programs. Our results contribute to the understanding of problem settings in logic programming in the sense that they show in which scenarios the usage of certain constructs are superfluous or not. We deal with finite propositional disjunctive logic programs containing rules (over a set At of atoms) of form a 1 ∨ · · · ∨ a l ← b 1 , . . . , b m , not b m+1 , . . . , not b n , where l ≥ 0, n ≥ m ≥ 0, all a i , b j are from At, and not denotes default negation. A rule r as described is normal, if l ≤ 1; positive, if m = n; and a fact, if l = 1 and m = n = 0.
doi:10.1007/978-3-540-89982-2_47 fatcat:cggw3cpekvh3jpxmknqsxpfafe

Dealing with Inconsistency When Combining Ontologies and Rules Using DL-Programs [chapter]

Jörg Pührer, Stijn Heymans, Thomas Eiter
2010 Lecture Notes in Computer Science  
Description Logic Programs (DL-programs) have been introduced to combine ontological and rule-based reasoning in the context of the Semantic Web. A DL-program loosely combines a Description Logic (DL) ontology with a non-monotonic logic program (LP) such that dedicated atoms in the LP, called DL-atoms, allow for a bidirectional flow of knowledge between the two components. Unfortunately, the information sent from the LP-part to the DL-part might cause an inconsistency in the latter, leading to
more » ... he trivial satisfaction of every query. As a consequence, in such a case, the answer sets that define the semantics of the DL-program may contain spoiled information influencing the overall deduction. For avoiding unintuitive answer sets, we introduce a refined semantics for DL-programs that is sensitive for inconsistency caused by the combination of DL and LP, and dynamically deactivates rules whenever such an inconsistency would arise. We analyze the complexity of the new semantics, discuss implementational issues and introduce a notion of stratification that guarantees uniqueness of answer sets.
doi:10.1007/978-3-642-13486-9_13 fatcat:zyyd7brprffx3plcpec6tdkhbu
« Previous Showing results 1 — 15 out of 59 results