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)
