A Survey of Evaluation Techniques and Systems for Answer Set Programming

Introduction and Preliminaries
Evaluation Techniques and Systems
Interfaces and Systems for Extensions
References
A Survey of Evaluation Techniques
and Systems for Answer Set Programming
Francesco Ricca
University of Calabria, Italy
Klagenfurt 2019
Francesco Ricca Techniques and Systems for ASP

References
Outline
1 Introduction and Preliminaries
2 Evaluation Techniques and Systems
3 Interfaces and Systems for Extensions

References
Answer Set Programming (ASP) (1)
Answer Set Programming (ASP)[BET11]
Declarative programming paradigm
Non-monotonic reasoning and logic programming
Stable model semantics [GL91]
Expressive KRR Language
Roots in Datalog and Nonmonotonic logic
Extended over the years to ease modeling
→ Disjunction, (Weak) Constraints, Aggregates, Functions...
Can model problems up to ΣP
2 /ΠP
2 [EGM97, DEGV01]
→ even problems not (polynomially) translatable to SAT
Standardized syntax: ASPCore 2.0 [CFG+
12]

References
Idea:
1 Represent a computational problem by a Logic program
2 Answer sets correspond to problem solutions
3 Use an ASP solver to ﬁnd these solutions

References
ASP: A Major paradigm for logic-based AI
1 Declarative, readable and expressive language
→ stable model semantics, language extensions [GL91])
2 Robust and efﬁcient implementations [LMR16]
→ continuous improvements (see ASP comp. [CGMR16, GMR17])
3 Applications in several ﬁelds [EGL16]
Workforce Management, Planning, Scheduling,
Information Integration, Data cleaning, Bioinformatics,
Robotics, Natural Language Understanding, ...
see e.g. [Lif02, EFLP99, EFLP99, EIST06, EEB10, Sak11, SN99,
DGH09, CHO+
09, RDG+
10, RGA+
12, GNA13]

References
ASP Syntax
Rule: a1 | . . . | an :- b1, . . . , bk , not bk+1, . . . , not bm.
head body
Atoms and Literals: ai , bi , not bi
Positive Body: b1, . . . , bk
Negative Body: not bk+1, . . . , not bm.
Fact: A rule with empty body
Constraint: A rule with empty head
Variables: allowed in atom’s arguments
Must occur in the positive body (Safety)
Can be seen as placeholders for constants

References
Informal Semantics
head body
Informal Semantics:
“If all b1, . . . , bk are true and all bk+1, . . . , bm are not true,
then at least one among a1, . . . , an is true”.

References
Informal Semantics
head body
Informal Semantics:
“If all b1, . . . , bk are true and all bk+1, . . . , bm are not true,
then at least one among a1, . . . , an is true”.
Example
isInterestedinASP(X) | isCurious(X) :- attendsASP(X).
attendsASP(john).
Two (minimal) models encoding two plausible scenarios:
M1:{isInterestedinASP(john), attendsASP(john).}
M2:{isCurious(john), attendsASP(john).}

References
Informal Semantics (3)
Constraint:
:- b1, . . . , bk , not bk+1, . . . , not bm.
Informal Semantics:
“It is not possible that all b1, . . . , bk are true and all bk+1, . . . , bm are false”.
Example
isInterestedinASP(X) | isCurious(X) :- attendsASP(X).
:- hatesASP(X), isInterestedinASP(X).
attendsASP(john). hatesASP(john).
Only one plausible scenario:
M1:{isInterestedinASP(john), attendsASP(john), hatesASP(john).}
M2:{isCurious(john), attendsASP(john), hatesASP(john).}

References
Extensions for Modeling Optimization Problems
Weak Constraints:
Express desiderata
Constraints which should possibly be satisﬁed
(as soft constraints in CSP)
Syntax: :∼ b(X, Y).
Intuitive meaning: “set b as false, if possible”

References
Extensions for Modeling Optimization Problems
Weak Constraints:
Express desiderata
Constraints which should possibly be satisﬁed
(as soft constraints in CSP)
Syntax: :∼ b(X, Y). [w@p]
Weigth and Priority: ([w@p])
• higher weights/priorities ⇒ higher importance
• “@p” can be omitted
“minimize the sum of the weights of the violated constraints in the highest
priority level, and so on”
Declarative speciﬁcation of optimization problems

References
Aggregates (Informal)
Aggregate atoms: Express functions calculated over sets of elements:
Lg <op f{S} <op Ug
Example
5 < #count{EmpId : emp(EmpId, male, Skill, Salary)} ≤ 10
The atom is true if the number of male employees is greater than 5 and does
not exceed 10.

References
Aggregates (Informal)
Aggregate atoms: Express functions calculated over sets of elements:
Lg <op f{S} <op Ug
Example
5 < #count{EmpId : emp(EmpId, male, Skill, Salary)} ≤ 10
The atom is true if the number of male employees is greater than 5 and does
not exceed 10.
Allows for compact speciﬁcations of rules and constraints!

References
Programming in ASP (Example 1)
Example (3-col)
Problem: Given a graph, assign one color out of 3 colors to each node such
that two adjacent nodes have always different colors.
Input: a Graph is represented by node(_) and edge(_, _).
% guess a coloring for the nodes
(r) col(X, red) | col(X, yellow) | col(X, green) :- node(X).
% discard colorings where adjacent nodes have the same color
(c) :- edge(X, Y), col(X, C), col(Y, C).
% NB: answer sets are subset minimal → only one color per node

References
Example (Team Building)
% An employee is either included in the team or not
inTeam(I) | outTeam(I) :- emp(I, Sx, Sk, Sa).
% The team consists of a certain number of employees
:- nEmp(N), #count{I : inTeam(I)} <> N.
% At least a given number of different skills must be present in the team
:- nSkill(M), #count{Sk : emp(I, Sx, Sk, Sa), inTeam(I)} < M.
% The sum of the salaries of the employees working in the team must not
exceed the given budget
:- budget(B), #sum{Sa, I : emp(I, Sx, Sk, Sa), inTeam(I)} > B.
% The salary of each individual employee is within a speciﬁed limit
:- maxSal(M), #max{Sa : emp(I, Sx, Sk, Sa), inTeam(I)} > M.

References
Example (Traveling Salesman Person)
Problem: Find a path of minimum length in a Weighted Graph beginning at
the starting node which contains all nodes of the graph.
Input: node(_) and edge(_, _, _), and start(_).
% Guess a path
inPath(X, Y) | outPath(X, Y) :- edge(X, Y, _).
% Ensure that it is Hamiltonian
:- #count{X : inPath(X, Y)} > 1.
:- #count{Y : inPath(X, Y)} > 1.
:- node(X), not reached(X).
:- inPath(X, Y), start(Y).
reached(X) :- reached(Y), inPath(Y, X).
reached(X) :- start(X).
% Minimize the sum of distances
:∼ inPath(X, Y), edge(X, Y, C). [C]
| Guess
|
| Check
|
|
| Aux. Rules
|
| Optimize

References
Main Evaluation Strategies
Evaluation of ASP Programs [KLPS16]
Traditionally a two-step process: “Ground+Solve”
1 Instantiation or grounding
→ Variable elimination → Exponential output
→ Support language features & Keep output small!!
2 Propositional search or ASP solving
→ Model Generation: “compute models” → related to SAT
→ (Stable) Model Checking: “check if model is stable” → coNP
Single step evaluation: “Grounding-less”
→ Grounding bottleneck → Grounding and search interleaved

References
The traditional Architecture of ASP Systems
“Pay as you go approach”
The instantiator can often evaluate stratiﬁed programs
The model generator or solver sufﬁces for normal/HCF
The model checker needed for unrestricted disjunction

References
About the Instantiation
Some facts:
Exponential in the worst case
Input of a subsequent exponential procedure
Signiﬁcantly affects the performance of the overall process
Full instantiation: i.e., apply every possible substitution
→ Not viable in practice
Intelligent instantiation
→ Keep the size of the instantiation as small as possible
→ Equivalent to the full one
→ Intelligent Instantiators can solve problems in P
→ Deductive Databases as a subcase!

References
Instantiation Example: 3-Colorability
Instance: node(1). node(2). node(3). edge(1, 2). edge(2, 3).

References
Full Theoretical Instantiation:
col(red, red) | col(red, yellow) | col(red, green) :- node(red).
col(yellow, red) | col(yellow, yellow) | col(yellow, green) :- node(yellow).
col(green, red) | col(green, yellow) | col(green, green) :- node(green).
. . .
col(1, red) | col(1, yellow) | col(1, green) :- node(1).
. . .
:- edge(1, 2), col(1, 1), col(2, 1).
. . .
:- edge(1, 2), col(1, red), col(2, red).
. . .

References
Full Theoretical Instantiation: → is huge (2916 rules) and redundant!
col(red, red) | col(red, yellow) | col(red, green) :- node(red).
col(yellow, red) | col(yellow, yellow) | col(yellow, green) :- node(yellow).
col(green, red) | col(green, yellow) | col(green, green) :- node(green).
. . .
col(1, red) | col(1, yellow) | col(1, green) :- node(1). ← OK!
. . .
:- edge(1, 2), col(1, 1), col(2, 1). ← redundant!
. . .
:- edge(1, 2), col(1, red), col(2, red). ← OK!
. . .

References
Intelligent Instantiation: → equivalent but much smaller (9 rules)!
col(1, red) | col(1, yellow) | col(1, green).
:- col(1, red), col(2, red).
:- col(1, green), col(2, green).
:- col(1, yellow), col(2, yellow).

References
Model Generation & Checking
Model Generator or Solver → produces candidate models
Works on propositional programs
Similar to a SAT solver
Intelligent backtracking algorithm
Propagate Deterministic Consequences
→ Unit Propagation, Support Propagation,
→ Well-founded Negation, etc.
Assume a literal l (heuristically) until a model is generated
Upon inconsistency Backtrack (assume not l)
Model Checker → checks if candidates are Answer Sets
Enabled only for hard (non-HCF) instances
Implements a coNP-complete task

References
Model Generation Example: 3-Colorability
Model Generation step:
True: {}
False: {}

References
Model Generation step: Chose literal
True: {} ← col(1, red)
False: {}

References
Model Generation step: Propagate Deterministic Consequences
col(1, red) | col(1, yellow) | col(1, green). ← 1-support propagation
:- col(1, red), col(2, red). ← 2-unit propagation
True: {col(1, red)}
False: { col(1, yellow), col(1, green), col(2, red) }

References
True: {col(1, red) ← col(2, yellow) }
False: { col(1, yellow), col(1, green), col(2, red) }

References
col(2, red) | col(2, yellow) | col(2, green). ←1-support propagation
:- col(2, yellow), col(3, yellow). ← 2-unit propagation
True: {col(1, red), col(2, yellow) }
False: { col(1, yellow), col(1, green), col(2, red), col(2, green),
col(3, yellow) }

References
True: {col(1, red), col(2, yellow)} ← col(3, red)
col(3, yellow) }

References
col(3, red) | col(3, yellow) | col(3, green). ←support propagation
True: {col(1, red), col(2, yellow), col(3, red)
col(3, yellow) col(3, green) }

References
Model Generation step: Answer set found!
Answer Set: {col(1, red), col(2, yellow), col(3, red) }

References
Model Checking via SAT test (1)
Consider: M = {a, b}
a | b | c.
a :- b.
b :- a, not c..
a :- c.

References
Step:(1)
a | b | c.
a :- b.
b :- a, not c..
a :- c.

References
Step:(2)
a | b | c.
a :- b.
b :- a, not c.

References
Step:(3)
a | b | c.
a :- b.
b :- a.

References
a | b.
a :- b.
b :- a.

References
Step: (6-9)
a | b. =⇒ ← a ∧ b
a :- b.
b :- a.

References
Step: (6-9)
a | b. =⇒ ← a ∧ b
a :- b. =⇒ b ← a
b :- a.

References
Step: (6-9)
a | b. =⇒ ← a ∧ b
a :- b. =⇒ b ← a
b :- a. =⇒ a ← b

References
Step: (6-9)
Consider: M = {a, b} =⇒ a ∨ b ←
a | b. =⇒ ← a ∧ b
a :- b. =⇒ b ← a
b :- a. =⇒ a ← b

References
Step: (6-9)
Consider: M = {a, b} =⇒ a ∨ b
a | b. =⇒ ← a ∧ b =⇒ ¬a ∨ ¬b
a :- b. =⇒ b ← a =⇒ ¬a ∨ b
b :- a. =⇒ a ← b =⇒ ¬b ∨ a

References
Consider: M = {a, b} =⇒ a ∨ b
=⇒ ¬a ∨ ¬b
=⇒ ¬a ∨ b
=⇒ ¬b ∨ a
Unsatisﬁable → Answer Set!

References
Evolution of grounders
Lparse [SN01]
→ front-end system → intermediate format
→ normal programs
→ ω-restricted → “domains”
DLV [LPF+
06]
→ disjunctive programs
→ safety condition
→ deductive database techniques
Gringo [GST07]
→ front-end system → Lparse format
→ λ-restricted → “positive recursion”
Gringo v.3+ and i-dlv [GKKS11, CFPZ17]
→ Reinterpret DLV’s + new tech. (e.g., decompositions [BMMW17])
→ ASPCore2 standard language + Language extensions

References
Native Solvers & Systems
DPLL-based [DLL62]
Smodels [SNS02] → dedicated inferences normal programs
GnT [JNS+
06] → disj. model checking based on Smodels
DLV [LPF+
06] → disj. unfounded sets + SAT-based check [? ]
CDCL-based [SLM09]
Clasp [GKNS07] → nogood learning + SAT tech.
Wasp [ADLR15] → clause learning + SAT tech.
Beyond CDCL (and ASP)
Clingo [GKK+
16] → monolithic (Gringo + Clasp) + ...
DLV 2.0 [ACD+
17] → monolithic (i-dlv + Wasp) + ...

References
Translation-based solvers
Translation to SAT
Cmodels (v1) → Clark completion for tight programs [EL03]
assat [LZ02] & Cmodels (v2) [LM04] → Loop formulas
Cmodels (v3) [GLM06] → disj. via SAT-based stability check
lp2sat [Jan06, JN11] → level rankings [Nie08]
Other target formalisms
lp2acyc [GJR] → aciclycity condition
lp2mip [LJN12] → mixed integer programming
lp2* [JNS09, NJN11] → PB-Constraint, Diff. Logic, Bit Vector

References
Grounding less systems
Lazy grounding (Interleave/blend grounding+search)
GASP [PDPR09] → Based on [LPST10]
ASPERIX [LN09] → Based on [LPST10]
OMIGA [DEF+
12] → Based on Rete [For82]
ALPHA [Wei17] → Lazy grounding + CDCL
IDP [dCDBS15] → Lazy model expansion

References
Multiprocessing & Portfolios
Portfolio systems (Dominating ASP Competitions since 2011)
Claspfolio [GKK+
11a, HLS14] → SATZILLA approach [XHHL08]
ME-ASP [MPR14, MPR15] → AQME approach [PT09]
ASPEED & PPfolio → Optimized portfolios [HKLS15]
Multiprocessing
DLV parallel grounding [PRS13] (SMP machines)
Lparse + DPLL-based parallel ASP solvers
→ [FMMT01, PBB03, BPEL05, GJM+
06] based on [ZBH96]
Multiprocessing variants of Clasp [GKK+
11b, GKS12, GKK+
15]
→ Parallel & distributed CDCL-search & portfolio
ASP solving utilizing GPUs [DFPV16]

References
Systems Interfaces
ASP Systems
Highly optimized and sophisticated implementations
Extensions are non-obvious
API to make extensions easier
Clingo API [GKK+b]
→ Customized solving control via C, lua and python scripts
→ Incremental solving [GKK+
a] and External propagators [DW12]
Wasp API [ADLR15]
→ Solver extension via Python, C++, and Perl
→ Domain Heuristics [DGL+
16] and Custom Propagators [CDRS17]
DLV 2.0 [ACD+
17]
→ i-dlv + Wasp easier development of propagators.

References
Systems for ASP Extensions
Advanced frameworks based on ASP
Constraint ASP (CASP) [BBG05, BKOS17, BL17]
→ Augment the Boolean representations of ASP with constraints
→ Systems: ACSOLVER, CLINGCON, EZCSP, IDP, INCA, and MINGO
ASP Modulo Theories (ASPMT) [SL16]
→ Systems: ASPMT2SMT, EZSMT
Bound-Founded ASP (BFASP) [ACS13]
→ System: CHUFFED (CP solver + propagator BF integer variables)
Higher-order EXternal (HEX) programs [EFI+16]
→ ASP programs + external sources (e.g., ontological reasoning)
→ System: DLVHEX

References
Conclusion
1 History of ASP Implementations
Ground + Solve
→ Grounders, Native and Translation-based Solvers
→ Portfolios and Parallel-distributed implementations
Grounding-less
2 Interfaces and Extensions
Easy extensions with Python, C++, etc.
→ Customized control over grounding and solving
→ New Heuristics and Propagators
3 Systems for ASP Extensions
Constraint ASP (CASP), ASPMT, HEX Programs, etc.

References
Acknowledgments
Thanks for your attention!

References
Thanks to my co-authors
All the details and references in our paper:
[GLMPRS18]
Martin Gebser, Nicola Leone, Marco Maratea, Simona
Perri, Francesco Ricca, Torsten Schaub:
“Evaluation Techniques and Systems for Answer Set
Programming: a Survey”
Proceedings of IJCAI 2018, pg. 5450-5456 AAAI Press

References
References
[ACD+
17] Mario Alviano, Francesco Calimeri, Carmine Dodaro, Davide
Fuscà, Nicola Leone, Simona Perri, Francesco Ricca,
Pierfrancesco Veltri, and Jessica Zangari. The ASP system
DLV2. In LPNMR, volume 10377 of Lecture Notes in Computer
Science, pages 215–221. Springer, 2017.
[ACS13] R. A. Aziz, G. Chu, and P. J. Stuckey. Stable model semantics
for founded bounds. TPLP, 13(4-5):517–532, 2013.
[ADLR15] Mario Alviano, Carmine Dodaro, Nicola Leone, and Francesco
Ricca. Advances in WASP. In LPNMR, volume 9345 of Lecture
Notes in Computer Science, pages 40–54. Springer, 2015.
[BBG05] S. Baselice, P. A. Bonatti, and M. Gelfond. A preliminary report
on integrating of answer set and constraint solving. In Answer
Set Programming, volume 142 of CEUR Workshop Proceedings,
2005.

References
References (cont.)
[BET11] Gerhard Brewka, Thomas Eiter, and Miroslaw Truszczynski.
Answer set programming at a glance. Commun. ACM,
54(12):92–103, 2011.
[BKOS17] M. Banbara, B. Kaufmann, M. Ostrowski, and T. Schaub.
Clingcon: The next generation. TPLP, 17(4):408–461, 2017.
[BL17] M. Balduccini and Y. Lierler. Constraint answer set solver
EZCSP and why integration schemas matter. TPLP,
17(4):462–515, 2017.
[BMMW17] Bernhard Bliem, Marius Moldovan, Michael Morak, and Stefan
Woltran. The impact of treewidth on ASP grounding and solving.
In IJCAI, pages 852–858. ijcai.org, 2017.
[BPEL05] Marcello Balduccini, Enrico Pontelli, Omar El-Khatib, and Hung
Le. Issues in parallel execution of non-monotonic reasoning
systems. Parallel Computing, 31(6):608–647, 2005.

References
References (cont.)
[CDRS17] B. Cuteri, C. Dodaro, F. Ricca, and P. Schüller. Constraints, lazy
constraints, or propagators in ASP solving: An empirical
analysis. TPLP, 17(5-6):780–799, 2017.
[CFG+
12] F. Calimeri, W. Faber, M. Gebser, G. Ianni, R. Kaminski,
T. Krennwallner, N. Leone, F. Ricca, and T. Schaub.
ASP-Core-2: Input language format. https://www.mat.
unical.it/aspcomp2013/ASPStandardization/, 2012.
[CFPZ17] Francesco Calimeri, Davide Fuscà, Simona Perri, and Jessica
Zangari. I-DLV: the new intelligent grounder of DLV. Intelligenza
Artiﬁciale, 11(1):5–20, 2017.
[CGMR16] Francesco Calimeri, Martin Gebser, Marco Maratea, and
Francesco Ricca. Design and results of the ﬁfth answer set
programming competition. Artif. Intell., 231:151–181, 2016.

References
References (cont.)
[CHO+
09] Ozan Caldiran, Kadir Haspalamutgil, Abdullah Ok, Can Palaz,
Esra Erdem, and Volkan Patoglu. Bridging the gap between
high-level reasoning and low-level control. In LPNMR, pages
342–354, 2009.
[dCDBS15] Broes de Cat, Marc Denecker, Maurice Bruynooghe, and
Peter J. Stuckey. Lazy model expansion: Interleaving grounding
with search. J. Artif. Intell. Res., 52:235–286, 2015.
[DEF+
12] Minh Dao-Tran, Thomas Eiter, Michael Fink, Gerald Weidinger,
and Antonius Weinzierl. Omiga : An open minded grounding
on-the-ﬂy answer set solver. In JELIA, volume 7519 of Lecture
[DEGV01] Evgeny Dantsin, Thomas Eiter, Georg Gottlob, and Andrei
Voronkov. Complexity and Expressive Power of Logic
Programming. ACM Computing Surveys, 33(3):374–425, 2001.

References
References (cont.)
[DFPV16] A. Dovier, A. Formisano, E. Pontelli, and F. Vella. A GPU
implementation of the ASP computation. In PADL’16, volume
9585, pages 30–47, 2016.
[DGH09] James P. Delgrande, Torsten Grote, and Aaron Hunter. A general
approach to the veriﬁcation of cryptographic protocols using
answer set programming. In LPNMR, pages 355–367, 2009.
[DGL+
16] C. Dodaro, P. Gasteiger, N. Leone, B. Musitsch, F. Ricca, and
K. Schekotihin. Combining answer set programming and domain
heuristics for solving hard industrial problems (application
paper). TPLP, 16(5-6):653–669, 2016.
[DLL62] Martin Davis, George Logemann, and Donald W. Loveland. A
machine program for theorem-proving. Commun. ACM,
5(7):394–397, 1962.

References
References (cont.)
[DW12] C. Drescher and T. Walsh. Answer set solving with lazy nogood
generation. In Technical Communications of ICLP’12, pages
188–200, 2012.
[EEB10] Halit Erdogan, Esra Erdem, and Olivier Bodenreider. Exploiting
umls semantics for checking semantic consistency among umls
concepts. In In Proc. of MedInfo, 2010.
[EFI+
16] T. Eiter, M. Fink, G. Ianni, T. Krennwallner, C. Redl, and
P. Schüller. A model building framework for answer set
programming with external computations. Theory and Practice
of Logic Progeamming, 16(4):418–464, 2016.
[EFLP99] Thomas Eiter, Wolfgang Faber, Nicola Leone, and Gerald Pfeifer.
The diagnosis frontend of the dlv system. AI Commun.,
12(1-2):99–111, 1999.
[EGL16] Esra Erdem, Michael Gelfond, and Nicola Leone. Applications of
answer set programming. AI Magazine, 37(3):53–68, 2016.

References
References (cont.)
[EGM97] Thomas Eiter, Georg Gottlob, and Heikki Mannila. Disjunctive
datalog. ACM Trans. Database Syst., 22(3):364–418, 1997.
[EIST06] Thomas Eiter, Giovambattista Ianni, Roman Schindlauer, and
Hans Tompits. Effective integration of declarative rules with
external evaluations for semantic-web reasoning. In ESWC,
pages 273–287, 2006.
[EL03] Esra Erdem and Vladimir Lifschitz. Tight logic programs. TPLP,
3(4-5):499–518, 2003.
[FMMT01] R. Finkel, V. Marek, N. Moore, and M. Truszczy´nski. Computing
stable models in parallel. In ASP’01, 2001.
[For82] Charles L. Forgy. Rete: A fast algorithm for the many
pattern/many object pattern match problem. Artiﬁcial
Intelligence, 19(1):17 – 37, 1982.

References
References (cont.)
[GJM+
06] J. Gressmann, T. Janhunen, R. E. Mercer, T. Schaub, S. Thiele,
and R. Tichy. On probing and multi-threading in platypus. In
ECAI’06, volume 141 of FAIA, pages 392–396. IOS Press, 2006.
[GJR] M. Gebser, T. Janhunen, and J. Rintanen. Answer set
programming as SAT modulo acyclicity. pages 351–356.
[GKK+
a] M. Gebser, R. Kaminski, B. Kaufmann, M. Ostrowski, T. Schaub,
and S. Thiele. Engineering an incremental ASP solver. pages
190–205.
[GKK+
b] M. Gebser, R. Kaminski, B. Kaufmann, M. Ostrowski, T. Schaub,
and P. Wanko. Theory solving made easy with clingo 5. pages
2:1–2:15.
[GKK+
11a] M. Gebser, R. Kaminski, B. Kaufmann, T. Schaub, M. Schneider,
and S. Ziller. A portfolio solver for answer set programming:
Preliminary report. In LPNMR’11, volume 6645, pages 352–357,
2011.

References
References (cont.)
[GKK+
11b] M. Gebser, R. Kaminski, B. Kaufmann, T. Schaub, and
B. Schnor. Cluster-based ASP solving with claspar. In
LPNMR’11, volume 6645, pages 364–369, 2011.
[GKK+
15] M. Gebser, R. Kaminski, B. Kaufmann, J. Romero, and
T. Schaub. Progress in clasp series 3. In LPNMR’15, volume
9345 of LNCS, pages 368–383. Springer, 2015.
[GKK+
16] Martin Gebser, Roland Kaminski, Benjamin Kaufmann, Max
Ostrowski, Torsten Schaub, and Philipp Wanko. Theory solving
made easy with clingo 5. In ICLP (Technical Communications),
volume 52 of OASICS, pages 2:1–2:15. Schloss Dagstuhl -
Leibniz-Zentrum fuer Informatik, 2016.
[GKKS11] Martin Gebser, Roland Kaminski, Arne König, and Torsten
Schaub. Advances in gringo series 3. In LPNMR, volume 6645
of Lecture Notes in Computer Science, pages 345–351.
Springer, 2011.

References
References (cont.)
[GKNS07] Martin Gebser, Benjamin Kaufmann, André Neumann, and
Torsten Schaub. clasp : A conﬂict-driven answer set solver. In
LPNMR, volume 4483 of Lecture Notes in Computer Science,
pages 260–265. Springer, 2007.
[GKS12] M. Gebser, B. Kaufmann, and T. Schaub. Multi-threaded ASP
solving with clasp. TPLP, 12(4-5):525–545, 2012.
[GL91] Michael Gelfond and Vladimir Lifschitz. Classical negation in
logic programs and disjunctive databases. New Generation
Comput., 9(3/4):365–386, 1991.
[GLM06] Enrico Giunchiglia, Yuliya Lierler, and Marco Maratea. Answer
set programming based on propositional satisﬁability. J. Autom.
Reasoning, 36(4):345–377, 2006.
[GMR17] Martin Gebser, Marco Maratea, and Francesco Ricca. The sixth
answer set programming competition. J. Artif. Intell. Res.,
60:41–95, 2017.

References
References (cont.)
[GNA13] Terracina Giorgio, Leone Nicola, and Martello Alessandra.
Logic-based techniques for data cleaning: an application to the
italian national healthcare system. LPNMR, 2013.
[GST07] Martin Gebser, Torsten Schaub, and Sven Thiele. Gringo : A
new grounder for answer set programming. In LPNMR, volume
4483 of Lecture Notes in Computer Science, pages 266–271.
Springer, 2007.
[HKLS15] Holger Hoos, Roland Kaminski, Marius Lindauer, and Torsten
Schaub. aspeed: Solver scheduling via answer set
programming. TPLP, 15(1):117–142, 2015.
[HLS14] H. Hoos, M. Lindauer, and T. Schaub. claspfolio 2: Advances in
algorithm selection for answer set programming. TPLP,
14(4-5):569–585, 2014.

References
References (cont.)
[Jan06] T. Janhunen. Some (in)translatability results for normal logic
programs and propositional theories. J. of Appl. Non-Class.
Log., 16(1-2):35–86, 2006.
[JN11] T. Janhunen and I. Niemelä. Compact translations of
non-disjunctive answer set programs to propositional clauses. In
LP, KR, and NMR, volume 6565 of LNCS, pages 111–130.
Springer, 2011.
[JNS+
06] Tomi Janhunen, Ilkka Niemelä, Dietmar Seipel, Patrik Simons,
and Jia-Huai You. Unfolding partiality and disjunctions in stable
model semantics. ACM Trans. Comput. Log., 7(1):1–37, 2006.
[JNS09] T. Janhunen, I. Niemelä, and M. Sevalnev. Computing stable
models via reductions to difference logic. In LPNMR’09, volume
5753, pages 142–154, 2009.

References
References (cont.)
[KLPS16] Benjamin Kaufmann, Nicola Leone, Simona Perri, and Torsten
Schaub. Grounding and solving in answer set programming. AI
Magazine, 37(3):25–32, 2016.
[Lif02] Vladimir Lifschitz. Answer set programming and plan generation.
Artif. Intell., 138(1-2):39–54, 2002.
[LJN12] G. Liu, T. Janhunen, and I. Niemelä. Answer set programming
via mixed integer programming. In KR’12, pages 32–42. AAAI
Press, 2012.
[LM04] Yuliya Lierler and Marco Maratea. Cmodels-2: Sat-based
answer set solver enhanced to non-tight programs. In LPNMR,
volume 2923 of Lecture Notes in Computer Science, pages
346–350. Springer, 2004.
[LMR16] Yuliya Lierler, Marco Maratea, and Francesco Ricca. Systems,
engineering environments, and competitions. AI Magazine,
37(3):45–52, 2016.

References
References (cont.)
[LN09] Claire Lefèvre and Pascal Nicolas. The ﬁrst version of a new
ASP solver : Asperix. In LPNMR, volume 5753 of Lecture Notes
in Computer Science, pages 522–527. Springer, 2009.
[LPF+
06] Nicola Leone, Gerald Pfeifer, Wolfgang Faber, Thomas Eiter,
Georg Gottlob, Simona Perri, and Francesco Scarcello. The DLV
system for knowledge representation and reasoning. ACM
Trans. Comput. Log., 7(3):499–562, 2006.
[LPST10] Lengning Liu, Enrico Pontelli, Tran Cao Son, and Miroslaw
Truszczynski. Logic programs with abstract constraint atoms:
The role of computations. Artif. Intell., 174(3-4):295–315, 2010.
[LZ02] Fangzhen Lin and Yuting Zhao. ASSAT: Computing answer sets
of a logic program by sat solvers. In
the Eighteenth National Conference on Artif. Intell. (AAAI-2002),
Edmonton, Alberta, Canada, 2002. AAAI Press / MIT Press.

References
References (cont.)
[MPR14] M. Maratea, L. Pulina, and F. Ricca. A multi-engine approach to
answer-set programming. TPLP, 14(6):841–868, 2014.
[MPR15] M. Maratea, L. Pulina, and F. Ricca. Multi-level algorithm
selection for ASP. In LPNMR’15, volume 9345 of LNCS, pages
439–445. Springer, 2015.
[Nie08] I. Niemelä. Stable models and difference logic.
53(1-4):313–329, 2008.
[NJN11] M. Nguyen, T. Janhunen, and I. Niemelä. Translating answer-set
programs into bit-vector logic. In INAP’11 and WLP’11, volume
7773, pages 95–113, 2011.
[PBB03] E. Pontelli, M. Balduccini, and F. Bermudez. Non-monotonic
reasoning on Beowulf platforms. In PADL’03, volume 2562,
pages 37–57, 2003.

References
References (cont.)
[PDPR09] Alessandro Dal Palù, Agostino Dovier, Enrico Pontelli, and
Gianfranco Rossi. GASP: answer set programming with lazy
grounding. Fundam. Inform., 96(3):297–322, 2009.
[PRS13] S. Perri, F. Ricca, and M. Sirianni. Parallel instantiation of ASP
programs: Techniques and experiments. 13(2):253–278, 2013.
[PT09] L. Pulina and A. Tacchella. A self-adaptive multi-engine solver for
quantiﬁed Boolean formulas. Constraints, 14(1):80–116, 2009.
[RDG+
10] Francesco Ricca, Antonella Dimasi, Giovanni Grasso,
Salvatore Maria Ielpa, Salvatore Iiritano, Marco Manna, and
Nicola Leone. A logic-based system for e-tourism. Fundam.
Inform., 105(1-2):35–55, 2010.
[RGA+
12] Francesco Ricca, Giovanni Grasso, Mario Alviano, Marco
Manna, Vincenzino Lio, Salvatore Iiritano, and Nicola Leone.
Team-building with answer set programming in the gioia-tauro
seaport. TPLP, 12(3):361–381, 2012.

References
References (cont.)
[Sak11] Chiaki Sakama. Dishonest reasoning by abduction. In IJCAI,
pages 1063–1064, 2011.
[SL16] B. Susman and Y. Lierler. Smt-based constraint answer set
solver EZSMT (system description). In ICLP (Technical
Communications), volume 52 of OASICS, pages 1:1–1:15. SD,
2016.
[SLM09] João P. Marques Silva, Inês Lynce, and Sharad Malik.
Conflict-driven clause learning SAT solvers. In Handbook of
Satisfiability, volume 185 of Frontiers in Artificial Intelligence and
Applications, pages 131–153. IOS Press, 2009.
[SN99] Timo Soininen and Ilkka Niemelä. Developing a declarative rule
language for applications in product configuration. In PADL,
pages 305–319, 1999.

References
References (cont.)
[SN01] Tommi Syrjänen and Ilkka Niemelä. The smodels system. In
LPNMR, volume 2173 of Lecture Notes in Computer Science,
pages 434–438. Springer, 2001.
[SNS02] Patrik Simons, Ilkka Niemelä, and Timo Soininen. Extending and
implementing the stable model semantics. Artif. Intell.,
138(1-2):181–234, 2002.
[Wei17] Antonius Weinzierl. Blending lazy-grounding and CDNL search
for answer-set solving. In LPNMR, volume 10377 of Lecture
[XHHL08] L. Xu, F. Hutter, H. Hoos, and K. Leyton-Brown. SATzilla:
Portfolio-based algorithm selection for SAT. Journal of Artif.
Intell. Research, 32:565–606, 2008.
[ZBH96] H. Zhang, M. Bonacina, and J. Hsiang. PSATO: A distributed
propositional prover and its application to quasigroup problems.
Journal of Symbolic Computation, 21(4):543–560, 1996.

A Survey of Evaluation Techniques and Systems for Answer Set Programming

Recomendados

Recomendados

Más contenido relacionado

La actualidad más candente

La actualidad más candente (10)

Similar a A Survey of Evaluation Techniques and Systems for Answer Set Programming

Similar a A Survey of Evaluation Techniques and Systems for Answer Set Programming (20)

Más de Förderverein Technische Fakultät

Más de Förderverein Technische Fakultät (20)

Último

Último (20)

A Survey of Evaluation Techniques and Systems for Answer Set Programming