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 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 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 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 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_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 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_r_grounded_semantics_with_negated_random_variable(self):
baba = ExampleFrameworks.r_framework()
baba.rv_world = [
Semantics.Sentence('s', random_variable=True, negation=True),
Semantics.Sentence('t', random_variable=True, negation=False)
]
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 [a, c]]))
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 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 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 extract_random_variable(random_variable):
if not matches_random_variable_declaration(random_variable):
raise ProgramParseException(
"Provided random variable does not match required format")
extracted = extract_from_parentheses(random_variable).split(',')
is_negation = extracted[0].strip().startswith(NEGATION_CHAR)
probability = float(extracted[1].strip())
if is_negation:
rv = Semantics.Sentence(extracted[0].strip()[1:],
random_variable=True,
negation=True)
return rv, (1 - probability)
else:
rv = Semantics.Sentence(extracted[0].strip(), random_variable=True)
return rv, probability
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_extract_conditional_variables(self):
variables = '[a, b]'
extracted_variables = Parser.extract_conditional_variables(variables)
self.assertEqual(2, len(extracted_variables))
self.assertTrue(
all([
elem in [
Semantics.Sentence('a', random_variable=True),
Semantics.Sentence('b', random_variable=True)
] for elem in extracted_variables
]))
variables = '[a , c, b ]'
extracted_variables = Parser.extract_conditional_variables(variables)
self.assertEqual(3, len(extracted_variables))
self.assertTrue(
all([
elem in [
Semantics.Sentence('a', random_variable=True),
Semantics.Sentence('b', random_variable=True),
Semantics.Sentence('c', random_variable=True)
] for elem in extracted_variables
]))
variables = '[c , a ]'
extracted_variables = Parser.extract_conditional_variables(variables)
self.assertEqual(2, len(extracted_variables))
self.assertTrue(
all([
elem in [
Semantics.Sentence('a', random_variable=True),
Semantics.Sentence('c', random_variable=True)
] for elem in extracted_variables
]))
rv_a = Semantics.Sentence('a', random_variable=True)
rv_b = Semantics.Sentence('b', random_variable=True)
rv_c = Semantics.Sentence('c', random_variable=True)
self.assertTrue(rv_a in Parser.extract_conditional_variables("[ a]"))
self.assertTrue(
all(elem in [rv_a, rv_b, rv_c] for elem in
Parser.extract_conditional_variables("[b, c , a]")))
def extract_conditional_random_variable(text):
if not matches_conditional_random_variable_declaration(text):
raise ProgramParseException(
"Provided conditional random variable does not match required format"
)
rv_definition = extract_from_parentheses(text)
arguments = rv_definition.split('[')
sentence = Semantics.Sentence(arguments.pop(0).split(',')[0].strip(),
random_variable=True)
conditional_variables = extract_conditional_variables('[' +
arguments.pop(0))
conditional_probabilities = extract_conditional_probabilities(
'[' + ''.join(arguments))
conditional_probability = Bayesian.ConditionalProbability(
sentence, conditional_variables, conditional_probabilities)
return sentence, conditional_probability
def test_parse_program_from_file(self):
parser = Parser.BABAProgramParser(filename='BABA_program_1')
baba = parser.parse()
self.assertTrue(
all([
elem in baba.language
for elem in [a, _a, b, _b, c, _c, d, _d, e, _e]
]))
self.assertEqual(11, len(baba.language))
self.assertTrue(
all([elem in baba.assumptions for elem in [a, b, c, d, e]]))
self.assertEqual(5, len(baba.assumptions))
self.assertTrue(
all([elem in baba.contraries for elem in [a, b, c, d, e]]))
self.assertEqual(5, len(baba.contraries))
self.assertIn(Semantics.Sentence('t', random_variable=True),
baba.random_variables)
self.assertEqual(1, len(baba.random_variables))
self.assertEqual(5, len(baba.rules))
import unittest
from PythonSemantics import Semantics, Bayesian
bn = Bayesian.BayesianNetwork({'a': 0.5, 'b': 0.8, 'c': 0.3})
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)
c_neg = Semantics.Sentence('c', random_variable=True, negation=True)
d = Semantics.Sentence('d', random_variable=True)
class TestBayesianNetwork(unittest.TestCase):
def test_validates_valid_network(self):
bn.validate()
def test_validates_invalid_network(self):
def invalid_network_instantiation():
Bayesian.BayesianNetwork({'a': 0.4, 'b': 1.0001, 'c': -0.4})
self.assertRaises(Bayesian.InvalidRandomVariableException,
invalid_network_instantiation)
def test_p(self):
baba = Bayesian.BayesianNetwork({'a': 0.5, 'b': 0.8, 'c': 0.3})
self.assertAlmostEqual(0.5, baba.p(a))
self.assertAlmostEqual(0.5, baba.p(a_neg))
self.assertAlmostEqual(0.8, baba.p(b))
self.assertAlmostEqual(0.2, baba.p(b_neg))
import unittest
from PythonSemantics import SemanticsUtils as Utils, Semantics
list_a = ['a', 'b']
list_b = ['c', 'd']
list_c = ['e', 'f']
list_d = ['g', 'h']
a = Semantics.Sentence('a')
b = Semantics.Sentence('b')
c = Semantics.Sentence('c')
d = Semantics.Sentence('d')
e = Semantics.Sentence('e')
f = Semantics.Sentence('f')
class TestSemantics(unittest.TestCase):
def test_list_combinations_empty(self):
self.assertEqual([], Utils.list_combinations([], []))
def test_list_combinations_one_empty(self):
self.assertEqual(list_a, Utils.list_combinations(list_a, []))
def test_list_combinations_both_non_empty(self):
combinations = Utils.list_combinations(list_a, list_b)
self.assertIn(['a', 'c'], combinations)
self.assertIn(['a', 'd'], combinations)
self.assertIn(['b', 'c'], combinations)
self.assertIn(['b', 'd'], combinations)
self.assertEqual(4, len(combinations))
def test_random_variable_initialises_with_probability(self):
rv = Semantics.Sentence('a', random_variable=True, negation=True)
self.assertEqual('a', rv.symbol)
self.assertEqual(True, rv.random_variable)
self.assertEqual(True, rv.negation)
from PythonSemantics import Semantics, Bayesian
a = Semantics.Sentence('a')
b = Semantics.Sentence('b')
c = Semantics.Sentence('c')
d = Semantics.Sentence('d')
e = Semantics.Sentence('e')
f = Semantics.Sentence('f')
g = Semantics.Sentence('g')
h = Semantics.Sentence('h')
i = Semantics.Sentence('i')
j = Semantics.Sentence('j')
s = Semantics.Sentence('s', random_variable=True)
t = Semantics.Sentence('t', random_variable=True)
_a = Semantics.Sentence('_a')
_b = Semantics.Sentence('_b')
_c = Semantics.Sentence('_c')
_d = Semantics.Sentence('_d')
_e = Semantics.Sentence('_e')
_f = Semantics.Sentence('_f')
HP = Semantics.Sentence('HP')
not_HP = Semantics.Sentence('not_HP')
HOC = Semantics.Sentence('HOC')
not_HOC = Semantics.Sentence('not_HOC')
CCA = Semantics.Sentence('CCA')
not_CCA = Semantics.Sentence('not_CCA')
FM = Semantics.Sentence('FM')
not_FM = Semantics.Sentence('not_FM')
import unittest
from PythonSemantics import ExampleFrameworks, Semantics
a = Semantics.Sentence('a')
b = Semantics.Sentence('b')
c = Semantics.Sentence('c')
d = Semantics.Sentence('d')
e = Semantics.Sentence('e')
f = Semantics.Sentence('f')
g = Semantics.Sentence('g')
h = Semantics.Sentence('h')
i = Semantics.Sentence('i')
j = Semantics.Sentence('j')
larger_baba = ExampleFrameworks.larger_framework()
venice_baba = ExampleFrameworks.venice_framework()
s_baba = ExampleFrameworks.s_framework()
class TestSemantics(unittest.TestCase):
def test_rule_initialises_with_no_body(self):
head = 0
rule = Semantics.Rule(head)
self.assertEqual(head, rule.head)
self.assertEqual([], rule.body, [])
def test_rule_initialises_with_body(self):
head = 0
body = [1, 2, 3]
import unittest
from PythonSemantics import Semantics, Bayesian
from PythonSemantics.Parsing import BABAProgramParser as Parser
program_1_string = "myAsm(a).\nmyAsm(b).\nmyAsm(c).\nmyAsm(d).\nmyAsm(e).\n" \
"contrary(a, _a).\ncontrary(b, _b).\ncontrary(c, _c).\ncontrary(d, _d)." \
"\ncontrary(e, _e).\nmyRule(_b, [c]).\nmyRule(_a, [b])." \
"\nmyRule(_c, [d]).\nmyRule(_d, [e]).\nmyRule(_e, [d]).\nmyRV(t, 0.5)."
a = Semantics.Sentence('a')
b = Semantics.Sentence('b')
c = Semantics.Sentence('c')
d = Semantics.Sentence('d')
e = Semantics.Sentence('e')
_a = Semantics.Sentence('_a')
_b = Semantics.Sentence('_b')
_c = Semantics.Sentence('_c')
_d = Semantics.Sentence('_d')
_e = Semantics.Sentence('_e')
t = Semantics.Sentence('t')
abc = Semantics.Sentence('abc')
ab = Semantics.Sentence('ab')
bc = Semantics.Sentence('bc')
bd = Semantics.Sentence('bd')
sentence = Semantics.Sentence('sentence')
_sentence = Semantics.Sentence('_sentence')
rv_a = Semantics.Sentence('a', random_variable=True)
rv_b = Semantics.Sentence('b', random_variable=True)
rv_c = Semantics.Sentence('c', random_variable=True)
rv_c_neg = Semantics.Sentence('c', random_variable=True, negation=True)
def extract_conditional_variables(text):
variables = extract_from_square_brackets(text)
return [
Semantics.Sentence(v.strip(), random_variable=True)
for v in variables.split(',')
]
def extract_assumption(assumption):
if not matches_assumption_declaration(assumption):
raise ProgramParseException(
"Provided assumption does not match required format")
return Semantics.Sentence(extract_from_parentheses(assumption))
