def tryKB(label, base):
kbString = base['kb']
kb = FolKB([])
for kbLine in kbString.split('\n'):
s = kbLine.strip()
if len(s) == 0:
continue
if (s[0] == '#'):
continue
try:
sentence = expr(s)
kb.tell(sentence)
except:
traceback.print_exc()
printKB(label, kb)
print(indent(2), 'queries:')
queryString = base['queries']
for qLine in queryString.split('\n'):
s = qLine.strip()
if len(s) == 0:
continue
if (s[0] == '#'):
continue
try:
query = expr(s)
generator = kb.ask_generator(query)
print(indent(3), str(query) + '?', end=' ')
if 'limit' in base:
printResults(query, generator, base['limit'])
else:
printResults(query, generator)
except:
traceback.print_exc()
def tryKB(label, base):
kbString = base['kb']
kb = FolKB([])
for kbLine in kbString.split('\n'):
s = kbLine.strip()
if len(s) > 0:
try:
sentence = expr(s)
kb.tell(sentence)
except:
traceback.print_exc()
printKB(label, kb)
queryString = base['queries']
for qLine in queryString.split('\n'):
s = qLine.strip()
if len(s) > 0:
try:
query = expr(s)
long = kb.ask(query)
short = {}
for v in long:
if v in query.args:
short[v] = long[v]
print(indent(2), 'queries:')
print(indent(3), str(query) + '?', short)
except:
traceback.print_exc()
def test_action():
precond = 'At(c, a) & At(p, a) & Cargo(c) & Plane(p) & Airport(a)'
effect = 'In(c, p) & ~At(c, a)'
a = Action('Load(c, p, a)', precond, effect)
args = [expr("C1"), expr("P1"), expr("SFO")]
assert a.substitute(expr("Load(c, p, a)"), args) == expr("Load(C1, P1, SFO)")
test_kb = FolKB(conjuncts(expr('At(C1, SFO) & At(C2, JFK) & At(P1, SFO) & At(P2, JFK) & Cargo(C1) & Cargo(C2) & Plane(P1) & Plane(P2) & Airport(SFO) & Airport(JFK)')))
assert a.check_precond(test_kb, args)
a.act(test_kb, args)
assert test_kb.ask(expr("In(C1, P2)")) is False
assert test_kb.ask(expr("In(C1, P1)")) is not False
assert test_kb.ask(expr("Plane(P2)")) is not False
assert not a.check_precond(test_kb, args)
def test_action():
precond = [[expr("P(x)"), expr("Q(y, z)")], [expr("Q(x)")]]
effect = [[expr("Q(x)")], [expr("P(x)")]]
a=Action(expr("A(x,y,z)"), precond, effect)
args = [expr("A"), expr("B"), expr("C")]
assert a.substitute(expr("P(x, z, y)"), args) == expr("P(A, C, B)")
test_kb = FolKB([expr("P(A)"), expr("Q(B, C)"), expr("R(D)")])
assert a.check_precond(test_kb, args)
a.act(test_kb, args)
assert test_kb.ask(expr("P(A)")) is False
assert test_kb.ask(expr("Q(A)")) is not False
assert test_kb.ask(expr("Q(B, C)")) is not False
assert not a.check_precond(test_kb, args)
def test_action():
precond = [[expr("P(x)"), expr("Q(y, z)")], [expr("Q(x)")]]
effect = [[expr("Q(x)")], [expr("P(x)")]]
a = Action(expr("A(x,y,z)"), precond, effect)
args = [expr("A"), expr("B"), expr("C")]
assert a.substitute(expr("P(x, z, y)"), args) == expr("P(A, C, B)")
test_kb = FolKB([expr("P(A)"), expr("Q(B, C)"), expr("R(D)")])
assert a.check_precond(test_kb, args)
a.act(test_kb, args)
assert test_kb.ask(expr("P(A)")) is False
assert test_kb.ask(expr("Q(A)")) is not False
assert test_kb.ask(expr("Q(B, C)")) is not False
assert not a.check_precond(test_kb, args)
def predictSuccess(current_skills, equation):
curr_skills_KB = FolKB()
required_skills_KB = FolKB()
required_skills = set()
# Create KnowledgeBase for current skills that exist
for skill in current_skills:
curr_skills_KB.tell(expr(skill))
steps_for_solving = solveEquation(equation)
lht = getLeftTerms(equation)
rht = getRightTerms(equation)
divisor = calcDivisor(lht, rht)
rht_var_combine = calcCombineVars(rht)
lht_var_combine = calcCombineVars(lht)
for step in steps_for_solving:
if 'addVar' in step:
if step[6] == '-':
required_skills.add('S2')
else:
required_skills.add('S1')
elif 'addConst' in step:
if step[9] == '-':
required_skills.add('S4')
else:
required_skills.add('S3')
elif 'divide' in step:
if divisor > 0:
required_skills.add('S5')
else:
required_skills.add('S6')
elif ('combineRightConst' or 'combineRightConstTwo') in step:
required_skills.add('S9')
elif 'combineLeftVar':
if (rht_var_combine > 0) | (lht_var_combine > 0):
required_skills.add('S7')
else:
required_skills.add('S8')
for sk in required_skills:
required_skills_KB.tell(expr(sk))
for curr_sk in curr_skills_KB.clauses:
if curr_sk in required_skills_KB.clauses:
required_skills_KB.retract(curr_sk)
missing_skills = required_skills_KB.clauses
return missing_skills
def tryKB(label, base):
kb = FolKB([])
# define the Differ predicate,
# e.g., Differ(A, B), Differ(B, C), ...
if 'Differ' in base:
objString = base['Differ']
objects = []
for obj in objString.split(','):
obj = obj.strip(' \t\n\r')
if obj == '':
continue
if obj[0] == '#':
continue
objects.append(obj)
for ob1 in objects:
for ob2 in objects:
if ob1 == ob2:
continue
s = 'Differ(' + ob1 + ', ' + ob2 + ')'
try:
sentence = expr(s)
kb.tell(sentence)
except:
traceback.print_exc()
# read facts and rules
kbString = base['kb']
for kbLine in kbString.split('\n'):
s = kbLine.strip()
if len(s) == 0:
continue
if (s[0] == '#'):
continue
try:
sentence = expr(s)
kb.tell(sentence)
except:
traceback.print_exc()
printKB(label, kb)
# now, ask some questions
print(indent(2), 'queries:')
queryString = base['queries']
for qLine in queryString.split('\n'):
s = qLine.strip()
if len(s) == 0:
continue
if (s[0] == '#'):
continue
try:
query = expr(s)
generator = kb.ask_generator(query)
print(indent(3), str(query) + '?', end=' ')
if 'limit' in base:
printResults(query, generator, base['limit'])
else:
printResults(query, generator)
except:
traceback.print_exc()
def test_graph_call():
pdll = spare_tire()
negkb = FolKB([expr('At(Flat, Trunk)')])
graph = Graph(pdll, negkb)
levels_size = len(graph.levels)
graph()
assert levels_size == len(graph.levels) - 1
def check_precond(self, kb, args):
"""Checks if the precondition is satisfied in the current state"""
if isinstance(kb, list):
kb = FolKB(kb)
for clause in self.precond:
if self.substitute(clause, args) not in kb.clauses:
return False
return True
def act(self, kb, args):
"""Executes the action on the state's knowledge base"""
if isinstance(kb, list):
kb = FolKB(kb)
if not self.check_precond(kb, args):
raise Exception('Action pre-conditions not satisfied')
for clause in self.effect:
kb.tell(self.substitute(clause, args))
if clause.op[:3] == 'Not':
new_clause = Expr(clause.op[3:], *clause.args)
if kb.ask(self.substitute(new_clause, args)) is not False:
kb.retract(self.substitute(new_clause, args))
else:
new_clause = Expr('Not' + clause.op, *clause.args)
if kb.ask(self.substitute(new_clause, args)) is not False:
kb.retract(self.substitute(new_clause, args))
return kb
def spare_tire_graphplan():
pdll = spare_tire()
negkb = FolKB([expr('At(Flat, Trunk)')])
graphplan = GraphPlan(pdll, negkb)
##Not sure
goals_pos = [expr('At(Spare, Axle)'), expr('At(Flat, Ground)')]
goals_neg = []
while True:
if goal_test(graphplan.graph.levels[-1].poskb, goals_pos) and graphplan.graph.non_mutex_goals(goals_pos+goals_neg, -1):
solution = graphplan.extract_solution(goals_pos, goals_neg, -1)
if solution:
return solution
graphplan.graph.expand_graph()
if len(graphplan.graph.levels)>=2 and graphplan.check_leveloff():
return None
def act(self, kb, args):
"""Executes the action on the state's knowledge base"""
if isinstance(kb, list):
kb = FolKB(kb)
if not self.check_precond(kb, args):
raise Exception('Action pre-conditions not satisfied')
for clause in self.effect:
kb.tell(self.substitute(clause, args))
if clause.op[:3] == 'Not':
new_clause = Expr(clause.op[3:], *clause.args)
if kb.ask(self.substitute(new_clause, args)) is not False:
kb.retract(self.substitute(new_clause, args))
else:
new_clause = Expr('Not' + clause.op, *clause.args)
if kb.ask(self.substitute(new_clause, args)) is not False:
kb.retract(self.substitute(new_clause, args))
return kb
def __init__(self, clauses=None):
self.const_syms = set()
self.pred_syms = set()
FolKB.__init__(self, clauses)
def predictSuccess(current_skills, equation, debug=False):
skills_needed = []
statements, counts = parse_equation(equation)
print("Predicting success on " + equation)
print("\tSkills: " + str(current_skills))
if debug:
print("\tStatements: " + str(statements))
skills_kb = FolKB()
for statement in statements:
skills_kb.tell(expr(statement))
# Skill 9 - combine two constant terms
if len(counts["Const"]["Left"]) + len(counts["Const"]["Right"]) > 1:
skills_kb.tell(expr("LeftConst(a) & RightConst(b) ==> Skill9(a, b)"))
skills_kb.tell(expr("RightConst(a) & RightConst(b) ==> Skill9(a, b)"))
# Skill 8 - combine two variable terms on a side to get a negative number
# Skill 7 - combine two variable terms on a side to get a positive number
if len(counts["Var"]["Left"]) + len(counts["Var"]["Right"]) > 1:
if len(counts["Var"]["Left"]) == 1 and len(
counts["Var"]["Right"]) == 1: # Ex: 2x=4x+1
if counts["Var"]["Left"][0] - counts["Var"]["Right"][0] < 0:
skills_kb.tell(
expr("LeftVar(a) & RightVar(b) ==> Skill8(a, b)"))
else:
skills_kb.tell(
expr("LeftVar(a) & RightVar(b) ==> Skill7(a, b)"))
elif len(counts["Var"]["Left"]) >= 2:
if counts["Var"]["Left"][0] + counts["Var"]["Left"][
1] < 0: # Ex: 4x-6x=4
skills_kb.tell(
expr("LeftVar(a) & LeftVar(b) ==> Skill8(a, b)"))
else:
skills_kb.tell(
expr("LeftVar(a) & LeftVar(b) ==> Skill7(a, b)"))
elif len(counts["Var"]["Right"]) >= 2:
if counts["Var"]["Right"][0] + counts["Var"]["Right"][
1] < 0: # Ex: 4=4x-6x
skills_kb.tell(
expr("RightVar(a) & RightVar(b) ==> Skill8(a, b)"))
else:
skills_kb.tell(
expr("RightVar(a) & RightVar(b) ==> Skill7(a, b)"))
# Skill 6 - divide both sides by a negative constant
# Skill 5 - divide both sides by a positive constant
final_var_value = 0
for varVal in counts["Var"]["Left"]:
final_var_value += varVal
for varVal in counts["Var"]["Right"]:
final_var_value -= varVal
if debug:
print("\tFinal var value: " + str(final_var_value))
if final_var_value < 0:
skills_kb.tell(expr("LeftVar(a) ==> Skill6(a)"))
skills_kb.tell(expr("RightVar(a) ==> Skill6(a)"))
elif final_var_value == 1:
pass
else:
skills_kb.tell(expr("LeftVar(a) ==> Skill5(a)"))
skills_kb.tell(expr("RightVar(a) ==> Skill5(a)"))
# Skill 4 - add a negative constant term from both sides
# Skill 3 - add a positive constant term to both sides
if len(counts["Const"]["Left"]) > 0:
final_left_value = 0
for constVal in counts["Const"]["Left"]:
final_left_value += constVal
if final_left_value < 0:
skills_kb.tell(expr("LeftConst(a) ==> Skill3(a)"))
else:
skills_kb.tell(expr("LeftConst(a) ==> Skill4(a)"))
skills = [
"Skill9", "Skill8", "Skill7", "Skill6", "Skill5", "Skill4", "Skill3",
"Skill2", "Skill1"
]
two_param_skills = ["Skill9", "Skill8", "Skill7"]
# Skill 2 - add a negative variable term to both sides
# Skill 1 - add a positive variable term to both sides
if len(counts["Var"]["Right"]) > 0:
final_right_value = 0
for varVal in counts["Var"]["Right"]:
final_right_value += varVal
if final_right_value < 0:
skills_kb.tell(expr("RightVar(a) ==> Skill1(a)"))
else:
skills_kb.tell(expr("RightVar(a) ==> Skill2(a)"))
if debug:
print("\tAsk KB:")
for skill in skills:
if skill in two_param_skills and skills_kb.ask(expr(skill + '(a, b)')):
skills_needed.append(skill[0] + skill[-1])
if debug:
print("\t\t" + skill + " ==> NEEDED")
elif skills_kb.ask(expr(skill + '(a)')):
skills_needed.append(skill[0] + skill[-1])
if debug:
print("\t\t" + skill + " ==> NEEDED")
missing_skills = []
for skill in skills_needed:
if skill not in current_skills: # If we don't know the skill yet
missing_skills.append(skill)
return missing_skills
def __init__(self, initial_state, actions, goal_test):
self.kb = FolKB(initial_state)
self.actions = actions
self.goal_test_func = goal_test
from logic import FolKB
from utils import expr
kb = FolKB(
map(expr, [
'List(xs) ==> List(Ins(x, xs))', 'List(EmptyList)',
'Pert(x, Ins(x, xs))', 'Pert(x, ys) ==> Pert(x, Ins(y,ys))',
'Concat(EmptyList, ys, ys)',
'Concat(xs, ys, zs) ==> Concat(Ins(x, xs), ys, Ins(x, zs))'
]))
def test_list():
assert repr(kb.ask(expr('List(EmptyList)'))) == '{}'
assert repr(kb.ask(
expr('List(Ins(One, EmptyList))'))) == '{v_3: One, v_2: EmptyList}'
assert repr(kb.ask(expr('List(Ins(One, Ins(Two, EmptyList)))'))) == '{v_7: One, v_6: Ins(Two, EmptyList),' \
' v_9: Two, v_8: EmptyList}'
assert repr(kb.ask(expr('List(Ins(One, Two))'))) == 'False'
def test_x_in_2_1_3():
answer = kb.ask_generator(
expr('Pert(x, (Ins(Two,Ins(One ,Ins(Three, EmptyList)))))'))
for i in answer:
if i == 0:
assert i.x == 'Two'
if i == 1:
assert i.x == 'One'
if i == 2:
assert i.x == 'Three'
def perform_actions(self):
"""Performs the necessary actions and returns a new Level"""
new_kb = FolKB(list(set(self.next_state_links.keys())))
return Level(new_kb)
def __init__(self, pddl):
self.pddl = pddl
self.kb = FolKB(pddl.init)
self.levels = [Level(self.kb)]
self.objects = set(arg for clause in self.kb.clauses for arg in clause.args)
def perform_actions(self):
new_kb_pos, new_kb_neg = FolKB(
list(set(self.next_state_links_pos.keys()))), FolKB(
list(set(self.next_state_links_neg.keys())))
return Level(new_kb_pos, new_kb_neg)
def __init__(self, clauses=[]):
self.const_syms = set()
self.pred_syms = set()
FolKB.__init__(self, clauses)
