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 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_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_list_combinations_lists_of_lists(self):
combinations = Utils.list_combinations([list_a, list_b],
[list_c, list_d])
self.assertIn(['a', 'b', 'e', 'f'], combinations)
self.assertIn(['a', 'b', 'g', 'h'], combinations)
self.assertIn(['c', 'd', 'e', 'f'], combinations)
self.assertIn(['c', 'd', 'g', 'h'], combinations)
self.assertEqual(4, len(combinations))
def test_list_combinations(self):
product = Utils.list_combinations([[a]], [[b]])
self.assertIn(a, product[0])
self.assertIn(b, product[0])
self.assertEqual(len(product[0]), 2)
product = Utils.list_combinations([[a], [b]], [[c]])
self.assertIn(a, product[0])
self.assertIn(c, product[0])
self.assertIn(b, product[1])
self.assertIn(c, product[1])
self.assertEqual(len(product[0]), 2)
self.assertEqual(len(product[0]), 2)
product = Utils.list_combinations([[a]], [[]])
self.assertIn(a, product[0])
self.assertEqual(len(product[0]), 1)
def test_powerset(self):
test_set = [1, 2, 3]
power_sets = Utils.powerset(test_set)
self.assertIn([], power_sets)
self.assertIn([1], power_sets)
self.assertIn([2], power_sets)
self.assertIn([3], power_sets)
self.assertIn([1, 2], power_sets)
self.assertIn([1, 3], power_sets)
self.assertIn([2, 3], power_sets)
self.assertIn([1, 2, 3], power_sets)
self.assertEqual(8, len(power_sets))
def test_minimal_set(self):
set_a = Semantics.SemanticSet([a, b])
set_b = Semantics.SemanticSet([c, d])
set_c = Semantics.SemanticSet([b, d])
set_d = Semantics.SemanticSet([a, b, d])
set_e = Semantics.SemanticSet([a, c, d])
set_f = Semantics.SemanticSet([a, b, c, d])
minimal_sets = Utils.minimal_set(
set([set_a, set_b, set_c, set_d, set_e, set_f]))
self.assertIn(set_a, minimal_sets)
self.assertIn(set_b, minimal_sets)
self.assertIn(set_c, minimal_sets)
self.assertNotIn(set_d, minimal_sets)
self.assertNotIn(set_e, minimal_sets)
self.assertNotIn(set_f, minimal_sets)
def test_base_elements_multi_level_list(self):
base_elements = Utils.base_elements([list_a, list_b])
all(
self.assertIn(element, base_elements)
for element in ['a', 'b', 'c', 'd'])
self.assertEqual(4, len(base_elements))
def test_base_elements_trivial_case(self):
base_elements = Utils.base_elements(list_a)
self.assertIn('a', base_elements)
self.assertIn('b', base_elements)
self.assertEqual(2, len(base_elements))
def test_list_combinations_one_empty(self):
self.assertEqual(list_a, Utils.list_combinations(list_a, []))
def test_list_combinations_empty(self):
self.assertEqual([], Utils.list_combinations([], []))
def test_extensions_and_derivations_to_str_list(self):
ext_deriv = [(Semantics.SemanticSet([a, b, c]), [d, e, f]),
(Semantics.SemanticSet([d, e, f]), [a, b, c])]
string_representation = Utils.extensions_and_derivations_to_str_list(
ext_deriv)