def test_intersect(self):
     self.b.add_belief(Belief('p^q'))
     self.assertEqual(self.b,BeliefBase.intersect([self.b]))
     self.b_.add_belief(Belief('q^p'))
     self.assertEqual(self.b,BeliefBase.intersect([self.b,self.b_]))
     self.b.add_belief(Belief('(rvs)^p'))
     self.assertNotEqual(self.b,BeliefBase.intersect([self.b,self.b_]))
     self.b_.add_belief(Belief('(svr)^p'))
     self.assertEqual(self.b,BeliefBase.intersect([self.b,self.b_]))
def belief_base(s=''):
    '''Construct a belief base from a propositional logic sentence

    Optional: takes in a string of propositional logic in cnf
        if this is omitted, an empty belief base will be constructed
    Returns a BeliefBase object
    '''
    b = BeliefBase()
    if s != '':
        b.add_belief(Belief(s))
    return b
    def test_partial_meet_contraction(self):
        for i in ['p', 'q', 'r']:
            self.b.add_belief(Belief(i))
        r = BeliefBase()
        for i in ['q', 'r']:
            r.add_belief(Belief(i))
        self.b.contract(Belief('p^q'),'partial-meet')
        self.assertEqual(self.b, r)

        self.b.clear_beliefs()
        for i in ['p', '~pvr','r', 'p^q']:
            self.b.add_belief(Belief(i))
        r.clear_beliefs()
        r.add_belief(Belief('rv~p'))
        self.b.contract(Belief('r'),'partial-meet')
        self.assertEqual(self.b, r)
    def test_revision(self):
        for i in ['p', 'q', 'r']:
            self.b.add_belief(Belief(i))
        r = BeliefBase()
        for i in ['p', 'q', 'r','p^q']:
            r.add_belief(Belief(i))
        self.b.revise(Belief('p^q'),'maxichoice')
        self.assertEqual(self.b, r)

        self.b.clear_beliefs()
        for i in ['p^q', 'r']:
            self.b.add_belief(Belief(i))
        r.clear_beliefs()
        for i in ['~p','r']:
            r.add_belief(Belief(i))
        self.b.revise(Belief('~p'),'full-meet')
        self.assertEqual(self.b, r)
    def test_maxichoice_contraction(self):
        for i in ['p', 'q', 'r']:
            self.b.add_belief(Belief(i))
        r = BeliefBase()
        for i in ['q', 'r']:
            r.add_belief(Belief(i))
        self.b.contract(Belief('p^q'),'maxichoice')
        self.assertEqual(self.b, r)

        self.b.clear_beliefs()
        for i in ['p', 'q', '~pvr','r']:
            self.b.add_belief(Belief(i))
        r = BeliefBase()
        for i in ['q', 'rv~p']:
            r.add_belief(Belief(i))
        self.b.contract(Belief('r'),'maxichoice')
        self.assertEqual(self.b, r)
Esempio n. 6
0
        print()

    elif action == 'h':
        print_help()

    elif action == 'q':
        exit()

    else:
        print('Sorry, the command was not recognized. Type \'h\' for help.')
        print()

    handle_input(bb)


if __name__ == '__main__':
    parser = argparse.ArgumentParser(
        description='Belief base revision CLI tool.')
    parser.add_argument('--debug',
                        action='store_true',
                        help='enable debugging')
    args = parser.parse_args()

    if args.debug:
        logging.basicConfig(format='%(levelname)s:%(message)s',
                            level=logging.DEBUG)

    bb = BeliefBase()
    print_help()
    handle_input(bb)
 def setUp(self):
     self.b = BeliefBase()
     self.b_ = BeliefBase()
    def test_remainders(self):
        self.b.add_belief(Belief('p'))
        self.b.add_belief(Belief('q'))
        r1 = BeliefBase()
        r1.add_belief(Belief('p'))
        r2 = BeliefBase()
        r2.add_belief(Belief('q'))
        self.assertCountEqual(self.b.remainders(Belief('p^q')), [r1,r2])

        self.b.add_belief(Belief('~pvr'))
        r1.clear_beliefs()
        for i in ['p', 'q', '~pvr']:
            r1.add_belief(Belief(i))
        self.assertCountEqual(self.b.remainders(Belief('~r')), [r1])

        self.b.add_belief(Belief('r'))
        r1.clear_beliefs()
        for i in ['q', '~pvr']:
            r1.add_belief(Belief(i))
        r2.clear_beliefs()
        for i in ['p', 'q']:
            r2.add_belief(Belief(i))
        self.assertCountEqual(self.b.remainders(Belief('r')), [r1,r2])
class TestBeliefBase(unittest.TestCase):
    def setUp(self):
        self.b = BeliefBase()
        self.b_ = BeliefBase()

    def tearDown(self):
        self.b.clear_beliefs()
        self.b_.clear_beliefs()

    # tests the __eq__ and __ne__ functions
    def test_equality(self):
        self.b.add_belief(Belief('p'))
        self.b.add_belief(Belief('q'))
        self.b_.add_belief(Belief('q'))
        self.b_.add_belief(Belief('p'))
        self.assertEqual(self.b, self.b_)
        self.b.add_belief(Belief('(rvs)^p'))
        self.assertNotEqual(self.b, self.b_)
        self.b_.add_belief(Belief('(rvs)^p'))
        self.assertEqual(self.b, self.b_)
        self.b.del_belief(Belief('(rvs)^p'))
        self.assertNotEqual(self.b, self.b_)

    # tests the __str__ function
    def test_print(self):
        self.assertEqual(str(self.b), '{}')
        self.b.add_belief(Belief('p'))
        self.assertEqual(str(self.b), '{(p)}')
        self.b.add_belief(Belief('q'))
        self.assertEqual(str(self.b), '{(p), (q)}')
        self.b.del_belief(Belief('p'))
        self.assertEqual(str(self.b), '{(q)}')

    def test_intersect(self):
        self.b.add_belief(Belief('p^q'))
        self.assertEqual(self.b,BeliefBase.intersect([self.b]))
        self.b_.add_belief(Belief('q^p'))
        self.assertEqual(self.b,BeliefBase.intersect([self.b,self.b_]))
        self.b.add_belief(Belief('(rvs)^p'))
        self.assertNotEqual(self.b,BeliefBase.intersect([self.b,self.b_]))
        self.b_.add_belief(Belief('(svr)^p'))
        self.assertEqual(self.b,BeliefBase.intersect([self.b,self.b_]))

    # tests the entails function
    def test_entails(self):
        self.b.add_belief(Belief('p'))
        self.assertTrue(self.b.entails('p'))
        self.assertFalse(self.b.entails('q'))
        self.b.add_belief(Belief('q'))
        self.assertTrue(self.b.entails('p^q'))
        self.b.add_belief(Belief('r'))
        self.assertFalse(self.b.entails('(r^~p)'))
        self.assertTrue(self.b.entails('p^q^r^(~rvp)')) # raises error due to remove function

    # test the remainder function
    def test_remainders(self):
        self.b.add_belief(Belief('p'))
        self.b.add_belief(Belief('q'))
        r1 = BeliefBase()
        r1.add_belief(Belief('p'))
        r2 = BeliefBase()
        r2.add_belief(Belief('q'))
        self.assertCountEqual(self.b.remainders(Belief('p^q')), [r1,r2])

        self.b.add_belief(Belief('~pvr'))
        r1.clear_beliefs()
        for i in ['p', 'q', '~pvr']:
            r1.add_belief(Belief(i))
        self.assertCountEqual(self.b.remainders(Belief('~r')), [r1])

        self.b.add_belief(Belief('r'))
        r1.clear_beliefs()
        for i in ['q', '~pvr']:
            r1.add_belief(Belief(i))
        r2.clear_beliefs()
        for i in ['p', 'q']:
            r2.add_belief(Belief(i))
        self.assertCountEqual(self.b.remainders(Belief('r')), [r1,r2])

    def test_full_meet_contraction(self):
        for i in ['p', 'q', 'r']:
            self.b.add_belief(Belief(i))
        r = BeliefBase()
        r.add_belief(Belief('r'))
        self.b.contract(Belief('p^q'),'full-meet')
        self.assertEqual(self.b, r)

        self.b.clear_beliefs()
        for i in ['p', 'q', '~pvr','r']:
            self.b.add_belief(Belief(i))
        r.clear_beliefs()
        r.add_belief(Belief('q'))
        self.b.contract(Belief('r'),'full-meet')
        self.assertEqual(self.b, r)

        self.b.clear_beliefs()
        for i in ['~pvr','r']:
            self.b.add_belief(Belief(i))
        r.clear_beliefs()
        r.add_belief(Belief('rv~p'))
        self.b.contract(Belief('r'),'full-meet')
        self.assertEqual(self.b, r)

    def test_maxichoice_contraction(self):
        for i in ['p', 'q', 'r']:
            self.b.add_belief(Belief(i))
        r = BeliefBase()
        for i in ['q', 'r']:
            r.add_belief(Belief(i))
        self.b.contract(Belief('p^q'),'maxichoice')
        self.assertEqual(self.b, r)

        self.b.clear_beliefs()
        for i in ['p', 'q', '~pvr','r']:
            self.b.add_belief(Belief(i))
        r = BeliefBase()
        for i in ['q', 'rv~p']:
            r.add_belief(Belief(i))
        self.b.contract(Belief('r'),'maxichoice')
        self.assertEqual(self.b, r)

    def test_contained_by(self):
        self.b.add_belief(Belief('p'))
        self.assertTrue(self.b.contained_by(Belief('p^q')))
        self.b_.add_belief(Belief('p^q'))
        self.assertTrue(self.b_.contained_by(Belief('p^q^r')))
        self.assertFalse(self.b_.contained_by(Belief('(p)^(qvr)')))
        self.assertFalse(self.b.contained_by(Belief('(q)^(pv~r)')))

    def test_partial_meet_contraction(self):
        for i in ['p', 'q', 'r']:
            self.b.add_belief(Belief(i))
        r = BeliefBase()
        for i in ['q', 'r']:
            r.add_belief(Belief(i))
        self.b.contract(Belief('p^q'),'partial-meet')
        self.assertEqual(self.b, r)

        self.b.clear_beliefs()
        for i in ['p', '~pvr','r', 'p^q']:
            self.b.add_belief(Belief(i))
        r.clear_beliefs()
        r.add_belief(Belief('rv~p'))
        self.b.contract(Belief('r'),'partial-meet')
        self.assertEqual(self.b, r)

    def test_revision(self):
        for i in ['p', 'q', 'r']:
            self.b.add_belief(Belief(i))
        r = BeliefBase()
        for i in ['p', 'q', 'r','p^q']:
            r.add_belief(Belief(i))
        self.b.revise(Belief('p^q'),'maxichoice')
        self.assertEqual(self.b, r)

        self.b.clear_beliefs()
        for i in ['p^q', 'r']:
            self.b.add_belief(Belief(i))
        r.clear_beliefs()
        for i in ['~p','r']:
            r.add_belief(Belief(i))
        self.b.revise(Belief('~p'),'full-meet')
        self.assertEqual(self.b, r)