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