def create_complexes(self):
"""
Creates left- and right-hand sides of rule as multisets of Complexes.
:return: two multisets of Complexes represented as object Side
"""
lhs, rhs = [], []
for (f, t) in self.complexes:
c = Complex(self.agents[f:t + 1], self.compartments[f])
lhs.append(c) if t < self.mid else rhs.append(c)
return Side(lhs), Side(rhs)
def setUp(self):
# agents
self.a1 = AtomicAgent("T", "i")
self.a2 = AtomicAgent("S", "i")
self.a3 = AtomicAgent("T", "a")
self.a4 = AtomicAgent("S", "a")
self.s1 = StructureAgent("X", {self.a4})
self.s2 = StructureAgent("X", {self.a2})
self.s3 = StructureAgent("K", {self.a3})
self.s4 = StructureAgent("K", {self.a1})
self.s5 = StructureAgent("X", set())
self.s6 = StructureAgent("K", set())
self.c1 = Complex([self.s6], "cyt") # K()::cyt
self.c2 = Complex([self.s3], "cyt") # K(T{a})::cyt
self.c3 = Complex([self.s4], "cyt") # K(T{i})::cyt
self.c4 = Complex([self.s4, self.s1], "cyt") # K(T{i}).X(S{a})::cyt
self.c5 = Complex([self.s4, self.s2], "cyt") # K(T{i}).X(S{i})::cyt
self.c6 = Complex([self.s3, self.s1], "cyt") # K(T{a}).X(S{a})::cyt
self.c7 = Complex([self.s3, self.s2], "cyt") # K(T{a}).X(S{i})::cyt
# rates
self.parser = Parser("rate")
rate_expr = "3.0*[K()::cyt]/2.0*v_1"
self.rate_1 = Core.Rate.Rate(self.parser.parse(rate_expr).data)
rate_expr = "3.0*[K(T{i}).X()::cyt] + [K()::cyt]"
self.rate_2 = Core.Rate.Rate(self.parser.parse(rate_expr).data)
# states
self.state_1 = State(np.array([2, 3]))
self.state_2 = State(np.array([2, 0, 3, 1, 6, 2]))
def setUp(self):
self.s1 = StructureAgent("X", set())
self.s2 = StructureAgent("Y", set())
self.s3 = StructureAgent("Z", set())
self.c1 = Complex([self.s1], "rep")
self.c2 = Complex([self.s2], "rep")
self.c3 = Complex([self.s3], "rep")
ordering = (self.c1, self.c2, self.c3)
params = {"k1": 0.05, "k2": 0.1}
self.rate_parser = Parser("rate")
rate_expr = "1/(1+([X()::rep])**2)"
rate_1 = Rate(self.rate_parser.parse(rate_expr).data)
rate_1.vectorize(ordering, params)
rate_expr = "k1*[X()::rep]"
rate_2 = Rate(self.rate_parser.parse(rate_expr).data)
rate_2.vectorize(ordering, params)
rate_expr = "k2*[Z()::rep]"
rate_3 = Rate(self.rate_parser.parse(rate_expr).data)
rate_3.vectorize(ordering, params)
init = State(np.array([2.0, 1.0, 1.0]))
vector_reactions = {
VectorReaction(State(np.array([0.0, 0.0, 0.0])),
State(np.array([0.0, 1.0, 0.0])), rate_1),
VectorReaction(State(np.array([1.0, 0.0, 0.0])),
State(np.array([0.0, 0.0, 0.0])), rate_2),
VectorReaction(State(np.array([0.0, 0.0, 1.0])),
State(np.array([1.0, 0.0, 0.0])), None)
}
self.vm_1 = VectorModel(vector_reactions, init, ordering, None)
vector_reactions = {
VectorReaction(State(np.array([0.0, 0.0, 0.0])),
State(np.array([0.0, 1.0, 0.0])), rate_1),
VectorReaction(State(np.array([1.0, 0.0, 0.0])),
State(np.array([0.0, 0.0, 0.0])), rate_2),
VectorReaction(State(np.array([0.0, 0.0, 1.0])),
State(np.array([1.0, 0.0, 0.0])), rate_3)
}
self.vm_2 = VectorModel(vector_reactions, init, ordering, None)
# test abstract model
self.model_parser = Parser("model")
self.model_abstract = \
"""#! rules
=> X()::rep @ k2*[T{_}::rep]
T{a}::rep => T{i}::rep @ k1*[T{_}::rep]
#! inits
10 T{a}::rep
#! definitions
k1 = 0.05
k2 = 0.12
"""
# test transition system generating
a1 = AtomicAgent("B", "a")
a2 = AtomicAgent("S", "u")
a3 = AtomicAgent("S", "p")
a4 = AtomicAgent("T", "i")
s1 = StructureAgent("K", {a3, a4})
s2 = StructureAgent("K", {a2, a4})
cx1 = Complex([a1], "cyt")
cx2 = Complex([s1], "cyt")
cx3 = Complex([s2], "cyt")
cx4 = Complex([s1, a1], "cyt")
cx5 = Complex([s2, a1], "cyt")
ordering = (cx5, cx4, cx3, cx2, cx1)
# (K(S{u},T{i}).B{a}::cyt, K(S{p},T{i}).B{a}::cyt, K(S{u},T{i})::cyt, K(S{p},T{i})::cyt, B{a}::cyt)
self.model_TS = \
"""#! rules
=> K(S{u},T{i})::cyt @ omega
K(S{u})::cyt => K(S{p})::cyt @ alpha*[K(S{u})::cyt]
K(S{p})::cyt + B{a}::cyt => K(S{p}).B{a}::cyt @ beta*[K(S{p})::cyt]*[B{a}::cyt]
B{_}::cyt => @ gamma*[B{_}::cyt]
K(S{u},T{i}).B{a}::cyt => @ 5
#! inits
1 B{a}::cyt
#! definitions
alpha = 10
beta = 5
gamma = 2
omega = 3
"""
alpha = 10
beta = 5
gamma = 2
omega = 3
self.test_ts = TransitionSystem(ordering)
states = [
State(np.array((0.0, 0.0, 0.0, 0.0, 1.0))),
State(np.array((0.0, 0.0, 0.0, 0.0, 0.0))),
State(np.array((0.0, 0.0, 1.0, 0.0, 0.0))),
State(np.array((0.0, 0.0, 1.0, 0.0, 1.0))),
State(np.array((np.inf, np.inf, np.inf, np.inf, np.inf))),
State(np.array((0.0, 0.0, 0.0, 1.0, 1.0))),
State(np.array((0.0, 0.0, 1.0, 1.0, 1.0))),
State(np.array((0.0, 1.0, 0.0, 0.0, 0.0))),
State(np.array((0.0, 0.0, 0.0, 1.0, 0.0))),
State(np.array((0.0, 0.0, 1.0, 1.0, 0.0))),
State(np.array((0.0, 1.0, 1.0, 0.0, 0.0))),
State(np.array((0.0, 1.0, 0.0, 1.0, 0.0))),
State(np.array((0.0, 1.0, 1.0, 1.0, 0.0)))
]
# in edges we have probabilities, not rates, so we must normalise
go = gamma + omega # 5
goa = gamma + omega + alpha # 15
goab = gamma + omega + alpha + beta # 20
gob = gamma + omega + beta # 10
oa = omega + alpha # 13
self.test_ts.processed = set(states)
self.test_ts.edges = {
Edge(states[0], states[1], gamma / go),
Edge(states[0], states[3], omega / go),
Edge(states[1], states[2], omega / omega),
Edge(states[2], states[4], omega / oa),
Edge(states[2], states[8], alpha / oa),
Edge(states[3], states[2], gamma / goa),
Edge(states[3], states[4], omega / goa),
Edge(states[3], states[5], alpha / goa),
Edge(states[4], states[4], 1),
Edge(states[5], states[6], omega / gob),
Edge(states[5], states[7], beta / gob),
Edge(states[5], states[8], gamma / gob),
Edge(states[6], states[4], oa / goab),
Edge(states[6], states[9], gamma / goab),
Edge(states[6], states[10], beta / goab),
Edge(states[7], states[10], omega / omega),
Edge(states[8], states[9], gamma / gamma),
Edge(states[9], states[4], 1),
Edge(states[10], states[4], omega / oa),
Edge(states[10], states[11], alpha / oa),
Edge(states[11], states[12], omega / omega),
Edge(states[12], states[4], 1)
}
self.test_ts.encode(states[0])
# bigger TS
self.model_bigger_TS = \
"""#! rules
=> 2 K(S{u},T{i})::cyt @ omega
K(S{u})::cyt => K(S{p})::cyt @ alpha*[K(S{u})::cyt]
K(S{p})::cyt + B{a}::cyt => K(S{p}).B{a}::cyt @ beta*[K(S{p})::cyt]*[B{a}::cyt]
B{_}::cyt => @ gamma*[B{_}::cyt]
K(S{u},T{i}).B{a}::cyt => @ 5
#! inits
6 B{a}::cyt
#! definitions
alpha = 10
beta = 5
gamma = 2
omega = 3
"""
# even bigger TS
self.model_even_bigger_TS = \
"""#! rules
=> K(S{u},T{i})::cyt @ omega
K(S{u})::cyt => K(S{p})::cyt @ alpha*[K(S{u})::cyt]
K(S{p})::cyt + B{a}::cyt => K(S{p}).B{a}::cyt @ beta*[K(S{p})::cyt]*[B{a}::cyt]
B{_}::cyt => @ gamma*[B{_}::cyt]
K(S{u},T{i}).B{a}::cyt => @ 5
#! inits
10 B{a}::cyt
#! definitions
alpha = 10
beta = 5
gamma = 2
omega = 3
"""
self.model_parametrised = \
"""#! rules
=> K(S{u},T{i})::cyt @ omega
K(S{u})::cyt => K(S{p})::cyt @ alpha*[K(S{u})::cyt]
K(S{p})::cyt + B{a}::cyt => K(S{p}).B{a}::cyt @ beta*[K(S{p})::cyt]*[B{a}::cyt]
B{_}::cyt => @ gamma*[B{_}::cyt]
K(S{u},T{i}).B{a}::cyt => @ 5
#! inits
1 B{a}::cyt
#! definitions
alpha = 10
beta = 5
//gamma = 2
omega = 3
"""
self.model_with_sinks = \
"""#! rules
def setUp(self):
# agents
self.s1 = StructureAgent("X", set())
self.s2 = StructureAgent("Y", set())
self.s3 = StructureAgent("Z", set())
self.c1 = Complex([self.s1], "rep")
self.c2 = Complex([self.s2], "rep")
self.c3 = Complex([self.s3], "rep")
# rules
sequence_1 = (self.s1,)
mid_1 = 1
compartments_1 = ["rep"]
complexes_1 = [(0, 0)]
pairs_1 = [(0, None)]
rate_1 = Rate("k1*[X()::rep]")
self.r1 = Rule(sequence_1, mid_1, compartments_1, complexes_1, pairs_1, rate_1)
sequence_2 = (self.s3, self.s1)
mid_2 = 1
compartments_2 = ["rep"] * 2
complexes_2 = [(0, 0), (1, 1)]
pairs_2 = [(0, 1)]
self.r2 = Rule(sequence_2, mid_2, compartments_2, complexes_2, pairs_2, None)
sequence_3 = (self.s2,)
mid_3 = 0
compartments_3 = ["rep"]
complexes_3 = [(0, 0)]
pairs_3 = [(None, 0)]
rate_3 = Rate("1.0/(1.0+([X()::rep])**4.0)")
self.r3 = Rule(sequence_3, mid_3, compartments_3, complexes_3, pairs_3, rate_3)
# inits
self.inits = collections.Counter({self.c1: 2, self.c2: 1})
# defs
self.defs = {'k1': 0.05, 'k2': 0.12}
self.model = Model({self.r1, self.r2, self.r3}, self.inits, self.defs, set())
# model
self.model_str_1 = """
#! rules
X()::rep => @ k1*[X()::rep]
Z()::rep => X()::rep
=> Y()::rep @ 1/(1+([X()::rep])**4)
#! inits
2 X()::rep
Y()::rep
#! definitions
k1 = 0.05
k2 = 0.12
"""
self.model_parser = Parser("model")
self.model_str_2 = """
#! rules
X(K{i})::rep => X(K{p})::rep @ k1*[X()::rep]
X(T{a})::rep => X(T{o})::rep @ k2*[Z()::rep]
=> Y(P{f})::rep @ 1/(1+([X()::rep])**4)
#! inits
2 X(K{c}, T{e}).X(K{c}, T{j})::rep
Y(P{g}, N{l})::rep
#! definitions
k1 = 0.05
k2 = 0.12
"""
# vectors
ordering = (self.c1, self.c2, self.c3)
self.rate_parser = Parser("rate")
rate_expr = "1/(1+([X()::rep])**4)"
rate_1 = Rate(self.rate_parser.parse(rate_expr).data)
rate_1.vectorize(ordering, dict())
rate_expr = "k1*[X()::rep]"
rate_2 = Rate(self.rate_parser.parse(rate_expr).data)
rate_2.vectorize(ordering, {"k1": 0.05})
init = State(np.array([2, 1, 0]))
vector_reactions = {VectorReaction(State(np.array([0, 0, 0])), State(np.array([0, 1, 0])), rate_1),
VectorReaction(State(np.array([1, 0, 0])), State(np.array([0, 0, 0])), rate_2),
VectorReaction(State(np.array([0, 0, 1])), State(np.array([1, 0, 0])), None)}
self.vm_1 = VectorModel(vector_reactions, init, ordering, None)
# wrong models
self.model_wrong_1 = \
"""#! rules
X(K{i})::rep => X(K{p})::rep @ k1*[X()::rep]
X(T{a})::rep => X(T{o}):;rep @ k2*[Z()::rep]
=> Y(P{f})::rep @ 1/(1+([X()::rep])**4)
#! inits
2 X(K{c}, T{e}).X(K{c}, T{j})::rep
Y(P{g}, N{l})::rep
#! definitions
k1 = 0.05
k2 = 0.12
"""
self.model_wrong_2 = \
"""#! rules
X(K{i})::rep => X(K{p})::rep @ k1*[X()::rep]
X(T{a})::rep = X(T{o})::rep @ k2*[Z()::rep]
=> Y(P{f})::rep @ 1/(1+([X()::rep])**4)
#! inits
2 X(K{c}, T{e}).X(K{c}, T{j})::rep
Y(P{g}, N{l})::rep
#! definitions
k1 = 0.05
k2 = 0.12
"""
self.model_with_comments = """
#! rules
// commenting
X(K{i})::rep => X(K{p})::rep @ k1*[X()::rep] // also here
X(T{a})::rep => X(T{o})::rep @ k2*[Z()::rep]
=> Y(P{f})::rep @ 1/(1+([X()::rep])**4) // ** means power (^)
#! inits
// here
2 X(K{c}, T{e}).X(K{c}, T{j})::rep
Y(P{g}, N{l})::rep // comment just 1 item
#! definitions
// and
k1 = 0.05 // also
k2 = 0.12
"""
self.model_with_complexes = """
#! rules
// commenting
X(T{a}):XX::rep => X(T{o}):XX::rep @ k2*[X().X()::rep]
K{i}:X():XYZ::rep => K{p}:X():XYZ::rep @ k1*[X().Y().Z()::rep] // also here
=> P{f}:XP::rep @ 1/(1+([X().P{_}::rep])**4) // ** means power (^)
#! inits
// here
2 X(K{c}, T{e}).X(K{c}, T{j})::rep
Y(P{g}, N{l})::rep // comment just 1 item
#! definitions
// and
k1 = 0.05 // also
k2 = 0.12
#! complexes
XYZ = X().Y().Z() // a big complex
XX = X().X()
XP = X().P{_}
"""
self.model_without_complexes = """
#! rules
// commenting
X(T{a}).X()::rep => X(T{o}).X()::rep @ k2*[X().X()::rep]
X(K{i}).Y().Z()::rep => X(K{p}).Y().Z()::rep @ k1*[X().Y().Z()::rep] // also here
=> X().P{f}::rep @ 1/(1+([X().P{_}::rep])**4) // ** means power (^)
#! inits
// here
2 X(K{c}, T{e}).X(K{c}, T{j})::rep
Y(P{g}, N{l})::rep // comment just 1 item
#! definitions
// and
k1 = 0.05 // also
k2 = 0.12
"""
self.model_with_variable = """
#! rules
// commenting
T{a}:X():?::rep => T{o}:X():?::rep @ k2*[X().X()::rep] ; ? = { XX, XY }
K{i}:X():XY::rep => K{p}:X():XY::rep @ k1*[X().Y().Z().X()::rep] // also here
#! inits
// here
2 X(K{c}, T{e}).X(K{c}, T{j})::rep
#! definitions
// and
k1 = 0.05 // also
k2 = 0.12
#! complexes
XX = X().X()
XY = X().Y()
"""
self.model_without_variable = """
#! rules
// commenting
X(K{i}).Y()::rep => X(K{p}).Y()::rep @ k1*[X().Y().Z().X()::rep]
X(T{a}).X()::rep => X(T{o}).X()::rep @ k2*[X().X()::rep]
X(T{a}).Y()::rep => X(T{o}).Y()::rep @ k2*[X().X()::rep]
#! inits
// here
2 X(K{c}, T{e}).X(K{c}, T{j})::rep
#! definitions
// and
k1 = 0.05 // also
k2 = 0.12
"""
self.model_with_redundant = """
#! rules
K(S{u}).B()::cyt => K(S{p})::cyt + B()::cyt + D(A{_})::cell @ 3*[K().B()::cyt]/2*v_1
K().B()::cyt => K()::cyt + B()::cyt + D(A{_})::cell @ 3*[K().B()::cyt]/2*v_1
K().K()::cyt => K()::cyt + K()::cyt
K(S{i}).K()::cyt => K(S{a})::cyt + K()::cyt
K(S{i}, T{p}).K()::cyt => K(S{a}, T{p})::cyt + K()::cyt
#! inits
2 X(K{c}, T{e}).X(K{c}, T{j})::rep
#! definitions
v_1 = 0.05
k2 = 0.12
"""
self.model_without_redundant = """
#! rules
K().B()::cyt => K()::cyt + B()::cyt + D(A{_})::cell @ 3*[K().B()::cyt]/2*v_1
K().K()::cyt => K()::cyt + K()::cyt
#! inits
2 X(K{c}, T{e}).X(K{c}, T{j})::rep
#! definitions
v_1 = 0.05
k2 = 0.12
"""
self.model_with_context = """
#! rules
K(S{i}).B(T{a})::cyt => K(S{i})::cyt + B(T{a})::cyt @ 3*[K(S{i}).B(T{a})::cyt]/2*v_1
A{p}.K(S{i},T{i})::cyt => A{i}::cyt + K(S{a},T{a})::cyt
K(S{i},T{i})::cyt => K(S{a},T{i})::cyt
#! inits
2 K(S{i}).B(T{a})::cyt
1 A{p}.K(S{i},T{i})::cyt
#! definitions
v_1 = 0.05
k2 = 0.12
"""
self.model_without_context = """
#! rules
K().B()::cyt => K()::cyt + B()::cyt @ 3*[K().B()::cyt]/2*v_1
A{_}.K()::cyt => A{_}::cyt + K()::cyt
#! inits
2 K().B()::cyt
1 A{_}.K()::cyt
#! definitions
v_1 = 0.05
k2 = 0.12
"""
self.model_reachable = """
#! rules
K(S{i}).B()::cyt => K(S{a})::cyt + B()::cyt @ 3*[K(S{i}).B()::cyt]/2*v_1
K(S{a})::cyt + A{i}::cyt => K(S{a}).A{i}::cyt
K().A{i}::cyt => K().A{a}::cyt
#! inits
2 K(S{i}).B()::cyt
1 A{i}::cyt
#! definitions
v_1 = 0.05
k2 = 0.12
"""
self.model_nonreachable = """
#! rules
K(S{i}).B()::cyt => K(S{a})::cyt + B()::cyt @ 3*[K(S{i}).B()::cyt]/2*v_1
K(S{a})::cyt + A{i}::cyt => K(S{a}).A{i}::cyt
#! inits
2 K(S{i}).B()::cyt
1 A{i}::cyt
#! definitions
v_1 = 0.05
k2 = 0.12
"""
self.model_parametrised = """
#! rules
// commenting
X(K{i})::rep => X(K{p})::rep @ k1*[X()::rep] // also here
X(T{a})::rep => X(T{o})::rep @ k2*[Z()::rep]
=> Y(P{f})::rep @ 1/(v_3+([X()::rep])**4) // ** means power (^)
#! inits
2 X(K{c}, T{e}).X(K{c}, T{j})::rep
Y(P{g}, N{l})::rep // comment just 1 item
#! definitions
k1 = 0.05
"""
self.miyoshi = """
def setUp(self):
self.str1 = StructureAgent("X", set())
self.str2 = StructureAgent("Y", set())
self.str3 = StructureAgent("Z", set())
self.str4 = StructureAgent("W", set())
self.c1 = Complex([self.str1], "rep")
self.c2 = Complex([self.str2], "rep")
self.c3 = Complex([self.str3], "rep")
self.c4 = Complex([self.str4], "rep")
ordering = (self.c1, self.c2, self.c3)
ordering_wrong = (self.c1, self.c2, self.c3, self.c4),
ordering_reordered = (self.c3, self.c1, self.c2)
self.s1 = State(np.array((1, 2, 3)))
self.s2 = State(np.array((1, 2, 4)))
self.s3 = State(np.array((1, 2, 5)))
self.s4 = State(np.array((4, 2, 3)))
self.hell = State(np.array((np.inf, np.inf, np.inf)))
self.hell.is_inf = True
self.s1_reordered = State(np.array((3, 1, 2)))
self.s2_reordered = State(np.array((4, 1, 2)))
self.s3_reordered = State(np.array((5, 1, 2)))
self.ts = TransitionSystem(tuple())
self.ts.states_encoding = {self.s1: 1, self.s2: 2}
self.edge_1 = Edge(0, 1, 0.5)
# equality of TS
self.ts_eq_1 = TransitionSystem(ordering)
self.ts_eq_1.states_encoding = {self.s1: 0, self.s2: 1, self.s3: 2}
self.ts_eq_1.edges = {Edge(0, 1, 0.3), Edge(0, 2, 0.7), Edge(1, 2, 1)}
self.ts_eq_2 = TransitionSystem(ordering)
self.ts_eq_2.states_encoding = {self.s1: 1, self.s2: 2, self.s3: 0}
self.ts_eq_2.edges = {Edge(1, 2, 0.3), Edge(1, 0, 0.7), Edge(2, 0, 1)}
self.ts_eq_3 = TransitionSystem(ordering_reordered)
self.ts_eq_3.states_encoding = {self.s1_reordered: 1, self.s2_reordered: 2, self.s3_reordered: 0}
self.ts_eq_3.edges = {Edge(1, 2, 0.3), Edge(1, 0, 0.7), Edge(2, 0, 1)}
# inequality of TS
self.ts_neq_1 = TransitionSystem(ordering)
self.ts_neq_1.states_encoding = {self.s1: 0, self.s2: 1, self.s3: 2}
self.ts_neq_1.edges = {Edge(0, 1, 0.3), Edge(0, 2, 0.7), Edge(1, 2, 1)}
self.ts_neq_2 = TransitionSystem(ordering)
self.ts_neq_2.states_encoding = {self.s1: 1, self.s2: 2, self.s3: 0}
self.ts_neq_2.edges = {Edge(1, 2, 0.3), Edge(1, 0, 0.7), Edge(0, 2, 1)}
self.ts_neq_3 = TransitionSystem(ordering_wrong)
self.ts_neq_3.states_encoding = {self.s1: 1, self.s2: 2, self.s3: 0}
self.ts_neq_3.edges = {Edge(1, 2, 0.3), Edge(1, 0, 0.7), Edge(0, 2, 1)}
# test bigger TS
ordering = (self.c1, self.c2, self.c3, self.c4)
self.ts_bigger = TransitionSystem(ordering)
self.ts_bigger.states_encoding = {self.s1: 1, self.s2: 2, self.s3: 0, self.s4: 3}
self.ts_bigger.edges = {Edge(1, 2, 0.8), Edge(0, 1, 0.5), Edge(1, 0, 0.3),
Edge(3, 1, 0.9), Edge(3, 2, 0.1), Edge(1, 3, 0.2)}
def to_side(self):
return Side([
Complex(self.seq[c[0]:c[1] + 1], self.comp[c[0]])
for c in self.complexes
])
def rate_complex(self, matches):
sequence = []
for item in matches[0].children:
sequence.append(item.children[0])
compartment = matches[2]
return Tree("agent", [Complex(sequence, compartment)])
def setUp(self):
self.a1 = AtomicAgent("T", "s")
self.a2 = AtomicAgent("S", "i")
self.a3 = AtomicAgent("U", "a")
self.a4 = AtomicAgent("T", "_")
self.a5 = AtomicAgent("U", "_")
self.a6 = AtomicAgent("S", "_")
self.s1 = StructureAgent("X", {self.a1})
self.s2 = StructureAgent("A", {self.a2, self.a3})
self.s3 = StructureAgent("X", {self.a4})
self.s4 = StructureAgent("A", {self.a2, self.a5})
self.s5 = StructureAgent("A", {self.a6, self.a3})
self.s6 = StructureAgent("A", set())
self.c1 = Complex([self.s1, self.s2, self.s2], "cyt")
self.c2 = Complex([self.s3, self.s4, self.s5], "cyt")
self.c3 = Complex([self.s2, self.s2, self.s1], "cyt")
self.c4 = Complex([self.s2, self.s2, self.s1], "cell")
self.c5 = Complex([self.s2, self.s4, self.a1], "cell")
self.c6 = Complex([self.s6, self.s6, self.a4], "cell")
self.large_c1 = Complex([self.s4] * 6 + [self.s3] * 5, "cell")
self.large_c2 = Complex([self.s5] * 7 + [self.s3] * 6, "cell")
class TestComplex(unittest.TestCase):
def setUp(self):
self.a1 = AtomicAgent("T", "s")
self.a2 = AtomicAgent("S", "i")
self.a3 = AtomicAgent("U", "a")
self.a4 = AtomicAgent("T", "_")
self.a5 = AtomicAgent("U", "_")
self.a6 = AtomicAgent("S", "_")
self.s1 = StructureAgent("X", {self.a1})
self.s2 = StructureAgent("A", {self.a2, self.a3})
self.s3 = StructureAgent("X", {self.a4})
self.s4 = StructureAgent("A", {self.a2, self.a5})
self.s5 = StructureAgent("A", {self.a6, self.a3})
self.s6 = StructureAgent("A", set())
self.c1 = Complex([self.s1, self.s2, self.s2], "cyt")
self.c2 = Complex([self.s3, self.s4, self.s5], "cyt")
self.c3 = Complex([self.s2, self.s2, self.s1], "cyt")
self.c4 = Complex([self.s2, self.s2, self.s1], "cell")
self.c5 = Complex([self.s2, self.s4, self.a1], "cell")
self.c6 = Complex([self.s6, self.s6, self.a4], "cell")
self.large_c1 = Complex([self.s4] * 6 + [self.s3] * 5, "cell")
self.large_c2 = Complex([self.s5] * 7 + [self.s3] * 6, "cell")
def test_eq(self):
self.assertEqual(self.c1, self.c3)
self.assertNotEqual(self.c1, self.c4)
def test_print(self):
self.assertEqual(str(self.c1), "X(T{s}).A(S{i},U{a}).A(S{i},U{a})::cyt")
self.assertEqual(str(self.c2), "X(T{_}).A(S{i},U{_}).A(S{_},U{a})::cyt")
def test_compatibility(self):
self.assertTrue(self.c2.compatible(self.c1))
self.assertFalse(self.c1.compatible(self.c2))
self.assertFalse(self.c2.compatible(self.c4))
self.assertFalse(self.large_c1.compatible(self.large_c2))
def test_to_PRISM_code(self):
self.assertEqual(self.c1.to_PRISM_code(5), "VAR_5")
def test_reduce_context(self):
self.assertEqual(self.c5.reduce_context(), self.c6)
def test_create_all_compatible(self):
atomic_signature = {"S": {"a", "i"}, "T": {"u", "p"}}
structure_signature = {"KaiC": {"S"}}
complex_parser = Parsing.ParseBCSL.Parser("rate_complex")
complex1 = complex_parser.parse("KaiC(S{a}).T{u}::cyt").data.children[0]
complex2 = complex_parser.parse("KaiC(S{a}).T{p}::cyt").data.children[0]
complex3 = complex_parser.parse("KaiC(S{i}).T{u}::cyt").data.children[0]
complex4 = complex_parser.parse("KaiC(S{i}).T{p}::cyt").data.children[0]
results_1 = {complex1, complex2, complex3, complex4}
results_2 = {complex1, complex2}
complex = complex_parser.parse("KaiC().T{_}::cyt").data.children[0]
output_comples = complex.create_all_compatible(atomic_signature, structure_signature)
self.assertEqual(output_comples, results_1)
complex = complex_parser.parse("KaiC(S{a}).T{_}::cyt").data.children[0]
output_comples = complex.create_all_compatible(atomic_signature, structure_signature)
self.assertEqual(output_comples, results_2)
atomic_signature = {"S": {"a", "i"}, "T": {"u", "p"}}
structure_signature = {"KaiC": {"S", "T"}}
results = set()
with open("Testing/complexes_1.txt") as file:
for complex in file.readlines():
results.add(complex_parser.parse(complex).data.children[0])
complex = complex_parser.parse("KaiC().KaiC().KaiC().KaiC().KaiC().KaiC()::cyt").data.children[0]
output_comples = complex.create_all_compatible(atomic_signature, structure_signature)
self.assertEqual(output_comples, results)
atomic_signature = {"A": {"+", "-"}, "B": {"HA", "HE"}}
structure_signature = {"KaiB": {"A", "B"}}
results = set()
with open("Testing/complexes_2.txt") as file:
for complex in file.readlines():
results.add(complex_parser.parse(complex).data.children[0])
complex = complex_parser.parse("KaiB().KaiB().KaiB()::cyt").data.children[0]
output_comples = complex.create_all_compatible(atomic_signature, structure_signature)
self.assertEqual(output_comples, results)
def setUp(self):
self.model_parser = Parser("model")
"""
Model 1 - Transition system of die model
Analysis of a PRISM example model from the Knuth-Yao
source: storm website
"""
self.str1 = StructureAgent("S", set())
self.str2 = StructureAgent("D", set())
self.c1 = Complex([self.str1], "rep")
self.c2 = Complex([self.str2], "rep")
ordering = (self.c1, self.c2)
self.s1 = State(np.array((0, 0)))
self.s2 = State(np.array((1, 0)))
self.s3 = State(np.array((2, 0)))
self.s4 = State(np.array((3, 0)))
self.s5 = State(np.array((4, 0)))
self.s6 = State(np.array((5, 0)))
self.s7 = State(np.array((6, 0)))
self.s8 = State(np.array((7, 1)))
self.s9 = State(np.array((7, 2)))
self.s10 = State(np.array((7, 3)))
self.s11 = State(np.array((7, 4)))
self.s12 = State(np.array((7, 5)))
self.s13 = State(np.array((7, 6)))
self.die_ts = TransitionSystem(ordering)
self.die_ts.init = 0
self.die_ts.states_encoding = {self.s1: 0, self.s2: 1, self.s3: 2, self.s4: 3, self.s5: 4,
self.s6: 5, self.s7: 6, self.s8: 7, self.s9: 8, self.s10: 9,
self.s11: 10, self.s12: 11, self.s13: 12}
self.die_ts.edges = {Edge(0, 1, 0.5), Edge(0, 2, 0.5), Edge(1, 3, 0.5), Edge(1, 4, 0.5), Edge(2, 5, 0.5),
Edge(2, 6, 0.5), Edge(3, 1, 0.5), Edge(3, 7, 0.5), Edge(4, 8, 0.5), Edge(4, 9, 0.5),
Edge(5, 10, 0.5), Edge(5, 11, 0.5), Edge(6, 2, 0.5), Edge(6, 12, 0.5), Edge(7, 7, 1),
Edge(8, 8, 1), Edge(9, 9, 1), Edge(10, 10, 1), Edge(11, 11, 1), Edge(12, 12, 1)}
# die parametric TS
self.die_ts_parametric = TransitionSystem(ordering)
self.die_ts_parametric.init = 0
self.die_ts_parametric.states_encoding = {self.s1: 0, self.s2: 1, self.s3: 2, self.s4: 3, self.s5: 4,
self.s6: 5, self.s7: 6, self.s8: 7, self.s9: 8, self.s10: 9,
self.s11: 10, self.s12: 11, self.s13: 12}
self.die_ts_parametric.edges = {Edge(0, 1, "p"), Edge(0, 2, "(1-p)"), Edge(1, 3, "p"), Edge(1, 4, "(1-p)"),
Edge(2, 5, "p"),
Edge(2, 6, "(1-p)"), Edge(3, 1, "p"), Edge(3, 7, "(1-p)"), Edge(4, 8, "p"),
Edge(4, 9, "(1-p)"),
Edge(5, 10, "p"), Edge(5, 11, "(1-p)"), Edge(6, 2, "p"), Edge(6, 12, "(1-p)"),
Edge(7, 7, 1),
Edge(8, 8, 1), Edge(9, 9, 1), Edge(10, 10, 1), Edge(11, 11, 1), Edge(12, 12, 1)}
self.labels = {0: {'init'}, 7: {'one', 'done'},
9: {'done'}, 8: {'done'}, 10: {'done'}, 11: {'done'}, 12: {'done'}}
# PCTL formulas for model checking
self.die_pctl_prism = "P=? [F VAR_0=7&VAR_1=1]" # 0.1666666667
self.die_pctl_explicit = "P=? [F \"one\"]" # 0.1666666667
self.die_pctl_parametric = "P=? [F VAR_0=7&VAR_1=1]"
self.die_pctl1 = "P=? [F VAR_0=7&VAR_1=1 || F VAR_0=7&VAR_1<4]" # 0.3333333333 not used
self.die_pctl2 = "P<=0.15 [F VAR_0=7&VAR_1=1]" # false not used
self.result = 0.166666667
def setUp(self):
self.a1 = AtomicAgent("S", "u")
self.a2 = AtomicAgent("S", "p")
self.a3 = AtomicAgent("B", "_")
self.a4 = AtomicAgent("B", "-")
self.a5 = AtomicAgent("B", "+")
self.s1 = StructureAgent("K", {self.a1})
self.s2 = StructureAgent("B", set())
self.s3 = StructureAgent("K", {self.a2})
self.s4 = StructureAgent("B", set())
self.s5 = StructureAgent("D", {self.a3})
self.s6 = StructureAgent("K", {self.a4})
self.s7 = StructureAgent("K", {self.a5})
self.c1 = Complex([self.s1, self.s2], "cyt")
self.c2 = Complex([self.s3], "cyt")
self.c3 = Complex([self.s2], "cyt")
self.c4 = Complex([self.s5], "cell")
# rules
sequence_1 = (self.s1, self.s2, self.s3, self.s4)
mid_1 = 2
compartments_1 = ["cyt"] * 4
complexes_1 = [(0, 1), (2, 2), (3, 3)]
pairs_1 = [(0, 2), (1, 3)]
rate_1 = Rate("3.0*[K()::cyt]/2.0*v_1")
self.r1 = Rule(sequence_1, mid_1, compartments_1, complexes_1, pairs_1,
rate_1)
sequence_2 = (self.s1, self.s2, self.s3, self.s4, self.s5)
mid_2 = 2
compartments_2 = ["cyt"] * 4 + ["cell"]
complexes_2 = [(0, 1), (2, 2), (3, 3), (4, 4)]
pairs_2 = [(0, 2), (1, 3), (None, 4)]
rate_2 = Rate("3.0*[K()::cyt]/2.0*v_1")
self.r2 = Rule(sequence_2, mid_2, compartments_2, complexes_2, pairs_2,
rate_2)
sequence_3 = (self.s6, self.s2, self.s5, self.s7, self.s4)
mid_3 = 3
compartments_3 = ["cyt"] * 2 + ["cell"] + ["cyt"] * 2
complexes_3 = [(0, 1), (2, 2), (3, 3), (4, 4)]
pairs_3 = [(0, 3), (1, 4), (2, None)]
rate_3 = Rate("3.0*[K(T{3+})::cyt]/2.0*v_1")
self.r3 = Rule(sequence_3, mid_3, compartments_3, complexes_3, pairs_3,
rate_3)
# special cases
self.s1_s = StructureAgent("X", set())
self.s2_s = StructureAgent("Y", set())
self.s3_s = StructureAgent("Z", set())
sequence_4 = (self.s1_s, )
mid_4 = 1
compartments_4 = ["rep"]
complexes_4 = [(0, 0)]
pairs_4 = [(0, None)]
rate_4 = Rate("k1*[X()::rep]")
self.r4 = Rule(sequence_4, mid_4, compartments_4, complexes_4, pairs_4,
rate_4)
sequence_5 = (self.s2_s, )
mid_5 = 0
compartments_5 = ["rep"]
complexes_5 = [(0, 0)]
pairs_5 = [(None, 0)]
rate_5 = Rate("1.0/(1.0+([X()::rep])**4.0)")
self.r5 = Rule(sequence_5, mid_5, compartments_5, complexes_5, pairs_5,
rate_5)
# reactions
lhs = Side([self.c1])
rhs = Side([self.c2, self.c3, self.c4])
self.reaction1 = Reaction(lhs, rhs, rate_2)
# create
self.t_i = AtomicAgent("T", "i")
self.t_a = AtomicAgent("T", "a")
self.a4_p = AtomicAgent("C", "p")
self.a4_u = AtomicAgent("C", "u")
self.u2_c1_p = AtomicAgent("U", "p")
self.u2_c1_u = AtomicAgent("U", "u")
self.s6 = StructureAgent("D", set())
self.s6_c1_p = StructureAgent("D", {self.a4_p})
self.s6_c1_u = StructureAgent("D", {self.a4_u})
self.s2_c1_p = StructureAgent("B", {self.u2_c1_p})
self.s2_c1_u = StructureAgent("B", {self.u2_c1_u})
self.s1_c1_a = StructureAgent("K", {self.a1, self.t_a})
self.s1_c1_i = StructureAgent("K", {self.a1, self.t_i})
self.s3_c1_a = StructureAgent("K", {self.a2, self.t_a})
self.s3_c1_i = StructureAgent("K", {self.a2, self.t_i})
sequence_c1 = (self.s1, self.s2, self.s3, self.s4, self.s6)
mid_c1 = 2
compartments_c1 = ["cyt"] * 5
complexes_c1 = [(0, 0), (1, 1), (2, 3), (4, 4)]
pairs_c1 = [(0, 2), (1, 3), (None, 4)]
rate_c1 = Rate("3*[K()::cyt]/2*v_1")
self.c1_c1 = Complex([self.s2_c1_u], "cyt") # B(U{u})::cyt
self.c1_c2 = Complex([self.s2_c1_p], "cyt") # B(U{p})::cyt
self.c1_c3 = Complex([self.s1_c1_a], "cyt") # K(S{u},T{a})::cyt
self.c1_c4 = Complex([self.s1_c1_i], "cyt") # K(S{u},T{i})::cyt
self.c1_c5 = Complex([self.s3_c1_a, self.s2_c1_u],
"cyt") # K(S{p},T{a}).B(U{u})::c
self.c1_c6 = Complex([self.s3_c1_i, self.s2_c1_u],
"cyt") # K(S{p},T{i}).B(U{u})::c
self.c1_c7 = Complex([self.s3_c1_i, self.s2_c1_p],
"cyt") # K(S{p},T{i}).B(U{p})::c
self.c1_c8 = Complex([self.s3_c1_a, self.s2_c1_p],
"cyt") # K(S{p},T{a}).B(U{p})::c
self.c1_c9 = Complex([self.s6_c1_p], "cyt") # D(C{p})::cyt
self.c1_c10 = Complex([self.s6_c1_u], "cyt") # D(C{u})::cyt
self.rule_c1 = Rule(sequence_c1, mid_c1, compartments_c1, complexes_c1,
pairs_c1, rate_c1)
self.reaction_c1_1 = Reaction(Side([self.c1_c1, self.c1_c3]),
Side([self.c1_c5, self.c1_c9]), rate_c1)
self.reaction_c1_2 = Reaction(Side([self.c1_c1, self.c1_c3]),
Side([self.c1_c5, self.c1_c10]), rate_c1)
self.reaction_c1_3 = Reaction(Side([self.c1_c2, self.c1_c4]),
Side([self.c1_c7, self.c1_c10]), rate_c1)
self.reaction_c1_4 = Reaction(Side([self.c1_c1, self.c1_c4]),
Side([self.c1_c6, self.c1_c9]), rate_c1)
self.reaction_c1_5 = Reaction(Side([self.c1_c2, self.c1_c3]),
Side([self.c1_c8, self.c1_c9]), rate_c1)
self.reaction_c1_6 = Reaction(Side([self.c1_c2, self.c1_c3]),
Side([self.c1_c8, self.c1_c10]), rate_c1)
self.reaction_c1_7 = Reaction(Side([self.c1_c1, self.c1_c4]),
Side([self.c1_c6, self.c1_c10]), rate_c1)
self.reaction_c1_8 = Reaction(Side([self.c1_c2, self.c1_c4]),
Side([self.c1_c7, self.c1_c9]), rate_c1)
self.reactions_c1 = {
self.reaction_c1_1, self.reaction_c1_2, self.reaction_c1_3,
self.reaction_c1_4, self.reaction_c1_5, self.reaction_c1_6,
self.reaction_c1_7, self.reaction_c1_8
}
# context no change
sequence_no_change = (self.s1_c1_a, self.s2_c1_u, self.s3_c1_a,
self.s2_c1_u, self.s6_c1_p)
self.rule_no_change = Rule(sequence_no_change, mid_c1, compartments_c1,
complexes_c1, pairs_c1, rate_c1)
# parsing
self.parser = Parser("rule")
self.rule_no_rate = Rule(sequence_1, mid_1, compartments_1,
complexes_1, pairs_1, None)