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_dolink_sat(self):
x, y = datatypes.new_variable(), datatypes.new_variable()
pred = predicate.DoLink(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)
