def expand(self, new_belief):
# Do not add tautologies or contradictions
if entails({}, new_belief.formula) or entails({},
Not(new_belief.formula)):
return
self.beliefs.add(new_belief)
def revise(self, new_belief):
# Do not add tautologies or contradictions
if entails({}, new_belief.formula) or entails({},
Not(new_belief.formula)):
return
# Levi identity
not_belief = Belief(Not(new_belief.formula), new_belief.order)
self.contract(not_belief)
self.expand(new_belief)
def test_inclusion_contraction(self):
bb = self.belief_base
phi = self.p
# Phi is not a tautology
if entails({}, phi):
assert False
bb.revise(Belief(phi))
assert entails(bb.get_clauses(), phi)
def test_success_contraction(self):
bb = self.belief_base
phi = self.p
# Phi is not a tautology
if entails({}, phi):
assert False
bb.contract(Belief(phi))
assert not entails(bb.get_clauses(), phi)
def _get_remainders(self, phi):
"""
Find subsets which do not entail phi, disregarding order
"""
# Local function for finding all subsets
def find_subsets(s, n):
return list(
set(combination)
for combination in itertools.combinations(s, n))
N = len(self.beliefs)
remainders = []
# Start with n - 1 size subsets and iterate to 1
for n in range(N, 0, -1):
n_size_subsets = find_subsets(self.beliefs, n)
for subset in n_size_subsets:
# Check for a larger subset
c_prime_exists = sum(
[subset.issubset(remainder)
for remainder in remainders]) > 0
if c_prime_exists:
continue
# Create clauses of formulas and check that it does not entail phi
clauses = [belief.formula for belief in subset]
if not entails(clauses, phi.formula):
remainders.append(subset)
return remainders
def test_success_revision(self):
bb = self.belief_base
phi = self.p
bb.revise(Belief(phi))
assert entails(bb.get_clauses(), phi)
def test_entailment_3(self):
p = self.p
q = self.q
r = self.r
kb = {And(p, Biconditional(r, Or(p, q)))}
assert entails(kb, r)
def test_and_elimination(self):
"""
KB: {p & r}
Phi: p
"""
p = self.p
r = self.r
assert entails({And(p, r)}, p)
def test_vacuity_contraction(self):
bb = self.belief_base
phi = Proposition("r")
# Phi is not a member of Belief Base
if entails(bb.get_clauses(), phi):
assert False
bb.contract(Belief(phi))
assert bb == bb
def test_modus_ponens(self):
"""
KB:
{p, p -> q}
Phi:
q
"""
r = self.r
p = self.p
assert entails({p, Implication(p, r)}, r)
def test_vacuity_revision(self):
bb = self.belief_base
phi = self.p
bb2 = BeliefBase(self.belief_base.beliefs,
selection_function=select_largest_set)
# Phi is not a member of Belief Base
if entails(bb.get_clauses(), Not(phi)):
assert False
bb.revise(Belief(phi))
bb2.expand(Belief(phi))
assert bb == bb2
def test_extensionality_revision(self):
bb = self.belief_base
bb2 = BeliefBase(self.belief_base.beliefs,
selection_function=select_largest_set)
phi = Or(self.p, self.q)
xi = Or(self.p, self.q)
# Phi is not a member of Belief Base
if not entails({}, Biconditional(phi, xi)):
assert False
bb.revise(Belief(phi))
bb2.revise(Belief(xi))
assert bb == bb2
def test_extensionality_contraction(self):
bb = self.belief_base
bb2 = BeliefBase(self.belief_base.beliefs,
selection_function=select_largest_set)
phi = Implication(self.p, self.q)
xi = Or(Not(self.p), self.q)
# Phi is not a member of Belief Base
if entails({}, Biconditional(phi, xi)):
assert False
bb.contract(Belief(phi))
bb2.contract(Belief(xi))
assert bb == bb2
def test_entailment_fail(self):
"""
Test entailment on KB:
p <-> r
Formula for entailment:
-p & r
"""
r = self.r
p = self.p
# KB in CNF and split into clauses
clauses = {And(Or(Not(p), r), Or(Not(r), p))}
# Test if the formula: -p & r is entailed from the KB
assert not entails(clauses, And(Not(p), r))
def test_conjunctive_inclusion_contraction(self):
bb = self.belief_base
bb2 = BeliefBase(self.belief_base.beliefs,
selection_function=select_largest_set)
phi = self.p
xi = self.q
# Phi is not a member of Belief Base
bb.contract(Belief(And(phi, xi)))
if entails(bb.get_clauses(), phi):
assert False
bb2.contract(Belief(phi))
assert bb.beliefs.issubset(bb2.beliefs)
def test_closure_contraction(self):
"""
The outcome of contraction is logically closed
"""
bb = self.belief_base
bb.contract(Belief(self.p))
clauses = bb.get_clauses()
cn_bb = BeliefBase(selection_function=select_largest_set)
# Check that all formulas in the belief base is a logical consequence of the belief base
for belief in bb.beliefs:
if entails(clauses, belief.formula):
cn_bb.expand(belief)
assert cn_bb == bb
def test_subexpansion_revision(self):
bb = self.belief_base
bb2 = BeliefBase(self.belief_base.beliefs,
selection_function=select_largest_set)
phi = self.p
xi = self.q
# Phi is not a member of Belief Base
bb.revise(Belief(phi))
if entails(bb.get_clauses(), Not(xi)):
assert False
bb.expand(Belief(xi))
bb2.revise(Belief(And(phi, xi)))
assert bb.beliefs.issubset(bb2.beliefs)
def test_entailment_2(self):
"""
Test entailment on KB:
{-p -> q, q -> p, p -> r & s}
Formula for entailment:
p & r & s
"""
p = self.p
q = Proposition('q')
r = self.r
s = self.s
# KB in CNF and split into clauses
clauses = {Or(p, q), Or(Not(q), p), Or(Not(p), r), Or(Not(p), s)}
phi = And(And(p, r), s)
assert entails(clauses, phi)
def test_entailment(self):
"""
Test entailment on KB:
Robert does well in the exam if and only if he is prepared or lucky.
Robert does not do well in the exam
Formula for entailment:
Robert is not prepared
"""
r = self.r
p = self.p
s = self.s
# KB in CNF and split into clauses
clauses = {Or(Or(Not(r), p), s), Or(Not(p), r), Or(Not(s), r), Not(r)}
# Test if the formula: Not(p) is entailed from the KB
assert entails(clauses, Not(p))
def test_entailment_contradiction(self):
p = self.p
assert not entails({}, Implication(p, Not(p)))
def test_entailment_tautology(self):
p = self.p
assert entails({}, Or(p, Not(p)))
