pg = [
partitionGrid0, partitionGrid1, partitionGrid2, partitionGrid3,
partitionGrid4, partitionGrid5
]
# gwg.save('gridworldfig.png')
visdist = [4, 4, 4, 4, 4, 4]
vel = [2, 2, 2, 2, 2, 2]
print 'Writing input file...'
invisibilityset = []
filename = []
for n in range(gwg.nagents):
iset = dict.fromkeys(set(gwg.states),
frozenset({gwg.nrows * gwg.ncols + 1}))
for s in set(gwg.states):
iset[s] = visibility.invis(gwg, s, visdist[n]).intersection(
set(allowed_states[n]))
iset[s] = iset[s] - set(fullvis_states[n])
if s in gwg.obstacles:
iset[s] = {-1}
pickle_out = open("dict{}.pickle".format(n), "wb")
pickle.dump(iset, pickle_out)
pickle_out.close()
pickle_in = open("dict{}.pickle".format(n), "rb")
iset = pickle.load(pickle_in)
invisibilityset.append(iset)
outfile = 'finalcdc_6sensor{}.json'.format(n)
infile = 'finalcdc_6sensor{}'.format(n)
filename.append(outfile)
print 'output file: ', outfile
print 'input file name:', infile
Salty_input.write_to_slugs_part_dist_impsensors(infile,
def run_counterexample(fname,gwg,numbeliefstates):
xstates = list(set(gwg.states) - set(gwg.edges))
partitionGrid = grid_partition.partitionGrid(gwg,numbeliefstates)
allstates = copy.deepcopy(xstates)
beliefcombs = powerset(partitionGrid.keys())
for i in range(gwg.nstates,gwg.nstates+ len(beliefcombs)):
allstates.append(i)
with open(fname) as f:
content = f.readlines()
# you may also want to remove whitespace characters like `\n` at the end of each line
content = [x.strip() for x in content]
ind = 0
gwg.colorstates = [set(), set()]
truebeliefstates = set()
truebeliefstates_next = set()
while True:
envstatebin = []
agentstatebin = []
beliefstate = set()
line = content[ind].split(' ')
for r in line[6::]:
if r[1] == 'y' or r[0] == 'y':
envstatebin.append(r[-2])
elif r[1] == 'x' or r[0] == 'x':
agentstatebin.append(r[-2])
envstate = int(''.join(str(e) for e in envstatebin)[::-1],2)
if envstate < len(xstates):
print 'Environment position is ', xstates[envstate]
truebeliefstates_next = {xstates[envstate]}
# for a in gwg.actlist:
# for t in np.nonzero(gwg.prob[a][xstates[envstate]])[0]:
# truebeliefstates_next.add(t)
else:
for b in beliefcombs[envstate - len(xstates)]:
beliefstate = beliefstate.union(partitionGrid[b])
truebeliefstates = copy.deepcopy(truebeliefstates_next)
for s in truebeliefstates_next:
for a in gwg.actlist:
for t in np.nonzero(gwg.prob[a][s])[0]:
truebeliefstates.add(t)
truebeliefstates = truebeliefstates - set(gwg.obstacles)
truebeliefstates_next = copy.deepcopy(truebeliefstates)
print 'Environment position is ', beliefstate
if len(agentstatebin) > 0:
agentstate = xstates[int(''.join(str(e) for e in agentstatebin)[::-1], 2)]
else:
print 'Failure state reached'
break
print 'Agent position is ', agentstate
if content[ind+1] == 'With no successors.':
print 'Reached terminal state'
break
if len(beliefstate) > 0:
invisstates = visibility.invis(gwg,agentstate)
visstates = set(gwg.states) - invisstates - set(gwg.walls)
beliefvisstates = visstates.intersection(beliefstate)
beliefinvisstates = beliefstate - beliefvisstates
truebeliefstates_next = truebeliefstates_next.intersection(beliefinvisstates)
truebeliefstates = copy.deepcopy(truebeliefstates_next)
print "Fully refined belief states are", truebeliefstates
print('There are a total of {} invisible belief states'.format(len(beliefinvisstates)))
print 'Invisible states in belief states are ', beliefinvisstates
gwg.colorstates[1] = copy.deepcopy(beliefinvisstates)
gwg.moveobstacles = []
else:
gwg.moveobstacles = [copy.deepcopy(xstates[envstate])]
gwg.colorstates[1] = set()
gwg.render()
gwg.current[0] = copy.deepcopy(agentstate)
gwg.colorstates[0] = set()
gwg.colorstates[0].update(visibility.invis(gwg,agentstate))
gwg.colorstates[0] = gwg.colorstates[0].intersection(visibility.invis(gwg,agentstate))
gwg.render()
gwg.draw_state_labels()
nextposstates = map(int,content[ind+1][18:].split(', '))
print 'Choose from one of the following states:', nextposstates
nextautostate = int(raw_input('Next state in automaton: '))
for w in range(0,len(content),2):
if int(content[w].split(' ')[1]) == nextautostate:
ind = w
break
def write_to_slugs(gw, inittarg):
agentstates = list(set(gw.states) - set(gw.edges))
agenttrans = set()
for s in set(gw.states) - set(gw.walls):
for a in range(gw.nactions):
for t in np.nonzero(gw.prob[gw.actlist[a]][s])[0]:
agenttrans.add((agentstates.index(s), a, agentstates.index(t)))
xstates = list(set(gw.states) - set(gw.edges))
invisibilityset = dict.fromkeys(
set(gw.states) - set(gw.edges), frozenset({gw.nrows * gw.ncols + 1}))
for s in set(gw.states) - set(gw.edges):
invisibilityset[s] = visibility.invis(gw, s) - set(gw.targets)
if s in gw.obstacles:
invisibilityset[s] = -1
invisstates = list(set(invisibilityset.values()))
for s in invisibilityset.values():
if s not in invisstates:
invisstates.append(s)
envtransitions = set()
for s in set(gw.states) - set(gw.edges):
for a in range(gw.nactions):
for t in np.nonzero(gw.prob[gw.actlist[a]][s])[0]:
envtransitions.add(
frozenset({(invisstates.index(invisibilityset[s]),
invisstates.index(invisibilityset[t]))}))
print envtransitions
filename = 'slugs_input.salt'
file = open(filename, 'w')
file.write('controller Visgame where\n\n')
file.write(
'-- Inputs ----------------------------------------------------------\n\n'
)
file.write('input y : Int 0 ... {} = {}\n\n'.format(
len(xstates), invisstates.index(invisibilityset[inittarg])))
file.write(
'-- Outputs ----------------------------------------------------------\n\n'
)
file.write('output x : Int 0 ... {} = {}\n\n'.format(
len(xstates), xstates.index(gw.current)))
# writing env_trans
file.write('env_trans\n')
for x in range(len(xstates)):
s = xstates[x]
str = " y == {} -> ".format(x)
counter = 1
for a in range(gw.nactions):
for t in np.nonzero(gw.prob[gw.actlist[a]][s])[0]:
if counter == 1:
str += ' y\' == {}'.format(xstates.index(t))
counter += 1
else:
str += ' \\/ y\' == {} '.format(xstates.index(t))
counter += 1
if counter > 1:
str += '\n'
file.write(str)
# Writing env_safety
for obs in gw.obstacles:
file.write(' y != {}\n'.format(xstates.index(obs)))
file.write(' y != {}\n'.format(xstates.index(gw.targets[0])))
# writing sys_trans
file.write('\nsys_trans\n')
for x in range(len(xstates)):
s = xstates[x]
str = " x == {} -> ".format(x)
counter = 1
for a in range(gw.nactions):
for t in np.nonzero(gw.prob[gw.actlist[a]][s])[0]:
if counter == 1:
str += ' x\' == {}'.format(xstates.index(t))
counter += 1
else:
str += ' \\/ x\' == {} '.format(xstates.index(t))
counter += 1
if counter > 1:
str += '\n'
file.write(str)
# Writing sys_safety
for obs in gw.obstacles:
file.write(' x != {}\n'.format(xstates.index(obs)))
for s in xstates:
if s not in gw.obstacles:
invisstates = invisibilityset[s]
if len(invisstates) > 1:
str = ' y == {} -> x != {} '.format(xstates.index(s),
xstates.index(s))
for x in invisstates:
str += ' /\\ x != {}'.format(xstates.index(x))
str += '\n'
file.write(str)
# Writing sys_liveness
file.write('\nsys_liveness\n')
file.write(' x == {}\n'.format(xstates.index(gw.targets[0])))
# Writing env_liveness
file.write('\nenv_liveness\n')
# file.write('y = {}\n'.format(xstates.index(gw.current)))
# file.write('y = {}\n'.format(xstates.index(inittarg)))
# file.write('y = {}\n'.format(xstates.index(88)))
file.write(' y == {}\n'.format(xstates.index(22)))
file.close()
def userControlled_partition(filename, gwg, partitionGrid, moveobstacles):
file = open(filename)
data = json.load(file)
file.close()
xstates = list(set(gwg.states) - set(gwg.edges))
allstates = copy.deepcopy(xstates)
beliefcombs = powerset(partitionGrid.keys())
for i in range(gwg.nstates, gwg.nstates + len(beliefcombs)):
allstates.append(i)
gwg.moveobstacles = copy.deepcopy(moveobstacles)
currstate = 0
gridstate = copy.deepcopy(moveobstacles[0])
gwg.colorstates = [set(), set()]
while True:
for v in data['variables']:
if 'y' not in v:
envsize = data['variables'].index(v)
break
totstate = data['nodes'][str(currstate)]['state']
envstatebin = totstate[0:envsize]
agentstatebin = totstate[envsize:len(totstate)]
envstate = allstates[int(''.join(str(e) for e in envstatebin)[::-1],
2)]
agentstate = [None] * gwg.nagents
for n in range(gwg.nagents):
singleagentstatebin = agentstatebin[n * len(agentstatebin) /
gwg.nagents:(n + 1) *
len(agentstatebin) /
gwg.nagents]
agentstate[n] = xstates[int(
''.join(str(e) for e in singleagentstatebin)[::-1], 2)]
gwg.render()
gwg.moveobstacles[0] = copy.deepcopy(gridstate)
gwg.render()
gwg.current = copy.deepcopy(agentstate)
print 'Agent state in grid is ', gwg.current[0]
print 'Agent state in automaton is ', xstates.index(gwg.current[0])
gwg.colorstates[0] = set()
gwg.colorstates[0].update(visibility.invis(gwg, agentstate[0]))
for n in range(1, gwg.nagents):
gwg.colorstates[0] = gwg.colorstates.intersection(
visibility.invis(gwg, agentstate[n]))
gwg.render()
# gwg.draw_state_labels()
nextstates = data['nodes'][str(currstate)]['trans']
nextstatedirn = {
'Left': None,
'Right': None,
'Down': None,
'Up': None,
'Belief': set()
}
for n in nextstates:
ntotstate = data['nodes'][str(n)]['state']
nenvstatebin = ntotstate[0:envsize]
nenvstate = allstates[int(
''.join(str(e) for e in nenvstatebin)[::-1], 2)]
if nenvstate == gwg.moveobstacles[0] - 1:
nextstatedirn['Left'] = n
if nenvstate == gwg.moveobstacles[0] + 1:
nextstatedirn['Right'] = n
if nenvstate == gwg.moveobstacles[0] + gwg.ncols:
nextstatedirn['Down'] = n
if nenvstate == gwg.moveobstacles[0] - gwg.ncols:
nextstatedirn['Up'] = n
if nenvstate not in xstates:
nextstatedirn['Belief'].add(n)
while True:
nextstate = None
while nextstate == None:
while True:
arrow = gwg.getkeyinput()
if arrow != None:
break
nextstate = nextstatedirn[arrow]
if nextstate == None:
if arrow == 'Left':
gridstate = gwg.moveobstacles[0] - 1
elif arrow == 'Right':
gridstate = gwg.moveobstacles[0] + 1
elif arrow == 'Down':
gridstate = gwg.moveobstacles[0] + gwg.ncols
elif arrow == 'Up':
gridstate = gwg.moveobstacles[0] - gwg.ncols
for n in nextstatedirn['Belief']:
ntotstate = data['nodes'][str(n)]['state']
nenvstatebin = ntotstate[0:envsize]
nenvstate = allstates[int(
''.join(str(e) for e in nenvstatebin)[::-1], 2)]
nextbeliefs = beliefcombs[len(beliefcombs) -
(len(allstates) -
allstates.index(nenvstate))]
if any(gridstate in partitionGrid[x]
for x in nextbeliefs):
nextstate = copy.deepcopy(n)
print 'Environment state in automaton is', allstates.index(
nenvstate)
print 'Belief state is', beliefcombs[
allstates.index(nenvstate) - len(xstates)]
nagentstatebin = ntotstate[envsize:len(ntotstate)]
nextagentstate = [None] * gwg.nagents
for n in range(gwg.nagents):
singleagentstatebin = nagentstatebin[
n * len(nagentstatebin) /
gwg.nagents:(n + 1) * len(nagentstatebin) /
gwg.nagents]
nextagentstate[n] = xstates[int(
''.join(
str(e)
for e in singleagentstatebin)[::-1],
2)]
invisstates = visibility.invis(
gwg, nextagentstate[0])
visstates = set(xstates) - invisstates
if nenvstate not in xstates:
beliefcombstate = beliefcombs[
allstates.index(nenvstate) - len(xstates)]
beliefstates = set()
for b in beliefcombstate:
beliefstates = beliefstates.union(
partitionGrid[b])
truebeliefstates = beliefstates - beliefstates.intersection(
visstates)
gwg.colorstates[1] = copy.deepcopy(
truebeliefstates)
gwg.render()
print 'True belief set is ', truebeliefstates
print 'Size of true belief set is ', len(
truebeliefstates)
else:
ntotstate = data['nodes'][str(nextstate)]['state']
nenvstatebin = ntotstate[0:envsize]
nenvstate = xstates[int(
''.join(str(e) for e in nenvstatebin)[::-1], 2)]
print 'Environment state in automaton is', allstates.index(
nenvstate)
print 'Environment state in grid is', nenvstate
gridstate = copy.deepcopy(nenvstate)
gwg.colorstates[1] = set()
gwg.render()
if len(data['nodes'][str(nextstate)]['trans']) > 0:
break
print 'Automaton state is ', nextstate
currstate = nextstate
def userControlled_belief_multitarget(filename, gwg, numbeliefstates):
file = open(filename)
data = json.load(file)
file.close()
xstates = list(set(gwg.states) - set(gwg.edges))
partitionGrid = grid_partition.partitionGrid(gwg, numbeliefstates)
allstates = copy.deepcopy(xstates)
beliefcombs = powerset(partitionGrid.keys())
for i in range(gwg.nstates, gwg.nstates + len(beliefcombs)):
allstates.append(i)
targetletters = ['y', 'd', 'e', 'f', 'g']
currstate = 0
gridstate = copy.deepcopy(gwg.moveobstacles)
gwg.colorstates = [set(), set()]
while True:
for v in data['variables']:
if targetletters[0] not in v:
envsize = data['variables'].index(v)
break
totstate = data['nodes'][str(currstate)]['state']
envstate = [None] * len(gwg.moveobstacles)
for targn in range(len(gwg.moveobstacles)):
singleenvstatebin = totstate[envsize * targn:envsize * (targn + 1)]
envstate[targn] = allstates[int(
''.join(str(e) for e in singleenvstatebin)[::-1], 2)]
agentstatebin = totstate[envsize *
len(gwg.moveobstacles):len(totstate)]
agentstate = [None] * gwg.nagents
for n in range(gwg.nagents):
singleagentstatebin = agentstatebin[n * len(agentstatebin) /
gwg.nagents:(n + 1) *
len(agentstatebin) /
gwg.nagents]
agentstate[n] = xstates[int(
''.join(str(e) for e in singleagentstatebin)[::-1], 2)]
gwg.render()
gwg.moveobstacles = copy.deepcopy(gridstate)
gwg.render()
gwg.current = copy.deepcopy(agentstate)
print 'Agent state in grid is ', gwg.current[0]
print 'Agent state in automaton is ', xstates.index(gwg.current[0])
gwg.colorstates[0] = set()
gwg.colorstates[0].update(visibility.invis(gwg, agentstate[0]))
for n in range(1, gwg.nagents):
gwg.colorstates[0] = gwg.colorstates.intersection(
visibility.invis(gwg, agentstate[n]))
# time.sleep(0.4)
gwg.render()
# gwg.draw_state_labels()
dirns = ['Left', 'Right', 'Up', 'Down', 'Belief']
nextdirns = list(
itertools.product(dirns, repeat=len(gwg.moveobstacles)))
nextstates = data['nodes'][str(currstate)]['trans']
emptysets = [set() for x in range(len(nextdirns))]
nextstatedirn = dict(zip(nextdirns, emptysets))
for n in nextstates:
targnextstatedirn = [None] * len(
gwg.moveobstacles) # Where is each agent moving
ntotstate = data['nodes'][str(n)]['state']
nenvstate = [None] * len(gwg.moveobstacles)
for targn in range(len(gwg.moveobstacles)):
nsingleenvstatebin = ntotstate[envsize * targn:envsize *
(targn + 1)]
nenvstate[targn] = allstates[int(
''.join(str(e) for e in nsingleenvstatebin)[::-1], 2)]
if nenvstate[targn] == gwg.moveobstacles[targn] - 1:
targnextstatedirn[targn] = 'Left'
elif nenvstate[targn] == gwg.moveobstacles[targn] + 1:
targnextstatedirn[targn] = 'Right'
elif nenvstate[targn] == gwg.moveobstacles[targn] + gwg.ncols:
targnextstatedirn[targn] = 'Down'
elif nenvstate[targn] == gwg.moveobstacles[targn] - gwg.ncols:
targnextstatedirn[targn] = 'Up'
elif nenvstate[targn] not in xstates:
targnextstatedirn[targn] = 'Belief'
if None not in targnextstatedirn:
nextstatedirn[tuple(targnextstatedirn)].add(n)
while True:
nextstate = None
combarrow = [None] * len(gwg.moveobstacles)
while nextstate is None:
for targn in range(len(gwg.moveobstacles)):
while True:
combarrow[targn] = gwg.getkeyinput()
if combarrow[targn] != None:
break
nextstate = nextstatedirn[tuple(combarrow)]
combdirn = [None] * len(gwg.moveobstacles)
checker = 0
if len(nextstate) == 0:
for targn in range(len(gwg.moveobstacles)):
arrow = combarrow[targn]
if arrow == 'Left':
gridstate[targn] = gwg.moveobstacles[targn] - 1
elif arrow == 'Right':
gridstate[targn] = gwg.moveobstacles[targn] + 1
elif arrow == 'Down':
gridstate[
targn] = gwg.moveobstacles[targn] + gwg.ncols
elif arrow == 'Up':
gridstate[
targn] = gwg.moveobstacles[targn] - gwg.ncols
if gridstate[targn] in visibility.invis(
gwg, gwg.current[0]):
combdirn[
targn] = 'Belief' # Means the particular target is in a belief state
else:
combdirn[targn] = arrow
for n in nextstatedirn[tuple(
combdirn
)]: #Need to figure out which target(s) are in belief states
ntotstate = data['nodes'][str(n)]['state']
nextbeliefs = set()
for targn in range(len(gwg.moveobstacles)):
nsingleenvstatebin = ntotstate[envsize *
targn:envsize *
(targn + 1)]
nenvstate[targn] = allstates[int(
''.join(str(e)
for e in nsingleenvstatebin)[::-1], 2)]
if nenvstate[targn] not in xstates:
nextbeliefs = nextbeliefs.union(beliefcombs[
len(beliefcombs) -
(len(allstates) -
allstates.index(nenvstate[targn]))])
if any(gridstate[belieftargn] in partitionGrid[x]
for x in nextbeliefs for belieftargn in [
i for i, y in enumerate(combdirn)
if y == 'Belief'
]):
for belieftargn in [
i for i, x in enumerate(combdirn)
if x == 'Belief'
]:
if envstate[belieftargn] in xstates or (
beliefcombs[len(beliefcombs) - (
len(allstates) - allstates.index(
envstate[belieftargn]))] <
nextbeliefs):
checker = 1
nextstate = copy.deepcopy(n)
# print 'Environment state in automaton is', allstates.index(nenvstate)
# print 'Environment state in grid is', nenvstate
nagentstatebin = ntotstate[
envsize *
len(gwg.moveobstacles):len(ntotstate)]
nextagentstate = [None] * gwg.nagents
for agent in range(gwg.nagents):
singleagentstatebin = nagentstatebin[
agent * len(nagentstatebin) /
gwg.nagents:(agent + 1) *
len(nagentstatebin) / gwg.nagents]
nextagentstate[agent] = xstates[int(
''.join(
str(e) for e in
singleagentstatebin)[::-1], 2)]
invisstates = visibility.invis(
gwg, nextagentstate[0])
visstates = set(xstates) - invisstates
if nenvstate[belieftargn] not in xstates:
beliefcombstate = beliefcombs[
allstates.index(
nenvstate[belieftargn]) -
len(xstates)]
beliefstates = set()
for b in beliefcombstate:
beliefstates = beliefstates.union(
partitionGrid[b])
truebeliefstates = beliefstates - beliefstates.intersection(
visstates)
gwg.colorstates[1] = copy.deepcopy(
truebeliefstates)
gwg.render()
print 'Belief set is ', truebeliefstates
print 'Size of belief set is ', len(
truebeliefstates)
elif checker == 0 and beliefcombs[
len(beliefcombs) -
(len(allstates) -
allstates.index(envstate[belieftargn])
)] <= nextbeliefs:
nextstate = copy.deepcopy(n)
# print 'Environment state in automaton is', allstates.index(nenvstate)
# print 'Environment state in grid is', nenvstate
nagentstatebin = ntotstate[
envsize *
len(gwg.moveobstacles):len(ntotstate)]
nextagentstate = [None] * gwg.nagents
for agent in range(gwg.nagents):
singleagentstatebin = nagentstatebin[
agent * len(nagentstatebin) /
gwg.nagents:(agent + 1) *
len(nagentstatebin) / gwg.nagents]
nextagentstate[agent] = xstates[int(
''.join(
str(e) for e in
singleagentstatebin)[::-1], 2)]
invisstates = visibility.invis(
gwg, nextagentstate[0])
visstates = set(xstates) - invisstates
if nenvstate not in xstates:
beliefcombstate = beliefcombs[
allstates.index(
nenvstate[belieftargn]) -
len(xstates)]
beliefstates = set()
for b in beliefcombstate:
beliefstates = beliefstates.union(
partitionGrid[b])
truebeliefstates = beliefstates - beliefstates.intersection(
visstates)
gwg.colorstates[1] = copy.deepcopy(
truebeliefstates)
# gwg.render()
print 'Belief set is ', truebeliefstates
print 'Size of belief set is ', len(
truebeliefstates)
else:
(nextstate, ) = nextstate
ntotstate = data['nodes'][str(nextstate)]['state']
for targn in range(len(gwg.moveobstacles)):
nsingleenvstatebin = ntotstate[envsize *
targn:envsize *
(targn + 1)]
nenvstate[targn] = xstates[int(
''.join(str(e) for e in nsingleenvstatebin)[::-1],
2)]
# print 'Environment state in automaton is', allstates.index(nenvstate)
# print 'Environment state in grid is', nenvstate
gridstate = copy.deepcopy(nenvstate)
gwg.colorstates[1] = set()
gwg.render()
if len(data['nodes'][str(nextstate)]['trans']) > 0:
break
print 'Automaton state is ', nextstate
currstate = nextstate
def analyse_counterexample(fname, gwg, partitionGrid, belief_safety,
belief_liveness, target_reachability, targets):
global visited_nodes
global visited_pairs
global path_beliefs
global path_abstract
global belief_true_next
global toRefine
global prefix_length
global refine_states
global neg_states
visited_nodes = set()
visited_pairs = set()
path_beliefs = list()
path_abstract = list()
belief_true_next = set()
toRefine = list()
prefix_length = 0
refine_states = set()
neg_states = set()
with open(fname) as f:
content = f.readlines()
content = [x.strip() for x in content]
xstates = list(set(gwg.states) - set(gwg.edges))
allstates = copy.deepcopy(xstates)
beliefcombs = counterexample_parser.powerset(partitionGrid.keys())
for i in range(gwg.nstates, gwg.nstates + len(beliefcombs)):
allstates.append(i)
invisibilityset = [
dict.fromkeys(
set(gwg.states) - set(gwg.edges),
frozenset({gwg.nrows * gwg.ncols + 1}))
] * gwg.nagents
for n in range(gwg.nagents):
for s in set(gwg.states) - set(gwg.edges):
invisibilityset[n][s] = visibility.invis(gwg,
s) #- set(gwg.targets[n])
if s in gwg.obstacles:
invisibilityset[n][s] = {-1}
def traverse_counterexample_safety(fname, gwg, partitionGrid,
belief_safety, ind, agentstate_parent):
global visited_nodes
global visited_pairs
global belief_true_next
global toRefine
global refine_states
global neg_states
visited_nodes.add(ind)
#print 'INDEX IN COUNTEREXAMPLE ', ind
envstatebin = []
agentstatebin = []
beliefstate = set()
line = content[ind].split(' ')
for r in line[6::]:
if r[1] == 'y' or r[0] == 'y':
envstatebin.append(r[-2])
elif r[1] == 'x' or r[0] == 'x':
agentstatebin.append(r[-2])
# agent position
if len(agentstatebin) > 0:
agentstate = xstates[int(
''.join(str(e) for e in agentstatebin)[::-1], 2)]
#print 'Agent position is ', agentstate
else: # failure state
return
if content[ind + 1] == 'With no successors.': # terminal state
return
# environment position
envstate = int(''.join(str(e) for e in envstatebin)[::-1], 2)
if envstate < len(xstates):
belief_true = {xstates[envstate]}
#print 'Environment position is ', xstates[envstate]
else:
for b in beliefcombs[envstate - len(xstates)]:
beliefstate = beliefstate.union(partitionGrid[b])
beliefstate = beliefstate - set(gwg.targets[0])
belief_true = copy.deepcopy(belief_true_next)
#print 'Environment position is ', beliefstate
if (((ind, frozenset(belief_true))
in visited_pairs)): # already explored
return
visited_pairs.add((ind, frozenset(belief_true)))
# compute true belief for successor nodes w.r.t. current position of agent
belief_true_next = set()
for s in (belief_true - set(gwg.targets[0])):
for a in gwg.actlist:
for t in np.nonzero(gwg.prob[a][s])[0]:
if t in gwg.targets[0]:
continue # do not add goal locations
belief_true_next.add(t)
belief_true_next = belief_true_next - set(gwg.walls)
belief_true_next = belief_true_next.intersection(
invisibilityset[0][agentstate])
if len(beliefstate) > 0:
# invisible states in belief w.r.t. previous position of agent
belief_invisible = beliefstate.intersection(
invisibilityset[0][agentstate_parent])
belief_visible = beliefstate - invisibilityset[0][agentstate_parent]
if len(belief_invisible) > 0 and len(belief_true) == 0:
print 'UNCONCRETIZABLE PATH'
print 'AGENT STATE', agentstate_parent
print 'ABSTRACT BELIEF', beliefstate
print 'ABSTRACT BELIEF INVISIBLE', belief_invisible
refine_states = copy.deepcopy(belief_true)
# partitions in the leaf node that will be refined
tr = set()
for b in beliefcombs[envstate - len(xstates)]:
tr.add(b)
neg_states = neg_states.union(
partitionGrid[b].difference(belief_visible))
toRefine.append(tr)
return
if len(belief_invisible
) > belief_safety: # belief violates constraint
if len(belief_true
) <= belief_safety: # true belief satisfies constraint
print 'SAFETY'
print 'AGENT STATE', agentstate_parent
print 'ABSTRACT BELIEF', beliefstate
print 'ABSTRACT BELIEF INVISIBLE', belief_invisible
print 'TRUE BELIEF', belief_true
refine_states = copy.deepcopy(belief_true)
leaf_plus_vis = belief_visible.union(belief_true)
# partitions in the leaf node that will be refined
tr = set()
for b in beliefcombs[envstate - len(xstates)]:
tr.add(b)
neg_states = neg_states.union(
partitionGrid[b].difference(leaf_plus_vis))
toRefine.append(tr)
return
'''
recurse over the successors (subtrees) of the current node, searching for a leaf node to refine
if in some subtree such node is found, add the current node to the counterexample and return
'''
belief_true_next_current = copy.deepcopy(belief_true_next)
nextposstates = map(int, content[ind + 1][18:].split(', '))
for succ in range(0, len(content), 2):
belief_true_next = copy.deepcopy(belief_true_next_current)
if (int(content[succ].split(' ')[1]) in nextposstates):
if (not ((succ, frozenset(belief_true_next)) in visited_pairs)
and not (len(belief_true_next) == 0
and succ in visited_nodes)):
traverse_counterexample_safety(fname, gwg, partitionGrid,
belief_safety, succ,
agentstate)
if toRefine:
tr = set()
if envstate >= len(xstates):
for b in beliefcombs[envstate - len(xstates)]:
tr.add(b)
toRefine.append(tr)
return
return
def traverse_counterexample_liveness(fname, gwg, partitionGrid,
belief_liveness, ind,
agentstate_parent):
global visited_nodes
global visited_pairs
global belief_true_next
global toRefine
global prefix_length
global refine_states
global neg_states
visited_nodes.add(ind)
#print 'INDEX IN COUNTEREXAMPLE ', ind
envstatebin = []
agentstatebin = []
beliefstate = set()
line = content[ind].split(' ')
for r in line[6::]:
if r[1] == 'y' or r[0] == 'y':
envstatebin.append(r[-2])
elif r[1] == 'x' or r[0] == 'x':
agentstatebin.append(r[-2])
# environment position
envstate = int(''.join(str(e) for e in envstatebin)[::-1], 2)
if envstate < len(xstates):
belief_true = {xstates[envstate]}
#print 'Environment position is ', xstates[envstate]
else:
for b in beliefcombs[envstate - len(xstates)]:
beliefstate = beliefstate.union(partitionGrid[b])
beliefstate = beliefstate - set(gwg.targets[0])
belief_true = copy.deepcopy(belief_true_next)
#print 'Environment position is ', beliefstate
if (((ind, frozenset(belief_true))
in visited_pairs)): # already explored
return
visited_pairs.add((ind, frozenset(belief_true)))
path_beliefs.append((ind, frozenset(belief_true)))
# agent position
if len(agentstatebin) > 0:
agentstate = xstates[int(
''.join(str(e) for e in agentstatebin)[::-1], 2)]
#print 'Agent position is ', agentstate
else: # failure state
path_beliefs.pop()
return
if content[ind + 1] == 'With no successors.': # terminal state
path_beliefs.pop()
return
# invisible states in belief w.r.t. previous position of agent
belief_invisible = beliefstate.intersection(
invisibilityset[0][agentstate_parent])
belief_visible = beliefstate.difference(
invisibilityset[0][agentstate_parent])
path_abstract.append(
(envstate, frozenset(belief_invisible), frozenset(belief_visible)))
if len(belief_invisible) > 0 and len(belief_true) == 0:
print 'UNCONCRETIZABLE PATH'
print 'AGENT STATE', agentstate_parent
print 'ABSTRACT BELIEF', beliefstate
print 'ABSTRACT BELIEF INVISIBLE', belief_invisible
refine_states = copy.deepcopy(belief_true)
# partitions in the leaf node that will be refined
tr = set()
for b in beliefcombs[envstate - len(xstates)]:
tr.add(b)
neg_states = neg_states.union(
partitionGrid[b].difference(belief_visible))
toRefine.append(tr)
prefix_length = 0
path_beliefs.pop()
path_abstract.pop()
return
# compute true belief for successor nodes w.r.t. current position of agent
belief_true_next = set()
for s in (belief_true - set(gwg.targets[0])):
for a in gwg.actlist:
for t in np.nonzero(gwg.prob[a][s])[0]:
if t in gwg.targets[0]:
continue # do not add goal locations
belief_true_next.add(t)
belief_true_next = belief_true_next - set(gwg.walls)
belief_true_next = belief_true_next.intersection(
invisibilityset[0][agentstate])
'''
recurse over the successors (subtrees) of the current node, searching for a leaf node to refine
if in some subtree such node is found, add the current node to the counterexample and return
'''
belief_true_next_current = copy.deepcopy(belief_true_next)
nextposstates = map(int, content[ind + 1][18:].split(', '))
for succ in range(0, len(content), 2):
belief_true_next = copy.deepcopy(belief_true_next_current)
if (int(content[succ].split(' ')[1]) in nextposstates):
envstatebin_succ = []
beliefstate_succ = set()
line_succ = content[succ].split(' ')
for r in line[6::]:
if r[1] == 'y' or r[0] == 'y':
envstatebin_succ.append(r[-2])
envstate_succ = int(
''.join(str(e) for e in envstatebin_succ)[::-1], 2)
if envstate_succ < len(xstates):
beliefstate_succ = {xstates[envstate]}
else:
for b in beliefcombs[envstate_succ - len(xstates)]:
beliefstate_succ = beliefstate_succ.union(
partitionGrid[b])
beliefstate_succ = beliefstate_succ - set(gwg.targets[0])
belief_visible_succ = beliefstate_succ - invisibilityset[0][
agentstate]
belief_invisible_succ = beliefstate_succ.intersection(
invisibilityset[0][agentstate])
good_loop = False
for (s, t), (e, bi, bv) in zip(reversed(path_beliefs),
reversed(path_abstract)):
if (s, t) == (succ, frozenset(belief_true_next)):
break
if len(bi) <= belief_liveness:
good_loop = True
break
#if good_loop:
# continue
if belief_true_next and (
succ,
frozenset(belief_true_next)) in path_beliefs and len(
belief_true_next) <= belief_liveness and len(
belief_invisible_succ) > belief_liveness:
print 'LIVENESS'
print 'AGENT STATE', agentstate
print 'ABSTRACT BELIEF', beliefstate_succ
print 'ABSTRACT BELIEF INVISIBLE', belief_invisible_succ
print 'TRUE BELIEF', belief_true_next
#print 'PATH BELIEFS', path_beliefs
#print 'SUCC', (succ,frozenset(belief_true_next))
prefix_length = path_beliefs.index(
(succ, frozenset(belief_true_next)))
refine_states = copy.deepcopy(belief_true_next)
leaf_plus_vis = belief_visible_succ.union(belief_true_next)
tr_succ = set()
if envstate_succ >= len(xstates):
for b in beliefcombs[envstate_succ - len(xstates)]:
neg_states = neg_states.union(
partitionGrid[b].difference(leaf_plus_vis))
tr_succ.add(b)
toRefine.append(tr_succ)
tr = set()
if envstate >= len(xstates):
for b in beliefcombs[envstate - len(xstates)]:
tr.add(b)
toRefine.append(tr)
path_beliefs.pop()
path_abstract.pop()
return
if (not ((succ, frozenset(belief_true_next)) in visited_pairs)
and not (len(belief_true_next) == 0
and succ in visited_nodes)):
traverse_counterexample_liveness(fname, gwg, partitionGrid,
belief_liveness, succ,
agentstate)
if toRefine:
tr = set()
if envstate >= len(xstates):
for b in beliefcombs[envstate - len(xstates)]:
tr.add(b)
toRefine.append(tr)
path_beliefs.pop()
path_abstract.pop()
return
path_beliefs.pop()
path_abstract.pop()
return
def traverse_counterexample_ltl(fname, gwg, partitionGrid, targets, ind,
agentstate_parent):
global visited_nodes
global visited_pairs
global belief_true_next
global toRefine
global refine_states
global neg_states
visited_nodes.add(ind)
#print 'INDEX IN COUNTEREXAMPLE ', ind
envstatebin = []
agentstatebin = []
beliefstate = set()
line = content[ind].split(' ')
for r in line[6::]:
if r[1] == 'y' or r[0] == 'y':
envstatebin.append(r[-2])
elif r[1] == 'x' or r[0] == 'x':
agentstatebin.append(r[-2])
# environment position
envstate = int(''.join(str(e) for e in envstatebin)[::-1], 2)
if envstate < len(xstates):
belief_true = {xstates[envstate]}
#print 'Environment position is ', xstates[envstate]
else:
for b in beliefcombs[envstate - len(xstates)]:
beliefstate = beliefstate.union(partitionGrid[b])
beliefstate = beliefstate - set(gwg.targets[0])
belief_true = copy.deepcopy(belief_true_next)
#print 'Environment position is ', beliefstate
if (((ind, frozenset(belief_true))
in visited_pairs)): # already explored
return
visited_pairs.add((ind, frozenset(belief_true)))
# agent position
if len(agentstatebin) > 0:
agentstate = xstates[int(
''.join(str(e) for e in agentstatebin)[::-1], 2)]
#print 'Agent position is ', agentstate
else: # failure state
return
if content[ind + 1] == 'With no successors.': # terminal state
return
# invisible states in belief w.r.t. previous position of agent
belief_invisible = beliefstate.intersection(
invisibilityset[0][agentstate_parent])
belief_visible = beliefstate.difference(
invisibilityset[0][agentstate_parent])
# compute true belief for successor nodes w.r.t. current position of agent
belief_true_next = set()
for s in (belief_true - set(gwg.targets[0])):
for a in gwg.actlist:
for t in np.nonzero(gwg.prob[a][s])[0]:
if t in gwg.targets[0]:
continue # do not add goal locations
belief_true_next.add(t)
belief_true_next = belief_true_next - set(gwg.walls)
belief_true_next = belief_true_next.intersection(
invisibilityset[0][agentstate])
if len(belief_invisible) > 0 and len(belief_true) == 0:
print 'UNCONCRETIZABLE PATH'
print 'AGENT STATE', agentstate_parent
print 'ABSTRACT BELIEF INVISIBLE', belief_invisible
print 'ABSTRACT BELIEF', beliefstate
refine_states = copy.deepcopy(belief_true)
# partitions in the leaf node that will be refined
tr = set()
for b in beliefcombs[envstate - len(xstates)]:
tr.add(b)
neg_states = neg_states.union(
partitionGrid[b].difference(belief_visible))
toRefine.append(tr)
return
if (len(belief_invisible) > len(belief_true)):
print 'LTL'
print 'AGENT STATE', agentstate_parent
print 'ABSTRACT BELIEF', beliefstate
print 'ABSTRACT BELIEF INVISIBLE', belief_invisible
print 'TRUE BELIEF', belief_true
refine_states = copy.deepcopy(belief_true)
leaf_plus_vis = copy.deepcopy(belief_visible.union(belief_true))
# belief state imprecise: refine for LTL spec
tr = set()
for b in beliefcombs[envstate - len(xstates)]:
tr.add(b)
neg_states = neg_states.union(
partitionGrid[b].difference(leaf_plus_vis))
toRefine.append(tr)
return
'''
recurse over the successors (subtrees) of the current node, searching for a leaf node to refine
if in some subtree such node is found, add the current node to the counterexample and return
'''
belief_true_next_current = copy.deepcopy(belief_true_next)
nextposstates = map(int, content[ind + 1][18:].split(', '))
for succ in range(0, len(content), 2):
belief_true_next = copy.deepcopy(belief_true_next_current)
if (int(content[succ].split(' ')[1]) in nextposstates):
if (not ((succ, frozenset(belief_true_next)) in visited_pairs)
and
not (not belief_true_next and succ in visited_nodes)):
traverse_counterexample_ltl(fname, gwg, partitionGrid,
targets, succ, agentstate)
if toRefine:
tr = set()
if envstate >= len(xstates):
for b in beliefcombs[envstate - len(xstates)]:
tr.add(b)
toRefine.append(tr)
return
return
def traverse_counterexample_liveness_basic(fname, gwg, partitionGrid,
belief_liveness, ind,
agentstate_parent):
global visited_nodes
global visited_pairs
global belief_true_next
global toRefine
global refine_states
global neg_states
visited_nodes.add(ind)
#print 'INDEX IN COUNTEREXAMPLE ', ind
envstatebin = []
agentstatebin = []
beliefstate = set()
line = content[ind].split(' ')
for r in line[6::]:
if r[1] == 'y' or r[0] == 'y':
envstatebin.append(r[-2])
elif r[1] == 'x' or r[0] == 'x':
agentstatebin.append(r[-2])
# environment position
envstate = int(''.join(str(e) for e in envstatebin)[::-1], 2)
if envstate < len(xstates):
belief_true = {xstates[envstate]}
#print 'Environment position is ', xstates[envstate]
else:
for b in beliefcombs[envstate - len(xstates)]:
beliefstate = beliefstate.union(partitionGrid[b])
beliefstate = beliefstate - set(gwg.targets[0])
belief_true = copy.deepcopy(belief_true_next)
#print 'Environment position is ', beliefstate
if (((ind, frozenset(belief_true))
in visited_pairs)): # already explored
return
visited_pairs.add((ind, frozenset(belief_true)))
# agent position
if len(agentstatebin) > 0:
agentstate = xstates[int(
''.join(str(e) for e in agentstatebin)[::-1], 2)]
#print 'Agent position is ', agentstate
else: # failure state
return
if content[ind + 1] == 'With no successors.': # terminal state
return
# invisible states in belief w.r.t. previous position of agent
belief_invisible = beliefstate.intersection(
invisibilityset[0][agentstate_parent])
belief_visible = beliefstate - invisibilityset[0][agentstate_parent]
# compute true belief for successor nodes w.r.t. current position of agent
belief_true_next = set()
for s in (belief_true - set(gwg.targets[0])):
for a in gwg.actlist:
for t in np.nonzero(gwg.prob[a][s])[0]:
if t in gwg.targets[0]:
continue # do not add goal locations
belief_true_next.add(t)
belief_true_next = belief_true_next - set(gwg.walls)
belief_true_next = belief_true_next.intersection(
invisibilityset[0][agentstate])
if len(belief_invisible) > 0 and len(belief_true) == 0:
print 'UNCONCRETIZABLE PATH'
print 'AGENT STATE', agentstate_parent
print 'ABSTRACT BELIEF', beliefstate
print 'ABSTRACT BELIEF INVISIBLE', belief_invisible
refine_states = copy.deepcopy(belief_true)
# partitions in the leaf node that will be refined
tr = set()
for b in beliefcombs[envstate - len(xstates)]:
tr.add(b)
neg_states = neg_states.union(
partitionGrid[b].difference(belief_visible))
toRefine.append(tr)
return
leaf_plus_vis = belief_visible.union(belief_true)
if len(beliefstate) > 0:
if len(belief_invisible) > len(belief_true):
# belief violates the constraint and true belief satisfies constraint
print 'LIVENESS'
print 'AGENT STATE', agentstate_parent
print 'ABSTRACT BELIEF', beliefstate
print 'ABSTRACT BELIEF INVISIBLE', belief_invisible
print 'TRUE BELIEF', belief_true
# partitions in the leaf node that will be refined
tr = set()
for b in beliefcombs[envstate - len(xstates)]:
tr.add(b)
neg_states = neg_states.union(
partitionGrid[b].difference(leaf_plus_vis))
toRefine.append(tr)
refine_states = copy.deepcopy(belief_true)
return
'''
recurse over the successors (subtrees) of the current node, searching for a leaf node to refine
if in some subtree such node is found, add the current node to the counterexample and return
'''
belief_true_next_current = copy.deepcopy(belief_true_next)
nextposstates = map(int, content[ind + 1][18:].split(', '))
for succ in range(0, len(content), 2):
belief_true_next = copy.deepcopy(belief_true_next_current)
if (int(content[succ].split(' ')[1]) in nextposstates):
if (not ((succ, frozenset(belief_true_next)) in visited_pairs)
and not (
(not belief_true_next) and succ in visited_nodes)):
traverse_counterexample_liveness_basic(
fname, gwg, partitionGrid, belief_liveness, succ,
agentstate)
if toRefine:
tr = set()
if envstate >= len(xstates):
for b in beliefcombs[envstate - len(xstates)]:
tr.add(b)
toRefine.append(tr)
return
return
if belief_safety > 0:
traverse_counterexample_safety(fname, gwg, partitionGrid,
belief_safety, 0, gwg.current[0])
ref = 'safety'
if not toRefine and belief_liveness > 0:
visited_nodes = set()
visited_pairs = set()
path_beliefs = list()
path_abstract = list()
belief_true_next = set()
traverse_counterexample_liveness(fname, gwg, partitionGrid,
belief_liveness, 0, gwg.current[0])
ref = 'liveness'
if not toRefine and target_reachability:
visited_nodes = set()
visited_pairs = set()
belief_true_next = set()
traverse_counterexample_ltl(fname, gwg, partitionGrid, targets, 0,
gwg.current[0])
ref = 'ltl'
if not toRefine:
ref = 'none'
return (ref, toRefine, refine_states, neg_states, prefix_length)
def write_to_slugs_belief_multipletargets(infile,
gw,
vel=1,
belief_partitions=0,
beliefconstraint=1):
agentletters = ['x', 'z', 'a', 'b', 'c']
targetletters = ['y', 'd', 'e', 'f', 'g']
nonbeliefstates = list(set(gw.states) - set(gw.edges))
partitionGrid = grid_partition.partitionGrid(gw, belief_partitions)
allstates = copy.deepcopy(nonbeliefstates)
beliefcombs = powerset(partitionGrid.keys())
for i in range(gw.nstates, gw.nstates + len(beliefcombs)):
allstates.append(i)
invisibilityset = [
dict.fromkeys(
set(gw.states) - set(gw.edges), frozenset(
{gw.nrows * gw.ncols + 1}))
] * gw.nagents
for n in range(gw.nagents):
for s in set(gw.states) - set(gw.edges):
invisibilityset[n][s] = visibility.invis(gw, s) - set(
gw.targets[n])
if s in gw.obstacles:
invisibilityset[n][s] = {-1}
filename = infile + '.structuredslugs'
file = open(filename, 'w')
file.write('[INPUT]\n')
for n in range(len(gw.moveobstacles)):
file.write(targetletters[n] + ':0...{}\n'.format(len(allstates) - 1))
file.write('[OUTPUT]\n')
for n in range(gw.nagents):
file.write(agentletters[n] +
':0...{}\n'.format(len(nonbeliefstates) - 1))
file.write('[ENV_INIT]\n')
for n in range(len(gw.moveobstacles)):
file.write(
targetletters[n] +
' = {}\n'.format(nonbeliefstates.index(gw.moveobstacles[n])))
file.write('[SYS_INIT]\n')
for n in range(gw.nagents):
file.write(agentletters[n] +
' = {}\n'.format(nonbeliefstates.index(gw.current[n])))
# writing env_trans
file.write('\n[ENV_TRANS]\n')
for targn in range(len(gw.moveobstacles)):
for y in range(len(allstates)):
if allstates[y] in nonbeliefstates:
for x in range(len(nonbeliefstates)):
sagent = nonbeliefstates[x]
stri = " (x = {} /\\ {} = {}) -> ".format(
x, targetletters[targn], y)
senv = allstates[y]
beliefset = set()
for a in range(gw.nactions):
for t in np.nonzero(gw.prob[gw.actlist[a]][senv])[0]:
if not any(t in invisibilityset[n][sagent]
for n in range(gw.nagents)):
stri += ' {}\' = {} \\/'.format(
targetletters[targn], allstates.index(t))
else:
t2 = partitionGrid.keys()[[
inv for inv in range(
len(partitionGrid.values()))
if t in partitionGrid.values()[inv]
][0]]
beliefset.add(t2)
if len(beliefset) > 0:
b2 = allstates[len(nonbeliefstates) +
beliefcombs.index(beliefset)]
stri += ' {}\' = {} \\/'.format(
targetletters[targn], allstates.index(b2))
stri = stri[:-3]
stri += '\n'
file.write(stri)
for n in range(gw.nagents):
file.write("{} = {} -> !{}' = {}\n".format(
agentletters[n], x, targetletters[targn],
allstates.index(sagent)))
else:
for x in range(len(nonbeliefstates)):
sagent = nonbeliefstates[x]
invisstates = invisibilityset[0][sagent]
beliefcombstate = beliefcombs[y - len(nonbeliefstates)]
beliefstates = set()
visstates = set(nonbeliefstates) - invisstates
for currbeliefstate in beliefcombstate:
beliefstates = beliefstates.union(
partitionGrid[currbeliefstate])
truebeliefstates = beliefstates - beliefstates.intersection(
visstates)
if len(truebeliefstates) > 0 or 1 == 1:
stri = " (x = {} /\\ {} = {}) -> ".format(
x, targetletters[targn], y)
beliefset = set()
beliefset = beliefset.union(beliefcombstate)
for b in beliefstates:
for a in range(gw.nactions):
for t in np.nonzero(
gw.prob[gw.actlist[a]][b])[0]:
if not any(t in invisibilityset[n][sagent]
for n in range(gw.nagents)):
stri += ' {}\' = {} \\/'.format(
targetletters[targn],
allstates.index(t))
else:
t2 = partitionGrid.keys()[[
inv for inv in range(
len(partitionGrid.values()))
if t in partitionGrid.values()[inv]
][0]]
beliefset.add(t2)
if len(beliefset) > 0:
b2 = allstates[len(nonbeliefstates) +
beliefcombs.index(beliefset)]
stri += ' {}\' = {} \\/'.format(
targetletters[targn], allstates.index(b2))
stri = stri[:-3]
stri += '\n'
file.write(stri)
# Writing env_safety
for obs in gw.obstacles:
for targn in range(len(gw.moveobstacles)):
file.write('!{} = {}\n'.format(targetletters[targn],
allstates.index(obs)))
for n in range(gw.nagents):
for targn in range(len(gw.moveobstacles)):
# file.write('!y = {}\n'.format(agentletters[n]))
file.write('!{} = {}\n'.format(targetletters[targn],
allstates.index(gw.targets[n][0])))
# writing sys_trans
file.write('\n[SYS_TRANS]\n')
for n in range(gw.nagents):
for x in range(len(nonbeliefstates)):
s = nonbeliefstates[x]
stri = "{} = {} -> ".format(agentletters[n], x)
t = reach_states(gw, {s})
for i in range(1, vel):
t.update(reach_states(gw, t))
for t2 in t:
stri += ' {}\' = {} \\/ '.format(agentletters[n],
nonbeliefstates.index(t2))
stri = stri[:-3]
stri += '\n'
file.write(stri)
# Writing sys_safety
for obs in gw.obstacles:
file.write('!{} = {}\n'.format(agentletters[n],
nonbeliefstates.index(obs)))
for s in set(nonbeliefstates):
for targn in range(len(gw.moveobstacles)):
for n in range(gw.nagents):
stri = '{} = {} -> !{} = {}\n'.format(targetletters[targn],
allstates.index(s),
agentletters[n],
nonbeliefstates.index(s))
file.write(stri)
stri = '{} = {} -> !{}\' = {}\n'.format(
targetletters[targn], allstates.index(s), agentletters[n],
nonbeliefstates.index(s))
file.write(stri)
combined_belief = list(
itertools.product(beliefcombs, repeat=len(gw.moveobstacles)))
for b in combined_belief:
beliefset = set()
for targb in b:
for beliefstate in targb:
beliefset = beliefset.union(partitionGrid[beliefstate])
if len(beliefset) > beliefconstraint:
for targn in range(len(gw.moveobstacles)):
stri = '{} = {} /\\ '.format(
targetletters[targn],
len(nonbeliefstates) + beliefcombs.index(b[targn]))
stri = stri[:-3]
counter = 0 #To check if the visible states from target location brings the beliefset below the constraint
stri += '-> ('
for n in range(gw.nagents):
stri += '('
for x in nonbeliefstates:
invisstates = invisibilityset[n][x]
visstates = set(nonbeliefstates) - invisstates
truebelief = beliefset - beliefset.intersection(visstates)
if len(truebelief) > beliefconstraint:
stri += '!{} = {} /\\ '.format(
agentletters[n], nonbeliefstates.index(x))
counter += 1
stri = stri[:-3]
stri += ') \\/ '
stri = stri[:-3]
stri += ')'
stri += '\n'
if counter > 0:
file.write(stri)
if gw.nagents > 1:
for s in nonbeliefstates:
for n in range(gw.nagents):
stri = '{} = {} ->'.format(agentletters[n],
nonbeliefstates.index(s))
for m in range(gw.nagents):
if m != n:
stri += ' !{} = {} /\\'.format(
agentletters[m], nonbeliefstates.index(s))
stri = stri[:-2]
stri += '\n'
file.write(stri)
# Writing sys_liveness
file.write('\n[SYS_LIVENESS]\n')
for n in range(gw.nagents):
file.write('{} = {}\n'.format(agentletters[n],
nonbeliefstates.index(gw.targets[n][0])))
# Writing env_liveness
file.write('\n[ENV_LIVENESS]\n')
# file.write('y = {}\n'.format(xstates.index(gw.current)))
# file.write('y = {}\n'.format(xstates.index(inittarg)))
# file.write('y = {}\n'.format(xstates.index(88)))
for targn in range(len(gw.moveobstacles)):
file.write('{} = {}\n'.format(targetletters[targn],
nonbeliefstates.index(gw.ncols + 2)))
file.close()
def write_to_slugs_part(infile,
gw,
inittarg,
vel=1,
partitionGrid=[],
belief_safety=0,
belief_liveness=0,
target_reachability=False):
nonbeliefstates = list(set(gw.states) - set(gw.edges))
beliefcombs = powerset(partitionGrid.keys())
allstates = copy.deepcopy(nonbeliefstates)
for i in range(gw.nstates, gw.nstates + len(beliefcombs)):
allstates.append(i)
invisibilityset = [
dict.fromkeys(
set(gw.states) - set(gw.edges), frozenset(
{gw.nrows * gw.ncols + 1}))
] * gw.nagents
for n in range(gw.nagents):
for s in set(gw.states) - set(gw.edges):
invisibilityset[n][s] = visibility.invis(gw, s)
if s in gw.obstacles:
invisibilityset[n][s] = {-1}
filename = infile + '.structuredslugs'
file = open(filename, 'w')
file.write('[INPUT]\n')
file.write('y:0...{}\n'.format(len(allstates) - 1))
file.write('[OUTPUT]\n')
agentletters = ['x', 'z', 'a', 'b', 'c']
for n in range(gw.nagents):
file.write(agentletters[n] +
':0...{}\n'.format(len(nonbeliefstates) - 1))
file.write('[ENV_INIT]\n')
file.write('y = {}\n'.format(allstates.index(gw.moveobstacles[0])))
file.write('[SYS_INIT]\n')
for n in range(gw.nagents):
file.write(agentletters[n] +
' = {}\n'.format(nonbeliefstates.index(gw.current[n])))
# writing env_trans
file.write('\n[ENV_TRANS]\n')
for y in range(len(allstates)):
if allstates[y] in nonbeliefstates:
for x in range(len(nonbeliefstates)):
sagent = nonbeliefstates[x]
stri = " (x = {} /\\ y = {}) -> ".format(x, y)
senv = allstates[y]
beliefset = set()
for a in range(gw.nactions):
for t in np.nonzero(gw.prob[gw.actlist[a]][senv])[0]:
if not any(t in invisibilityset[n][sagent]
for n in range(gw.nagents)):
stri += ' y\' = {} \\/'.format(allstates.index(t))
else:
if not t == sagent and t not in gw.targets[
0]: # not allowed to move on agent's position
t2 = partitionGrid.keys()[[
inv for inv in range(
len(partitionGrid.values()))
if t in partitionGrid.values()[inv]
][0]]
beliefset.add(t2)
if len(beliefset) > 0:
b2 = allstates[len(nonbeliefstates) +
beliefcombs.index(beliefset)]
stri += ' y\' = {} \\/'.format(allstates.index(b2))
stri = stri[:-3]
stri += '\n'
file.write(stri)
for n in range(gw.nagents):
file.write("{} = {} -> !y' = {}\n".format(
agentletters[n], x, allstates.index(sagent)))
else:
for x in range(len(nonbeliefstates)):
sagent = nonbeliefstates[x]
invisstates = invisibilityset[0][sagent]
visstates = set(nonbeliefstates) - invisstates
beliefcombstate = beliefcombs[y - len(nonbeliefstates)]
beliefstates = set()
for currbeliefstate in beliefcombstate:
beliefstates = beliefstates.union(
partitionGrid[currbeliefstate])
for n in range(
gw.nagents
): # remove taret positions (no transitions from target positions)
beliefstates = beliefstates - set(gw.targets[n])
beliefstates_vis = beliefstates.intersection(visstates)
beliefstates_invis = beliefstates - beliefstates_vis
if belief_safety > 0 and len(
beliefstates_invis) > belief_safety:
continue # no transitions from error states
if len(beliefstates) > 0:
stri = " (x = {} /\\ y = {}) -> ".format(x, y)
beliefset = set()
for b in beliefstates:
for a in range(gw.nactions):
for t in np.nonzero(gw.prob[gw.actlist[a]][b])[0]:
if not any(t in invisibilityset[n][sagent]
for n in range(gw.nagents)):
stri += ' y\' = {} \\/'.format(
allstates.index(t))
else:
if t in gw.targets[0]:
continue
t2 = partitionGrid.keys()[[
inv for inv in range(
len(partitionGrid.values()))
if t in partitionGrid.values()[inv]
][0]]
beliefset.add(t2)
if len(beliefset) > 0:
b2 = allstates[len(nonbeliefstates) +
beliefcombs.index(beliefset)]
stri += ' y\' = {} \\/'.format(allstates.index(b2))
'''
for b in beliefstates_vis: # successors of visible states in beliefstates
beliefset = set()
for a in range(gw.nactions):
for t in np.nonzero(gw.prob[gw.actlist[a]][b])[0]:
if not any(t in invisibilityset[n][sagent] for n in range(gw.nagents)):
stri += ' y\' = {} \\/'.format(allstates.index(t))
else:
t2 = partitionGrid.keys()[[inv for inv in range(len(partitionGrid.values())) if t in partitionGrid.values()[inv]][0]]
beliefset.add(t2)
if len(beliefset) > 0:
b2 = allstates[len(nonbeliefstates) + beliefcombs.index(beliefset)]
stri += ' y\' = {} \\/'.format(allstates.index(b2))
'''
stri = stri[:-3]
stri += '\n'
file.write(stri)
# Writing env_safety
for obs in gw.obstacles:
file.write('!y = {}\n'.format(allstates.index(obs)))
if target_reachability:
for n in range(gw.nagents):
file.write('!y = {}\n'.format(allstates.index(gw.targets[n][0])))
# writing sys_trans
file.write('\n[SYS_TRANS]\n')
for n in range(gw.nagents):
for x in range(len(nonbeliefstates)):
s = nonbeliefstates[x]
stri = "{} = {} -> ".format(agentletters[n], x)
t = reach_states(gw, {s})
for i in range(1, vel):
t.update(reach_states(gw, t))
for t2 in t:
stri += ' {}\' = {} \\/ '.format(agentletters[n],
nonbeliefstates.index(t2))
stri = stri[:-3]
stri += '\n'
file.write(stri)
# Writing sys_safety
for obs in gw.obstacles:
file.write('!{} = {}\n'.format(agentletters[n],
nonbeliefstates.index(obs)))
for s in set(nonbeliefstates):
for n in range(gw.nagents):
stri = 'y = {} -> !{} = {}\n'.format(allstates.index(s),
agentletters[n],
nonbeliefstates.index(s))
file.write(stri)
stri = 'y = {} -> !{}\' = {}\n'.format(allstates.index(s),
agentletters[n],
nonbeliefstates.index(s))
file.write(stri)
if belief_safety > 0:
for b in beliefcombs:
beliefset = set()
for beliefstate in b:
beliefset = beliefset.union(partitionGrid[beliefstate])
beliefset = beliefset - set(gw.targets[0])
if len(beliefset) > belief_safety:
stri = 'y = {} -> '.format(
len(nonbeliefstates) + beliefcombs.index(b))
counter = 0
stri += '('
for n in range(gw.nagents):
stri += '('
for x in nonbeliefstates:
invisstates = invisibilityset[n][x]
beliefset_invis = beliefset.intersection(invisstates)
if len(beliefset_invis) > belief_safety:
stri += '!{} = {} /\\ '.format(
agentletters[n], nonbeliefstates.index(x))
counter += 1
stri = stri[:-3]
stri += ') \\/ '
stri = stri[:-3]
stri += ')'
stri += '\n'
if counter > 0:
file.write(stri)
if gw.nagents > 1:
for s in nonbeliefstates:
for n in range(gw.nagents):
stri = '{} = {} ->'.format(agentletters[n],
nonbeliefstates.index(s))
for m in range(gw.nagents):
if m != n:
stri += ' !{} = {} /\\'.format(
agentletters[m], nonbeliefstates.index(s))
stri = stri[:-2]
stri += '\n'
file.write(stri)
# Writing sys_liveness
file.write('\n[SYS_LIVENESS]\n')
if target_reachability:
for n in range(gw.nagents):
file.write('{} = {}\n'.format(
agentletters[n], nonbeliefstates.index(gw.targets[n][0])))
stri = ''
if belief_liveness > 0:
for y in range(len(nonbeliefstates)):
stri += 'y = {}'.format(y)
if y < len(nonbeliefstates) - 1:
stri += ' \\/ '
for b in beliefcombs:
beliefset = set()
for beliefstate in b:
beliefset = beliefset.union(partitionGrid[beliefstate])
beliefset = beliefset - set(gw.targets[0])
stri1 = ' \\/ (y = {} /\\ ('.format(
len(nonbeliefstates) + beliefcombs.index(b))
count = 0
for n in range(gw.nagents):
for x in nonbeliefstates:
truebelief = beliefset.intersection(invisibilityset[n][x])
if len(truebelief) <= belief_liveness:
if count > 0:
stri1 += ' \\/ '
stri1 += ' {} = {} '.format(agentletters[n],
nonbeliefstates.index(x))
count += 1
stri1 += '))'
if count > 0 and count < len(nonbeliefstates):
stri += stri1
if count == len(nonbeliefstates):
stri += ' \\/ y = {}'.format(
len(nonbeliefstates) + beliefcombs.index(b))
stri += '\n'
file.write(stri)
# Writing env_liveness
file.write('\n[ENV_LIVENESS]\n')
stri = 'y = {}'.format(gw.targets[0][0])
file.write(stri)
file.close()