def test_conflict_free_trivially(self):
baba = ExampleFrameworks.valid_BABA_framework()
self.assertTrue(Semantics.conflict_free(baba, []))
self.assertTrue(Semantics.conflict_free(baba, [a]))
self.assertTrue(Semantics.conflict_free(baba, [a, b, c]))
self.assertFalse(Semantics.conflict_free(baba, [b, d]))
self.assertFalse(Semantics.conflict_free(baba, [a, b, c, d, e]))
def test_extract_conditional_random_variable(self):
cond_prob = Bayesian.ConditionalProbability(rv_a, [rv_b], {
'b': 0.4,
'~b': 0.3
})
parsed_rv, parsed_probability = Parser.extract_conditional_random_variable(
'myRV(a, [b], [b: 0.4, ~b: 0.3]).')
self.assertEqual(Semantics.Sentence('a', random_variable=True),
parsed_rv)
self.assertTrue(cond_prob == parsed_probability)
cond_prob = Bayesian.ConditionalProbability(rv_a, [rv_b, rv_c], {
'bc': 0.2,
'b~c': 0.4,
'~bc': 0.1,
'~b~c': 0.7
})
parsed_rv, parsed_probability = Parser.extract_conditional_random_variable(
'myRV(a, [b, c], [bc: 0.2, b~c: 0.4, ~bc: 0.1, ~b~c: 0.7]).')
self.assertEqual(Semantics.Sentence('a', random_variable=True),
parsed_rv)
self.assertTrue(cond_prob == parsed_probability)
cond_prob = Bayesian.ConditionalProbability(rv_a, [rv_c], {
'c': 0.2,
'~c': 0.3
})
parsed_rv, parsed_probability = Parser.extract_conditional_random_variable(
'myRV( a , [ c ] , [~c : 0.3, c: 0.2]).')
self.assertEqual(Semantics.Sentence('a', random_variable=True),
parsed_rv)
self.assertTrue(cond_prob == parsed_probability)
def test_integration_framework_with_random_variables(self):
parser = Parser.BABAProgramParser(
filename='../PythonSemantics/Parsing/BABA_program_3')
baba = parser.parse()
self.assertEqual(
0.64,
Semantics.semantic_probability(Semantics.GROUNDED, baba,
[ExampleFrameworks.j]))
self.assertEqual(
0.64,
Semantics.semantic_probability(Semantics.GROUNDED, baba,
[ExampleFrameworks.a]))
self.assertEqual(
0.64,
Semantics.semantic_probability(
Semantics.GROUNDED, baba,
[ExampleFrameworks.a, ExampleFrameworks.j]))
self.assertEqual(
0.6,
Semantics.semantic_probability(Semantics.GROUNDED, baba,
[ExampleFrameworks.b]))
self.assertEqual(
1.0,
Semantics.semantic_probability(Semantics.GROUNDED, baba,
[ExampleFrameworks.c]))
def test_Rule_str_function(self):
rule1 = Semantics.Rule(a, [b, c])
self.assertEqual(str(rule1), "a :- b, c")
rule2 = Semantics.Rule(b, [c, d, e])
self.assertEqual(str(rule2), "b :- c, d, e")
rule3 = Semantics.Rule(a, [])
self.assertEqual(str(rule3), "a :- ")
def test_admissible_larger_framework(self):
baba = ExampleFrameworks.larger_framework()
self.assertTrue(Semantics.is_admissible(baba, [b, e, g, h]))
self.assertTrue(Semantics.is_admissible(baba, [b, e, i]))
self.assertTrue(Semantics.is_admissible(baba, [b, f, h, g, i]))
self.assertFalse(Semantics.is_admissible(baba, [b, e, f, g, h]))
self.assertFalse(Semantics.is_admissible(baba, [b, e, f, i]))
def calculate_average_probability_execution_time(semantics, baba_framework,
number_of_trials):
start_time = time.process_time()
for i in range(number_of_trials):
Semantics.compute_semantic_probability(semantics, baba_framework)
return 100 * (time.process_time() - start_time)
def test_Random_Variables_equality(self):
rv1 = Semantics.Sentence('a', random_variable=True)
rv2 = Semantics.Sentence('a', random_variable=True)
rv3 = Semantics.Sentence('b', random_variable=True)
self.assertEqual(rv1, rv2)
self.assertNotEqual(rv1, rv3)
self.assertNotEqual(rv2, rv3)
def test_Contrary_equality(self):
contrary1 = Semantics.Contrary(a, b)
contrary2 = Semantics.Contrary(a, b)
contrary3 = Semantics.Contrary(a, c)
self.assertEqual(contrary1, contrary2)
self.assertNotEqual(contrary1, contrary3)
self.assertNotEqual(contrary2, contrary3)
def test_Rule_equality(self):
rule1 = Semantics.Rule(a, [b, c, d])
rule2 = Semantics.Rule(a, [d, b, c])
rule3 = Semantics.Rule(b, [b, c, d])
self.assertEqual(rule1, rule2)
self.assertNotEqual(rule1, rule3)
self.assertNotEqual(rule2, rule3)
def test_Attack_equality(self):
attack1 = Semantics.Attack(a, [b, c])
attack2 = Semantics.Attack(a, [c, b])
attack3 = Semantics.Attack(a, [b, d])
self.assertTrue(attack1 == attack2)
self.assertFalse(attack1 == attack3)
self.assertFalse(attack2 == attack3)
def invalid_non_flat_framework():
language = [a, b, c]
rules = [Semantics.Rule(a, [b, c])]
assumptions = [a, b, c]
contraries = {}
random_variables = []
return Semantics.BABA(language, rules, assumptions, contraries,
random_variables, None)
def extract_contrary(contrary):
if not matches_contrary_declaration(contrary):
raise ProgramParseException(
"Provided contrary does not match required format")
extracted = extract_from_parentheses(contrary).split(',')
assumption = Semantics.Sentence(extracted[0].strip())
contrary = Semantics.Sentence(extracted[1].strip())
return Semantics.Contrary(assumption, contrary)
def test_extract_assumption(self):
self.assertEqual(Parser.extract_assumption('myAsm(a).'),
Semantics.Sentence('a'))
self.assertEqual(Parser.extract_assumption('myAsm(myAsm).'),
Semantics.Sentence('myAsm'))
self.assertEqual(Parser.extract_assumption('myAsm(As09).'),
Semantics.Sentence('As09'))
self.assertEqual(Parser.extract_assumption('myAsm(abcde).'),
Semantics.Sentence('abcde'))
def test_ideal_framework(self):
sceptically_preferred_sets = Semantics.sceptically_preferred(
ExampleFrameworks.ideal_framework())
self.assertIn(Semantics.SemanticSet([a]), sceptically_preferred_sets)
self.assertEqual(1, len(sceptically_preferred_sets))
ideal_sets = Semantics.ideal(ExampleFrameworks.ideal_framework())
self.assertIn(Semantics.SemanticSet([]), ideal_sets)
self.assertEqual(1, len(ideal_sets))
def valid_BABA_framework():
f = Semantics.Sentence('f', random_variable=True)
language = [a, b, c, d, e, f]
rules = [Semantics.Rule(a, [b, c])]
assumptions = [b, c]
contraries = {b: Semantics.Contrary(b, d), c: Semantics.Contrary(c, e)}
random_variables = [f]
return Semantics.BABA(language, rules, assumptions, contraries,
random_variables, None)
def test_SemanticSet_equality(self):
s1 = Semantics.SemanticSet([a, b, c])
s2 = Semantics.SemanticSet([c, a, b])
s3 = Semantics.SemanticSet([a, b])
self.assertEqual(s1, s2)
self.assertNotEqual(s1, s3)
self.assertNotEqual(s2, s3)
self.assertTrue(s1 in set([s1]))
def test_r_grounded_semantics_with_random_variable_world(self):
baba = ExampleFrameworks.r_framework()
baba.rv_world = [Semantics.Sentence('s', random_variable=True)]
grounded = Semantics.grounded(baba)
self.assertEqual(1, len(grounded))
grounded_set = grounded.pop()
self.assertEqual(2, len(grounded_set.elements))
self.assertTrue(all([elem in grounded_set.elements
for elem in [b, c]]))
def test_extract_contrary(self):
self.assertEqual(Parser.extract_contrary('contrary(a, _a).'),
Semantics.Contrary(a, _a))
self.assertEqual(Parser.extract_contrary('contrary(abc, t).'),
Semantics.Contrary(abc, t))
self.assertEqual(
Parser.extract_contrary('contrary(sentence, _sentence).'),
Semantics.Contrary(sentence, _sentence))
self.assertEqual(Parser.extract_contrary('contrary(a , _a).'),
Semantics.Contrary(a, _a))
def with_chaining():
language = [a, b, c, d, e, f, g]
rules = [
Semantics.Rule(a, [b, c]),
Semantics.Rule(c, [d, e]),
Semantics.Rule(e, [f]),
Semantics.Rule(g, [c])
]
assumptions = [b, d, f]
return Semantics.BABA(language, rules, assumptions, {}, [], None)
def test_RandomVariable_str_function(self):
self.assertEqual(
str(Semantics.Sentence('a', random_variable=True, negation=True)),
"~a")
self.assertEqual(
str(Semantics.Sentence('b', random_variable=True, negation=False)),
"b")
self.assertEqual(
str(Semantics.Sentence('c', random_variable=True, negation=True)),
"~c")
def conditional_cow_framework():
language = [
HP, not_HP, HOC, not_HOC, CCA, not_CCA, FM, not_FM, cond_JN,
cond_neg_JN, JF, CM
]
rules = [
Semantics.Rule(HP, [HOC, CCA, not_FM]),
Semantics.Rule(HOC, []),
Semantics.Rule(FM, [CM]),
Semantics.Rule(CCA, [cond_neg_JN])
]
assumptions = [not_HP, not_HOC, not_CCA, not_FM]
contraries = {
not_HP: Semantics.Contrary(not_HP, HP),
not_HOC: Semantics.Contrary(not_HOC, HOC),
not_CCA: Semantics.Contrary(not_CCA, CCA),
not_FM: Semantics.Contrary(not_FM, FM)
}
random_variables = [cond_JN, JF, CM]
BN = Bayesian.BayesianNetwork({
cond_JN.symbol:
Bayesian.ConditionalProbability(cond_JN.symbol, [JF], {
"JF": 0.8,
"~JF": 0.0
}),
JF.symbol:
0.25,
CM.symbol:
0.1
})
return Semantics.BABA(language, rules, assumptions, contraries,
random_variables, BN)
def test_extract_rule(self):
self.assertEqual(Parser.extract_rule('myRule(a, [b,c]).', []),
Semantics.Rule(a, [b, c]))
self.assertEqual(Parser.extract_rule('myRule(a,[b , c, d]).', []),
Semantics.Rule(a, [b, c, d]))
self.assertEqual(Parser.extract_rule('myRule(abc, [ab, bc, bd]).', []),
Semantics.Rule(abc, [ab, bc, bd]))
self.assertEqual(Parser.extract_rule('myRule(t, [a, b, ~c]).', [rv_c]),
Semantics.Rule(t, [a, b, rv_c_neg]))
self.assertEqual(Parser.extract_rule('myRule(t, []).', []),
Semantics.Rule(t, []))
def test_derivable_with_empty_body_rules(self):
baba = ExampleFrameworks.cow_framework()
self.assertTrue(Semantics.derivable(baba, ExampleFrameworks.HOC, []))
self.assertFalse(
Semantics.derivable(baba, ExampleFrameworks.not_HOC, []))
self.assertTrue(
Semantics.derivable(baba, ExampleFrameworks.not_FM,
[ExampleFrameworks.not_FM]))
self.assertFalse(
Semantics.derivable(baba, ExampleFrameworks.FM,
[ExampleFrameworks.not_FM]))
def test_extract_random_variable(self):
self.assertEqual((Semantics.Sentence('a', random_variable=True), 0.5),
Parser.extract_random_variable('myRV(a, 0.5).'))
self.assertEqual(
(Semantics.Sentence('abc', random_variable=True), 0.00001),
Parser.extract_random_variable('myRV(abc, 0.00001).'))
self.assertEqual((Semantics.Sentence('t', random_variable=True), 1),
Parser.extract_random_variable('myRV(t, 1).'))
self.assertEqual((Semantics.Sentence('a', random_variable=True), 0.1),
Parser.extract_random_variable('myRV(a,0.1).'))
self.assertEqual((Semantics.Sentence(
'a', random_variable=True, negation=True), 0.9),
Parser.extract_random_variable('myRV( ~a, 0.1).'))
def test_grounded_probability(self):
baba = ExampleFrameworks.r_framework()
self.assertEqual(
0.64, Semantics.semantic_probability(Semantics.GROUNDED, baba,
[j]))
self.assertEqual(
0.64, Semantics.semantic_probability(Semantics.GROUNDED, baba,
[a]))
self.assertEqual(
0.64,
Semantics.semantic_probability(Semantics.GROUNDED, baba, [a, j]))
self.assertEqual(
0.6, Semantics.semantic_probability(Semantics.GROUNDED, baba, [b]))
self.assertEqual(
1.0, Semantics.semantic_probability(Semantics.GROUNDED, baba, [c]))
def conditional_probability_key(self, cond_variables):
required_variables = [
rv for rv in cond_variables if Semantics.Sentence(
rv.symbol, random_variable=True) in self.conditional_variables
]
sorted_variables = sorted(required_variables, key=lambda rv: rv.symbol)
return ''.join([str(rv) for rv in sorted_variables])
def test_generate_worlds(self):
a = Semantics.Sentence('a', random_variable=True)
a_neg = Semantics.Sentence('a', random_variable=True, negation=True)
b = Semantics.Sentence('b', random_variable=True)
b_neg = Semantics.Sentence('b', random_variable=True, negation=True)
c = Semantics.Sentence('c', random_variable=True)
four_worlds = Utils.generate_worlds([a, b])
self.assertEqual(4, len(four_worlds))
for world in four_worlds:
self.assertEqual(2, len(world))
self.assertFalse(a in world and a_neg in world)
self.assertFalse(b in world and b_neg in world)
eight_worlds = Utils.generate_worlds([a, b, c])
self.assertEqual(8, len(eight_worlds))
def test_group_intersection(self):
set_a = Semantics.SemanticSet([a, b, c])
set_b = Semantics.SemanticSet([a, b])
set_c = Semantics.SemanticSet([c])
intersection_a_b = Utils.group_intersection([set_a, set_b])
self.assertIn(a, intersection_a_b.elements)
self.assertIn(b, intersection_a_b.elements)
self.assertEqual(2, len(intersection_a_b.elements))
intersection_a_c = Utils.group_intersection([set_a, set_c])
self.assertIn(c, intersection_a_c.elements)
self.assertEqual(1, len(intersection_a_c.elements))
intersection_b_c = Utils.group_intersection([set_b, set_c])
self.assertEqual(0, len(intersection_b_c.elements))
def generate_worlds(random_variables):
worlds = []
for rv in random_variables:
pos = Semantics.Sentence(rv.symbol, random_variable=True)
neg = Semantics.Sentence(rv.symbol, random_variable=True, negation=True)\
possible_world = [pos, neg]
if len(worlds) == 0:
worlds = [[pos], [neg]]
continue
worlds = list(itertools.product(worlds, possible_world))
worlds = [flatten(list(world)) for world in worlds]
return worlds
def test_contrary_initialisation(self):
assumption = 1
contrary_value = 2
contrary = Semantics.Contrary(assumption, contrary_value)
self.assertEqual(assumption, contrary.assumption)
self.assertEqual(contrary_value, contrary.contrary)
