Python MySolver Examples

Example #1

File: test_with_walters_example.py Project: csvoss/syndra

    def test_build_context(self):
        RAF = Agent("RAF")
        HRAS = Agent("HRAS")
        MEK1 = Agent("MEK1")
        ERK1 = Agent("ERK1")
        SAF1 = Agent("SAF1")
        gtp = Label("GTP")
        phosphate = Label("phosphate")

        predicate = And(
            ModelHasRule(lambda r: And(
                    PregraphHas(r, RAF.bound(HRAS.labeled(gtp))),
                    PregraphHas(r, MEK1),
                    PostgraphHas(r, MEK1.labeled(phosphate))
            )),
            ModelHasRule(lambda r: And(
                    PregraphHas(r, MEK1.labeled(phosphate)),
                    PregraphHas(r, ERK1),
                    PostgraphHas(r, ERK1.labeled(phosphate))
            )),
            ModelHasRule(lambda r: And(
                    PregraphHas(r, ERK1.labeled(phosphate)),
                    PregraphHas(r, SAF1),
                    PostgraphHas(r, SAF1.labeled(phosphate))
            ))
        )
        solver = MySolver("RAF", "HRAS", "MEK1", "ERK1", "SAF1")
        solver.add(predicate)
        self.assertTrue(solver.check())
        self.assertIsNotNone(solver.model())

Example #2

File: test_with_walters_example.py Project: arey0pushpa/syndra

    def test_some_unsat_thing(self):
        RAF = Agent("RAF")
        HRAS = Agent("HRAS")
        MEK1 = Agent("MEK1")
        gtp = Label("GTP")
        phosphate = Label("phosphate")

        predicate = And(
            ModelHasRule(
                lambda r: And(PregraphHas(r, RAF.bound(HRAS.labeled(gtp))),
                              PregraphHas(r, MEK1),
                              PostgraphHas(r, MEK1.labeled(phosphate)))),
            Not(
                ModelHasRule(
                    lambda r: And(PregraphHas(r, RAF.bound(HRAS.labeled(gtp))),
                                  PregraphHas(r, MEK1),
                                  PostgraphHas(r, MEK1.labeled(phosphate))))))
        solver = MySolver("RAF", "HRAS", "MEK1")
        solver.add(predicate)
        self.assertFalse(solver.check())
        with self.assertRaises(ValueError):
            solver.model()

Example #3

File: test_with_walters_example.py Project: csvoss/syndra

    def test_some_unsat_thing(self):
        RAF = Agent("RAF")
        HRAS = Agent("HRAS")
        MEK1 = Agent("MEK1")
        gtp = Label("GTP")
        phosphate = Label("phosphate")

        predicate = And(
            ModelHasRule(lambda r: And(
                    PregraphHas(r, RAF.bound(HRAS.labeled(gtp))),
                    PregraphHas(r, MEK1),
                    PostgraphHas(r, MEK1.labeled(phosphate))
            )),
            Not(ModelHasRule(lambda r: And(
                    PregraphHas(r, RAF.bound(HRAS.labeled(gtp))),
                    PregraphHas(r, MEK1),
                    PostgraphHas(r, MEK1.labeled(phosphate))
            )))
        )
        solver = MySolver("RAF", "HRAS", "MEK1")
        solver.add(predicate)
        self.assertFalse(solver.check())
        with self.assertRaises(ValueError):
            solver.model()

Example #4

File: test_with_walters_example.py Project: arey0pushpa/syndra

    def test_build_context(self):
        RAF = Agent("RAF")
        HRAS = Agent("HRAS")
        MEK1 = Agent("MEK1")
        ERK1 = Agent("ERK1")
        SAF1 = Agent("SAF1")
        gtp = Label("GTP")
        phosphate = Label("phosphate")

        predicate = And(
            ModelHasRule(
                lambda r: And(PregraphHas(r, RAF.bound(HRAS.labeled(gtp))),
                              PregraphHas(r, MEK1),
                              PostgraphHas(r, MEK1.labeled(phosphate)))),
            ModelHasRule(lambda r: And(
                PregraphHas(r, MEK1.labeled(phosphate)), PregraphHas(r, ERK1),
                PostgraphHas(r, ERK1.labeled(phosphate)))),
            ModelHasRule(lambda r: And(
                PregraphHas(r, ERK1.labeled(phosphate)), PregraphHas(r, SAF1),
                PostgraphHas(r, SAF1.labeled(phosphate)))))
        solver = MySolver("RAF", "HRAS", "MEK1", "ERK1", "SAF1")
        solver.add(predicate)
        self.assertTrue(solver.check())
        self.assertIsNotNone(solver.model())

Example #5

File: test_solver.py Project: arey0pushpa/syndra

 def setUp(self):
     self.solver = MySolver("A", "B")

Example #6

File: test_solver.py Project: arey0pushpa/syndra

class SolverTestCase(TestCase):

    def setUp(self):
        self.solver = MySolver("A", "B")

    def test_quick_check_true(self):
        self.assertTrue(self.solver.quick_check(syndra_true))

    def test_quick_check_false(self):
        self.assertFalse(self.solver.quick_check(syndra_false))

    def test_quick_check_pushes_and_pops(self):
        self.assertTrue(self.solver.check())
        self.assertFalse(self.solver.quick_check(syndra_false))
        self.assertTrue(self.solver.check())

    def test_context(self):
        with self.solver.context():
            self.solver.add(syndra_false)
            self.assertFalse(self.solver.check())
        self.assertTrue(self.solver.check())

    def test_add(self):
        with self.solver.context():
            self.assertTrue(self.solver.check())
            self.solver.add(syndra_true)
            self.assertTrue(self.solver.check())
            self.solver.add(syndra_false)
            self.assertFalse(self.solver.check())

    def test_quick_check_valid_f_t(self):
        with self.solver.context():
            self.solver.add(syndra_false)
            self.assertTrue(self.solver.quick_check_valid(syndra_true))

    def test_quick_check_valid_f_f(self):
        with self.solver.context():
            self.solver.add(syndra_false)
            self.assertTrue(self.solver.quick_check_valid(syndra_false))

    def test_quick_check_valid_t_t(self):
        with self.solver.context():
            self.solver.add(syndra_true)
            self.assertTrue(self.solver.quick_check_valid(syndra_true))

    def test_quick_check_valid_t_f(self):
        with self.solver.context():
            self.solver.add(syndra_true)
            self.assertFalse(self.solver.quick_check_valid(syndra_false))

    def test_push_pop(self):
        self.assertTrue(self.solver.check())
        self.solver.push()
        self.assertTrue(self.solver.check())
        self.solver.add(syndra_false)
        self.assertFalse(self.solver.check())
        self.solver.pop()
        self.assertTrue(self.solver.check())

Example #7

File: causality_analyzer.py Project: csvoss/syndra

    # TODO assert that the model is not true, etc etc

if __name__ == '__main__':
    print "---"
    kinase = Agent("kinase")
    # phosphate = Label("phosphate")
    # oxalate = Label("oxalate")
    substrate = Agent("substrate")
    pred = ModelHasRule(lambda r: And(
            PregraphHas(r, kinase.bound(substrate)),
            PostgraphHas(r, kinase),
            PostgraphHas(r, substrate),
    ))

    solver = MySolver("kinase", "substrate")
    print "---"
    solver.add(pred)
    print solver.check()
    print solver.model()
    print "---"

    # RAF = Agent("RAF")
    # HRAS = Agent("HRAS")
    # MEK1 = Agent("MEK1")
    # ERK1 = Agent("ERK1")
    # SAF1 = Agent("SAF1")
    # gtp = Label("GTP")
    # phosphate = Label("phosphate")
    # solver = MySolver("RAF", "HRAS", "MEK1", "ERK1", "SAF1")
    # pred = And(

Example #8

import unittest

import predicate
import structure

from solver import MySolver
solver = MySolver("enzyme", "enzyme_site", "substrate", "d", "e")

class SimplePredicateTestCase(unittest.TestCase):
    def assertSat(self, pred):
        self.assertTrue(solver.quick_check(pred))

    def assertUnsat(self, pred):
        self.assertFalse(solver.quick_check(pred))

    def test_top_sat(self):
        self.assertSat(predicate.Top())

    def test_bottom_unsat(self):
        self.assertUnsat(predicate.Bottom())

    def test_modelhasrule_sat(self):
        pred = predicate.ModelHasRule(lambda r: predicate.Top())
        self.assertSat(pred)


class PredicateTestCase(unittest.TestCase):
    def setUp(self):
        enzyme = structure.Agent("enzyme")
        enzyme_site = structure.Agent("enzyme_site")
        substrate = structure.Agent("substrate")

Example #9

File: causality_analyzer.py Project: arey0pushpa/syndra

    # TODO assert that the model is not true, etc etc


if __name__ == '__main__':
    print "---"
    kinase = Agent("kinase")
    # phosphate = Label("phosphate")
    # oxalate = Label("oxalate")
    substrate = Agent("substrate")
    pred = ModelHasRule(lambda r: And(
        PregraphHas(r, kinase.bound(substrate)),
        PostgraphHas(r, kinase),
        PostgraphHas(r, substrate),
    ))

    solver = MySolver("kinase", "substrate")
    print "---"
    solver.add(pred)
    print solver.check()
    print solver.model()
    print "---"

    # RAF = Agent("RAF")
    # HRAS = Agent("HRAS")
    # MEK1 = Agent("MEK1")
    # ERK1 = Agent("ERK1")
    # SAF1 = Agent("SAF1")
    # gtp = Label("GTP")
    # phosphate = Label("phosphate")
    # solver = MySolver("RAF", "HRAS", "MEK1", "ERK1", "SAF1")
    # pred = And(