def test_mazeprops9(self):
mc1 = MazeClause([(("X", (1, 1)), True), (("Y", (1, 1)), False),
(("Z", (1, 1)), True)])
mc2 = MazeClause([(("X", (1, 1)), False), (("Y", (1, 1)), True),
(("W", (1, 1)), False)])
res = MazeClause.resolve(mc1, mc2)
self.assertEqual(len(res), 0)
def ask (self, query):
"""
Given a MazeClause query, returns True if the KB entails
the query, False otherwise
"""
# TODO: Implement resolution inference here!
# This is currently implemented incorrectly; see
# spec for details!
# create copy of clauses
temp_clauses = self.clauses.copy()
# negate query and add to set of cluases
for key in query.props:
query.props[key] = not query.props[key]
temp_clauses.add(query)
new_clauses = set()
while True:
# iterate through each pair
for pair in itertools.combinations(temp_clauses, 2):
resolved_clause = MazeClause.resolve(pair[0], pair[1])
if (len(resolved_clause) == 1):
resolved_clause_check = resolved_clause.pop()
if resolved_clause_check.is_empty():
return True
resolved_clause.add(resolved_clause_check)
new_clauses.update(resolved_clause)
if new_clauses.issubset(temp_clauses):
return False
temp_clauses.update(new_clauses)
def test_mazeprops7(self):
mc1 = MazeClause([(("X", (1, 1)), True), (("Y", (1, 1)), True)])
mc2 = MazeClause([(("X", (1, 1)), False), (("Y", (2, 2)), True)])
res = MazeClause.resolve(mc1, mc2)
self.assertEqual(len(res), 1)
self.assertTrue(
MazeClause([(("Y", (1, 1)), True), (("Y", (2, 2)), True)]) in res)
def ask(self, query):
"""
Given a MazeClause query, returns True if the KB entails
the query, False otherwise
"""
clauses = self.clauses.copy()
new = set()
negation = set()
for i in query.props.items():
prop, neg = i[0], i[1]
#query.props[prop] = not neg
negation.add(MazeClause([(prop, not neg)]))
clauses |= negation
while True:
clause_combinations = itertools.combinations(clauses, 2)
for first_clause, second_clause in clause_combinations:
resolvents = MazeClause.resolve(first_clause, second_clause)
if any(clause.is_empty() for clause in resolvents):
return True
new |= resolvents
if new.issubset(clauses):
return False
clauses |= new
def ask(self, query):
"""
Given a MazeClause query, returns True if the KB entails
the query, False otherwise
"""
currentClauses = set(self.clauses)
newClauses = set()
for cell, bool in query.props.items():
currentClauses.add(MazeClause([(cell, not bool)]))
while True:
iterations = list(itertools.combinations(currentClauses, 2))
for pair in iterations:
toResolve = MazeClause.resolve(pair[0], pair[1])
for clauses in toResolve:
if clauses.is_empty():
return True
newClauses = newClauses | toResolve
if newClauses <= currentClauses:
return False
currentClauses = currentClauses | newClauses
def ask(self, query):
"""
Given a MazeClause query, returns True if the KB entails
the query, False otherwise
"""
new_kb = list(self.clauses)
# add ATTC to new_kb
for keys in query.props:
query_negated = MazeClause([(keys, not query.props.get(keys))])
pairs = list(product(new_kb, [query_negated]))
new_kb.append(query_negated)
while len(pairs) != 0:
resolvent = MazeClause.resolve(pairs[0][0], pairs[0][1])
if MazeClause([]) in resolvent:
return True
# something was resolved
if len(resolvent) != 0:
for keys in resolvent:
pairs = pairs + list(product(new_kb, [keys]))
new_kb.append(keys)
pairs.pop(0)
return False
def ask(self, query):
"""
Given a MazeClause query, returns True if the KB entails
the query, False otherwise
"""
negatedQuery = set()
for prop, value in query.props.items():
q = MazeClause([(prop, not value)])
negatedQuery.add(q)
new = set()
clauses = negatedQuery | set(self.clauses)
while True:
combinations = itertools.combinations(clauses, 2)
for combination in combinations:
resolvents = MazeClause.resolve(combination[0], combination[1])
if resolvents and list(resolvents)[0].is_empty():
return True
new = new | resolvents
if new.issubset(clauses):
return False
clauses = clauses | new
def ask(self, query):
"""
Given a MazeClause query, returns True if the KB entails
the query, False otherwise
"""
inferred = set()
clause_copy = copy.deepcopy(self.clauses)
for key, value in query.props.items():
clause_copy.add(MazeClause([(key, not value)]))
while True:
for combo in itertools.combinations(clause_copy, 2):
resolvents = MazeClause.resolve(combo[0], combo[1])
if MazeClause([]) in resolvents:
return True
inferred = inferred | resolvents
if inferred.issubset(clause_copy):
return False
clause_copy = clause_copy | inferred
def ask (self, query):
"""
Given a MazeClause query, returns True if the KB entails
the query, False otherwise
"""
temp_kb = copy.deepcopy(self)
for prop in query.props:
# get the clauses
clause = [(prop, False if query.props.get(prop) else True)]
clause = MazeClause(clause)
temp_kb.tell(clause)
while True:
kb = list(temp_kb.clauses)
for i in range(0, len(kb)):
for j in range(i+1, len(kb)):
res = MazeClause.resolve(kb[i], kb[j])
if MazeClause([]) in res:
return True
for clause in res:
temp_kb.tell(clause)
if len(temp_kb.clauses) == len(kb):
return False