Merge branch 'master' of github.com:potassco/plasp into develop

README.md

@@ -64,11 +64,12 @@ If you want to write your own meta encoding for `plasp`’s output, this [simple
 
 `plasp` requires `boost` and is built via CMake and a C++ compiler.
 
-See [building instructions](doc/building-instructions.md) for more details.
+See [building](doc/building.md) for more details.
 
 ## Contributors
 
 * [Patrick Lühne](https://www.luehne.de)
+* Martin Gebser (encodings)
 * Torsten Schaub (encodings)
 
 ### Earlier Versions

doc/building.md

@@ -1,4 +1,4 @@
-# Building Instructions
+# Building
 
 `plasp` requires a C++14 compiler (preferrably GCC ≥ 6.1 or clang ≥ 3.8), the `boost` libraries (≥ 1.55), and CMake for building.
 

encodings/strips/README.md

@@ -0,0 +1,56 @@
+# Incremental STRIPS Planning Encodings
+
+This suite of incremental STRIPS planning encodings implements diverse methods.
+The included encoding files provide the following functionalities:
+
+## Encodings
+
+### [preprocess.lp](preprocess.lp): static analysis of potentially relevant actions
+
+* Parameters: `_closure` (default value: `3`)
+  * Value `1`: forward chaining of effects w.r.t. initial variable values
+  * Value `2`: backward regression of effects w.r.t. goal variable values
+  * Value `3`: both forward chaining and backward regression of effects
+  * Otherwise: off (simply take all actions as given)
+
+### [strips-incremental.lp](strips-incremental.lp): sequential and parallel planning encoding variants
+* Parameters: `_parallel` (default value: `0`)
+  * Value `1`: “forall” parallel actions that can be arranged in any sequence
+  * Value `2`: “exists” parallel actions that can be arranged in some sequence
+  * Otherwise: sequential actions
+
+### [redundancy.lp](redundancy.lp): enforcement of ‘redundant’ actions to constrain parallel plans
+* Remarks:
+  * Only relevant together with parallel actions
+  * Encoded constraints seem rather ineffective though
+  * Heavy space overhead in combination with “exists” parallel actions
+
+### [postprocess.lp](postprocess.lp): plan feasibility checking and conversion to sequential plan
+
+## Usage Examples
+
+Some example invocations (using `clingo` 5.1.0) are as follows:
+
+```bash
+plasp ../../instances/PDDL/ipc-2000-elevator-m10-strips/domain.pddl ../../instances/PDDL/ipc-2000-elevator-m10-strips/problem-04-00.pddl | clingo - preprocess.lp strips-incremental.lp
+
+plasp ../../instances/PDDL/ipc-2000-elevator-m10-strips/domain.pddl ../../instances/PDDL/ipc-2000-elevator-m10-strips/problem-04-00.pddl | clingo - preprocess.lp strips-incremental.lp -c _closure=0
+
+plasp ../../instances/PDDL/ipc-2000-elevator-m10-strips/domain.pddl ../../instances/PDDL/ipc-2000-elevator-m10-strips/problem-04-00.pddl | clingo - preprocess.lp strips-incremental.lp -c _closure=1
+
+plasp ../../instances/PDDL/ipc-2000-elevator-m10-strips/domain.pddl ../../instances/PDDL/ipc-2000-elevator-m10-strips/problem-04-00.pddl | clingo - preprocess.lp strips-incremental.lp -c _closure=2
+
+plasp ../../instances/PDDL/ipc-2000-elevator-m10-strips/domain.pddl ../../instances/PDDL/ipc-2000-elevator-m10-strips/problem-04-00.pddl | clingo - preprocess.lp strips-incremental.lp -c _parallel=1
+
+plasp ../../instances/PDDL/ipc-2000-elevator-m10-strips/domain.pddl ../../instances/PDDL/ipc-2000-elevator-m10-strips/problem-04-00.pddl | clingo - preprocess.lp strips-incremental.lp -c _parallel=2
+
+plasp ../../instances/PDDL/ipc-2000-elevator-m10-strips/domain.pddl ../../instances/PDDL/ipc-2000-elevator-m10-strips/problem-04-00.pddl | clingo - preprocess.lp strips-incremental.lp -c _parallel=1 redundancy.lp
+
+plasp ../../instances/PDDL/ipc-2000-elevator-m10-strips/domain.pddl ../../instances/PDDL/ipc-2000-elevator-m10-strips/problem-04-00.pddl | clingo - preprocess.lp strips-incremental.lp -c _parallel=2 redundancy.lp
+
+plasp ../../instances/PDDL/ipc-2000-elevator-m10-strips/domain.pddl ../../instances/PDDL/ipc-2000-elevator-m10-strips/problem-04-00.pddl | clingo - preprocess.lp strips-incremental.lp --outf=1 | grep -A1 -e "ANSWER" | tail -n1 | clingo - postprocess.lp <(plasp ../../instances/PDDL/ipc-2000-elevator-m10-strips/domain.pddl ../../instances/PDDL/ipc-2000-elevator-m10-strips/problem-04-00.pddl)
+
+plasp ../../instances/PDDL/ipc-2000-elevator-m10-strips/domain.pddl ../../instances/PDDL/ipc-2000-elevator-m10-strips/problem-04-00.pddl | clingo - preprocess.lp strips-incremental.lp --outf=1 -c _parallel=1 | grep -A1 -e "ANSWER" | tail -n1 | clingo - postprocess.lp <(plasp ../../instances/PDDL/ipc-2000-elevator-m10-strips/domain.pddl ../../instances/PDDL/ipc-2000-elevator-m10-strips/problem-04-00.pddl)
+
+plasp ../../instances/PDDL/ipc-2000-elevator-m10-strips/domain.pddl ../../instances/PDDL/ipc-2000-elevator-m10-strips/problem-04-00.pddl | clingo - preprocess.lp strips-incremental.lp --outf=1 -c _parallel=2 | grep -A1 -e "ANSWER" | tail -n1 | clingo - postprocess.lp <(plasp ../../instances/PDDL/ipc-2000-elevator-m10-strips/domain.pddl ../../instances/PDDL/ipc-2000-elevator-m10-strips/problem-04-00.pddl)
+```

encodings/strips/postprocess.lp

@@ -0,0 +1,58 @@
+% Convert a plan (possibly with parallel actions), given by atoms over occurs/2,
+% to a sequential plan, expressed by atoms over sequence/2
+
+time(T) :- occurs(A,T).
+time    :- time(T).
+
+:- goal(X,V), not initialState(X,V), not time.
+
+last(T2) :- time, T2 = #max{T1 : time(T1)}.
+
+offset(T2,M)    :- time(T2), M = #count{A,T1 : occurs(A,T1), T1 < T2}.
+finish(T,M+N)   :- offset(T,M), N = #count{A : occurs(A,T)}.
+index(T,M+1..N) :- offset(T,M), finish(T,N).
+
+postcondition(A,X,V) :- postcondition(A,E,X,V), occurs(A,T).
+postcondition(A,X)   :- postcondition(A,X,V).
+
+before(A1,A2,T) :- occurs(A1,T), occurs(A2,T), A1 != A2,
+                   precondition(A1,X,V), postcondition(A2,X), not postcondition(A2,X,V).
+
+order(A1,A2,T) :- occurs(A1,T), occurs(A2,T), A1 < A2, A <= A1 : occurs(A,T), A < A2.
+first(A2,T)    :- occurs(A2,T), #false : order(A1,A2,T).
+
+undone(A,T,M) :- occurs(A,T), offset(T,M).
+undone(A,T,N) :- undone(A,T,N-1), select(A1,T,N), A != A1, index(T,N+1).
+
+done(A,T,N) :- select(A,T,N).
+done(A,T,N) :- done(A,T,N-1), index(T,N).
+
+:- finish(T,N), occurs(A,T), not done(A,T,N).
+
+hold(X,V,0) :- initialState(X,V).
+hold(X,V,N) :- select(A,T,N), postcondition(A,X,V).
+hold(X,V,N) :- select(A,T,N), hold(X,V,N-1), not postcondition(A,X).
+
+:- last(T), finish(T,N), goal(X,V), not hold(X,V,N).
+
+hold(X,N) :- hold(X,V,N).
+
+:- hold(X,N), #count{V : hold(X,V,N)} > 1.
+
+preconditions(A,T,N) :- undone(A,T,N), hold(X,V,N) : precondition(A,X,V).
+applicable(A,T,N)    :- preconditions(A,T,N), done(A1,T,N) : before(A1,A,T).
+
+inapplicable(A,T,N) :- done(A,T,N), index(T,N+1).
+inapplicable(A,T,N) :- undone(A,T,N), precondition(A,X,V1), hold(X,V2,N), V1 != V2.
+inapplicable(A,T,N) :- undone(A1,T,N), before(A1,A,T).
+
+continue(A2,T,N) :- order(A1,A2,T), inapplicable(A1,T,N), first(A1,T).
+continue(A2,T,N) :- order(A1,A2,T), inapplicable(A1,T,N), continue(A1,T,N).
+
+select(A,T,N+1) :- applicable(A,T,N), first(A,T).
+select(A,T,N+1) :- applicable(A,T,N), continue(A,T,N).
+
+% DISPLAY PART
+
+#show.
+#show sequence(A,N) : select(A,T,N).

encodings/strips/preprocess.lp

@@ -0,0 +1,48 @@
+% Constant '_closure' to (de)activate analysis of potentially relevant actions
+% - value '1': forward chaining of effects w.r.t. initial variable values
+% - value '2': backward regression of effects w.r.t. goal variable values
+% - value '3': both forward chaining and backward regression of effects
+% - otherwise: off
+
+#const _closure = 3.
+
+% Check feature requirements
+
+:- requires(feature(actionCosts)).
+:- requires(feature(axiomRules)).
+:- requires(feature(conditionalEffects)).
+
+% Basic redundancy check for actions
+
+postcondition(A,X,V) :- postcondition(A,E,X,V).
+
+has_condition(A,X,0) :- action(A), precondition(A,X,V).
+has_condition(A,X,1) :- action(A), postcondition(A,X,V).
+
+inconsistent(A) :- has_condition(A,X,P),
+                   #count{V : precondition(A,X,V), P = 0;
+                          V : postcondition(A,X,V), P = 1} > 1.
+consistent(A)   :- action(A), not inconsistent(A).
+irredundant(A)  :- consistent(A), postcondition(A,X,V), not precondition(A,X,V).
+
+% Forward chaining of effects w.r.t. initial variable values
+
+feasible(X,V) :- initialState(X,V).
+feasible(X,V) :- possible(A), postcondition(A,X,V).
+
+possible(A) :- irredundant(A), feasible(X,V) : precondition(A,X,V).
+possible(A) :- irredundant(A), _closure != 1, _closure != 3.
+
+:- goal(X,V), not feasible(X,V).
+
+% Backward regression of effects w.r.t. goal variable values
+
+produce(X,V) :- goal(X,V), not initialState(X,V).
+produce(X,V) :- active(A), precondition(A,X,V), not initialState(X,V).
+produce(X,V) :- persist(X,V), active(A), has_condition(A,X,1), not postcondition(A,X,V).
+
+persist(X,V) :- goal(X,V), initialState(X,V).
+persist(X,V) :- active(A), precondition(A,X,V), initialState(X,V).
+
+active(A) :- possible(A), postcondition(A,X,V), produce(X,V).
+active(A) :- possible(A), _closure != 2, _closure != 3.

encodings/strips/redundancy.lp

@@ -0,0 +1,33 @@
+% Additional rules for enforcing the inclusion of parallel actions in plans,
+% whenever such 'redundant' actions are compatible with states and other actions
+
+compatible(A,A1) :- active(A), active(A1), A != A1, _parallel = 2,
+                    not diverge(A,A1), not diverge(A1,A).
+compatible(A)    :- compatible(A,A1).
+
+disable(A,A1,A2) :- disable(A1,A2), compatible(A,A1), compatible(A,A2).
+disabled(A,A2)   :- disable(A,A1,A2).
+disabled(A,A2)   :- disable(A,A2).
+
+#program step(t).
+
+defeated(A,t) :- active(A), postcondition(A,X,V), fluent(X), not holds(X,V,t),
+                 _parallel = 1 : _parallel != 2.
+
+defeated(A,t) :- _parallel = 1, active(A), precondition(A,X,V), not holds(X,V,t-1).
+defeated(A,t) :- _parallel = 1, active(A), precondition(A,X,V), not holds(X,V,t).
+defeated(A,t) :- _parallel = 1, active(A), postcondition(A,X,V), not precondition(A,X,V),
+                 single(X,t).
+
+proceed(A,X,V,t) :- compatible(A), holds(X,V,t-1), scope(X,V).
+proceed(A,X,V,t) :- compatible(A,A1), occurs(A1,t), perform(A,A1,t),
+                    postcondition(A1,X,V), scope(X,V), not precondition(A1,X,V).
+
+perform(A,A1,t) :- disabled(A,A1), not occurs(A1,t).
+perform(A,A1,t) :- compatible(A,A1),
+                   proceed(A,X,V,t) : precondition(A1,X,V); perform(A,A2,t) : disable(A,A1,A2).
+
+defeated(A,t) :- compatible(A), precondition(A,X,V), not proceed(A,X,V,t).
+defeated(A,t) :- compatible(A), disable(A,A2), not perform(A,A2,t).
+
+:- active(A), not occurs(A,t), not defeated(A,t), _parallel = 1 : _parallel != 2.

encodings/strips/strips-incremental.lp

@@ -0,0 +1,104 @@
+% Constant '_parallel' to enable parallel actions
+% - value '1': "forall" parallel actions that can be arranged in any sequence
+% - value '2': "exists" parallel actions that can be arranged in some sequence
+% - otherwise: sequential actions
+
+#const _parallel = 0.
+
+#include <incmode>.
+
+% BASE PROGRAM
+
+% Define auxiliary predicates for actions w.r.t. parallel mode
+
+diverge(A1,A2,X) :- active(A1), active(A2), A1 < A2, postcondition(A1,X,V),
+                    has_condition(A2,X,1), not postcondition(A2,X,V),
+                    _parallel = 1 : _parallel != 2.
+diverge(A1,A2)   :- diverge(A1,A2,X).
+
+exclude(A1,A2) :- diverge(A1,A2), precondition(A1,X,V), _parallel = 1,
+                  has_condition(A2,X,0), not precondition(A2,X,V).
+
+disable(A1,A2) :- active(A1), active(A2), A1 != A2, postcondition(A1,X,V),
+                  has_condition(A2,X,0), not precondition(A2,X,V),
+                  _parallel = 2, not diverge(A1,A2), not diverge(A2,A1).
+
+scope(X,V) :- active(A), precondition(A,X,V), _parallel = 2.
+
+% Define relevant fluents w.r.t. parallel mode
+
+fluent(X,V) :- produce(X,V).
+fluent(X,V) :- persist(X,V).
+fluent(X,V) :- initialState(X,V), fluent(X).
+fluent(X,V) :- active(A), postcondition(A,X,V), fluent(X).
+fluent(X)   :- fluent(X,V).
+fluent(X)   :- diverge(A1,A2,X), not exclude(A1,A2).
+
+% Define unsubsumed mutexes
+
+mutex(G,X) :- mutexGroup(G), contains(G,X,V), fluent(X,V).
+mutex(G)   :- mutexGroup(G), #count{X : mutex(G,X)} > 1.
+
+% Define initial state
+
+holds(X,V,0) :- initialState(X,V), fluent(X).
+
+:- fluent(X), #count{V : holds(X,V,0)} > 1.
+:- mutex(G), #count{X,V : holds(X,V,0), contains(G,X,V)} > 1.
+
+% STEP PROGRAM
+
+#program step(t).
+
+% Generate successor state
+
+1 {holds(X,V,t) : fluent(X,V)} 1 :- fluent(X).
+
+:- mutex(G), #count{X,V : holds(X,V,t), contains(G,X,V)} > 1.
+
+change(X,t) :- holds(X,V,t-1), not holds(X,V,t).
+
+% Generate actions
+
+1 {occurs(A,t) : active(A)}.
+
+:- occurs(A,t), postcondition(A,X,V), fluent(X), not holds(X,V,t).
+
+effect(X,t) :- occurs(A,t), postcondition(A,X,V), fluent(X), not precondition(A,X,V).
+
+:- change(X,t), not effect(X,t).
+
+% Checks w.r.t. parallel mode
+
+:- _parallel != 1, _parallel != 2, #count{A : occurs(A,t)} > 1.
+
+:- _parallel != 2, occurs(A,t), precondition(A,X,V), not holds(X,V,t-1).
+
+:- _parallel = 1, occurs(A,t), precondition(A,X,V), not has_condition(A,X,1), not holds(X,V,t).
+
+single(X,t) :- occurs(A,t), precondition(A,X,V), _parallel = 1,
+               has_condition(A,X,1), not postcondition(A,X,V).
+
+:- single(X,t), #count{A : occurs(A,t), postcondition(A,X,V), not precondition(A,X,V)} > 1.
+
+proceed(X,V,t) :- holds(X,V,t-1), scope(X,V).
+proceed(X,V,t) :- occurs(A,t), postcondition(A,X,V), scope(X,V), not precondition(A,X,V),
+                  perform(A,t).
+
+perform(A1,t) :- active(A1), _parallel = 2, not occurs(A1,t).
+perform(A1,t) :- active(A1), _parallel = 2,
+                 proceed(X,V,t) : precondition(A1,X,V); perform(A2,t) : disable(A1,A2).
+
+:- _parallel = 2, active(A), not perform(A,t).
+
+% CHECK PROGRAM
+
+#program check(t).
+
+% Check goal conditions
+
+:- query(t), goal(X,V), not holds(X,V,t).
+
+% DISPLAY PART
+
+#show occurs/2.