def create_actions(problem, add_fuel):
lang = problem.language
at, cell_t, empty, carrying, adjacent = lang.get("at", "cell", "empty", "carrying", "adjacent")
t = lang.variable("t", 'truck')
p = lang.variable("p", 'package')
x = lang.variable("x", cell_t)
f = lang.variable("from", cell_t)
to = lang.variable("to", cell_t)
problem.action(name='pick-package', parameters=[t, p, x],
precondition=land(at(p, x), at(t, x), empty(t), flat=True),
effects=[
fs.DelEffect(at(p, x)),
fs.DelEffect(empty(t)),
fs.AddEffect(carrying(t, p)),
])
problem.action(name='drop-package', parameters=[t, p, x],
precondition=land(at(t, x), carrying(t, p), flat=True),
effects=[
fs.AddEffect(empty(t)),
fs.DelEffect(carrying(t, p)),
fs.AddEffect(at(p, x)),
])
problem.action(name='move', parameters=[t, f, to],
precondition=land(adjacent(f, to), at(t, f), flat=True),
effects=[
fs.DelEffect(at(t, f)),
fs.AddEffect(at(t, to)),
])
def generate_problem(nblocks, run):
lang = generate_atomic_bw_language(nblocks)
problem = create_fstrips_problem(lang,
domain_name="blocksworld-atomic",
problem_name=f'instance-{nblocks}-{run}')
clear, on, diff, table = lang.get('clear', 'on', 'diff', 'table')
# Generate init pattern
clearplaces, locations = generate_random_bw_pattern(lang)
for x, y in locations:
problem.init.add(on, lang.get(x), lang.get(y))
for x in clearplaces:
problem.init.add(clear, lang.get(x))
# Add the quadratic number of (static) diff(b, c) atoms
for x, y in itertools.permutations(lang.constants(), 2):
problem.init.add(diff, x, y)
# Generate goal pattern
_, locations = generate_random_bw_pattern(lang)
conjuncts = []
for x, y in locations:
conjuncts.append(on(lang.get(x), lang.get(y)))
problem.goal = land(*conjuncts, flat=True)
b, x, y = [lang.variable(name, 'object') for name in ['b', 'x', 'y']]
problem.action('move', [b, x, y],
precondition=land(diff(b, table),
diff(y, table),
diff(b, y),
clear(b),
on(b, x),
clear(y),
flat=True),
effects=[
fs.DelEffect(on(b, x)),
fs.AddEffect(clear(x)),
fs.DelEffect(clear(y)),
fs.AddEffect(on(b, y))
])
problem.action('move-to-table', [b, x],
precondition=land(diff(b, table),
diff(x, table),
clear(b),
on(b, x),
flat=True),
effects=[
fs.DelEffect(on(b, x)),
fs.AddEffect(clear(x)),
fs.AddEffect(on(b, table))
])
return problem, [table]
def get_conjunctions(self, fluent_list, flag):
if len(fluent_list) == 0:
if flag == POS_PREC:
return top
else:
return []
elif len(fluent_list) <= 1:
fluent = fluent_list[0]
variables = fluent[1]
var = [
self.variable_map[variable.replace('?', '')]
for variable in variables
]
if flag == POS_PREC:
return self.predicate_map[fluent[0]](*var)
elif flag == ADDS:
return [fs.AddEffect(self.predicate_map[fluent[0]](*var))]
elif flag == DELS:
return [fs.DelEffect(self.predicate_map[fluent[0]](*var))]
else:
and_fluent_list = []
if flag == POS_PREC:
for fluent in fluent_list:
variables = fluent[1]
var = [
self.variable_map[variable.replace('?', '')]
for variable in variables
]
and_fluent_list.append(self.predicate_map[fluent[0]](*var))
return land(*and_fluent_list)
elif flag == ADDS:
for fluent in fluent_list:
variables = fluent[1]
var = [
self.variable_map[variable.replace('?', '')]
for variable in variables
]
and_fluent_list.append(
fs.AddEffect(self.predicate_map[fluent[0]](*var)))
return and_fluent_list
elif flag == DELS:
for fluent in fluent_list:
variables = fluent[1]
var = [
self.variable_map[variable.replace('?', '')]
for variable in variables
]
and_fluent_list.append(
fs.DelEffect(self.predicate_map[fluent[0]](*var)))
return and_fluent_list
def generate_small_fstrips_bw_problem():
""" Generate a small Functional STRIPS BW problem with a few blocks, types, and one single action"""
lang = generate_small_fstrips_bw_language(nblocks=4)
problem = create_fstrips_problem(domain_name='blocksworld',
problem_name='test-instance',
language=lang)
b1, b2, b3, b4, clear, loc, table = lang.get('b1', 'b2', 'b3', 'b4',
'clear', 'loc', 'table')
problem.goal = (loc(b1) == b2) & (loc(b2) == b3) & (clear(b1))
to = lang.variable('to', 'place')
b = lang.variable('b', 'block')
problem.action("move", [b, to],
precondition=land(b != to,
loc(b) != to, clear(b), clear(to)),
effects=[
loc(b) << to,
fs.AddEffect(clear(loc(b))),
fs.DelEffect(clear(loc(b)), condition=to != table)
])
init = tarski.model.create(lang)
init.set(loc, b1, b2) # loc(b1) := b2
init.set(loc, b2, b3) # loc(b2) := b3
init.set(loc, b3, table) # loc(b3) := table
init.set(loc, b4, table) # loc(b4) := table
init.add(clear, b1) # clear(b1)
init.add(clear, b4) # clear(b4)
init.add(clear, table) # clear(table)
problem.init = init
return problem
def populate_fstrips_object(self):
# Populate initial state
for init_val in self.model_dict[INSTANCE][INIT]:
self.add_predicates_to_the_prob(init_val)
self.fstrips_problem.init.add(self.add_predicates_to_the_prob(init_val))
# populate goal state
self.fstrips_problem.goal = self.get_conjunctions(self.model_dict[INSTANCE][GOAL])
# populate action models
for act in self.model_dict[DOMAIN]:
act_name = act
# Only pos
variable_map = {}
if PARARMETERS in self.model_dict[DOMAIN][act]:
pars = []
for p,s in self.model_dict[DOMAIN][act][PARARMETERS]:
try:
sort = self.fstrips_problem.language.get_sort(s)
except UndefinedSort:
sort = self.fstrips_problem.language.sort(s)
print("SORT",s)
new_var = self.fstrips_problem.language.variable(p,sort)
variable_map[new_var.name] = new_var
pars.append(new_var)
precond = self.get_conjunctions(self.model_dict[DOMAIN][act][POS_PREC])
add_effects = [fs.AddEffect(self.add_predicates_to_the_prob(fl)()) for fl in self.model_dict[DOMAIN][act].get(ADDS,set())]
delete_effects = [fs.DelEffect(self.add_predicates_to_the_prob(fl)())
for fl in self.model_dict[DOMAIN][act].get(DELS,set())]
#pars = [self.fstrips_problem.language.variable(p,self.fstrips_problem.language.sort(s)) for p,s in self.model_dict[DOMAIN][act][PARARMETERS]]
#print(pars)
else:
pars = []
self.fstrips_problem.action(act_name, pars, precond, add_effects + delete_effects)
def generate_small_strips_bw_problem():
""" Generate the standard BW encoding, untyped and with 4 action schemas """
lang = generate_small_strips_bw_language()
problem = create_fstrips_problem(domain_name='blocksworld',
problem_name='test',
language=lang)
b1, b2, b3, clear, on, ontable, handempty, holding = \
lang.get('b1', 'b2', 'b3', 'clear', 'on', 'ontable', 'handempty', 'holding')
problem.goal = (on(b1, b2)) & (on(b2, b3)) & (clear(b1))
x = lang.variable('x', 'object')
y = lang.variable('y', 'object')
problem.action('pick-up', [x],
precondition=clear(x) & ontable(x) & handempty(),
effects=[
fs.DelEffect(ontable(x)),
fs.DelEffect(clear(x)),
fs.DelEffect(handempty()),
fs.AddEffect(holding(x))
])
problem.action('put-down', [x],
precondition=holding(x),
effects=[
fs.AddEffect(ontable(x)),
fs.AddEffect(clear(x)),
fs.AddEffect(handempty()),
fs.DelEffect(holding(x))
])
problem.action('unstack', [x, y],
precondition=on(x, y) & clear(x) & handempty(),
effects=[
fs.DelEffect(on(x, y)),
fs.AddEffect(clear(y)),
fs.DelEffect(clear(x)),
fs.DelEffect(handempty()),
fs.AddEffect(holding(x))
])
problem.action('stack', [x, y],
precondition=(x != y) & holding(x) & clear(y),
effects=[
fs.AddEffect(on(x, y)),
fs.DelEffect(clear(y)),
fs.AddEffect(clear(x)),
fs.AddEffect(handempty()),
fs.DelEffect(holding(x))
])
return problem
def create_small_task():
upp = create_small_language()
dummy_sheet = upp.constant('dummy-sheet', upp.sheet_t)
sheet1 = upp.constant('sheet1', upp.sheet_t)
M = tsk.model.create(upp)
M.evaluator = evaluate
M.add(upp.Uninitialized)
M.add(upp.Location, dummy_sheet, upp.some_finisher_tray)
M.add(upp.Prevsheet, sheet1, dummy_sheet)
M.add(upp.Sheetsize, sheet1, upp.letter)
M.add(upp.Location, sheet1, upp.some_feeder_tray)
M.set(upp.total_cost(), 0)
sheet = upp.variable('sheet', upp.sheet_t)
prevsheet = upp.variable('prevsheet', upp.sheet_t)
precondition = land(
upp.Available(upp.finisher2_rsrc), upp.Prevsheet(sheet, prevsheet),
upp.Location(prevsheet, upp.some_finisher_tray),
upp.Sheetsize(sheet, upp.letter),
upp.Location(sheet, upp.finisher2_entry_finisher1_exit))
effects = [
fs.DelEffect(upp.Available(upp.finisher2_rsrc)),
fs.DelEffect(upp.Location(sheet, upp.finisher2_entry_finisher1_exit)),
fs.AddEffect(upp.Location(sheet, upp.some_finisher_tray)),
fs.AddEffect(upp.Stackedin(sheet, upp.finisher2_tray)),
fs.AddEffect(upp.Available(upp.finisher2_rsrc)),
fs.IncreaseEffect(upp.total_cost(), 8000)
]
problem = fs.Problem()
problem.name = "fun"
problem.language = upp
problem.init = M
problem.goal = top
problem.action('Finisher2-Stack-Letter', [sheet, prevsheet], precondition,
effects)
problem.metric = fs.OptimizationMetric(upp.total_cost(),
fs.OptimizationType.MINIMIZE)
return problem
def create_small_task():
upp = parcprinter.create_small_language()
dummy_sheet = upp.constant('dummy-sheet', upp.sheet_t)
sheet1 = upp.constant('sheet1', upp.sheet_t)
M = tsk.model.create(upp)
M.evaluator = evaluate
M.add(upp.Uninitialized)
M.add(upp.Location, dummy_sheet, upp.some_finisher_tray)
M.add(upp.Prevsheet, sheet1, dummy_sheet)
M.add(upp.Sheetsize, sheet1, upp.letter)
M.add(upp.Location, sheet1, upp.some_feeder_tray)
sheet = upp.variable('sheet', upp.sheet_t)
prevsheet = upp.variable('prevsheet', upp.sheet_t)
precondition = land(upp.Available(upp.finisher2_rsrc),
upp.Prevsheet(sheet, prevsheet),
upp.Location(prevsheet, upp.some_finisher_tray),
upp.Sheetsize(sheet, upp.letter),
upp.Location(sheet, upp.finisher2_entry_finisher1_exit))
# MRJ: note that the positive effects should be under an extra X op, as per the
# "deletes before adds" semantics,
effects = [fs.DelEffect(upp.Available(upp.finisher2_rsrc)),
fs.DelEffect(upp.Location(sheet, upp.finisher2_entry_finisher1_exit)),
fs.AddEffect(upp.Location(sheet, upp.some_finisher_tray)),
fs.AddEffect(upp.Stackedin(sheet, upp.finisher2_tray)),
fs.AddEffect(upp.Available(upp.finisher2_rsrc))
]
P = fs.Problem()
P.name = "fun"
P.language = upp
P.init = M
P.goal = top
P.action('Finisher2-Stack-Letter', [sheet, prevsheet], precondition, effects)
return P
def create_simple_problem():
lang = create_simple_untyped_language()
problem = fs.create_fstrips_problem(lang,
problem_name="simple",
domain_name="simple")
p, q, a = lang.get("p", "q", "a")
init = tarski.model.create(lang)
problem.init = init
init.add(p, a) # p(a)
init.add(q, a) # q(a)
problem.goal = neg(p(a))
x = lang.variable("x", lang.Object)
problem.action("negate", [x],
precondition=p(a),
effects=[fs.DelEffect(p(a))])
return problem
def create_4blocks_task():
bw = generate_bw_loc_and_clear(4)
M = tarski.model.create(bw)
loc = bw.get_function('loc')
clear = bw.get_predicate('clear')
b1, b2, b3, b4 = [bw.get_constant('b{}'.format(k)) for k in range(1, 5)]
table = bw.get_constant('table')
hand = bw.get_constant('hand')
M.setx(loc(b1), b2) # loc(b1) := b2
M.setx(loc(b2), b3) # loc(b2) := b3
M.setx(loc(b3), table) # loc(b3) := table
M.setx(loc(b4), table) # loc(b4) := table
M.setx(loc(table), table)
M.setx(loc(hand), hand)
M.add(clear, b1) # clear(b1)
M.add(clear, b4) # clear(b4)
M.add(clear, hand) # handempty
G = land(loc(b1) == b2, loc(b2) == b3, loc(b3) == b4, loc(b4) == table)
P = fs.Problem()
P.name = "tower4"
P.domain_name = "blocksworld"
P.language = bw
P.init = M
P.goal = G
# P.constraints += [clear_constraint]
# @NOTE: These are the state variables associated with the constraint above
P.state_variables = [
] # [StateVariable(clear(dest), [tb]) for tb in [tb1, tb2, tb3, tb4, table]]
b = bw.variable('b', bw.Object)
P.action(
'pick_up', [b],
land(clear(b), clear(hand),
loc(b) == table, b != hand, b != table), [
fs.FunctionalEffect(loc(b), hand),
fs.DelEffect(clear(b)),
fs.DelEffect(clear(hand))
])
P.action('put_down', [b], land(loc(b) == hand, b != table, b != hand), [
fs.FunctionalEffect(loc(b), table),
fs.AddEffect(clear(b)),
fs.AddEffect(clear(hand))
])
src = bw.variable('src', bw.Object)
dest = bw.variable('dest', bw.Object)
P.action(
'stack', [src, dest],
land(
loc(src) == hand, clear(dest), src != dest, src != table,
src != hand, dest != table, dest != hand), [
fs.FunctionalEffect(loc(src), dest),
fs.DelEffect(clear(dest)),
fs.AddEffect(clear(src)),
fs.AddEffect(clear(hand))
])
P.action(
'unstack', [src, dest],
land(clear(hand),
loc(src) == dest, clear(src), src != dest, src != table,
src != hand, dest != table, dest != hand), [
fs.FunctionalEffect(loc(src), hand),
fs.DelEffect(clear(src)),
fs.AddEffect(clear(dest)),
fs.DelEffect(clear(hand))
])
return P
def generate_strips_blocksworld_problem(nblocks=4, use_inequalities=True):
""" Generate the standard BW encoding, untyped and with 4 action schemas """
lang = generate_strips_bw_language(nblocks=nblocks)
problem = create_fstrips_problem(lang, domain_name=BASE_DOMAIN_NAME, problem_name='test-instance')
clear, on, ontable, handempty, holding = lang.get('clear', 'on', 'ontable', 'handempty', 'holding')
# Generate init pattern
clearplaces, locations = generate_random_bw_pattern(lang)
for x, y in locations:
if y == 'table':
problem.init.add(ontable, lang.get(x))
else:
problem.init.add(on, lang.get(x), lang.get(y))
for x in clearplaces:
if x != 'table':
problem.init.add(clear, lang.get(x))
problem.init.add(handempty)
# Generate goal pattern
_, locations = generate_random_bw_pattern(lang)
conjuncts = []
for x, y in locations:
if y == 'table':
conjuncts.append(ontable(lang.get(x)))
else:
conjuncts.append(on(lang.get(x), lang.get(y)))
problem.goal = land(*conjuncts, flat=True)
x = lang.variable('x', 'object')
y = lang.variable('y', 'object')
problem.action('pick-up', [x],
precondition=clear(x) & ontable(x) & handempty(),
effects=[fs.DelEffect(ontable(x)),
fs.DelEffect(clear(x)),
fs.DelEffect(handempty()),
fs.AddEffect(holding(x))])
problem.action('put-down', [x],
precondition=holding(x),
effects=[fs.AddEffect(ontable(x)),
fs.AddEffect(clear(x)),
fs.AddEffect(handempty()),
fs.DelEffect(holding(x))])
problem.action('unstack', [x, y],
precondition=on(x, y) & clear(x) & handempty(),
effects=[fs.DelEffect(on(x, y)),
fs.AddEffect(clear(y)),
fs.DelEffect(clear(x)),
fs.DelEffect(handempty()),
fs.AddEffect(holding(x))])
prec = holding(x) & clear(y)
if use_inequalities:
prec = prec & (x != y)
problem.action('stack', [x, y],
precondition=prec,
effects=[fs.AddEffect(on(x, y)),
fs.DelEffect(clear(y)),
fs.AddEffect(clear(x)),
fs.AddEffect(handempty()),
fs.DelEffect(holding(x))])
return problem
def create_sample_problem():
lang = create_sample_language()
init = tarski.model.create(lang)
room, ball, at_robby, free, at, gripper, carry = lang.get(
"room", "ball", "at-robby", "free", "at", "gripper", "carry")
rooma, roomb, ball4, ball3, ball2, ball1, left, right = lang.get(
'rooma', 'roomb', 'ball4', 'ball3', 'ball2', 'ball1', 'left', 'right')
init.add(room, rooma)
init.add(room, roomb)
init.add(ball, ball1)
init.add(ball, ball2)
init.add(ball, ball3)
init.add(ball, ball4)
init.add(gripper, left)
init.add(gripper, right)
init.add(at_robby, rooma)
init.add(free, left)
init.add(free, right)
init.add(at, ball1, rooma)
init.add(at, ball2, rooma)
init.add(at, ball3, rooma)
init.add(at, ball4, rooma)
problem = fs.create_fstrips_problem(lang,
problem_name="sample",
domain_name="gripper-strips")
problem.init = init
problem.goal = land(at(ball1, roomb), at(ball2, roomb), at(ball3, roomb),
at(ball4, roomb))
from_, to, o, r, g = [
lang.variable(x, lang.Object) for x in ["from", "to", "o", "r", "g"]
]
problem.action(
"move", [from_, to],
precondition=land(from_ != to,
room(from_),
room(to),
at_robby(from_),
flat=True),
effects=[fs.AddEffect(at_robby(to)),
fs.DelEffect(at_robby(from_))])
problem.action("pick", [o, r, g],
precondition=land(ball(o),
room(r),
gripper(g),
at(o, r),
at_robby(r),
free(g),
flat=True),
effects=[
fs.AddEffect(carry(o, g)),
fs.DelEffect(at(o, r)),
fs.DelEffect(free(g))
])
problem.action("drop", [o, r, g],
precondition=land(ball(o),
room(r),
gripper(g),
carry(o, g),
at_robby(r),
flat=True),
effects=[
fs.DelEffect(carry(o, g)),
fs.AddEffect(at(o, r)),
fs.AddEffect(free(g))
])
return problem
def generate_strips_3op_blocksworld_problem(nblocks):
""" Generate the standard BW encoding, untyped and with 4 action schemas """
lang = generate_strips_3op_bw_language(nblocks=nblocks)
problem = create_fstrips_problem(lang,
domain_name=BASE_DOMAIN_NAME,
problem_name=f'random-{nblocks}-blocks')
clear, on, ontable = lang.get('clear', 'on', 'ontable')
# Generate init pattern
clearplaces, locations = generate_random_bw_pattern(lang)
for x, y in locations:
if y == 'table':
problem.init.add(ontable, lang.get(x))
else:
problem.init.add(on, lang.get(x), lang.get(y))
for x in clearplaces:
if x != 'table':
problem.init.add(clear, lang.get(x))
# Generate goal pattern
_, locations = generate_random_bw_pattern(lang)
conjuncts = []
for x, y in locations:
if y == 'table':
conjuncts.append(ontable(lang.get(x)))
else:
conjuncts.append(on(lang.get(x), lang.get(y)))
problem.goal = land(*conjuncts, flat=True)
b = lang.variable('b', 'object')
f = lang.variable('from', 'object')
t = lang.variable('to', 'object')
problem.action('move-block-to-block', [b, f, t],
precondition=land(clear(b), clear(t), on(b, f), flat=True),
effects=[
fs.AddEffect(on(b, t)),
fs.DelEffect(on(b, f)),
fs.AddEffect(clear(f)),
fs.DelEffect(clear(t)),
])
problem.action('move-block-to-table', [b, f],
precondition=land(clear(b), on(b, f), flat=True),
effects=[
fs.AddEffect(ontable(b)),
fs.DelEffect(on(b, f)),
fs.AddEffect(clear(f)),
])
problem.action('move-table-to-block', [b, t],
precondition=land(clear(b), clear(t), ontable(b),
flat=True),
effects=[
fs.AddEffect(on(b, t)),
fs.DelEffect(ontable(b)),
fs.DelEffect(clear(t)),
])
return problem
