Clingo = Answer Set Programming + Control

Martin Gebser? Roland KaminskiBenjamin Kaufmann Torsten Schaub

University of Potsdam

?Aalto University

M. Gebser, R. Kaminski, B. Kaufmann, T. Schaub Clingo = ASP + Control 1 / 20

MotivationASP is an approach to declarative problem solving, combining

a rich yet simple modeling languagewith high-performance solving capacities

tailored to Knowledge Representation and ReasoningElaborate reasoning processes feature

incremental solving, as in planning or finite model finding, or evenreactive solving, as in robotics or query-answering

Problem

LogicProgram Grounder Solver Stable

Models

Solutions

- - -

?

6

One-shot ASP Solving

M. Gebser, R. Kaminski, B. Kaufmann, T. Schaub Clingo = ASP + Control 2 / 20

MotivationASP is an approach to declarative problem solving, combining

a rich yet simple modeling languagewith high-performance solving capacities

tailored to Knowledge Representation and ReasoningElaborate reasoning processes feature

incremental solving, as in planning or finite model finding, or evenreactive solving, as in robotics or query-answering

Problem

LogicProgram Grounder Solver Stable

Models

Solutions

- - -

?

6

Incremental ASP Solving

6

M. Gebser, R. Kaminski, B. Kaufmann, T. Schaub Clingo = ASP + Control 2 / 20

MotivationASP is an approach to declarative problem solving, combining

a rich yet simple modeling languagewith high-performance solving capacities

tailored to Knowledge Representation and ReasoningElaborate reasoning processes feature

incremental solving, as in planning or finite model finding, or evenreactive solving, as in robotics or query-answering

Problem

LogicProgram Grounder Solver Stable

Models

Solutions

- - -

?

6

Reactive ASP Solving

66

M. Gebser, R. Kaminski, B. Kaufmann, T. Schaub Clingo = ASP + Control 2 / 20

Outline

1 Background

2 (More) Control

3 Summary

M. Gebser, R. Kaminski, B. Kaufmann, T. Schaub Clingo = ASP + Control 3 / 20

Background

Outline

1 Background

2 (More) Control

3 Summary

M. Gebser, R. Kaminski, B. Kaufmann, T. Schaub Clingo = ASP + Control 4 / 20

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 solvercumulative(i): grounded for increasing i-values and stored by solvervolatile(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

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 solvercumulative(i): grounded for increasing i-values and stored by solvervolatile(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

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 solvercumulative(i): grounded for increasing i-values and stored by solvervolatile(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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

(More) Control

Outline

1 Background

2 (More) Control

3 Summary

M. Gebser, R. Kaminski, B. Kaufmann, T. Schaub Clingo = ASP + Control 13 / 20

(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

(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

(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

(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

(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

(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

(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

(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

(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

(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

(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

(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

(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: breakprg.release external(Fun("query", [step]))

imin = imin+1

#end.

M. Gebser, R. Kaminski, B. Kaufmann, T. Schaub Clingo = ASP + Control 16 / 20

(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: breakprg.release external(Fun("query", [step]))

imin = imin+1

#end.

M. Gebser, R. Kaminski, B. Kaufmann, T. Schaub Clingo = ASP + Control 16 / 20

(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: breakprg.release external(Fun("query", [step]))

imin = imin+1

#end.

M. Gebser, R. Kaminski, B. Kaufmann, T. Schaub Clingo = ASP + Control 16 / 20

(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: breakprg.release external(Fun("query", [step]))

imin = imin+1

#end.

M. Gebser, R. Kaminski, B. Kaufmann, T. Schaub Clingo = ASP + Control 16 / 20

(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: breakprg.release external(Fun("query", [step]))

imin = imin+1

#end.

M. Gebser, R. Kaminski, B. Kaufmann, T. Schaub Clingo = ASP + Control 16 / 20

(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: breakprg.release external(Fun("query", [step]))

imin = imin+1

#end.

M. Gebser, R. Kaminski, B. Kaufmann, T. Schaub Clingo = ASP + Control 16 / 20

(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: breakprg.release external(Fun("query", [step]))

imin = imin+1

#end.

M. Gebser, R. Kaminski, B. Kaufmann, T. Schaub Clingo = ASP + Control 16 / 20

(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: breakprg.release external(Fun("query", [step]))

imin = imin+1

#end.

M. Gebser, R. Kaminski, B. Kaufmann, T. Schaub Clingo = ASP + Control 16 / 20

(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: breakprg.release external(Fun("query", [step]))

imin = imin+1

#end.

M. Gebser, R. Kaminski, B. Kaufmann, T. Schaub Clingo = ASP + Control 16 / 20

(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: breakimin = imin+1

#end.

M. Gebser, R. Kaminski, B. Kaufmann, T. Schaub Clingo = ASP + Control 16 / 20

(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

(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

(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

(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

(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

(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

(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

(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

(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

(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

(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

Summary

Outline

1 Background

2 (More) Control

3 Summary

M. Gebser, R. Kaminski, B. Kaufmann, T. Schaub Clingo = ASP + Control 19 / 20

Summary

Summary

ASP as an under-the-hood technology !

Clingo 4Multi-shot ASP solving

Continuously changing programs

Opens up new areas of applications

AgentsPoliciesPlanningRoboticsInteractionTheory solvingQuery-answering. . .

http://potassco.sourceforge.net

M. Gebser, R. Kaminski, B. Kaufmann, T. Schaub Clingo = ASP + Control 20 / 20

Summary

Summary

ASP as an under-the-hood technology !

Clingo 4Multi-shot ASP solving

Continuously changing programs

Opens up new areas of applications

AgentsPoliciesPlanningRoboticsInteractionTheory solvingQuery-answering. . .

http://potassco.sourceforge.net

M. Gebser, R. Kaminski, B. Kaufmann, T. Schaub Clingo = ASP + Control 20 / 20

Summary

Summary

ASP as an under-the-hood technology !

Clingo 4Multi-shot ASP solving

Continuously changing programs

Opens up new areas of applications

AgentsPoliciesPlanningRoboticsInteractionTheory solvingQuery-answering. . .

http://potassco.sourceforge.net

M. Gebser, R. Kaminski, B. Kaufmann, T. Schaub Clingo = ASP + Control 20 / 20