def cow_framework(): JN = Semantics.Sentence('JN') not_JN = Semantics.Sentence('not_JN') language = [ HP, not_HP, HOC, not_HOC, CCA, not_CCA, FM, not_FM, JN, not_JN, JF, CM ] rules = [ Semantics.Rule(HP, [HOC, CCA, not_FM]), Semantics.Rule(HOC, []), Semantics.Rule(FM, [CM]), Semantics.Rule(CCA, [not_JN]), Semantics.Rule(JN, [JF]) ] assumptions = [not_HP, not_HOC, not_CCA, not_FM, not_JN] 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), not_JN: Semantics.Contrary(not_JN, JN), HP: Semantics.Contrary(HP, not_HP), HOC: Semantics.Contrary(HOC, not_HOC), CCA: Semantics.Contrary(CCA, not_CCA), FM: Semantics.Contrary(FM, not_FM), JN: Semantics.Contrary(JN, not_JN) } random_variables = [JF, CM] BN = Bayesian.BayesianNetwork({CM.symbol: 0.1, JF.symbol: 0.8}) return Semantics.BABA(language, rules, assumptions, contraries, random_variables, BN)
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_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_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 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_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 with_contraries(): language = [a, b, c, d, e, f, g, h, i] rules = [ Semantics.Rule(a, [d, e]), Semantics.Rule(b, [f, g]), Semantics.Rule(c, [h, i]) ] assumptions = [d, e, f, g, h, i] contraries = { b: Semantics.Contrary(b, d), d: Semantics.Contrary(d, b), c: Semantics.Contrary(c, e), e: Semantics.Contrary(e, c) } return Semantics.BABA(language, rules, assumptions, contraries, [], None)
def extract_rule(rule, random_variables): if not matches_rule_declaration(rule): raise ProgramParseException( "Provided rule does not match required format") extracted = extract_from_parentheses(rule).split(',', 1) head = Semantics.Sentence(extracted[0].strip()) body = [] for elem in extract_from_square_brackets(extracted[1].strip()).split(','): if len(elem) == 0: continue rv = Semantics.Sentence(elem.strip(), random_variable=True) is_negation = elem.strip().startswith(NEGATION_CHAR) if is_negation: rv = Semantics.Sentence(elem.strip()[1:], random_variable=True) if rv in random_variables: body.append( Semantics.Sentence(rv.symbol, random_variable=True, negation=is_negation)) else: body.append(Semantics.Sentence(elem.strip())) return Semantics.Rule(head, body)
def test_rule_initialises_with_body(self): head = 0 body = [1, 2, 3] rule = Semantics.Rule(head, body) self.assertEqual(head, rule.head) self.assertEqual(body, rule.body)
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 r_framework(): language = [a, _a, b, _b, c, _c, j, t, s] rules = [ Semantics.Rule(j, [a]), Semantics.Rule(_a, [b, s]), Semantics.Rule(_b, [c, t]) ] assumptions = [a, b, c] contraries = { a: Semantics.Contrary(a, _a), b: Semantics.Contrary(b, _b), c: Semantics.Contrary(c, _c) } random_variables = [s, t] bayes_net = Bayesian.BayesianNetwork({s.symbol: 0.6, t.symbol: 0.4}) return Semantics.BABA(language, rules, assumptions, contraries, random_variables, bayes_net)
def ideal_framework(): language = [a, _a, b, _b, c, _c, d, _d] rules = [ Semantics.Rule(_a, [b]), Semantics.Rule(_b, [c]), Semantics.Rule(_b, [d]), Semantics.Rule(_c, [d]), Semantics.Rule(_d, [c]) ] assumptions = [a, b, c, d] contraries = { a: Semantics.Contrary(a, _a), b: Semantics.Contrary(b, _b), c: Semantics.Contrary(c, _c), d: Semantics.Contrary(d, _d) } return Semantics.BABA(language, rules, assumptions, contraries, [], None)
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 larger_framework(): language = [a, b, c, d, e, f, g, h, i, j] rules = [ Semantics.Rule(a, [b]), Semantics.Rule(a, [e, f]), Semantics.Rule(c, [d, e, f]), Semantics.Rule(d, [g, h]), Semantics.Rule(d, [i]), Semantics.Rule(j, []) ] assumptions = [b, e, f, g, h, i] contraries = {b: Semantics.Contrary(b, c)} return Semantics.BABA(language, rules, assumptions, contraries, [], None)
def s_framework(): language = [a, _a, b, _b, c, _c, d, _d, e, _e, f, _f] rules = [ Semantics.Rule(_a, [b]), Semantics.Rule(_b, [a]), Semantics.Rule(_c, [b]), Semantics.Rule(_d, [c]), Semantics.Rule(_e, [d]), Semantics.Rule(_d, [e]) ] assumptions = [a, b, c, d, e, f] contraries = { a: Semantics.Contrary(a, _a), b: Semantics.Contrary(b, _b), c: Semantics.Contrary(c, _c), d: Semantics.Contrary(d, _d), e: Semantics.Contrary(e, _e), f: Semantics.Contrary(f, _f) } return Semantics.BABA(language, rules, assumptions, contraries, [], None)
def test_rule_initialises_with_no_body(self): head = 0 rule = Semantics.Rule(head) self.assertEqual(head, rule.head) self.assertEqual([], rule.body, [])
def with_no_contraries(): language = [a, b, c, d, e, f] rules = [Semantics.Rule(a, [b, c])] assumptions = [b, c] return Semantics.BABA(language, rules, assumptions, {}, [], None)