Transcript Intro to Galliwasp system

University of Texas at Dallas
Goal-directed Execution of
Answer Set Programs
Kyle Marple, Ajay Bansal, Richard Min, Gopal Gupta
Applied Logic, Programming-Languages
and Systems (ALPS) Lab
The University of Texas at Dallas
Applied Logic, Programming-Languages and Systems (ALPS) Lab @ UTD Slide- 1
University of Texas at Dallas
Outline
• Answer Set Programming
• General overview
• Odd Loops Over Negation (OLONs)
• Other Implementations
• Goal-directed execution of ASP Programs
• Why we want it
• How we achieve it
• Our Implementation, Galliwasp
• Improving performance
• Benchmark results
• Related and Future Work
• Updated benchmark results
Applied Logic, Programming-Languages and Systems (ALPS) Lab @ UTD Slide- 2
University of Texas at Dallas
Answer Set Programming
• Answer set programming (ASP)
• Based on Stable Model Semantics
• Attempts to give a better semantics to negation as failure
(not p holds if we fail to establish p)
• Captures default reasoning, non-monotonic reasoning, etc.,
in a natural way
• Applications of ASP
•
•
•
•
Default/Non-monotonic reasoning
Planning problems
Action Languages
Abductive reasoning
• Serious applications of ASP developed
Applied Logic, Programming-Languages and Systems (ALPS) Lab @ UTD Slide- 3
University of Texas at Dallas
Gelfond-Lifschitz Method
• Given an answer set program and a
candidate answer set S, compute the residual
program:
• for each p ∈ S, delete all rules whose body
contains “not p”
• delete all goals of the form “not q” in remaining
rules
• Compute the least fix point, L, of the residual
program
• If S = L, then S is an answer set
Applied Logic, Programming-Languages and Systems (ALPS) Lab @ UTD Slide- 4
University of Texas at Dallas
ASP
• Consider the following program, P:
p :- not q.
q :- not p.
t.
s.
r :- t, s.
• P has 2 answer sets: {p, r, t, s} & {q, r, t, s}.
• Now suppose we add the following rule to P:
h :- p, not h.
(falsify p)
• Only one answer set remains: {q, r, t, s}
• Consider another program:
p :- not q.
q :- not p.
r :- not r.
• No answer set exists
Applied Logic, Programming-Languages and Systems (ALPS) Lab @ UTD Slide- 5
University of Texas at Dallas
Odd Loops Over Negation
• The rules that cause problems are of the form:
h :- p, not h.
• ASP also allows rules of the form:
:- p.
• Such rules are said to contain Odd Loops Over
Negation (OLONs) and force p to be false
• The two are equivalent, except that in the first case,
not h may be called indirectly:
h :- p, q, s.
s :- r, not h.
• More generally, the recursive call to h may be under
any odd number of negations
Applied Logic, Programming-Languages and Systems (ALPS) Lab @ UTD Slide- 6
University of Texas at Dallas
Implementations of ASP
• ASP currently implemented using
• Guess and check + heuristics (Smodels)
• SAT Solvers (Cmodels, ASSAT) + Learning (CLASP)
• There are many more implementations available
• A goal-directed method deemed impossible
• Several attempts made which either modify the
semantics or restrict the program and/or query
• We present an SLD resolution-style, goal-directed
method that works for any ASP program and query
• One poses a query Q to the system and partial answer sets
satisfying Q are systematically computed via backtracking
• Partial answer sets are subsets of some answer set
Applied Logic, Programming-Languages and Systems (ALPS) Lab @ UTD Slide- 7
University of Texas at Dallas
Why Goal-directed ASP?
• Most of the time, given a theory, we are
interested in knowing if a particular goal is
true or not
• Top down goal-directed execution provides
an operational semantics (important for
usability)
• Why check the consistency of the whole
knowledgebase?
• Inconsistency in some unrelated part will scuttle
the whole system
Applied Logic, Programming-Languages and Systems (ALPS) Lab @ UTD Slide- 8
University of Texas at Dallas
Why Goal-directed ASP?
• Many practical examples imitate the use of a query
anyway, using a constraint to force the answer set to
contain a certain goal
• E.g. Zebra puzzle:
:- not satisfied.
• With a goal-directed strategy, it is possible to extend
ASP to predicates; current execution methodology
can only handle finitely groundable programs
• Goal-directed ASP can be extended (more) naturally
• with constraints (e.g., CLP(R))
• with probabilistic reasoning (in style of ProbLog)
• Abduction can be incorporated with greater ease
• Or-parallel implementations can be obtained
Applied Logic, Programming-Languages and Systems (ALPS) Lab @ UTD Slide- 9
University of Texas at Dallas
Coinductive LP
• Our goal-directed procedure relies on coinduction
• Coinduction is the dual of induction: a proof technique to reason
about rational infinite quantities
• Incorporating coinduction in LP (coinductive LP or Co-LP) allows
computation of elements of the GFP
• Given the rule: p :- p. the query ?-p. will succeed
• To adhere to stable model semantics, our ASP algorithm
disallows; recursive calls with no intervening negation fail
• Co-LP proofs are infinite in size; they terminate because we are
only interested in rational infinite proofs
• Co-LP is implemented by remembering ancestor calls. If a
recursive call unifies with its ancestor call, it succeeds
(coinductive hypothesis rule)
Applied Logic, Programming-Languages and Systems (ALPS) Lab @ UTD Slide- 10
University of Texas at Dallas
Negation in Co-LP
• For ASP, Co-LP must be extended with negation
• To incorporate negation, a negative coinductive
hypothesis rule is needed:
• In the process of establishing not p, if not p is
seen again, then not p succeeds [co-SLDNF
Resolution]
• Given a clause such as
p :- q, not p.
p fails coinductively when not p is encountered
• not not p reduces to p
Applied Logic, Programming-Languages and Systems (ALPS) Lab @ UTD Slide- 11
University of Texas at Dallas
Goal-directed Execution
• Consider an answer set program; we first identify
OLON rules and ordinary rules
• Ordinary rules:
• contain an even number of negations between the head of a
clause and its recursive invocation in the call graph, or are
• Non-recursive
• OLON rules:
• contain an odd number of negations between the head of a
clause and its recursive invocation in the call graph
p :- q, not r. …Rule 1
Rule 1 is both an ordinary
r :- not p. …Rule 2
and an OLON rule
q :- t, not p. …Rule 3
Applied Logic, Programming-Languages and Systems (ALPS) Lab @ UTD Slide- 12
University of Texas at Dallas
Ordinary Rules
• If the head of an OLON rule matches a call,
expanding it will always lead to failure
• So, only ordinary rules produce a successful
execution
• Given a goal G and a program P with only ordinary
rules, G can be executed top-down using
coinduction:
• Record each call in a coinductive hypothesis set (CHS)
• At the time of call c, if c is in CHS, then c succeeds, if not c
is in the CHS, the call fails and we backtrack
• If call c is not in CHS, expand it using a matching rule
• Simplify not not p to p wherever applicable
• If no goals left, and success is achieved, the CHS contains
a partial answer set
Applied Logic, Programming-Languages and Systems (ALPS) Lab @ UTD Slide- 13
University of Texas at Dallas
Ordinary Rules
• Consider the following ordinary rules:
p :- not q.
q :- not p.
• Two answer sets: {p, not q} and {q, not p}
• :- p
:- not q
:- not not p
:- p
:- true
• :- q
:- not p
:- not not q
:- q
:- true
% CHS = {}
% CHS = {p}
% CHS = {p, not q}
% CHS = {p, not q}
% success: answer set is {p, not q}
% CHS = {}
% CHS = {q}
% CHS = {q, not p}
% CHS = {q, not p}
% success: answer set is {q, not p}
Applied Logic, Programming-Languages and Systems (ALPS) Lab @ UTD Slide- 14
University of Texas at Dallas
Handling OLON Rules
• Every candidate answer set produced by ordinary
rules in response to a query must obey the
constraints laid down by the OLON rules
• Consider an OLON rule:
p :- B, not p.
where B is a conjunction of positive and negative
literals
• A candidate answer set must satisfy (p ∨ not B) to
stay consistent with the OLON rule above
• If p is present in the candidate answer set, then the
constraint rule will be removed by the GL method
• If not, then the candidate answer set must falsify B in
order to be a valid partial answer set
Applied Logic, Programming-Languages and Systems (ALPS) Lab @ UTD Slide- 15
University of Texas at Dallas
Handling OLON Rules
• In general, for the constraint rules with p as their
head:
p :- B1. p :- B2. ... p :- Bn.
generate rule(s) of the form:
chk_p1 :- not p, B1.
chk_p2 :- not p, B2.
...
chk_pn :- not p, Bn.
• Generate:
nmr_chk :- not chk_p1, ... , not chk_pn.
• Append the NMR check to each query: if user wants
to ask a query Q, then ask:
?- Q, nmr_chk.
• Execution keeps track of positive and negative literals
in the answer set (CHS)
Applied Logic, Programming-Languages and Systems (ALPS) Lab @ UTD Slide- 16
University of Texas at Dallas
Goal-directed ASP
• Consider the following program, A:
p :- not q.
q :- not p, r.
t.
s.
r :- t, s.
h :- p, not h.
• Separate into OLON and ordinary rules: only 1 OLON
rule in this case
• Execute the query under co-LP to generate candidate
answer sets
• Keep the candidate sets not rejected OLON rules
• Suppose the query is ?- q.
• Execution: q  not p, r  not not q, r  q, r  r  t,
s  s  success. Ans = {q, r, t, s}
• Next, we need to check that constraint rules will not
reject the generated answer set.
• it doesn’t in this case as {q, r, t, s} falsifies p
Applied Logic, Programming-Languages and Systems (ALPS) Lab @ UTD Slide- 17
University of Texas at Dallas
Goal-directed ASP
• Consider the following program, P1:
(i) p :- not q.
(ii) q:- not r.
(iii) r :- not p.
(iv) q :- not p.
• Separate into:
• 3 OLON rules (i, ii, iii)
• 2 ordinary rules (i, iv).
• Generate nmr_chk:
• p :- not q. q :- not r. r :- not p. q :- not p.
• chk_p :- not p, not q. chk_q :- not q, not r. chk_r :- not r, not p.
• nmr_chk :- not chk_p, not chk_q, not chk_r.
• Suppose the query is ?- r. Expand as in co-LP:
• r  not p  not not q  q ( not r  fail, backtrack)  not
p  success.
• Ans = {r, q} which satisfies the nmr_chk.
Applied Logic, Programming-Languages and Systems (ALPS) Lab @ UTD Slide- 18
University of Texas at Dallas
Implementation
• Galliwasp implements our goal-directed procedure
• Supports A-Prolog with no restrictions on rules or
queries
• Uses grounded programs from lparse; grounded
program analyzed further (compiler is ~7400 lines of
Prolog)
• The compiled program is executed by the runtime
system (~5,600 lines of C) implementing the topdown procedure
• Given a query Q, it is extended to Q, nmr_chk
• Q generates candidate sets and nmr_chk tests them
Applied Logic, Programming-Languages and Systems (ALPS) Lab @ UTD Slide- 19
University of Texas at Dallas
Dynamic Reordering of the NMR Check
• The order of goals and rules becomes very important
as goals are tried left to right and rules top to bottom
textually
• Significant amount of backtracking can take place
• Efficiency can be significantly improved through
incremental generate and test
• Given Q, nmr_chk, as soon as Q generates an
element of the candidate answer set, the
corresponding checks in nmr_chk will be simplified
• When a check becomes deterministic, the
corresponding call in nmr_chk is reordered to allow
immediate execution
Applied Logic, Programming-Languages and Systems (ALPS) Lab @ UTD Slide- 20
University of Texas at Dallas
Galliwasp System Architecture
Applied Logic, Programming-Languages and Systems (ALPS) Lab @ UTD Slide- 21
University of Texas at Dallas
Old Performance Figures
Problem
Galliwasp
Clasp
Cmodels
Smodels
Queens-12
0.033
0.019
0.055
0.112
Queens-13
0.034
0.022
0.071
0.132
Queens-14
0.076
0.029
0.098
0.362
Queens-15
0.071
0.034
0.119
0.592
Queens-16
0.293
0.043
0.138
1.356
Queens-17
0.198
0.049
0.176
4.293
Queens-18
1.239
0.059
0.224
8.653
Queens-19
0.148
0.070
0.272
3.288
Queens-20
6.744
0.084
0.316
47.782
Queens-21
0.420
0.104
0.398
95.710
Queens-22
69.224
0.112
0.472
N/A
Queens-23
1.282
0.132
0.582
N/A
Queens-24
19.916
0.152
0.602
N/A
Applied Logic, Programming-Languages and Systems (ALPS) Lab @ UTD Slide- 22
University of Texas at Dallas
Old Performance Figures
Problem
Galliwasp
Clasp
Cmodels
Smodels
Mapcolor-4x20
0.018
0.006
0.011
0.013
Mapcolor-4x25
0.021
0.007
0.014
0.016
Mapcolor-4x29
0.023
0.008
0.016
0.018
Mapcolor-4x30
0.026
0.008
0.016
0.019
Mapcolor-3x20
0.022
0.005
0.009
0.008
Mapcolor-3x25
0.065
0.006
0.011
0.010
Mapcolor-3x29
0.394
0.006
0.012
0.011
Mapcolor-3x30
0.342
0.007
0.012
0.011
Schur-3x13
0.209
0.006
0.010
0.009
Schur-2x13
0.019
0.005
0.007
0.006
Schur-4x44
N/A
0.230
1.394
0.349
Schur-3x44
7.010
0.026
0.100
0.076
Pigeon-10x10
0.020
0.009
0.020
0.025
Pigeon-20x20
0.050
0.048
0.163
0.517
Pigeon-30x30
0.132
0.178
0.691
4.985
Pigeon-8x7
0.123
0.072
0.089
0.535
Pigeon-9x8
0.888
0.528
0.569
4.713
Pigeon-10x9
8.339
4.590
2.417
46.208
Pigeon-11x10
90.082
40.182
102.694
N/A
Applied Logic, Programming-Languages and Systems (ALPS) Lab @ UTD Slide- 23
University of Texas at Dallas
Future Work
• Further improvements to the implementation of
Galliwasp
• Generalize to predicates (datalog ASP); work for callconsistent datalog ASP programs already done
• Add constraints so that applications like real-time
planning can be realized
• Add support for probabilistic reasoning
• Realize an or-parallel implementation through stacksplitting
Applied Logic, Programming-Languages and Systems (ALPS) Lab @ UTD Slide- 24
University of Texas at Dallas
Related Work
• Kakas and Toni: Query driven procedure with
argumentation semantics (works for only callconsistent programs)
• Pareira and Pinto have explored variants of ASP.
Given p :- not p. p is in the answer set
• Bonatti et al: restrict the type of programs that can be
executed; inefficient since computations may be
executed multiple times
• Alferes et al: Implementation of abduction; does not
handle arbitrary ASP
Applied Logic, Programming-Languages and Systems (ALPS) Lab @ UTD Slide- 25
University of Texas at Dallas
QUESTIONS?
Applied Logic, Programming-Languages and Systems (ALPS) Lab @ UTD Slide- 26