Example #1
0
    def test_prune_False_from_And_right(self):
        phi = NamedAtomicProposition("phi")
        formula = And(phi, False)

        exp = False
        got = simplify(formula)
        self.assertFalse(got, f"Problem discovered. Expected {exp}, got {got}")
Example #2
0
    def test_prune_True_from_Or_right(self):
        phi = NamedAtomicProposition("phi")
        formula = Or(phi, True)

        exp = phi
        got = simplify(formula)
        self.assertTrue(got, f"Problem discovered. Expected {exp}, got {got}")
Example #3
0
    def test_prune_nested_False(self):
        phi = NamedAtomicProposition("phi")
        psi = NamedAtomicProposition("psi")
        formula = And(And(phi, False), And(False, psi))

        exp = And(phi, psi)
        got = simplify(formula)
        self.assertFalse(got, f"Problem discovered. Expected {exp}, got {got}")
Example #4
0
    def test_prune_True_from_And_left(self):
        phi = NamedAtomicProposition("phi")
        formula = And(True, phi)

        exp = phi
        got = simplify(formula)
        self.assertTrue(exp.eq(got),
                        f"Problem discovered. Expected {exp}, got {got}")
Example #5
0
    def test_prune_quadruple_nested_Not(self):
        phi = NamedAtomicProposition("phi")
        formula = Not(Not(Not(Not(Not(phi)))))

        exp = Not(phi)
        got = simplify(formula)
        self.assertTrue(exp.eq(got),
                        f"Problem discovered. Expected {exp}, got {got}")
Example #6
0
    def test_deMorgan_negated_Or(self):
        phi = NamedAtomicProposition("phi")
        psi = NamedAtomicProposition("psi")
        formula = Not(And(phi, psi))

        exp = Or(Not(phi), Not(psi))
        got = simplify(formula)
        self.assertTrue(exp.eq(got),
                        f"Problem discovered. Expected {exp}, got {got}")
Example #7
0
    def test_prune_nested_True(self):
        phi = NamedAtomicProposition("phi")
        psi = NamedAtomicProposition("psi")
        formula = And(And(phi, True), And(True, psi))

        exp = And(phi, psi)
        got = simplify(formula)
        self.assertTrue(exp.eq(got),
                        f"Problem discovered. Expected {exp}, got {got}")
Example #8
0
    def test_large_example(self):
        pa = NamedAtomicProposition("pa")
        phi = NamedAtomicProposition("phi")
        formula = \
            Not(And(
                pa,
                Not(And(
                    Not(Not(phi)),
                    Not(And(
                        Not(EU(
                            Not(And(Not(phi), Not(And(Not(Not(pa)), Not(True))))) ,
                            True
                        )),
                        Not(
                            EU(
                                Not(And(
                                    Not(phi),
                                    Not(And(
                                        Not(Not(pa)),
                                        Not(True)
                                    ))
                                )),
                                And(
                                    Not(True),
                                    Not(And(
                                        Not(phi),
                                        Not(And(
                                            Not(Not(pa)),
                                            Not(True)
                                        ))
                                    ))
                                )
                            )
                        )
                    ))
                ))
            ))


        exp = \
            Or(Not(pa), phi)
        got = simplify(formula)
        self.assertTrue(exp.eq(got),
                        f"Problem discovered. Expected {exp}, got {got}")
Example #9
0
 def test_simplify_negated_False(self):
     self.assertEqual(True, simplify(Not(False)))