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)