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()