domain
stringclasses 1
value | problem_pddl
stringlengths 175
252
| solution
stringlengths 97
459
| plan
stringlengths 46
408
| na
int64 2
24
| problem_english
stringlengths 1.51k
1.62k
| answer
stringlengths 21
282
| ntoks
int64 362
394
|
|---|---|---|---|---|---|---|---|
(define (domain blocksworld-4ops)
(:requirements :strips)
(:predicates (clear ?x)
(ontable ?x)
(handempty)
(holding ?x)
(on ?x ?y))
(:action pick-up
:parameters (?ob)
:precondition (and (clear ?ob) (ontable ?ob) (handempty))
:effect (and (holding ?ob) (not (clear ?ob)) (not (ontable ?ob))
(not (handempty))))
(:action put-down
:parameters (?ob)
:precondition (holding ?ob)
:effect (and (clear ?ob) (handempty) (ontable ?ob)
(not (holding ?ob))))
(:action stack
:parameters (?ob ?underob)
:precondition (and (clear ?underob) (holding ?ob))
:effect (and (handempty) (clear ?ob) (on ?ob ?underob)
(not (clear ?underob)) (not (holding ?ob))))
(:action unstack
:parameters (?ob ?underob)
:precondition (and (on ?ob ?underob) (clear ?ob) (handempty))
:effect (and (holding ?ob) (clear ?underob)
(not (on ?ob ?underob)) (not (clear ?ob)) (not (handempty)))))
|
(define (problem BW-rand-4)
(:domain blocksworld-4ops)
(:objects a b c d )
(:init
(handempty)
(ontable a)
(ontable b)
(on c a)
(on d b)
(clear c)
(clear d)
)
(:goal
(and
(on a d)
(on b c)
(on d b))
)
)
| status: SOLVED_SATISFICING
engine: Pyperplan
plan: SequentialPlan:
unstack(c, a)
put-down(c)
unstack(d, b)
put-down(d)
pick-up(a)
stack(a, d)
pick-up(b)
stack(b, c)
unstack(a, d)
put-down(a)
pick-up(d)
stack(d, b)
pick-up(a)
stack(a, d) | SequentialPlan:
unstack(c, a)
put-down(c)
unstack(d, b)
put-down(d)
pick-up(a)
stack(a, d)
pick-up(b)
stack(b, c)
unstack(a, d)
put-down(a)
pick-up(d)
stack(d, b)
pick-up(a)
stack(a, d) | 14 | I am playing with a set of objects.
Here are the actions I can do:
pick-up with ob
put-down with ob
stack with ob, underob
unstack with ob, underob
I have the following restrictions on my actions:
To perform pick-up action, the following facts need to be true: (clear(ob) and ontable(ob) and handempty).
Once pick-up action is performed the following facts will be true: holding(ob).
Once pick-up action is performed the following facts will be false: clear(ob), ontable(ob), handempty.
To perform put-down action, the following facts need to be true: holding(ob).
Once put-down action is performed the following facts will be true: clear(ob), handempty, ontable(ob).
Once put-down action is performed the following facts will be false: holding(ob).
To perform stack action, the following facts need to be true: (clear(underob) and holding(ob)).
Once stack action is performed the following facts will be true: handempty, clear(ob), on(ob, underob).
Once stack action is performed the following facts will be false: clear(underob), holding(ob).
To perform unstack action, the following facts need to be true: (on(ob, underob) and clear(ob) and handempty).
Once unstack action is performed the following facts will be true: holding(ob), clear(underob).
Once unstack action is performed the following facts will be false: on(ob, underob), clear(ob), handempty.
Everything is false by default
[STATEMENT]
As initial conditions I have that, handempty, ontable(a), ontable(b), on(c, a), on(d, b), clear(c), clear(d).
My goal is to have that (on(a, d) and on(b, c) and on(d, b)). | unstack(c,a)
put-down(c)
unstack(d,b)
put-down(d)
pick-up(a)
stack(a,d)
pick-up(b)
stack(b,c)
unstack(a,d)
put-down(a)
pick-up(d)
stack(d,b)
pick-up(a)
stack(a,d) | 383 |
(define (domain blocksworld-4ops)
(:requirements :strips)
(:predicates (clear ?x)
(ontable ?x)
(handempty)
(holding ?x)
(on ?x ?y))
(:action pick-up
:parameters (?ob)
:precondition (and (clear ?ob) (ontable ?ob) (handempty))
:effect (and (holding ?ob) (not (clear ?ob)) (not (ontable ?ob))
(not (handempty))))
(:action put-down
:parameters (?ob)
:precondition (holding ?ob)
:effect (and (clear ?ob) (handempty) (ontable ?ob)
(not (holding ?ob))))
(:action stack
:parameters (?ob ?underob)
:precondition (and (clear ?underob) (holding ?ob))
:effect (and (handempty) (clear ?ob) (on ?ob ?underob)
(not (clear ?underob)) (not (holding ?ob))))
(:action unstack
:parameters (?ob ?underob)
:precondition (and (on ?ob ?underob) (clear ?ob) (handempty))
:effect (and (holding ?ob) (clear ?underob)
(not (on ?ob ?underob)) (not (clear ?ob)) (not (handempty)))))
|
(define (problem BW-rand-4)
(:domain blocksworld-4ops)
(:objects a b c d )
(:init
(handempty)
(ontable a)
(on b d)
(ontable c)
(ontable d)
(clear a)
(clear b)
(clear c)
)
(:goal
(and
(on a d)
(on d b))
)
)
| status: SOLVED_SATISFICING
engine: Pyperplan
plan: SequentialPlan:
unstack(b, d)
put-down(b)
pick-up(d)
stack(d, b)
pick-up(a)
stack(a, d) | SequentialPlan:
unstack(b, d)
put-down(b)
pick-up(d)
stack(d, b)
pick-up(a)
stack(a, d) | 6 | I am playing with a set of objects.
Here are the actions I can do:
pick-up with ob
put-down with ob
stack with ob, underob
unstack with ob, underob
I have the following restrictions on my actions:
To perform pick-up action, the following facts need to be true: (clear(ob) and ontable(ob) and handempty).
Once pick-up action is performed the following facts will be true: holding(ob).
Once pick-up action is performed the following facts will be false: clear(ob), ontable(ob), handempty.
To perform put-down action, the following facts need to be true: holding(ob).
Once put-down action is performed the following facts will be true: clear(ob), handempty, ontable(ob).
Once put-down action is performed the following facts will be false: holding(ob).
To perform stack action, the following facts need to be true: (clear(underob) and holding(ob)).
Once stack action is performed the following facts will be true: handempty, clear(ob), on(ob, underob).
Once stack action is performed the following facts will be false: clear(underob), holding(ob).
To perform unstack action, the following facts need to be true: (on(ob, underob) and clear(ob) and handempty).
Once unstack action is performed the following facts will be true: holding(ob), clear(underob).
Once unstack action is performed the following facts will be false: on(ob, underob), clear(ob), handempty.
[STATEMENT]
As initial conditions I have that, handempty, ontable(a), on(b, d), ontable(c), ontable(d), clear(a), clear(b), clear(c).
My goal is to have that (on(a, d) and on(d, b)). | unstack(b,d)
put-down(b)
pick-up(d)
stack(d,b)
pick-up(a)
stack(a,d) | 373 |
(define (domain blocksworld-4ops)
(:requirements :strips)
(:predicates (clear ?x)
(ontable ?x)
(handempty)
(holding ?x)
(on ?x ?y))
(:action pick-up
:parameters (?ob)
:precondition (and (clear ?ob) (ontable ?ob) (handempty))
:effect (and (holding ?ob) (not (clear ?ob)) (not (ontable ?ob))
(not (handempty))))
(:action put-down
:parameters (?ob)
:precondition (holding ?ob)
:effect (and (clear ?ob) (handempty) (ontable ?ob)
(not (holding ?ob))))
(:action stack
:parameters (?ob ?underob)
:precondition (and (clear ?underob) (holding ?ob))
:effect (and (handempty) (clear ?ob) (on ?ob ?underob)
(not (clear ?underob)) (not (holding ?ob))))
(:action unstack
:parameters (?ob ?underob)
:precondition (and (on ?ob ?underob) (clear ?ob) (handempty))
:effect (and (holding ?ob) (clear ?underob)
(not (on ?ob ?underob)) (not (clear ?ob)) (not (handempty)))))
|
(define (problem BW-rand-4)
(:domain blocksworld-4ops)
(:objects a b c d )
(:init
(handempty)
(ontable a)
(ontable b)
(on c b)
(on d c)
(clear a)
(clear d)
)
(:goal
(and
(on c d)
(on d b))
)
)
| status: SOLVED_SATISFICING
engine: Pyperplan
plan: SequentialPlan:
unstack(d, c)
put-down(d)
unstack(c, b)
put-down(c)
pick-up(d)
stack(d, b)
pick-up(c)
stack(c, d) | SequentialPlan:
unstack(d, c)
put-down(d)
unstack(c, b)
put-down(c)
pick-up(d)
stack(d, b)
pick-up(c)
stack(c, d) | 8 | I am playing with a set of objects.
Here are the actions I can do:
pick-up with ob
put-down with ob
stack with ob, underob
unstack with ob, underob
I have the following restrictions on my actions:
To perform pick-up action, the following facts need to be true: (clear(ob) and ontable(ob) and handempty).
Once pick-up action is performed the following facts will be true: holding(ob).
Once pick-up action is performed the following facts will be false: clear(ob), ontable(ob), handempty.
To perform put-down action, the following facts need to be true: holding(ob).
Once put-down action is performed the following facts will be true: clear(ob), handempty, ontable(ob).
Once put-down action is performed the following facts will be false: holding(ob).
To perform stack action, the following facts need to be true: (clear(underob) and holding(ob)).
Once stack action is performed the following facts will be true: handempty, clear(ob), on(ob, underob).
Once stack action is performed the following facts will be false: clear(underob), holding(ob).
To perform unstack action, the following facts need to be true: (on(ob, underob) and clear(ob) and handempty).
Once unstack action is performed the following facts will be true: holding(ob), clear(underob).
Once unstack action is performed the following facts will be false: on(ob, underob), clear(ob), handempty.
Everything is false by default
[STATEMENT]
As initial conditions I have that, handempty, ontable(a), ontable(b), on(c, b), on(d, c), clear(a), clear(d).
My goal is to have that (on(c, d) and on(d, b)). | unstack(d,c)
put-down(d)
unstack(c,b)
put-down(c)
pick-up(d)
stack(d,b)
pick-up(c)
stack(c,d) | 377 |
(define (domain blocksworld-4ops)
(:requirements :strips)
(:predicates (clear ?x)
(ontable ?x)
(handempty)
(holding ?x)
(on ?x ?y))
(:action pick-up
:parameters (?ob)
:precondition (and (clear ?ob) (ontable ?ob) (handempty))
:effect (and (holding ?ob) (not (clear ?ob)) (not (ontable ?ob))
(not (handempty))))
(:action put-down
:parameters (?ob)
:precondition (holding ?ob)
:effect (and (clear ?ob) (handempty) (ontable ?ob)
(not (holding ?ob))))
(:action stack
:parameters (?ob ?underob)
:precondition (and (clear ?underob) (holding ?ob))
:effect (and (handempty) (clear ?ob) (on ?ob ?underob)
(not (clear ?underob)) (not (holding ?ob))))
(:action unstack
:parameters (?ob ?underob)
:precondition (and (on ?ob ?underob) (clear ?ob) (handempty))
:effect (and (holding ?ob) (clear ?underob)
(not (on ?ob ?underob)) (not (clear ?ob)) (not (handempty)))))
|
(define (problem BW-rand-5)
(:domain blocksworld-4ops)
(:objects a b c d e )
(:init
(handempty)
(on a e)
(on b c)
(ontable c)
(ontable d)
(on e b)
(clear a)
(clear d)
)
(:goal
(and
(on b d)
(on e a))
)
)
| status: SOLVED_SATISFICING
engine: Pyperplan
plan: SequentialPlan:
unstack(a, e)
put-down(a)
unstack(e, b)
stack(e, a)
unstack(b, c)
stack(b, d) | SequentialPlan:
unstack(a, e)
put-down(a)
unstack(e, b)
stack(e, a)
unstack(b, c)
stack(b, d) | 6 | I am playing with a set of objects.
Here are the actions I can do:
pick-up with ob
put-down with ob
stack with ob, underob
unstack with ob, underob
I have the following restrictions on my actions:
To perform pick-up action, the following facts need to be true: (clear(ob) and ontable(ob) and handempty).
Once pick-up action is performed the following facts will be true: holding(ob).
Once pick-up action is performed the following facts will be false: clear(ob), ontable(ob), handempty.
To perform put-down action, the following facts need to be true: holding(ob).
Once put-down action is performed the following facts will be true: clear(ob), handempty, ontable(ob).
Once put-down action is performed the following facts will be false: holding(ob).
To perform stack action, the following facts need to be true: (clear(underob) and holding(ob)).
Once stack action is performed the following facts will be true: handempty, clear(ob), on(ob, underob).
Once stack action is performed the following facts will be false: clear(underob), holding(ob).
To perform unstack action, the following facts need to be true: (on(ob, underob) and clear(ob) and handempty).
Once unstack action is performed the following facts will be true: holding(ob), clear(underob).
Once unstack action is performed the following facts will be false: on(ob, underob), clear(ob), handempty.
[STATEMENT]
As initial conditions I have that, handempty, on(a, e), on(b, c), ontable(c), ontable(d), on(e, b), clear(a), clear(d).
My goal is to have that (on(b, d) and on(e, a)). | unstack(a,e)
put-down(a)
unstack(e,b)
stack(e,a)
unstack(b,c)
stack(b,d) | 376 |
(define (domain blocksworld-4ops)
(:requirements :strips)
(:predicates (clear ?x)
(ontable ?x)
(handempty)
(holding ?x)
(on ?x ?y))
(:action pick-up
:parameters (?ob)
:precondition (and (clear ?ob) (ontable ?ob) (handempty))
:effect (and (holding ?ob) (not (clear ?ob)) (not (ontable ?ob))
(not (handempty))))
(:action put-down
:parameters (?ob)
:precondition (holding ?ob)
:effect (and (clear ?ob) (handempty) (ontable ?ob)
(not (holding ?ob))))
(:action stack
:parameters (?ob ?underob)
:precondition (and (clear ?underob) (holding ?ob))
:effect (and (handempty) (clear ?ob) (on ?ob ?underob)
(not (clear ?underob)) (not (holding ?ob))))
(:action unstack
:parameters (?ob ?underob)
:precondition (and (on ?ob ?underob) (clear ?ob) (handempty))
:effect (and (holding ?ob) (clear ?underob)
(not (on ?ob ?underob)) (not (clear ?ob)) (not (handempty)))))
|
(define (problem BW-rand-4)
(:domain blocksworld-4ops)
(:objects a b c d )
(:init
(handempty)
(on a b)
(ontable b)
(ontable c)
(on d a)
(clear c)
(clear d)
)
(:goal
(and
(on a c)
(on c b)
(on d a))
)
)
| status: SOLVED_SATISFICING
engine: Pyperplan
plan: SequentialPlan:
unstack(d, a)
put-down(d)
unstack(a, b)
put-down(a)
pick-up(d)
stack(d, a)
pick-up(c)
stack(c, b)
unstack(d, a)
put-down(d)
pick-up(a)
stack(a, c)
pick-up(d)
stack(d, a) | SequentialPlan:
unstack(d, a)
put-down(d)
unstack(a, b)
put-down(a)
pick-up(d)
stack(d, a)
pick-up(c)
stack(c, b)
unstack(d, a)
put-down(d)
pick-up(a)
stack(a, c)
pick-up(d)
stack(d, a) | 14 | I am playing with a set of objects.
Here are the actions I can do:
pick-up with ob
put-down with ob
stack with ob, underob
unstack with ob, underob
I have the following restrictions on my actions:
To perform pick-up action, the following facts need to be true: (clear(ob) and ontable(ob) and handempty).
Once pick-up action is performed the following facts will be true: holding(ob).
Once pick-up action is performed the following facts will be false: clear(ob), ontable(ob), handempty.
To perform put-down action, the following facts need to be true: holding(ob).
Once put-down action is performed the following facts will be true: clear(ob), handempty, ontable(ob).
Once put-down action is performed the following facts will be false: holding(ob).
To perform stack action, the following facts need to be true: (clear(underob) and holding(ob)).
Once stack action is performed the following facts will be true: handempty, clear(ob), on(ob, underob).
Once stack action is performed the following facts will be false: clear(underob), holding(ob).
To perform unstack action, the following facts need to be true: (on(ob, underob) and clear(ob) and handempty).
Once unstack action is performed the following facts will be true: holding(ob), clear(underob).
Once unstack action is performed the following facts will be false: on(ob, underob), clear(ob), handempty.
Everything is false by default
[STATEMENT]
As initial conditions I have that, handempty, on(a, b), ontable(b), ontable(c), on(d, a), clear(c), clear(d).
My goal is to have that (on(a, c) and on(c, b) and on(d, a)). | unstack(d,a)
put-down(d)
unstack(a,b)
put-down(a)
pick-up(d)
stack(d,a)
pick-up(c)
stack(c,b)
unstack(d,a)
put-down(d)
pick-up(a)
stack(a,c)
pick-up(d)
stack(d,a) | 383 |
(define (domain blocksworld-4ops)
(:requirements :strips)
(:predicates (clear ?x)
(ontable ?x)
(handempty)
(holding ?x)
(on ?x ?y))
(:action pick-up
:parameters (?ob)
:precondition (and (clear ?ob) (ontable ?ob) (handempty))
:effect (and (holding ?ob) (not (clear ?ob)) (not (ontable ?ob))
(not (handempty))))
(:action put-down
:parameters (?ob)
:precondition (holding ?ob)
:effect (and (clear ?ob) (handempty) (ontable ?ob)
(not (holding ?ob))))
(:action stack
:parameters (?ob ?underob)
:precondition (and (clear ?underob) (holding ?ob))
:effect (and (handempty) (clear ?ob) (on ?ob ?underob)
(not (clear ?underob)) (not (holding ?ob))))
(:action unstack
:parameters (?ob ?underob)
:precondition (and (on ?ob ?underob) (clear ?ob) (handempty))
:effect (and (holding ?ob) (clear ?underob)
(not (on ?ob ?underob)) (not (clear ?ob)) (not (handempty)))))
|
(define (problem BW-rand-4)
(:domain blocksworld-4ops)
(:objects a b c d )
(:init
(handempty)
(on a b)
(ontable b)
(on c d)
(ontable d)
(clear a)
(clear c)
)
(:goal
(and
(on b d)
(on c a)
(on d c))
)
)
| status: SOLVED_SATISFICING
engine: Pyperplan
plan: SequentialPlan:
unstack(c, d)
put-down(c)
pick-up(d)
stack(d, c)
unstack(a, b)
put-down(a)
unstack(d, c)
put-down(d)
pick-up(b)
stack(b, d)
pick-up(c)
stack(c, a)
unstack(b, d)
put-down(b)
pick-up(d)
stack(d, c)
pick-up(b)
stack(b, d) | SequentialPlan:
unstack(c, d)
put-down(c)
pick-up(d)
stack(d, c)
unstack(a, b)
put-down(a)
unstack(d, c)
put-down(d)
pick-up(b)
stack(b, d)
pick-up(c)
stack(c, a)
unstack(b, d)
put-down(b)
pick-up(d)
stack(d, c)
pick-up(b)
stack(b, d) | 18 | I am playing with a set of objects.
Here are the actions I can do:
pick-up with ob
put-down with ob
stack with ob, underob
unstack with ob, underob
I have the following restrictions on my actions:
To perform pick-up action, the following facts need to be true: (clear(ob) and ontable(ob) and handempty).
Once pick-up action is performed the following facts will be true: holding(ob).
Once pick-up action is performed the following facts will be false: clear(ob), ontable(ob), handempty.
To perform put-down action, the following facts need to be true: holding(ob).
Once put-down action is performed the following facts will be true: clear(ob), handempty, ontable(ob).
Once put-down action is performed the following facts will be false: holding(ob).
To perform stack action, the following facts need to be true: (clear(underob) and holding(ob)).
Once stack action is performed the following facts will be true: handempty, clear(ob), on(ob, underob).
Once stack action is performed the following facts will be false: clear(underob), holding(ob).
To perform unstack action, the following facts need to be true: (on(ob, underob) and clear(ob) and handempty).
Once unstack action is performed the following facts will be true: holding(ob), clear(underob).
Once unstack action is performed the following facts will be false: on(ob, underob), clear(ob), handempty.
[STATEMENT]
As initial conditions I have that, handempty, on(a, b), ontable(b), on(c, d), ontable(d), clear(a), clear(c).
My goal is to have that (on(b, d) and on(c, a) and on(d, c)). | unstack(c,d)
put-down(c)
pick-up(d)
stack(d,c)
unstack(a,b)
put-down(a)
unstack(d,c)
put-down(d)
pick-up(b)
stack(b,d)
pick-up(c)
stack(c,a)
unstack(b,d)
put-down(b)
pick-up(d)
stack(d,c)
pick-up(b)
stack(b,d) | 377 |
(define (domain blocksworld-4ops)
(:requirements :strips)
(:predicates (clear ?x)
(ontable ?x)
(handempty)
(holding ?x)
(on ?x ?y))
(:action pick-up
:parameters (?ob)
:precondition (and (clear ?ob) (ontable ?ob) (handempty))
:effect (and (holding ?ob) (not (clear ?ob)) (not (ontable ?ob))
(not (handempty))))
(:action put-down
:parameters (?ob)
:precondition (holding ?ob)
:effect (and (clear ?ob) (handempty) (ontable ?ob)
(not (holding ?ob))))
(:action stack
:parameters (?ob ?underob)
:precondition (and (clear ?underob) (holding ?ob))
:effect (and (handempty) (clear ?ob) (on ?ob ?underob)
(not (clear ?underob)) (not (holding ?ob))))
(:action unstack
:parameters (?ob ?underob)
:precondition (and (on ?ob ?underob) (clear ?ob) (handempty))
:effect (and (holding ?ob) (clear ?underob)
(not (on ?ob ?underob)) (not (clear ?ob)) (not (handempty)))))
|
(define (problem BW-rand-4)
(:domain blocksworld-4ops)
(:objects a b c d )
(:init
(handempty)
(on a b)
(ontable b)
(on c d)
(on d a)
(clear c)
)
(:goal
(and
(on a b)
(on b d)
(on d c))
)
)
| status: SOLVED_SATISFICING
engine: Pyperplan
plan: SequentialPlan:
unstack(c, d)
put-down(c)
unstack(d, a)
stack(d, c)
unstack(a, b)
put-down(a)
pick-up(b)
stack(b, d)
pick-up(a)
stack(a, b) | SequentialPlan:
unstack(c, d)
put-down(c)
unstack(d, a)
stack(d, c)
unstack(a, b)
put-down(a)
pick-up(b)
stack(b, d)
pick-up(a)
stack(a, b) | 10 | I am playing with a set of objects.
Here are the actions I can do:
pick-up with ob
put-down with ob
stack with ob, underob
unstack with ob, underob
I have the following restrictions on my actions:
To perform pick-up action, the following facts need to be true: (clear(ob) and ontable(ob) and handempty).
Once pick-up action is performed the following facts will be true: holding(ob).
Once pick-up action is performed the following facts will be false: clear(ob), ontable(ob), handempty.
To perform put-down action, the following facts need to be true: holding(ob).
Once put-down action is performed the following facts will be true: clear(ob), handempty, ontable(ob).
Once put-down action is performed the following facts will be false: holding(ob).
To perform stack action, the following facts need to be true: (clear(underob) and holding(ob)).
Once stack action is performed the following facts will be true: handempty, clear(ob), on(ob, underob).
Once stack action is performed the following facts will be false: clear(underob), holding(ob).
To perform unstack action, the following facts need to be true: (on(ob, underob) and clear(ob) and handempty).
Once unstack action is performed the following facts will be true: holding(ob), clear(underob).
Once unstack action is performed the following facts will be false: on(ob, underob), clear(ob), handempty.
[STATEMENT]
As initial conditions I have that, handempty, on(a, b), ontable(b), on(c, d), on(d, a), clear(c).
My goal is to have that (on(a, b) and on(b, d) and on(d, c)). | unstack(c,d)
put-down(c)
unstack(d,a)
stack(d,c)
unstack(a,b)
put-down(a)
pick-up(b)
stack(b,d)
pick-up(a)
stack(a,b) | 375 |
(define (domain blocksworld-4ops)
(:requirements :strips)
(:predicates (clear ?x)
(ontable ?x)
(handempty)
(holding ?x)
(on ?x ?y))
(:action pick-up
:parameters (?ob)
:precondition (and (clear ?ob) (ontable ?ob) (handempty))
:effect (and (holding ?ob) (not (clear ?ob)) (not (ontable ?ob))
(not (handempty))))
(:action put-down
:parameters (?ob)
:precondition (holding ?ob)
:effect (and (clear ?ob) (handempty) (ontable ?ob)
(not (holding ?ob))))
(:action stack
:parameters (?ob ?underob)
:precondition (and (clear ?underob) (holding ?ob))
:effect (and (handempty) (clear ?ob) (on ?ob ?underob)
(not (clear ?underob)) (not (holding ?ob))))
(:action unstack
:parameters (?ob ?underob)
:precondition (and (on ?ob ?underob) (clear ?ob) (handempty))
:effect (and (holding ?ob) (clear ?underob)
(not (on ?ob ?underob)) (not (clear ?ob)) (not (handempty)))))
|
(define (problem BW-rand-4)
(:domain blocksworld-4ops)
(:objects a b c d )
(:init
(handempty)
(ontable a)
(on b c)
(on c a)
(ontable d)
(clear b)
(clear d)
)
(:goal
(and
(on a c)
(on b d))
)
)
| status: SOLVED_SATISFICING
engine: Pyperplan
plan: SequentialPlan:
unstack(b, c)
stack(b, d)
unstack(c, a)
put-down(c)
pick-up(a)
stack(a, c) | SequentialPlan:
unstack(b, c)
stack(b, d)
unstack(c, a)
put-down(c)
pick-up(a)
stack(a, c) | 6 | I am playing with a set of objects.
Here are the actions I can do:
pick-up with ob
put-down with ob
stack with ob, underob
unstack with ob, underob
I have the following restrictions on my actions:
To perform pick-up action, the following facts need to be true: (clear(ob) and ontable(ob) and handempty).
Once pick-up action is performed the following facts will be true: holding(ob).
Once pick-up action is performed the following facts will be false: clear(ob), ontable(ob), handempty.
To perform put-down action, the following facts need to be true: holding(ob).
Once put-down action is performed the following facts will be true: clear(ob), handempty, ontable(ob).
Once put-down action is performed the following facts will be false: holding(ob).
To perform stack action, the following facts need to be true: (clear(underob) and holding(ob)).
Once stack action is performed the following facts will be true: handempty, clear(ob), on(ob, underob).
Once stack action is performed the following facts will be false: clear(underob), holding(ob).
To perform unstack action, the following facts need to be true: (on(ob, underob) and clear(ob) and handempty).
Once unstack action is performed the following facts will be true: holding(ob), clear(underob).
Once unstack action is performed the following facts will be false: on(ob, underob), clear(ob), handempty.
Everything is false by default
[STATEMENT]
As initial conditions I have that, handempty, ontable(a), on(b, c), on(c, a), ontable(d), clear(b), clear(d).
My goal is to have that (on(a, c) and on(b, d)). | unstack(b,c)
stack(b,d)
unstack(c,a)
put-down(c)
pick-up(a)
stack(a,c) | 377 |
(define (domain blocksworld-4ops)
(:requirements :strips)
(:predicates (clear ?x)
(ontable ?x)
(handempty)
(holding ?x)
(on ?x ?y))
(:action pick-up
:parameters (?ob)
:precondition (and (clear ?ob) (ontable ?ob) (handempty))
:effect (and (holding ?ob) (not (clear ?ob)) (not (ontable ?ob))
(not (handempty))))
(:action put-down
:parameters (?ob)
:precondition (holding ?ob)
:effect (and (clear ?ob) (handempty) (ontable ?ob)
(not (holding ?ob))))
(:action stack
:parameters (?ob ?underob)
:precondition (and (clear ?underob) (holding ?ob))
:effect (and (handempty) (clear ?ob) (on ?ob ?underob)
(not (clear ?underob)) (not (holding ?ob))))
(:action unstack
:parameters (?ob ?underob)
:precondition (and (on ?ob ?underob) (clear ?ob) (handempty))
:effect (and (holding ?ob) (clear ?underob)
(not (on ?ob ?underob)) (not (clear ?ob)) (not (handempty)))))
|
(define (problem BW-rand-4)
(:domain blocksworld-4ops)
(:objects a b c d )
(:init
(handempty)
(on a c)
(ontable b)
(ontable c)
(ontable d)
(clear a)
(clear b)
(clear d)
)
(:goal
(and
(on b a)
(on c d)
(on d b))
)
)
| status: SOLVED_SATISFICING
engine: Pyperplan
plan: SequentialPlan:
pick-up(d)
stack(d, b)
unstack(a, c)
put-down(a)
unstack(d, b)
put-down(d)
pick-up(c)
stack(c, d)
pick-up(b)
stack(b, a)
unstack(c, d)
put-down(c)
pick-up(d)
stack(d, b)
pick-up(c)
stack(c, d) | SequentialPlan:
pick-up(d)
stack(d, b)
unstack(a, c)
put-down(a)
unstack(d, b)
put-down(d)
pick-up(c)
stack(c, d)
pick-up(b)
stack(b, a)
unstack(c, d)
put-down(c)
pick-up(d)
stack(d, b)
pick-up(c)
stack(c, d) | 16 | I am playing with a set of objects.
Here are the actions I can do:
pick-up with ob
put-down with ob
stack with ob, underob
unstack with ob, underob
I have the following restrictions on my actions:
To perform pick-up action, the following facts need to be true: (clear(ob) and ontable(ob) and handempty).
Once pick-up action is performed the following facts will be true: holding(ob).
Once pick-up action is performed the following facts will be false: clear(ob), ontable(ob), handempty.
To perform put-down action, the following facts need to be true: holding(ob).
Once put-down action is performed the following facts will be true: clear(ob), handempty, ontable(ob).
Once put-down action is performed the following facts will be false: holding(ob).
To perform stack action, the following facts need to be true: (clear(underob) and holding(ob)).
Once stack action is performed the following facts will be true: handempty, clear(ob), on(ob, underob).
Once stack action is performed the following facts will be false: clear(underob), holding(ob).
To perform unstack action, the following facts need to be true: (on(ob, underob) and clear(ob) and handempty).
Once unstack action is performed the following facts will be true: holding(ob), clear(underob).
Once unstack action is performed the following facts will be false: on(ob, underob), clear(ob), handempty.
Everything is false by default
[STATEMENT]
As initial conditions I have that, handempty, on(a, c), ontable(b), ontable(c), ontable(d), clear(a), clear(b), clear(d).
My goal is to have that (on(b, a) and on(c, d) and on(d, b)). | pick-up(d)
stack(d,b)
unstack(a,c)
put-down(a)
unstack(d,b)
put-down(d)
pick-up(c)
stack(c,d)
pick-up(b)
stack(b,a)
unstack(c,d)
put-down(c)
pick-up(d)
stack(d,b)
pick-up(c)
stack(c,d) | 385 |
(define (domain blocksworld-4ops)
(:requirements :strips)
(:predicates (clear ?x)
(ontable ?x)
(handempty)
(holding ?x)
(on ?x ?y))
(:action pick-up
:parameters (?ob)
:precondition (and (clear ?ob) (ontable ?ob) (handempty))
:effect (and (holding ?ob) (not (clear ?ob)) (not (ontable ?ob))
(not (handempty))))
(:action put-down
:parameters (?ob)
:precondition (holding ?ob)
:effect (and (clear ?ob) (handempty) (ontable ?ob)
(not (holding ?ob))))
(:action stack
:parameters (?ob ?underob)
:precondition (and (clear ?underob) (holding ?ob))
:effect (and (handempty) (clear ?ob) (on ?ob ?underob)
(not (clear ?underob)) (not (holding ?ob))))
(:action unstack
:parameters (?ob ?underob)
:precondition (and (on ?ob ?underob) (clear ?ob) (handempty))
:effect (and (holding ?ob) (clear ?underob)
(not (on ?ob ?underob)) (not (clear ?ob)) (not (handempty)))))
|
(define (problem BW-rand-4)
(:domain blocksworld-4ops)
(:objects a b c d )
(:init
(handempty)
(ontable a)
(ontable b)
(on c a)
(on d b)
(clear c)
(clear d)
)
(:goal
(and
(on a c)
(on b d)
(on d a))
)
)
| status: SOLVED_SATISFICING
engine: Pyperplan
plan: SequentialPlan:
unstack(c, a)
put-down(c)
unstack(d, b)
put-down(d)
pick-up(b)
stack(b, d)
pick-up(a)
stack(a, c)
unstack(b, d)
put-down(b)
pick-up(d)
stack(d, a)
pick-up(b)
stack(b, d) | SequentialPlan:
unstack(c, a)
put-down(c)
unstack(d, b)
put-down(d)
pick-up(b)
stack(b, d)
pick-up(a)
stack(a, c)
unstack(b, d)
put-down(b)
pick-up(d)
stack(d, a)
pick-up(b)
stack(b, d) | 14 | I am playing with a set of objects.
Here are the actions I can do:
pick-up with ob
put-down with ob
stack with ob, underob
unstack with ob, underob
I have the following restrictions on my actions:
To perform pick-up action, the following facts need to be true: (clear(ob) and ontable(ob) and handempty).
Once pick-up action is performed the following facts will be true: holding(ob).
Once pick-up action is performed the following facts will be false: clear(ob), ontable(ob), handempty.
To perform put-down action, the following facts need to be true: holding(ob).
Once put-down action is performed the following facts will be true: clear(ob), handempty, ontable(ob).
Once put-down action is performed the following facts will be false: holding(ob).
To perform stack action, the following facts need to be true: (clear(underob) and holding(ob)).
Once stack action is performed the following facts will be true: handempty, clear(ob), on(ob, underob).
Once stack action is performed the following facts will be false: clear(underob), holding(ob).
To perform unstack action, the following facts need to be true: (on(ob, underob) and clear(ob) and handempty).
Once unstack action is performed the following facts will be true: holding(ob), clear(underob).
Once unstack action is performed the following facts will be false: on(ob, underob), clear(ob), handempty.
[STATEMENT]
As initial conditions I have that, handempty, ontable(a), ontable(b), on(c, a), on(d, b), clear(c), clear(d).
My goal is to have that (on(a, c) and on(b, d) and on(d, a)). | unstack(c,a)
put-down(c)
unstack(d,b)
put-down(d)
pick-up(b)
stack(b,d)
pick-up(a)
stack(a,c)
unstack(b,d)
put-down(b)
pick-up(d)
stack(d,a)
pick-up(b)
stack(b,d) | 377 |
(define (domain blocksworld-4ops)
(:requirements :strips)
(:predicates (clear ?x)
(ontable ?x)
(handempty)
(holding ?x)
(on ?x ?y))
(:action pick-up
:parameters (?ob)
:precondition (and (clear ?ob) (ontable ?ob) (handempty))
:effect (and (holding ?ob) (not (clear ?ob)) (not (ontable ?ob))
(not (handempty))))
(:action put-down
:parameters (?ob)
:precondition (holding ?ob)
:effect (and (clear ?ob) (handempty) (ontable ?ob)
(not (holding ?ob))))
(:action stack
:parameters (?ob ?underob)
:precondition (and (clear ?underob) (holding ?ob))
:effect (and (handempty) (clear ?ob) (on ?ob ?underob)
(not (clear ?underob)) (not (holding ?ob))))
(:action unstack
:parameters (?ob ?underob)
:precondition (and (on ?ob ?underob) (clear ?ob) (handempty))
:effect (and (holding ?ob) (clear ?underob)
(not (on ?ob ?underob)) (not (clear ?ob)) (not (handempty)))))
|
(define (problem BW-rand-4)
(:domain blocksworld-4ops)
(:objects a b c d )
(:init
(handempty)
(on a b)
(ontable b)
(ontable c)
(on d a)
(clear c)
(clear d)
)
(:goal
(and
(on a c)
(on d b))
)
)
| status: SOLVED_SATISFICING
engine: Pyperplan
plan: SequentialPlan:
unstack(d, a)
put-down(d)
unstack(a, b)
stack(a, c)
pick-up(d)
stack(d, b) | SequentialPlan:
unstack(d, a)
put-down(d)
unstack(a, b)
stack(a, c)
pick-up(d)
stack(d, b) | 6 | I am playing with a set of objects.
Here are the actions I can do:
pick-up with ob
put-down with ob
stack with ob, underob
unstack with ob, underob
I have the following restrictions on my actions:
To perform pick-up action, the following facts need to be true: (clear(ob) and ontable(ob) and handempty).
Once pick-up action is performed the following facts will be true: holding(ob).
Once pick-up action is performed the following facts will be false: clear(ob), ontable(ob), handempty.
To perform put-down action, the following facts need to be true: holding(ob).
Once put-down action is performed the following facts will be true: clear(ob), handempty, ontable(ob).
Once put-down action is performed the following facts will be false: holding(ob).
To perform stack action, the following facts need to be true: (clear(underob) and holding(ob)).
Once stack action is performed the following facts will be true: handempty, clear(ob), on(ob, underob).
Once stack action is performed the following facts will be false: clear(underob), holding(ob).
To perform unstack action, the following facts need to be true: (on(ob, underob) and clear(ob) and handempty).
Once unstack action is performed the following facts will be true: holding(ob), clear(underob).
Once unstack action is performed the following facts will be false: on(ob, underob), clear(ob), handempty.
Everything is false by default
[STATEMENT]
As initial conditions I have that, handempty, on(a, b), ontable(b), ontable(c), on(d, a), clear(c), clear(d).
My goal is to have that (on(a, c) and on(d, b)). | unstack(d,a)
put-down(d)
unstack(a,b)
stack(a,c)
pick-up(d)
stack(d,b) | 377 |
(define (domain blocksworld-4ops)
(:requirements :strips)
(:predicates (clear ?x)
(ontable ?x)
(handempty)
(holding ?x)
(on ?x ?y))
(:action pick-up
:parameters (?ob)
:precondition (and (clear ?ob) (ontable ?ob) (handempty))
:effect (and (holding ?ob) (not (clear ?ob)) (not (ontable ?ob))
(not (handempty))))
(:action put-down
:parameters (?ob)
:precondition (holding ?ob)
:effect (and (clear ?ob) (handempty) (ontable ?ob)
(not (holding ?ob))))
(:action stack
:parameters (?ob ?underob)
:precondition (and (clear ?underob) (holding ?ob))
:effect (and (handempty) (clear ?ob) (on ?ob ?underob)
(not (clear ?underob)) (not (holding ?ob))))
(:action unstack
:parameters (?ob ?underob)
:precondition (and (on ?ob ?underob) (clear ?ob) (handempty))
:effect (and (holding ?ob) (clear ?underob)
(not (on ?ob ?underob)) (not (clear ?ob)) (not (handempty)))))
|
(define (problem BW-rand-4)
(:domain blocksworld-4ops)
(:objects a b c d )
(:init
(handempty)
(ontable a)
(on b a)
(ontable c)
(on d c)
(clear b)
(clear d)
)
(:goal
(and
(on c a)
(on d c))
)
)
| status: SOLVED_SATISFICING
engine: Pyperplan
plan: SequentialPlan:
unstack(b, a)
put-down(b)
unstack(d, c)
put-down(d)
pick-up(c)
stack(c, a)
pick-up(d)
stack(d, c) | SequentialPlan:
unstack(b, a)
put-down(b)
unstack(d, c)
put-down(d)
pick-up(c)
stack(c, a)
pick-up(d)
stack(d, c) | 8 | I am playing with a set of objects.
Here are the actions I can do:
pick-up with ob
put-down with ob
stack with ob, underob
unstack with ob, underob
I have the following restrictions on my actions:
To perform pick-up action, the following facts need to be true: (clear(ob) and ontable(ob) and handempty).
Once pick-up action is performed the following facts will be true: holding(ob).
Once pick-up action is performed the following facts will be false: clear(ob), ontable(ob), handempty.
To perform put-down action, the following facts need to be true: holding(ob).
Once put-down action is performed the following facts will be true: clear(ob), handempty, ontable(ob).
Once put-down action is performed the following facts will be false: holding(ob).
To perform stack action, the following facts need to be true: (clear(underob) and holding(ob)).
Once stack action is performed the following facts will be true: handempty, clear(ob), on(ob, underob).
Once stack action is performed the following facts will be false: clear(underob), holding(ob).
To perform unstack action, the following facts need to be true: (on(ob, underob) and clear(ob) and handempty).
Once unstack action is performed the following facts will be true: holding(ob), clear(underob).
Once unstack action is performed the following facts will be false: on(ob, underob), clear(ob), handempty.
Everything is false by default
[STATEMENT]
As initial conditions I have that, handempty, ontable(a), on(b, a), ontable(c), on(d, c), clear(b), clear(d).
My goal is to have that (on(c, a) and on(d, c)). | unstack(b,a)
put-down(b)
unstack(d,c)
put-down(d)
pick-up(c)
stack(c,a)
pick-up(d)
stack(d,c) | 377 |
(define (domain blocksworld-4ops)
(:requirements :strips)
(:predicates (clear ?x)
(ontable ?x)
(handempty)
(holding ?x)
(on ?x ?y))
(:action pick-up
:parameters (?ob)
:precondition (and (clear ?ob) (ontable ?ob) (handempty))
:effect (and (holding ?ob) (not (clear ?ob)) (not (ontable ?ob))
(not (handempty))))
(:action put-down
:parameters (?ob)
:precondition (holding ?ob)
:effect (and (clear ?ob) (handempty) (ontable ?ob)
(not (holding ?ob))))
(:action stack
:parameters (?ob ?underob)
:precondition (and (clear ?underob) (holding ?ob))
:effect (and (handempty) (clear ?ob) (on ?ob ?underob)
(not (clear ?underob)) (not (holding ?ob))))
(:action unstack
:parameters (?ob ?underob)
:precondition (and (on ?ob ?underob) (clear ?ob) (handempty))
:effect (and (holding ?ob) (clear ?underob)
(not (on ?ob ?underob)) (not (clear ?ob)) (not (handempty)))))
|
(define (problem BW-rand-4)
(:domain blocksworld-4ops)
(:objects a b c d )
(:init
(handempty)
(on a d)
(ontable b)
(on c a)
(on d b)
(clear c)
)
(:goal
(and
(on a c)
(on b a)
(on c d))
)
)
| status: SOLVED_SATISFICING
engine: Pyperplan
plan: SequentialPlan:
unstack(c, a)
put-down(c)
unstack(a, d)
stack(a, c)
unstack(d, b)
put-down(d)
unstack(a, c)
put-down(a)
pick-up(b)
stack(b, a)
pick-up(c)
stack(c, d)
unstack(b, a)
put-down(b)
pick-up(a)
stack(a, c)
pick-up(b)
stack(b, a) | SequentialPlan:
unstack(c, a)
put-down(c)
unstack(a, d)
stack(a, c)
unstack(d, b)
put-down(d)
unstack(a, c)
put-down(a)
pick-up(b)
stack(b, a)
pick-up(c)
stack(c, d)
unstack(b, a)
put-down(b)
pick-up(a)
stack(a, c)
pick-up(b)
stack(b, a) | 18 | I am playing with a set of objects.
Here are the actions I can do:
pick-up with ob
put-down with ob
stack with ob, underob
unstack with ob, underob
I have the following restrictions on my actions:
To perform pick-up action, the following facts need to be true: (clear(ob) and ontable(ob) and handempty).
Once pick-up action is performed the following facts will be true: holding(ob).
Once pick-up action is performed the following facts will be false: clear(ob), ontable(ob), handempty.
To perform put-down action, the following facts need to be true: holding(ob).
Once put-down action is performed the following facts will be true: clear(ob), handempty, ontable(ob).
Once put-down action is performed the following facts will be false: holding(ob).
To perform stack action, the following facts need to be true: (clear(underob) and holding(ob)).
Once stack action is performed the following facts will be true: handempty, clear(ob), on(ob, underob).
Once stack action is performed the following facts will be false: clear(underob), holding(ob).
To perform unstack action, the following facts need to be true: (on(ob, underob) and clear(ob) and handempty).
Once unstack action is performed the following facts will be true: holding(ob), clear(underob).
Once unstack action is performed the following facts will be false: on(ob, underob), clear(ob), handempty.
[STATEMENT]
As initial conditions I have that, handempty, on(a, d), ontable(b), on(c, a), on(d, b), clear(c).
My goal is to have that (on(a, c) and on(b, a) and on(c, d)). | unstack(c,a)
put-down(c)
unstack(a,d)
stack(a,c)
unstack(d,b)
put-down(d)
unstack(a,c)
put-down(a)
pick-up(b)
stack(b,a)
pick-up(c)
stack(c,d)
unstack(b,a)
put-down(b)
pick-up(a)
stack(a,c)
pick-up(b)
stack(b,a) | 375 |
(define (domain blocksworld-4ops)
(:requirements :strips)
(:predicates (clear ?x)
(ontable ?x)
(handempty)
(holding ?x)
(on ?x ?y))
(:action pick-up
:parameters (?ob)
:precondition (and (clear ?ob) (ontable ?ob) (handempty))
:effect (and (holding ?ob) (not (clear ?ob)) (not (ontable ?ob))
(not (handempty))))
(:action put-down
:parameters (?ob)
:precondition (holding ?ob)
:effect (and (clear ?ob) (handempty) (ontable ?ob)
(not (holding ?ob))))
(:action stack
:parameters (?ob ?underob)
:precondition (and (clear ?underob) (holding ?ob))
:effect (and (handempty) (clear ?ob) (on ?ob ?underob)
(not (clear ?underob)) (not (holding ?ob))))
(:action unstack
:parameters (?ob ?underob)
:precondition (and (on ?ob ?underob) (clear ?ob) (handempty))
:effect (and (holding ?ob) (clear ?underob)
(not (on ?ob ?underob)) (not (clear ?ob)) (not (handempty)))))
|
(define (problem BW-rand-4)
(:domain blocksworld-4ops)
(:objects a b c d )
(:init
(handempty)
(on a c)
(ontable b)
(ontable c)
(ontable d)
(clear a)
(clear b)
(clear d)
)
(:goal
(and
(on c a)
(on d c))
)
)
| status: SOLVED_SATISFICING
engine: Pyperplan
plan: SequentialPlan:
unstack(a, c)
put-down(a)
pick-up(c)
stack(c, a)
pick-up(d)
stack(d, c) | SequentialPlan:
unstack(a, c)
put-down(a)
pick-up(c)
stack(c, a)
pick-up(d)
stack(d, c) | 6 | I am playing with a set of objects.
Here are the actions I can do:
pick-up with ob
put-down with ob
stack with ob, underob
unstack with ob, underob
I have the following restrictions on my actions:
To perform pick-up action, the following facts need to be true: (clear(ob) and ontable(ob) and handempty).
Once pick-up action is performed the following facts will be true: holding(ob).
Once pick-up action is performed the following facts will be false: clear(ob), ontable(ob), handempty.
To perform put-down action, the following facts need to be true: holding(ob).
Once put-down action is performed the following facts will be true: clear(ob), handempty, ontable(ob).
Once put-down action is performed the following facts will be false: holding(ob).
To perform stack action, the following facts need to be true: (clear(underob) and holding(ob)).
Once stack action is performed the following facts will be true: handempty, clear(ob), on(ob, underob).
Once stack action is performed the following facts will be false: clear(underob), holding(ob).
To perform unstack action, the following facts need to be true: (on(ob, underob) and clear(ob) and handempty).
Once unstack action is performed the following facts will be true: holding(ob), clear(underob).
Once unstack action is performed the following facts will be false: on(ob, underob), clear(ob), handempty.
[STATEMENT]
As initial conditions I have that, handempty, on(a, c), ontable(b), ontable(c), ontable(d), clear(a), clear(b), clear(d).
My goal is to have that (on(c, a) and on(d, c)). | unstack(a,c)
put-down(a)
pick-up(c)
stack(c,a)
pick-up(d)
stack(d,c) | 373 |
(define (domain blocksworld-4ops)
(:requirements :strips)
(:predicates (clear ?x)
(ontable ?x)
(handempty)
(holding ?x)
(on ?x ?y))
(:action pick-up
:parameters (?ob)
:precondition (and (clear ?ob) (ontable ?ob) (handempty))
:effect (and (holding ?ob) (not (clear ?ob)) (not (ontable ?ob))
(not (handempty))))
(:action put-down
:parameters (?ob)
:precondition (holding ?ob)
:effect (and (clear ?ob) (handempty) (ontable ?ob)
(not (holding ?ob))))
(:action stack
:parameters (?ob ?underob)
:precondition (and (clear ?underob) (holding ?ob))
:effect (and (handempty) (clear ?ob) (on ?ob ?underob)
(not (clear ?underob)) (not (holding ?ob))))
(:action unstack
:parameters (?ob ?underob)
:precondition (and (on ?ob ?underob) (clear ?ob) (handempty))
:effect (and (holding ?ob) (clear ?underob)
(not (on ?ob ?underob)) (not (clear ?ob)) (not (handempty)))))
|
(define (problem BW-rand-4)
(:domain blocksworld-4ops)
(:objects a b c d )
(:init
(handempty)
(ontable a)
(on b c)
(on c d)
(on d a)
(clear b)
)
(:goal
(and
(on a c)
(on d a))
)
)
| status: SOLVED_SATISFICING
engine: Pyperplan
plan: SequentialPlan:
unstack(b, c)
put-down(b)
unstack(c, d)
put-down(c)
unstack(d, a)
put-down(d)
pick-up(a)
stack(a, c)
pick-up(d)
stack(d, a) | SequentialPlan:
unstack(b, c)
put-down(b)
unstack(c, d)
put-down(c)
unstack(d, a)
put-down(d)
pick-up(a)
stack(a, c)
pick-up(d)
stack(d, a) | 10 | I am playing with a set of objects.
Here are the actions I can do:
pick-up with ob
put-down with ob
stack with ob, underob
unstack with ob, underob
I have the following restrictions on my actions:
To perform pick-up action, the following facts need to be true: (clear(ob) and ontable(ob) and handempty).
Once pick-up action is performed the following facts will be true: holding(ob).
Once pick-up action is performed the following facts will be false: clear(ob), ontable(ob), handempty.
To perform put-down action, the following facts need to be true: holding(ob).
Once put-down action is performed the following facts will be true: clear(ob), handempty, ontable(ob).
Once put-down action is performed the following facts will be false: holding(ob).
To perform stack action, the following facts need to be true: (clear(underob) and holding(ob)).
Once stack action is performed the following facts will be true: handempty, clear(ob), on(ob, underob).
Once stack action is performed the following facts will be false: clear(underob), holding(ob).
To perform unstack action, the following facts need to be true: (on(ob, underob) and clear(ob) and handempty).
Once unstack action is performed the following facts will be true: holding(ob), clear(underob).
Once unstack action is performed the following facts will be false: on(ob, underob), clear(ob), handempty.
Everything is false by default
[STATEMENT]
As initial conditions I have that, handempty, ontable(a), on(b, c), on(c, d), on(d, a), clear(b).
My goal is to have that (on(a, c) and on(d, a)). | unstack(b,c)
put-down(b)
unstack(c,d)
put-down(c)
unstack(d,a)
put-down(d)
pick-up(a)
stack(a,c)
pick-up(d)
stack(d,a) | 375 |
(define (domain blocksworld-4ops)
(:requirements :strips)
(:predicates (clear ?x)
(ontable ?x)
(handempty)
(holding ?x)
(on ?x ?y))
(:action pick-up
:parameters (?ob)
:precondition (and (clear ?ob) (ontable ?ob) (handempty))
:effect (and (holding ?ob) (not (clear ?ob)) (not (ontable ?ob))
(not (handempty))))
(:action put-down
:parameters (?ob)
:precondition (holding ?ob)
:effect (and (clear ?ob) (handempty) (ontable ?ob)
(not (holding ?ob))))
(:action stack
:parameters (?ob ?underob)
:precondition (and (clear ?underob) (holding ?ob))
:effect (and (handempty) (clear ?ob) (on ?ob ?underob)
(not (clear ?underob)) (not (holding ?ob))))
(:action unstack
:parameters (?ob ?underob)
:precondition (and (on ?ob ?underob) (clear ?ob) (handempty))
:effect (and (holding ?ob) (clear ?underob)
(not (on ?ob ?underob)) (not (clear ?ob)) (not (handempty)))))
|
(define (problem BW-rand-4)
(:domain blocksworld-4ops)
(:objects a b c d )
(:init
(handempty)
(ontable a)
(on b a)
(ontable c)
(on d c)
(clear b)
(clear d)
)
(:goal
(and
(on a b)
(on b c)
(on c d))
)
)
| status: SOLVED_SATISFICING
engine: Pyperplan
plan: SequentialPlan:
unstack(b, a)
put-down(b)
unstack(d, c)
put-down(d)
pick-up(a)
stack(a, b)
pick-up(c)
stack(c, d)
unstack(a, b)
put-down(a)
pick-up(b)
stack(b, c)
pick-up(a)
stack(a, b) | SequentialPlan:
unstack(b, a)
put-down(b)
unstack(d, c)
put-down(d)
pick-up(a)
stack(a, b)
pick-up(c)
stack(c, d)
unstack(a, b)
put-down(a)
pick-up(b)
stack(b, c)
pick-up(a)
stack(a, b) | 14 | I am playing with a set of objects.
Here are the actions I can do:
pick-up with ob
put-down with ob
stack with ob, underob
unstack with ob, underob
I have the following restrictions on my actions:
To perform pick-up action, the following facts need to be true: (clear(ob) and ontable(ob) and handempty).
Once pick-up action is performed the following facts will be true: holding(ob).
Once pick-up action is performed the following facts will be false: clear(ob), ontable(ob), handempty.
To perform put-down action, the following facts need to be true: holding(ob).
Once put-down action is performed the following facts will be true: clear(ob), handempty, ontable(ob).
Once put-down action is performed the following facts will be false: holding(ob).
To perform stack action, the following facts need to be true: (clear(underob) and holding(ob)).
Once stack action is performed the following facts will be true: handempty, clear(ob), on(ob, underob).
Once stack action is performed the following facts will be false: clear(underob), holding(ob).
To perform unstack action, the following facts need to be true: (on(ob, underob) and clear(ob) and handempty).
Once unstack action is performed the following facts will be true: holding(ob), clear(underob).
Once unstack action is performed the following facts will be false: on(ob, underob), clear(ob), handempty.
[STATEMENT]
As initial conditions I have that, handempty, ontable(a), on(b, a), ontable(c), on(d, c), clear(b), clear(d).
My goal is to have that (on(a, b) and on(b, c) and on(c, d)). | unstack(b,a)
put-down(b)
unstack(d,c)
put-down(d)
pick-up(a)
stack(a,b)
pick-up(c)
stack(c,d)
unstack(a,b)
put-down(a)
pick-up(b)
stack(b,c)
pick-up(a)
stack(a,b) | 377 |
(define (domain blocksworld-4ops)
(:requirements :strips)
(:predicates (clear ?x)
(ontable ?x)
(handempty)
(holding ?x)
(on ?x ?y))
(:action pick-up
:parameters (?ob)
:precondition (and (clear ?ob) (ontable ?ob) (handempty))
:effect (and (holding ?ob) (not (clear ?ob)) (not (ontable ?ob))
(not (handempty))))
(:action put-down
:parameters (?ob)
:precondition (holding ?ob)
:effect (and (clear ?ob) (handempty) (ontable ?ob)
(not (holding ?ob))))
(:action stack
:parameters (?ob ?underob)
:precondition (and (clear ?underob) (holding ?ob))
:effect (and (handempty) (clear ?ob) (on ?ob ?underob)
(not (clear ?underob)) (not (holding ?ob))))
(:action unstack
:parameters (?ob ?underob)
:precondition (and (on ?ob ?underob) (clear ?ob) (handempty))
:effect (and (holding ?ob) (clear ?underob)
(not (on ?ob ?underob)) (not (clear ?ob)) (not (handempty)))))
|
(define (problem BW-rand-4)
(:domain blocksworld-4ops)
(:objects a b c d )
(:init
(handempty)
(on a c)
(on b a)
(ontable c)
(on d b)
(clear d)
)
(:goal
(and
(on b c)
(on c d))
)
)
| status: SOLVED_SATISFICING
engine: Pyperplan
plan: SequentialPlan:
unstack(d, b)
put-down(d)
unstack(b, a)
put-down(b)
unstack(a, c)
put-down(a)
pick-up(c)
stack(c, d)
pick-up(b)
stack(b, c) | SequentialPlan:
unstack(d, b)
put-down(d)
unstack(b, a)
put-down(b)
unstack(a, c)
put-down(a)
pick-up(c)
stack(c, d)
pick-up(b)
stack(b, c) | 10 | I am playing with a set of objects.
Here are the actions I can do:
pick-up with ob
put-down with ob
stack with ob, underob
unstack with ob, underob
I have the following restrictions on my actions:
To perform pick-up action, the following facts need to be true: (clear(ob) and ontable(ob) and handempty).
Once pick-up action is performed the following facts will be true: holding(ob).
Once pick-up action is performed the following facts will be false: clear(ob), ontable(ob), handempty.
To perform put-down action, the following facts need to be true: holding(ob).
Once put-down action is performed the following facts will be true: clear(ob), handempty, ontable(ob).
Once put-down action is performed the following facts will be false: holding(ob).
To perform stack action, the following facts need to be true: (clear(underob) and holding(ob)).
Once stack action is performed the following facts will be true: handempty, clear(ob), on(ob, underob).
Once stack action is performed the following facts will be false: clear(underob), holding(ob).
To perform unstack action, the following facts need to be true: (on(ob, underob) and clear(ob) and handempty).
Once unstack action is performed the following facts will be true: holding(ob), clear(underob).
Once unstack action is performed the following facts will be false: on(ob, underob), clear(ob), handempty.
Everything is false by default
[STATEMENT]
As initial conditions I have that, handempty, on(a, c), on(b, a), ontable(c), on(d, b), clear(d).
My goal is to have that (on(b, c) and on(c, d)). | unstack(d,b)
put-down(d)
unstack(b,a)
put-down(b)
unstack(a,c)
put-down(a)
pick-up(c)
stack(c,d)
pick-up(b)
stack(b,c) | 375 |
(define (domain blocksworld-4ops)
(:requirements :strips)
(:predicates (clear ?x)
(ontable ?x)
(handempty)
(holding ?x)
(on ?x ?y))
(:action pick-up
:parameters (?ob)
:precondition (and (clear ?ob) (ontable ?ob) (handempty))
:effect (and (holding ?ob) (not (clear ?ob)) (not (ontable ?ob))
(not (handempty))))
(:action put-down
:parameters (?ob)
:precondition (holding ?ob)
:effect (and (clear ?ob) (handempty) (ontable ?ob)
(not (holding ?ob))))
(:action stack
:parameters (?ob ?underob)
:precondition (and (clear ?underob) (holding ?ob))
:effect (and (handempty) (clear ?ob) (on ?ob ?underob)
(not (clear ?underob)) (not (holding ?ob))))
(:action unstack
:parameters (?ob ?underob)
:precondition (and (on ?ob ?underob) (clear ?ob) (handempty))
:effect (and (holding ?ob) (clear ?underob)
(not (on ?ob ?underob)) (not (clear ?ob)) (not (handempty)))))
|
(define (problem BW-rand-4)
(:domain blocksworld-4ops)
(:objects a b c d )
(:init
(handempty)
(on a b)
(on b c)
(ontable c)
(ontable d)
(clear a)
(clear d)
)
(:goal
(and
(on b d)
(on d a))
)
)
| status: SOLVED_SATISFICING
engine: Pyperplan
plan: SequentialPlan:
unstack(a, b)
put-down(a)
pick-up(d)
stack(d, a)
unstack(b, c)
stack(b, d) | SequentialPlan:
unstack(a, b)
put-down(a)
pick-up(d)
stack(d, a)
unstack(b, c)
stack(b, d) | 6 | I am playing with a set of objects.
Here are the actions I can do:
pick-up with ob
put-down with ob
stack with ob, underob
unstack with ob, underob
I have the following restrictions on my actions:
To perform pick-up action, the following facts need to be true: (clear(ob) and ontable(ob) and handempty).
Once pick-up action is performed the following facts will be true: holding(ob).
Once pick-up action is performed the following facts will be false: clear(ob), ontable(ob), handempty.
To perform put-down action, the following facts need to be true: holding(ob).
Once put-down action is performed the following facts will be true: clear(ob), handempty, ontable(ob).
Once put-down action is performed the following facts will be false: holding(ob).
To perform stack action, the following facts need to be true: (clear(underob) and holding(ob)).
Once stack action is performed the following facts will be true: handempty, clear(ob), on(ob, underob).
Once stack action is performed the following facts will be false: clear(underob), holding(ob).
To perform unstack action, the following facts need to be true: (on(ob, underob) and clear(ob) and handempty).
Once unstack action is performed the following facts will be true: holding(ob), clear(underob).
Once unstack action is performed the following facts will be false: on(ob, underob), clear(ob), handempty.
Everything is false by default
[STATEMENT]
As initial conditions I have that, handempty, on(a, b), on(b, c), ontable(c), ontable(d), clear(a), clear(d).
My goal is to have that (on(b, d) and on(d, a)). | unstack(a,b)
put-down(a)
pick-up(d)
stack(d,a)
unstack(b,c)
stack(b,d) | 377 |
(define (domain blocksworld-4ops)
(:requirements :strips)
(:predicates (clear ?x)
(ontable ?x)
(handempty)
(holding ?x)
(on ?x ?y))
(:action pick-up
:parameters (?ob)
:precondition (and (clear ?ob) (ontable ?ob) (handempty))
:effect (and (holding ?ob) (not (clear ?ob)) (not (ontable ?ob))
(not (handempty))))
(:action put-down
:parameters (?ob)
:precondition (holding ?ob)
:effect (and (clear ?ob) (handempty) (ontable ?ob)
(not (holding ?ob))))
(:action stack
:parameters (?ob ?underob)
:precondition (and (clear ?underob) (holding ?ob))
:effect (and (handempty) (clear ?ob) (on ?ob ?underob)
(not (clear ?underob)) (not (holding ?ob))))
(:action unstack
:parameters (?ob ?underob)
:precondition (and (on ?ob ?underob) (clear ?ob) (handempty))
:effect (and (holding ?ob) (clear ?underob)
(not (on ?ob ?underob)) (not (clear ?ob)) (not (handempty)))))
|
(define (problem BW-rand-4)
(:domain blocksworld-4ops)
(:objects a b c d )
(:init
(handempty)
(ontable a)
(on b c)
(on c d)
(on d a)
(clear b)
)
(:goal
(and
(on b c)
(on c a))
)
)
| status: SOLVED_SATISFICING
engine: Pyperplan
plan: SequentialPlan:
unstack(b, c)
put-down(b)
unstack(c, d)
put-down(c)
unstack(d, a)
put-down(d)
pick-up(c)
stack(c, a)
pick-up(b)
stack(b, c) | SequentialPlan:
unstack(b, c)
put-down(b)
unstack(c, d)
put-down(c)
unstack(d, a)
put-down(d)
pick-up(c)
stack(c, a)
pick-up(b)
stack(b, c) | 10 | I am playing with a set of objects.
Here are the actions I can do:
pick-up with ob
put-down with ob
stack with ob, underob
unstack with ob, underob
I have the following restrictions on my actions:
To perform pick-up action, the following facts need to be true: (clear(ob) and ontable(ob) and handempty).
Once pick-up action is performed the following facts will be true: holding(ob).
Once pick-up action is performed the following facts will be false: clear(ob), ontable(ob), handempty.
To perform put-down action, the following facts need to be true: holding(ob).
Once put-down action is performed the following facts will be true: clear(ob), handempty, ontable(ob).
Once put-down action is performed the following facts will be false: holding(ob).
To perform stack action, the following facts need to be true: (clear(underob) and holding(ob)).
Once stack action is performed the following facts will be true: handempty, clear(ob), on(ob, underob).
Once stack action is performed the following facts will be false: clear(underob), holding(ob).
To perform unstack action, the following facts need to be true: (on(ob, underob) and clear(ob) and handempty).
Once unstack action is performed the following facts will be true: holding(ob), clear(underob).
Once unstack action is performed the following facts will be false: on(ob, underob), clear(ob), handempty.
[STATEMENT]
As initial conditions I have that, handempty, ontable(a), on(b, c), on(c, d), on(d, a), clear(b).
My goal is to have that (on(b, c) and on(c, a)). | unstack(b,c)
put-down(b)
unstack(c,d)
put-down(c)
unstack(d,a)
put-down(d)
pick-up(c)
stack(c,a)
pick-up(b)
stack(b,c) | 369 |
(define (domain blocksworld-4ops)
(:requirements :strips)
(:predicates (clear ?x)
(ontable ?x)
(handempty)
(holding ?x)
(on ?x ?y))
(:action pick-up
:parameters (?ob)
:precondition (and (clear ?ob) (ontable ?ob) (handempty))
:effect (and (holding ?ob) (not (clear ?ob)) (not (ontable ?ob))
(not (handempty))))
(:action put-down
:parameters (?ob)
:precondition (holding ?ob)
:effect (and (clear ?ob) (handempty) (ontable ?ob)
(not (holding ?ob))))
(:action stack
:parameters (?ob ?underob)
:precondition (and (clear ?underob) (holding ?ob))
:effect (and (handempty) (clear ?ob) (on ?ob ?underob)
(not (clear ?underob)) (not (holding ?ob))))
(:action unstack
:parameters (?ob ?underob)
:precondition (and (on ?ob ?underob) (clear ?ob) (handempty))
:effect (and (holding ?ob) (clear ?underob)
(not (on ?ob ?underob)) (not (clear ?ob)) (not (handempty)))))
|
(define (problem BW-rand-4)
(:domain blocksworld-4ops)
(:objects a b c d )
(:init
(handempty)
(ontable a)
(on b d)
(ontable c)
(on d c)
(clear a)
(clear b)
)
(:goal
(and
(on a c)
(on b d)
(on d a))
)
)
| status: SOLVED_SATISFICING
engine: Pyperplan
plan: SequentialPlan:
unstack(b, d)
put-down(b)
unstack(d, c)
put-down(d)
pick-up(b)
stack(b, d)
pick-up(a)
stack(a, c)
unstack(b, d)
put-down(b)
pick-up(d)
stack(d, a)
pick-up(b)
stack(b, d) | SequentialPlan:
unstack(b, d)
put-down(b)
unstack(d, c)
put-down(d)
pick-up(b)
stack(b, d)
pick-up(a)
stack(a, c)
unstack(b, d)
put-down(b)
pick-up(d)
stack(d, a)
pick-up(b)
stack(b, d) | 14 | I am playing with a set of objects.
Here are the actions I can do:
pick-up with ob
put-down with ob
stack with ob, underob
unstack with ob, underob
I have the following restrictions on my actions:
To perform pick-up action, the following facts need to be true: (clear(ob) and ontable(ob) and handempty).
Once pick-up action is performed the following facts will be true: holding(ob).
Once pick-up action is performed the following facts will be false: clear(ob), ontable(ob), handempty.
To perform put-down action, the following facts need to be true: holding(ob).
Once put-down action is performed the following facts will be true: clear(ob), handempty, ontable(ob).
Once put-down action is performed the following facts will be false: holding(ob).
To perform stack action, the following facts need to be true: (clear(underob) and holding(ob)).
Once stack action is performed the following facts will be true: handempty, clear(ob), on(ob, underob).
Once stack action is performed the following facts will be false: clear(underob), holding(ob).
To perform unstack action, the following facts need to be true: (on(ob, underob) and clear(ob) and handempty).
Once unstack action is performed the following facts will be true: holding(ob), clear(underob).
Once unstack action is performed the following facts will be false: on(ob, underob), clear(ob), handempty.
Everything is false by default
[STATEMENT]
As initial conditions I have that, handempty, ontable(a), on(b, d), ontable(c), on(d, c), clear(a), clear(b).
My goal is to have that (on(a, c) and on(b, d) and on(d, a)). | unstack(b,d)
put-down(b)
unstack(d,c)
put-down(d)
pick-up(b)
stack(b,d)
pick-up(a)
stack(a,c)
unstack(b,d)
put-down(b)
pick-up(d)
stack(d,a)
pick-up(b)
stack(b,d) | 383 |
(define (domain blocksworld-4ops)
(:requirements :strips)
(:predicates (clear ?x)
(ontable ?x)
(handempty)
(holding ?x)
(on ?x ?y))
(:action pick-up
:parameters (?ob)
:precondition (and (clear ?ob) (ontable ?ob) (handempty))
:effect (and (holding ?ob) (not (clear ?ob)) (not (ontable ?ob))
(not (handempty))))
(:action put-down
:parameters (?ob)
:precondition (holding ?ob)
:effect (and (clear ?ob) (handempty) (ontable ?ob)
(not (holding ?ob))))
(:action stack
:parameters (?ob ?underob)
:precondition (and (clear ?underob) (holding ?ob))
:effect (and (handempty) (clear ?ob) (on ?ob ?underob)
(not (clear ?underob)) (not (holding ?ob))))
(:action unstack
:parameters (?ob ?underob)
:precondition (and (on ?ob ?underob) (clear ?ob) (handempty))
:effect (and (holding ?ob) (clear ?underob)
(not (on ?ob ?underob)) (not (clear ?ob)) (not (handempty)))))
|
(define (problem BW-rand-4)
(:domain blocksworld-4ops)
(:objects a b c d )
(:init
(handempty)
(on a c)
(on b d)
(ontable c)
(ontable d)
(clear a)
(clear b)
)
(:goal
(and
(on a c)
(on b a))
)
)
| status: SOLVED_SATISFICING
engine: Pyperplan
plan: SequentialPlan:
unstack(b, d)
stack(b, a) | SequentialPlan:
unstack(b, d)
stack(b, a) | 2 | I am playing with a set of objects.
Here are the actions I can do:
pick-up with ob
put-down with ob
stack with ob, underob
unstack with ob, underob
I have the following restrictions on my actions:
To perform pick-up action, the following facts need to be true: (clear(ob) and ontable(ob) and handempty).
Once pick-up action is performed the following facts will be true: holding(ob).
Once pick-up action is performed the following facts will be false: clear(ob), ontable(ob), handempty.
To perform put-down action, the following facts need to be true: holding(ob).
Once put-down action is performed the following facts will be true: clear(ob), handempty, ontable(ob).
Once put-down action is performed the following facts will be false: holding(ob).
To perform stack action, the following facts need to be true: (clear(underob) and holding(ob)).
Once stack action is performed the following facts will be true: handempty, clear(ob), on(ob, underob).
Once stack action is performed the following facts will be false: clear(underob), holding(ob).
To perform unstack action, the following facts need to be true: (on(ob, underob) and clear(ob) and handempty).
Once unstack action is performed the following facts will be true: holding(ob), clear(underob).
Once unstack action is performed the following facts will be false: on(ob, underob), clear(ob), handempty.
[STATEMENT]
As initial conditions I have that, handempty, on(a, c), on(b, d), ontable(c), ontable(d), clear(a), clear(b).
My goal is to have that (on(a, c) and on(b, a)). | unstack(b,d)
stack(b,a) | 371 |
(define (domain blocksworld-4ops)
(:requirements :strips)
(:predicates (clear ?x)
(ontable ?x)
(handempty)
(holding ?x)
(on ?x ?y))
(:action pick-up
:parameters (?ob)
:precondition (and (clear ?ob) (ontable ?ob) (handempty))
:effect (and (holding ?ob) (not (clear ?ob)) (not (ontable ?ob))
(not (handempty))))
(:action put-down
:parameters (?ob)
:precondition (holding ?ob)
:effect (and (clear ?ob) (handempty) (ontable ?ob)
(not (holding ?ob))))
(:action stack
:parameters (?ob ?underob)
:precondition (and (clear ?underob) (holding ?ob))
:effect (and (handempty) (clear ?ob) (on ?ob ?underob)
(not (clear ?underob)) (not (holding ?ob))))
(:action unstack
:parameters (?ob ?underob)
:precondition (and (on ?ob ?underob) (clear ?ob) (handempty))
:effect (and (holding ?ob) (clear ?underob)
(not (on ?ob ?underob)) (not (clear ?ob)) (not (handempty)))))
|
(define (problem BW-rand-4)
(:domain blocksworld-4ops)
(:objects a b c d )
(:init
(handempty)
(ontable a)
(on b c)
(ontable c)
(on d b)
(clear a)
(clear d)
)
(:goal
(and
(on a b)
(on b c)
(on d a))
)
)
| status: SOLVED_SATISFICING
engine: Pyperplan
plan: SequentialPlan:
unstack(d, b)
put-down(d)
pick-up(a)
stack(a, b)
pick-up(d)
stack(d, a) | SequentialPlan:
unstack(d, b)
put-down(d)
pick-up(a)
stack(a, b)
pick-up(d)
stack(d, a) | 6 | I am playing with a set of objects.
Here are the actions I can do:
pick-up with ob
put-down with ob
stack with ob, underob
unstack with ob, underob
I have the following restrictions on my actions:
To perform pick-up action, the following facts need to be true: (clear(ob) and ontable(ob) and handempty).
Once pick-up action is performed the following facts will be true: holding(ob).
Once pick-up action is performed the following facts will be false: clear(ob), ontable(ob), handempty.
To perform put-down action, the following facts need to be true: holding(ob).
Once put-down action is performed the following facts will be true: clear(ob), handempty, ontable(ob).
Once put-down action is performed the following facts will be false: holding(ob).
To perform stack action, the following facts need to be true: (clear(underob) and holding(ob)).
Once stack action is performed the following facts will be true: handempty, clear(ob), on(ob, underob).
Once stack action is performed the following facts will be false: clear(underob), holding(ob).
To perform unstack action, the following facts need to be true: (on(ob, underob) and clear(ob) and handempty).
Once unstack action is performed the following facts will be true: holding(ob), clear(underob).
Once unstack action is performed the following facts will be false: on(ob, underob), clear(ob), handempty.
Everything is false by default
[STATEMENT]
As initial conditions I have that, handempty, ontable(a), on(b, c), ontable(c), on(d, b), clear(a), clear(d).
My goal is to have that (on(a, b) and on(b, c) and on(d, a)). | unstack(d,b)
put-down(d)
pick-up(a)
stack(a,b)
pick-up(d)
stack(d,a) | 383 |
(define (domain blocksworld-4ops)
(:requirements :strips)
(:predicates (clear ?x)
(ontable ?x)
(handempty)
(holding ?x)
(on ?x ?y))
(:action pick-up
:parameters (?ob)
:precondition (and (clear ?ob) (ontable ?ob) (handempty))
:effect (and (holding ?ob) (not (clear ?ob)) (not (ontable ?ob))
(not (handempty))))
(:action put-down
:parameters (?ob)
:precondition (holding ?ob)
:effect (and (clear ?ob) (handempty) (ontable ?ob)
(not (holding ?ob))))
(:action stack
:parameters (?ob ?underob)
:precondition (and (clear ?underob) (holding ?ob))
:effect (and (handempty) (clear ?ob) (on ?ob ?underob)
(not (clear ?underob)) (not (holding ?ob))))
(:action unstack
:parameters (?ob ?underob)
:precondition (and (on ?ob ?underob) (clear ?ob) (handempty))
:effect (and (holding ?ob) (clear ?underob)
(not (on ?ob ?underob)) (not (clear ?ob)) (not (handempty)))))
|
(define (problem BW-rand-4)
(:domain blocksworld-4ops)
(:objects a b c d )
(:init
(handempty)
(ontable a)
(ontable b)
(ontable c)
(ontable d)
(clear a)
(clear b)
(clear c)
(clear d)
)
(:goal
(and
(on a b)
(on b d)
(on c a))
)
)
| status: SOLVED_SATISFICING
engine: Pyperplan
plan: SequentialPlan:
pick-up(c)
stack(c, a)
pick-up(b)
stack(b, d)
unstack(c, a)
put-down(c)
pick-up(a)
stack(a, b)
pick-up(c)
stack(c, a) | SequentialPlan:
pick-up(c)
stack(c, a)
pick-up(b)
stack(b, d)
unstack(c, a)
put-down(c)
pick-up(a)
stack(a, b)
pick-up(c)
stack(c, a) | 10 | I am playing with a set of objects.
Here are the actions I can do:
pick-up with ob
put-down with ob
stack with ob, underob
unstack with ob, underob
I have the following restrictions on my actions:
To perform pick-up action, the following facts need to be true: (clear(ob) and ontable(ob) and handempty).
Once pick-up action is performed the following facts will be true: holding(ob).
Once pick-up action is performed the following facts will be false: clear(ob), ontable(ob), handempty.
To perform put-down action, the following facts need to be true: holding(ob).
Once put-down action is performed the following facts will be true: clear(ob), handempty, ontable(ob).
Once put-down action is performed the following facts will be false: holding(ob).
To perform stack action, the following facts need to be true: (clear(underob) and holding(ob)).
Once stack action is performed the following facts will be true: handempty, clear(ob), on(ob, underob).
Once stack action is performed the following facts will be false: clear(underob), holding(ob).
To perform unstack action, the following facts need to be true: (on(ob, underob) and clear(ob) and handempty).
Once unstack action is performed the following facts will be true: holding(ob), clear(underob).
Once unstack action is performed the following facts will be false: on(ob, underob), clear(ob), handempty.
Everything is false by default
[STATEMENT]
As initial conditions I have that, handempty, ontable(a), ontable(b), ontable(c), ontable(d), clear(a), clear(b), clear(c), clear(d).
My goal is to have that (on(a, b) and on(b, d) and on(c, a)). | pick-up(c)
stack(c,a)
pick-up(b)
stack(b,d)
unstack(c,a)
put-down(c)
pick-up(a)
stack(a,b)
pick-up(c)
stack(c,a) | 387 |
(define (domain blocksworld-4ops)
(:requirements :strips)
(:predicates (clear ?x)
(ontable ?x)
(handempty)
(holding ?x)
(on ?x ?y))
(:action pick-up
:parameters (?ob)
:precondition (and (clear ?ob) (ontable ?ob) (handempty))
:effect (and (holding ?ob) (not (clear ?ob)) (not (ontable ?ob))
(not (handempty))))
(:action put-down
:parameters (?ob)
:precondition (holding ?ob)
:effect (and (clear ?ob) (handempty) (ontable ?ob)
(not (holding ?ob))))
(:action stack
:parameters (?ob ?underob)
:precondition (and (clear ?underob) (holding ?ob))
:effect (and (handempty) (clear ?ob) (on ?ob ?underob)
(not (clear ?underob)) (not (holding ?ob))))
(:action unstack
:parameters (?ob ?underob)
:precondition (and (on ?ob ?underob) (clear ?ob) (handempty))
:effect (and (holding ?ob) (clear ?underob)
(not (on ?ob ?underob)) (not (clear ?ob)) (not (handempty)))))
|
(define (problem BW-rand-4)
(:domain blocksworld-4ops)
(:objects a b c d )
(:init
(handempty)
(on a d)
(on b c)
(ontable c)
(on d b)
(clear a)
)
(:goal
(and
(on a c)
(on c b)
(on d a))
)
)
| status: SOLVED_SATISFICING
engine: Pyperplan
plan: SequentialPlan:
unstack(a, d)
put-down(a)
unstack(d, b)
stack(d, a)
unstack(b, c)
put-down(b)
pick-up(c)
stack(c, b)
unstack(d, a)
put-down(d)
pick-up(a)
stack(a, c)
pick-up(d)
stack(d, a) | SequentialPlan:
unstack(a, d)
put-down(a)
unstack(d, b)
stack(d, a)
unstack(b, c)
put-down(b)
pick-up(c)
stack(c, b)
unstack(d, a)
put-down(d)
pick-up(a)
stack(a, c)
pick-up(d)
stack(d, a) | 14 | I am playing with a set of objects.
Here are the actions I can do:
pick-up with ob
put-down with ob
stack with ob, underob
unstack with ob, underob
I have the following restrictions on my actions:
To perform pick-up action, the following facts need to be true: (clear(ob) and ontable(ob) and handempty).
Once pick-up action is performed the following facts will be true: holding(ob).
Once pick-up action is performed the following facts will be false: clear(ob), ontable(ob), handempty.
To perform put-down action, the following facts need to be true: holding(ob).
Once put-down action is performed the following facts will be true: clear(ob), handempty, ontable(ob).
Once put-down action is performed the following facts will be false: holding(ob).
To perform stack action, the following facts need to be true: (clear(underob) and holding(ob)).
Once stack action is performed the following facts will be true: handempty, clear(ob), on(ob, underob).
Once stack action is performed the following facts will be false: clear(underob), holding(ob).
To perform unstack action, the following facts need to be true: (on(ob, underob) and clear(ob) and handempty).
Once unstack action is performed the following facts will be true: holding(ob), clear(underob).
Once unstack action is performed the following facts will be false: on(ob, underob), clear(ob), handempty.
[STATEMENT]
As initial conditions I have that, handempty, on(a, d), on(b, c), ontable(c), on(d, b), clear(a).
My goal is to have that (on(a, c) and on(c, b) and on(d, a)). | unstack(a,d)
put-down(a)
unstack(d,b)
stack(d,a)
unstack(b,c)
put-down(b)
pick-up(c)
stack(c,b)
unstack(d,a)
put-down(d)
pick-up(a)
stack(a,c)
pick-up(d)
stack(d,a) | 375 |
(define (domain blocksworld-4ops)
(:requirements :strips)
(:predicates (clear ?x)
(ontable ?x)
(handempty)
(holding ?x)
(on ?x ?y))
(:action pick-up
:parameters (?ob)
:precondition (and (clear ?ob) (ontable ?ob) (handempty))
:effect (and (holding ?ob) (not (clear ?ob)) (not (ontable ?ob))
(not (handempty))))
(:action put-down
:parameters (?ob)
:precondition (holding ?ob)
:effect (and (clear ?ob) (handempty) (ontable ?ob)
(not (holding ?ob))))
(:action stack
:parameters (?ob ?underob)
:precondition (and (clear ?underob) (holding ?ob))
:effect (and (handempty) (clear ?ob) (on ?ob ?underob)
(not (clear ?underob)) (not (holding ?ob))))
(:action unstack
:parameters (?ob ?underob)
:precondition (and (on ?ob ?underob) (clear ?ob) (handempty))
:effect (and (holding ?ob) (clear ?underob)
(not (on ?ob ?underob)) (not (clear ?ob)) (not (handempty)))))
|
(define (problem BW-rand-4)
(:domain blocksworld-4ops)
(:objects a b c d )
(:init
(handempty)
(on a d)
(on b a)
(on c b)
(ontable d)
(clear c)
)
(:goal
(and
(on c a)
(on d b))
)
)
| status: SOLVED_SATISFICING
engine: Pyperplan
plan: SequentialPlan:
unstack(c, b)
put-down(c)
unstack(b, a)
put-down(b)
unstack(a, d)
put-down(a)
pick-up(c)
stack(c, a)
pick-up(d)
stack(d, b) | SequentialPlan:
unstack(c, b)
put-down(c)
unstack(b, a)
put-down(b)
unstack(a, d)
put-down(a)
pick-up(c)
stack(c, a)
pick-up(d)
stack(d, b) | 10 | I am playing with a set of objects.
Here are the actions I can do:
pick-up with ob
put-down with ob
stack with ob, underob
unstack with ob, underob
I have the following restrictions on my actions:
To perform pick-up action, the following facts need to be true: (clear(ob) and ontable(ob) and handempty).
Once pick-up action is performed the following facts will be true: holding(ob).
Once pick-up action is performed the following facts will be false: clear(ob), ontable(ob), handempty.
To perform put-down action, the following facts need to be true: holding(ob).
Once put-down action is performed the following facts will be true: clear(ob), handempty, ontable(ob).
Once put-down action is performed the following facts will be false: holding(ob).
To perform stack action, the following facts need to be true: (clear(underob) and holding(ob)).
Once stack action is performed the following facts will be true: handempty, clear(ob), on(ob, underob).
Once stack action is performed the following facts will be false: clear(underob), holding(ob).
To perform unstack action, the following facts need to be true: (on(ob, underob) and clear(ob) and handempty).
Once unstack action is performed the following facts will be true: holding(ob), clear(underob).
Once unstack action is performed the following facts will be false: on(ob, underob), clear(ob), handempty.
Everything is false by default
[STATEMENT]
As initial conditions I have that, handempty, on(a, d), on(b, a), on(c, b), ontable(d), clear(c).
My goal is to have that (on(c, a) and on(d, b)). | unstack(c,b)
put-down(c)
unstack(b,a)
put-down(b)
unstack(a,d)
put-down(a)
pick-up(c)
stack(c,a)
pick-up(d)
stack(d,b) | 375 |
(define (domain blocksworld-4ops)
(:requirements :strips)
(:predicates (clear ?x)
(ontable ?x)
(handempty)
(holding ?x)
(on ?x ?y))
(:action pick-up
:parameters (?ob)
:precondition (and (clear ?ob) (ontable ?ob) (handempty))
:effect (and (holding ?ob) (not (clear ?ob)) (not (ontable ?ob))
(not (handempty))))
(:action put-down
:parameters (?ob)
:precondition (holding ?ob)
:effect (and (clear ?ob) (handempty) (ontable ?ob)
(not (holding ?ob))))
(:action stack
:parameters (?ob ?underob)
:precondition (and (clear ?underob) (holding ?ob))
:effect (and (handempty) (clear ?ob) (on ?ob ?underob)
(not (clear ?underob)) (not (holding ?ob))))
(:action unstack
:parameters (?ob ?underob)
:precondition (and (on ?ob ?underob) (clear ?ob) (handempty))
:effect (and (holding ?ob) (clear ?underob)
(not (on ?ob ?underob)) (not (clear ?ob)) (not (handempty)))))
|
(define (problem BW-rand-4)
(:domain blocksworld-4ops)
(:objects a b c d )
(:init
(handempty)
(ontable a)
(on b c)
(ontable c)
(on d b)
(clear a)
(clear d)
)
(:goal
(and
(on c b)
(on d c))
)
)
| status: SOLVED_SATISFICING
engine: Pyperplan
plan: SequentialPlan:
unstack(d, b)
put-down(d)
unstack(b, c)
put-down(b)
pick-up(c)
stack(c, b)
pick-up(d)
stack(d, c) | SequentialPlan:
unstack(d, b)
put-down(d)
unstack(b, c)
put-down(b)
pick-up(c)
stack(c, b)
pick-up(d)
stack(d, c) | 8 | I am playing with a set of objects.
Here are the actions I can do:
pick-up with ob
put-down with ob
stack with ob, underob
unstack with ob, underob
I have the following restrictions on my actions:
To perform pick-up action, the following facts need to be true: (clear(ob) and ontable(ob) and handempty).
Once pick-up action is performed the following facts will be true: holding(ob).
Once pick-up action is performed the following facts will be false: clear(ob), ontable(ob), handempty.
To perform put-down action, the following facts need to be true: holding(ob).
Once put-down action is performed the following facts will be true: clear(ob), handempty, ontable(ob).
Once put-down action is performed the following facts will be false: holding(ob).
To perform stack action, the following facts need to be true: (clear(underob) and holding(ob)).
Once stack action is performed the following facts will be true: handempty, clear(ob), on(ob, underob).
Once stack action is performed the following facts will be false: clear(underob), holding(ob).
To perform unstack action, the following facts need to be true: (on(ob, underob) and clear(ob) and handempty).
Once unstack action is performed the following facts will be true: holding(ob), clear(underob).
Once unstack action is performed the following facts will be false: on(ob, underob), clear(ob), handempty.
[STATEMENT]
As initial conditions I have that, handempty, ontable(a), on(b, c), ontable(c), on(d, b), clear(a), clear(d).
My goal is to have that (on(c, b) and on(d, c)). | unstack(d,b)
put-down(d)
unstack(b,c)
put-down(b)
pick-up(c)
stack(c,b)
pick-up(d)
stack(d,c) | 371 |
(define (domain blocksworld-4ops)
(:requirements :strips)
(:predicates (clear ?x)
(ontable ?x)
(handempty)
(holding ?x)
(on ?x ?y))
(:action pick-up
:parameters (?ob)
:precondition (and (clear ?ob) (ontable ?ob) (handempty))
:effect (and (holding ?ob) (not (clear ?ob)) (not (ontable ?ob))
(not (handempty))))
(:action put-down
:parameters (?ob)
:precondition (holding ?ob)
:effect (and (clear ?ob) (handempty) (ontable ?ob)
(not (holding ?ob))))
(:action stack
:parameters (?ob ?underob)
:precondition (and (clear ?underob) (holding ?ob))
:effect (and (handempty) (clear ?ob) (on ?ob ?underob)
(not (clear ?underob)) (not (holding ?ob))))
(:action unstack
:parameters (?ob ?underob)
:precondition (and (on ?ob ?underob) (clear ?ob) (handempty))
:effect (and (holding ?ob) (clear ?underob)
(not (on ?ob ?underob)) (not (clear ?ob)) (not (handempty)))))
|
(define (problem BW-rand-4)
(:domain blocksworld-4ops)
(:objects a b c d )
(:init
(handempty)
(on a b)
(ontable b)
(on c d)
(ontable d)
(clear a)
(clear c)
)
(:goal
(and
(on a c)
(on b d)
(on d a))
)
)
| status: SOLVED_SATISFICING
engine: Pyperplan
plan: SequentialPlan:
unstack(c, d)
put-down(c)
unstack(a, b)
stack(a, c)
pick-up(d)
stack(d, a)
pick-up(b)
stack(b, d) | SequentialPlan:
unstack(c, d)
put-down(c)
unstack(a, b)
stack(a, c)
pick-up(d)
stack(d, a)
pick-up(b)
stack(b, d) | 8 | I am playing with a set of objects.
Here are the actions I can do:
pick-up with ob
put-down with ob
stack with ob, underob
unstack with ob, underob
I have the following restrictions on my actions:
To perform pick-up action, the following facts need to be true: (clear(ob) and ontable(ob) and handempty).
Once pick-up action is performed the following facts will be true: holding(ob).
Once pick-up action is performed the following facts will be false: clear(ob), ontable(ob), handempty.
To perform put-down action, the following facts need to be true: holding(ob).
Once put-down action is performed the following facts will be true: clear(ob), handempty, ontable(ob).
Once put-down action is performed the following facts will be false: holding(ob).
To perform stack action, the following facts need to be true: (clear(underob) and holding(ob)).
Once stack action is performed the following facts will be true: handempty, clear(ob), on(ob, underob).
Once stack action is performed the following facts will be false: clear(underob), holding(ob).
To perform unstack action, the following facts need to be true: (on(ob, underob) and clear(ob) and handempty).
Once unstack action is performed the following facts will be true: holding(ob), clear(underob).
Once unstack action is performed the following facts will be false: on(ob, underob), clear(ob), handempty.
[STATEMENT]
As initial conditions I have that, handempty, on(a, b), ontable(b), on(c, d), ontable(d), clear(a), clear(c).
My goal is to have that (on(a, c) and on(b, d) and on(d, a)). | unstack(c,d)
put-down(c)
unstack(a,b)
stack(a,c)
pick-up(d)
stack(d,a)
pick-up(b)
stack(b,d) | 377 |
(define (domain blocksworld-4ops)
(:requirements :strips)
(:predicates (clear ?x)
(ontable ?x)
(handempty)
(holding ?x)
(on ?x ?y))
(:action pick-up
:parameters (?ob)
:precondition (and (clear ?ob) (ontable ?ob) (handempty))
:effect (and (holding ?ob) (not (clear ?ob)) (not (ontable ?ob))
(not (handempty))))
(:action put-down
:parameters (?ob)
:precondition (holding ?ob)
:effect (and (clear ?ob) (handempty) (ontable ?ob)
(not (holding ?ob))))
(:action stack
:parameters (?ob ?underob)
:precondition (and (clear ?underob) (holding ?ob))
:effect (and (handempty) (clear ?ob) (on ?ob ?underob)
(not (clear ?underob)) (not (holding ?ob))))
(:action unstack
:parameters (?ob ?underob)
:precondition (and (on ?ob ?underob) (clear ?ob) (handempty))
:effect (and (holding ?ob) (clear ?underob)
(not (on ?ob ?underob)) (not (clear ?ob)) (not (handempty)))))
|
(define (problem BW-rand-4)
(:domain blocksworld-4ops)
(:objects a b c d )
(:init
(handempty)
(on a d)
(ontable b)
(on c a)
(on d b)
(clear c)
)
(:goal
(and
(on c b))
)
)
| status: SOLVED_SATISFICING
engine: Pyperplan
plan: SequentialPlan:
unstack(c, a)
put-down(c)
unstack(a, d)
put-down(a)
unstack(d, b)
put-down(d)
pick-up(c)
stack(c, b) | SequentialPlan:
unstack(c, a)
put-down(c)
unstack(a, d)
put-down(a)
unstack(d, b)
put-down(d)
pick-up(c)
stack(c, b) | 8 | I am playing with a set of objects.
Here are the actions I can do:
pick-up with ob
put-down with ob
stack with ob, underob
unstack with ob, underob
I have the following restrictions on my actions:
To perform pick-up action, the following facts need to be true: (clear(ob) and ontable(ob) and handempty).
Once pick-up action is performed the following facts will be true: holding(ob).
Once pick-up action is performed the following facts will be false: clear(ob), ontable(ob), handempty.
To perform put-down action, the following facts need to be true: holding(ob).
Once put-down action is performed the following facts will be true: clear(ob), handempty, ontable(ob).
Once put-down action is performed the following facts will be false: holding(ob).
To perform stack action, the following facts need to be true: (clear(underob) and holding(ob)).
Once stack action is performed the following facts will be true: handempty, clear(ob), on(ob, underob).
Once stack action is performed the following facts will be false: clear(underob), holding(ob).
To perform unstack action, the following facts need to be true: (on(ob, underob) and clear(ob) and handempty).
Once unstack action is performed the following facts will be true: holding(ob), clear(underob).
Once unstack action is performed the following facts will be false: on(ob, underob), clear(ob), handempty.
Everything is false by default
[STATEMENT]
As initial conditions I have that, handempty, on(a, d), ontable(b), on(c, a), on(d, b), clear(c).
My goal is to have that on(c, b). | unstack(c,a)
put-down(c)
unstack(a,d)
put-down(a)
unstack(d,b)
put-down(d)
pick-up(c)
stack(c,b) | 368 |
(define (domain blocksworld-4ops)
(:requirements :strips)
(:predicates (clear ?x)
(ontable ?x)
(handempty)
(holding ?x)
(on ?x ?y))
(:action pick-up
:parameters (?ob)
:precondition (and (clear ?ob) (ontable ?ob) (handempty))
:effect (and (holding ?ob) (not (clear ?ob)) (not (ontable ?ob))
(not (handempty))))
(:action put-down
:parameters (?ob)
:precondition (holding ?ob)
:effect (and (clear ?ob) (handempty) (ontable ?ob)
(not (holding ?ob))))
(:action stack
:parameters (?ob ?underob)
:precondition (and (clear ?underob) (holding ?ob))
:effect (and (handempty) (clear ?ob) (on ?ob ?underob)
(not (clear ?underob)) (not (holding ?ob))))
(:action unstack
:parameters (?ob ?underob)
:precondition (and (on ?ob ?underob) (clear ?ob) (handempty))
:effect (and (holding ?ob) (clear ?underob)
(not (on ?ob ?underob)) (not (clear ?ob)) (not (handempty)))))
|
(define (problem BW-rand-4)
(:domain blocksworld-4ops)
(:objects a b c d )
(:init
(handempty)
(ontable a)
(on b a)
(ontable c)
(on d b)
(clear c)
(clear d)
)
(:goal
(and
(on b c)
(on c a)
(on d b))
)
)
| status: SOLVED_SATISFICING
engine: Pyperplan
plan: SequentialPlan:
unstack(d, b)
put-down(d)
unstack(b, a)
put-down(b)
pick-up(d)
stack(d, b)
pick-up(c)
stack(c, a)
unstack(d, b)
put-down(d)
pick-up(b)
stack(b, c)
pick-up(d)
stack(d, b) | SequentialPlan:
unstack(d, b)
put-down(d)
unstack(b, a)
put-down(b)
pick-up(d)
stack(d, b)
pick-up(c)
stack(c, a)
unstack(d, b)
put-down(d)
pick-up(b)
stack(b, c)
pick-up(d)
stack(d, b) | 14 | I am playing with a set of objects.
Here are the actions I can do:
pick-up with ob
put-down with ob
stack with ob, underob
unstack with ob, underob
I have the following restrictions on my actions:
To perform pick-up action, the following facts need to be true: (clear(ob) and ontable(ob) and handempty).
Once pick-up action is performed the following facts will be true: holding(ob).
Once pick-up action is performed the following facts will be false: clear(ob), ontable(ob), handempty.
To perform put-down action, the following facts need to be true: holding(ob).
Once put-down action is performed the following facts will be true: clear(ob), handempty, ontable(ob).
Once put-down action is performed the following facts will be false: holding(ob).
To perform stack action, the following facts need to be true: (clear(underob) and holding(ob)).
Once stack action is performed the following facts will be true: handempty, clear(ob), on(ob, underob).
Once stack action is performed the following facts will be false: clear(underob), holding(ob).
To perform unstack action, the following facts need to be true: (on(ob, underob) and clear(ob) and handempty).
Once unstack action is performed the following facts will be true: holding(ob), clear(underob).
Once unstack action is performed the following facts will be false: on(ob, underob), clear(ob), handempty.
[STATEMENT]
As initial conditions I have that, handempty, ontable(a), on(b, a), ontable(c), on(d, b), clear(c), clear(d).
My goal is to have that (on(b, c) and on(c, a) and on(d, b)). | unstack(d,b)
put-down(d)
unstack(b,a)
put-down(b)
pick-up(d)
stack(d,b)
pick-up(c)
stack(c,a)
unstack(d,b)
put-down(d)
pick-up(b)
stack(b,c)
pick-up(d)
stack(d,b) | 377 |
(define (domain blocksworld-4ops)
(:requirements :strips)
(:predicates (clear ?x)
(ontable ?x)
(handempty)
(holding ?x)
(on ?x ?y))
(:action pick-up
:parameters (?ob)
:precondition (and (clear ?ob) (ontable ?ob) (handempty))
:effect (and (holding ?ob) (not (clear ?ob)) (not (ontable ?ob))
(not (handempty))))
(:action put-down
:parameters (?ob)
:precondition (holding ?ob)
:effect (and (clear ?ob) (handempty) (ontable ?ob)
(not (holding ?ob))))
(:action stack
:parameters (?ob ?underob)
:precondition (and (clear ?underob) (holding ?ob))
:effect (and (handempty) (clear ?ob) (on ?ob ?underob)
(not (clear ?underob)) (not (holding ?ob))))
(:action unstack
:parameters (?ob ?underob)
:precondition (and (on ?ob ?underob) (clear ?ob) (handempty))
:effect (and (holding ?ob) (clear ?underob)
(not (on ?ob ?underob)) (not (clear ?ob)) (not (handempty)))))
|
(define (problem BW-rand-4)
(:domain blocksworld-4ops)
(:objects a b c d )
(:init
(handempty)
(ontable a)
(ontable b)
(on c a)
(on d c)
(clear b)
(clear d)
)
(:goal
(and
(on a b)
(on c d)
(on d a))
)
)
| status: SOLVED_SATISFICING
engine: Pyperplan
plan: SequentialPlan:
unstack(d, c)
put-down(d)
unstack(c, a)
stack(c, d)
pick-up(a)
stack(a, b)
unstack(c, d)
put-down(c)
pick-up(d)
stack(d, a)
pick-up(c)
stack(c, d) | SequentialPlan:
unstack(d, c)
put-down(d)
unstack(c, a)
stack(c, d)
pick-up(a)
stack(a, b)
unstack(c, d)
put-down(c)
pick-up(d)
stack(d, a)
pick-up(c)
stack(c, d) | 12 | I am playing with a set of objects.
Here are the actions I can do:
pick-up with ob
put-down with ob
stack with ob, underob
unstack with ob, underob
I have the following restrictions on my actions:
To perform pick-up action, the following facts need to be true: (clear(ob) and ontable(ob) and handempty).
Once pick-up action is performed the following facts will be true: holding(ob).
Once pick-up action is performed the following facts will be false: clear(ob), ontable(ob), handempty.
To perform put-down action, the following facts need to be true: holding(ob).
Once put-down action is performed the following facts will be true: clear(ob), handempty, ontable(ob).
Once put-down action is performed the following facts will be false: holding(ob).
To perform stack action, the following facts need to be true: (clear(underob) and holding(ob)).
Once stack action is performed the following facts will be true: handempty, clear(ob), on(ob, underob).
Once stack action is performed the following facts will be false: clear(underob), holding(ob).
To perform unstack action, the following facts need to be true: (on(ob, underob) and clear(ob) and handempty).
Once unstack action is performed the following facts will be true: holding(ob), clear(underob).
Once unstack action is performed the following facts will be false: on(ob, underob), clear(ob), handempty.
Everything is false by default
[STATEMENT]
As initial conditions I have that, handempty, ontable(a), ontable(b), on(c, a), on(d, c), clear(b), clear(d).
My goal is to have that (on(a, b) and on(c, d) and on(d, a)). | unstack(d,c)
put-down(d)
unstack(c,a)
stack(c,d)
pick-up(a)
stack(a,b)
unstack(c,d)
put-down(c)
pick-up(d)
stack(d,a)
pick-up(c)
stack(c,d) | 383 |
(define (domain blocksworld-4ops)
(:requirements :strips)
(:predicates (clear ?x)
(ontable ?x)
(handempty)
(holding ?x)
(on ?x ?y))
(:action pick-up
:parameters (?ob)
:precondition (and (clear ?ob) (ontable ?ob) (handempty))
:effect (and (holding ?ob) (not (clear ?ob)) (not (ontable ?ob))
(not (handempty))))
(:action put-down
:parameters (?ob)
:precondition (holding ?ob)
:effect (and (clear ?ob) (handempty) (ontable ?ob)
(not (holding ?ob))))
(:action stack
:parameters (?ob ?underob)
:precondition (and (clear ?underob) (holding ?ob))
:effect (and (handempty) (clear ?ob) (on ?ob ?underob)
(not (clear ?underob)) (not (holding ?ob))))
(:action unstack
:parameters (?ob ?underob)
:precondition (and (on ?ob ?underob) (clear ?ob) (handempty))
:effect (and (holding ?ob) (clear ?underob)
(not (on ?ob ?underob)) (not (clear ?ob)) (not (handempty)))))
|
(define (problem BW-rand-4)
(:domain blocksworld-4ops)
(:objects a b c d )
(:init
(handempty)
(on a b)
(on b c)
(on c d)
(ontable d)
(clear a)
)
(:goal
(and
(on a c)
(on c b))
)
)
| status: SOLVED_SATISFICING
engine: Pyperplan
plan: SequentialPlan:
unstack(a, b)
put-down(a)
unstack(b, c)
put-down(b)
unstack(c, d)
stack(c, b)
pick-up(a)
stack(a, c) | SequentialPlan:
unstack(a, b)
put-down(a)
unstack(b, c)
put-down(b)
unstack(c, d)
stack(c, b)
pick-up(a)
stack(a, c) | 8 | I am playing with a set of objects.
Here are the actions I can do:
pick-up with ob
put-down with ob
stack with ob, underob
unstack with ob, underob
I have the following restrictions on my actions:
To perform pick-up action, the following facts need to be true: (clear(ob) and ontable(ob) and handempty).
Once pick-up action is performed the following facts will be true: holding(ob).
Once pick-up action is performed the following facts will be false: clear(ob), ontable(ob), handempty.
To perform put-down action, the following facts need to be true: holding(ob).
Once put-down action is performed the following facts will be true: clear(ob), handempty, ontable(ob).
Once put-down action is performed the following facts will be false: holding(ob).
To perform stack action, the following facts need to be true: (clear(underob) and holding(ob)).
Once stack action is performed the following facts will be true: handempty, clear(ob), on(ob, underob).
Once stack action is performed the following facts will be false: clear(underob), holding(ob).
To perform unstack action, the following facts need to be true: (on(ob, underob) and clear(ob) and handempty).
Once unstack action is performed the following facts will be true: holding(ob), clear(underob).
Once unstack action is performed the following facts will be false: on(ob, underob), clear(ob), handempty.
[STATEMENT]
As initial conditions I have that, handempty, on(a, b), on(b, c), on(c, d), ontable(d), clear(a).
My goal is to have that (on(a, c) and on(c, b)). | unstack(a,b)
put-down(a)
unstack(b,c)
put-down(b)
unstack(c,d)
stack(c,b)
pick-up(a)
stack(a,c) | 369 |
(define (domain blocksworld-4ops)
(:requirements :strips)
(:predicates (clear ?x)
(ontable ?x)
(handempty)
(holding ?x)
(on ?x ?y))
(:action pick-up
:parameters (?ob)
:precondition (and (clear ?ob) (ontable ?ob) (handempty))
:effect (and (holding ?ob) (not (clear ?ob)) (not (ontable ?ob))
(not (handempty))))
(:action put-down
:parameters (?ob)
:precondition (holding ?ob)
:effect (and (clear ?ob) (handempty) (ontable ?ob)
(not (holding ?ob))))
(:action stack
:parameters (?ob ?underob)
:precondition (and (clear ?underob) (holding ?ob))
:effect (and (handempty) (clear ?ob) (on ?ob ?underob)
(not (clear ?underob)) (not (holding ?ob))))
(:action unstack
:parameters (?ob ?underob)
:precondition (and (on ?ob ?underob) (clear ?ob) (handempty))
:effect (and (holding ?ob) (clear ?underob)
(not (on ?ob ?underob)) (not (clear ?ob)) (not (handempty)))))
|
(define (problem BW-rand-4)
(:domain blocksworld-4ops)
(:objects a b c d )
(:init
(handempty)
(ontable a)
(ontable b)
(ontable c)
(on d c)
(clear a)
(clear b)
(clear d)
)
(:goal
(and
(on c d))
)
)
| status: SOLVED_SATISFICING
engine: Pyperplan
plan: SequentialPlan:
unstack(d, c)
put-down(d)
pick-up(c)
stack(c, d) | SequentialPlan:
unstack(d, c)
put-down(d)
pick-up(c)
stack(c, d) | 4 | I am playing with a set of objects.
Here are the actions I can do:
pick-up with ob
put-down with ob
stack with ob, underob
unstack with ob, underob
I have the following restrictions on my actions:
To perform pick-up action, the following facts need to be true: (clear(ob) and ontable(ob) and handempty).
Once pick-up action is performed the following facts will be true: holding(ob).
Once pick-up action is performed the following facts will be false: clear(ob), ontable(ob), handempty.
To perform put-down action, the following facts need to be true: holding(ob).
Once put-down action is performed the following facts will be true: clear(ob), handempty, ontable(ob).
Once put-down action is performed the following facts will be false: holding(ob).
To perform stack action, the following facts need to be true: (clear(underob) and holding(ob)).
Once stack action is performed the following facts will be true: handempty, clear(ob), on(ob, underob).
Once stack action is performed the following facts will be false: clear(underob), holding(ob).
To perform unstack action, the following facts need to be true: (on(ob, underob) and clear(ob) and handempty).
Once unstack action is performed the following facts will be true: holding(ob), clear(underob).
Once unstack action is performed the following facts will be false: on(ob, underob), clear(ob), handempty.
Everything is false by default
[STATEMENT]
As initial conditions I have that, handempty, ontable(a), ontable(b), ontable(c), on(d, c), clear(a), clear(b), clear(d).
My goal is to have that on(c, d). | unstack(d,c)
put-down(d)
pick-up(c)
stack(c,d) | 372 |
(define (domain blocksworld-4ops)
(:requirements :strips)
(:predicates (clear ?x)
(ontable ?x)
(handempty)
(holding ?x)
(on ?x ?y))
(:action pick-up
:parameters (?ob)
:precondition (and (clear ?ob) (ontable ?ob) (handempty))
:effect (and (holding ?ob) (not (clear ?ob)) (not (ontable ?ob))
(not (handempty))))
(:action put-down
:parameters (?ob)
:precondition (holding ?ob)
:effect (and (clear ?ob) (handempty) (ontable ?ob)
(not (holding ?ob))))
(:action stack
:parameters (?ob ?underob)
:precondition (and (clear ?underob) (holding ?ob))
:effect (and (handempty) (clear ?ob) (on ?ob ?underob)
(not (clear ?underob)) (not (holding ?ob))))
(:action unstack
:parameters (?ob ?underob)
:precondition (and (on ?ob ?underob) (clear ?ob) (handempty))
:effect (and (holding ?ob) (clear ?underob)
(not (on ?ob ?underob)) (not (clear ?ob)) (not (handempty)))))
|
(define (problem BW-rand-4)
(:domain blocksworld-4ops)
(:objects a b c d )
(:init
(handempty)
(ontable a)
(ontable b)
(ontable c)
(on d a)
(clear b)
(clear c)
(clear d)
)
(:goal
(and
(on a c)
(on b a)
(on c d))
)
)
| status: SOLVED_SATISFICING
engine: Pyperplan
plan: SequentialPlan:
unstack(d, a)
put-down(d)
pick-up(b)
stack(b, a)
pick-up(c)
stack(c, d)
unstack(b, a)
put-down(b)
pick-up(a)
stack(a, c)
pick-up(b)
stack(b, a) | SequentialPlan:
unstack(d, a)
put-down(d)
pick-up(b)
stack(b, a)
pick-up(c)
stack(c, d)
unstack(b, a)
put-down(b)
pick-up(a)
stack(a, c)
pick-up(b)
stack(b, a) | 12 | I am playing with a set of objects.
Here are the actions I can do:
pick-up with ob
put-down with ob
stack with ob, underob
unstack with ob, underob
I have the following restrictions on my actions:
To perform pick-up action, the following facts need to be true: (clear(ob) and ontable(ob) and handempty).
Once pick-up action is performed the following facts will be true: holding(ob).
Once pick-up action is performed the following facts will be false: clear(ob), ontable(ob), handempty.
To perform put-down action, the following facts need to be true: holding(ob).
Once put-down action is performed the following facts will be true: clear(ob), handempty, ontable(ob).
Once put-down action is performed the following facts will be false: holding(ob).
To perform stack action, the following facts need to be true: (clear(underob) and holding(ob)).
Once stack action is performed the following facts will be true: handempty, clear(ob), on(ob, underob).
Once stack action is performed the following facts will be false: clear(underob), holding(ob).
To perform unstack action, the following facts need to be true: (on(ob, underob) and clear(ob) and handempty).
Once unstack action is performed the following facts will be true: holding(ob), clear(underob).
Once unstack action is performed the following facts will be false: on(ob, underob), clear(ob), handempty.
[STATEMENT]
As initial conditions I have that, handempty, ontable(a), ontable(b), ontable(c), on(d, a), clear(b), clear(c), clear(d).
My goal is to have that (on(a, c) and on(b, a) and on(c, d)). | unstack(d,a)
put-down(d)
pick-up(b)
stack(b,a)
pick-up(c)
stack(c,d)
unstack(b,a)
put-down(b)
pick-up(a)
stack(a,c)
pick-up(b)
stack(b,a) | 379 |
(define (domain blocksworld-4ops)
(:requirements :strips)
(:predicates (clear ?x)
(ontable ?x)
(handempty)
(holding ?x)
(on ?x ?y))
(:action pick-up
:parameters (?ob)
:precondition (and (clear ?ob) (ontable ?ob) (handempty))
:effect (and (holding ?ob) (not (clear ?ob)) (not (ontable ?ob))
(not (handempty))))
(:action put-down
:parameters (?ob)
:precondition (holding ?ob)
:effect (and (clear ?ob) (handempty) (ontable ?ob)
(not (holding ?ob))))
(:action stack
:parameters (?ob ?underob)
:precondition (and (clear ?underob) (holding ?ob))
:effect (and (handempty) (clear ?ob) (on ?ob ?underob)
(not (clear ?underob)) (not (holding ?ob))))
(:action unstack
:parameters (?ob ?underob)
:precondition (and (on ?ob ?underob) (clear ?ob) (handempty))
:effect (and (holding ?ob) (clear ?underob)
(not (on ?ob ?underob)) (not (clear ?ob)) (not (handempty)))))
|
(define (problem BW-rand-4)
(:domain blocksworld-4ops)
(:objects a b c d )
(:init
(handempty)
(on a d)
(on b a)
(ontable c)
(on d c)
(clear b)
)
(:goal
(and
(on a d)
(on c b)
(on d c))
)
)
| status: SOLVED_SATISFICING
engine: Pyperplan
plan: SequentialPlan:
unstack(b, a)
put-down(b)
unstack(a, d)
put-down(a)
unstack(d, c)
put-down(d)
pick-up(a)
stack(a, d)
pick-up(c)
stack(c, b)
unstack(a, d)
put-down(a)
pick-up(d)
stack(d, c)
pick-up(a)
stack(a, d) | SequentialPlan:
unstack(b, a)
put-down(b)
unstack(a, d)
put-down(a)
unstack(d, c)
put-down(d)
pick-up(a)
stack(a, d)
pick-up(c)
stack(c, b)
unstack(a, d)
put-down(a)
pick-up(d)
stack(d, c)
pick-up(a)
stack(a, d) | 16 | I am playing with a set of objects.
Here are the actions I can do:
pick-up with ob
put-down with ob
stack with ob, underob
unstack with ob, underob
I have the following restrictions on my actions:
To perform pick-up action, the following facts need to be true: (clear(ob) and ontable(ob) and handempty).
Once pick-up action is performed the following facts will be true: holding(ob).
Once pick-up action is performed the following facts will be false: clear(ob), ontable(ob), handempty.
To perform put-down action, the following facts need to be true: holding(ob).
Once put-down action is performed the following facts will be true: clear(ob), handempty, ontable(ob).
Once put-down action is performed the following facts will be false: holding(ob).
To perform stack action, the following facts need to be true: (clear(underob) and holding(ob)).
Once stack action is performed the following facts will be true: handempty, clear(ob), on(ob, underob).
Once stack action is performed the following facts will be false: clear(underob), holding(ob).
To perform unstack action, the following facts need to be true: (on(ob, underob) and clear(ob) and handempty).
Once unstack action is performed the following facts will be true: holding(ob), clear(underob).
Once unstack action is performed the following facts will be false: on(ob, underob), clear(ob), handempty.
[STATEMENT]
As initial conditions I have that, handempty, on(a, d), on(b, a), ontable(c), on(d, c), clear(b).
My goal is to have that (on(a, d) and on(c, b) and on(d, c)). | unstack(b,a)
put-down(b)
unstack(a,d)
put-down(a)
unstack(d,c)
put-down(d)
pick-up(a)
stack(a,d)
pick-up(c)
stack(c,b)
unstack(a,d)
put-down(a)
pick-up(d)
stack(d,c)
pick-up(a)
stack(a,d) | 375 |
(define (domain blocksworld-4ops)
(:requirements :strips)
(:predicates (clear ?x)
(ontable ?x)
(handempty)
(holding ?x)
(on ?x ?y))
(:action pick-up
:parameters (?ob)
:precondition (and (clear ?ob) (ontable ?ob) (handempty))
:effect (and (holding ?ob) (not (clear ?ob)) (not (ontable ?ob))
(not (handempty))))
(:action put-down
:parameters (?ob)
:precondition (holding ?ob)
:effect (and (clear ?ob) (handempty) (ontable ?ob)
(not (holding ?ob))))
(:action stack
:parameters (?ob ?underob)
:precondition (and (clear ?underob) (holding ?ob))
:effect (and (handempty) (clear ?ob) (on ?ob ?underob)
(not (clear ?underob)) (not (holding ?ob))))
(:action unstack
:parameters (?ob ?underob)
:precondition (and (on ?ob ?underob) (clear ?ob) (handempty))
:effect (and (holding ?ob) (clear ?underob)
(not (on ?ob ?underob)) (not (clear ?ob)) (not (handempty)))))
|
(define (problem BW-rand-4)
(:domain blocksworld-4ops)
(:objects a b c d )
(:init
(handempty)
(ontable a)
(on b a)
(on c d)
(on d b)
(clear c)
)
(:goal
(and
(on a c)
(on d b))
)
)
| status: SOLVED_SATISFICING
engine: Pyperplan
plan: SequentialPlan:
unstack(c, d)
put-down(c)
unstack(d, b)
put-down(d)
unstack(b, a)
put-down(b)
pick-up(a)
stack(a, c)
pick-up(d)
stack(d, b) | SequentialPlan:
unstack(c, d)
put-down(c)
unstack(d, b)
put-down(d)
unstack(b, a)
put-down(b)
pick-up(a)
stack(a, c)
pick-up(d)
stack(d, b) | 10 | I am playing with a set of objects.
Here are the actions I can do:
pick-up with ob
put-down with ob
stack with ob, underob
unstack with ob, underob
I have the following restrictions on my actions:
To perform pick-up action, the following facts need to be true: (clear(ob) and ontable(ob) and handempty).
Once pick-up action is performed the following facts will be true: holding(ob).
Once pick-up action is performed the following facts will be false: clear(ob), ontable(ob), handempty.
To perform put-down action, the following facts need to be true: holding(ob).
Once put-down action is performed the following facts will be true: clear(ob), handempty, ontable(ob).
Once put-down action is performed the following facts will be false: holding(ob).
To perform stack action, the following facts need to be true: (clear(underob) and holding(ob)).
Once stack action is performed the following facts will be true: handempty, clear(ob), on(ob, underob).
Once stack action is performed the following facts will be false: clear(underob), holding(ob).
To perform unstack action, the following facts need to be true: (on(ob, underob) and clear(ob) and handempty).
Once unstack action is performed the following facts will be true: holding(ob), clear(underob).
Once unstack action is performed the following facts will be false: on(ob, underob), clear(ob), handempty.
Everything is false by default
[STATEMENT]
As initial conditions I have that, handempty, ontable(a), on(b, a), on(c, d), on(d, b), clear(c).
My goal is to have that (on(a, c) and on(d, b)). | unstack(c,d)
put-down(c)
unstack(d,b)
put-down(d)
unstack(b,a)
put-down(b)
pick-up(a)
stack(a,c)
pick-up(d)
stack(d,b) | 375 |
(define (domain blocksworld-4ops)
(:requirements :strips)
(:predicates (clear ?x)
(ontable ?x)
(handempty)
(holding ?x)
(on ?x ?y))
(:action pick-up
:parameters (?ob)
:precondition (and (clear ?ob) (ontable ?ob) (handempty))
:effect (and (holding ?ob) (not (clear ?ob)) (not (ontable ?ob))
(not (handempty))))
(:action put-down
:parameters (?ob)
:precondition (holding ?ob)
:effect (and (clear ?ob) (handempty) (ontable ?ob)
(not (holding ?ob))))
(:action stack
:parameters (?ob ?underob)
:precondition (and (clear ?underob) (holding ?ob))
:effect (and (handempty) (clear ?ob) (on ?ob ?underob)
(not (clear ?underob)) (not (holding ?ob))))
(:action unstack
:parameters (?ob ?underob)
:precondition (and (on ?ob ?underob) (clear ?ob) (handempty))
:effect (and (holding ?ob) (clear ?underob)
(not (on ?ob ?underob)) (not (clear ?ob)) (not (handempty)))))
|
(define (problem BW-rand-4)
(:domain blocksworld-4ops)
(:objects a b c d )
(:init
(handempty)
(ontable a)
(ontable b)
(on c a)
(ontable d)
(clear b)
(clear c)
(clear d)
)
(:goal
(and
(on a b))
)
)
| status: SOLVED_SATISFICING
engine: Pyperplan
plan: SequentialPlan:
unstack(c, a)
put-down(c)
pick-up(a)
stack(a, b) | SequentialPlan:
unstack(c, a)
put-down(c)
pick-up(a)
stack(a, b) | 4 | I am playing with a set of objects.
Here are the actions I can do:
pick-up with ob
put-down with ob
stack with ob, underob
unstack with ob, underob
I have the following restrictions on my actions:
To perform pick-up action, the following facts need to be true: (clear(ob) and ontable(ob) and handempty).
Once pick-up action is performed the following facts will be true: holding(ob).
Once pick-up action is performed the following facts will be false: clear(ob), ontable(ob), handempty.
To perform put-down action, the following facts need to be true: holding(ob).
Once put-down action is performed the following facts will be true: clear(ob), handempty, ontable(ob).
Once put-down action is performed the following facts will be false: holding(ob).
To perform stack action, the following facts need to be true: (clear(underob) and holding(ob)).
Once stack action is performed the following facts will be true: handempty, clear(ob), on(ob, underob).
Once stack action is performed the following facts will be false: clear(underob), holding(ob).
To perform unstack action, the following facts need to be true: (on(ob, underob) and clear(ob) and handempty).
Once unstack action is performed the following facts will be true: holding(ob), clear(underob).
Once unstack action is performed the following facts will be false: on(ob, underob), clear(ob), handempty.
Everything is false by default
[STATEMENT]
As initial conditions I have that, handempty, ontable(a), ontable(b), on(c, a), ontable(d), clear(b), clear(c), clear(d).
My goal is to have that on(a, b). | unstack(c,a)
put-down(c)
pick-up(a)
stack(a,b) | 372 |
(define (domain blocksworld-4ops)
(:requirements :strips)
(:predicates (clear ?x)
(ontable ?x)
(handempty)
(holding ?x)
(on ?x ?y))
(:action pick-up
:parameters (?ob)
:precondition (and (clear ?ob) (ontable ?ob) (handempty))
:effect (and (holding ?ob) (not (clear ?ob)) (not (ontable ?ob))
(not (handempty))))
(:action put-down
:parameters (?ob)
:precondition (holding ?ob)
:effect (and (clear ?ob) (handempty) (ontable ?ob)
(not (holding ?ob))))
(:action stack
:parameters (?ob ?underob)
:precondition (and (clear ?underob) (holding ?ob))
:effect (and (handempty) (clear ?ob) (on ?ob ?underob)
(not (clear ?underob)) (not (holding ?ob))))
(:action unstack
:parameters (?ob ?underob)
:precondition (and (on ?ob ?underob) (clear ?ob) (handempty))
:effect (and (holding ?ob) (clear ?underob)
(not (on ?ob ?underob)) (not (clear ?ob)) (not (handempty)))))
|
(define (problem BW-rand-4)
(:domain blocksworld-4ops)
(:objects a b c d )
(:init
(handempty)
(on a b)
(on b c)
(on c d)
(ontable d)
(clear a)
)
(:goal
(and
(on b c)
(on c a)
(on d b))
)
)
| status: SOLVED_SATISFICING
engine: Pyperplan
plan: SequentialPlan:
unstack(a, b)
put-down(a)
unstack(b, c)
put-down(b)
unstack(c, d)
stack(c, a)
pick-up(b)
stack(b, c)
pick-up(d)
stack(d, b) | SequentialPlan:
unstack(a, b)
put-down(a)
unstack(b, c)
put-down(b)
unstack(c, d)
stack(c, a)
pick-up(b)
stack(b, c)
pick-up(d)
stack(d, b) | 10 | I am playing with a set of objects.
Here are the actions I can do:
pick-up with ob
put-down with ob
stack with ob, underob
unstack with ob, underob
I have the following restrictions on my actions:
To perform pick-up action, the following facts need to be true: (clear(ob) and ontable(ob) and handempty).
Once pick-up action is performed the following facts will be true: holding(ob).
Once pick-up action is performed the following facts will be false: clear(ob), ontable(ob), handempty.
To perform put-down action, the following facts need to be true: holding(ob).
Once put-down action is performed the following facts will be true: clear(ob), handempty, ontable(ob).
Once put-down action is performed the following facts will be false: holding(ob).
To perform stack action, the following facts need to be true: (clear(underob) and holding(ob)).
Once stack action is performed the following facts will be true: handempty, clear(ob), on(ob, underob).
Once stack action is performed the following facts will be false: clear(underob), holding(ob).
To perform unstack action, the following facts need to be true: (on(ob, underob) and clear(ob) and handempty).
Once unstack action is performed the following facts will be true: holding(ob), clear(underob).
Once unstack action is performed the following facts will be false: on(ob, underob), clear(ob), handempty.
Everything is false by default
[STATEMENT]
As initial conditions I have that, handempty, on(a, b), on(b, c), on(c, d), ontable(d), clear(a).
My goal is to have that (on(b, c) and on(c, a) and on(d, b)). | unstack(a,b)
put-down(a)
unstack(b,c)
put-down(b)
unstack(c,d)
stack(c,a)
pick-up(b)
stack(b,c)
pick-up(d)
stack(d,b) | 381 |
(define (domain blocksworld-4ops)
(:requirements :strips)
(:predicates (clear ?x)
(ontable ?x)
(handempty)
(holding ?x)
(on ?x ?y))
(:action pick-up
:parameters (?ob)
:precondition (and (clear ?ob) (ontable ?ob) (handempty))
:effect (and (holding ?ob) (not (clear ?ob)) (not (ontable ?ob))
(not (handempty))))
(:action put-down
:parameters (?ob)
:precondition (holding ?ob)
:effect (and (clear ?ob) (handempty) (ontable ?ob)
(not (holding ?ob))))
(:action stack
:parameters (?ob ?underob)
:precondition (and (clear ?underob) (holding ?ob))
:effect (and (handempty) (clear ?ob) (on ?ob ?underob)
(not (clear ?underob)) (not (holding ?ob))))
(:action unstack
:parameters (?ob ?underob)
:precondition (and (on ?ob ?underob) (clear ?ob) (handempty))
:effect (and (holding ?ob) (clear ?underob)
(not (on ?ob ?underob)) (not (clear ?ob)) (not (handempty)))))
|
(define (problem BW-rand-4)
(:domain blocksworld-4ops)
(:objects a b c d )
(:init
(handempty)
(on a c)
(on b d)
(ontable c)
(ontable d)
(clear a)
(clear b)
)
(:goal
(and
(on c b)
(on d c))
)
)
| status: SOLVED_SATISFICING
engine: Pyperplan
plan: SequentialPlan:
unstack(a, c)
put-down(a)
unstack(b, d)
put-down(b)
pick-up(c)
stack(c, b)
pick-up(d)
stack(d, c) | SequentialPlan:
unstack(a, c)
put-down(a)
unstack(b, d)
put-down(b)
pick-up(c)
stack(c, b)
pick-up(d)
stack(d, c) | 8 | I am playing with a set of objects.
Here are the actions I can do:
pick-up with ob
put-down with ob
stack with ob, underob
unstack with ob, underob
I have the following restrictions on my actions:
To perform pick-up action, the following facts need to be true: (clear(ob) and ontable(ob) and handempty).
Once pick-up action is performed the following facts will be true: holding(ob).
Once pick-up action is performed the following facts will be false: clear(ob), ontable(ob), handempty.
To perform put-down action, the following facts need to be true: holding(ob).
Once put-down action is performed the following facts will be true: clear(ob), handempty, ontable(ob).
Once put-down action is performed the following facts will be false: holding(ob).
To perform stack action, the following facts need to be true: (clear(underob) and holding(ob)).
Once stack action is performed the following facts will be true: handempty, clear(ob), on(ob, underob).
Once stack action is performed the following facts will be false: clear(underob), holding(ob).
To perform unstack action, the following facts need to be true: (on(ob, underob) and clear(ob) and handempty).
Once unstack action is performed the following facts will be true: holding(ob), clear(underob).
Once unstack action is performed the following facts will be false: on(ob, underob), clear(ob), handempty.
[STATEMENT]
As initial conditions I have that, handempty, on(a, c), on(b, d), ontable(c), ontable(d), clear(a), clear(b).
My goal is to have that (on(c, b) and on(d, c)). | unstack(a,c)
put-down(a)
unstack(b,d)
put-down(b)
pick-up(c)
stack(c,b)
pick-up(d)
stack(d,c) | 371 |
(define (domain blocksworld-4ops)
(:requirements :strips)
(:predicates (clear ?x)
(ontable ?x)
(handempty)
(holding ?x)
(on ?x ?y))
(:action pick-up
:parameters (?ob)
:precondition (and (clear ?ob) (ontable ?ob) (handempty))
:effect (and (holding ?ob) (not (clear ?ob)) (not (ontable ?ob))
(not (handempty))))
(:action put-down
:parameters (?ob)
:precondition (holding ?ob)
:effect (and (clear ?ob) (handempty) (ontable ?ob)
(not (holding ?ob))))
(:action stack
:parameters (?ob ?underob)
:precondition (and (clear ?underob) (holding ?ob))
:effect (and (handempty) (clear ?ob) (on ?ob ?underob)
(not (clear ?underob)) (not (holding ?ob))))
(:action unstack
:parameters (?ob ?underob)
:precondition (and (on ?ob ?underob) (clear ?ob) (handempty))
:effect (and (holding ?ob) (clear ?underob)
(not (on ?ob ?underob)) (not (clear ?ob)) (not (handempty)))))
|
(define (problem BW-rand-4)
(:domain blocksworld-4ops)
(:objects a b c d )
(:init
(handempty)
(ontable a)
(ontable b)
(ontable c)
(ontable d)
(clear a)
(clear b)
(clear c)
(clear d)
)
(:goal
(and
(on a b)
(on d a))
)
)
| status: SOLVED_SATISFICING
engine: Pyperplan
plan: SequentialPlan:
pick-up(a)
stack(a, b)
pick-up(d)
stack(d, a) | SequentialPlan:
pick-up(a)
stack(a, b)
pick-up(d)
stack(d, a) | 4 | I am playing with a set of objects.
Here are the actions I can do:
pick-up with ob
put-down with ob
stack with ob, underob
unstack with ob, underob
I have the following restrictions on my actions:
To perform pick-up action, the following facts need to be true: (clear(ob) and ontable(ob) and handempty).
Once pick-up action is performed the following facts will be true: holding(ob).
Once pick-up action is performed the following facts will be false: clear(ob), ontable(ob), handempty.
To perform put-down action, the following facts need to be true: holding(ob).
Once put-down action is performed the following facts will be true: clear(ob), handempty, ontable(ob).
Once put-down action is performed the following facts will be false: holding(ob).
To perform stack action, the following facts need to be true: (clear(underob) and holding(ob)).
Once stack action is performed the following facts will be true: handempty, clear(ob), on(ob, underob).
Once stack action is performed the following facts will be false: clear(underob), holding(ob).
To perform unstack action, the following facts need to be true: (on(ob, underob) and clear(ob) and handempty).
Once unstack action is performed the following facts will be true: holding(ob), clear(underob).
Once unstack action is performed the following facts will be false: on(ob, underob), clear(ob), handempty.
Everything is false by default
[STATEMENT]
As initial conditions I have that, handempty, ontable(a), ontable(b), ontable(c), ontable(d), clear(a), clear(b), clear(c), clear(d).
My goal is to have that (on(a, b) and on(d, a)). | pick-up(a)
stack(a,b)
pick-up(d)
stack(d,a) | 381 |
(define (domain blocksworld-4ops)
(:requirements :strips)
(:predicates (clear ?x)
(ontable ?x)
(handempty)
(holding ?x)
(on ?x ?y))
(:action pick-up
:parameters (?ob)
:precondition (and (clear ?ob) (ontable ?ob) (handempty))
:effect (and (holding ?ob) (not (clear ?ob)) (not (ontable ?ob))
(not (handempty))))
(:action put-down
:parameters (?ob)
:precondition (holding ?ob)
:effect (and (clear ?ob) (handempty) (ontable ?ob)
(not (holding ?ob))))
(:action stack
:parameters (?ob ?underob)
:precondition (and (clear ?underob) (holding ?ob))
:effect (and (handempty) (clear ?ob) (on ?ob ?underob)
(not (clear ?underob)) (not (holding ?ob))))
(:action unstack
:parameters (?ob ?underob)
:precondition (and (on ?ob ?underob) (clear ?ob) (handempty))
:effect (and (holding ?ob) (clear ?underob)
(not (on ?ob ?underob)) (not (clear ?ob)) (not (handempty)))))
|
(define (problem BW-rand-4)
(:domain blocksworld-4ops)
(:objects a b c d )
(:init
(handempty)
(ontable a)
(ontable b)
(on c d)
(on d b)
(clear a)
(clear c)
)
(:goal
(and
(on a d)
(on c a))
)
)
| status: SOLVED_SATISFICING
engine: Pyperplan
plan: SequentialPlan:
unstack(c, d)
put-down(c)
pick-up(a)
stack(a, d)
pick-up(c)
stack(c, a) | SequentialPlan:
unstack(c, d)
put-down(c)
pick-up(a)
stack(a, d)
pick-up(c)
stack(c, a) | 6 | I am playing with a set of objects.
Here are the actions I can do:
pick-up with ob
put-down with ob
stack with ob, underob
unstack with ob, underob
I have the following restrictions on my actions:
To perform pick-up action, the following facts need to be true: (clear(ob) and ontable(ob) and handempty).
Once pick-up action is performed the following facts will be true: holding(ob).
Once pick-up action is performed the following facts will be false: clear(ob), ontable(ob), handempty.
To perform put-down action, the following facts need to be true: holding(ob).
Once put-down action is performed the following facts will be true: clear(ob), handempty, ontable(ob).
Once put-down action is performed the following facts will be false: holding(ob).
To perform stack action, the following facts need to be true: (clear(underob) and holding(ob)).
Once stack action is performed the following facts will be true: handempty, clear(ob), on(ob, underob).
Once stack action is performed the following facts will be false: clear(underob), holding(ob).
To perform unstack action, the following facts need to be true: (on(ob, underob) and clear(ob) and handempty).
Once unstack action is performed the following facts will be true: holding(ob), clear(underob).
Once unstack action is performed the following facts will be false: on(ob, underob), clear(ob), handempty.
Everything is false by default
[STATEMENT]
As initial conditions I have that, handempty, ontable(a), ontable(b), on(c, d), on(d, b), clear(a), clear(c).
My goal is to have that (on(a, d) and on(c, a)). | unstack(c,d)
put-down(c)
pick-up(a)
stack(a,d)
pick-up(c)
stack(c,a) | 377 |
(define (domain blocksworld-4ops)
(:requirements :strips)
(:predicates (clear ?x)
(ontable ?x)
(handempty)
(holding ?x)
(on ?x ?y))
(:action pick-up
:parameters (?ob)
:precondition (and (clear ?ob) (ontable ?ob) (handempty))
:effect (and (holding ?ob) (not (clear ?ob)) (not (ontable ?ob))
(not (handempty))))
(:action put-down
:parameters (?ob)
:precondition (holding ?ob)
:effect (and (clear ?ob) (handempty) (ontable ?ob)
(not (holding ?ob))))
(:action stack
:parameters (?ob ?underob)
:precondition (and (clear ?underob) (holding ?ob))
:effect (and (handempty) (clear ?ob) (on ?ob ?underob)
(not (clear ?underob)) (not (holding ?ob))))
(:action unstack
:parameters (?ob ?underob)
:precondition (and (on ?ob ?underob) (clear ?ob) (handempty))
:effect (and (holding ?ob) (clear ?underob)
(not (on ?ob ?underob)) (not (clear ?ob)) (not (handempty)))))
|
(define (problem BW-rand-4)
(:domain blocksworld-4ops)
(:objects a b c d )
(:init
(handempty)
(on a c)
(on b a)
(ontable c)
(on d b)
(clear d)
)
(:goal
(and
(on a b)
(on b c)
(on d a))
)
)
| status: SOLVED_SATISFICING
engine: Pyperplan
plan: SequentialPlan:
unstack(d, b)
put-down(d)
unstack(b, a)
put-down(b)
unstack(a, c)
put-down(a)
pick-up(d)
stack(d, a)
pick-up(b)
stack(b, c)
unstack(d, a)
put-down(d)
pick-up(a)
stack(a, b)
pick-up(d)
stack(d, a) | SequentialPlan:
unstack(d, b)
put-down(d)
unstack(b, a)
put-down(b)
unstack(a, c)
put-down(a)
pick-up(d)
stack(d, a)
pick-up(b)
stack(b, c)
unstack(d, a)
put-down(d)
pick-up(a)
stack(a, b)
pick-up(d)
stack(d, a) | 16 | I am playing with a set of objects.
Here are the actions I can do:
pick-up with ob
put-down with ob
stack with ob, underob
unstack with ob, underob
I have the following restrictions on my actions:
To perform pick-up action, the following facts need to be true: (clear(ob) and ontable(ob) and handempty).
Once pick-up action is performed the following facts will be true: holding(ob).
Once pick-up action is performed the following facts will be false: clear(ob), ontable(ob), handempty.
To perform put-down action, the following facts need to be true: holding(ob).
Once put-down action is performed the following facts will be true: clear(ob), handempty, ontable(ob).
Once put-down action is performed the following facts will be false: holding(ob).
To perform stack action, the following facts need to be true: (clear(underob) and holding(ob)).
Once stack action is performed the following facts will be true: handempty, clear(ob), on(ob, underob).
Once stack action is performed the following facts will be false: clear(underob), holding(ob).
To perform unstack action, the following facts need to be true: (on(ob, underob) and clear(ob) and handempty).
Once unstack action is performed the following facts will be true: holding(ob), clear(underob).
Once unstack action is performed the following facts will be false: on(ob, underob), clear(ob), handempty.
Everything is false by default
[STATEMENT]
As initial conditions I have that, handempty, on(a, c), on(b, a), ontable(c), on(d, b), clear(d).
My goal is to have that (on(a, b) and on(b, c) and on(d, a)). | unstack(d,b)
put-down(d)
unstack(b,a)
put-down(b)
unstack(a,c)
put-down(a)
pick-up(d)
stack(d,a)
pick-up(b)
stack(b,c)
unstack(d,a)
put-down(d)
pick-up(a)
stack(a,b)
pick-up(d)
stack(d,a) | 381 |
(define (domain blocksworld-4ops)
(:requirements :strips)
(:predicates (clear ?x)
(ontable ?x)
(handempty)
(holding ?x)
(on ?x ?y))
(:action pick-up
:parameters (?ob)
:precondition (and (clear ?ob) (ontable ?ob) (handempty))
:effect (and (holding ?ob) (not (clear ?ob)) (not (ontable ?ob))
(not (handempty))))
(:action put-down
:parameters (?ob)
:precondition (holding ?ob)
:effect (and (clear ?ob) (handempty) (ontable ?ob)
(not (holding ?ob))))
(:action stack
:parameters (?ob ?underob)
:precondition (and (clear ?underob) (holding ?ob))
:effect (and (handempty) (clear ?ob) (on ?ob ?underob)
(not (clear ?underob)) (not (holding ?ob))))
(:action unstack
:parameters (?ob ?underob)
:precondition (and (on ?ob ?underob) (clear ?ob) (handempty))
:effect (and (holding ?ob) (clear ?underob)
(not (on ?ob ?underob)) (not (clear ?ob)) (not (handempty)))))
|
(define (problem BW-rand-4)
(:domain blocksworld-4ops)
(:objects a b c d )
(:init
(handempty)
(on a c)
(ontable b)
(on c b)
(ontable d)
(clear a)
(clear d)
)
(:goal
(and
(on b c)
(on c d)
(on d a))
)
)
| status: SOLVED_SATISFICING
engine: Pyperplan
plan: SequentialPlan:
unstack(a, c)
put-down(a)
unstack(c, b)
put-down(c)
pick-up(b)
stack(b, c)
pick-up(d)
stack(d, a)
unstack(b, c)
put-down(b)
pick-up(c)
stack(c, d)
pick-up(b)
stack(b, c) | SequentialPlan:
unstack(a, c)
put-down(a)
unstack(c, b)
put-down(c)
pick-up(b)
stack(b, c)
pick-up(d)
stack(d, a)
unstack(b, c)
put-down(b)
pick-up(c)
stack(c, d)
pick-up(b)
stack(b, c) | 14 | I am playing with a set of objects.
Here are the actions I can do:
pick-up with ob
put-down with ob
stack with ob, underob
unstack with ob, underob
I have the following restrictions on my actions:
To perform pick-up action, the following facts need to be true: (clear(ob) and ontable(ob) and handempty).
Once pick-up action is performed the following facts will be true: holding(ob).
Once pick-up action is performed the following facts will be false: clear(ob), ontable(ob), handempty.
To perform put-down action, the following facts need to be true: holding(ob).
Once put-down action is performed the following facts will be true: clear(ob), handempty, ontable(ob).
Once put-down action is performed the following facts will be false: holding(ob).
To perform stack action, the following facts need to be true: (clear(underob) and holding(ob)).
Once stack action is performed the following facts will be true: handempty, clear(ob), on(ob, underob).
Once stack action is performed the following facts will be false: clear(underob), holding(ob).
To perform unstack action, the following facts need to be true: (on(ob, underob) and clear(ob) and handempty).
Once unstack action is performed the following facts will be true: holding(ob), clear(underob).
Once unstack action is performed the following facts will be false: on(ob, underob), clear(ob), handempty.
Everything is false by default
[STATEMENT]
As initial conditions I have that, handempty, on(a, c), ontable(b), on(c, b), ontable(d), clear(a), clear(d).
My goal is to have that (on(b, c) and on(c, d) and on(d, a)). | unstack(a,c)
put-down(a)
unstack(c,b)
put-down(c)
pick-up(b)
stack(b,c)
pick-up(d)
stack(d,a)
unstack(b,c)
put-down(b)
pick-up(c)
stack(c,d)
pick-up(b)
stack(b,c) | 383 |
(define (domain blocksworld-4ops)
(:requirements :strips)
(:predicates (clear ?x)
(ontable ?x)
(handempty)
(holding ?x)
(on ?x ?y))
(:action pick-up
:parameters (?ob)
:precondition (and (clear ?ob) (ontable ?ob) (handempty))
:effect (and (holding ?ob) (not (clear ?ob)) (not (ontable ?ob))
(not (handempty))))
(:action put-down
:parameters (?ob)
:precondition (holding ?ob)
:effect (and (clear ?ob) (handempty) (ontable ?ob)
(not (holding ?ob))))
(:action stack
:parameters (?ob ?underob)
:precondition (and (clear ?underob) (holding ?ob))
:effect (and (handempty) (clear ?ob) (on ?ob ?underob)
(not (clear ?underob)) (not (holding ?ob))))
(:action unstack
:parameters (?ob ?underob)
:precondition (and (on ?ob ?underob) (clear ?ob) (handempty))
:effect (and (holding ?ob) (clear ?underob)
(not (on ?ob ?underob)) (not (clear ?ob)) (not (handempty)))))
|
(define (problem BW-rand-4)
(:domain blocksworld-4ops)
(:objects a b c d )
(:init
(handempty)
(on a d)
(on b a)
(on c b)
(ontable d)
(clear c)
)
(:goal
(and
(on b c)
(on c d)
(on d a))
)
)
| status: SOLVED_SATISFICING
engine: Pyperplan
plan: SequentialPlan:
unstack(c, b)
put-down(c)
unstack(b, a)
stack(b, c)
unstack(a, d)
put-down(a)
pick-up(d)
stack(d, a)
unstack(b, c)
put-down(b)
pick-up(c)
stack(c, d)
pick-up(b)
stack(b, c) | SequentialPlan:
unstack(c, b)
put-down(c)
unstack(b, a)
stack(b, c)
unstack(a, d)
put-down(a)
pick-up(d)
stack(d, a)
unstack(b, c)
put-down(b)
pick-up(c)
stack(c, d)
pick-up(b)
stack(b, c) | 14 | I am playing with a set of objects.
Here are the actions I can do:
pick-up with ob
put-down with ob
stack with ob, underob
unstack with ob, underob
I have the following restrictions on my actions:
To perform pick-up action, the following facts need to be true: (clear(ob) and ontable(ob) and handempty).
Once pick-up action is performed the following facts will be true: holding(ob).
Once pick-up action is performed the following facts will be false: clear(ob), ontable(ob), handempty.
To perform put-down action, the following facts need to be true: holding(ob).
Once put-down action is performed the following facts will be true: clear(ob), handempty, ontable(ob).
Once put-down action is performed the following facts will be false: holding(ob).
To perform stack action, the following facts need to be true: (clear(underob) and holding(ob)).
Once stack action is performed the following facts will be true: handempty, clear(ob), on(ob, underob).
Once stack action is performed the following facts will be false: clear(underob), holding(ob).
To perform unstack action, the following facts need to be true: (on(ob, underob) and clear(ob) and handempty).
Once unstack action is performed the following facts will be true: holding(ob), clear(underob).
Once unstack action is performed the following facts will be false: on(ob, underob), clear(ob), handempty.
[STATEMENT]
As initial conditions I have that, handempty, on(a, d), on(b, a), on(c, b), ontable(d), clear(c).
My goal is to have that (on(b, c) and on(c, d) and on(d, a)). | unstack(c,b)
put-down(c)
unstack(b,a)
stack(b,c)
unstack(a,d)
put-down(a)
pick-up(d)
stack(d,a)
unstack(b,c)
put-down(b)
pick-up(c)
stack(c,d)
pick-up(b)
stack(b,c) | 375 |
(define (domain blocksworld-4ops)
(:requirements :strips)
(:predicates (clear ?x)
(ontable ?x)
(handempty)
(holding ?x)
(on ?x ?y))
(:action pick-up
:parameters (?ob)
:precondition (and (clear ?ob) (ontable ?ob) (handempty))
:effect (and (holding ?ob) (not (clear ?ob)) (not (ontable ?ob))
(not (handempty))))
(:action put-down
:parameters (?ob)
:precondition (holding ?ob)
:effect (and (clear ?ob) (handempty) (ontable ?ob)
(not (holding ?ob))))
(:action stack
:parameters (?ob ?underob)
:precondition (and (clear ?underob) (holding ?ob))
:effect (and (handempty) (clear ?ob) (on ?ob ?underob)
(not (clear ?underob)) (not (holding ?ob))))
(:action unstack
:parameters (?ob ?underob)
:precondition (and (on ?ob ?underob) (clear ?ob) (handempty))
:effect (and (holding ?ob) (clear ?underob)
(not (on ?ob ?underob)) (not (clear ?ob)) (not (handempty)))))
|
(define (problem BW-rand-4)
(:domain blocksworld-4ops)
(:objects a b c d )
(:init
(handempty)
(ontable a)
(on b d)
(ontable c)
(on d a)
(clear b)
(clear c)
)
(:goal
(and
(on b c)
(on c d)
(on d a))
)
)
| status: SOLVED_SATISFICING
engine: Pyperplan
plan: SequentialPlan:
unstack(b, d)
put-down(b)
pick-up(c)
stack(c, d)
pick-up(b)
stack(b, c) | SequentialPlan:
unstack(b, d)
put-down(b)
pick-up(c)
stack(c, d)
pick-up(b)
stack(b, c) | 6 | I am playing with a set of objects.
Here are the actions I can do:
pick-up with ob
put-down with ob
stack with ob, underob
unstack with ob, underob
I have the following restrictions on my actions:
To perform pick-up action, the following facts need to be true: (clear(ob) and ontable(ob) and handempty).
Once pick-up action is performed the following facts will be true: holding(ob).
Once pick-up action is performed the following facts will be false: clear(ob), ontable(ob), handempty.
To perform put-down action, the following facts need to be true: holding(ob).
Once put-down action is performed the following facts will be true: clear(ob), handempty, ontable(ob).
Once put-down action is performed the following facts will be false: holding(ob).
To perform stack action, the following facts need to be true: (clear(underob) and holding(ob)).
Once stack action is performed the following facts will be true: handempty, clear(ob), on(ob, underob).
Once stack action is performed the following facts will be false: clear(underob), holding(ob).
To perform unstack action, the following facts need to be true: (on(ob, underob) and clear(ob) and handempty).
Once unstack action is performed the following facts will be true: holding(ob), clear(underob).
Once unstack action is performed the following facts will be false: on(ob, underob), clear(ob), handempty.
[STATEMENT]
As initial conditions I have that, handempty, ontable(a), on(b, d), ontable(c), on(d, a), clear(b), clear(c).
My goal is to have that (on(b, c) and on(c, d) and on(d, a)). | unstack(b,d)
put-down(b)
pick-up(c)
stack(c,d)
pick-up(b)
stack(b,c) | 377 |
(define (domain blocksworld-4ops)
(:requirements :strips)
(:predicates (clear ?x)
(ontable ?x)
(handempty)
(holding ?x)
(on ?x ?y))
(:action pick-up
:parameters (?ob)
:precondition (and (clear ?ob) (ontable ?ob) (handempty))
:effect (and (holding ?ob) (not (clear ?ob)) (not (ontable ?ob))
(not (handempty))))
(:action put-down
:parameters (?ob)
:precondition (holding ?ob)
:effect (and (clear ?ob) (handempty) (ontable ?ob)
(not (holding ?ob))))
(:action stack
:parameters (?ob ?underob)
:precondition (and (clear ?underob) (holding ?ob))
:effect (and (handempty) (clear ?ob) (on ?ob ?underob)
(not (clear ?underob)) (not (holding ?ob))))
(:action unstack
:parameters (?ob ?underob)
:precondition (and (on ?ob ?underob) (clear ?ob) (handempty))
:effect (and (holding ?ob) (clear ?underob)
(not (on ?ob ?underob)) (not (clear ?ob)) (not (handempty)))))
|
(define (problem BW-rand-4)
(:domain blocksworld-4ops)
(:objects a b c d )
(:init
(handempty)
(on a c)
(on b d)
(ontable c)
(on d a)
(clear b)
)
(:goal
(and
(on a c)
(on b a)
(on c d))
)
)
| status: SOLVED_SATISFICING
engine: Pyperplan
plan: SequentialPlan:
unstack(b, d)
put-down(b)
unstack(d, a)
put-down(d)
unstack(a, c)
put-down(a)
pick-up(b)
stack(b, a)
pick-up(c)
stack(c, d)
unstack(b, a)
put-down(b)
pick-up(a)
stack(a, c)
pick-up(b)
stack(b, a) | SequentialPlan:
unstack(b, d)
put-down(b)
unstack(d, a)
put-down(d)
unstack(a, c)
put-down(a)
pick-up(b)
stack(b, a)
pick-up(c)
stack(c, d)
unstack(b, a)
put-down(b)
pick-up(a)
stack(a, c)
pick-up(b)
stack(b, a) | 16 | I am playing with a set of objects.
Here are the actions I can do:
pick-up with ob
put-down with ob
stack with ob, underob
unstack with ob, underob
I have the following restrictions on my actions:
To perform pick-up action, the following facts need to be true: (clear(ob) and ontable(ob) and handempty).
Once pick-up action is performed the following facts will be true: holding(ob).
Once pick-up action is performed the following facts will be false: clear(ob), ontable(ob), handempty.
To perform put-down action, the following facts need to be true: holding(ob).
Once put-down action is performed the following facts will be true: clear(ob), handempty, ontable(ob).
Once put-down action is performed the following facts will be false: holding(ob).
To perform stack action, the following facts need to be true: (clear(underob) and holding(ob)).
Once stack action is performed the following facts will be true: handempty, clear(ob), on(ob, underob).
Once stack action is performed the following facts will be false: clear(underob), holding(ob).
To perform unstack action, the following facts need to be true: (on(ob, underob) and clear(ob) and handempty).
Once unstack action is performed the following facts will be true: holding(ob), clear(underob).
Once unstack action is performed the following facts will be false: on(ob, underob), clear(ob), handempty.
[STATEMENT]
As initial conditions I have that, handempty, on(a, c), on(b, d), ontable(c), on(d, a), clear(b).
My goal is to have that (on(a, c) and on(b, a) and on(c, d)). | unstack(b,d)
put-down(b)
unstack(d,a)
put-down(d)
unstack(a,c)
put-down(a)
pick-up(b)
stack(b,a)
pick-up(c)
stack(c,d)
unstack(b,a)
put-down(b)
pick-up(a)
stack(a,c)
pick-up(b)
stack(b,a) | 375 |
(define (domain blocksworld-4ops)
(:requirements :strips)
(:predicates (clear ?x)
(ontable ?x)
(handempty)
(holding ?x)
(on ?x ?y))
(:action pick-up
:parameters (?ob)
:precondition (and (clear ?ob) (ontable ?ob) (handempty))
:effect (and (holding ?ob) (not (clear ?ob)) (not (ontable ?ob))
(not (handempty))))
(:action put-down
:parameters (?ob)
:precondition (holding ?ob)
:effect (and (clear ?ob) (handempty) (ontable ?ob)
(not (holding ?ob))))
(:action stack
:parameters (?ob ?underob)
:precondition (and (clear ?underob) (holding ?ob))
:effect (and (handempty) (clear ?ob) (on ?ob ?underob)
(not (clear ?underob)) (not (holding ?ob))))
(:action unstack
:parameters (?ob ?underob)
:precondition (and (on ?ob ?underob) (clear ?ob) (handempty))
:effect (and (holding ?ob) (clear ?underob)
(not (on ?ob ?underob)) (not (clear ?ob)) (not (handempty)))))
|
(define (problem BW-rand-4)
(:domain blocksworld-4ops)
(:objects a b c d )
(:init
(handempty)
(ontable a)
(ontable b)
(on c b)
(ontable d)
(clear a)
(clear c)
(clear d)
)
(:goal
(and
(on b a)
(on d b))
)
)
| status: SOLVED_SATISFICING
engine: Pyperplan
plan: SequentialPlan:
unstack(c, b)
put-down(c)
pick-up(b)
stack(b, a)
pick-up(d)
stack(d, b) | SequentialPlan:
unstack(c, b)
put-down(c)
pick-up(b)
stack(b, a)
pick-up(d)
stack(d, b) | 6 | I am playing with a set of objects.
Here are the actions I can do:
pick-up with ob
put-down with ob
stack with ob, underob
unstack with ob, underob
I have the following restrictions on my actions:
To perform pick-up action, the following facts need to be true: (clear(ob) and ontable(ob) and handempty).
Once pick-up action is performed the following facts will be true: holding(ob).
Once pick-up action is performed the following facts will be false: clear(ob), ontable(ob), handempty.
To perform put-down action, the following facts need to be true: holding(ob).
Once put-down action is performed the following facts will be true: clear(ob), handempty, ontable(ob).
Once put-down action is performed the following facts will be false: holding(ob).
To perform stack action, the following facts need to be true: (clear(underob) and holding(ob)).
Once stack action is performed the following facts will be true: handempty, clear(ob), on(ob, underob).
Once stack action is performed the following facts will be false: clear(underob), holding(ob).
To perform unstack action, the following facts need to be true: (on(ob, underob) and clear(ob) and handempty).
Once unstack action is performed the following facts will be true: holding(ob), clear(underob).
Once unstack action is performed the following facts will be false: on(ob, underob), clear(ob), handempty.
Everything is false by default
[STATEMENT]
As initial conditions I have that, handempty, ontable(a), ontable(b), on(c, b), ontable(d), clear(a), clear(c), clear(d).
My goal is to have that (on(b, a) and on(d, b)). | unstack(c,b)
put-down(c)
pick-up(b)
stack(b,a)
pick-up(d)
stack(d,b) | 379 |
(define (domain blocksworld-4ops)
(:requirements :strips)
(:predicates (clear ?x)
(ontable ?x)
(handempty)
(holding ?x)
(on ?x ?y))
(:action pick-up
:parameters (?ob)
:precondition (and (clear ?ob) (ontable ?ob) (handempty))
:effect (and (holding ?ob) (not (clear ?ob)) (not (ontable ?ob))
(not (handempty))))
(:action put-down
:parameters (?ob)
:precondition (holding ?ob)
:effect (and (clear ?ob) (handempty) (ontable ?ob)
(not (holding ?ob))))
(:action stack
:parameters (?ob ?underob)
:precondition (and (clear ?underob) (holding ?ob))
:effect (and (handempty) (clear ?ob) (on ?ob ?underob)
(not (clear ?underob)) (not (holding ?ob))))
(:action unstack
:parameters (?ob ?underob)
:precondition (and (on ?ob ?underob) (clear ?ob) (handempty))
:effect (and (holding ?ob) (clear ?underob)
(not (on ?ob ?underob)) (not (clear ?ob)) (not (handempty)))))
|
(define (problem BW-rand-4)
(:domain blocksworld-4ops)
(:objects a b c d )
(:init
(handempty)
(on a d)
(ontable b)
(on c a)
(ontable d)
(clear b)
(clear c)
)
(:goal
(and
(on b d)
(on c b))
)
)
| status: SOLVED_SATISFICING
engine: Pyperplan
plan: SequentialPlan:
unstack(c, a)
stack(c, b)
unstack(a, d)
put-down(a)
unstack(c, b)
put-down(c)
pick-up(b)
stack(b, d)
pick-up(c)
stack(c, b) | SequentialPlan:
unstack(c, a)
stack(c, b)
unstack(a, d)
put-down(a)
unstack(c, b)
put-down(c)
pick-up(b)
stack(b, d)
pick-up(c)
stack(c, b) | 10 | I am playing with a set of objects.
Here are the actions I can do:
pick-up with ob
put-down with ob
stack with ob, underob
unstack with ob, underob
I have the following restrictions on my actions:
To perform pick-up action, the following facts need to be true: (clear(ob) and ontable(ob) and handempty).
Once pick-up action is performed the following facts will be true: holding(ob).
Once pick-up action is performed the following facts will be false: clear(ob), ontable(ob), handempty.
To perform put-down action, the following facts need to be true: holding(ob).
Once put-down action is performed the following facts will be true: clear(ob), handempty, ontable(ob).
Once put-down action is performed the following facts will be false: holding(ob).
To perform stack action, the following facts need to be true: (clear(underob) and holding(ob)).
Once stack action is performed the following facts will be true: handempty, clear(ob), on(ob, underob).
Once stack action is performed the following facts will be false: clear(underob), holding(ob).
To perform unstack action, the following facts need to be true: (on(ob, underob) and clear(ob) and handempty).
Once unstack action is performed the following facts will be true: holding(ob), clear(underob).
Once unstack action is performed the following facts will be false: on(ob, underob), clear(ob), handempty.
[STATEMENT]
As initial conditions I have that, handempty, on(a, d), ontable(b), on(c, a), ontable(d), clear(b), clear(c).
My goal is to have that (on(b, d) and on(c, b)). | unstack(c,a)
stack(c,b)
unstack(a,d)
put-down(a)
unstack(c,b)
put-down(c)
pick-up(b)
stack(b,d)
pick-up(c)
stack(c,b) | 371 |
(define (domain blocksworld-4ops)
(:requirements :strips)
(:predicates (clear ?x)
(ontable ?x)
(handempty)
(holding ?x)
(on ?x ?y))
(:action pick-up
:parameters (?ob)
:precondition (and (clear ?ob) (ontable ?ob) (handempty))
:effect (and (holding ?ob) (not (clear ?ob)) (not (ontable ?ob))
(not (handempty))))
(:action put-down
:parameters (?ob)
:precondition (holding ?ob)
:effect (and (clear ?ob) (handempty) (ontable ?ob)
(not (holding ?ob))))
(:action stack
:parameters (?ob ?underob)
:precondition (and (clear ?underob) (holding ?ob))
:effect (and (handempty) (clear ?ob) (on ?ob ?underob)
(not (clear ?underob)) (not (holding ?ob))))
(:action unstack
:parameters (?ob ?underob)
:precondition (and (on ?ob ?underob) (clear ?ob) (handempty))
:effect (and (holding ?ob) (clear ?underob)
(not (on ?ob ?underob)) (not (clear ?ob)) (not (handempty)))))
|
(define (problem BW-rand-4)
(:domain blocksworld-4ops)
(:objects a b c d )
(:init
(handempty)
(on a b)
(ontable b)
(ontable c)
(on d a)
(clear c)
(clear d)
)
(:goal
(and
(on a b)
(on c d))
)
)
| status: SOLVED_SATISFICING
engine: Pyperplan
plan: SequentialPlan:
pick-up(c)
stack(c, d) | SequentialPlan:
pick-up(c)
stack(c, d) | 2 | I am playing with a set of objects.
Here are the actions I can do:
pick-up with ob
put-down with ob
stack with ob, underob
unstack with ob, underob
I have the following restrictions on my actions:
To perform pick-up action, the following facts need to be true: (clear(ob) and ontable(ob) and handempty).
Once pick-up action is performed the following facts will be true: holding(ob).
Once pick-up action is performed the following facts will be false: clear(ob), ontable(ob), handempty.
To perform put-down action, the following facts need to be true: holding(ob).
Once put-down action is performed the following facts will be true: clear(ob), handempty, ontable(ob).
Once put-down action is performed the following facts will be false: holding(ob).
To perform stack action, the following facts need to be true: (clear(underob) and holding(ob)).
Once stack action is performed the following facts will be true: handempty, clear(ob), on(ob, underob).
Once stack action is performed the following facts will be false: clear(underob), holding(ob).
To perform unstack action, the following facts need to be true: (on(ob, underob) and clear(ob) and handempty).
Once unstack action is performed the following facts will be true: holding(ob), clear(underob).
Once unstack action is performed the following facts will be false: on(ob, underob), clear(ob), handempty.
[STATEMENT]
As initial conditions I have that, handempty, on(a, b), ontable(b), ontable(c), on(d, a), clear(c), clear(d).
My goal is to have that (on(a, b) and on(c, d)). | pick-up(c)
stack(c,d) | 371 |
(define (domain blocksworld-4ops)
(:requirements :strips)
(:predicates (clear ?x)
(ontable ?x)
(handempty)
(holding ?x)
(on ?x ?y))
(:action pick-up
:parameters (?ob)
:precondition (and (clear ?ob) (ontable ?ob) (handempty))
:effect (and (holding ?ob) (not (clear ?ob)) (not (ontable ?ob))
(not (handempty))))
(:action put-down
:parameters (?ob)
:precondition (holding ?ob)
:effect (and (clear ?ob) (handempty) (ontable ?ob)
(not (holding ?ob))))
(:action stack
:parameters (?ob ?underob)
:precondition (and (clear ?underob) (holding ?ob))
:effect (and (handempty) (clear ?ob) (on ?ob ?underob)
(not (clear ?underob)) (not (holding ?ob))))
(:action unstack
:parameters (?ob ?underob)
:precondition (and (on ?ob ?underob) (clear ?ob) (handempty))
:effect (and (holding ?ob) (clear ?underob)
(not (on ?ob ?underob)) (not (clear ?ob)) (not (handempty)))))
|
(define (problem BW-rand-4)
(:domain blocksworld-4ops)
(:objects a b c d )
(:init
(handempty)
(ontable a)
(on b c)
(on c a)
(on d b)
(clear d)
)
(:goal
(and
(on b a))
)
)
| status: SOLVED_SATISFICING
engine: Pyperplan
plan: SequentialPlan:
unstack(d, b)
put-down(d)
unstack(b, c)
put-down(b)
unstack(c, a)
put-down(c)
pick-up(b)
stack(b, a) | SequentialPlan:
unstack(d, b)
put-down(d)
unstack(b, c)
put-down(b)
unstack(c, a)
put-down(c)
pick-up(b)
stack(b, a) | 8 | I am playing with a set of objects.
Here are the actions I can do:
pick-up with ob
put-down with ob
stack with ob, underob
unstack with ob, underob
I have the following restrictions on my actions:
To perform pick-up action, the following facts need to be true: (clear(ob) and ontable(ob) and handempty).
Once pick-up action is performed the following facts will be true: holding(ob).
Once pick-up action is performed the following facts will be false: clear(ob), ontable(ob), handempty.
To perform put-down action, the following facts need to be true: holding(ob).
Once put-down action is performed the following facts will be true: clear(ob), handempty, ontable(ob).
Once put-down action is performed the following facts will be false: holding(ob).
To perform stack action, the following facts need to be true: (clear(underob) and holding(ob)).
Once stack action is performed the following facts will be true: handempty, clear(ob), on(ob, underob).
Once stack action is performed the following facts will be false: clear(underob), holding(ob).
To perform unstack action, the following facts need to be true: (on(ob, underob) and clear(ob) and handempty).
Once unstack action is performed the following facts will be true: holding(ob), clear(underob).
Once unstack action is performed the following facts will be false: on(ob, underob), clear(ob), handempty.
Everything is false by default
[STATEMENT]
As initial conditions I have that, handempty, ontable(a), on(b, c), on(c, a), on(d, b), clear(d).
My goal is to have that on(b, a). | unstack(d,b)
put-down(d)
unstack(b,c)
put-down(b)
unstack(c,a)
put-down(c)
pick-up(b)
stack(b,a) | 368 |
(define (domain blocksworld-4ops)
(:requirements :strips)
(:predicates (clear ?x)
(ontable ?x)
(handempty)
(holding ?x)
(on ?x ?y))
(:action pick-up
:parameters (?ob)
:precondition (and (clear ?ob) (ontable ?ob) (handempty))
:effect (and (holding ?ob) (not (clear ?ob)) (not (ontable ?ob))
(not (handempty))))
(:action put-down
:parameters (?ob)
:precondition (holding ?ob)
:effect (and (clear ?ob) (handempty) (ontable ?ob)
(not (holding ?ob))))
(:action stack
:parameters (?ob ?underob)
:precondition (and (clear ?underob) (holding ?ob))
:effect (and (handempty) (clear ?ob) (on ?ob ?underob)
(not (clear ?underob)) (not (holding ?ob))))
(:action unstack
:parameters (?ob ?underob)
:precondition (and (on ?ob ?underob) (clear ?ob) (handempty))
:effect (and (holding ?ob) (clear ?underob)
(not (on ?ob ?underob)) (not (clear ?ob)) (not (handempty)))))
|
(define (problem BW-rand-4)
(:domain blocksworld-4ops)
(:objects a b c d )
(:init
(handempty)
(on a c)
(on b a)
(ontable c)
(ontable d)
(clear b)
(clear d)
)
(:goal
(and
(on a c)
(on d b))
)
)
| status: SOLVED_SATISFICING
engine: Pyperplan
plan: SequentialPlan:
pick-up(d)
stack(d, b) | SequentialPlan:
pick-up(d)
stack(d, b) | 2 | I am playing with a set of objects.
Here are the actions I can do:
pick-up with ob
put-down with ob
stack with ob, underob
unstack with ob, underob
I have the following restrictions on my actions:
To perform pick-up action, the following facts need to be true: (clear(ob) and ontable(ob) and handempty).
Once pick-up action is performed the following facts will be true: holding(ob).
Once pick-up action is performed the following facts will be false: clear(ob), ontable(ob), handempty.
To perform put-down action, the following facts need to be true: holding(ob).
Once put-down action is performed the following facts will be true: clear(ob), handempty, ontable(ob).
Once put-down action is performed the following facts will be false: holding(ob).
To perform stack action, the following facts need to be true: (clear(underob) and holding(ob)).
Once stack action is performed the following facts will be true: handempty, clear(ob), on(ob, underob).
Once stack action is performed the following facts will be false: clear(underob), holding(ob).
To perform unstack action, the following facts need to be true: (on(ob, underob) and clear(ob) and handempty).
Once unstack action is performed the following facts will be true: holding(ob), clear(underob).
Once unstack action is performed the following facts will be false: on(ob, underob), clear(ob), handempty.
[STATEMENT]
As initial conditions I have that, handempty, on(a, c), on(b, a), ontable(c), ontable(d), clear(b), clear(d).
My goal is to have that (on(a, c) and on(d, b)). | pick-up(d)
stack(d,b) | 371 |
(define (domain blocksworld-4ops)
(:requirements :strips)
(:predicates (clear ?x)
(ontable ?x)
(handempty)
(holding ?x)
(on ?x ?y))
(:action pick-up
:parameters (?ob)
:precondition (and (clear ?ob) (ontable ?ob) (handempty))
:effect (and (holding ?ob) (not (clear ?ob)) (not (ontable ?ob))
(not (handempty))))
(:action put-down
:parameters (?ob)
:precondition (holding ?ob)
:effect (and (clear ?ob) (handempty) (ontable ?ob)
(not (holding ?ob))))
(:action stack
:parameters (?ob ?underob)
:precondition (and (clear ?underob) (holding ?ob))
:effect (and (handempty) (clear ?ob) (on ?ob ?underob)
(not (clear ?underob)) (not (holding ?ob))))
(:action unstack
:parameters (?ob ?underob)
:precondition (and (on ?ob ?underob) (clear ?ob) (handempty))
:effect (and (holding ?ob) (clear ?underob)
(not (on ?ob ?underob)) (not (clear ?ob)) (not (handempty)))))
|
(define (problem BW-rand-5)
(:domain blocksworld-4ops)
(:objects a b c d e )
(:init
(handempty)
(ontable a)
(on b d)
(ontable c)
(ontable d)
(on e b)
(clear a)
(clear c)
(clear e)
)
(:goal
(and
(on b d)
(on c e)
(on e a))
)
)
| status: SOLVED_SATISFICING
engine: Pyperplan
plan: SequentialPlan:
unstack(e, b)
stack(e, a)
pick-up(c)
stack(c, e) | SequentialPlan:
unstack(e, b)
stack(e, a)
pick-up(c)
stack(c, e) | 4 | I am playing with a set of objects.
Here are the actions I can do:
pick-up with ob
put-down with ob
stack with ob, underob
unstack with ob, underob
I have the following restrictions on my actions:
To perform pick-up action, the following facts need to be true: (clear(ob) and ontable(ob) and handempty).
Once pick-up action is performed the following facts will be true: holding(ob).
Once pick-up action is performed the following facts will be false: clear(ob), ontable(ob), handempty.
To perform put-down action, the following facts need to be true: holding(ob).
Once put-down action is performed the following facts will be true: clear(ob), handempty, ontable(ob).
Once put-down action is performed the following facts will be false: holding(ob).
To perform stack action, the following facts need to be true: (clear(underob) and holding(ob)).
Once stack action is performed the following facts will be true: handempty, clear(ob), on(ob, underob).
Once stack action is performed the following facts will be false: clear(underob), holding(ob).
To perform unstack action, the following facts need to be true: (on(ob, underob) and clear(ob) and handempty).
Once unstack action is performed the following facts will be true: holding(ob), clear(underob).
Once unstack action is performed the following facts will be false: on(ob, underob), clear(ob), handempty.
Everything is false by default
[STATEMENT]
As initial conditions I have that, handempty, ontable(a), on(b, d), ontable(c), ontable(d), on(e, b), clear(a), clear(c), clear(e).
My goal is to have that (on(b, d) and on(c, e) and on(e, a)). | unstack(e,b)
stack(e,a)
pick-up(c)
stack(c,e) | 390 |
(define (domain blocksworld-4ops)
(:requirements :strips)
(:predicates (clear ?x)
(ontable ?x)
(handempty)
(holding ?x)
(on ?x ?y))
(:action pick-up
:parameters (?ob)
:precondition (and (clear ?ob) (ontable ?ob) (handempty))
:effect (and (holding ?ob) (not (clear ?ob)) (not (ontable ?ob))
(not (handempty))))
(:action put-down
:parameters (?ob)
:precondition (holding ?ob)
:effect (and (clear ?ob) (handempty) (ontable ?ob)
(not (holding ?ob))))
(:action stack
:parameters (?ob ?underob)
:precondition (and (clear ?underob) (holding ?ob))
:effect (and (handempty) (clear ?ob) (on ?ob ?underob)
(not (clear ?underob)) (not (holding ?ob))))
(:action unstack
:parameters (?ob ?underob)
:precondition (and (on ?ob ?underob) (clear ?ob) (handempty))
:effect (and (holding ?ob) (clear ?underob)
(not (on ?ob ?underob)) (not (clear ?ob)) (not (handempty)))))
|
(define (problem BW-rand-4)
(:domain blocksworld-4ops)
(:objects a b c d )
(:init
(handempty)
(on a d)
(ontable b)
(on c a)
(on d b)
(clear c)
)
(:goal
(and
(on c d)
(on d b))
)
)
| status: SOLVED_SATISFICING
engine: Pyperplan
plan: SequentialPlan:
unstack(c, a)
put-down(c)
unstack(a, d)
put-down(a)
pick-up(c)
stack(c, d) | SequentialPlan:
unstack(c, a)
put-down(c)
unstack(a, d)
put-down(a)
pick-up(c)
stack(c, d) | 6 | I am playing with a set of objects.
Here are the actions I can do:
pick-up with ob
put-down with ob
stack with ob, underob
unstack with ob, underob
I have the following restrictions on my actions:
To perform pick-up action, the following facts need to be true: (clear(ob) and ontable(ob) and handempty).
Once pick-up action is performed the following facts will be true: holding(ob).
Once pick-up action is performed the following facts will be false: clear(ob), ontable(ob), handempty.
To perform put-down action, the following facts need to be true: holding(ob).
Once put-down action is performed the following facts will be true: clear(ob), handempty, ontable(ob).
Once put-down action is performed the following facts will be false: holding(ob).
To perform stack action, the following facts need to be true: (clear(underob) and holding(ob)).
Once stack action is performed the following facts will be true: handempty, clear(ob), on(ob, underob).
Once stack action is performed the following facts will be false: clear(underob), holding(ob).
To perform unstack action, the following facts need to be true: (on(ob, underob) and clear(ob) and handempty).
Once unstack action is performed the following facts will be true: holding(ob), clear(underob).
Once unstack action is performed the following facts will be false: on(ob, underob), clear(ob), handempty.
Everything is false by default
[STATEMENT]
As initial conditions I have that, handempty, on(a, d), ontable(b), on(c, a), on(d, b), clear(c).
My goal is to have that (on(c, d) and on(d, b)). | unstack(c,a)
put-down(c)
unstack(a,d)
put-down(a)
pick-up(c)
stack(c,d) | 375 |
(define (domain blocksworld-4ops)
(:requirements :strips)
(:predicates (clear ?x)
(ontable ?x)
(handempty)
(holding ?x)
(on ?x ?y))
(:action pick-up
:parameters (?ob)
:precondition (and (clear ?ob) (ontable ?ob) (handempty))
:effect (and (holding ?ob) (not (clear ?ob)) (not (ontable ?ob))
(not (handempty))))
(:action put-down
:parameters (?ob)
:precondition (holding ?ob)
:effect (and (clear ?ob) (handempty) (ontable ?ob)
(not (holding ?ob))))
(:action stack
:parameters (?ob ?underob)
:precondition (and (clear ?underob) (holding ?ob))
:effect (and (handempty) (clear ?ob) (on ?ob ?underob)
(not (clear ?underob)) (not (holding ?ob))))
(:action unstack
:parameters (?ob ?underob)
:precondition (and (on ?ob ?underob) (clear ?ob) (handempty))
:effect (and (holding ?ob) (clear ?underob)
(not (on ?ob ?underob)) (not (clear ?ob)) (not (handempty)))))
|
(define (problem BW-rand-4)
(:domain blocksworld-4ops)
(:objects a b c d )
(:init
(handempty)
(on a d)
(ontable b)
(on c a)
(on d b)
(clear c)
)
(:goal
(and
(on d c))
)
)
| status: SOLVED_SATISFICING
engine: Pyperplan
plan: SequentialPlan:
unstack(c, a)
put-down(c)
unstack(a, d)
put-down(a)
unstack(d, b)
stack(d, c) | SequentialPlan:
unstack(c, a)
put-down(c)
unstack(a, d)
put-down(a)
unstack(d, b)
stack(d, c) | 6 | I am playing with a set of objects.
Here are the actions I can do:
pick-up with ob
put-down with ob
stack with ob, underob
unstack with ob, underob
I have the following restrictions on my actions:
To perform pick-up action, the following facts need to be true: (clear(ob) and ontable(ob) and handempty).
Once pick-up action is performed the following facts will be true: holding(ob).
Once pick-up action is performed the following facts will be false: clear(ob), ontable(ob), handempty.
To perform put-down action, the following facts need to be true: holding(ob).
Once put-down action is performed the following facts will be true: clear(ob), handempty, ontable(ob).
Once put-down action is performed the following facts will be false: holding(ob).
To perform stack action, the following facts need to be true: (clear(underob) and holding(ob)).
Once stack action is performed the following facts will be true: handempty, clear(ob), on(ob, underob).
Once stack action is performed the following facts will be false: clear(underob), holding(ob).
To perform unstack action, the following facts need to be true: (on(ob, underob) and clear(ob) and handempty).
Once unstack action is performed the following facts will be true: holding(ob), clear(underob).
Once unstack action is performed the following facts will be false: on(ob, underob), clear(ob), handempty.
Everything is false by default
[STATEMENT]
As initial conditions I have that, handempty, on(a, d), ontable(b), on(c, a), on(d, b), clear(c).
My goal is to have that on(d, c). | unstack(c,a)
put-down(c)
unstack(a,d)
put-down(a)
unstack(d,b)
stack(d,c) | 368 |
(define (domain blocksworld-4ops)
(:requirements :strips)
(:predicates (clear ?x)
(ontable ?x)
(handempty)
(holding ?x)
(on ?x ?y))
(:action pick-up
:parameters (?ob)
:precondition (and (clear ?ob) (ontable ?ob) (handempty))
:effect (and (holding ?ob) (not (clear ?ob)) (not (ontable ?ob))
(not (handempty))))
(:action put-down
:parameters (?ob)
:precondition (holding ?ob)
:effect (and (clear ?ob) (handempty) (ontable ?ob)
(not (holding ?ob))))
(:action stack
:parameters (?ob ?underob)
:precondition (and (clear ?underob) (holding ?ob))
:effect (and (handempty) (clear ?ob) (on ?ob ?underob)
(not (clear ?underob)) (not (holding ?ob))))
(:action unstack
:parameters (?ob ?underob)
:precondition (and (on ?ob ?underob) (clear ?ob) (handempty))
:effect (and (holding ?ob) (clear ?underob)
(not (on ?ob ?underob)) (not (clear ?ob)) (not (handempty)))))
|
(define (problem BW-rand-4)
(:domain blocksworld-4ops)
(:objects a b c d )
(:init
(handempty)
(ontable a)
(ontable b)
(on c a)
(ontable d)
(clear b)
(clear c)
(clear d)
)
(:goal
(and
(on b c)
(on d b))
)
)
| status: SOLVED_SATISFICING
engine: Pyperplan
plan: SequentialPlan:
pick-up(b)
stack(b, c)
pick-up(d)
stack(d, b) | SequentialPlan:
pick-up(b)
stack(b, c)
pick-up(d)
stack(d, b) | 4 | I am playing with a set of objects.
Here are the actions I can do:
pick-up with ob
put-down with ob
stack with ob, underob
unstack with ob, underob
I have the following restrictions on my actions:
To perform pick-up action, the following facts need to be true: (clear(ob) and ontable(ob) and handempty).
Once pick-up action is performed the following facts will be true: holding(ob).
Once pick-up action is performed the following facts will be false: clear(ob), ontable(ob), handempty.
To perform put-down action, the following facts need to be true: holding(ob).
Once put-down action is performed the following facts will be true: clear(ob), handempty, ontable(ob).
Once put-down action is performed the following facts will be false: holding(ob).
To perform stack action, the following facts need to be true: (clear(underob) and holding(ob)).
Once stack action is performed the following facts will be true: handempty, clear(ob), on(ob, underob).
Once stack action is performed the following facts will be false: clear(underob), holding(ob).
To perform unstack action, the following facts need to be true: (on(ob, underob) and clear(ob) and handempty).
Once unstack action is performed the following facts will be true: holding(ob), clear(underob).
Once unstack action is performed the following facts will be false: on(ob, underob), clear(ob), handempty.
Everything is false by default
[STATEMENT]
As initial conditions I have that, handempty, ontable(a), ontable(b), on(c, a), ontable(d), clear(b), clear(c), clear(d).
My goal is to have that (on(b, c) and on(d, b)). | pick-up(b)
stack(b,c)
pick-up(d)
stack(d,b) | 379 |
(define (domain blocksworld-4ops)
(:requirements :strips)
(:predicates (clear ?x)
(ontable ?x)
(handempty)
(holding ?x)
(on ?x ?y))
(:action pick-up
:parameters (?ob)
:precondition (and (clear ?ob) (ontable ?ob) (handempty))
:effect (and (holding ?ob) (not (clear ?ob)) (not (ontable ?ob))
(not (handempty))))
(:action put-down
:parameters (?ob)
:precondition (holding ?ob)
:effect (and (clear ?ob) (handempty) (ontable ?ob)
(not (holding ?ob))))
(:action stack
:parameters (?ob ?underob)
:precondition (and (clear ?underob) (holding ?ob))
:effect (and (handempty) (clear ?ob) (on ?ob ?underob)
(not (clear ?underob)) (not (holding ?ob))))
(:action unstack
:parameters (?ob ?underob)
:precondition (and (on ?ob ?underob) (clear ?ob) (handempty))
:effect (and (holding ?ob) (clear ?underob)
(not (on ?ob ?underob)) (not (clear ?ob)) (not (handempty)))))
|
(define (problem BW-rand-4)
(:domain blocksworld-4ops)
(:objects a b c d )
(:init
(handempty)
(ontable a)
(ontable b)
(on c d)
(ontable d)
(clear a)
(clear b)
(clear c)
)
(:goal
(and
(on b d)
(on c a))
)
)
| status: SOLVED_SATISFICING
engine: Pyperplan
plan: SequentialPlan:
unstack(c, d)
stack(c, a)
pick-up(b)
stack(b, d) | SequentialPlan:
unstack(c, d)
stack(c, a)
pick-up(b)
stack(b, d) | 4 | I am playing with a set of objects.
Here are the actions I can do:
pick-up with ob
put-down with ob
stack with ob, underob
unstack with ob, underob
I have the following restrictions on my actions:
To perform pick-up action, the following facts need to be true: (clear(ob) and ontable(ob) and handempty).
Once pick-up action is performed the following facts will be true: holding(ob).
Once pick-up action is performed the following facts will be false: clear(ob), ontable(ob), handempty.
To perform put-down action, the following facts need to be true: holding(ob).
Once put-down action is performed the following facts will be true: clear(ob), handempty, ontable(ob).
Once put-down action is performed the following facts will be false: holding(ob).
To perform stack action, the following facts need to be true: (clear(underob) and holding(ob)).
Once stack action is performed the following facts will be true: handempty, clear(ob), on(ob, underob).
Once stack action is performed the following facts will be false: clear(underob), holding(ob).
To perform unstack action, the following facts need to be true: (on(ob, underob) and clear(ob) and handempty).
Once unstack action is performed the following facts will be true: holding(ob), clear(underob).
Once unstack action is performed the following facts will be false: on(ob, underob), clear(ob), handempty.
[STATEMENT]
As initial conditions I have that, handempty, ontable(a), ontable(b), on(c, d), ontable(d), clear(a), clear(b), clear(c).
My goal is to have that (on(b, d) and on(c, a)). | unstack(c,d)
stack(c,a)
pick-up(b)
stack(b,d) | 373 |
(define (domain blocksworld-4ops)
(:requirements :strips)
(:predicates (clear ?x)
(ontable ?x)
(handempty)
(holding ?x)
(on ?x ?y))
(:action pick-up
:parameters (?ob)
:precondition (and (clear ?ob) (ontable ?ob) (handempty))
:effect (and (holding ?ob) (not (clear ?ob)) (not (ontable ?ob))
(not (handempty))))
(:action put-down
:parameters (?ob)
:precondition (holding ?ob)
:effect (and (clear ?ob) (handempty) (ontable ?ob)
(not (holding ?ob))))
(:action stack
:parameters (?ob ?underob)
:precondition (and (clear ?underob) (holding ?ob))
:effect (and (handempty) (clear ?ob) (on ?ob ?underob)
(not (clear ?underob)) (not (holding ?ob))))
(:action unstack
:parameters (?ob ?underob)
:precondition (and (on ?ob ?underob) (clear ?ob) (handempty))
:effect (and (holding ?ob) (clear ?underob)
(not (on ?ob ?underob)) (not (clear ?ob)) (not (handempty)))))
|
(define (problem BW-rand-4)
(:domain blocksworld-4ops)
(:objects a b c d )
(:init
(handempty)
(on a c)
(on b a)
(ontable c)
(ontable d)
(clear b)
(clear d)
)
(:goal
(and
(on c a))
)
)
| status: SOLVED_SATISFICING
engine: Pyperplan
plan: SequentialPlan:
unstack(b, a)
put-down(b)
unstack(a, c)
put-down(a)
pick-up(c)
stack(c, a) | SequentialPlan:
unstack(b, a)
put-down(b)
unstack(a, c)
put-down(a)
pick-up(c)
stack(c, a) | 6 | I am playing with a set of objects.
Here are the actions I can do:
pick-up with ob
put-down with ob
stack with ob, underob
unstack with ob, underob
I have the following restrictions on my actions:
To perform pick-up action, the following facts need to be true: (clear(ob) and ontable(ob) and handempty).
Once pick-up action is performed the following facts will be true: holding(ob).
Once pick-up action is performed the following facts will be false: clear(ob), ontable(ob), handempty.
To perform put-down action, the following facts need to be true: holding(ob).
Once put-down action is performed the following facts will be true: clear(ob), handempty, ontable(ob).
Once put-down action is performed the following facts will be false: holding(ob).
To perform stack action, the following facts need to be true: (clear(underob) and holding(ob)).
Once stack action is performed the following facts will be true: handempty, clear(ob), on(ob, underob).
Once stack action is performed the following facts will be false: clear(underob), holding(ob).
To perform unstack action, the following facts need to be true: (on(ob, underob) and clear(ob) and handempty).
Once unstack action is performed the following facts will be true: holding(ob), clear(underob).
Once unstack action is performed the following facts will be false: on(ob, underob), clear(ob), handempty.
Everything is false by default
[STATEMENT]
As initial conditions I have that, handempty, on(a, c), on(b, a), ontable(c), ontable(d), clear(b), clear(d).
My goal is to have that on(c, a). | unstack(b,a)
put-down(b)
unstack(a,c)
put-down(a)
pick-up(c)
stack(c,a) | 370 |
(define (domain blocksworld-4ops)
(:requirements :strips)
(:predicates (clear ?x)
(ontable ?x)
(handempty)
(holding ?x)
(on ?x ?y))
(:action pick-up
:parameters (?ob)
:precondition (and (clear ?ob) (ontable ?ob) (handempty))
:effect (and (holding ?ob) (not (clear ?ob)) (not (ontable ?ob))
(not (handempty))))
(:action put-down
:parameters (?ob)
:precondition (holding ?ob)
:effect (and (clear ?ob) (handempty) (ontable ?ob)
(not (holding ?ob))))
(:action stack
:parameters (?ob ?underob)
:precondition (and (clear ?underob) (holding ?ob))
:effect (and (handempty) (clear ?ob) (on ?ob ?underob)
(not (clear ?underob)) (not (holding ?ob))))
(:action unstack
:parameters (?ob ?underob)
:precondition (and (on ?ob ?underob) (clear ?ob) (handempty))
:effect (and (holding ?ob) (clear ?underob)
(not (on ?ob ?underob)) (not (clear ?ob)) (not (handempty)))))
|
(define (problem BW-rand-4)
(:domain blocksworld-4ops)
(:objects a b c d )
(:init
(handempty)
(ontable a)
(on b c)
(on c d)
(ontable d)
(clear a)
(clear b)
)
(:goal
(and
(on a d)
(on b a)
(on d c))
)
)
| status: SOLVED_SATISFICING
engine: Pyperplan
plan: SequentialPlan:
unstack(b, c)
stack(b, a)
unstack(c, d)
put-down(c)
pick-up(d)
stack(d, c)
unstack(b, a)
put-down(b)
pick-up(a)
stack(a, d)
pick-up(b)
stack(b, a) | SequentialPlan:
unstack(b, c)
stack(b, a)
unstack(c, d)
put-down(c)
pick-up(d)
stack(d, c)
unstack(b, a)
put-down(b)
pick-up(a)
stack(a, d)
pick-up(b)
stack(b, a) | 12 | I am playing with a set of objects.
Here are the actions I can do:
pick-up with ob
put-down with ob
stack with ob, underob
unstack with ob, underob
I have the following restrictions on my actions:
To perform pick-up action, the following facts need to be true: (clear(ob) and ontable(ob) and handempty).
Once pick-up action is performed the following facts will be true: holding(ob).
Once pick-up action is performed the following facts will be false: clear(ob), ontable(ob), handempty.
To perform put-down action, the following facts need to be true: holding(ob).
Once put-down action is performed the following facts will be true: clear(ob), handempty, ontable(ob).
Once put-down action is performed the following facts will be false: holding(ob).
To perform stack action, the following facts need to be true: (clear(underob) and holding(ob)).
Once stack action is performed the following facts will be true: handempty, clear(ob), on(ob, underob).
Once stack action is performed the following facts will be false: clear(underob), holding(ob).
To perform unstack action, the following facts need to be true: (on(ob, underob) and clear(ob) and handempty).
Once unstack action is performed the following facts will be true: holding(ob), clear(underob).
Once unstack action is performed the following facts will be false: on(ob, underob), clear(ob), handempty.
Everything is false by default
[STATEMENT]
As initial conditions I have that, handempty, ontable(a), on(b, c), on(c, d), ontable(d), clear(a), clear(b).
My goal is to have that (on(a, d) and on(b, a) and on(d, c)). | unstack(b,c)
stack(b,a)
unstack(c,d)
put-down(c)
pick-up(d)
stack(d,c)
unstack(b,a)
put-down(b)
pick-up(a)
stack(a,d)
pick-up(b)
stack(b,a) | 383 |
(define (domain blocksworld-4ops)
(:requirements :strips)
(:predicates (clear ?x)
(ontable ?x)
(handempty)
(holding ?x)
(on ?x ?y))
(:action pick-up
:parameters (?ob)
:precondition (and (clear ?ob) (ontable ?ob) (handempty))
:effect (and (holding ?ob) (not (clear ?ob)) (not (ontable ?ob))
(not (handempty))))
(:action put-down
:parameters (?ob)
:precondition (holding ?ob)
:effect (and (clear ?ob) (handempty) (ontable ?ob)
(not (holding ?ob))))
(:action stack
:parameters (?ob ?underob)
:precondition (and (clear ?underob) (holding ?ob))
:effect (and (handempty) (clear ?ob) (on ?ob ?underob)
(not (clear ?underob)) (not (holding ?ob))))
(:action unstack
:parameters (?ob ?underob)
:precondition (and (on ?ob ?underob) (clear ?ob) (handempty))
:effect (and (holding ?ob) (clear ?underob)
(not (on ?ob ?underob)) (not (clear ?ob)) (not (handempty)))))
|
(define (problem BW-rand-4)
(:domain blocksworld-4ops)
(:objects a b c d )
(:init
(handempty)
(on a b)
(on b c)
(ontable c)
(on d a)
(clear d)
)
(:goal
(and
(on a d)
(on c b)
(on d c))
)
)
| status: SOLVED_SATISFICING
engine: Pyperplan
plan: SequentialPlan:
unstack(d, a)
put-down(d)
unstack(a, b)
stack(a, d)
unstack(b, c)
put-down(b)
pick-up(c)
stack(c, b)
unstack(a, d)
put-down(a)
pick-up(d)
stack(d, c)
pick-up(a)
stack(a, d) | SequentialPlan:
unstack(d, a)
put-down(d)
unstack(a, b)
stack(a, d)
unstack(b, c)
put-down(b)
pick-up(c)
stack(c, b)
unstack(a, d)
put-down(a)
pick-up(d)
stack(d, c)
pick-up(a)
stack(a, d) | 14 | I am playing with a set of objects.
Here are the actions I can do:
pick-up with ob
put-down with ob
stack with ob, underob
unstack with ob, underob
I have the following restrictions on my actions:
To perform pick-up action, the following facts need to be true: (clear(ob) and ontable(ob) and handempty).
Once pick-up action is performed the following facts will be true: holding(ob).
Once pick-up action is performed the following facts will be false: clear(ob), ontable(ob), handempty.
To perform put-down action, the following facts need to be true: holding(ob).
Once put-down action is performed the following facts will be true: clear(ob), handempty, ontable(ob).
Once put-down action is performed the following facts will be false: holding(ob).
To perform stack action, the following facts need to be true: (clear(underob) and holding(ob)).
Once stack action is performed the following facts will be true: handempty, clear(ob), on(ob, underob).
Once stack action is performed the following facts will be false: clear(underob), holding(ob).
To perform unstack action, the following facts need to be true: (on(ob, underob) and clear(ob) and handempty).
Once unstack action is performed the following facts will be true: holding(ob), clear(underob).
Once unstack action is performed the following facts will be false: on(ob, underob), clear(ob), handempty.
Everything is false by default
[STATEMENT]
As initial conditions I have that, handempty, on(a, b), on(b, c), ontable(c), on(d, a), clear(d).
My goal is to have that (on(a, d) and on(c, b) and on(d, c)). | unstack(d,a)
put-down(d)
unstack(a,b)
stack(a,d)
unstack(b,c)
put-down(b)
pick-up(c)
stack(c,b)
unstack(a,d)
put-down(a)
pick-up(d)
stack(d,c)
pick-up(a)
stack(a,d) | 381 |
(define (domain blocksworld-4ops)
(:requirements :strips)
(:predicates (clear ?x)
(ontable ?x)
(handempty)
(holding ?x)
(on ?x ?y))
(:action pick-up
:parameters (?ob)
:precondition (and (clear ?ob) (ontable ?ob) (handempty))
:effect (and (holding ?ob) (not (clear ?ob)) (not (ontable ?ob))
(not (handempty))))
(:action put-down
:parameters (?ob)
:precondition (holding ?ob)
:effect (and (clear ?ob) (handempty) (ontable ?ob)
(not (holding ?ob))))
(:action stack
:parameters (?ob ?underob)
:precondition (and (clear ?underob) (holding ?ob))
:effect (and (handempty) (clear ?ob) (on ?ob ?underob)
(not (clear ?underob)) (not (holding ?ob))))
(:action unstack
:parameters (?ob ?underob)
:precondition (and (on ?ob ?underob) (clear ?ob) (handempty))
:effect (and (holding ?ob) (clear ?underob)
(not (on ?ob ?underob)) (not (clear ?ob)) (not (handempty)))))
|
(define (problem BW-rand-4)
(:domain blocksworld-4ops)
(:objects a b c d )
(:init
(handempty)
(on a b)
(ontable b)
(ontable c)
(on d a)
(clear c)
(clear d)
)
(:goal
(and
(on a d)
(on c b)
(on d c))
)
)
| status: SOLVED_SATISFICING
engine: Pyperplan
plan: SequentialPlan:
unstack(d, a)
put-down(d)
unstack(a, b)
stack(a, d)
pick-up(c)
stack(c, b)
unstack(a, d)
put-down(a)
pick-up(d)
stack(d, c)
pick-up(a)
stack(a, d) | SequentialPlan:
unstack(d, a)
put-down(d)
unstack(a, b)
stack(a, d)
pick-up(c)
stack(c, b)
unstack(a, d)
put-down(a)
pick-up(d)
stack(d, c)
pick-up(a)
stack(a, d) | 12 | I am playing with a set of objects.
Here are the actions I can do:
pick-up with ob
put-down with ob
stack with ob, underob
unstack with ob, underob
I have the following restrictions on my actions:
To perform pick-up action, the following facts need to be true: (clear(ob) and ontable(ob) and handempty).
Once pick-up action is performed the following facts will be true: holding(ob).
Once pick-up action is performed the following facts will be false: clear(ob), ontable(ob), handempty.
To perform put-down action, the following facts need to be true: holding(ob).
Once put-down action is performed the following facts will be true: clear(ob), handempty, ontable(ob).
Once put-down action is performed the following facts will be false: holding(ob).
To perform stack action, the following facts need to be true: (clear(underob) and holding(ob)).
Once stack action is performed the following facts will be true: handempty, clear(ob), on(ob, underob).
Once stack action is performed the following facts will be false: clear(underob), holding(ob).
To perform unstack action, the following facts need to be true: (on(ob, underob) and clear(ob) and handempty).
Once unstack action is performed the following facts will be true: holding(ob), clear(underob).
Once unstack action is performed the following facts will be false: on(ob, underob), clear(ob), handempty.
Everything is false by default
[STATEMENT]
As initial conditions I have that, handempty, on(a, b), ontable(b), ontable(c), on(d, a), clear(c), clear(d).
My goal is to have that (on(a, d) and on(c, b) and on(d, c)). | unstack(d,a)
put-down(d)
unstack(a,b)
stack(a,d)
pick-up(c)
stack(c,b)
unstack(a,d)
put-down(a)
pick-up(d)
stack(d,c)
pick-up(a)
stack(a,d) | 383 |
(define (domain blocksworld-4ops)
(:requirements :strips)
(:predicates (clear ?x)
(ontable ?x)
(handempty)
(holding ?x)
(on ?x ?y))
(:action pick-up
:parameters (?ob)
:precondition (and (clear ?ob) (ontable ?ob) (handempty))
:effect (and (holding ?ob) (not (clear ?ob)) (not (ontable ?ob))
(not (handempty))))
(:action put-down
:parameters (?ob)
:precondition (holding ?ob)
:effect (and (clear ?ob) (handempty) (ontable ?ob)
(not (holding ?ob))))
(:action stack
:parameters (?ob ?underob)
:precondition (and (clear ?underob) (holding ?ob))
:effect (and (handempty) (clear ?ob) (on ?ob ?underob)
(not (clear ?underob)) (not (holding ?ob))))
(:action unstack
:parameters (?ob ?underob)
:precondition (and (on ?ob ?underob) (clear ?ob) (handempty))
:effect (and (holding ?ob) (clear ?underob)
(not (on ?ob ?underob)) (not (clear ?ob)) (not (handempty)))))
|
(define (problem BW-rand-4)
(:domain blocksworld-4ops)
(:objects a b c d )
(:init
(handempty)
(ontable a)
(on b a)
(ontable c)
(ontable d)
(clear b)
(clear c)
(clear d)
)
(:goal
(and
(on a c)
(on b d))
)
)
| status: SOLVED_SATISFICING
engine: Pyperplan
plan: SequentialPlan:
unstack(b, a)
stack(b, d)
pick-up(a)
stack(a, c) | SequentialPlan:
unstack(b, a)
stack(b, d)
pick-up(a)
stack(a, c) | 4 | I am playing with a set of objects.
Here are the actions I can do:
pick-up with ob
put-down with ob
stack with ob, underob
unstack with ob, underob
I have the following restrictions on my actions:
To perform pick-up action, the following facts need to be true: (clear(ob) and ontable(ob) and handempty).
Once pick-up action is performed the following facts will be true: holding(ob).
Once pick-up action is performed the following facts will be false: clear(ob), ontable(ob), handempty.
To perform put-down action, the following facts need to be true: holding(ob).
Once put-down action is performed the following facts will be true: clear(ob), handempty, ontable(ob).
Once put-down action is performed the following facts will be false: holding(ob).
To perform stack action, the following facts need to be true: (clear(underob) and holding(ob)).
Once stack action is performed the following facts will be true: handempty, clear(ob), on(ob, underob).
Once stack action is performed the following facts will be false: clear(underob), holding(ob).
To perform unstack action, the following facts need to be true: (on(ob, underob) and clear(ob) and handempty).
Once unstack action is performed the following facts will be true: holding(ob), clear(underob).
Once unstack action is performed the following facts will be false: on(ob, underob), clear(ob), handempty.
[STATEMENT]
As initial conditions I have that, handempty, ontable(a), on(b, a), ontable(c), ontable(d), clear(b), clear(c), clear(d).
My goal is to have that (on(a, c) and on(b, d)). | unstack(b,a)
stack(b,d)
pick-up(a)
stack(a,c) | 373 |
(define (domain blocksworld-4ops)
(:requirements :strips)
(:predicates (clear ?x)
(ontable ?x)
(handempty)
(holding ?x)
(on ?x ?y))
(:action pick-up
:parameters (?ob)
:precondition (and (clear ?ob) (ontable ?ob) (handempty))
:effect (and (holding ?ob) (not (clear ?ob)) (not (ontable ?ob))
(not (handempty))))
(:action put-down
:parameters (?ob)
:precondition (holding ?ob)
:effect (and (clear ?ob) (handempty) (ontable ?ob)
(not (holding ?ob))))
(:action stack
:parameters (?ob ?underob)
:precondition (and (clear ?underob) (holding ?ob))
:effect (and (handempty) (clear ?ob) (on ?ob ?underob)
(not (clear ?underob)) (not (holding ?ob))))
(:action unstack
:parameters (?ob ?underob)
:precondition (and (on ?ob ?underob) (clear ?ob) (handempty))
:effect (and (holding ?ob) (clear ?underob)
(not (on ?ob ?underob)) (not (clear ?ob)) (not (handempty)))))
|
(define (problem BW-rand-4)
(:domain blocksworld-4ops)
(:objects a b c d )
(:init
(handempty)
(on a b)
(on b d)
(ontable c)
(on d c)
(clear a)
)
(:goal
(and
(on b a))
)
)
| status: SOLVED_SATISFICING
engine: Pyperplan
plan: SequentialPlan:
unstack(a, b)
put-down(a)
unstack(b, d)
stack(b, a) | SequentialPlan:
unstack(a, b)
put-down(a)
unstack(b, d)
stack(b, a) | 4 | I am playing with a set of objects.
Here are the actions I can do:
pick-up with ob
put-down with ob
stack with ob, underob
unstack with ob, underob
I have the following restrictions on my actions:
To perform pick-up action, the following facts need to be true: (clear(ob) and ontable(ob) and handempty).
Once pick-up action is performed the following facts will be true: holding(ob).
Once pick-up action is performed the following facts will be false: clear(ob), ontable(ob), handempty.
To perform put-down action, the following facts need to be true: holding(ob).
Once put-down action is performed the following facts will be true: clear(ob), handempty, ontable(ob).
Once put-down action is performed the following facts will be false: holding(ob).
To perform stack action, the following facts need to be true: (clear(underob) and holding(ob)).
Once stack action is performed the following facts will be true: handempty, clear(ob), on(ob, underob).
Once stack action is performed the following facts will be false: clear(underob), holding(ob).
To perform unstack action, the following facts need to be true: (on(ob, underob) and clear(ob) and handempty).
Once unstack action is performed the following facts will be true: holding(ob), clear(underob).
Once unstack action is performed the following facts will be false: on(ob, underob), clear(ob), handempty.
Everything is false by default
[STATEMENT]
As initial conditions I have that, handempty, on(a, b), on(b, d), ontable(c), on(d, c), clear(a).
My goal is to have that on(b, a). | unstack(a,b)
put-down(a)
unstack(b,d)
stack(b,a) | 368 |
(define (domain blocksworld-4ops)
(:requirements :strips)
(:predicates (clear ?x)
(ontable ?x)
(handempty)
(holding ?x)
(on ?x ?y))
(:action pick-up
:parameters (?ob)
:precondition (and (clear ?ob) (ontable ?ob) (handempty))
:effect (and (holding ?ob) (not (clear ?ob)) (not (ontable ?ob))
(not (handempty))))
(:action put-down
:parameters (?ob)
:precondition (holding ?ob)
:effect (and (clear ?ob) (handempty) (ontable ?ob)
(not (holding ?ob))))
(:action stack
:parameters (?ob ?underob)
:precondition (and (clear ?underob) (holding ?ob))
:effect (and (handempty) (clear ?ob) (on ?ob ?underob)
(not (clear ?underob)) (not (holding ?ob))))
(:action unstack
:parameters (?ob ?underob)
:precondition (and (on ?ob ?underob) (clear ?ob) (handempty))
:effect (and (holding ?ob) (clear ?underob)
(not (on ?ob ?underob)) (not (clear ?ob)) (not (handempty)))))
|
(define (problem BW-rand-4)
(:domain blocksworld-4ops)
(:objects a b c d )
(:init
(handempty)
(ontable a)
(on b d)
(ontable c)
(on d c)
(clear a)
(clear b)
)
(:goal
(and
(on b a)
(on c b))
)
)
| status: SOLVED_SATISFICING
engine: Pyperplan
plan: SequentialPlan:
unstack(b, d)
stack(b, a)
unstack(d, c)
put-down(d)
pick-up(c)
stack(c, b) | SequentialPlan:
unstack(b, d)
stack(b, a)
unstack(d, c)
put-down(d)
pick-up(c)
stack(c, b) | 6 | I am playing with a set of objects.
Here are the actions I can do:
pick-up with ob
put-down with ob
stack with ob, underob
unstack with ob, underob
I have the following restrictions on my actions:
To perform pick-up action, the following facts need to be true: (clear(ob) and ontable(ob) and handempty).
Once pick-up action is performed the following facts will be true: holding(ob).
Once pick-up action is performed the following facts will be false: clear(ob), ontable(ob), handempty.
To perform put-down action, the following facts need to be true: holding(ob).
Once put-down action is performed the following facts will be true: clear(ob), handempty, ontable(ob).
Once put-down action is performed the following facts will be false: holding(ob).
To perform stack action, the following facts need to be true: (clear(underob) and holding(ob)).
Once stack action is performed the following facts will be true: handempty, clear(ob), on(ob, underob).
Once stack action is performed the following facts will be false: clear(underob), holding(ob).
To perform unstack action, the following facts need to be true: (on(ob, underob) and clear(ob) and handempty).
Once unstack action is performed the following facts will be true: holding(ob), clear(underob).
Once unstack action is performed the following facts will be false: on(ob, underob), clear(ob), handempty.
[STATEMENT]
As initial conditions I have that, handempty, ontable(a), on(b, d), ontable(c), on(d, c), clear(a), clear(b).
My goal is to have that (on(b, a) and on(c, b)). | unstack(b,d)
stack(b,a)
unstack(d,c)
put-down(d)
pick-up(c)
stack(c,b) | 371 |
(define (domain blocksworld-4ops)
(:requirements :strips)
(:predicates (clear ?x)
(ontable ?x)
(handempty)
(holding ?x)
(on ?x ?y))
(:action pick-up
:parameters (?ob)
:precondition (and (clear ?ob) (ontable ?ob) (handempty))
:effect (and (holding ?ob) (not (clear ?ob)) (not (ontable ?ob))
(not (handempty))))
(:action put-down
:parameters (?ob)
:precondition (holding ?ob)
:effect (and (clear ?ob) (handempty) (ontable ?ob)
(not (holding ?ob))))
(:action stack
:parameters (?ob ?underob)
:precondition (and (clear ?underob) (holding ?ob))
:effect (and (handempty) (clear ?ob) (on ?ob ?underob)
(not (clear ?underob)) (not (holding ?ob))))
(:action unstack
:parameters (?ob ?underob)
:precondition (and (on ?ob ?underob) (clear ?ob) (handempty))
:effect (and (holding ?ob) (clear ?underob)
(not (on ?ob ?underob)) (not (clear ?ob)) (not (handempty)))))
|
(define (problem BW-rand-4)
(:domain blocksworld-4ops)
(:objects a b c d )
(:init
(handempty)
(on a d)
(on b c)
(on c a)
(ontable d)
(clear b)
)
(:goal
(and
(on b c)
(on d b))
)
)
| status: SOLVED_SATISFICING
engine: Pyperplan
plan: SequentialPlan:
unstack(b, c)
put-down(b)
unstack(c, a)
put-down(c)
unstack(a, d)
put-down(a)
pick-up(b)
stack(b, c)
pick-up(d)
stack(d, b) | SequentialPlan:
unstack(b, c)
put-down(b)
unstack(c, a)
put-down(c)
unstack(a, d)
put-down(a)
pick-up(b)
stack(b, c)
pick-up(d)
stack(d, b) | 10 | I am playing with a set of objects.
Here are the actions I can do:
pick-up with ob
put-down with ob
stack with ob, underob
unstack with ob, underob
I have the following restrictions on my actions:
To perform pick-up action, the following facts need to be true: (clear(ob) and ontable(ob) and handempty).
Once pick-up action is performed the following facts will be true: holding(ob).
Once pick-up action is performed the following facts will be false: clear(ob), ontable(ob), handempty.
To perform put-down action, the following facts need to be true: holding(ob).
Once put-down action is performed the following facts will be true: clear(ob), handempty, ontable(ob).
Once put-down action is performed the following facts will be false: holding(ob).
To perform stack action, the following facts need to be true: (clear(underob) and holding(ob)).
Once stack action is performed the following facts will be true: handempty, clear(ob), on(ob, underob).
Once stack action is performed the following facts will be false: clear(underob), holding(ob).
To perform unstack action, the following facts need to be true: (on(ob, underob) and clear(ob) and handempty).
Once unstack action is performed the following facts will be true: holding(ob), clear(underob).
Once unstack action is performed the following facts will be false: on(ob, underob), clear(ob), handempty.
[STATEMENT]
As initial conditions I have that, handempty, on(a, d), on(b, c), on(c, a), ontable(d), clear(b).
My goal is to have that (on(b, c) and on(d, b)). | unstack(b,c)
put-down(b)
unstack(c,a)
put-down(c)
unstack(a,d)
put-down(a)
pick-up(b)
stack(b,c)
pick-up(d)
stack(d,b) | 369 |
(define (domain blocksworld-4ops)
(:requirements :strips)
(:predicates (clear ?x)
(ontable ?x)
(handempty)
(holding ?x)
(on ?x ?y))
(:action pick-up
:parameters (?ob)
:precondition (and (clear ?ob) (ontable ?ob) (handempty))
:effect (and (holding ?ob) (not (clear ?ob)) (not (ontable ?ob))
(not (handempty))))
(:action put-down
:parameters (?ob)
:precondition (holding ?ob)
:effect (and (clear ?ob) (handempty) (ontable ?ob)
(not (holding ?ob))))
(:action stack
:parameters (?ob ?underob)
:precondition (and (clear ?underob) (holding ?ob))
:effect (and (handempty) (clear ?ob) (on ?ob ?underob)
(not (clear ?underob)) (not (holding ?ob))))
(:action unstack
:parameters (?ob ?underob)
:precondition (and (on ?ob ?underob) (clear ?ob) (handempty))
:effect (and (holding ?ob) (clear ?underob)
(not (on ?ob ?underob)) (not (clear ?ob)) (not (handempty)))))
|
(define (problem BW-rand-4)
(:domain blocksworld-4ops)
(:objects a b c d )
(:init
(handempty)
(ontable a)
(on b a)
(ontable c)
(on d b)
(clear c)
(clear d)
)
(:goal
(and
(on b d)
(on d c))
)
)
| status: SOLVED_SATISFICING
engine: Pyperplan
plan: SequentialPlan:
unstack(d, b)
stack(d, c)
unstack(b, a)
stack(b, d) | SequentialPlan:
unstack(d, b)
stack(d, c)
unstack(b, a)
stack(b, d) | 4 | I am playing with a set of objects.
Here are the actions I can do:
pick-up with ob
put-down with ob
stack with ob, underob
unstack with ob, underob
I have the following restrictions on my actions:
To perform pick-up action, the following facts need to be true: (clear(ob) and ontable(ob) and handempty).
Once pick-up action is performed the following facts will be true: holding(ob).
Once pick-up action is performed the following facts will be false: clear(ob), ontable(ob), handempty.
To perform put-down action, the following facts need to be true: holding(ob).
Once put-down action is performed the following facts will be true: clear(ob), handempty, ontable(ob).
Once put-down action is performed the following facts will be false: holding(ob).
To perform stack action, the following facts need to be true: (clear(underob) and holding(ob)).
Once stack action is performed the following facts will be true: handempty, clear(ob), on(ob, underob).
Once stack action is performed the following facts will be false: clear(underob), holding(ob).
To perform unstack action, the following facts need to be true: (on(ob, underob) and clear(ob) and handempty).
Once unstack action is performed the following facts will be true: holding(ob), clear(underob).
Once unstack action is performed the following facts will be false: on(ob, underob), clear(ob), handempty.
Everything is false by default
[STATEMENT]
As initial conditions I have that, handempty, ontable(a), on(b, a), ontable(c), on(d, b), clear(c), clear(d).
My goal is to have that (on(b, d) and on(d, c)). | unstack(d,b)
stack(d,c)
unstack(b,a)
stack(b,d) | 377 |
(define (domain blocksworld-4ops)
(:requirements :strips)
(:predicates (clear ?x)
(ontable ?x)
(handempty)
(holding ?x)
(on ?x ?y))
(:action pick-up
:parameters (?ob)
:precondition (and (clear ?ob) (ontable ?ob) (handempty))
:effect (and (holding ?ob) (not (clear ?ob)) (not (ontable ?ob))
(not (handempty))))
(:action put-down
:parameters (?ob)
:precondition (holding ?ob)
:effect (and (clear ?ob) (handempty) (ontable ?ob)
(not (holding ?ob))))
(:action stack
:parameters (?ob ?underob)
:precondition (and (clear ?underob) (holding ?ob))
:effect (and (handempty) (clear ?ob) (on ?ob ?underob)
(not (clear ?underob)) (not (holding ?ob))))
(:action unstack
:parameters (?ob ?underob)
:precondition (and (on ?ob ?underob) (clear ?ob) (handempty))
:effect (and (holding ?ob) (clear ?underob)
(not (on ?ob ?underob)) (not (clear ?ob)) (not (handempty)))))
|
(define (problem BW-rand-4)
(:domain blocksworld-4ops)
(:objects a b c d )
(:init
(handempty)
(on a c)
(on b d)
(ontable c)
(ontable d)
(clear a)
(clear b)
)
(:goal
(and
(on a b))
)
)
| status: SOLVED_SATISFICING
engine: Pyperplan
plan: SequentialPlan:
unstack(a, c)
stack(a, b) | SequentialPlan:
unstack(a, c)
stack(a, b) | 2 | I am playing with a set of objects.
Here are the actions I can do:
pick-up with ob
put-down with ob
stack with ob, underob
unstack with ob, underob
I have the following restrictions on my actions:
To perform pick-up action, the following facts need to be true: (clear(ob) and ontable(ob) and handempty).
Once pick-up action is performed the following facts will be true: holding(ob).
Once pick-up action is performed the following facts will be false: clear(ob), ontable(ob), handempty.
To perform put-down action, the following facts need to be true: holding(ob).
Once put-down action is performed the following facts will be true: clear(ob), handempty, ontable(ob).
Once put-down action is performed the following facts will be false: holding(ob).
To perform stack action, the following facts need to be true: (clear(underob) and holding(ob)).
Once stack action is performed the following facts will be true: handempty, clear(ob), on(ob, underob).
Once stack action is performed the following facts will be false: clear(underob), holding(ob).
To perform unstack action, the following facts need to be true: (on(ob, underob) and clear(ob) and handempty).
Once unstack action is performed the following facts will be true: holding(ob), clear(underob).
Once unstack action is performed the following facts will be false: on(ob, underob), clear(ob), handempty.
Everything is false by default
[STATEMENT]
As initial conditions I have that, handempty, on(a, c), on(b, d), ontable(c), ontable(d), clear(a), clear(b).
My goal is to have that on(a, b). | unstack(a,c)
stack(a,b) | 370 |
(define (domain blocksworld-4ops)
(:requirements :strips)
(:predicates (clear ?x)
(ontable ?x)
(handempty)
(holding ?x)
(on ?x ?y))
(:action pick-up
:parameters (?ob)
:precondition (and (clear ?ob) (ontable ?ob) (handempty))
:effect (and (holding ?ob) (not (clear ?ob)) (not (ontable ?ob))
(not (handempty))))
(:action put-down
:parameters (?ob)
:precondition (holding ?ob)
:effect (and (clear ?ob) (handempty) (ontable ?ob)
(not (holding ?ob))))
(:action stack
:parameters (?ob ?underob)
:precondition (and (clear ?underob) (holding ?ob))
:effect (and (handempty) (clear ?ob) (on ?ob ?underob)
(not (clear ?underob)) (not (holding ?ob))))
(:action unstack
:parameters (?ob ?underob)
:precondition (and (on ?ob ?underob) (clear ?ob) (handempty))
:effect (and (holding ?ob) (clear ?underob)
(not (on ?ob ?underob)) (not (clear ?ob)) (not (handempty)))))
|
(define (problem BW-rand-4)
(:domain blocksworld-4ops)
(:objects a b c d )
(:init
(handempty)
(on a b)
(on b d)
(ontable c)
(on d c)
(clear a)
)
(:goal
(and
(on c b)
(on d c))
)
)
| status: SOLVED_SATISFICING
engine: Pyperplan
plan: SequentialPlan:
unstack(a, b)
put-down(a)
unstack(b, d)
put-down(b)
unstack(d, c)
put-down(d)
pick-up(c)
stack(c, b)
pick-up(d)
stack(d, c) | SequentialPlan:
unstack(a, b)
put-down(a)
unstack(b, d)
put-down(b)
unstack(d, c)
put-down(d)
pick-up(c)
stack(c, b)
pick-up(d)
stack(d, c) | 10 | I am playing with a set of objects.
Here are the actions I can do:
pick-up with ob
put-down with ob
stack with ob, underob
unstack with ob, underob
I have the following restrictions on my actions:
To perform pick-up action, the following facts need to be true: (clear(ob) and ontable(ob) and handempty).
Once pick-up action is performed the following facts will be true: holding(ob).
Once pick-up action is performed the following facts will be false: clear(ob), ontable(ob), handempty.
To perform put-down action, the following facts need to be true: holding(ob).
Once put-down action is performed the following facts will be true: clear(ob), handempty, ontable(ob).
Once put-down action is performed the following facts will be false: holding(ob).
To perform stack action, the following facts need to be true: (clear(underob) and holding(ob)).
Once stack action is performed the following facts will be true: handempty, clear(ob), on(ob, underob).
Once stack action is performed the following facts will be false: clear(underob), holding(ob).
To perform unstack action, the following facts need to be true: (on(ob, underob) and clear(ob) and handempty).
Once unstack action is performed the following facts will be true: holding(ob), clear(underob).
Once unstack action is performed the following facts will be false: on(ob, underob), clear(ob), handempty.
[STATEMENT]
As initial conditions I have that, handempty, on(a, b), on(b, d), ontable(c), on(d, c), clear(a).
My goal is to have that (on(c, b) and on(d, c)). | unstack(a,b)
put-down(a)
unstack(b,d)
put-down(b)
unstack(d,c)
put-down(d)
pick-up(c)
stack(c,b)
pick-up(d)
stack(d,c) | 369 |
(define (domain blocksworld-4ops)
(:requirements :strips)
(:predicates (clear ?x)
(ontable ?x)
(handempty)
(holding ?x)
(on ?x ?y))
(:action pick-up
:parameters (?ob)
:precondition (and (clear ?ob) (ontable ?ob) (handempty))
:effect (and (holding ?ob) (not (clear ?ob)) (not (ontable ?ob))
(not (handempty))))
(:action put-down
:parameters (?ob)
:precondition (holding ?ob)
:effect (and (clear ?ob) (handempty) (ontable ?ob)
(not (holding ?ob))))
(:action stack
:parameters (?ob ?underob)
:precondition (and (clear ?underob) (holding ?ob))
:effect (and (handempty) (clear ?ob) (on ?ob ?underob)
(not (clear ?underob)) (not (holding ?ob))))
(:action unstack
:parameters (?ob ?underob)
:precondition (and (on ?ob ?underob) (clear ?ob) (handempty))
:effect (and (holding ?ob) (clear ?underob)
(not (on ?ob ?underob)) (not (clear ?ob)) (not (handempty)))))
|
(define (problem BW-rand-4)
(:domain blocksworld-4ops)
(:objects a b c d )
(:init
(handempty)
(ontable a)
(ontable b)
(on c d)
(ontable d)
(clear a)
(clear b)
(clear c)
)
(:goal
(and
(on b d))
)
)
| status: SOLVED_SATISFICING
engine: Pyperplan
plan: SequentialPlan:
unstack(c, d)
put-down(c)
pick-up(b)
stack(b, d) | SequentialPlan:
unstack(c, d)
put-down(c)
pick-up(b)
stack(b, d) | 4 | I am playing with a set of objects.
Here are the actions I can do:
pick-up with ob
put-down with ob
stack with ob, underob
unstack with ob, underob
I have the following restrictions on my actions:
To perform pick-up action, the following facts need to be true: (clear(ob) and ontable(ob) and handempty).
Once pick-up action is performed the following facts will be true: holding(ob).
Once pick-up action is performed the following facts will be false: clear(ob), ontable(ob), handempty.
To perform put-down action, the following facts need to be true: holding(ob).
Once put-down action is performed the following facts will be true: clear(ob), handempty, ontable(ob).
Once put-down action is performed the following facts will be false: holding(ob).
To perform stack action, the following facts need to be true: (clear(underob) and holding(ob)).
Once stack action is performed the following facts will be true: handempty, clear(ob), on(ob, underob).
Once stack action is performed the following facts will be false: clear(underob), holding(ob).
To perform unstack action, the following facts need to be true: (on(ob, underob) and clear(ob) and handempty).
Once unstack action is performed the following facts will be true: holding(ob), clear(underob).
Once unstack action is performed the following facts will be false: on(ob, underob), clear(ob), handempty.
Everything is false by default
[STATEMENT]
As initial conditions I have that, handempty, ontable(a), ontable(b), on(c, d), ontable(d), clear(a), clear(b), clear(c).
My goal is to have that on(b, d). | unstack(c,d)
put-down(c)
pick-up(b)
stack(b,d) | 372 |
(define (domain blocksworld-4ops)
(:requirements :strips)
(:predicates (clear ?x)
(ontable ?x)
(handempty)
(holding ?x)
(on ?x ?y))
(:action pick-up
:parameters (?ob)
:precondition (and (clear ?ob) (ontable ?ob) (handempty))
:effect (and (holding ?ob) (not (clear ?ob)) (not (ontable ?ob))
(not (handempty))))
(:action put-down
:parameters (?ob)
:precondition (holding ?ob)
:effect (and (clear ?ob) (handempty) (ontable ?ob)
(not (holding ?ob))))
(:action stack
:parameters (?ob ?underob)
:precondition (and (clear ?underob) (holding ?ob))
:effect (and (handempty) (clear ?ob) (on ?ob ?underob)
(not (clear ?underob)) (not (holding ?ob))))
(:action unstack
:parameters (?ob ?underob)
:precondition (and (on ?ob ?underob) (clear ?ob) (handempty))
:effect (and (holding ?ob) (clear ?underob)
(not (on ?ob ?underob)) (not (clear ?ob)) (not (handempty)))))
|
(define (problem BW-rand-4)
(:domain blocksworld-4ops)
(:objects a b c d )
(:init
(handempty)
(on a c)
(on b d)
(ontable c)
(ontable d)
(clear a)
(clear b)
)
(:goal
(and
(on c b)
(on d a))
)
)
| status: SOLVED_SATISFICING
engine: Pyperplan
plan: SequentialPlan:
unstack(b, d)
put-down(b)
unstack(a, c)
put-down(a)
pick-up(c)
stack(c, b)
pick-up(d)
stack(d, a) | SequentialPlan:
unstack(b, d)
put-down(b)
unstack(a, c)
put-down(a)
pick-up(c)
stack(c, b)
pick-up(d)
stack(d, a) | 8 | I am playing with a set of objects.
Here are the actions I can do:
pick-up with ob
put-down with ob
stack with ob, underob
unstack with ob, underob
I have the following restrictions on my actions:
To perform pick-up action, the following facts need to be true: (clear(ob) and ontable(ob) and handempty).
Once pick-up action is performed the following facts will be true: holding(ob).
Once pick-up action is performed the following facts will be false: clear(ob), ontable(ob), handempty.
To perform put-down action, the following facts need to be true: holding(ob).
Once put-down action is performed the following facts will be true: clear(ob), handempty, ontable(ob).
Once put-down action is performed the following facts will be false: holding(ob).
To perform stack action, the following facts need to be true: (clear(underob) and holding(ob)).
Once stack action is performed the following facts will be true: handempty, clear(ob), on(ob, underob).
Once stack action is performed the following facts will be false: clear(underob), holding(ob).
To perform unstack action, the following facts need to be true: (on(ob, underob) and clear(ob) and handempty).
Once unstack action is performed the following facts will be true: holding(ob), clear(underob).
Once unstack action is performed the following facts will be false: on(ob, underob), clear(ob), handempty.
Everything is false by default
[STATEMENT]
As initial conditions I have that, handempty, on(a, c), on(b, d), ontable(c), ontable(d), clear(a), clear(b).
My goal is to have that (on(c, b) and on(d, a)). | unstack(b,d)
put-down(b)
unstack(a,c)
put-down(a)
pick-up(c)
stack(c,b)
pick-up(d)
stack(d,a) | 377 |
(define (domain blocksworld-4ops)
(:requirements :strips)
(:predicates (clear ?x)
(ontable ?x)
(handempty)
(holding ?x)
(on ?x ?y))
(:action pick-up
:parameters (?ob)
:precondition (and (clear ?ob) (ontable ?ob) (handempty))
:effect (and (holding ?ob) (not (clear ?ob)) (not (ontable ?ob))
(not (handempty))))
(:action put-down
:parameters (?ob)
:precondition (holding ?ob)
:effect (and (clear ?ob) (handempty) (ontable ?ob)
(not (holding ?ob))))
(:action stack
:parameters (?ob ?underob)
:precondition (and (clear ?underob) (holding ?ob))
:effect (and (handempty) (clear ?ob) (on ?ob ?underob)
(not (clear ?underob)) (not (holding ?ob))))
(:action unstack
:parameters (?ob ?underob)
:precondition (and (on ?ob ?underob) (clear ?ob) (handempty))
:effect (and (holding ?ob) (clear ?underob)
(not (on ?ob ?underob)) (not (clear ?ob)) (not (handempty)))))
|
(define (problem BW-rand-4)
(:domain blocksworld-4ops)
(:objects a b c d )
(:init
(handempty)
(on a b)
(on b d)
(ontable c)
(ontable d)
(clear a)
(clear c)
)
(:goal
(and
(on b d)
(on c a)
(on d c))
)
)
| status: SOLVED_SATISFICING
engine: Pyperplan
plan: SequentialPlan:
unstack(a, b)
put-down(a)
pick-up(c)
stack(c, a)
unstack(b, d)
put-down(b)
pick-up(d)
stack(d, c)
pick-up(b)
stack(b, d) | SequentialPlan:
unstack(a, b)
put-down(a)
pick-up(c)
stack(c, a)
unstack(b, d)
put-down(b)
pick-up(d)
stack(d, c)
pick-up(b)
stack(b, d) | 10 | I am playing with a set of objects.
Here are the actions I can do:
pick-up with ob
put-down with ob
stack with ob, underob
unstack with ob, underob
I have the following restrictions on my actions:
To perform pick-up action, the following facts need to be true: (clear(ob) and ontable(ob) and handempty).
Once pick-up action is performed the following facts will be true: holding(ob).
Once pick-up action is performed the following facts will be false: clear(ob), ontable(ob), handempty.
To perform put-down action, the following facts need to be true: holding(ob).
Once put-down action is performed the following facts will be true: clear(ob), handempty, ontable(ob).
Once put-down action is performed the following facts will be false: holding(ob).
To perform stack action, the following facts need to be true: (clear(underob) and holding(ob)).
Once stack action is performed the following facts will be true: handempty, clear(ob), on(ob, underob).
Once stack action is performed the following facts will be false: clear(underob), holding(ob).
To perform unstack action, the following facts need to be true: (on(ob, underob) and clear(ob) and handempty).
Once unstack action is performed the following facts will be true: holding(ob), clear(underob).
Once unstack action is performed the following facts will be false: on(ob, underob), clear(ob), handempty.
[STATEMENT]
As initial conditions I have that, handempty, on(a, b), on(b, d), ontable(c), ontable(d), clear(a), clear(c).
My goal is to have that (on(b, d) and on(c, a) and on(d, c)). | unstack(a,b)
put-down(a)
pick-up(c)
stack(c,a)
unstack(b,d)
put-down(b)
pick-up(d)
stack(d,c)
pick-up(b)
stack(b,d) | 377 |
(define (domain blocksworld-4ops)
(:requirements :strips)
(:predicates (clear ?x)
(ontable ?x)
(handempty)
(holding ?x)
(on ?x ?y))
(:action pick-up
:parameters (?ob)
:precondition (and (clear ?ob) (ontable ?ob) (handempty))
:effect (and (holding ?ob) (not (clear ?ob)) (not (ontable ?ob))
(not (handempty))))
(:action put-down
:parameters (?ob)
:precondition (holding ?ob)
:effect (and (clear ?ob) (handempty) (ontable ?ob)
(not (holding ?ob))))
(:action stack
:parameters (?ob ?underob)
:precondition (and (clear ?underob) (holding ?ob))
:effect (and (handempty) (clear ?ob) (on ?ob ?underob)
(not (clear ?underob)) (not (holding ?ob))))
(:action unstack
:parameters (?ob ?underob)
:precondition (and (on ?ob ?underob) (clear ?ob) (handempty))
:effect (and (holding ?ob) (clear ?underob)
(not (on ?ob ?underob)) (not (clear ?ob)) (not (handempty)))))
|
(define (problem BW-rand-4)
(:domain blocksworld-4ops)
(:objects a b c d )
(:init
(handempty)
(ontable a)
(on b c)
(ontable c)
(on d b)
(clear a)
(clear d)
)
(:goal
(and
(on b c)
(on c a)
(on d b))
)
)
| status: SOLVED_SATISFICING
engine: Pyperplan
plan: SequentialPlan:
unstack(d, b)
put-down(d)
unstack(b, c)
put-down(b)
pick-up(d)
stack(d, b)
pick-up(c)
stack(c, a)
unstack(d, b)
put-down(d)
pick-up(b)
stack(b, c)
pick-up(d)
stack(d, b) | SequentialPlan:
unstack(d, b)
put-down(d)
unstack(b, c)
put-down(b)
pick-up(d)
stack(d, b)
pick-up(c)
stack(c, a)
unstack(d, b)
put-down(d)
pick-up(b)
stack(b, c)
pick-up(d)
stack(d, b) | 14 | I am playing with a set of objects.
Here are the actions I can do:
pick-up with ob
put-down with ob
stack with ob, underob
unstack with ob, underob
I have the following restrictions on my actions:
To perform pick-up action, the following facts need to be true: (clear(ob) and ontable(ob) and handempty).
Once pick-up action is performed the following facts will be true: holding(ob).
Once pick-up action is performed the following facts will be false: clear(ob), ontable(ob), handempty.
To perform put-down action, the following facts need to be true: holding(ob).
Once put-down action is performed the following facts will be true: clear(ob), handempty, ontable(ob).
Once put-down action is performed the following facts will be false: holding(ob).
To perform stack action, the following facts need to be true: (clear(underob) and holding(ob)).
Once stack action is performed the following facts will be true: handempty, clear(ob), on(ob, underob).
Once stack action is performed the following facts will be false: clear(underob), holding(ob).
To perform unstack action, the following facts need to be true: (on(ob, underob) and clear(ob) and handempty).
Once unstack action is performed the following facts will be true: holding(ob), clear(underob).
Once unstack action is performed the following facts will be false: on(ob, underob), clear(ob), handempty.
[STATEMENT]
As initial conditions I have that, handempty, ontable(a), on(b, c), ontable(c), on(d, b), clear(a), clear(d).
My goal is to have that (on(b, c) and on(c, a) and on(d, b)). | unstack(d,b)
put-down(d)
unstack(b,c)
put-down(b)
pick-up(d)
stack(d,b)
pick-up(c)
stack(c,a)
unstack(d,b)
put-down(d)
pick-up(b)
stack(b,c)
pick-up(d)
stack(d,b) | 377 |
(define (domain blocksworld-4ops)
(:requirements :strips)
(:predicates (clear ?x)
(ontable ?x)
(handempty)
(holding ?x)
(on ?x ?y))
(:action pick-up
:parameters (?ob)
:precondition (and (clear ?ob) (ontable ?ob) (handempty))
:effect (and (holding ?ob) (not (clear ?ob)) (not (ontable ?ob))
(not (handempty))))
(:action put-down
:parameters (?ob)
:precondition (holding ?ob)
:effect (and (clear ?ob) (handempty) (ontable ?ob)
(not (holding ?ob))))
(:action stack
:parameters (?ob ?underob)
:precondition (and (clear ?underob) (holding ?ob))
:effect (and (handempty) (clear ?ob) (on ?ob ?underob)
(not (clear ?underob)) (not (holding ?ob))))
(:action unstack
:parameters (?ob ?underob)
:precondition (and (on ?ob ?underob) (clear ?ob) (handempty))
:effect (and (holding ?ob) (clear ?underob)
(not (on ?ob ?underob)) (not (clear ?ob)) (not (handempty)))))
|
(define (problem BW-rand-4)
(:domain blocksworld-4ops)
(:objects a b c d )
(:init
(handempty)
(on a d)
(ontable b)
(ontable c)
(ontable d)
(clear a)
(clear b)
(clear c)
)
(:goal
(and
(on a b)
(on b c)
(on c d))
)
)
| status: SOLVED_SATISFICING
engine: Pyperplan
plan: SequentialPlan:
unstack(a, d)
stack(a, b)
pick-up(c)
stack(c, d)
unstack(a, b)
put-down(a)
pick-up(b)
stack(b, c)
pick-up(a)
stack(a, b) | SequentialPlan:
unstack(a, d)
stack(a, b)
pick-up(c)
stack(c, d)
unstack(a, b)
put-down(a)
pick-up(b)
stack(b, c)
pick-up(a)
stack(a, b) | 10 | I am playing with a set of objects.
Here are the actions I can do:
pick-up with ob
put-down with ob
stack with ob, underob
unstack with ob, underob
I have the following restrictions on my actions:
To perform pick-up action, the following facts need to be true: (clear(ob) and ontable(ob) and handempty).
Once pick-up action is performed the following facts will be true: holding(ob).
Once pick-up action is performed the following facts will be false: clear(ob), ontable(ob), handempty.
To perform put-down action, the following facts need to be true: holding(ob).
Once put-down action is performed the following facts will be true: clear(ob), handempty, ontable(ob).
Once put-down action is performed the following facts will be false: holding(ob).
To perform stack action, the following facts need to be true: (clear(underob) and holding(ob)).
Once stack action is performed the following facts will be true: handempty, clear(ob), on(ob, underob).
Once stack action is performed the following facts will be false: clear(underob), holding(ob).
To perform unstack action, the following facts need to be true: (on(ob, underob) and clear(ob) and handempty).
Once unstack action is performed the following facts will be true: holding(ob), clear(underob).
Once unstack action is performed the following facts will be false: on(ob, underob), clear(ob), handempty.
[STATEMENT]
As initial conditions I have that, handempty, on(a, d), ontable(b), ontable(c), ontable(d), clear(a), clear(b), clear(c).
My goal is to have that (on(a, b) and on(b, c) and on(c, d)). | unstack(a,d)
stack(a,b)
pick-up(c)
stack(c,d)
unstack(a,b)
put-down(a)
pick-up(b)
stack(b,c)
pick-up(a)
stack(a,b) | 379 |
(define (domain blocksworld-4ops)
(:requirements :strips)
(:predicates (clear ?x)
(ontable ?x)
(handempty)
(holding ?x)
(on ?x ?y))
(:action pick-up
:parameters (?ob)
:precondition (and (clear ?ob) (ontable ?ob) (handempty))
:effect (and (holding ?ob) (not (clear ?ob)) (not (ontable ?ob))
(not (handempty))))
(:action put-down
:parameters (?ob)
:precondition (holding ?ob)
:effect (and (clear ?ob) (handempty) (ontable ?ob)
(not (holding ?ob))))
(:action stack
:parameters (?ob ?underob)
:precondition (and (clear ?underob) (holding ?ob))
:effect (and (handempty) (clear ?ob) (on ?ob ?underob)
(not (clear ?underob)) (not (holding ?ob))))
(:action unstack
:parameters (?ob ?underob)
:precondition (and (on ?ob ?underob) (clear ?ob) (handempty))
:effect (and (holding ?ob) (clear ?underob)
(not (on ?ob ?underob)) (not (clear ?ob)) (not (handempty)))))
|
(define (problem BW-rand-4)
(:domain blocksworld-4ops)
(:objects a b c d )
(:init
(handempty)
(on a d)
(ontable b)
(ontable c)
(on d b)
(clear a)
(clear c)
)
(:goal
(and
(on a c)
(on b a)
(on d b))
)
)
| status: SOLVED_SATISFICING
engine: Pyperplan
plan: SequentialPlan:
unstack(a, d)
stack(a, c)
unstack(d, b)
put-down(d)
pick-up(b)
stack(b, a)
pick-up(d)
stack(d, b) | SequentialPlan:
unstack(a, d)
stack(a, c)
unstack(d, b)
put-down(d)
pick-up(b)
stack(b, a)
pick-up(d)
stack(d, b) | 8 | I am playing with a set of objects.
Here are the actions I can do:
pick-up with ob
put-down with ob
stack with ob, underob
unstack with ob, underob
I have the following restrictions on my actions:
To perform pick-up action, the following facts need to be true: (clear(ob) and ontable(ob) and handempty).
Once pick-up action is performed the following facts will be true: holding(ob).
Once pick-up action is performed the following facts will be false: clear(ob), ontable(ob), handempty.
To perform put-down action, the following facts need to be true: holding(ob).
Once put-down action is performed the following facts will be true: clear(ob), handempty, ontable(ob).
Once put-down action is performed the following facts will be false: holding(ob).
To perform stack action, the following facts need to be true: (clear(underob) and holding(ob)).
Once stack action is performed the following facts will be true: handempty, clear(ob), on(ob, underob).
Once stack action is performed the following facts will be false: clear(underob), holding(ob).
To perform unstack action, the following facts need to be true: (on(ob, underob) and clear(ob) and handempty).
Once unstack action is performed the following facts will be true: holding(ob), clear(underob).
Once unstack action is performed the following facts will be false: on(ob, underob), clear(ob), handempty.
Everything is false by default
[STATEMENT]
As initial conditions I have that, handempty, on(a, d), ontable(b), ontable(c), on(d, b), clear(a), clear(c).
My goal is to have that (on(a, c) and on(b, a) and on(d, b)). | unstack(a,d)
stack(a,c)
unstack(d,b)
put-down(d)
pick-up(b)
stack(b,a)
pick-up(d)
stack(d,b) | 383 |
(define (domain blocksworld-4ops)
(:requirements :strips)
(:predicates (clear ?x)
(ontable ?x)
(handempty)
(holding ?x)
(on ?x ?y))
(:action pick-up
:parameters (?ob)
:precondition (and (clear ?ob) (ontable ?ob) (handempty))
:effect (and (holding ?ob) (not (clear ?ob)) (not (ontable ?ob))
(not (handempty))))
(:action put-down
:parameters (?ob)
:precondition (holding ?ob)
:effect (and (clear ?ob) (handempty) (ontable ?ob)
(not (holding ?ob))))
(:action stack
:parameters (?ob ?underob)
:precondition (and (clear ?underob) (holding ?ob))
:effect (and (handempty) (clear ?ob) (on ?ob ?underob)
(not (clear ?underob)) (not (holding ?ob))))
(:action unstack
:parameters (?ob ?underob)
:precondition (and (on ?ob ?underob) (clear ?ob) (handempty))
:effect (and (holding ?ob) (clear ?underob)
(not (on ?ob ?underob)) (not (clear ?ob)) (not (handempty)))))
|
(define (problem BW-rand-4)
(:domain blocksworld-4ops)
(:objects a b c d )
(:init
(handempty)
(on a b)
(ontable b)
(on c d)
(ontable d)
(clear a)
(clear c)
)
(:goal
(and
(on c a))
)
)
| status: SOLVED_SATISFICING
engine: Pyperplan
plan: SequentialPlan:
unstack(c, d)
stack(c, a) | SequentialPlan:
unstack(c, d)
stack(c, a) | 2 | I am playing with a set of objects.
Here are the actions I can do:
pick-up with ob
put-down with ob
stack with ob, underob
unstack with ob, underob
I have the following restrictions on my actions:
To perform pick-up action, the following facts need to be true: (clear(ob) and ontable(ob) and handempty).
Once pick-up action is performed the following facts will be true: holding(ob).
Once pick-up action is performed the following facts will be false: clear(ob), ontable(ob), handempty.
To perform put-down action, the following facts need to be true: holding(ob).
Once put-down action is performed the following facts will be true: clear(ob), handempty, ontable(ob).
Once put-down action is performed the following facts will be false: holding(ob).
To perform stack action, the following facts need to be true: (clear(underob) and holding(ob)).
Once stack action is performed the following facts will be true: handempty, clear(ob), on(ob, underob).
Once stack action is performed the following facts will be false: clear(underob), holding(ob).
To perform unstack action, the following facts need to be true: (on(ob, underob) and clear(ob) and handempty).
Once unstack action is performed the following facts will be true: holding(ob), clear(underob).
Once unstack action is performed the following facts will be false: on(ob, underob), clear(ob), handempty.
Everything is false by default
[STATEMENT]
As initial conditions I have that, handempty, on(a, b), ontable(b), on(c, d), ontable(d), clear(a), clear(c).
My goal is to have that on(c, a). | unstack(c,d)
stack(c,a) | 370 |
(define (domain blocksworld-4ops)
(:requirements :strips)
(:predicates (clear ?x)
(ontable ?x)
(handempty)
(holding ?x)
(on ?x ?y))
(:action pick-up
:parameters (?ob)
:precondition (and (clear ?ob) (ontable ?ob) (handempty))
:effect (and (holding ?ob) (not (clear ?ob)) (not (ontable ?ob))
(not (handempty))))
(:action put-down
:parameters (?ob)
:precondition (holding ?ob)
:effect (and (clear ?ob) (handempty) (ontable ?ob)
(not (holding ?ob))))
(:action stack
:parameters (?ob ?underob)
:precondition (and (clear ?underob) (holding ?ob))
:effect (and (handempty) (clear ?ob) (on ?ob ?underob)
(not (clear ?underob)) (not (holding ?ob))))
(:action unstack
:parameters (?ob ?underob)
:precondition (and (on ?ob ?underob) (clear ?ob) (handempty))
:effect (and (holding ?ob) (clear ?underob)
(not (on ?ob ?underob)) (not (clear ?ob)) (not (handempty)))))
|
(define (problem BW-rand-4)
(:domain blocksworld-4ops)
(:objects a b c d )
(:init
(handempty)
(on a c)
(ontable b)
(on c b)
(ontable d)
(clear a)
(clear d)
)
(:goal
(and
(on d c))
)
)
| status: SOLVED_SATISFICING
engine: Pyperplan
plan: SequentialPlan:
unstack(a, c)
put-down(a)
pick-up(d)
stack(d, c) | SequentialPlan:
unstack(a, c)
put-down(a)
pick-up(d)
stack(d, c) | 4 | I am playing with a set of objects.
Here are the actions I can do:
pick-up with ob
put-down with ob
stack with ob, underob
unstack with ob, underob
I have the following restrictions on my actions:
To perform pick-up action, the following facts need to be true: (clear(ob) and ontable(ob) and handempty).
Once pick-up action is performed the following facts will be true: holding(ob).
Once pick-up action is performed the following facts will be false: clear(ob), ontable(ob), handempty.
To perform put-down action, the following facts need to be true: holding(ob).
Once put-down action is performed the following facts will be true: clear(ob), handempty, ontable(ob).
Once put-down action is performed the following facts will be false: holding(ob).
To perform stack action, the following facts need to be true: (clear(underob) and holding(ob)).
Once stack action is performed the following facts will be true: handempty, clear(ob), on(ob, underob).
Once stack action is performed the following facts will be false: clear(underob), holding(ob).
To perform unstack action, the following facts need to be true: (on(ob, underob) and clear(ob) and handempty).
Once unstack action is performed the following facts will be true: holding(ob), clear(underob).
Once unstack action is performed the following facts will be false: on(ob, underob), clear(ob), handempty.
[STATEMENT]
As initial conditions I have that, handempty, on(a, c), ontable(b), on(c, b), ontable(d), clear(a), clear(d).
My goal is to have that on(d, c). | unstack(a,c)
put-down(a)
pick-up(d)
stack(d,c) | 364 |
(define (domain blocksworld-4ops)
(:requirements :strips)
(:predicates (clear ?x)
(ontable ?x)
(handempty)
(holding ?x)
(on ?x ?y))
(:action pick-up
:parameters (?ob)
:precondition (and (clear ?ob) (ontable ?ob) (handempty))
:effect (and (holding ?ob) (not (clear ?ob)) (not (ontable ?ob))
(not (handempty))))
(:action put-down
:parameters (?ob)
:precondition (holding ?ob)
:effect (and (clear ?ob) (handempty) (ontable ?ob)
(not (holding ?ob))))
(:action stack
:parameters (?ob ?underob)
:precondition (and (clear ?underob) (holding ?ob))
:effect (and (handempty) (clear ?ob) (on ?ob ?underob)
(not (clear ?underob)) (not (holding ?ob))))
(:action unstack
:parameters (?ob ?underob)
:precondition (and (on ?ob ?underob) (clear ?ob) (handempty))
:effect (and (holding ?ob) (clear ?underob)
(not (on ?ob ?underob)) (not (clear ?ob)) (not (handempty)))))
|
(define (problem BW-rand-4)
(:domain blocksworld-4ops)
(:objects a b c d )
(:init
(handempty)
(ontable a)
(on b c)
(ontable c)
(ontable d)
(clear a)
(clear b)
(clear d)
)
(:goal
(and
(on a d)
(on c a))
)
)
| status: SOLVED_SATISFICING
engine: Pyperplan
plan: SequentialPlan:
unstack(b, c)
put-down(b)
pick-up(a)
stack(a, d)
pick-up(c)
stack(c, a) | SequentialPlan:
unstack(b, c)
put-down(b)
pick-up(a)
stack(a, d)
pick-up(c)
stack(c, a) | 6 | I am playing with a set of objects.
Here are the actions I can do:
pick-up with ob
put-down with ob
stack with ob, underob
unstack with ob, underob
I have the following restrictions on my actions:
To perform pick-up action, the following facts need to be true: (clear(ob) and ontable(ob) and handempty).
Once pick-up action is performed the following facts will be true: holding(ob).
Once pick-up action is performed the following facts will be false: clear(ob), ontable(ob), handempty.
To perform put-down action, the following facts need to be true: holding(ob).
Once put-down action is performed the following facts will be true: clear(ob), handempty, ontable(ob).
Once put-down action is performed the following facts will be false: holding(ob).
To perform stack action, the following facts need to be true: (clear(underob) and holding(ob)).
Once stack action is performed the following facts will be true: handempty, clear(ob), on(ob, underob).
Once stack action is performed the following facts will be false: clear(underob), holding(ob).
To perform unstack action, the following facts need to be true: (on(ob, underob) and clear(ob) and handempty).
Once unstack action is performed the following facts will be true: holding(ob), clear(underob).
Once unstack action is performed the following facts will be false: on(ob, underob), clear(ob), handempty.
Everything is false by default
[STATEMENT]
As initial conditions I have that, handempty, ontable(a), on(b, c), ontable(c), ontable(d), clear(a), clear(b), clear(d).
My goal is to have that (on(a, d) and on(c, a)). | unstack(b,c)
put-down(b)
pick-up(a)
stack(a,d)
pick-up(c)
stack(c,a) | 379 |
(define (domain blocksworld-4ops)
(:requirements :strips)
(:predicates (clear ?x)
(ontable ?x)
(handempty)
(holding ?x)
(on ?x ?y))
(:action pick-up
:parameters (?ob)
:precondition (and (clear ?ob) (ontable ?ob) (handempty))
:effect (and (holding ?ob) (not (clear ?ob)) (not (ontable ?ob))
(not (handempty))))
(:action put-down
:parameters (?ob)
:precondition (holding ?ob)
:effect (and (clear ?ob) (handempty) (ontable ?ob)
(not (holding ?ob))))
(:action stack
:parameters (?ob ?underob)
:precondition (and (clear ?underob) (holding ?ob))
:effect (and (handempty) (clear ?ob) (on ?ob ?underob)
(not (clear ?underob)) (not (holding ?ob))))
(:action unstack
:parameters (?ob ?underob)
:precondition (and (on ?ob ?underob) (clear ?ob) (handempty))
:effect (and (holding ?ob) (clear ?underob)
(not (on ?ob ?underob)) (not (clear ?ob)) (not (handempty)))))
|
(define (problem BW-rand-4)
(:domain blocksworld-4ops)
(:objects a b c d )
(:init
(handempty)
(ontable a)
(on b c)
(on c a)
(on d b)
(clear d)
)
(:goal
(and
(on b a)
(on c b)
(on d c))
)
)
| status: SOLVED_SATISFICING
engine: Pyperplan
plan: SequentialPlan:
unstack(d, b)
put-down(d)
unstack(b, c)
put-down(b)
unstack(c, a)
put-down(c)
pick-up(d)
stack(d, c)
pick-up(b)
stack(b, a)
unstack(d, c)
put-down(d)
pick-up(c)
stack(c, b)
pick-up(d)
stack(d, c) | SequentialPlan:
unstack(d, b)
put-down(d)
unstack(b, c)
put-down(b)
unstack(c, a)
put-down(c)
pick-up(d)
stack(d, c)
pick-up(b)
stack(b, a)
unstack(d, c)
put-down(d)
pick-up(c)
stack(c, b)
pick-up(d)
stack(d, c) | 16 | I am playing with a set of objects.
Here are the actions I can do:
pick-up with ob
put-down with ob
stack with ob, underob
unstack with ob, underob
I have the following restrictions on my actions:
To perform pick-up action, the following facts need to be true: (clear(ob) and ontable(ob) and handempty).
Once pick-up action is performed the following facts will be true: holding(ob).
Once pick-up action is performed the following facts will be false: clear(ob), ontable(ob), handempty.
To perform put-down action, the following facts need to be true: holding(ob).
Once put-down action is performed the following facts will be true: clear(ob), handempty, ontable(ob).
Once put-down action is performed the following facts will be false: holding(ob).
To perform stack action, the following facts need to be true: (clear(underob) and holding(ob)).
Once stack action is performed the following facts will be true: handempty, clear(ob), on(ob, underob).
Once stack action is performed the following facts will be false: clear(underob), holding(ob).
To perform unstack action, the following facts need to be true: (on(ob, underob) and clear(ob) and handempty).
Once unstack action is performed the following facts will be true: holding(ob), clear(underob).
Once unstack action is performed the following facts will be false: on(ob, underob), clear(ob), handempty.
Everything is false by default
[STATEMENT]
As initial conditions I have that, handempty, ontable(a), on(b, c), on(c, a), on(d, b), clear(d).
My goal is to have that (on(b, a) and on(c, b) and on(d, c)). | unstack(d,b)
put-down(d)
unstack(b,c)
put-down(b)
unstack(c,a)
put-down(c)
pick-up(d)
stack(d,c)
pick-up(b)
stack(b,a)
unstack(d,c)
put-down(d)
pick-up(c)
stack(c,b)
pick-up(d)
stack(d,c) | 381 |
(define (domain blocksworld-4ops)
(:requirements :strips)
(:predicates (clear ?x)
(ontable ?x)
(handempty)
(holding ?x)
(on ?x ?y))
(:action pick-up
:parameters (?ob)
:precondition (and (clear ?ob) (ontable ?ob) (handempty))
:effect (and (holding ?ob) (not (clear ?ob)) (not (ontable ?ob))
(not (handempty))))
(:action put-down
:parameters (?ob)
:precondition (holding ?ob)
:effect (and (clear ?ob) (handempty) (ontable ?ob)
(not (holding ?ob))))
(:action stack
:parameters (?ob ?underob)
:precondition (and (clear ?underob) (holding ?ob))
:effect (and (handempty) (clear ?ob) (on ?ob ?underob)
(not (clear ?underob)) (not (holding ?ob))))
(:action unstack
:parameters (?ob ?underob)
:precondition (and (on ?ob ?underob) (clear ?ob) (handempty))
:effect (and (holding ?ob) (clear ?underob)
(not (on ?ob ?underob)) (not (clear ?ob)) (not (handempty)))))
|
(define (problem BW-rand-4)
(:domain blocksworld-4ops)
(:objects a b c d )
(:init
(handempty)
(on a d)
(on b a)
(ontable c)
(ontable d)
(clear b)
(clear c)
)
(:goal
(and
(on b d)
(on c a))
)
)
| status: SOLVED_SATISFICING
engine: Pyperplan
plan: SequentialPlan:
unstack(b, a)
put-down(b)
unstack(a, d)
put-down(a)
pick-up(c)
stack(c, a)
pick-up(b)
stack(b, d) | SequentialPlan:
unstack(b, a)
put-down(b)
unstack(a, d)
put-down(a)
pick-up(c)
stack(c, a)
pick-up(b)
stack(b, d) | 8 | I am playing with a set of objects.
Here are the actions I can do:
pick-up with ob
put-down with ob
stack with ob, underob
unstack with ob, underob
I have the following restrictions on my actions:
To perform pick-up action, the following facts need to be true: (clear(ob) and ontable(ob) and handempty).
Once pick-up action is performed the following facts will be true: holding(ob).
Once pick-up action is performed the following facts will be false: clear(ob), ontable(ob), handempty.
To perform put-down action, the following facts need to be true: holding(ob).
Once put-down action is performed the following facts will be true: clear(ob), handempty, ontable(ob).
Once put-down action is performed the following facts will be false: holding(ob).
To perform stack action, the following facts need to be true: (clear(underob) and holding(ob)).
Once stack action is performed the following facts will be true: handempty, clear(ob), on(ob, underob).
Once stack action is performed the following facts will be false: clear(underob), holding(ob).
To perform unstack action, the following facts need to be true: (on(ob, underob) and clear(ob) and handempty).
Once unstack action is performed the following facts will be true: holding(ob), clear(underob).
Once unstack action is performed the following facts will be false: on(ob, underob), clear(ob), handempty.
Everything is false by default
[STATEMENT]
As initial conditions I have that, handempty, on(a, d), on(b, a), ontable(c), ontable(d), clear(b), clear(c).
My goal is to have that (on(b, d) and on(c, a)). | unstack(b,a)
put-down(b)
unstack(a,d)
put-down(a)
pick-up(c)
stack(c,a)
pick-up(b)
stack(b,d) | 377 |
(define (domain blocksworld-4ops)
(:requirements :strips)
(:predicates (clear ?x)
(ontable ?x)
(handempty)
(holding ?x)
(on ?x ?y))
(:action pick-up
:parameters (?ob)
:precondition (and (clear ?ob) (ontable ?ob) (handempty))
:effect (and (holding ?ob) (not (clear ?ob)) (not (ontable ?ob))
(not (handempty))))
(:action put-down
:parameters (?ob)
:precondition (holding ?ob)
:effect (and (clear ?ob) (handempty) (ontable ?ob)
(not (holding ?ob))))
(:action stack
:parameters (?ob ?underob)
:precondition (and (clear ?underob) (holding ?ob))
:effect (and (handempty) (clear ?ob) (on ?ob ?underob)
(not (clear ?underob)) (not (holding ?ob))))
(:action unstack
:parameters (?ob ?underob)
:precondition (and (on ?ob ?underob) (clear ?ob) (handempty))
:effect (and (holding ?ob) (clear ?underob)
(not (on ?ob ?underob)) (not (clear ?ob)) (not (handempty)))))
|
(define (problem BW-rand-4)
(:domain blocksworld-4ops)
(:objects a b c d )
(:init
(handempty)
(on a b)
(ontable b)
(on c a)
(ontable d)
(clear c)
(clear d)
)
(:goal
(and
(on b c)
(on c d)
(on d a))
)
)
| status: SOLVED_SATISFICING
engine: Pyperplan
plan: SequentialPlan:
unstack(c, a)
stack(c, d)
unstack(a, b)
put-down(a)
unstack(c, d)
put-down(c)
pick-up(b)
stack(b, c)
pick-up(d)
stack(d, a)
unstack(b, c)
put-down(b)
pick-up(c)
stack(c, d)
pick-up(b)
stack(b, c) | SequentialPlan:
unstack(c, a)
stack(c, d)
unstack(a, b)
put-down(a)
unstack(c, d)
put-down(c)
pick-up(b)
stack(b, c)
pick-up(d)
stack(d, a)
unstack(b, c)
put-down(b)
pick-up(c)
stack(c, d)
pick-up(b)
stack(b, c) | 16 | I am playing with a set of objects.
Here are the actions I can do:
pick-up with ob
put-down with ob
stack with ob, underob
unstack with ob, underob
I have the following restrictions on my actions:
To perform pick-up action, the following facts need to be true: (clear(ob) and ontable(ob) and handempty).
Once pick-up action is performed the following facts will be true: holding(ob).
Once pick-up action is performed the following facts will be false: clear(ob), ontable(ob), handempty.
To perform put-down action, the following facts need to be true: holding(ob).
Once put-down action is performed the following facts will be true: clear(ob), handempty, ontable(ob).
Once put-down action is performed the following facts will be false: holding(ob).
To perform stack action, the following facts need to be true: (clear(underob) and holding(ob)).
Once stack action is performed the following facts will be true: handempty, clear(ob), on(ob, underob).
Once stack action is performed the following facts will be false: clear(underob), holding(ob).
To perform unstack action, the following facts need to be true: (on(ob, underob) and clear(ob) and handempty).
Once unstack action is performed the following facts will be true: holding(ob), clear(underob).
Once unstack action is performed the following facts will be false: on(ob, underob), clear(ob), handempty.
Everything is false by default
[STATEMENT]
As initial conditions I have that, handempty, on(a, b), ontable(b), on(c, a), ontable(d), clear(c), clear(d).
My goal is to have that (on(b, c) and on(c, d) and on(d, a)). | unstack(c,a)
stack(c,d)
unstack(a,b)
put-down(a)
unstack(c,d)
put-down(c)
pick-up(b)
stack(b,c)
pick-up(d)
stack(d,a)
unstack(b,c)
put-down(b)
pick-up(c)
stack(c,d)
pick-up(b)
stack(b,c) | 383 |
(define (domain blocksworld-4ops)
(:requirements :strips)
(:predicates (clear ?x)
(ontable ?x)
(handempty)
(holding ?x)
(on ?x ?y))
(:action pick-up
:parameters (?ob)
:precondition (and (clear ?ob) (ontable ?ob) (handempty))
:effect (and (holding ?ob) (not (clear ?ob)) (not (ontable ?ob))
(not (handempty))))
(:action put-down
:parameters (?ob)
:precondition (holding ?ob)
:effect (and (clear ?ob) (handempty) (ontable ?ob)
(not (holding ?ob))))
(:action stack
:parameters (?ob ?underob)
:precondition (and (clear ?underob) (holding ?ob))
:effect (and (handempty) (clear ?ob) (on ?ob ?underob)
(not (clear ?underob)) (not (holding ?ob))))
(:action unstack
:parameters (?ob ?underob)
:precondition (and (on ?ob ?underob) (clear ?ob) (handempty))
:effect (and (holding ?ob) (clear ?underob)
(not (on ?ob ?underob)) (not (clear ?ob)) (not (handempty)))))
|
(define (problem BW-rand-4)
(:domain blocksworld-4ops)
(:objects a b c d )
(:init
(handempty)
(on a d)
(on b a)
(ontable c)
(on d c)
(clear b)
)
(:goal
(and
(on a b)
(on c d))
)
)
| status: SOLVED_SATISFICING
engine: Pyperplan
plan: SequentialPlan:
unstack(b, a)
put-down(b)
unstack(a, d)
stack(a, b)
unstack(d, c)
put-down(d)
pick-up(c)
stack(c, d) | SequentialPlan:
unstack(b, a)
put-down(b)
unstack(a, d)
stack(a, b)
unstack(d, c)
put-down(d)
pick-up(c)
stack(c, d) | 8 | I am playing with a set of objects.
Here are the actions I can do:
pick-up with ob
put-down with ob
stack with ob, underob
unstack with ob, underob
I have the following restrictions on my actions:
To perform pick-up action, the following facts need to be true: (clear(ob) and ontable(ob) and handempty).
Once pick-up action is performed the following facts will be true: holding(ob).
Once pick-up action is performed the following facts will be false: clear(ob), ontable(ob), handempty.
To perform put-down action, the following facts need to be true: holding(ob).
Once put-down action is performed the following facts will be true: clear(ob), handempty, ontable(ob).
Once put-down action is performed the following facts will be false: holding(ob).
To perform stack action, the following facts need to be true: (clear(underob) and holding(ob)).
Once stack action is performed the following facts will be true: handempty, clear(ob), on(ob, underob).
Once stack action is performed the following facts will be false: clear(underob), holding(ob).
To perform unstack action, the following facts need to be true: (on(ob, underob) and clear(ob) and handempty).
Once unstack action is performed the following facts will be true: holding(ob), clear(underob).
Once unstack action is performed the following facts will be false: on(ob, underob), clear(ob), handempty.
Everything is false by default
[STATEMENT]
As initial conditions I have that, handempty, on(a, d), on(b, a), ontable(c), on(d, c), clear(b).
My goal is to have that (on(a, b) and on(c, d)). | unstack(b,a)
put-down(b)
unstack(a,d)
stack(a,b)
unstack(d,c)
put-down(d)
pick-up(c)
stack(c,d) | 375 |
(define (domain blocksworld-4ops)
(:requirements :strips)
(:predicates (clear ?x)
(ontable ?x)
(handempty)
(holding ?x)
(on ?x ?y))
(:action pick-up
:parameters (?ob)
:precondition (and (clear ?ob) (ontable ?ob) (handempty))
:effect (and (holding ?ob) (not (clear ?ob)) (not (ontable ?ob))
(not (handempty))))
(:action put-down
:parameters (?ob)
:precondition (holding ?ob)
:effect (and (clear ?ob) (handempty) (ontable ?ob)
(not (holding ?ob))))
(:action stack
:parameters (?ob ?underob)
:precondition (and (clear ?underob) (holding ?ob))
:effect (and (handempty) (clear ?ob) (on ?ob ?underob)
(not (clear ?underob)) (not (holding ?ob))))
(:action unstack
:parameters (?ob ?underob)
:precondition (and (on ?ob ?underob) (clear ?ob) (handempty))
:effect (and (holding ?ob) (clear ?underob)
(not (on ?ob ?underob)) (not (clear ?ob)) (not (handempty)))))
|
(define (problem BW-rand-4)
(:domain blocksworld-4ops)
(:objects a b c d )
(:init
(handempty)
(ontable a)
(ontable b)
(ontable c)
(on d c)
(clear a)
(clear b)
(clear d)
)
(:goal
(and
(on a d)
(on b a)
(on c b))
)
)
| status: SOLVED_SATISFICING
engine: Pyperplan
plan: SequentialPlan:
pick-up(b)
stack(b, a)
unstack(d, c)
put-down(d)
unstack(b, a)
put-down(b)
pick-up(c)
stack(c, b)
pick-up(a)
stack(a, d)
unstack(c, b)
put-down(c)
pick-up(b)
stack(b, a)
pick-up(c)
stack(c, b) | SequentialPlan:
pick-up(b)
stack(b, a)
unstack(d, c)
put-down(d)
unstack(b, a)
put-down(b)
pick-up(c)
stack(c, b)
pick-up(a)
stack(a, d)
unstack(c, b)
put-down(c)
pick-up(b)
stack(b, a)
pick-up(c)
stack(c, b) | 16 | I am playing with a set of objects.
Here are the actions I can do:
pick-up with ob
put-down with ob
stack with ob, underob
unstack with ob, underob
I have the following restrictions on my actions:
To perform pick-up action, the following facts need to be true: (clear(ob) and ontable(ob) and handempty).
Once pick-up action is performed the following facts will be true: holding(ob).
Once pick-up action is performed the following facts will be false: clear(ob), ontable(ob), handempty.
To perform put-down action, the following facts need to be true: holding(ob).
Once put-down action is performed the following facts will be true: clear(ob), handempty, ontable(ob).
Once put-down action is performed the following facts will be false: holding(ob).
To perform stack action, the following facts need to be true: (clear(underob) and holding(ob)).
Once stack action is performed the following facts will be true: handempty, clear(ob), on(ob, underob).
Once stack action is performed the following facts will be false: clear(underob), holding(ob).
To perform unstack action, the following facts need to be true: (on(ob, underob) and clear(ob) and handempty).
Once unstack action is performed the following facts will be true: holding(ob), clear(underob).
Once unstack action is performed the following facts will be false: on(ob, underob), clear(ob), handempty.
Everything is false by default
[STATEMENT]
As initial conditions I have that, handempty, ontable(a), ontable(b), ontable(c), on(d, c), clear(a), clear(b), clear(d).
My goal is to have that (on(a, d) and on(b, a) and on(c, b)). | pick-up(b)
stack(b,a)
unstack(d,c)
put-down(d)
unstack(b,a)
put-down(b)
pick-up(c)
stack(c,b)
pick-up(a)
stack(a,d)
unstack(c,b)
put-down(c)
pick-up(b)
stack(b,a)
pick-up(c)
stack(c,b) | 385 |
(define (domain blocksworld-4ops)
(:requirements :strips)
(:predicates (clear ?x)
(ontable ?x)
(handempty)
(holding ?x)
(on ?x ?y))
(:action pick-up
:parameters (?ob)
:precondition (and (clear ?ob) (ontable ?ob) (handempty))
:effect (and (holding ?ob) (not (clear ?ob)) (not (ontable ?ob))
(not (handempty))))
(:action put-down
:parameters (?ob)
:precondition (holding ?ob)
:effect (and (clear ?ob) (handempty) (ontable ?ob)
(not (holding ?ob))))
(:action stack
:parameters (?ob ?underob)
:precondition (and (clear ?underob) (holding ?ob))
:effect (and (handempty) (clear ?ob) (on ?ob ?underob)
(not (clear ?underob)) (not (holding ?ob))))
(:action unstack
:parameters (?ob ?underob)
:precondition (and (on ?ob ?underob) (clear ?ob) (handempty))
:effect (and (holding ?ob) (clear ?underob)
(not (on ?ob ?underob)) (not (clear ?ob)) (not (handempty)))))
|
(define (problem BW-rand-4)
(:domain blocksworld-4ops)
(:objects a b c d )
(:init
(handempty)
(ontable a)
(on b a)
(ontable c)
(on d b)
(clear c)
(clear d)
)
(:goal
(and
(on b a)
(on c b))
)
)
| status: SOLVED_SATISFICING
engine: Pyperplan
plan: SequentialPlan:
unstack(d, b)
put-down(d)
pick-up(c)
stack(c, b) | SequentialPlan:
unstack(d, b)
put-down(d)
pick-up(c)
stack(c, b) | 4 | I am playing with a set of objects.
Here are the actions I can do:
pick-up with ob
put-down with ob
stack with ob, underob
unstack with ob, underob
I have the following restrictions on my actions:
To perform pick-up action, the following facts need to be true: (clear(ob) and ontable(ob) and handempty).
Once pick-up action is performed the following facts will be true: holding(ob).
Once pick-up action is performed the following facts will be false: clear(ob), ontable(ob), handempty.
To perform put-down action, the following facts need to be true: holding(ob).
Once put-down action is performed the following facts will be true: clear(ob), handempty, ontable(ob).
Once put-down action is performed the following facts will be false: holding(ob).
To perform stack action, the following facts need to be true: (clear(underob) and holding(ob)).
Once stack action is performed the following facts will be true: handempty, clear(ob), on(ob, underob).
Once stack action is performed the following facts will be false: clear(underob), holding(ob).
To perform unstack action, the following facts need to be true: (on(ob, underob) and clear(ob) and handempty).
Once unstack action is performed the following facts will be true: holding(ob), clear(underob).
Once unstack action is performed the following facts will be false: on(ob, underob), clear(ob), handempty.
Everything is false by default
[STATEMENT]
As initial conditions I have that, handempty, ontable(a), on(b, a), ontable(c), on(d, b), clear(c), clear(d).
My goal is to have that (on(b, a) and on(c, b)). | unstack(d,b)
put-down(d)
pick-up(c)
stack(c,b) | 377 |
(define (domain blocksworld-4ops)
(:requirements :strips)
(:predicates (clear ?x)
(ontable ?x)
(handempty)
(holding ?x)
(on ?x ?y))
(:action pick-up
:parameters (?ob)
:precondition (and (clear ?ob) (ontable ?ob) (handempty))
:effect (and (holding ?ob) (not (clear ?ob)) (not (ontable ?ob))
(not (handempty))))
(:action put-down
:parameters (?ob)
:precondition (holding ?ob)
:effect (and (clear ?ob) (handempty) (ontable ?ob)
(not (holding ?ob))))
(:action stack
:parameters (?ob ?underob)
:precondition (and (clear ?underob) (holding ?ob))
:effect (and (handempty) (clear ?ob) (on ?ob ?underob)
(not (clear ?underob)) (not (holding ?ob))))
(:action unstack
:parameters (?ob ?underob)
:precondition (and (on ?ob ?underob) (clear ?ob) (handempty))
:effect (and (holding ?ob) (clear ?underob)
(not (on ?ob ?underob)) (not (clear ?ob)) (not (handempty)))))
|
(define (problem BW-rand-4)
(:domain blocksworld-4ops)
(:objects a b c d )
(:init
(handempty)
(ontable a)
(on b a)
(on c d)
(on d b)
(clear c)
)
(:goal
(and
(on a c)
(on b a))
)
)
| status: SOLVED_SATISFICING
engine: Pyperplan
plan: SequentialPlan:
unstack(c, d)
put-down(c)
unstack(d, b)
put-down(d)
unstack(b, a)
put-down(b)
pick-up(a)
stack(a, c)
pick-up(b)
stack(b, a) | SequentialPlan:
unstack(c, d)
put-down(c)
unstack(d, b)
put-down(d)
unstack(b, a)
put-down(b)
pick-up(a)
stack(a, c)
pick-up(b)
stack(b, a) | 10 | I am playing with a set of objects.
Here are the actions I can do:
pick-up with ob
put-down with ob
stack with ob, underob
unstack with ob, underob
I have the following restrictions on my actions:
To perform pick-up action, the following facts need to be true: (clear(ob) and ontable(ob) and handempty).
Once pick-up action is performed the following facts will be true: holding(ob).
Once pick-up action is performed the following facts will be false: clear(ob), ontable(ob), handempty.
To perform put-down action, the following facts need to be true: holding(ob).
Once put-down action is performed the following facts will be true: clear(ob), handempty, ontable(ob).
Once put-down action is performed the following facts will be false: holding(ob).
To perform stack action, the following facts need to be true: (clear(underob) and holding(ob)).
Once stack action is performed the following facts will be true: handempty, clear(ob), on(ob, underob).
Once stack action is performed the following facts will be false: clear(underob), holding(ob).
To perform unstack action, the following facts need to be true: (on(ob, underob) and clear(ob) and handempty).
Once unstack action is performed the following facts will be true: holding(ob), clear(underob).
Once unstack action is performed the following facts will be false: on(ob, underob), clear(ob), handempty.
[STATEMENT]
As initial conditions I have that, handempty, ontable(a), on(b, a), on(c, d), on(d, b), clear(c).
My goal is to have that (on(a, c) and on(b, a)). | unstack(c,d)
put-down(c)
unstack(d,b)
put-down(d)
unstack(b,a)
put-down(b)
pick-up(a)
stack(a,c)
pick-up(b)
stack(b,a) | 369 |
(define (domain blocksworld-4ops)
(:requirements :strips)
(:predicates (clear ?x)
(ontable ?x)
(handempty)
(holding ?x)
(on ?x ?y))
(:action pick-up
:parameters (?ob)
:precondition (and (clear ?ob) (ontable ?ob) (handempty))
:effect (and (holding ?ob) (not (clear ?ob)) (not (ontable ?ob))
(not (handempty))))
(:action put-down
:parameters (?ob)
:precondition (holding ?ob)
:effect (and (clear ?ob) (handempty) (ontable ?ob)
(not (holding ?ob))))
(:action stack
:parameters (?ob ?underob)
:precondition (and (clear ?underob) (holding ?ob))
:effect (and (handempty) (clear ?ob) (on ?ob ?underob)
(not (clear ?underob)) (not (holding ?ob))))
(:action unstack
:parameters (?ob ?underob)
:precondition (and (on ?ob ?underob) (clear ?ob) (handempty))
:effect (and (holding ?ob) (clear ?underob)
(not (on ?ob ?underob)) (not (clear ?ob)) (not (handempty)))))
|
(define (problem BW-rand-4)
(:domain blocksworld-4ops)
(:objects a b c d )
(:init
(handempty)
(ontable a)
(on b a)
(ontable c)
(on d c)
(clear b)
(clear d)
)
(:goal
(and
(on a b)
(on c d)
(on d a))
)
)
| status: SOLVED_SATISFICING
engine: Pyperplan
plan: SequentialPlan:
unstack(b, a)
put-down(b)
unstack(d, c)
put-down(d)
pick-up(c)
stack(c, d)
pick-up(a)
stack(a, b)
unstack(c, d)
put-down(c)
pick-up(d)
stack(d, a)
pick-up(c)
stack(c, d) | SequentialPlan:
unstack(b, a)
put-down(b)
unstack(d, c)
put-down(d)
pick-up(c)
stack(c, d)
pick-up(a)
stack(a, b)
unstack(c, d)
put-down(c)
pick-up(d)
stack(d, a)
pick-up(c)
stack(c, d) | 14 | I am playing with a set of objects.
Here are the actions I can do:
pick-up with ob
put-down with ob
stack with ob, underob
unstack with ob, underob
I have the following restrictions on my actions:
To perform pick-up action, the following facts need to be true: (clear(ob) and ontable(ob) and handempty).
Once pick-up action is performed the following facts will be true: holding(ob).
Once pick-up action is performed the following facts will be false: clear(ob), ontable(ob), handempty.
To perform put-down action, the following facts need to be true: holding(ob).
Once put-down action is performed the following facts will be true: clear(ob), handempty, ontable(ob).
Once put-down action is performed the following facts will be false: holding(ob).
To perform stack action, the following facts need to be true: (clear(underob) and holding(ob)).
Once stack action is performed the following facts will be true: handempty, clear(ob), on(ob, underob).
Once stack action is performed the following facts will be false: clear(underob), holding(ob).
To perform unstack action, the following facts need to be true: (on(ob, underob) and clear(ob) and handempty).
Once unstack action is performed the following facts will be true: holding(ob), clear(underob).
Once unstack action is performed the following facts will be false: on(ob, underob), clear(ob), handempty.
[STATEMENT]
As initial conditions I have that, handempty, ontable(a), on(b, a), ontable(c), on(d, c), clear(b), clear(d).
My goal is to have that (on(a, b) and on(c, d) and on(d, a)). | unstack(b,a)
put-down(b)
unstack(d,c)
put-down(d)
pick-up(c)
stack(c,d)
pick-up(a)
stack(a,b)
unstack(c,d)
put-down(c)
pick-up(d)
stack(d,a)
pick-up(c)
stack(c,d) | 377 |
(define (domain blocksworld-4ops)
(:requirements :strips)
(:predicates (clear ?x)
(ontable ?x)
(handempty)
(holding ?x)
(on ?x ?y))
(:action pick-up
:parameters (?ob)
:precondition (and (clear ?ob) (ontable ?ob) (handempty))
:effect (and (holding ?ob) (not (clear ?ob)) (not (ontable ?ob))
(not (handempty))))
(:action put-down
:parameters (?ob)
:precondition (holding ?ob)
:effect (and (clear ?ob) (handempty) (ontable ?ob)
(not (holding ?ob))))
(:action stack
:parameters (?ob ?underob)
:precondition (and (clear ?underob) (holding ?ob))
:effect (and (handempty) (clear ?ob) (on ?ob ?underob)
(not (clear ?underob)) (not (holding ?ob))))
(:action unstack
:parameters (?ob ?underob)
:precondition (and (on ?ob ?underob) (clear ?ob) (handempty))
:effect (and (holding ?ob) (clear ?underob)
(not (on ?ob ?underob)) (not (clear ?ob)) (not (handempty)))))
|
(define (problem BW-rand-4)
(:domain blocksworld-4ops)
(:objects a b c d )
(:init
(handempty)
(ontable a)
(on b c)
(ontable c)
(on d b)
(clear a)
(clear d)
)
(:goal
(and
(on b c)
(on c d)
(on d a))
)
)
| status: SOLVED_SATISFICING
engine: Pyperplan
plan: SequentialPlan:
unstack(d, b)
stack(d, a)
unstack(b, c)
put-down(b)
pick-up(c)
stack(c, d)
pick-up(b)
stack(b, c) | SequentialPlan:
unstack(d, b)
stack(d, a)
unstack(b, c)
put-down(b)
pick-up(c)
stack(c, d)
pick-up(b)
stack(b, c) | 8 | I am playing with a set of objects.
Here are the actions I can do:
pick-up with ob
put-down with ob
stack with ob, underob
unstack with ob, underob
I have the following restrictions on my actions:
To perform pick-up action, the following facts need to be true: (clear(ob) and ontable(ob) and handempty).
Once pick-up action is performed the following facts will be true: holding(ob).
Once pick-up action is performed the following facts will be false: clear(ob), ontable(ob), handempty.
To perform put-down action, the following facts need to be true: holding(ob).
Once put-down action is performed the following facts will be true: clear(ob), handempty, ontable(ob).
Once put-down action is performed the following facts will be false: holding(ob).
To perform stack action, the following facts need to be true: (clear(underob) and holding(ob)).
Once stack action is performed the following facts will be true: handempty, clear(ob), on(ob, underob).
Once stack action is performed the following facts will be false: clear(underob), holding(ob).
To perform unstack action, the following facts need to be true: (on(ob, underob) and clear(ob) and handempty).
Once unstack action is performed the following facts will be true: holding(ob), clear(underob).
Once unstack action is performed the following facts will be false: on(ob, underob), clear(ob), handempty.
[STATEMENT]
As initial conditions I have that, handempty, ontable(a), on(b, c), ontable(c), on(d, b), clear(a), clear(d).
My goal is to have that (on(b, c) and on(c, d) and on(d, a)). | unstack(d,b)
stack(d,a)
unstack(b,c)
put-down(b)
pick-up(c)
stack(c,d)
pick-up(b)
stack(b,c) | 377 |
(define (domain blocksworld-4ops)
(:requirements :strips)
(:predicates (clear ?x)
(ontable ?x)
(handempty)
(holding ?x)
(on ?x ?y))
(:action pick-up
:parameters (?ob)
:precondition (and (clear ?ob) (ontable ?ob) (handempty))
:effect (and (holding ?ob) (not (clear ?ob)) (not (ontable ?ob))
(not (handempty))))
(:action put-down
:parameters (?ob)
:precondition (holding ?ob)
:effect (and (clear ?ob) (handempty) (ontable ?ob)
(not (holding ?ob))))
(:action stack
:parameters (?ob ?underob)
:precondition (and (clear ?underob) (holding ?ob))
:effect (and (handempty) (clear ?ob) (on ?ob ?underob)
(not (clear ?underob)) (not (holding ?ob))))
(:action unstack
:parameters (?ob ?underob)
:precondition (and (on ?ob ?underob) (clear ?ob) (handempty))
:effect (and (holding ?ob) (clear ?underob)
(not (on ?ob ?underob)) (not (clear ?ob)) (not (handempty)))))
|
(define (problem BW-rand-4)
(:domain blocksworld-4ops)
(:objects a b c d )
(:init
(handempty)
(on a c)
(ontable b)
(on c d)
(on d b)
(clear a)
)
(:goal
(and
(on b a)
(on d c))
)
)
| status: SOLVED_SATISFICING
engine: Pyperplan
plan: SequentialPlan:
unstack(a, c)
put-down(a)
unstack(c, d)
put-down(c)
unstack(d, b)
stack(d, c)
pick-up(b)
stack(b, a) | SequentialPlan:
unstack(a, c)
put-down(a)
unstack(c, d)
put-down(c)
unstack(d, b)
stack(d, c)
pick-up(b)
stack(b, a) | 8 | I am playing with a set of objects.
Here are the actions I can do:
pick-up with ob
put-down with ob
stack with ob, underob
unstack with ob, underob
I have the following restrictions on my actions:
To perform pick-up action, the following facts need to be true: (clear(ob) and ontable(ob) and handempty).
Once pick-up action is performed the following facts will be true: holding(ob).
Once pick-up action is performed the following facts will be false: clear(ob), ontable(ob), handempty.
To perform put-down action, the following facts need to be true: holding(ob).
Once put-down action is performed the following facts will be true: clear(ob), handempty, ontable(ob).
Once put-down action is performed the following facts will be false: holding(ob).
To perform stack action, the following facts need to be true: (clear(underob) and holding(ob)).
Once stack action is performed the following facts will be true: handempty, clear(ob), on(ob, underob).
Once stack action is performed the following facts will be false: clear(underob), holding(ob).
To perform unstack action, the following facts need to be true: (on(ob, underob) and clear(ob) and handempty).
Once unstack action is performed the following facts will be true: holding(ob), clear(underob).
Once unstack action is performed the following facts will be false: on(ob, underob), clear(ob), handempty.
Everything is false by default
[STATEMENT]
As initial conditions I have that, handempty, on(a, c), ontable(b), on(c, d), on(d, b), clear(a).
My goal is to have that (on(b, a) and on(d, c)). | unstack(a,c)
put-down(a)
unstack(c,d)
put-down(c)
unstack(d,b)
stack(d,c)
pick-up(b)
stack(b,a) | 375 |
(define (domain blocksworld-4ops)
(:requirements :strips)
(:predicates (clear ?x)
(ontable ?x)
(handempty)
(holding ?x)
(on ?x ?y))
(:action pick-up
:parameters (?ob)
:precondition (and (clear ?ob) (ontable ?ob) (handempty))
:effect (and (holding ?ob) (not (clear ?ob)) (not (ontable ?ob))
(not (handempty))))
(:action put-down
:parameters (?ob)
:precondition (holding ?ob)
:effect (and (clear ?ob) (handempty) (ontable ?ob)
(not (holding ?ob))))
(:action stack
:parameters (?ob ?underob)
:precondition (and (clear ?underob) (holding ?ob))
:effect (and (handempty) (clear ?ob) (on ?ob ?underob)
(not (clear ?underob)) (not (holding ?ob))))
(:action unstack
:parameters (?ob ?underob)
:precondition (and (on ?ob ?underob) (clear ?ob) (handempty))
:effect (and (holding ?ob) (clear ?underob)
(not (on ?ob ?underob)) (not (clear ?ob)) (not (handempty)))))
|
(define (problem BW-rand-4)
(:domain blocksworld-4ops)
(:objects a b c d )
(:init
(handempty)
(ontable a)
(ontable b)
(ontable c)
(on d b)
(clear a)
(clear c)
(clear d)
)
(:goal
(and
(on a b)
(on b c)
(on c d))
)
)
| status: SOLVED_SATISFICING
engine: Pyperplan
plan: SequentialPlan:
unstack(d, b)
put-down(d)
pick-up(a)
stack(a, b)
pick-up(c)
stack(c, d)
unstack(a, b)
put-down(a)
pick-up(b)
stack(b, c)
pick-up(a)
stack(a, b) | SequentialPlan:
unstack(d, b)
put-down(d)
pick-up(a)
stack(a, b)
pick-up(c)
stack(c, d)
unstack(a, b)
put-down(a)
pick-up(b)
stack(b, c)
pick-up(a)
stack(a, b) | 12 | I am playing with a set of objects.
Here are the actions I can do:
pick-up with ob
put-down with ob
stack with ob, underob
unstack with ob, underob
I have the following restrictions on my actions:
To perform pick-up action, the following facts need to be true: (clear(ob) and ontable(ob) and handempty).
Once pick-up action is performed the following facts will be true: holding(ob).
Once pick-up action is performed the following facts will be false: clear(ob), ontable(ob), handempty.
To perform put-down action, the following facts need to be true: holding(ob).
Once put-down action is performed the following facts will be true: clear(ob), handempty, ontable(ob).
Once put-down action is performed the following facts will be false: holding(ob).
To perform stack action, the following facts need to be true: (clear(underob) and holding(ob)).
Once stack action is performed the following facts will be true: handempty, clear(ob), on(ob, underob).
Once stack action is performed the following facts will be false: clear(underob), holding(ob).
To perform unstack action, the following facts need to be true: (on(ob, underob) and clear(ob) and handempty).
Once unstack action is performed the following facts will be true: holding(ob), clear(underob).
Once unstack action is performed the following facts will be false: on(ob, underob), clear(ob), handempty.
[STATEMENT]
As initial conditions I have that, handempty, ontable(a), ontable(b), ontable(c), on(d, b), clear(a), clear(c), clear(d).
My goal is to have that (on(a, b) and on(b, c) and on(c, d)). | unstack(d,b)
put-down(d)
pick-up(a)
stack(a,b)
pick-up(c)
stack(c,d)
unstack(a,b)
put-down(a)
pick-up(b)
stack(b,c)
pick-up(a)
stack(a,b) | 379 |
(define (domain blocksworld-4ops)
(:requirements :strips)
(:predicates (clear ?x)
(ontable ?x)
(handempty)
(holding ?x)
(on ?x ?y))
(:action pick-up
:parameters (?ob)
:precondition (and (clear ?ob) (ontable ?ob) (handempty))
:effect (and (holding ?ob) (not (clear ?ob)) (not (ontable ?ob))
(not (handempty))))
(:action put-down
:parameters (?ob)
:precondition (holding ?ob)
:effect (and (clear ?ob) (handempty) (ontable ?ob)
(not (holding ?ob))))
(:action stack
:parameters (?ob ?underob)
:precondition (and (clear ?underob) (holding ?ob))
:effect (and (handempty) (clear ?ob) (on ?ob ?underob)
(not (clear ?underob)) (not (holding ?ob))))
(:action unstack
:parameters (?ob ?underob)
:precondition (and (on ?ob ?underob) (clear ?ob) (handempty))
:effect (and (holding ?ob) (clear ?underob)
(not (on ?ob ?underob)) (not (clear ?ob)) (not (handempty)))))
|
(define (problem BW-rand-4)
(:domain blocksworld-4ops)
(:objects a b c d )
(:init
(handempty)
(on a b)
(on b c)
(ontable c)
(ontable d)
(clear a)
(clear d)
)
(:goal
(and
(on b a)
(on d b))
)
)
| status: SOLVED_SATISFICING
engine: Pyperplan
plan: SequentialPlan:
unstack(a, b)
put-down(a)
unstack(b, c)
stack(b, a)
pick-up(d)
stack(d, b) | SequentialPlan:
unstack(a, b)
put-down(a)
unstack(b, c)
stack(b, a)
pick-up(d)
stack(d, b) | 6 | I am playing with a set of objects.
Here are the actions I can do:
pick-up with ob
put-down with ob
stack with ob, underob
unstack with ob, underob
I have the following restrictions on my actions:
To perform pick-up action, the following facts need to be true: (clear(ob) and ontable(ob) and handempty).
Once pick-up action is performed the following facts will be true: holding(ob).
Once pick-up action is performed the following facts will be false: clear(ob), ontable(ob), handempty.
To perform put-down action, the following facts need to be true: holding(ob).
Once put-down action is performed the following facts will be true: clear(ob), handempty, ontable(ob).
Once put-down action is performed the following facts will be false: holding(ob).
To perform stack action, the following facts need to be true: (clear(underob) and holding(ob)).
Once stack action is performed the following facts will be true: handempty, clear(ob), on(ob, underob).
Once stack action is performed the following facts will be false: clear(underob), holding(ob).
To perform unstack action, the following facts need to be true: (on(ob, underob) and clear(ob) and handempty).
Once unstack action is performed the following facts will be true: holding(ob), clear(underob).
Once unstack action is performed the following facts will be false: on(ob, underob), clear(ob), handempty.
[STATEMENT]
As initial conditions I have that, handempty, on(a, b), on(b, c), ontable(c), ontable(d), clear(a), clear(d).
My goal is to have that (on(b, a) and on(d, b)). | unstack(a,b)
put-down(a)
unstack(b,c)
stack(b,a)
pick-up(d)
stack(d,b) | 371 |
(define (domain blocksworld-4ops)
(:requirements :strips)
(:predicates (clear ?x)
(ontable ?x)
(handempty)
(holding ?x)
(on ?x ?y))
(:action pick-up
:parameters (?ob)
:precondition (and (clear ?ob) (ontable ?ob) (handempty))
:effect (and (holding ?ob) (not (clear ?ob)) (not (ontable ?ob))
(not (handempty))))
(:action put-down
:parameters (?ob)
:precondition (holding ?ob)
:effect (and (clear ?ob) (handempty) (ontable ?ob)
(not (holding ?ob))))
(:action stack
:parameters (?ob ?underob)
:precondition (and (clear ?underob) (holding ?ob))
:effect (and (handempty) (clear ?ob) (on ?ob ?underob)
(not (clear ?underob)) (not (holding ?ob))))
(:action unstack
:parameters (?ob ?underob)
:precondition (and (on ?ob ?underob) (clear ?ob) (handempty))
:effect (and (holding ?ob) (clear ?underob)
(not (on ?ob ?underob)) (not (clear ?ob)) (not (handempty)))))
|
(define (problem BW-rand-4)
(:domain blocksworld-4ops)
(:objects a b c d )
(:init
(handempty)
(on a b)
(on b c)
(ontable c)
(on d a)
(clear d)
)
(:goal
(and
(on a c)
(on b d))
)
)
| status: SOLVED_SATISFICING
engine: Pyperplan
plan: SequentialPlan:
unstack(d, a)
put-down(d)
unstack(a, b)
put-down(a)
unstack(b, c)
stack(b, d)
pick-up(a)
stack(a, c) | SequentialPlan:
unstack(d, a)
put-down(d)
unstack(a, b)
put-down(a)
unstack(b, c)
stack(b, d)
pick-up(a)
stack(a, c) | 8 | I am playing with a set of objects.
Here are the actions I can do:
pick-up with ob
put-down with ob
stack with ob, underob
unstack with ob, underob
I have the following restrictions on my actions:
To perform pick-up action, the following facts need to be true: (clear(ob) and ontable(ob) and handempty).
Once pick-up action is performed the following facts will be true: holding(ob).
Once pick-up action is performed the following facts will be false: clear(ob), ontable(ob), handempty.
To perform put-down action, the following facts need to be true: holding(ob).
Once put-down action is performed the following facts will be true: clear(ob), handempty, ontable(ob).
Once put-down action is performed the following facts will be false: holding(ob).
To perform stack action, the following facts need to be true: (clear(underob) and holding(ob)).
Once stack action is performed the following facts will be true: handempty, clear(ob), on(ob, underob).
Once stack action is performed the following facts will be false: clear(underob), holding(ob).
To perform unstack action, the following facts need to be true: (on(ob, underob) and clear(ob) and handempty).
Once unstack action is performed the following facts will be true: holding(ob), clear(underob).
Once unstack action is performed the following facts will be false: on(ob, underob), clear(ob), handempty.
Everything is false by default
[STATEMENT]
As initial conditions I have that, handempty, on(a, b), on(b, c), ontable(c), on(d, a), clear(d).
My goal is to have that (on(a, c) and on(b, d)). | unstack(d,a)
put-down(d)
unstack(a,b)
put-down(a)
unstack(b,c)
stack(b,d)
pick-up(a)
stack(a,c) | 375 |
(define (domain blocksworld-4ops)
(:requirements :strips)
(:predicates (clear ?x)
(ontable ?x)
(handempty)
(holding ?x)
(on ?x ?y))
(:action pick-up
:parameters (?ob)
:precondition (and (clear ?ob) (ontable ?ob) (handempty))
:effect (and (holding ?ob) (not (clear ?ob)) (not (ontable ?ob))
(not (handempty))))
(:action put-down
:parameters (?ob)
:precondition (holding ?ob)
:effect (and (clear ?ob) (handempty) (ontable ?ob)
(not (holding ?ob))))
(:action stack
:parameters (?ob ?underob)
:precondition (and (clear ?underob) (holding ?ob))
:effect (and (handempty) (clear ?ob) (on ?ob ?underob)
(not (clear ?underob)) (not (holding ?ob))))
(:action unstack
:parameters (?ob ?underob)
:precondition (and (on ?ob ?underob) (clear ?ob) (handempty))
:effect (and (holding ?ob) (clear ?underob)
(not (on ?ob ?underob)) (not (clear ?ob)) (not (handempty)))))
|
(define (problem BW-rand-4)
(:domain blocksworld-4ops)
(:objects a b c d )
(:init
(handempty)
(ontable a)
(on b a)
(ontable c)
(on d b)
(clear c)
(clear d)
)
(:goal
(and
(on b d))
)
)
| status: SOLVED_SATISFICING
engine: Pyperplan
plan: SequentialPlan:
unstack(d, b)
put-down(d)
unstack(b, a)
stack(b, d) | SequentialPlan:
unstack(d, b)
put-down(d)
unstack(b, a)
stack(b, d) | 4 | I am playing with a set of objects.
Here are the actions I can do:
pick-up with ob
put-down with ob
stack with ob, underob
unstack with ob, underob
I have the following restrictions on my actions:
To perform pick-up action, the following facts need to be true: (clear(ob) and ontable(ob) and handempty).
Once pick-up action is performed the following facts will be true: holding(ob).
Once pick-up action is performed the following facts will be false: clear(ob), ontable(ob), handempty.
To perform put-down action, the following facts need to be true: holding(ob).
Once put-down action is performed the following facts will be true: clear(ob), handempty, ontable(ob).
Once put-down action is performed the following facts will be false: holding(ob).
To perform stack action, the following facts need to be true: (clear(underob) and holding(ob)).
Once stack action is performed the following facts will be true: handempty, clear(ob), on(ob, underob).
Once stack action is performed the following facts will be false: clear(underob), holding(ob).
To perform unstack action, the following facts need to be true: (on(ob, underob) and clear(ob) and handempty).
Once unstack action is performed the following facts will be true: holding(ob), clear(underob).
Once unstack action is performed the following facts will be false: on(ob, underob), clear(ob), handempty.
Everything is false by default
[STATEMENT]
As initial conditions I have that, handempty, ontable(a), on(b, a), ontable(c), on(d, b), clear(c), clear(d).
My goal is to have that on(b, d). | unstack(d,b)
put-down(d)
unstack(b,a)
stack(b,d) | 370 |
(define (domain blocksworld-4ops)
(:requirements :strips)
(:predicates (clear ?x)
(ontable ?x)
(handempty)
(holding ?x)
(on ?x ?y))
(:action pick-up
:parameters (?ob)
:precondition (and (clear ?ob) (ontable ?ob) (handempty))
:effect (and (holding ?ob) (not (clear ?ob)) (not (ontable ?ob))
(not (handempty))))
(:action put-down
:parameters (?ob)
:precondition (holding ?ob)
:effect (and (clear ?ob) (handempty) (ontable ?ob)
(not (holding ?ob))))
(:action stack
:parameters (?ob ?underob)
:precondition (and (clear ?underob) (holding ?ob))
:effect (and (handempty) (clear ?ob) (on ?ob ?underob)
(not (clear ?underob)) (not (holding ?ob))))
(:action unstack
:parameters (?ob ?underob)
:precondition (and (on ?ob ?underob) (clear ?ob) (handempty))
:effect (and (holding ?ob) (clear ?underob)
(not (on ?ob ?underob)) (not (clear ?ob)) (not (handempty)))))
|
(define (problem BW-rand-4)
(:domain blocksworld-4ops)
(:objects a b c d )
(:init
(handempty)
(on a c)
(ontable b)
(on c d)
(ontable d)
(clear a)
(clear b)
)
(:goal
(and
(on a c)
(on c d)
(on d b))
)
)
| status: SOLVED_SATISFICING
engine: Pyperplan
plan: SequentialPlan:
unstack(a, c)
put-down(a)
unstack(c, d)
put-down(c)
pick-up(a)
stack(a, c)
pick-up(d)
stack(d, b)
unstack(a, c)
put-down(a)
pick-up(c)
stack(c, d)
pick-up(a)
stack(a, c) | SequentialPlan:
unstack(a, c)
put-down(a)
unstack(c, d)
put-down(c)
pick-up(a)
stack(a, c)
pick-up(d)
stack(d, b)
unstack(a, c)
put-down(a)
pick-up(c)
stack(c, d)
pick-up(a)
stack(a, c) | 14 | I am playing with a set of objects.
Here are the actions I can do:
pick-up with ob
put-down with ob
stack with ob, underob
unstack with ob, underob
I have the following restrictions on my actions:
To perform pick-up action, the following facts need to be true: (clear(ob) and ontable(ob) and handempty).
Once pick-up action is performed the following facts will be true: holding(ob).
Once pick-up action is performed the following facts will be false: clear(ob), ontable(ob), handempty.
To perform put-down action, the following facts need to be true: holding(ob).
Once put-down action is performed the following facts will be true: clear(ob), handempty, ontable(ob).
Once put-down action is performed the following facts will be false: holding(ob).
To perform stack action, the following facts need to be true: (clear(underob) and holding(ob)).
Once stack action is performed the following facts will be true: handempty, clear(ob), on(ob, underob).
Once stack action is performed the following facts will be false: clear(underob), holding(ob).
To perform unstack action, the following facts need to be true: (on(ob, underob) and clear(ob) and handempty).
Once unstack action is performed the following facts will be true: holding(ob), clear(underob).
Once unstack action is performed the following facts will be false: on(ob, underob), clear(ob), handempty.
[STATEMENT]
As initial conditions I have that, handempty, on(a, c), ontable(b), on(c, d), ontable(d), clear(a), clear(b).
My goal is to have that (on(a, c) and on(c, d) and on(d, b)). | unstack(a,c)
put-down(a)
unstack(c,d)
put-down(c)
pick-up(a)
stack(a,c)
pick-up(d)
stack(d,b)
unstack(a,c)
put-down(a)
pick-up(c)
stack(c,d)
pick-up(a)
stack(a,c) | 377 |
(define (domain blocksworld-4ops)
(:requirements :strips)
(:predicates (clear ?x)
(ontable ?x)
(handempty)
(holding ?x)
(on ?x ?y))
(:action pick-up
:parameters (?ob)
:precondition (and (clear ?ob) (ontable ?ob) (handempty))
:effect (and (holding ?ob) (not (clear ?ob)) (not (ontable ?ob))
(not (handempty))))
(:action put-down
:parameters (?ob)
:precondition (holding ?ob)
:effect (and (clear ?ob) (handempty) (ontable ?ob)
(not (holding ?ob))))
(:action stack
:parameters (?ob ?underob)
:precondition (and (clear ?underob) (holding ?ob))
:effect (and (handempty) (clear ?ob) (on ?ob ?underob)
(not (clear ?underob)) (not (holding ?ob))))
(:action unstack
:parameters (?ob ?underob)
:precondition (and (on ?ob ?underob) (clear ?ob) (handempty))
:effect (and (holding ?ob) (clear ?underob)
(not (on ?ob ?underob)) (not (clear ?ob)) (not (handempty)))))
|
(define (problem BW-rand-4)
(:domain blocksworld-4ops)
(:objects a b c d )
(:init
(handempty)
(on a b)
(on b c)
(ontable c)
(ontable d)
(clear a)
(clear d)
)
(:goal
(and
(on b c)
(on d a))
)
)
| status: SOLVED_SATISFICING
engine: Pyperplan
plan: SequentialPlan:
pick-up(d)
stack(d, a) | SequentialPlan:
pick-up(d)
stack(d, a) | 2 | I am playing with a set of objects.
Here are the actions I can do:
pick-up with ob
put-down with ob
stack with ob, underob
unstack with ob, underob
I have the following restrictions on my actions:
To perform pick-up action, the following facts need to be true: (clear(ob) and ontable(ob) and handempty).
Once pick-up action is performed the following facts will be true: holding(ob).
Once pick-up action is performed the following facts will be false: clear(ob), ontable(ob), handempty.
To perform put-down action, the following facts need to be true: holding(ob).
Once put-down action is performed the following facts will be true: clear(ob), handempty, ontable(ob).
Once put-down action is performed the following facts will be false: holding(ob).
To perform stack action, the following facts need to be true: (clear(underob) and holding(ob)).
Once stack action is performed the following facts will be true: handempty, clear(ob), on(ob, underob).
Once stack action is performed the following facts will be false: clear(underob), holding(ob).
To perform unstack action, the following facts need to be true: (on(ob, underob) and clear(ob) and handempty).
Once unstack action is performed the following facts will be true: holding(ob), clear(underob).
Once unstack action is performed the following facts will be false: on(ob, underob), clear(ob), handempty.
Everything is false by default
[STATEMENT]
As initial conditions I have that, handempty, on(a, b), on(b, c), ontable(c), ontable(d), clear(a), clear(d).
My goal is to have that (on(b, c) and on(d, a)). | pick-up(d)
stack(d,a) | 377 |
(define (domain blocksworld-4ops)
(:requirements :strips)
(:predicates (clear ?x)
(ontable ?x)
(handempty)
(holding ?x)
(on ?x ?y))
(:action pick-up
:parameters (?ob)
:precondition (and (clear ?ob) (ontable ?ob) (handempty))
:effect (and (holding ?ob) (not (clear ?ob)) (not (ontable ?ob))
(not (handempty))))
(:action put-down
:parameters (?ob)
:precondition (holding ?ob)
:effect (and (clear ?ob) (handempty) (ontable ?ob)
(not (holding ?ob))))
(:action stack
:parameters (?ob ?underob)
:precondition (and (clear ?underob) (holding ?ob))
:effect (and (handempty) (clear ?ob) (on ?ob ?underob)
(not (clear ?underob)) (not (holding ?ob))))
(:action unstack
:parameters (?ob ?underob)
:precondition (and (on ?ob ?underob) (clear ?ob) (handempty))
:effect (and (holding ?ob) (clear ?underob)
(not (on ?ob ?underob)) (not (clear ?ob)) (not (handempty)))))
|
(define (problem BW-rand-4)
(:domain blocksworld-4ops)
(:objects a b c d )
(:init
(handempty)
(ontable a)
(on b a)
(on c d)
(ontable d)
(clear b)
(clear c)
)
(:goal
(and
(on b c)
(on d a))
)
)
| status: SOLVED_SATISFICING
engine: Pyperplan
plan: SequentialPlan:
unstack(b, a)
put-down(b)
unstack(c, d)
put-down(c)
pick-up(b)
stack(b, c)
pick-up(d)
stack(d, a) | SequentialPlan:
unstack(b, a)
put-down(b)
unstack(c, d)
put-down(c)
pick-up(b)
stack(b, c)
pick-up(d)
stack(d, a) | 8 | I am playing with a set of objects.
Here are the actions I can do:
pick-up with ob
put-down with ob
stack with ob, underob
unstack with ob, underob
I have the following restrictions on my actions:
To perform pick-up action, the following facts need to be true: (clear(ob) and ontable(ob) and handempty).
Once pick-up action is performed the following facts will be true: holding(ob).
Once pick-up action is performed the following facts will be false: clear(ob), ontable(ob), handempty.
To perform put-down action, the following facts need to be true: holding(ob).
Once put-down action is performed the following facts will be true: clear(ob), handempty, ontable(ob).
Once put-down action is performed the following facts will be false: holding(ob).
To perform stack action, the following facts need to be true: (clear(underob) and holding(ob)).
Once stack action is performed the following facts will be true: handempty, clear(ob), on(ob, underob).
Once stack action is performed the following facts will be false: clear(underob), holding(ob).
To perform unstack action, the following facts need to be true: (on(ob, underob) and clear(ob) and handempty).
Once unstack action is performed the following facts will be true: holding(ob), clear(underob).
Once unstack action is performed the following facts will be false: on(ob, underob), clear(ob), handempty.
[STATEMENT]
As initial conditions I have that, handempty, ontable(a), on(b, a), on(c, d), ontable(d), clear(b), clear(c).
My goal is to have that (on(b, c) and on(d, a)). | unstack(b,a)
put-down(b)
unstack(c,d)
put-down(c)
pick-up(b)
stack(b,c)
pick-up(d)
stack(d,a) | 371 |
(define (domain blocksworld-4ops)
(:requirements :strips)
(:predicates (clear ?x)
(ontable ?x)
(handempty)
(holding ?x)
(on ?x ?y))
(:action pick-up
:parameters (?ob)
:precondition (and (clear ?ob) (ontable ?ob) (handempty))
:effect (and (holding ?ob) (not (clear ?ob)) (not (ontable ?ob))
(not (handempty))))
(:action put-down
:parameters (?ob)
:precondition (holding ?ob)
:effect (and (clear ?ob) (handempty) (ontable ?ob)
(not (holding ?ob))))
(:action stack
:parameters (?ob ?underob)
:precondition (and (clear ?underob) (holding ?ob))
:effect (and (handempty) (clear ?ob) (on ?ob ?underob)
(not (clear ?underob)) (not (holding ?ob))))
(:action unstack
:parameters (?ob ?underob)
:precondition (and (on ?ob ?underob) (clear ?ob) (handempty))
:effect (and (holding ?ob) (clear ?underob)
(not (on ?ob ?underob)) (not (clear ?ob)) (not (handempty)))))
|
(define (problem BW-rand-4)
(:domain blocksworld-4ops)
(:objects a b c d )
(:init
(handempty)
(on a d)
(ontable b)
(ontable c)
(on d c)
(clear a)
(clear b)
)
(:goal
(and
(on c d)
(on d b))
)
)
| status: SOLVED_SATISFICING
engine: Pyperplan
plan: SequentialPlan:
unstack(a, d)
put-down(a)
unstack(d, c)
stack(d, b)
pick-up(c)
stack(c, d) | SequentialPlan:
unstack(a, d)
put-down(a)
unstack(d, c)
stack(d, b)
pick-up(c)
stack(c, d) | 6 | I am playing with a set of objects.
Here are the actions I can do:
pick-up with ob
put-down with ob
stack with ob, underob
unstack with ob, underob
I have the following restrictions on my actions:
To perform pick-up action, the following facts need to be true: (clear(ob) and ontable(ob) and handempty).
Once pick-up action is performed the following facts will be true: holding(ob).
Once pick-up action is performed the following facts will be false: clear(ob), ontable(ob), handempty.
To perform put-down action, the following facts need to be true: holding(ob).
Once put-down action is performed the following facts will be true: clear(ob), handempty, ontable(ob).
Once put-down action is performed the following facts will be false: holding(ob).
To perform stack action, the following facts need to be true: (clear(underob) and holding(ob)).
Once stack action is performed the following facts will be true: handempty, clear(ob), on(ob, underob).
Once stack action is performed the following facts will be false: clear(underob), holding(ob).
To perform unstack action, the following facts need to be true: (on(ob, underob) and clear(ob) and handempty).
Once unstack action is performed the following facts will be true: holding(ob), clear(underob).
Once unstack action is performed the following facts will be false: on(ob, underob), clear(ob), handempty.
[STATEMENT]
As initial conditions I have that, handempty, on(a, d), ontable(b), ontable(c), on(d, c), clear(a), clear(b).
My goal is to have that (on(c, d) and on(d, b)). | unstack(a,d)
put-down(a)
unstack(d,c)
stack(d,b)
pick-up(c)
stack(c,d) | 371 |
(define (domain blocksworld-4ops)
(:requirements :strips)
(:predicates (clear ?x)
(ontable ?x)
(handempty)
(holding ?x)
(on ?x ?y))
(:action pick-up
:parameters (?ob)
:precondition (and (clear ?ob) (ontable ?ob) (handempty))
:effect (and (holding ?ob) (not (clear ?ob)) (not (ontable ?ob))
(not (handempty))))
(:action put-down
:parameters (?ob)
:precondition (holding ?ob)
:effect (and (clear ?ob) (handempty) (ontable ?ob)
(not (holding ?ob))))
(:action stack
:parameters (?ob ?underob)
:precondition (and (clear ?underob) (holding ?ob))
:effect (and (handempty) (clear ?ob) (on ?ob ?underob)
(not (clear ?underob)) (not (holding ?ob))))
(:action unstack
:parameters (?ob ?underob)
:precondition (and (on ?ob ?underob) (clear ?ob) (handempty))
:effect (and (holding ?ob) (clear ?underob)
(not (on ?ob ?underob)) (not (clear ?ob)) (not (handempty)))))
|
(define (problem BW-rand-4)
(:domain blocksworld-4ops)
(:objects a b c d )
(:init
(handempty)
(on a d)
(ontable b)
(ontable c)
(on d c)
(clear a)
(clear b)
)
(:goal
(and
(on a b)
(on b c)
(on d a))
)
)
| status: SOLVED_SATISFICING
engine: Pyperplan
plan: SequentialPlan:
unstack(a, d)
put-down(a)
unstack(d, c)
stack(d, a)
pick-up(b)
stack(b, c)
unstack(d, a)
put-down(d)
pick-up(a)
stack(a, b)
pick-up(d)
stack(d, a) | SequentialPlan:
unstack(a, d)
put-down(a)
unstack(d, c)
stack(d, a)
pick-up(b)
stack(b, c)
unstack(d, a)
put-down(d)
pick-up(a)
stack(a, b)
pick-up(d)
stack(d, a) | 12 | I am playing with a set of objects.
Here are the actions I can do:
pick-up with ob
put-down with ob
stack with ob, underob
unstack with ob, underob
I have the following restrictions on my actions:
To perform pick-up action, the following facts need to be true: (clear(ob) and ontable(ob) and handempty).
Once pick-up action is performed the following facts will be true: holding(ob).
Once pick-up action is performed the following facts will be false: clear(ob), ontable(ob), handempty.
To perform put-down action, the following facts need to be true: holding(ob).
Once put-down action is performed the following facts will be true: clear(ob), handempty, ontable(ob).
Once put-down action is performed the following facts will be false: holding(ob).
To perform stack action, the following facts need to be true: (clear(underob) and holding(ob)).
Once stack action is performed the following facts will be true: handempty, clear(ob), on(ob, underob).
Once stack action is performed the following facts will be false: clear(underob), holding(ob).
To perform unstack action, the following facts need to be true: (on(ob, underob) and clear(ob) and handempty).
Once unstack action is performed the following facts will be true: holding(ob), clear(underob).
Once unstack action is performed the following facts will be false: on(ob, underob), clear(ob), handempty.
[STATEMENT]
As initial conditions I have that, handempty, on(a, d), ontable(b), ontable(c), on(d, c), clear(a), clear(b).
My goal is to have that (on(a, b) and on(b, c) and on(d, a)). | unstack(a,d)
put-down(a)
unstack(d,c)
stack(d,a)
pick-up(b)
stack(b,c)
unstack(d,a)
put-down(d)
pick-up(a)
stack(a,b)
pick-up(d)
stack(d,a) | 377 |
(define (domain blocksworld-4ops)
(:requirements :strips)
(:predicates (clear ?x)
(ontable ?x)
(handempty)
(holding ?x)
(on ?x ?y))
(:action pick-up
:parameters (?ob)
:precondition (and (clear ?ob) (ontable ?ob) (handempty))
:effect (and (holding ?ob) (not (clear ?ob)) (not (ontable ?ob))
(not (handempty))))
(:action put-down
:parameters (?ob)
:precondition (holding ?ob)
:effect (and (clear ?ob) (handempty) (ontable ?ob)
(not (holding ?ob))))
(:action stack
:parameters (?ob ?underob)
:precondition (and (clear ?underob) (holding ?ob))
:effect (and (handempty) (clear ?ob) (on ?ob ?underob)
(not (clear ?underob)) (not (holding ?ob))))
(:action unstack
:parameters (?ob ?underob)
:precondition (and (on ?ob ?underob) (clear ?ob) (handempty))
:effect (and (holding ?ob) (clear ?underob)
(not (on ?ob ?underob)) (not (clear ?ob)) (not (handempty)))))
|
(define (problem BW-rand-4)
(:domain blocksworld-4ops)
(:objects a b c d )
(:init
(handempty)
(ontable a)
(on b c)
(on c d)
(on d a)
(clear b)
)
(:goal
(and
(on b a)
(on d b))
)
)
| status: SOLVED_SATISFICING
engine: Pyperplan
plan: SequentialPlan:
unstack(b, c)
put-down(b)
unstack(c, d)
put-down(c)
unstack(d, a)
put-down(d)
pick-up(b)
stack(b, a)
pick-up(d)
stack(d, b) | SequentialPlan:
unstack(b, c)
put-down(b)
unstack(c, d)
put-down(c)
unstack(d, a)
put-down(d)
pick-up(b)
stack(b, a)
pick-up(d)
stack(d, b) | 10 | I am playing with a set of objects.
Here are the actions I can do:
pick-up with ob
put-down with ob
stack with ob, underob
unstack with ob, underob
I have the following restrictions on my actions:
To perform pick-up action, the following facts need to be true: (clear(ob) and ontable(ob) and handempty).
Once pick-up action is performed the following facts will be true: holding(ob).
Once pick-up action is performed the following facts will be false: clear(ob), ontable(ob), handempty.
To perform put-down action, the following facts need to be true: holding(ob).
Once put-down action is performed the following facts will be true: clear(ob), handempty, ontable(ob).
Once put-down action is performed the following facts will be false: holding(ob).
To perform stack action, the following facts need to be true: (clear(underob) and holding(ob)).
Once stack action is performed the following facts will be true: handempty, clear(ob), on(ob, underob).
Once stack action is performed the following facts will be false: clear(underob), holding(ob).
To perform unstack action, the following facts need to be true: (on(ob, underob) and clear(ob) and handempty).
Once unstack action is performed the following facts will be true: holding(ob), clear(underob).
Once unstack action is performed the following facts will be false: on(ob, underob), clear(ob), handempty.
[STATEMENT]
As initial conditions I have that, handempty, ontable(a), on(b, c), on(c, d), on(d, a), clear(b).
My goal is to have that (on(b, a) and on(d, b)). | unstack(b,c)
put-down(b)
unstack(c,d)
put-down(c)
unstack(d,a)
put-down(d)
pick-up(b)
stack(b,a)
pick-up(d)
stack(d,b) | 369 |
(define (domain blocksworld-4ops)
(:requirements :strips)
(:predicates (clear ?x)
(ontable ?x)
(handempty)
(holding ?x)
(on ?x ?y))
(:action pick-up
:parameters (?ob)
:precondition (and (clear ?ob) (ontable ?ob) (handempty))
:effect (and (holding ?ob) (not (clear ?ob)) (not (ontable ?ob))
(not (handempty))))
(:action put-down
:parameters (?ob)
:precondition (holding ?ob)
:effect (and (clear ?ob) (handempty) (ontable ?ob)
(not (holding ?ob))))
(:action stack
:parameters (?ob ?underob)
:precondition (and (clear ?underob) (holding ?ob))
:effect (and (handempty) (clear ?ob) (on ?ob ?underob)
(not (clear ?underob)) (not (holding ?ob))))
(:action unstack
:parameters (?ob ?underob)
:precondition (and (on ?ob ?underob) (clear ?ob) (handempty))
:effect (and (holding ?ob) (clear ?underob)
(not (on ?ob ?underob)) (not (clear ?ob)) (not (handempty)))))
|
(define (problem BW-rand-4)
(:domain blocksworld-4ops)
(:objects a b c d )
(:init
(handempty)
(on a d)
(ontable b)
(ontable c)
(on d b)
(clear a)
(clear c)
)
(:goal
(and
(on a c)
(on b d)
(on d a))
)
)
| status: SOLVED_SATISFICING
engine: Pyperplan
plan: SequentialPlan:
unstack(a, d)
stack(a, c)
unstack(d, b)
stack(d, a)
pick-up(b)
stack(b, d) | SequentialPlan:
unstack(a, d)
stack(a, c)
unstack(d, b)
stack(d, a)
pick-up(b)
stack(b, d) | 6 | I am playing with a set of objects.
Here are the actions I can do:
pick-up with ob
put-down with ob
stack with ob, underob
unstack with ob, underob
I have the following restrictions on my actions:
To perform pick-up action, the following facts need to be true: (clear(ob) and ontable(ob) and handempty).
Once pick-up action is performed the following facts will be true: holding(ob).
Once pick-up action is performed the following facts will be false: clear(ob), ontable(ob), handempty.
To perform put-down action, the following facts need to be true: holding(ob).
Once put-down action is performed the following facts will be true: clear(ob), handempty, ontable(ob).
Once put-down action is performed the following facts will be false: holding(ob).
To perform stack action, the following facts need to be true: (clear(underob) and holding(ob)).
Once stack action is performed the following facts will be true: handempty, clear(ob), on(ob, underob).
Once stack action is performed the following facts will be false: clear(underob), holding(ob).
To perform unstack action, the following facts need to be true: (on(ob, underob) and clear(ob) and handempty).
Once unstack action is performed the following facts will be true: holding(ob), clear(underob).
Once unstack action is performed the following facts will be false: on(ob, underob), clear(ob), handempty.
[STATEMENT]
As initial conditions I have that, handempty, on(a, d), ontable(b), ontable(c), on(d, b), clear(a), clear(c).
My goal is to have that (on(a, c) and on(b, d) and on(d, a)). | unstack(a,d)
stack(a,c)
unstack(d,b)
stack(d,a)
pick-up(b)
stack(b,d) | 377 |
(define (domain blocksworld-4ops)
(:requirements :strips)
(:predicates (clear ?x)
(ontable ?x)
(handempty)
(holding ?x)
(on ?x ?y))
(:action pick-up
:parameters (?ob)
:precondition (and (clear ?ob) (ontable ?ob) (handempty))
:effect (and (holding ?ob) (not (clear ?ob)) (not (ontable ?ob))
(not (handempty))))
(:action put-down
:parameters (?ob)
:precondition (holding ?ob)
:effect (and (clear ?ob) (handempty) (ontable ?ob)
(not (holding ?ob))))
(:action stack
:parameters (?ob ?underob)
:precondition (and (clear ?underob) (holding ?ob))
:effect (and (handempty) (clear ?ob) (on ?ob ?underob)
(not (clear ?underob)) (not (holding ?ob))))
(:action unstack
:parameters (?ob ?underob)
:precondition (and (on ?ob ?underob) (clear ?ob) (handempty))
:effect (and (holding ?ob) (clear ?underob)
(not (on ?ob ?underob)) (not (clear ?ob)) (not (handempty)))))
|
(define (problem BW-rand-4)
(:domain blocksworld-4ops)
(:objects a b c d )
(:init
(handempty)
(ontable a)
(on b c)
(on c a)
(ontable d)
(clear b)
(clear d)
)
(:goal
(and
(on b d)
(on c a))
)
)
| status: SOLVED_SATISFICING
engine: Pyperplan
plan: SequentialPlan:
unstack(b, c)
stack(b, d) | SequentialPlan:
unstack(b, c)
stack(b, d) | 2 | I am playing with a set of objects.
Here are the actions I can do:
pick-up with ob
put-down with ob
stack with ob, underob
unstack with ob, underob
I have the following restrictions on my actions:
To perform pick-up action, the following facts need to be true: (clear(ob) and ontable(ob) and handempty).
Once pick-up action is performed the following facts will be true: holding(ob).
Once pick-up action is performed the following facts will be false: clear(ob), ontable(ob), handempty.
To perform put-down action, the following facts need to be true: holding(ob).
Once put-down action is performed the following facts will be true: clear(ob), handempty, ontable(ob).
Once put-down action is performed the following facts will be false: holding(ob).
To perform stack action, the following facts need to be true: (clear(underob) and holding(ob)).
Once stack action is performed the following facts will be true: handempty, clear(ob), on(ob, underob).
Once stack action is performed the following facts will be false: clear(underob), holding(ob).
To perform unstack action, the following facts need to be true: (on(ob, underob) and clear(ob) and handempty).
Once unstack action is performed the following facts will be true: holding(ob), clear(underob).
Once unstack action is performed the following facts will be false: on(ob, underob), clear(ob), handempty.
[STATEMENT]
As initial conditions I have that, handempty, ontable(a), on(b, c), on(c, a), ontable(d), clear(b), clear(d).
My goal is to have that (on(b, d) and on(c, a)). | unstack(b,c)
stack(b,d) | 371 |
(define (domain blocksworld-4ops)
(:requirements :strips)
(:predicates (clear ?x)
(ontable ?x)
(handempty)
(holding ?x)
(on ?x ?y))
(:action pick-up
:parameters (?ob)
:precondition (and (clear ?ob) (ontable ?ob) (handempty))
:effect (and (holding ?ob) (not (clear ?ob)) (not (ontable ?ob))
(not (handempty))))
(:action put-down
:parameters (?ob)
:precondition (holding ?ob)
:effect (and (clear ?ob) (handempty) (ontable ?ob)
(not (holding ?ob))))
(:action stack
:parameters (?ob ?underob)
:precondition (and (clear ?underob) (holding ?ob))
:effect (and (handempty) (clear ?ob) (on ?ob ?underob)
(not (clear ?underob)) (not (holding ?ob))))
(:action unstack
:parameters (?ob ?underob)
:precondition (and (on ?ob ?underob) (clear ?ob) (handempty))
:effect (and (holding ?ob) (clear ?underob)
(not (on ?ob ?underob)) (not (clear ?ob)) (not (handempty)))))
|
(define (problem BW-rand-4)
(:domain blocksworld-4ops)
(:objects a b c d )
(:init
(handempty)
(ontable a)
(on b d)
(ontable c)
(ontable d)
(clear a)
(clear b)
(clear c)
)
(:goal
(and
(on a b)
(on b c)
(on c d))
)
)
| status: SOLVED_SATISFICING
engine: Pyperplan
plan: SequentialPlan:
unstack(b, d)
put-down(b)
pick-up(a)
stack(a, b)
pick-up(c)
stack(c, d)
unstack(a, b)
put-down(a)
pick-up(b)
stack(b, c)
pick-up(a)
stack(a, b) | SequentialPlan:
unstack(b, d)
put-down(b)
pick-up(a)
stack(a, b)
pick-up(c)
stack(c, d)
unstack(a, b)
put-down(a)
pick-up(b)
stack(b, c)
pick-up(a)
stack(a, b) | 12 | I am playing with a set of objects.
Here are the actions I can do:
pick-up with ob
put-down with ob
stack with ob, underob
unstack with ob, underob
I have the following restrictions on my actions:
To perform pick-up action, the following facts need to be true: (clear(ob) and ontable(ob) and handempty).
Once pick-up action is performed the following facts will be true: holding(ob).
Once pick-up action is performed the following facts will be false: clear(ob), ontable(ob), handempty.
To perform put-down action, the following facts need to be true: holding(ob).
Once put-down action is performed the following facts will be true: clear(ob), handempty, ontable(ob).
Once put-down action is performed the following facts will be false: holding(ob).
To perform stack action, the following facts need to be true: (clear(underob) and holding(ob)).
Once stack action is performed the following facts will be true: handempty, clear(ob), on(ob, underob).
Once stack action is performed the following facts will be false: clear(underob), holding(ob).
To perform unstack action, the following facts need to be true: (on(ob, underob) and clear(ob) and handempty).
Once unstack action is performed the following facts will be true: holding(ob), clear(underob).
Once unstack action is performed the following facts will be false: on(ob, underob), clear(ob), handempty.
[STATEMENT]
As initial conditions I have that, handempty, ontable(a), on(b, d), ontable(c), ontable(d), clear(a), clear(b), clear(c).
My goal is to have that (on(a, b) and on(b, c) and on(c, d)). | unstack(b,d)
put-down(b)
pick-up(a)
stack(a,b)
pick-up(c)
stack(c,d)
unstack(a,b)
put-down(a)
pick-up(b)
stack(b,c)
pick-up(a)
stack(a,b) | 379 |
(define (domain blocksworld-4ops)
(:requirements :strips)
(:predicates (clear ?x)
(ontable ?x)
(handempty)
(holding ?x)
(on ?x ?y))
(:action pick-up
:parameters (?ob)
:precondition (and (clear ?ob) (ontable ?ob) (handempty))
:effect (and (holding ?ob) (not (clear ?ob)) (not (ontable ?ob))
(not (handempty))))
(:action put-down
:parameters (?ob)
:precondition (holding ?ob)
:effect (and (clear ?ob) (handempty) (ontable ?ob)
(not (holding ?ob))))
(:action stack
:parameters (?ob ?underob)
:precondition (and (clear ?underob) (holding ?ob))
:effect (and (handempty) (clear ?ob) (on ?ob ?underob)
(not (clear ?underob)) (not (holding ?ob))))
(:action unstack
:parameters (?ob ?underob)
:precondition (and (on ?ob ?underob) (clear ?ob) (handempty))
:effect (and (holding ?ob) (clear ?underob)
(not (on ?ob ?underob)) (not (clear ?ob)) (not (handempty)))))
|
(define (problem BW-rand-4)
(:domain blocksworld-4ops)
(:objects a b c d )
(:init
(handempty)
(on a d)
(ontable b)
(on c b)
(on d c)
(clear a)
)
(:goal
(and
(on a c)
(on b a))
)
)
| status: SOLVED_SATISFICING
engine: Pyperplan
plan: SequentialPlan:
unstack(a, d)
put-down(a)
unstack(d, c)
put-down(d)
unstack(c, b)
put-down(c)
pick-up(a)
stack(a, c)
pick-up(b)
stack(b, a) | SequentialPlan:
unstack(a, d)
put-down(a)
unstack(d, c)
put-down(d)
unstack(c, b)
put-down(c)
pick-up(a)
stack(a, c)
pick-up(b)
stack(b, a) | 10 | I am playing with a set of objects.
Here are the actions I can do:
pick-up with ob
put-down with ob
stack with ob, underob
unstack with ob, underob
I have the following restrictions on my actions:
To perform pick-up action, the following facts need to be true: (clear(ob) and ontable(ob) and handempty).
Once pick-up action is performed the following facts will be true: holding(ob).
Once pick-up action is performed the following facts will be false: clear(ob), ontable(ob), handempty.
To perform put-down action, the following facts need to be true: holding(ob).
Once put-down action is performed the following facts will be true: clear(ob), handempty, ontable(ob).
Once put-down action is performed the following facts will be false: holding(ob).
To perform stack action, the following facts need to be true: (clear(underob) and holding(ob)).
Once stack action is performed the following facts will be true: handempty, clear(ob), on(ob, underob).
Once stack action is performed the following facts will be false: clear(underob), holding(ob).
To perform unstack action, the following facts need to be true: (on(ob, underob) and clear(ob) and handempty).
Once unstack action is performed the following facts will be true: holding(ob), clear(underob).
Once unstack action is performed the following facts will be false: on(ob, underob), clear(ob), handempty.
[STATEMENT]
As initial conditions I have that, handempty, on(a, d), ontable(b), on(c, b), on(d, c), clear(a).
My goal is to have that (on(a, c) and on(b, a)). | unstack(a,d)
put-down(a)
unstack(d,c)
put-down(d)
unstack(c,b)
put-down(c)
pick-up(a)
stack(a,c)
pick-up(b)
stack(b,a) | 369 |
(define (domain blocksworld-4ops)
(:requirements :strips)
(:predicates (clear ?x)
(ontable ?x)
(handempty)
(holding ?x)
(on ?x ?y))
(:action pick-up
:parameters (?ob)
:precondition (and (clear ?ob) (ontable ?ob) (handempty))
:effect (and (holding ?ob) (not (clear ?ob)) (not (ontable ?ob))
(not (handempty))))
(:action put-down
:parameters (?ob)
:precondition (holding ?ob)
:effect (and (clear ?ob) (handempty) (ontable ?ob)
(not (holding ?ob))))
(:action stack
:parameters (?ob ?underob)
:precondition (and (clear ?underob) (holding ?ob))
:effect (and (handempty) (clear ?ob) (on ?ob ?underob)
(not (clear ?underob)) (not (holding ?ob))))
(:action unstack
:parameters (?ob ?underob)
:precondition (and (on ?ob ?underob) (clear ?ob) (handempty))
:effect (and (holding ?ob) (clear ?underob)
(not (on ?ob ?underob)) (not (clear ?ob)) (not (handempty)))))
|
(define (problem BW-rand-4)
(:domain blocksworld-4ops)
(:objects a b c d )
(:init
(handempty)
(on a b)
(ontable b)
(on c a)
(ontable d)
(clear c)
(clear d)
)
(:goal
(and
(on a c)
(on c d)
(on d b))
)
)
| status: SOLVED_SATISFICING
engine: Pyperplan
plan: SequentialPlan:
unstack(c, a)
put-down(c)
unstack(a, b)
stack(a, c)
pick-up(d)
stack(d, b)
unstack(a, c)
put-down(a)
pick-up(c)
stack(c, d)
pick-up(a)
stack(a, c) | SequentialPlan:
unstack(c, a)
put-down(c)
unstack(a, b)
stack(a, c)
pick-up(d)
stack(d, b)
unstack(a, c)
put-down(a)
pick-up(c)
stack(c, d)
pick-up(a)
stack(a, c) | 12 | I am playing with a set of objects.
Here are the actions I can do:
pick-up with ob
put-down with ob
stack with ob, underob
unstack with ob, underob
I have the following restrictions on my actions:
To perform pick-up action, the following facts need to be true: (clear(ob) and ontable(ob) and handempty).
Once pick-up action is performed the following facts will be true: holding(ob).
Once pick-up action is performed the following facts will be false: clear(ob), ontable(ob), handempty.
To perform put-down action, the following facts need to be true: holding(ob).
Once put-down action is performed the following facts will be true: clear(ob), handempty, ontable(ob).
Once put-down action is performed the following facts will be false: holding(ob).
To perform stack action, the following facts need to be true: (clear(underob) and holding(ob)).
Once stack action is performed the following facts will be true: handempty, clear(ob), on(ob, underob).
Once stack action is performed the following facts will be false: clear(underob), holding(ob).
To perform unstack action, the following facts need to be true: (on(ob, underob) and clear(ob) and handempty).
Once unstack action is performed the following facts will be true: holding(ob), clear(underob).
Once unstack action is performed the following facts will be false: on(ob, underob), clear(ob), handempty.
[STATEMENT]
As initial conditions I have that, handempty, on(a, b), ontable(b), on(c, a), ontable(d), clear(c), clear(d).
My goal is to have that (on(a, c) and on(c, d) and on(d, b)). | unstack(c,a)
put-down(c)
unstack(a,b)
stack(a,c)
pick-up(d)
stack(d,b)
unstack(a,c)
put-down(a)
pick-up(c)
stack(c,d)
pick-up(a)
stack(a,c) | 377 |
Subsets and Splits