def test_basic_representation_queries(): lang = generate_small_fstrips_bw_language(nblocks=5) clear, loc, b1, b2, b3 = lang.get('clear', 'loc', 'b1', 'b2', 'b3') x = lang.variable('x', lang.ns.block) assert rep.is_function_free(b1) assert rep.is_function_free(clear(b1)) assert rep.is_function_free((clear(b1) & clear(b2)) | clear(b3)) assert rep.is_function_free(exists(x, clear(x))) assert not rep.is_function_free(loc(b1) == b2) assert rep.is_conjunction_of_literals(clear(b1)) assert rep.is_conjunction_of_literals(~clear(b1)) assert rep.is_conjunction_of_literals(~~clear(b1)) assert rep.is_conjunction_of_literals(clear(b1) & clear(b2)) assert rep.is_conjunction_of_literals(clear(b1) & ~clear(b2)) assert rep.is_conjunction_of_literals(clear(b1) & ~~clear(b2)) assert rep.is_conjunction_of_literals(loc(b1) == b2) assert rep.is_conjunction_of_literals(loc(b1) != b2) assert rep.is_conjunction_of_literals(~(loc(b1) == b2)) assert not rep.is_conjunction_of_literals(~(clear(b1) & clear(b2))) assert not rep.is_conjunction_of_literals((clear(b1) & clear(b2)) | clear(b3)) assert not rep.is_conjunction_of_literals(exists(x, clear(x)))
def create_small_bw_task(): lang = generate_small_fstrips_bw_language() init = tarski.model.create(lang) b1, b2, b3, b4, clear, loc, table = lang.get('b1', 'b2', 'b3', 'b4', 'clear', 'loc', 'table') block, place = lang.get('block', 'place') 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) src = lang.variable('src', block) dest = lang.variable('dest', place) x = lang.variable('x', block) y = lang.variable('y', block) clear_constraint = forall( x, equiv(neg(clear(x)), land(x != table, exists(y, loc(y) == x)))) G = land(loc(b1) == b2, loc(b2) == b3, loc(b3) == b4, loc(b4) == table) problem = fs.Problem("tower4", "blocksworld") problem.language = lang problem.init = init problem.goal = G problem.constraints += [clear_constraint] problem.action('move', [src, dest], land(clear(src), clear(dest)), [fs.FunctionalEffect(loc(src), dest)]) return problem
def test_lp_compilation(): problem = create_sample_problem() lang = problem.language x, y, z = [lang.variable(x, lang.Object) for x in ["x", "y", "z"]] room, ball, at_robby, free, at, gripper, carry = lang.get( "room", "ball", "at-robby", "free", "at", "gripper", "carry") # The conjunction results in a rule body "room(X), room(Y)", with both variable names capitalized, and room prefixed # with "atom" to prevent name clashes a1, a2 = create_compiler(problem).process_formula(room(x) & room(y)) assert isinstance( a1, LPAtom) and a1.symbol == a2.symbol == "atom_room" and a1.args == [ "X" ] and a2.args == ["Y"] # A simple built-in equality atom results in an LPAtom a1, = create_compiler(problem).process_formula(x == y) assert isinstance(a1, LPAtom) and a1.symbol == "=" and a1.args == ["X", "Y"] # A disjunction results in an auxiliary atom plus two rules c = create_compiler(problem) a1, = c.process_formula(room(x) | (room(y) & room(z))) assert isinstance(a1, LPAtom) and len(a1.args) == 3 and c.lp.nrules() == 2 # A nested conjunction with two subatoms a1, a2 = create_compiler(problem).process_formula( room(x) & (room(y) | room(z))) assert str(a1) == "atom_room(X)" and "__f" in str(a2) # An existentially quantified formula c = create_compiler(problem) a1, = c.process_formula(exists(x, y, room(x) & room(y))) assert str(a1) == "__f1()" and c.lp.nrules() == 1
def test_simplification_of_ex_quantification(): problem = generate_fstrips_counters_problem(ncounters=3) lang = problem.language value, max_int, counter, val_t, c1 = lang.get('value', 'max_int', 'counter', 'val', 'c1') x = lang.variable('x', counter) z = lang.variable('z', counter) two, three, six = [lang.constant(c, val_t) for c in (2, 3, 6)] phi = exists(z, land(x == z, top, value(z) < six)) assert simplify_existential_quantification(phi, inplace=False) == land(top, value(x) < six), \ "z has been replaced by x and removed from the quantification list, thus removing the quantifier" phi = exists(x, z, land(x == z, z == x, value(z) < six, flat=True)) assert simplify_existential_quantification(phi, inplace=False) == exists(x, value(x) < six), \ "The circular substitution dependency has been treated appropriately and only one substitution performed"
def test_literal_collection(): lang = generate_small_fstrips_bw_language(nblocks=5) clear, loc, b1, b2, b3 = lang.get('clear', 'loc', 'b1', 'b2', 'b3') x = lang.variable('x', lang.ns.block) assert rep.collect_literals_from_conjunction(clear(b1)) == {(clear(b1), True)} assert rep.collect_literals_from_conjunction(~clear(b1)) == {(clear(b1), False)} assert len(rep.collect_literals_from_conjunction(clear(b1) & ~clear(b2))) == 2 assert len( rep.collect_literals_from_conjunction( land(clear(b1), clear(b2), clear(b3)))) == 3 assert len( rep.collect_literals_from_conjunction(clear(x) & clear(b1) & clear(x))) == 2 # These ones are not conjunctions of literals, so should return None assert rep.collect_literals_from_conjunction(~(clear(b1) & clear(b2))) is None assert rep.collect_literals_from_conjunction((clear(b1) & clear(b2)) | clear(b3)) is None assert rep.collect_literals_from_conjunction(exists(x, clear(x))) is None # ATM we don't want to deal with the complexity of nested negation, so we expect the method to return None for # "not not clear(b2)" assert rep.collect_literals_from_conjunction(clear(b1) & ~~clear(b2)) is None
def test_variables_classification(): tw = tarskiworld.create_small_world() x = tw.variable('x', tw.Object) y = tw.variable('y', tw.Object) s = neg(land(tw.Cube(x), exists(y, land(tw.Tet(x), tw.LeftOf(x, y))))) free = free_variables(s) assert len(free) == 1 and symref(free[0]) == symref(x) assert len(all_variables(s)) == 2
def create_single_action_version(problem): lang = problem.language cell_t, at, reward, unblocked, picked, adjacent = lang.get("cell", "at", "reward", "unblocked", "picked", "adjacent") from_ = lang.variable("from", cell_t) to = lang.variable("to", cell_t) c = lang.variable("c", cell_t) problem.action(name='move', parameters=[from_, to], precondition=land(adjacent(from_, to), at(from_), unblocked(to), exists(c, reward(c)), flat=True), effects=[DelEffect(at(from_)), AddEffect(at(to)), # AddEffect(visited(to)), DelEffect(reward(to))])
def test_formula_writing1(): problem, loc, clear, b1, table = get_bw_elements() lang = problem.language assert print_formula(clear(b1)) == "(clear b1)" assert print_formula(loc(b1) == table) == "(= (loc b1) table)" assert print_formula(loc(b1) != table) == "(not (= (loc b1) table))" assert print_formula(clear(b1) | clear(table)) == "(or (clear b1) (clear table))" b = lang.variable('B', lang.ns.block) assert print_formula(forall(b, clear(b))) == "(forall (?B - block) (clear ?B))" assert print_formula(exists(b, clear(b))) == "(exists (?B - block) (clear ?B))"
def compute_gamma(self, ml, symbol, idx): tvar = _get_timestep_var(ml) disjuncts = [] for act, eff in idx[symbol.name]: action_binding = generate_action_arguments(ml, act) action_happens_at_t = ml.get_predicate(act.name)(*action_binding, tvar) effcond = self.to_metalang(eff.condition, tvar) gamma_binding = self.compute_gamma_binding(ml, eff, symbol) gamma_act = land(action_happens_at_t, effcond, *gamma_binding, flat=True) if action_binding: # exist-quantify the action parameters other than the timestep t gamma_act = exists(*action_binding, gamma_act) # We chain a couple of simplifications of the original gamma expression gamma_act = Simplify().simplify_expression( simplify_existential_quantification(gamma_act)) disjuncts.append(gamma_act) return lor(*disjuncts, flat=True)
def test_detect_free_variables(): tw = tarskiworld.create_small_world() x = tw.variable('x', tw.Object) y = tw.variable('y', tw.Object) s = neg(land(tw.Cube(x), exists(y, land(tw.Tet(x), tw.LeftOf(x, y))))) assert len(free_variables(s)) == 1