[Paper Review] A System for Interactive Query Answering with Answer Set Programming

Martin Gebser, Philipp Obermeier+1 more|arXiv (Cornell University)|Dec 20, 2013

Logic, Reasoning, and Knowledge13 references3 citations

TL;DR

This paper presents quontroller, a system that enables interactive query answering and theory exploration in Answer Set Programming (ASP) by integrating reactive ASP with a dedicated front-end. Leveraging oclingo’s online solving and a mapping scheme that uses sequence numbers and internal assertions, quontroller allows users to pose successive queries, temporarily assert hypotheses, and retract them—enabling efficient, incremental reasoning over dynamic logic programs without restarting the solver.

ABSTRACT

Reactive answer set programming has paved the way for incorporating online information into operative solving processes. Although this technology was originally devised for dealing with data streams in dynamic environments, like assisted living and cognitive robotics, it can likewise be used to incorporate facts, rules, or queries provided by a user. As a result, we present the design and implementation of a system for interactive query answering with reactive answer set programming. Our system quontroller is based on the reactive solver oclingo and implemented as a dedicated front-end. We describe its functionality and implementation, and we illustrate its features by some selected use cases.

Motivation & Objective

• Address the limitation of traditional one-shot ASP solvers that require relaunching for each new query or hypothesis.
• Enable interactive exploration of large, under-constrained domains such as biological networks, where users need to test multiple hypotheses incrementally.
• Support both temporary and persistent assertions of facts, rules, or queries during reasoning, mimicking in-silico experiments.
• Overcome modularity constraints in reactive ASP by mapping user queries to internal representations using sequence numbers and step counters.
• Provide a user-friendly front-end that integrates with oclingo to support online, incremental solving with labeled and volatile assertions.

Proposed method

• Use reactive ASP via oclingo to support online, incremental solving with dynamic input changes.
• Map user queries to internal representations using sequence numbers: e.g., 'mark(1,1).' becomes '_assert_mark(1,1,2)' in step 2.
• Implement labeled assertions (persistent) via '#assert' and volatile assertions (time-limited) via '#volatile' to control lifespan.
• Exploit oclingo’s assumption-based solving to manage transient rules, where expiration is enforced via assumption literals like '_expire(3)'
• Encode domain-specific logic in ASP (e.g., n-coloring) and use setup files to define domains, choices, and query projections.
• Support query streams with '#step', '#endstep', '#forget', and '#retract' to manage state transitions and retract prior assertions.

Experimental results

Research questions

• RQ1 How can interactive query answering be supported in Answer Set Programming without restarting the solver for each new query?
• RQ2 Can reactive ASP be adapted to support user-driven hypothesis testing through temporary or persistent rule and fact assertions?
• RQ3 How can modularity constraints in reactive ASP be overcome to allow repeated assertions of the same atom across different queries?
• RQ4 What mechanisms enable efficient incremental reasoning with persistent conflict information and dynamic domain updates?
• RQ5 How can a user interface be designed to support both labeled (persistent) and volatile (time-limited) assertions in a logical reasoning system?

Key findings

• quontroller enables interactive query answering by mapping user queries to reactive ASP rules using sequence numbers, allowing repeated assertions of the same atom across different queries.
• The system supports both labeled assertions (persistent until explicitly retracted) and volatile assertions (automatically expired after a defined number of steps), enabling flexible hypothesis testing.
• Using oclingo’s assumption-based solving, the system efficiently maintains conflict information and avoids redundant computation across query steps.
• In the n-coloring example, the first query yields six stable models; the second query, with a volatile assertion of mark(1,1), reduces this to two models.
• The third query, which asserts an edge to form a clique, results in no stable models, demonstrating the system’s ability to detect inconsistency under new hypotheses.
• After retracting the edge and adding a new volatile assertion, the system recovers a single stable model, showing effective incremental reasoning and state management.