= Multi-Context System Querying = <> == Problem Description == We consider queries over Multi-Context Systems (MCSs), which are a formalism for interlinking distributed (possibly nonmonotonic) knowledge bases - here called contexts - using pointwise information exchange in the form of (possibly nonmonotonic) logic programming rules - here called bridge rules. The "Equilibrium Semantics" definition which is the subject of these benchmark instances was introduced by Brewka and Eiter [1]. Intuitively, these semantics provide a logic programming layer that links contexts without imposing a foundedness condition on that knowledge integration layer. We consider systems where each context C_i is a propositional logic program P_i under stable model semantics. A query to output atom in(ContextID,Atom) shall return true iff in all equilibria of the encoded MCS, the atom "Atom" is contained in the stable model of context "ContextID". Rationale for this kind of benchmark instances: The problem instances consist of subprograms (contexts) that are interacting in a not very tight way (via bridge rules). The reasoning task itself is not hard, but instance sizes could become a challenge. A more detailed MCS semantics definition follows. (Note that the benchmark instance is for the system competition, so the semantics are taken care of in the given encoding.) For an MCS with n contexts, a belief state S is an n-tuple of models, one model S_i for each context C_i. A bridge rule of the form * (c_k : p_k) <- (c_1 : p_1), ..., not (c_j : p_j), ... . is applicable in belief state S if p_i \in S_{c_i},..., p_j \notin S_{c_j},... . Now S is an equilibrium if each program P_i plus heads bridge rules that are applicable wrt S has S_i as a stable model. For details on the semantics definition [1] and work leading up to that definition [2,3] please refer to references given below. == Input format == Input Predicates: ctx/1, ctxrule/2, ctxrulehead/2, ctxrulebody/3, brule/2, brulehead/2, brulebody/4 Input predicates specify contexts and bridge rules as follows: * ctx(ContextID): introduces identifiers of contexts. * ctxrule(ContextID,CRuleID): introduces identifies of rules in contexts. * ctxrulehead(CRuleID,Atom): describes the head of a rule within a context (a rule may have no head at all, in this case it is a constraint, or it has one head, there are no disjunctive rules). * ctxrulebody(CRuleID,Atom,PosNeg): describes one body atom of a rule within a context, where PosNeg is either "pos" or "neg" (without quotes). * brule(ContextID,BRuleID): introduces a bridge rule identifier at a certain context. * brulehead(BRuleID,Atom): describes the head of a bridge rule (there must be exactly one). * brulebody(BRuleID,ContextID,Atom,PosNeg): describes one body atom of a bridge rule, where ContextID is the context where the atom is checked, Atom is the atom, and PosNeg is again one of "pos" or "neg". == Output format == Output Predicates: in/2 == Example == == Author(s) == Author: Peter Schüller <
> Affiliation: Institute of Information Systems, TU Vienna == References == * [1] Brewka, G., and Eiter, T. 2007. ''Equilibria in heterogeneous nonmonotonic multi-context systems''. In AAAI Conference on Artificial Intelligence (AAAI), 385–390. * [2] Brewka, G., Roelofsen, F., and Serafini, L. 2007. ''Contextual default reasoning''. In International Joint Conference on Artificial Intelligence (IJCAI), 268–273. * [3] Giunchiglia, F., and Serafini, L. 1994. ''Multilanguage hierarchical logics, or: How we can do without modal logics''. Artificial Intelligence 65(1):29–70.