EP3545473A1

EP3545473A1 - Branching heuristics for an lazy-grounding-based asp solver

Info

Publication number: EP3545473A1
Application number: EP18704466.4A
Authority: EP
Inventors: Richard TAUPE
Original assignee: Siemens AG Oesterreich
Current assignee: Siemens AG Oesterreich
Priority date: 2017-02-06
Filing date: 2018-01-31
Publication date: 2019-10-02
Also published as: WO2018141763A1

Abstract

The invention is related to a Computer implemented Lazy-Grounding-based ASP Solver characterized in that a branching heuristic is used to steer the search for solutions.

Description

Beschreibung / Description

Branching Heuristics for an Lazy-Grounding-based ASP Solver The invention is related to Answer Set Programming (ASP) , which is a popular approach to declarative problem solving.

Problem encodings (programs) consist of logical rules which may contain variables. Such programs are then solved by ASP systems, the most prominent example being the Potsdam Answer Set Solving Collection (Potassco, https://potassco.org/) . State-of-the-art systems require their users to first run a grounder on the model, which replaces the variables in the rules with all possible constant values they may take. Then a solver is run on the resulting propositional (variable-free) model. Grounding usually leads to a blow-up in space, i.e. the produced ground programs are very large. This constitues a bottleneck in the answer-set solving process and makes the approach unfit for large-scale (industrial) problem instanc- es .

As already said, ASP programs consist of logical sentences (or rules) . The most basic form of such rules is as follows: ao :^_ ai, a_m, not a_m+i, not a_n.

For 0 ≤ i ≤ n, a± is a so-called atom. The atom aO in the above rule is called the head of the rules, while the other atoms form its body.

This basic form of rule is extended by various language con^¬ structs in ASP, but these are out of scope of this document.

As described above, a program consisting of such rules and containing variables is first processed by a grounder which produces a variable-free program, which is equivalent to, but usually significantly larger than the original program. This program again consists of rules of the given form, but now these rules contain no variables anymore. To mitigate the problem of the grounding bottleneck, new ASP systems have been developed that do not rely on pre- grounding. This approach is called "lazy grounding". To my knowledge, there exist four systems implementing lazy ground- ing :

ASPeRiX (Claire Lefevre, Christopher Beatrix, Igor

Stephan, and Laurent Garcia: Asperix, a first order forward chaining approach for answer set computing. CoRR, abs/1503.07717, 2015)

GASP (Alessandro Dal Palii, Agostino Dovier, Enrico

Pontelli, and Gianfranco Rossi: Gasp: Answer set pro^¬ gramming with lazy grounding. Fundamenta Informaticae, 2009)

- OMiGA (Minh Dao-Tran, Thomas Eiter, Michael Fink, Gerald Weidinger, and Antonius Weinzierl: Omiga: An open minded grounding on-the-fly answer set solver. In Luis Farinas del Cerro, Andreas Herzig, and Jerome Mengin, editors, Logics in Artificial Intelligence, volume 7519 of Lec^¬ ture Notes in Artificial Intelligence, pages 480-483, Berlin, Heidelberg, 2012. Springer)

Alpha (the successor of OMiGA, currently being developed by Antonius Weinzierl et al . at

github.com/AntoniusW/Alpha, no research paper yet).

While all of these systems manage to mitigate the grounding problem using various approaches, neither of them can compete with state-of-the-art systems like Potassco in terms of time consumption, i.e. they take much longer to compute a solution to an ASP problem. How to achieve better performance is cur^¬ rently the big open problem of lazy grounding.

One approach to improve performance is to invent good domain independent heuristics to steer the search for solutions, i.e. to decide which branches in the search space to explore first . Known and established heuristics for ASP, most notably

BerkMin (Goldberg, E . ; Novikov, Y . (2002): BerkMin: A fast and robust SAT-solver. In : Design, Automation and Test in Europe Conference and Exhibition, 2002. Proceedings. IEEE, pp. 142-149), are designed in a way such that they work only for pre-grounding systems, i.e. the whole search space must be known to be able to compute values for heuristic deci^¬ sions . The invention relates directly to the approach implemented by Alpha, which is based on conflict-driven nogood learning, an idea also implemented by state-of-the-art systems like

Potassco (Gebser, M., Kaufmann, B., Schaub, T.: Conflict- driven Answer Set Solving: From Theory to Practice. Artifi- cial Intelligence 187-188, 52{89 (2012)).

For presentation, we divide the decision procedure of the heuristic into three methods: chooseAtom() chooses an atom to explore next, chooseSign() decides which value (true or false) to assign to it, and getMostActiveBody ( ) uses one of several aggregate functions to choose a rule body which is considered most active. chooseAtomO

o a ^-mo st active atom occurring in recently learned nogoods (as in BerkMin)

o B ^-set of atoms representing bodies of rules in which a occurs (in the head or in the body)

o B ^-elements of B that are not yet assigned

o b ^-getMostActiveBody (B)

o return b

getMostActiveBody (B : set of atoms representing rule bodies)

o return b in B which exhibits the highest aggrega- tion of activity values (computed as in BerkMin) over its literals

chooseSign (a : atom)

o h head of role whose body is represented by a o proceed as in BerkMin, i.e.:

- choose value for h that is likely to satisfy more nogoods in which h occurs, i.e.:

- if h occurs more often positively

· return false

else

• return true

Note that the method getMostActiveBody can be implemented us- ing one of several aggregation functions, thereby providing a degree of variability to create different variants of the heuristic. Possible aggregation functions are: max, sum, avg,

As initial experiments show, the new heuristic is able to find a solution in fewer steps compared to a direct applica^¬ tion of BerkMin to a lazy-grounding solver. At the moment we only have a very prototypical implementation of the new heu^¬ ristic, which still suffers from overhead that renders these gains void in many cases. More efficient implementations will be developed until the paper deadline (see section 13) .

Having no special heuristic at all, compared to using one like the one described before, has the disadvantage of lead^¬ ing to unpredictable and often inferior solving performance.

Ideas from BerkMin have been borrowed and extended substan^¬ tially as described to fit the approach taken by the lazy- grounding solver Alpha. Past endeavours to use ASP in an industrial setting, e.g. for large-scale configuration problems have often failed because of the grounding bottleneck. This invention is an important step towards improving the performance of ASP systems that have the potential to solve also large-scale problem instanc- es .

Claims

Patentanspriiche / Patent claims

Computer implemented Lazy-Grounding-based ASP Solver characterized in that a branching heuristic is used to steer the search for solutions.

Computer implemented Lazy-Grounding-based ASP Solver ac cording to claim 1 characterized in that the decision procedure of the heuristic is divided into three meth^¬ ods: chooseAtomO chooses an atom to explore next, chooseSign() decides which value (true or false) to as^¬ sign to it, and getMostActiveBody ( ) uses one of several aggregate functions to choose a rule body which is con^¬ sidered most active.