def binds(name_a, name_b): """Rule for 'A binds B'.""" A = new_variable(nickname=name_a) B = new_variable(nickname=name_b) return predicate.Exists(predicate.Implies(predicate.Named(A, name_a), predicate.Implies(predicate.Named(B, name_b), predicate.Not(predicate.And(predicate.PreLink(A, B)), predicate.PostLink(A, B)))))
def directly_phosphorylates(name_a, name_b): """ Macro for '"A" phosphorylates "B"'. """ A = new_variable(nickname=name_a) B = new_variable(nickname=name_b) return ForAll(A, ForAll(B, Implies(Named(A, name_a), Implies(Named(B, name_b), And(PreLabeled(A, ACTIVE), PreUnlabeled(B, PHOSPHORYLATED), PostLabeled(A, ACTIVE), PostLabeled(B, PHOSPHORYLATED))))))
def directly_activates(name_a, name_b): """ Macro for 'activated "A" activates "B"'. """ # Forall Model, Exists Rule in Model, [...] A = new_variable(nickname=name_a) B = new_variable(nickname=name_b) intp = datatypes.new_interpretation() return predicate.Exists(predicate.Implies(predicate.Named(A, name_a), predicate.Implies(predicate.Named(B, name_b), predicate.And(predicate.PreLabeled(A, ACTIVE), predicate.PreUnlabeled(B, ACTIVE), predicate.PostLabeled(A, ACTIVE), predicate.PostLabeled(B, ACTIVE)))))
def test_equal_transitive(self): v1 = datatypes.new_variable() v2 = datatypes.new_variable() v3 = datatypes.new_variable() pred1 = atomic_predicate.Equal(v1, v2) pred2 = atomic_predicate.Equal(v2, v3) pred3 = atomic_predicate.Equal(v1, v3) with solver.context(): solver.add(pred1._assert(self.submodel, self.interpretation)) solver.add(pred2._assert(self.submodel, self.interpretation)) sat = solver.check() self.assertTrue(sat) solver.add( z3.Not(pred3._assert(self.submodel, self.interpretation))) unsat = solver.check() self.assertFalse(unsat)
def directly_phosphorylates(name_a, name_b): """ Macro for 'activated "A" phosphorylates "B"'. """ A = new_variable(nickname=name_a) B = new_variable(nickname=name_b) # Okay, so what I actually want this to say is as follows: # Forall Model, Exists Rule in Model, reaction stuff holds over rule # reaction stuff = Forall A B, Named A name_a /\ Named B name_b => prelabeled etc intp = datatypes.new_interpretation() return predicate.Exists(predicate.Implies(predicate.Named(A, name_a), predicate.Implies(predicate.Named(B, name_b), predicate.And(predicate.PreLabeled(A, ACTIVE), predicate.PreUnlabeled(B, PHOSPHORYLATED), predicate.PostLabeled(A, ACTIVE), predicate.PostLabeled(B, PHOSPHORYLATED)))))
def test_named_get_model(self): v = datatypes.new_variable() s = "Name" pred = atomic_predicate.Named(v, s) z3pred = pred._assert(self.submodel, self.interpretation) with solver.context(): solver.add(z3pred) model = solver.model() self.assertIsNotNone(model[v]) self.assertEquals(model[v], datatypes.Variable.variable(1))
def test_named_still_sat(self): v = datatypes.new_variable() s1 = "Same Name" s2 = "Same Name" pred1 = atomic_predicate.Named(v, s1) pred2 = atomic_predicate.Named(v, s2) status = solver.quick_check( z3.And(pred1._assert(self.submodel, self.interpretation), pred2._assert(self.submodel, self.interpretation))) self.assertTrue(status)
def phosphorylated_is_active(name_b): """ Macro for 'phosphorylated "B" is active'. """ B = new_variable(nickname=name_b) return ForAll(B, Implies(Named(B, name_b), And(Implies(PreLabeled(B, PHOSPHORYLATED), PreLabeled(B, ACTIVE)), Implies(PostLabeled(B, PHOSPHORYLATED), PostLabeled(B, ACTIVE)))))
def test_validity_of_name_implies_name(self): v = datatypes.new_variable() s1 = "Same Name" s2 = "Same Name" pred1 = atomic_predicate.Named(v, s1) pred2 = atomic_predicate.Named(v, s2) with solver.context(): solver.add(pred1._assert(self.submodel, self.interpretation)) self.assertTrue(solver.check()) status = solver.quick_check_implied( pred2._assert(self.submodel, self.interpretation)) self.assertTrue(status)
def phosphorylated_is_active(name_b): """ Macro for 'phosphorylated "B" is active'. """ # Forall Model, *Forall* Rule in Model, Forall B, Named B named_b => and(...) B = new_variable(nickname=name_b) intp = datatypes.new_interpretation() return predicate.ForAll(predicate.Implies(predicate.Named(B, name_b), predicate.And(predicate.Implies(predicate.PreLabeled(B, PHOSPHORYLATED), predicate.PreLabeled(B, ACTIVE)), predicate.Implies(predicate.PostLabeled(B, PHOSPHORYLATED), predicate.PostLabeled(B, ACTIVE)))))
def test_postunlabeled_sat(self): x = datatypes.new_variable() y = "Label" pred = predicate.PostUnlabeled(x, y) self.assertSat(pred)
def test_posthas_sat(self): v = datatypes.new_variable() pred = predicate.PostHas(v) self.assertSat(pred)
def test_equal_sat(self): v1 = datatypes.new_variable() v2 = datatypes.new_variable() pred = predicate.Equal(v1, v2) self.assertSat(pred)
def test_postlink_sat(self): x, y = datatypes.new_variable(), datatypes.new_variable() pred = atomic_predicate.PostLink(x, y) self.assertSat(pred)
def test_prehas_sat(self): v = datatypes.new_variable() pred = predicate.PreHas(v) self.assertSat(pred)
def test_rem_sat(self): v = datatypes.new_variable() pred = predicate.Add(v) import pdb pdb.set_trace() self.assertSat(pred)
def test_postparent_sat(self): x, y = datatypes.new_variable(), datatypes.new_variable() pred = atomic_predicate.PostParent(x, y) self.assertSat(pred)
def test_dolink_sat(self): x, y = datatypes.new_variable(), datatypes.new_variable() pred = predicate.DoLink(x, y) self.assertSat(pred)
def test_equal_sat(self): v1 = datatypes.new_variable() v2 = datatypes.new_variable() pred = atomic_predicate.Equal(v1, v2) self.assertSat(pred)
def test_preunlabeled_sat(self): x = datatypes.new_variable() y = "Label" pred = predicate.PreUnlabeled(x, y) self.assertSat(pred)
def test_named_sat(self): v = datatypes.new_variable() s = "Name" pred = atomic_predicate.Named(v, s) self.assertSat(pred)
def test_preparent_sat(self): x, y = datatypes.new_variable(), datatypes.new_variable() pred = predicate.PreParent(x, y) self.assertSat(pred)
def test_posthas_sat(self): v = datatypes.new_variable() pred = atomic_predicate.PostHas(v) self.assertSat(pred)
def test_add_sat(self): v = datatypes.new_variable() pred = atomic_predicate.Add(v) self.assertSat(pred)
def test_rem_sat(self): v = datatypes.new_variable() pred = predicate.Add(v) import pdb; pdb.set_trace() self.assertSat(pred)
def test_rem_sat(self): v = datatypes.new_variable() pred = atomic_predicate.Rem(v) self.assertSat(pred)
def test_named_sat(self): v = datatypes.new_variable() s = "Name" pred = predicate.Named(v, s) self.assertSat(pred)
def test_dounlink_sat(self): x, y = datatypes.new_variable(), datatypes.new_variable() pred = atomic_predicate.DoUnlink(x, y) self.assertSat(pred)
def test_postunlabeled_sat(self): x = datatypes.new_variable() y = "Label" pred = atomic_predicate.PostUnlabeled(x, y) self.assertSat(pred)
def test_postparent_sat(self): x, y = datatypes.new_variable(), datatypes.new_variable() pred = predicate.PostParent(x, y) self.assertSat(pred)
""" Macro for 'phosphorylated "B" is active'. """ B = new_variable(nickname=name_b) return ForAll(B, Implies(Named(B, name_b), And(Implies(PreLabeled(B, PHOSPHORYLATED), PreLabeled(B, ACTIVE)), Implies(PostLabeled(B, PHOSPHORYLATED), PostLabeled(B, ACTIVE))))) # n.b.: this is ActivityActivity def directly_activates(name_a, name_b): """ Macro for '"A" activates "B"'. """ A = new_variable(nickname=name_a) B = new_variable(nickname=name_b) return ForAll(A, ForAll(B, Implies(Named(A, name_a), Implies(Named(B, name_b), And(PreLabeled(A, ACTIVE), PreUnlabeled(B, ACTIVE), PostLabeled(A, ACTIVE), PostLabeled(B, ACTIVE)))))) # Other things: more specific phosphorylation (serine-phosphorylated; # serine-phosphorylated-at). Can prove theorems about this. # Other theorems to prove: can't have phosphorylated_is_active and not # phosphorylated_is_active. # Use cases for reductions (from transitive closure to minimal set of rules)