Clingo = Answer Set Programming + Control Talk by MARTIN GEBSER @UNICAL (department of mathematics and computer science), Rende, Italy

1. Clingo = Answer Set Programming + Control
Martin Gebser Roland Kaminski
Benjamin Kaufmann Torsten Schaub
University of Potsdam
Aalto University
M. Gebser, R. Kaminski, B. Kaufmann, T. Schaub Clingo = ASP + Control 1 / 20

2. Motivation
ASP is an approach to declarative problem solving, combining
a rich yet simple modeling language
with high-performance solving capacities
tailored to Knowledge Representation and Reasoning
Elaborate reasoning processes feature
incremental solving, as in planning or finite model finding, or even
reactive solving, as in robotics or query-answering
Problem
Logic
Program Grounder Solver Stable
Models
Solutions
- - -
?
6
One-shot ASP Solving
M. Gebser, R. Kaminski, B. Kaufmann, T. Schaub Clingo = ASP + Control 2 / 20

3. Motivation
ASP is an approach to declarative problem solving, combining
a rich yet simple modeling language
with high-performance solving capacities
tailored to Knowledge Representation and Reasoning
Elaborate reasoning processes feature
incremental solving, as in planning or finite model finding, or even
reactive solving, as in robotics or query-answering
Problem
Logic
Program Grounder Solver Stable
Models
Solutions
- - -
?
6
Incremental ASP Solving
6
M. Gebser, R. Kaminski, B. Kaufmann, T. Schaub Clingo = ASP + Control 2 / 20

4. Motivation
ASP is an approach to declarative problem solving, combining
a rich yet simple modeling language
with high-performance solving capacities
tailored to Knowledge Representation and Reasoning
Elaborate reasoning processes feature
incremental solving, as in planning or finite model finding, or even
reactive solving, as in robotics or query-answering
Problem
Logic
Program Grounder Solver Stable
Models
Solutions
- - -
?
6
Reactive ASP Solving
66
M. Gebser, R. Kaminski, B. Kaufmann, T. Schaub Clingo = ASP + Control 2 / 20

5. Outline
1 Background
2 (More) Control
3 Summary
M. Gebser, R. Kaminski, B. Kaufmann, T. Schaub Clingo = ASP + Control 3 / 20

6. Background
Outline
1 Background
2 (More) Control
3 Summary
M. Gebser, R. Kaminski, B. Kaufmann, T. Schaub Clingo = ASP + Control 4 / 20

7. Background
Clingo 3 Series
One-shot ASP solving by means of grounder gringo and solver clasp
Clingo: gringo | clasp
Incremental ASP solving by dedicated handling of three program parts
iClingo: Clingo [base ∪ n
i=1cumulative(i) ∪ volatile(n)]∗
n=1
base: grounded once and stored by solver
cumulative(i): grounded for increasing i-values and stored by solver
volatile(i): grounded like cumulative(i) but not stored by solver
Reactive ASP solving by further incorporating external program parts
oClingo: iClingo [ m
j=1external(j)]∗
m=1
M. Gebser, R. Kaminski, B. Kaufmann, T. Schaub Clingo = ASP + Control 5 / 20

8. Background
Clingo 3 Series
One-shot ASP solving by means of grounder gringo and solver clasp
Clingo: gringo | clasp
Incremental ASP solving by dedicated handling of three program parts
iClingo: Clingo [base ∪ n
i=1cumulative(i) ∪ volatile(n)]∗
n=1
base: grounded once and stored by solver
cumulative(i): grounded for increasing i-values and stored by solver
volatile(i): grounded like cumulative(i) but not stored by solver
Reactive ASP solving by further incorporating external program parts
oClingo: iClingo [ m
j=1external(j)]∗
m=1
M. Gebser, R. Kaminski, B. Kaufmann, T. Schaub Clingo = ASP + Control 5 / 20

9. Background
Clingo 3 Series
One-shot ASP solving by means of grounder gringo and solver clasp
Clingo: gringo | clasp
Incremental ASP solving by dedicated handling of three program parts
iClingo: Clingo [base ∪ n
i=1cumulative(i) ∪ volatile(n)]∗
n=1
base: grounded once and stored by solver
cumulative(i): grounded for increasing i-values and stored by solver
volatile(i): grounded like cumulative(i) but not stored by solver
Reactive ASP solving by further incorporating external program parts
oClingo: iClingo [ m
j=1external(j)]∗
m=1
M. Gebser, R. Kaminski, B. Kaufmann, T. Schaub Clingo = ASP + Control 5 / 20

10. Background
Elevator Control Example
Setup:
floor(1..3).
at(1,0).
Request 1:
request(2,1,1).
Request 2:
request(3,1,2).
1
2
3
1
2
3
1
1
2
3
1 2 3
1
2
3
1
2
1
2
3
1
2
2
3 4
5
M. Gebser, R. Kaminski, B. Kaufmann, T. Schaub Clingo = ASP + Control 6 / 20

11. Background
Elevator Control Example
Setup:
floor(1..3).
at(1,0).
Request 1:
request(2,1,1).
Request 2:
request(3,1,2).
1
2
3
1
2
3
1
1
2
3
1 2 3
1
2
3
1
2
1
2
3
1
2
2
3 4
5
M. Gebser, R. Kaminski, B. Kaufmann, T. Schaub Clingo = ASP + Control 6 / 20

12. Background
Elevator Control Example
Setup:
floor(1..3).
at(1,0).
Request 1:
request(2,1,1).
Request 2:
request(3,1,2).
1
2
3
1
2
3
1
1
2
3
1 2 3
1
2
3
1
2
1
2
3
1
2
2
3 4
5
M. Gebser, R. Kaminski, B. Kaufmann, T. Schaub Clingo = ASP + Control 6 / 20

13. Background
Elevator Control Example
Setup:
floor(1..3).
at(1,0).
Request 1:
request(2,1,1).
Request 2:
request(3,1,2).
1
2
3
1
2
3
1
1
2
3
1 2 3
1
2
3
1
2
1
2
3
1
2
2
3 4
5
M. Gebser, R. Kaminski, B. Kaufmann, T. Schaub Clingo = ASP + Control 6 / 20

14. Background
Elevator Control Example
Setup:
floor(1..3).
at(1,0).
Request 1:
request(2,1,1).
Request 2:
request(3,1,2).
1
2
3
1
2
3
1
1
2
3
1 2 3
1
2
3
1
2
1
2
3
1
2
2
3 4
5
M. Gebser, R. Kaminski, B. Kaufmann, T. Schaub Clingo = ASP + Control 6 / 20

15. Background
Encoding for One-shot ASP Solving
diff(-1;1).
{ move(D,T) : diff(D) } 1 :- time(T).
move(T) :- move(D,T).
% State update
at(F, T) :- at(F,T-1), time(T), not move(T).
at(F+D,T) :- at(F,T-1), move(D,T), floor(F+D).
:- time(T), not 1 { at(F,T) } 1.
% Pending requests
task(F1,F2,D,T) :- request(F1,F2,T), D = (F2-F1)/|F2-F1|.
task(F1,F2,D,T) :- task(F1,F2,D,T-1), time(T), not exec(F1,F2,D,T).
% Started tasks must be processed till completion
exec(F1,F2,D,T) :- task(F1,F2,D,T-1), at(F1,T-1), move(D,T).
exec(F2,D,T) :- exec(F1,F2,D,T).
exec(F2,D,T) :- exec(F2,D,T-1), time(T), not at(F2,T-1).
exec(D,T) :- exec(F2,D,T).
:- exec(D,T), not move(D,T).
:- move(D,T), not move(D,T+1), not exec(D,T), not exec(-D,T+1).
% Move iff there is some task to process
open(T) :- task(F1,F2,D,T).
open(T) :- exec(F2,D,T), not at(F2,T).
:- move(T), not open(T-1).
:- open(T), not move(T+1).
M. Gebser, R. Kaminski, B. Kaufmann, T. Schaub Clingo = ASP + Control 7 / 20

16. Background
One-shot ASP Solving
Request 1: clingo-3 <files> <(echo "time(1..3).")
Solving...
Answer: 1
move(1,2) move(-1,3)
Request 2: clingo-3 <files> <(echo "time(1..5).")
Solving...
Answer: 1
move(1,2) move(1,3) move(-1,4) move(-1,5)
1
2
3
1
1
2
3
1 2 3
1
2
3
1
2
1
2
3
1
2
2
3 4
5
M. Gebser, R. Kaminski, B. Kaufmann, T. Schaub Clingo = ASP + Control 8 / 20

17. Background
One-shot ASP Solving
Request 1: clingo-3 <files> <(echo "time(1..3).")
Solving...
Answer: 1
move(1,2) move(-1,3)
Request 2: clingo-3 <files> <(echo "time(1..5).")
Solving...
Answer: 1
move(1,2) move(1,3) move(-1,4) move(-1,5)
1
2
3
1
1
2
3
1 2 3
1
2
3
1
2
1
2
3
1
2
2
3 4
5
M. Gebser, R. Kaminski, B. Kaufmann, T. Schaub Clingo = ASP + Control 8 / 20

18. Background
One-shot ASP Solving
Request 1: clingo-3 <files> <(echo "time(1..3).")
Solving...
Answer: 1
move(1,2) move(-1,3)
Request 2: clingo-3 <files> <(echo "time(1..5).")
Solving...
Answer: 1
move(1,2) move(1,3) move(-1,4) move(-1,5)
1
2
3
1
1
2
3
1 2 3
1
2
3
1
2
1
2
3
1
2
2
3 4
5
M. Gebser, R. Kaminski, B. Kaufmann, T. Schaub Clingo = ASP + Control 8 / 20

19. Background
One-shot ASP Solving
Request 1: clingo-3 <files> <(echo "time(1..3).")
Solving...
Answer: 1
move(1,2) move(-1,3)
Request 2: clingo-3 <files> <(echo "time(1..5).")
Solving...
Answer: 1
move(1,2) move(1,3) move(-1,4) move(-1,5)
1
2
3
1
1
2
3
1 2 3
1
2
3
1
2
1
2
3
1
2
2
3 4
5
M. Gebser, R. Kaminski, B. Kaufmann, T. Schaub Clingo = ASP + Control 8 / 20

20. Background
Encoding for Incremental ASP Solving
#base.
diff(-1;1).
task(F1,F2,D,0) :- request(F1,F2,0), D = (F2-F1)/|F2-F1|.
#cumulative t.
{ move(D,T) : diff(D) } 1 :- time(T).
move(T) :- move(D,T).
% State update
at(F, T) :- at(F,T-1), time(T), not move(T).
at(F+D,T) :- at(F,T-1), move(D,T), floor(F+D).
:- time(T), not 1 { at(F,T) } 1.
% Pending requests
task(F1,F2,D,T) :- request(F1,F2,T), D = (F2-F1)/|F2-F1|.
task(F1,F2,D,T) :- task(F1,F2,D,T-1), time(T), not exec(F1,F2,D,T).
% Started tasks must be processed till completion
...
:- move(D,T), not move(D,T+1), not exec(D,T), not exec(-D,T+1).
% Move iff there is some task to process
...
:- open(T), not move(T+1).
#volatile t.
:- open(t).
M. Gebser, R. Kaminski, B. Kaufmann, T. Schaub Clingo = ASP + Control 9 / 20

21. Background
Encoding for Incremental ASP Solving
#base.
diff(-1;1).
task(F1,F2,D,0) :- request(F1,F2,0), D = (F2-F1)/|F2-F1|.
#cumulative t.
{ move(D,T) : diff(D) } 1 :- time(T).
move(T) :- move(D,T).
% State update
at(F, T) :- at(F,T-1), time(T), not move(T).
at(F+D,T) :- at(F,T-1), move(D,T), floor(F+D).
:- time(T), not 1 { at(F,T) } 1.
% Pending requests
task(F1,F2,D,T) :- request(F1,F2,T), D = (F2-F1)/|F2-F1|.
task(F1,F2,D,T) :- task(F1,F2,D,T-1), time(T), not exec(F1,F2,D,T).
% Started tasks must be processed till completion
...
:- move(D,T), not move(D,T+1), not exec(D,T), not exec(-D,T+1).
% Move iff there is some task to process
...
:- open(T), not move(T+1).
#volatile t.
:- open(t).
M. Gebser, R. Kaminski, B. Kaufmann, T. Schaub Clingo = ASP + Control 9 / 20

22. Background
Encoding for Incremental ASP Solving
#base.
diff(-1;1).
task(F1,F2,D,0) :- request(F1,F2,0), D = (F2-F1)/|F2-F1|.
#cumulative t.
{ move(D,T) : diff(D) } 1 :- time(T).
move(T) :- move(D,T).
% State update
at(F, T) :- at(F,T-1), time(T), not move(T).
at(F+D,T) :- at(F,T-1), move(D,T), floor(F+D).
:- time(T), not 1 { at(F,T) } 1.
% Pending requests
task(F1,F2,D,T) :- request(F1,F2,T), D = (F2-F1)/|F2-F1|.
task(F1,F2,D,T) :- task(F1,F2,D,T-1), time(T), not exec(F1,F2,D,T).
% Started tasks must be processed till completion
...
:- move(D,T), not move(D,T+1), not exec(D,T), not exec(-D,T+1).
% Move iff there is some task to process
...
:- open(T), not move(T+1).
#volatile t.
:- open(t).
M. Gebser, R. Kaminski, B. Kaufmann, T. Schaub Clingo = ASP + Control 9 / 20

23. Background
Encoding for Incremental ASP Solving
#base.
diff(-1;1).
task(F1,F2,D,0) :- request(F1,F2,0), D = (F2-F1)/|F2-F1|.
#cumulative t.
{ move(D,T) : diff(D) } 1 :- time(T).
move(T) :- move(D,T).
% State update
at(F, T) :- at(F,T-1), time(T), not move(T).
at(F+D,T) :- at(F,T-1), move(D,T), floor(F+D).
:- time(T), not 1 { at(F,T) } 1.
% Pending requests
task(F1,F2,D,T) :- request(F1,F2,T), D = (F2-F1)/|F2-F1|.
task(F1,F2,D,T) :- task(F1,F2,D,T-1), time(T), not exec(F1,F2,D,T).
% Started tasks must be processed till completion
...
:- move(D,T), not move(D,T+1), not exec(D,T), not exec(-D,T+1).
% Move iff there is some task to process
...
:- open(T), not move(T+1).
#volatile t.
:- open(t).
M. Gebser, R. Kaminski, B. Kaufmann, T. Schaub Clingo = ASP + Control 9 / 20

24. Background
Encoding for Incremental ASP Solving
#base.
diff(-1;1).
task(F1,F2,D,0) :- request(F1,F2,0), D = (F2-F1)/|F2-F1|.
#cumulative t.
{ move(D,T) : diff(D) } 1 :- time(T).
move(T) :- move(D,T).
% State update
at(F, T) :- at(F,T-1), time(T), not move(T).
at(F+D,T) :- at(F,T-1), move(D,T), floor(F+D).
:- time(T), not 1 { at(F,T) } 1.
% Pending requests
task(F1,F2,D,T) :- request(F1,F2,T), D = (F2-F1)/|F2-F1|.
task(F1,F2,D,T) :- task(F1,F2,D,T-1), time(T), not exec(F1,F2,D,T).
% Started tasks must be processed till completion
...
:- move(D,T), not move(D,T+1), not exec(D,T), not exec(-D,T+1).
% Move iff there is some task to process
...
:- open(T), not move(T+1).
#volatile t.
:- open(t).
M. Gebser, R. Kaminski, B. Kaufmann, T. Schaub Clingo = ASP + Control 9 / 20

25. Background
Encoding for Incremental ASP Solving
#base.
diff(-1;1).
task(F1,F2,D,0) :- request(F1,F2,0), D = (F2-F1)/|F2-F1|.
#cumulative t.
{ move(D,t) : diff(D) } 1.
move(t) :- move(D,t).
% State update
at(F, t) :- at(F,t-1), not move(t).
at(F+D,t) :- at(F,t-1), move(D,t), floor(F+D).
:- not 1 { at(F,t) } 1.
% Pending requests
task(F1,F2,D,t) :- request(F1,F2,t), D = (F2-F1)/|F2-F1|.
task(F1,F2,D,t) :- task(F1,F2,D,t-1), not exec(F1,F2,D,t).
% Started tasks must be processed till completion
...
:- move(D,t), not move(D,t+1), not exec(D,t), not exec(-D,t+1).
% Move iff there is some task to process
...
:- open(t), not move(t+1).
#volatile t.
:- open(t).
M. Gebser, R. Kaminski, B. Kaufmann, T. Schaub Clingo = ASP + Control 9 / 20

26. Background
Encoding for Incremental ASP Solving
#base.
diff(-1;1).
task(F1,F2,D,0) :- request(F1,F2,0), D = (F2-F1)/|F2-F1|.
#cumulative t.
{ move(D,t) : diff(D) } 1.
move(t) :- move(D,t).
% State update
at(F, t) :- at(F,t-1), not move(t).
at(F+D,t) :- at(F,t-1), move(D,t), floor(F+D).
:- not 1 { at(F,t) } 1.
% Pending requests
task(F1,F2,D,t) :- request(F1,F2,t), D = (F2-F1)/|F2-F1|.
task(F1,F2,D,t) :- task(F1,F2,D,t-1), not exec(F1,F2,D,t).
% Started tasks must be processed till completion
...
:- move(D,t), not move(D,t+1), not exec(D,t), not exec(-D,t+1).
% Move iff there is some task to process
...
:- open(t), not move(t+1).
#volatile t.
:- open(t).
M. Gebser, R. Kaminski, B. Kaufmann, T. Schaub Clingo = ASP + Control 9 / 20

27. Background
Encoding for Incremental ASP Solving
#base.
diff(-1;1).
task(F1,F2,D,0) :- request(F1,F2,0), D = (F2-F1)/|F2-F1|.
#cumulative t.
{ move(D,t) : diff(D) } 1.
move(t) :- move(D,t).
% State update
at(F, t) :- at(F,t-1), not move(t).
at(F+D,t) :- at(F,t-1), move(D,t), floor(F+D).
:- not 1 { at(F,t) } 1.
% Pending requests
task(F1,F2,D,t) :- request(F1,F2,t), D = (F2-F1)/|F2-F1|.
task(F1,F2,D,t) :- task(F1,F2,D,t-1), not exec(F1,F2,D,t).
% Started tasks must be processed till completion
...
:- move(D,t-1), not move(D,t), not exec(D,t-1), not exec(-D,t).
% Move iff there is some task to process
...
:- open(t-1), not move(t).
#volatile t.
:- open(t).
M. Gebser, R. Kaminski, B. Kaufmann, T. Schaub Clingo = ASP + Control 9 / 20

28. Background
Encoding for Incremental ASP Solving
#base.
diff(-1;1).
task(F1,F2,D,0) :- request(F1,F2,0), D = (F2-F1)/|F2-F1|.
#cumulative t.
{ move(D,t) : diff(D) } 1.
move(t) :- move(D,t).
% State update
at(F, t) :- at(F,t-1), not move(t).
at(F+D,t) :- at(F,t-1), move(D,t), floor(F+D).
:- not 1 { at(F,t) } 1.
% Pending requests
task(F1,F2,D,t) :- request(F1,F2,t), D = (F2-F1)/|F2-F1|.
task(F1,F2,D,t) :- task(F1,F2,D,t-1), not exec(F1,F2,D,t).
% Started tasks must be processed till completion
...
:- move(D,t-1), not move(D,t), not exec(D,t-1), not exec(-D,t).
% Move iff there is some task to process
...
:- open(t-1), not move(t).
#volatile t.
:- open(t).
M. Gebser, R. Kaminski, B. Kaufmann, T. Schaub Clingo = ASP + Control 9 / 20

29. Background
Incremental ASP Solving
Request 1: iclingo-3 <files>
Solving... Solving... Solving...
Answer: 1
move(1,2) move(-1,3)
Request 2: iclingo-3 <files>
Solving... Solving... Solving... Solving... Solving...
Answer: 1
move(1,2) move(1,3) move(-1,4) move(-1,5)
1
2
3
1
1
2
3
1 2 3
1
2
3
1
2
1
2
3
1
2
2
3 4
5
M. Gebser, R. Kaminski, B. Kaufmann, T. Schaub Clingo = ASP + Control 10 / 20

30. Background
Incremental ASP Solving
Request 1: iclingo-3 <files>
Solving... Solving... Solving...
Answer: 1
move(1,2) move(-1,3)
Request 2: iclingo-3 <files>
Solving... Solving... Solving... Solving... Solving...
Answer: 1
move(1,2) move(1,3) move(-1,4) move(-1,5)
1
2
3
1
1
2
3
1 2 3
1
2
3
1
2
1
2
3
1
2
2
3 4
5
M. Gebser, R. Kaminski, B. Kaufmann, T. Schaub Clingo = ASP + Control 10 / 20

31. Background
Incremental ASP Solving
Request 1: iclingo-3 <files>
Solving... Solving... Solving...
Answer: 1
move(1,2) move(-1,3)
Request 2: iclingo-3 <files>
Solving... Solving... Solving... Solving... Solving...
Answer: 1
move(1,2) move(1,3) move(-1,4) move(-1,5)
1
2
3
1
1
2
3
1 2 3
1
2
3
1
2
1
2
3
1
2
2
3 4
5
M. Gebser, R. Kaminski, B. Kaufmann, T. Schaub Clingo = ASP + Control 10 / 20

32. Background
Incremental ASP Solving
Request 1: iclingo-3 <files>
Solving... Solving... Solving...
Answer: 1
move(1,2) move(-1,3)
Request 2: iclingo-3 <files>
Solving... Solving... Solving... Solving... Solving...
Answer: 1
move(1,2) move(1,3) move(-1,4) move(-1,5)
1
2
3
1
1
2
3
1 2 3
1
2
3
1
2
1
2
3
1
2
2
3 4
5
M. Gebser, R. Kaminski, B. Kaufmann, T. Schaub Clingo = ASP + Control 10 / 20

33. Background
Encoding for Reactive ASP Solving
#base.
#external request(F1,F2,0) : floor(F1) : floor(F2) : F1 != F2.
diff(-1;1).
task(F1,F2,D,0) :- request(F1,F2,0), D = (F2-F1)/|F2-F1|.
#cumulative t.
#external request(F1,F2,t) : floor(F1) : floor(F2) : F1 != F2.
...
% Pending requests
task(F1,F2,D,t) :- request(F1,F2,t), D = (F2-F1)/|F2-F1|.
task(F1,F2,D,t) :- task(F1,F2,D,t-1), not exec(F1,F2,D,t).
...
Inputs:
#step 1.
request(2,1,1).
#endstep.
#step 2.
request(3,1,2).
#endstep.
M. Gebser, R. Kaminski, B. Kaufmann, T. Schaub Clingo = ASP + Control 11 / 20

34. Background
Encoding for Reactive ASP Solving
#base.
#external request(F1,F2,0) : floor(F1) : floor(F2) : F1 != F2.
diff(-1;1).
task(F1,F2,D,0) :- request(F1,F2,0), D = (F2-F1)/|F2-F1|.
#cumulative t.
#external request(F1,F2,t) : floor(F1) : floor(F2) : F1 != F2.
...
% Pending requests
task(F1,F2,D,t) :- request(F1,F2,t), D = (F2-F1)/|F2-F1|.
task(F1,F2,D,t) :- task(F1,F2,D,t-1), not exec(F1,F2,D,t).
...
Inputs:
#step 1.
request(2,1,1).
#endstep.
#step 2.
request(3,1,2).
#endstep.
M. Gebser, R. Kaminski, B. Kaufmann, T. Schaub Clingo = ASP + Control 11 / 20

35. Background
Encoding for Reactive ASP Solving
#base.
#external request(F1,F2,0) : floor(F1) : floor(F2) : F1 != F2.
diff(-1;1).
task(F1,F2,D,0) :- request(F1,F2,0), D = (F2-F1)/|F2-F1|.
#cumulative t.
#external request(F1,F2,t) : floor(F1) : floor(F2) : F1 != F2.
...
% Pending requests
task(F1,F2,D,t) :- request(F1,F2,t), D = (F2-F1)/|F2-F1|.
task(F1,F2,D,t) :- task(F1,F2,D,t-1), not exec(F1,F2,D,t).
...
Inputs:
#step 1.
request(2,1,1).
#endstep.
#step 2.
request(3,1,2).
#endstep.
M. Gebser, R. Kaminski, B. Kaufmann, T. Schaub Clingo = ASP + Control 11 / 20

36. Background
Encoding for Reactive ASP Solving
#base.
#external request(F1,F2,0) : floor(F1) : floor(F2) : F1 != F2.
diff(-1;1).
task(F1,F2,D,0) :- request(F1,F2,0), D = (F2-F1)/|F2-F1|.
#cumulative t.
#external request(F1,F2,t) : floor(F1) : floor(F2) : F1 != F2.
...
% Pending requests
task(F1,F2,D,t) :- request(F1,F2,t), D = (F2-F1)/|F2-F1|.
task(F1,F2,D,t) :- task(F1,F2,D,t-1), not exec(F1,F2,D,t).
...
Inputs:
#step 1.
request(2,1,1).
#endstep.
#step 2.
request(3,1,2).
#endstep.
M. Gebser, R. Kaminski, B. Kaufmann, T. Schaub Clingo = ASP + Control 11 / 20

37. Background
Reactive ASP Solving
oclingo-3 <files> + controller.py
Request 1:
Solving... Solving... Solving...
Answer: 1
move(1,2) move(-1,3)
Request 2:
Solving... Solving... Solving...
Answer: 1
move(1,2) move(1,3) move(-1,4) move(-1,5)
1
2
3
1
2
3
1
1
2
3
1 2 3
1
2
3
1
2
1
2
3
1
2
2
3 4
5
M. Gebser, R. Kaminski, B. Kaufmann, T. Schaub Clingo = ASP + Control 12 / 20

38. Background
Reactive ASP Solving
oclingo-3 <files> + controller.py
Request 1:
Solving... Solving... Solving...
Answer: 1
move(1,2) move(-1,3)
Request 2:
Solving... Solving... Solving...
Answer: 1
move(1,2) move(1,3) move(-1,4) move(-1,5)
1
2
3
1
2
3
1
1
2
3
1 2 3
1
2
3
1
2
1
2
3
1
2
2
3 4
5
M. Gebser, R. Kaminski, B. Kaufmann, T. Schaub Clingo = ASP + Control 12 / 20

39. Background
Reactive ASP Solving
oclingo-3 <files> + controller.py
Request 1:
Solving... Solving... Solving...
Answer: 1
move(1,2) move(-1,3)
Request 2:
Solving... Solving... Solving...
Answer: 1
move(1,2) move(1,3) move(-1,4) move(-1,5)
1
2
3
1
2
3
1
1
2
3
1 2 3
1
2
3
1
2
1
2
3
1
2
2
3 4
5
M. Gebser, R. Kaminski, B. Kaufmann, T. Schaub Clingo = ASP + Control 12 / 20

40. Background
Reactive ASP Solving
oclingo-3 <files> + controller.py
Request 1:
Solving... Solving... Solving...
Answer: 1
move(1,2) move(-1,3)
Request 2:
Solving... Solving... Solving...
Answer: 1
move(1,2) move(1,3) move(-1,4) move(-1,5)
1
2
3
1
2
3
1
1
2
3
1 2 3
1
2
3
1
2
1
2
3
1
2
2
3 4
5
M. Gebser, R. Kaminski, B. Kaufmann, T. Schaub Clingo = ASP + Control 12 / 20

41. Background
Reactive ASP Solving
oclingo-3 <files> + controller.py
Request 1:
Solving... Solving... Solving...
Answer: 1
move(1,2) move(-1,3)
Request 2:
Solving... Solving... Solving...
Answer: 1
move(1,2) move(1,3) move(-1,4) move(-1,5)
1
2
3
1
2
3
1
1
2
3
1 2 3
1
2
3
1
2
1
2
3
1
2
2
3 4
5
M. Gebser, R. Kaminski, B. Kaufmann, T. Schaub Clingo = ASP + Control 12 / 20

42. (More) Control
Outline
1 Background
2 (More) Control
3 Summary
M. Gebser, R. Kaminski, B. Kaufmann, T. Schaub Clingo = ASP + Control 13 / 20

43. (More) Control
Clingo 4 Approach
Custom grounding and solving via embedded scripting languages
Lua: main(prg), prg:ground(parts), prg:solve(), . . .
Python: main(prg), prg.ground(parts), prg.solve(), . . .
Library: prg.ground(parts), prg.solve(), . . .
Predecessor systems can easily be scripted
One-shot ASP solving (default): (ground | solve)
Incremental ASP solving: (ground | solve)∗
Reactive ASP solving: (ground∗
| solve)∗
. . .
Clingo: ASP + Control
M. Gebser, R. Kaminski, B. Kaufmann, T. Schaub Clingo = ASP + Control 14 / 20

44. (More) Control
Clingo 4 Approach
Custom grounding and solving via embedded scripting languages
Lua: main(prg), prg:ground(parts), prg:solve(), . . .
Python: main(prg), prg.ground(parts), prg.solve(), . . .
Library: prg.ground(parts), prg.solve(), . . .
Predecessor systems can easily be scripted
One-shot ASP solving (default): (ground | solve)
Incremental ASP solving: (ground | solve)∗
Reactive ASP solving: (ground∗
| solve)∗
. . .
Clingo: ASP + Control
M. Gebser, R. Kaminski, B. Kaufmann, T. Schaub Clingo = ASP + Control 14 / 20

45. (More) Control
Clingo 4 Approach
Custom grounding and solving via embedded scripting languages
Lua: main(prg), prg:ground(parts), prg:solve(), . . .
Python: main(prg), prg.ground(parts), prg.solve(), . . .
Library: prg.ground(parts), prg.solve(), . . .
Predecessor systems can easily be scripted
One-shot ASP solving (default): (ground | solve)
Incremental ASP solving: (ground | solve)∗
Reactive ASP solving: (ground∗
| solve)∗
. . .
Clingo: ASP + Control
M. Gebser, R. Kaminski, B. Kaufmann, T. Schaub Clingo = ASP + Control 14 / 20

46. (More) Control
Clingo 4 Approach
Custom grounding and solving via embedded scripting languages
Lua: main(prg), prg:ground(parts), prg:solve(), . . .
Python: main(prg), prg.ground(parts), prg.solve(), . . .
Library: prg.ground(parts), prg.solve(), . . .
Predecessor systems can easily be scripted
One-shot ASP solving (default): (ground | solve)
Incremental ASP solving: (ground | solve)∗
Reactive ASP solving: (ground∗
| solve)∗
. . .
Clingo: ASP + Control
M. Gebser, R. Kaminski, B. Kaufmann, T. Schaub Clingo = ASP + Control 14 / 20

47. (More) Control
Clingo 4 Approach
Custom grounding and solving via embedded scripting languages
Lua: main(prg), prg:ground(parts), prg:solve(), . . .
Python: main(prg), prg.ground(parts), prg.solve(), . . .
Library: prg.ground(parts), prg.solve(), . . .
Predecessor systems can easily be scripted
One-shot ASP solving (default): (ground | solve)
Incremental ASP solving: (ground | solve)∗
Reactive ASP solving: (ground∗
| solve)∗
. . .
Clingo: ASP + Control
M. Gebser, R. Kaminski, B. Kaufmann, T. Schaub Clingo = ASP + Control 14 / 20

48. (More) Control
Encoding for Incremental ASP Solving
#base.
diff(-1;1).
task(F1,F2,D,0) :- request(F1,F2,0), D = (F2-F1)/|F2-F1|.
#cumulative t.
{ move(D,t) : diff(D) } 1.
move(t) :- move(D,t).
% State update
at(F, t) :- at(F,t-1), not move(t).
at(F+D,t) :- at(F,t-1), move(D,t), floor(F+D).
:- not 1 { at(F,t) } 1.
% Pending requests
task(F1,F2,D,t) :- request(F1,F2,t), D = (F2-F1)/|F2-F1|.
task(F1,F2,D,t) :- task(F1,F2,D,t-1), not exec(F1,F2,D,t).
% Started tasks must be processed till completion
...
:- move(D,t-1), not move(D,t), not exec(D,t-1), not exec(-D,t).
% Move iff there is some task to process
...
:- open(t-1), not move(t).
#volatile t.
:- open(t).
M. Gebser, R. Kaminski, B. Kaufmann, T. Schaub Clingo = ASP + Control 15 / 20

49. (More) Control
Encoding for Incremental ASP Solving
#base.
diff(-1;1).
task(F1,F2,D,0) :- request(F1,F2,0), D = (F2-F1)/|F2-F1|.
#cumulative t.
{ move(D,t) : diff(D) } 1.
move(t) :- move(D,t).
% State update
at(F, t) :- at(F,t-1), not move(t).
at(F+D,t) :- at(F,t-1), move(D,t), floor(F+D).
:- not 1 { at(F,t) } 1.
% Pending requests
task(F1,F2,D,t) :- request(F1,F2,t), D = (F2-F1)/|F2-F1|.
task(F1,F2,D,t) :- task(F1,F2,D,t-1), not exec(F1,F2,D,t).
% Started tasks must be processed till completion
...
:- move(D,t-1), not move(D,t), not exec(D,t-1), not exec(-D,t).
% Move iff there is some task to process
...
:- open(t-1), not move(t).
#volatile t.
:- open(t).
M. Gebser, R. Kaminski, B. Kaufmann, T. Schaub Clingo = ASP + Control 15 / 20

50. (More) Control
Encoding for Incremental ASP Solving
#program base.
diff(-1;1).
task(F1,F2,D,0) :- request(F1,F2,0), D = (F2-F1)/|F2-F1|.
#cumulative t.
{ move(D,t) : diff(D) } 1.
move(t) :- move(D,t).
% State update
at(F, t) :- at(F,t-1), not move(t).
at(F+D,t) :- at(F,t-1), move(D,t), floor(F+D).
:- not 1 { at(F,t) } 1.
% Pending requests
task(F1,F2,D,t) :- request(F1,F2,t), D = (F2-F1)/|F2-F1|.
task(F1,F2,D,t) :- task(F1,F2,D,t-1), not exec(F1,F2,D,t).
% Started tasks must be processed till completion
...
:- move(D,t-1), not move(D,t), not exec(D,t-1), not exec(-D,t).
% Move iff there is some task to process
...
:- open(t-1), not move(t).
#volatile t.
:- open(t).
M. Gebser, R. Kaminski, B. Kaufmann, T. Schaub Clingo = ASP + Control 15 / 20

51. (More) Control
Encoding for Incremental ASP Solving
#program base.
diff(-1;1).
task(F1,F2,D,0) :- request(F1,F2,0), D = (F2-F1)/|F2-F1|.
#cumulative t.
{ move(D,t) : diff(D) } 1.
move(t) :- move(D,t).
% State update
at(F, t) :- at(F,t-1), not move(t).
at(F+D,t) :- at(F,t-1), move(D,t), floor(F+D).
:- not 1 { at(F,t) } 1.
% Pending requests
task(F1,F2,D,t) :- request(F1,F2,t), D = (F2-F1)/|F2-F1|.
task(F1,F2,D,t) :- task(F1,F2,D,t-1), not exec(F1,F2,D,t).
% Started tasks must be processed till completion
...
:- move(D,t-1), not move(D,t), not exec(D,t-1), not exec(-D,t).
% Move iff there is some task to process
...
:- open(t-1), not move(t).
#volatile t.
:- open(t).
M. Gebser, R. Kaminski, B. Kaufmann, T. Schaub Clingo = ASP + Control 15 / 20

52. (More) Control
Encoding for Incremental ASP Solving
#program base.
diff(-1;1).
task(F1,F2,D,0) :- request(F1,F2,0), D = (F2-F1)/|F2-F1|.
#program cumulative(t).
{ move(D,t) : diff(D) } 1.
move(t) :- move(D,t).
% State update
at(F, t) :- at(F,t-1), not move(t).
at(F+D,t) :- at(F,t-1), move(D,t), floor(F+D).
:- not 1 { at(F,t) } 1.
% Pending requests
task(F1,F2,D,t) :- request(F1,F2,t), D = (F2-F1)/|F2-F1|.
task(F1,F2,D,t) :- task(F1,F2,D,t-1), not exec(F1,F2,D,t).
% Started tasks must be processed till completion
...
:- move(D,t-1), not move(D,t), not exec(D,t-1), not exec(-D,t).
% Move iff there is some task to process
...
:- open(t-1), not move(t).
#volatile t.
:- open(t).
M. Gebser, R. Kaminski, B. Kaufmann, T. Schaub Clingo = ASP + Control 15 / 20

53. (More) Control
Encoding for Incremental ASP Solving
#program base.
diff(-1;1).
task(F1,F2,D,0) :- request(F1,F2,0), D = (F2-F1)/|F2-F1|.
#program cumulative(t).
{ move(D,t) : diff(D) } 1.
move(t) :- move(D,t).
% State update
at(F, t) :- at(F,t-1), not move(t).
at(F+D,t) :- at(F,t-1), move(D,t), floor(F+D).
:- not 1 { at(F,t) } 1.
% Pending requests
task(F1,F2,D,t) :- request(F1,F2,t), D = (F2-F1)/|F2-F1|.
task(F1,F2,D,t) :- task(F1,F2,D,t-1), not exec(F1,F2,D,t).
% Started tasks must be processed till completion
...
:- move(D,t-1), not move(D,t), not exec(D,t-1), not exec(-D,t).
% Move iff there is some task to process
...
:- open(t-1), not move(t).
#volatile t.
:- open(t).
M. Gebser, R. Kaminski, B. Kaufmann, T. Schaub Clingo = ASP + Control 15 / 20

54. (More) Control
Encoding for Incremental ASP Solving
#program base.
diff(-1;1).
task(F1,F2,D,0) :- request(F1,F2,0), D = (F2-F1)/|F2-F1|.
#program cumulative(t).
{ move(D,t) : diff(D) } 1.
move(t) :- move(D,t).
% State update
at(F, t) :- at(F,t-1), not move(t).
at(F+D,t) :- at(F,t-1), move(D,t), floor(F+D).
:- not 1 { at(F,t) } 1.
% Pending requests
task(F1,F2,D,t) :- request(F1,F2,t), D = (F2-F1)/|F2-F1|.
task(F1,F2,D,t) :- task(F1,F2,D,t-1), not exec(F1,F2,D,t).
% Started tasks must be processed till completion
...
:- move(D,t-1), not move(D,t), not exec(D,t-1), not exec(-D,t).
% Move iff there is some task to process
...
:- open(t-1), not move(t).
#external query(t).
:- open(t), query(t).
M. Gebser, R. Kaminski, B. Kaufmann, T. Schaub Clingo = ASP + Control 15 / 20

55. (More) Control
Script for Incremental ASP Solving
#script(python)
from gringo import *
def main(prg):
imin = prg.get const("imin")
if imin == None: imin = 1
step = 0
parts = [("base", [])]
while True:
if step < imin:
step = step+1
parts.append(("cumulative", [step]))
if step == imin:
prg.ground(parts)
parts = []
prg.assign external(Fun("query", [step]), True)
ret = prg.solve()
if ret == SolveResult.SAT: break
prg.release external(Fun("query", [step]))
imin = imin+1
#end.
M. Gebser, R. Kaminski, B. Kaufmann, T. Schaub Clingo = ASP + Control 16 / 20

56. (More) Control
Script for Incremental ASP Solving
#script(python)
from gringo import *
def main(prg):
imin = prg.get const("imin")
if imin == None: imin = 1
step = 0
parts = [("base", [])]
while True:
if step < imin:
step = step+1
parts.append(("cumulative", [step]))
if step == imin:
prg.ground(parts)
parts = []
prg.assign external(Fun("query", [step]), True)
ret = prg.solve()
if ret == SolveResult.SAT: break
prg.release external(Fun("query", [step]))
imin = imin+1
#end.
M. Gebser, R. Kaminski, B. Kaufmann, T. Schaub Clingo = ASP + Control 16 / 20

57. (More) Control
Script for Incremental ASP Solving
#script(python)
from gringo import *
def main(prg):
imin = prg.get const("imin")
if imin == None: imin = 1
step = 0
parts = [("base", [])]
while True:
if step < imin:
step = step+1
parts.append(("cumulative", [step]))
if step == imin:
prg.ground(parts)
parts = []
prg.assign external(Fun("query", [step]), True)
ret = prg.solve()
if ret == SolveResult.SAT: break
prg.release external(Fun("query", [step]))
imin = imin+1
#end.
M. Gebser, R. Kaminski, B. Kaufmann, T. Schaub Clingo = ASP + Control 16 / 20

58. (More) Control
Script for Incremental ASP Solving
#script(python)
from gringo import *
def main(prg):
imin = prg.get const("imin")
if imin == None: imin = 1
step = 0
parts = [("base", [])]
while True:
if step < imin:
step = step+1
parts.append(("cumulative", [step]))
if step == imin:
prg.ground(parts)
parts = []
prg.assign external(Fun("query", [step]), True)
ret = prg.solve()
if ret == SolveResult.SAT: break
prg.release external(Fun("query", [step]))
imin = imin+1
#end.
M. Gebser, R. Kaminski, B. Kaufmann, T. Schaub Clingo = ASP + Control 16 / 20

59. (More) Control
Script for Incremental ASP Solving
#script(python)
from gringo import *
def main(prg):
imin = prg.get const("imin")
if imin == None: imin = 1
step = 0
parts = [("base", [])]
while True:
if step < imin:
step = step+1
parts.append(("cumulative", [step]))
if step == imin:
prg.ground(parts)
parts = []
prg.assign external(Fun("query", [step]), True)
ret = prg.solve()
if ret == SolveResult.SAT: break
prg.release external(Fun("query", [step]))
imin = imin+1
#end.
M. Gebser, R. Kaminski, B. Kaufmann, T. Schaub Clingo = ASP + Control 16 / 20

60. (More) Control
Script for Incremental ASP Solving
#script(python)
from gringo import *
def main(prg):
imin = prg.get const("imin")
if imin == None: imin = 1
step = 0
parts = [("base", [])]
while True:
if step < imin:
step = step+1
parts.append(("cumulative", [step]))
if step == imin:
prg.ground(parts)
parts = []
prg.assign external(Fun("query", [step]), True)
ret = prg.solve()
if ret == SolveResult.SAT: break
prg.release external(Fun("query", [step]))
imin = imin+1
#end.
M. Gebser, R. Kaminski, B. Kaufmann, T. Schaub Clingo = ASP + Control 16 / 20

61. (More) Control
Script for Incremental ASP Solving
#script(python)
from gringo import *
def main(prg):
imin = prg.get const("imin")
if imin == None: imin = 1
step = 0
parts = [("base", [])]
while True:
if step < imin:
step = step+1
parts.append(("cumulative", [step]))
if step == imin:
prg.ground(parts)
parts = []
prg.assign external(Fun("query", [step]), True)
ret = prg.solve()
if ret == SolveResult.SAT: break
prg.release external(Fun("query", [step]))
imin = imin+1
#end.
M. Gebser, R. Kaminski, B. Kaufmann, T. Schaub Clingo = ASP + Control 16 / 20

62. (More) Control
Script for Incremental ASP Solving
#script(python)
from gringo import *
def main(prg):
imin = prg.get const("imin")
if imin == None: imin = 1
step = 0
parts = [("base", [])]
while True:
if step < imin:
step = step+1
parts.append(("cumulative", [step]))
if step == imin:
prg.ground(parts)
parts = []
prg.assign external(Fun("query", [step]), True)
ret = prg.solve()
if ret == SolveResult.SAT: break
prg.release external(Fun("query", [step]))
imin = imin+1
#end.
M. Gebser, R. Kaminski, B. Kaufmann, T. Schaub Clingo = ASP + Control 16 / 20

63. (More) Control
My Script for Incremental ASP Solving
#script(python)
from gringo import *
def main(prg):
imin = prg.get const("imin")
if imin == None: imin = 1
step = 0
parts = [("base", [])]
while True:
if step < imin:
step = step+1
parts.append(("cumulative", [step]))
if step == imin:
prg.ground(parts)
parts = []
prg.assign external(Fun("query", [step]), True)
ret = prg.solve()
if ret == SolveResult.SAT: break
prg.release external(Fun("query", [step]))
imin = imin+1
#end.
M. Gebser, R. Kaminski, B. Kaufmann, T. Schaub Clingo = ASP + Control 16 / 20

64. (More) Control
My Script for Incremental ASP Solving
#script(python)
from gringo import *
def main(prg):
imin = prg.get const("imin")
if imin == None: imin = 1
step = 0
parts = [("base", []), ("task", [step])]
while True:
if step < imin:
step = step+1
parts.append(("cumulative", [step]))
parts.append(("task", [step]))
if step == imin:
prg.ground(parts)
parts = []
ret = prg.solve()
if ret == SolveResult.SAT: break
imin = imin+1
#end.
M. Gebser, R. Kaminski, B. Kaufmann, T. Schaub Clingo = ASP + Control 16 / 20

65. (More) Control
My Encoding for Incremental ASP Solving
#program base.
diff(-1;1).
task(F1,F2,D,0) :- request(F1,F2,0), D = (F2-F1)/|F2-F1|.
#program cumulative(t).
{ move(D,t) : diff(D) } 1.
move(t) :- move(D,t).
% State update
...
% Pending requests
task(F1,F2,D,t) :- request(F1,F2,t), D = (F2-F1)/|F2-F1|.
task(F1,F2,D,t) :- task(F1,F2,D,t-1), not exec(F1,F2,D,t).
% Started tasks must be processed till completion
...
:- move(D,t-1), not move(D,t), not exec(D,t-1), not exec(-D,t).
% Move iff there is some task to process
open(t) :- task(F1,F2,D,t).
open(t) :- exec(F2,D,t), not at(F2,t).
:- move(t), not open(t-1).
:- open(t-1), not move(t).
#external query(t).
:- open(t), query(t).
M. Gebser, R. Kaminski, B. Kaufmann, T. Schaub Clingo = ASP + Control 17 / 20

66. (More) Control
My Encoding for Incremental ASP Solving
#program base.
diff(-1;1).
task(F1,F2,D,0) :- request(F1,F2,0), D = (F2-F1)/|F2-F1|.
#program cumulative(t).
{ move(D,t) : diff(D) } 1.
move(t) :- move(D,t).
% State update
...
% Pending requests
task(F1,F2,D,t) :- request(F1,F2,t), D = (F2-F1)/|F2-F1|.
task(F1,F2,D,t) :- task(F1,F2,D,t-1), not exec(F1,F2,D,t).
% Started tasks must be processed till completion
...
:- move(D,t-1), not move(D,t), not exec(D,t-1), not exec(-D,t).
% Move iff there is some task to process
open(t) :- task(F1,F2,D,t).
open(t) :- exec(F2,D,t), not at(F2,t).
:- move(t), not open(t-1).
:- open(t-1), not move(t).
#external query(t).
:- open(t), query(t).
M. Gebser, R. Kaminski, B. Kaufmann, T. Schaub Clingo = ASP + Control 17 / 20

67. (More) Control
My Encoding for Incremental ASP Solving
#program base.
diff(-1;1).
task(F1,F2,D,0) :- request(F1,F2,0), D = (F2-F1)/|F2-F1|.
#program cumulative(t).
{ move(D,t) : diff(D) } 1.
move(t) :- move(D,t).
% State update
...
% Pending requests
task(F1,F2,D,t) :- request(F1,F2,t), D = (F2-F1)/|F2-F1|.
task(F1,F2,D,t) :- task(F1,F2,D,t-1), not exec(F1,F2,D,t).
% Started tasks must be processed till completion
...
:- move(D,t-1), not move(D,t), not exec(D,t-1), not exec(-D,t).
% Move iff there is some task to process
open(t) :- task(F1,F2,D,t).
open(t) :- exec(F2,D,t), not at(F2,t).
:- move(t), not open(t-1).
:- open(t-1), not move(t).
#external query(t).
:- open(t), query(t).
M. Gebser, R. Kaminski, B. Kaufmann, T. Schaub Clingo = ASP + Control 17 / 20

68. (More) Control
My Encoding for Incremental ASP Solving
#program base.
diff(-1;1).
#program task(t).
#external move(t+1).
task(F1,F2,D,t) :- request(F1,F2,t), D = (F2-F1)/|F2-F1|.
open(t) :- task(F1,F2,D,t).
:- open(t), not move(t+1).
#program cumulative(t).
{ move(D,t) : diff(D) } 1.
move(t) :- move(D,t).
% State update
...
% Pending requests
task(F1,F2,D,t) :- task(F1,F2,D,t-1), not exec(F1,F2,D,t).
% Started tasks must be processed till completion
...
:- move(D,t-1), not move(D,t), not exec(D,t-1), not exec(-D,t).
% Move iff there is some task to process
open(t) :- exec(F2,D,t), not at(F2,t).
:- move(t), not open(t-1).
M. Gebser, R. Kaminski, B. Kaufmann, T. Schaub Clingo = ASP + Control 17 / 20

69. (More) Control
My Encoding for Incremental ASP Solving
#program base.
diff(-1;1).
#program task(t).
#external move(t+1).
task(F1,F2,D,t) :- request(F1,F2,t), D = (F2-F1)/|F2-F1|.
open(t) :- task(F1,F2,D,t).
:- open(t), not move(t+1).
#program cumulative(t).
{ move(D,t) : diff(D) } 1.
move(t) :- move(D,t).
% State update
...
% Pending requests
task(F1,F2,D,t) :- task(F1,F2,D,t-1), not exec(F1,F2,D,t).
% Started tasks must be processed till completion
...
:- move(D,t-1), not move(D,t), not exec(D,t-1), not exec(-D,t).
% Move iff there is some task to process
open(t) :- exec(F2,D,t), not at(F2,t).
:- move(t), not open(t-1).
M. Gebser, R. Kaminski, B. Kaufmann, T. Schaub Clingo = ASP + Control 17 / 20

70. (More) Control
My Encoding for Incremental ASP Solving
#program base.
diff(-1;1).
#program task(t).
#external move(t+1).
task(F1,F2,D,t) :- request(F1,F2,t), D = (F2-F1)/|F2-F1|.
open(t) :- task(F1,F2,D,t).
:- open(t), not move(t+1).
#program cumulative(t).
{ move(D,t) : diff(D) } 1.
move(t) :- move(D,t).
% State update
...
% Pending requests
task(F1,F2,D,t) :- task(F1,F2,D,t-1), not exec(F1,F2,D,t).
% Started tasks must be processed till completion
...
:- move(D,t-1), not move(D,t), not exec(D,t-1), not exec(-D,t).
% Move iff there is some task to process
open(t) :- exec(F2,D,t), not at(F2,t).
:- move(t), not open(t-1).
M. Gebser, R. Kaminski, B. Kaufmann, T. Schaub Clingo = ASP + Control 17 / 20

71. (More) Control
My Encoding for Incremental ASP Solving
#program base.
diff(-1;1).
#program task(t).
#external move(t+1).
task(F1,F2,D,t) :- request(F1,F2,t), D = (F2-F1)/|F2-F1|.
open(t) :- task(F1,F2,D,t).
:- open(t), not move(t+1).
#program cumulative(t).
#external move(D,t+1) : diff(D).
#external exec(D,t+1) : diff(D).
{ move(D,t) : diff(D) } 1.
move(t) :- move(D,t).
% State update
...
% Pending requests
task(F1,F2,D,t) :- task(F1,F2,D,t-1), not exec(F1,F2,D,t).
% Started tasks must be processed till completion
...
:- move(D,t), not move(D,t+1), not exec(D,t), not exec(-D,t+1).
% Move iff there is some task to process
open(t) :- exec(F2,D,t), not at(F2,t).
:- move(t), not open(t-1).
M. Gebser, R. Kaminski, B. Kaufmann, T. Schaub Clingo = ASP + Control 17 / 20

72. (More) Control
My Encoding for Incremental ASP Solving
#program base.
diff(-1;1).
#program task(t).
#external move(t+1).
task(F1,F2,D,t) :- request(F1,F2,t), D = (F2-F1)/|F2-F1|.
open(t) :- task(F1,F2,D,t).
:- open(t), not move(t+1).
#program cumulative(t).
#external move(D,t+1) : diff(D).
#external exec(D,t+1) : diff(D).
{ move(D,t) : diff(D) } 1.
move(t) :- move(D,t).
% State update
...
% Pending requests
task(F1,F2,D,t) :- task(F1,F2,D,t-1), not exec(F1,F2,D,t).
% Started tasks must be processed till completion
...
:- move(D,t), not move(D,t+1), not exec(D,t), not exec(-D,t+1).
% Move iff there is some task to process
open(t) :- exec(F2,D,t), not at(F2,t).
:- move(t), not open(t-1).
M. Gebser, R. Kaminski, B. Kaufmann, T. Schaub Clingo = ASP + Control 17 / 20

73. (More) Control
Custom ASP Solving
Encoding consisting of named and parameterizable subprograms
#program base. (default), #program cumulative(t)., . . .
External (yet undefined) atoms provide input interface to other parts
#external <atom> [ : <body> ].
Embedded scripts allow for flexible grounding and solving control
#script(python | lua) . . . main(prg) . . . #end.
Instantiation triggered by passing subprogram names plus arguments
prg.ground([("base", []), ("task", [step])])
Ground program parts constitute modules (with disjoint head atoms)
Search for stable models of ground program parts stored by solver
prg.solve(), prg.solve(on model = pretty print), . . .
Incremental and/or reactive ASP solving via “i/oClingo” scripts
#include <iclingo>.
prg.add("request1", [], "request(2,1,1).")
M. Gebser, R. Kaminski, B. Kaufmann, T. Schaub Clingo = ASP + Control 18 / 20

74. (More) Control
Custom ASP Solving
Encoding consisting of named and parameterizable subprograms
#program base. (default), #program cumulative(t)., . . .
External (yet undefined) atoms provide input interface to other parts
#external <atom> [ : <body> ].
Embedded scripts allow for flexible grounding and solving control
#script(python | lua) . . . main(prg) . . . #end.
Instantiation triggered by passing subprogram names plus arguments
prg.ground([("base", []), ("task", [step])])
Ground program parts constitute modules (with disjoint head atoms)
Search for stable models of ground program parts stored by solver
prg.solve(), prg.solve(on model = pretty print), . . .
Incremental and/or reactive ASP solving via “i/oClingo” scripts
#include <iclingo>.
prg.add("request1", [], "request(2,1,1).")
M. Gebser, R. Kaminski, B. Kaufmann, T. Schaub Clingo = ASP + Control 18 / 20

75. (More) Control
Custom ASP Solving
Encoding consisting of named and parameterizable subprograms
#program base. (default), #program cumulative(t)., . . .
External (yet undefined) atoms provide input interface to other parts
#external <atom> [ : <body> ].
Embedded scripts allow for flexible grounding and solving control
#script(python | lua) . . . main(prg) . . . #end.
Instantiation triggered by passing subprogram names plus arguments
prg.ground([("base", []), ("task", [step])])
Ground program parts constitute modules (with disjoint head atoms)
Search for stable models of ground program parts stored by solver
prg.solve(), prg.solve(on model = pretty print), . . .
Incremental and/or reactive ASP solving via “i/oClingo” scripts
#include <iclingo>.
prg.add("request1", [], "request(2,1,1).")
M. Gebser, R. Kaminski, B. Kaufmann, T. Schaub Clingo = ASP + Control 18 / 20

76. Summary
Outline
1 Background
2 (More) Control
3 Summary
M. Gebser, R. Kaminski, B. Kaufmann, T. Schaub Clingo = ASP + Control 19 / 20

77. Summary
Summary
ASP as an under-the-hood technology !
Clingo 4
Multi-shot ASP solving
Continuously changing programs
Opens up new areas of applications
Agents
Policies
Planning
Robotics
Interaction
Theory solving
Query-answering
. . .
http://potassco.sourceforge.net
M. Gebser, R. Kaminski, B. Kaufmann, T. Schaub Clingo = ASP + Control 20 / 20

78. Summary
Summary
ASP as an under-the-hood technology !
Clingo 4
Multi-shot ASP solving
Continuously changing programs
Opens up new areas of applications
Agents
Policies
Planning
Robotics
Interaction
Theory solving
Query-answering
. . .
http://potassco.sourceforge.net
M. Gebser, R. Kaminski, B. Kaufmann, T. Schaub Clingo = ASP + Control 20 / 20

79. Summary
Summary
ASP as an under-the-hood technology !
Clingo 4
Multi-shot ASP solving
Continuously changing programs
Opens up new areas of applications
Agents
Policies
Planning
Robotics
Interaction
Theory solving
Query-answering
. . .
http://potassco.sourceforge.net
M. Gebser, R. Kaminski, B. Kaufmann, T. Schaub Clingo = ASP + Control 20 / 20