Abstract Modular Systems and Solvers
Integrating diverse formalisms into modular knowledge representation systems offers increased expressivity, modeling convenience and computational benefits. We introduce concepts of abstract modules and abstract modular systems to study general principles behind the design and analysis of model-finding programs, or solvers, for integrated heterogeneous multi-logic systems. We show how abstract modules and abstract modular systems give rise to transition systems, which are a natural and convenient representation of solvers pioneered by the SAT community. We illustrate our approach by showing how it applies to answer set programming and propositional logic, and to multi-logic systems based on these two formalisms.
Knowledge representation and reasoning (KR) is concerned with developing formal languages and logics to model knowledge, and with designing and implementing corresponding automated reasoning tools. The choice of specific logics and tools depends on the type of knowledge to be represented and reasoned about. Different logics are suitable for common-sense reasoning, reasoning under incomplete information and uncertainty, for temporal and spatial reasoning, and for modeling and solving boolean constraints, or constraints over larger, even continuous domains. In applications in areas such as distributed databases, semantic web, hybrid constraint modeling and solving, to name just a few, several of these aspects come to play. Accordingly, often diverse logics have to be accommodated together. Similar issues arise in research on multi-context systems where the major task is to model contextual information and the flow of information among contexts [17, 7]. The contexts are commonly modeled by theories in some logics.
Modeling convenience is not the only reason why diverse logics are combined into modular hybrid KR systems. Another major motivation is to exploit in reasoning the transparent structure that comes from modularity, computational strengths of individual logics, and synergies that may arise when they are put together. Constraint logic programming  and satisfiability modulo theories (SMT) [20, 2] are well-known examples of formalisms stemming directly from such considerations. More recent examples include constraint answer set programming (CASP) , which integrates answer set programming (ASP) [6, 15, 18]) with constraint modeling languages , and “multi-logic” formalisms PC(ID) , SM(ASP)  and ASP-FO  that combine modules expressed as logic theories under the classical semantics with modules given as answer-set programs.
The key computational task arising in KR is that of model generation. Model-generating programs or solvers, developed in satisfiability (SAT) and ASP proved to be effective in a broad range of KR applications. Accordingly, model generation is of critical importance in modular multi-logic systems. Research on formalisms listed above resulted in fast solvers that demonstrate gains one can obtain from their heterogeneous nature. However, the diversity of logics considered and low-level technical details of their syntax and semantics obscure general principles that are important in the design and analysis of solvers for multi-logic systems.
In this paper we address this problem by proposing a language for talking about modular multi-logic systems that (i) abstracts away the syntactic details, (ii) is expressive enough to capture various concepts of inference, and (iii) is based only on the weakest assumptions concerning the semantics. The basic elements of this language are abstract modules. Collections of abstract modules constitute abstract modular systems. We define the semantics of abstract modules and show that they provide a uniform language capable of capturing different logics, diverse inference mechanisms, and their modular combinations. Importantly, abstract modules and abstract modular systems give rise to transition systems of the type introduced by Nieuwenhuis, Oliveras, and Tinelli  in their study of SAT and SMT solvers. We show that as in that earlier work, our transition systems provide a natural and convenient representation of solvers for abstract modules and abstract modular systems. We demonstrate that they lend themselves well to extensions that capture such important solver design techniques as learning (which here comes in two flavors: local that is limited to single modules, and global that is applied across modules). Throughout the paper, we illustrate our approach by showing how it applies to propositional logic and answer set programming, and to multi-logic systems based on these two formalisms.
The results of our paper show that abstract modular systems and the corresponding abstract framework for describing and analyzing algorithms for modular declarative programming tools relying on multi-logics are useful and effective conceptualizations that can contribute to (i) clarifying computational principles of such systems and to (ii) the development of new ones.
The paper is organized as follows. We start by introducing one of the main concepts in the paper – abstract modules. We then proceed to formulating an algorithm (a family of algorithms) for finding models of such modules. We use an abstract transition system stemming from the framework by Nieuwenhuis et al.  for this purpose. Section 4 presents the definition of an abstract modular system and a corresponding solver based on backtrack search. We then discuss how this solver maybe augmented by such advanced SAT solving technique as learning. Section 6 provides an account on related work.
2 Abstract Modules
Let be a fixed finite vocabulary (a set of propositional atoms). A module over the vocabulary is a directed graph whose nodes are and all consistent sets of literals, and each edge is of the form or , where and is a shorthand for . If is a module, we write for its vocabulary. For a set of literals, we denote and .
Intuitively, an edge in a module indicates that the module supports inferring whenever all literals in are given. An edge , , indicates that there is a literal such that a derivation of its dual (and hence, a derivation of a contradiction) is supported by the module, assuming the literals in are given. Finally, the edge indicates that the module is “explicitly” contradictory.
A node in a module is terminal if no edge leaves it. A terminal node that is consistent and complete is a model node of the module. A set of atoms is a model of a module if for some model node in , . Thus, models of modules are not restricted to the signature of the module. Clearly, for every model node in , is a model of .
A module entails a formula , written , if for every model of we have . It is immaterial what logic the formula comes from as long as (i) the vocabulary of the logic is a subset of the vocabulary of , and (ii) the semantics of the logic is given by a satisfiability relation . A module entails a formula wrt a set of literals (over the same vocabulary as ), written , if for every model of such that and , .
Clearly, if two modules over the same signature have the same model nodes, they have the same models. Semantically the three modules in Figure 1 are the same. They have the same models (each has as its only model in the signature of the module) and so they entail the same formulas. We call modules with the same models equivalent.
Modules represent more than just the set of their models. As already suggested above, the intended role of edges in a module is to represent allowed “local” inferences. For instance, given the empty set of literals, the first module in Figure 1 supports inferring and the third module . In the latter case, the inference is not “sound” as it contradicts the semantic information in the module as that module does not entail with respect to the empty set of literals.
Formally, an edge from a node to a node in a module is sound if .111In the paper, we sometimes identify a set of literals with the conjunction of its elements. Here is to be understood as the conjunction of its elements. Clearly, if has the form then if and only if . Similarly, if then if and only if no model of is consistent with (that is, contains and is disjoint with ). A module is sound if all of its edges are sound, that is, if all inferences supported by the module are sound with respect to the semantics of the module given by its set of models. The modules in Figures 1(a) and (b) are sound, the one in Figure 1(c) is not. Namely, the inference of from is not sound.
Given two modules and over the same vocabulary, we say that is equivalently contained in , , if and are equivalent (have the same model nodes) and the set of edges of is a subset of the set of edges of . Maximal (wrt ) sound modules are called saturated. We say that an edge from a node to in a module is critical if is a complete and consistent set of literals over . The following properties are evident.
Every two modules over the same signature and with the same critical edges are equivalent. For a saturated module , every sound module with the same critical edges as is equivalently contained in . A module is saturated if and only if it is sound and for every set of literals and for every literal , is an edge of whenever .
Clearly, only the module in Figure 1(a) is saturated. The other two are not. The one in (b) is not maximal with respect to the containment relation, the one in (c) is not sound. We also note that all three modules have the same critical edges. Thus, by Proposition 1, they are equivalent, a property we already observed earlier. Finally, the module in Figure 1(b) is equivalently contained in the module in Figure 1(a).
In practice, modules (graphs) are specified by means of theories and logics (more precisely, specific forms of inference in logics). For instance, a propositional theory over a vocabulary and the inference method given by the classical concept of entailment determine a module over in which (i) is an edge if and only if ; and (ii) is an edge if and only if no model of is consistent with . Figure 1(a) shows the module determined in this way by the theory consisting of the clause . Similarly, Figure 2 presents such a module for the theory
This module is saturated. Also, theory (1) and the inference method given by the unit propagate rule, a classical propagator used in SAT solvers, determines this module. In other words, for the theory (1) the unit propagation rule captures entailment.
Modules are not meant for modeling. Representations by means of logic theories are usually more concise (the size of a module is exponential in the size of its vocabulary). Furthermore, the logic languages align closely with natural language, which facilitates modeling and makes the correspondence between logic theories and knowledge they represent direct. Modules lack this connection to natural language.
The power of modules comes from the fact that they provide a uniform, syntax-independent way to describe theories and inference methods stemming from different logics. For instance, they represent equally well both propositional theories and logic programs under the answer-set semantics. Indeed, let us consider the logic program
where represents the so-called choice rule . This program has two answer sets and . Since these are also the only two models of the propositional theory (1), it is clear that the module in Figure 2 represents the program (2) and the reasoning mechanism of entailment with respect to its answer sets. Two other modules associated with program (2) are given in Figure 3. The module in Figure 3(a) represents program (2) and the reasoning on programs based on forward chaining; we call this module . We recall that given a set of literals, forward chaining supports the derivation of the head of a rule whose body is satisfied. We note that the module is not equivalent to program (2). Indeed, is a model of whereas it is not an answer set of (2). This is due to the fact that the critical edge from to is unsupported by forward chaining and is not present in . On the other hand, all edges due to forward chaining are sound both in the module in Figure 2, which we call , and . In the next section we discuss a combination of inference rules that yields a reasoning mechanism subsuming forward chaining and resulting in a module, shown in Figure 3(b), that is equivalently contained in and so, equivalent to the program (2). This discussion indicates that the language of modules is flexible enough to represent not only the semantic mechanism of entailment, but also syntactically defined “proof systems” — reasoning mechanisms based on specific inference rules.
3 Abstract Modular Solver:
Finding models of logic theories and programs is a key computational task in declarative programming. Nieuwenhuis et al.  proposed to use transition systems to describe search procedures involved in model-finding programs commonly called solvers, and developed that approach for the case of SAT. Their transition system framework can express dpll, the basic search procedure employed by SAT solvers, and its enhancements such as conflict driven clause learning. Lierler  proposed a similar framework for specifying an answer set solver smodels. Lierler and Truszczynski  extended that framework to capture such modern ASP solvers as cmodels and clasp, as well as a PC(ID) solver minisat(id).
An abstract nature (independence from language and reasoning method selection) of modules introduced in this work and their relation to proof systems makes them a convenient, broadly applicable tool to study and analyze solvers. In this section, we adapt the transition system framework of Nieuwenhuis et al.  to the case of abstract modules. We then illustrate how it can be used to define solvers for instantiations of abstract modules such as propositional theories under the classical semantics and logic programs under the answer-set semantics.
A state relative to is either a special state (fail state) or an ordered consistent set of literals over , some possibly annotated by , which marks them as decision literals. For instance, the states relative to a singleton set of atoms are
Frequently, we consider a state as a set of literals, ignoring both the annotations and the order between its elements. If neither a literal nor its complement occur in , then is unassigned by .
Each module determines its transition graph : The set of nodes of consists of the states relative to the vocabulary of . The edges of the graph are specified by the transition rules listed in Figure 4. The first three rules depend on the module, the fourth rule, Decide, does not. It has the same form no matter what module we consider. Hence, we omit the reference to the module from its notation.
The graph can be used to decide whether a module has a model. The following properties are essential.
For every sound module ,
graph is finite and acyclic,
for any terminal state of other than , is a model of ,
state is reachable from in if and only if is unsatisfiable (has no models).
Thus, to decide whether a sound module has a model it is enough to find in the graph a path leading from node to a terminal node . If , is unsatisfiable. Otherwise, is a model of .
For instance, let be a module in Figure 2. Below we show a path in the transition graph with every edge annotated by the corresponding transition rule:
The state is terminal. Thus, Theorem 3.1 (b) asserts that is a model of . There may be several paths determining the same model. For instance, the path
leads to the terminal node , which is different from but corresponds to the same model. We can view a path in the graph as a description of a process of search for a model of module by applying transition rules. Therefore, we can characterize a solver based on the transition system by describing a strategy for choosing a path in . Such a strategy can be based, in particular, on assigning priorities to some or all transition rules of , so that a solver will never apply a transition rule in a state if a rule with higher priority is applicable to the same state. For example, priorities
on the transition rules of specify a solver that follows available inferences (modeled by edges in the module ) before executing a transition due to Decide. The path (3) in the transition graph of the module from Figure 2 follows that strategy, whereas the path (4) does not.
We now review the graph introduced for the classical DPLL algorithm by Nieuvenhuis et al. , adjusting the presentation to the form convenient for our purposes. We then demonstrate its relation to the graph. The set of nodes of consists of the states relative to the vocabulary of a CNF formula (a set of clauses) . The edges of the graph are specified by the transition rule Decide of the graph and the rules presented in Figure 5.
For example, let be the theory consisting of a single clause . Figure 6 presents .
For a CNF formula , by we denote the graph (abstract module) constructed from by dropping all nodes that contain decision literals. We note that for the graph in Figure 6, the module coincides with the module in Figure 1(a). This is a manifestation of a general property.
For every CNF formula , the graph is a sound abstract module equivalent to . Furthermore, the graphs and are identical.
Theorem 3.1 and the fact that the module is equivalent to a CNF formula (Proposition 2) imply that the graph can be used for deciding the satisfiability of . It is enough to find a path leading from node to a terminal node : if then is unsatisfiable; otherwise, is a model of . For instance, the only terminal states reachable from the state in are and . This translates into the fact that is a model of . This is exactly the result that Nieuwenhuis et al.  stated for the graph :
For any CNF formula ,
graph is finite and acyclic,
for any terminal state of other than , is a model of ,
state is reachable from in if and only if is unsatisfiable (has no models).
We now introduce the graph that extends the dpll graph by Nieuwenhuis et al. so that the result can be used to specify an algorithm for finding answer sets of a program. The graph can be used to form a sound module equivalent to a program in the same way as we used to form a sound module equivalent to a CNF formula .
We assume the reader to be familiar with the concept of unfounded sets [26, 10]. For a set of literals and a program , by we denote an unfounded set on w.r.t. . It is common to identify logic rules of a program with sets of clauses. By we denote the set of clauses corresponding to the rules of . For instance, let be (2), then consists of clauses .
The set of nodes of consists of the states relative to the vocabulary of program . The edges of the graph are specified by the transition rules of the graph and the rules presented in Figure 7.
For a program , by we denote the graph (abstract module) constructed from by removing all nodes that contain decision literals.
For every program , the graph is a sound abstract module equivalent to a program under the answer set semantics. Furthermore, the graphs and are identical.
From Theorem 3.1 and the fact that is an abstract module equivalent to an answer-set program it follows that the graph can be used for deciding whether has an answer set. It is enough to find a path in leading from the node to a terminal node . If then has no answer sets; otherwise, is an answer set of .
For any program ,
graph is finite and acyclic,
for any terminal state of other than , is an answer set of ,
state is reachable from in if and only if has no answer sets.
Let be the program (2). Figure 3(b) presents the module . It is easy to see that this module is equivalently contained in the saturated module for presented in Figure 2. For program the inference rules of UnitPropagate and Unfounded are capable to capture all but one inference due to the entailment (the missing inference corresponds to the edge from to in Figure 2).
Let us now consider the graph constructed from by either dropping the rules , , or the rules , , . In each case, the module in general is not equivalent to a program . This demonstrates the importance of two kinds of inferences for the case of logic programs: (i) those stemming from unit propagate and related to the fact that an answer set of a program is also its classical model; as well as (ii) those based on the concept of “unfoundedness” and related to the fact that every answer set of a program contains no unfounded sets. We note that forward chaining mentioned in earlier section is subsumed by unit propagate.
The graph is inspired by the graph introduced by Lierler  for specifying an answer set solver smodels . The graph extends by two additional transition rules (inference rules or propagators): All Rules Cancelled and Backchain True. We chose to start the presentation with the graph for its simplicity. We now recall the definition of and illustrate how a similar result to Proposition 3 is applicable to it.
If is a conjunction of literals then by we understand the set of the complements of literals occurring in .
The set of nodes of consists of the states relative to the vocabulary of program . The edges of the graph are specified by the transition rules of the graph and the following rules:
The graph shares the important properties of the graph . Indeed, Proposition 3 and Corollary 2 hold if one replaces with . Corollary 2 in this form was one of the main results stated in 222In , Lierler presented the graph in a slightly different from: the states of that graph permitted inconsistent states of literals, which in turn allowed to unify the Fail and Backtrack transition rules for different propagators..
Let be the program (2). Figure 3(b) presents the module . The module coincides with the saturated module for presented in Figure 2. For program , the inference rule Backchain True captures the inference that corresponds to the edge from to , which the transition rules of the graph are incapable to capture.
The examples above show that the framework of abstract modules uniformly encompasses different logics. We illustrated this point by means of propositional logic and answer-set programming. Furthermore, it uniformly models diverse reasoning mechanisms (entailment and its proof theoretic specializations). The results also demonstrate that transition systems proposed earlier to represent and analyze SAT and ASP solvers are special cases of general transition systems for abstract modules introduced here.
4 Abstract Modular System and Solver
By capturing diverse logics in a single framework, abstract modules are well suited for studying modularity in declarative formalisms, and principles underlying solvers for modular declarative formalisms. We now define an abstract modular declarative framework that uses the concept of a module as its basic element. We then show how abstract transition systems for modules generalize to the new formalism.
An abstract modular system (AMS) is a set of modules. The vocabulary of an AMS is the union of the vocabularies of modules of (they do not have to have the same vocabulary); we denote it by .
An interpretation over (that is, a subset of ) is a model of , written , if is a model of every module . An AMS entails a formula (over the same vocabulary as ), written , if for every model of we have . We say that an AMS is sound if every module is sound.
For a vocabulary and a set of literals , by we denote the maximal subset of consisting of literals over . For example, .
Each AMS determines its transition system . The set of nodes of consists of the states relative to . The transition rules of comprise the rule Decide and the rules , , and , for all modules . The latter three rules are modified to account for the vocabulary and are presented in Figure 8.
For every sound AMS ,
the graph is finite and acyclic,
any terminal state of other than is a model of ,
the state is reachable from in if and only if is unsatisfiable.
This theorem demonstrates that to decide a satisfiability of a sound AMS it is sufficient to find a path leading from node to a terminal node. It provides a foundation for the development and analysis of solvers for modular systems.
For instance, let be the AMS . Below is a valid path in the transition graph with every edge annotated by the corresponding transition rule:
The state is terminal. Thus, Theorem 4.1 (b) asserts that is a model of . Let us interpret this example. Earlier we demonstrated that module can be regarded as a representation of a propositional theory consisting of a single clause whereas corresponds to the logic program (2) under the semantics of answer sets. We then illustrated how modules and give rise to particular algorithms for implementing search procedures. The graph represents the algorithm obtained by integrating the algorithms supported by the modules and separately.
The results presented above imply, as special cases, earlier results on the logics PC(ID) and SM(ASP), and their solvers .
5 Learning in Solvers for AMSs.
Nieuwenhuis et al. [20, Section 2.4] defined the DPLL System with Learning graph to describe SAT solvers’ learning, one of the crucial features of current SAT solvers responsible for rapid success in this area of automated reasoning. The approach of Nieuwenhuis, Oliveras, and Tinelli extends to our abstract setting. Specifically, the graph can be extended with “learning transitions” to represent solvers for AMSs that incorporate learning.
The intuition behind learning in SAT is to allow new propagations by extending the original clause database as computation proceeds. These “learned” clauses provide new “immediate derivations” to a SAT solver by enabling additional applications of UnitPropagate. In the framework of abstract modules, immediate derivations are represented by edges. Adding edges to modules captures the idea of learning by supporting new propagations that the transition rule Propagate may take an advantage of. We now state these intuitions formally for the case of abstract modular systems.
Let be a module and a set of edges between nodes of . By we denote the module constructed by adding to the edges in . A set of edges is -safe if the module is sound and equivalent to . For an AMS and a set of edges over the vocabulary of , we define (where is the set of those edges in that connect nodes in ). We say that is -safe if and are equivalent, and each module in is sound.
An (augmented) state relative to an AMS is either a distinguished state or a pair of the form where is an ordered consistent set of literals over , some possibly annotated by ; and are sets of edges between nodes of modules , respectively. Sometimes we denote by . For any AMS , we define a graph . Its nodes are the augmented states relative to . The rule Decide of the graph extends to as follows
Figure 9 presents the transition rules of that are specific to each module in . We note that the set of edges in the rule is required to consist of edges that run between the nodes of . The transition rule
where is a set of edges between nodes over the vocabulary , concludes the definition of .
We refer to the transition rules Propagate, Backtrack, Decide, and Fail of the graph as basic. We say that a node in the graph is semi-terminal if no basic rule is applicable to it. The graph can be used for deciding whether an AMS has an answer set by constructing a path from to a semi-terminal node.
For any sound AMS ,
there is an integer such that every path in contains at most edges due to basic transition rules,
for any semi-terminal state of reachable from , is a model of ,
state is reachable from in if and only if has no models.
It follows that if we are constructing a path starting in in a way that guarantees that every sequence of consecutive edges of the path labeled with Learn Local and Learn Global eventually ends (is finite), then the path will reach some semi-terminal state. As soon as a semi-terminal state is reached the problem of finding a model is solved.
There is an important difference between Learn Local and Learn Global. The first one allows new propagations within a module but does not change its semantics as the models of the module stay the same (and it is local, other modules are unaffected by it). The application of Learn Global while preserving the overall semantics of the system may change the semantics of individual modules by eliminating some of their models (and, being global, affects in principle all modules of the system). SAT researchers have demonstrated that Learn Local is crucial for the success of SAT technology both in practice and theoretically. Our initial considerations suggest that under some circumstances, Learn Global offers additional substantial performance benefits.
We stress that our discussion of learning does not aim at any specific algorithmic ways in which one could perform learning. Instead, we formulate conditions that learned edges are to satisfy (-safety for learning local to a module , and -safety for the global learning rule), which ensure the correctness of solvers that implement learning so that to satisfy them. In this way, we provide a uniform framework for correctness proofs of multi-logic solvers incorporating learning.
6 Related Work
In an important development, Brewka and Eiter  introduced an abstract notion of a heterogeneous nonmonotonic multi-context system (MCS). One of the key aspects of that proposal is its abstract representation of a logic and hence contexts that rely on such abstract logics. The independence of contexts from syntax promoted focus on semantic aspect of modularity exhibited by multi-context systems. Since their inception, multi-context systems have received substantial attention and inspired implementations of hybrid reasoning systems including dlvhex  and dmcs . Abstract modular systems introduced here are similar to MCSs as they too do not rely on any particular syntax for logics assumed in modules (a counterpart of a context). What distinguishes them is that they encapsulate some semantic features stemming from inferences allowed by the underlying logic. This feature of abstract modules is essential for our purposes as we utilize them as a tool for studying algorithmic aspects of multi-logic systems. Another difference between AMS and MCS is due to “bridge rules.” Bridge rules are crucial for defining the semantics of an MCS. They are also responsible for “information sharing” in MCSs. They are absent in our formalism altogether. In AMS information sharing is implemented by a simple notion of a shared vocabulary between the modules.
Modularity is one of the key techniques in principled software development. This has been a major trigger inspiring research on modularity in declarative programming paradigms rooting in KR languages such as answer set programming, for instance. Oikarinen and Janhunen  proposed a modular version of answer set programs called lp-modules. In that work, the authors were primarily concerned with the decomposition of lp-modules into sets of simpler ones. They proved that under some assumptions such decompositions are possible. Järvisalo, Oikarinen, Janhunen, and Niemelä , and Tasharrofi and Ternovska  studied the generalizations of lp-modules. In their work the main focus was to abstract lp-modules formalism away from any particular syntax or semantics. They then study properties of the modules such as “joinability” and analyze different ways to join modules together and the semantics of such a join. We are interested in building simple modular systems using abstract modules – the only composition mechanism that we study is based on conjunction of modules. Also in contrast to the work by Järvisalo et al.  and Tasharrofi and Ternovska , we define such conjunction for any modules disregarding their internal structure and interdepencies between each other.
Tasharrofi, Wu, and Ternovska  developed and studied an algorithm for processing modular model expansion tasks in the abstract multi-logic system concept developed by Tasharrofi and Ternovska . They use the traditional pseudocode method to present the developed algorithm. In this work we adapt the graph-based framework for designing backtrack search algorithms for abstract modular systems. The benefits of that approach for modeling families of backtrack search procedures employed in SAT, ASP, and PC(ID) solvers were demonstrated by Nieuwenhuis et al. , Lierler , and Lierler and Truszczynski . Our work provides additional support for the generality and flexibility of the graph-based framework as a finer abstraction of backtrack search algorithms than direct pseudocode representations, allowing for convenient means to prove correctness and study relationships between the families of the algorithms.
We introduced abstract modules and abstract modular systems and showed that they provide a framework capable of capturing diverse logics and inference mechanisms integrated into modular knowledge representation systems. In particular, we showed that transition graphs determined by modules and modular systems provide a unifying representation of model-generating algorithms, or solvers, and simplify reasoning about such issues as correctness or termination. We believe they can be useful in theoretical comparisons of solver effectiveness and in the development of new solvers. Learning, a fundamental technique in solver design, displays itself in two quite different flavors, local and global. The former corresponds to learning studied before in SAT and SMT and demonstrated both theoretically and practically to be essential for good performance. Global learning is a new concept that we identified in the context of modular systems. It concerns learning across modules and, as local learning, promises to lead to performance gains. In the future work we will conduct a systematic study of global learning in abstract modular systems and its impact on solvers for practical multi-logic formalisms.
-  Bairakdar, S.E.D., Dao-Tran, M., Eiter, T., Fink, M., Krennwallner, T.: The dmcs solver for distributed nonmonotonic multi-context systems. In: 12th European Conference on Logics in Artificial Intelligence (JELIA). pp. 352–355 (2010)
-  Barrett, C., Sebastiani, R., Seshia, S., Tinelli, C.: Satisfiability modulo theories. In: Biere, A., Heule, M., van Maaren, H., Walsch, T. (eds.) Handbook of Satisfiability, pp. 737–797. IOS Press (2008)
-  Brewka, G., Eiter, T.: Equilibria in heterogeneous nonmonotonic multi-context systems. In: Proceedings of National conference on Artificial Intelligence (AAAI). pp. 385–390 (2007)
-  Denecker, M., Lierler, Y., Truszczynski, M., Vennekens, J.: A Tarskian informal semantics for answer set programming. In: Dovier, A., Costa, V.S. (eds.) International Conference on Logic Programming (ICLP). LIPIcs, vol. 17. Schloss Dagstuhl - Leibniz-Zentrum fuer Informatik (2012)
-  Eiter, T., Ianni, G., Schindlauer, R., Tompits, H.: A uniform integration of higher-order reasoning and external evaluations in answer set programming. In: Proceedings of International Joint Conference on Artificial Intelligence (IJCAI). pp. 90–96 (2005)
-  Gelfond, M., Lifschitz, V.: The stable model semantics for logic programming. In: Kowalski, R., Bowen, K. (eds.) Proceedings of International Logic Programming Conference and Symposium. pp. 1070–1080. MIT Press (1988)
-  Giunchiglia, F.: Contextual reasoning. Epistemologia XVI, 345–364 (1993)
-  Jaffar, J., Maher, M.: Constraint logic programming: A survey. Journal of Logic Programming 19(20), 503–581 (1994)
-  Järvisalo, M., Oikarinen, E., Janhunen, T., Niemelä, I.: A module-based framework for multi-language constraint modeling. In: Proceedings of the 10th International Conference on Logic Programming and Nonmonotonic Reasoning. pp. 155–168. LPNMR ’09, Springer-Verlag, Berlin, Heidelberg (2009), http://dx.doi.org/10.1007/978-3-642-04238-6_15
-  Lee, J.: A model-theoretic counterpart of loop formulas. In: Proceedings of International Joint Conference on Artificial Intelligence (IJCAI). pp. 503–508. Professional Book Center (2005)
-  Lierler, Y.: Abstract answer set solvers. In: Proceedings of International Conference on Logic Programming (ICLP). pp. 377–391. Springer (2008)
-  Lierler, Y.: Abstract answer set solvers with backjumping and learning. Theory and Practice of Logic Programming 11, 135–169 (2011)
-  Lierler, Y.: On the relation of constraint answer set programming languages and algorithms. In: Proceedings of the AAAI Conference on Artificial Intelligence. MIT Press (2012)
-  Lierler, Y., Truszczynski, M.: Transition systems for model generators — a unifying approach. Theory and Practice of Logic Programming, 27th Int’l. Conference on Logic Programming (ICLP’11) Special Issue 11, issue 4-5 (2011)
-  Marek, V., Truszczyński, M.: Stable models and an alternative logic programming paradigm. In: The Logic Programming Paradigm: a 25-Year Perspective, pp. 375–398. Springer Verlag (1999)
-  Mariën, M., Wittocx, J., Denecker, M., Bruynooghe, M.: SAT(ID): Satisfiability of propositional logic extended with inductive definitions. In: SAT. pp. 211–224 (2008)
-  McCarthy, J.: Generality in Artificial Intelligence. Communications of the ACM 30(12), 1030–1035 (1987), reproduced in [mcc90]
-  Niemelä, I.: Logic programs with stable model semantics as a constraint programming paradigm. Annals of Mathematics and Artificial Intelligence 25, 241–273 (1999)
-  Niemelä, I., Simons, P.: Extending the Smodels system with cardinality and weight constraints. In: Minker, J. (ed.) Logic-Based Artificial Intelligence, pp. 491–521. Kluwer (2000)
-  Nieuwenhuis, R., Oliveras, A., Tinelli, C.: Solving SAT and SAT modulo theories: From an abstract Davis-Putnam-Logemann-Loveland procedure to DPLL(T). Journal of the ACM 53(6), 937–977 (2006)
-  Oikarinen, E., Janhunen, T.: Modular equivalence for normal logic programs. In: 17th European Conference on Artificial Intelligence(ECAI). pp. 412–416 (2006)
-  Rossi, F., van Beek, P., Walsh, T.: Constraint programming. In: van Harmelen, F., Lifschitz, V., Porter, B. (eds.) Handbook of Knowledge Representation, pp. 181–212. Elsevier (2008)
-  Simons, P., Niemelä, I., Soininen, T.: Extending and implementing the stable model semantics. Artificial Intelligence 138, 181–234 (2002)
-  Tasharrofi, S., Ternovska, E.: A semantic account for modularity in multi-language modelling of search problems. In: Frontiers of Combining Systems, 8th International Symposium (FroCoS). pp. 259–274 (2011)
-  Tasharrofi, S., Wu, X.N., Ternovska, E.: Solving modular model expansion tasks. CoRR abs/1109.0583 (2011)
-  Van Gelder, A., Ross, K., Schlipf, J.: The well-founded semantics for general logic programs. Journal of ACM 38(3), 620–650 (1991)