def test_action_to_steps():
aut = symbolic.Automaton()
aut.declare_variables(x='bool', y=(0, 17))
aut.varlist['env'] = ['x']
aut.varlist['sys'] = ['y']
keys = ('x', 'y')
aut.init['env'] = aut.add_expr('x /\ (y = 1)')
aut.action['sys'] = aut.add_expr("y' /= y")
aut.action['env'] = aut.true
aut.qinit = '\A \A'
aut.moore = True
aut.build()
g = enum.action_to_steps(aut, qinit=aut.qinit)
# 36 states reachable, but should enumerate fewer
assert len(g) == 4, g.nodes()
# these are state projections (partial assignments)
# a state assigns to all variable names
# (infinitely many)
states = {
enum._node_tuple(d, keys)
for u, d in g.nodes(data=True)}
assert tuple([True, 1]) in states, states
r = {p for p in states if p[0] is True}
assert len(r) == 2
r = {p for p in states if p[0] is False}
assert len(r) == 2
def synthesize_enumerated_streett(spec, use_cudd=False):
"""Return transducer enumerated as a graph.
@type spec: `tulip.spec.form.GRSpec`
@param use_cudd: efficient BDD computations with `dd.cudd`
@rtype: `networkx.DiGraph`
"""
aut = _grspec_to_automaton(spec)
sym.fill_blanks(aut)
bdd = _init_bdd(use_cudd)
aut.bdd = bdd
a = aut.build()
assert a.action['sys'][0] != bdd.false
t0 = time.time()
z, yij, xijk = gr1.solve_streett_game(a)
t1 = time.time()
# unrealizable ?
if not gr1.is_realizable(z, a):
print('WARNING: unrealizable')
return None
t = gr1.make_streett_transducer(z, yij, xijk, a)
t2 = time.time()
(u, ) = t.action['sys']
assert u != bdd.false
g = enum.action_to_steps(t, qinit=spec.qinit)
h = _strategy_to_state_annotated(g, a)
del u, yij, xijk
t3 = time.time()
log.info(('Winning set computed in {win} sec.\n'
'Symbolic strategy computed in {sym} sec.\n'
'Strategy enumerated in {enu} sec.').format(win=t1 - t0,
sym=t2 - t1,
enu=t3 - t2))
return h
def synthesize_enumerated_streett(spec):
"""Return transducer enumerated as a graph.
@type spec: `tulip.spec.form.GRSpec`
@rtype: `networkx.DiGraph`
"""
aut = _grspec_to_automaton(spec)
assert aut.action['sys'] != aut.false
t0 = time.time()
z, yij, xijk = gr1.solve_streett_game(aut)
t1 = time.time()
# unrealizable ?
if not gr1.is_realizable(z, aut):
print('WARNING: unrealizable')
return None
gr1.make_streett_transducer(z, yij, xijk, aut)
t2 = time.time()
g = enum.action_to_steps(aut, 'env', 'impl', qinit=aut.qinit)
h = _strategy_to_state_annotated(g, aut)
del z, yij, xijk
t3 = time.time()
log.info(('Winning set computed in {win} sec.\n'
'Symbolic strategy computed in {sym} sec.\n'
'Strategy enumerated in {enu} sec.').format(win=t1 - t0,
sym=t2 - t1,
enu=t3 - t2))
return h
def test_action_to_steps():
aut = symbolic.Automaton()
aut.declare_variables(x='bool', y=(0, 17))
env = 'env_foo'
sys = 'sys_bar'
aut.varlist[env] = ['x']
aut.varlist[sys] = ['y']
keys = ('x', 'y')
aut.init[env] = aut.add_expr('x /\ (y = 1)')
aut.init[sys] = aut.true
aut.action[env] = aut.true
aut.action[sys] = aut.add_expr("y' /= y")
aut.win['<>[]'] = aut.bdds_from('x')
aut.win['[]<>'] = aut.bdds_from('y != 1')
aut.qinit = '\A \A'
aut.moore = True
aut.prime_varlists()
g = enum.action_to_steps(aut, env=env, sys=sys, qinit=aut.qinit)
# 36 states reachable, but should enumerate fewer
assert len(g) == 4, g.nodes()
# these are state projections (partial assignments)
# a state assigns to all variable names
# (infinitely many)
states = {enum._node_tuple(d, keys) for u, d in g.nodes(data=True)}
assert tuple([True, 1]) in states, states
r = {p for p in states if p[0] is True}
assert len(r) == 2
r = {p for p in states if p[0] is False}
assert len(r) == 2
def enumerate_impl(spec):
"""Return enumerated controller."""
# modifies env, sys (which serve as a reusable interface)
spec.init['sys'] = spec.init['impl']
spec.action['sys'] = spec.action['impl']
graph = enum.action_to_steps(spec, qinit=spec.qinit)
graph.inputs = spec.varlist['env']
graph.outputs = spec.varlist['sys']
# pprint.pprint(graph.nodes(data=True))
return graph
def synthesize_some_controller(aut):
"""Return a controller that implements the spec.
If no controller exists, then raise an `Exception`.
The returned controller is represented as a `networkx` graph.
"""
z, yij, xijk = gr1.solve_streett_game(aut)
gr1.make_streett_transducer(z, yij, xijk, aut)
g = enum.action_to_steps(
aut, env='env', sys='impl', qinit=aut.qinit)
return g
def synthesize_rabin_controller(b):
"""Return enumerated graph with steps as edges.
after solving Rabin(1) game.
@param b: game with <>[] & []<> winning
@type b: `symbolic.Automaton`
"""
qinit = b.qinit
aut_rabin = b.build()
zk, yki, xkijr = gr1.solve_rabin_game(aut_rabin)
t= gr1.make_rabin_transducer(zk, yki, xkijr, aut_rabin)
g = enum.action_to_steps(t, qinit=qinit)
return g
def synthesize_some_controller(aut):
"""Return a controller that implements the spec.
If no controller exists, then raise an `Exception`.
The returned controller is represented as a `networkx` graph.
"""
z, yij, xijk = gr1.solve_streett_game(aut)
gr1.make_streett_transducer(z, yij, xijk, aut)
aut.init['env'] = aut.init['impl_env']
aut.init['sys'] = aut.init['impl_sys']
aut.action['sys'] = aut.action['impl']
g = enum.action_to_steps(aut, qinit=aut.qinit)
return g
'''
aut.define(specs)
aut.init.update(env='envInit', sys='sysInit')
aut.action.update(env='envNext', sys='sysNext')
# aut.win['<>[]'] = aut.bdds_from('(sysX1 = 0 /\ sysY1 = 0)','(sysX1 = 2 /\ sysY1 = 0)', '(sysX1 = 0 /\ sysY1 = 2)')
# aut.win['[]<>'] = aut.bdds_from('(sysX1 = 0 /\ sysY1 = 0)','(sysX1 = 2 /\ sysY1 = 0)', '(sysX1 = 0 /\ sysY1 = 2)')
aut.win['<>[]'] = aut.bdds_from('TRUE')
aut.win['[]<>'] = aut.bdds_from('pos1 = 1', 'pos1 = 2')
aut.qinit = '\E \A'
aut.moore = True
aut.plus_one = True
# g = enum.action_to_steps(aut, 'env', 'sys', qinit=aut.qinit)
# h, _ = sym_enum._format_nx(g)
# pd = nx.drawing.nx_pydot.to_pydot(h)
# pd.write_pdf('outputs/single_gridworld_game_states_omega.pdf')
z, yij, xijk = gr1.solve_streett_game(aut)
gr1.make_streett_transducer(z, yij, xijk, aut)
aut.varlist['sys'].append('_goal')
aut.prime_varlists()
# enumerate
g = enum.action_to_steps(aut, 'env', 'impl', qinit=aut.qinit)
h, _ = sym_enum._format_nx(g)
pd = nx.drawing.nx_pydot.to_pydot(h)
pd.write_pdf('single_gridworld_game_states_omega.pdf')
def enumerate_controller(aut):
aut.init['env'] = aut.init['impl_env']
aut.init['sys'] = aut.init['impl_sys']
aut.action['sys'] = aut.action['impl']
g = enum.action_to_steps(aut, qinit=aut.qinit)
return g
def enumerate_controller(aut):
g = enum.action_to_steps(
aut, env='env', sys='impl', qinit=aut.qinit)
return g
def enumerate_controller(aut):
aut.init['env'] = aut.init['impl_env']
aut.init['sys'] = aut.init['impl_sys']
aut.action['sys'] = aut.action['impl']
g = enum.action_to_steps(aut, qinit=aut.qinit)
return g
print(a.action['sys'])
assert a.action['sys'][0] != bdd.false
t0 = time.time()
z, yij, xijk = gr1.solve_streett_game(a)
t1 = time.time()
print(t1-t0)
# unrealizable ?
if not gr1.is_realizable(z, a):
print('WARNING: unrealizable')
t = gr1.make_streett_transducer(z, yij, xijk, a)
t2 = time.time()
(u,) = t.action['sys']
assert u != bdd.false
g = enum.action_to_steps(t, qinit=spec.qinit)
h = omega_int._strategy_to_state_annotated(g, a)
del u, yij, xijk
t3 = time.time()
print((
'Winning set computed in {win} sec.\n'
'Symbolic strategy computed in {sym} sec.\n'
'Strategy enumerated in {enu} sec.').format(
win=t1 - t0,
sym=t2 - t1,
enu=t3 - t2))
bdd.dump('manager.p')
bdd2 = omega_int._init_bdd(use_cudd)
_bdd.copy_vars(t.bdd,bdd2)
n1=bdd.copy(z,bdd2)
